source: branches/HeuristicLab.Problems.GrammaticalOptimization/DynamicDataDisplay/Charts/Axes/AxisControl.cs @ 12503

using System;
using System.Diagnostics;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Shapes;
using Microsoft.Research.DynamicDataDisplay.Common.Auxiliary;
using System.Collections.Generic;
using System.ComponentModel;
using Microsoft.Research.DynamicDataDisplay.Charts.Axes;
using System.Windows.Data;
using Microsoft.Research.DynamicDataDisplay.Common;
using System.Windows.Threading;

namespace Microsoft.Research.DynamicDataDisplay.Charts
{
  /// <summary>
  /// Defines a base class for axis UI representation.
  /// Contains a number of properties that can be used to adjust ticks set and their look.
  /// </summary>
  /// <typeparam name="T"></typeparam>
  [TemplatePart(Name = "PART_AdditionalLabelsCanvas", Type = typeof(StackCanvas))]
  [TemplatePart(Name = "PART_CommonLabelsCanvas", Type = typeof(StackCanvas))]
  [TemplatePart(Name = "PART_TicksPath", Type = typeof(Path))]
  [TemplatePart(Name = "PART_ContentsGrid", Type = typeof(Panel))]
  public abstract class AxisControl<T> : AxisControlBase
  {
    private const string templateKey = "axisControlTemplate";
    private const string smoothTemplateKey = "smoothAxisControlTemplate";
    private const string additionalLabelTransformKey = "additionalLabelsTransform";

    private const string PART_AdditionalLabelsCanvas = "PART_AdditionalLabelsCanvas";
    private const string PART_CommonLabelsCanvas = "PART_CommonLabelsCanvas";
    private const string PART_TicksPath = "PART_TicksPath";
    private const string PART_ContentsGrid = "PART_ContentsGrid";

    /// <summary>
    /// Initializes a new instance of the <see cref="AxisControl&lt;T&gt;"/> class.
    /// </summary>
    protected AxisControl()
    {
      HorizontalContentAlignment = HorizontalAlignment.Stretch;
      VerticalContentAlignment = VerticalAlignment.Stretch;

      Background = Brushes.Transparent;
      Focusable = false;

      UpdateUIResources();
      UpdateSizeGetters();
    }

    internal void MakeDependent()
    {
      independent = false;
    }

    /// <summary>
    /// This conversion is performed to make horizontal one-string and two-string labels
    /// stay at one height.
    /// </summary>
    /// <param name="placement"></param>
    /// <returns></returns>
    private static AxisPlacement GetBetterPlacement(AxisPlacement placement)
    {
      switch (placement)
      {
        case AxisPlacement.Left:
          return AxisPlacement.Left;
        case AxisPlacement.Right:
          return AxisPlacement.Right;
        case AxisPlacement.Top:
          return AxisPlacement.Top;
        case AxisPlacement.Bottom:
          return AxisPlacement.Bottom;
        default:
          throw new NotSupportedException();
      }
    }

    #region Properties

    private AxisPlacement placement = AxisPlacement.Bottom;
    /// <summary>
    /// Gets or sets the placement of axis control.
    /// Relative positioning of parts of axis depends on this value.
    /// </summary>
    /// <value>The placement.</value>
    public AxisPlacement Placement
    {
      get { return placement; }
      set
      {
        if (placement != value)
        {
          placement = value;
          UpdateUIResources();
          UpdateSizeGetters();
        }
      }
    }

    private void UpdateSizeGetters()
    {
      switch (placement)
      {
        case AxisPlacement.Left:
        case AxisPlacement.Right:
          getSize = size => size.Height;
          getCoordinate = p => p.Y;
          createScreenPoint1 = d => new Point(scrCoord1, d);
          createScreenPoint2 = (d, size) => new Point(scrCoord2 * size, d);
          break;
        case AxisPlacement.Top:
        case AxisPlacement.Bottom:
          getSize = size => size.Width;
          getCoordinate = p => p.X;
          createScreenPoint1 = d => new Point(d, scrCoord1);
          createScreenPoint2 = (d, size) => new Point(d, scrCoord2 * size);
          break;
        default:
          break;
      }

      switch (placement)
      {
        case AxisPlacement.Left:
          createDataPoint = d => new Point(0, d);
          break;
        case AxisPlacement.Right:
          createDataPoint = d => new Point(1, d);
          break;
        case AxisPlacement.Top:
          createDataPoint = d => new Point(d, 1);
          break;
        case AxisPlacement.Bottom:
          createDataPoint = d => new Point(d, 0);
          break;
        default:
          break;
      }
    }

    private void UpdateUIResources()
    {
      ResourceDictionary resources = new ResourceDictionary
      {
        Source = new Uri("/DynamicDataDisplay;component/Charts/Axes/AxisControlStyle.xaml", UriKind.Relative)
      };

      string templateKey;
      if (useSmoothPanning)
        templateKey = smoothTemplateKey;
      else
        templateKey = AxisControl<T>.templateKey;

      AxisPlacement placement = GetBetterPlacement(this.placement);
      ControlTemplate template = (ControlTemplate)resources[templateKey + placement.ToString()];

      Verify.AssertNotNull(template);
      var content = (FrameworkElement)template.LoadContent();

      if (ticksPath != null && ticksPath.Data != null)
      {
        GeometryGroup group = (GeometryGroup)ticksPath.Data;
        foreach (var child in group.Children)
        {
          LineGeometry geometry = (LineGeometry)child;
          lineGeomPool.Put(geometry);
        }
        group.Children.Clear();
      }

      ticksPath = (Path)content.FindName(PART_TicksPath);
      ticksPath.SnapsToDevicePixels = true;
      Verify.AssertNotNull(ticksPath);

      // as this method can be called not only on loading of axisControl, but when its placement changes, internal panels
      // can be not empty and their contents should be released
      if (commonLabelsCanvas != null && labelProvider != null)
      {
        foreach (UIElement child in commonLabelsCanvas.Children)
        {
          if (child != null)
          {
            labelProvider.ReleaseLabel(child);
          }
        }

        labels = null;
        commonLabelsCanvas.Children.Clear();
      }

      commonLabelsCanvas = (StackCanvas)content.FindName(PART_CommonLabelsCanvas);
      Verify.AssertNotNull(commonLabelsCanvas);
      commonLabelsCanvas.Placement = placement;

      if (additionalLabelsCanvas != null && majorLabelProvider != null)
      {
        foreach (UIElement child in additionalLabelsCanvas.Children)
        {
          if (child != null)
          {
            majorLabelProvider.ReleaseLabel(child);
          }
        }
      }

      additionalLabelsCanvas = (StackCanvas)content.FindName(PART_AdditionalLabelsCanvas);
      Verify.AssertNotNull(additionalLabelsCanvas);
      additionalLabelsCanvas.Placement = placement;

      mainGrid = (Panel)content.FindName(PART_ContentsGrid);
      Verify.AssertNotNull(mainGrid);

      mainGrid.SetBinding(Control.BackgroundProperty, new Binding { Path = new PropertyPath("Background"), Source = this });
      mainGrid.SizeChanged += new SizeChangedEventHandler(mainGrid_SizeChanged);

      Content = mainGrid;

      string transformKey = additionalLabelTransformKey + placement.ToString();
      if (resources.Contains(transformKey))
      {
        additionalLabelTransform = (Transform)resources[transformKey];
      }

      UpdateUI();
    }

    private void mainGrid_SizeChanged(object sender, SizeChangedEventArgs e)
    {
      if (placement.IsBottomOrTop() && e.WidthChanged ||
         e.HeightChanged)
      {
        // this is performed because if not, whole axisControl's size was measured wrongly.
        InvalidateMeasure();
        UpdateUI();
      }
    }

    private bool updateOnCommonChange = true;

    internal IDisposable OpenUpdateRegion(bool forceUpdate)
    {
      return new UpdateRegionHolder<T>(this, forceUpdate);
    }

    private sealed class UpdateRegionHolder<TT> : IDisposable
    {
      private Range<TT> prevRange;
      private CoordinateTransform prevTransform;
      private AxisControl<TT> owner;
      private bool forceUpdate = false;

      public UpdateRegionHolder(AxisControl<TT> owner) : this(owner, false) { }

      public UpdateRegionHolder(AxisControl<TT> owner, bool forceUpdate)
      {
        this.owner = owner;
        owner.updateOnCommonChange = false;

        prevTransform = owner.transform;
        prevRange = owner.range;
        this.forceUpdate = forceUpdate;
      }

      #region IDisposable Members

      public void Dispose()
      {
        owner.updateOnCommonChange = true;

        bool shouldUpdate = owner.range != prevRange;

        var screenRect = owner.Transform.ScreenRect;
        var prevScreenRect = prevTransform.ScreenRect;
        if (owner.placement.IsBottomOrTop())
        {
          shouldUpdate |= prevScreenRect.Width != screenRect.Width;
        }
        else
        {
          shouldUpdate |= prevScreenRect.Height != screenRect.Height;
        }

        shouldUpdate |= owner.transform.DataTransform != prevTransform.DataTransform;
        shouldUpdate |= forceUpdate;

        if (shouldUpdate)
        {
          owner.UpdateUI();
        }
        owner = null;
      }

      #endregion
    }

    private Range<T> range;
    /// <summary>
    /// Gets or sets the range, which ticks are generated for.
    /// </summary>
    /// <value>The range.</value>
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public Range<T> Range
    {
      get { return range; }
      set
      {
        range = value;
        if (updateOnCommonChange)
        {
          UpdateUI();
        }
      }
    }

    private bool drawMinorTicks = true;
    /// <summary>
    /// Gets or sets a value indicating whether to show minor ticks.
    /// </summary>
    /// <value><c>true</c> if show minor ticks; otherwise, <c>false</c>.</value>
    public bool DrawMinorTicks
    {
      get { return drawMinorTicks; }
      set
      {
        if (drawMinorTicks != value)
        {
          drawMinorTicks = value;
          UpdateUI();
        }
      }
    }

    private bool drawMajorLabels = true;
    /// <summary>
    /// Gets or sets a value indicating whether to show major labels.
    /// </summary>
    /// <value><c>true</c> if show major labels; otherwise, <c>false</c>.</value>
    public bool DrawMajorLabels
    {
      get { return drawMajorLabels; }
      set
      {
        if (drawMajorLabels != value)
        {
          drawMajorLabels = value;
          UpdateUI();
        }
      }
    }

    private bool drawTicks = true;
    public bool DrawTicks
    {
      get { return drawTicks; }
      set
      {
        if (drawTicks != value)
        {
          drawTicks = value;
          UpdateUI();
        }
      }
    }

    #region TicksProvider

    private ITicksProvider<T> ticksProvider;
    /// <summary>
    /// Gets or sets the ticks provider - generator of ticks for given range.
    /// 
    /// Should not be null.
    /// </summary>
    /// <value>The ticks provider.</value>
    public ITicksProvider<T> TicksProvider
    {
      get { return ticksProvider; }
      set
      {
        if (value == null)
          throw new ArgumentNullException("value");

        if (ticksProvider != value)
        {
          DetachTicksProvider();

          ticksProvider = value;

          AttachTicksProvider();

          UpdateUI();
        }
      }
    }

    private void AttachTicksProvider()
    {
      if (ticksProvider != null)
      {
        ticksProvider.Changed += ticksProvider_Changed;
      }
    }

    private void ticksProvider_Changed(object sender, EventArgs e)
    {
      UpdateUI();
    }

    private void DetachTicksProvider()
    {
      if (ticksProvider != null)
      {
        ticksProvider.Changed -= ticksProvider_Changed;
      }
    }

    #endregion

    [EditorBrowsable(EditorBrowsableState.Never)]
    public override bool ShouldSerializeContent()
    {
      return false;
    }

    protected override bool ShouldSerializeProperty(DependencyProperty dp)
    {
      // do not serialize template - for XAML serialization
      if (dp == TemplateProperty) return false;

      return base.ShouldSerializeProperty(dp);
    }

    #region MajorLabelProvider

    private LabelProviderBase<T> majorLabelProvider;
    /// <summary>
    /// Gets or sets the major label provider, which creates labels for major ticks.
    /// If null, major labels will not be shown.
    /// </summary>
    /// <value>The major label provider.</value>
    public LabelProviderBase<T> MajorLabelProvider
    {
      get { return majorLabelProvider; }
      set
      {
        if (majorLabelProvider != value)
        {
          DetachMajorLabelProvider();

          majorLabelProvider = value;

          AttachMajorLabelProvider();

          UpdateUI();
        }
      }
    }

    private void AttachMajorLabelProvider()
    {
      if (majorLabelProvider != null)
      {
        majorLabelProvider.Changed += majorLabelProvider_Changed;
      }
    }

    private void majorLabelProvider_Changed(object sender, EventArgs e)
    {
      UpdateUI();
    }

    private void DetachMajorLabelProvider()
    {
      if (majorLabelProvider != null)
      {
        majorLabelProvider.Changed -= majorLabelProvider_Changed;
      }
    }

    #endregion

    #region LabelProvider

    private LabelProviderBase<T> labelProvider;
    /// <summary>
    /// Gets or sets the label provider, which generates labels for axis ticks.
    /// Should not be null.
    /// </summary>
    /// <value>The label provider.</value>
    [NotNull]
    public LabelProviderBase<T> LabelProvider
    {
      get { return labelProvider; }
      set
      {
        if (value == null)
          throw new ArgumentNullException("value");

        if (labelProvider != value)
        {
          DetachLabelProvider();

          labelProvider = value;

          AttachLabelProvider();

          UpdateUI();
        }
      }
    }

    private void AttachLabelProvider()
    {
      if (labelProvider != null)
      {
        labelProvider.Changed += labelProvider_Changed;
      }
    }

    private void labelProvider_Changed(object sender, EventArgs e)
    {
      UpdateUI();
    }

    private void DetachLabelProvider()
    {
      if (labelProvider != null)
      {
        labelProvider.Changed -= labelProvider_Changed;
      }
    }

    #endregion

    private CoordinateTransform transform = CoordinateTransform.CreateDefault();
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    [EditorBrowsable(EditorBrowsableState.Never)]
    public CoordinateTransform Transform
    {
      get { return transform; }
      set
      {
        transform = value;
        if (updateOnCommonChange)
        {
          UpdateUI();
        }
      }
    }

    #endregion

    private const double defaultSmallerSize = 1;
    private const double defaultBiggerSize = 150;
    protected override Size MeasureOverride(Size constraint)
    {
      var baseSize = base.MeasureOverride(constraint);

      mainGrid.Measure(constraint);
      Size gridSize = mainGrid.DesiredSize;
      Size result = gridSize;

      bool isHorizontal = placement == AxisPlacement.Bottom || placement == AxisPlacement.Top;
      if (Double.IsInfinity(constraint.Width) && isHorizontal)
      {
        result = new Size(defaultBiggerSize, gridSize.Height != 0 ? gridSize.Height : defaultSmallerSize);
      }
      else if (Double.IsInfinity(constraint.Height) && !isHorizontal)
      {
        result = new Size(gridSize.Width != 0 ? gridSize.Width : defaultSmallerSize, defaultBiggerSize);
      }

      return result;
    }

    //protected override void OnRenderSizeChanged(SizeChangedInfo sizeInfo)
    //{
    //    base.OnRenderSizeChanged(sizeInfo);

    //    bool isHorizontal = placement == AxisPlacement.Top || placement == AxisPlacement.Bottom;
    //    if (isHorizontal && sizeInfo.WidthChanged || !isHorizontal && sizeInfo.HeightChanged)
    //    {
    //        UpdateUIRepresentation();
    //    }
    //}

    private void InitTransform(Size newRenderSize)
    {
      Rect dataRect = CreateDataRect();

      transform = transform.WithRects(dataRect, new Rect(newRenderSize));
    }

    private Rect CreateDataRect()
    {
      double min = convertToDouble(range.Min);
      double max = convertToDouble(range.Max);

      Rect dataRect;
      switch (placement)
      {
        case AxisPlacement.Left:
        case AxisPlacement.Right:
          dataRect = new Rect(new Point(min, min), new Point(max, max));
          break;
        case AxisPlacement.Top:
        case AxisPlacement.Bottom:
          dataRect = new Rect(new Point(min, min), new Point(max, max));
          break;
        default:
          throw new NotSupportedException();
      }
      return dataRect;
    }

    /// <summary>
    /// Gets the Path with ticks strokes.
    /// </summary>
    /// <value>The ticks path.</value>
    public override Path TicksPath
    {
      get { return ticksPath; }
    }

    private Panel mainGrid;
    private StackCanvas additionalLabelsCanvas;
    private StackCanvas commonLabelsCanvas;
    private Path ticksPath;
    private bool rendered = false;
    protected override void OnRender(DrawingContext dc)
    {
      base.OnRender(dc);

      if (!rendered)
      {
        UpdateUI();
      }
      rendered = true;
    }

    private bool independent = true;

    private double scrCoord1 = 0; // px
    private double scrCoord2 = 10; // px
    /// <summary>
    /// Gets or sets the size of main axis ticks.
    /// </summary>
    /// <value>The size of the tick.</value>
    public double TickSize
    {
      get { return scrCoord2; }
      set
      {
        if (scrCoord2 != value)
        {
          scrCoord2 = value;
          UpdateUI();
        }
      }
    }

    private bool useSmoothPanning = false;
    /// <summary>
    /// Gets or sets a value indicating whether axis control uses smooth panning.
    /// </summary>
    /// <value><c>true</c> if control uses smooth panning; otherwise, <c>false</c>.</value>
    public bool UseSmoothPanning
    {
      get { return useSmoothPanning; }
      set
      {
        useSmoothPanning = value;
        UpdateUIResources();
      }
    }

    double cachedPartLength;
    double[] originalScreenTicks;
    private Range<double> axisLongRange;
    private GeometryGroup geomGroup = new GeometryGroup();
    internal void UpdateUI()
    {
      if (range.IsEmpty)
        return;

      if (transform == null) return;

      if (independent)
      {
        InitTransform(RenderSize);
      }

      bool isHorizontal = Placement == AxisPlacement.Bottom || Placement == AxisPlacement.Top;
      if (transform.ScreenRect.Width == 0 && isHorizontal
        || transform.ScreenRect.Height == 0 && !isHorizontal)
        return;

      if (!IsMeasureValid)
      {
        InvalidateMeasure();
      }

      Range<double> currentDoubleRange = new Range<double>(convertToDouble(range.Min), convertToDouble(range.Max));
      bool sameLength = Math.Abs(cachedPartLength - currentDoubleRange.GetLength()) / cachedPartLength < 0.01 || cachedPartLength == 0;

      if (UseSmoothPanning && sameLength)
      {
        Debug.WriteLine(Placement + " " + range + " " + axisLongRange);
        // current range is included into axisLongRange
        if (currentDoubleRange < axisLongRange)
        {
          var axisContent = (FrameworkElement)mainGrid.Children[0];
          double leftScreen;
          if (placement.IsBottomOrTop())
            leftScreen = ((axisLongRange.Min - currentDoubleRange.Min) / currentDoubleRange.GetLength() + 1) * getSize(transform.ScreenRect.Size);
          else
            leftScreen = -((axisLongRange.Min - currentDoubleRange.Min) / currentDoubleRange.GetLength() + 1) * getSize(transform.ScreenRect.Size);

          StackCanvas.SetCoordinate(axisContent, leftScreen);

          // this call should be commented
          // double rightScreen = ((axisLongRange.Max - currentDoubleRange.Max) / currentDoubleRange.GetLength() + 1) * getSize(transform.ScreenRect.Size);
          // StackCanvas.SetEndCoordinate(axisContent, rightScreen);
        }
        else
        {
          double length = currentDoubleRange.GetLength();
          cachedPartLength = length;

          // cached axis part is three times longer
          double min = currentDoubleRange.Min - length;
          double max = currentDoubleRange.Max + length;
          Range<T> widerRange = new Range<T>(convertFromDouble(min), convertFromDouble(max));
          axisLongRange = new Range<double>(min, max);

          // rebuild entire ticks
          FillParts(widerRange);

          Debug.WriteLine("не шире " + Placement + " " + widerRange);

          originalScreenTicks = screenTicks.ToArray();
        }

        // updating screen ticks (for axis grid)
        // 3 is a ratio of cached area to visible area
        double shift = (currentDoubleRange.Min - (axisLongRange.Min + axisLongRange.GetLength() / 3)) * getSize(transform.ScreenRect.Size);

        if (!placement.IsBottomOrTop())
          shift *= -1;

        screenTicks = originalScreenTicks.ToArray();
        for (int i = 0; i < originalScreenTicks.Length; i++)
        {
          screenTicks[i] -= shift;
        }
      }
      else
      {
        FillParts(range);
      }

      ScreenTicksChanged.Raise(this);
    }

    private void FillParts(Range<T> range)
    {
      CreateTicks(range);

      // removing unfinite screen ticks
      var tempTicks = new List<T>(ticks);
      var tempScreenTicks = new List<double>(ticks.Length);
      var tempLabels = new List<UIElement>(labels);

      int i = 0;
      while (i < tempTicks.Count)
      {
        T tick = tempTicks[i];
        double screenTick = getCoordinate(createDataPoint(convertToDouble(tick)).DataToScreen(transform));
        if (screenTick.IsFinite())
        {
          tempScreenTicks.Add(screenTick);
          i++;
        }
        else
        {
          tempTicks.RemoveAt(i);
          tempLabels.RemoveAt(i);
        }
      }

      ticks = tempTicks.ToArray();
      screenTicks = tempScreenTicks.ToArray();
      labels = tempLabels.ToArray();

      // saving generated lines into pool
      for (i = 0; i < geomGroup.Children.Count; i++)
      {
        var geometry = (LineGeometry)geomGroup.Children[i];
        lineGeomPool.Put(geometry);
      }

      geomGroup = new GeometryGroup();
      geomGroup.Children = new GeometryCollection(lineGeomPool.Count);

      if (drawTicks)
        DoDrawTicks(screenTicks, geomGroup.Children);

      if (drawMinorTicks)
        DoDrawMinorTicks(geomGroup.Children);

      ticksPath.Data = geomGroup;

      DoDrawCommonLabels(screenTicks);

      if (drawMajorLabels)
        DoDrawMajorLabels();
    }

    bool drawTicksOnEmptyLabel = false;
    /// <summary>
    /// Gets or sets a value indicating whether to draw ticks on empty label.
    /// </summary>
    /// <value>
    ///   <c>true</c> if draw ticks on empty label; otherwise, <c>false</c>.
    /// </value>
    public bool DrawTicksOnEmptyLabel
    {
      get { return drawTicksOnEmptyLabel; }
      set
      {
        if (drawTicksOnEmptyLabel != value)
        {
          drawTicksOnEmptyLabel = value;
          UpdateUI();
        }
      }
    }

    private readonly ResourcePool<LineGeometry> lineGeomPool = new ResourcePool<LineGeometry>();
    private void DoDrawTicks(double[] screenTicksX, ICollection<Geometry> lines)
    {
      for (int i = 0; i < screenTicksX.Length; i++)
      {
        if (labels[i] == null && !drawTicksOnEmptyLabel)
          continue;

        Point p1 = createScreenPoint1(screenTicksX[i]);
        Point p2 = createScreenPoint2(screenTicksX[i], 1);

        LineGeometry line = lineGeomPool.GetOrCreate();

        line.StartPoint = p1;
        line.EndPoint = p2;
        lines.Add(line);
      }
    }

    private double GetRangesRatio(Range<T> nominator, Range<T> denominator)
    {
      double nomMin = ConvertToDouble(nominator.Min);
      double nomMax = ConvertToDouble(nominator.Max);
      double denMin = ConvertToDouble(denominator.Min);
      double denMax = ConvertToDouble(denominator.Max);

      return (nomMax - nomMin) / (denMax - denMin);
    }

    Transform additionalLabelTransform = null;
    private void DoDrawMajorLabels()
    {
      ITicksProvider<T> majorTicksProvider = ticksProvider.MajorProvider;
      additionalLabelsCanvas.Children.Clear();

      if (majorTicksProvider != null && majorLabelProvider != null)
      {
        additionalLabelsCanvas.Visibility = Visibility.Visible;

        Size renderSize = RenderSize;
        var majorTicks = majorTicksProvider.GetTicks(range, DefaultTicksProvider.DefaultTicksCount);

        double[] screenCoords = majorTicks.Ticks.Select(tick => createDataPoint(convertToDouble(tick))).
          Select(p => p.DataToScreen(transform)).Select(p => getCoordinate(p)).ToArray();

        // todo this is not the best decision - when displaying, for example,
        // milliseconds, it causes to create hundreds and thousands of textBlocks.
        double rangesRatio = GetRangesRatio(majorTicks.Ticks.GetPairs().ToArray()[0], range);

        object info = majorTicks.Info;
        MajorLabelsInfo newInfo = new MajorLabelsInfo
        {
          Info = info,
          MajorLabelsCount = (int)Math.Ceiling(rangesRatio)
        };

        var newMajorTicks = new TicksInfo<T>
        {
          Info = newInfo,
          Ticks = majorTicks.Ticks,
          TickSizes = majorTicks.TickSizes
        };

        UIElement[] additionalLabels = MajorLabelProvider.CreateLabels(newMajorTicks);

        for (int i = 0; i < additionalLabels.Length; i++)
        {
          if (screenCoords[i].IsNaN())
            continue;

          UIElement tickLabel = additionalLabels[i];

          tickLabel.Measure(renderSize);

          StackCanvas.SetCoordinate(tickLabel, screenCoords[i]);
          StackCanvas.SetEndCoordinate(tickLabel, screenCoords[i + 1]);

          if (tickLabel is FrameworkElement)
            ((FrameworkElement)tickLabel).LayoutTransform = additionalLabelTransform;

          additionalLabelsCanvas.Children.Add(tickLabel);
        }
      }
      else
      {
        additionalLabelsCanvas.Visibility = Visibility.Collapsed;
      }
    }

    private int prevMinorTicksCount = DefaultTicksProvider.DefaultTicksCount;
    private const int maxTickArrangeIterations = 12;
    private void DoDrawMinorTicks(ICollection<Geometry> lines)
    {
      ITicksProvider<T> minorTicksProvider = ticksProvider.MinorProvider;
      if (minorTicksProvider != null)
      {
        int minorTicksCount = prevMinorTicksCount;
        int prevActualTicksCount = -1;
        ITicksInfo<T> minorTicks;
        TickCountChange result = TickCountChange.OK;
        TickCountChange prevResult;
        int iteration = 0;
        do
        {
          Verify.IsTrue(++iteration < maxTickArrangeIterations);

          minorTicks = minorTicksProvider.GetTicks(range, minorTicksCount);

          prevActualTicksCount = minorTicks.Ticks.Length;
          prevResult = result;
          result = CheckMinorTicksArrangement(minorTicks);
          if (prevResult == TickCountChange.Decrease && result == TickCountChange.Increase)
          {
            // stop tick number oscillating
            result = TickCountChange.OK;
          }
          if (result == TickCountChange.Decrease)
          {
            int newMinorTicksCount = minorTicksProvider.DecreaseTickCount(minorTicksCount);
            if (newMinorTicksCount == minorTicksCount)
            {
              result = TickCountChange.OK;
            }
            minorTicksCount = newMinorTicksCount;
          }
          else if (result == TickCountChange.Increase)
          {
            int newCount = minorTicksProvider.IncreaseTickCount(minorTicksCount);
            if (newCount == minorTicksCount)
            {
              result = TickCountChange.OK;
            }
            minorTicksCount = newCount;
          }

        } while (result != TickCountChange.OK);
        prevMinorTicksCount = minorTicksCount;

        double[] sizes = minorTicks.TickSizes;

        double[] screenCoords = minorTicks.Ticks.Select(
          coord => getCoordinate(createDataPoint(convertToDouble(coord)).
            DataToScreen(transform))).ToArray();

        minorScreenTicks = new MinorTickInfo<double>[screenCoords.Length];
        for (int i = 0; i < screenCoords.Length; i++)
        {
          minorScreenTicks[i] = new MinorTickInfo<double>(sizes[i], screenCoords[i]);
        }

        for (int i = 0; i < screenCoords.Length; i++)
        {
          double screenCoord = screenCoords[i];

          Point p1 = createScreenPoint1(screenCoord);
          Point p2 = createScreenPoint2(screenCoord, sizes[i]);

          LineGeometry line = lineGeomPool.GetOrCreate();
          line.StartPoint = p1;
          line.EndPoint = p2;

          lines.Add(line);
        }
      }
    }

    private TickCountChange CheckMinorTicksArrangement(ITicksInfo<T> minorTicks)
    {
      Size renderSize = RenderSize;
      TickCountChange result = TickCountChange.OK;
      if (minorTicks.Ticks.Length * 3 > getSize(renderSize))
        result = TickCountChange.Decrease;
      else if (minorTicks.Ticks.Length * 6 < getSize(renderSize))
        result = TickCountChange.Increase;
      return result;
    }

    private bool isStaticAxis = false;
    /// <summary>
    /// Gets or sets a value indicating whether this instance is a static axis.
    /// If axis is static, its labels from sides are shifted so that they are not clipped by axis bounds.
    /// </summary>
    /// <value>
    ///   <c>true</c> if this instance is static axis; otherwise, <c>false</c>.
    /// </value>
    public bool IsStaticAxis
    {
      get { return isStaticAxis; }
      set
      {
        if (isStaticAxis != value)
        {
          isStaticAxis = value;
          UpdateUI();
        }
      }
    }

    private double ToScreen(T value)
    {
      return getCoordinate(createDataPoint(convertToDouble(value)).DataToScreen(transform));
    }

    private double staticAxisMargin = 1; // px

    private void DoDrawCommonLabels(double[] screenTicksX)
    {
      Size renderSize = RenderSize;

      commonLabelsCanvas.Children.Clear();

#if DEBUG
      if (labels != null)
      {
        foreach (FrameworkElement item in labels)
        {
          if (item != null)
            Debug.Assert(item.Parent == null);
        }
      }
#endif

      double minCoordUnsorted = ToScreen(range.Min);
      double maxCoordUnsorted = ToScreen(range.Max);

      double minCoord = Math.Min(minCoordUnsorted, maxCoordUnsorted);
      double maxCoord = Math.Max(minCoordUnsorted, maxCoordUnsorted);

      double maxCoordDiff = (maxCoord - minCoord) / labels.Length / 2.0;

      double minCoordToAdd = minCoord - maxCoordDiff;
      double maxCoordToAdd = maxCoord + maxCoordDiff;

      for (int i = 0; i < ticks.Length; i++)
      {
        FrameworkElement tickLabel = (FrameworkElement)labels[i];
        if (tickLabel == null) continue;

        Debug.Assert(((FrameworkElement)tickLabel).Parent == null);

        tickLabel.Measure(new Size(Double.PositiveInfinity, Double.PositiveInfinity));

        double screenX = screenTicksX[i];
        double coord = screenX;

        tickLabel.HorizontalAlignment = HorizontalAlignment.Center;
        tickLabel.VerticalAlignment = VerticalAlignment.Center;

        if (isStaticAxis)
        {
          // getting real size of label
          tickLabel.Measure(renderSize);
          Size tickLabelSize = tickLabel.DesiredSize;

          if (Math.Abs(screenX - minCoord) < maxCoordDiff)
          {
            coord = minCoord + staticAxisMargin;
            if (placement.IsBottomOrTop())
              tickLabel.HorizontalAlignment = HorizontalAlignment.Left;
            else
              tickLabel.VerticalAlignment = VerticalAlignment.Top;
          }
          else if (Math.Abs(screenX - maxCoord) < maxCoordDiff)
          {
            coord = maxCoord - getSize(tickLabelSize) / 2 - staticAxisMargin;
            if (!placement.IsBottomOrTop())
            {
              tickLabel.VerticalAlignment = VerticalAlignment.Bottom;
              coord = maxCoord - staticAxisMargin;
            }
          }
        }

        // label is out of visible area
        if (coord < minCoord || coord > maxCoord)
        {
          // todo investigate
          //continue;
        }

        if (coord.IsNaN())
          continue;

        StackCanvas.SetCoordinate(tickLabel, coord);

        commonLabelsCanvas.Children.Add(tickLabel);
      }
    }

    private double GetCoordinateFromTick(T tick)
    {
      return getCoordinate(createDataPoint(convertToDouble(tick)).DataToScreen(transform));
    }

    private Func<T, double> convertToDouble;
    /// <summary>
    /// Gets or sets the convertion of tick to double.
    /// Should not be null.
    /// </summary>
    /// <value>The convert to double.</value>
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public Func<T, double> ConvertToDouble
    {
      get { return convertToDouble; }
      set
      {
        if (value == null)
          throw new ArgumentNullException("value");

        convertToDouble = value;
        UpdateUI();
      }
    }

    private Func<double, T> convertFromDouble;
    /// <summary>
    /// Convertation function for use in smooth axes panning.
    /// Converts from axis value to double.
    /// </summary>
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public Func<double, T> ConvertFromDouble
    {
      get { return convertFromDouble; }
      set
      {
        if (value == null)
          throw new ArgumentNullException("value");

        convertFromDouble = value;
        UpdateUI();
      }
    }

    internal event EventHandler ScreenTicksChanged;
    private double[] screenTicks;
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    [EditorBrowsable(EditorBrowsableState.Never)]
    public double[] ScreenTicks
    {
      get { return screenTicks; }
    }

    private MinorTickInfo<double>[] minorScreenTicks;
    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    [EditorBrowsable(EditorBrowsableState.Never)]
    public MinorTickInfo<double>[] MinorScreenTicks
    {
      get { return minorScreenTicks; }
    }

    ITicksInfo<T> ticksInfo;
    private T[] ticks;
    private UIElement[] labels;
    private const double increaseRatio = 3.0;
    private const double decreaseRatio = 1.6;

    private Func<Size, double> getSize = size => size.Width;
    private Func<Point, double> getCoordinate = p => p.X;
    private Func<double, Point> createDataPoint = d => new Point(d, 0);

    private Func<double, Point> createScreenPoint1 = d => new Point(d, 0);
    private Func<double, double, Point> createScreenPoint2 = (d, size) => new Point(d, size);

    private int previousTickCount = DefaultTicksProvider.DefaultTicksCount;
    private void CreateTicks(Range<T> range)
    {
      TickCountChange result = TickCountChange.OK;
      TickCountChange prevResult;

      int prevActualTickCount = -1;

      int tickCount = previousTickCount;
      int iteration = 0;

      do
      {
        Verify.IsTrue(++iteration < maxTickArrangeIterations);

        ticksInfo = ticksProvider.GetTicks(range, tickCount);
        ticks = ticksInfo.Ticks;

        if (ticks.Length == prevActualTickCount)
        {
          result = TickCountChange.OK;
          break;
        }

        prevActualTickCount = ticks.Length;

        if (labels != null)
        {
          for (int i = 0; i < labels.Length; i++)
          {
            labelProvider.ReleaseLabel(labels[i]);
          }
        }

        labels = labelProvider.CreateLabels(ticksInfo);

        prevResult = result;
        result = CheckLabelsArrangement(labels, ticks);

        if (prevResult == TickCountChange.Decrease && result == TickCountChange.Increase)
        {
          // stop tick number oscillating
          result = TickCountChange.OK;
        }

        if (result != TickCountChange.OK)
        {
          int prevTickCount = tickCount;
          if (result == TickCountChange.Decrease)
            tickCount = ticksProvider.DecreaseTickCount(tickCount);
          else
          {
            tickCount = ticksProvider.IncreaseTickCount(tickCount);
            //DebugVerify.Is(tickCount >= prevTickCount);
          }

          // ticks provider could not create less ticks or tick number didn't change
          if (tickCount == 0 || prevTickCount == tickCount)
          {
            tickCount = prevTickCount;
            result = TickCountChange.OK;
          }
        }
      } while (result != TickCountChange.OK);

      previousTickCount = tickCount;
    }

    private TickCountChange CheckLabelsArrangement(UIElement[] labels, T[] ticks)
    {
      var actualLabels = labels.Select((label, i) => new { Label = label, Index = i })
        .Where(el => el.Label != null)
        .Select(el => new { Label = el.Label, Tick = ticks[el.Index] })
        .ToList();

      actualLabels.ForEach(item => item.Label.Measure(RenderSize));

      var sizeInfos = actualLabels.Select(item =>
        new { X = GetCoordinateFromTick(item.Tick), Size = getSize(item.Label.DesiredSize) })
        .OrderBy(item => item.X).ToArray();

      TickCountChange res = TickCountChange.OK;

      int increaseCount = 0;
      for (int i = 0; i < sizeInfos.Length - 1; i++)
      {
        if ((sizeInfos[i].X + sizeInfos[i].Size * decreaseRatio) > sizeInfos[i + 1].X)
        {
          res = TickCountChange.Decrease;
          break;
        }
        if ((sizeInfos[i].X + sizeInfos[i].Size * increaseRatio) < sizeInfos[i + 1].X)
        {
          increaseCount++;
        }
      }
      if (increaseCount > sizeInfos.Length / 2)
        res = TickCountChange.Increase;

      return res;
    }
  }

  [DebuggerDisplay("{X} + {Size}")]
  internal sealed class SizeInfo : IComparable<SizeInfo>
  {
    public double Size { get; set; }
    public double X { get; set; }


    public int CompareTo(SizeInfo other)
    {
      return X.CompareTo(other.X);
    }
  }

  internal enum TickCountChange
  {
    Increase = -1,
    OK = 0,
    Decrease = 1
  }

  /// <summary>
  /// Represents an auxiliary structure for storing additional info during major DateTime labels generation.
  /// </summary>
  public struct MajorLabelsInfo
  {
    public object Info { get; set; }
    public int MajorLabelsCount { get; set; }

    public override string ToString()
    {
      return String.Format("{0}, Count={1}", Info, MajorLabelsCount);
    }
  }
}