Telerik DataFilter using DevForce instead of RIA Services

 

Stephane

 

 

 

namespace Telerik.Windows.Examples.DataFilter.DomainDataSource
{
    /// <summary>
    /// Interaction logic for Example.xaml
    /// </summary>
    public partial class Example
    {
  private Dictionary<Telerik.Windows.Data.FilterDescriptor, System.Windows.Controls.FilterDescriptor> filterMap
   = new Dictionary<Telerik.Windows.Data.FilterDescriptor, System.Windows.Controls.FilterDescriptor>();

  public Example()
  {
   InitializeComponent();

   // First of all, turn off filter composition, because the DomainDataSource
   // does not support composite filters like the Telerik Data Engine.
   this.radDataFilter.CanUserCreateCompositeFilters = false;
   
   // We must know the type, so we can inform RadDataFilter what to display.
   Type entityType = this.domainDataSource.DomainContext.DomainClient.EntityTypes.First();

   // This is an extension method from Telerik. It converts a type to a collection
   // of ItemProperyInfo's. RadDataFilter populates its combo boxes based on them.
   // It is located in the DataControls assembly and its namespace is
   // Telerik.Windows.Controls.Data
   IEnumerable<ItemPropertyInfo> itemProperties = entityType.ToItemProperties();
   
   // Since RadDataFilter is in unbound mode, i.e. does not have any Source.
   // we must tell it what properties to display in its combo boxes.
   this.radDataFilter.ItemProperties = itemProperties;

   // Hook up the logical operator.
   ICompositeFilterDescriptor cfd = this.radDataFilter.FilterDescriptors;
   this.domainDataSource.FilterOperator = CreateRIALogicalOperator(cfd.LogicalOperator);
   this.radDataFilter.FilterDescriptors.PropertyChanged += this.OnFilterDescriptorsPropertyChanged;

   // Hook up the FilterDescriptors
   this.radDataFilter.FilterDescriptors.CollectionChanged += this.OnFilterDescriptorsCollectionChanged;
  }

  private void OnFilterDescriptorsPropertyChanged(object sender, PropertyChangedEventArgs e)
  {
   ICompositeFilterDescriptor cfd = (ICompositeFilterDescriptor)sender;
   if (e.PropertyName == "LogicalOperator")
   {
    this.domainDataSource.FilterOperator = CreateRIALogicalOperator(cfd.LogicalOperator);
   }
  }

  private void OnFilterDescriptorsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
  {
   ICompositeFilterDescriptor cfd = (ICompositeFilterDescriptor)sender;

   switch (e.Action)
   {
    case NotifyCollectionChangedAction.Add:
     foreach (Telerik.Windows.Data.FilterDescriptor filterDescriptor
      in e.NewItems.OfType<Telerik.Windows.Data.FilterDescriptor>())
     {
      this.AddFilter(filterDescriptor);
     }
     break;
    case NotifyCollectionChangedAction.Remove:
     foreach (Telerik.Windows.Data.FilterDescriptor filterDescriptor
      in e.OldItems.OfType<Telerik.Windows.Data.FilterDescriptor>())
     {
      this.RemoveFilter(filterDescriptor);
     }
     break;
    case NotifyCollectionChangedAction.Reset:
     this.domainDataSource.FilterDescriptors.Clear();
     foreach (Telerik.Windows.Data.FilterDescriptor filterDescriptor in cfd.FilterDescriptors)
     {
      this.AddFilter(filterDescriptor);
     }
     break;
   }
  }
  
  private void AddFilter(Telerik.Windows.Data.FilterDescriptor filterDescriptor)
  {
   // Create the corresponding RIA filter based on the Telerik one.
   System.Windows.Controls.FilterDescriptor riaFilterDescriptor =
    CreateRIAFilterDescriptor(filterDescriptor);

   // Link them together so that we can find the RIA one when the
   // Telerik one fires PropertyChanged, i.e. you change its operator, value, etc.
   this.filterMap[filterDescriptor] = riaFilterDescriptor;

   // Listen for property changes, i.e. member, operator, value, etc.
   filterDescriptor.PropertyChanged += this.OnFilterDescriptorPropertyChanged;

   // We will add the descriptor, once it becomes active, i.e. when its
   // value becomes something different from FilterDescriptor.UnsetValue
  }

  private void RemoveFilter(Telerik.Windows.Data.FilterDescriptor filterDescriptor)
  {
   // Find the corresponding RIA filter from the hashtable.
   System.Windows.Controls.FilterDescriptor riaFilterDescriptor = this.filterMap[filterDescriptor];

   // Delete it from the map, since it is going away.
   this.filterMap[filterDescriptor] = null;

   // Unhook the event listener because we will no longer need it.
   filterDescriptor.PropertyChanged -= this.OnFilterDescriptorPropertyChanged;

   // Finally, remove the RIA filter from the DomainDataSource.
   this.domainDataSource.FilterDescriptors.Remove(riaFilterDescriptor);
  }
  
  private void OnFilterDescriptorPropertyChanged(object sender, PropertyChangedEventArgs e)
  {
   Telerik.Windows.Data.FilterDescriptor filterDescriptor = (Telerik.Windows.Data.FilterDescriptor)sender;
   
   // Find the corresponding RIA filter from the hashtable.
   System.Windows.Controls.FilterDescriptor riaFilterDescriptor = this.filterMap[filterDescriptor];

   switch (e.PropertyName)
   {
    case "Member":
     riaFilterDescriptor.PropertyPath = filterDescriptor.Member;
     break;
    case "Operator":
     riaFilterDescriptor.Operator = CreateRIAOperator(filterDescriptor.Operator);
     break;
    case "Value":
     // DDS is picky about these kinds of things.
     if (filterDescriptor.Value == null
      && filterDescriptor.Operator != Telerik.Windows.Data.FilterOperator.IsEqualTo
      && filterDescriptor.Operator != Telerik.Windows.Data.FilterOperator.IsNotEqualTo)
     {
      filterDescriptor.Value = Telerik.Windows.Data.FilterDescriptor.UnsetValue;
     }

     riaFilterDescriptor.Value = filterDescriptor.Value;
     
        // In case this filter is being activated for the first time -- add it.
     if (!FilterDescriptor.UnsetValue.Equals(riaFilterDescriptor.Value)
      && !this.domainDataSource.FilterDescriptors.Contains(riaFilterDescriptor))
     {
      this.domainDataSource.FilterDescriptors.Add(riaFilterDescriptor);
     }
     
     break;
    case "IsCaseSensitive":
     riaFilterDescriptor.IsCaseSensitive = filterDescriptor.IsCaseSensitive;
     break;
   }
  }

  private static System.Windows.Controls.FilterOperator CreateRIAOperator(Telerik.Windows.Data.FilterOperator filterOperator)
  {
   return (System.Windows.Controls.FilterOperator)Enum.Parse(typeof(System.Windows.Controls.FilterOperator), filterOperator.ToString(), true);
  }
  
  private static System.Windows.Controls.FilterDescriptorLogicalOperator CreateRIALogicalOperator(Telerik.Windows.Data.FilterCompositionLogicalOperator logicalOperator)
  {
   return (System.Windows.Controls.FilterDescriptorLogicalOperator)Enum.Parse(typeof(Telerik.Windows.Data.FilterCompositionLogicalOperator), logicalOperator.ToString(), true);
  }

  private static System.Windows.Controls.FilterDescriptor CreateRIAFilterDescriptor(Telerik.Windows.Data.FilterDescriptor filterDescriptor)
  {
   System.Windows.Controls.FilterDescriptor riaFilterDescriptor = new System.Windows.Controls.FilterDescriptor();
   riaFilterDescriptor.PropertyPath = filterDescriptor.Member;
   riaFilterDescriptor.Operator = CreateRIAOperator(filterDescriptor.Operator);
   riaFilterDescriptor.Value = filterDescriptor.Value;
   riaFilterDescriptor.IsCaseSensitive = filterDescriptor.IsCaseSensitive;
   
   // This is very important. Telerik filters are born with a value equal to
   // Telerik.Windows.Data.FilterDescriptor.UnsetValue. Set this to be the
   // IgnoredValue value so that the DomainDataSource knows that such filters
   // are not yet active.
   riaFilterDescriptor.IgnoredValue = Telerik.Windows.Data.FilterDescriptor.UnsetValue;
   
   return riaFilterDescriptor;
  }

  private void OnDomainDataSourceLoadedData(object sender, System.Windows.Controls.LoadedDataEventArgs e)
  {
   if (e.HasError)
   {
    //Avoid showing exceptions when data exceeds URI length limitations /e.g adding too many filter descriptors/
    e.MarkErrorAsHandled();
   }
  }
    }
}