source: branches/HeuristicLab.Problems.GrammaticalOptimization/DynamicDataDisplay/Charts/PointGraphBase.cs @ 12747

using System;
using System.Windows;
using Microsoft.Research.DynamicDataDisplay.DataSources;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using Microsoft.Research.DynamicDataDisplay.Common;
using Microsoft.Research.DynamicDataDisplay.Charts;

namespace Microsoft.Research.DynamicDataDisplay
{
  public abstract class PointsGraphBase : ViewportElement2D, IOneDimensionalChart
  {
    /// <summary>
    /// Initializes a new instance of the <see cref="PointsGraphBase"/> class.
    /// </summary>
    protected PointsGraphBase()
    {
      Viewport2D.SetIsContentBoundsHost(this, true);
    }

    #region DataSource

    public IPointDataSource DataSource
    {
      get { return (IPointDataSource)GetValue(DataSourceProperty); }
      set { SetValue(DataSourceProperty, value); }
    }

    public static readonly DependencyProperty DataSourceProperty =
      DependencyProperty.Register(
        "DataSource",
        typeof(IPointDataSource),
        typeof(PointsGraphBase),
        new FrameworkPropertyMetadata
        {
          AffectsRender = true,
          DefaultValue = null,
          PropertyChangedCallback = OnDataSourceChangedCallback
        }
      );

    private static void OnDataSourceChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
      PointsGraphBase graph = (PointsGraphBase)d;
      if (e.NewValue != e.OldValue)
      {
        graph.DetachDataSource(e.OldValue as IPointDataSource);
        graph.AttachDataSource(e.NewValue as IPointDataSource);
      }
      graph.OnDataSourceChanged(e);
    }

    private void AttachDataSource(IPointDataSource source)
    {
      if (source != null)
      {
        source.DataChanged += OnDataChanged;
      }
    }

    private void DetachDataSource(IPointDataSource source)
    {
      if (source != null)
      {
        source.DataChanged -= OnDataChanged;
      }
    }

    private void OnDataChanged(object sender, EventArgs e)
    {
      OnDataChanged();
    }

    protected virtual void OnDataChanged()
    {
      UpdateBounds(DataSource);

      RaiseDataChanged();
      Update();
    }

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

    protected virtual void OnDataSourceChanged(DependencyPropertyChangedEventArgs args)
    {
      IPointDataSource newDataSource = (IPointDataSource)args.NewValue;
      if (newDataSource != null)
      {
        UpdateBounds(newDataSource);
      }

      Update();
    }

    private void UpdateBounds(IPointDataSource dataSource)
    {
      if (Plotter2D != null)
      {
        var transform = GetTransform();
        DataRect bounds = BoundsHelper.GetViewportBounds(dataSource.GetPoints(), transform.DataTransform);
        Viewport2D.SetContentBounds(this, bounds);
      }
    }

    #endregion

    #region DataTransform

    private DataTransform dataTransform = null;
    public DataTransform DataTransform
    {
      get { return dataTransform; }
      set
      {
        if (dataTransform != value)
        {
          dataTransform = value;
          Update();
        }
      }
    }

    protected CoordinateTransform GetTransform()
    {
      if (Plotter == null)
        return null;

      var transform = Plotter2D.Viewport.Transform;
      if (dataTransform != null)
        transform = transform.WithDataTransform(dataTransform);

      return transform;
    }

    #endregion

    #region VisiblePoints

    public ReadOnlyCollection<Point> VisiblePoints
    {
      get { return GetVisiblePoints(this); }
      protected set { SetVisiblePoints(this, value); }
    }

    public static ReadOnlyCollection<Point> GetVisiblePoints(DependencyObject obj)
    {
      return (ReadOnlyCollection<Point>)obj.GetValue(VisiblePointsProperty);
    }

    public static void SetVisiblePoints(DependencyObject obj, ReadOnlyCollection<Point> value)
    {
      obj.SetValue(VisiblePointsProperty, value);
    }

    public static readonly DependencyProperty VisiblePointsProperty = DependencyProperty.RegisterAttached(
      "VisiblePoints",
      typeof(ReadOnlyCollection<Point>),
      typeof(PointsGraphBase),
      new FrameworkPropertyMetadata(null, OnVisiblePointsChanged));

    private static void OnVisiblePointsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
      PointsGraphBase graph = d as PointsGraphBase;
      if (graph != null)
      {
        graph.RaiseVisiblePointsChanged();
      }
    }

    public event EventHandler VisiblePointsChanged;
    protected void RaiseVisiblePointsChanged()
    {
      VisiblePointsChanged.Raise(this);
    }

    private bool provideVisiblePoints = false;
    public bool ProvideVisiblePoints
    {
      get { return provideVisiblePoints; }
      set
      {
        provideVisiblePoints = value;
        UpdateCore();
      }
    }

    #endregion

    protected IEnumerable<Point> GetPoints()
    {
      return DataSource.GetPoints(GetContext());
    }

    private readonly DataSource2dContext context = new DataSource2dContext();
    protected DependencyObject GetContext()
    {
      //context.VisibleRect = Plotter2D.Viewport.Visible;
      //context.ScreenRect = Plotter2D.Viewport.Output;

      return context;
    }
  }
}