source: branches/HeuristicLab.Problems.GrammaticalOptimization/DynamicDataDisplay/Charts/Navigation/CursorCoordinateGraph.xaml.cs @ 12503

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Diagnostics;
using Microsoft.Research.DynamicDataDisplay.Common.Auxiliary;
using Microsoft.Research.DynamicDataDisplay;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using Microsoft.Research.DynamicDataDisplay.Common;

namespace Microsoft.Research.DynamicDataDisplay.Charts.Navigation
{
  /// <summary>
  /// Adds to ChartPlotter two crossed lines, bound to mouse cursor position, and two labels near axes with mouse position in its text.
  /// </summary>
  public partial class CursorCoordinateGraph : ContentGraph
  {
    /// <summary>
    /// Initializes a new instance of the <see cref="CursorCoordinateGraph"/> class.
    /// </summary>
    public CursorCoordinateGraph()
    {
      InitializeComponent();
    }

    Vector blockShift = new Vector(3, 3);

    #region Plotter

    protected override void OnPlotterAttached()
    {
      UIElement parent = (UIElement)Parent;

      parent.MouseMove += parent_MouseMove;
      parent.MouseEnter += Parent_MouseEnter;
      parent.MouseLeave += Parent_MouseLeave;

      UpdateVisibility();
      UpdateUIRepresentation();
    }

    protected override void OnPlotterDetaching()
    {
      UIElement parent = (UIElement)Parent;

      parent.MouseMove -= parent_MouseMove;
      parent.MouseEnter -= Parent_MouseEnter;
      parent.MouseLeave -= Parent_MouseLeave;
    }

    #endregion

    private bool autoHide = true;
    /// <summary>
    /// Gets or sets a value indicating whether to hide automatically cursor lines when mouse leaves plotter.
    /// </summary>
    /// <value><c>true</c> if auto hide; otherwise, <c>false</c>.</value>
    public bool AutoHide
    {
      get { return autoHide; }
      set { autoHide = value; }
    }

    private void Parent_MouseEnter(object sender, MouseEventArgs e)
    {
      if (autoHide)
      {
        UpdateVisibility();
      }
    }

    private void UpdateVisibility()
    {
      horizLine.Visibility = vertGrid.Visibility = GetHorizontalVisibility();
      vertLine.Visibility = horizGrid.Visibility = GetVerticalVisibility();
    }

    private Visibility GetHorizontalVisibility()
    {
      return showHorizontalLine ? Visibility.Visible : Visibility.Hidden;
    }

    private Visibility GetVerticalVisibility()
    {
      return showVerticalLine ? Visibility.Visible : Visibility.Hidden;
    }

    private void Parent_MouseLeave(object sender, MouseEventArgs e)
    {
      if (autoHide)
      {
        horizLine.Visibility = Visibility.Hidden;
        vertLine.Visibility = Visibility.Hidden;
        horizGrid.Visibility = Visibility.Hidden;
        vertGrid.Visibility = Visibility.Hidden;
      }
    }

    private bool followMouse = true;
    /// <summary>
    /// Gets or sets a value indicating whether lines are following mouse cursor position.
    /// </summary>
    /// <value><c>true</c> if lines are following mouse cursor position; otherwise, <c>false</c>.</value>
    public bool FollowMouse
    {
      get { return followMouse; }
      set
      {
        followMouse = value;

        if (!followMouse)
        {
          AutoHide = false;
        }

        UpdateUIRepresentation();
      }
    }

    private void parent_MouseMove(object sender, MouseEventArgs e)
    {
      if (followMouse)
      {
        UpdateUIRepresentation();
      }
    }

    protected override void OnViewportPropertyChanged(ExtendedPropertyChangedEventArgs e)
    {
      UpdateUIRepresentation();
    }

    private string customXFormat = null;
    /// <summary>
    /// Gets or sets the custom format string of x label.
    /// </summary>
    /// <value>The custom X format.</value>
    public string CustomXFormat
    {
      get { return customXFormat; }
      set
      {
        if (customXFormat != value)
        {
          customXFormat = value;
          UpdateUIRepresentation();
        }
      }
    }

    private string customYFormat = null;
    /// <summary>
    /// Gets or sets the custom format string of y label.
    /// </summary>
    /// <value>The custom Y format.</value>
    public string CustomYFormat
    {
      get { return customYFormat; }
      set
      {
        if (customYFormat != value)
        {
          customYFormat = value;
          UpdateUIRepresentation();
        }
      }
    }

    private Func<double, string> xTextMapping = null;
    /// <summary>
    /// Gets or sets the text mapping of x label - function that builds text from x-coordinate of mouse in data.
    /// </summary>
    /// <value>The X text mapping.</value>
    public Func<double, string> XTextMapping
    {
      get { return xTextMapping; }
      set
      {
        if (xTextMapping != value)
        {
          xTextMapping = value;
          UpdateUIRepresentation();
        }
      }
    }

    private Func<double, string> yTextMapping = null;
    /// <summary>
    /// Gets or sets the text mapping of y label - function that builds text from y-coordinate of mouse in data.
    /// </summary>
    /// <value>The Y text mapping.</value>
    public Func<double, string> YTextMapping
    {
      get { return yTextMapping; }
      set
      {
        if (yTextMapping != value)
        {
          yTextMapping = value;
          UpdateUIRepresentation();
        }
      }
    }

    private bool showHorizontalLine = true;
    /// <summary>
    /// Gets or sets a value indicating whether to show horizontal line.
    /// </summary>
    /// <value><c>true</c> if horizontal line is shown; otherwise, <c>false</c>.</value>
    public bool ShowHorizontalLine
    {
      get { return showHorizontalLine; }
      set
      {
        if (showHorizontalLine != value)
        {
          showHorizontalLine = value;
          UpdateVisibility();
        }
      }
    }

    private bool showVerticalLine = true;
    /// <summary>
    /// Gets or sets a value indicating whether to show vertical line.
    /// </summary>
    /// <value><c>true</c> if vertical line is shown; otherwise, <c>false</c>.</value>
    public bool ShowVerticalLine
    {
      get { return showVerticalLine; }
      set
      {
        if (showVerticalLine != value)
        {
          showVerticalLine = value;
          UpdateVisibility();
        }
      }
    }

    private void UpdateUIRepresentation()
    {
      Point position = followMouse ? Mouse.GetPosition(this) : Position;
      UpdateUIRepresentation(position);
    }

    private void UpdateUIRepresentation(Point mousePos)
    {
      if (Plotter2D == null) return;

      var transform = Plotter2D.Viewport.Transform;
      DataRect visible = Plotter2D.Viewport.Visible;
      Rect output = Plotter2D.Viewport.Output;

      if (!output.Contains(mousePos))
      {
        if (autoHide)
        {
          horizGrid.Visibility = horizLine.Visibility = vertGrid.Visibility = vertLine.Visibility = Visibility.Hidden;
        }
        return;
      }

      if (!followMouse)
      {
        mousePos = mousePos.DataToScreen(transform);
      }

      horizLine.X1 = output.Left;
      horizLine.X2 = output.Right;
      horizLine.Y1 = mousePos.Y;
      horizLine.Y2 = mousePos.Y;

      vertLine.X1 = mousePos.X;
      vertLine.X2 = mousePos.X;
      vertLine.Y1 = output.Top;
      vertLine.Y2 = output.Bottom;

      if (UseDashOffset)
      {
        horizLine.StrokeDashOffset = (output.Right - mousePos.X) / 2;
        vertLine.StrokeDashOffset = (output.Bottom - mousePos.Y) / 2;
      }

      Point mousePosInData = mousePos.ScreenToData(transform);

      string text = null;

      if (showVerticalLine)
      {
        double xValue = mousePosInData.X;
        if (xTextMapping != null)
          text = xTextMapping(xValue);

        // doesnot have xTextMapping or it returned null
        if (text == null)
          text = GetRoundedValue(visible.XMin, visible.XMax, xValue);

        if (!String.IsNullOrEmpty(customXFormat))
          text = String.Format(customXFormat, text);
        horizTextBlock.Text = text;
      }

      double width = horizGrid.ActualWidth;
      double x = mousePos.X + blockShift.X;
      if (x + width > output.Right)
      {
        x = mousePos.X - blockShift.X - width;
      }
      Canvas.SetLeft(horizGrid, x);

      if (showHorizontalLine)
      {
        double yValue = mousePosInData.Y;
        text = null;
        if (yTextMapping != null)
          text = yTextMapping(yValue);

        if (text == null)
          text = GetRoundedValue(visible.YMin, visible.YMax, yValue);

        if (!String.IsNullOrEmpty(customYFormat))
          text = String.Format(customYFormat, text);
        vertTextBlock.Text = text;
      }

      // by default vertGrid is positioned on the top of line.
      double height = vertGrid.ActualHeight;
      double y = mousePos.Y - blockShift.Y - height;
      if (y < output.Top)
      {
        y = mousePos.Y + blockShift.Y;
      }
      Canvas.SetTop(vertGrid, y);

      if (followMouse)
        Position = mousePos;
    }

    /// <summary>
    /// Gets or sets the mouse position in screen coordinates.
    /// </summary>
    /// <value>The position.</value>
    public Point Position
    {
      get { return (Point)GetValue(PositionProperty); }
      set { SetValue(PositionProperty, value); }
    }

    /// <summary>
    /// Identifies Position dependency property.
    /// </summary>
    public static readonly DependencyProperty PositionProperty = DependencyProperty.Register(
      "Position",
      typeof(Point),
      typeof(CursorCoordinateGraph),
      new UIPropertyMetadata(new Point(), OnPositionChanged));

    private static void OnPositionChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
      CursorCoordinateGraph graph = (CursorCoordinateGraph)d;
      graph.UpdateUIRepresentation((Point)e.NewValue);
    }

    private string GetRoundedValue(double min, double max, double value)
    {
      double roundedValue = value;
      var log = RoundingHelper.GetDifferenceLog(min, max);
      string format = "G3";
      double diff = Math.Abs(max - min);
      if (1E3 < diff && diff < 1E6)
      {
        format = "F0";
      }
      if (log < 0)
        format = "G" + (-log + 2).ToString();

      return roundedValue.ToString(format);
    }

    #region UseDashOffset property

    public bool UseDashOffset
    {
      get { return (bool)GetValue(UseDashOffsetProperty); }
      set { SetValue(UseDashOffsetProperty, value); }
    }

    public static readonly DependencyProperty UseDashOffsetProperty = DependencyProperty.Register(
      "UseDashOffset",
      typeof(bool),
      typeof(CursorCoordinateGraph),
      new FrameworkPropertyMetadata(true, UpdateUIRepresentation));

    private static void UpdateUIRepresentation(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
      CursorCoordinateGraph graph = (CursorCoordinateGraph)d;
      if ((bool)e.NewValue)
      {
        graph.UpdateUIRepresentation();
      }
      else
      {
        graph.vertLine.ClearValue(Line.StrokeDashOffsetProperty);
        graph.horizLine.ClearValue(Line.StrokeDashOffsetProperty);
      }
    }

    #endregion

    #region LineStroke property

    public Brush LineStroke
    {
      get { return (Brush)GetValue(LineStrokeProperty); }
      set { SetValue(LineStrokeProperty, value); }
    }

    public static readonly DependencyProperty LineStrokeProperty = DependencyProperty.Register(
      "LineStroke",
      typeof(Brush),
      typeof(CursorCoordinateGraph),
      new PropertyMetadata(new SolidColorBrush(Color.FromArgb(170, 86, 86, 86))));

    #endregion

    #region LineStrokeThickness property

    public double LineStrokeThickness
    {
      get { return (double)GetValue(LineStrokeThicknessProperty); }
      set { SetValue(LineStrokeThicknessProperty, value); }
    }

    public static readonly DependencyProperty LineStrokeThicknessProperty = DependencyProperty.Register(
      "LineStrokeThickness",
      typeof(double),
      typeof(CursorCoordinateGraph),
      new PropertyMetadata(2.0));

    #endregion

    #region LineStrokeDashArray property

    [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]
    public DoubleCollection LineStrokeDashArray
    {
      get { return (DoubleCollection)GetValue(LineStrokeDashArrayProperty); }
      set { SetValue(LineStrokeDashArrayProperty, value); }
    }

    public static readonly DependencyProperty LineStrokeDashArrayProperty = DependencyProperty.Register(
      "LineStrokeDashArray",
      typeof(DoubleCollection),
      typeof(CursorCoordinateGraph),
      new FrameworkPropertyMetadata(DoubleCollectionHelper.Create(3, 3)));

    #endregion
  }
}