Quelle est la meilleure façon de simuler un clic avec MouseUp & MouseDown événements ou autrement?

voici un comportement que vous pouvez ajouter à n'importe quel élément pour qu'il élève l'événement ButtonBase.Click en utilisant le bouton normal logic:

public class ClickBehavior : Behavior<FrameworkElement>
{
    protected override void OnAttached()
    {
        AssociatedObject.MouseLeftButtonDown += (s, e) =>
        {
            e.Handled = true;
            AssociatedObject.CaptureMouse();
        };
        AssociatedObject.MouseLeftButtonUp += (s, e) =>
        {
            if (!AssociatedObject.IsMouseCaptured) return;
            e.Handled = true;
            AssociatedObject.ReleaseMouseCapture();
            if (AssociatedObject.InputHitTest(e.GetPosition(AssociatedObject)) != null)
                AssociatedObject.RaiseEvent(new RoutedEventArgs(ButtonBase.ClickEvent));
        };
    }
}

remarquez l'utilisation de la capture/libération de la souris et la vérification du test de succès d'entrée. Avec ce comportement en place, Nous pouvons écrire les gestionnaires de clic comme ceci:

<Grid>
    <Rectangle Width="100" Height="100" Fill="LightGreen" ButtonBase.Click="Rectangle_Click">
        <i:Interaction.Behaviors>
            <utils:ClickBehavior/>
        </i:Interaction.Behaviors>
    </Rectangle>
</Grid>

et le code derrière:

    private void Rectangle_Click(object sender, RoutedEventArgs e)
    {
        Debug.WriteLine("Code-behind: Click");
    }

il est assez facile de convertir ceci à tout le code-derrière; la partie importante est la logique de capture et de clic.

si vous n'êtes pas familier avec les behaviors, installez L'Expression Blend 4 SDK et ajoutez ce namespace:

xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"

et ajouter System.Windows.Interactivity à votre projet.

Edit:

Voici comment attacher le comportement de clic à un élément dans le code-behind et Ajouter un handler pour l'événement de clic:

void AttachClickBehaviors()
{
    AttachClickBehavior(rectangle1, new RoutedEventHandler(OnAttachedClick));
}

void OnAttachedClick(object sender, RoutedEventArgs e)
{
    Debug.WriteLine("Attached: Click");
}

// Reusable: doesn't need to be in the code-behind.
static void AttachClickBehavior(FrameworkElement element, RoutedEventHandler clickHandler)
{
    Interaction.GetBehaviors(element).Add(new ClickBehavior());
    element.AddHandler(ButtonBase.ClickEvent, clickHandler);
}

Ok, j'ai juste pensé que je pourrais jouer avec des événements attachés et voir où je vais avec elle, ce qui suit semble fonctionner dans la plupart des cas, pourrait utiliser un certain raffinement/débugging:

public static class Extensions
{
    public static readonly RoutedEvent ClickEvent = EventManager.RegisterRoutedEvent(
        "Click",
        RoutingStrategy.Bubble,
        typeof(RoutedEventHandler),
        typeof(UIElement)
        );

    public static void AddClickHandler(DependencyObject d, RoutedEventHandler handler)
    {
        UIElement element = d as UIElement;
        if (element != null)
        {
            element.MouseLeftButtonDown += new MouseButtonEventHandler(element_MouseLeftButtonDown);
            element.MouseLeftButtonUp += new MouseButtonEventHandler(element_MouseLeftButtonUp);
            element.AddHandler(Extensions.ClickEvent, handler);
        }
    }

    public static void RemoveClickHandler(DependencyObject d, RoutedEventHandler handler)
    {
        UIElement element = d as UIElement;
        if (element != null)
        {
            element.MouseLeftButtonDown -= new MouseButtonEventHandler(element_MouseLeftButtonDown);
            element.MouseLeftButtonUp -= new MouseButtonEventHandler(element_MouseLeftButtonUp);
            element.RemoveHandler(Extensions.ClickEvent, handler);
        }
    }

    static void element_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
    {
        UIElement uie = sender as UIElement;
        if (uie != null)
        {
            uie.CaptureMouse();
        }
    }
    static void element_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
    {
        UIElement uie = sender as UIElement;
        if (uie != null && uie.IsMouseCaptured)
        {
            uie.ReleaseMouseCapture();
            UIElement element = e.OriginalSource as UIElement;
            if (element != null && element.InputHitTest(e.GetPosition(element)) != null) element.RaiseEvent(new RoutedEventArgs(Extensions.ClickEvent));
        }
    }
}

Utilisation:

<TextBlock local:Extensions.Click="TextBlock_Click" Text="Test"/>

Edit: Changé d'utiliser la souris de capture au lieu de stocker de l'expéditeur/source qui ne se purifient pas suffisamment. Le problème restant est que vous ne pouvez pas ajouter l'événement dans le code en utilisant UIElement.AddHandler(Extensions.ClickEvent, handler) parce que cela omet les pièces jointes des autres événements de la souris qui sont nécessaires pour soulever l'événement de clic (vous devez utiliser Extensions.AddClickHandler(object, handler) à la place).

Voici une solution simple que j'utilise assez régulièrement. Il est facile, et fonctionne dans toutes sortes de scénarios.

dans votre code, placez ceci.

private object DownOn = null;

private void LeftButtonUp(object sender, MouseButtonEventArgs e)
{
  if (DownOn == sender)
  {
    MessageBox.Show((sender as FrameworkElement).Name);
  }
  DownOn = null;
}

private void LeftButtonDown(object sender, MouseButtonEventArgs e)
{
  DownOn = sender;
}

maintenant, tout ce que vous avez à faire est de configurer les gestionnaires pour tous les contrôles que vous vous souciez i.e.

<Border Background="Red"  MouseLeftButtonUp="LeftButtonUp" MouseLeftButtonDown="LeftButtonDown".../>
<Border Background="Blue" MouseLeftButtonUp="LeftButtonUp" MouseLeftButtonDown="LeftButtonDown".../>

si vous avez une tonne de commandes, et que vous ne voulez pas tout faire dans XAML, vous pouvez le faire dans votre programme controls / window constructor.

cela couvrira la plupart de vos scénarios, et il peut facilement être modifié pour traiter des cas spéciaux.

ajouter D'abord une fonction de clic d'événement de souris:

/// <summary>
/// Returns mouse click.
/// </summary>
/// <returns>mouseeEvent</returns>
public static MouseButtonEventArgs MouseClickEvent()
{
    MouseDevice md = InputManager.Current.PrimaryMouseDevice;
    MouseButtonEventArgs mouseEvent = new MouseButtonEventArgs(md, 0, MouseButton.Left);
    return mouseEvent;
}

Ajouter un événement click à l'un de vos contrôles WPF:

private void btnDoSomeThing_Click(object sender, RoutedEventArgs e)
{
    // Do something
}

enfin, appelez l'événement de clic de n'importe quelle fonction:

btnDoSomeThing_Click(new object(), MouseClickEvent());

pour simuler un double clic, ajoutez un événement double clic comme PreviewMouseDoubleClick et assurez-vous que n'importe quel code commence dans une fonction séparée:

private void lvFiles_PreviewMouseDoubleClick(object sender, MouseButtonEventArgs e)
{
    DoMouseDoubleClick(e);
}

private void DoMouseDoubleClick(RoutedEventArgs e)
{
    // Add your logic here
}

pour invoquer l'événement de double clic, il suffit d'appeler il d'une autre fonction (comme KeyDown):

private void someControl_KeyDown(object sender, System.Windows.Input.KeyEventArgs e)
{
    if (e.Key == Key.Enter)
        DoMouseDoubleClick(e);
}