private Predicate <object> PropertySearchFunc(FilterStatesCollection filters)
{
Predicate <object> predicate = null;
var activeFilters = filters.Where(x => x.Value != FilterState.Any).ToList();
foreach (var f in activeFilters)
{
FilterState fs = f.Value;
Enum key = (Enum)f.Key;
bool yes = fs == FilterState.Yes;
Predicate <object> p = o => ((BadgeIdentity)o).CheckProperty(key) == yes;
if (predicate == null)
{
predicate = p;
}
else
{
Predicate <object> z = predicate;
predicate = o => z(o) && p(o);
}
}
return(predicate);
}
public async ValueTask <TargetFrameworkMoniker> SelectTargetFrameworkAsync(IProject project, CancellationToken token)
{
if (project is null)
{
throw new ArgumentNullException(nameof(project));
}
var appBase = _selectorOptions.TargetTfmSupport switch
{
UpgradeTarget.Current => _selectorOptions.Current,
UpgradeTarget.Preview => _selectorOptions.Preview,
UpgradeTarget.LTS => _selectorOptions.LTS,
_ => _selectorOptions.LTS,
};
var current = GetDefaultTargetFrameworkMoniker(project);
if (!_comparer.TryParse(appBase, out var appBaseTfm))
{
throw new InvalidOperationException("Invalid app base TFM");
}
var updater = new FilterState(_comparer, project, current, appBaseTfm, _logger)
{
Components = await project.GetComponentsAsync(token).ConfigureAwait(false),
};
foreach (var selector in _selectors)
{
selector.Process(updater);
}
return(updater.Current);
}
/// <summary>
/// Restores filter state from the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void RestoreFilterState(FilterState state)
{
base.RestoreFilterState(state);
isAdvancedMode = state.GetBoolean("AdvancedMode");
ViewState["IsAdvancedMode"] = isAdvancedMode;
SetFieldsVisibility();
}
private void OnFilterApplied(object source, PropertyFilterAppliedEventArgs args)
{
// If the filter just switched between empty and non-empty
if (args.Filter.IsEmpty && this.filterIsEmpty != FilterState.Empty || !args.Filter.IsEmpty && this.filterIsEmpty != FilterState.NotEmpty)
{
// If the filter is now empty
if (args.Filter.IsEmpty)
{
if (this.haveCachedExpanded)
{
// Set Pinned and Expanded to what they were before the filter
this.Expanded = this.wasExpandedBeforeFilter;
this.AdvancedSectionPinned = this.wasAdvancedPinnedBeforeFilter;
}
}
else
{
// Cache the Pinned and Expanded state
this.haveCachedExpanded = true;
this.wasExpandedBeforeFilter = this.Expanded;
this.wasAdvancedPinnedBeforeFilter = this.AdvancedSectionPinned;
}
}
if (!args.Filter.IsEmpty)
{
this.Expanded = this.BasicPropertyMatchesFilter || this.AdvancedPropertyMatchesFilter;
this.AdvancedSectionPinned = this.AdvancedPropertyMatchesFilter;
}
this.filterIsEmpty = args.Filter.IsEmpty ? FilterState.Empty : FilterState.NotEmpty;
}
public override int GetState(int dwMilliSecsTimeout, out FilterState filtState)
{
base.GetState(dwMilliSecsTimeout, out filtState);
// This tells the graph no to cue up samples in pause state. We do this here to prevent background downloading.
return(0x00040268 /*VFW_S_CANT_CUE*/);
//return S_OK;
}
/// <summary>
/// Stores filter state to the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void StoreFilterState(FilterState state)
{
base.StoreFilterState(state);
state.AddValue("AdvancedMode", isAdvancedMode);
state.AddValue("TimeBetweenFrom", fltTimeBetween.ValueFromTime);
state.AddValue("TimeBetweenTo", fltTimeBetween.ValueToTime);
}
public IHttpActionResult Query([FromBody] FilterState filterState)
{
return(Try(() =>
{
return Ok(_userFacade.Query(filterState));
}));
}
public FilterContext(ObjectCache cache, CompositionContainer container, IAssetResolver assetResolver, FilterState state)
{
this.Container = container;
this.Cache = cache;
this.AssetResolver = assetResolver;
this.State = state;
}
public static StackLayout GEN(string cardType, Binary b,
TapGestureRecognizer tap, FilterState state)
{
StackLayout card = null;
if (cardType == "default")
{
card = new CardDefault(b);
}
else if (cardType == "admin")
{
card = new CardAdmin(b);
}
else if (cardType == "booked")
{
card = new CardBooked(b);
}
else if (cardType == "user")
{
card = new CardUser(b);
}
StackLayout st = new StackLayout
{
HorizontalOptions = LayoutOptions.FillAndExpand,
VerticalOptions = LayoutOptions.FillAndExpand,
Children =
{
card
},
GestureRecognizers = { tap }
};
return(st);
}
public FilterContext(ObjectCache cache, CompositionContainer container, FilterState state, params IAssetFilter[] filters)
{
this.Container = container;
this.Cache = cache;
this.State = state;
this._filters = filters;
}
/// <summary>
/// This method seeks the movie to the given time position.
/// The time has to be in units of the <see cref="IReferenceClock"/>.
/// By default that are 100-nanosecond units.
/// </summary>
/// <param name="timeToStart">An <see cref="Int64"/> with the absolute start time to seek,
/// or null if the start time should not be set</param>
/// <param name="timeToStop">An <see cref="Int64"/> with the absolute time at which the play should stop,
/// or null if the stop time should not be set.</param>
/// <remarks>If the timeToStop parameter is null, the stop time is set to the duration
/// of the video.</remarks>
public void SeekMovie(Int64?timeToStart, Int64?timeToStop)
{
try
{
if (this.mediaSeeking != null)
{
int hr = 0;
if (timeToStart.HasValue)
{
hr = this.mediaSeeking.SetPositions(timeToStart.Value * 10000, AMSeekingSeekingFlags.AbsolutePositioning,
null, AMSeekingSeekingFlags.NoPositioning);
DsError.ThrowExceptionForHR(hr);
}
if (this.mediaControl != null)
{
FilterState state = FilterState.Stopped;
int timeout = 100;
hr = this.mediaControl.GetState(timeout, out state);
DsError.ThrowExceptionForHR(hr);
this.StepOneFrame();
}
}
}
catch (Exception ex)
{
MessageBox.Show("Could not seek movie because: " + ex.Message);
}
}
void OnMediaStateChanged(FilterState oldState, string oldMedia, FilterState newState, string newMedia)
{
string FilterState = string.Empty;
_hasMediaStateChangedAtLeastOnce = true;
if (BuildMediaStateString(false, ref FilterState))
{
mnuMediaState.Visible = true;
if (FilterState.Length > 45)
{
mnuMediaState.Text = FilterState.Substring(0, 45) + "...";
mnuMediaState.ToolTipText = FilterState.Replace(": ", ":\n");
}
else
{
mnuMediaState.Text = FilterState;
mnuMediaState.ToolTipText = "";
}
}
else
{
mnuMediaState.Visible = false;
}
SetTitle(mediaPlayer.BuildTitle());
BuildThumbnailButtons(false);
}
/// <summary>
/// Restores filter state from the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void RestoreFilterState(FilterState state)
{
base.RestoreFilterState(state);
isAdvancedMode = state.GetBoolean("AdvancedMode");
ViewState["IsAdvancedMode"] = isAdvancedMode;
hdnAlpha.Value = state.GetString("Alphabet");
}
private void FireFilterStateChanged(FilterState oldState, string oldMedia, FilterState newState, string newMedia)
{
if (FilterStateChanged != null)
{
FilterStateChanged(oldState, oldMedia, newState, newMedia);
}
}
/// <summary>
/// Stores filter state to the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void StoreFilterState(FilterState state)
{
state.AddValue("AdvancedMode", IsAdvancedMode);
state.AddValue("ToTime", fltModified.ValueToTime);
state.AddValue("FromTime", fltModified.ValueFromTime);
base.StoreFilterState(state);
}
public GlobalFilters(Guid OrgId, int DeptID, int UserID)
{
DataRow _row = SelectState(OrgId, DeptID, UserID);
if (_row == null)
{
return;
}
if ((bool)_row["btGlobalFilterEnabled"])
{
m_State = FilterState.EnabledGlobalFilters;
}
else if ((bool)_row["btLimitToAssignedTkts"])
{
m_State = FilterState.LimitToAssignedTickets;
}
else if ((bool)_row["btDisabledReports"])
{
m_State = FilterState.DisabledReports;
}
DataTable _dt = SelectFilterByType(OrgId, DeptID, UserID, FilterType.GlobalFilterTypes);
foreach (DataRow _r in _dt.Rows)
{
if ((bool)_r["State"])
{
m_Type[(int)_r["Filter"]] = true;
}
}
}
/// <summary>
/// Restores filter state from the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void RestoreFilterState(FilterState state)
{
EnsureChildControls();
base.RestoreFilterState(state);
drpOptions.SelectedIndex = state.GetInt32("RuleCategory");
}
public int Pause()
{
Debug.WriteLine("Pause", _Name);
//lock (_LockObj)
//{
// Notify all pins of the change to active state
if (_State == FilterState.Stopped)
{
for (int i = 0; i < Pins.Count; i++)
{
// Disconnected pins are not activated - this saves pins
// worrying about this state themselves
if (Pins[i].IsConnected)
{
HRESULT hr = (HRESULT)Pins[i].Active();
if (HR.FAILED(hr))
{
unchecked
{
return((int)hr);
}
}
}
}
}
_State = FilterState.Paused;
return(OnPause());
// }
}
/// <summary>
/// Restores filter state from the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void RestoreFilterState(FilterState state)
{
base.RestoreFilterState(state);
// Restore additional state properties
drpStatus.SelectedValue = state.GetString("drpStatus", "-1");
}
/// <summary>
/// Stores filter state to the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void StoreFilterState(FilterState state)
{
base.StoreFilterState(state);
// Store additional state properties
state.AddValue("drpStatus", drpStatus.SelectedValue);
}
public void ChangeFilter(FilterState state)
{
if (events.filter == state)
{
return;
}
Button b1 = null; Button b2 = null;
if (state == FilterState.ALL)
{
b1 = filter_all;
b2 = filter_b;
}
else if (state == FilterState.B)
{
b2 = filter_all;
b1 = filter_b;
}
b1.BackgroundColor = (Color)App.Current.Resources["P_Selected"];
b2.BackgroundColor = (Color)App.Current.Resources["P"];
events.ChangeFilter(state);
if (state == FilterState.ALL)
{
search.Placeholder = "Sƶk restauranger";
}
else if (state == FilterState.B)
{
search.Placeholder = "Sƶk produkter";
}
}
/// <summary>
/// Restores filter state from the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void RestoreFilterState(FilterState state)
{
base.RestoreFilterState(state);
IsAdvancedMode = state.GetBoolean("AdvancedMode");
fltModified.ValueFromTime = state.GetDateTime("FromTime");
fltModified.ValueToTime = state.GetDateTime("ToTime");
}
public int Run(long tStart)
{
Debug.WriteLine("Run " + tStart, _Name);
lock (_LockObj)
{
// Remember the stream time offset
m_tStart = tStart;
if (_State == FilterState.Stopped)
{
HRESULT hr = (HRESULT)Pause();
unchecked
{
if (HR.FAILED(hr))
{
return((int)hr);
}
}
}
_State = FilterState.Running;
return(OnRun(tStart));
}
}
/// <summary>
/// Restores filter state from the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void RestoreFilterState(FilterState state)
{
EnsureChildControls();
base.RestoreFilterState(state);
drpOptions.SelectedIndex = state.GetInt32("RuleCategory");
}
public CardScrollContent(Binary b, TapGestureRecognizer tap, string cardType,
FilterState state)
{
HorizontalOptions = LayoutOptions.FillAndExpand;
VerticalOptions = LayoutOptions.FillAndExpand;
Padding = 10;
Content = CardInside.GEN(cardType, b, tap, state);
}
/// <summary>
/// Restores filter state from the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void RestoreFilterState(FilterState state)
{
base.RestoreFilterState(state);
IsAdvancedMode = state.GetBoolean("AdvancedMode");
fltAccountStatus.Value = state.GetString("Status");
fltCreated.ValueFromTime = state.GetDateTime("FromTime");
fltCreated.ValueToTime = state.GetDateTime("ToTime");
}
/// <summary>
/// Stores filter state to the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void StoreFilterState(FilterState state)
{
state.AddValue("AdvancedMode", IsAdvancedMode);
state.AddValue("Status", fltAccountStatus.Value);
state.AddValue("ToTime", fltCreated.ValueToTime);
state.AddValue("FromTime", fltCreated.ValueFromTime);
base.StoreFilterState(state);
}
/// <summary>
/// Stores filter state to the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void StoreFilterState(FilterState state)
{
state.AddValue("radSalesForceLeadReplicationStatus", radSalesForceLeadReplicationStatus.SelectedValue);
state.AddValue("AdvancedMode", IsAdvancedMode);
state.AddValue("ToTime", fltCreated.ValueToTime);
state.AddValue("FromTime", fltCreated.ValueFromTime);
base.StoreFilterState(state);
}
public void RestoreFilterButton(FilterButton Button)
{
FilterState fs = filters[Button.FilterType];
Button.FilterValue = fs.Value;
Button.ValueType = fs.ValueType;
Button.StartChar = fs.StartChar;
}
static QuickFilters()
{
// load json into memory. if file doesn't exist, nothing to do. save() will create if needed
if (File.Exists(JsonFile))
{
inMemoryState = JsonConvert.DeserializeObject <FilterState>(File.ReadAllText(JsonFile));
}
}
/// <summary>
/// Restores filter state from the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void RestoreFilterState(FilterState state)
{
base.RestoreFilterState(state);
radSalesForceLeadReplicationStatus.SelectedValue = state.GetString("radSalesForceLeadReplicationStatus");
IsAdvancedMode = state.GetBoolean("AdvancedMode");
fltCreated.ValueFromTime = state.GetDateTime("FromTime");
fltCreated.ValueToTime = state.GetDateTime("ToTime");
}
private void SetFilter(FilterState filter)
{
if (filter == FilterState.Administrator)
{
_ordersFilter.SetUserId("");
_ordersFilter.SetDressId("");
}
}
public IEnumerable <Order> GetAll(FilterState filter)
{
SetFilter(filter);
return(_DressBookingDBContext.Orders
.Include(b => b.Dress)
.Where(OrderFilter)
.ToList());
}
/// <summary>
/// Restores filter state from the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void RestoreFilterState(FilterState state)
{
base.RestoreFilterState(state);
isAdvancedMode = state.GetBoolean("AdvancedMode");
ViewState["IsAdvancedMode"] = isAdvancedMode;
ShowFilterElements(isAdvancedMode);
fltTimeBetween.ValueFromTime = state.GetDateTime("TimeBetweenFrom");
fltTimeBetween.ValueToTime = state.GetDateTime("TimeBetweenTo");
}
public GlobalFilters(Guid OrgId, int DeptID, int UserID)
{
DataRow _row = SelectState(OrgId, DeptID, UserID);
if (_row == null) return;
if ((bool)_row["btGlobalFilterEnabled"]) m_State = FilterState.EnabledGlobalFilters;
else if ((bool)_row["btLimitToAssignedTkts"]) m_State = FilterState.LimitToAssignedTickets;
else if ((bool)_row["btDisabledReports"]) m_State = FilterState.DisabledReports;
DataTable _dt = SelectFilterByType(OrgId, DeptID, UserID, FilterType.GlobalFilterTypes);
foreach (DataRow _r in _dt.Rows)
if ((bool)_r["State"]) m_Type[(int)_r["Filter"]] = true;
}
public MainDlg()
{
InitializeComponent();
try
{
m_pPlayer = new ClipPlayer(this.Handle, MSG_ENDOFSEGMENT, MSG_DSEVENT);
m_bTracking = false;
m_State = FilterState.Stopped;
}
catch
{
MessageBox.Show("Please register GMFBridge.DLL with regsvr32");
}
}
public MpqFileSourceFilter(MpqFile file)
{
CopyMediaTypes(detectedMediaType, defaultMediaType);
name = "Stream Source Filter";
filterState = FilterState.Stopped;
var extension = Path.GetExtension(file.Name);
try
{
using (var mediaTypeKey = Registry.ClassesRoot.OpenSubKey(@"Media Type"))
{
if (extension != null && extension.Length > 1)
try
{
using (var extensionsKey = mediaTypeKey.OpenSubKey(@"Extensions"))
using (var extensionKey = extensionsKey.OpenSubKey(extension))
{
var mediaType = new Guid(extensionKey.GetValue("Media Type", MediaType.Stream.ToString()) as string);
var subType = new Guid(extensionKey.GetValue("SubType", MediaSubType.None.ToString()) as string);
if (mediaType == MediaType.Stream && subType != MediaSubType.None && subType != MediaSubType.Null)
{
detectedMediaType.majorType = mediaType;
detectedMediaType.subType = subType;
return;
}
}
}
catch (Exception) { }
using (var streamMediaKey = mediaTypeKey.OpenSubKey(MediaType.Stream.ToString()))
foreach (var subTypeKeyName in streamMediaKey.GetSubKeyNames())
try
{
using (var subTypeKey = streamMediaKey.OpenSubKey(subTypeKeyName))
;
}
catch (Exception) { }
}
}
catch (Exception) { }
finally { outputPin = new StreamOutputPin(this); }
}
public override bool IncrementToken()
{
if (currentState == FilterState.Init)
{
if (!input.IncrementToken())
return false;
}
currentState = (FilterState) ((int) currentState + 1);
switch (currentState)
{
case FilterState.WholePath:
return true;
case FilterState.File:
return SetTermToFileName();
case FilterState.FileWithoutExtension:
return RemoveExtension();
default:
return NextFileNamePart();
}
return false;
}
/// <summary>
/// Restores filter state from the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void RestoreFilterState(FilterState state)
{
filter.SelectedValue = state.GetString("condition");
txtEmail.Text = state.GetString("email");
}
/// <summary>
/// Stores filter state to the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void StoreFilterState(FilterState state)
{
state.AddValue("ToTime", dtFromTo.ValueToTime);
state.AddValue("FromTime", dtFromTo.ValueFromTime);
base.StoreFilterState(state);
}
/// <summary>
/// Restores filter state from the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void RestoreFilterState(FilterState state)
{
filter.SelectedValue = state.GetString("condition");
txtName.Text = state.GetString("categoryName");
}
/// <summary>
/// Restores filter state from the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void RestoreFilterState(FilterState state)
{
// Before retrieving selected value from saved state is necessary to ensure items in DropDownList (delete before)
EnsureDropDownListFilterItems();
base.RestoreFilterState(state);
SelectedUser = state.GetInt32("RecycleBinUser");
}
private void btnFrameStep_Click(object sender, EventArgs e)
{
if (_mediaStep != null)
{
_mediaStep.Step(FRAME_STEP_INCREMENT,null);
state = FilterState.Paused;
// m_bFrameStepping = true;
}
}
public int GetState(int dwMilliSecsTimeout, out FilterState filtState)
{
filtState = filterState;
return S_OK;
}
/// <summary>
/// Stores filter state to the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void StoreFilterState(FilterState state)
{
base.StoreFilterState(state);
state.AddValue("ReportStatus", drpStatus.SelectedValue);
}
/// <summary>
/// Restores filter state from the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void RestoreFilterState(FilterState state)
{
filter.SelectedValue = state.GetString("type");
}
/// <summary>
/// Stores filter state to the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void StoreFilterState(FilterState state)
{
base.StoreFilterState(state);
state.AddValue("RecycleBinUser", SelectedUser);
}
/// <summary>
/// Stores filter state to the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void StoreFilterState(FilterState state)
{
base.StoreFilterState(state);
state.AddValue("AdvancedMode", isAdvancedMode);
state.AddValue("TimeBetweenFrom", fltTimeBetween.ValueFromTime);
state.AddValue("TimeBetweenTo", fltTimeBetween.ValueToTime);
}
private void btnStop_Click(object sender, EventArgs e)
{
if (state == FilterState.Stopped) return;
if (_mediaCtrl != null)
{
int hr = _mediaCtrl.Stop();
DsError.ThrowExceptionForHR(hr);
state = FilterState.Stopped;
}
// Seek back to the start.
if (_mediaPos != null)
{
_offsetseek = 0;
seekbar.Value = 0;
_mediaPos.put_CurrentPosition(0);
}
}
private void btnPlay_Click(object sender, EventArgs e)
{
if (state == FilterState.Running) return;
RunGraph();
_mediaCtrl.Run();
state = FilterState.Running;
}
private void btnPause_Click(object sender, EventArgs e)
{
if (state == FilterState.Paused) return;
if (_mediaCtrl != null)
{
int hr = _mediaCtrl.Pause();
DsError.ThrowExceptionForHR(hr);
state = FilterState.Paused;
}
}
/// <summary>
/// Stores filter state to the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void StoreFilterState(FilterState state)
{
state.AddValue("condition", filter.SelectedValue);
state.AddValue("email", txtEmail.Text);
}
/// <summary>
/// Restores filter state from the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void RestoreFilterState(FilterState state)
{
base.RestoreFilterState(state);
dtFromTo.ValueFromTime = state.GetDateTime("FromTime");
dtFromTo.ValueToTime = state.GetDateTime("ToTime");
}
/// <summary>
/// Stores filter state to the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void StoreFilterState(FilterState state)
{
state.AddValue("type", filter.SelectedValue);
}
/// <summary>
/// Filter the specified input.
/// </summary>
/// <remarks>Filters the specified input buffer starting at the given index,
/// spanning across the specified number of bytes.</remarks>
/// <returns>The filtered output.</returns>
/// <param name="input">The input buffer.</param>
/// <param name="startIndex">The starting index of the input buffer.</param>
/// <param name="length">Length.</param>
/// <param name="outputIndex">Output index.</param>
/// <param name="outputLength">Output length.</param>
/// <param name="flush">If set to <c>true</c> flush.</param>
protected override byte[] Filter (byte[] input, int startIndex, int length, out int outputIndex, out int outputLength, bool flush)
{
int endIndex = startIndex + length;
int index = startIndex;
// read the compressed size if we haven't already...
if (state == FilterState.CompressedSize) {
if (!TryReadInt32 (input, ref index, endIndex, out compressedSize)) {
outputLength = 0;
outputIndex = 0;
return input;
}
state = FilterState.UncompressedSize;
compressedSize -= 12;
}
// read the uncompressed size if we haven't already...
if (state == FilterState.UncompressedSize) {
if (!TryReadInt32 (input, ref index, endIndex, out uncompressedSize)) {
outputLength = 0;
outputIndex = 0;
return input;
}
state = FilterState.Magic;
}
// read the compression mode magic if we haven't already...
if (state == FilterState.Magic) {
int magic;
if (!TryReadInt32 (input, ref index, endIndex, out magic)) {
outputLength = 0;
outputIndex = 0;
return input;
}
CompressionMode = (RtfCompressionMode) magic;
state = FilterState.Crc32;
}
// read the crc32 checksum if we haven't already...
if (state == FilterState.Crc32) {
if (!TryReadInt32 (input, ref index, endIndex, out checksum)) {
outputLength = 0;
outputIndex = 0;
return input;
}
state = FilterState.BeginControlRun;
}
if (CompressionMode != RtfCompressionMode.Compressed) {
// the data is not compressed, just keep track of the CRC32 checksum
crc32.Update (input, index, endIndex - index);
outputLength = Math.Max (Math.Min (endIndex - index, compressedSize - size), 0);
size += outputLength;
outputIndex = index;
return input;
}
int extra = Math.Abs (uncompressedSize - compressedSize);
int estimatedSize = (endIndex - index) + extra;
EnsureOutputSize (Math.Max (estimatedSize, 4096), false);
outputLength = 0;
outputIndex = 0;
while (index < endIndex) {
byte value = input[index++];
crc32.Update (value);
size++;
switch (state) {
case FilterState.BeginControlRun:
flags = value;
flagCount = 1;
if ((flags & 0x1) != 0)
state = FilterState.ReadControlOffset;
else
state = FilterState.ReadLiteral;
break;
case FilterState.ReadLiteral:
EnsureOutputSize (outputLength + 1, true);
OutputBuffer[outputLength++] = value;
dict[dictWriteOffset++] = value;
dictEndOffset = Math.Max (dictWriteOffset, dictEndOffset);
dictWriteOffset = (short) (dictWriteOffset % 4096);
if ((flagCount++ % 8) != 0) {
flags = (byte) (flags >> 1);
if ((flags & 0x1) != 0)
state = FilterState.ReadControlOffset;
else
state = FilterState.ReadLiteral;
} else {
state = FilterState.BeginControlRun;
}
break;
case FilterState.ReadControlOffset:
state = FilterState.ProcessControl;
dictReadOffset = value;
break;
case FilterState.ProcessControl:
dictReadOffset = (short) ((dictReadOffset << 4) | (value >> 4));
int controlLength = (value & 0x0F) + 2;
if (dictReadOffset == dictWriteOffset) {
state = FilterState.Complete;
break;
}
EnsureOutputSize (outputLength + controlLength, true);
int controlEnd = dictReadOffset + controlLength;
while (dictReadOffset < controlEnd) {
value = dict[dictReadOffset++ % 4096];
OutputBuffer[outputLength++] = value;
dict[dictWriteOffset++] = value;
dictEndOffset = Math.Max (dictWriteOffset, dictEndOffset);
dictWriteOffset = (short) (dictWriteOffset % 4096);
}
if ((flagCount++ % 8) != 0) {
flags = (byte) (flags >> 1);
if ((flags & 0x1) != 0)
state = FilterState.ReadControlOffset;
else
state = FilterState.ReadLiteral;
} else {
state = FilterState.BeginControlRun;
}
break;
case FilterState.Complete:
break;
}
}
return OutputBuffer;
}
/// <summary>
/// Resets the filter.
/// </summary>
/// <remarks>
/// Resets the filter.
/// </remarks>
public override void Reset ()
{
Buffer.BlockCopy (DictionaryInitializer, 0, dict, 0, DictionaryInitializer.Length);
dictEndOffset = dictWriteOffset = (short) DictionaryInitializer.Length; // 207
state = FilterState.CompressedSize;
dictReadOffset = 0;
compressedSize = 0;
crc32.Reset ();
flagCount = 0;
checksum = 0;
flags = 0;
saved = 0;
size = 0;
base.Reset ();
}
/// <summary>
/// Restores filter state from the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void RestoreFilterState(FilterState state)
{
base.RestoreFilterState(state);
Value = state.GetString("Value");
}
private void StopGraph()
{
if (_mediaCtrl != null)
{
int hr = _mediaCtrl.Stop();
DsError.ThrowExceptionForHR(hr);
state = FilterState.Stopped;
}
}
/// <summary>
/// Stores filter state to the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void StoreFilterState(FilterState state)
{
state.AddValue("condition", filter.SelectedValue);
state.AddValue("categoryName", txtName.Text);
}
/// <summary>
/// Stores filter state to the specified object.
/// </summary>
/// <param name="state">The object that holds the filter state.</param>
public override void StoreFilterState(FilterState state)
{
state.AddValue("Value", Value);
base.StoreFilterState(state);
}
