private void ProcessScrollInput(int px, int py)
{
var scroll = Input.GetAxis("Mouse ScrollWheel");
scroll = scroll * _mainEngine.BrowserTexture.height;
var scInt = (int)scroll;
if (scInt != 0)
{
var msg = new MouseMessage {
Type = MouseEventType.Wheel,
X = px,
Y = py,
GenericType = BrowserEventType.Mouse,
Delta = scInt,
Button = MouseButton.None
};
if (Input.GetMouseButton(0))
{
msg.Button = MouseButton.Left;
}
if (Input.GetMouseButton(1))
{
msg.Button = MouseButton.Right;
}
if (Input.GetMouseButton(1))
{
msg.Button = MouseButton.Middle;
}
_mainEngine.SendMouseEvent(msg);
}
}
private void PictureBox1_MouseWheel(object sender, MouseEventArgs e)
{
//pictureBox1.Focus();
MouseMessage msg = new MouseMessage
{
Type = MouseEventType.Wheel,
X = e.X,
Y = e.Y,
Delta = e.Delta,
GenericType = BrowserEventType.Mouse,
Button = MouseButton.None
};
if (e.Button == MouseButtons.Left)
{
msg.Button = MouseButton.Left;
}
if (e.Button == MouseButtons.Right)
{
msg.Button = MouseButton.Right;
}
if (e.Button == MouseButtons.Middle)
{
msg.Button = MouseButton.Middle;
}
SendMouseEvent(msg);
}
public void OnMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
if (_destroyed)
{
return;
}
ApplicationActivityMonitor.Instance.LastActivityTick = Environment.TickCount;
Focus();
PerformanceMonitor.CurrentInstance.CurrentTile = this;
lock (_mouseEventLock)
{
bool isDoubleClick = InterpretAsLeftDoubleClick(e);
Point pos = e.GetPosition(TileImage);
Message msg = new MouseMessage
{
Identifier = Guid.NewGuid(),
TargetId = ServerEntity.Identifier,
Button = MouseButton.Left,
MouseButtonState = MouseButtonState.Down,
ClickCount = isDoubleClick ? 2 : 1,
MousePosition = new Position {
X = (int)pos.X, Y = (int)pos.Y
}
};
_eventMediator.DispatchMessage(msg);
_mouseInside = true;
OnCursorChanged(ServerEntity.Cursor);
MouseHelper.SetActiveElement(this);
}
}
private Message[] getOutput()
{
Position myPos = new Position();
Actions myActions = new Actions();
myPos.setPosition("ABSOLUTE", 3, 4);
MouseMessage myMessage = new MouseMessage();
myMessage.player = "1";
myMessage.position = myPos;
myMessage.action = "PRESSED";
myMessage.payload = "PAYLOAD";
List <Keys> KeysEntered = new List <Keys>();
KeysEntered.Add(new Keys('a'));
KeysEntered.Add(new Keys("Right"));
KeysEntered.Add(new Keys('b'));
myActions.setActions("PRESSED", "PAYLOAD", KeysEntered.ToArray());
Actions mySecondActions = new Actions();
mySecondActions.setActions("RELEASED", "PAYLOAD12", KeysEntered.ToArray());
KeyboardMessage myKeyboardMessage = new KeyboardMessage();
myKeyboardMessage.player = "1";
myKeyboardMessage.actions = new Actions[] { myActions, mySecondActions };
return(new Message[] { myKeyboardMessage, myMessage });
}
private async Task ListenAsync(short channel)
{
bool listening = true;
while (listening)
{
var result = await Client.ReceiveAsync();
var message = Messaging.ReceiveMessage(result.Buffer);
switch (message.Type)
{
case MessageType.Disconnect:
case MessageType.Terminate:
IsConnected = false;
await EndConnection(channel, true);
listening = false;
break;
case MessageType.Acknowledge:
IsConnected = true;
Connect?.Invoke(this, new EventArgs());
break;
case MessageType.MouseMessage:
var mouseMessage = new MouseMessage(message.Payload);
MouseInput?.Invoke(this, new MouseMessageEventArgs(mouseMessage.X, mouseMessage.Y, mouseMessage.WheelDelta, mouseMessage.ScreenWidth, mouseMessage.ScreenHeight, mouseMessage.LeftButton, mouseMessage.MiddleButton, mouseMessage.RightButton, mouseMessage.FirstExtendedButton, mouseMessage.SecondExtendedButton));
break;
case MessageType.KeyboardMessage:
var keyboardMessage = new KeyboardMessage(message.Payload);
KeyboardInput?.Invoke(this, new KeyboardEventArgs(keyboardMessage.IsDown, keyboardMessage.Keys));
break;
}
}
}
//really spammy
private void pictureBox1_MouseMove(object sender, MouseEventArgs e)
{
// MessageBox.Show("_______MOVE 1");
if (posX != e.X || posY != e.Y)
{
MouseMessage msg = new MouseMessage
{
Type = MouseEventType.Move,
X = e.X,
Y = e.Y,
GenericType = BrowserEventType.Mouse,
Delta = e.Delta,
Button = MouseButton.None
};
if (e.Button == MouseButtons.Left)
{
msg.Button = MouseButton.Left;
}
if (e.Button == MouseButtons.Right)
{
msg.Button = MouseButton.Right;
}
if (e.Button == MouseButtons.Middle)
{
msg.Button = MouseButton.Middle;
}
posX = e.X;
posY = e.Y;
SendMouseEvent(msg);
}
}
/// <summary>
/// 마우스 프로시저 처리하기
/// </summary>
/// <param name="code">코드</param>
/// <param name="wordParameter">WORD 매개 변수</param>
/// <param name="longParameter">LONG 매개 변수</param>
/// <returns>처리 결과</returns>
private static IntPtr MouseProc(int code, IntPtr wordParameter, IntPtr longParameter)
{
if (code >= 0)
{
_mouseHookStructure = (MOUSEHOOKSTRUCT)Marshal.PtrToStructure
(
longParameter,
typeof(MOUSEHOOKSTRUCT)
);
MouseMessage mouseMessage = (MouseMessage)wordParameter;
if (UseGlobal)
{
if (mouseMessage == MouseMessage.WM_LBUTTONDOWN || mouseMessage == MouseMessage.WM_LBUTTONUP)
{
MouseClick?.Invoke(_mouseHookStructure.Location, mouseMessage);
if (mouseMessage == MouseMessage.WM_LBUTTONDOWN && IsHookingArea())
{
return((IntPtr)1);
}
}
}
}
return(WIN32Helper.CallNextHookEx(_mouseHookHandle, code, wordParameter, longParameter));
}
/// <summary>
/// Control <see cref="State"/> based on mouse input.
/// </summary>
private bool ProcessMouseMessage(MouseMessage mouseMessage)
{
if (mouseMessage == MouseMessage.WM_LBUTTONUP)
{
// left mouse up
lock (StateLock)
{
// no matter what state it was before, we just released left mouse, therefore get to idle state
State = AimBotState.Up;
}
return(true);
}
if (mouseMessage == MouseMessage.WM_LBUTTONDOWN)
{
if (!GameProcess.IsValid || !GameData.Player.IsAlive() || TriggerBot.IsHotKeyDown())
{
return(true);
}
// left mouse down
lock (StateLock)
{
if (State == AimBotState.Up)
{
// change state and signal to not call CallNextHookEx (stop this left mouse down)
State = AimBotState.DownSuppressed;
return(false);
}
}
}
return(true);
}
/// <summary>
/// Low-level mouse hook procedure
/// The system call this function every time a new mouse input event is
/// about to be posted into a thread input queue. The mouse input can come
/// from the local mouse driver or from calls to the mouse_event function.
/// If the input comes from a call to mouse_event, the input was
/// "injected". However, the WH_MOUSE_LL hook is not injected into another
/// process. Instead, the context switches back to the process that
/// installed the hook and it is called in its original context. Then the
/// context switches back to the application that generated the event.
/// </summary>
/// <param name="nCode">
/// The hook code passed to the current hook procedure.
/// When nCode equals HC_ACTION, the wParam and lParam parameters contain
/// information about a mouse message.
/// </param>
/// <param name="wParam">
/// This parameter can be one of the following messages:
/// WM_LBUTTONDOWN, WM_LBUTTONUP, WM_MOUSEMOVE, WM_MOUSEWHEEL,
/// WM_MOUSEHWHEEL, WM_RBUTTONDOWN, or WM_RBUTTONUP.
/// </param>
/// <param name="lParam">Pointer to an MSLLHOOKSTRUCT structure.</param>
/// <returns></returns>
/// <see cref="http://msdn.microsoft.com/en-us/library/ms644986.aspx"/>
public int LowLevelMouseProc(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0)
{
// Marshal the MSLLHOOKSTRUCT data from the callback lParam
MSLLHOOKSTRUCT mouseLLHookStruct = (MSLLHOOKSTRUCT)
Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
// Get the mouse WM from the wParam parameter
MouseMessage wmMouse = (MouseMessage)wParam;
if (wmMouse == MouseMessage.WM_LBUTTONUP)
{
MouseUpEvent mouseUp = OnMouseUp;
if (mouseUp != null)
{
Task.Factory.StartNew(delegate() { mouseUp(new Point(mouseLLHookStruct.pt.x, mouseLLHookStruct.pt.y)); });
//ThreadPool.QueueUserWorkItem((o) => mouseUp(new Point(mouseLLHookStruct.pt.x, mouseLLHookStruct.pt.y)));
}
}
}
// Pass the hook information to the next hook procedure in chain
return(NativeMethod.CallNextHookEx(hGlobalLLMouseHook, nCode, wParam, lParam));
}
private MouseButtons GetMouseButtons(MouseMessage mouseMsg)
{
MouseButtons result = MouseButtons.None;
switch (mouseMsg)
{
case MouseMessage.WM_LBUTTONDBLCLK:
case MouseMessage.WM_LBUTTONDOWN:
case MouseMessage.WM_LBUTTONUP:
result = MouseButtons.Left;
break;
case MouseMessage.WM_MBUTTONDBLCLK:
case MouseMessage.WM_MBUTTONDOWN:
case MouseMessage.WM_MBUTTONUP:
result = MouseButtons.Middle;
break;
case MouseMessage.WM_RBUTTONDBLCLK:
case MouseMessage.WM_RBUTTONDOWN:
case MouseMessage.WM_RBUTTONUP:
result = MouseButtons.Right;
break;
}
return(result);
}
private void pictureBox1_MouseUp(object sender, MouseEventArgs e)
{
MouseMessage msg = new MouseMessage
{
Type = MouseEventType.ButtonUp,
X = e.X,
Y = e.Y,
GenericType = BrowserEventType.Mouse,
Button = MouseButton.None
};
if (e.Button == MouseButtons.Left)
{
msg.Button = MouseButton.Left;
}
if (e.Button == MouseButtons.Right)
{
msg.Button = MouseButton.Right;
}
if (e.Button == MouseButtons.Middle)
{
msg.Button = MouseButton.Middle;
}
SendMouseEvent(msg);
}
internal static MouseHookEventArgs Create(MouseMessage wParam, IntPtr lParam)
{
switch (wParam)
{
case MouseMessage.WM_LBUTTONDOWN:
return(new MouseHookEventArgs(MouseButton.Left, true));
case MouseMessage.WM_LBUTTONUP:
return(new MouseHookEventArgs(MouseButton.Left, false));
case MouseMessage.WM_RBUTTONDOWN:
return(new MouseHookEventArgs(MouseButton.Right, true));
case MouseMessage.WM_RBUTTONUP:
return(new MouseHookEventArgs(MouseButton.Right, false));
case MouseMessage.WM_MBUTTONDOWN:
return(new MouseHookEventArgs(MouseButton.Middle, true));
case MouseMessage.WM_MBUTTONUP:
return(new MouseHookEventArgs(MouseButton.Middle, false));
case MouseMessage.WM_XBUTTONDOWN:
return(new MouseHookEventArgs(GetButton(lParam), true));
case MouseMessage.WM_XBUTTONUP:
return(new MouseHookEventArgs(GetButton(lParam), false));
default:
return(null);
}
}
/*
* Covert internal numbers,taken for working example
* http://stackoverflow.com/questions/14876345/using-sendmessage-to-simulate-mouse-clicks
*
* Complete list of values:
* https://msdn.microsoft.com/it-it/library/windows/desktop/ms646260(v=vs.85).aspx
*
*/
static public int convertMessageToInt(MouseMessage mouseMessage)
{
switch (mouseMessage)
{
case MouseMessage.WM_LBUTTONDOWN:
return(0x02);
case MouseMessage.WM_LBUTTONUP:
return(0x04);
case MouseMessage.WM_RBUTTONDOWN:
return(0x08);
case MouseMessage.WM_RBUTTONUP:
return(0x010);
case MouseMessage.WM_MBUTTONDOWN:
return(0x020);
case MouseMessage.WM_MBUTTONUP:
return(0x040);
case MouseMessage.WM_MOUSEWHEEL:
return(0x0800);
case MouseMessage.WM_MOUSEHWHEEL:
return(0x01000);
default:
int a = 1;
return(0);
break;
}
}
private int CallNextHook(int code, MouseMessage message, ref MOUSESTATE state)
{
if (code >= 0)
{
OnMouseHooked(new MouseHookedEventArgs(message, ref state));
}
return(NativeMethod.CallNextHookEx(hook, code, message, ref state));
}
private int CallNextHook(int code, MouseMessage message, ref MouseState state)
{
if (code >= 0)
{
OnMouseHooked(new MouseHookedEventArgs(message, ref state));
}
return(CallNextHookEx(hook, code, message, ref state));
}
public TestingAI(string playerNum)
{
myPos = new Position();
myActions = new Actions();
random = new Random();
myKeyboardMessage = new KeyboardMessage();
myMouseMessage = new MouseMessage();
myPlayer = playerNum;
}
/// <summary>
/// 新しいインスタンスを作成する。
/// </summary>
/// ec
/// <param name="message">マウス操作の種類を表すMouseMessage値の一つ。</param>
/// <param name="button"></param>
/// <param name="isDoubleClick"></param>
/// <param name="isDesktop"></param>
/// <param name="state">マウスの状態を表すMouseState構造体。</param>
internal GlobalMouseHookedEventArgs(MouseMessage message, MouseButtons button, bool isDoubleClick,
bool isDesktop, ref MouseState state)
{
Message = message;
this.state = state;
MouseButton = button;
IsDoubleClick = isDoubleClick;
IsDesktop = isDesktop;
}
/// <summary>
/// 新しいインスタンスを作成する。
/// </summary>
/// ec
/// <param name="message">マウス操作の種類を表すMouseMessage値の一つ。</param>
/// <param name="button"></param>
/// <param name="isDoubleClick"></param>
/// <param name="isDesktop"></param>
/// <param name="state">マウスの状態を表すMouseState構造体。</param>
internal GlobalMouseHookedEventArgs(MouseMessage message, MouseButtons button, bool isDoubleClick,
bool isDesktop, ref MouseState state)
{
Message = message;
this.state = state;
MouseButton = button;
IsDoubleClick = isDoubleClick;
IsDesktop = isDesktop;
}
private int CallNextHook(int code, MouseMessage message, ref MouseState state)
{
if (code >= 0)
{
var button = MouseButtons.None;
switch (message)
{
case MouseMessage.LDown:
//case MouseMessage.LUp:
button = MouseButtons.Left;
break;
case MouseMessage.RDown:
//case MouseMessage.RUp:
button = MouseButtons.Right;
break;
case MouseMessage.MDown:
//case MouseMessage.MUp:
button = MouseButtons.Middle;
break;
case MouseMessage.XDown:
//case MouseMessage.XUp:
if (state.XButtonData.IsXButton1)
{
button = MouseButtons.XButton1;
}
if (state.XButtonData.IsXButton2)
{
button = MouseButtons.XButton2;
}
break;
default:
button = MouseButtons.None;
break;
}
if ((_captureMouseButtons.Length == 0 || _captureMouseButtons.Contains(_button)) &&
button != MouseButtons.None)
{
var e = new GlobalMouseHookedEventArgs(
message,
button,
IsDoubleClick(button, state),
IsDesktop(state),
ref state);
OnMouseHooked(e);
if (e.Cancel)
{
return(-1);
}
}
}
return(CallNextHookEx(_hook, code, message, ref state));
}
//tracker
IEnumerator TrackPointer()
{
var _raycaster = GetComponentInParent <GraphicRaycaster>();
var _input = FindObjectOfType <StandaloneInputModule>();
if (_raycaster != null && _input != null && _mainEngine.Initialized)
{
while (Application.isPlaying)
{
Vector2 localPos = GetScreenCoords(_raycaster, _input);
int px = (int)localPos.x;
int py = (int)localPos.y;
ProcessScrollInput(px, py);
if (posX != px || posY != py)
{
MouseMessage msg = new MouseMessage
{
Type = MouseEventType.Move,
X = px,
Y = py,
GenericType = MessageLibrary.BrowserEventType.Mouse,
// Delta = e.Delta,
Button = MouseButton.None
};
if (Input.GetMouseButton(0))
{
msg.Button = MouseButton.Left;
}
if (Input.GetMouseButton(1))
{
msg.Button = MouseButton.Right;
}
if (Input.GetMouseButton(2))
{
msg.Button = MouseButton.Middle;
}
posX = px;
posY = py;
_mainEngine.SendMouseEvent(msg);
}
yield return(0);
}
}
// else
// UnityEngine.Debug.LogWarning("Could not find GraphicRaycaster and/or StandaloneInputModule");
}
private static int LowLevelMouseProc(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0)
{
MouseMessage wmMouse = (MouseMessage)wParam;
if (wmMouse == MouseMessage.WM_LBUTTONDOWN || wmMouse == MouseMessage.WM_RBUTTONDOWN)
{
MouseEventHandler?.Invoke(default(object), default(EventArgs));
}
}
return(NativeMethods.CallNextHookEx(hGlobalLLMouseHook, nCode, wParam, lParam));
}
private void pictureBox1_MouseDown(object sender, MouseEventArgs e)
{
MouseMessage msg = new MouseMessage
{
Type = MouseEventType.ButtonDown,
X = e.X,
Y = e.Y,
GenericType = BrowserEventType.Mouse
};
SendMouseEvent(msg);
}
private void pictureBox1_MouseLeave(object sender, EventArgs e)
{
MouseMessage msg = new MouseMessage
{
Type = MouseEventType.Leave,
X = 0,
Y = 0,
GenericType = BrowserEventType.Mouse
};
SendMouseEvent(msg);
}
private void SendMouseButtonEvent(int x, int y, MouseButton btn, MouseEventType type)
{
var msg = new MouseMessage {
Type = type,
X = x,
Y = y,
GenericType = BrowserEventType.Mouse,
// Delta = e.Delta,
Button = btn
};
_mainEngine.SendMouseEvent(msg);
}
// protected bool ProcessCallback(int wParam, IntPtr lParam)
protected bool ProcessCallback(IntPtr wParam, IntPtr lParam)
{
//bool shouldProcess = ProcessCallback(wParam, lParam);
MSLLHOOKSTRUCT hookStruct = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
MouseMessage wmMouse = (MouseMessage)wParam;
if (sendMInputToQueue(hookStruct, wmMouse) == true)
{
return(true);
}
return(false);
}
public void SendMouseEvent(MouseMessage msg)
{
if (Initialized)
{
EventPacket ep = new EventPacket
{
Event = msg,
Type = MessageLibrary.BrowserEventType.Mouse
};
_outCommServer.WriteMessage(ep);
}
}
private int CallNextHook(int code, MouseMessage message, ref MouseState state)
{
if (code >= 0)
{
MouseHookedEventArgs e = new MouseHookedEventArgs(message, ref state);
this.OnMouseHooked(e);
if (e.Cancel)
{
return(-1);
}
}
return(CallNextHookEx(hook, code, message, ref state));
}
private void ProcessMouseMessage(MouseMessage message)
{
if (message.Button == MouseButton.Left)
{
if (message.MouseButtonState == MouseButtonState.Down)
{
MouseEventArgs e = new MouseEventArgs(MouseButtons.Left, message.ClickCount, message.MousePosition.X, message.MousePosition.Y, 0);
object msg = _tileInputTranslator.OnMouseDown(e);
_tileController.ProcessMessage(msg);
_isMouseDown = true;
}
else if (message.MouseButtonState == MouseButtonState.Up)
{
MouseEventArgs e = new MouseEventArgs(MouseButtons.Left, 1, message.MousePosition.X, message.MousePosition.Y, 0);
object msg = _tileInputTranslator.OnMouseUp(e);
_tileController.ProcessMessage(msg);
//do a mouse move to set the focus state of graphics
e = new MouseEventArgs(MouseButtons.None, 0, message.MousePosition.X, message.MousePosition.Y, 0);
msg = _tileInputTranslator.OnMouseMove(e);
_tileController.ProcessMessage(msg);
_isMouseDown = false;
}
}
else if (message.Button == MouseButton.Right)
{
if (message.MouseButtonState == MouseButtonState.Down)
{
MouseEventArgs e = new MouseEventArgs(MouseButtons.Right, message.ClickCount, message.MousePosition.X, message.MousePosition.Y, 0);
object msg = _tileInputTranslator.OnMouseDown(e);
_tileController.ProcessMessage(msg);
_isMouseDown = false;
}
else if (message.MouseButtonState == MouseButtonState.Up)
{
//TODO (CR May 2010): should we be calling this when the tilecontroller fires an event?
FireContextMenuEvent();
MouseEventArgs e = new MouseEventArgs(MouseButtons.Right, 1, message.MousePosition.X, message.MousePosition.Y, 0);
object msg = _tileInputTranslator.OnMouseUp(e);
_tileController.ProcessMessage(msg);
//do a mouse move to set the focus state of graphics
e = new MouseEventArgs(MouseButtons.None, 0, message.MousePosition.X, message.MousePosition.Y, 0);
msg = _tileInputTranslator.OnMouseMove(e);
_tileController.ProcessMessage(msg);
_isMouseDown = true;
}
}
}
void ProcessMouse(IInputMessageHandler handler)
{
if (handler == null)
{
return;
}
MouseMessage mouseMsg = new MouseMessage();
float deltaX = Input.GetAxis("Mouse X");
float deltaY = Input.GetAxis("Mouse Y");
float deltaW = Input.GetAxis("Mouse ScrollWheel");
mouseMsg.dx = deltaX;
mouseMsg.dy = deltaY;
mouseMsg.x = Input.mousePosition.x;
mouseMsg.y = Input.mousePosition.y;
//先處理鼠標移動事件
mouseMsg.type = InputMsgType.InputMsgType_MouseMove;
handler.OnMouseMessage(mouseMsg);
//再處理滾輪
mouseMsg.wheelChange = deltaW;
mouseMsg.type = InputMsgType.InputMsgType_MouseWheel;
handler.OnMouseMessage(mouseMsg);
//再處理按鍵
if (Input.GetMouseButtonUp(0))
{
mouseMsg.type = InputMsgType.InputMsgType_LButtonUp;
mouseMsg.button = MouseButton.MouseButtonLeft;
handler.OnMouseMessage(mouseMsg);
}
if (Input.GetMouseButtonUp(1))
{
mouseMsg.type = InputMsgType.InputMsgType_RButtonUp;
mouseMsg.button = MouseButton.MouseButtonRight;
handler.OnMouseMessage(mouseMsg);
}
if (Input.GetMouseButtonDown(0))
{
mouseMsg.type = InputMsgType.InputMsgType_LButtonDown;
mouseMsg.button = MouseButton.MouseButtonLeft;
handler.OnMouseMessage(mouseMsg);
}
if (Input.GetMouseButtonDown(1))
{
mouseMsg.type = InputMsgType.InputMsgType_RButtonDown;
mouseMsg.button = MouseButton.MouseButtonRight;
handler.OnMouseMessage(mouseMsg);
}
}
private void windowHost_WmMouse(object sender, MouseMessage msg, int x, int y)
{
if (msg == MouseMessage.MouseLButtonDown ||
msg == MouseMessage.MouseLButtonUp ||
msg == MouseMessage.MouseRButtonDown ||
msg == MouseMessage.MouseRButtonUp)
{
if (!isKeyFocus)
{
Keyboard.Focus(this);
isKeyFocus = true;
}
}
EngineService.Instance.OnMouseMessage(msg, x, y);
}
public void SendMouseEvent(MouseMessage msg)
{
if (Initialized)
{
EventPacket ep = new EventPacket
{
Event = msg,
Type = BrowserEventType.Mouse
};
if (!_outCommServer.TrySend(ep, 100))
{
Debug.LogWarningFormat("mouse message lost {0}", ep.Type);
}
}
}
public static void Start()
{
var record = new INPUT_RECORD();
uint recordLen = 0;
while (true)
{
var handle = Native.GetConsoleInputHandle();
if (!(Native.ReadConsoleInput(handle, ref record, 1, ref recordLen)))
{
throw new Win32Exception();
}
switch (record.EventType)
{
case Native.MOUSE_EVENT:
{
//Console.WriteLine("Mouse event");
//Console.WriteLine(string.Format(" X ...............: {0,4:0} ", record.MouseEvent.dwMousePosition.X));
//Console.WriteLine(string.Format(" Y ...............: {0,4:0} ", record.MouseEvent.dwMousePosition.Y));
//Console.WriteLine(string.Format(" dwButtonState ...: 0x{0:X4} ", record.MouseEvent.dwButtonState));
//Console.WriteLine(string.Format(" dwControlKeyState: 0x{0:X4} ", record.MouseEvent.dwControlKeyState));
//Console.WriteLine(string.Format(" dwEventFlags ....: 0x{0:X4} ", record.MouseEvent.dwEventFlags));
var message = new MouseMessage(record.MouseEvent);
_focusManagers.ToList().ForEach((fm) => {
fm.Message(message);
});
}
break;
case Native.KEY_EVENT:
{
//Console.WriteLine("Key event ");
//Console.WriteLine(string.Format(" bKeyDown .......: {0,5} ", record.KeyEvent.bKeyDown));
//Console.WriteLine(string.Format(" wRepeatCount ....: {0,4:0} ", record.KeyEvent.wRepeatCount));
//Console.WriteLine(string.Format(" wVirtualKeyCode .: {0,4:0} ", record.KeyEvent.wVirtualKeyCode));
//Console.WriteLine(string.Format(" uChar ...........: {0} ", record.KeyEvent.UnicodeChar));
//Console.WriteLine(string.Format(" dwControlKeyState: 0x{0:X4} ", record.KeyEvent.dwControlKeyState));
var message = new KeyMessage(record.KeyEvent);
_focusManagers.ToList().ForEach((fm) => {
fm.Message(message);
});
//if (record.KeyEvent.wVirtualKeyCode == (int)ConsoleKey.Escape) { return; }
}
break;
}
}
}
/// <summary>
/// Method witch look at the MouseMessage(wParam of the HookProc delegate) to about which button this event is.
/// </summary>
private ButtonInfo GetButtonInfo( MouseMessage mouseMessage, out string extraInfo )
{
ButtonInfo button = ButtonInfo.None;
extraInfo = String.Empty;
if( mouseMessage == MouseMessage.WM_LBUTTONDOWN ||
mouseMessage == MouseMessage.WM_LBUTTONUP ) button = ButtonInfo.DefaultButton;
if( mouseMessage == MouseMessage.WM_RBUTTONDOWN ||
mouseMessage == MouseMessage.WM_RBUTTONUP ) { button = ButtonInfo.XButton; extraInfo = ButtonExtraInfo.Right; }
if( mouseMessage == MouseMessage.WM_MBUTTONDOWN ||
mouseMessage == MouseMessage.WM_MBUTTONUP ) { button = ButtonInfo.XButton; extraInfo = ButtonExtraInfo.Middle; }
if( mouseMessage == MouseMessage.WM_MOUSEMOVE ) button = ButtonInfo.None;
return button;
}
public void CreateMouseMessage()
{
mouseMessage = new MouseMessage(Vector2D.Half, 0, new[] { MouseButton.Left });
}
///<summary>
///新しいインスタンスを作成する。
///</summary>
///<param name="message">マウス操作の種類を表すMouseMessage値の一つ。</param>
///<param name="state">マウスの状態を表すMouseState構造体。</param>
internal MouseHookedEventArgs(MouseMessage message, ref MouseState state)
{
this.message = message;
this.state = state;
}
private int CallNextHook(int code, MouseMessage message, ref MouseState state)
{
if (code >= 0)
{
MouseHookedEventArgs e = new MouseHookedEventArgs(message, ref state);
this.OnMouseHooked(e);
if (e.Cancel)
return -1;
}
return CallNextHookEx(hook, code, message, ref state);
}
private int CallNextHook(int code, MouseMessage message, ref MouseState state)
{
if (code >= 0)
{
OnMouseHooked(new MouseHookedEventArgs(message, ref state));
}
return CallNextHookEx(hook, code, message, ref state);
}
private static extern int CallNextHookEx(IntPtr hook, int code, MouseMessage message, ref MouseState state);
private int CallNextHook(int code, MouseMessage message, ref MouseState state)
{
if (code >= 0)
{
var button = MouseButtons.None;
switch (message)
{
case MouseMessage.LDown:
//case MouseMessage.LUp:
button = MouseButtons.Left;
break;
case MouseMessage.RDown:
//case MouseMessage.RUp:
button = MouseButtons.Right;
break;
case MouseMessage.MDown:
//case MouseMessage.MUp:
button = MouseButtons.Middle;
break;
case MouseMessage.XDown:
//case MouseMessage.XUp:
if (state.XButtonData.IsXButton1) button = MouseButtons.XButton1;
if (state.XButtonData.IsXButton2) button = MouseButtons.XButton2;
break;
default:
button = MouseButtons.None;
break;
}
if ((_captureMouseButtons.Length == 0 || _captureMouseButtons.Contains(_button)) &&
button != MouseButtons.None)
{
var e = new GlobalMouseHookedEventArgs(
message,
button,
IsDoubleClick(button, state),
IsDesktop(state),
ref state);
OnMouseHooked(e);
if (e.Cancel)
return -1;
}
}
return CallNextHookEx(_hook, code, message, ref state);
}
private async Task ListenAsync(short channel)
{
bool listening = true;
while (listening)
{
var result = await Client.ReceiveAsync();
var message = Messaging.ReceiveMessage(result.Buffer);
switch (message.Type)
{
case MessageType.Disconnect:
case MessageType.Terminate:
await EndConnection(channel, true);
listening = false;
break;
case MessageType.Acknowledge:
var acknowledgeMessage = new AcknowledgeMessage(message.Payload);
ClientResolutionChanged?.Invoke(this,
new ClientResolutionChangedEventArgs(acknowledgeMessage.ScreenWidth, acknowledgeMessage.ScreenHeight));
IsConnected = true;
break;
case MessageType.Sharing:
var sharingMessage = new SharingMessage(message.Payload);
Sharing?.Invoke(this, sharingMessage.IsSharing);
break;
case MessageType.Image:
var imageMessage = new ImageMessage(message.Payload);
try
{
var imageFragment = ImageFragments.FirstOrDefault(mf => mf.MessageId.Equals(message.MessageId));
if (imageFragment == null)
{
imageFragment = new ImageFragment(message.MessageId, imageMessage);
ImageFragments.Add(imageFragment);
}
else
imageFragment.AddFragment(imageMessage);
}
catch (Exception ex)
{
Console.WriteLine($"Something bad happened: {ex.Message}");
}
break;
case MessageType.MouseMessage:
var mouseMessage = new MouseMessage(message.Payload);
MouseMove?.Invoke(this,
new MouseMoveEventArgs(mouseMessage.X, mouseMessage.Y, mouseMessage.ScreenWidth,
mouseMessage.ScreenHeight));
break;
}
}
}
