/Main/src/DynamicDataDisplay/Viewport2D.cs

using System;

using System.Collections.ObjectModel;

using System.Collections.Specialized;

using System.ComponentModel;

using System.Diagnostics;

using System.Diagnostics.CodeAnalysis;

using System.Windows;

using System.Windows.Data;

using Microsoft.Research.DynamicDataDisplay.Common.Auxiliary;

using Microsoft.Research.DynamicDataDisplay.ViewportConstraints;

using Microsoft.Research.DynamicDataDisplay.Common;

using System.Windows.Threading;



namespace Microsoft.Research.DynamicDataDisplay

{

	/// <summary>

	/// Viewport2D provides virtual coordinates.

	/// </summary>

	public partial class Viewport2D : DependencyObject

	{

		private DispatcherOperation updateVisibleOperation = null;

		private int updateVisibleCounter = 0;

		private readonly RingDictionary<DataRect> prevVisibles = new RingDictionary<DataRect>(2);

		private bool fromContentBounds = false;

		private readonly DispatcherPriority invocationPriority = DispatcherPriority.Send;



		public const string VisiblePropertyName = "Visible";



		public bool FromContentBounds

		{

			get { return fromContentBounds; }

			set { fromContentBounds = value; }

		}



		private readonly Plotter2D plotter;

		internal Plotter2D Plotter2D

		{

			get { return plotter; }

		}



		private readonly FrameworkElement hostElement;

		internal FrameworkElement HostElement

		{

			get { return hostElement; }

		}



		protected internal Viewport2D(FrameworkElement host, Plotter2D plotter)

		{

			hostElement = host;

			host.ClipToBounds = true;

			host.SizeChanged += OnHostElementSizeChanged;



			this.plotter = plotter;

			plotter.Children.CollectionChanged += OnPlotterChildrenChanged;



			constraints = new ConstraintCollection(this);

			constraints.Add(new MinimalSizeConstraint());

			constraints.CollectionChanged += constraints_CollectionChanged;



			fitToViewConstraints = new ConstraintCollection(this);

			fitToViewConstraints.CollectionChanged += fitToViewConstraints_CollectionChanged;



			readonlyContentBoundsHosts = new ReadOnlyObservableCollection<DependencyObject>(contentBoundsHosts);



			UpdateVisible();

			UpdateTransform();

		}



		private void OnHostElementSizeChanged(object sender, SizeChangedEventArgs e)

		{

			SetValue(OutputPropertyKey, new Rect(e.NewSize));

			CoerceValue(VisibleProperty);

		}



		private void fitToViewConstraints_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)

		{

			if (IsFittedToView)

			{

				CoerceValue(VisibleProperty);

			}

		}



		private void constraints_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)

		{

			CoerceValue(VisibleProperty);

		}



		private static void OnPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)

		{

			Viewport2D viewport = (Viewport2D)d;

			viewport.UpdateTransform();

			viewport.RaisePropertyChangedEvent(e);

		}



		public BindingExpressionBase SetBinding(DependencyProperty property, BindingBase binding)

		{

			return BindingOperations.SetBinding(this, property, binding);

		}



		/// <summary>

		/// Forces viewport to go to fit to view mode - clears locally set value of <see cref="Visible"/> property

		/// and sets it during the coercion process to a value of united content bounds of all charts inside of <see cref="Plotter"/>.

		/// </summary>

		public void FitToView()

		{

			if (!IsFittedToView)

			{

				ClearValue(VisibleProperty);

				CoerceValue(VisibleProperty);

				FittedToView.Raise(this);

			}

		}



		public event EventHandler FittedToView;



		/// <summary>

		/// Gets a value indicating whether Viewport is fitted to view.

		/// </summary>

		/// <value>

		/// 	<c>true</c> if Viewport is fitted to view; otherwise, <c>false</c>.

		/// </value>

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

		public bool IsFittedToView

		{

			get { return ReadLocalValue(VisibleProperty) == DependencyProperty.UnsetValue; }

		}



		internal void UpdateVisible()

		{

			if (updateVisibleCounter == 0)

			{

				UpdateVisibleBody();

			}

			else if (updateVisibleOperation == null)

			{

				updateVisibleOperation = Dispatcher.BeginInvoke(() => UpdateVisibleBody(), invocationPriority);

				return;

			}

			else if (updateVisibleOperation.Status == DispatcherOperationStatus.Pending)

			{

				updateVisibleOperation.Abort();

				updateVisibleOperation = Dispatcher.BeginInvoke(() => UpdateVisibleBody(), invocationPriority);

			}

		}



		private void UpdateVisibleBody()

		{

			if (updateVisibleCounter > 0)

				return;



			updateVisibleCounter++;

			if (IsFittedToView)

			{

				CoerceValue(VisibleProperty);

			}

			updateVisibleOperation = null;

			updateVisibleCounter--;

		}



		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

		[EditorBrowsable(EditorBrowsableState.Never)]

		public Plotter2D Plotter

		{

			get { return plotter; }

		}



		private readonly ConstraintCollection constraints;

		/// <summary>

		/// Gets the collection of <see cref="ViewportConstraint"/>s that are applied each time <see cref="Visible"/> is updated.

		/// </summary>

		/// <value>The constraints.</value>

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]

		public ConstraintCollection Constraints

		{

			get { return constraints; }

		}





		private readonly ConstraintCollection fitToViewConstraints;



		/// <summary>

		/// Gets the collection of <see cref="ViewportConstraint"/>s that are applied only when Viewport is fitted to view.

		/// </summary>

		/// <value>The fit to view constraints.</value>

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]

		public ConstraintCollection FitToViewConstraints

		{

			get { return fitToViewConstraints; }

		}



		#region Output property



		/// <summary>

		/// Gets the rectangle in screen coordinates that is output.

		/// </summary>

		/// <value>The output.</value>

		public Rect Output

		{

			get { return (Rect)GetValue(OutputProperty); }

		}



		[SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]

		private static readonly DependencyPropertyKey OutputPropertyKey = DependencyProperty.RegisterReadOnly(

			"Output",

			typeof(Rect),

			typeof(Viewport2D),

			new FrameworkPropertyMetadata(new Rect(0, 0, 1, 1), OnPropertyChanged));



		/// <summary>

		/// Identifies the <see cref="Output"/> dependency property.

		/// </summary>

		public static readonly DependencyProperty OutputProperty = OutputPropertyKey.DependencyProperty;



		#endregion



		#region UnitedContentBounds property



		/// <summary>

		/// Gets the united content bounds of all the charts.

		/// </summary>

		/// <value>The content bounds.</value>

		public DataRect UnitedContentBounds

		{

			get { return (DataRect)GetValue(UnitedContentBoundsProperty); }

			internal set { SetValue(UnitedContentBoundsProperty, value); }

		}



		/// <summary>

		/// Identifies the <see cref="UnitedContentBounds"/> dependency property.

		/// </summary>

		public static readonly DependencyProperty UnitedContentBoundsProperty = DependencyProperty.Register(

		  "UnitedContentBounds",

		  typeof(DataRect),

		  typeof(Viewport2D),

		  new FrameworkPropertyMetadata(DataRect.Empty, OnUnitedContentBoundsChanged));



		private static void OnUnitedContentBoundsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)

		{

			Viewport2D owner = (Viewport2D)d;

			owner.ContentBoundsChanged.Raise(owner);

		}



		public event EventHandler ContentBoundsChanged;



		#endregion



		#region Visible property



		/// <summary>

		/// Gets or sets the visible rectangle.

		/// </summary>

		/// <value>The visible.</value>

		public DataRect Visible

		{

			get { return (DataRect)GetValue(VisibleProperty); }

			set { SetValue(VisibleProperty, value); }

		}



		/// <summary>

		/// Identifies the <see cref="Visible"/> dependency property.

		/// </summary>

		public static readonly DependencyProperty VisibleProperty =

			DependencyProperty.Register("Visible", typeof(DataRect), typeof(Viewport2D),

			new FrameworkPropertyMetadata(

				new DataRect(0, 0, 1, 1),

				OnPropertyChanged,

				OnCoerceVisible),

			ValidateVisibleCallback);



		private static bool ValidateVisibleCallback(object value)

		{

			DataRect rect = (DataRect)value;



			return !rect.IsNaN();

		}



		private void UpdateContentBoundsHosts()

		{

			contentBoundsHosts.Clear();

			foreach (var item in plotter.Children)

			{

				DependencyObject dependencyObject = item as DependencyObject;

				if (dependencyObject != null)

				{

					bool hasNonEmptyBounds = !Viewport2D.GetContentBounds(dependencyObject).IsEmpty;

					if (hasNonEmptyBounds && Viewport2D.GetIsContentBoundsHost(dependencyObject))

					{

						contentBoundsHosts.Add(dependencyObject);

					}

				}

			}



			bool prevFromContentBounds = FromContentBounds;

			FromContentBounds = true;

			UpdateVisible();

			FromContentBounds = prevFromContentBounds;

		}



		private readonly ObservableCollection<DependencyObject> contentBoundsHosts = new ObservableCollection<DependencyObject>();

		private readonly ReadOnlyObservableCollection<DependencyObject> readonlyContentBoundsHosts;

		/// <summary>

		/// Gets the collection of all charts that can has its own content bounds.

		/// </summary>

		/// <value>The content bounds hosts.</value>

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

		public ReadOnlyObservableCollection<DependencyObject> ContentBoundsHosts

		{

			get { return readonlyContentBoundsHosts; }

		}



		private bool useApproximateContentBoundsComparison = true;

		/// <summary>

		/// Gets or sets a value indicating whether to use approximate content bounds comparison.

		/// This this property to true can increase performance, as Visible will change less often.

		/// </summary>

		/// <value>

		/// 	<c>true</c> if approximate content bounds comparison is used; otherwise, <c>false</c>.

		/// </value>

		public bool UseApproximateContentBoundsComparison

		{

			get { return useApproximateContentBoundsComparison; }

			set { useApproximateContentBoundsComparison = value; }

		}



		private double maxContentBoundsComparisonMistake = 0.02;

		public double MaxContentBoundsComparisonMistake

		{

			get { return maxContentBoundsComparisonMistake; }

			set { maxContentBoundsComparisonMistake = value; }

		}



		private DataRect prevContentBounds = DataRect.Empty;

		protected virtual DataRect CoerceVisible(DataRect newVisible)

		{

			if (Plotter == null)

			{

				return newVisible;

			}



			bool isDefaultValue = newVisible == (DataRect)VisibleProperty.DefaultMetadata.DefaultValue;

			if (isDefaultValue)

			{

				newVisible = DataRect.Empty;

			}



			if (isDefaultValue && IsFittedToView)

			{

				// determining content bounds

				DataRect bounds = DataRect.Empty;



				foreach (var item in contentBoundsHosts)

				{

					IPlotterElement plotterElement = item as IPlotterElement;

					if (plotterElement == null)

						continue;

					if (plotterElement.Plotter == null)

						continue;



					DataRect contentBounds = Viewport2D.GetContentBounds(item);

					if (contentBounds.Width.IsNaN() || contentBounds.Height.IsNaN())

						continue;



					bounds.UnionFinite(contentBounds);

				}



				if (useApproximateContentBoundsComparison)

				{

					var intersection = prevContentBounds;

					intersection.Intersect(bounds);



					double currSquare = bounds.GetSquare();

					double prevSquare = prevContentBounds.GetSquare();

					double intersectionSquare = intersection.GetSquare();



					double squareTopLimit = 1 + maxContentBoundsComparisonMistake;

					double squareBottomLimit = 1 - maxContentBoundsComparisonMistake;



					if (intersectionSquare != 0)

					{

						double currRatio = currSquare / intersectionSquare;

						double prevRatio = prevSquare / intersectionSquare;



						if (squareBottomLimit < currRatio &&

							currRatio < squareTopLimit &&

							squareBottomLimit < prevRatio &&

							prevRatio < squareTopLimit)

						{

							bounds = prevContentBounds;

						}

					}

				}



				prevContentBounds = bounds;

				UnitedContentBounds = bounds;



				// applying fit-to-view constraints

				bounds = fitToViewConstraints.Apply(Visible, bounds, this);



				// enlarging

				if (!bounds.IsEmpty)

				{

					bounds = CoordinateUtilities.RectZoom(bounds, bounds.GetCenter(), clipToBoundsEnlargeFactor);

				}

				else

				{

					bounds = (DataRect)VisibleProperty.DefaultMetadata.DefaultValue;

				}

				newVisible.Union(bounds);

			}



			if (newVisible.IsEmpty)

			{

				newVisible = (DataRect)VisibleProperty.DefaultMetadata.DefaultValue;

			}

			else if (newVisible.Width == 0 || newVisible.Height == 0 || newVisible.IsEmptyX || newVisible.IsEmptyY)

			{

				DataRect defRect = (DataRect)VisibleProperty.DefaultMetadata.DefaultValue;

				Size size = newVisible.Size;

				Point location = newVisible.Location;



				if (newVisible.Width == 0 || newVisible.IsEmptyX)

				{

					size.Width = defRect.Width;

					location.X -= size.Width / 2;

				}

				if (newVisible.Height == 0 || newVisible.IsEmptyY)

				{

					size.Height = defRect.Height;

					location.Y -= size.Height / 2;

				}



				newVisible = new DataRect(location, size);

			}



			// apply domain constraint

			newVisible = domainConstraint.Apply(Visible, newVisible, this);



			// apply other restrictions

			newVisible = constraints.Apply(Visible, newVisible, this);



			// applying transform's data domain constraint

			if (!transform.DataTransform.DataDomain.IsEmpty)

			{

				var newDataRect = newVisible.ViewportToData(transform);

				newDataRect = DataRect.Intersect(newDataRect, transform.DataTransform.DataDomain);

				newVisible = newDataRect.DataToViewport(transform);

			}



			if (newVisible.IsEmpty)

				newVisible = new Rect(0, 0, 1, 1);



			return newVisible;

		}



		private static object OnCoerceVisible(DependencyObject d, object newValue)

		{

			Viewport2D viewport = (Viewport2D)d;

			DataRect newVisible = (DataRect)newValue;



			DataRect newRect = viewport.CoerceVisible(newVisible);



			if (viewport.FromContentBounds && viewport.prevVisibles.ContainsValue(newRect))

				return DependencyProperty.UnsetValue;

			else

				viewport.prevVisibles.AddValue(newRect);



			if (newRect.Width == 0 || newRect.Height == 0)

			{

				// doesn't apply rects with zero square

				return DependencyProperty.UnsetValue;

			}

			else

			{

				return newRect;

			}

		}



		#endregion



		#region Domain



		private readonly DomainConstraint domainConstraint = new DomainConstraint { Domain = Rect.Empty };



		/// <summary>

		/// Gets or sets the domain - rectangle in viewport coordinates that limits maximal size of <see cref="Visible"/> rectangle.

		/// </summary>

		/// <value>The domain.</value>

		public DataRect Domain

		{

			get { return (DataRect)GetValue(DomainProperty); }

			set { SetValue(DomainProperty, value); }

		}



		public static readonly DependencyProperty DomainProperty = DependencyProperty.Register(

		  "Domain",

		  typeof(DataRect),

		  typeof(Viewport2D),

		  new FrameworkPropertyMetadata(DataRect.Empty, OnDomainReplaced));



		private static void OnDomainReplaced(DependencyObject d, DependencyPropertyChangedEventArgs e)

		{

			Viewport2D owner = (Viewport2D)d;

			owner.OnDomainChanged();

		}



		private void OnDomainChanged()

		{

			domainConstraint.Domain = Domain;

			DomainChanged.Raise(this);

			CoerceValue(VisibleProperty);

		}



		/// <summary>

		/// Occurs when <see cref="Domain"/> property changes.

		/// </summary>

		public event EventHandler DomainChanged;



		#endregion



		private double clipToBoundsEnlargeFactor = 1.10;

		/// <summary>

		/// Gets or sets the viewport enlarge factor.

		/// </summary>

		/// <remarks>

		/// Default value is 1.10.

		/// </remarks>

		/// <value>The clip to bounds factor.</value>

		public double ClipToBoundsEnlargeFactor

		{

			get { return clipToBoundsEnlargeFactor; }

			set

			{

				if (clipToBoundsEnlargeFactor != value)

				{

					clipToBoundsEnlargeFactor = value;

					UpdateVisible();

				}

			}

		}



		private void UpdateTransform()

		{

			transform = transform.WithRects(Visible, Output);

		}



		private CoordinateTransform transform = CoordinateTransform.CreateDefault();

		/// <summary>

		/// Gets or sets the coordinate transform of Viewport.

		/// </summary>

		/// <value>The transform.</value>

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

		[NotNull]

		public virtual CoordinateTransform Transform

		{

			get { return transform; }

			set

			{

				value.VerifyNotNull();



				if (value != transform)

				{

					var oldTransform = transform;



					transform = value;



					RaisePropertyChangedEvent("Transform", oldTransform, transform);

				}

			}

		}



		/// <summary>

		/// Occurs when viewport property changes.

		/// </summary>

		public event EventHandler<ExtendedPropertyChangedEventArgs> PropertyChanged;



		private void RaisePropertyChangedEvent(string propertyName, object oldValue, object newValue)

		{

			if (PropertyChanged != null)

			{

				RaisePropertyChanged(new ExtendedPropertyChangedEventArgs { PropertyName = propertyName, OldValue = oldValue, NewValue = newValue });

			}

		}



		private void RaisePropertyChangedEvent(string propertyName)

		{

			if (PropertyChanged != null)

			{

				RaisePropertyChanged(new ExtendedPropertyChangedEventArgs { PropertyName = propertyName });

			}

		}



		/// <summary>

		/// Gets or sets the type of viewport change.

		/// </summary>

		/// <value>The type of the change.</value>

		public ChangeType ChangeType { get; internal set; }



		/// <summary>

		/// Sets the type of viewport change.

		/// </summary>

		/// <param name="changeType">Type of the change.</param>

		public void SetChangeType(ChangeType changeType = ChangeType.None)

		{

			this.ChangeType = changeType;

		}



		int propertyChangedCounter = 0;

		private DispatcherOperation notifyOperation = null;

		private void RaisePropertyChangedEvent(DependencyPropertyChangedEventArgs e)

		{

			if (notifyOperation == null)

			{

				ChangeType changeType = ChangeType;

				notifyOperation = Dispatcher.BeginInvoke(() =>

				{

					RaisePropertyChangedEventBody(e, changeType);

				}, invocationPriority);

				return;

			}

			else if (notifyOperation.Status == DispatcherOperationStatus.Pending)

			{

				notifyOperation.Abort();

				ChangeType changeType = ChangeType;

				notifyOperation = Dispatcher.BeginInvoke(() =>

				{

					RaisePropertyChangedEventBody(e, changeType);

				}, invocationPriority);

			}

		}



		private void RaisePropertyChangedEventBody(DependencyPropertyChangedEventArgs e, ChangeType changeType)

		{

			if (propertyChangedCounter > 0)

				return;



			propertyChangedCounter++;

			RaisePropertyChanged(ExtendedPropertyChangedEventArgs.FromDependencyPropertyChanged(e), changeType);

			propertyChangedCounter--;



			notifyOperation = null;

		}



		protected virtual void RaisePropertyChanged(ExtendedPropertyChangedEventArgs args, ChangeType changeType = ChangeType.None)

		{

			args.ChangeType = changeType;

			PropertyChanged.Raise(this, args);

		}



		private void OnPlotterChildrenChanged(object sender, NotifyCollectionChangedEventArgs e)

		{

			UpdateContentBoundsHosts();

		}



		#region Panning state



		private Viewport2DPanningState panningState = Viewport2DPanningState.NotPanning;

		public Viewport2DPanningState PanningState

		{

			get { return panningState; }

			set

			{

				var prevState = panningState;



				panningState = value;



				OnPanningStateChanged(prevState, panningState);

			}

		}



		private void OnPanningStateChanged(Viewport2DPanningState prevState, Viewport2DPanningState currState)

		{

			PanningStateChanged.Raise(this, prevState, currState);

			if (currState == Viewport2DPanningState.Panning)

				BeginPanning.Raise(this);

			else if (currState == Viewport2DPanningState.NotPanning)

				EndPanning.Raise(this);

		}



		internal event EventHandler<ValueChangedEventArgs<Viewport2DPanningState>> PanningStateChanged;



		public event EventHandler BeginPanning;

		public event EventHandler EndPanning;



		#endregion // end of Panning state

	}



	public enum ChangeType

	{

		None = 0,

		Pan,

		PanX,

		PanY,

		Zoom,

		ZoomX,

		ZoomY

	}

}