protected void UpdateMouseKeyStatus(MouseKey key, bool down)
{
if (key == MouseKey.Unknown)
{
return;
}
int keyIndex = (short)key - 1;
if (keyIndex > _mouseKeys.Length - 1)
{
return;
}
// If it was down, but no longer is - it was let go.
if (_mouseKeys[keyIndex] && !down)
{
OnMouseKey.Invoke(key, KeyStatus.Up);
}
// If it was up, and now is down - it was pressed.
if (!_mouseKeys[keyIndex] && down)
{
OnMouseKey.Invoke(key, KeyStatus.Down);
}
_mouseKeys[keyIndex] = down;
}
public void RunAction()
{
Thread.Sleep(DelayBefore);
var key = new MouseKey(Key);
switch (InputType)
{
case InputType.Down:
mouse_event(key.MouseEventDown, 0, 0, 0, 0);
break;
case InputType.Up:
mouse_event(key.MouseEventUp, 0, 0, 0, 0);
break;
case InputType.Press:
mouse_event(key.MouseEventDown, 0, 0, 0, 0);
mouse_event(key.MouseEventUp, 0, 0, 0, 0);
break;
default:
throw new ArgumentOutOfRangeException();
}
Thread.Sleep(DelayAfter);
}
/// <summary>
/// Listens for mouse button release events.
/// </summary>
/// <param name="key">Released key.</param>
private void OnInputMouseReleased(MouseKey key)
{
if (!this.Transitioning)
{
this.Interface.OnInputMouseRelease(this.input.Mouse.Position, key);
}
}
private void GetMouseKey(object sender, MouseEventArgs e)
{
if (e.MouseKey == MouseKey.Left || e.MouseKey == MouseKey.Right)
{
this.keyValue = Key.None;
this.MouseKey = MouseKey.None;
}
else
{
this.keyValue = Key.None;
this.MouseKey = e.MouseKey;
}
e.Process = false;
this.InputManager.KeyUp -= this.GetKey;
this.InputManager.MouseKeyUp -= this.GetMouseKey;
if (this.MouseKey != MouseKey.None)
{
this.InputManager.MouseKeyUp += this.MouseKeyUp;
}
this.changingKey = false;
}
public InteractionKey(MouseKey ButtonMouse, string ButtonKeyboard, string ButtonXbox, string ButtonSpacepilot)
{
this.ButtonMouse = ButtonMouse;
this.ButtonKeyboard = ButtonKeyboard;
this.ButtonXbox = ButtonXbox;
this.ButtonSpacepilot = ButtonSpacepilot;
}
public InteractionKey(MouseKey ButtonMouse, string ButtonKeyboard, string ButtonXbox, string ButtonSpacepilot)
{
this.ButtonMouse = ButtonMouse;
this.ButtonKeyboard = ButtonKeyboard;
this.ButtonXbox = ButtonXbox;
this.ButtonSpacepilot = ButtonSpacepilot;
}
private void EnqueueMouseButtonEvent(MouseKey mouseKey, VK_State state)
{
VirtualKeyParameter lParam = ParameterPool.GetParameter <VirtualKeyParameter>();
lParam.key = GetVirtualKeyMapData(mouseKey);
GlobalEventQueue.EnQueueEvent(state, lParam);
}
private void MouseDown(System.Drawing.Point pt, Double2 xy, MouseKey buttons)
{
if (buttons == MouseKey.Left && enabled)
{
Select(xy);
}
}
private void InputHandler_MouseMove(Point p, Double2 xy, MouseKey button)
{
if (button == MouseKey.Left)
{
_mousePos = xy;
}
}
protected override LResult WindowProcedure(WindowHandle window, MessageType message, WParam wParam, LParam lParam)
{
switch (message)
{
case MessageType.Size:
int cxClient = lParam.LowWord;
int cyClient = lParam.HighWord;
_apt[0].X = cxClient / 4;
_apt[0].Y = cyClient / 2;
_apt[1].X = cxClient / 2;
_apt[1].Y = cyClient / 4;
_apt[2].X = cxClient / 2;
_apt[2].Y = 3 * cyClient / 4;
_apt[3].X = 3 * cxClient / 4;
_apt[3].Y = cyClient / 2;
return(0);
case MessageType.LeftButtonDown:
case MessageType.RightButtonDown:
case MessageType.MouseMove:
MouseKey mk = (MouseKey)wParam.LowWord;
if ((mk & (MouseKey.LeftButton | MouseKey.RightButton)) != 0)
{
using (DeviceContext dc = window.GetDeviceContext())
{
dc.SelectObject(StockPen.White);
DrawBezier(dc, _apt);
if ((mk & MouseKey.LeftButton) != 0)
{
_apt[1].X = lParam.LowWord;
_apt[1].Y = lParam.HighWord;
}
if ((mk & MouseKey.RightButton) != 0)
{
_apt[2].X = lParam.LowWord;
_apt[2].Y = lParam.HighWord;
}
dc.SelectObject(StockPen.Black);
DrawBezier(dc, _apt);
}
}
return(0);
case MessageType.Paint:
window.Invalidate(true);
using (DeviceContext dc = window.BeginPaint())
{
DrawBezier(dc, _apt);
}
return(0);
}
return(base.WindowProcedure(window, message, wParam, lParam));
}
private static void OnMouseKeyDown(MouseKey key)
{
mouse.keys[key] = KeyState.DOWN;
foreach (var l in listeners)
{
l.OnMouseKeyDown(key);
}
}
private void MouseDown(Point p, Double2 xy, MouseKey button)
{
if (button == _selectButton && Enabled)
{
mouseDownXY = xy;
mouseDownPoint = p;
}
}
private static void OnMouseKeyUp(MouseKey key)
{
mouse.keys[key] = KeyState.UP;
foreach (var l in listeners)
{
l.OnMouseKeyUp(key);
}
}
public MouseHookEventArgs(MSLLHOOKSTRUCT data, CURSORINFO info, MouseKey keys, int param, int lastX, int lastY)
{
_data = data;
_info = info;
_keys = keys;
_Param = param;
_LastX = lastX;
_LastY = lastY;
}
public MouseHookEventArgs(MSLLHOOKSTRUCT data, CURSORINFO info, MouseKey keys, int param, int lastX, int lastY)
{
_data = data;
_info = info;
_keys = keys;
_Param = param;
_LastX = lastX;
_LastY = lastY;
}
/// <inheritdoc />
public bool IsMouseKeyUp(MouseKey key)
{
if (key == MouseKey.Unknown)
{
return(false);
}
int keyIndex = (short)key - 1;
return(!_mouseKeysIM[keyIndex] && _mouseKeysPreviousIM[keyIndex]);
}
private void MouseUp(System.Drawing.Point pt, Double2 xy, MouseKey buttons)
{
if (buttons == MouseKey.Left && enabled && shifting)
{
shifting = false;
if (selectionHandler.Count > 0 && PositionChanged != null)
{
PositionChanged();
}
}
}
/// <inheritdoc />
public bool IsMouseKeyDown(MouseKey key)
{
bool down = _mouseStatus[key] && !_mouseStatusShadow[key];
if (down)
{
Engine.Log.Trace($"Mouse button {key} is pressed down.", MessageSource.Input);
}
return(down);
}
/// <inheritdoc />
public bool IsMouseKeyUp(MouseKey key)
{
bool up = !_mouseStatus[key] && _mouseStatusShadow[key];
if (up)
{
Engine.Log.Trace($"Mouse button {key} is released.", MessageSource.Input);
}
return(up);
}
public static void SendMouse(IntPtr windows, MouseKey type, int x, int y)
{
Rect rct = new Rect();
if (!GetWindowRect(windows, ref rct))
{
return;
}
if (type == MouseKey.LEFT_CLICK)
{
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_LBUTTONDOWN, (int)Keys.LButton,
MakeLParam(x - rct.Left, y - rct.Top));
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_LBUTTONUP, (int)Keys.LButton,
MakeLParam(x - rct.Left, y - rct.Top));
}
if (type == MouseKey.LEFT_DBCLICK)
{
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_LBUTTONDBLCLK, 0,
MakeLParam(x - rct.Left, y - rct.Top));
}
if (type == MouseKey.LEFT_DOWN)
{
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_LBUTTONDOWN, (int)Keys.LButton,
MakeLParam(x - rct.Left, y - rct.Top));
}
if (type == MouseKey.LEFT_UP)
{
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_LBUTTONUP, (int)Keys.LButton,
MakeLParam(x - rct.Left, y - rct.Top));
}
if (type == MouseKey.RIGHT_CLICK)
{
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_RBUTTONDOWN, (int)Keys.RButton,
MakeLParam(x - rct.Left, y - rct.Top));
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_RBUTTONUP, (int)Keys.RButton,
MakeLParam(x - rct.Left, y - rct.Top));
}
if (type == MouseKey.RIGHT_DBCLICK)
{
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_RBUTTONDBLCLK, 0,
MakeLParam(x - rct.Left, y - rct.Top));
}
if (type == MouseKey.RIGHT_DOWN)
{
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_RBUTTONDOWN, (int)Keys.RButton,
MakeLParam(x - rct.Left, y - rct.Top));
}
if (type == MouseKey.RIGHT_UP)
{
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_RBUTTONUP, (int)Keys.RButton,
MakeLParam(x - rct.Left, y - rct.Top));
}
}
private void MouseUp(Point p, Double2 xy, MouseKey button)
{
if (button == _selectButton && Enabled)
{
if (p.X != mouseDownPoint.X || p.Y != mouseDownPoint.Y)
{
Select(mouseDownXY, xy);
}
selectionRectangleNode.Visible = false;
}
}
private void MouseMove(Point p, Double2 xy, MouseKey button)
{
if (button == _selectButton && enabled)
{
selectionRectangle.Origin = new Double2((Math.Min(mouseDownXY.X, xy.X) + 1) * 0.5, (Math.Min(mouseDownXY.Y, xy.Y) + 1) * 0.5);
double sizeX = Math.Max(mouseDownXY.X, xy.X) - Math.Min(mouseDownXY.X, xy.X);
double sizeY = Math.Max(mouseDownXY.Y, xy.Y) - Math.Min(mouseDownXY.Y, xy.Y);
selectionRectangle.Scaling = new Double2(0.5 * sizeX, 0.5 * sizeY);
selectionRectangleNode.Visible = true;
}
}
//private SelectableSceneNode node = null;
private void MouseDown(System.Drawing.Point pt, Double2 xy, MouseKey buttons)
{
if (buttons == MouseKey.Left && enabled)
{
lastPos = xy;
PickingResult r;
shifting = selectionHandler.Select(xy, out r);
if (r != null && r.Node is IInteractiveDirectionSceneNode)
{
shifting = false;
}
}
}
VK_Enum GetVirtualKeyMapData(MouseKey mouseKey)
{
for (int i = 0; i < mouseMappingList.Count; i++)
{
if (mouseKey == mouseMappingList[i].input)
{
return(mouseMappingList[i].vk);
}
}
Debug.LogErrorFormat("MouseInput=> 매핑 데이터를 찾지 못했습니다. {0}", mouseKey);
return(VK_Enum.None);
}
public static bool IsPressed(MouseKey key)
{
switch (key)
{
case MouseKey.LeftButton: return(currentMouseState.LeftButton == ButtonState.Pressed);
case MouseKey.MiddleButton: return(currentMouseState.MiddleButton == ButtonState.Pressed);
case MouseKey.RightButton: return(currentMouseState.RightButton == ButtonState.Pressed);
default: return(false);
}
}
public static bool HasBeenPressed(MouseKey key)
{
previousMouseState = currentMouseState;
currentMouseState = Microsoft.Xna.Framework.Input.Mouse.GetState();
switch (key)
{
case MouseKey.LeftButton: return((currentMouseState.LeftButton == ButtonState.Pressed) && !(previousMouseState.LeftButton == ButtonState.Pressed));
case MouseKey.MiddleButton: return((currentMouseState.MiddleButton == ButtonState.Pressed) && !(previousMouseState.MiddleButton == ButtonState.Pressed));
case MouseKey.RightButton: return((currentMouseState.RightButton == ButtonState.Pressed) && !(previousMouseState.RightButton == ButtonState.Pressed));
default: return(false);
}
}
private void GetKey(object sender, Input.EventArgs.KeyEventArgs e)
{
this.Key = e.Key == Key.Escape ? Key.None : e.Key;
this.mouseKeyValue = MouseKey.None;
e.Process = false;
this.InputManager.KeyUp -= this.GetKey;
this.InputManager.MouseKeyUp -= this.GetMouseKey;
if (this.Key != Key.None)
{
this.InputManager.KeyUp += this.OnKeyUp;
}
this.changingKey = false;
}
public static void SendMouseEx(IntPtr windows, MouseKey type, int x, int y)
{
if (type == MouseKey.LEFT_CLICK)
{
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_LBUTTONDOWN, (int)Keys.LButton,
MakeLParam(x, y));
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_LBUTTONUP, (int)Keys.LButton,
MakeLParam(x, y));
}
if (type == MouseKey.LEFT_DBCLICK)
{
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_LBUTTONDBLCLK, 0,
MakeLParam(x, y));
}
if (type == MouseKey.LEFT_DOWN)
{
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_LBUTTONDOWN, (int)Keys.LButton,
MakeLParam(x, y));
}
if (type == MouseKey.LEFT_UP)
{
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_LBUTTONUP, (int)Keys.LButton,
MakeLParam(x, y));
}
if (type == MouseKey.RIGHT_CLICK)
{
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_RBUTTONDOWN, (int)Keys.RButton,
MakeLParam(x, y));
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_RBUTTONUP, (int)Keys.RButton,
MakeLParam(x, y));
}
if (type == MouseKey.RIGHT_DBCLICK)
{
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_RBUTTONDBLCLK, 0,
MakeLParam(x, y));
}
if (type == MouseKey.RIGHT_DOWN)
{
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_RBUTTONDOWN, (int)Keys.RButton,
MakeLParam(x, y));
}
if (type == MouseKey.RIGHT_UP)
{
PostMessage(windows, (uint)MouseHook.MouseMessages.WM_RBUTTONUP, (int)Keys.RButton,
MakeLParam(x, y));
}
}
private void GetKey(Divine.KeyEventArgs e)
{
this.Key = e.Key == Key.Escape ? Key.None : e.Key;
this.mouseKeyValue = MouseKey.None;
e.Process = false;
InputManager.KeyUp -= this.GetKey;
InputManager.MouseKeyUp -= this.GetMouseKey;
if (this.Key != Key.None)
{
InputManager.KeyDown += this.OnKeyDown;
InputManager.KeyUp += this.OnKeyUp;
}
this.changingKey = false;
}
public void SimulateMouseUp(MouseKey key, int x, int y)
{
inputSimulator.Mouse.MoveMouseTo(NormalizePixelX(x), NormalizePixelY(y));
if (key == MouseKey.LEFT)
{
inputSimulator.Mouse.LeftButtonUp();
}
else if (key == MouseKey.RIGHT)
{
inputSimulator.Mouse.RightButtonUp();
}
else if (key == MouseKey.MIDDLE)
{
inputSimulator.Mouse.MiddleButtonUp();
}
}
/// <summary>
/// Called when a mouse button is released.
/// </summary>
/// <param name="position">The position.</param>
/// <param name="key">The key.</param>
internal void OnInputMouseRelease(Vector2 position, MouseKey key)
{
if (this.isMouseDown.ContainsKey(key.Key))
{
if (this.isMouseDown[key.Key])
{
this.MouseClick(this, new MouseEventArgs(AlmiranteEngine.Time.Total, key));
if (AlmiranteEngine.Time.Total - this.lastMouseUp <= (SystemInformation.DoubleClickTime / 1000.0f) &&
Math.Abs(this.lastMouseUpPosition.X - position.X) <= SystemInformation.DoubleClickSize.Width &&
Math.Abs(this.lastMouseUpPosition.Y - position.Y) <= SystemInformation.DoubleClickSize.Height &&
this.lastMouseKeyUp == key.Key)
{
this.lastMouseUp = 0.0;
this.MouseDoubleClick(this, new MouseEventArgs(AlmiranteEngine.Time.Total, key));
}
else
{
this.lastMouseKeyUp = key.Key;
this.lastMouseUp = AlmiranteEngine.Time.Total;
this.lastMouseUpPosition = position;
}
this.isMouseDown[key.Key] = false;
this.MouseUp(this, new MouseEventArgs(AlmiranteEngine.Time.Total, key));
if (!this.IsPointInside(position))
{
this.isMouseOver = false;
this.MouseLeave(this, new EventArgs());
}
}
}
var relative = position - this.position;
foreach (var control in this.Controls)
{
control.OnInputMouseRelease(relative, key);
}
}
/// <summary>
/// Listens for mouse button press events.
/// </summary>
/// <param name="key">Pressed key.</param>
private void OnInputMousePressed(MouseKey key)
{
if (!this.Transitioning)
{
var control = this.Interface.GetControlAt(this.input.Mouse.Position);
if (control != null)
{
if (key.Key == MouseButton.Left)
{
if (control.CanFocus)
{
if (this.focus != control)
{
this.Focus(control);
}
}
}
control.OnInputMousePress(this.input.Mouse.Position - control.RealPosition, key);
}
}
}
private void SetPressed(ButtonState state, ButtonState lastState, MouseKey key)
{
if ((ButtonState.Pressed == lastState) && (ButtonState.Released == state) && (null != this.inputKey))
{
this.inputMode = InputMode.Menu;
this.inputKey.SetKey(key);
this.inputKey = null;
}
}
public Bind(X360Keys xboxKey, MouseKey key)
{
this.xboxKey = xboxKey;
this.mouseKey = key;
this.keyType = KeyType.Mouse;
}
private void Map(MouseKey key, ref byte stick, byte value)
{
switch (key)
{
case MouseKey.MouseLeft:
Map(Mouse.GetState().LeftButton, ref stick, value);
break;
case MouseKey.MouseRight:
Map(Mouse.GetState().RightButton, ref stick, value);
break;
case MouseKey.MouseMiddle:
Map(Mouse.GetState().MiddleButton, ref stick, value);
break;
case MouseKey.MouseWheelUp:
Map((Mouse.GetState().ScrollWheelValue - prevW > 0) ? ButtonState.Pressed : ButtonState.Released, ref stick, value);
break;
case MouseKey.MouseWheelDown:
Map((Mouse.GetState().ScrollWheelValue - prevW < 0) ? ButtonState.Pressed : ButtonState.Released, ref stick, value);
break;
default:
throw new NotSupportedException();
}
}
/// 模拟鼠标按键
public static void MouseKeyEvent(MouseKey vKeyCoad, bool doubleClick)
{
mouse_event((int)vKeyCoad, 0, 0, 0, 0);
if (vKeyCoad == MouseKey.MOUSEEVENTF_LEFTDOWN)
{
Mouse.LeftKey = true;
}
else if (vKeyCoad == MouseKey.MOUSEEVENTF_MIDDLEUP)
{
Mouse.LeftKey = false;
}
if (vKeyCoad == MouseKey.MOUSEEVENTF_MIDDLEDOWN)
{
Mouse.MiddleKey = true;
}
else if (vKeyCoad == MouseKey.MOUSEEVENTF_MIDDLEUP)
{
Mouse.MiddleKey = false;
}
if (vKeyCoad == MouseKey.MOUSEEVENTF_RIGHTDOWN)
{
Mouse.RightKey = true;
}
else if (vKeyCoad == MouseKey.MOUSEEVENTF_RIGHTUP)
{
Mouse.RightKey = false;
}
if (doubleClick)
{
mouse_event((int)vKeyCoad, 0, 0, 0, 0);
}
}
internal void SetKey(MouseKey key)
{
this.Border = BorderStyle.None;
this.BackColor = Colors.None;
this.Value = key;
}
public MouseEventArgs(MouseKey mouseKey)
{
PressedKey = mouseKey;
}
