Forcing a WPF tooltip to stay on the screen
Solution 1
Just put this code in initialization section.
ToolTipService.ShowDurationProperty.OverrideMetadata(
typeof(DependencyObject), new FrameworkPropertyMetadata(Int32.MaxValue));
Solution 2
If you want to set this for just one tooltip, set the duration on the object having the Tooltip, like this:
<Label ToolTipService.ShowDuration="12000" Name="lblShowTooltip" Content="Shows tooltip">
<Label.ToolTip>
<ToolTip>
<TextBlock>Hello world!</TextBlock>
</ToolTip>
</Label.ToolTip>
</Label>
I'd say that this design was chosen because it allows same tooltip with different timeouts on different controls.
If you want this globally for your whole app, see the accepted answer.
Solution 3
This was also driving me crazy tonight. I created a ToolTip
subclass to handle the issue. For me, on .NET 4.0, the ToolTip.StaysOpen
property is not "really" stays open.
In the class below, use the new property ToolTipEx.IsReallyOpen
, instead of property ToolTip.IsOpen
. You will get the control you want. Via the Debug.Print()
call, you can watch in the debugger Output window just how many times this.IsOpen = false
is called! So much for StaysOpen
, or should I say "StaysOpen"
? Enjoy.
public class ToolTipEx : ToolTip
{
static ToolTipEx()
{
IsReallyOpenProperty =
DependencyProperty.Register(
"IsReallyOpen",
typeof(bool),
typeof(ToolTipEx),
new FrameworkPropertyMetadata(
defaultValue: false,
flags: FrameworkPropertyMetadataOptions.None,
propertyChangedCallback: StaticOnIsReallyOpenedChanged));
}
public static readonly DependencyProperty IsReallyOpenProperty;
protected static void StaticOnIsReallyOpenedChanged(
DependencyObject o, DependencyPropertyChangedEventArgs e)
{
ToolTipEx self = (ToolTipEx)o;
self.OnIsReallyOpenedChanged((bool)e.OldValue, (bool)e.NewValue);
}
protected void OnIsReallyOpenedChanged(bool oldValue, bool newValue)
{
this.IsOpen = newValue;
}
public bool IsReallyOpen
{
get
{
bool b = (bool)this.GetValue(IsReallyOpenProperty);
return b;
}
set { this.SetValue(IsReallyOpenProperty, value); }
}
protected override void OnClosed(RoutedEventArgs e)
{
System.Diagnostics.Debug.Print(String.Format(
"OnClosed: IsReallyOpen: {0}, StaysOpen: {1}", this.IsReallyOpen, this.StaysOpen));
if (this.IsReallyOpen && this.StaysOpen)
{
e.Handled = true;
// We cannot set this.IsOpen directly here. Instead, send an event asynchronously.
// DispatcherPriority.Send is the highest priority possible.
Dispatcher.CurrentDispatcher.BeginInvoke(
(Action)(() => this.IsOpen = true),
DispatcherPriority.Send);
}
else
{
base.OnClosed(e);
}
}
}
Small rant: Why didn't Microsoft make DependencyProperty
properties (getters/setters) virtual so we can accept/reject/adjust changes in subclasses? Or make a virtual OnXYZPropertyChanged
for each and every DependencyProperty
? Ugh.
---Edit---
My solution above looks weird in the XAML editor -- the tooltip is always showing, blocking some text in Visual Studio!
Here is a better way to solve this problem:
Some XAML:
<!-- Need to add this at top of your XAML file:
xmlns:System="clr-namespace:System;assembly=mscorlib"
-->
<ToolTip StaysOpen="True" Placement="Bottom" HorizontalOffset="10"
ToolTipService.InitialShowDelay="0" ToolTipService.BetweenShowDelay="0"
ToolTipService.ShowDuration="{x:Static Member=System:Int32.MaxValue}"
>This is my tooltip text.</ToolTip>
Some code:
// Alternatively, you can attach an event listener to FrameworkElement.Loaded
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
// Be gentle here: If someone creates a (future) subclass or changes your control template,
// you might not have tooltip anymore.
ToolTip toolTip = this.ToolTip as ToolTip;
if (null != toolTip)
{
// If I don't set this explicitly, placement is strange.
toolTip.PlacementTarget = this;
toolTip.Closed += new RoutedEventHandler(OnToolTipClosed);
}
}
protected void OnToolTipClosed(object sender, RoutedEventArgs e)
{
// You may want to add additional focus-related tests here.
if (this.IsKeyboardFocusWithin)
{
// We cannot set this.IsOpen directly here. Instead, send an event asynchronously.
// DispatcherPriority.Send is the highest priority possible.
Dispatcher.CurrentDispatcher.BeginInvoke(
(Action)delegate
{
// Again: Be gentle when using this.ToolTip.
ToolTip toolTip = this.ToolTip as ToolTip;
if (null != toolTip)
{
toolTip.IsOpen = true;
}
},
DispatcherPriority.Send);
}
}
Conclusion: Something is different about classes ToolTip
and ContextMenu
. Both have "service" classes, like ToolTipService
and ContextMenuService
, that manage certain properties, and both use Popup
as a "secret" parent control during display. Finally, I noticed ALL the XAML ToolTip examples on the Web do not use class ToolTip
directly. Instead, they embed a StackPanel
with TextBlock
s. Things that make you say: "hmmm..."
Solution 4
You probably want to use Popup instead of Tooltip, since Tooltip assumes that you're using it in the pre-defined UI-standards way.
I'm not sure why StaysOpen doesn't work, but ShowDuration works as documented in MSDN -- it's the amount of time the Tooltip is displayed WHEN it's displayed. Set it to a small amount (e.g. 500 msec) to see the difference.
The trick in your case is maintaining the "last hovered control" state, but once you have that it should be fairly trivial to change the placement target and the content dynamically (either manually, or via binding) if you're using one Popup, or hiding the last visible Popup if you're using multiple.
There are some gotchas with Popups as far as Window resizing and moving (Popups don't move w/the containers), so you may want to also have that in mind while you're tweaking the behavior. See this link for more details.
HTH.
Solution 5
If you want to specify that only certain elements in your Window
have
effectively indefinite ToolTip
duration you can define a Style
in your Window.Resources
for those elements. Here is a Style
for Button
that has such a ToolTip
:
<Window
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:sys="clr-namespace:System;assembly=mscorlib"
...>
...
<Window.Resources>
<Style x:Key="ButtonToolTipIndefinate" TargetType="{x:Type Button}">
<Setter Property="ToolTipService.ShowDuration"
Value="{x:Static Member=sys:Int32.MaxValue}"/>
</Style>
...
</Window.Resources>
...
<Button Style="{DynamicResource ButtonToolTipIndefinate}"
ToolTip="This should stay open"/>
<Button ToolTip="This Should disappear after the default time.">
...
One can also add Style.Resources
to the Style
to change the appearance of the ToolTip
it shows, for example:
<Style x:Key="ButtonToolTipTransparentIndefinate" TargetType="{x:Type Button}">
<Style.Resources>
<Style x:Key="{x:Type ToolTip}" TargetType="{x:Type ToolTip}">
<Setter Property="Background" Value="Transparent"/>
<Setter Property="BorderBrush" Value="Transparent"/>
<Setter Property="HasDropShadow" Value="False"/>
</Style>
</Style.Resources>
<Setter Property="ToolTipService.ShowDuration"
Value="{x:Static Member=sys:Int32.MaxValue}"/>
</Style>
Note: When I did this I also used BasedOn
in the Style
so everything else defined for the version of my custom control with a normal ToolTip
would be applied.
Comments
-
jmistx almost 2 years
I have a tooltip for a Label and I want it to stay open until the user moves the mouse to a different control.
I have tried the following properties on the tooltip:
StaysOpen="True"
and
ToolTipService.ShowDuration = "60000"
But in both cases the tooltip is only displayed for exactly 5 seconds.
Why are these values being ignored?
-
Jeff B almost 15 yearsAlso beware that Popups are always on top of all desktop objects - even if you switch to another program, the popup will be visible and obscure part of the other program.
-
benPearce over 13 yearsToolTip has a property called HasContent which you could use instead
-
Rachel over 13 yearsThat's exactly why I don't like using popups.... because they don't shrink with the program and they stay on top of all other programs. Also, resizing/moving the main application doesn't move the popup with it by default.
-
svick over 11 yearsIt also allows you to specify the content of the
ToolTip
directly, without explicit<ToolTip>
, which can make binding simpler. -
Hannish about 11 yearsYou should get more votes on your answer just for its thoroughness. +1 from me.
-
InvalidBrainException almost 10 yearsThis was the only solution that worked for me. How can you adapt this code to set the Placement property to Top?
new FrameworkPropertyMetadata("Top")
doesn't work. -
Roman Starkov over 9 yearsFWIW, this UI convention is rubbish anyway. Few things are more annoying than a tooltip that disappears while I'm reading it.
-
dbeachy1 over 9 yearsThis worked perfectly for me, thanks for this! I put mine in the
Window_Loaded
event handler, which is invoked just before the window content is rendered. -
jmistx about 9 yearsI have marked this (after nearly 6 years years, sorry) as the correct answer because this actually works on all supported versions of Windows and keeps it open for 49 days, which should be long enough :p
-
Vlad about 9 yearsThis should be the chosen answer as it is context specific and not global.
-
Contango almost 9 yearsThe duration is in milliseconds. The default is 5000. The code above specifies 12 seconds.
-
JGeerWM over 8 yearsAfter experimenting with different options based on advice from this posting, I settled with recommendation below by Martin Konicek, which allows the timeout to be context specific.
-
CodingYourLife about 8 yearsthis is copy&paste of accepted answer with second most upvotes
-
springy76 about 8 yearsIf you use the same tooltip instance with multiple controls you sooner or later will get a "already visual child of a different parent" exception.
-
nicko over 7 yearsI also put this in my Window_Loaded event and it works great. The only thing you have to do is make sure that you get rid of any "ToolTipService.ShowDuration" that you have set in your XAML, the durations you set in XAML will override the behavior that this code is trying to achieve. Thanks to John Whiter for providing the solution.
-
Ceco about 7 yearsThe solution below from @Martin Konicek is the one that works best IMO. Here is the link: stackoverflow.com/questions/896574/…
-
j riv almost 7 yearsThe main reason this should be the correct answer is that it's in the spirit of actual high level programming, right into the XAML code, and easy to notice. The other solution is kinda hacky and verbose besides the point it's global. I bet most people that used that forgot about how they did it in a week.
-
Miral over 6 yearsFWIW, I prefer this one precisely because it's global -- I want all tooltips in my app to persist longer without further fanfare. Doing this still allows you to selectively apply a smaller value in context-specific places, as well, exactly as in the other answer. (But as always, this is only valid if you are the application -- if you're writing a control library or something else then you must only use context-specific solutions; global state is not yours to play with.)
-
Jeson Martajaya over 4 yearsToolTipService needs to be placed on parent element, see Martin Konicek's answer above.
-
IngoB about 4 yearsAs Miral said, it is global, that is to say you must make sure to call this code only once in your app, e. g. in App.xaml.cs or a main window or so.
-
jan about 4 yearsThis can be dangerous! Wpf internally uses TimeSpan.FromMilliseconds() when setting the timer interval which does double calculations. This means that when the value is applied to the timer using the Interval property you can get ArgumentOutOfRangeException.
-
stijn over 3 yearsAs counterpoint for the 'this should be the answer' comments: sure if you need this in one single place, this is fine. But applications should be consistent in style and behavior so it makes quite a lot of sense to apply this particular option globally. If the code behind way is the way which just works and with the least amount of friction, it's a nice and KISS solution. At moments like that you don't want to strictly adhere to whatever principle if that actually makes life harder. Programming good practices aren't strict rules but guidelines.
-
Martin Konicek over 3 yearsGood point! Edited the answer to show the two different approaches - local or global. When I originally wrote this answer, I needed to set the duration just on a single tooltip in my app because that tooltip had a long message.
-
gil123 over 2 yearsThis is the best solution that works because it is not global . But you need to put this line after
InitializeComponent()