Erzwingen, dass ein WPF-Tooltip auf dem Bildschirm angezeigt wird

Ich habe einen Tooltip für ein Etikett und möchte, dass es geöffnet bleibt, bis der Benutzer die Maus auf ein anderes Steuerelement bewegt.

Ich habe die folgenden Eigenschaften im Tooltip ausprobiert:

StaysOpen="True"

und

ToolTipService.ShowDuration = "60000"

In beiden Fällen wird der Tooltip jedoch nur genau 5 Sekunden lang angezeigt.

Warum werden diese Werte ignoriert?

Fügen Sie diesen Code einfach in den Initialisierungsabschnitt ein.

ToolTipService.ShowDurationProperty.OverrideMetadata(
    typeof(DependencyObject), new FrameworkPropertyMetadata(Int32.MaxValue));

TooltipService.ShowDuration funktioniert, aber Sie müssen es für das Objekt mit dem Tooltip wie folgt festlegen:

<Label ToolTipService.ShowDuration="12000" Name="lblShowTooltip" Content="Shows tooltip">
    <Label.ToolTip>
        <ToolTip>
            <TextBlock>Hello world!</TextBlock>
        </ToolTip>
    </Label.ToolTip>
</Label>

Ich würde sagen, dass dieses Design gewählt wurde, weil es denselben Tooltip mit unterschiedlichen Zeitüberschreitungen auf verschiedenen Steuerelementen ermöglicht.

Das hat mich heute Abend auch verrückt gemacht. Ich habe eine ToolTipUnterklasse erstellt, um das Problem zu beheben. Für mich unter .NET 4.0 ToolTip.StaysOpenbleibt die Eigenschaft nicht "wirklich" offen.

Verwenden Sie in der folgenden Klasse die neue Eigenschaft ToolTipEx.IsReallyOpenanstelle der Eigenschaft ToolTip.IsOpen. Sie erhalten die Kontrolle, die Sie wollen. Über den Debug.Print()Aufruf können Sie im Debugger-Ausgabefenster sehen, wie oft this.IsOpen = falseaufgerufen wird! Soviel zu StaysOpenoder soll ich sagen "StaysOpen"? Genießen.

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);
        }
    }
}

Kleiner Scherz: Warum hat Microsoft DependencyPropertyEigenschaften (Getter / Setter) nicht virtuell gemacht, damit wir Änderungen in Unterklassen akzeptieren / ablehnen / anpassen können? Oder virtual OnXYZPropertyChangedfür jeden etwas machen DependencyProperty? Pfui.

---Bearbeiten---

Meine obige Lösung sieht im XAML-Editor seltsam aus - der Tooltip wird immer angezeigt und blockiert Text in Visual Studio!

Hier ist ein besserer Weg, um dieses Problem zu lösen:

Einige 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>

Etwas 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);
    }
}

Fazit: Etwas ist anders an Klassen ToolTipund ContextMenu. Beide haben "Service" -Klassen wie ToolTipServiceund ContextMenuService, die bestimmte Eigenschaften verwalten, und beide Popupwerden während der Anzeige als "geheimes" übergeordnetes Steuerelement verwendet. Schließlich habe ich festgestellt, dass ALLE XAML ToolTip-Beispiele im Web die Klasse nicht ToolTipdirekt verwenden. Stattdessen binden sie ein StackPanelmit TextBlocks ein. Dinge, die dich sagen lassen: "hmmm ..."

Sie möchten wahrscheinlich Popup anstelle von Tooltip verwenden, da Tooltip davon ausgeht, dass Sie es auf vordefinierte Weise für UI-Standards verwenden.

Ich bin nicht sicher, warum StaysOpen nicht funktioniert, aber ShowDuration funktioniert wie in MSDN dokumentiert - es ist die Zeit, die der Tooltip angezeigt wird, wenn er angezeigt wird. Stellen Sie einen kleinen Wert (z. B. 500 ms) ein, um den Unterschied zu erkennen.

Der Trick in Ihrem Fall besteht darin, den Status "Zuletzt schwebendes Steuerelement" beizubehalten. Sobald Sie dies jedoch getan haben, sollte es ziemlich trivial sein, das Platzierungsziel und den Inhalt dynamisch (entweder manuell oder über Bindung) zu ändern, wenn Sie ein Popup verwenden. oder das letzte sichtbare Popup ausblenden, wenn Sie mehrere verwenden.

Es gibt einige Fallstricke bei Popups, wenn es um die Größenänderung und das Verschieben von Fenstern geht (Popups werden nicht mit den Containern verschoben). Daher sollten Sie dies auch berücksichtigen, während Sie das Verhalten optimieren. Siehe diesen Link für weitere Details.

HTH.

Wenn Sie angeben möchten, dass nur bestimmte Elemente in Ihrer Windoweffektiv unbegrenzte ToolTipDauer haben, können Sie Stylein Ihrer Window.Resourcesfür diese Elemente ein definieren. Hier ist ein Stylefür Buttondas hat so ein 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.">
    ...

Man kann auch hinzufügen Style.Resources, Styleum das Erscheinungsbild der angezeigten zu ändern ToolTip, zum Beispiel:

<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>

Hinweis: Als ich dies tat, verwendete ich auch BasedOnin, Styledamit alles andere, was für die Version meines benutzerdefinierten Steuerelements mit einem Normal definiert wurde ToolTip, angewendet wurde.

Ich habe erst neulich mit dem WPF Tooltip gerungen. Es scheint nicht möglich zu sein, zu verhindern, dass es von selbst erscheint und verschwindet, also habe ich am Ende auf die Behandlung des OpenedEreignisses zurückgegriffen. Zum Beispiel wollte ich verhindern, dass es geöffnet wird, es sei denn, es enthält Inhalte. Deshalb habe ich das OpenedEreignis behandelt und dann Folgendes ausgeführt:

tooltip.IsOpen = (tooltip.Content != null);

Es ist ein Hack, aber es hat funktioniert.

Vermutlich könnten Sie das ClosedEreignis auf ähnliche Weise behandeln und anweisen, es erneut zu öffnen, um es sichtbar zu halten.

Nur der Vollständigkeit halber: Im Code sieht es so aus:

ToolTipService.SetShowDuration(element, 60000);

Auch wenn Sie jemals ein anderes Steuerelement in Ihre QuickInfo einfügen möchten, kann es nicht fokussiert werden, da eine QuickInfo selbst fokussiert werden kann. Wie Micahtan sagte, ist Ihr bester Schuss ein Popup.

Habe mein Problem mit dem gleichen Code behoben.

ToolTipService.ShowDurationProperty.OverrideMetadata (typeof (DependencyObject), neue FrameworkPropertyMetadata (Int32.MaxValue));

ToolTipService.ShowDurationProperty.OverrideMetadata(
    typeof(DependencyObject), new FrameworkPropertyMetadata(Int32.MaxValue));

Es funktioniert für mich. Kopieren Sie diese Zeile in Ihren Klassenkonstruktor.