Initial Commit

Charts/Shapes/PositionalViewportUIContainer.cs

@@ -0,0 +1,194 @@
+#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
+	}
+}