public SortDescriptionInfo( DataGridItemPropertyBase property, ListSortDirection direction) { m_property = property; m_direction = direction; }
internal AutoFilterValuesChangedEventArgs( DataGridDetailDescription detailDescription, DataGridItemPropertyBase itemProperty, IList autoFilterValues, NotifyCollectionChangedEventArgs collectionChangedEvent) { if (itemProperty == null) { throw new ArgumentNullException("itemProperty"); } if (autoFilterValues == null) { throw new ArgumentNullException("autoFilterValues"); } if (collectionChangedEvent == null) { throw new ArgumentNullException("collectionChangedEvent"); } this.DetailDescription = detailDescription; this.ItemProperty = itemProperty; this.CollectionChangedEventArgs = collectionChangedEvent; this.AutoFilterValues = autoFilterValues; }
protected DataGridItemPropertyBase(DataGridItemPropertyBase template) : this() { m_name = template.m_name; m_dataType = template.m_dataType; m_title = template.m_title; m_synonym = template.m_synonym; m_flags[DataGridItemPropertyBaseFlags.IsReadOnly] = template.m_flags[DataGridItemPropertyBaseFlags.IsReadOnly]; m_flags[DataGridItemPropertyBaseFlags.IsOverrideReadOnlyForInsertionSet] = template.m_flags[DataGridItemPropertyBaseFlags.IsOverrideReadOnlyForInsertionSet]; m_flags[DataGridItemPropertyBaseFlags.IsOverrideReadOnlyForInsertion] = template.m_flags[DataGridItemPropertyBaseFlags.IsOverrideReadOnlyForInsertion]; m_flags[DataGridItemPropertyBaseFlags.IsASubRelationshipSet] = template.m_flags[DataGridItemPropertyBaseFlags.IsASubRelationshipSet]; m_flags[DataGridItemPropertyBaseFlags.IsASubRelationship] = template.m_flags[DataGridItemPropertyBaseFlags.IsASubRelationship]; m_flags[DataGridItemPropertyBaseFlags.IsBrowsable] = template.m_flags[DataGridItemPropertyBaseFlags.IsBrowsable]; m_flags[DataGridItemPropertyBaseFlags.CalculateDistinctValues] = template.m_flags[DataGridItemPropertyBaseFlags.CalculateDistinctValues]; m_converter = template.m_converter; m_converterCulture = template.m_converterCulture; m_converterParameter = template.m_converterParameter; this.FilterCriterion = template.m_filterCriterion; m_foreignKeyDescription = template.m_foreignKeyDescription; m_maxDistinctValues = template.m_maxDistinctValues; m_sortComparer = template.m_sortComparer; this.DistinctValuesEqualityComparer = template.DistinctValuesEqualityComparer; this.DistinctValuesSortComparer = template.DistinctValuesSortComparer; // FilterCriterionChanged is not cloned since only used after the clone occurs this.PropertyChanged += template.PropertyChanged; this.QueryDistinctValue += template.m_queryDistinctValue; }
internal object[] GetItemPropertyDistinctValues(DataGridItemPropertyBase dataGridItemProperty) { if (m_queryableSource == null) { return(new object[0]); } IQueryable distinctQueryable = m_queryableSource.GetSubGroupsAndCountsQueryable(dataGridItemProperty.Name, false, ListSortDirection.Ascending); List <object> distinctValuesAndCounts = new List <object>(); try { System.Collections.IEnumerator enumerator = distinctQueryable.GetEnumerator(); while (enumerator.MoveNext()) { QueryableExtensions.IQueryableGroupNameCountPair current = enumerator.Current as QueryableExtensions.IQueryableGroupNameCountPair; if (current != null) { distinctValuesAndCounts.Add(current.GroupName); } } return(distinctValuesAndCounts.ToArray()); } catch { // TimeOut exception on the connection or other. return(new object[0]); } }
private void OnAutoFilterValuesCollectionChanged(object sender, NotifyCollectionChangedEventArgs e) { if (this.AutoFilterMode == AutoFilterMode.None) { return; } ObservableHashList hashList = sender as ObservableHashList; if (hashList == null) { return; } string fieldName = m_registeredAutoFilterValuesToFieldNames[hashList]; if (string.IsNullOrEmpty(fieldName)) { return; } DataGridItemPropertyBase itemProperty = this.ItemProperties[fieldName]; if (itemProperty == null) { return; } this.DetailDescriptionAutoFilterValuesChanged(new AutoFilterValuesChangedEventArgs(this, itemProperty, hashList, e)); }
internal virtual void OnItemPropertiesCollectionChanged(object sender, NotifyCollectionChangedEventArgs e) { switch (e.Action) { case NotifyCollectionChangedAction.Replace: Debug.Assert(false, "The replace of an ItemProperty is not supported."); break; case NotifyCollectionChangedAction.Remove: int oldItemsCount = (e.OldItems != null) ? e.OldItems.Count : 0; for (int i = 0; i < oldItemsCount; i++) { DataGridItemPropertyBase dataGridItemProperty = e.OldItems[i] as DataGridItemPropertyBase; Debug.Assert(dataGridItemProperty != null); this.UnregisterAutoFilterValuesChangedEvent(dataGridItemProperty.Name); } break; case NotifyCollectionChangedAction.Reset: this.UnregisterAllAutoFilterValuesChangedEvent(); break; } }
internal override void OnEditBegun(DataGridItemEventArgs e) { object item = e.Item; DataGridPageManagerBase pageManager = this.RootGroup.GetVirtualPageManager(); if (!pageManager.IsItemDirty(item)) { // First time we enter edit on this item. DataGridItemPropertyCollection itemProperties = this.ItemProperties; int count = itemProperties.Count; string[] propertyNames = new string[count]; object[] cachedValues = new object[count]; for (int i = 0; i < count; i++) { DataGridItemPropertyBase itemProperty = itemProperties[i]; propertyNames[i] = itemProperty.Name; cachedValues[i] = itemProperty.GetValue(item); } // Cache the values of the never edited before row. This will help the developer find the corresponding row // in the source when times comes to commit the changes to the data source. pageManager.SetCachedValuesForItem(item, propertyNames, cachedValues); } base.OnEditBegun(e); }
public override object GetValue(object component) { DataGridItemPropertyBase dataGridItemProperty = this.DataGridItemProperty; if (dataGridItemProperty == null) { return(null); } return(dataGridItemProperty.GetValue(base.GetValue(component))); }
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); } }
public override void SetValue(object component, object value) { if (component is EmptyDataItem) { throw new InvalidOperationException("An attempt was made to set a value on an empty data item."); } DataGridItemPropertyBase dataGridItemProperty = this.DataGridItemProperty; if (dataGridItemProperty == null) { return; } dataGridItemProperty.SetValue(component, value); }
internal virtual void ApplyExtraPropertiesToView(DataGridCollectionViewBase currentView) { DataGridItemPropertyCollection currentViewItemProperties = currentView.ItemProperties; int count = m_itemProperties.Count; for (int i = 0; i < count; i++) { DataGridItemPropertyBase itemProperty = m_itemProperties[i]; int index = currentViewItemProperties.IndexOf(itemProperty.Name); if (index == -1) { currentViewItemProperties.Add(itemProperty); } else { currentViewItemProperties[index] = itemProperty; } } count = currentView.ItemProperties.Count; bool defaultCalculateDistinctValues = this.DefaultCalculateDistinctValues; for (int i = 0; i < count; i++) { DataGridItemPropertyBase dataGridItemProperty = currentView.ItemProperties[i]; // Set default value for CalculateDistinctValues if not explicitly set if (!dataGridItemProperty.IsCalculateDistinctValuesInitialized) { dataGridItemProperty.CalculateDistinctValues = defaultCalculateDistinctValues; } } count = m_dataGridDetailDescriptions.Count; bool autoCreateForeignKeyDescriptions = this.AutoCreateForeignKeyDescriptions; DataGridDetailDescriptionCollection currentViewDetailDescriptions = currentView.DetailDescriptions; for (int i = 0; i < count; i++) { DataGridDetailDescription detailDescription = m_dataGridDetailDescriptions[i]; int index = currentViewDetailDescriptions.IndexOf(detailDescription.RelationName); if (index == -1) { currentViewDetailDescriptions.Add(detailDescription); } else { currentViewDetailDescriptions[index] = detailDescription; } // 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; } } currentView.AutoFilterMode = this.AutoFilterMode; currentView.DistinctValuesConstraint = this.DistinctValuesConstraint; currentView.DistinctValuesUpdateMode = this.DistinctValuesUpdateMode; currentView.FilterCriteriaMode = this.FilterCriteriaMode; }
public PropertyDescriptorFromItemPropertyBase(DataGridItemPropertyBase dataGridItemProperty) : base(dataGridItemProperty.Name) { m_dataGridItemProperty = new WeakReference(dataGridItemProperty); m_propertyType = dataGridItemProperty.DataType; }
internal QueryAutoFilterDistinctValuesEventArgs(DataGridItemPropertyBase itemProperty) { m_itemProperty = itemProperty; m_distinctValues = new List <object>(); }
private Expression GetAutoFilterValuesExpression(IQueryable queryable, ParameterExpression sharedParameterExpression) { if (queryable == null) { throw new ArgumentNullException("queryable"); } AutoFilterMode autoFilterMode = m_parentCollectionView.AutoFilterMode; if (autoFilterMode == AutoFilterMode.None) { return(null); } DataGridItemPropertyCollection itemProperties = m_parentCollectionView.ItemProperties; int itemPropertiesCount = itemProperties.Count; Expression autoFilterValuesExpression = null; for (int i = 0; i < itemPropertiesCount; i++) { DataGridItemPropertyBase itemProperty = itemProperties[i]; string itemPropertyName = itemProperty.Name; IList itemPropertyAutoFilterValues; if (m_parentCollectionView.AutoFilterValues.TryGetValue(itemPropertyName, out itemPropertyAutoFilterValues)) { int itemPropertyAutoFilterValuesCount = itemPropertyAutoFilterValues.Count; if (itemPropertyAutoFilterValuesCount == 0) { continue; } object[] itemPropertyAutoFilterValuesArray = new object[itemPropertyAutoFilterValuesCount]; itemPropertyAutoFilterValues.CopyTo(itemPropertyAutoFilterValuesArray, 0); Expression itemPropertyAutoFilterExpression = queryable.CreateEqualExpression(sharedParameterExpression, itemPropertyName, itemPropertyAutoFilterValuesArray); if (autoFilterValuesExpression == null) { autoFilterValuesExpression = itemPropertyAutoFilterExpression; } else { Debug.Assert((autoFilterMode == AutoFilterMode.And) || (autoFilterMode == AutoFilterMode.Or)); // Merge this DataGridItemProperty AutoFilterExpressions if (autoFilterMode == AutoFilterMode.And) { autoFilterValuesExpression = Expression.And(autoFilterValuesExpression, itemPropertyAutoFilterExpression); } else { autoFilterValuesExpression = Expression.Or(autoFilterValuesExpression, itemPropertyAutoFilterExpression); } } } // Loop to next DataGridItemProperty. } return(autoFilterValuesExpression); }
private Expression GetFilterCriterionsExpression(IQueryable queryable, ParameterExpression sharedParameterExpression) { if (queryable == null) { throw new ArgumentNullException("queryable"); } FilterCriteriaMode filterCriteriaMode = m_parentCollectionView.FilterCriteriaMode; if (filterCriteriaMode == FilterCriteriaMode.None) { return(null); } DataGridItemPropertyCollection itemProperties = m_parentCollectionView.ItemProperties; int itemPropertiesCount = itemProperties.Count; Expression filterCriterionsExpression = null; for (int i = 0; i < itemPropertiesCount; i++) { DataGridItemPropertyBase itemProperty = itemProperties[i]; string itemPropertyName = itemProperty.Name; FilterCriterion filterCriterion = itemProperty.FilterCriterion; if (filterCriterion == null) { continue; } Expression propertyFilterCriterionExpression = filterCriterion.ToLinqExpression(queryable, sharedParameterExpression, itemPropertyName); if (propertyFilterCriterionExpression == null) { continue; } if (filterCriterionsExpression == null) { filterCriterionsExpression = propertyFilterCriterionExpression; } else { Debug.Assert((filterCriteriaMode == FilterCriteriaMode.And) || (filterCriteriaMode == FilterCriteriaMode.Or)); // Merge this DataGridItemProperty FilterCriterionExpressions if (filterCriteriaMode == FilterCriteriaMode.And) { filterCriterionsExpression = Expression.And(filterCriterionsExpression, propertyFilterCriterionExpression); } else { filterCriterionsExpression = Expression.Or(filterCriterionsExpression, propertyFilterCriterionExpression); } } // Loop to next DataGridItemProperty. } return(filterCriterionsExpression); }
public int Compare(RawItem xRawItem, RawItem yRawItem) { if (xRawItem == null) { if (yRawItem == null) { return(0); } else { return(-1); } } else { if (yRawItem == null) { return(1); } } ListSortDirection lastSortDirection = ListSortDirection.Ascending; SortDescriptionCollection sortDescriptions = m_collectionView.SortDescriptions; int sortDescriptionCount = sortDescriptions.Count; if (sortDescriptionCount > 0) { int result; DataGridItemPropertyCollection itemProperties = m_collectionView.ItemProperties; for (int i = 0; i < sortDescriptionCount; i++) { SortDescription sortDescription = sortDescriptions[i]; lastSortDirection = sortDescription.Direction; DataGridItemPropertyBase dataProperty = itemProperties[sortDescription.PropertyName]; if (dataProperty == null) { continue; } ISupportInitialize supportInitialize = dataProperty as ISupportInitialize; object xData = null; object yData = null; if (supportInitialize != null) { supportInitialize.BeginInit(); } try { xData = dataProperty.GetValue(xRawItem.DataItem); yData = dataProperty.GetValue(yRawItem.DataItem); } finally { if (supportInitialize != null) { supportInitialize.EndInit(); } } IComparer sortComparer = dataProperty.SortComparer; if (sortComparer != null) { result = sortComparer.Compare(xData, yData); } else { result = ObjectDataStore.CompareData(xData, yData); } if (result != 0) { if (lastSortDirection == ListSortDirection.Descending) { result = -result; } return(result); } } } if (lastSortDirection == ListSortDirection.Descending) { return(yRawItem.Index - xRawItem.Index); } return(xRawItem.Index - yRawItem.Index); }