source: branches/HeuristicLab.Problems.GrammaticalOptimization/DynamicDataDisplay/Charts/Navigation/KeyboardNavigation.cs @ 13847

using System.Windows;
using System.Windows.Input;
using System.Windows.Media;
using Microsoft.Win32;
using System;
using Microsoft.Research.DynamicDataDisplay.Common.UndoSystem;
using System.Collections.Generic;
using Microsoft.Research.DynamicDataDisplay.Charts.Navigation;

namespace Microsoft.Research.DynamicDataDisplay.Navigation
{
  /// <summary>Provides keyboard navigation around viewport of ChartPlotter.</summary>
  public class KeyboardNavigation : IPlotterElement
  {
    /// <summary>
    /// Initializes a new instance of the <see cref="KeyboardNavigation"/> class.
    /// </summary>
    public KeyboardNavigation() { }

    private bool isReversed = true;
    /// <summary>
    /// Gets or sets a value indicating whether panning directions are reversed.
    /// </summary>
    /// <value>
    ///   <c>true</c> if panning directions are reversed; otherwise, <c>false</c>.
    /// </value>
    public bool IsReversed
    {
      get { return isReversed; }
      set { isReversed = value; }
    }

    private readonly List<CommandBinding> addedBindings = new List<CommandBinding>();
    private void AddBinding(CommandBinding binding)
    {
      plotter2D.CommandBindings.Add(binding);
      addedBindings.Add(binding);
    }

    private void InitCommands()
    {
      if (plotter2D == null)
        return;

      var zoomOutToMouseCommandBinding = new CommandBinding(
        ChartCommands.ZoomOutToMouse,
        ZoomOutToMouseExecute,
        ZoomOutToMouseCanExecute);
      AddBinding(zoomOutToMouseCommandBinding);

      var zoomInToMouseCommandBinding = new CommandBinding(
        ChartCommands.ZoomInToMouse,
        ZoomInToMouseExecute,
        ZoomInToMouseCanExecute);
      AddBinding(zoomInToMouseCommandBinding);

      var zoomWithParamCommandBinding = new CommandBinding(
        ChartCommands.ZoomWithParameter,
        ZoomWithParamExecute,
        ZoomWithParamCanExecute);
      AddBinding(zoomWithParamCommandBinding);

      var zoomInCommandBinding = new CommandBinding(
        ChartCommands.ZoomIn,
        ZoomInExecute,
        ZoomInCanExecute);
      AddBinding(zoomInCommandBinding);

      var zoomOutCommandBinding = new CommandBinding(
        ChartCommands.ZoomOut,
        ZoomOutExecute,
        ZoomOutCanExecute);
      AddBinding(zoomOutCommandBinding);

      var fitToViewCommandBinding = new CommandBinding(
        ChartCommands.FitToView,
        FitToViewExecute,
        FitToViewCanExecute);
      AddBinding(fitToViewCommandBinding);

      var ScrollLeftCommandBinding = new CommandBinding(
          ChartCommands.ScrollLeft,
          ScrollLeftExecute,
          ScrollLeftCanExecute);
      AddBinding(ScrollLeftCommandBinding);

      var ScrollRightCommandBinding = new CommandBinding(
        ChartCommands.ScrollRight,
        ScrollRightExecute,
        ScrollRightCanExecute);
      AddBinding(ScrollRightCommandBinding);

      var ScrollUpCommandBinding = new CommandBinding(
        ChartCommands.ScrollUp,
        ScrollUpExecute,
        ScrollUpCanExecute);
      AddBinding(ScrollUpCommandBinding);

      var ScrollDownCommandBinding = new CommandBinding(
        ChartCommands.ScrollDown,
        ScrollDownExecute,
        ScrollDownCanExecute);
      AddBinding(ScrollDownCommandBinding);

      var SaveScreenshotCommandBinding = new CommandBinding(
        ChartCommands.SaveScreenshot,
        SaveScreenshotExecute,
        SaveScreenshotCanExecute);
      AddBinding(SaveScreenshotCommandBinding);

      var CopyScreenshotCommandBinding = new CommandBinding(
        ChartCommands.CopyScreenshot,
        CopyScreenshotExecute,
        CopyScreenshotCanExecute);
      AddBinding(CopyScreenshotCommandBinding);

      var ShowHelpCommandBinding = new CommandBinding(
        ChartCommands.ShowHelp,
        ShowHelpExecute,
        ShowHelpCanExecute);
      AddBinding(ShowHelpCommandBinding);

      var UndoCommandBinding = new CommandBinding(
        ApplicationCommands.Undo,
        UndoExecute,
        UndoCanExecute);
      AddBinding(UndoCommandBinding);

      var RedoCommandBinding = new CommandBinding(
        ApplicationCommands.Redo,
        RedoExecute,
        RedoCanExecute);
      AddBinding(RedoCommandBinding);
    }

    #region Zoom Out To Mouse

    private void ZoomToPoint(double coeff)
    {
      Point pt = Mouse.GetPosition(plotter2D.CentralGrid);
      Point dataPoint = Viewport.Transform.ScreenToData(pt);
      DataRect visible = Viewport.Visible;

      Viewport.SetChangeType(ChangeType.Zoom);
      Viewport.Visible = visible.Zoom(dataPoint, coeff);
      Viewport.SetChangeType();
    }

    private void ZoomOutToMouseExecute(object target, ExecutedRoutedEventArgs e)
    {
      ZoomToPoint(zoomOutCoeff);
      e.Handled = true;
    }

    private void ZoomOutToMouseCanExecute(object target, CanExecuteRoutedEventArgs e)
    {
      e.CanExecute = true;
    }

    #endregion

    #region Zoom In To Mouse

    private void ZoomInToMouseExecute(object target, ExecutedRoutedEventArgs e)
    {
      ZoomToPoint(zoomInCoeff);
      e.Handled = true;
    }

    private void ZoomInToMouseCanExecute(object target, CanExecuteRoutedEventArgs e)
    {
      e.CanExecute = true;
    }

    #endregion

    #region Zoom With param

    private void ZoomWithParamExecute(object target, ExecutedRoutedEventArgs e)
    {
      double zoomParam = (double)e.Parameter;
      plotter2D.Viewport.Zoom(zoomParam);
      e.Handled = true;
    }

    private void ZoomWithParamCanExecute(object target, CanExecuteRoutedEventArgs e)
    {
      e.CanExecute = true;
    }

    #endregion

    #region Zoom in

    private const double zoomInCoeff = 0.9;
    private void ZoomInExecute(object target, ExecutedRoutedEventArgs e)
    {
      Viewport.Zoom(zoomInCoeff);
      e.Handled = true;
    }

    private void ZoomInCanExecute(object target, CanExecuteRoutedEventArgs e)
    {
      e.CanExecute = true;
    }

    #endregion

    #region Zoom out

    private const double zoomOutCoeff = 1 / zoomInCoeff;
    private void ZoomOutExecute(object target, ExecutedRoutedEventArgs e)
    {
      Viewport.Zoom(zoomOutCoeff);
      e.Handled = true;
    }

    private void ZoomOutCanExecute(object target, CanExecuteRoutedEventArgs e)
    {
      e.CanExecute = true;
    }

    #endregion

    #region Fit to view

    private void FitToViewExecute(object target, ExecutedRoutedEventArgs e)
    {
      // todo сделать нормально.
      (Viewport as Viewport2D).FitToView();
      e.Handled = true;
    }

    private void FitToViewCanExecute(object target, CanExecuteRoutedEventArgs e)
    {
      // todo add a check if viewport is already fitted to view.
      e.CanExecute = true;
    }

    #endregion

    #region Scroll

    private double scrollCoeff = 0.05;
    private void ScrollVisibleProportionally(double xShiftCoeff, double yShiftCoeff)
    {
      DataRect visible = Viewport.Visible;
      DataRect oldVisible = visible;
      double width = visible.Width;
      double height = visible.Height;

      double reverseCoeff = isReversed ? -1 : 1;
      visible.Offset(reverseCoeff * xShiftCoeff * width, reverseCoeff * yShiftCoeff * height);

      Viewport.SetChangeType(xShiftCoeff == 0 ? ChangeType.PanY : ChangeType.PanX);
      Viewport.Visible = visible;
      Viewport.SetChangeType();

      plotter2D.UndoProvider.AddAction(new DependencyPropertyChangedUndoAction(Viewport, Viewport2D.VisibleProperty, oldVisible, visible));
    }

    #region ScrollLeft

    private void ScrollLeftExecute(object target, ExecutedRoutedEventArgs e)
    {
      ScrollVisibleProportionally(scrollCoeff, 0);
      e.Handled = true;
    }

    private void ScrollLeftCanExecute(object target, CanExecuteRoutedEventArgs e)
    {
      e.CanExecute = true;
    }

    #endregion

    #region ScrollRight

    private void ScrollRightExecute(object target, ExecutedRoutedEventArgs e)
    {
      ScrollVisibleProportionally(-scrollCoeff, 0);
      e.Handled = true;
    }

    private void ScrollRightCanExecute(object target, CanExecuteRoutedEventArgs e)
    {
      e.CanExecute = true;
    }

    #endregion

    #region ScrollUp

    private void ScrollUpExecute(object target, ExecutedRoutedEventArgs e)
    {
      ScrollVisibleProportionally(0, -scrollCoeff);
      e.Handled = true;
    }

    private void ScrollUpCanExecute(object target, CanExecuteRoutedEventArgs e)
    {
      e.CanExecute = true;
    }

    #endregion

    #region ScrollDown

    private void ScrollDownExecute(object target, ExecutedRoutedEventArgs e)
    {
      ScrollVisibleProportionally(0, scrollCoeff);
      e.Handled = true;
    }

    private void ScrollDownCanExecute(object target, CanExecuteRoutedEventArgs e)
    {
      e.CanExecute = true;
    }

    #endregion

    #endregion

    #region SaveScreenshot

    private void SaveScreenshotExecute(object target, ExecutedRoutedEventArgs e)
    {
      SaveFileDialog dlg = new SaveFileDialog();
      dlg.Filter = "PNG (*.png)|*.png|JPEG (*.jpg)|*.jpg|BMP (*.bmp)|*.bmp|GIF (*.gif)|*.gif";
      dlg.FilterIndex = 1;
      dlg.AddExtension = true;
      if (dlg.ShowDialog().GetValueOrDefault(false))
      {
        string filePath = dlg.FileName;
        plotter2D.SaveScreenshot(filePath);
        e.Handled = true;
      }
    }

    private void SaveScreenshotCanExecute(object target, CanExecuteRoutedEventArgs e)
    {
      e.CanExecute = true;
    }

    #endregion

    #region CopyScreenshot

    private void CopyScreenshotExecute(object target, ExecutedRoutedEventArgs e)
    {
      plotter2D.CopyScreenshotToClipboard();
      e.Handled = true;
    }

    private void CopyScreenshotCanExecute(object target, CanExecuteRoutedEventArgs e)
    {
      e.CanExecute = true;
    }

    #endregion

    #region ShowHelp

    private bool aboutWindowOpened = false;
    private void ShowHelpExecute(object target, ExecutedRoutedEventArgs e)
    {
      if (!aboutWindowOpened)
      {
        AboutWindow window = new AboutWindow();
        window.Closed += new EventHandler(aboutWindow_Closed);
        window.DataContext = plotter2D;

        window.Owner = Window.GetWindow(plotter2D);

        aboutWindowOpened = true;
        window.Show();

        e.Handled = true;
      }
    }

    void aboutWindow_Closed(object sender, EventArgs e)
    {
      Window window = (Window)sender;
      window.Closed -= aboutWindow_Closed;
      aboutWindowOpened = false;
    }

    private void ShowHelpCanExecute(object target, CanExecuteRoutedEventArgs e)
    {
      e.CanExecute = !aboutWindowOpened;
    }

    #endregion

    #region Undo

    private void UndoExecute(object target, ExecutedRoutedEventArgs e)
    {
      plotter2D.UndoProvider.Undo();
      e.Handled = true;
    }

    private void UndoCanExecute(object target, CanExecuteRoutedEventArgs e)
    {
      e.CanExecute = plotter2D.UndoProvider.CanUndo;
    }

    #endregion

    #region Redo

    private void RedoExecute(object target, ExecutedRoutedEventArgs e)
    {
      plotter2D.UndoProvider.Redo();
      e.Handled = true;
    }

    private void RedoCanExecute(object target, CanExecuteRoutedEventArgs e)
    {
      e.CanExecute = plotter2D.UndoProvider.CanRedo;
    }

    #endregion

    #region IPlotterElement Members

    private Viewport2D Viewport
    {
      get { return plotter2D.Viewport; }
    }

    private Plotter2D plotter2D;
    void IPlotterElement.OnPlotterAttached(Plotter plotter)
    {
      plotter2D = (Plotter2D)plotter;

      InitCommands();
    }

    void IPlotterElement.OnPlotterDetaching(Plotter plotter)
    {
      foreach (var commandBinding in addedBindings)
      {
        plotter.CommandBindings.Remove(commandBinding);
      }
      addedBindings.Clear();

      this.plotter2D = null;
    }

    Plotter IPlotterElement.Plotter
    {
      get { return plotter2D; }
    }

    #endregion
  }
}