internal QueryGroupsEventArgs( DataGridVirtualizingCollectionView collectionView, DataGridVirtualizingCollectionViewGroup parentGroup, GroupDescription childGroupDescription) { m_dataGridVirtualizingCollectionView = collectionView; m_readonlyGroupPath = parentGroup.GroupPath.AsReadOnly(); m_childGroupDescription = childGroupDescription; this.ChildGroupPropertyName = DataGridCollectionViewBase.GetPropertyNameFromGroupDescription(childGroupDescription); m_sortDirection = SortDirection.None; SortDescriptionCollection sortDescriptions = m_dataGridVirtualizingCollectionView.SortDescriptions; int sortDescriptionCount = (sortDescriptions == null) ? 0 : sortDescriptions.Count; for (int i = 0; i < sortDescriptions.Count; i++) { SortDescription sortDescription = sortDescriptions[i]; if (string.Equals(sortDescription.PropertyName, this.ChildGroupPropertyName)) { m_sortDirection = (sortDescription.Direction == ListSortDirection.Ascending) ? SortDirection.Ascending : SortDirection.Descending; break; } } m_childGroupNameCountPairs = new List <GroupNameCountPair>(); }
private static IDisposable DeferResortHelper( IEnumerable itemsSourceCollection, CollectionView collectionView, SortDescriptionCollection sortDescriptions) { IDisposable resortDisposable = null; DataGridSortDescriptionCollection dataGridSortDescriptions = sortDescriptions as DataGridSortDescriptionCollection; if (dataGridSortDescriptions != null) { // We are in a detail resortDisposable = dataGridSortDescriptions.DeferResort(); } else { Debug.Assert(collectionView != null, "We must have a CollectionView when we are not processing a Detail"); DataGridCollectionViewBase dataGridCollectionView = itemsSourceCollection as DataGridCollectionViewBase; if (dataGridCollectionView != null) { resortDisposable = dataGridCollectionView.DataGridSortDescriptions.DeferResort(); } else { resortDisposable = collectionView.DeferRefresh(); } } Debug.Assert(resortDisposable != null); return(resortDisposable); }
internal override DataGridCollectionViewBase CreateDetailDataGridCollectionViewBase( IEnumerable detailDataSource, DataGridDetailDescription parentDetailDescription, DataGridCollectionViewBase rootDataGridCollectionViewBase) { throw new NotImplementedException(); }
protected override void CancelEditCore() { DataGridContext dataGridContext = DataGridControl.GetDataGridContext(this); DataGridCollectionViewBase dataGridCollectionViewBase = (dataGridContext == null) ? null : dataGridContext.ItemsSourceCollection as DataGridCollectionViewBase; if (dataGridCollectionViewBase != null) { // We do not want to call EditItem when the item is the one in the insertionrow if (dataGridCollectionViewBase.CurrentEditItem == this.DataContext) { dataGridCollectionViewBase.CancelEdit(); } } else { IEditableObject editableObject = this.EditableObject; // editableObject can be equal to this when the datarow is directly inserted as Items in the DataGridControl. if ((editableObject != null) && (editableObject != this)) { editableObject.CancelEdit(); } } base.CancelEditCore(); }
internal virtual void ApplyExtraPropertiesToView(DataGridCollectionViewBase currentView) { var currentViewItemProperties = currentView.ItemProperties; foreach (var itemProperty in m_itemProperties) { currentViewItemProperties[itemProperty.Name] = itemProperty; } var defaultCalculateDistinctValues = this.DefaultCalculateDistinctValues; foreach (var itemProperty in currentViewItemProperties) { // Set default value for CalculateDistinctValues if not explicitly set if (!itemProperty.IsCalculateDistinctValuesInitialized) { itemProperty.CalculateDistinctValues = defaultCalculateDistinctValues; } } var autoCreateForeignKeyDescriptions = this.AutoCreateForeignKeyDescriptions; for (int i = 0; i < m_dataGridDetailDescriptions.Count; i++) { DataGridDetailDescription detailDescription = m_dataGridDetailDescriptions[i]; // We assume we want to auto-create ForeignKeyDescriptions for DetailDescriptions // if this.AutoCreateForeignKeyDescriptions is true and it was auto-created if (detailDescription.IsAutoCreated) { detailDescription.AutoCreateForeignKeyDescriptions = autoCreateForeignKeyDescriptions; } } }
public DataGridItemEventArgs( DataGridCollectionViewBase collectionView, object item) { m_collectionView = collectionView; m_item = item; }
private void EnsureDataGridCollectionViewBase() { var success = false; try { var newView = this.EnsureDataGridCollectionViewBaseCore(); if (newView != m_currentView) { this.ClearView(); m_currentView = newView; if (m_currentView != null) { m_currentView.ParentCollectionViewSourceBase = m_parentSource; } } Debug.Assert((m_currentView == null) || (m_currentView.ParentCollectionViewSourceBase == m_parentSource)); success = true; } finally { if (!success) { this.ClearView(); } } }
protected internal override IEnumerable GetDetailsForParentItem(DataGridCollectionViewBase parentCollectionView, object parentItem) { if (this.PropertyDescriptor == null) { throw new InvalidOperationException("An attempt was made to obtain details of a PropertyDetailDescription object whose PropertyDescriptor property has not been set."); } this.Seal(); object value = this.PropertyDescriptor.GetValue(parentItem); if (value == null) { return(null); } IEnumerable enumeration = value as IEnumerable; if (enumeration == null) { IListSource listSource = value as IListSource; if (listSource != null) { enumeration = listSource.GetList(); } } return(enumeration); }
private void EnsurePosition(DataGridContext dataGridContext) { // In the case the ItemsSource is a DataGridCollectionView // we notify the item that correspond to the DataRow for the possible modification // of his data, and should then check if is position is still the same. if (dataGridContext == null) { throw new ArgumentNullException("dataGridContext"); } if (this.IsBeingEdited) { this.RepositionPending = true; return; } this.RepositionPending = false; DataGridCollectionViewBase dataGridCollectionViewBase = dataGridContext.ItemsSourceCollection as DataGridCollectionViewBase; if (dataGridCollectionViewBase != null) { int globalSortedIndex = dataGridCollectionViewBase.IndexOf(this.DataContext); if (globalSortedIndex == -1) { return; } dataGridCollectionViewBase.EnsurePosition(globalSortedIndex); } }
public DataGridItemCancelEventArgs( DataGridCollectionViewBase collectionView, object item, bool cancel) : base(collectionView, item) { m_cancel = cancel; }
protected internal override IEnumerable GetDetailsForParentItem(DataGridCollectionViewBase parentCollectionView, object parentItem) { EntityObject entityObject = parentItem as EntityObject; if (entityObject == null) { return(null); } // Even if EntityObject is not in a loadable state, we must still return the IList // so that the ItemProperties can be extracted based on the elements type. bool entityObjectLoadable = ItemsSourceHelper.IsEntityObjectLoadable(entityObject); // We let the user take charge of handling the details. QueryEntityDetailsEventArgs args = new QueryEntityDetailsEventArgs(entityObject); if (entityObjectLoadable) { this.OnQueryDetails(args); } // The parentItem must implement IEntityWithRelationships Type parentItemType = parentItem.GetType(); if (typeof(IEntityWithRelationships).IsAssignableFrom(parentItemType)) { // Since the relationship was based on the the property // name, we must find that property using reflection. PropertyInfo propertyInfo = parentItemType.GetProperty(this.RelationName); if (propertyInfo != null) { RelatedEnd relatedEnd = propertyInfo.GetValue(parentItem, null) as RelatedEnd; if (relatedEnd != null) { // Make sure that the details are loaded // except if the user already handled it. if (!relatedEnd.IsLoaded && !args.Handled && entityObjectLoadable) { relatedEnd.Load(); } IListSource listSource = relatedEnd as IListSource; // Returns an IList to have proper change notification events. if (listSource != null) { return(listSource.GetList()); } } } } return(null); }
internal override void ApplyExtraPropertiesToView(DataGridCollectionViewBase currentView) { base.ApplyExtraPropertiesToView(currentView); DataGridVirtualizingCollectionViewBase dataGridVirtualizingCollectionView = currentView as DataGridVirtualizingCollectionViewBase; dataGridVirtualizingCollectionView.PreemptivePageQueryRatio = this.PreemptivePageQueryRatio; dataGridVirtualizingCollectionView.CommitMode = this.CommitMode; }
public DataGridCreatingNewItemEventArgs( DataGridCollectionViewBase collectionView, object newItem, bool cancel) : base(cancel) { m_collectionView = collectionView; m_newItem = newItem; }
internal void InternalInitialize(DataGridCollectionViewBase parentCollectionView) { if (string.IsNullOrEmpty(this.RelationName)) { throw new InvalidOperationException("An attempt was made to initialize a detail description that does not have a relation name."); } this.Initialize(parentCollectionView); }
public DistinctValuesDictionary(DataGridCollectionViewBase dataGridCollectionViewBase) { if (dataGridCollectionViewBase == null) { throw new DataGridInternalException("dataGridCollectionView is null."); } m_dataGridCollectionViewBase = dataGridCollectionViewBase; }
protected override void EndEditCore() { DataGridContext dataGridContext = DataGridControl.GetDataGridContext(this); base.EndEditCore(); DataGridCollectionViewBase dataGridCollectionViewBase = (dataGridContext == null) ? null : dataGridContext.ItemsSourceCollection as DataGridCollectionViewBase; try { if (dataGridCollectionViewBase != null) { if (dataGridCollectionViewBase.CurrentEditItem == this.DataContext) { dataGridCollectionViewBase.CommitEdit(); } } else { IEditableObject editableObject = this.EditableObject; // editableObject can be equal to this when the datarow is directly inserted as Items in the DataGridControl. if ((editableObject != null) && (editableObject != this)) { editableObject.EndEdit(); } } } catch (Exception exception) { // Note that we do not update the created cell's Content from the source in case the IEditableObject EndEdit implementation // throwed an exception. This is mainly due because we want to make sure that we do not lose all of the edited cells values. // This way, the end user will have the chance to correct the mistakes without loosing everything he typed. // If EndEdit throwed, call BeginEdit on the IEditableObject to make sure that it stays in edit mode. // We don't have to do this when bound to a DataGridCollectionView since it will take care of it. if (dataGridCollectionViewBase == null) { IEditableObject editableObject = this.EditableObject; // editableObject can be equal to this when the datarow is directly inserted as Items in the DataGridControl. if ((editableObject != null) && (editableObject != this)) { editableObject.BeginEdit(); } } // This method will set a validation error on the row and throw back a DataGridValidationException so that // the row stays in edition. Row.SetRowValidationErrorOnException(this, exception); } // Update the created cell's Content from the source in case the IEditableObject EndEdit implementation rectified // some values. this.UpdateCellsContentBindingTarget(); }
internal override void RefreshDistinctValuesForField(DataGridItemPropertyBase dataGridItemProperty) { if (dataGridItemProperty == null) { return; } if (dataGridItemProperty.CalculateDistinctValues == false) { return; } // List containing current column distinct values HashSet <object> currentColumnDistinctValues = new HashSet <object>(); ReadOnlyObservableHashList readOnlyColumnDistinctValues = null; // If the key is not set in DistinctValues yet, do not calculate distinct values for this field if (!(( DistinctValuesDictionary )this.DistinctValues).InternalTryGetValue(dataGridItemProperty.Name, out readOnlyColumnDistinctValues)) { return; } ObservableHashList columnDistinctValues = readOnlyColumnDistinctValues.InnerObservableHashList; // We use the DistinctValuesSortComparer if present, else the SortComparer for the DataGridItemProperty, else, // the Comparer used is the one of the base class. IComparer distinctValuesSortComparer = dataGridItemProperty.DistinctValuesSortComparer; if (distinctValuesSortComparer == null) { distinctValuesSortComparer = dataGridItemProperty.SortComparer; } using (columnDistinctValues.DeferINotifyCollectionChanged()) { DataGridVirtualizingQueryableCollectionViewGroupRoot rootGroup = this.RootGroup as DataGridVirtualizingQueryableCollectionViewGroupRoot; Debug.Assert(rootGroup != null); object[] distinctValues = rootGroup.GetItemPropertyDistinctValues(dataGridItemProperty); foreach (object distinctValue in distinctValues) { // Compute current value to be able to remove unused values currentColumnDistinctValues.Add(distinctValue); } DataGridCollectionViewBase.RemoveUnusedDistinctValues( distinctValuesSortComparer, currentColumnDistinctValues, columnDistinctValues, null); } }
internal DeferredOperationManager(DataGridCollectionViewBase collectionView, Dispatcher dispatcher, bool postPendingRefreshWithoutDispatching) { m_collectionView = collectionView; m_deferredOperations = new List <DeferredOperation>(1000); m_invalidatedGroups = new HashSet <DataGridCollectionViewGroup>(); if (postPendingRefreshWithoutDispatching) { this.Add(new DeferredOperation(DeferredOperation.DeferredOperationAction.Refresh, -1, null)); } m_dispatcher = dispatcher; }
private void ClearView() { if (m_currentView == null) { return; } var view = m_currentView; m_currentView = null; view.Dispose(); }
protected internal override IEnumerable GetDetailsForParentItem(DataGridCollectionViewBase parentCollectionView, object parentItem) { IListSource listSource = parentItem as IListSource; if (listSource == null) { return(null); } this.Seal(); return(listSource.GetList()); }
protected internal override IEnumerable GetDetailsForParentItem(DataGridCollectionViewBase parentCollectionView, object parentItem) { IEnumerable enumerable = parentItem as IEnumerable; if (enumerable == null) { return(null); } this.Seal(); return(enumerable); }
public DeferredOperationManager( DataGridCollectionViewBase collectionViewToUpdate, Dispatcher dispatcher, bool postPendingRefreshWithoutDispatching) { m_collectionViewToUpdate = collectionViewToUpdate; if (postPendingRefreshWithoutDispatching) { this.Add(new DeferredOperation(DeferredOperation.DeferredOperationAction.Refresh, -1, null)); } m_dispatcher = dispatcher; }
/////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////// protected override IEnumerable GetDetailsForParentItem(DataGridCollectionViewBase parentCollectionView, object parentItem) { Debug.Assert(parentItem is Route); IEnumerable <Stop> details = new List <Stop>(); if (null != parentItem) { _route = (Route)parentItem; details = new SortedDataObjectCollection <Stop>(_route.Stops, new StopsComparer()); } return(details); }
internal static void UpdateColumnsForeignKeyConfigurations(Dictionary <string, ColumnBase> columns, IEnumerable itemsSourceCollection, Dictionary <string, ItemsSourceHelper.FieldDescriptor> fieldDescriptors, bool autoCreateForeignKeyConfigurations) { DataGridCollectionViewBase collectionViewBase = itemsSourceCollection as DataGridCollectionViewBase; if (collectionViewBase != null) { ForeignKeyConfiguration.UpdateColumnsForeignKeyConfigurationsFromDataGridCollectionView(columns, collectionViewBase.ItemProperties, autoCreateForeignKeyConfigurations); } else { ForeignKeyConfiguration.UpdateColumnsForeignKeyConfigurationsFromFieldDescriptors(columns, fieldDescriptors, autoCreateForeignKeyConfigurations); } }
public static void RemoveListener(DataGridCollectionViewBase source, IWeakEventListener listener) { if (source == null) { throw new ArgumentNullException("source"); } if (listener == null) { throw new ArgumentNullException("listener"); } CurrentManager.ProtectedRemoveListener(source, listener); }
/////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////// protected override IEnumerable GetDetailsForParentItem(DataGridCollectionViewBase parentCollectionView, object parentItem) { IEnumerable <MessageDetailDataWrap> details = new List <MessageDetailDataWrap>(); if (null != parentItem) { _parentDataObject = (MessageWindowDataWrapper?)parentItem; if (_parentDataObject.HasValue) { details = _parentDataObject.Value.Details; } } return(details); }
internal override void ApplyExtraPropertiesToView(DataGridCollectionViewBase currentView) { base.ApplyExtraPropertiesToView(currentView); DataGridCollectionView dataGridCollectionView = currentView as DataGridCollectionView; dataGridCollectionView.StatFunctions.Clear(); foreach (var statFunction in m_statFunctions) { dataGridCollectionView.StatFunctions.Add(statFunction); } dataGridCollectionView.UpdateChangedPropertyStatsOnly = this.UpdateChangedPropertyStatsOnly; }
protected internal override void Initialize(DataGridCollectionViewBase parentCollectionView) { base.Initialize(parentCollectionView); if (this.PropertyDescriptor != null) { return; } string relationName = this.RelationName; if (String.IsNullOrEmpty(relationName) == true) { throw new InvalidOperationException("An attempt was made to initialize a PropertyDetailDescription whose Name property has not been set."); } var enumeration = parentCollectionView as IEnumerable; if (enumeration != null) { // Try to get it from the first item in the DataGridCollectionView var firstItem = ItemsSourceHelper.GetFirstItemByEnumerable(enumeration); if (firstItem != null) { var propertyDescriptor = this.GetPropertyDescriptorFromFirstItem(firstItem); if (propertyDescriptor != null) { this.PropertyDescriptor = propertyDescriptor; return; } } } // If the list is empty, check if the SourceCollection is ITypedList var typedList = parentCollectionView.SourceCollection as ITypedList; if (typedList != null) { var propertyDescriptor = this.GetPropertyDescriptorFromITypedList(typedList); if (propertyDescriptor != null) { this.PropertyDescriptor = propertyDescriptor; return; } } throw new InvalidOperationException("An attempt was made to initialize a PropertyDetailDescription whose data source does not contain a property that corresponds to the specified relation name."); }
internal override void ApplyExtraPropertiesToView(DataGridCollectionViewBase currentView) { base.ApplyExtraPropertiesToView(currentView); DataGridCollectionView dataGridCollectionView = currentView as DataGridCollectionView; dataGridCollectionView.StatFunctions.Clear(); int count = m_statFunctions.Count; for (int i = 0; i < count; i++) { dataGridCollectionView.StatFunctions.Add(m_statFunctions[i]); } dataGridCollectionView.UpdateChangedPropertyStatsOnly = this.UpdateChangedPropertyStatsOnly; }
internal DataGridGroupInfo(GroupDescription groupDescription, CollectionViewGroup collectionViewGroup) { if (groupDescription == null) { throw new ArgumentNullException("groupDescription"); } if (collectionViewGroup == null) { throw new ArgumentNullException("collectionViewGroup"); } this.GroupDescription = groupDescription; this.PropertyName = DataGridCollectionViewBase.GetPropertyNameFromGroupDescription(groupDescription); this.Value = collectionViewGroup.Name; }