Code:
/ DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Framework / System / Windows / Controls / PopupControlService.cs / 2 / PopupControlService.cs
//----------------------------------------------------------------------------
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//---------------------------------------------------------------------------
using MS.Internal;
using MS.Internal.KnownBoxes;
using MS.Internal.Media;
using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Data;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Media3D;
using System.Windows.Markup;
using System.Windows.Threading;
using System.Security;
using System.Security.Permissions;
namespace System.Windows.Controls
{
///
/// Service class that provides the input for the ContextMenu and ToolTip services.
///
internal sealed class PopupControlService
{
#region Creation
///
/// Critical - this function elevates by accessing InputManger.Current.
/// TreatAsSafe: This code simply attaches a call back which is private
///
[SecurityCritical,SecurityTreatAsSafe]
internal PopupControlService()
{
InputManager.Current.PostProcessInput += new ProcessInputEventHandler(OnPostProcessInput);
}
#endregion
#region Input Handling
/////////////////////////////////////////////////////////////////////
///
/// Critical: accesses e.StagingItem.Input. Also this code revieves an event that has
/// user initiated set.
///
[SecurityCritical]
private void OnPostProcessInput(object sender, ProcessInputEventArgs e)
{
if (e.StagingItem.Input.RoutedEvent == InputManager.InputReportEvent)
{
InputReportEventArgs report = (InputReportEventArgs)e.StagingItem.Input;
if (!report.Handled)
{
if (report.Report.Type == InputType.Mouse)
{
RawMouseInputReport mouseReport = (RawMouseInputReport)report.Report;
if ((mouseReport.Actions & RawMouseActions.AbsoluteMove) == RawMouseActions.AbsoluteMove)
{
if ((Mouse.LeftButton == MouseButtonState.Pressed) ||
(Mouse.RightButton == MouseButtonState.Pressed))
{
RaiseToolTipClosingEvent(true /* reset */);
}
else
{
IInputElement directlyOver = Mouse.PrimaryDevice.RawDirectlyOver;
Point pt = Mouse.PrimaryDevice.GetPosition(directlyOver);
// If possible, check that the mouse position is within the render bounds
// (avoids mouse capture confusion).
if (WithinRenderBounds(directlyOver, pt))
{
OnMouseMove(directlyOver, pt);
}
}
}
else if ((mouseReport.Actions & RawMouseActions.Deactivate) == RawMouseActions.Deactivate)
{
if (LastMouseDirectlyOver != null)
{
LastMouseDirectlyOver = null;
if (LastMouseOverWithToolTip != null)
{
RaiseToolTipClosingEvent(true /* reset */);
// When the user moves the cursor outside of the window,
// clear the LastMouseOverWithToolTip property so if the user returns
// the mouse to the same item, the tooltip will reappear. If
// the deactivation is coming from a window grabbing capture
// (such as Drag and Drop) do not clear the property.
if (MS.Win32.SafeNativeMethods.GetCapture() == IntPtr.Zero)
{
LastMouseOverWithToolTip = null;
}
}
}
}
}
}
}
else if (e.StagingItem.Input.RoutedEvent == Keyboard.KeyDownEvent)
{
ProcessKeyDown(sender, (KeyEventArgs)e.StagingItem.Input);
}
else if (e.StagingItem.Input.RoutedEvent == Keyboard.KeyUpEvent)
{
ProcessKeyUp(sender, (KeyEventArgs)e.StagingItem.Input);
}
else if (e.StagingItem.Input.RoutedEvent == Mouse.MouseUpEvent)
{
ProcessMouseUp(sender, (MouseButtonEventArgs)e.StagingItem.Input);
}
else if (e.StagingItem.Input.RoutedEvent == Mouse.MouseDownEvent)
{
RaiseToolTipClosingEvent(true /* reset */);
}
}
private bool WithinRenderBounds(IInputElement directlyOver, Point pt)
{
// attempt to cast the DO to a UIElement or UIElement3D
UIElement directlyOverAsUIElement = directlyOver as UIElement;
UIElement3D directlyOverAsUIElement3D = (directlyOverAsUIElement == null) ? directlyOver as UIElement3D : null;
// in the case we can't tell we will return true
bool doesContainPoint = true;
if (directlyOverAsUIElement != null || directlyOverAsUIElement3D != null)
{
if (directlyOverAsUIElement != null)
{
Size comparisonSize = directlyOverAsUIElement.RenderSize;
doesContainPoint = ((pt.X >= 0) && (pt.X < comparisonSize.Width) &&
(pt.Y >= 0) && (pt.Y < comparisonSize.Height));
}
else
{
Rect comparisonRect = directlyOverAsUIElement3D.Visual2DContentBounds;
doesContainPoint = comparisonRect.Contains(pt);
}
}
return doesContainPoint;
}
private void OnMouseMove(IInputElement directlyOver, Point pt)
{
if (directlyOver != LastMouseDirectlyOver)
{
LastMouseDirectlyOver = directlyOver;
if (directlyOver != LastMouseOverWithToolTip)
{
InspectElementForToolTip(directlyOver as DependencyObject);
}
}
}
/////////////////////////////////////////////////////////////////////
///
/// Critical: This has the ability to spoof input for paste
///
[SecurityCritical]
private void ProcessMouseUp(object sender, MouseButtonEventArgs e)
{
RaiseToolTipClosingEvent(false /* reset */);
if (!e.Handled)
{
if ((e.ChangedButton == MouseButton.Right) &&
(e.RightButton == MouseButtonState.Released))
{
IInputElement directlyOver = Mouse.PrimaryDevice.RawDirectlyOver;
if (directlyOver != null)
{
Point pt = Mouse.PrimaryDevice.GetPosition(directlyOver);
if (RaiseContextMenuOpeningEvent(directlyOver, pt.X, pt.Y,e.UserInitiated))
{
e.Handled = true;
}
}
}
}
}
/////////////////////////////////////////////////////////////////////
///
/// Critical: This has the ability to spoof input for paste
///
[SecurityCritical]
private void ProcessKeyDown(object sender, KeyEventArgs e)
{
if (!e.Handled)
{
if ((e.SystemKey == Key.F10) && ((Keyboard.Modifiers & ModifierKeys.Shift) == ModifierKeys.Shift))
{
RaiseContextMenuOpeningEvent(e);
}
}
}
/////////////////////////////////////////////////////////////////////
///
/// Critical: This has the ability to spoof input for paste
///
[SecurityCritical]
private void ProcessKeyUp(object sender, KeyEventArgs e)
{
if (!e.Handled)
{
if (e.Key == Key.Apps)
{
RaiseContextMenuOpeningEvent(e);
}
}
}
#endregion
#region ToolTip
private void InspectElementForToolTip(DependencyObject o)
{
DependencyObject origObj = o;
if (LocateNearestToolTip(ref o))
{
// Show the ToolTip on "o" or keep the current ToolTip active
if (o != null)
{
// A ToolTip value was found and is enabled, proceed to firing the event
if (LastMouseOverWithToolTip != null)
{
// If a ToolTip is active, don't show it anymore
RaiseToolTipClosingEvent(true /* reset */);
}
LastChecked = origObj;
LastMouseOverWithToolTip = o;
bool quickShow = _quickShow; // ResetToolTipTimer may reset _quickShow
ResetToolTipTimer();
if (quickShow)
{
_quickShow = false;
RaiseToolTipOpeningEvent();
}
else
{
ToolTipTimer = new DispatcherTimer(DispatcherPriority.Normal);
ToolTipTimer.Interval = TimeSpan.FromMilliseconds(ToolTipService.GetInitialShowDelay(o));
ToolTipTimer.Tag = BooleanBoxes.TrueBox; // should open
ToolTipTimer.Tick += new EventHandler(OnRaiseToolTipOpeningEvent);
ToolTipTimer.Start();
}
}
}
else
{
// If a ToolTip is active, don't show it anymore
RaiseToolTipClosingEvent(true /* reset */);
// No longer over an item with a tooltip
LastMouseOverWithToolTip = null;
}
}
///
/// Finds the nearest element with an enabled tooltip.
///
///
/// The most "leaf" element to start looking at.
/// This element will be replaced with the element that
/// contains an active tooltip OR null if the element
/// is already in play.
///
/// True if there is an active tooltip in play.
private bool LocateNearestToolTip(ref DependencyObject o)
{
IInputElement element = o as IInputElement;
if (element != null)
{
FindToolTipEventArgs args = new FindToolTipEventArgs();
element.RaiseEvent(args);
if (args.TargetElement != null)
{
// Open this element's ToolTip
o = args.TargetElement;
return true;
}
else if (args.KeepCurrentActive)
{
// Keep the current ToolTip active
o = null;
return true;
}
}
// Close any existing ToolTips
return false;
}
internal bool StopLookingForToolTip(DependencyObject o)
{
if ((o == LastChecked) || (o == LastMouseOverWithToolTip) || (o == _currentToolTip) || WithinCurrentToolTip(o))
{
// In this case, don't show the ToolTip, but the current ToolTip is still OK to show.
return true;
}
return false;
}
private bool WithinCurrentToolTip(DependencyObject o)
{
// If no current tooltip, then no need to look
if (_currentToolTip == null)
{
return false;
}
DependencyObject v = o as Visual;
if (v == null)
{
ContentElement ce = o as ContentElement;
if (ce != null)
{
v = FindContentElementParent(ce);
}
else
{
v = o as Visual3D;
}
}
return (v != null) &&
((v is Visual && ((Visual)v).IsDescendantOf(_currentToolTip)) ||
(v is Visual3D && ((Visual3D)v).IsDescendantOf(_currentToolTip)));
}
private void ResetToolTipTimer()
{
if (_toolTipTimer != null)
{
_toolTipTimer.Stop();
_toolTipTimer = null;
_quickShow = false;
}
}
private void OnRaiseToolTipOpeningEvent(object sender, EventArgs e)
{
RaiseToolTipOpeningEvent();
}
private void RaiseToolTipOpeningEvent()
{
ResetToolTipTimer();
if (_forceCloseTimer != null)
{
OnForceClose(null, EventArgs.Empty);
}
DependencyObject o = LastMouseOverWithToolTip;
if (o != null)
{
bool show = true;
IInputElement element = o as IInputElement;
if (element != null)
{
ToolTipEventArgs args = new ToolTipEventArgs(true);
element.RaiseEvent(args);
show = !args.Handled;
}
if (show)
{
object tooltip = ToolTipService.GetToolTip(o);
ToolTip tip = tooltip as ToolTip;
if (tip != null)
{
_currentToolTip = tip;
_ownToolTip = false;
}
else if ((_currentToolTip == null) || !_ownToolTip)
{
_currentToolTip = new ToolTip();
_ownToolTip = true;
_currentToolTip.SetValue(ServiceOwnedProperty, BooleanBoxes.TrueBox);
// Bind the content of the tooltip to the ToolTip attached property
Binding binding = new Binding();
binding.Path = new PropertyPath(ToolTipService.ToolTipProperty);
binding.Mode = BindingMode.OneWay;
binding.Source = o;
_currentToolTip.SetBinding(ToolTip.ContentProperty, binding);
}
if (!_currentToolTip.StaysOpen)
{
// The popup takes capture in this case, which causes us to hit test to the wrong window.
// We do not support this scenario. Cleanup and then throw and exception.
throw new NotSupportedException(SR.Get(SRID.ToolTipStaysOpenFalseNotAllowed));
}
_currentToolTip.SetValue(OwnerProperty, o);
_currentToolTip.Closed += OnToolTipClosed;
_currentToolTip.IsOpen = true;
ToolTipTimer = new DispatcherTimer(DispatcherPriority.Normal);
ToolTipTimer.Interval = TimeSpan.FromMilliseconds(ToolTipService.GetShowDuration(o));
ToolTipTimer.Tick += new EventHandler(OnRaiseToolTipClosingEvent);
ToolTipTimer.Start();
}
}
}
private void OnRaiseToolTipClosingEvent(object sender, EventArgs e)
{
RaiseToolTipClosingEvent(false /* reset */);
}
///
/// Closes the current tooltip, firing a Closing event if necessary.
///
///
/// When false, will continue to treat input as if the tooltip were open so that
/// the tooltip of the current element won't re-open. Example: Clicking on a button
/// will hide the tooltip, but when the mouse is released, the tooltip should not
/// appear unless the mouse is moved off and then back on the button.
///
private void RaiseToolTipClosingEvent(bool reset)
{
ResetToolTipTimer();
if (reset)
{
LastChecked = null;
}
DependencyObject o = LastMouseOverWithToolTip;
if (o != null)
{
if (_currentToolTip != null)
{
bool isOpen = _currentToolTip.IsOpen;
try
{
if (isOpen)
{
IInputElement element = o as IInputElement;
if (element != null)
{
element.RaiseEvent(new ToolTipEventArgs(false));
}
}
}
finally
{
if (isOpen)
{
_currentToolTip.IsOpen = false;
// Keep references and owner set for the fade out or slide animation
// Owner is released when animation completes
_forceCloseTimer = new DispatcherTimer(DispatcherPriority.Normal);
_forceCloseTimer.Interval = Popup.AnimationDelayTime;
_forceCloseTimer.Tick += new EventHandler(OnForceClose);
_forceCloseTimer.Tag = _currentToolTip;
_forceCloseTimer.Start();
_quickShow = true;
ToolTipTimer = new DispatcherTimer(DispatcherPriority.Normal);
ToolTipTimer.Interval = TimeSpan.FromMilliseconds(ToolTipService.GetBetweenShowDelay(o));
ToolTipTimer.Tick += new EventHandler(OnBetweenShowDelay);
ToolTipTimer.Start();
}
else
{
// Release owner now
_currentToolTip.ClearValue(OwnerProperty);
if (_ownToolTip)
BindingOperations.ClearBinding(_currentToolTip, ToolTip.ContentProperty);
}
_currentToolTip = null;
}
}
}
}
// Clear owner when tooltip has closed
private void OnToolTipClosed(object sender, EventArgs e)
{
ToolTip toolTip = (ToolTip)sender;
toolTip.Closed -= OnToolTipClosed;
toolTip.ClearValue(OwnerProperty);
if ((bool)toolTip.GetValue(ServiceOwnedProperty))
{
BindingOperations.ClearBinding(toolTip, ToolTip.ContentProperty);
}
}
// The previous tooltip hasn't closed and we are trying to open a new one
private void OnForceClose(object sender, EventArgs e)
{
_forceCloseTimer.Stop();
ToolTip toolTip = (ToolTip)_forceCloseTimer.Tag;
toolTip.ForceClose();
_forceCloseTimer = null;
}
private void OnBetweenShowDelay(object source, EventArgs e)
{
ResetToolTipTimer();
}
private IInputElement LastMouseDirectlyOver
{
get
{
if (_lastMouseDirectlyOver != null)
{
IInputElement e = (IInputElement)_lastMouseDirectlyOver.Target;
if (e != null)
{
return e;
}
else
{
// Stale reference
_lastMouseDirectlyOver = null;
}
}
return null;
}
set
{
if (value == null)
{
_lastMouseDirectlyOver = null;
}
else if (_lastMouseDirectlyOver == null)
{
_lastMouseDirectlyOver = new WeakReference(value);
}
else
{
_lastMouseDirectlyOver.Target = value;
}
}
}
private DependencyObject LastMouseOverWithToolTip
{
get
{
if (_lastMouseOverWithToolTip != null)
{
DependencyObject o = (DependencyObject)_lastMouseOverWithToolTip.Target;
if (o != null)
{
return o;
}
else
{
// Stale reference
_lastMouseOverWithToolTip = null;
}
}
return null;
}
set
{
if (value == null)
{
_lastMouseOverWithToolTip = null;
}
else if (_lastMouseOverWithToolTip == null)
{
_lastMouseOverWithToolTip = new WeakReference(value);
}
else
{
_lastMouseOverWithToolTip.Target = value;
}
}
}
private DependencyObject LastChecked
{
get
{
if (_lastChecked != null)
{
DependencyObject o = (DependencyObject)_lastChecked.Target;
if (o != null)
{
return o;
}
else
{
// Stale reference
_lastChecked = null;
}
}
return null;
}
set
{
if (value == null)
{
_lastChecked = null;
}
else if (_lastChecked == null)
{
_lastChecked = new WeakReference(value);
}
else
{
_lastChecked.Target = value;
}
}
}
#endregion
#region ContextMenu
///
/// Event that fires on ContextMenu when it opens.
/// Located here to avoid circular dependencies.
///
internal static readonly RoutedEvent ContextMenuOpenedEvent =
EventManager.RegisterRoutedEvent("Opened", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(PopupControlService));
///
/// Event that fires on ContextMenu when it closes.
/// Located here to avoid circular dependencies.
///
internal static readonly RoutedEvent ContextMenuClosedEvent =
EventManager.RegisterRoutedEvent("Closed", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(PopupControlService));
/////////////////////////////////////////////////////////////////////
///
/// Critical: This has the ability to spoof input for paste since it passes user initiated bit
///
[SecurityCritical]
private void RaiseContextMenuOpeningEvent(KeyEventArgs e)
{
IInputElement source = e.OriginalSource as IInputElement;
if (source != null)
{
if (RaiseContextMenuOpeningEvent(source, -1.0, -1.0,e.UserInitiated))
{
e.Handled = true;
}
}
}
///
/// Critical: This has the ability to spoof input for paste since it passes user initiated bit
///
[SecurityCritical]
private bool RaiseContextMenuOpeningEvent(IInputElement source, double x, double y,bool userInitiated)
{
// Fire the event
ContextMenuEventArgs args = new ContextMenuEventArgs(source, true /* opening */, x, y);
DependencyObject sourceDO = source as DependencyObject;
if (userInitiated && sourceDO != null)
{
if (InputElement.IsUIElement(sourceDO))
{
((UIElement)sourceDO).RaiseEvent(args, userInitiated);
}
else if (InputElement.IsContentElement(sourceDO))
{
((ContentElement)sourceDO).RaiseEvent(args, userInitiated);
}
else if (InputElement.IsUIElement3D(sourceDO))
{
((UIElement3D)sourceDO).RaiseEvent(args, userInitiated);
}
else
{
source.RaiseEvent(args);
}
}
else
{
source.RaiseEvent(args);
}
if (!args.Handled)
{
// No one handled the event, auto show any available ContextMenus
// Saved from the bubble up the tree where we looked for a set ContextMenu property
DependencyObject o = args.TargetElement;
if ((o != null) && ContextMenuService.ContextMenuIsEnabled(o))
{
// Retrieve the value
object menu = ContextMenuService.GetContextMenu(o);
ContextMenu cm = menu as ContextMenu;
cm.SetValue(OwnerProperty, o);
cm.Closed += new RoutedEventHandler(OnContextMenuClosed);
if ((x == -1.0) && (y == -1.0))
{
// We infer this to mean that the ContextMenu was opened with the keyboard
cm.Placement = PlacementMode.Center;
}
else
{
// If there is a CursorLeft and CursorTop, it was opened with the mouse.
cm.Placement = PlacementMode.MousePoint;
}
// Clear any open tooltips
RaiseToolTipClosingEvent(true /*reset */);
cm.IsOpen = true;
return true; // A menu was opened
}
return false; // There was no menu to open
}
// Clear any open tooltips since someone else opened one
RaiseToolTipClosingEvent(true /*reset */);
return true; // The event was handled by someone else
}
private void OnContextMenuClosed(object source, RoutedEventArgs e)
{
ContextMenu cm = source as ContextMenu;
if (cm != null)
{
cm.Closed -= OnContextMenuClosed;
DependencyObject o = (DependencyObject)cm.GetValue(OwnerProperty);
if (o != null)
{
cm.ClearValue(OwnerProperty);
UIElement uie = GetTarget(o);
if (uie != null)
{
if (!IsPresentationSourceNull(uie))
{
IInputElement inputElement = (o is ContentElement || o is UIElement3D) ? (IInputElement)o : (IInputElement)uie;
ContextMenuEventArgs args = new ContextMenuEventArgs(inputElement, false /*opening */);
inputElement.RaiseEvent(args);
}
}
}
}
}
///
/// Critical - as this gets PresentationSource.
/// Safe - as the value is not returned but is only checked for null.
///
[SecurityCritical, SecurityTreatAsSafe]
private static bool IsPresentationSourceNull(DependencyObject uie)
{
return PresentationSource.CriticalFromVisual(uie) == null;
}
#endregion
#region Helpers
internal static DependencyObject FindParent(DependencyObject o)
{
// see if o is a Visual or a Visual3D
DependencyObject v = o as Visual;
if (v == null)
{
v = o as Visual3D;
}
ContentElement ce = (v == null) ? o as ContentElement : null;
if (ce != null)
{
o = ContentOperations.GetParent(ce);
if (o != null)
{
return o;
}
else
{
FrameworkContentElement fce = ce as FrameworkContentElement;
if (fce != null)
{
return fce.Parent;
}
}
}
else if (v != null)
{
return VisualTreeHelper.GetParent(v);
}
return null;
}
internal static DependencyObject FindContentElementParent(ContentElement ce)
{
DependencyObject nearestVisual = null;
DependencyObject o = ce;
while (o != null)
{
nearestVisual = o as Visual;
if (nearestVisual != null)
{
break;
}
nearestVisual = o as Visual3D;
if (nearestVisual != null)
{
break;
}
ce = o as ContentElement;
if (ce != null)
{
o = ContentOperations.GetParent(ce);
if (o == null)
{
FrameworkContentElement fce = ce as FrameworkContentElement;
if (fce != null)
{
o = fce.Parent;
}
}
}
else
{
// This could be application.
break;
}
}
return nearestVisual;
}
internal static bool IsElementEnabled(DependencyObject o)
{
bool enabled = true;
UIElement uie = o as UIElement;
ContentElement ce = (uie == null) ? o as ContentElement : null;
UIElement3D uie3D = (uie == null && ce == null) ? o as UIElement3D : null;
if (uie != null)
{
enabled = uie.IsEnabled;
}
else if (ce != null)
{
enabled = ce.IsEnabled;
}
else if (uie3D != null)
{
enabled = uie3D.IsEnabled;
}
return enabled;
}
internal static PopupControlService Current
{
get
{
return FrameworkElement.PopupControlService;
}
}
internal ToolTip CurrentToolTip
{
get
{
return _currentToolTip;
}
}
private DispatcherTimer ToolTipTimer
{
get
{
return _toolTipTimer;
}
set
{
ResetToolTipTimer();
_toolTipTimer = value;
}
}
///
/// Returns the UIElement target
///
private static UIElement GetTarget(DependencyObject o)
{
UIElement uie = o as UIElement;
if (uie == null)
{
ContentElement ce = o as ContentElement;
if (ce != null)
{
DependencyObject ceParent = FindContentElementParent(ce);
// attempt to cast to a UIElement
uie = ceParent as UIElement;
if (uie == null)
{
// target can't be a UIElement3D - so get the nearest containing UIElement
UIElement3D uie3D = ceParent as UIElement3D;
if (uie3D != null)
{
uie = UIElementHelper.GetContainingUIElement2D(uie3D);
}
}
}
else
{
// it wasn't a UIElement or ContentElement, try one last cast to UIElement3D
// target can't be a UIElement3D - so get the nearest containing UIElement
UIElement3D uie3D = o as UIElement3D;
if (uie3D != null)
{
uie = UIElementHelper.GetContainingUIElement2D(uie3D);
}
}
}
return uie;
}
///
/// Indicates whether the service owns the tooltip
///
private static readonly DependencyProperty ServiceOwnedProperty =
DependencyProperty.RegisterAttached("ServiceOwned", // Name
typeof(bool), // Type
typeof(PopupControlService), // Owner
new FrameworkPropertyMetadata(BooleanBoxes.FalseBox));
///
/// Stores the original element on which to fire the closed event
///
internal static readonly DependencyProperty OwnerProperty =
DependencyProperty.RegisterAttached("Owner", // Name
typeof(DependencyObject), // Type
typeof(PopupControlService), // Owner
new FrameworkPropertyMetadata((DependencyObject)null, // Default Value
new PropertyChangedCallback(OnOwnerChanged)));
// When the owner changes, coerce all attached properties from the service
private static void OnOwnerChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
{
if (o is ContextMenu)
{
o.CoerceValue(ContextMenu.HorizontalOffsetProperty);
o.CoerceValue(ContextMenu.VerticalOffsetProperty);
o.CoerceValue(ContextMenu.PlacementTargetProperty);
o.CoerceValue(ContextMenu.PlacementRectangleProperty);
o.CoerceValue(ContextMenu.PlacementProperty);
o.CoerceValue(ContextMenu.HasDropShadowProperty);
}
else if (o is ToolTip)
{
o.CoerceValue(ToolTip.HorizontalOffsetProperty);
o.CoerceValue(ToolTip.VerticalOffsetProperty);
o.CoerceValue(ToolTip.PlacementTargetProperty);
o.CoerceValue(ToolTip.PlacementRectangleProperty);
o.CoerceValue(ToolTip.PlacementProperty);
o.CoerceValue(ToolTip.HasDropShadowProperty);
}
}
// Returns the value of dp on the Owner if it is set there,
// otherwise returns the value set on o (the tooltip or contextmenu)
internal static object CoerceProperty(DependencyObject o, object value, DependencyProperty dp)
{
DependencyObject owner = (DependencyObject)o.GetValue(OwnerProperty);
if (owner != null)
{
bool hasModifiers;
if (owner.GetValueSource(dp, null, out hasModifiers) != BaseValueSourceInternal.Default || hasModifiers)
{
// Return a value if it is set on the owner
return owner.GetValue(dp);
}
else if (dp == ToolTip.PlacementTargetProperty || dp == ContextMenu.PlacementTargetProperty)
{
UIElement uie = GetTarget(owner);
// If it is the PlacementTarget property, return the owner itself
if (uie != null)
return uie;
}
}
return value;
}
#endregion
#region Data
private DispatcherTimer _toolTipTimer;
private bool _quickShow = false;
private WeakReference _lastMouseDirectlyOver;
private WeakReference _lastMouseOverWithToolTip;
private WeakReference _lastChecked;
private ToolTip _currentToolTip;
private DispatcherTimer _forceCloseTimer;
private bool _ownToolTip;
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- FunctionNode.cs
- AnnotationHelper.cs
- XamlGridLengthSerializer.cs
- AssemblyFilter.cs
- DBSqlParserColumnCollection.cs
- AliasGenerator.cs
- COM2TypeInfoProcessor.cs
- LockCookie.cs
- HttpWebRequest.cs
- GeneralTransform3D.cs
- RawStylusInputCustomData.cs
- HtmlTableRow.cs
- SessionEndingCancelEventArgs.cs
- RijndaelManaged.cs
- Odbc32.cs
- TextTabProperties.cs
- Crc32.cs
- TextBoxAutomationPeer.cs
- DataGridViewTextBoxCell.cs
- MultipartContentParser.cs
- Setter.cs
- SecurityPolicySection.cs
- ScrollBarAutomationPeer.cs
- TableSectionStyle.cs
- ButtonBaseAutomationPeer.cs
- XslUrlEditor.cs
- TypeReference.cs
- _TimerThread.cs
- RotateTransform3D.cs
- SqlClientFactory.cs
- versioninfo.cs
- PipelineComponent.cs
- FloaterParaClient.cs
- AssemblyBuilder.cs
- DataBindingCollectionEditor.cs
- DescriptionAttribute.cs
- JsonByteArrayDataContract.cs
- IsolatedStorageFile.cs
- SubMenuStyle.cs
- MarkupCompilePass2.cs
- BaseResourcesBuildProvider.cs
- AnnotationAuthorChangedEventArgs.cs
- OleDbDataReader.cs
- GeneralTransform.cs
- UIElement3DAutomationPeer.cs
- NotificationContext.cs
- HelpProvider.cs
- Model3D.cs
- KeySplineConverter.cs
- NameValueFileSectionHandler.cs
- XmlNamespaceMappingCollection.cs
- BypassElement.cs
- Freezable.cs
- SmiEventStream.cs
- CompleteWizardStep.cs
- NameValueSectionHandler.cs
- OleDbPropertySetGuid.cs
- AndCondition.cs
- Panel.cs
- _AutoWebProxyScriptHelper.cs
- ParsedAttributeCollection.cs
- BamlLocalizerErrorNotifyEventArgs.cs
- NavigationPropertyEmitter.cs
- AgileSafeNativeMemoryHandle.cs
- WebPartConnection.cs
- UserNamePasswordValidator.cs
- graph.cs
- XmlChildNodes.cs
- DependencyObjectType.cs
- RefreshPropertiesAttribute.cs
- TextRunCache.cs
- ModuleConfigurationInfo.cs
- TreeView.cs
- GeneralTransform.cs
- StartUpEventArgs.cs
- WebPartMovingEventArgs.cs
- Privilege.cs
- PersianCalendar.cs
- SecurityTokenValidationException.cs
- ExpandSegmentCollection.cs
- CapabilitiesUse.cs
- SqlWriter.cs
- BindingNavigatorDesigner.cs
- BinaryObjectReader.cs
- Brushes.cs
- FreezableDefaultValueFactory.cs
- Vector3DIndependentAnimationStorage.cs
- DesignSurfaceManager.cs
- HotSpot.cs
- X509CertificateCollection.cs
- SafeNativeMethods.cs
- SessionSwitchEventArgs.cs
- ACE.cs
- DefaultBindingPropertyAttribute.cs
- SingleAnimation.cs
- WorkflowRuntimeService.cs
- SqlDataSourceCustomCommandEditor.cs
- CacheManager.cs
- Style.cs
- DrawToolTipEventArgs.cs