/Main/src/DynamicDataDisplay/Charts/Navigation/KeyboardNavigation.cs

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

	}

}