Wymuszanie podpowiedzi WPF do pozostania na ekranie

Mam podpowiedź dotyczącą etykiety i chcę, aby pozostawała otwarta, dopóki użytkownik nie przeniesie myszy do innej kontrolki.

Wypróbowałem następujące właściwości w podpowiedzi:

StaysOpen="True"

i

ToolTipService.ShowDuration = "60000"

Ale w obu przypadkach podpowiedź jest wyświetlana tylko przez dokładnie 5 sekund.

Dlaczego te wartości są ignorowane?

Po prostu umieść ten kod w sekcji inicjalizacji.

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

TooltipService.ShowDuration działa, ale musisz ustawić go na obiekcie posiadającym etykietkę, na przykład:

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

Powiedziałbym, że ten projekt został wybrany, ponieważ pozwala na takie same podpowiedzi z różnymi limitami czasu na różnych kontrolkach.

To też doprowadzało mnie do szału. Stworzyłem ToolTippodklasę do obsługi tego problemu. Dla mnie w .NET 4.0 ToolTip.StaysOpenobiekt nie jest „naprawdę” pozostaje otwarty.

W klasie poniżej użyj nowej właściwości ToolTipEx.IsReallyOpenzamiast property ToolTip.IsOpen. Uzyskasz kontrolę, jaką chcesz. Poprzez Debug.Print()rozmowy, można oglądać w oknie Output debuggera, jak wiele razy this.IsOpen = falsenazywa! To tyle StaysOpen, czy powinienem powiedzieć "StaysOpen"? Cieszyć się.

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

Mały rant: dlaczego firma Microsoft nie uczyniła DependencyPropertywłaściwości (pobierających / ustawiających) wirtualnych, abyśmy mogli akceptować / odrzucać / dostosowywać zmiany w podklasach? Albo zrobić virtual OnXYZPropertyChangeddla każdego DependencyProperty? Fuj.

---Edytować---

Moje rozwiązanie powyżej wygląda dziwnie w edytorze XAML - podpowiedź zawsze się wyświetla, blokując część tekstu w Visual Studio!

Oto lepszy sposób rozwiązania tego problemu:

Niektóre 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>

Jakiś kod:

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

Wniosek: Coś jest innego w przypadku klas ToolTipi ContextMenu. Obie mają klasy „usług”, takie jak ToolTipServicei ContextMenuService, które zarządzają określonymi właściwościami i obie używają Popupjako „tajnej” kontroli nadrzędnej podczas wyświetlania. Wreszcie zauważyłem, że WSZYSTKIE przykłady etykiet narzędzi XAML w Internecie nie używają klasy ToolTipbezpośrednio. Zamiast tego osadzają a StackPanelz TextBlocks. Rzeczy, które sprawiają, że mówisz: „hmmm ...”

Prawdopodobnie chcesz użyć Popup zamiast Tooltip, ponieważ Tooltip zakłada, że ​​używasz go zgodnie z predefiniowanymi standardami interfejsu użytkownika.

Nie jestem pewien, dlaczego StaysOpen nie działa, ale ShowDuration działa zgodnie z dokumentacją w MSDN - jest to czas, przez który podpowiedź jest wyświetlana, GDY jest wyświetlana. Ustaw małą wartość (np. 500 ms), aby zobaczyć różnicę.

Sztuczka w twoim przypadku polega na utrzymaniu stanu „ostatniej aktywowanej kontroli”, ale kiedy już to zrobisz, zmiana miejsca docelowego i zawartości dynamicznie (ręcznie lub przez powiązanie) powinna być dość trywialna, jeśli używasz jednego Popup, lub ukrywanie ostatniego widocznego Popup, jeśli używasz wielu.

Istnieje kilka problemów z wyskakującymi okienkami, jeśli chodzi o zmianę rozmiaru i przesuwanie okna (wyskakujące okienka nie poruszają się w / w kontenerach), więc możesz również mieć to na uwadze podczas dostosowywania zachowania. Zobacz ten link, aby uzyskać więcej informacji.

HTH.

Jeśli chcesz określić, że tylko niektóre elementy w twoim Windowmają efektywnie nieokreślony czas ToolTiptrwania, możesz zdefiniować Stylew swoim Window.Resourcesdla tych elementów. Oto Stylefor, Buttonktóry ma taki 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.">
    ...

Można również dodać, Style.Resourcesaby Stylezmienić wygląd ToolTippokazanych na nim pokazów, na przykład:

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

Uwaga: Kiedy to zrobiłem, użyłem również BasedOnw programie, Stylewięc wszystko inne zdefiniowane dla wersji mojej kontrolki niestandardowej z normalnym ToolTipzostanie zastosowane.

Zmagałem się z WPF Tooltip dopiero niedawno. Wydaje się, że nie da się powstrzymać tego przed pojawieniem się i zniknięciem, więc w końcu postanowiłem zająć się tym Openedwydarzeniem. Na przykład chciałem zatrzymać otwieranie go, chyba że ma jakąś treść, więc obsłużyłem Openedzdarzenie, a potem zrobiłem to:

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

To hack, ale zadziałał.

Prawdopodobnie mógłbyś w podobny sposób obsłużyć Closedzdarzenie i nakazać mu ponowne otwarcie, dzięki czemu jest widoczne.

Gwoli ścisłości: w kodzie wygląda to tak:

ToolTipService.SetShowDuration(element, 60000);

Ponadto, jeśli kiedykolwiek zechcesz umieścić jakąkolwiek inną kontrolę w swojej podpowiedzi, nie będzie można jej skupić, ponieważ sama podpowiedź może uzyskać fokus. Tak jak powiedział Micahtan, najlepszym strzałem jest Popup.

Naprawiono mój problem za pomocą tego samego kodu.

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

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

To działa dla mnie. Skopiuj ten wiersz do konstruktora klasy.