/Main/src/DynamicDataDisplay/Charts/Isolines/IsolineGraphBase.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using Microsoft.Research.DynamicDataDisplay.Common.Palettes;

using Microsoft.Research.DynamicDataDisplay.DataSources;

using DataSource = Microsoft.Research.DynamicDataDisplay.DataSources.IDataSource2D<double>;

using System.Windows;

using Microsoft.Research.DynamicDataDisplay.Charts.Shapes;



namespace Microsoft.Research.DynamicDataDisplay.Charts.Isolines

{

	public abstract class IsolineGraphBase : ContentGraph

	{

		protected IsolineGraphBase() { }



		private IsolineCollection collection = new IsolineCollection();

		protected IsolineCollection Collection

		{

			get { return collection; }

			set { collection = value; }

		}



		private readonly IsolineBuilder isolineBuilder = new IsolineBuilder();

		protected IsolineBuilder IsolineBuilder

		{

			get { return isolineBuilder; }

		}



		private readonly IsolineTextAnnotater annotater = new IsolineTextAnnotater();

		protected IsolineTextAnnotater Annotater

		{

			get { return annotater; }

		}



		#region Properties



		#region IsolineCollection property



		public IsolineCollection IsolineCollection

		{

			get { return (IsolineCollection)GetValue(IsolineCollectionProperty); }

			set { SetValue(IsolineCollectionProperty, value); }

		}



		public static readonly DependencyProperty IsolineCollectionProperty = DependencyProperty.Register(

		  "IsolineCollection",

		  typeof(IsolineCollection),

		  typeof(IsolineGraphBase),

		  new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits));



		#endregion // end of IsolineCollection property



		#region WayBeforeTextMultiplier



		public double WayBeforeTextMultiplier

		{

			get { return (double)GetValue(WayBeforeTextMultiplierProperty); }

			set { SetValue(WayBeforeTextMultiplierProperty, value); }

		}



		public static readonly DependencyProperty WayBeforeTextMultiplierProperty = DependencyProperty.Register(

		  "WayBeforeTextCoeff",

		  typeof(double),

		  typeof(IsolineGraphBase),

		  new FrameworkPropertyMetadata(1.0, FrameworkPropertyMetadataOptions.Inherits, OnIsolinePropertyChanged));



		#endregion // end of WayBeforeTextCoeff



		private static void OnIsolinePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)

		{

			// todo do smth here

		}



		#region Palette property



		public IPalette Palette

		{

			get { return (IPalette)GetValue(PaletteProperty); }

			set { SetValue(PaletteProperty, value); }

		}



		public static readonly DependencyProperty PaletteProperty = DependencyProperty.Register(

		  "Palette",

		  typeof(IPalette),

		  typeof(IsolineGraphBase),

		  new FrameworkPropertyMetadata(new HsbPalette(), FrameworkPropertyMetadataOptions.Inherits, OnIsolinePropertyChanged), ValidatePalette);



		private static bool ValidatePalette(object value)

		{

			return value != null;

		}



		#endregion // end of Palette property



		#region DataSource property



		public DataSource DataSource

		{

			get { return (DataSource)GetValue(DataSourceProperty); }

			set { SetValue(DataSourceProperty, value); }

		}



		public static readonly DependencyProperty DataSourceProperty = DependencyProperty.Register(

		  "DataSource",

		  typeof(DataSource),

		  typeof(IsolineGraphBase),

		  new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.Inherits, OnDataSourceChanged));



		private static void OnDataSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)

		{

			IsolineGraphBase owner = (IsolineGraphBase)d;

			owner.OnDataSourceChanged((DataSource)e.OldValue, (DataSource)e.NewValue);

		}



		protected virtual void OnDataSourceChanged(IDataSource2D<double> prevDataSource, IDataSource2D<double> currDataSource)

		{

			if (prevDataSource != null)

				prevDataSource.Changed -= OnDataSourceChanged;

			if (currDataSource != null)

				currDataSource.Changed += OnDataSourceChanged;



			UpdateDataSource();

			CreateUIRepresentation();



			RaiseEvent(new RoutedEventArgs(BackgroundRenderer.UpdateRequested));

		}



		#endregion // end of DataSource property



		#region DrawLabels property



		public bool DrawLabels

		{

			get { return (bool)GetValue(DrawLabelsProperty); }

			set { SetValue(DrawLabelsProperty, value); }

		}



		public static readonly DependencyProperty DrawLabelsProperty = DependencyProperty.Register(

			"DrawLabels",

			typeof(bool),

			typeof(IsolineGraphBase),

			new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.Inherits, OnIsolinePropertyChanged));



		#endregion // end of DrawLabels property

		

		#region LabelStringFormat



		public string LabelStringFormat

		{

			get { return (string)GetValue(LabelStringFormatProperty); }

			set { SetValue(LabelStringFormatProperty, value); }

		}



		public static readonly DependencyProperty LabelStringFormatProperty = DependencyProperty.Register(

		  "LabelStringFormat",

		  typeof(string),

		  typeof(IsolineGraphBase),

		  new FrameworkPropertyMetadata("F", FrameworkPropertyMetadataOptions.Inherits, OnIsolinePropertyChanged));



		#endregion // end of LabelStringFormat



		#region UseBezierCurves



		public bool UseBezierCurves

		{

			get { return (bool)GetValue(UseBezierCurvesProperty); }

			set { SetValue(UseBezierCurvesProperty, value); }

		}



		public static readonly DependencyProperty UseBezierCurvesProperty = DependencyProperty.Register(

		  "UseBezierCurves",

		  typeof(bool),

		  typeof(IsolineGraphBase),

		  new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.Inherits));



		#endregion // end of UseBezierCurves



		public double LabelsScaling

		{

			get { return (double)GetValue(LabelsScalingProperty); }

			set { SetValue(LabelsScalingProperty, value); }

		}



		public static readonly DependencyProperty LabelsScalingProperty = DependencyProperty.Register(

		  "LabelsScaling",

		  typeof(double),

		  typeof(IsolineGraphBase),

		  new FrameworkPropertyMetadata(1.0, FrameworkPropertyMetadataOptions.Inherits));





		#endregion // end of Properties



		#region DataSource



		//private DataSource dataSource = null;

		///// <summary>

		///// Gets or sets the data source.

		///// </summary>

		///// <value>The data source.</value>

		//public DataSource DataSource

		//{

		//    get { return dataSource; }

		//    set

		//    {

		//        if (dataSource != value)

		//        {

		//            DetachDataSource(dataSource);

		//            dataSource = value;

		//            AttachDataSource(dataSource);



		//            UpdateDataSource();

		//        }

		//    }

		//}



		#region MissingValue property



		public double MissingValue

		{

			get { return (double)GetValue(MissingValueProperty); }

			set { SetValue(MissingValueProperty, value); }

		}



		public static readonly DependencyProperty MissingValueProperty = DependencyProperty.Register(

		  "MissingValue",

		  typeof(double),

		  typeof(IsolineGraphBase),

		  new FrameworkPropertyMetadata(Double.NaN, FrameworkPropertyMetadataOptions.Inherits, OnMissingValueChanged));



		private static void OnMissingValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)

		{

			IsolineGraphBase owner = (IsolineGraphBase)d;

			owner.UpdateDataSource();

		}



		#endregion // end of MissineValue property



		public void SetDataSource(DataSource dataSource, double missingValue)

		{

			DataSource = dataSource;

			MissingValue = missingValue;



			UpdateDataSource();

		}



		/// <summary>

		/// This method is called when data source changes.

		/// </summary>

		protected virtual void UpdateDataSource()

		{

		}



		protected virtual void CreateUIRepresentation() { }



		protected virtual void OnDataSourceChanged(object sender, EventArgs e)

		{

			UpdateDataSource();

		}



		#endregion



		#region StrokeThickness



		/// <summary>

		/// Gets or sets thickness of isoline lines.

		/// </summary>

		/// <value>The stroke thickness.</value>

		public double StrokeThickness

		{

			get { return (double)GetValue(StrokeThicknessProperty); }

			set { SetValue(StrokeThicknessProperty, value); }

		}



		/// <summary>

		/// Identifies the StrokeThickness dependency property.

		/// </summary>

		public static readonly DependencyProperty StrokeThicknessProperty =

			DependencyProperty.Register(

			  "StrokeThickness",

			  typeof(double),

			  typeof(IsolineGraphBase),

			  new FrameworkPropertyMetadata(2.0, OnLineThicknessChanged));



		private static void OnLineThicknessChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)

		{

			IsolineGraphBase graph = (IsolineGraphBase)d;

			graph.OnLineThicknessChanged();

		}



		protected virtual void OnLineThicknessChanged() { }



		#endregion

	}

}