Selezionare TreeView Node facendo clic con il pulsante destro del mouse prima di visualizzare ContextMenu

Vorrei selezionare un nodo WPF TreeView facendo clic con il pulsante destro del mouse, subito prima che venga visualizzato ContextMenu.

Per WinForms potrei usare codice come questo nodo Trova cliccato nel menu contestuale , quali sono le alternative WPF?

A seconda del modo in cui l'albero è stato popolato, i valori del mittente e di e.Source possono variare .

Una delle possibili soluzioni è utilizzare e.OriginalSource e trovare TreeViewItem utilizzando 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;
}

Se desideri una soluzione solo XAML, puoi utilizzare Blend Interactivity.

Si supponga che i TreeViewdati siano legati a una raccolta gerarchica di modelli di visualizzazione aventi una Booleanproprietà IsSelectede una Stringproprietà Name, nonché una raccolta di elementi figlio denominati 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>

Ci sono due parti interessanti:

1. La TreeViewItem.IsSelectedproprietà è vincolata alla IsSelectedproprietà sul modello di visualizzazione. Impostando la IsSelectedproprietà sul modello di visualizzazione su true si selezionerà il nodo corrispondente nell'albero.

2. Quando PreviewMouseRightButtonDownsi attiva sulla parte visiva del nodo (in questo esempio a TextBlock) la IsSelectedproprietà sul modello di visualizzazione è impostata su true. Tornando a 1. si può vedere che il nodo corrispondente su cui si è fatto clic nell'albero diventa il nodo selezionato.

Un modo per ottenere Blend Interactivity nel progetto consiste nell'usare il pacchetto NuGet Unofficial.Blend.Interactivity .

Utilizzando "item.Focus ();" non sembra funzionare al 100%, utilizzando "item.IsSelected = true;" fa.

In XAML, aggiungi un gestore PreviewMouseRightButtonDown in 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>

Quindi gestisci l'evento in questo modo:

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

Utilizzando l'idea originale di alex2k8, gestendo correttamente le immagini non visive di Wieser Software Ltd, XAML di Stefan, IsSelected di Erlend e il mio contributo per rendere veramente generico il metodo statico:

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>

Codice C # dietro:

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

Modifica: il codice precedente ha sempre funzionato correttamente per questo scenario, ma in un altro scenario VisualTreeHelper.GetParent ha restituito null quando LogicalTreeHelper ha restituito un valore, quindi è stato risolto.

Quasi giusto , ma devi fare attenzione alle immagini non visive nell'albero, (come un Run, per esempio).

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

Penso che la registrazione di un gestore di classi dovrebbe fare il trucco. Basta registrare un gestore di eventi indirizzati su PreviewMouseRightButtonDownEvent di TreeViewItem nel file di codice app.xaml.cs in questo modo:

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

Un altro modo per risolverlo utilizzando MVVM è il comando bind per fare clic con il pulsante destro del mouse sul modello di visualizzazione. Lì puoi specificare altra logica e source.IsSelected = true. Questo utilizza solo xmlns:i="http://schemas.microsoft.com/expression/2010/intera‌​ctivity"da System.Windows.Interactivity.

XAML per la visualizzazione:

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

Visualizza modello:

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

Ho riscontrato un problema con la selezione dei bambini con un metodo HierarchicalDataTemplate. Se selezionassi il figlio di un nodo, in qualche modo selezionerei il genitore radice di quel figlio. Ho scoperto che l'evento MouseRightButtonDown veniva chiamato per ogni livello del bambino. Ad esempio, se hai un albero simile a questo:

Elemento 1
   - Bambino 1
   - Bambino 2
      - Sottoelemento1
      - Sottoelemento2

Se selezionassi Subitem2, l'evento si sarebbe attivato tre volte e sarebbe stato selezionato l'elemento 1. Ho risolto questo problema con una chiamata booleana e una chiamata asincrona.

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

Sembra un po 'rumoroso, ma fondamentalmente ho impostato il valore booleano su true al primo passaggio e l'ho resettato su un altro thread in pochi secondi (3 in questo caso). Ciò significa che il prossimo passaggio attraverso il punto in cui tenterebbe di salire sull'albero verrà saltato lasciandoti con il nodo corretto selezionato. Finora sembra funzionare :-)

Puoi selezionarlo con l'evento su mouse down. Ciò attiverà la selezione prima che il menu contestuale si attivi.

Se vuoi rimanere all'interno del pattern MVVM puoi fare quanto segue:

Visualizza:

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

Codice dietro:

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

Ora puoi reagire alla modifica della proprietà ClickedTreeElement o puoi usare un comando che funziona internamente con ClickedTreeElement.

Visualizzazione estesa:

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