WPF的悬停工具栏实现方案

解决方法：参照ToolTip控件实现一个功能更为强大的ToolTip（命名为RichToolTip）

1、目标：仿照Word2007的悬停工具栏，如下图实现上下文工具栏。

2、虽然ToolTip的控件模板可以定义为包含可交互操作的控件（如Button,TextBox等），然而却无法接受焦点（鼠标移到ToolTip上内容立即就消失），所以无法用此办法实现；

3、使用方法与ToolTipService类似，参见如下代码：

<TextBox x:Name="_txtWords" BorderThickness="1" BorderBrush="Black" Margin="5">
    <controls:RichToolTip.PopupContent>
        <controls:RichToolTip
                PlacementTarget="{Binding RelativeSource={RelativeSource Self}, Path=RelatedObject}"
                Placement="MousePoint" 
                HorizontalOffset="0"
                VerticalOffset="0">
            <Border BorderBrush="Black" BorderThickness="1" Margin="5" Background="DarkKhaki">
                <utils:HoverOverToolBarView />
            </Border>
        </controls:RichToolTip>
    </controls:RichToolTip.PopupContent>
</TextBox>

4、应用效果如下所见：

 5、代码实现：

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using System.Windows.Threading;
using System.Runtime.InteropServices;
using System.Windows.Interop;
using System.Reflection;
using System.Diagnostics;
using System.Security;
using System.Security.Permissions;
using System.Windows.Navigation;
using System.Windows.Media.Animation;

namespace JetSun.Presentation.Controls
{
    /// <summary>
    /// A kind-of Tooltip implementation that stays open once element is hovered and the content inside is responsive
    /// 
    /// It corresponds to most of the TooltipService attached properties so use them as you wish
    /// Known Issues:
    /// 1 - I didn't have the time nor the strength to care about repositioning. I simply hide the popup whenever it would need repositioning. (Window movement, etc..) But it's ok since it's the default behavior of popup overall.
    /// 2 - XBap mode sets transparency through a hack! supported only in full trust.
    /// 3 - In XBap mode, moving the mouse slowly towards the popup will cause it to hide
    /// 4 - In XBap mode, moving the mouse over the element shows the tooltip even when the browser isn't the active window
    /// </summary>
    /// 
    public partial class RichToolTip : ContentControl
    {
        #region Fields
        const int _animationDurationInMs = 200;
        const int _showDeferredMilliseconds = 500;
        const bool _animationEnabledDefault = true;

        delegate void Action();
        Popup _parentPopup;

        static RichToolTip _lastShownPopup = null;
        #endregion

        #region Properties
        UIElement _relatedObject;
        /// <summary>
        /// 关联控件
        /// </summary>
        public UIElement RelatedObject
        {
            get { return _relatedObject; }
        }

        private bool _enableAnimation = _animationEnabledDefault;
        /// <summary>
        /// 是否显示动画
        /// </summary>
        public bool EnableAnimation
        {
            get { return _enableAnimation; }
            set { _enableAnimation = value; }
        }
        #endregion

        #region Instancing
        static RichToolTip()
        {
            EventManager.RegisterClassHandler(typeof(UIElement), UIElement.MouseDownEvent, new MouseButtonEventHandler(OnElementMouseDown), true);
            EventManager.RegisterClassHandler(typeof(RichToolTip), ButtonBase.ClickEvent, new RoutedEventHandler(OnButtonBaseClick), false);
            EventManager.RegisterClassHandler(typeof(Selector), Selector.SelectionChangedEvent, new SelectionChangedEventHandler(selector_SelectionChangedEvent), true);

            if (BrowserInteropHelper.IsBrowserHosted)
            {
                EventManager.RegisterClassHandler(typeof(NavigationWindow), UIElement.MouseLeaveEvent, new RoutedEventHandler(OnNavigationWindowMouseLeaveEvent), true);
            }
            else
            {
                EventManager.RegisterClassHandler(typeof(Window), Window.SizeChangedEvent, new RoutedEventHandler(OnWindowSizeChanged), true);
            }

            CommandManager.RegisterClassCommandBinding(typeof(RichToolTip), new CommandBinding(CloseCommand, ExecuteCloseCommand));
            InitStoryboards();
        }
        /// <summary>
        /// 
        /// </summary>
        public RichToolTip()
        {
            Loaded += new RoutedEventHandler(ContentTooltip_Loaded);
            Unloaded += new RoutedEventHandler(ContentTooltip_Unloaded);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="relatedObject"></param>
        public RichToolTip(UIElement relatedObject)
            : this()
        {
            Load(relatedObject);
        }
        #endregion

        #region Loading
        void Load(UIElement relatedObject)
        {
            _relatedObject = relatedObject;

            FrameworkElement fe = relatedObject as FrameworkElement;

            if (fe == null)
            {
                throw new InvalidOperationException("The element is not supported");
            }

            _relatedObject.MouseEnter += element_MouseEnter;
            _relatedObject.MouseLeave += element_MouseLeave;

            fe.Unloaded += new RoutedEventHandler(RelatedObject_Unloaded);

            BindRootVisual();

            this.MouseLeave += new MouseEventHandler(RichToolTip_MouseLeave);
        }

        void RichToolTip_MouseLeave(object sender, MouseEventArgs e)
        {
            if (IsShown() && this == _lastShownPopup)
            {
                Hide(true);
            }
        }

        void RelatedObject_Unloaded(object sender, RoutedEventArgs e)
        {
            _relatedObject.MouseEnter -= element_MouseEnter;
            _relatedObject.MouseLeave -= element_MouseLeave;
        }

        void ContentTooltip_Unloaded(object sender, RoutedEventArgs e)
        {
            UnbindRootVisual();
        }

        void ContentTooltip_Loaded(object sender, RoutedEventArgs e)
        {
            BindRootVisual();
        }
        #endregion

        #region Popup Creation
        private static readonly Type PopupType = typeof(Popup);
        private static readonly Type PopupSecurityHelperType = PopupType.GetNestedType("PopupSecurityHelper", BindingFlags.Public | BindingFlags.NonPublic);

        private static readonly FieldInfo Popup_secHelper = PopupType.GetField("_secHelper", BindingFlags.Instance | BindingFlags.NonPublic);
        private static readonly FieldInfo PopupSecurityHelper_isChildPopupInitialized = PopupSecurityHelperType.GetField("_isChildPopupInitialized", BindingFlags.Instance | BindingFlags.NonPublic);
        private static readonly FieldInfo PopupSecurityHelper_isChildPopup = PopupSecurityHelperType.GetField("_isChildPopup", BindingFlags.Instance | BindingFlags.NonPublic);

        void HookupParentPopup()
        {
            _parentPopup = new Popup();

            if (BrowserInteropHelper.IsBrowserHosted)
            {
                try
                {
                    new ReflectionPermission(PermissionState.Unrestricted).Demand();

                    DoPopupHacks();
                }
                catch (SecurityException) { }
            }

            _parentPopup.AllowsTransparency = true;
            Popup.CreateRootPopup(_parentPopup, this);
        }

        void DoPopupHacks()
        {
            object secHelper = Popup_secHelper.GetValue(_parentPopup);
            PopupSecurityHelper_isChildPopupInitialized.SetValue(secHelper, true);
            PopupSecurityHelper_isChildPopup.SetValue(secHelper, false);
        }
        #endregion

        #region Commands
        /// <summary>
        /// 
        /// </summary>
        public static RoutedCommand CloseCommand = new RoutedCommand("Close", typeof(RichToolTip));
        static void ExecuteCloseCommand(object sender, ExecutedRoutedEventArgs e)
        {
            HideLastShown(true);
        }
        #endregion

        #region Dependency Properties
        /// <summary>
        /// 
        /// </summary>
        public static readonly DependencyProperty PlacementProperty = ToolTipService.PlacementProperty.AddOwner(typeof(RichToolTip));
        /// <summary>
        /// 
        /// </summary>
        public PlacementMode Placement
        {
            get { return (PlacementMode)GetValue(PlacementProperty); }
            set { SetValue(PlacementProperty, value); }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static PlacementMode GetPlacement(DependencyObject obj)
        {
            return (PlacementMode)obj.GetValue(PlacementProperty);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="value"></param>
        public static void SetPlacement(DependencyObject obj, PlacementMode value)
        {
            obj.SetValue(PlacementProperty, value);
        }
        /// <summary>
        /// 
        /// </summary>
        public static readonly DependencyProperty PlacementTargetProperty = ToolTipService.PlacementTargetProperty.AddOwner(typeof(RichToolTip));
        /// <summary>
        /// 
        /// </summary>
        public UIElement PlacementTarget
        {
            get { return (UIElement)GetValue(PlacementTargetProperty); }
            set { SetValue(PlacementTargetProperty, value); }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static UIElement GetPlacementTarget(DependencyObject obj)
        {
            return (UIElement)obj.GetValue(PlacementTargetProperty);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="value"></param>
        public static void SetPlacementTarget(DependencyObject obj, UIElement value)
        {
            obj.SetValue(PlacementTargetProperty, value);
        }
        /// <summary>
        /// 
        /// </summary>
        public static readonly DependencyProperty PlacementRectangleProperty = ToolTipService.PlacementRectangleProperty.AddOwner(typeof(RichToolTip));
        /// <summary>
        /// 
        /// </summary>
        public Rect PlacementRectangle
        {
            get { return (Rect)GetValue(PlacementRectangleProperty); }
            set { SetValue(PlacementRectangleProperty, value); }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static Rect GetPlacementRectangle(DependencyObject obj)
        {
            return (Rect)obj.GetValue(PlacementRectangleProperty);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="value"></param>
        public static void SetPlacementRectangle(DependencyObject obj, Rect value)
        {
            obj.SetValue(PlacementRectangleProperty, value);
        }
        /// <summary>
        /// 
        /// </summary>
        public static readonly DependencyProperty HorizontalOffsetProperty = ToolTipService.HorizontalOffsetProperty.AddOwner(typeof(RichToolTip));
        /// <summary>
        /// 
        /// </summary>
        public double HorizontalOffset
        {
            get { return (double)GetValue(HorizontalOffsetProperty); }
            set { SetValue(HorizontalOffsetProperty, value); }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static double GetHorizontalOffset(DependencyObject obj)
        {
            return (double)obj.GetValue(HorizontalOffsetProperty);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="value"></param>
        public static void SetHorizontalOffset(DependencyObject obj, double value)
        {
            obj.SetValue(HorizontalOffsetProperty, value);
        }
        /// <summary>
        /// 
        /// </summary>
        public static readonly DependencyProperty VerticalOffsetProperty = ToolTipService.VerticalOffsetProperty.AddOwner(typeof(RichToolTip));
        /// <summary>
        /// 
        /// </summary>
        public double VerticalOffset
        {
            get { return (double)GetValue(VerticalOffsetProperty); }
            set { SetValue(VerticalOffsetProperty, value); }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static double GetVerticalOffset(DependencyObject obj)
        {
            return (double)obj.GetValue(VerticalOffsetProperty);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="value"></param>
        public static void SetVerticalOffset(DependencyObject obj, double value)
        {
            obj.SetValue(VerticalOffsetProperty, value);
        }
        /// <summary>
        /// 
        /// </summary>
        public static readonly DependencyProperty IsOpenProperty =
                Popup.IsOpenProperty.AddOwner(typeof(RichToolTip), new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, new PropertyChangedCallback(OnIsOpenChanged)));
        /// <summary>
        /// 
        /// </summary>
        public bool IsOpen
        {
            get { return (bool)GetValue(IsOpenProperty); }
            set { SetValue(IsOpenProperty, value); }
        }

        private static void OnIsOpenChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            RichToolTip ctrl = (RichToolTip)d;

            if ((bool)e.NewValue)
            {
                if (ctrl._parentPopup == null)
                {
                    ctrl.HookupParentPopup();
                }
            }
        }

        #endregion

        #region Attached Properties

        #region HideOnClick
        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static bool GetHideOnClick(DependencyObject obj)
        {
            return (bool)obj.GetValue(HideOnClickProperty);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="value"></param>
        public static void SetHideOnClick(DependencyObject obj, bool value)
        {
            obj.SetValue(HideOnClickProperty, value);
        }
        /// <summary>
        /// 
        /// </summary>
        public static readonly DependencyProperty HideOnClickProperty =
            DependencyProperty.RegisterAttached("HideOnClick", typeof(bool), typeof(RichToolTip), new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.Inherits));
        #endregion

        #region PopupContent
        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static object GetPopupContent(DependencyObject obj)
        {
            return obj.GetValue(PopupContentProperty);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="value"></param>
        public static void SetPopupContent(DependencyObject obj, object value)
        {
            obj.SetValue(PopupContentProperty, value);
        }
        /// <summary>
        /// 
        /// </summary>
        public static readonly DependencyProperty PopupContentProperty =
            DependencyProperty.RegisterAttached("PopupContent", typeof(object), typeof(RichToolTip), new FrameworkPropertyMetadata(OnPopupContentChanged));

        private static void OnPopupContentChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
        {
            UIElement element = o as UIElement;
            if (element == null)
            {
                throw new InvalidOperationException("Can't hook to events other than UI Element");
            }

            if (e.NewValue != null)
            {
                RichToolTip popup = e.NewValue as RichToolTip;

                if (popup != null)
                {
                    popup.Load(element);
                }
                else
                {
                    popup = new RichToolTip(element);

                    Binding binding = new Binding
                    {
                        Path = new PropertyPath(PopupContentProperty),
                        Mode = BindingMode.OneWay,
                        Source = o,
                    };
                    popup.SetBinding(ContentProperty, binding);
                }

                SetContentTooltipWrapper(o, popup);
            }
        }
        #endregion

        #region ContentTooltipWrapper
        internal static RichToolTip GetContentTooltipWrapper(DependencyObject obj)
        {
            return (RichToolTip)obj.GetValue(ContentTooltipWrapperProperty);
        }

        internal static void SetContentTooltipWrapper(DependencyObject obj, RichToolTip value)
        {
            obj.SetValue(ContentTooltipWrapperProperty, value);
        }

        internal static readonly DependencyProperty ContentTooltipWrapperProperty =
            DependencyProperty.RegisterAttached("ContentTooltipWrapper", typeof(RichToolTip), typeof(RichToolTip));
        #endregion

        #endregion

        #region Root Visual Binding
        bool _boundToRoot = false;
        bool _hasParentWindow = false;
        Window _parentWindow = null;

        void BindRootVisual()
        {
            if (!_boundToRoot)
            {
                if (!BrowserInteropHelper.IsBrowserHosted)
                {
                    _parentWindow = UIHelpers.FindLogicalAncestorByType<Window>(_relatedObject)
                        ?? UIHelpers.FindVisualAncestorByType<Window>(_relatedObject);

                    if (_parentWindow != null)
                    {
                        _hasParentWindow = true;

                        _parentWindow.Deactivated += window_Deactivated;
                        _parentWindow.LocationChanged += window_LocationChanged;
                    }
                }

                _boundToRoot = true;
            }
        }

        void UnbindRootVisual()
        {
            if (_boundToRoot)
            {
                if (_parentWindow != null)
                {
                    _parentWindow.Deactivated -= window_Deactivated;
                    _parentWindow.LocationChanged -= window_LocationChanged;
                }

                _boundToRoot = false;
            }
        }
        #endregion

        #region Animations & Intervals
        static DispatcherTimer _timer;
        static Storyboard _showStoryboard;
        static Storyboard _hideStoryboard;
        bool setRenderTransform;

        static void InitStoryboards()
        {
            _showStoryboard = new Storyboard();
            _hideStoryboard = new Storyboard();

            TimeSpan duration = TimeSpan.FromMilliseconds(_animationDurationInMs);

            DoubleAnimation animation = new DoubleAnimation(1, duration, FillBehavior.Stop);
            Storyboard.SetTargetProperty(animation, new PropertyPath(UIElement.OpacityProperty));
            _showStoryboard.Children.Add(animation);

            animation = new DoubleAnimation(0.1, 1, duration, FillBehavior.Stop);
            Storyboard.SetTargetProperty(animation, new PropertyPath("(0).(1)", FrameworkElement.RenderTransformProperty, ScaleTransform.ScaleXProperty));
            _showStoryboard.Children.Add(animation);

            animation = new DoubleAnimation(0.1, 1, duration, FillBehavior.Stop);
            Storyboard.SetTargetProperty(animation, new PropertyPath("(0).(1)", FrameworkElement.RenderTransformProperty, ScaleTransform.ScaleYProperty));
            _showStoryboard.Children.Add(animation);

            animation = new DoubleAnimation(0, duration, FillBehavior.Stop);
            Storyboard.SetTargetProperty(animation, new PropertyPath(UIElement.OpacityProperty));
            _hideStoryboard.Children.Add(animation);

            _hideStoryboard.Completed += delegate { OnAnimationCompleted(); };
        }

        static void InitTimer()

        {
            _timer = new DispatcherTimer();
            _timer.Interval = TimeSpan.FromMilliseconds(_showDeferredMilliseconds);
        }

        static void ResetTimer(RichToolTip tooltip)
        {
            if (_timer != null)
            {
                _timer.Tick -= tooltip.ShowDeferred;
                _timer.Stop();
            }
        }

        void Animate(bool show)
        {
            if (show)
            {
                if (!setRenderTransform)
                {
                    RenderTransform = new ScaleTransform();

                    setRenderTransform = true;
                }

                _showStoryboard.Begin(this);
            }
            else
            {
                _hideStoryboard.Begin(this);
            }
        }

        static void OnAnimationCompleted()
        {
            HideLastShown(false);
        }
        #endregion

        #region Event Invocations
        void element_MouseEnter(object sender, MouseEventArgs e)
        {
            if (!IsShown() && this != _lastShownPopup)
            {
                if (!_hasParentWindow || _parentWindow.IsActive)
                {
                    Show(true);
                }
            }
        }

        void element_MouseLeave(object sender, MouseEventArgs e)
        {
            ResetTimer(this);

            if (IsShown() && this == _lastShownPopup)
            {
                Hide(true);
            }
        }

        static void OnNavigationWindowMouseLeaveEvent(object sender, RoutedEventArgs e)
        {
            Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Background,
            new Action(() =>
            {
                if (_lastShownPopup != null && !_lastShownPopup.IsMouseOver)
                {
                    HideLastShown(false);
                }
            }));
        }

        void window_LocationChanged(object sender, EventArgs e)
        {
            if (IsShown())
            {
                HideLastShown(false);
            }
        }

        void window_Deactivated(object sender, EventArgs e)
        {
            if (IsShown())
            {
                HideLastShown(false);
            }
        }

        static void OnWindowSizeChanged(object sender, RoutedEventArgs e)
        {
            HideLastShown();
        }

        static void OnElementMouseDown(object sender, MouseButtonEventArgs e)
        {
            if (_lastShownPopup != null && _lastShownPopup.IsShown())
            {
                RichToolTip popup;

                DependencyObject o = e.OriginalSource as DependencyObject;
                if (!TryFindPopupParent(e.OriginalSource, out popup))
                {
                    HideLastShown(true);
                }
            }
        }

        static void OnButtonBaseClick(object sender, RoutedEventArgs e)
        {
            if (_lastShownPopup != null && _lastShownPopup.IsShown())
            {
                DependencyObject o = e.OriginalSource as DependencyObject;

                bool hide = GetHideOnClick(o);
                if (hide)
                {
                    HideLastShown(true);

                    e.Handled = true;
                }
            }
        }

        static void selector_SelectionChangedEvent(object sender, SelectionChangedEventArgs e)
        {
            HideLastShown();
        }

        static bool TryFindPopupParent(object source, out RichToolTip popup)
        {
            popup = null;
            UIElement element = source as UIElement;

            if (element != null)
            {
                popup = UIHelpers.FindVisualAncestorByType<RichToolTip>(element);

                if (popup == null)
                {
                    popup = UIHelpers.FindLogicalAncestorByType<RichToolTip>(element);
                }

                return popup != null;
            }

            return false;
        }
        #endregion

        #region Show / Hide
        bool _showAnimate = _animationEnabledDefault;

        bool IsShown()
        {
            return IsOpen;
        }

        public void Show(bool animate)
        {
            _showAnimate = animate;

            if (_timer == null)
            {
                InitTimer();
            }

            _timer.Tick += ShowDeferred;

            if (!_timer.IsEnabled)
            {
                _timer.Start();
            }
        }

        private void ShowDeferred(object sender, EventArgs e)
        {
            ResetTimer(this);

            HideLastShown(false);

            ShowInternal();

            if (_showAnimate && EnableAnimation)
            {
                Animate(true);
            }
            else
            {
                this.Opacity = 1;
            }

            _lastShownPopup = this;
        }

        private void ShowInternal()
        {
            Visibility = Visibility.Visible;

            IsOpen = true;
        }

        static void HideLastShown()
        {
            HideLastShown(false);
        }

        static void HideLastShown(bool animate)
        {
            if (_lastShownPopup != null)
            {
                _lastShownPopup.Hide(animate);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="animate"></param>
        public void Hide(bool animate)
        {
            Point pt = Mouse.GetPosition(this);
            if (pt.X >= 0 && pt.Y >= 0 && pt.X <= this.ActualWidth && pt.Y <= this.ActualHeight) return;

            if (animate && EnableAnimation)
            {
                Animate(false);
            }
            else
            {
                HideInternal();
            }
        }

        private void HideInternal()
        {
            this.Visibility = Visibility.Collapsed;
            this.IsOpen = false;

            _lastShownPopup = null;
        }

        #endregion
    }
}