Comment sélectionner par programme un élément dans un WPF TreeView?
Comment est-il possible de sélectionner par programme un élément dans une variable WPF TreeView? Le modèle ItemsControl semble l’empêcher.
C'est une vraie douleur pour une raison étrange, vous devez utiliser ContainerFromItem pour obtenir le conteneur, puis appeler la méthode select.
// 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;
}
Il était une fois un article de blog sur la façon de le faire ici , mais le lien est mort maintenant.
Pour ceux qui recherchent toujours la bonne solution à ce problème, voici celle ci-dessous. J'ai trouvé celui-ci dans les commentaires de l'article de Code Project «WPF TreeView Selection» http://www.codeproject.com/KB/WPF/TreeView_SelectionWPF.aspx deanneranderer . 25 novembre 2008. Cela a très bien fonctionné pour moi. Merci Kenrae!
Voici son post:
Au lieu de parcourir l'arborescence, demandez à votre propre objet de données d'avoir la propriété IsSelected (et je recommande également la propriété IsExpanded). Définissez un style pour les TreeViewItems de l'arborescence à l'aide de la propriété ItemContainerStyle sur TreeView qui lie ces propriétés de TreeViewItem à vos objets de données. Quelque chose comme ça:
<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}/>
Vous devez obtenir la variable TreeViewItem, puis définir IsSelected à true.
J'ai réussi avec ce code:
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;
}
Usage:
var tvi = FindTviFromObjectRecursive(TheTreeView, TheModel);
if (tvi != null) tvi.IsSelected = true;
J'ai écrit une méthode d'extension:
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;
}
}
}
}
Que je peux utiliser comme ceci:
if (_items.Count > 0)
_treeView.SelectItem(_items[0]);
Si vous souhaitez sélectionner un élément situé dans les enfants de l'enfant, vous pouvez utiliser la récursivité pour le faire.
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;
}
J'ai créé une méthode VisualTreeExt.GetDescendants<T> qui renvoie une collection énumérable d'éléments correspondant au type spécifié:
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;
}
}
}
Lorsque vous demandez VisualTreeHelperExt.GetDescendants<TreeViewItem>(MyAmazingTreeView), vous obtenez tous les enfants TreeViewItem. Vous pouvez sélectionner une valeur particulière en utilisant le code suivant:
var treeViewItem = VisualTreeExt.GetDescendants<TreeViewItem>(MyTreeView).FirstOrDefault(tvi => tvi.DataContext == newValue);
if (treeViewItem != null)
treeViewItem.IsSelected = true;
C'est une solution un peu sale (et probablement pas la plus efficace) et ne fonctionnera pas si vous utilisez un TreeView virtualisé, car cela dépend de l'existence des éléments visuels. Mais cela fonctionne pour ma situation ...
Je pensais juste à la solution que j'avais choisie, au cas où cela pourrait aider quelqu'un. Notez que la meilleure façon de le faire est d'utiliser une propriété liée telle que 'IsSelected' selon la réponse de kuninl, mais dans mon cas, il s'agissait d'une application héritée qui ne suivait pas MVVM.
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;
}
}
}
Cela permet de sélectionner et de développer l'élément de l'arborescence dans l'interface utilisateur qui représente le dataitem sélectionné dans le code derrière. L'objectif était de modifier la sélection dans l'arborescence lorsque la sélection des utilisateurs était modifiée dans un contrôle d'éléments de la même fenêtre.
Ouais .. Je sais depuis bien des années depuis que la question a été posée mais .. toujours pas de solution rapide à ce problème .. et donc:
Ce qui suit fera ce que le PO a demandé.
Ce que j’ai fait en gros est de lire toutes les réponses sur cette page et de suivre tous les liens pertinents pour créer une solution une fois pour toutes à ce problème irritant.
Avantages:
- Il prend également en charge la virtualisation de TreeView.
- Il utilise la technique du comportement, le XAML est donc très facile.
- Ajoute une propriété de dépendance pour permettre la liaison à l'élément TreeView sélectionné.
Cette partie est le seul code que vous devez copier, les autres parties servent simplement à compléter un exemple.
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
}
Et voici un exemple de la façon dont la ligne TreeView ressemble à XAML:
<TreeView x:Name="trvwSs"
Grid.Column="2" Grid.Row="1" Margin="4" ItemsSource="{Binding ItemsTreeViewSs}"
behaviors:TreeViewSelectedItemExBehavior.SelectedItemEx="{Binding SelectedItemTreeViewSs}" />
La seule chose à laquelle vous devez vous soucier est de vous assurer que la propriété de modèle de vue que vous allez lier à SelectedItemEx n'est pas nulle. Mais ce n’est pas un cas particulier. Je viens de le mentionner au cas où les gens s’embrouilleraient.
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)));
}
}
}
Et dernière chose .. exemple de sélection par programme: J’ai créé un bouton sur mon MainWindow.xaml et à partir de son gestionnaire ..
private void Button_Click(object sender, RoutedEventArgs e)
{
TreeViewSelectedItemExBehavior.SetSelectedItemEx(trvwSs, trvwSs.Items[3]);
//TreeViewSelectedItemExBehavior.SetSelectedItemEx(trvwSs, null);
}
J'espère que ça aide quelqu'un :)
Je pense que c'est la solution la plus simple:
private void MouseDownEventProcessing(TreeNodeMouseClickEventArgs e)
{
tvEmployeeDirectory.SelectedNode = e.Node;
}
La réponse proposée ne fonctionne pas. La réponse de @ fandisusanto fonctionne probablement, mais elle peut être simplifiée. C'est la réponse la plus simple que je puisse trouver:
private static void DeselectTreeViewItem(IEnumerable<TreeViewItem> treeViewItems)
{
foreach (var treeViewItem in treeViewItems)
{
if (treeViewItem.IsSelected)
{
treeViewItem.IsSelected = false;
return;
}
DeselectTreeViewItem(treeViewItem.Items.Cast<TreeViewItem>());
}
}
Usage:
private void ClearSelectedItem()
{
if (AssetTreeView.SelectedItem != null)
{
DeselectTreeViewItem(AssetTreeView.Items.Cast<TreeViewItem>());
}
}
Essayez avec ça
/// <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;
}
Référence: http://amastaneh.blogspot.com/2011/06/wpf-selectedvalue-for-treeview.html
Vous pouvez le faire via le code derrière comme
if (TreeView1.Items.Count > 0)
(TreeView1.Items[0] as TreeViewItem).IsSelected = true;