source: branches/HeuristicLab.Problems.GrammaticalOptimization/DynamicDataDisplay/ChartPlotter.cs @ 13834

using System;
using System.Linq;
using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using Microsoft.Research.DynamicDataDisplay.Charts;
using Microsoft.Research.DynamicDataDisplay.Charts.Navigation;
using Microsoft.Research.DynamicDataDisplay.Navigation;
using Microsoft.Research.DynamicDataDisplay.Common;
using Microsoft.Research.DynamicDataDisplay.Charts.Axes;

namespace Microsoft.Research.DynamicDataDisplay
{
  /// <summary>
  /// Chart plotter is a plotter that renders axis and grid
  /// </summary>
  public class ChartPlotter : Plotter2D
  {
    private GeneralAxis horizontalAxis = new HorizontalAxis();
    private GeneralAxis verticalAxis = new VerticalAxis();
    private AxisGrid axisGrid = new AxisGrid();

    private Legend legend = new Legend();

    public ItemsPanelTemplate LegendPanelTemplate
    {
      get { return legend.ItemsPanel; }
      set
      {
        if (legend == null)
          throw new ArgumentNullException("LegendPanelTemplate");

        legend.ItemsPanel = value;
      }
    }

    public Style LegendStyle
    {
      get { return legend.Style; }
      set { legend.Style = value; }
    }

    /// <summary>
    /// Sets a value indicating whether to enable smooth axes panning for numeric axes.
    /// </summary>
    /// <value>
    ///   <c>true</c> if enable smooth axes panning for numeric axes; otherwise, <c>false</c>.
    /// </value>
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public bool EnableSmoothPanningForNumericAxes
    {
      // todo improve returned value
      get { return false; }// throw new NotImplementedException(); }
      set
      {
        foreach (var axis in Children.OfType<NumericAxis>())
        {
          axis.UseSmoothPanning = value;
        }
      }
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="ChartPlotter"/> class.
    /// </summary>
    public ChartPlotter()
      : base()
    {
      horizontalAxis.TicksChanged += OnHorizontalAxisTicksChanged;
      verticalAxis.TicksChanged += OnVerticalAxisTicksChanged;

      SetIsDefaultAxis(horizontalAxis as DependencyObject, true);
      SetIsDefaultAxis(verticalAxis as DependencyObject, true);

      mouseNavigation = new MouseNavigation();
      keyboardNavigation = new KeyboardNavigation();
      defaultContextMenu = new DefaultContextMenu();
      horizontalAxisNavigation = new AxisNavigation { Placement = AxisPlacement.Bottom };
      verticalAxisNavigation = new AxisNavigation { Placement = AxisPlacement.Left };

      Children.AddMany(
        horizontalAxis,
        verticalAxis,
        axisGrid,
        mouseNavigation,
        keyboardNavigation,
        defaultContextMenu,
        horizontalAxisNavigation,
        verticalAxisNavigation,
        new LongOperationsIndicator(),
        legend
        );

#if DEBUG
      Children.Add(new DebugMenu());
#endif

      SetAllChildrenAsDefault();
    }

    /// <summary>
    /// Creates generic plotter from this ChartPlotter.
    /// </summary>
    /// <returns></returns>
    public GenericChartPlotter<double, double> GetGenericPlotter()
    {
      return new GenericChartPlotter<double, double>(this);
    }

    /// <summary>
    /// Creates generic plotter from this ChartPlotter.
    /// Horizontal and Vertical types of GenericPlotter should correspond to ChartPlotter's actual main axes types.
    /// </summary>
    /// <typeparam name="THorizontal">The type of horizontal values.</typeparam>
    /// <typeparam name="TVertical">The type of vertical values.</typeparam>
    /// <returns>GenericChartPlotter, associated to this ChartPlotter.</returns>
    public GenericChartPlotter<THorizontal, TVertical> GetGenericPlotter<THorizontal, TVertical>()
    {
      return new GenericChartPlotter<THorizontal, TVertical>(this);
    }

    /// <summary>
    /// Creates generic plotter from this ChartPlotter.
    /// </summary>
    /// <typeparam name="THorizontal">The type of the horizontal axis.</typeparam>
    /// <typeparam name="TVertical">The type of the vertical axis.</typeparam>
    /// <param name="horizontalAxis">The horizontal axis to use as data conversion source.</param>
    /// <param name="verticalAxis">The vertical axis to use as data conversion source.</param>
    /// <returns>GenericChartPlotter, associated to this ChartPlotter</returns>
    public GenericChartPlotter<THorizontal, TVertical> GetGenericPlotter<THorizontal, TVertical>(AxisBase<THorizontal> horizontalAxis, AxisBase<TVertical> verticalAxis)
    {
      return new GenericChartPlotter<THorizontal, TVertical>(this, horizontalAxis, verticalAxis);
    }

    protected ChartPlotter(PlotterLoadMode loadMode) : base(loadMode) { }

    /// <summary>
    /// Creates empty plotter without any axes, navigation, etc.
    /// </summary>
    /// <returns>Empty plotter without any axes, navigation, etc.</returns>
    public static ChartPlotter CreateEmpty()
    {
      return new ChartPlotter(PlotterLoadMode.OnlyViewport);
    }

    public void BeginLongOperation()
    {
      LongOperationsIndicator.BeginLongOperation(this);
    }

    public void EndLongOperation()
    {
      LongOperationsIndicator.EndLongOperation(this);
    }

    #region Default charts

    private MouseNavigation mouseNavigation;
    /// <summary>
    /// Gets the default mouse navigation of ChartPlotter.
    /// </summary>
    /// <value>The mouse navigation.</value>
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public MouseNavigation MouseNavigation
    {
      get { return mouseNavigation; }
    }

    private KeyboardNavigation keyboardNavigation;
    /// <summary>
    /// Gets the default keyboard navigation of ChartPlotter.
    /// </summary>
    /// <value>The keyboard navigation.</value>
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public KeyboardNavigation KeyboardNavigation
    {
      get { return keyboardNavigation; }
    }

    private DefaultContextMenu defaultContextMenu;
    /// <summary>
    /// Gets the default context menu of ChartPlotter.
    /// </summary>
    /// <value>The default context menu.</value>
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public DefaultContextMenu DefaultContextMenu
    {
      get { return defaultContextMenu; }
    }

    private AxisNavigation horizontalAxisNavigation;
    /// <summary>
    /// Gets the default horizontal axis navigation of ChartPlotter.
    /// </summary>
    /// <value>The horizontal axis navigation.</value>
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public AxisNavigation HorizontalAxisNavigation
    {
      get { return horizontalAxisNavigation; }
    }

    private AxisNavigation verticalAxisNavigation;
    /// <summary>
    /// Gets the default vertical axis navigation of ChartPlotter.
    /// </summary>
    /// <value>The vertical axis navigation.</value>
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public AxisNavigation VerticalAxisNavigation
    {
      get { return verticalAxisNavigation; }
    }

    /// <summary>
    /// Gets the default axis grid of ChartPlotter.
    /// </summary>
    /// <value>The axis grid.</value>
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public AxisGrid AxisGrid
    {
      get { return axisGrid; }
    }

    #endregion

    private void OnHorizontalAxisTicksChanged(object sender, EventArgs e)
    {
      GeneralAxis axis = (GeneralAxis)sender;
      UpdateHorizontalTicks(axis);
    }

    private void UpdateHorizontalTicks(GeneralAxis axis)
    {
      axisGrid.BeginTicksUpdate();

      if (axis != null)
      {
        axisGrid.HorizontalTicks = axis.ScreenTicks;
        axisGrid.MinorHorizontalTicks = axis.MinorScreenTicks;
      }
      else
      {
        axisGrid.HorizontalTicks = null;
        axisGrid.MinorHorizontalTicks = null;
      }

      axisGrid.EndTicksUpdate();
    }

    private void OnVerticalAxisTicksChanged(object sender, EventArgs e)
    {
      GeneralAxis axis = (GeneralAxis)sender;
      UpdateVerticalTicks(axis);
    }

    private void UpdateVerticalTicks(GeneralAxis axis)
    {
      axisGrid.BeginTicksUpdate();

      if (axis != null)
      {
        axisGrid.VerticalTicks = axis.ScreenTicks;
        axisGrid.MinorVerticalTicks = axis.MinorScreenTicks;
      }
      else
      {
        axisGrid.VerticalTicks = null;
        axisGrid.MinorVerticalTicks = null;
      }

      axisGrid.EndTicksUpdate();
    }

    bool keepOldAxis = false;
    bool updatingAxis = false;

    /// <summary>
    /// Gets or sets the main vertical axis of ChartPlotter.
    /// Main vertical axis of ChartPlotter is axis which ticks are used to draw horizontal lines on AxisGrid.
    /// Value can be set to null to completely remove main vertical axis.
    /// </summary>
    /// <value>The main vertical axis.</value>
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public GeneralAxis MainVerticalAxis
    {
      get { return verticalAxis; }
      set
      {
        if (updatingAxis)
          return;

        if (value == null && verticalAxis != null)
        {
          if (!keepOldAxis)
          {
            Children.Remove(verticalAxis);
          }
          verticalAxis.TicksChanged -= OnVerticalAxisTicksChanged;
          verticalAxis = null;

          UpdateVerticalTicks(verticalAxis);

          return;
        }

        VerifyAxisType(value.Placement, AxisType.Vertical);

        if (value != verticalAxis)
        {
          ValidateVerticalAxis(value);

          updatingAxis = true;

          if (verticalAxis != null)
          {
            verticalAxis.TicksChanged -= OnVerticalAxisTicksChanged;
            SetIsDefaultAxis(verticalAxis, false);
            if (!keepOldAxis)
            {
              Children.Remove(verticalAxis);
            }
            value.Visibility = verticalAxis.Visibility;
          }
          SetIsDefaultAxis(value, true);

          verticalAxis = value;
          verticalAxis.TicksChanged += OnVerticalAxisTicksChanged;

          if (!Children.Contains(value))
          {
            Children.Add(value);
          }

          UpdateVerticalTicks(value);
          OnVerticalAxisChanged();

          updatingAxis = false;
        }
      }
    }

    protected virtual void OnVerticalAxisChanged() { }
    protected virtual void ValidateVerticalAxis(GeneralAxis axis) { }

    /// <summary>
    /// Gets or sets the main horizontal axis visibility.
    /// </summary>
    /// <value>The main horizontal axis visibility.</value>
    public Visibility MainHorizontalAxisVisibility
    {
      get { return MainHorizontalAxis != null ? ((UIElement)MainHorizontalAxis).Visibility : Visibility.Hidden; }
      set
      {
        if (MainHorizontalAxis != null)
        {
          ((UIElement)MainHorizontalAxis).Visibility = value;
        }
      }
    }

    /// <summary>
    /// Gets or sets the main vertical axis visibility.
    /// </summary>
    /// <value>The main vertical axis visibility.</value>
    public Visibility MainVerticalAxisVisibility
    {
      get { return MainVerticalAxis != null ? ((UIElement)MainVerticalAxis).Visibility : Visibility.Hidden; }
      set
      {
        if (MainVerticalAxis != null)
        {
          ((UIElement)MainVerticalAxis).Visibility = value;
        }
      }
    }

    /// <summary>
    /// Gets or sets the main horizontal axis of ChartPlotter.
    /// Main horizontal axis of ChartPlotter is axis which ticks are used to draw vertical lines on AxisGrid.
    /// Value can be set to null to completely remove main horizontal axis.
    /// </summary>
    /// <value>The main horizontal axis.</value>
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public GeneralAxis MainHorizontalAxis
    {
      get { return horizontalAxis; }
      set
      {
        if (updatingAxis)
          return;

        if (value == null && horizontalAxis != null)
        {
          Children.Remove(horizontalAxis);
          horizontalAxis.TicksChanged -= OnHorizontalAxisTicksChanged;
          horizontalAxis = null;

          UpdateHorizontalTicks(horizontalAxis);

          return;
        }

        VerifyAxisType(value.Placement, AxisType.Horizontal);

        if (value != horizontalAxis)
        {
          ValidateHorizontalAxis(value);

          updatingAxis = true;

          if (horizontalAxis != null)
          {
            horizontalAxis.TicksChanged -= OnHorizontalAxisTicksChanged;
            SetIsDefaultAxis(horizontalAxis, false);
            if (!keepOldAxis)
            {
              Children.Remove(horizontalAxis);
            }
            value.Visibility = horizontalAxis.Visibility;
          }
          SetIsDefaultAxis(value, true);

          horizontalAxis = value;
          horizontalAxis.TicksChanged += OnHorizontalAxisTicksChanged;

          if (!Children.Contains(value))
          {
            Children.Add(value);
          }

          UpdateHorizontalTicks(value);
          OnHorizontalAxisChanged();

          updatingAxis = false;
        }
      }
    }

    protected virtual void OnHorizontalAxisChanged() { }
    protected virtual void ValidateHorizontalAxis(GeneralAxis axis) { }

    private static void VerifyAxisType(AxisPlacement axisPlacement, AxisType axisType)
    {
      bool result = false;
      switch (axisPlacement)
      {
        case AxisPlacement.Left:
        case AxisPlacement.Right:
          result = axisType == AxisType.Vertical;
          break;
        case AxisPlacement.Top:
        case AxisPlacement.Bottom:
          result = axisType == AxisType.Horizontal;
          break;
        default:
          break;
      }

      if (!result)
        throw new ArgumentException(Strings.Exceptions.InvalidAxisPlacement);
    }

    protected override void OnIsDefaultAxisChangedCore(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
      GeneralAxis axis = d as GeneralAxis;
      if (axis != null)
      {
        bool value = (bool)e.NewValue;
        bool oldKeepOldAxis = keepOldAxis;

        bool horizontal = axis.Placement == AxisPlacement.Bottom || axis.Placement == AxisPlacement.Top;
        keepOldAxis = true;

        if (value && horizontal)
        {
          MainHorizontalAxis = axis;
        }
        else if (value && !horizontal)
        {
          MainVerticalAxis = axis;
        }
        else if (!value && horizontal)
        {
          MainHorizontalAxis = null;
        }
        else if (!value && !horizontal)
        {
          MainVerticalAxis = null;
        }

        keepOldAxis = oldKeepOldAxis;
      }
    }

    /// <summary>
    /// Gets the default legend of ChartPlotter.
    /// </summary>
    /// <value>The legend.</value>
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public Legend Legend
    {
      get { return legend; }
    }

    /// <summary>
    /// Gets or sets the visibility of legend.
    /// </summary>
    /// <value>The legend visibility.</value>
    public Visibility LegendVisibility
    {
      get { return legend.Visibility; }
      set { legend.Visibility = value; }
    }

    public bool LegendVisible
    {
      get { return legend.LegendVisible; }
      set { legend.LegendVisible = value; }
    }

    private enum AxisType
    {
      Horizontal,
      Vertical
    }
  }
}