source: branches/HeuristicLab.Problems.GrammaticalOptimization/DynamicDataDisplay/DataSources/OneDimensional/ObservableDataSource.cs @ 12503

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Windows;
using System.Windows.Threading;

namespace Microsoft.Research.DynamicDataDisplay.DataSources
{
  // todo I don't think that we should create data source which supports 
  // suspending its DataChanged event - it is better to create
  // collection with the same functionality - then it would be able to be used
  // as a source in many data sources.
  public class ObservableDataSource<T> : IPointDataSource
  {

    /// <summary>True if collection was changed between SuspendUpdate and ResumeUpdate
    /// or false otherwise</summary>
    private bool collectionChanged = false;

    /// <summary>True if event should be raised on each collection change
    /// or false otherwise</summary>
    private bool updatesEnabled = true;

    public ObservableDataSource()
    {
      collection.CollectionChanged += OnCollectionChanged;

      // todo this is hack
      if (typeof(T) == typeof(Point))
      {
        xyMapping = t => (Point)(object)t;
      }
    }

    public ObservableDataSource(IEnumerable<T> data)
      : this()
    {
      if (data == null)
        throw new ArgumentNullException("data");

      foreach (T item in data)
      {
        collection.Add(item);
      }
    }

    public void SuspendUpdate()
    {
      updatesEnabled = false;
    }

    public void ResumeUpdate()
    {
      updatesEnabled = true;
      if (collectionChanged)
      {
        collectionChanged = false;
        RaiseDataChanged();
      }
    }

    private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
    {
      if (updatesEnabled)
      {
        RaiseDataChanged();
      }
      else
      {
        collectionChanged = true;
      }
    }

    private readonly ObservableCollection<T> collection = new ObservableCollection<T>();

    public ObservableCollection<T> Collection
    {
      get { return collection; }
    }

    public void AppendMany(IEnumerable<T> data)
    {
      if (data == null)
        throw new ArgumentNullException("data");

      updatesEnabled = false;
      foreach (var p in data)
      {
        collection.Add(p);
      }
      updatesEnabled = true;
      RaiseDataChanged();
    }

    public void AppendAsync(Dispatcher dispatcher, T item)
    {
      dispatcher.Invoke(DispatcherPriority.Normal,
        new Action(() =>
        {
          collection.Add(item);
          RaiseDataChanged();
        }));
    }

    private readonly List<Mapping<T>> mappings = new List<Mapping<T>>();
    private Func<T, double> xMapping;
    private Func<T, double> yMapping;
    private Func<T, Point> xyMapping;

    public void SetXMapping(Func<T, double> mapping)
    {
      if (mapping == null)
        throw new ArgumentNullException("mapping");

      this.xMapping = mapping;
    }

    public void SetYMapping(Func<T, double> mapping)
    {
      if (mapping == null)
        throw new ArgumentNullException("mapping");

      this.yMapping = mapping;
    }

    public void SetXYMapping(Func<T, Point> mapping)
    {
      if (mapping == null)
        throw new ArgumentNullException("mapping");

      this.xyMapping = mapping;
    }

    #region IChartDataSource Members

    private class ObservableIterator : IPointEnumerator
    {
      private readonly ObservableDataSource<T> dataSource;
      private readonly IEnumerator<T> enumerator;

      public ObservableIterator(ObservableDataSource<T> dataSource)
      {
        this.dataSource = dataSource;
        enumerator = dataSource.collection.GetEnumerator();
      }

      #region IChartPointEnumerator Members

      public bool MoveNext()
      {
        return enumerator.MoveNext();
      }

      public void GetCurrent(ref Point p)
      {
        dataSource.FillPoint(enumerator.Current, ref p);
      }

      public void ApplyMappings(DependencyObject target)
      {
        dataSource.ApplyMappings(target, enumerator.Current);
      }

      public void Dispose()
      {
        enumerator.Dispose();
        GC.SuppressFinalize(this);
      }

      #endregion
    }

    private void FillPoint(T elem, ref Point point)
    {
      if (xyMapping != null)
      {
        point = xyMapping(elem);
      }
      else
      {
        if (xMapping != null)
        {
          point.X = xMapping(elem);
        }
        if (yMapping != null)
        {
          point.Y = yMapping(elem);
        }
      }
    }

    private void ApplyMappings(DependencyObject target, T elem)
    {
      if (target != null)
      {
        foreach (var mapping in mappings)
        {
          target.SetValue(mapping.Property, mapping.F(elem));
        }
      }
    }

    public IPointEnumerator GetEnumerator(DependencyObject context)
    {
      return new ObservableIterator(this);
    }

    public event EventHandler DataChanged;
    private void RaiseDataChanged()
    {
      if (DataChanged != null)
      {
        DataChanged(this, EventArgs.Empty);
      }
    }

    #endregion
  }
}