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