#define old



using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows.Controls;

using System.Windows;

using Microsoft.Research.DynamicDataDisplay;

using System.Windows.Threading;

using System.Diagnostics;

using System.Windows.Markup;

using System.Collections.ObjectModel;

using Microsoft.Research.DynamicDataDisplay.Common;

using Microsoft.Research.DynamicDataDisplay.Common.Auxiliary;

using System.Windows.Data;



namespace Microsoft.Research.DynamicDataDisplay.Charts

{

	public sealed class PositionChangedEventArgs : EventArgs

	{

		public Point Position { get; internal set; }

		public Point PreviousPosition { get; internal set; }

	}



	public delegate Point PositionCoerceCallback(PositionalViewportUIContainer container, Point position);



	public class PositionalViewportUIContainer : ContentControl, IPlotterElement

	{

		static PositionalViewportUIContainer()

		{

			Type type = typeof(PositionalViewportUIContainer);



			// todo subscribe for properties changes

			HorizontalContentAlignmentProperty.AddOwner(

				type, new FrameworkPropertyMetadata(HorizontalAlignment.Center));

			VerticalContentAlignmentProperty.AddOwner(

				type, new FrameworkPropertyMetadata(VerticalAlignment.Center));

		}



		public PositionalViewportUIContainer()

		{

			PlotterEvents.PlotterChangedEvent.Subscribe(this, OnPlotterChanged);



			//SetBinding(ViewportPanel.XProperty, new Binding("Position.X") { Source = this, Mode = BindingMode.TwoWay });

			//SetBinding(ViewportPanel.YProperty, new Binding("Position.Y") { Source = this, Mode = BindingMode.TwoWay });

		}



		protected virtual void OnPlotterChanged(object sender, PlotterChangedEventArgs e)

		{

			if (e.CurrentPlotter != null)

				OnPlotterAttached(e.CurrentPlotter);

			else if (e.PreviousPlotter != null)

				OnPlotterDetaching(e.PreviousPlotter);

		}



		public Point Position

		{

			get { return (Point)GetValue(PositionProperty); }

			set { SetValue(PositionProperty, value); }

		}



		public static readonly DependencyProperty PositionProperty =

			DependencyProperty.Register(

			  "Position",

			  typeof(Point),

			  typeof(PositionalViewportUIContainer),

			  new FrameworkPropertyMetadata(new Point(0, 0), OnPositionChanged, CoercePosition));



		private static object CoercePosition(DependencyObject d, object value)

		{

			PositionalViewportUIContainer owner = (PositionalViewportUIContainer)d;

			if (owner.positionCoerceCallbacks.Count > 0)

			{

				Point position = (Point)value;

				foreach (var callback in owner.positionCoerceCallbacks)

				{

					position = callback(owner, position);

				}

				value = position;

			}

			return value;

		}



		private readonly ObservableCollection<PositionCoerceCallback> positionCoerceCallbacks = new ObservableCollection<PositionCoerceCallback>();

		/// <summary>

		/// Gets the list of callbacks which are called every time Position changes to coerce it.

		/// </summary>

		/// <value>The position coerce callbacks.</value>

		public ObservableCollection<PositionCoerceCallback> PositionCoerceCallbacks

		{

			get { return positionCoerceCallbacks; }

		}



		private static void OnPositionChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)

		{

			PositionalViewportUIContainer container = (PositionalViewportUIContainer)d;

			container.OnPositionChanged(e);

		}



		public event EventHandler<PositionChangedEventArgs> PositionChanged;



		private void OnPositionChanged(DependencyPropertyChangedEventArgs e)

		{

			PositionChanged.Raise(this, new PositionChangedEventArgs { Position = (Point)e.NewValue, PreviousPosition = (Point)e.OldValue });



			ViewportPanel.SetX(this, Position.X);

			ViewportPanel.SetY(this, Position.Y);

		}



		#region IPlotterElement Members



		private const string canvasName = "ViewportUIContainer_Canvas";

		private ViewportHostPanel hostPanel;

		private Plotter2D plotter;

		public void OnPlotterAttached(Plotter plotter)

		{

			if (Parent == null)

			{

				hostPanel = new ViewportHostPanel();

				Viewport2D.SetIsContentBoundsHost(hostPanel, false);

				hostPanel.Children.Add(this);



				plotter.Dispatcher.BeginInvoke(() =>

				{

					plotter.Children.Add(hostPanel);

				}, DispatcherPriority.Send);

			}

#if !old

			Canvas hostCanvas = (Canvas)hostPanel.FindName(canvasName);

			if (hostCanvas == null)

			{

				hostCanvas = new Canvas { ClipToBounds = true };

				Panel.SetZIndex(hostCanvas, 1);



				INameScope nameScope = NameScope.GetNameScope(hostPanel);

				if (nameScope == null)

				{

					nameScope = new NameScope();

					NameScope.SetNameScope(hostPanel, nameScope);

				}



				hostPanel.RegisterName(canvasName, hostCanvas);

				hostPanel.Children.Add(hostCanvas);

			}



			hostCanvas.Children.Add(this);

#else

#endif



			Plotter2D plotter2d = (Plotter2D)plotter;

			this.plotter = plotter2d;

		}



		public void OnPlotterDetaching(Plotter plotter)

		{

			Plotter2D plotter2d = (Plotter2D)plotter;



#if !old

			Canvas hostCanvas = (Canvas)hostPanel.FindName(canvasName);



			if (hostCanvas.Children.Count == 1)

			{

				// only this ViewportUIContainer left

				hostPanel.Children.Remove(hostCanvas);

			}

			hostCanvas.Children.Remove(this);

#else

			if (hostPanel != null)

			{

				hostPanel.Children.Remove(this);

			}

			plotter.Dispatcher.BeginInvoke(() =>

			{

				plotter.Children.Remove(hostPanel);

			}, DispatcherPriority.Send);

#endif



			this.plotter = null;

		}



		public Plotter2D Plotter

		{

			get { return plotter; }

		}



		Plotter IPlotterElement.Plotter

		{

			get { return plotter; }

		}



		#endregion

	}

}