Forcer une info-bulle WPF à rester à l'écran

J'ai une info-bulle pour une étiquette et je veux qu'elle reste ouverte jusqu'à ce que l'utilisateur déplace la souris vers un contrôle différent.

J'ai essayé les propriétés suivantes dans l'info-bulle:

StaysOpen="True"

et

ToolTipService.ShowDuration = "60000"

Mais dans les deux cas, l'info-bulle ne s'affiche que pendant exactement 5 secondes.

Pourquoi ces valeurs sont-elles ignorées?

Mettez simplement ce code dans la section d'initialisation.

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

TooltipService.ShowDuration fonctionne, mais vous devez le définir sur l'objet ayant l'info-bulle, comme ceci:

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

Je dirais que cette conception a été choisie car elle permet la même info-bulle avec différents délais d'expiration sur différents contrôles.

Cela me rendait aussi fou ce soir. J'ai créé une ToolTipsous - classe pour gérer le problème. Pour moi, sur .NET 4.0, la ToolTip.StaysOpenpropriété n'est pas "vraiment" reste ouverte.

Dans la classe ci-dessous, utilisez la nouvelle propriété ToolTipEx.IsReallyOpenau lieu de property ToolTip.IsOpen. Vous obtiendrez le contrôle que vous souhaitez. Via l' Debug.Print()appel, vous pouvez regarder dans la fenêtre de sortie du débogueur combien de fois this.IsOpen = falseest appelé! Tant pis StaysOpen, ou devrais-je dire "StaysOpen"? Prendre plaisir.

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

Petite diatribe: Pourquoi Microsoft n'a-t-il pas rendu les DependencyPropertypropriétés (getters / setters) virtuelles afin que nous puissions accepter / rejeter / ajuster les changements dans les sous-classes? Ou en faire un virtual OnXYZPropertyChangedpour chacun DependencyProperty? Pouah.

---Éditer---

Ma solution ci-dessus semble étrange dans l'éditeur XAML - l'info-bulle est toujours affichée, bloquant du texte dans Visual Studio!

Voici une meilleure façon de résoudre ce problème:

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

Un peu de 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: Il y a quelque chose de différent dans les classes ToolTipet ContextMenu. Les deux ont des classes "service", comme ToolTipServiceet ContextMenuService, qui gèrent certaines propriétés, et les deux utilisent Popupcomme contrôle parent "secret" pendant l'affichage. Enfin, j'ai remarqué que TOUS les exemples XAML ToolTip sur le Web n'utilisent pas ToolTipdirectement la classe . Au lieu de cela, ils intègrent un StackPanelavec l' TextBlockart. Des choses qui vous font dire: "hmmm ..."

Vous souhaiterez probablement utiliser Popup au lieu de Tooltip, car Tooltip suppose que vous l'utilisez selon les normes d'interface utilisateur prédéfinies.

Je ne sais pas pourquoi StaysOpen ne fonctionne pas, mais ShowDuration fonctionne comme documenté dans MSDN - c'est la durée pendant laquelle l'info-bulle est affichée LORSQUE elle est affichée. Réglez-le sur une petite quantité (par exemple 500 ms) pour voir la différence.

L'astuce dans votre cas est de conserver l'état "dernier contrôle survolé", mais une fois que vous l'avez fait, il devrait être assez simple de changer la cible de placement et le contenu de manière dynamique (soit manuellement, soit via une liaison) si vous utilisez un Popup, ou masquer le dernier Popup visible si vous en utilisez plusieurs.

Il y a quelques pièges avec les fenêtres contextuelles en ce qui concerne le redimensionnement et le déplacement de la fenêtre (les fenêtres contextuelles ne bougent pas avec les conteneurs), vous voudrez peut-être également garder cela à l'esprit lorsque vous peaufinez le comportement. Voir ce lien pour plus de détails.

HTH.

Si vous souhaitez spécifier que seuls certains éléments de votre Windowont effectivement une ToolTipdurée indéfinie, vous pouvez définir un Styledans votre Window.Resourcespour ces éléments. Voici un Stylepour Buttonqui a un tel 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.">
    ...

On peut également ajouter Style.Resourcesau Stylepour changer l'apparence de celui- ToolTipci, par exemple:

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

Remarque: lorsque j'ai fait cela, j'ai également utilisé BasedOndans le Styleafin que tout le reste défini pour la version de mon contrôle personnalisé avec une normale ToolTipsoit appliqué.

Je ne luttais avec l'info-bulle WPF que l'autre jour. Il ne semble pas possible de l'empêcher d'apparaître et de disparaître par lui-même, alors j'ai finalement eu recours à la gestion de l' Openedévénement. Par exemple, je voulais l'empêcher de s'ouvrir à moins qu'il ne contienne du contenu, j'ai donc géré l' Openedévénement, puis j'ai fait ceci:

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

C'est un hack, mais ça a marché.

Vous pouvez probablement gérer l' Closedévénement de la même manière et lui dire de s'ouvrir à nouveau, le gardant ainsi visible.

Juste pour être complet: dans le code, cela ressemble à ceci:

ToolTipService.SetShowDuration(element, 60000);

De plus, si vous souhaitez mettre un autre contrôle dans votre info-bulle, il ne sera pas focalisable car une info-bulle elle-même peut obtenir le focus. Donc, comme l'a dit micahtan, votre meilleur coup est un Popup.

J'ai résolu mon problème avec le même code.

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

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

Ça marche pour moi. Copiez cette ligne dans votre constructeur de classe.