source: branches/HeuristicLab.Problems.GrammaticalOptimization/DynamicDataDisplay/Charts/LiveTooltips/LiveTooltipService.cs @ 12503

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Input;
using System.Windows.Documents;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Data;
using System.ComponentModel;

namespace Microsoft.Research.DynamicDataDisplay.Charts
{
  public static class LiveToolTipService
  {

    # region Properties

    public static object GetToolTip(DependencyObject obj)
    {
      return (object)obj.GetValue(ToolTipProperty);
    }

    public static void SetToolTip(DependencyObject obj, object value)
    {
      obj.SetValue(ToolTipProperty, value);
    }

    public static readonly DependencyProperty ToolTipProperty = DependencyProperty.RegisterAttached(
      "ToolTip",
      typeof(object),
      typeof(LiveToolTipService),
      new FrameworkPropertyMetadata(null, OnToolTipChanged));

    private static LiveToolTip GetLiveToolTip(DependencyObject obj)
    {
      return (LiveToolTip)obj.GetValue(LiveToolTipProperty);
    }

    private static void SetLiveToolTip(DependencyObject obj, LiveToolTip value)
    {
      obj.SetValue(LiveToolTipProperty, value);
    }

    private static readonly DependencyProperty LiveToolTipProperty = DependencyProperty.RegisterAttached(
      "LiveToolTip",
      typeof(LiveToolTip),
      typeof(LiveToolTipService),
      new FrameworkPropertyMetadata(null));

    #region Opacity

    public static double GetTooltipOpacity(DependencyObject obj)
    {
      return (double)obj.GetValue(TooltipOpacityProperty);
    }

    public static void SetTooltipOpacity(DependencyObject obj, double value)
    {
      obj.SetValue(TooltipOpacityProperty, value);
    }

    public static readonly DependencyProperty TooltipOpacityProperty = DependencyProperty.RegisterAttached(
      "TooltipOpacity",
      typeof(double),
      typeof(LiveToolTipService),
      new FrameworkPropertyMetadata(1.0, OnTooltipOpacityChanged));

    private static void OnTooltipOpacityChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
      LiveToolTip liveTooltip = GetLiveToolTip(d);
      if (liveTooltip != null)
      {
        liveTooltip.Opacity = (double)e.NewValue;
      }
    }

    #endregion // end of Opacity

    #region IsPropertyProxy property

    public static bool GetIsPropertyProxy(DependencyObject obj)
    {
      return (bool)obj.GetValue(IsPropertyProxyProperty);
    }

    public static void SetIsPropertyProxy(DependencyObject obj, bool value)
    {
      obj.SetValue(IsPropertyProxyProperty, value);
    }

    public static readonly DependencyProperty IsPropertyProxyProperty = DependencyProperty.RegisterAttached(
      "IsPropertyProxy",
      typeof(bool),
      typeof(LiveToolTipService),
      new FrameworkPropertyMetadata(false));

    #endregion // end of IsPropertyProxy property

    #endregion

    private static void OnToolTipChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
      FrameworkElement source = (FrameworkElement)d;

      if (e.NewValue == null)
      {
        source.Loaded -= source_Loaded;
        source.ClearValue(LiveToolTipProperty);
      }

      if (GetIsPropertyProxy(source)) return;

      var content = e.NewValue;

      DataTemplate template = content as DataTemplate;
      if (template != null)
      {
        content = template.LoadContent();
      }

      LiveToolTip tooltip = null;
      if (e.NewValue is LiveToolTip)
      {
        tooltip = e.NewValue as LiveToolTip;
      }
      else
      {
        tooltip = new LiveToolTip { Content = content };
      }

      if (tooltip == null && e.OldValue == null)
      {
        tooltip = new LiveToolTip { Content = content };
      }

      if (tooltip != null)
      {
        SetLiveToolTip(source, tooltip);
        if (!source.IsLoaded)
        {
          source.Loaded += source_Loaded;
        }
        else
        {
          AddTooltip(source);
        }
      }
    }

    private static void AddTooltipForElement(FrameworkElement source, LiveToolTip tooltip)
    {
      AdornerLayer layer = AdornerLayer.GetAdornerLayer(source);

      LiveToolTipAdorner adorner = new LiveToolTipAdorner(source, tooltip);
      layer.Add(adorner);
    }

    private static void source_Loaded(object sender, RoutedEventArgs e)
    {
      FrameworkElement source = (FrameworkElement)sender;

      if (source.IsLoaded)
      {
        AddTooltip(source);
      }
    }

    private static void AddTooltip(FrameworkElement source)
    {
      if (DesignerProperties.GetIsInDesignMode(source)) return;

      LiveToolTip tooltip = GetLiveToolTip(source);

      Window window = Window.GetWindow(source);
      FrameworkElement child = source;
      FrameworkElement parent = null;
      if (window != null)
      {
        while (parent != window)
        {
          parent = (FrameworkElement)VisualTreeHelper.GetParent(child);
          child = parent;

          if (parent == null)
            return;

          var nameScope = NameScope.GetNameScope(parent);
          if (nameScope != null)
          {
            string nameScopeName = nameScope.ToString();
            if (nameScopeName != "System.Windows.TemplateNameScope")
            {
              NameScope.SetNameScope(tooltip, nameScope);
              break;
            }
          }
        }
      }

      var binding = BindingOperations.GetBinding(tooltip, LiveToolTip.ContentProperty);
      if (binding != null)
      {
        BindingOperations.ClearBinding(tooltip, LiveToolTip.ContentProperty);
        BindingOperations.SetBinding(tooltip, LiveToolTip.ContentProperty, binding);
      }

      Binding dataContextBinding = new Binding { Path = new PropertyPath("DataContext"), Source = source };
      tooltip.SetBinding(LiveToolTip.DataContextProperty, dataContextBinding);

      tooltip.Owner = source;
      if (GetTooltipOpacity(source) != (double)LiveToolTipService.TooltipOpacityProperty.DefaultMetadata.DefaultValue)
      {
        tooltip.Opacity = LiveToolTipService.GetTooltipOpacity(source);
      }

      AddTooltipForElement(source, tooltip);
    }
  }
}