source: branches/HeuristicLab.Problems.GrammaticalOptimization/DynamicDataDisplay/Common/Plotter.cs @ 13792

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Windows;
using System.Windows.Automation.Peers;
using System.Windows.Controls;
using System.Windows.Markup;
using System.Windows.Media.Imaging;
using Microsoft.Research.DynamicDataDisplay.Common;
using Microsoft.Research.DynamicDataDisplay.Common.Auxiliary;
using Microsoft.Research.DynamicDataDisplay.Common.UndoSystem;
using Microsoft.Research.DynamicDataDisplay.Navigation;

namespace Microsoft.Research.DynamicDataDisplay
{
  /// <summary>Plotter is a base control for displaying various graphs. It provides
  /// means to draw chart itself and side space for axes, annotations, etc</summary>
  [ContentProperty("Children")]
  [TemplatePart(Name = "PART_HeaderPanel", Type = typeof(StackPanel))]
  [TemplatePart(Name = "PART_FooterPanel", Type = typeof(StackPanel))]

  [TemplatePart(Name = "PART_BottomPanel", Type = typeof(StackPanel))]
  [TemplatePart(Name = "PART_LeftPanel", Type = typeof(StackPanel))]
  [TemplatePart(Name = "PART_RightPanel", Type = typeof(StackPanel))]
  [TemplatePart(Name = "PART_TopPanel", Type = typeof(StackPanel))]

  [TemplatePart(Name = "PART_MainCanvas", Type = typeof(Canvas))]
  [TemplatePart(Name = "PART_CentralGrid", Type = typeof(Grid))]
  [TemplatePart(Name = "PART_MainGrid", Type = typeof(Grid))]
  [TemplatePart(Name = "PART_ContentsGrid", Type = typeof(Grid))]
  [TemplatePart(Name = "PART_ParallelCanvas", Type = typeof(Canvas))]
  public abstract class Plotter : ContentControl
  {
    private PlotterLoadMode loadMode = PlotterLoadMode.Normal;
    protected PlotterLoadMode LoadMode
    {
      get { return loadMode; }
    }

    private static Plotter current;
    /// <summary>
    /// Gets the current plotter. Used in VisualDebug.
    /// </summary>
    /// <value>The current.</value>
    internal static Plotter Current
    {
      get { return Plotter.current; }
    }

    protected Plotter() : this(PlotterLoadMode.Normal) { }

    /// <summary>
    /// Initializes a new instance of the <see cref="Plotter"/> class.
    /// </summary>
    protected Plotter(PlotterLoadMode loadMode)
    {
      current = this;

      this.loadMode = loadMode;

      SetPlotter(this, this);

      if (loadMode == PlotterLoadMode.Normal)
      {
        UpdateUIParts();
      }

      children = new PlotterChildrenCollection(this);
      children.CollectionChanged += OnChildrenCollectionChanged;
      Loaded += Plotter_Loaded;
      Unloaded += Plotter_Unloaded;

      genericResources = (ResourceDictionary)Application.LoadComponent(new Uri("/DynamicDataDisplay;component/Themes/Generic.xaml", UriKind.Relative));

      ContextMenu = null;

      foreach (var panel in GetAllPanels().Where(panel => panel != null))
      {
        Plotter.SetIsDefaultPanel(panel, true);
      }
    }

    private void Plotter_Unloaded(object sender, RoutedEventArgs e)
    {
      OnUnloaded();
    }

    protected virtual void OnUnloaded() { }

    protected override AutomationPeer OnCreateAutomationPeer()
    {
      return new PlotterAutomationPeer(this);
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    public override bool ShouldSerializeContent()
    {
      return false;
    }

    protected override bool ShouldSerializeProperty(DependencyProperty dp)
    {
      // do not serialize context menu if it was created by DefaultContextMenu, because that context menu items contains references of plotter
      if (dp == ContextMenuProperty && children.Any(el => el is DefaultContextMenu)) return false;
      if (dp == TemplateProperty) return false;
      if (dp == ContentProperty) return false;

      return base.ShouldSerializeProperty(dp);
    }

    private const string templateKey = "defaultPlotterTemplate";
    private const string styleKey = "defaultPlotterStyle";
    private void UpdateUIParts()
    {
      ResourceDictionary dict = new ResourceDictionary
      {
        Source = new Uri("/DynamicDataDisplay;component/Common/PlotterStyle.xaml", UriKind.Relative)
      };

      Resources.MergedDictionaries.Add(dict);

      Style = (Style)dict[styleKey];

      ControlTemplate template = (ControlTemplate)dict[templateKey];
      Template = template;
      ApplyTemplate();
    }

    private ResourceDictionary genericResources;
    protected ResourceDictionary GenericResources
    {
      get { return genericResources; }
    }

    /// <summary>
    /// Forces plotter to load.
    /// </summary>
    public void PerformLoad()
    {
      isLoadedIntensionally = true;
      ApplyTemplate();

      Plotter_Loaded(null, null);
    }

    private bool isLoadedIntensionally = false;
    protected virtual bool IsLoadedInternal
    {
      get { return isLoadedIntensionally || IsLoaded; }
    }

    private void Plotter_Loaded(object sender, RoutedEventArgs e)
    {
      ExecuteWaitingChildrenAdditions();

      OnLoaded();
    }

    protected internal void ExecuteWaitingChildrenAdditions()
    {
      executedWaitingChildrenAdding = true;

      foreach (var pair in waitingForExecute)
      {
        pair.Value.Invoke();
      }

      waitingForExecute.Clear();
    }

    protected virtual void OnLoaded()
    {
      // this is done to enable keyboard shortcuts
      Focus();
    }

    protected override void OnTemplateChanged(ControlTemplate oldTemplate, ControlTemplate newTemplate)
    {
      base.OnTemplateChanged(oldTemplate, newTemplate);
    }

    private Grid contentsGrid;
    public override void OnApplyTemplate()
    {
      base.OnApplyTemplate();

      var headerPanel = GetPart<StackPanel>("PART_HeaderPanel");
      MigrateChildren(this.headerPanel, headerPanel);
      this.headerPanel = headerPanel;

      var footerPanel = GetPart<StackPanel>("PART_FooterPanel");
      MigrateChildren(this.footerPanel, footerPanel);
      this.footerPanel = footerPanel;

      var leftPanel = GetPart<StackPanel>("PART_LeftPanel");
      MigrateChildren(this.leftPanel, leftPanel);
      this.leftPanel = leftPanel;

      var bottomPanel = GetPart<StackPanel>("PART_BottomPanel");
      MigrateChildren(this.bottomPanel, bottomPanel);
      this.bottomPanel = bottomPanel;

      var rightPanel = GetPart<StackPanel>("PART_RightPanel");
      MigrateChildren(this.rightPanel, rightPanel);
      this.rightPanel = rightPanel;

      var topPanel = GetPart<StackPanel>("PART_TopPanel");
      MigrateChildren(this.topPanel, topPanel);
      this.topPanel = topPanel;

      var mainCanvas = GetPart<Canvas>("PART_MainCanvas");
      MigrateChildren(this.mainCanvas, mainCanvas);
      this.mainCanvas = mainCanvas;

      var centralGrid = GetPart<Grid>("PART_CentralGrid");
      MigrateChildren(this.centralGrid, centralGrid);
      this.centralGrid = centralGrid;

      var mainGrid = GetPart<Grid>("PART_MainGrid");
      MigrateChildren(this.mainGrid, mainGrid);
      this.mainGrid = mainGrid;

      var parallelCanvas = GetPart<Canvas>("PART_ParallelCanvas");
      MigrateChildren(this.parallelCanvas, parallelCanvas);
      this.parallelCanvas = parallelCanvas;

      var contentsGrid = GetPart<Grid>("PART_ContentsGrid");
      MigrateChildren(this.contentsGrid, contentsGrid);
      this.contentsGrid = contentsGrid;

      Content = contentsGrid;
      AddLogicalChild(contentsGrid);

      if (contentsGrid != null)
        ExecuteWaitingChildrenAdditions();
    }

    private void MigrateChildren(Panel previousParent, Panel currentParent)
    {
      if (previousParent != null && currentParent != null)
      {
        UIElement[] children = new UIElement[previousParent.Children.Count];
        previousParent.Children.CopyTo(children, 0);
        previousParent.Children.Clear();

        foreach (var child in children)
        {
          bool isDefaultPanel = GetIsDefaultPanel(child);
          if (!currentParent.Children.Contains(child) && !isDefaultPanel)
          {
            currentParent.Children.Add(child);
          }
        }
      }
      else if (previousParent != null)
      {
        previousParent.Children.Clear();
      }
    }

    internal virtual IEnumerable<Panel> GetAllPanels()
    {
      yield return headerPanel;
      yield return footerPanel;

      yield return leftPanel;
      yield return bottomPanel;
      yield return rightPanel;
      yield return topPanel;

      yield return mainCanvas;
      yield return centralGrid;
      yield return mainGrid;
      yield return parallelCanvas;
      yield return contentsGrid;
    }

    private T GetPart<T>(string name)
    {
      return (T)Template.FindName(name, this);
    }

    #region Children and add/removed events handling

    private readonly PlotterChildrenCollection children;

    /// <summary>
    /// Provides access to Plotter's children charts.
    /// </summary>
    /// <value>The children.</value>
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
    public PlotterChildrenCollection Children
    {
      [DebuggerStepThrough]
      get { return children; }
    }

    private readonly Dictionary<IPlotterElement, Action> waitingForExecute = new Dictionary<IPlotterElement, Action>();

    bool executedWaitingChildrenAdding = false;
    private void OnChildrenCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
    {
      if (IsLoadedInternal && !executedWaitingChildrenAdding)
      {
        ExecuteWaitingChildrenAdditions();
        executedWaitingChildrenAdding = true;
      }

      if (e.NewItems != null)
      {
        foreach (IPlotterElement item in e.NewItems)
        {
          if (IsLoadedInternal)
          {
            OnChildAdded(item);
          }
          else
          {
            waitingForExecute.Remove(item);
            waitingForExecute.Add(item, () => OnChildAdded(item));
          }
        }
      }
      if (e.OldItems != null)
      {
        foreach (IPlotterElement item in e.OldItems)
        {
          if (IsLoadedInternal)
          {
            OnChildRemoving(item);
          }
          else
          {
            waitingForExecute.Remove(item);
            waitingForExecute.Add(item, () => OnChildRemoving(item));
          }
        }
      }
    }

    bool performChildChecks = true;
    internal bool PerformChildChecks
    {
      get { return performChildChecks; }
      set { performChildChecks = value; }
    }

    private IPlotterElement currentChild = null;
    protected IPlotterElement CurrentChild
    {
      get { return currentChild; }
    }

    protected virtual void OnChildAdded(IPlotterElement child)
    {
      if (child != null)
      {
        currentChild = child;

        if (performChildChecks && child.Plotter != null)
        {
          throw new InvalidOperationException(Strings.Exceptions.PlotterElementAddedToAnotherPlotter);
        }

        if (performChildChecks)
        {
          child.OnPlotterAttached(this);
          if (child.Plotter != this)
          {
            throw new InvalidOperationException(Strings.Exceptions.InvalidParentPlotterValue);
          }
        }

        DependencyObject dependencyObject = child as DependencyObject;
        if (dependencyObject != null)
        {
          SetPlotter(dependencyObject, this);
        }
      }
    }

    protected virtual void OnChildRemoving(IPlotterElement child)
    {
      if (child != null)
      {
        // todo probably here child.Plotter can be null.
        if (performChildChecks && child.Plotter != this)
        {
          //throw new InvalidOperationException(Strings.Exceptions.InvalidParentPlotterValueRemoving);
        }

        if (performChildChecks)
        {
          if (child.Plotter != null)
            child.OnPlotterDetaching(this);

          if (child.Plotter != null)
          {
            throw new InvalidOperationException(Strings.Exceptions.ParentPlotterNotNull);
          }
        }

        DependencyObject dependencyObject = child as DependencyObject;
        if (dependencyObject != null)
        {
          SetPlotter(dependencyObject, null);
        }
      }
    }

    #endregion

    #region Layout zones

    private Panel parallelCanvas = new Canvas();
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public Panel ParallelCanvas
    {
      get { return parallelCanvas; }
      protected set { parallelCanvas = value; }
    }

    private Panel headerPanel = new StackPanel();
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public Panel HeaderPanel
    {
      get { return headerPanel; }
      protected set { headerPanel = value; }
    }

    private Panel footerPanel = new StackPanel();
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public Panel FooterPanel
    {
      get { return footerPanel; }
      protected set { footerPanel = value; }
    }

    private Panel leftPanel = new StackPanel();
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public Panel LeftPanel
    {
      get { return leftPanel; }
      protected set { leftPanel = value; }
    }

    private Panel rightPanel = new StackPanel();
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public Panel RightPanel
    {
      get { return rightPanel; }
      protected set { rightPanel = value; }
    }

    private Panel topPanel = new StackPanel();
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public Panel TopPanel
    {
      get { return topPanel; }
      protected set { topPanel = value; }
    }

    private Panel bottomPanel = new StackPanel();
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public Panel BottomPanel
    {
      get { return bottomPanel; }
      protected set { bottomPanel = value; }
    }

    private Panel mainCanvas = new Canvas();
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public Panel MainCanvas
    {
      get { return mainCanvas; }
      protected set { mainCanvas = value; }
    }

    private Panel centralGrid = new Grid();
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public Panel CentralGrid
    {
      get { return centralGrid; }
      protected set { centralGrid = value; }
    }

    private Panel mainGrid = new Grid();
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public Panel MainGrid
    {
      get { return mainGrid; }
      protected set { mainGrid = value; }
    }

    #endregion

    #region Screenshots & copy to clipboard

    public BitmapSource CreateScreenshot()
    {
      UIElement parent = (UIElement)Parent;

      Rect renderBounds = new Rect(RenderSize);

      Point p1 = renderBounds.TopLeft;
      Point p2 = renderBounds.BottomRight;

      if (parent != null)
      {
        //p1 = TranslatePoint(p1, parent);
        //p2 = TranslatePoint(p2, parent);
      }

      Int32Rect rect = new Rect(p1, p2).ToInt32Rect();

      return ScreenshotHelper.CreateScreenshot(this, rect);
    }


    /// <summary>Saves screenshot to file.</summary>
    /// <param name="filePath">File path.</param>
    public void SaveScreenshot(string filePath)
    {
      ScreenshotHelper.SaveBitmapToFile(CreateScreenshot(), filePath);
    }

    /// <summary>
    /// Saves screenshot to stream.
    /// </summary>
    /// <param name="stream">The stream.</param>
    /// <param name="fileExtension">The file type extension.</param>
    public void SaveScreenshotToStream(Stream stream, string fileExtension)
    {
      ScreenshotHelper.SaveBitmapToStream(CreateScreenshot(), stream, fileExtension);
    }

    /// <summary>Copies the screenshot to clipboard.</summary>
    public void CopyScreenshotToClipboard()
    {
      Clipboard.Clear();
      Clipboard.SetImage(CreateScreenshot());
    }

    #endregion

    #region IsDefaultElement attached property

    protected void SetAllChildrenAsDefault()
    {
      foreach (var child in Children.OfType<DependencyObject>())
      {
        child.SetValue(IsDefaultElementProperty, true);
      }
    }

    /// <summary>Gets a value whether specified graphics object is default to this plotter or not</summary>
    /// <param name="obj">Graphics object to check</param>
    /// <returns>True if it is default or false otherwise</returns>
    public static bool GetIsDefaultElement(DependencyObject obj)
    {
      return (bool)obj.GetValue(IsDefaultElementProperty);
    }

    public static void SetIsDefaultElement(DependencyObject obj, bool value)
    {
      obj.SetValue(IsDefaultElementProperty, value);
    }

    public static readonly DependencyProperty IsDefaultElementProperty = DependencyProperty.RegisterAttached(
      "IsDefaultElement",
      typeof(bool),
      typeof(Plotter),
      new UIPropertyMetadata(false));

    /// <summary>Removes all user graphs from given UIElementCollection, 
    /// leaving only default graphs</summary>
    protected static void RemoveUserElements(IList<IPlotterElement> elements)
    {
      int index = 0;

      while (index < elements.Count)
      {
        DependencyObject d = elements[index] as DependencyObject;
        if (d != null && !GetIsDefaultElement(d))
        {
          elements.RemoveAt(index);
        }
        else
        {
          index++;
        }
      }
    }

    public void RemoveUserElements()
    {
      RemoveUserElements(Children);
    }

    #endregion

    #region IsDefaultAxis

    public static bool GetIsDefaultAxis(DependencyObject obj)
    {
      return (bool)obj.GetValue(IsDefaultAxisProperty);
    }

    public static void SetIsDefaultAxis(DependencyObject obj, bool value)
    {
      obj.SetValue(IsDefaultAxisProperty, value);
    }

    public static readonly DependencyProperty IsDefaultAxisProperty = DependencyProperty.RegisterAttached(
      "IsDefaultAxis",
      typeof(bool),
      typeof(Plotter),
      new UIPropertyMetadata(false, OnIsDefaultAxisChanged));

    private static void OnIsDefaultAxisChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
      Plotter parentPlotter = null;
      IPlotterElement plotterElement = d as IPlotterElement;
      if (plotterElement != null)
      {
        parentPlotter = plotterElement.Plotter;

        if (parentPlotter != null)
        {
          parentPlotter.OnIsDefaultAxisChangedCore(d, e);
        }
      }
    }

    protected virtual void OnIsDefaultAxisChangedCore(DependencyObject d, DependencyPropertyChangedEventArgs e) { }

    #endregion

    #region Undo

    private readonly UndoProvider undoProvider = new UndoProvider();
    public UndoProvider UndoProvider
    {
      get { return undoProvider; }
    }

    #endregion

    #region Plotter attached property

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public static Plotter GetPlotter(DependencyObject obj)
    {
      return (Plotter)obj.GetValue(PlotterProperty);
    }

    public static void SetPlotter(DependencyObject obj, Plotter value)
    {
      obj.SetValue(PlotterProperty, value);
    }

    public static readonly DependencyProperty PlotterProperty = DependencyProperty.RegisterAttached(
      "Plotter",
      typeof(Plotter),
      typeof(Plotter),
      new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits, OnPlotterChanged));

    private static void OnPlotterChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
      FrameworkElement element = d as FrameworkElement;
      Plotter prevPlotter = (Plotter)e.OldValue;
      Plotter currPlotter = (Plotter)e.NewValue;

      // raise Plotter[*] events, where * is Attached, Detaching, Changed.
      if (element != null)
      {
        PlotterChangedEventArgs args = new PlotterChangedEventArgs(prevPlotter, currPlotter, PlotterDetachingEvent);

        if (currPlotter == null && prevPlotter != null)
        {
          RaisePlotterEvent(element, args);
        }
        else if (currPlotter != null)
        {
          args.RoutedEvent = PlotterAttachedEvent;
          RaisePlotterEvent(element, args);
        }

        args.RoutedEvent = PlotterChangedEvent;
        RaisePlotterEvent(element, args);
      }
    }

    private static void RaisePlotterEvent(FrameworkElement element, PlotterChangedEventArgs args)
    {
      element.RaiseEvent(args);
      PlotterEvents.Notify(element, args);
    }

    #endregion

    #region Plotter routed events

    public static readonly RoutedEvent PlotterAttachedEvent = EventManager.RegisterRoutedEvent(
      "PlotterAttached",
      RoutingStrategy.Direct,
      typeof(PlotterChangedEventHandler),
      typeof(Plotter));

    public static readonly RoutedEvent PlotterDetachingEvent = EventManager.RegisterRoutedEvent(
      "PlotterDetaching",
      RoutingStrategy.Direct,
      typeof(PlotterChangedEventHandler),
      typeof(Plotter));

    public static readonly RoutedEvent PlotterChangedEvent = EventManager.RegisterRoutedEvent(
      "PlotterChanged",
      RoutingStrategy.Direct,
      typeof(PlotterChangedEventHandler),
      typeof(Plotter));

    #endregion

    #region DefaultPanel property

    /// <summary>
    /// Gets the value indicating that this is a default panel.
    /// Default panels are those that are contained in plotter by default, like MainGrid or CentralCanvas.
    /// </summary>
    /// <param name="obj">The obj.</param>
    /// <returns></returns>
    public static bool GetIsDefaultPanel(DependencyObject obj)
    {
      return (bool)obj.GetValue(IsDefaultPanelProperty);
    }

    public static void SetIsDefaultPanel(DependencyObject obj, bool value)
    {
      obj.SetValue(IsDefaultPanelProperty, value);
    }

    public static readonly DependencyProperty IsDefaultPanelProperty = DependencyProperty.RegisterAttached(
      "IsDefaultPanel",
      typeof(bool),
      typeof(Plotter),
      new FrameworkPropertyMetadata(false));

    #endregion
  }

  public delegate void PlotterChangedEventHandler(object sender, PlotterChangedEventArgs e);
}