internal void OnMouseDown(MouseEventArgs e)
{
if (MouseDown != null)
{
MouseDown.Invoke(this, e);
}
}
private IntPtr MouseHookProc(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0)
{
MSLLHOOKSTRUCT mouseHookStruct = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
if (wParam.ToInt32() == WM_LBUTTONDOWN)
{
if (MouseDown != null)
{
MouseDown.Invoke(null, new System.Drawing.Point(mouseHookStruct.pt.x, mouseHookStruct.pt.y));
}
return(new IntPtr(-1));
}
if (wParam.ToInt32() == WM_MOUSEWHEEL)
{
if (MouseWheel != null)
{
MouseDevice mouseDev = InputManager.Current.PrimaryMouseDevice;
MouseWheel.Invoke(null, new MouseWheelEventArgs(mouseDev, Environment.TickCount, (int)mouseHookStruct.mouseData >> 16));
}
}
}
return(CallNextHookEx(_mouseHookHandle, nCode, wParam, lParam));
}
public void OnPointerDown(PointerEventData eventData)
{
if (MouseDown != null)
{
MouseDown.Invoke(this, eventData);
}
}
private void listView1_MouseDown(object sender, MouseEventArgs e)
{
if (MouseDown != null)
{
MouseDown.Invoke(sender, e);
}
}
public DisplayPanelBox(PictureBox pBox, VScrollBar vs, HScrollBar hs)
{
pictureBox = pBox;
pictureBox.MouseDown += (s, e) =>
{
clicking = true;
MouseDown.Invoke(e);
};
pictureBox.MouseMove += (s, e) =>
{
if (clicking)
{
MouseDrag.Invoke(e);
}
else
{
MouseMove.Invoke(e);
}
};
pictureBox.MouseUp += (s, e) =>
{
clicking = false;
MouseUp.Invoke(e);
};
vScroll = vs;
hScroll = hs;
}
public void Invoke(string EventName, Game CurrentGame, EventArguments Args)
{
if (EventName == "Closing")
{
Closing.Invoke(CurrentGame, Args);
}
if (EventName == "KeyDown")
{
KeyDown.Invoke(CurrentGame, Args);
}
if (EventName == "KeyUp")
{
KeyUp.Invoke(CurrentGame, Args);
}
if (EventName == "KeyPress")
{
KeyPress.Invoke(CurrentGame, Args);
}
if (EventName == "Load")
{
Load.Invoke(CurrentGame, Args);
}
if (EventName == "MouseDown")
{
MouseDown.Invoke(CurrentGame, Args);
}
if (EventName == "MouseUp")
{
MouseUp.Invoke(CurrentGame, Args);
}
if (EventName == "MouseClick")
{
MouseClick.Invoke(CurrentGame, Args);
}
if (EventName == "MouseMove")
{
MouseMove.Invoke(CurrentGame, Args);
}
if (EventName == "MouseWheel")
{
MouseWheel.Invoke(CurrentGame, Args);
}
if (EventName == "RenderFrame")
{
RenderFrame.Invoke(CurrentGame, Args);
}
if (EventName == "Resize")
{
Resize.Invoke(CurrentGame, Args);
}
if (EventName == "TimerTick")
{
TimerTick.Invoke(CurrentGame, Args);
}
}
/// <summary>
/// Receives all MouseDown events, and checks if control is focused and
/// should receive event.
/// </summary>
/// <param name="args">Mouse event arguments.</param>
protected virtual void MouseDownIntercept(MouseEventArgs args)
{
// Check coordinates as well because modal mode messes up the
// MouseDown event.
if (this.guiManager.GetFocus() == this &&
CheckCoordinates(args.Position.X, args.Position.Y)
)
{
MouseDown.Invoke(args);
}
}
private void setKeyDown(MouseButton key)
{
if (key == MouseButton.NONE)
{
return;
}
buttons.Put(key, true);
if (MouseDown != null)
{
MouseDown.Invoke(this, new MouseEvent(this, key));
}
}
public void Update()
{
if (Input.GetMouseButtonUp(0))
{
MouseUp.Invoke();
}
if (Input.GetMouseButtonDown(0))
{
MouseClick.Invoke();
}
if (Input.GetMouseButton(0))
{
MouseDown.Invoke();
}
OnUpdate.Invoke();
}
protected override void WndProc(ref Message m)
{
if (m.Msg == WM_PASTE)
{
if (Clipboard.ContainsText())
{
Paste.Invoke(this, new EventArgs());
}
return;
}
if (m.Msg == WM_LBUTTONDOWN)
{
MouseDown.Invoke(this, new EventArgs());
}
base.WndProc(ref m);
}
} // UpdateMouse
private void UpdateButtons()
{
MouseEventArgs e = new MouseEventArgs();
foreach (InputMouseButton btn in mouseButtons)
{
ButtonState bs;
if (btn.Button == MouseButton.Left) bs = Mouse.State.LeftButton;
else if (btn.Button == MouseButton.Right) bs = Mouse.State.RightButton;
else if (btn.Button == MouseButton.Middle) bs = Mouse.State.MiddleButton;
else if (btn.Button == MouseButton.XButton1) bs = Mouse.State.XButton1;
else if (btn.Button == MouseButton.XButton2) bs = Mouse.State.XButton2;
else continue;
bool pressed = (bs == ButtonState.Pressed); // The current state
if (pressed && !btn.Pressed) // If is pressed and the last frame wasn't pressed.
{
btn.Pressed = true;
BuildMouseEvent(btn.Button, ref e);
if (MouseDown != null) MouseDown.Invoke(this, e);
if (MousePress != null) MousePress.Invoke(this, e);
}
else if (!pressed && btn.Pressed) // If isn't pressed and the last frame was pressed.
{
btn.Pressed = false;
BuildMouseEvent(btn.Button, ref e);
if (MouseUp != null) MouseUp.Invoke(this, e);
}
else if (pressed && btn.Pressed) // If is pressed and was pressed.
{
e.Button = btn.Button;
BuildMouseEvent(btn.Button, ref e);
if (MousePress != null) MousePress.Invoke(this, e);
}
}
} // UpdateButtons
public virtual void OnMouseDown(MouseEventArgs e)
{
if (!_enabled)
{
return;
}
Activate();
TrySort();
if (_movable)
{
Moving = true;
_movePoint = CMain.MPoint.Subtract(Location);
}
if (MouseDown != null)
{
MouseDown.Invoke(this, e);
}
}
public virtual void OnMouseDown(MouseEventArgs e)
{
if (!_Enabled)
{
return;
}
ActiveControl = this;
TrySort();
if (_Movable)
{
Moving = true;
MovePoint = Functions.PointS(e.Location, Location);
}
if (MouseDown != null)
{
MouseDown.Invoke(this, e);
}
}
private void OnMouseDown()
{
MouseDown.Invoke();
}
//down
protected void RaiseMouseDown(object sender, MouseArg e)
{
MouseDown?.Invoke(sender, e);
}
public void ProcessMouseDown(MouseArgs args)
{
MouseDown?.Invoke(this, args);
}
/// <summary>
/// Invokes the MouseDown event.
/// </summary>
/// <param name="v">Location of the mouse.</param>
/// <param name="b">The current state of the mouse buttons.</param>
internal void DoMouseDown(Vec2 v, MouseButtons b)
{
MouseDown.Invoke(v, b);
}
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
private void UpdateButtons(MouseState state, GameTime gameTime)
{
#if (!XBOX && !XBOX_FAKE)
MouseEventArgs e = new MouseEventArgs();
foreach (InputMouseButton btn in mouseButtons)
{
ButtonState bs = ButtonState.Released;
if (btn.Button == MouseButton.Left)
{
bs = state.LeftButton;
}
else if (btn.Button == MouseButton.Right)
{
bs = state.RightButton;
}
else if (btn.Button == MouseButton.Middle)
{
bs = state.MiddleButton;
}
else if (btn.Button == MouseButton.XButton1)
{
bs = state.XButton1;
}
else if (btn.Button == MouseButton.XButton2)
{
bs = state.XButton2;
}
else
{
continue;
}
bool pressed = (bs == ButtonState.Pressed);
if (pressed)
{
double ms = gameTime.ElapsedGameTime.TotalMilliseconds;
if (pressed)
{
btn.Countdown -= ms;
}
}
if ((pressed) && (!btn.Pressed))
{
btn.Pressed = true;
BuildMouseEvent(state, btn.Button, ref e);
if (MouseDown != null)
{
MouseDown.Invoke(this, e);
}
if (MousePress != null)
{
MousePress.Invoke(this, e);
}
}
else if ((!pressed) && (btn.Pressed))
{
btn.Pressed = false;
btn.Countdown = RepeatDelay;
BuildMouseEvent(state, btn.Button, ref e);
if (MouseUp != null)
{
MouseUp.Invoke(this, e);
}
}
else if (btn.Pressed && btn.Countdown < 0)
{
e.Button = btn.Button;
btn.Countdown = RepeatRate;
BuildMouseEvent(state, btn.Button, ref e);
if (MousePress != null)
{
MousePress.Invoke(this, e);
}
}
}
#endif
}
/// <param name="gameTime">Snapshot of the application's timing values.</param>
/// <param name="state">Current state of the mouse device.</param>
/// <summary>
/// Updates the state of the Mouse buttons.
/// </summary>
private void UpdateButtons(MouseState state, GameTime gameTime)
{
#if (!XBOX && !XBOX_FAKE)
var e = new MouseEventArgs();
// Update the state of the buttons in the mouse button list.
foreach (var btn in mouseButtons)
{
// Current button state of the current gamepad button.
var bs = ButtonState.Released;
if (btn.Button == MouseButton.Left)
{
bs = state.LeftButton;
}
else if (btn.Button == MouseButton.Right)
{
bs = state.RightButton;
}
else if (btn.Button == MouseButton.Middle)
{
bs = state.MiddleButton;
}
else if (btn.Button == MouseButton.XButton1)
{
bs = state.XButton1;
}
else if (btn.Button == MouseButton.XButton2)
{
bs = state.XButton2;
}
else
{
continue;
}
// Current state button pressed?
var pressed = (bs == ButtonState.Pressed);
if (pressed)
{
// Update the repeat delay timer for the associated button.
var ms = gameTime.ElapsedGameTime.TotalMilliseconds;
if (pressed)
{
btn.Countdown -= ms;
}
}
// Button was just pressed?
if ((pressed) && (!btn.Pressed))
{
// "Press" the associated button.
btn.Pressed = true;
BuildMouseEvent(state, btn.Button, ref e);
// Fire the MouseDown and MousePress events.
if (MouseDown != null)
{
MouseDown.Invoke(this, e);
}
// Fire the repeat MousePress event.
}
// Button was just released?
else if ((!pressed) && (btn.Pressed))
{
// "Release" the associated button and reset the repeat delay timer.
btn.Pressed = false;
btn.Countdown = RepeatDelay;
BuildMouseEvent(state, btn.Button, ref e);
// Fire the MouseUp event.
if (MouseUp != null)
{
MouseUp.Invoke(this, e);
}
}
// Button is held down and it's time to fire a repeat press event?
else if (btn.Pressed && btn.Countdown < 0)
{
// Update event args and reset timer.
e.Button = btn.Button;
btn.Countdown = RepeatRate;
BuildMouseEvent(state, btn.Button, ref e);
// Fire the repeat MousePress event.
if (MousePress != null)
{
MousePress.Invoke(this, e);
}
}
}
#endif
}
/// <summary>
/// Raise the event <see cref="MouseDown"/>.
/// </summary>
protected virtual void OnMouseDown(Point location, MouseButton buttons)
{
MouseDown?.Invoke(this, new NativeWindowMouseEventArgs(_DeviceContext, _RenderContext, location, buttons));
}
/// <summary>
/// Goes through each key checking its state compared to the last
/// frame, triggering events if necessary. Updates the current mouse
/// state and triggers events if necessary.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
#region Update Keyboard
// Create the Arguments class and fill in with the modifier data
KeyEventArgs keyEvent = new KeyEventArgs();
foreach (Keys key in Keyboard.GetState().GetPressedKeys())
{
if (key == Keys.LeftAlt || key == Keys.RightAlt)
{
keyEvent.Alt = true;
}
else if (key == Keys.LeftShift || key == Keys.RightShift)
{
keyEvent.Shift = true;
}
else if (key == Keys.LeftControl || key == Keys.RightControl)
{
keyEvent.Control = true;
}
}
// Loop through our keys
foreach (InputKey key in this.keys)
{
// If they are any of the modifier keys, skip them
if (key.Key == Keys.LeftAlt || key.Key == Keys.RightAlt ||
key.Key == Keys.LeftShift || key.Key == Keys.RightShift ||
key.Key == Keys.LeftControl || key.Key == Keys.RightControl
)
{
continue;
}
// Check if the key was pressed
bool pressed = Keyboard.GetState().IsKeyDown(key.Key);
// If it was, decrement the countdown for that key
if (pressed)
{
key.Countdown -= gameTime.ElapsedRealTime.Milliseconds;
}
if ((pressed) && (!key.Pressed)) // If it is pressed, but wasn't before...
{
// Set some flags and invoke the KeyDown event
key.Pressed = true;
keyEvent.Key = key.Key;
if (KeyDown != null)
{
KeyDown.Invoke(keyEvent);
}
}
else if ((!pressed) && (key.Pressed)) // If it isn't pressed, but was before...
{
// Set some flags, reset the countdown
key.Pressed = false;
key.Countdown = RepeatDelay;
keyEvent.Key = key.Key;
// Invoke the Key Up event
if (KeyUp != null)
{
KeyUp.Invoke(keyEvent);
}
}
// If the Key's Countdown has zeroed out, reset it, and make
// sure that KeyDown fires again
if (key.Countdown < 0)
{
keyEvent.Key = key.Key;
if (KeyDown != null)
{
KeyDown.Invoke(keyEvent);
}
key.Countdown = RepeatRate;
}
}
#endregion
#region Update Mouse
MouseState mouseState = Mouse.GetState();
// Check for mouse move event
if ((mouseState.X != this.currentMouseState.X) || (mouseState.Y != this.currentMouseState.Y))
{
if (MouseMove != null)
{
MouseEventArgs mouseEvent = new MouseEventArgs();
mouseEvent.State = mouseState;
mouseEvent.Button = MouseButtons.None;
// Cap mouse position to the window boundaries
mouseEvent.Position = new Point(mouseState.X, mouseState.Y);
if (mouseEvent.Position.X < 0)
{
mouseEvent.Position.X = 0;
}
if (mouseEvent.Position.Y < 0)
{
mouseEvent.Position.Y = 0;
}
Rectangle bounds = this.Game.Window.ClientBounds;
if (mouseEvent.Position.X > bounds.Width)
{
mouseEvent.Position.X = bounds.Width;
}
if (mouseEvent.Position.Y > bounds.Height)
{
mouseEvent.Position.Y = bounds.Height;
}
MouseMove.Invoke(mouseEvent);
}
}
if (mouseState.LeftButton != currentMouseState.LeftButton)
{
if ((MouseUp != null) || (MouseDown != null))
{
MouseEventArgs mouseEvent = new MouseEventArgs();
mouseEvent.State = mouseState;
mouseEvent.Position = new Point(mouseState.X, mouseState.Y);
mouseEvent.Button = MouseButtons.Left;
if (mouseState.LeftButton == ButtonState.Released)
{
if (MouseUp != null)
{
MouseUp.Invoke(mouseEvent);
}
}
else
{
if (MouseDown != null)
{
// Must request focus first, to prevent mousedown
// event from being swallowed up
if (RequestingFocus != null)
{
RequestingFocus.Invoke(mouseEvent);
}
MouseDown.Invoke(mouseEvent);
}
}
}
}
if (mouseState.RightButton != currentMouseState.RightButton)
{
if ((MouseUp != null) || (MouseDown != null))
{
MouseEventArgs mouseEvent = new MouseEventArgs();
mouseEvent.State = mouseState;
mouseEvent.Position = new Point(mouseState.X, mouseState.Y);
mouseEvent.Button = MouseButtons.Right;
if (mouseState.RightButton == ButtonState.Released)
{
if (MouseUp != null)
{
MouseUp.Invoke(mouseEvent);
}
}
else
{
if (MouseDown != null)
{
MouseDown.Invoke(mouseEvent);
}
}
}
}
// Update mouse state
this.currentMouseState = mouseState;
#endregion
base.Update(gameTime);
}
protected virtual void OnMouseDown(MouseButton button) => MouseDown?.Invoke(button);
/// <summary>
/// Raises the MouseDown event. Override this method to add code to handle when a mouse button is pressed
/// </summary>
/// <param name="e">InputEventCM for the MouseDown event</param>
private void invokeMouseDown(InputEventMouse e)
{
MouseDown?.Invoke(e);
}
private void pbMyPictureBox_MouseDown(object sender, MouseEventArgs e)
{
MouseDown?.Invoke(this, e);
}
private IntPtr MouseHookProc(int nCode, IntPtr wParam, IntPtr lParam)
{
Hook.MSLLHOOKSTRUCT hs = (Hook.MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(Hook.MSLLHOOKSTRUCT));
Message.WindowsMessage wm = (Message.WindowsMessage)wParam;
if (nCode >= 0)
{
Keyboard.VirtualKeyStates key;
switch (wm)
{
case Message.WindowsMessage.LBUTTONDOWN:
case Message.WindowsMessage.NCLBUTTONDOWN:
case Message.WindowsMessage.LBUTTONUP:
case Message.WindowsMessage.NCLBUTTONUP:
key = Keyboard.VirtualKeyStates.LButton;
break;
case Message.WindowsMessage.RBUTTONDOWN:
case Message.WindowsMessage.NCRBUTTONDOWN:
case Message.WindowsMessage.RBUTTONUP:
case Message.WindowsMessage.NCRBUTTONUP:
key = Keyboard.VirtualKeyStates.RButton;
break;
case Message.WindowsMessage.MBUTTONDOWN:
case Message.WindowsMessage.NCMBUTTONDOWN:
case Message.WindowsMessage.MBUTTONUP:
case Message.WindowsMessage.NCMBUTTONUP:
key = Keyboard.VirtualKeyStates.MButton;
break;
case Message.WindowsMessage.XBUTTONDOWN:
case Message.WindowsMessage.NCXBUTTONDOWN:
case Message.WindowsMessage.XBUTTONUP:
case Message.WindowsMessage.NCXBUTTONUP:
key = (hs.mouseData & 0x10000) != 0 ? Keyboard.VirtualKeyStates.XButton1 : Keyboard.VirtualKeyStates.XButton2;
break;
default:
key = Keyboard.VirtualKeyStates.None;
break;
}
MouseState.MouseStatus status;
switch (wm)
{
case Message.WindowsMessage.LBUTTONDOWN:
case Message.WindowsMessage.NCLBUTTONDOWN:
case Message.WindowsMessage.RBUTTONDOWN:
case Message.WindowsMessage.NCRBUTTONDOWN:
case Message.WindowsMessage.MBUTTONDOWN:
case Message.WindowsMessage.NCMBUTTONDOWN:
case Message.WindowsMessage.XBUTTONDOWN:
case Message.WindowsMessage.NCXBUTTONDOWN:
status = MouseState.MouseStatus.Down;
break;
case Message.WindowsMessage.LBUTTONUP:
case Message.WindowsMessage.NCLBUTTONUP:
case Message.WindowsMessage.RBUTTONUP:
case Message.WindowsMessage.NCRBUTTONUP:
case Message.WindowsMessage.MBUTTONUP:
case Message.WindowsMessage.NCMBUTTONUP:
case Message.WindowsMessage.XBUTTONUP:
case Message.WindowsMessage.NCXBUTTONUP:
status = MouseState.MouseStatus.Up;
break;
case Message.WindowsMessage.MOUSEWHEEL:
case Message.WindowsMessage.MOUSEHWHEEL:
status = MouseState.MouseStatus.Wheel;
break;
case Message.WindowsMessage.MOUSEMOVE:
case Message.WindowsMessage.NCMOUSEMOVE:
status = MouseState.MouseStatus.Move;
break;
default:
status = MouseState.MouseStatus.None;
break;
}
int wheel;
int hWheel;
switch (wm)
{
case Message.WindowsMessage.MOUSEWHEEL:
wheel = (short)(hs.mouseData >> 16);
hWheel = 0;
break;
case Message.WindowsMessage.MOUSEHWHEEL:
wheel = 0;
hWheel = (short)(hs.mouseData >> 16);
break;
default:
wheel = 0;
hWheel = 0;
break;
}
MouseState ms = MouseState.CreateCurrent(key, status, hs.x, hs.y, wheel, hWheel, TimeSpan.FromMilliseconds(hs.time));
switch (ms.Status)
{
case MouseState.MouseStatus.Down:
MouseAny?.Invoke(this, ms);
MouseDown?.Invoke(this, ms);
break;
case MouseState.MouseStatus.Up:
MouseAny?.Invoke(this, ms);
MouseUp?.Invoke(this, ms);
break;
case MouseState.MouseStatus.Wheel:
MouseAny?.Invoke(this, ms);
MouseWheel?.Invoke(this, ms);
break;
case MouseState.MouseStatus.Move:
MouseAny?.Invoke(this, ms);
MouseMove?.Invoke(this, ms);
break;
default:
MouseAny?.Invoke(this, ms);
break;
}
if (CallNextHook is null || CallNextHook(this, ms))
{
return(Hook.CallNextHookEx(_mHHook, nCode, wParam, lParam));
}
else
{
return(_mHHook);
}
}
/// <summary>
/// Allows for inheriting tools to control OnMouseDown.
/// </summary>
/// <param name="e">A GeoMouseArgs parameter.</param>
protected virtual void OnMouseDown(GeoMouseArgs e)
{
MouseDown?.Invoke(this, e);
}
protected override bool HookCallback(IntPtr wParam, IntPtr lParam)
{
var mouseHookStruct = (MouseLLHookStruct)Marshal.PtrToStructure(lParam, typeof(MouseLLHookStruct));
MouseButtons button = MouseButtons.None;
Keys keyCode = Keys.None;
short mouseDelta = 0;
int clickCount = 0;
bool isMouseButtonDown = false;
bool isMouseButtonUp = false;
switch ((Messages)wParam)
{
case Messages.WM_LBUTTONDOWN:
case Messages.WM_LBUTTONUP:
case Messages.WM_LBUTTONDBLCLK:
button = MouseButtons.Left;
keyCode = Keys.LButton;
break;
case Messages.WM_RBUTTONDOWN:
case Messages.WM_RBUTTONUP:
case Messages.WM_RBUTTONDBLCLK:
button = MouseButtons.Right;
keyCode = Keys.RButton;
break;
case Messages.WM_MBUTTONDOWN:
case Messages.WM_MBUTTONUP:
case Messages.WM_MBUTTONDBLCLK:
button = MouseButtons.Middle;
keyCode = Keys.MButton;
break;
case Messages.WM_XBUTTONDOWN:
case Messages.WM_XBUTTONUP:
case Messages.WM_XBUTTONDBLCLK:
if (mouseHookStruct.MouseData == 1)
{
button = MouseButtons.XButton1;
keyCode = Keys.XButton1;
}
else
{
button = MouseButtons.XButton2;
keyCode = Keys.XButton2;
}
break;
}
switch ((Messages)wParam)
{
case Messages.WM_MOUSEWHEEL:
mouseDelta = mouseHookStruct.MouseData;
if (mouseDelta > 0)
{
keyCode = (Keys)KeysEx.WheelUp;
}
if (mouseDelta < 0)
{
keyCode = (Keys)KeysEx.WheelDown;
}
break;
case Messages.WM_MOUSEHWHEEL:
//mouseDelta = mouseHookStruct.MouseData;
break;
case Messages.WM_LBUTTONDOWN:
case Messages.WM_RBUTTONDOWN:
case Messages.WM_MBUTTONDOWN:
case Messages.WM_XBUTTONDOWN:
clickCount = 1;
isMouseButtonDown = true;
break;
case Messages.WM_LBUTTONUP:
case Messages.WM_RBUTTONUP:
case Messages.WM_MBUTTONUP:
case Messages.WM_XBUTTONUP:
clickCount = 1;
isMouseButtonUp = true;
break;
case Messages.WM_LBUTTONDBLCLK:
case Messages.WM_RBUTTONDBLCLK:
case Messages.WM_MBUTTONDBLCLK:
case Messages.WM_XBUTTONDBLCLK:
clickCount = 2;
break;
}
var e = new MouseEventExtArgs(
button,
keyCode,
clickCount,
mouseHookStruct.Point.X,
mouseHookStruct.Point.Y,
mouseDelta);
if (MouseDown != null && isMouseButtonDown)
{
MouseDown.Invoke(null, e);
}
if (MouseUp != null && isMouseButtonUp)
{
MouseUp.Invoke(null, e);
}
if (MouseWheel != null && mouseDelta != 0)
{
MouseWheel.Invoke(null, e);
}
if (MouseMove != null && !_oldPoint.Equals(mouseHookStruct.Point))
{
MouseMove.Invoke(null, e);
}
_oldPoint = mouseHookStruct.Point;
return(e.Handled);
}
internal void InvokeMouseDown(ScreenEventArgs args) => MouseDown?.Invoke(this, args);
private void mouseHook_Callback(int nCode, IntPtr wParam, IntPtr lParam, ref bool handled)
{
//Marshall the data from callback.
MouseLLHookStruct mouseHookStruct =
(MouseLLHookStruct)Marshal.PtrToStructure(lParam, typeof(MouseLLHookStruct));
//detect button clicked
MouseButtons button = MouseButtons.None;
short mouseDelta = 0;
bool mouseDown = false;
bool mouseUp = false;
switch ((int)wParam)
{
case WM_LBUTTONDOWN:
mouseDown = true;
button = MouseButtons.Left;
break;
case WM_LBUTTONUP:
mouseUp = true;
button = MouseButtons.Left;
break;
case WM_RBUTTONDOWN:
mouseDown = true;
button = MouseButtons.Right;
break;
case WM_RBUTTONUP:
mouseUp = true;
button = MouseButtons.Right;
break;
case WM_MBUTTONDOWN:
mouseDown = true;
button = MouseButtons.Middle;
break;
case WM_MBUTTONUP:
mouseUp = true;
button = MouseButtons.Middle;
break;
case WM_MOUSEWHEEL:
//If the message is WM_MOUSEWHEEL, the high-order word of MouseData member is the wheel delta.
//One wheel click is defined as WHEEL_DELTA, which is 120.
//(value >> 16) & 0xffff; retrieves the high-order word from the given 32-bit value
mouseDelta = (short)((mouseHookStruct.MouseData >> 16) & 0xffff);
break;
case WM_XBUTTONDOWN:
mouseDown = true;
switch (mouseHookStruct.MouseData >> 16)
{
case XBUTTON1:
button = MouseButtons.XButton1;
break;
case XBUTTON2:
button = MouseButtons.XButton2;
break;
}
break;
case WM_XBUTTONUP:
mouseUp = true;
switch (mouseHookStruct.MouseData >> 16)
{
case XBUTTON1:
button = MouseButtons.XButton1;
break;
case XBUTTON2:
button = MouseButtons.XButton2;
break;
}
break;
}
//generate event
MouseEventExtArgs e = new MouseEventExtArgs(
button,
mouseUp || mouseDown ? 1 : 0,
mouseHookStruct.Point.X,
mouseHookStruct.Point.Y,
mouseDelta);
//Mouse down
if (MouseDown != null && mouseDown)
{
MouseDown.Invoke(null, e);
}
//If someone listens to click and a click is heppened
if (MouseClick != null && mouseDown)
{
MouseClick.Invoke(null, e);
}
//Mouse up
if (MouseUp != null && mouseUp)
{
MouseUp.Invoke(null, e);
}
//Wheel was moved
if (MouseWheel != null && mouseDelta != 0)
{
MouseWheel.Invoke(null, e);
}
handled = handled || e.Handled;
//If someone listens to move and there was a change in coordinates raise move event
if ((MouseMove != null) && (mOldX != mouseHookStruct.Point.X || mOldY != mouseHookStruct.Point.Y))
{
mOldX = mouseHookStruct.Point.X;
mOldY = mouseHookStruct.Point.Y;
MouseMove.Invoke(null, e);
handled = handled || (e.Handled && (int)wParam == WM_MOUSEMOVE);
}
}
internal void InvokeMouseDown(S sender, T state, UIMouseDownEventArgs e)
{
MouseDown.Invoke(new SenderInfo(sender, state), e);
}
