public virtual void Clear()
{
foreach (TelerikFieldFilterDescriptor fieldFilter in ObservedFieldFilters)
{
fieldFilter.PropertyChanged -= fieldFilterHasChangedDelegate;
}
ObservedFieldFilters.Clear();
AmbethFilterDescriptor = null;
}
// Convert a complete list of arbitrary Telerik filter descriptors into a single Ambeth filter descriptor:
public virtual AmbethIFilterDescriptor ConvertTelerikFilterCollection(IList <TelerikIFilterDescriptor> filterCollection, AmbethLogicalOperator logicalOperator = AmbethLogicalOperator.AND)
{
if (filterCollection.Count < 1)
{
return(null);
}
AmbethIFilterDescriptor resultFilter = ConvertTelerikFilterDescriptor(filterCollection[0]);
for (int i = 1; i < filterCollection.Count; ++i)
{
resultFilter = AddTelerikFilterDescriptor(resultFilter, filterCollection[i], logicalOperator);
}
return(resultFilter);
}
// Return a String that visualizes the complete filter hierarchy:
public virtual String DebugVisualize(AmbethIFilterDescriptor filter, String prefix, String logicalOperator)
{
String result;
if (filter is AmbethFilterDescriptor)
{
result = prefix + logicalOperator + " " + filter.Member + " " + filter.Operator.ToString() + " " + filter.Value;
if (filter.IsCaseSensitive == true)
{
result += " (case sensitive)";
}
result += "\n";
return(result);
}
else
{
result = prefix + logicalOperator + " {\n";
String newPrefix = prefix + " " + new String(' ', logicalOperator.Length);
bool first = true;
String newLogicalOperator;
if (filter.ChildFilterDescriptors != null)
{
foreach (AmbethIFilterDescriptor filterDescriptor in filter.ChildFilterDescriptors)
{
if (first)
{
first = false;
newLogicalOperator = " ";
}
else
{
if (filter.LogicalOperator == AmbethLogicalOperator.AND)
{
newLogicalOperator = "AND";
}
else
{
newLogicalOperator = " OR";
}
}
result += DebugVisualize(filterDescriptor, newPrefix, newLogicalOperator);
}
}
result += prefix + new String(' ', logicalOperator.Length) + " }\n";
return(result);
}
}
public virtual void ControlFiltering(Object sender, GridViewFilteringEventArgs e)
{
UIControlFilterList = ((GridViewDataControl)sender).FilterDescriptors;
if (ObservedFieldFilters.Count > UIControlFilterList.Count)
{
IList <TelerikFieldFilterDescriptor> toDelete = new List <TelerikFieldFilterDescriptor>();
foreach (TelerikFieldFilterDescriptor fieldFilter in ObservedFieldFilters)
{
if (!fieldFilter.IsActive)
{
toDelete.Add(fieldFilter);
}
}
foreach (TelerikFieldFilterDescriptor fieldFilter in toDelete)
{
if (ObservedFieldFilters.Remove(fieldFilter))
{
fieldFilter.PropertyChanged -= fieldFilterHasChangedDelegate;
}
}
}
// If only the logical operator of a FieldFilter is changed, then no Filtering event is fired
// => Changes in the FieldFilters must be tracked in addition
if (e.ColumnFilterDescriptor.IsActive && e.ColumnFilterDescriptor.FieldFilter != null)
{
if (!ObservedFieldFilters.Contains(e.ColumnFilterDescriptor.FieldFilter))
{
ObservedFieldFilters.Add(e.ColumnFilterDescriptor.FieldFilter);
e.ColumnFilterDescriptor.FieldFilter.PropertyChanged += fieldFilterHasChangedDelegate;
}
}
AmbethIFilterDescriptor tempDescriptor = FilterDescriptorConverter.ConvertTelerikFilterCollection(UIControlFilterList);
if (e.ColumnFilterDescriptor.IsActive == false && e.Added.Count <TelerikIFilterDescriptor>() > 0)
{
AmbethFilterDescriptor = this.FilterDescriptorConverter.AddTelerikFilterDescriptor(tempDescriptor, ((IList <TelerikIFilterDescriptor>)e.Added)[0]);
return;
}
AmbethFilterDescriptor = tempDescriptor;
}
protected virtual bool IsMatch(AmbethIFilterDescriptor filter1, AmbethIFilterDescriptor filter2)
{
if (filter1 is AmbethFilterDescriptor)
{
if (filter2 is AmbethCompositeFilterDescriptor)
{
return(false);
}
if (filter1.Member != filter2.Member ||
filter1.Value != filter2.Value ||
filter1.Operator != filter2.Operator ||
filter1.IsCaseSensitive != filter2.IsCaseSensitive)
{
return(false);
}
return(true);
}
if (filter2 is AmbethFilterDescriptor)
{
return(false);
}
if (filter1.ChildFilterDescriptors.Count != filter2.ChildFilterDescriptors.Count)
{
return(false);
}
foreach (AmbethIFilterDescriptor child1 in filter1.ChildFilterDescriptors)
{
bool isMatched = false;
foreach (AmbethIFilterDescriptor child2 in filter2.ChildFilterDescriptors)
{
if (IsMatch(child1, child2))
{
isMatched = true;
break;
}
}
if (!isMatched)
{
return(false);
}
}
return(true);
}
// Tries to simplify a given AmbethFilter:
protected virtual AmbethIFilterDescriptor TryReduce(AmbethIFilterDescriptor filter)
{
if (filter == null)
{
return(null);
}
if (filter is AmbethFilterDescriptor)
{
return(filter);
}
if (filter.ChildFilterDescriptors == null || filter.ChildFilterDescriptors.Count == 0)
{
return(null);
}
if (filter.ChildFilterDescriptors.Count == 1)
{
return(TryReduce(filter.ChildFilterDescriptors[0]));
}
return(filter);
}
protected virtual AmbethIFilterDescriptor RemoveAmbethFilterDescriptor(AmbethIFilterDescriptor ambethFilter, AmbethIFilterDescriptor toRemoveFilter)
{
if (IsMatch(ambethFilter, toRemoveFilter))
{
return(null);
}
if (ambethFilter is AmbethFilterDescriptor)
{
return(ambethFilter);
}
foreach (AmbethIFilterDescriptor child in ambethFilter.ChildFilterDescriptors)
{
if (IsMatch(child, toRemoveFilter))
{
ambethFilter.ChildFilterDescriptors.Remove(child);
return(ambethFilter);
}
}
return(ambethFilter);
}
public virtual AmbethIFilterDescriptor Compose(AmbethIFilterDescriptor filter1, AmbethIFilterDescriptor filter2, AmbethLogicalOperator logicalOperator = AmbethLogicalOperator.AND)
{
// Try to simplify both filters before combining them:
filter1 = TryReduce(filter1);
if (filter1 == null)
{
return(TryReduce(filter2));
}
filter2 = TryReduce(filter2);
if (filter2 == null)
{
return(filter1);
}
if (filter1 is AmbethCompositeFilterDescriptor)
{
if (filter2 is AmbethCompositeFilterDescriptor)
{
return(ComposeTwoComposite(filter1 as AmbethCompositeFilterDescriptor, filter2 as AmbethCompositeFilterDescriptor, logicalOperator));
}
return(ComposeSimpleAndComposite(filter2 as AmbethFilterDescriptor, filter1 as AmbethCompositeFilterDescriptor, logicalOperator));
}
if (filter2 is AmbethCompositeFilterDescriptor)
{
return(ComposeSimpleAndComposite(filter1 as AmbethFilterDescriptor, filter2 as AmbethCompositeFilterDescriptor, logicalOperator));
}
AmbethCompositeFilterDescriptor newComposite = new AmbethCompositeFilterDescriptor();
newComposite.LogicalOperator = logicalOperator;
newComposite.ChildFilterDescriptors = new List <AmbethIFilterDescriptor>();
newComposite.ChildFilterDescriptors.Add(filter1);
newComposite.ChildFilterDescriptors.Add(filter2);
return(newComposite);
}
protected virtual void FieldFilterHasChanged(Object sender, PropertyChangedEventArgs e)
{
AmbethFilterDescriptor = FilterDescriptorConverter.ConvertTelerikFilterCollection(UIControlFilterList);
}
public virtual AmbethIFilterDescriptor RemoveTelerikFilterDescriptor(AmbethIFilterDescriptor ambethFilter, TelerikIFilterDescriptor telerikFilterDescriptor)
{
AmbethIFilterDescriptor toRemoveFilter = ConvertTelerikFilterDescriptor(telerikFilterDescriptor);
return(RemoveAmbethFilterDescriptor(ambethFilter, toRemoveFilter));
}
// Extend an Ambeth filter descriptor by an arbitrary Telerik filter descriptor:
public virtual AmbethIFilterDescriptor AddTelerikFilterDescriptor(AmbethIFilterDescriptor ambethFilter, TelerikIFilterDescriptor telerikFilterDescriptor, AmbethLogicalOperator logicalOperator = AmbethLogicalOperator.AND)
{
return(Compose(ambethFilter, ConvertTelerikFilterDescriptor(telerikFilterDescriptor), logicalOperator));
}
public virtual void Clear()
{
AmbethFilterDescriptor = null;
}
public virtual void ControlFiltering(Object sender, NotifyCollectionChangedEventArgs e)
{
AmbethFilterDescriptor = FilterDescriptorConverter.ConvertTelerikFilterCollection(((RadDataFilter)sender).FilterDescriptors);
}
