Comment puis-je annuler un utilisateur WPF Arborescence, cliquez sur?

Mise à JOUR

Réalisé que je pourrais mettre de la logique dans SelectedItemChanged à la place. Un peu plus propre solution.

Xaml

<TreeView Name="c_treeView"
          SelectedItemChanged="c_treeView_SelectedItemChanged">
    <TreeView.ItemContainerStyle>
        <Style TargetType="{x:Type TreeViewItem}">
            <Setter Property="IsSelected" Value="{Binding Path=IsSelected, Mode=TwoWay}" />
        </Style>
    </TreeView.ItemContainerStyle>
</TreeView>

Code derrière. J'ai quelques classes qui est mon ItemsSource de l'Arborescence, j'ai donc fait une interface (MyInterface) qui expose la propriété IsSelected pour tous.

private MyInterface m_selectedTreeViewItem = null;
private void c_treeView_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs<object> e)
{
    if (m_selectedTreeViewItem != null)
    {
        if (e.NewValue == m_selectedTreeViewItem)
        {
            //Will only end up here when reversing item
            //Without this line childs can't be selected
            //twice if "No" was pressed in the question..   
            c_treeView.Focus();   
        }
        else
        {
            if (MessageBox.Show("Change TreeViewItem?",
                                "Really change",
                                MessageBoxButton.YesNo,
                                MessageBoxImage.Question) != MessageBoxResult.Yes)
            {
                EventHandler eventHandler = null;
                eventHandler = new EventHandler(delegate
                {
                    c_treeView.LayoutUpdated -= eventHandler;
                    m_selectedTreeViewItem.IsSelected = true;
                });
                //Will be fired after SelectedItemChanged, to early to change back here
                c_treeView.LayoutUpdated += eventHandler;
            }   
            else
            {
                m_selectedTreeViewItem = e.NewValue as MyInterface;
            }        
        }
    }
    else
    {
        m_selectedTreeViewItem = e.NewValue as MyInterface;
    }
}

Je n'ai pas trouvé une situation où il ne veut pas revenir à l'élément précédent en appuyant sur "Non".

OriginalL'auteur Fredrik Hedblad

Au lieu de sélectionner pour sélectionner/désélectionner, une meilleure solution pourrait être de s'accrocher dans PreviewMouseDown. Le preblem à la manipulation de l'Sélectionnés et non sélectionnés événement est que l'événement a déjà eu lieu lorsque vous recevez la notification. Il n'y a rien à annuler parce que c'est déjà arrivé.

D'autre part, l'Aperçu des événements sont annulables. Ce n'est pas l'exacte de l'événement que vous voulez, mais il ne vous donner la oppuritunity pour éviter à l'utilisateur de sélectionner un autre nœud.

OriginalL'auteur JaredPar

CAMS_ARIES:

XAML:

code :

  private bool ManejarSeleccionNodoArbol(Object origen)
{
return true;  //with true, the selected nodo don't change
return false //with false, the selected nodo change
}
private void Arbol_PreviewMouseDown(object sender, MouseButtonEventArgs e)
{            
if (e.Source is TreeViewItem)
{
e.Handled = ManejarSeleccionNodoArbol(e.Source);
}
}
private void Arbol_PreviewKeyDown(object sender, KeyEventArgs e)
{
if (e.Source is TreeViewItem)
{
e.Handled=ManejarSeleccionNodoArbol(e.Source);
}
}         

OriginalL'auteur

Depuis le SelectedItemChanged événement est déclenché après la SelectedItem a déjà changé, vous ne pouvez pas vraiment d'annuler l'événement à ce point.

Ce que vous pouvez faire est d'écouter pour des clics de souris et de les annuler avant la SelectedItem est changé.

OriginalL'auteur Eclipse

J'ai résolu ce problème pour 1 affichage de l'arborescence et l'affichage de 1 document à la fois. Cette solution est basée sur une saisissable comportement qui peut être attaché à une normale treeview:

<TreeView Grid.Column="0"
ItemsSource="{Binding TreeViewItems}"
behav:TreeViewSelectionChangedBehavior.ChangedCommand="{Binding SelectItemChangedCommand}"
>
<TreeView.ItemTemplate>
<HierarchicalDataTemplate ItemsSource="{Binding Children}">
<StackPanel Orientation="Horizontal">
<TextBlock Text="{Binding Name}"
ToolTipService.ShowOnDisabled="True"
VerticalAlignment="Center" Margin="3" />
</StackPanel>
</HierarchicalDataTemplate>
</TreeView.ItemTemplate>
<TreeView.ItemContainerStyle>
<Style TargetType="{x:Type TreeViewItem}">
<Setter Property="IsExpanded" Value="{Binding IsExpanded, Mode=TwoWay}" />
<Setter Property="IsSelected" Value="{Binding IsSelected, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
</Style>
</TreeView.ItemContainerStyle>
</TreeView>

et le code pour le comportement est ceci:

///<summary>
///Source:
///http://stackoverflow.com/questions/1034374/drag-and-drop-in-mvvm-with-scatterview
///http://social.msdn.microsoft.com/Forums/de-DE/wpf/thread/21bed380-c485-44fb-8741-f9245524d0ae
///
///Attached behaviour to implement the SelectionChanged command/event via delegate command binding or routed commands.
///</summary>
public static class TreeViewSelectionChangedBehavior
{
#region fields
///<summary>
///Field of attached ICommand property
///</summary>
private static readonly DependencyProperty ChangedCommandProperty = DependencyProperty.RegisterAttached(
"ChangedCommand",
typeof(ICommand),
typeof(TreeViewSelectionChangedBehavior),
new PropertyMetadata(null, OnSelectionChangedCommandChange));
///<summary>
///Implement backing store for UndoSelection dependency proeprty to indicate whether selection should be
///cancelled via MessageBox query or not.
///</summary>
public static readonly DependencyProperty UndoSelectionProperty =
DependencyProperty.RegisterAttached("UndoSelection",
typeof(bool),
typeof(TreeViewSelectionChangedBehavior),
new PropertyMetadata(false, OnUndoSelectionChanged));
#endregion fields
#region methods
#region ICommand changed methods
///<summary>
///Setter method of the attached ChangedCommand <seealso cref="ICommand"/> property
///</summary>
///<param name="source"></param>
///<param name="value"></param>
public static void SetChangedCommand(DependencyObject source, ICommand value)
{
source.SetValue(ChangedCommandProperty, value);
}
///<summary>
///Getter method of the attached ChangedCommand <seealso cref="ICommand"/> property
///</summary>
///<param name="source"></param>
///<returns></returns>
public static ICommand GetChangedCommand(DependencyObject source)
{
return (ICommand)source.GetValue(ChangedCommandProperty);
}
#endregion ICommand changed methods
#region UndoSelection methods
public static bool GetUndoSelection(DependencyObject obj)
{
return (bool)obj.GetValue(UndoSelectionProperty);
}
public static void SetUndoSelection(DependencyObject obj, bool value)
{
obj.SetValue(UndoSelectionProperty, value);
}
#endregion UndoSelection methods
///<summary>
///This method is hooked in the definition of the <seealso cref="ChangedCommandProperty"/>.
///It is called whenever the attached property changes - in our case the event of binding
///and unbinding the property to a sink is what we are looking for.
///</summary>
///<param name="d"></param>
///<param name="e"></param>
private static void OnSelectionChangedCommandChange(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
TreeView uiElement = d as TreeView;  //Remove the handler if it exist to avoid memory leaks
if (uiElement != null)
{
uiElement.SelectedItemChanged -= Selection_Changed;
var command = e.NewValue as ICommand;
if (command != null)
{
//the property is attached so we attach the Drop event handler
uiElement.SelectedItemChanged += Selection_Changed;
}
}
}
///<summary>
///This method is called when the selection changed event occurs. The sender should be the control
///on which this behaviour is attached - so we convert the sender into a <seealso cref="UIElement"/>
///and receive the Command through the <seealso cref="GetChangedCommand"/> getter listed above.
///
///The <paramref name="e"/> parameter contains the standard EventArgs data,
///which is unpacked and reales upon the bound command.
///
///This implementation supports binding of delegate commands and routed commands.
///</summary>
///<param name="sender"></param>
///<param name="e"></param>
private static void Selection_Changed(object sender, RoutedPropertyChangedEventArgs<object> e)
{
var uiElement = sender as TreeView;
//Sanity check just in case this was somehow send by something else
if (uiElement == null)
return;
ICommand changedCommand = TreeViewSelectionChangedBehavior.GetChangedCommand(uiElement);
//There may not be a command bound to this after all
if (changedCommand == null)
return;
//Check whether this attached behaviour is bound to a RoutedCommand
if (changedCommand is RoutedCommand)
{
//Execute the routed command
(changedCommand as RoutedCommand).Execute(e.NewValue, uiElement);
}
else
{
//Execute the Command as bound delegate
changedCommand.Execute(e.NewValue);
}
}
///<summary>
///Executes when the bound boolean property indicates that a user should be asked
///about changing a treeviewitem selection instead of just performing it.
///</summary>
///<param name="d"></param>
///<param name="e"></param>
private static void OnUndoSelectionChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
TreeView uiElement = d as TreeView;  //Remove the handler if it exist to avoid memory leaks
if (uiElement != null)
{
uiElement.PreviewMouseDown -= uiElement_PreviewMouseDown;
var command = (bool)e.NewValue;
if (command == true)
{
//the property is attached so we attach the Drop event handler
uiElement.PreviewMouseDown += uiElement_PreviewMouseDown;
}
}
}
///<summary>
///Based on the solution proposed here:
///Source: http://stackoverflow.com/questions/20244916/wpf-treeview-selection-change
///</summary>
///<param name="sender"></param>
///<param name="e"></param>
private static void uiElement_PreviewMouseDown(object sender, MouseButtonEventArgs e)
{
//first did the user click on a tree node?
var source = e.OriginalSource as DependencyObject;
while (source != null && !(source is TreeViewItem))
source = VisualTreeHelper.GetParent(source);
var itemSource = source as TreeViewItem;
if (itemSource == null)
return;
var treeView = sender as TreeView;
if (treeView == null)
return;
bool undoSelection = TreeViewSelectionChangedBehavior.GetUndoSelection(treeView);
if (undoSelection == false)
return;
//Cancel the attempt to select an item.
var result = MessageBox.Show("The current document has unsaved data. Do you want to continue without saving data?", "Are you really sure?",
MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No);
if (result == MessageBoxResult.No)
{
//Cancel the attempt to select a differnet item.
e.Handled = true;
}
else
{
//Lets disable this for a moment, otherwise, we'll get into an event "recursion"
treeView.PreviewMouseDown -= uiElement_PreviewMouseDown;
//Select the new item - make sure a SelectedItemChanged event is fired in any case
//Even if this means that we have to deselect/select the one and the same item
if (itemSource.IsSelected == true )
itemSource.IsSelected = false;
itemSource.IsSelected = true;
//Lets enable this to get back to business for next selection
treeView.PreviewMouseDown += uiElement_PreviewMouseDown;
}
}
#endregion methods
}

Dans cet exemple, je suis en train de montrer un blocage de la boîte de message dans le but de bloquer la PreviewMouseDown événement lorsqu'il se produit. L'événement est ensuite traitée pour signaler que la sélection est annulée ou n'est pas traitée à laisser le treeview lui-même gérer l'événement en sélectionnant l'élément qui est sur le point d'être sélectionné.

Le comportement invoque ensuite une commande de limite dans le viewmodel si l'utilisateur décide de continuer, de toute façon (PreviewMouseDown événement n'est pas géré par le comportement attaché et lié commande est invoquée.

Je suppose que la boîte de message indiquant pourrait être fait dans d'autres façons, mais je pense qu'il est essentiel ici de bloquer l'événement quand il se produit depuis sa sinon pas possible de l'annuler(?). Ainsi, l'améliorer, seulement je pouvais possible pensent à propos de ce code est de se lier à certaines chaînes de rendre le message qui s'affiche configurable.

J'ai écrit un article qui contient un échantillon téléchargeable depuis cela, c'est un domaine difficile à expliquer (on doit faire de nombreuses hypothèses sur les pièces manquantes et le peut pas toujours être partagé par tous les lecteurs)

Voici un article qui contient mes résultats:
http://www.codeproject.com/Articles/995629/Cancelable-TreeView-Navigation-for-Documents-in-WP

S'il vous plaît commentaire sur cette solution et laissez-moi savoir si vous voyez de la place pour de l'amélioration.

OriginalL'auteur user3313608