source: branches/HeuristicLab.Problems.GrammaticalOptimization/DynamicDataDisplay/Charts/ViewportHostPanel.cs @ 13401

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

namespace Microsoft.Research.DynamicDataDisplay.Charts
{
  public class ViewportHostPanel : ViewportPanel, IPlotterElement
  {
    static ViewportHostPanel()
    {
      //EventManager.RegisterClassHandler(typeof(ViewportHostPanel), d3.Plotter.PlotterChangedEvent, new PlotterChangedEventHandler(OnPlotterChanged));
    }

    public ViewportHostPanel()
    {
#if false
      // for debug purposes
      Width = 100;
      Height = 100;
      Background = Brushes.PaleGreen.MakeTransparent(0.2);
#endif
    }

    private static void OnPlotterChanged(object sender, PlotterChangedEventArgs e)
    {
      ViewportHostPanel owner = (ViewportHostPanel)sender;

      if (owner.plotter != null && e.PreviousPlotter != null)
      {
        owner.viewport.PropertyChanged -= owner.Viewport_PropertyChanged;
        owner.viewport = null;
        owner.plotter = null;
      }
      if (owner.plotter == null && e.CurrentPlotter != null)
      {
        owner.plotter = (Plotter2D)e.CurrentPlotter;
        owner.viewport = owner.plotter.Viewport;
        owner.viewport.PropertyChanged += owner.Viewport_PropertyChanged;
      }
    }

    private Canvas hostingCanvas = new Canvas();
    internal Canvas HostingCanvas
    {
      get { return hostingCanvas; }
    }

    #region IPlotterElement Members

    private Plotter2D plotter;
    public Plotter2D Plotter
    {
      get { return plotter; }
    }

    Viewport2D viewport;
    public virtual void OnPlotterAttached(Plotter plotter)
    {
      this.plotter = (Plotter2D)plotter;
      viewport = this.plotter.Viewport;

      if (!IsMarkersHost)
      {
        plotter.CentralGrid.Children.Add(hostingCanvas);
      }
      if (Parent == null)
      {
        hostingCanvas.Children.Add(this);
      }
      this.plotter.Viewport.PropertyChanged += Viewport_PropertyChanged;
    }

    public virtual void OnPlotterDetaching(Plotter plotter)
    {
      this.plotter.Viewport.PropertyChanged -= Viewport_PropertyChanged;

      if (!IsMarkersHost)
      {
        plotter.CentralGrid.Children.Remove(hostingCanvas);
      }
      hostingCanvas.Children.Remove(this);

      this.plotter = null;
    }

    Plotter IPlotterElement.Plotter
    {
      get { return plotter; }
    }

    protected override void OnChildDesiredSizeChanged(UIElement child)
    {
      base.OnChildDesiredSizeChanged(child);
      InvalidatePosition((FrameworkElement)child);
    }

    Vector prevVisualOffset;
    bool sizeChanged = true;
    DataRect visibleWhileCreation;
    protected virtual void Viewport_PropertyChanged(object sender, ExtendedPropertyChangedEventArgs e)
    {
      if (e.PropertyName == Viewport2D.VisiblePropertyName)
      {
        DataRect visible = (DataRect)e.NewValue;
        DataRect prevVisible = (DataRect)e.OldValue;

        InvalidateMeasure();
        // todo previous way
//                if (prevVisible.Size.EqualsApproximately(visible.Size) && !sizeChanged)
//                {
//                    var transform = viewport.Transform;

//                    Point prevLocation = prevVisible.Location.ViewportToScreen(transform);
//                    Point location = visible.Location.ViewportToScreen(transform);

//                    Vector offset = prevLocation - location;
//                    // todo was true
//#if false
//                    translateTransform.X += offset.X;
//                    translateTransform.Y += offset.Y;
//#else
//                    InvalidateMeasure();
//#endif

//                }
//                else
//                {
//                    visibleWhileCreation = visible;
//                    translateTransform.X = 0;
//                    translateTransform.Y = 0;
//                    InvalidateMeasure();
//                }

        sizeChanged = false;
      }
      else if (e.PropertyName == "Output")
      {
        sizeChanged = true;
        InvalidateMeasure();
      }

      prevVisualOffset = VisualOffset;
    }

    #endregion

    protected internal override void OnChildAdded(FrameworkElement child)
    {
      if (plotter == null) return;

      InvalidatePosition(child);
      //Dispatcher.BeginInvoke(((Action)(()=> InvalidatePosition(child))), DispatcherPriority.ApplicationIdle);
    }

    private DataRect overallViewportBounds = DataRect.Empty;
    internal DataRect OverallViewportBounds
    {
      get { return overallViewportBounds; }
      set { overallViewportBounds = value; }
    }

    private BoundsUnionMode boundsUnionMode;
    internal BoundsUnionMode BoundsUnionMode
    {
      get { return boundsUnionMode; }
      set { boundsUnionMode = value; }
    }

    protected override void InvalidatePosition(FrameworkElement child)
    {
      invalidatePositionCalls++;

      if (viewport == null) return;
      if (child.Visibility != Visibility.Visible)
        return;

      var transform = viewport.Transform;

      Size elementSize = GetElementSize(child, AvailableSize, transform);
      child.Measure(elementSize);

      Rect bounds = GetElementScreenBounds(transform, child);
      child.Arrange(bounds);

      var viewportBounds = Viewport2D.GetContentBounds(this);
      if (!viewportBounds.IsEmpty)
        overallViewportBounds = viewportBounds;

      UniteWithBounds(transform, bounds);

      if (!InBatchAdd)
      {
        Viewport2D.SetContentBounds(this, overallViewportBounds);
        ContentBoundsChanged.Raise(this);
      }
    }

    private void UniteWithBounds(CoordinateTransform transform, Rect bounds)
    {
      var childViewportBounds = bounds.ScreenToViewport(transform);
      if (boundsUnionMode == BoundsUnionMode.Bounds)
        overallViewportBounds.Union(childViewportBounds);
      else
      {
        overallViewportBounds.Union(childViewportBounds.GetCenter());
      }
    }

    int invalidatePositionCalls = 0;
    public override void BeginBatchAdd()
    {
      base.BeginBatchAdd();
      invalidatePositionCalls = 0;
    }

    public override void EndBatchAdd()
    {
      base.EndBatchAdd();

      if (plotter == null) return;

      UpdateContentBounds(Children.Count > 0 && invalidatePositionCalls == 0);
    }

    public void UpdateContentBounds()
    {
      UpdateContentBounds(true);
    }

    private void UpdateContentBounds(bool recalculate)
    {
      if (recalculate)
      {
        var transform = plotter.Viewport.Transform;
        overallViewportBounds = DataRect.Empty;
        foreach (FrameworkElement child in Children)
        {
          if (child != null)
          {
            if (child.Visibility != Visibility.Visible)
              continue;

            Rect bounds = GetElementScreenBounds(transform, child);
            UniteWithBounds(transform, bounds);
          }
        }
      }

      Viewport2D.SetContentBounds(this, overallViewportBounds);
      ContentBoundsChanged.Raise(this);
    }

    protected override Size ArrangeOverride(Size finalSize)
    {
      if (plotter == null)
        return finalSize;

      var transform = plotter.Viewport.Transform;

      overallViewportBounds = DataRect.Empty;
      foreach (UIElement child in InternalChildren)
      {
        if (child != null)
        {
          if (child.Visibility != Visibility.Visible)
            continue;

          Rect bounds = GetElementScreenBounds(transform, child);
          child.Arrange(bounds);

          UniteWithBounds(transform, bounds);
        }
      }

      if (!InBatchAdd)
      {
        Viewport2D.SetContentBounds(this, overallViewportBounds);
        ContentBoundsChanged.Raise(this);
      }

      return finalSize;
    }

    public event EventHandler ContentBoundsChanged;

    protected override Size MeasureOverride(Size availableSize)
    {
      AvailableSize = availableSize;

      if (plotter == null)
      {
        if (availableSize.Width.IsInfinite() || availableSize.Height.IsInfinite())
          return new Size();
        return availableSize;
      }

      var transform = plotter.Viewport.Transform;

      foreach (FrameworkElement child in InternalChildren)
      {
        if (child != null)
        {
          Size elementSize = GetElementSize(child, availableSize, transform);
          child.Measure(elementSize);
        }
      }

      if (availableSize.Width.IsInfinite())
        availableSize.Width = 0;
      if (availableSize.Height.IsInfinite())
        availableSize.Height = 0;
      return availableSize;
    }
  }

  public enum BoundsUnionMode
  {
    Center,
    Bounds
  }
}