source: branches/HeuristicLab.Problems.GrammaticalOptimization/DynamicDataDisplay/InjectedPlotter.cs @ 12588

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Controls;
using Microsoft.Research.DynamicDataDisplay.Common;
using System.Windows.Data;
using System.Windows;
using System.Windows.Threading;
using System.Windows.Media;
using System.ComponentModel;

namespace Microsoft.Research.DynamicDataDisplay
{
  /// <summary>
  /// Represents a nested plotter, which can control the way how its children are drawn in dependency of parent ChartPlotter Visible rect.
  /// This plotter is designed to work inside of some other plotter.
  /// <remarks>
  /// There are 8 properties (ParentXMin, SelfXMin, etc) which can be used to tune the size and position of inner plotter
  /// in dependence on parent Plotter's Visible rect.
  /// For example, you can specify that when parent x coordinates are from 0.0 to 1.0, inner plotter's visible x coordinates are
  /// from -1.0 to 2.0. This data will be used to calculate next positions of inner plotter's children charts.
  /// </remarks>
  /// </summary>
  [SkipPropertyCheck]
  public class InjectedPlotter : InjectedPlotterBase, IPlotterElement
  {
    private double xScale = 1.0;
    private double xShift = 0.0;
    private double yScale = 1.0;
    private double yShift = 0.0;

    /// <summary>
    /// Initializes a new instance of the <see cref="InjectedPlotter"/> class.
    /// </summary>
    public InjectedPlotter() : base() { }

    protected override DataRect CoerceVisible(DataRect newVisible, DataRect baseVisible)
    {
      DataRect result = newVisible;

      if (Plotter == null)
        return baseVisible;

      DataRect outerVisible = Plotter.Viewport.Visible;

      double xMin = outerVisible.XMin * xScale + xShift;
      double xMax = outerVisible.XMax * xScale + xShift;
      double yMin = outerVisible.YMin * yScale + yShift;
      double yMax = outerVisible.YMax * yScale + yShift;

      outerVisible = DataRect.Create(xMin, yMin, xMax, yMax);

      switch (ConjunctionMode)
      {
        case ViewportConjunctionMode.None:
          result = baseVisible;
          break;
        case ViewportConjunctionMode.X:
          result = new DataRect(outerVisible.XMin, baseVisible.YMin, outerVisible.Width, baseVisible.Height);
          break;
        case ViewportConjunctionMode.Y:
          result = new DataRect(baseVisible.XMin, outerVisible.YMin, baseVisible.Width, outerVisible.Height);
          break;
        case ViewportConjunctionMode.XY:
          result = outerVisible;
          break;
        default:
          break;
      }

      return result;
    }

    private void UpdateTransform()
    {
      xScale = (SelfXMax - SelfXMin) / (ParentXMax - ParentXMin);
      xShift = SelfXMin - ParentXMin;

      yScale = (SelfYMax - SelfYMin) / (ParentYMax - ParentYMin);
      yShift = SelfYMin - ParentYMin;
    }

    protected override void OnConjunctionModeChanged()
    {
      CoerceVisible();
    }

    #region Properties

    #region Conversion properties

    public double ParentXMin
    {
      get { return (double)GetValue(ParentXMinProperty); }
      set { SetValue(ParentXMinProperty, value); }
    }

    public static readonly DependencyProperty ParentXMinProperty = DependencyProperty.Register(
      "ParentXMin",
      typeof(double),
      typeof(InjectedPlotter),
      new FrameworkPropertyMetadata(0.0, OnTransformChanged));

    public double ParentXMax
    {
      get { return (double)GetValue(ParentXMaxProperty); }
      set { SetValue(ParentXMaxProperty, value); }
    }

    public static readonly DependencyProperty ParentXMaxProperty = DependencyProperty.Register(
      "ParentXMax",
      typeof(double),
      typeof(InjectedPlotter),
      new FrameworkPropertyMetadata(1.0, OnTransformChanged));

    public double SelfXMin
    {
      get { return (double)GetValue(SelfXMinProperty); }
      set { SetValue(SelfXMinProperty, value); }
    }

    public static readonly DependencyProperty SelfXMinProperty = DependencyProperty.Register(
      "SelfXMin",
      typeof(double),
      typeof(InjectedPlotter),
      new FrameworkPropertyMetadata(0.0, OnTransformChanged));

    public double SelfXMax
    {
      get { return (double)GetValue(SelfXMaxProperty); }
      set { SetValue(SelfXMaxProperty, value); }
    }

    public static readonly DependencyProperty SelfXMaxProperty = DependencyProperty.Register(
      "SelfXMax",
      typeof(double),
      typeof(InjectedPlotter),
      new FrameworkPropertyMetadata(1.0, OnTransformChanged));

    public double ParentYMin
    {
      get { return (double)GetValue(ParentYMinProperty); }
      set { SetValue(ParentYMinProperty, value); }
    }

    public static readonly DependencyProperty ParentYMinProperty = DependencyProperty.Register(
      "ParentYMin",
      typeof(double),
      typeof(InjectedPlotter),
      new FrameworkPropertyMetadata(0.0, OnTransformChanged));

    public double ParentYMax
    {
      get { return (double)GetValue(ParentYMaxProperty); }
      set { SetValue(ParentYMaxProperty, value); }
    }

    public static readonly DependencyProperty ParentYMaxProperty = DependencyProperty.Register(
      "ParentYMax",
      typeof(double),
      typeof(InjectedPlotter),
      new FrameworkPropertyMetadata(1.0, OnTransformChanged));

    public double SelfYMin
    {
      get { return (double)GetValue(SelfYMinProperty); }
      set { SetValue(SelfYMinProperty, value); }
    }

    public static readonly DependencyProperty SelfYMinProperty = DependencyProperty.Register(
      "SelfYMin",
      typeof(double),
      typeof(InjectedPlotter),
      new FrameworkPropertyMetadata(0.0, OnTransformChanged));

    public double SelfYMax
    {
      get { return (double)GetValue(SelfYMaxProperty); }
      set { SetValue(SelfYMaxProperty, value); }
    }

    public static readonly DependencyProperty SelfYMaxProperty = DependencyProperty.Register(
      "SelfYMax",
      typeof(double),
      typeof(InjectedPlotter),
      new FrameworkPropertyMetadata(1.0, OnTransformChanged));

    private static void OnTransformChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
      InjectedPlotter plotter = (InjectedPlotter)d;
      plotter.UpdateTransform();
    }

    #endregion

    #endregion
  }
}