如何检测左右按钮是否被按下？

Question

我想在控件上有三个鼠标动作：left，right和BOTH。

我已经得到了左侧和右侧，目前正在使用第三个中间按钮，但我很好奇如何使用左右按钮被按在一起，对于那些用户没有鼠标的情况中间按钮。这将在自定义控件的OnMouseDown方法中处理。

UPDATE 审查建议的答复后，我需要澄清的是什么，我试图做的是采取在MouseDown事件的鼠标点击动作（实际上onmousedown事件控制的方法）。因为看起来，当鼠标左键和右键都被点击（每个按钮一个）时，.NET总是会引发两个MouseDown事件，我猜测唯一的方法是做一些低级别的Windows消息管理或在MouseDown后执行某种操作的延迟执行。最后，使用鼠标中键只是简单一些。

现在，如果动作发生在MouseUp上，那么Gary或nos的建议将会奏效。

对这个问题的任何进一步的见解将不胜感激。谢谢！

Answer 1

根据我从其他答案中学到的知识，我能够做到这一点。我在这里发布解决方案，以防其他人需要它。

我创建了一个组件MouseDownManager，我在MouseDown事件期间调用它。它跟踪刚刚按下的按钮，确定我们正在等待的按钮，以便拥有“两个”按钮按下事件，然后启动一个定时器以等待该按钮。如果在分配的时间内，按下了正确的按钮，则MouseDownManager引发相应的“两个”按钮向下事件。否则，它会引发相应的单个按钮事件。在窗体上，我正在处理MouseDownManager的MouseDown事件以对翻译的鼠标单击进行操作。

我现在可以将这个组件放在窗体/控件上，然后我可以对“双方”单击作出反应。

感谢您的帮助解决这个问题。

/// <summary> 
/// Manage mouse down event to enable using both buttons at once. 
/// I.e. allowing the pressing of the right and left mouse 
/// buttons together. 
/// </summary> 
public partial class MouseDownManager : Component 
{ 

    /// <summary> 
    /// Raised when a mouse down event is triggered by this 
    /// component. 
    /// </summary> 
    public event EventHandler<MouseEventArgs> MouseDown; 

    protected virtual void OnMouseDown(MouseEventArgs e) 
    { 
    if (this.MouseDown != null) 
    { 
     this.MouseDown(this, e); 
    } 
    } 

    public MouseDownManager() 
    { 
    //-- the timer was dropped on the designer, so it 
    // is initialized by InitializeComponent. 
    InitializeComponent(); 
    } 

    /// <summary> 
    /// Defines the interval that the timer will wait for the other 
    /// click, in milliseconds. 
    /// </summary> 
    public int BothClickInterval 
    { 
    get 
    { 
     return this.tmrBothInterval.Interval; 
    } 
    set 
    { 
     this.tmrBothInterval.Interval = value; 
    } 
    } 

    private MouseButtons _virtualButton = MouseButtons.Middle; 

    /// <summary> 
    /// Defines the button that is sent when both buttons are 
    /// pressed. This can be either a single button (like a middle 
    /// button) or more than one button (like both the left and 
    /// right buttons. 
    /// </summary> 
    public MouseButtons VirtualButton 
    { 
    get 
    { 
     return _virtualButton; 
    } 
    set 
    { 
     _virtualButton = value; 
    } 
    } 

    private MouseEventArgs _originalArgs; 

    /// <summary> 
    /// Defines the original mouse event arguments that is associated 
    /// with the original press. 
    /// </summary> 
    private MouseEventArgs OriginalArgs 
    { 
    get 
    { 
     return _originalArgs; 
    } 
    set 
    { 
     _originalArgs = value; 
    } 
    } 

    private MouseButtons _waitButton = MouseButtons.None; 

    /// <summary> 
    /// Defines the button that we are waiting on, for there to be a 
    /// both button click. 
    /// </summary> 
    private MouseButtons WaitButton 
    { 
    get 
    { 
     return _waitButton; 
    } 
    set 
    { 
     _waitButton = value; 
    } 
    } 

    /// <summary> 
    /// Manage a mouse button being depressed. 
    /// </summary> 
    /// <remarks> 
    /// This will instigate one of two actions. If there is no 
    /// current wait button, this will set the appropriate wait 
    /// button (if the button pressed was the left button, then we 
    /// are waiting on the right button) and start a timer. If the 
    /// wait button is set, but this isn't that button, then the wait 
    /// button is updated and the timer restarted. Also, this will 
    /// trigger the waiting event. If it is the wait button, then 
    /// the appropriate event is raised for a "both" button press. 
    /// </remarks> 
    public void ManageMouseDown(MouseEventArgs mouseArgs) 
    { 
    //-- Is the the button we are waiting for? 
    if (mouseArgs.Button == this.WaitButton) 
    { 
     //-- Turn off timer. 
     this.ClearTimer(); 

     //-- Create new mouse event args for our virtual event. 
     MouseEventArgs bothArgs = new MouseEventArgs(this.VirtualButton 
                , mouseArgs.Clicks 
                , mouseArgs.X 
                , mouseArgs.Y 
                , mouseArgs.Delta); 

     //-- Raise the mouse down event. 
     this.OnMouseDown(bothArgs); 
    } 
    else 
    { 
     //-- Clear timer 
     this.ClearTimer(); 

     //-- If we were waiting for a button, then 
     // fire the event for the original button. 
     if (this.WaitButton != MouseButtons.None) 
     { 
     this.OnMouseDown(this.OriginalArgs); 
     } 

     //-- Cache the original mouse event args. 
     MouseEventArgs newMouseArgs = new MouseEventArgs(mouseArgs.Button 
                 , mouseArgs.Clicks 
                 , mouseArgs.X 
                 , mouseArgs.Y 
                 , mouseArgs.Delta); 
     this.OriginalArgs = newMouseArgs; 

     //-- Reset to wait for the appropriate next button. 
     switch (mouseArgs.Button) 
     { 
     case MouseButtons.Left: 
      this.WaitButton = MouseButtons.Right; 
      break; 
     case MouseButtons.Right: 
      this.WaitButton = MouseButtons.Left; 
      break; 
     default: 
      this.WaitButton = MouseButtons.None; 
      break; 
     } 

     //-- Start timer 
     this.tmrBothInterval.Enabled = true; 
    } 
    } 

    /// <summary> 
    /// Raise the event for the button that was pressed initially 
    /// and turn off the timer. 
    /// </summary> 
    private void tmrBothInterval_Tick(object sender, EventArgs e) 
    { 
    //-- Turn off the timer. 
    this.tmrBothInterval.Enabled = false; 

    //-- Based on the original button pressed, raise 
    // the appropriate mouse down event. 
    this.OnMouseDown(this.OriginalArgs); 

    //-- Clear timer. 
    this.ClearTimer(); 
    } 

    /// <summary> 
    /// Clear the timer and associated variables so we aren't waiting 
    /// for the second click. 
    /// </summary> 
    private void ClearTimer() 
    { 
    //-- Turn off the timer. 
    this.tmrBothInterval.Enabled = false; 

    //-- Clear the wait button. 
    this.WaitButton = MouseButtons.None; 

    //-- Clear the original args 
    this.OriginalArgs = null; 
    } 
} 

/// <summary> 
/// Just the mouse code from the control needing the functionality. 
/// </summary> 
public class MyControl: Control 
{ 
    /// <summary> 
    /// Handle the mouse down event. This delegates the actual event 
    /// to the MouseDownManager, so we can capture the situation 
    /// where both buttons are clicked. 
    /// </summary> 
    protected override void OnMouseDown(MouseEventArgs e) 
    { 
    this.mdmMain.ManageMouseDown(e); 
    } 

    /// <summary> 
    /// Process the mouse down event. 
    /// </summary> 
    private void mdmMain_MouseDown(object sender, MouseEventArgs e) 
    { 
    //-- Get the reported button state. 
    MouseButtons mouseButton = e.Button; 

    //-- Execute logic based on button pressed, which now can include 
    // both the left and right together if needed.... 
    } 
} 

Answer 2

不知道是否有一个本地.NET的方式来做到这一点，但如果你满意的P/Invoke，您可以使用GetKeyState或GetAsyncKeyState这样的：

[DllImport("user32.dll")] 
public static extern short GetKeyState(int nVirtKey); 

if (GetKeyState((int)Keys.LButton) < 0 && GetKeyState((int)Keys.RButton) < 0) 
{ 
    // Both buttons are pressed. 
} 

Answer 3

不是“中间的”同“左右”在一起？至少这是我从什么地方还记得，但那是从遥想当年我有两个按钮，鼠标没有滚轮按钮...

Answer 4

总是有“自己动手”的方法：

只要记住状态按钮按下并释放。在OnMouseDown中，您只需记住按钮，然后在OnMouseUp中检查记住的按钮，以及清除按钮的状态。

当你释放按钮时，你需要一些逻辑来不做一些动作。 喜欢的东西

MouseButtons buttonPressed; 
.. 

void OnMouseDown(MouseEventArgs e) 
{ 
    buttonPressed |= e.Button; 
} 


void OnMouseUp(MouseEventArgs e) 
{ 
    if(!doneAction) { 
    if((buttonPressed & MouseButtons.Right == MouseButtons.Right 
     && buttonPressed & MouseButtons.Left == MouseButtons.Left) 
     || buttonPressed & MouseButtons.Middle== MouseButtons.Middle) { 
     DoMiddleAction(); 
     doneAction = true; 
    } else if(check Right button , etc.) { 
     .... 
    } 
    } 

    buttonpressed &= ~e.Button; 
    if(buttonpressed == None) 
     doneAction = false; 

} 

Answer 5

我会亲自使用MouseUp和MouseDown事件更清洁的方式来处理它，避免互操作。基本上，这段代码使用一个静态类来保存两个按钮的状态，并通过检查确定两者实际上是否关闭。

using System.Windows.Forms; 

namespace WindowsFormsApplication1 
{ 

    public static class MouseButtonStatus 
    { 
     static bool RightButton; 
     static bool LeftButton; 

     public static bool RightButtonPressed 
     { 
      get 
      { 
       return RightButton; 
      } 
      set 
      { 
       RightButton = value; 
      } 
     } 

     public static bool LeftButtonPressed 
     { 
      get 
      { 
       return LeftButton; 
      } 
      set 
      { 
       LeftButton = value; 
      } 
     } 


    } 


    public partial class Form1 : Form 
    { 
     public Form1() 
     { 
      InitializeComponent(); 
     } 

     public void HandleButtons(bool LeftPressed, bool RightPressed) 
     { 
      if(LeftPressed && RightPressed) 
      { 
       //BOTH ARE PRESSED 
      } 
      else if(LeftPressed) 
      { 
       //LEFT IS PRESSED 
      } 
      else if(RightPressed) 
      { 
       //RIGHT IS PRESSED 
      } 
      else 
      { 
       //NONE ARE PRESSED 
      } 
     } 

     private void Form1_MouseDown(object sender, MouseEventArgs e) 
     { 
      if(e.Button == MouseButtons.Left) 
      { 
       MouseButtonStatus.LeftButtonPressed = true; 
      } 
      if(e.Button == MouseButtons.Right) 
      { 
       MouseButtonStatus.RightButtonPressed = true; 
      } 

      HandleButtons(MouseButtonStatus.LeftButtonPressed, MouseButtonStatus.RightButtonPressed); 
     } 

     private void Form1_MouseUp(object sender, MouseEventArgs e) 
     { 
      if(e.Button == MouseButtons.Left) 
      { 
       MouseButtonStatus.LeftButtonPressed = false; 
      } 
      if(e.Button == MouseButtons.Right) 
      { 
       MouseButtonStatus.RightButtonPressed = false; 
      } 

      HandleButtons(MouseButtonStatus.LeftButtonPressed, MouseButtonStatus.RightButtonPressed); 
     } 



    } 
}