WPF anzeigen Daten aus mehreren Datacontexts in Quick-Info von Items

Question

Ich versuche, für ein Element von einer ItemsControl erzeugte ein Tooltip angezeigt werden, die Daten aus konzeptionell unabhängigen Quellen zu ziehen braucht. Zum Beispiel, sagen, dass ich ein Item-Klasse haben wie folgt:

public class Item
{
    public string ItemDescription { get; set; }
    public string ItemName { get; set; }
}

Ich kann innerhalb eines Itemscontrol mit einem Tooltip die Artikel angezeigt werden wie folgt:

<ItemsControl x:Name="itemsControl" ItemsSource="{Binding Items}">
    <ItemsControl.ItemTemplate>
        <DataTemplate>
            <TextBlock Text="{Binding ItemName}">
                <TextBlock.ToolTip>
                    <ToolTip>
                        <TextBlock Text="{Binding ItemDescription}" />
                    </ToolTip>
                </TextBlock.ToolTip>
            </TextBlock>
        </DataTemplate>
    </ItemsControl.ItemTemplate>
</ItemsControl>

Aber ich sage eine andere Eigenschaft haben, die über die DataContext des ItemsControl zugegriffen werden kann. Gibt es eine Möglichkeit, dies innerhalb der Tooltip zu tun? Z.B.

<ItemsControl x:Name="itemsControl" ItemsSource="{Binding Items}">
    <ItemsControl.ItemTemplate>
        <DataTemplate>
            <TextBlock Text="{Binding ItemName}">
                <TextBlock.ToolTip>
                    <ToolTip>
                        <Grid>
                            <Grid.RowDefinitions>
                                <RowDefinition />
                                <RowDefinition />
                            </Grid.RowDefinitions>
                            <TextBlock Text="{Binding ItemDescription}" />
                            <TextBlock Grid.Row="1" Text="{Bind this to another property of the ItemsControl DataContext}" />
                        </Grid>
                    </ToolTip>
                </TextBlock.ToolTip>
            </TextBlock>
        </DataTemplate>
    </ItemsControl.ItemTemplate>
</ItemsControl>

Der Code für das Testfenster I verwendet wird, ist wie folgt:

public partial class Window1 : Window
{
    public Window1()
    {
        InitializeComponent();

        List<Item> itemList = new List<Item>() {
            new Item() { ItemName = "First Item", ItemDescription = "This is the first item." },
            new Item() { ItemName = "Second Item", ItemDescription = "This is the second item." } 
        };

        this.Items = itemList;
        this.GlobalText = "Something else for the tooltip.";
        this.DataContext = this;
    }

    public string GlobalText { get; private set; }

    public List<Item> Items { get; private set; }
}

Also in diesem Beispiel möchte ich den Wert der GlobalText Eigenschaft zeigen (in Wirklichkeit wäre dies ein weiteres benutzerdefiniertes Objekt sein).

Angelegenheiten erschweren, verwende ich eigentlich Datatemplates und zeigen zwei verschiedene Arten von Objekten innerhalb des Items, aber jede Hilfe wäre sehr geschätzt!

Answer 1

Nach einer Stunde Haare ziehen ich zu der Überzeugung gekommen, dass Sie nicht einen anderen Datacontext in einem Datatemplate für eine Quick-Info verweisen können. Für andere Bindungen ist es durchaus möglich, wie andere Plakate unter Beweis gestellt haben. Deshalb sollten Sie nicht den Trick Relative entweder verwenden können. Was Sie tun können, ist eine statische Eigenschaft auf Item-Klasse implementieren und Referenz , die :

<Window x:Class="ToolTipSpike.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="300" Width="300"
    Name="Root"
    xmlns:ToolTipSpike="clr-namespace:ToolTipSpike">
    <Grid>
        <ItemsControl x:Name="itemsControl" ItemsSource="{Binding Items}">
            <ItemsControl.ItemTemplate>
                <DataTemplate>
                    <TextBlock Text="{Binding ItemName}"> 
                        <TextBlock.ToolTip>
                            <ToolTip>
                                <Grid>
                                    <Grid.RowDefinitions>
                                        <RowDefinition />
                                        <RowDefinition />
                                    </Grid.RowDefinitions>
                                    <TextBlock Text="{Binding ItemDescription}" />
                                    <TextBlock Grid.Row="1" 
                   Text="{Binding Source={x:Static ToolTipSpike:Item.GlobalText},
                   Path=.}"
                                    />
                                </Grid>
                            </ToolTip>
                        </TextBlock.ToolTip>
                    </TextBlock>
                </DataTemplate>
            </ItemsControl.ItemTemplate>
        </ItemsControl>
    </Grid>
</Window>

using System.Collections.Generic;
using System.Windows;

namespace ToolTipSpike
{
    public partial class Window1 : Window
    {

        public List<Item> Items { get; private set; }
        public Window1()
        {
            InitializeComponent();
            var itemList = new List<Item>
                  {
                      new Item { ItemName = "First Item", ItemDescription = "This is the first item." },
                      new Item { ItemName = "Second Item", ItemDescription = "This is the second item." }
                  };
            this.Items = itemList;
            this.DataContext = this;
       }
    }

     public class Item
     {
         static Item()
         {
             GlobalText = "Additional Text";
         }
         public static string GlobalText { get; set; }
         public string ItemName{ get; set;}
         public string ItemDescription{ get; set;}
     }
}

Answer 2

Zweiter Versuch

Ok, die Relative Quelle Bindung funktioniert nicht in diesem Fall . Es funktioniert tatsächlich aus einer Datenvorlage, können Sie viele Beispiele dafür auf dem Internete finden. Aber hier (Sie waren richtig, David, in Ihrem Kommentar) ist ToolTip ein besonderes Tier, das nicht richtig in dem VisualTree platziert ist (es ist eine Eigenschaft, nicht eine Kontrolle per se), und es hat keinen Zugriff auf den richtigen Namen Umfang verwenden relative Bindung.

Nach weiterer Suche gefunden: diesen Artikel , die diesen Effekt im Detail beschreibt und schlägt eine Implementierung eines BindableToolTip.

Es könnte zuviel des Guten sein, weil Sie andere Optionen haben -. Wie eine statische Eigenschaft einer Klasse (wie in Dabblernl Antwort) oder das Hinzufügen einer neuen Instanz Eigenschaft auf Ihre Item

Erster Versuch:)

Sie sollten mit den Relative Quelle Binding-Typen (in dieser Spickzettel Beispiel):

So Ihre Bindung sieht irgendwie ähnlich wie folgt aus:

{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type ItemsControl}}, Path= GlobalText}

Answer 3

Fast richtig Yacoder und vermutete Art und Weise falsch es Dabblernl;)

Ihre Denkweise ist richtig und es ist möglich, die Datacontext Ihrer Items

referenzieren

Sie fehlen die Datacontext-Eigenschaft in Pfad:

{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type ItemsControl}}, Path=DataContext.GlobalText}

Zweiter Versuch;)

http: / /blogs.msdn.com/tom_mathews/archive/2006/11/06/binding-a-tooltip-in-xaml.aspx

Hier ist ein Artikel mit dem gleichen Problem. Sie können die Datacontext ihrer Eltern Kontrolle durch die Placement Eigenschaft verweisen:

<ToolTip DataContext=”{Binding RelativeSource={RelativeSource Self},Path=PlacementTarget.Parent}”>

Wenn Sie die Datacontext auf einer tieferen Ebene platzieren würde, vermeiden Sie, wenn Sie Ihre Artikel Datacontext

  

Ein zweiter Vorschlag (Neil und Adam Smith) war, dass wir Placement in der Bindung nutzen könnten. Das ist schön, wie ich eigentlich bin, das Datacontext bereits von der Seite zu erben, die die Datacontrol hostet, und dies ermöglicht es der Quick-Info Zugriff auf die origial Kontrolle zurück zu gewinnen. Wie Adam bemerkte, obwohl, müssen Sie die Eltern / Kind-Struktur aus Ihrem Markup darüber im Klaren sein:

Answer 4

Dies ist ein Fall, wo ich denke, es ist vom Konzept her besser geeignet dieses in dem View-Modell zu tun, als es ohnehin in der Ansicht ist. Setzen Sie die Tooltip Informationen zu der Ansicht, als Eigenschaft der View-Modells Artikel. Das läßt die Ansicht tun, was es ist gut (präsentierenden Eigenschaften des Elements) und das View-Modell zu tun, was es ist gut (zu entscheiden, welche Informationen dargestellt werden).

Answer 5

hatte ich ein sehr ähnliches Problem und kamen Antworten auf diese Frage zu suchen. Am Ende kam ich mit einer anderen Lösung, die in meinem Fall gearbeitet und kann für andere nützlich sein.

In meiner Lösung, habe ich eine Eigenschaft, um das Kind Element, das das übergeordnete Modell verweist, und es aufgefüllt, wenn die Kinder generiert wurden. In der XAML für die Quick-Info, ich dann einfach die Eigenschaft aus dem Muttermodell verweisen auf jedes Element und legen Sie den Datacontext auf die übergeordnete Modelleigenschaft.

ich mit dieser Lösung wohler fühlte als Proxy-Elemente in XAML Erstellen und Referenzierung.

den Beispielcode für diese Frage verwenden, würden Sie die folgende tun. Hinweis Ich habe nicht dieses Szenario in einem Compiler getestet, aber habe so erfolgreich umgesetzt, diese Lösung in dem Code für mein eigenes Szenario getan.

Item:

public class Item
{
    public List<Item> Parent { get; set; }
    public string ItemDescription { get; set; }
    public string ItemName { get; set; }
}

Fenster:

public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();

            List<Item> itemList = new List<Item>();
            itemList.Add(new Item() { Parent = this, ItemName = "First Item", ItemDescription = "This is the first item." });
            itemList.Add(new Item() { Parent = this, ItemName = "Second Item", ItemDescription = "This is the second item." });


            this.Items = itemList;
            this.GlobalText = "Something else for the tooltip.";
            this.DataContext = this;
        }

        public string GlobalText { get; private set; }

        public List<Item> Items { get; private set; }
    }

XAML:

<ItemsControl x:Name="itemsControl" ItemsSource="{Binding Items}">
    <ItemsControl.ItemTemplate>
        <DataTemplate>
            <TextBlock Text="{Binding ItemName}">
                <TextBlock.ToolTip>
                    <ToolTip>
                        <Grid>
                            <Grid.RowDefinitions>
                                <RowDefinition />
                                <RowDefinition />
                            </Grid.RowDefinitions>
                            <TextBlock Text="{Binding ItemDescription}" />
                            <TextBlock Grid.Row="1" DataContext={Binding Parent} Text="{Bind this to aproperty of the parent data model}" />
                        </Grid>
                    </ToolTip>
                </TextBlock.ToolTip>
            </TextBlock>
        </DataTemplate>
    </ItemsControl.ItemTemplate>
</ItemsControl>