public static void ProcessMouseEvent(SDL_Event ev)
{
switch (ev.type)
{
case SDL_EventType.SDL_MOUSEBUTTONDOWN:
SetMouseButtonState(ev.button.button, true);
if (OnMouseDown != null)
{
var button = TranslatePlatformMouseButton(ev.button.button);
OnMouseDown.Invoke(button);
}
break;
case SDL_EventType.SDL_MOUSEBUTTONUP:
SetMouseButtonState(ev.button.button, false);
if (OnMouseUp != null)
{
var button = TranslatePlatformMouseButton(ev.button.button);
OnMouseUp.Invoke(button);
}
break;
case SDL_EventType.SDL_MOUSEMOTION:
OnMouseMove?.Invoke();
break;
}
}
static public void InvokeOnMouseDown(OpenTK.Input.MouseButtonEventArgs e)
{
if (OnMouseDown != null)
{
OnMouseDown.Invoke(null, e);
}
}
// use this when you want to run the delegate corresponding to this button
public void Clicked()
{
if (MouseEvent != null)
{
MouseEvent.Invoke();
}
}
public static void GUIEvents()
{
var current = Event.current;
switch (current.type)
{
case EventType.MouseDown:
if (mouseDownEvent != null)
{
mouseDownEvent.Invoke();
}
break;
case EventType.MouseDrag:
if (mouseDragEvent != null)
{
mouseDragEvent.Invoke();
}
break;
case EventType.MouseUp:
if (mouseUpEvent != null)
{
mouseUpEvent.Invoke();
}
break;
}
}
private static void InputEventHandler(InputEventArgs e)
{
switch (e.Type)
{
case InputEventType.KeyUp: OnKeyUp.Invoke(e); break;
case InputEventType.KeyDown: OnKeyDown.Invoke(e); break;
case InputEventType.MouseUp: OnMouseUp.Invoke(e); break;
case InputEventType.MouseDown: OnMouseDown.Invoke(e); break;
case InputEventType.MouseMove: OnMouseMove.Invoke(e); break;
}
}
void Start()
{
foreach (var item in spawnInstances)
{
item.onMouseDown.AddListener((GameObject instance) =>
{
onMouseDown.Invoke(instance);
});
item.onSpawn.AddListener((GameObject instance) =>
{
instances.Add(instance);
onSpawn.Invoke(instance);
});
item.onDestroy.AddListener((GameObject instance) =>
{
instances.Remove(instance);
onDestroy.Invoke(instance);
});
}
}
/// <summary>
/// Update cursor and keyboard events
/// </summary>
private void UpdateCursorAndKeyboardEvents()
{
if (!Visible)
{
return;
}
MouseEvent mouseState = MouseHandler.GetState();
KeyboardState kbState = KeyboardHandler.GetState();
var mouseSize = new Vector2(5);
var mouseRect = new Rectangle((int)mouseState.X, (int)mouseState.Y, (int)mouseSize.X, (int)mouseSize.Y);
var thisRect = new Rectangle((int)Position.X, (int)Position.Y, (int)Size.X, (int)Size.Y);
//First check position
if (mouseRect.Intersects(thisRect))
{
//Second, check buttons
//Left
if (LastMouseCheck.LeftButton == ButtonState.Released && mouseState.LeftButton == ButtonState.Pressed)
{
OnMouseDown?.Invoke(this, mouseState.Position, MouseButtons.Left);
}
if (LastMouseCheck.LeftButton == ButtonState.Pressed && mouseState.LeftButton == ButtonState.Released)
{
OnMouseUp?.Invoke(this, mouseState.Position, MouseButtons.Left);
OnMouseClick?.Invoke(this, mouseState.Position, MouseButtons.Left);
}
//Right
if (LastMouseCheck.RightButton == ButtonState.Released && mouseState.RightButton == ButtonState.Pressed)
{
OnMouseDown?.Invoke(this, mouseState.Position, MouseButtons.Right);
}
if (LastMouseCheck.RightButton == ButtonState.Pressed && mouseState.RightButton == ButtonState.Released)
{
OnMouseUp?.Invoke(this, mouseState.Position, MouseButtons.Right);
OnMouseClick?.Invoke(this, mouseState.Position, MouseButtons.Right);
}
//Middle
if (LastMouseCheck.MiddleButton == ButtonState.Released && mouseState.MiddleButton == ButtonState.Pressed)
{
OnMouseDown?.Invoke(this, mouseState.Position, MouseButtons.Middle);
}
if (LastMouseCheck.MiddleButton == ButtonState.Pressed && mouseState.MiddleButton == ButtonState.Released)
{
OnMouseUp?.Invoke(this, mouseState.Position, MouseButtons.Middle);
OnMouseClick?.Invoke(this, mouseState.Position, MouseButtons.Middle);
}
//Check move
if (LastMouseCheck.Position != mouseState.Position)
{
OnMouseMove?.Invoke(this, mouseState.Position, MouseButtons.None);
}
//Hook Keyboard
if (kbState.GetPressedKeys().Count() > 0 && LastKeyboardState.GetPressedKeys().Count() > 0)
{
//check pressed keys
List <Keys> pressedKeys = kbState.GetPressedKeys().Except(LastKeyboardState.GetPressedKeys()).ToList();
foreach (Keys p in pressedKeys)
{
OnKeyPress?.Invoke(this, p, kbState);
}
//check released keys
List <Keys> releasedKeys = LastKeyboardState.GetPressedKeys().Except(kbState.GetPressedKeys()).ToList();
foreach (Keys r in releasedKeys)
{
OnKeyUp?.Invoke(this, r, kbState);
OnKeyPress?.Invoke(this, r, kbState);
}
}
}
else
{
// Leave == Release
//Left
}
LastMouseCheck = mouseState;
LastKeyboardState = kbState;
}
/// <summary>
/// Plain mouse down, does not affect mouse recordings.
/// </summary>
public void MouseDown(MouseEventArgs args)
{
OnMouseDown?.Invoke(this, args);
}
/// <summary>
/// Mouse hook procedure
/// </summary>
/// <param name="code">Always 0 (HC_ACTION)</param>
/// <param name="wParam">The identifier of the mouse message.</param>
/// <param name="lParam">A pointer to an MSLLHOOKSTRUCT structure.</param>
/// <returns>Depending on <paramref name="code" /> and other conditions, it may yield different values.</returns>
private int LowLevelMouseProc(int code, IntPtr wParam, IntPtr lParam)
{
if (code == HC_ACTION)
{
// this is a mouse event
var eventInfo = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
ExtendedEventArgs <MouseEventArgs, bool> eventArgs = null;
switch (wParam.ToInt32())
{
case (int)User32.WindowMessage.WM_MOUSEMOVE:
OnMouseMove?.Invoke(this,
eventArgs = new ExtendedEventArgs <MouseEventArgs, bool>(new MouseEventArgs(this.buttonState,
0,
eventInfo.pt.x,
eventInfo.pt.y,
0)));
return(eventArgs?.ExtendedData == true ? 1 : 0);
case (int)User32.WindowMessage.WM_LBUTTONDOWN:
this.buttonState |= MouseButtons.Left;
OnMouseDown?.Invoke(this,
eventArgs = new ExtendedEventArgs <MouseEventArgs, bool>(new MouseEventArgs(this.buttonState,
1,
eventInfo.pt.x,
eventInfo.pt.y,
0)));
return(eventArgs?.ExtendedData == true ? 1 : 0);
case (int)User32.WindowMessage.WM_RBUTTONDOWN:
this.buttonState |= MouseButtons.Right;
OnMouseDown?.Invoke(this,
eventArgs = new ExtendedEventArgs <MouseEventArgs, bool>(new MouseEventArgs(this.buttonState,
1,
eventInfo.pt.x,
eventInfo.pt.y,
0)));
return(eventArgs?.ExtendedData == true ? 1 : 0);
case (int)User32.WindowMessage.WM_LBUTTONUP:
this.buttonState &= ~MouseButtons.Left;
OnMouseUp?.Invoke(this,
eventArgs = new ExtendedEventArgs <MouseEventArgs, bool>(new MouseEventArgs(this.buttonState,
0,
eventInfo.pt.x,
eventInfo.pt.y,
0)));
return(eventArgs?.ExtendedData == true ? 1 : 0);
case (int)User32.WindowMessage.WM_RBUTTONUP:
this.buttonState &= ~MouseButtons.Right;
OnMouseUp?.Invoke(this,
eventArgs = new ExtendedEventArgs <MouseEventArgs, bool>(new MouseEventArgs(this.buttonState,
0,
eventInfo.pt.x,
eventInfo.pt.y,
0)));
return(eventArgs?.ExtendedData == true ? 1 : 0);
}
}
// pass unprocessed messages to system
return(User32.CallNextHookEx(this.hookHandle, code, wParam, lParam));
}
internal void DispatchEvent(Map map, MapJsEventArgs eventArgs)
{
switch (eventArgs.Type)
{
case "click":
OnClick?.Invoke(new MapMouseEventArgs(map, eventArgs));
break;
case "contextmenu":
OnContextMenu?.Invoke(new MapMouseEventArgs(map, eventArgs));
break;
case "dblclick":
OnDblClick?.Invoke(new MapMouseEventArgs(map, eventArgs));
break;
case "layeradded":
OnLayerAdded?.Invoke(new MapEventArgs(map, eventArgs.Type));
break;
case "layerremoved":
OnLayerRemoved?.Invoke(new MapEventArgs(map, eventArgs.Type));
break;
case "mousedown":
OnMouseDown?.Invoke(new MapMouseEventArgs(map, eventArgs));
break;
case "mouseenter":
OnMouseEnter?.Invoke(new MapMouseEventArgs(map, eventArgs));
break;
case "mouseleave":
OnMouseLeave?.Invoke(new MapMouseEventArgs(map, eventArgs));
break;
case "mousemove":
OnMouseMove?.Invoke(new MapMouseEventArgs(map, eventArgs));
break;
case "mouseout":
OnMouseOut?.Invoke(new MapMouseEventArgs(map, eventArgs));
break;
case "mouseover":
OnMouseOver?.Invoke(new MapMouseEventArgs(map, eventArgs));
break;
case "mouseup":
OnMouseUp?.Invoke(new MapMouseEventArgs(map, eventArgs));
break;
case "touchcancel":
OnTouchCancel?.Invoke(new MapTouchEventArgs(map, eventArgs));
break;
case "touchend":
OnTouchEnd?.Invoke(new MapTouchEventArgs(map, eventArgs));
break;
case "touchmove":
OnTouchMove?.Invoke(new MapTouchEventArgs(map, eventArgs));
break;
case "touchstart":
OnTouchStart?.Invoke(new MapTouchEventArgs(map, eventArgs));
break;
case "wheel":
OnWheel?.Invoke(new MapEventArgs(map, eventArgs.Type));
break;
}
}
void OnMouseDown()
{
onMouseDown.Invoke(gameObject);
Debug.Log("InstanceLifeCycle OnMouseDown " + gameObject.name);
}
internal void InvokeMouseDown(float mouseX, float mouseY)
{
OnMouseDown?.Invoke(this, mouseX - Transform.Position.x, mouseY - Transform.Position.y);
}
internal void TriggerOnMouseDown(MouseState state, MouseButton buttons)
{
OnMouseDown?.Invoke(state, buttons);
}
static void InitEvents()
{
Log.Info("Registering window events");
window.RenderFrame += (sender, e) => {
timer.Tick();
RenderState.SetupViewport();
OnRender?.Invoke();
State?.Render();
window.SwapBuffers();
FinalizeGLResources();
};
window.UpdateFrame += (sender, e) => {
OnUpdate?.Invoke(e.Time);
var state = State;
if (state != null)
{
state.Update(e.Time);
if (state.Closed)
{
State = null;
}
}
if (State == null)
{
Kill();
}
};
window.KeyDown += (sender, e) => {
var key = (Key)e.Key;
if (e.IsRepeat)
{
OnKeyRepeat?.Invoke(key);
State?.KeyRepeat(key);
}
else
{
OnKeyDown?.Invoke(key);
State?.KeyDown(key);
}
if (e.Key == OpenTK.Input.Key.F4 && e.Modifiers.HasFlag(OpenTK.Input.KeyModifiers.Alt))
{
window.Close();
}
};
window.KeyUp += (sender, e) => {
OnKeyUp?.Invoke((Key)e.Key);
State?.KeyUp((Key)e.Key);
};
window.KeyPress += (sender, e) => {
OnCharInput?.Invoke(e.KeyChar);
State?.CharInput(e.KeyChar);
};
window.MouseDown += (sender, e) => {
OnMouseDown?.Invoke((MouseButton)e.Button, Mouse.Position);
State?.MouseDown((MouseButton)e.Button, Mouse.Position);
};
window.MouseUp += (sender, e) => {
OnMouseUp?.Invoke((MouseButton)e.Button, Mouse.Position);
State?.MouseUp((MouseButton)e.Button, Mouse.Position);
};
window.MouseMove += (sender, e) => {
OnMouseMove?.Invoke(Mouse.Position);
State?.MouseMove(Mouse.Position);
};
window.MouseWheel += (sender, e) => {
OnMouseWheel?.Invoke(e.DeltaPrecise);
State?.MouseWheel(e.DeltaPrecise);
};
window.Resize += (sender, e) => {
OpenTK.Graphics.OpenGL.GL.Viewport(0, 0, Width, Height);
};
}
public void MouseDown(object sender, MouseEventArgs mouseEventArgs)
{
OnMouseDown?.Invoke(sender, mouseEventArgs);
}
/// <summary>
/// Create the DropDown list.
/// </summary>
/// <param name="size">List size (refers to the whole size of the list + the header when dropdown list is opened).</param>
/// <param name="anchor">Position anchor.</param>
/// <param name="offset">Offset from anchor position.</param>
/// <param name="skin">Panel skin to use for this DropDown list and header.</param>
public DropDown(Vector2 size, Anchor anchor = Anchor.Auto, Vector2?offset = null, PanelSkin skin = PanelSkin.ListBackground) :
base(size, anchor, offset)
{
// default padding of self is 0
Padding = Vector2.Zero;
// to get collision right when list is opened
UseActualSizeForCollision = true;
// create the panel and paragraph used to show currently selected value (what's shown when drop-down is closed)
_selectedTextPanel = new Panel(new Vector2(0, SelectedPanelHeight), skin, Anchor.TopLeft);
_selectedTextParagraph = UserInterface.DefaultParagraph(string.Empty, Anchor.CenterLeft);
_selectedTextParagraph.UseActualSizeForCollision = false;
_selectedTextParagraph.UpdateStyle(SelectList.DefaultParagraphStyle);
_selectedTextParagraph.UpdateStyle(DefaultParagraphStyle);
_selectedTextParagraph.UpdateStyle(DefaultSelectedParagraphStyle);
_selectedTextPanel.AddChild(_selectedTextParagraph, true);
// create the arrow down icon
_arrowDownImage = new Image(Resources.ArrowDown, new Vector2(ArrowSize, ArrowSize), ImageDrawMode.Stretch, Anchor.CenterRight, new Vector2(-10, 0));
_selectedTextPanel.AddChild(_arrowDownImage, true);
// create the list component
_selectList = new SelectList(size, Anchor.TopCenter, Vector2.Zero, skin);
// update list offset and space before
_selectList.SetOffset(new Vector2(0, SelectedPanelHeight));
_selectList.SpaceBefore = Vector2.Zero;
// add the header and select list as children
AddChild(_selectedTextPanel);
AddChild(_selectList);
// add callback on list value change
_selectList.OnValueChange = (Entity entity) =>
{
// hide list
ListVisible = false;
// set selected text
_selectedTextParagraph.Text = (SelectedValue ?? DefaultText);
};
// hide the list by default
_selectList.Visible = false;
// setup the callback to show / hide the list when clicking the dropbox
_selectedTextPanel.OnClick = (Entity self) =>
{
// change visibility
ListVisible = !ListVisible;
};
// set starting text
_selectedTextParagraph.Text = (SelectedValue ?? DefaultText);
// update styles
_selectList.UpdateStyle(DefaultStyle);
// make the list events trigger the dropdown events
_selectList.OnListChange += (Entity entity) => { OnListChange?.Invoke(this); };
_selectList.OnMouseDown += (Entity entity) => { OnMouseDown?.Invoke(this); };
_selectList.OnMouseReleased += (Entity entity) => { OnMouseReleased?.Invoke(this); };
_selectList.WhileMouseDown += (Entity entity) => { WhileMouseDown?.Invoke(this); };
_selectList.WhileMouseHover += (Entity entity) => { WhileMouseHover?.Invoke(this); };
_selectList.OnClick += (Entity entity) => { OnClick?.Invoke(this); };
_selectList.OnValueChange += (Entity entity) => { OnValueChange?.Invoke(this); };
_selectList.OnMouseEnter += (Entity entity) => { OnMouseEnter?.Invoke(this); };
_selectList.OnMouseLeave += (Entity entity) => { OnMouseLeave?.Invoke(this); };
_selectList.OnMouseWheelScroll += (Entity entity) => { OnMouseWheelScroll?.Invoke(this); };
_selectList.OnStartDrag += (Entity entity) => { OnStartDrag?.Invoke(this); };
_selectList.OnStopDrag += (Entity entity) => { OnStopDrag?.Invoke(this); };
_selectList.WhileDragging += (Entity entity) => { WhileDragging?.Invoke(this); };
_selectList.BeforeDraw += (Entity entity) => { BeforeDraw?.Invoke(this); };
_selectList.AfterDraw += (Entity entity) => { AfterDraw?.Invoke(this); };
_selectList.BeforeUpdate += (Entity entity) => { BeforeUpdate?.Invoke(this); };
_selectList.AfterUpdate += (Entity entity) => { AfterUpdate?.Invoke(this); };
// make the selected value panel trigger the dropdown events
_selectedTextPanel.OnMouseDown += (Entity entity) => { OnMouseDown?.Invoke(this); };
_selectedTextPanel.OnMouseReleased += (Entity entity) => { OnMouseReleased?.Invoke(this); };
_selectedTextPanel.WhileMouseDown += (Entity entity) => { WhileMouseDown?.Invoke(this); };
_selectedTextPanel.WhileMouseHover += (Entity entity) => { WhileMouseHover?.Invoke(this); };
_selectedTextPanel.OnClick += (Entity entity) => { OnClick?.Invoke(this); };
_selectedTextPanel.OnValueChange += (Entity entity) => { OnValueChange?.Invoke(this); };
_selectedTextPanel.OnMouseEnter += (Entity entity) => { OnMouseEnter?.Invoke(this); };
_selectedTextPanel.OnMouseLeave += (Entity entity) => { OnMouseLeave?.Invoke(this); };
_selectedTextPanel.OnMouseWheelScroll += (Entity entity) => { OnMouseWheelScroll?.Invoke(this); };
_selectedTextPanel.OnStartDrag += (Entity entity) => { OnStartDrag?.Invoke(this); };
_selectedTextPanel.OnStopDrag += (Entity entity) => { OnStopDrag?.Invoke(this); };
_selectedTextPanel.WhileDragging += (Entity entity) => { WhileDragging?.Invoke(this); };
_selectedTextPanel.BeforeDraw += (Entity entity) => { BeforeDraw?.Invoke(this); };
_selectedTextPanel.AfterDraw += (Entity entity) => { AfterDraw?.Invoke(this); };
_selectedTextPanel.BeforeUpdate += (Entity entity) => { BeforeUpdate?.Invoke(this); };
_selectedTextPanel.AfterUpdate += (Entity entity) => { AfterUpdate?.Invoke(this); };
}
public override void MouseDown(UIMouseEvent evt)
{
_isDragging = true;
OnMouseDown?.Invoke(evt, this);
}
public override void MouseDown(UIMouseEvent evt)
{
OnMouseDown?.Invoke(evt, this);
}
internal void MouseDown(MouseEventArgs e)
{
OnMouseDown?.Invoke(e);
}
/// <summary>
/// Updates the internal adminstrates and triggers events where required.
/// </summary>
void HandleOnStep()
{
//mouse can enter/leave target without moving (the target may move!)
bool isOnTarget = _target.collider.Enabled && _target.HitTestPoint(MyGame.WorldMousePosition.x, MyGame.WorldMousePosition.y);
if (isOnTarget && !_wasOnTarget)
{
OnMouseOverTarget?.Invoke(_target, MouseEventType.MouseOverTarget);
}
else if (!isOnTarget && _wasOnTarget)
{
OnMouseOffTarget?.Invoke(_target, MouseEventType.MouseOffTarget);
}
//did we just press the mouse down?
if (!_wasMouseDown && Input.GetMouseButton(0))
{
OnMouseDown?.Invoke(_target, MouseEventType.MouseDown);
if (isOnTarget)
{
OnMouseDownOnTarget?.Invoke(_target, MouseEventType.MouseDownOnTarget);
}
_wasMouseDown = true;
_wasMouseDownOnTarget = isOnTarget;
_offset = _target.TransformPoint(0, 0);
_offset.x = _offset.x - Input.mouseX;
_offset.y = _offset.y - Input.mouseY;
}
else if (_wasMouseDown && !Input.GetMouseButton(0))
{
OnMouseUp?.Invoke(_target, MouseEventType.MouseUp);
if (isOnTarget)
{
OnMouseUpOnTarget?.Invoke(_target, MouseEventType.MouseUpOnTarget);
}
if (isOnTarget && _wasMouseDownOnTarget)
{
OnMouseClick?.Invoke(_target, MouseEventType.MouseClick);
}
_wasMouseDown = false;
_wasMouseDownOnTarget = false;
_offset.x = _offset.y = 0;
}
if (_lastX != Input.mouseX || _lastY != Input.mouseY)
{
_lastX = Input.mouseX;
_lastY = Input.mouseY;
if (OnMouseMove != null)
{
OnMouseMove(_target, MouseEventType.MouseMove);
}
if (isOnTarget)
{
OnMouseMoveOnTarget?.Invoke(_target, MouseEventType.MouseMoveOnTarget);
}
}
_wasOnTarget = isOnTarget;
}
private void MouseHook_OnMouseDown(object sender, Point p)
{
DisposeHook();
OnMouseDown?.Invoke(this, p);
}
// 鼠标左键在窗口内按下
public virtual void onMouseDown(Vector3 mousePos)
{
mMouseDownPosition = mousePos;
mPressCallback?.Invoke(this, true);
mOnMouseDown?.Invoke(mousePos);
}
public void Update(GameTime gameTime)
{
_currentState = Mouse.GetState();
#region mouse clicked
if (_currentState.RightButton == ButtonState.Released &&
_previousState.RightButton == ButtonState.Pressed)
{
OnMouseClicked?.Invoke(MouseButtonID.Right, gameTime);
}
if (_currentState.LeftButton == ButtonState.Released &&
_previousState.LeftButton == ButtonState.Pressed)
{
OnMouseClicked?.Invoke(MouseButtonID.Left, gameTime);
}
if (_currentState.MiddleButton == ButtonState.Released &&
_previousState.MiddleButton == ButtonState.Pressed)
{
OnMouseClicked?.Invoke(MouseButtonID.Middle, gameTime);
}
#endregion
#region mouse down
if ((_previousState.LeftButton == ButtonState.Pressed &&
_previousState.Position != _currentState.Position) ||
_previousState.LeftButton == ButtonState.Released)
{
if (_currentState.LeftButton == ButtonState.Pressed)
{
OnMouseDown?.Invoke(MouseButtonID.Left, gameTime);
}
}
if ((_previousState.MiddleButton == ButtonState.Pressed &&
_previousState.Position != _currentState.Position) ||
_previousState.MiddleButton == ButtonState.Released)
{
if (_currentState.MiddleButton == ButtonState.Pressed)
{
OnMouseDown?.Invoke(MouseButtonID.Middle, gameTime);
}
}
if ((_previousState.RightButton == ButtonState.Pressed &&
_previousState.Position != _currentState.Position) ||
_previousState.RightButton == ButtonState.Released)
{
if (_currentState.RightButton == ButtonState.Pressed)
{
OnMouseDown?.Invoke(MouseButtonID.Right, gameTime);
}
}
#endregion
if (_currentState.ScrollWheelValue != _previousState.ScrollWheelValue)
{
var scrollValue = _currentState.ScrollWheelValue - _previousState.ScrollWheelValue;
var direction = MouseScrollDirection.Up;
if ((_currentState.ScrollWheelValue - _previousState.ScrollWheelValue) < 0)
{
direction = MouseScrollDirection.Down;
}
OnMouseScroll?.Invoke(direction, _currentState.ScrollWheelValue, gameTime);
}
if (_currentState.Position != _previousState.Position)
{
OnMouseMoved?.Invoke(new Vector2(_previousState.X, _previousState.Y), gameTime);
}
_previousState = _currentState;
}
public void OnPointerDown(PointerEventData eventData)
{
OnMouseDown?.Invoke();
LockCursor();
}
/// <summary>
/// A callback function which will be called every time a mouse activity detected.
/// </summary>
/// <param name="nCode">
/// [in] Specifies whether the hook procedure must process the message.
/// If nCode is HC_ACTION, the hook procedure must process the message.
/// If nCode is less than zero, the hook procedure must pass the message to the
/// CallNextHookEx function without further processing and must return the
/// value returned by CallNextHookEx.
/// </param>
/// <param name="wParam">
/// [in] Specifies whether the message was sent by the current thread.
/// If the message was sent by the current thread, it is nonzero; otherwise, it is zero.
/// </param>
/// <param name="lParam">
/// [in] Pointer to a CWPSTRUCT structure that contains details about the message.
/// </param>
/// <returns>
/// If nCode is less than zero, the hook procedure must return the value returned by CallNextHookEx.
/// If nCode is greater than or equal to zero, it is highly recommended that you call CallNextHookEx
/// and return the value it returns; otherwise, other applications that have installed WH_CALLWNDPROC
/// hooks will not receive hook notifications and may behave incorrectly as a result. If the hook
/// procedure does not call CallNextHookEx, the return value should be zero.
/// </returns>
private int MouseHookProc(int nCode, int wParam, IntPtr lParam)
{
// if ok and someone listens to our events
if ((nCode >= 0) && (OnMouseActivity != null || OnMouseDown != null || OnMouseUp != null))
{
//Marshall the data from callback.
MouseLLHookStruct mouseHookStruct = (MouseLLHookStruct)Marshal.PtrToStructure(lParam, typeof(MouseLLHookStruct));
//detect button clicked
MouseButtons button = MouseButtons.None;
short mouseDelta = 0;
//mouseButton down
bool isMouseButtonDown = false;
//mouseButton up
bool isMouseButtonUp = false;
switch (wParam)
{
case WM_LBUTTONDOWN:
//case WM_LBUTTONUP:
//case WM_LBUTTONDBLCLK:
button = MouseButtons.Left;
isMouseButtonDown = true;
break;
case WM_LBUTTONUP:
button = MouseButtons.Left;
isMouseButtonUp = true;
break;
case WM_RBUTTONDOWN:
//case WM_RBUTTONUP:
//case WM_RBUTTONDBLCLK:
button = MouseButtons.Right;
isMouseButtonDown = true;
break;
case WM_RBUTTONUP:
button = MouseButtons.Right;
isMouseButtonUp = true;
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);
//TODO: X BUTTONS (I havent them so was unable to test)
//If the message is WM_XBUTTONDOWN, WM_XBUTTONUP, WM_XBUTTONDBLCLK, WM_NCXBUTTONDOWN, WM_NCXBUTTONUP,
//or WM_NCXBUTTONDBLCLK, the high-order word specifies which X button was pressed or released,
//and the low-order word is reserved. This value can be one or more of the following values.
//Otherwise, mouseData is not used.
break;
}
//double clicks
int clickCount = 0;
if (button != MouseButtons.None)
{
if (wParam == WM_LBUTTONDBLCLK || wParam == WM_RBUTTONDBLCLK)
{
clickCount = 2;
}
else
{
clickCount = 1;
}
}
//generate event
MouseEventArgs e = new MouseEventArgs(
button,
clickCount,
mouseHookStruct.pt.x,
mouseHookStruct.pt.y,
mouseDelta);
//raise it
OnMouseActivity?.Invoke(this, e);
//raise mouseDown
if (isMouseButtonDown)
{
OnMouseDown?.Invoke(this, e);
}
//raise mouseUp
if (isMouseButtonUp)
{
OnMouseUp?.Invoke(this, e);
}
}
//call next hook
return(CallNextHookEx(hMouseHook, nCode, wParam, lParam));
}
/// <summary>
/// GUI部品を更新する。
/// </summary>
/// <param name="mouse">マウス。</param>
/// <param name="pointX">マウスの相対X座標。</param>
/// <param name="pointY">マウスの相対Y座標。</param>
public virtual void Update(Mouse mouse = null, int?pointX = null, int?pointY = null)
{
if (mouse == null)
{
LeftJudge = (false, (0, 0));
LongClickCounter.Stop();
LongClickCounter.Reset();
Dragging = false;
return;
}
if (!pointX.HasValue || !pointY.HasValue)
{
MousePoint = (mouse.Point.x - X, mouse.Point.y - Y);
}
else
{
MousePoint = (pointX.Value - X, pointY.Value - Y);
}
var outSide = IsOutSide();
if (!outSide)
{
OnHovering?.Invoke(this, new MouseClickEventArgs(MousePoint.x, MousePoint.y));
if (!Hovering)
{
OnMouseEnter?.Invoke(this, new MouseClickEventArgs(MousePoint.x, MousePoint.y));
Hovering = true;
}
}
else
{
if (Hovering)
{
OnMouseLeave?.Invoke(this, new MouseClickEventArgs(MousePoint.x, MousePoint.y));
Hovering = false;
}
}
if (mouse.IsPushedButton(MouseButton.Left))
{
// マウス初回クリック処理
if (!outSide)
{
LeftJudge = (true, MousePoint);
LongClickCounter?.Start();
OnMouseDown?.Invoke(this, new MouseClickEventArgs(MousePoint.x, MousePoint.y));
}
}
else if (mouse.IsPushingButton(MouseButton.Left))
{
// マウスが要素内をクリックしてるかどうかの判定
if (LeftJudge.Item1)
{
if (outSide)
{
LeftJudge = (false, MousePoint);
OnMouseUp?.Invoke(this, new MouseClickEventArgs(MousePoint.x, MousePoint.y));
LongClickCounter.Stop();
LongClickCounter.Reset();
}
else
{
LongClickCounter?.Tick();
if (LongClickCounter.State == TimerState.Stopped)
{
// ロングタップ
LeftJudge = (false, MousePoint);
OnMouseUp?.Invoke(this, new MouseClickEventArgs(MousePoint.x, MousePoint.y));
if (!Dragging)
{
LongClicked?.Invoke(this, new MouseClickEventArgs(MousePoint.x, MousePoint.y));
}
LongClickCounter.Stop();
LongClickCounter.Reset();
Dragging = false;
}
}
}
}
else if (mouse.IsLeftButton(MouseButton.Left))
{
// クリック判定
if (LeftJudge.Item1)
{
if (!Dragging)
{
Clicked?.Invoke(this, new MouseClickEventArgs(MousePoint.x, MousePoint.y));
}
OnMouseUp?.Invoke(this, new MouseClickEventArgs(MousePoint.x, MousePoint.y));
}
LongClickCounter.Stop();
LongClickCounter.Reset();
Dragging = false;
}
foreach (var item in Child)
{
item.Update(mouse, MousePoint.x, MousePoint.y);
}
}
public void NotifyMouseDown(MouseEvent eventArgs)
{
OnMouseDown?.Invoke(this, eventArgs);
}
private void HookMouseCallback(HookData hookData)
{
MouseEventInformation info = MouseEventInformation.Get(hookData);
int mx = info.X;
int my = info.Y;
MouseButtons button = info.Button;
// 마우스 다운
if (info.IsMouseDown)
{
if (IsDoubleClick(info))
{
info = info.ToDobuleClickMouseEventInformation();
}
OnMouseDown?.Invoke(mx, my, button);
if (info.Clicks == 2)
{
m_DoubleButton |= info.Button;
}
if (info.Clicks == 1)
{
m_SingleButton |= button;
}
}
// 마우스 업
if (info.IsMouseUp)
{
OnMouseUp?.Invoke(mx, my, button);
// 마우스 클릭
if ((m_SingleButton & button) != MouseButtons.None)
{
OnMouseClick?.Invoke(mx, my, button);
m_SingleButton &= ~button;
}
// 마우스 더블 클릭
if ((m_DoubleButton & button) != MouseButtons.None)
{
OnMouseDoubleClick?.Invoke(mx, my, button);
m_DoubleButton &= ~button;
}
if (info.Clicks == 2)
{
m_PreviousClickedButton = MouseButtons.None;
m_PreviousClickedTime = 0;
m_PreviousClickedX = m_DefaultPositionXY;
m_PreviousClickedY = m_DefaultPositionXY;
}
if (info.Clicks == 1)
{
m_PreviousClickedButton = info.Button;
m_PreviousClickedTime = info.Timestamp;
m_PreviousClickedX = mx;
m_PreviousClickedY = my;
}
}
// 마우스 스크롤
if (info.IsMouseWheelScrolled)
{
OnMouseWheel?.Invoke(mx, my, button, info.Delta > 0 ? 1 : -1);
}
// 마우스 이동
if (IsMoved(mx, my))
{
m_PreviousX = mx;
m_PreviousY = my;
OnMouseMove?.Invoke(mx, my, button);
}
// 마우스 드래그
if ((m_SingleButton & MouseButtons.Left) != MouseButtons.None)
{
if (m_DragStartPositionX == m_DefaultPositionXY && m_DragStartPositionY == m_DefaultPositionXY)
{
m_DragStartPositionX = mx;
m_DragStartPositionY = my;
}
// 마우스 드래그 스타트
if (m_dragMode == false)
{
bool isXDragging = Math.Abs(mx - m_DragStartPositionX) > m_SystemDragX;
bool isYDragging = Math.Abs(my - m_DragStartPositionY) > m_SystemDragY;
m_dragMode = isXDragging || isYDragging;
if (m_dragMode == true)
{
OnMouseDragStart?.Invoke(mx, my, button);
}
}
}
else
{
m_DragStartPositionX = m_DefaultPositionXY;
m_DragStartPositionY = m_DefaultPositionXY;
// 마우스 드래그 엔드
if (m_dragMode == true)
{
OnMouseDragEnd?.Invoke(mx, my, button);
m_dragMode = false;
}
}
}
protected virtual void MouseDown(GUIMouseButtonEventArgs args)
{
OnMouseDown?.Invoke(args);
}
public virtual void MouseDown(MouseButton button, Vec2 position)
{
OnMouseDown?.Invoke(button, position);
}
