WPF ListBoxItem haga doble clic en?

Question

WPF ListBox no tiene un evento de DoubleClick, al menos no tan lejos como puedo decir. ¿Hay alguna solución para este problema que me permita hacer doble clic en un elemento para que un controlador de eventos haga algo con él? Gracias por tu ayuda.

Answer 1

Siempre puede anular la plantilla de control ListItem y manejar el evento de doble clic dentro de la plantilla, por ejemplo, en un borde invisible que contiene el contenido normal de ListBox.

This article shows you how to use a ControlTemplate with a ListBoxItem. Más allá de eso, simplemente agregue el controlador al elemento más externo de su plantilla de control.

Si tiene Expression Blend, puede usarlo para extraer la plantilla de control existente para que la modifique, de modo que no tenga que trabajar tanto para asegurarse de que el nuevo cuadro de lista se comporte igual que el anterior.

Answer 2

Resulta que hay un evento MouseDoubleClick para el ListBox. Agregué este evento a mi ListBox e hice que el controlador de eventos procesara mi tarea, copiando el elemento seleccionado a otro ListBox. Entonces, cada vez que hago doble clic en un elemento, se copia.

Answer 3

Si está utilizando el enlace de datos, a continuación, este problema es muy fácil de resolver

<ListBox.ItemTemplate> 
    <DataTemplate> 
     <TextBlock Text="{Binding ObjectName}" 
      MouseDown="TextBlock_MouseDown"/> 
    </DataTemplate> 
</ListBox.ItemTemplate>  

Luego, en su código detrás, compruebe si hay un doble clic de la siguiente manera

private void TextBlock_MouseDown(object sender, MouseButtonEventArgs e) 
{ 
    if (e.ClickCount>=2) 
    { 
     .... 
    } 
} 

Si el artículo se hace doble clic no se seleccionó antes del doble clic, entonces no aparecerá seleccionado en el controlador de eventos. Su lógica dentro de ese controlador necesita tener esto en cuenta

Answer 4

He usado la respuesta anterior de David (que comienza con 'Resulta que hay un evento MouseDoubleClick para el ListBox.') Para generar una solución que se basa en su enfoque, pero se implementa con un comportamiento adjunto.

No digo que no deba tener ningún código porque sé que hay situaciones en las que no debe evitarse a cualquier precio. Sin embargo, este es otro ejemplo más de cómo puede convertir una solución basada en eventos en una solución compatible con MVVM que funciona mediante la conversión de enlace de eventos a comandos.

Esta mi código de comportamiento adjunto:

using System.Windows; 
using System.Windows.Controls.Primitives; 
using System.Windows.Input; 

/// <summary> 
/// Class implements a <seealso cref="Selector"/> double click 
/// to command binding attached behaviour. 
/// </summary> 
public class DoubleClickSelectorItem 
{ 
    #region fields 
    public static readonly DependencyProperty DoubleClickItemCommandProperty = 
     DependencyProperty.RegisterAttached("DoubleClickItemCommand", 
              typeof(ICommand), 
              typeof(DoubleClickSelectorItem), 
              new PropertyMetadata(null, 
              DoubleClickSelectorItem.OnDoubleClickItemCommand)); 
    #endregion fields 

    #region constructor 
    /// <summary> 
    /// Class constructor 
    /// </summary> 
    public DoubleClickSelectorItem() 
    { 

    } 
    #endregion constructor 

    #region properties 
    #endregion properties 

    #region methods 
    #region attached dependency property methods 
    public static ICommand GetDoubleClickItemCommand(DependencyObject obj) 
    { 
    return (ICommand)obj.GetValue(DoubleClickItemCommandProperty); 
    } 

    public static void SetDoubleClickItemCommand(DependencyObject obj, ICommand value) 
    { 
    obj.SetValue(DoubleClickItemCommandProperty, value); 
    } 
    #endregion attached dependency property methods 

    private static void OnDoubleClickItemCommand(DependencyObject d, DependencyPropertyChangedEventArgs e) 
    { 
    var uiElement = d as Selector; 

    // Remove the handler if it exist to avoid memory leaks 
    if (uiElement != null) 
     uiElement.MouseDoubleClick -= UIElement_MouseDoubleClick; 

    var command = e.NewValue as ICommand; 
    if (command != null) 
    { 
     // the property is attached so we attach the Drop event handler 
     uiElement.MouseDoubleClick += UIElement_MouseDoubleClick; 
    } 
    } 

    private static void UIElement_MouseDoubleClick(object sender, MouseButtonEventArgs e) 
    { 
    var uiElement = sender as Selector; 

    // Sanity check just in case this was somehow send by something else 
    if (uiElement == null) 
     return; 

    // Is there a selected item that was double clicked? 
    if (uiElement.SelectedIndex == -1) 
     return; 

    ICommand doubleclickCommand = DoubleClickSelectorItem.GetDoubleClickItemCommand(uiElement); 

    // There may not be a command bound to this after all 
    if (doubleclickCommand == null) 
     return; 

    // Check whether this attached behaviour is bound to a RoutedCommand 
    if (doubleclickCommand is RoutedCommand) 
    { 
     // Execute the routed command 
     (doubleclickCommand as RoutedCommand).Execute(uiElement.SelectedItem, uiElement); 
    } 
    else 
    { 
     // Execute the Command as bound delegate 
     doubleclickCommand.Execute(uiElement.SelectedItem); 
    }    
    } 
    #endregion methods 
} 

uso en XAML:

<ListBox ItemsSource="{Binding CurrentItems}" 
     behav:DoubleClickSelectorItem.DoubleClickItemCommand="{Binding Path=NavigateDownCommand}" 
     /> 

Answer 5

Es posible enlazar comandos con parámetros a ListBoxItem s sin necesidad de utilizar de código subyacente o comportamientos adjuntos, simplemente usando InputBindings con MouseBinding, como se muestra anteriormente en this answer.

Ejemplo ListBox con MouseBinding para LeftDoubleClick:

<ListBox ItemsSource="{Binding MyDataSource}"> 
    <ListBox.ItemTemplate> 
     <DataTemplate> 
      <TextBlock Text="{Binding MySourceItemName}"> 
       <TextBlock.InputBindings> 
        <MouseBinding MouseAction="LeftDoubleClick" 
            Command="{Binding DataContext.MyCommand, RelativeSource={RelativeSource AncestorType={x:Type ListBox}}}" 
            CommandParameter="{Binding MySourceItemId}" /> 
       </TextBlock.InputBindings> 
      </TextBlock> 
     </DataTemplate> 
    </ListBox.ItemTemplate> 
</ListBox> 

Si el comando se define de la misma DataContext como el ItemsSource de la ListBox, que puede estar unido mediante el uso de la RelativeSource de unión como se incluye en el ejemplo.