Wie programm ein Element in einem WPF TreeView wählen?

StackOverflow https://stackoverflow.com/questions/413890

Frage

Wie ist es möglich, ein Element in einem WPF TreeView programmatisch zu wählen? Das ItemsControl Modell scheint es, zu verhindern.

War es hilfreich?

Lösung

Es ist ein echter Schmerz aus irgendeinem seltsamen Grund, Sie haben ContainerFromItem zu verwenden, um den Behälter zu erhalten, dann die select-Methode aufrufen. 

//  selectedItemObject is not a TreeViewItem, but an item from the collection that 
//  populated the TreeView.

var tvi = treeView.ItemContainerGenerator.ContainerFromItem(selectedItemObject) 
          as TreeViewItem;

if (tvi != null)
{
    tvi.IsSelected = true;
}

Es war einmal ein Blog-Eintrag auf, wie es hier , aber der Link ist tot.

Andere Tipps

Für diejenigen, die noch für die richtige Lösung für dieses Problem hier suchen, ist das eine unten. Ich fand diese in den Kommentaren zu dem Code Project Artikel „WPF TreeView Selection“ http: // www.codeproject.com/KB/WPF/TreeView_SelectionWPF.aspx von DaWanderer. Es wurde von Kenrae am 25. November veröffentlicht 2008. Das ist für mich großartig gearbeitet. Dank Kenrae!

Hier ist sein Beitrag:

Statt den Baum des Gehens, haben eine eigene Datenobjekt haben die IsSelected Eigenschaft (und ich empfehle auch die IsExpanded Eigenschaft). Definieren Sie einen Stil für die TreeViewItems des Baumes der ItemContainerStyle Eigenschaft auf dem TreeView verwenden, um diese Eigenschaften von der TreeViewItem auf Ihre Datenobjekte bindet. So etwas wie folgt aus: 

<Style x:Key="LibraryTreeViewItemStyle"
               TargetType="{x:Type TreeViewItem}">
            <Setter Property="IsExpanded"
                        Value="{Binding IsExpanded, Mode=TwoWay}" />
            <Setter Property="IsSelected"
                        Value="{Binding IsSelected, Mode=TwoWay}" />
            <Setter Property="FontWeight"
                        Value="Normal" />
            <Style.Triggers>
                  <Trigger Property="IsSelected"
                              Value="True">
                        <Setter Property="FontWeight"
                                    Value="Bold" />
                  </Trigger>
            </Style.Triggers>
      </Style>

<TreeView ItemsSource="{Binding Path=YourCollection}"
               ItemContainerStyle="{StaticResource LibraryTreeViewItemStyle}"
               ItemTemplate={StaticResource YourHierarchicalDataTemplate}/>

Sie müssen die TreeViewItem bekommen und dann setzen IsSelected true.

Ich habe mit diesem Code gelungen: 

public static TreeViewItem FindTviFromObjectRecursive(ItemsControl ic, object o) {
  //Search for the object model in first level children (recursively)
  TreeViewItem tvi = ic.ItemContainerGenerator.ContainerFromItem(o) as TreeViewItem;
  if (tvi != null) return tvi;
  //Loop through user object models
  foreach (object i in ic.Items) {
    //Get the TreeViewItem associated with the iterated object model
    TreeViewItem tvi2 = ic.ItemContainerGenerator.ContainerFromItem(i) as TreeViewItem;
    tvi = FindTviFromObjectRecursive(tvi2, o);
    if (tvi != null) return tvi;
  }
  return null;
}

Verbrauch: 

var tvi = FindTviFromObjectRecursive(TheTreeView, TheModel);
if (tvi != null) tvi.IsSelected = true;

Das ist nicht so einfach, wie es aussieht, sofern die Verbindung von Steven eine Lösung im Jahr 2008 veröffentlicht hat, der kann immer noch funktioniert, aber nicht kümmern virtualisierter TreeViews. Darüber hinaus viele andere Probleme werden in den Kommentaren dieses Artikels erwähnt. Kein Vergehen, aber ich bin auch mit dem gleichen Problem stecken und kann nicht eine perfekte Lösung finden. Hier sind die Links zu einigen der Artikel / Beiträge, die mir sehr geholfen -

Wie kann ich Elemente in einem TreeView erweitern? - Teil III: http://bea.stollnitz.com/blog/?p=59

ein Element programmgesteuert in einem TreeView-Auswahl: http: // blog. quantumbitdesigns.com/2008/07/22/programmatically-selecting-an-item-in-a-treeview/#respond

TreeView, TreeViewItem und IsSelected: http: // sozial. msdn.microsoft.com/Forums/en-US/wpf/thread/7e368b93-f509-4cd6-88e7-561e8d3246ae/

Ich schrieb eine Erweiterungsmethode: 

using System.Windows.Controls;

namespace Extensions
{
    public static class TreeViewEx
    {
        /// <summary>
        /// Select specified item in a TreeView
        /// </summary>
        public static void SelectItem(this TreeView treeView, object item)
        {
            var tvItem = treeView.ItemContainerGenerator.ContainerFromItem(item) as TreeViewItem;
            if (tvItem != null)
            {
                tvItem.IsSelected = true;
            }
        }
    }
}

Was ich kann wie folgt verwendet werden: 

if (_items.Count > 0)
    _treeView.SelectItem(_items[0]);

Wenn Sie innerhalb von Kindern Kind befindet sich um ein Element auszuwählen möchten, können Sie Benutzer Rekursion, das zu tun. 

public bool Select(TreeViewItem item, object select) // recursive function to set item selection in treeview
{
    if (item == null)
        return false;
    TreeViewItem child = item.ItemContainerGenerator.ContainerFromItem(select) as TreeViewItem;
    if (child != null)
    {
        child.IsSelected = true;
        return true;
    }
    foreach (object c in item.Items)
    {
        bool result = Select(item.ItemContainerGenerator.ContainerFromItem(c) as TreeViewItem, select);
        if (result == true)
            return true;
    }
    return false;
}

mit Try this 

    /// <summary>
    /// Selects the tree view item.
    /// </summary>
    /// <param name="Collection">The collection.</param>
    /// <param name="Value">The value.</param>
    /// <returns></returns>
    private TreeViewItem SelectTreeViewItem(ItemCollection Collection, String Value)
    {
        if (Collection == null) return null;
        foreach(TreeViewItem Item in Collection)
        {
            /// Find in current
            if (Item.Header.Equals(Value))
            {
                Item.IsSelected = true;
                return Item;
            }
            /// Find in Childs
            if (Item.Items != null)
            {
                TreeViewItem childItem = this.SelectTreeViewItem(Item.Items, Value);
                if (childItem != null)
                {
                    Item.IsExpanded = true;
                    return childItem;
                }
            }
        }
        return null;
    }

Referenz: http://amastaneh.blogspot.com/ 2011/06 / wpf-SelectedValue-for-treeview.html

dachte nur, dass ich mit der Lösung läuten würde ich ging, falls dies jemand helfen kann. Beachten Sie, dass der beste Weg, dies zu tun, ist eine gebundene Eigenschaft verwendet wie ‚IsSelected‘ wie pro kuninl Antwort, aber in meinem Fall war es eine Legacy-Anwendung, die nicht MVVM folgte, so landete ich mit der unten. 

private void ChangeSessionSelection()
{
    foreach (SessionContainer item in this.treeActiveSessions.Items)
    {
        var treeviewItem = this.treeActiveSessions.ItemContainerGenerator.ContainerFromItem(item) as TreeViewItem;

        if (item.Session == this.selectedSession.Session)
        {
            treeviewItem.IsSelected = true;
            treeviewItem.IsExpanded = true;
        }
        else
        {
            treeviewItem.IsSelected = false;
            treeviewItem.IsExpanded = false;
        }
    }            
}

Was das bedeutet ist, wählen und den Strukturansichtspunkt in der Benutzeroberfläche erweitern, die die ausgewählte Dataitem in der Code-behind darstellt. Der Zweck war die Änderung der Auswahl in der Baumstruktur haben, wenn die Benutzer-Auswahl in einem Artikel geändert im selben Fenster zu steuern.

Ich habe eine Methode VisualTreeExt.GetDescendants<T> erstellt, die eine zählbare Auflistung von Elementen zurück, die den angegebenen Typen entsprechen: 

public static class VisualTreeExt
{
  public static IEnumerable<T> GetDescendants<T>(DependencyObject parent) where T : DependencyObject
  {
    var count = VisualTreeHelper.GetChildrenCount(parent);
    for (var i = 0; i < count; ++i)
    {
       // Obtain the child
       var child = VisualTreeHelper.GetChild(parent, i);
       if (child is T)
         yield return (T)child;

       // Return all the descendant children
       foreach (var subItem in GetDescendants<T>(child))
         yield return subItem;
    }
  }
}

Wenn Sie sich für VisualTreeHelperExt.GetDescendants<TreeViewItem>(MyAmazingTreeView) fragen finden Sie alle TreeViewItem Childs bekommen. Sie können einen bestimmten Wert wählen Sie das folgende Stück Code verwendet: 

var treeViewItem = VisualTreeExt.GetDescendants<TreeViewItem>(MyTreeView).FirstOrDefault(tvi => tvi.DataContext == newValue);
if (treeViewItem != null)
  treeViewItem.IsSelected = true;

Es ist ein bisschen von einer schmutzigen Lösung (und wahrscheinlich nicht die effizienteste) und wird nicht funktionieren, wenn Sie eine virtualisierte TreeView verwenden, weil es auf der Existenz der tatsächlichen visuellen Elemente abhängt. Aber es funktioniert für meine Situation ...

Ja .. Ich weiß Vergangenheit viele Jahre her, seit die Frage gestellt wurde, aber .. noch keine schnelle Lösung für dieses Problem .. und so:

Im Folgenden wird das tun, was der OP gefragt.

Was ich im Grunde getan wird alle Antworten auf dieser Seite zu lesen und im Anschluss an alle relevanten Links ein erstellen ein für alle Mal Lösung für dieses Problem irritierend.

Vorteile:

  • Es Virtualisieren TreeView unterstützen auch.
  • Sie das Verhalten Technik, so XAML Weise einfach ist.
  • Fügt eine dependancy-Eigenschaft auf den ausgewählten TreeView Artikel zu ermöglichen, verbindlich.


Dieser Teil ist der einzige Code, den Sie kopieren müssen, sind die anderen Teile nur zu helfen, ein Beispiel abzuschließen. 

public static class TreeViewSelectedItemExBehavior
{
    private static List<TreeView> isRegisteredToSelectionChanged = new List<TreeView>();

    public static readonly DependencyProperty SelectedItemExProperty =
        DependencyProperty.RegisterAttached("SelectedItemEx",
            typeof(object),
            typeof(TreeViewSelectedItemExBehavior),
            new FrameworkPropertyMetadata(new object(), FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnSelectedItemExChanged, null));

    #region SelectedItemEx

    public static object GetSelectedItemEx(TreeView target)
    {
        return target.GetValue(SelectedItemExProperty);
    }

    public static void SetSelectedItemEx(TreeView target, object value)
    {
        target.SetValue(SelectedItemExProperty, value);
        var treeViewItemToSelect = GetTreeViewItem(target, value);
        if (treeViewItemToSelect == null)
        {
            if (target.SelectedItem == null)
                return;
            var treeViewItemToUnSelect = GetTreeViewItem(target, target.SelectedItem);
            treeViewItemToUnSelect.IsSelected = false;
        }
        else
            treeViewItemToSelect.IsSelected = true;
    }

    public static void OnSelectedItemExChanged(DependencyObject depObj, DependencyPropertyChangedEventArgs e)
    {
        var treeView = depObj as TreeView;
        if (treeView == null)
            return;
        if (!isRegisteredToSelectionChanged.Contains(treeView))
        {
            treeView.SelectedItemChanged += TreeView_SelectedItemChanged;
            isRegisteredToSelectionChanged.Add(treeView);
        }
    }

    #endregion

    private static void TreeView_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs<object> e)
    {
        var treeView = (TreeView)sender;
        SetSelectedItemEx(treeView, e.NewValue);
    }

    #region Helper Structures & Methods

    public class MyVirtualizingStackPanel : VirtualizingStackPanel
    {
        /// <summary>
        /// Publically expose BringIndexIntoView.
        /// </summary>
        public void BringIntoView(int index)
        {
            BringIndexIntoView(index);
        }
    }

    /// <summary>Recursively search for an item in this subtree.</summary>
    /// <param name="container">The parent ItemsControl. This can be a TreeView or a TreeViewItem.</param>
    /// <param name="item">The item to search for.</param>
    /// <returns>The TreeViewItem that contains the specified item.</returns>
    private static TreeViewItem GetTreeViewItem(ItemsControl container, object item)
    {
        if (container != null)
        {
            if (container.DataContext == item)
            {
                return container as TreeViewItem;
            }

            // Expand the current container
            if (container is TreeViewItem && !((TreeViewItem)container).IsExpanded)
            {
                container.SetValue(TreeViewItem.IsExpandedProperty, true);
            }

            // Try to generate the ItemsPresenter and the ItemsPanel.
            // by calling ApplyTemplate.  Note that in the 
            // virtualizing case even if the item is marked 
            // expanded we still need to do this step in order to 
            // regenerate the visuals because they may have been virtualized away.

            container.ApplyTemplate();
            ItemsPresenter itemsPresenter =
                (ItemsPresenter)container.Template.FindName("ItemsHost", container);
            if (itemsPresenter != null)
            {
                itemsPresenter.ApplyTemplate();
            }
            else
            {
                // The Tree template has not named the ItemsPresenter, 
                // so walk the descendents and find the child.
                itemsPresenter = FindVisualChild<ItemsPresenter>(container);
                if (itemsPresenter == null)
                {
                    container.UpdateLayout();

                    itemsPresenter = FindVisualChild<ItemsPresenter>(container);
                }
            }

            Panel itemsHostPanel = (Panel)VisualTreeHelper.GetChild(itemsPresenter, 0);


            // Ensure that the generator for this panel has been created.
            UIElementCollection children = itemsHostPanel.Children;

            MyVirtualizingStackPanel virtualizingPanel =
                itemsHostPanel as MyVirtualizingStackPanel;

            for (int i = 0, count = container.Items.Count; i < count; i++)
            {
                TreeViewItem subContainer;
                if (virtualizingPanel != null)
                {
                    // Bring the item into view so 
                    // that the container will be generated.
                    virtualizingPanel.BringIntoView(i);

                    subContainer =
                        (TreeViewItem)container.ItemContainerGenerator.
                        ContainerFromIndex(i);
                }
                else
                {
                    subContainer =
                        (TreeViewItem)container.ItemContainerGenerator.
                        ContainerFromIndex(i);

                    // Bring the item into view to maintain the 
                    // same behavior as with a virtualizing panel.
                    subContainer.BringIntoView();
                }

                if (subContainer != null)
                {
                    // Search the next level for the object.
                    TreeViewItem resultContainer = GetTreeViewItem(subContainer, item);
                    if (resultContainer != null)
                    {
                        return resultContainer;
                    }
                    else
                    {
                        // The object is not under this TreeViewItem
                        // so collapse it.
                        subContainer.IsExpanded = false;
                    }
                }
            }
        }

        return null;
    }

    /// <summary>Search for an element of a certain type in the visual tree.</summary>
    /// <typeparam name="T">The type of element to find.</typeparam>
    /// <param name="visual">The parent element.</param>
    /// <returns></returns>
    private static T FindVisualChild<T>(Visual visual) where T : Visual
    {
        for (int i = 0; i < VisualTreeHelper.GetChildrenCount(visual); i++)
        {
            Visual child = (Visual)VisualTreeHelper.GetChild(visual, i);
            if (child != null)
            {
                T correctlyTyped = child as T;
                if (correctlyTyped != null)
                {
                    return correctlyTyped;
                }

                T descendent = FindVisualChild<T>(child);
                if (descendent != null)
                {
                    return descendent;
                }
            }
        }
        return null;
    }

    #endregion
}

Und dies ist ein Beispiel dafür, wie die TreeView Linie sieht aus wie in XAML: 

<TreeView x:Name="trvwSs"
          Grid.Column="2" Grid.Row="1" Margin="4" ItemsSource="{Binding ItemsTreeViewSs}"
          behaviors:TreeViewSelectedItemExBehavior.SelectedItemEx="{Binding SelectedItemTreeViewSs}" />

Das einzige, was zu befürchten ist, dass Ihr View-Modell Eigentum zu machen, die Sie zu gebunden an SelectedItemEx nicht null sind. Aber das ist kein Sonderfall .. Nur erwähnte es bei Menschen verwirren. 

public class VmMainContainer : INotifyPropertyChanged
{
    private object selectedItemTreeViewSs = new object();
    private ObservableCollection<object> selectedItemsTreeViewSs = new ObservableCollection<object>();
    private ObservableCollection<VmItem> itemsTreeViewSs = new ObservableCollection<VmItem>();

 public object SelectedItemTreeViewSs
        {
            get
            {
                return selectedItemTreeViewSs;
            }
            set
            {
                selectedItemTreeViewSs = value;
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(SelectedItemTreeViewSs)));
            }
        }

public ObservableCollection<object> SelectedItemsTreeViewSs
        {
            get
            {
                return selectedItemsTreeViewSs;
            }
            set
            {
                selectedItemsTreeViewSs = value;
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(SelectedItemsTreeViewSs)));
            }
        }

 public ObservableCollection<VmItem> ItemsTreeViewSs
        {
            get { return itemsTreeViewSs; }
            set
            {
                itemsTreeViewSs = value;
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(ItemsTreeViewSs)));
            }
        }
    }

Und letzte, was .. Beispiel für die Auswahl programmatisch: Ich habe eine Schaltfläche auf meiner MainWindow.xaml und von seinem Handler .. 

private void Button_Click(object sender, RoutedEventArgs e)
{
    TreeViewSelectedItemExBehavior.SetSelectedItemEx(trvwSs, trvwSs.Items[3]);
    //TreeViewSelectedItemExBehavior.SetSelectedItemEx(trvwSs, null);
}

Hope, das hilft jemand:)

Sie können es über Code tun hinter wie 

if (TreeView1.Items.Count > 0)
        (TreeView1.Items[0] as TreeViewItem).IsSelected = true;

Ich denke, dies ist die einfachste Lösung: 

private void MouseDownEventProcessing(TreeNodeMouseClickEventArgs e)
{
    tvEmployeeDirectory.SelectedNode = e.Node;
}

Die vorgeschlagene Antwort funktioniert nicht. @ Fandisusanto Antwort wahrscheinlich nicht funktioniert, aber es kann einfacher gemacht werden. Dies ist die einfachste Antwort, die ich mit oben kommen kann: 

    private static void DeselectTreeViewItem(IEnumerable<TreeViewItem> treeViewItems)
    {
        foreach (var treeViewItem in treeViewItems)
        {
            if (treeViewItem.IsSelected)
            {
                treeViewItem.IsSelected = false;
                return;
            }

            DeselectTreeViewItem(treeViewItem.Items.Cast<TreeViewItem>());
        }
    }

Verbrauch: 

    private void ClearSelectedItem()
    {
        if (AssetTreeView.SelectedItem != null)
        {
            DeselectTreeViewItem(AssetTreeView.Items.Cast<TreeViewItem>());
        }
    }
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top