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)); } }
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); }
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); }