public static void MouseMove(MouseHooker hooker, MouseMessages message, HookStruct str)
{
MouseCatcher m = MouseCatcherRef;
m.Pattern.Actions.Add("WAIT " + m.GetElapsedTime());
m.Pattern.Actions.Add(str.pt.x + " " + str.pt.y);
}
public static void LeftClickDown(MouseHooker hook, MouseMessages message, HookStruct str)
{
MouseCatcher m = MouseCatcherRef;
if (message == MouseMessages.WM_LBUTTONDOWN)
m.Pattern.Actions.Add("LEFT_CLICK_DOWN");
}
public static void RightClickUp(MouseHooker hook, MouseMessages message, HookStruct str)
{
MouseCatcher m = MouseCatcherRef;
if (message == MouseMessages.WM_RBUTTONUP)
m.Pattern.Actions.Add("RIGHT_CLICK_UP");
}
private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0 && MouseMessages.WM_LBUTTONDOWN == (MouseMessages)wParam)
{
MouseMessages mouseState = (MouseMessages)wParam;
MSLLHOOKSTRUCT hookStruct = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
switch (mouseState)
{
case MouseMessages.WM_LBUTTONDOWN:
LeftButtonDown(this, new Point(hookStruct.pt.x, hookStruct.pt.y));
break;
case MouseMessages.WM_LBUTTONUP:
LeftButtonUp(this, new Point(hookStruct.pt.x, hookStruct.pt.y));
break;
case MouseMessages.WM_RBUTTONDOWN:
RightButtonDown(this, new Point(hookStruct.pt.x, hookStruct.pt.y));
break;
case MouseMessages.WM_RBUTTONUP:
RightButtonUp(this, new Point(hookStruct.pt.x, hookStruct.pt.y));
break;
}
}
return(CallNextHookEx(hookID, nCode, wParam, lParam));
}
public void MouseEventHandler(MouseMessages msg, int x, int y)
{
switch (msg)
{
case MouseMessages.WM_MOUSEMOVE:
_chromiumWebBrowser.GetBrowser().GetHost().SendMouseMoveEvent(x, y, false, CefEventFlags.None);
break;
case MouseMessages.WM_LBUTTONDOWN:
_chromiumWebBrowser.GetBrowser().GetHost().SendMouseClickEvent(x, y, MouseButtonType.Left, false, 1, CefEventFlags.None);
break;
case MouseMessages.WM_LBUTTONUP:
_chromiumWebBrowser.GetBrowser().GetHost().SendMouseClickEvent(x, y, MouseButtonType.Left, true, 1, CefEventFlags.None);
break;
case MouseMessages.WM_MOUSEWHEEL:
break;
case MouseMessages.WM_RBUTTONDOWN:
_chromiumWebBrowser.GetBrowser().GetHost().SendMouseClickEvent(x, y, MouseButtonType.Right, true, 1, CefEventFlags.None);
break;
case MouseMessages.WM_RBUTTONUP:
_chromiumWebBrowser.GetBrowser().GetHost().SendMouseClickEvent(x, y, MouseButtonType.Right, true, 1, CefEventFlags.None);
break;
}
}
private static bool HandleMouseInput(MSLLHOOKSTRUCT strct, MouseMessages mm)
{
if (strct.flags != 0 || !Program.isToggled || !(a.minecraft != IntPtr.Zero))
{
return(true);
}
switch (mm)
{
case MouseMessages.WM_LBUTTONDOWN:
isLeftDown = true;
PostMessage(a.minecraft, 513u, 0, 0);
break;
case MouseMessages.WM_LBUTTONUP:
isLeftDown = false;
PostMessage(a.minecraft, 514u, 0, 0);
break;
case MouseMessages.WM_RBUTTONDOWN:
PostMessage(a.minecraft, 516u, 0, 0);
break;
case MouseMessages.WM_RBUTTONUP:
PostMessage(a.minecraft, 517u, 0, 0);
break;
default:
return(true);
}
return(false);
}
private bool MessageEquals(MouseMessages mouseMsg, int nCode, IntPtr wParam)
{
if (nCode < 0)
{
return(false);
}
var mParam = (MouseMessages)wParam;
return(mParam == mouseMsg);
}
private void Action(MouseLLHookStruct data, MouseMessages message)
{
var strCaption = string.Format("time = {3}, x = {0}, y = {1}, flags = {4}, message = {2}\r\n",
data.pt.x.ToString("d"),
data.pt.y.ToString("d"),
(int)message,
data.time,
data.flags);
var bytes = Encoding.ASCII.GetBytes(strCaption);
fs.Write(bytes, 0, bytes.Length);
}
private void Action(MouseLLHookStruct data, MouseMessages message)
{
var strCaption = string.Format("time = {3}, x = {0}, y = {1}, flags = {4}, message = {2}\r\n",
data.pt.x.ToString("d"),
data.pt.y.ToString("d"),
(int)message,
data.time,
data.flags);
var bytes = Encoding.ASCII.GetBytes(strCaption);
fs.Write(bytes, 0, bytes.Length);
}
private static IntPtr HookCallback(
int nCode, IntPtr wParam, IntPtr lParam)
{
MouseMessages MSGTP = (MouseMessages)wParam;
if (nCode >= 0 && (MSGTP == MouseMessages.WM_MOUSEWHEEL || MSGTP == MouseMessages.WM_MOUSEMOVE))
{
MSLLHOOKSTRUCT hookStruct = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
MouseAction(null, new MouseEventArgs(NativeMethods.GET_WHEEL_DELTA_WPARAM(hookStruct.mouseData), hookStruct.pt.x, hookStruct.pt.y));
}
return(CallNextHookEx(_hookID, nCode, wParam, lParam));
}
private bool CheckMouseMessagesUp(MouseMessages wParam)
{
switch (wParam)
{
case MouseMessages.WM_LBUTTONUP:
return(true);
case MouseMessages.WM_RBUTTONUP:
return(true);
}
return(false);
}
private static void OnMouseDown(MouseMessages message, MouseLowLevelHookStruct mouseInfo)
{
var hWnd = User32.WindowFromPoint(mouseInfo.Point);
var control = Control.FromHandle(hWnd);
while (control != null)
{
if (ignoreHandles.Contains(control.Handle))
{
// Ignore this message
return;
}
control = control.Parent;
}
MouseButtons button;
if (message == MouseMessages.WM_LBUTTONDOWN ||
message == MouseMessages.WM_LBUTTONUP)
{
button = MouseButtons.Left;
}
else if (message == MouseMessages.WM_RBUTTONDOWN ||
message == MouseMessages.WM_RBUTTONUP)
{
button = MouseButtons.Right;
}
else
{
// TODO: other events?
return;
}
var mouseEventArgs = new MouseEventArgs(
button: button,
clicks: 1,
x: mouseInfo.Point.X,
y: mouseInfo.Point.Y,
delta: 0);
if (message == MouseMessages.WM_LBUTTONDOWN ||
message == MouseMessages.WM_RBUTTONDOWN)
{
MouseDown?.Invoke(null, mouseEventArgs);
}
else if (message == MouseMessages.WM_LBUTTONUP ||
message == MouseMessages.WM_RBUTTONUP)
{
MouseUp?.Invoke(null, mouseEventArgs);
}
}
private int MouseHookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
MouseMessages mouseInfo = (MouseMessages)wParam;
if (nCode >= 0 && ((mouseInfo == MouseMessages.WM_LBUTTONDOWN) || (mouseInfo == MouseMessages.WM_RBUTTONDOWN)))
{
LastActivity = DateTime.Now;
//Debug.WriteLine("MouseHookCallback: " + _currState.ToString() + "\t" + DateTime.Now.ToString() + "\t" + nCode.ToString() + "\t" + wParam + "\t" + lParam);
//Debug.WriteLine("\t" + hookStruct.flags.ToString() + "\t" + hookStruct.mouseData.ToString() + "\t" + hookStruct.time.ToString());
}
return(CallNextHookEx(_mouseHookID, nCode, wParam, lParam));
}
internal MouseHookEventArgs(IntPtr wparam, IntPtr lparam)
{
if (!Enum.IsDefined(typeof(MouseMessages), wparam.ToInt32()))
message = MouseMessages.Unknown;
else
message = (MouseMessages)wparam.ToInt32();
MOUSEHOOKSTRUCT hs = (MOUSEHOOKSTRUCT)Marshal.PtrToStructure(lparam, typeof(MOUSEHOOKSTRUCT));
point = new Point(hs.pt.x, hs.pt.y);
hwnd = hs.hwnd;
hitTestCode = (HitTestCodes)hs.hitTestCode;
extraInfo = hs.extraInfo;
}
//The funtion called when mouse event occurs
private static IntPtr MouseProc(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0)
{
MSLLHOOKSTRUCT hookStruct = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));// gets the structure pointed at by lParam
MouseMessages message = (MouseMessages)wParam;
if (MouseMessages.WM_LBUTTONDOWN == message)
{
MouseLBDown(hookStruct);
}
if (MouseMessages.WM_LBUTTONUP == message)
{
MouseLBUp(hookStruct);
}
if (MouseMessages.WM_RBUTTONDOWN == message)
{
MouseRBDown(hookStruct);
}
if (MouseMessages.WM_RBUTTONUP == message)
{
MouseRBUp(hookStruct);
}
if (MouseMessages.WM_MOUSEMOVE == message)
{
MouseMove(hookStruct);
}
if (MouseMessages.WM_MOUSEWHEEL == message)
{
MouseScroll(hookStruct);
}
if (MouseMessages.WM_XBUTTONDOWN == message)
{
MouseXDown(hookStruct);
}
if (MouseMessages.WM_XBUTTONUP == message)
{
MouseXUp(hookStruct);
}
if (MouseMessages.WM_MBUTTONDOWN == message)
{
MouseMBDown(hookStruct);
}
if (MouseMessages.WM_MBUTTONUP == message)
{
MouseMBUp(hookStruct);
}
}
return(CallNextHookEx(_mouseHookID, nCode, wParam, lParam));
}
private ButtonType ToButtonType(MouseMessages message)
{
if (message == MouseMessages.WM_RBUTTONDOWN || message == MouseMessages.WM_RBUTTONUP)
{
return(ButtonType.Right);
}
else if (message == MouseMessages.WM_WHEELBUTTONDOWN || message == MouseMessages.WM_WHEELBUTTONUP)
{
return(ButtonType.Wheel);
}
else
{
return(ButtonType.Left);
}
}
internal MouseHookEventArgs(System.IntPtr wparam, System.IntPtr lparam)
{
if (!System.Enum.IsDefined(typeof(MouseMessages), (int) wparam.ToInt32()))
{
this.message = MouseMessages.Unknown;
}
else
{
this.message = (MouseMessages) wparam.ToInt32();
}
MOUSEHOOKSTRUCT mousehookstruct = (MOUSEHOOKSTRUCT) System.Runtime.InteropServices.Marshal.PtrToStructure(lparam, typeof(MOUSEHOOKSTRUCT));
this.point = new System.Drawing.Point(mousehookstruct.pt.x, mousehookstruct.pt.y);
this.hwnd = mousehookstruct.hwnd;
this.hitTestCode = (HitTestCodes) mousehookstruct.hitTestCode;
this.extraInfo = mousehookstruct.extraInfo;
}
internal MouseHookEventArgs(IntPtr wparam, IntPtr lparam)
{
if (!Enum.IsDefined(typeof(MouseMessages), wparam.ToInt32()))
{
message = MouseMessages.Unknown;
}
else
{
message = (MouseMessages)wparam.ToInt32();
}
MOUSEHOOKSTRUCT hs = (MOUSEHOOKSTRUCT)Marshal.PtrToStructure(lparam, typeof(MOUSEHOOKSTRUCT));
point = new Point(hs.pt.x, hs.pt.y);
hwnd = hs.hwnd;
hitTestCode = (HitTestCodes)hs.hitTestCode;
extraInfo = hs.extraInfo;
}
private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0)
{
MouseMessages message = (MouseMessages)Marshal.ReadInt32(wParam);
MSLLHOOKSTRUCT hookStruct = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
this.Event(
this,
new MouseEventArgs(
hookStruct.pt.X,
hookStruct.pt.Y,
hookStruct.flags,
hookStruct.mouseData,
hookStruct.time,
message.GetName()));
}
return(Interop.CallNextHookEx(this.hookPointer, nCode, wParam, lParam));
}
public static void sendMouseClick(int hwnd, MouseMessages m, int x, int y)
{
//SetForegroundWindow(hwnd);
bool sent = false;
switch (m)
{
case MouseMessages.WM_LBUTTONUP:
sent = PostMessage(hwnd, MouseMessages.WM_LBUTTONUP, 0x00000000, MakeLParam(x, y));
break;
case MouseMessages.WM_LBUTTONDOWN:
sent = PostMessage(hwnd, MouseMessages.WM_LBUTTONDOWN, 0x00000001, MakeLParam(x, y));
break;
}
if (sent == false)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
}
private int HookCallBack(int nCode, int wParam, int lParam)
{
//Marshall the data from the callback.
MouseHookStruct CurrentMouseHookStruct = (MouseHookStruct)Marshal.PtrToStructure((IntPtr)lParam, typeof(MouseHookStruct));
MouseMessages CurrentMouseMessage = (MouseMessages)wParam;
if (nCode < 0)
{
return(CallNextHookEx(hHook, nCode, wParam, lParam));
}
else
{
//Create a string variable that shows the current mouse coordinates.
String strCaption = "x = " +
CurrentMouseHookStruct.pt.x.ToString("d") +
" y = " +
CurrentMouseHookStruct.pt.y.ToString("d");
MouseAction?.Invoke(CurrentMouseMessage, CurrentMouseHookStruct.pt.x, CurrentMouseHookStruct.pt.y);
return(CallNextHookEx(hHook, nCode, wParam, lParam));
}
}
public static string getStateMouse(MouseMessages m)
{
string mess = "";
switch (m)
{
case MouseMessages.WM_LBUTTONDOWN:
mess = "Left Click Down";
break;
case MouseMessages.WM_LBUTTONUP:
mess = "Left Click Up";
break;
case MouseMessages.WM_MOUSEMOVE:
mess = "Move";
break;
case MouseMessages.WM_MOUSEWHEEL:
mess = "Wheel";
break;
case MouseMessages.WM_RBUTTONDOWN:
mess = "Right Click Down";
break;
case MouseMessages.WM_RBUTTONUP:
mess = "Right Click Up";
break;
default:
mess = "Unkown Mouse Action";
break;
}
return(mess);
}
public MouseEventArgs(MouseMessages mouseMessage, Point point)
{
this.MouseMessage = mouseMessage;
this.Point = point;
}
/// <summary>
/// Mouse event hook callback
/// </summary>
/// <param name="nCode"></param>
/// <param name="wParam"></param>
/// <param name="lParam"></param>
/// <returns></returns>
private IntPtr Mouse_HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
try
{
if (nCode < 0)
{
return(User32.CallNextHookEx(mouseHookID, nCode, wParam, lParam));
}
POINT point = ((MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT))).pt;
MouseMessages mouseMessage = 0;
switch ((MouseMessages)wParam)
{
case MouseMessages.WM_MOUSEMOVE:
case MouseMessages.WM_LBUTTONDOWN:
case MouseMessages.WM_RBUTTONDOWN:
case MouseMessages.WM_LBUTTONUP:
case MouseMessages.WM_RBUTTONUP:
mouseMessage = (MouseMessages)wParam;
break;
default:
// Do not process other events.
return(User32.CallNextHookEx(mouseHookID, nCode, wParam, lParam));
}
IntPtr hWnd = IntPtr.Zero;
if (mouseMessage != MouseMessages.WM_MOUSEMOVE)
{ // over form1
IntPtr hOwner = tool.getRootOwner(point, out hWnd);
if (hOwner == Handle)
{
// The event happend on Form1, treat it as a mouse move event.
mouseMessage = MouseMessages.WM_MOUSEMOVE;
// Allow buttons on Form1 to receive clicking immediately.
this.Activate();
}
}
int nowMs = DateTime.Now.Millisecond;
if (mouseMessage == MouseMessages.WM_MOUSEMOVE &&
nowMs - refTimeMs < 200 && nowMs > refTimeMs)
{
// Filter out the mouse move events which happend in 200 ms.
return(User32.CallNextHookEx(mouseHookID, nCode, (IntPtr)mouseMessage, lParam));
}
// Prepare parementers and raise a local mouse event
MouseActionEventArgs e = new MouseActionEventArgs(mouseMessage, point, hWnd);
OnMouseAction(e);
// Change reference time
refTimeMs = DateTime.Now.Millisecond;
}
catch (Exception e)
{
Debug.WriteLine("Error in private IntPtr Mouse_HookCallback(int nCode, IntPtr wParam, IntPtr lParam): " + e.Message);
}
return(User32.CallNextHookEx(mouseHookID, nCode, wParam, lParam));
}
public InterceptMouseEventArgs(MouseMessages mouseMessage, Point point)
{
MouseMessage = mouseMessage;
MousePoint = point;
}
private static uint MouseEventCoverter(MouseMessages msg)
{
return((uint)(MouseEvents)Enum.Parse(typeof(MouseEvents), msg.ToString()));
}
public MouseActionEventArgs(MouseMessages mouseMessage, POINT point, IntPtr hWnd)
{
this.mouseMessage = mouseMessage;
this.point = point;
this.hWnd = hWnd;
}
public static extern int CallNextHookEx(IntPtr hhk, int nCode, MouseMessages wParam, [In] MSLLHOOKSTRUCT lParam);
//build mouse command
private static void BuildMouseCommand(IntPtr lParam, MouseMessages mouseMessage)
{
MsLlHookStruct hookStruct = (MsLlHookStruct)Marshal.PtrToStructure(lParam, typeof(MsLlHookStruct));
string mouseEventClickType;
switch (mouseMessage)
{
case MouseMessages.WmLButtonDown:
mouseEventClickType = "Left Down";
break;
case MouseMessages.WmLButtonUp:
mouseEventClickType = "Left Up";
break;
case MouseMessages.WmMButtonDown:
mouseEventClickType = "Middle Down";
break;
case MouseMessages.WmMButtonUp:
mouseEventClickType = "Middle Up";
break;
case MouseMessages.WmMouseMove:
mouseEventClickType = "None";
if (_lastMouseMove.ElapsedMilliseconds >= _msResolution)
{
_lastMouseMove.Restart();
}
else
{
return;
}
break;
case MouseMessages.WmRButtonDown:
mouseEventClickType = "Right Down";
break;
case MouseMessages.WmRButtonUp:
mouseEventClickType = "Right Up";
break;
default:
return;
}
//return if we do not want to capture mouse moves
if ((!_performMouseMoveCapture) && (mouseEventClickType == "None"))
{
return;
}
//return if we do not want to capture mouse clicks
if ((!_performMouseClickCapture) && (mouseEventClickType != "None"))
{
return;
}
if ((GeneratedCommands.Count > 1) && (GeneratedCommands[GeneratedCommands.Count - 1] is SendMouseMoveCommand) &&
mouseEventClickType != "None" && _stopWatch.ElapsedMilliseconds <= 500 &&
hookStruct.Pt.X == _lastClickHookStruct.Pt.X && hookStruct.Pt.Y == _lastClickHookStruct.Pt.Y)
{
var lastCreatedMouseCommand = (SendMouseMoveCommand)GeneratedCommands[GeneratedCommands.Count - 1];
switch ((GeneratedCommands[GeneratedCommands.Count - 1] as SendMouseMoveCommand).v_MouseClick)
{
case "Left Down":
if (mouseEventClickType == "Left Up")
{
lastCreatedMouseCommand.v_MouseClick = "Left Click";
}
break;
case "Middle Down":
if (mouseEventClickType == "Middle Up")
{
lastCreatedMouseCommand.v_MouseClick = "Middle Click";
}
break;
case "Right Down":
if (mouseEventClickType == "Right Up")
{
lastCreatedMouseCommand.v_MouseClick = "Right Click";
}
break;
case "Left Click":
if (mouseEventClickType == "Left Down")
{
lastCreatedMouseCommand.v_MouseClick = "Left Double Click";
}
break;
default:
break;
}
}
else
{
//build a pause command to track pause since last command
BuildPauseCommand();
//define new mouse command
var mouseMove = new SendMouseMoveCommand
{
v_XMousePosition = hookStruct.Pt.X.ToString(),
v_YMousePosition = hookStruct.Pt.Y.ToString(),
v_MouseClick = mouseEventClickType
};
if (mouseEventClickType != "None")
{
IntPtr winHandle = WindowFromPoint(hookStruct.Pt);
_ = GetWindowText(winHandle, _buffer, _buffer.Capacity);
var windowName = _buffer.ToString();
mouseMove.v_Comment = "Clicked On Window: " + windowName;
}
GeneratedCommands.Add(mouseMove);
}
_lastClickHookStruct = hookStruct;
}
public MouseActionEventArgs(MouseMessages mouseMessage, POINT point, IntPtr hWnd)
{
this.mouseMessage = mouseMessage;
this.point = point;
this.hWnd = hWnd;
}
public static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0)
{
MouseMessages mouseMessage = (MouseMessages)wParam;
MSLLHOOKSTRUCT hookStruct = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
// Translate mouse button into key code and action (press / release)
VirtualKeyCode keyCode;
MouseButtons mouseButton;
ButtonStates buttonState = ButtonStates.Press;
WheelMoves wheelMove = WheelMoves.None;
// Switch could be refactored into a lookup table to make this cleaner
// Translate mouse messages into something Glue can use
switch (mouseMessage)
{
case MouseMessages.WM_LBUTTONDBLCLK:
case MouseMessages.WM_LBUTTONDOWN:
keyCode = VirtualKeyCode.LBUTTON;
mouseButton = MouseButtons.Left;
LOGGER.Info(String.Format("Click at ({0}, {1})", hookStruct.pt.x, hookStruct.pt.y));
break;
case MouseMessages.WM_LBUTTONUP:
keyCode = VirtualKeyCode.LBUTTON;
mouseButton = MouseButtons.Left;
buttonState = ButtonStates.Release;
break;
case MouseMessages.WM_RBUTTONDOWN:
case MouseMessages.WM_RBUTTONDBLCLK:
keyCode = VirtualKeyCode.RBUTTON;
mouseButton = MouseButtons.Right;
break;
case MouseMessages.WM_RBUTTONUP:
keyCode = VirtualKeyCode.RBUTTON;
mouseButton = MouseButtons.Right;
buttonState = ButtonStates.Release;
break;
case MouseMessages.WM_MBUTTONDOWN:
case MouseMessages.WM_MBUTTONDBLCLK:
keyCode = VirtualKeyCode.MBUTTON;
mouseButton = MouseButtons.Middle;
buttonState = ButtonStates.Press;
break;
case MouseMessages.WM_MBUTTONUP:
keyCode = VirtualKeyCode.MBUTTON;
mouseButton = MouseButtons.Middle;
buttonState = ButtonStates.Release;
break;
case MouseMessages.WM_XBUTTONDOWN:
case MouseMessages.WM_XBUTTONDBLCLK:
keyCode = GetXButtonKeyCode(hookStruct);
mouseButton = GetXButtonMouse(hookStruct);
break;
case MouseMessages.WM_XBUTTONUP:
keyCode = GetXButtonKeyCode(hookStruct);
mouseButton = GetXButtonMouse(hookStruct);
buttonState = ButtonStates.Release;
break;
case MouseMessages.WM_MOUSEWHEEL:
if (unchecked ((short)((long)hookStruct.mouseData >> 16)) > 0)
{
wheelMove = WheelMoves.Up;
}
else
{
wheelMove = WheelMoves.Down;
}
keyCode = 0;
mouseButton = MouseButtons.None;
break;
case MouseMessages.WM_MOUSEMOVE:
default:
keyCode = 0;
mouseButton = MouseButtons.None;
buttonState = ButtonStates.Release;
break;
}
// Mouse buttons are handled like keyboard keys
if (mouseMessage != MouseMessages.WM_MOUSEMOVE)
{
if (KeyboardHandler.BroadcastKeyboardEvent((int)keyCode, buttonState))
{
// Eat mouse message if any event listener says to do so
return(new IntPtr(1));
}
}
// All mouse events go on the mouse bus
if (BroadcastMouseEvent(new EventMouse(mouseButton, buttonState, wheelMove, hookStruct.pt.x, hookStruct.pt.y)))
{
return(new IntPtr(1));
}
}
// Freeze the mouse if mouse safety is toggled (and not using filter driver)
if (!Tube.InterceptorDriverInput.IsLoaded &&
Tube.MouseLocked)
{
return(new IntPtr(1));
}
return(new IntPtr(0));
}
private static extern bool PostMessage(int hWnd, MouseMessages Msg, int wParam, int lParam);
public MouseLeftEventChangeArgs(MouseMessages msg)
{
message = msg;
}
private void msHook_MouseIntercepted(int msg, ManagedWinapi.Windows.POINT pt, int mouseData, int flags, int time, IntPtr dwExtraInfo, ref bool handled)
{
MouseEvents evt = 0;
Win32Input input = new Win32Input();
MouseMessages mouseMessage = (MouseMessages)msg;
input.type = 0;
input.mi = new MouseInput();
input.mi.dx = (int)(pt.X * (65535f / (Screen.PrimaryScreen.Bounds.Width)));
input.mi.dy = (int)(pt.Y * (65535f / Screen.PrimaryScreen.Bounds.Height));
input.mi.mouseData = 0;
switch (mouseMessage)
{
case MouseMessages.WM_MOUSEMOVE:
evt = MouseEvents.MOVE;
break;
case MouseMessages.WM_LBUTTONDOWN:
evt = MouseEvents.LEFTDOWN;
break;
case MouseMessages.WM_LBUTTONUP:
evt = MouseEvents.LEFTUP;
break;
case MouseMessages.WM_MBUTTONDOWN:
evt = MouseEvents.MIDDLEDOWN;
break;
case MouseMessages.WM_MBUTTONUP:
evt = MouseEvents.MIDDLEUP;
break;
case MouseMessages.WM_RBUTTONDOWN:
evt = MouseEvents.RIGHTDOWN;
break;
case MouseMessages.WM_RBUTTONUP:
evt = MouseEvents.RIGHTUP;
break;
case MouseMessages.WM_MOUSEWHEEL:
case MouseMessages.WM_MOUSEHWHEEL:
evt = MouseEvents.WHEEL;
input.mi.mouseData = (uint)(mouseData >> 16);
break;
case MouseMessages.WM_XBUTTONDOWN:
evt = MouseEvents.XDOWN;
input.mi.mouseData = (uint)(mouseData >> 16);
break;
case MouseMessages.WM_XBUTTONUP:
evt = MouseEvents.XUP;
input.mi.mouseData = (uint)(mouseData >> 16);
break;
default:
break;
}
evt |= MouseEvents.ABSOLUTE;
input.mi.dwFlags = (uint)evt;
input.mi.time = 0;
input.mi.dwExtraInfo = IntPtr.Zero;
macroEntries.Add(new MacroRecordEntry(input, watch.ElapsedMilliseconds));
}
//build mouse command
private static void BuildMouseCommand(IntPtr lParam, MouseMessages mouseMessage)
{
string mouseEventClickType = string.Empty;
switch (mouseMessage)
{
case MouseMessages.WM_LBUTTONDOWN:
mouseEventClickType = "Left Down";
break;
case MouseMessages.WM_LBUTTONUP:
mouseEventClickType = "Left Up";
break;
case MouseMessages.WM_MOUSEMOVE:
mouseEventClickType = "None";
if (lastMouseMove.ElapsedMilliseconds >= msResolution)
{
lastMouseMove.Restart();
}
else
{
return;
}
break;
case MouseMessages.WM_RBUTTONDOWN:
mouseEventClickType = "Right Down";
break;
case MouseMessages.WM_RBUTTONUP:
mouseEventClickType = "Right Up";
break;
default:
return;
}
////return if non matching event
//if (mouseEventClickType == string.Empty)
// return;
//return if we do not want to capture mouse moves
if ((!performMouseMoveCapture) && (mouseEventClickType == "None"))
{
return;
}
//return if we do not want to capture mouse clicks
if ((!performMouseClickCapture) && (mouseEventClickType != "None"))
{
return;
}
//build a pause command to track pause since last command
BuildPauseCommand();
//define new mouse command
MSLLHOOKSTRUCT hookStruct = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
var mouseMove = new Core.Automation.Commands.SendMouseMoveCommand
{
v_XMousePosition = hookStruct.pt.x.ToString(),
v_YMousePosition = hookStruct.pt.y.ToString(),
v_MouseClick = mouseEventClickType
};
if (mouseEventClickType != "None")
{
IntPtr winHandle = WindowFromPoint(hookStruct.pt);
int length = GetWindowText(winHandle, _Buffer, _Buffer.Capacity);
var windowName = _Buffer.ToString();
mouseMove.v_Comment = "Clicked On Window: " + windowName;
}
generatedCommands.Add(mouseMove);
}
public MouseEventArgs(MouseMessages mouseMessage)
{
this.MouseMessage = mouseMessage;
}
