Seleccione el nodo TreeView al hacer clic con el botón derecho antes de mostrar ContextMenu

Me gustaría seleccionar un nodo WPF TreeView haciendo clic derecho, justo antes de que se muestre el ContextMenu.

Para WinForms, podría usar un código como este Buscar nodo en el que se hace clic en el menú contextual , ¿cuáles son las alternativas de WPF?

Dependiendo de la forma en que se llenó el árbol, el remitente y los valores de e.Source pueden variar .

Una de las posibles soluciones es usar e.OriginalSource y encontrar TreeViewItem usando VisualTreeHelper:

private void OnPreviewMouseRightButtonDown(object sender, MouseButtonEventArgs e)
{
    TreeViewItem treeViewItem = VisualUpwardSearch(e.OriginalSource as DependencyObject);

    if (treeViewItem != null)
    {
        treeViewItem.Focus();
        e.Handled = true;
    }
}

static TreeViewItem VisualUpwardSearch(DependencyObject source)
{
    while (source != null && !(source is TreeViewItem))
        source = VisualTreeHelper.GetParent(source);

    return source as TreeViewItem;
}

Si desea una solución solo de XAML, puede usar Blend Interactivity.

Suponga que los TreeViewdatos están vinculados a una colección jerárquica de modelos de vista que tienen una Booleanpropiedad IsSelectedy una Stringpropiedad Name, así como una colección de elementos secundarios nombrados Children.

<TreeView ItemsSource="{Binding Items}">
  <TreeView.ItemContainerStyle>
    <Style TargetType="TreeViewItem">
      <Setter Property="IsSelected" Value="{Binding IsSelected, Mode=TwoWay}"/>
    </Style>
  </TreeView.ItemContainerStyle>
  <TreeView.ItemTemplate>
    <HierarchicalDataTemplate ItemsSource="{Binding Children}">
      <TextBlock Text="{Binding Name}">
        <i:Interaction.Triggers>
          <i:EventTrigger EventName="PreviewMouseRightButtonDown">
            <ei:ChangePropertyAction PropertyName="IsSelected" Value="true" TargetObject="{Binding}"/>
          </i:EventTrigger>
        </i:Interaction.Triggers>
      </TextBlock>
    </HierarchicalDataTemplate>
  </TreeView.ItemTemplate>
</TreeView>

Hay dos partes interesantes:

1. La TreeViewItem.IsSelectedpropiedad está vinculada a la IsSelectedpropiedad en el modelo de vista. Establecer la IsSelectedpropiedad en el modelo de vista en verdadero seleccionará el nodo correspondiente en el árbol.

2. Cuando se PreviewMouseRightButtonDowndispara en la parte visual del nodo (en este ejemplo a TextBlock), la IsSelectedpropiedad del modelo de vista se establece en verdadera. Volviendo a 1., puede ver que el nodo correspondiente en el que se hizo clic en el árbol se convierte en el nodo seleccionado.

Una forma de obtener Blend Interactivity en su proyecto es usar el paquete NuGet Unofficial.Blend.Interactivity .

Usando "item.Focus ();" no parece funcionar al 100%, usando "item.IsSelected = true;" hace.

En XAML, agregue un controlador PreviewMouseRightButtonDown en XAML:

    <TreeView.ItemContainerStyle>
        <Style TargetType="{x:Type TreeViewItem}">
            <!-- We have to select the item which is right-clicked on -->
            <EventSetter Event="TreeViewItem.PreviewMouseRightButtonDown" Handler="TreeViewItem_PreviewMouseRightButtonDown"/>
        </Style>
    </TreeView.ItemContainerStyle>

Luego maneja el evento de esta manera:

    private void TreeViewItem_PreviewMouseRightButtonDown( object sender, MouseEventArgs e )
    {
        TreeViewItem item = sender as TreeViewItem;
        if ( item != null )
        {
            item.Focus( );
            e.Handled = true;
        }
    }

Usando la idea original de alex2k8, manejando correctamente los elementos no visuales de Wieser Software Ltd, el XAML de Stefan, el IsSelected de Erlend, y mi contribución de hacer verdaderamente genérico el método estático:

XAML:

<TreeView.ItemContainerStyle> 
    <Style TargetType="{x:Type TreeViewItem}"> 
        <!-- We have to select the item which is right-clicked on --> 
        <EventSetter Event="TreeViewItem.PreviewMouseRightButtonDown"
                     Handler="TreeViewItem_PreviewMouseRightButtonDown"/> 
    </Style> 
</TreeView.ItemContainerStyle>

Código C # detrás:

void TreeViewItem_PreviewMouseRightButtonDown(object sender, MouseButtonEventArgs e)
{
    TreeViewItem treeViewItem = 
              VisualUpwardSearch<TreeViewItem>(e.OriginalSource as DependencyObject);

    if(treeViewItem != null)
    {
        treeViewItem.IsSelected = true;
        e.Handled = true;
    }
}

static T VisualUpwardSearch<T>(DependencyObject source) where T : DependencyObject
{
    DependencyObject returnVal = source;

    while(returnVal != null && !(returnVal is T))
    {
        DependencyObject tempReturnVal = null;
        if(returnVal is Visual || returnVal is Visual3D)
        {
            tempReturnVal = VisualTreeHelper.GetParent(returnVal);
        }
        if(tempReturnVal == null)
        {
            returnVal = LogicalTreeHelper.GetParent(returnVal);
        }
        else returnVal = tempReturnVal;
    }

    return returnVal as T;
}

Editar: el código anterior siempre funcionó bien para este escenario, pero en otro escenario VisualTreeHelper.GetParent devolvió nulo cuando LogicalTreeHelper devolvió un valor, así que lo solucionó.

Casi correcto , pero debes tener cuidado con los elementos no visuales en el árbol (como Run, por ejemplo).

static DependencyObject VisualUpwardSearch<T>(DependencyObject source) 
{
    while (source != null && source.GetType() != typeof(T))
    {
        if (source is Visual || source is Visual3D)
        {
            source = VisualTreeHelper.GetParent(source);
        }
        else
        {
            source = LogicalTreeHelper.GetParent(source);
        }
    }
    return source; 
}

Creo que registrar un controlador de clase debería ser suficiente. Simplemente registre un controlador de eventos enrutados en PreviewMouseRightButtonDownEvent de TreeViewItem en su archivo de código app.xaml.cs como este:

/// <summary>
/// Interaction logic for App.xaml
/// </summary>
public partial class App : Application
{
    protected override void OnStartup(StartupEventArgs e)
    {
        EventManager.RegisterClassHandler(typeof(TreeViewItem), TreeViewItem.PreviewMouseRightButtonDownEvent, new RoutedEventHandler(TreeViewItem_PreviewMouseRightButtonDownEvent));

        base.OnStartup(e);
    }

    private void TreeViewItem_PreviewMouseRightButtonDownEvent(object sender, RoutedEventArgs e)
    {
        (sender as TreeViewItem).IsSelected = true;
    }
}

Otra forma de resolverlo usando MVVM es el comando de enlace para hacer clic derecho en su modelo de vista. Allí puede especificar otra lógica además de source.IsSelected = true. Esto usa solo xmlns:i="http://schemas.microsoft.com/expression/2010/intera‌​ctivity"de System.Windows.Interactivity.

XAML para ver:

<TreeView ItemsSource="{Binding Items}">
  <TreeView.ItemContainerStyle>
    <Style TargetType="TreeViewItem">
      <Setter Property="IsSelected" Value="{Binding IsSelected, Mode=TwoWay}"/>
    </Style>
  </TreeView.ItemContainerStyle>
  <TreeView.ItemTemplate>
    <HierarchicalDataTemplate ItemsSource="{Binding Children}">
      <TextBlock Text="{Binding Name}">
        <i:Interaction.Triggers>
          <i:EventTrigger EventName="PreviewMouseRightButtonDown">
            <i:InvokeCommandAction Command="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}, Path=DataContext.TreeViewItemRigthClickCommand}" CommandParameter="{Binding}" />
          </i:EventTrigger>
        </i:Interaction.Triggers>
      </TextBlock>
    </HierarchicalDataTemplate>
  </TreeView.ItemTemplate>
</TreeView>

Ver modelo:

    public ICommand TreeViewItemRigthClickCommand
    {
        get
        {
            if (_treeViewItemRigthClickCommand == null)
            {
                _treeViewItemRigthClickCommand = new RelayCommand<object>(TreeViewItemRigthClick);
            }
            return _treeViewItemRigthClickCommand;
        }
    }
    private RelayCommand<object> _treeViewItemRigthClickCommand;

    private void TreeViewItemRigthClick(object sourceItem)
    {
        if (sourceItem is Item)
        {
            (sourceItem as Item).IsSelected = true;
        }
    }

Tenía un problema al seleccionar niños con un método HierarchicalDataTemplate. Si selecciono al hijo de un nodo, de alguna manera seleccionaría al padre raíz de ese hijo. Descubrí que el evento MouseRightButtonDown se llamaría para todos los niveles que tenía el niño. Por ejemplo, si tienes un árbol parecido a esto:

Elemento 1
   - Niño 1
   - Niño 2
      - Subitem1
      - Subitemm2

Si seleccioné Subitem2, el evento se dispararía tres veces y se seleccionaría el elemento 1. Resolví esto con una llamada booleana y asincrónica.

private bool isFirstTime = false;
    protected void TaskTreeView_MouseRightButtonDown(object sender, MouseButtonEventArgs e)
    {
        var item = sender as TreeViewItem;
        if (item != null && isFirstTime == false)
        {
            item.Focus();
            isFirstTime = true;
            ResetRightClickAsync();
        }
    }

    private async void ResetRightClickAsync()
    {
        isFirstTime = await SetFirstTimeToFalse();
    }

    private async Task<bool> SetFirstTimeToFalse()
    {
        return await Task.Factory.StartNew(() => { Thread.Sleep(3000); return false; });
    }

Se siente un poco complicado, pero básicamente configuro el booleano en verdadero en la primera pasada y lo restablezco en otro hilo en unos segundos (3 en este caso). Esto significa que el siguiente pasa por donde intentaría moverse hacia arriba, el árbol se saltará, dejándolo con el nodo correcto seleccionado. Parece funcionar hasta ahora :-)

Puede seleccionarlo con el evento on mouse down. Eso activará la selección antes de que se active el menú contextual.

Si desea permanecer dentro del patrón MVVM, puede hacer lo siguiente:

Ver:

<TreeView x:Name="trvName" ItemsSource="{Binding RootElementListView}" Tag="{Binding ClickedTreeElement, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}">
    <TreeView.ItemTemplate>
        <HierarchicalDataTemplate DataType="{x:Type models:YourTreeElementClass}" ItemsSource="{Binding Path=Subreports}">
            <TextBlock Text="{Binding YourTreeElementDisplayProperty}" PreviewMouseRightButtonDown="TreeView_PreviewMouseRightButtonDown"/>
        </HierarchicalDataTemplate>
    </TreeView.ItemTemplate>
</TreeView>

Código detrás:

private void TreeView_PreviewMouseRightButtonDown(object sender, MouseButtonEventArgs e)
{
    if (sender is TextBlock tb && tb.DataContext is YourTreeElementClass te)
    {
        trvName.Tag = te;
    }
}

ViewModel:

private YourTreeElementClass _clickedTreeElement;

public YourTreeElementClass ClickedTreeElement
{
    get => _clickedTreeElement;
    set => SetProperty(ref _clickedTreeElement, value);
}

Ahora puede reaccionar al cambio de propiedad de ClickedTreeElement o puede usar un comando que funcione internamente con ClickedTreeElement.

Vista extendida:

<UserControl ...
             xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity">
    <TreeView x:Name="trvName" ItemsSource="{Binding RootElementListView}" Tag="{Binding ClickedTreeElement, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}">
        <i:Interaction.Triggers>
            <i:EventTrigger EventName="MouseRightButtonUp">
                <i:InvokeCommandAction Command="{Binding HandleRightClickCommand}"/>
            </i:EventTrigger>
        </i:Interaction.Triggers>
        <TreeView.ItemTemplate>
            <HierarchicalDataTemplate DataType="{x:Type models:YourTreeElementClass}" ItemsSource="{Binding Path=Subreports}">
                <TextBlock Text="{Binding YourTreeElementDisplayProperty}" PreviewMouseRightButtonDown="TreeView_PreviewMouseRightButtonDown"/>
            </HierarchicalDataTemplate>
        </TreeView.ItemTemplate>
    </TreeView>
</UserControl>