/// <summary> /// Executes in two distinct scenarios. /// /// 1. If disposing is true, the method has been called directly /// or indirectly by a user's code via the Dispose method. /// Both managed and unmanaged resources can be disposed. /// /// 2. If disposing is false, the method has been called by the /// runtime from inside the finalizer and you should not reference (access) /// other managed objects, as they already have been garbage collected. /// Only unmanaged resources can be disposed. /// </summary> /// <param name="disposing"></param> /// <remarks> /// If any exceptions are thrown, that is fine. /// If the method is being done in a finalizer, it will be ignored. /// If it is thrown by client code calling Dispose, /// it needs to be handled by fixing the bug. /// /// If subclasses override this method, they should call the base implementation. /// </remarks> protected virtual void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (m_isDisposed) return; if (disposing) { // Dispose managed resources here. //ResetStatusBarPanel("StatusPanelRecordNumber", ""); //ResetStatusBarPanel("StatusPanelMessage", ""); m_list.ListChanged -= new ListChangedEventHandler(OnListChanged); m_list.AboutToReload -= new EventHandler(m_list_AboutToReload); m_list.DoneReload -= new EventHandler(m_list_DoneReload); m_list.Dispose(); if (m_mediator != null) { m_mediator.RemoveColleague(this); } if (m_filterProvider != null) m_filterProvider.Dispose(); if (m_rch != null && m_rch is IDisposable) (m_rch as IDisposable).Dispose(); if (m_recordBarHandler != null) m_recordBarHandler.Dispose(); } // Dispose unmanaged resources here, whether disposing is true or false. m_mediator = null; // This has to be done after the calls to ResetStatusBarPanel in the 'true' section. m_list = null; m_id = null; m_clerkProvidingRootObject = null; m_recordBarHandler = null; m_filterProvider = null; m_activeMenuBarFilter = null; m_rch = null; m_fIsActiveInGui = false; m_isDisposed = true; }
/// <summary> /// Record Filters that can contain more than one filter (e.g. AndFilter) should override this. /// </summary> /// <param name="other"></param> /// <returns></returns> public virtual bool Contains(RecordFilter other) { return SameFilter(other); }
/// <summary> /// /// </summary> /// <param name="filter"></param> /// <returns>True if one of our filters can be found in the given filter.</returns> private bool ContainsOurFilter(RecordFilter filter, out RecordFilter matchingFilter) { matchingFilter = null; if (filter == null) return false; for (int i = 0; i < Filters.Count; ++i) { if (filter.Contains(Filters[i] as RecordFilter)) { matchingFilter = (RecordFilter)Filters[i]; return true; } } return false; }
/// ------------------------------------------------------------------------------------------ /// <summary> /// Adds the specified f. /// </summary> /// <param name="f">The f.</param> /// ------------------------------------------------------------------------------------------ public void Add(RecordFilter f) { Debug.Assert(!this.Contains(f), "This filter (" + f.ToString() + ") has already been added to the list."); m_filters.Add(f); }
/// <summary> /// Does our AndFilter Contain the other recordfilter? /// </summary> /// <param name="other"></param> /// <returns></returns> public override bool Contains(RecordFilter other) { for (int i = 0; i < this.Count; ++i) { RecordFilter filter = this.Filters[i] as RecordFilter; if (filter.Contains(other)) return true; } return false; }
/// <summary> /// Does our AndFilter Contain the other recordfilter or one equal to it? If so answer the equal one. /// </summary> public override RecordFilter EqualContainedFilter(RecordFilter other) { for (int i = 0; i < Count; ++i) { RecordFilter filter = this.Filters[i] as RecordFilter; var result = filter.EqualContainedFilter(other); if (result != null) return result; } return null; }
/// <summary> /// If this or a contained filter is considered equal to the argument, answer the filter /// or subfilter that is consiered equal. /// Record Filters that can contain more than one filter (e.g. AndFilter) should override this. /// </summary> public virtual RecordFilter EqualContainedFilter(RecordFilter other) { return SameFilter(other) ? this : null; }
/// <summary> /// Given the current record filter of the clerk, determine whether any of the active /// filters could have been created by any of your filter sort items, and if so, /// update the filter bar to show they are active. /// </summary> /// <param name="currentFilter"></param> public void UpdateActiveItems(RecordFilter currentFilter) { CheckDisposed(); try { m_fInUpdateActive = true; if (currentFilter is AndFilter) { // We have to copy the list, because the internal operation of this loop // may change the original list, invalidating the (implicit) enumerator. // See LT-1133 for an example of what happens without making this copy. ArrayList filters = (ArrayList)(currentFilter as AndFilter).Filters.Clone(); foreach (RecordFilter filter in filters) { ActivateCompatibleFilter(filter); } } else { // Try to activate the single filter itself. ActivateCompatibleFilter(currentFilter); } } finally { //Adjust the FilterBar height and combo box heights to accomodate the //strings in the filter comboBoxes AdjustBarHeights(); m_fInUpdateActive = false; } }
/// <summary> /// Given a filter bar cell filter which is (part of) the active filter for your /// clerk, if one of your cells understands it install it as the active filter /// for that cell. Otherwise, remove it from the clerk filter. /// </summary> /// <param name="filter"></param> /// <returns>true if compatible filter is found and activated, false if /// a match was not found and signal clerk to deactivate.</returns> private bool ActivateCompatibleFilter(RecordFilter filter) { foreach (FilterSortItem fsi in m_items) { if (fsi != null && fsi.SetFromFilter(filter)) return true; } // we couldn't find a match in the active columns. // if we've already fully initialized the filters, then remove it from the clerk filter. if (FilterChanged != null) FilterChanged(this, new FilterChangeEventArgs(null, filter)); return false; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Determine whether this combo item could have produced the specified filter. /// If so, return the string that should be displayed as the value of the combo box /// when this filter is active. Otherwise return null. /// By default, if the filter is exactly the same, just return your label. /// </summary> /// <param name="recordFilter">The record filter.</param> /// <param name="item">The item.</param> /// <returns></returns> /// ------------------------------------------------------------------------------------ public override ITsString SetFromFilter(RecordFilter recordFilter, FilterSortItem item) { CheckDisposed(); ListChoiceFilter filter = recordFilter as ListChoiceFilter; if (filter == null) return null; if (!filter.CompatibleFilter(m_colSpec)) return null; return MakeLabel(filter); }
/// <summary> /// If this filter could have been created from this FSI, set it as your active /// filter and update your display accordingly, and answer true. Otherwise /// answer false. /// </summary> /// <param name="filter"></param> /// <returns></returns> public bool SetFromFilter(RecordFilter filter) { CheckDisposed(); if (filter == m_filter) return true; // we're already set. if (m_combo == null) return false; // probably can't happen, but play safe foreach (FilterComboItem fci in m_combo.Items) { if (fci == null) continue; // for safety, probably can't happen ITsString tssLabel = fci.SetFromFilter(filter, this); if (tssLabel == null) continue; m_combo.SelectedIndex = -1; // prevents failure of setting Tss if not in list. m_combo.Tss = tssLabel; m_filter = filter; // remember this filter is active! return true; } return false; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Determine whether this combo item could have produced the specified filter. /// If so, return the string that should be displayed as the value of the combo box /// when this filter is active. Otherwise return null. /// By default, if the filter is exactly the same, just return your label. /// </summary> /// <param name="recordFilter">The record filter.</param> /// <param name="item">The item.</param> /// <returns></returns> /// ------------------------------------------------------------------------------------ public virtual ITsString SetFromFilter(RecordFilter recordFilter, FilterSortItem item) { CheckDisposed(); FilterBarCellFilter filter = recordFilter as FilterBarCellFilter; if (filter == null) return null; // combo items that don't produce FilterBarCellFilters should override. if (!filter.Finder.SameFinder(item.Finder)) return null; IMatcher matcher = filter.Matcher; ITsString result = SetFromMatcher(matcher); if (result != null) m_matcher = matcher; return result; }
/// <summary> /// Executes in two distinct scenarios. /// /// 1. If disposing is true, the method has been called directly /// or indirectly by a user's code via the Dispose method. /// Both managed and unmanaged resources can be disposed. /// /// 2. If disposing is false, the method has been called by the /// runtime from inside the finalizer and you should not reference (access) /// other managed objects, as they already have been garbage collected. /// Only unmanaged resources can be disposed. /// </summary> /// <param name="disposing"></param> /// <remarks> /// If any exceptions are thrown, that is fine. /// If the method is being done in a finalizer, it will be ignored. /// If it is thrown by client code calling Dispose, /// it needs to be handled by fixing the bug. /// /// If subclasses override this method, they should call the base implementation. /// </remarks> protected virtual void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (m_isDisposed) return; if (disposing) { // Dispose managed resources here. // We didn't make these either, but we need to deal with them. // No. These belong to the RecordList. //if (m_finder != null && (m_finder is IDisposable)) // (m_finder as IDisposable).Dispose(); //if (m_sorter != null && (m_sorter is IDisposable)) // (m_sorter as IDisposable).Dispose(); //if (m_filter != null) // (m_filter as IDisposable).Dispose(); //if (m_matcher != null && m_matcher is IDisposable) // (m_matcher as IDisposable).Dispose(); } // Dispose unmanaged resources here, whether disposing is true or false. m_viewSpec = null; m_combo = null; // We didn't create it, so let whoever did dispose it. m_finder = null; m_sorter = null; m_filter = null; m_matcher = null; m_isDisposed = true; }
/// <summary> /// display the given record /// </summary> /// <param name="argument">the hvo of the record</param> /// <returns></returns> public bool OnJumpToRecord(object argument) { CheckDisposed(); bool fHandled = false; try { int hvoTarget = (int)argument; int index = IndexOfObjOrChild(hvoTarget); if (index == -1) { // See if base property is a virtual handler that knows how to add items. IAddItemToVirtualProperty adder = m_list.Cache.VwCacheDaAccessor.GetVirtualHandlerId(m_list.Flid) as IAddItemToVirtualProperty; if (adder != null && adder.Add(m_list.OwningObject.Hvo, hvoTarget)) index = IndexOfObjOrChild(hvoTarget); } if (m_list.Filter != null && index == -1) { // We can get here with an irrelevant target hvo, for example by inserting a new // affix allomorph in an entry (see LT-4025). So make sure we have a suitable // target before complaining to the user about a filter being on. FdoCache cache = m_list.Cache; IFwMetaDataCache mdc = cache.MetaDataCacheAccessor; uint clidList = mdc.GetDstClsId((uint)m_list.Flid); int clidObj = cache.GetClassOfObject(hvoTarget); // If (int) clidList is -1, that means it was for a virtual property and the IsSameOrSubclassOf // test won't be valid. // Enhance JohnT/CurtisH: It would be better to if virtual properties actually knew about their // destination class. bool fSuitableTarget; if ((int)clidList == -1) fSuitableTarget = true; else fSuitableTarget = cache.IsSameOrSubclassOf(clidObj, (int)clidList); if (fSuitableTarget) { DialogResult dr = MessageBox.Show( xWorksStrings.LinkTargetNotAvailableDueToFilter, xWorksStrings.TargetNotFound, MessageBoxButtons.YesNo); if (dr == DialogResult.Yes) { // We had changed from OnChangeFilter to SendMessage("RemoveFilters") to solve a filterbar // update issue reported in (LT-2448). However, that message only works in the context of a // BrowseViewer, not a document view (e.g. Dictionary) (see LT-7298). So, I've // tested OnChangeFilterClearAll, and it seems to solve both problems now. OnChangeFilterClearAll(null); m_activeMenuBarFilter = null; index = IndexOfObjOrChild(hvoTarget); } else { fHandled = true; // user wants to give up return fHandled; } } } if (index == -1) { // May be the item was just created by another program or tool (e.g., LT-8827) m_list.ReloadList(); index = IndexOfObjOrChild(hvoTarget); } if (index == -1) { // It may be the wrong clerk, so just bail out. //MessageBox.Show("The list target is no longer available. It may have been deleted.", // "Target not found", MessageBoxButtons.OK); return false; } else { JumpToIndex(index); } fHandled = true; return fHandled; //we handled this. } finally { // Even if we didn't handle it, that might just be because something prevented us from // finding the object. But if we leave load-record suspended, a pane may never again get // drawn this whole session! this.SuspendLoadingRecordUntilOnJumpToRecord = false; } }
/// <summary> /// Initialize the IxCoreColleague /// </summary> /// <param name="mediator"></param> /// <param name="viewConfiguration"></param> public virtual void Init(Mediator mediator, XmlNode viewConfiguration) { CheckDisposed(); XmlNode clerkConfiguration = ToolConfiguration.GetClerkNodeFromToolParamsNode(viewConfiguration); m_mediator = mediator; m_clerkConfiguration = clerkConfiguration; m_id = XmlUtils.GetOptionalAttributeValue(clerkConfiguration, "id", "missingId"); m_clerkProvidingRootObject = XmlUtils.GetOptionalAttributeValue(clerkConfiguration,"clerkProvidingOwner"); m_shouldHandleDeletion = XmlUtils.GetOptionalBooleanAttributeValue(clerkConfiguration, "shouldHandleDeletion", true); m_fAllowDeletions = XmlUtils.GetOptionalBooleanAttributeValue(clerkConfiguration, "allowDeletions", true); var cache = (FdoCache)m_mediator.PropertyTable.GetValue("cache"); m_list = RecordList.Create(cache, mediator, clerkConfiguration.SelectSingleNode("recordList")); m_list.Clerk = this; m_relatedClerk = XmlUtils.GetOptionalAttributeValue(clerkConfiguration, "relatedClerk"); m_relationToRelatedClerk = XmlUtils.GetOptionalAttributeValue(clerkConfiguration, "relationToRelatedClerk"); TryRestoreSorter(mediator, clerkConfiguration, cache); TryRestoreFilter(mediator, clerkConfiguration, cache); m_list.ListChanged += OnListChanged; m_list.AboutToReload += m_list_AboutToReload; m_list.DoneReload += m_list_DoneReload; XmlNode recordFilterListProviderNode = ToolConfiguration.GetDefaultRecordFilterListProvider(clerkConfiguration); bool fSetFilterMenu = false; if (recordFilterListProviderNode != null) { m_filterProvider = RecordFilterListProvider.Create(m_mediator, recordFilterListProviderNode); if (m_filterProvider != null && m_list.Filter != null) { // find any matching persisted menubar filter // NOTE: for now assume we can only set/persist one such menubar filter at a time. foreach (RecordFilter menuBarFilterOption in m_filterProvider.Filters) { if (m_list.Filter.Contains(menuBarFilterOption)) { m_activeMenuBarFilter = menuBarFilterOption; m_filterProvider.OnAdjustFilterSelection(m_activeMenuBarFilter); m_mediator.PropertyTable.SetDefault(CurrentFilterPropertyTableId, m_activeMenuBarFilter.id, false, PropertyTable.SettingsGroup.LocalSettings); fSetFilterMenu = true; break; } } } } if (!fSetFilterMenu) { OnAdjustFilterSelection(null); } // we never want to persist this value, since it is dependent upon the filter property. m_mediator.PropertyTable.SetPropertyPersistence(CurrentFilterPropertyTableId, false, PropertyTable.SettingsGroup.LocalSettings); //we handled the tree bar only if we are the root clerk if (m_clerkProvidingRootObject == null) { m_recordBarHandler = RecordBarHandler.Create(m_mediator, clerkConfiguration);//,m_flid); } else { RecordClerk clerkProvidingRootObject; Debug.Assert(TryClerkProvidingRootObject(out clerkProvidingRootObject), "We expected to find clerkProvidingOwner '" + m_clerkProvidingRootObject + "'. Possibly misspelled."); } //mediator. TraceLevel = TraceLevel.Info; //we do not want to be a top-level colleague, because //if we were, we would always receive events, for example navigation events //which might be intended for another RecordClerk, specifically the RecordClerk //being used by the currently active vector editor, browse view, etc. //so, instead, we let the currently active view include us as a "child" colleague. //NO! mediator.AddColleague(this); // Install this object in the PropertyTable so that others can find it. // NB: This *must* be done before the call to SetupDataContext, // or we are asking for an infinite loop, has SetupDataContext() // causes user interface widgets to wake up and look for this object. // If we have not registered the existence of this object yet in the property table, // those widgets will be inclined to try to create us. Hence, the infinite loop. //Note that, on the downside, this means that we need to be careful //not to broadcast any record changes until we are actually initialize enough //to deal with the resulting request that will come from those widgets. StoreClerkInPropertyTable(clerkConfiguration); SetupDataContext(false); }
/// <summary> /// Determine if the given filter (or subfilter) can be activated for the given /// column specification. /// </summary> /// <param name="filter">target filter</param> /// <param name="colSpec">column node spec </param> /// <returns>true, if the column node spec can use the filter.</returns> public bool CanActivateFilter(RecordFilter filter, XmlNode colSpec) { CheckDisposed(); if (filter is AndFilter) { ArrayList filters = (ArrayList)(filter as AndFilter).Filters; foreach (RecordFilter rf in filters) { if ((rf is FilterBarCellFilter || rf is ListChoiceFilter) && CanActivateFilter(rf, colSpec)) { return true; } } } else if (filter is FilterBarCellFilter) { FilterBarCellFilter fbcf = filter as FilterBarCellFilter; IStringFinder colFinder = LayoutFinder.CreateFinder(m_cache, colSpec, m_bv.BrowseView.Vc); if (fbcf.Finder.SameFinder(colFinder)) return true; } else if (filter is ListChoiceFilter) { return (filter as ListChoiceFilter).CompatibleFilter(colSpec); } return false; }
/// ------------------------------------------------------------------------------------------ /// <summary> /// Removes the specified f. /// </summary> /// <param name="f">The f.</param> /// ------------------------------------------------------------------------------------------ public void Remove(RecordFilter f) { for (int i = 0; i < m_filters.Count; ++i) { if (((RecordFilter)m_filters[i]).SameFilter(f)) { var filterToRemove = m_filters[i]; m_filters.RemoveAt(i); break; } } }
/// <summary> /// /// </summary> /// <param name="filter"></param> /// <returns>True if one of our filters can be found in the given filter.</returns> private bool ContainsOurFilter(RecordFilter filter) { if (filter == null) return false; for (int i = 0; i < Filters.Count; ++i) { if (filter.Contains(Filters[i] as RecordFilter)) return true; } return false; }
/// <summary> /// If this or a contained filter is considered equal to the argument, answer true /// </summary> public bool Contains(RecordFilter other) { return EqualContainedFilter(other) != null; }
/// <summary> /// display the given record /// </summary> /// <param name="argument">the hvo of the record</param> /// <returns></returns> public bool OnJumpToRecord(object argument) { CheckDisposed(); try { var hvoTarget = (int) argument; int index = IndexOfObjOrChildOrParent(hvoTarget); if (index == -1) { // See if this is a subclass that knows how to add items. if (AddItemToList(hvoTarget)) index = IndexOfObjOrChildOrParent(hvoTarget); } if (m_list.Filter != null && index == -1) { // We can get here with an irrelevant target hvo, for example by inserting a new // affix allomorph in an entry (see LT-4025). So make sure we have a suitable // target before complaining to the user about a filter being on. var mdc = (IFwMetaDataCacheManaged)m_list.VirtualListPublisher.MetaDataCache; int clidList = mdc.FieldExists(m_list.Flid) ? mdc.GetDstClsId(m_list.Flid) : -1; int clidObj = m_list.Cache.ServiceLocator.GetInstance<ICmObjectRepository>().GetObject(hvoTarget).ClassID; // If (int) clidList is -1, that means it was for a decorator property and the IsSameOrSubclassOf // test won't be valid. // Enhance JohnT/CurtisH: It would be better to if decorator properties were recorded in the MDC, or // if we could access the decorator MDC. bool fSuitableTarget = clidList == -1 || DomainObjectServices.IsSameOrSubclassOf(mdc, clidObj, clidList); if (fSuitableTarget) { DialogResult dr = MessageBox.Show( xWorksStrings.LinkTargetNotAvailableDueToFilter, xWorksStrings.TargetNotFound, MessageBoxButtons.YesNo); if (dr == DialogResult.Yes) { // We had changed from OnChangeFilter to SendMessage("RemoveFilters") to solve a filterbar // update issue reported in (LT-2448). However, that message only works in the context of a // BrowseViewer, not a document view (e.g. Dictionary) (see LT-7298). So, I've // tested OnChangeFilterClearAll, and it seems to solve both problems now. OnChangeFilterClearAll(null); m_activeMenuBarFilter = null; index = IndexOfObjOrChildOrParent(hvoTarget); } else { // user wants to give up return true; } } } if (index == -1) { // May be the item was just created by another program or tool (e.g., LT-8827) m_list.ReloadList(); index = IndexOfObjOrChildOrParent(hvoTarget); if (index == -1) { // It may be the wrong clerk, so just bail out. //MessageBox.Show("The list target is no longer available. It may have been deleted.", // "Target not found", MessageBoxButtons.OK); return false; } } JumpToIndex(index); return true; //we handled this. } finally { // Even if we didn't handle it, that might just be because something prevented us from // finding the object. But if we leave load-record suspended, a pane may never again get // drawn this whole session! SuspendLoadingRecordUntilOnJumpToRecord = false; } }
/// ------------------------------------------------------------------------------------------ /// <summary> /// This is the start of an equality test for filters, but for now I (JohnT) am not /// making it an actual Equals function, since it may not be robust enough to /// satisfy all the functions of Equals, and I don't want to mess with changing the /// hash function. It is mainly for FilterBarRecordFilters, so for now other classes /// just answer false. /// </summary> /// <param name="other">The other.</param> /// <returns></returns> /// ------------------------------------------------------------------------------------------ public override bool SameFilter(RecordFilter other) { FilterBarCellFilter fbcOther = other as FilterBarCellFilter; if (fbcOther == null) return false; return fbcOther.m_finder.SameFinder(m_finder) && fbcOther.m_matcher.SameMatcher(m_matcher); }
/// <summary> /// Change the list filter to the currently selected (checked) FilterList item. /// This selection is stored in the property table based on the name of the filter /// associated with the current clerk. /// </summary> private void OnChangeFilterToCheckedListPropertyChoice() { string filterName = m_mediator.PropertyTable.GetStringProperty(CurrentFilterPropertyTableId, "", PropertyTable.SettingsGroup.LocalSettings); RecordFilter addf = null; RecordFilter remf = null; var nof = new NoFilters(); // Check for special cases. if (filterName == (new UncheckAll()).Name) { // we're simply unselecting all items in the list. // no need for further changes. return; } if (filterName == nof.Name) { OnChangeFilterClearAll(null); // get rid of all the ones we're allowed to. return; } else if (m_filterProvider != null) { addf = (RecordFilter)m_filterProvider.GetFilter(filterName); if (addf == null || addf is NullFilter) { // If we have no filter defined for this name, it is effectively another way to turn // filters off. Turn off all we can. OnChangeFilterClearAll(null); // get rid of all the ones we're allowed to. return; } // If we have a menu-type filter active, remove it. Otherwise don't remove anything. remf = m_activeMenuBarFilter; m_activeMenuBarFilter = addf is NullFilter ? null : addf; } OnChangeFilter(new FilterChangeEventArgs(addf, remf)); }
/// ------------------------------------------------------------------------------------------ /// <summary> /// Removes the specified f. /// </summary> /// <param name="f">The f.</param> /// ------------------------------------------------------------------------------------------ public void Remove(RecordFilter f) { for (int i = 0; i < m_filters.Count; ++i) { if ((m_filters[i] as RecordFilter).SameFilter(f)) { m_filters.RemoveAt(i); break; } } }
private static void AddFilterChoice(RecordFilter filter, UIListDisplayProperties display) { string value = filter.id; string imageName = filter.imageName; // Since we are storing actual, instantiated filter objects, there's no point in also keeping // their configuration information separately. Any configuration information they had would // have already been sucked in when the filter was created. display.List.Add(filter.Name, value, imageName, null); }
/// --------------------------------------------------------------------------------------- /// <summary> /// This is the start of an equality test for filters, but for now I (JohnT) am not /// making it an actual Equals function, since it may not be robust enough to /// satisfy all the functions of Equals, and I don't want to mess with changing the /// hash function. It is mainly for FilterBarRecordFilters, so for now other classes /// just answer false. /// </summary> /// <param name="other">The other.</param> /// <returns></returns> /// --------------------------------------------------------------------------------------- public virtual bool SameFilter(RecordFilter other) { return other == this; }
/// <summary> /// Executes in two distinct scenarios. /// /// 1. If disposing is true, the method has been called directly /// or indirectly by a user's code via the Dispose method. /// Both managed and unmanaged resources can be disposed. /// /// 2. If disposing is false, the method has been called by the /// runtime from inside the finalizer and you should not reference (access) /// other managed objects, as they already have been garbage collected. /// Only unmanaged resources can be disposed. /// </summary> /// <param name="disposing"></param> /// <remarks> /// If any exceptions are thrown, that is fine. /// If the method is being done in a finalizer, it will be ignored. /// If it is thrown by client code calling Dispose, /// it needs to be handled by fixing the bug. /// /// If subclasses override this method, they should call the base implementation. /// </remarks> protected virtual void Dispose(bool disposing) { System.Diagnostics.Debug.WriteLineIf(!disposing, "****** Missing Dispose() call for " + GetType().Name + ". ****** "); // Must not be run more than once. if (m_isDisposed) return; if (disposing) { // Dispose managed resources here. //ResetStatusBarPanel("StatusPanelRecordNumber", ""); //ResetStatusBarPanel("StatusPanelMessage", ""); m_list.ListChanged -= OnListChanged; m_list.AboutToReload -= m_list_AboutToReload; m_list.DoneReload -= m_list_DoneReload; RemoveNotification(); // before disposing list, we need it to get to the Cache. m_list.Dispose(); if (m_mediator != null) { m_mediator.RemoveColleague(this); } if (m_rch != null) m_rch.Dispose(); if (m_recordBarHandler != null) m_recordBarHandler.Dispose(); } // Dispose unmanaged resources here, whether disposing is true or false. m_mediator = null; // This has to be done after the calls to ResetStatusBarPanel in the 'true' section. m_list = null; m_id = null; m_clerkProvidingRootObject = null; m_recordBarHandler = null; m_filterProvider = null; m_activeMenuBarFilter = null; m_rch = null; m_fIsActiveInGui = false; m_isDisposed = true; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="T:FilterChangeEventArgs"/> class. /// </summary> /// <param name="added">The added RecordFilter.</param> /// <param name="removed">The removed RecordFilter.</param> /// ------------------------------------------------------------------------------------ public FilterChangeEventArgs(RecordFilter added, RecordFilter removed) { m_added = added; m_removed = removed; }
public void OnChangeFilterClearAll(object commandObject) { CheckDisposed(); m_activeMenuBarFilter = null; // there won't be a menu bar filter after this. if (Filter is AndFilter) { // If some parts are not user visible we should not remove them. var af = (AndFilter) Filter; var children = af.Filters; var childrenToKeep = from RecordFilter filter in children where !filter.IsUserVisible select filter; var count = childrenToKeep.Count(); if (count == 1) { OnChangeFilter(new FilterChangeEventArgs(childrenToKeep.First(), af)); return; } else if (count > 0) { var af2 = m_list.CreateNewAndFilter(childrenToKeep.ToArray()); OnChangeFilter(new FilterChangeEventArgs(af2, Filter)); return; } // Otherwise none of the children need to be kept, get rid of the whole filter. } OnChangeFilter(new FilterChangeEventArgs(null, Filter)); }
/// <summary> /// Test to see if this filter matches the other filter. /// </summary> /// <param name="other"></param> /// <returns></returns> public override bool SameFilter(RecordFilter other) { return (other != null && other is WordSetFilter && other.id == this.id && other.Name == this.Name); }
/// <summary> /// Change the list filter to the currently selected (checked) FilterList item. /// This selection is stored in the property table based on the name of the filter /// associated with the current clerk. /// </summary> private void OnChangeFilterToCheckedListPropertyChoice() { string filterName = m_mediator.PropertyTable.GetStringProperty(this.CurrentFilterPropertyTableId, "", PropertyTable.SettingsGroup.LocalSettings); RecordFilter addf = null; RecordFilter remf = null; NoFilters nof = new NoFilters(); // Check for special cases. if (filterName == (new Filters.UncheckAll()).Name) { // we're simply unselecting all items in the list. // no need for further changes. return; } else if (filterName == nof.Name) { remf = Filter; m_activeMenuBarFilter = null; } else if (m_filterProvider != null) { addf = (RecordFilter)m_filterProvider.GetFilter(filterName); // If we have a filter defined for this filterName, then only remove the activeMenuBarFilter. // Otherwise remove all filters. if (addf != null) remf = m_activeMenuBarFilter; else remf = Filter; m_activeMenuBarFilter = addf is NullFilter ? null : addf; } OnChangeFilter(new FilterChangeEventArgs(addf, remf)); }