source: branches/HeuristicLab.Problems.GrammaticalOptimization/DynamicDataDisplay/Charts/Axes/StackCanvas.cs @ 13749

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Controls;
using System.Windows;
using System.Windows.Media;
using System.Diagnostics;
using Microsoft.Research.DynamicDataDisplay.Common.Auxiliary;

namespace Microsoft.Research.DynamicDataDisplay.Charts
{
  public class StackCanvas : Panel
  {
    public StackCanvas()
    {
    }

    #region EndCoordinate attached property

    [AttachedPropertyBrowsableForChildren]
    public static double GetEndCoordinate(DependencyObject obj)
    {
      return (double)obj.GetValue(EndCoordinateProperty);
    }

    public static void SetEndCoordinate(DependencyObject obj, double value)
    {
      obj.SetValue(EndCoordinateProperty, value);
    }

    public static readonly DependencyProperty EndCoordinateProperty = DependencyProperty.RegisterAttached(
      "EndCoordinate",
      typeof(double),
      typeof(StackCanvas),
      new PropertyMetadata(Double.NaN, OnCoordinateChanged));

    #endregion

    #region Coordinate attached property

    [AttachedPropertyBrowsableForChildren]
    public static double GetCoordinate(DependencyObject obj)
    {
      return (double)obj.GetValue(CoordinateProperty);
    }

    public static void SetCoordinate(DependencyObject obj, double value)
    {
      obj.SetValue(CoordinateProperty, value);
    }

    public static readonly DependencyProperty CoordinateProperty = DependencyProperty.RegisterAttached(
      "Coordinate",
      typeof(double),
      typeof(StackCanvas),
      new PropertyMetadata(0.0, OnCoordinateChanged));

    private static void OnCoordinateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
      UIElement reference = d as UIElement;
      if (reference != null)
      {
        StackCanvas parent = VisualTreeHelper.GetParent(reference) as StackCanvas;
        if (parent != null)
        {
          parent.InvalidateArrange();
        }
      }
    }
    #endregion

    #region AxisPlacement property

    public AxisPlacement Placement
    {
      get { return (AxisPlacement)GetValue(PlacementProperty); }
      set { SetValue(PlacementProperty, value); }
    }

    public static readonly DependencyProperty PlacementProperty =
      DependencyProperty.Register(
        "Placement",
        typeof(AxisPlacement),
        typeof(StackCanvas),
        new FrameworkPropertyMetadata(
          AxisPlacement.Bottom,
          FrameworkPropertyMetadataOptions.AffectsArrange));

    #endregion

    private bool IsHorizontal
    {
      get { return Placement == AxisPlacement.Top || Placement == AxisPlacement.Bottom; }
    }

    protected override Size MeasureOverride(Size constraint)
    {
      Size availableSize = constraint;
      Size size = new Size();

      bool isHorizontal = IsHorizontal;

      if (isHorizontal)
      {
        availableSize.Width = Double.PositiveInfinity;
        size.Width = constraint.Width;
      }
      else
      {
        availableSize.Height = Double.PositiveInfinity;
        size.Height = constraint.Height;
      }

      // measuring all children and determining self width and height
      foreach (UIElement element in base.Children)
      {
        if (element != null)
        {
          Size childSize = GetChildSize(element, availableSize);
          element.Measure(childSize);
          Size desiredSize = element.DesiredSize;

          if (isHorizontal)
          {
            size.Height = Math.Max(size.Height, desiredSize.Height);
          }
          else
          {
            size.Width = Math.Max(size.Width, desiredSize.Width);
          }
        }
      }

      if (Double.IsPositiveInfinity(size.Width)) size.Width = 0;
      if (Double.IsPositiveInfinity(size.Height)) size.Height = 0;

      return size;
    }

    private Size GetChildSize(UIElement element, Size availableSize)
    {
      var coordinate = GetCoordinate(element);
      var endCoordinate = GetEndCoordinate(element);

      if (coordinate.IsNotNaN() && endCoordinate.IsNotNaN())
      {
        if (Placement.IsBottomOrTop())
        {
          availableSize.Width = Math.Abs(endCoordinate - coordinate);
        }
        else
        {
          availableSize.Height = Math.Abs(endCoordinate - coordinate);
        }
      }

      return availableSize;
    }

    protected override Size ArrangeOverride(Size finalSize)
    {
      bool isHorizontal = IsHorizontal;

      foreach (FrameworkElement element in base.Children)
      {
        if (element == null)
        {
          continue;
        }

        Size elementSize = element.DesiredSize;
        double x = 0.0;
        double y = 0.0;

        switch (Placement)
        {
          case AxisPlacement.Left:
            x = finalSize.Width - elementSize.Width;
            break;
          case AxisPlacement.Right:
            x = 0;
            break;
          case AxisPlacement.Top:
            y = finalSize.Height - elementSize.Height;
            break;
          case AxisPlacement.Bottom:
            y = 0;
            break;
          default:
            break;
        }

        double coordinate = GetCoordinate(element);

        if (!Double.IsNaN(GetEndCoordinate(element)))
        {
          double endCoordinate = GetEndCoordinate(element);
          double size = endCoordinate - coordinate;
          if (size < 0)
          {
            size = -size;
            coordinate -= size;
          }
          if (isHorizontal)
            elementSize.Width = size;
          else
            elementSize.Height = size;
        }


        // shift for common tick labels, not for major ones.
        if (isHorizontal)
        {
          x = coordinate;
          if (element.HorizontalAlignment == HorizontalAlignment.Center)
            x = coordinate - elementSize.Width / 2;
        }
        else
        {
          y = coordinate;
          if (element.VerticalAlignment == VerticalAlignment.Center)
            y = coordinate - elementSize.Height / 2;
          else if (element.VerticalAlignment == VerticalAlignment.Bottom)
            y = coordinate - elementSize.Height;
          else if (element.VerticalAlignment == VerticalAlignment.Top)
            y = coordinate;
        }

        Rect bounds = new Rect(new Point(x, y), elementSize);
        element.Arrange(bounds);
      }

      return finalSize;
    }
  }
}