Forzare la visualizzazione di una descrizione comando WPF sullo schermo

Ho una descrizione comando per un'etichetta e desidero che rimanga aperta finché l'utente non sposta il mouse su un altro controllo.

Ho provato le seguenti proprietà nella descrizione comando:

StaysOpen="True"

e

ToolTipService.ShowDuration = "60000"

Ma in entrambi i casi la descrizione comando viene visualizzata solo per esattamente 5 secondi.

Perché questi valori vengono ignorati?

Metti semplicemente questo codice nella sezione di inizializzazione.

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

TooltipService.ShowDuration funziona, ma devi impostarlo sull'oggetto che ha il Tooltip, in questo modo:

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

Direi che questo design è stato scelto perché consente lo stesso suggerimento con timeout diversi su controlli diversi.

Anche questo mi stava facendo impazzire stasera. Ho creato una ToolTipsottoclasse per gestire il problema. Per me, su .NET 4.0, la ToolTip.StaysOpenproprietà non "realmente" rimane aperta.

Nella classe seguente, usa la nuova proprietà ToolTipEx.IsReallyOpen, invece della proprietà ToolTip.IsOpen. Otterrai il controllo che desideri. Tramite la Debug.Print()chiamata, puoi guardare nella finestra di output del debugger quante volte this.IsOpen = falseviene chiamato! Così tanto per StaysOpen, o dovrei dire "StaysOpen"? Godere.

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

Piccolo sproloquio: perché Microsoft non ha reso le DependencyPropertyproprietà (getter / setters) virtuali in modo da poter accettare / rifiutare / modificare le modifiche nelle sottoclassi? O crearne uno virtual OnXYZPropertyChangedper ognuno DependencyProperty? Ugh.

---Modificare---

La mia soluzione sopra sembra strana nell'editor XAML: il suggerimento è sempre visualizzato, bloccando del testo in Visual Studio!

Ecco un modo migliore per risolvere questo problema:

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

Alcuni codici:

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

Conclusione: c'è qualcosa di diverso nelle classi ToolTipe ContextMenu. Entrambi hanno classi "servizio", come ToolTipServicee ContextMenuService, che gestiscono determinate proprietà, ed entrambi utilizzano Popupcome controllo genitore "segreto" durante la visualizzazione. Infine, ho notato che TUTTI gli esempi di descrizioni comandi XAML sul Web non utilizzano la classe ToolTipdirettamente. Invece, incorporano un StackPanelcon TextBlocks. Cose che ti fanno dire: "hmmm ..."

Probabilmente vorrai usare Popup invece di Tooltip, poiché Tooltip presume che tu lo stia utilizzando nel modo predefinito dell'interfaccia utente.

Non sono sicuro del motivo per cui StaysOpen non funziona, ma ShowDuration funziona come documentato in MSDN: è la quantità di tempo che il Tooltip viene visualizzato QUANDO viene visualizzato. Impostalo su una piccola quantità (ad esempio 500 msec) per vedere la differenza.

Il trucco nel tuo caso è mantenere lo stato "ultimo controllo al passaggio del mouse", ma una volta ottenuto questo dovrebbe essere abbastanza banale cambiare il target di posizionamento e il contenuto in modo dinamico (manualmente o tramite associazione) se stai utilizzando un popup, o nascondendo l'ultimo Popup visibile se stai usando più.

Ci sono alcuni trucchi con i popup per quanto riguarda il ridimensionamento e lo spostamento della finestra (i popup non si spostano con i contenitori), quindi potresti tenerlo a mente mentre stai modificando il comportamento. Vedi questo collegamento per maggiori dettagli.

HTH.

Se vuoi specificare che solo alcuni elementi nel tuo Windowhanno una ToolTipdurata effettivamente indefinita puoi definire un Stylenel tuo Window.Resourcesper quegli elementi. Ecco un Styleper Buttonche ha un tale 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.">
    ...

Si può anche aggiungere Style.Resourcesalla Styleper modificare l'aspetto della ToolTipmostra, ad esempio:

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

Nota: quando ho fatto questo ho usato anche BasedOnnel Stylecosì tutto il resto definito per la versione del mio controllo personalizzato con una normale ToolTipsarebbe stato applicato.

Solo l'altro giorno stavo lottando con il tooltip di WPF. Non sembra possibile impedirgli di apparire e scomparire da solo, quindi alla fine sono ricorsi alla gestione Openeddell'evento. Ad esempio, volevo impedirne l'apertura a meno che non avesse dei contenuti, quindi ho gestito l' Openedevento e poi ho fatto questo:

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

È un trucco, ma ha funzionato.

Presumibilmente potresti gestire allo stesso modo l' Closedevento e dirgli di riaprirsi, mantenendolo così visibile.

Solo per completezza: nel codice assomiglia a questo:

ToolTipService.SetShowDuration(element, 60000);

Inoltre, se si desidera inserire qualsiasi altro controllo nella descrizione comando, non sarà attivabile poiché una descrizione comandi stessa può ottenere lo stato attivo. Quindi, come ha detto micahtan, il tuo colpo migliore è un Popup.

Ho risolto il mio problema con lo stesso codice.

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

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

Sta funzionando per me. Copia questa riga nel costruttore della tua classe.