//--------------------------------------------------------------------------------------------------
public void MouseWheel(Point pos, MouseWheel wheel, int delta, InputDevice device)
{
if (ViewportController == null || delta == 0)
{
return;
}
double scaledDelta = delta;
if (Keyboard.IsKeyDown(Key.LeftCtrl))
{
// Increase precision
scaledDelta /= 10.0;
}
switch (wheel)
{
case Panels.MouseWheel.Vertical:
ViewportController.Zoom(pos, scaledDelta / 200.0);
break;
case Panels.MouseWheel.Horizontal:
ViewportController.Rotate(0, scaledDelta / 50.0, 0);
break;
}
ViewportController.MouseMove(pos);
}
void GLControl_MouseWheel(object sender, System.Windows.Forms.MouseEventArgs e)
{
if (!KeyboardHelper.CtrlDown())
{
if (e.Delta < 0)
{
if (!Camera.IsOrthogonal)
{
Camera.Distance *= 1.25f;
}
else
{
Camera.OrthogonalSize *= 1.25f;
}
}
else if (e.Delta > 0)
{
if (!Camera.IsOrthogonal)
{
Camera.Distance /= 1.25f;
}
else
{
Camera.OrthogonalSize *= 1f / 1.25f;
}
}
}
else
{
Vector2 NewPosition = new Vector2(e.X, e.Y);
MouseWheel?.Invoke(_Camera.GetRayThroughPixel(NewPosition), e);
}
}
private void Viewport_MouseWheel(Ray3 ray, System.Windows.Forms.MouseEventArgs e)
{
if (SurfaceMesh == null)
{
return;
}
List <Intersection> Intersections = new List <Intersection>();
Intersections.AddRange(SurfaceMesh.Intersect(ray));
foreach (var group in PointGroups)
{
if (group.IsVisible)
{
Intersections.AddRange(group.Intersect(ray));
}
}
if (Intersections.Count > 0)
{
Intersections.Sort((i1, i2) => i1.Distance.CompareTo(i2.Distance));
MouseWheel?.Invoke(this, Intersections, e);
}
}
private IntPtr MouseHookProc(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0)
{
MSLLHOOKSTRUCT mouseHookStruct = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
if (wParam.ToInt32() == WM_LBUTTONDOWN)
{
if (MouseDown != null)
{
MouseDown.Invoke(null, new System.Drawing.Point(mouseHookStruct.pt.x, mouseHookStruct.pt.y));
}
return(new IntPtr(-1));
}
if (wParam.ToInt32() == WM_MOUSEWHEEL)
{
if (MouseWheel != null)
{
MouseDevice mouseDev = InputManager.Current.PrimaryMouseDevice;
MouseWheel.Invoke(null, new MouseWheelEventArgs(mouseDev, Environment.TickCount, (int)mouseHookStruct.mouseData >> 16));
}
}
}
return(CallNextHookEx(_mouseHookHandle, nCode, wParam, lParam));
}
private void OnInternalMouseWheel(object sender, OpenTK.Input.MouseWheelEventArgs e)
{
var args = new MouseWheelEventArgs(e);
OnMouseWheel(this, args);
MouseWheel?.Invoke(this, args);
}
/// <summary>
/// マウスのホイールがまわされたときの処理です
/// </summary>
/// <param name="mouseEvent"></param>
protected void OnMouseWheel(MouseEvent mouseEvent)
{
if (MouseWheel != null)
{
MouseWheel.Invoke(this, mouseEvent);
}
}
private void DgvMouseWheel(object sender, MouseEventArgs e)
{
((HandledMouseEventArgs)e).Handled = true;
int scrollspeed = MenuDefines.Scrollspeed;
if (e.Delta < 0)
{
if (dgv.FirstDisplayedScrollingRowIndex < dgv.Rows.Count - scrollspeed)
{
dgv.FirstDisplayedScrollingRowIndex += scrollspeed;
}
else
{
dgv.FirstDisplayedScrollingRowIndex = dgv.Rows.Count - 1;
}
}
else
{
if (dgv.FirstDisplayedScrollingRowIndex > 0 + scrollspeed)
{
dgv.FirstDisplayedScrollingRowIndex -= scrollspeed;
}
else
{
dgv.FirstDisplayedScrollingRowIndex = 0;
}
}
MouseWheel?.Invoke();
}
private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
{
if (msg == User32.WM_INPUT)
{
User32.RAWINPUTHEADER header = new User32.RAWINPUTHEADER();
var headerSize = (uint)Marshal.SizeOf(header);
uint bufferSize = 0;
uint res = User32.GetRawInputData(lParam, User32.RID_INPUT, IntPtr.Zero, ref bufferSize, headerSize);
if (res == 0)
{
var dataPtr = Marshal.AllocHGlobal((int)bufferSize);
uint writtenBytes = User32.GetRawInputData(lParam, User32.RID_INPUT, dataPtr, ref bufferSize, headerSize);
if (writtenBytes == bufferSize)
{
var rawInput = Marshal.PtrToStructure <User32.RAWINPUT>(dataPtr);
if (rawInput.header.dwType == User32.RIM_TYPEMOUSE)
{
if ((rawInput.mouse.usButtonFlags & User32.RI_MOUSE_WHEEL) == User32.RI_MOUSE_WHEEL)
{
Trace.WriteLine($"RawInputListener WM_INPUT MouseWheel: {rawInput.mouse.usButtonData}");
MouseWheel?.Invoke(this, rawInput.mouse.usButtonData);
}
}
}
Marshal.FreeHGlobal(dataPtr);
}
}
return(IntPtr.Zero);
}
private void onMouseWheel(object sender, MouseWheelScrollEventArgs e)
{
_controllers.CurrentlyUsingController = false;
_mouse.WheelDelta = (double)e.Delta;
MouseWheel?.Invoke(sender, e);
}
public MouseWheelEventArgs(int x, int y, MouseWheel wheel, int clicks) : this()
{
X = x;
Y = y;
Wheel = wheel;
Clicks = clicks;
}
public virtual bool OnMouseWheel(DxWindow window, DxControl ctl, MouseEventArgs args, Point pt)
{
if (Childs != null)
{
for (var i = Childs.Count - 1; i >= 0; i--)
{
if (Childs[i].OnMouseWheel(window, Childs[i], args, pt))
{
return(true);
}
}
}
if (!IntersectTest(pt.X, pt.Y))
{
return(false);
}
if (!IsMouseOver)
{
return(false);
}
MouseWheel?.Invoke(ctl, args, pt);
return(true);
}
/// <summary>Get the command assigned to the specified mouse wheel direction.</summary>
/// <param name="wheel">The direction to test.</param>
/// <returns>The command, or the default value if there is no such binding.</returns>
public TCommand GetCommand(MouseWheel wheel)
{
TCommand command;
_mouseWheelBindings.TryGetValue(wheel, out command);
return(command);
}
protected override void Track(MouseState newState, MouseState oldState)
{
if (newState.Position != oldState.Position)
{
Move?.Invoke(this, new MouseEventArgs(newState));
}
if (newState.ScrollWheelValue != oldState.ScrollWheelValue)
{
MouseWheel?.Invoke(this, new MouseWheelEventArgs(newState));
}
foreach (MouseButtons mouseButton in Enum.GetValues(typeof(MouseButtons)))
{
bool newButton = newState.IsButtonDown(mouseButton);
bool oldButton = oldState.IsButtonDown(mouseButton);
if (newButton != oldButton)
{
if (newButton)
{
this.MouseDown?.Invoke(this, new MouseButtonEventArgs(newState, mouseButton));
}
else
{
this.MouseUp?.Invoke(this, new MouseButtonEventArgs(newState, mouseButton));
}
}
}
}
public void Update(GameTime gt)
{
ms = Mouse.GetState();
List <MouseButton> keys = new List <MouseButton>(getPressedButtons(ms));
foreach (MouseButton key in buttons.Keys)
{
if (isButtonDown(key))
{
if (!keys.Contains(key))
{
setKeyUp(key);
}
}
}
foreach (MouseButton key in keys)
{
if (isButtonUp(key))
{
setKeyDown(key);
}
}
if (wheelValue != ms.ScrollWheelValue)
{
if (MouseWheel != null)
{
MouseWheel.Invoke(this, new MouseEvent(this, MouseButton.MIDDLE, (ms.ScrollWheelValue - wheelValue) / 120));
}
}
wheelValue = ms.ScrollWheelValue;
}
protected virtual void OnMouseWheel(object sender, MouseWheelScrollEventArgs e)
{
usingController.Value = false;
Interlocked.Exchange(ref wheelDelta, e.Delta);
Interlocked.Exchange(ref currentWindow, (Display.Window)sender);
MouseWheel?.Invoke(sender, e);
}
private void Element_MouseWheel(object sender, System.Windows.Input.MouseWheelEventArgs args)
{
var position = GetPosition(args);
var buttons = GetMouseButtons(args);
var delta = args.Delta;
MouseWheel?.Invoke(this, new MouseWheelEventArgs(CurrentTime, position, PointerId.FromMouse(PointerId.MouseNoButton), buttons, delta));
}
void treeView_MouseWheel(object sender, System.Windows.Forms.MouseEventArgs e)
{
MouseWheel?.Invoke(this, new Gui.Controls.MouseEventArgs(
(Gui.Controls.MouseButtons)e.Button,
e.Clicks,
e.X,
e.Y,
e.Delta));
}
static MouseInputManager()
{
InputHooks.MouseMove += (o, e) => MouseMove?.Invoke(new MouseHookEventArgs(e.X, e.Y, (e.Button), e.Delta));
InputHooks.MouseClick += (o, e) => MouseClick?.Invoke(new MouseHookEventArgs(e.X, e.Y, (e.Button), e.Delta));
InputHooks.MouseDown += (o, e) => MouseDown?.Invoke(new MouseHookEventArgs(e.X, e.Y, (e.Button), e.Delta));
InputHooks.MouseUp += (o, e) => MouseUp?.Invoke(new MouseHookEventArgs(e.X, e.Y, (e.Button), e.Delta));
InputHooks.MouseWheel += (o, e) => MouseWheel?.Invoke(new MouseHookEventArgs(e.X, e.Y, (e.Button), e.Delta));
InputHooks.MouseDoubleClick += (o, e) => MouseDoubleClick?.Invoke(new MouseHookEventArgs(e.X, e.Y, (e.Button), e.Delta));
}
public virtual void OnMouseWheel(MouseEventArgs e)
{
if (!Enabled)
{
return;
}
MouseWheel?.Invoke(this, e);
}
protected virtual void OnMouseWheel(int delta)
{
MouseWheel handler = MouseWheel;
if (handler != null)
{
handler(this, delta);
}
}
internal bool PerformMouseWheel(Viewport viewport, int delta)
{
var handled = OnMouseWheel(viewport, delta);
if (!handled)
{
MouseWheel?.Invoke(this, viewport, delta, ref handled);
}
return(handled);
}
public WinFormsMouseInput(Control control)
{
control.MouseWheel += (sender, args) => MouseWheel?.Invoke(control, new MouseWheelEventArgs(args.Delta));
control.MouseDown += (sender, args) => MouseDown?.Invoke(
control, new MouseButtonEventArgs(Convert(args.Button), new Point(args.X, args.Y), args.Clicks));
control.MouseUp += (sender, args) => MouseUp?.Invoke(
control, new MouseButtonEventArgs(Convert(args.Button), new Point(args.X, args.Y), args.Clicks));
control.MouseMove += (sender, args) => MouseMove?.Invoke(
control, new MouseMoveEventArgs(new Point(args.X, args.Y)));
}
public void PerformMouseWheel(MouseWheelEventArgs e)
{
MouseWheel?.Invoke(e);
if (FocusedControl != null)
{
MouseWheelEventArgs e2 = new MouseWheelEventArgs(e.X - (FocusedControl.Position.X * 8), e.Y - (FocusedControl.Position.Y * 12), e.Value, e.Delta);
FocusedControl.PerformMouseWheel(e2);
}
}
public void Invoke(string EventName, Game CurrentGame, EventArguments Args)
{
if (EventName == "Closing")
{
Closing.Invoke(CurrentGame, Args);
}
if (EventName == "KeyDown")
{
KeyDown.Invoke(CurrentGame, Args);
}
if (EventName == "KeyUp")
{
KeyUp.Invoke(CurrentGame, Args);
}
if (EventName == "KeyPress")
{
KeyPress.Invoke(CurrentGame, Args);
}
if (EventName == "Load")
{
Load.Invoke(CurrentGame, Args);
}
if (EventName == "MouseDown")
{
MouseDown.Invoke(CurrentGame, Args);
}
if (EventName == "MouseUp")
{
MouseUp.Invoke(CurrentGame, Args);
}
if (EventName == "MouseClick")
{
MouseClick.Invoke(CurrentGame, Args);
}
if (EventName == "MouseMove")
{
MouseMove.Invoke(CurrentGame, Args);
}
if (EventName == "MouseWheel")
{
MouseWheel.Invoke(CurrentGame, Args);
}
if (EventName == "RenderFrame")
{
RenderFrame.Invoke(CurrentGame, Args);
}
if (EventName == "Resize")
{
Resize.Invoke(CurrentGame, Args);
}
if (EventName == "TimerTick")
{
TimerTick.Invoke(CurrentGame, Args);
}
}
private IntPtr HookFunc(int nCode, IntPtr wParam, IntPtr lParam)
{
// Parse system messages
if (nCode >= 0)
{
if (MouseMessages.WM_LBUTTONDOWN == (MouseMessages)wParam)
{
LeftButtonDown?.Invoke(
(MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT)));
}
if (MouseMessages.WM_LBUTTONUP == (MouseMessages)wParam)
{
LeftButtonUp?.Invoke(
(MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT)));
}
if (MouseMessages.WM_RBUTTONDOWN == (MouseMessages)wParam)
{
RightButtonDown?.Invoke(
(MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT)));
}
if (MouseMessages.WM_RBUTTONUP == (MouseMessages)wParam)
{
RightButtonUp?.Invoke(
(MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT)));
}
if (MouseMessages.WM_MOUSEMOVE == (MouseMessages)wParam)
{
MouseMove?.Invoke(
(MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT)));
}
if (MouseMessages.WM_MOUSEWHEEL == (MouseMessages)wParam)
{
MouseWheel?.Invoke(
(MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT)));
}
if (MouseMessages.WM_LBUTTONDBLCLK == (MouseMessages)wParam)
{
DoubleClick?.Invoke(
(MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT)));
}
if (MouseMessages.WM_MBUTTONDOWN == (MouseMessages)wParam)
{
MiddleButtonDown?.Invoke(
(MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT)));
}
if (MouseMessages.WM_MBUTTONUP == (MouseMessages)wParam)
{
MiddleButtonUp?.Invoke(
(MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT)));
}
}
return(CallNextHookEx(_hookId, nCode, wParam, lParam));
}
/// <summary>Add a new mouse wheel binding.</summary>
/// <param name="command">The command that should be triggered.</param>
/// <param name="wheel">The mouse wheel direction for which to trigger the command.</param>
public void Add(TCommand command, MouseWheel wheel)
{
var bindings = GetBindings(command, true);
if (bindings.MouseWheel.Contains(wheel))
{
return;
}
bindings.MouseWheel.Add(wheel);
_mouseWheelBindings.Add(wheel, command);
}
private static void OnMouseWheel(int delta)
{
try
{
MouseWheel?.Invoke(delta);
}
catch (Exception ex)
{
Trace.WriteLine("Unhandled Exception in InternalOnPlayerChat!");
Trace.WriteLine(ex.ToString());
}
}
protected override int HookCallbackProcedure(int nCode, int wParam, IntPtr lParam)
{
if (nCode > -1 && (MouseDown != null || MouseUp != null || MouseMove != null))
{
MouseLLHookStruct mouseHookStruct =
(MouseLLHookStruct)Marshal.PtrToStructure(lParam, typeof(MouseLLHookStruct));
MouseButtons button = GetButton(wParam);
MouseEventType eventType = GetEventType(wParam);
MouseEventArgs e = new MouseEventArgs(
button,
(eventType == MouseEventType.DoubleClick ? 2 : 1),
mouseHookStruct.pt.x,
mouseHookStruct.pt.y,
(eventType == MouseEventType.MouseWheel ? (short)((mouseHookStruct.mouseData >> 16) & 0xffff) : 0));
// Prevent multiple Right Click events (this probably happens for popup menus)
if (button == MouseButtons.Right && mouseHookStruct.flags != 0)
{
eventType = MouseEventType.None;
}
switch (eventType)
{
case MouseEventType.MouseDown:
MouseDown?.Invoke(this, e);
break;
case MouseEventType.MouseUp:
Click?.Invoke(this, new EventArgs());
MouseUp?.Invoke(this, e);
break;
case MouseEventType.DoubleClick:
DoubleClick?.Invoke(this, new EventArgs());
break;
case MouseEventType.MouseWheel:
MouseWheel?.Invoke(this, e);
break;
case MouseEventType.MouseMove:
MouseMove?.Invoke(this, e);
break;
default:
break;
}
}
return(CallNextHookEx(_handleToHook, nCode, wParam, lParam));
}
public void Update()
{
var mouseState = _mouse.GetState();
if (mouseState.LeftButton != _previousMouseState.LeftButton)
{
if (mouseState.LeftButton == ButtonState.Pressed)
{
LeftButtonDown?.Invoke(this, new MouseEventArgs(ref mouseState));
}
else
{
LeftButtonUp?.Invoke(this, new MouseEventArgs(ref mouseState));
}
}
if (mouseState.MiddleButton != _previousMouseState.MiddleButton)
{
if (mouseState.MiddleButton == ButtonState.Pressed)
{
MiddleButtonDown?.Invoke(this, new MouseEventArgs(ref mouseState));
}
else
{
MiddleButtonUp?.Invoke(this, new MouseEventArgs(ref mouseState));
}
}
if (mouseState.RightButton != _previousMouseState.RightButton)
{
if (mouseState.RightButton == ButtonState.Pressed)
{
RightButtonDown?.Invoke(this, new MouseEventArgs(ref mouseState));
}
else
{
RightButtonUp?.Invoke(this, new MouseEventArgs(ref mouseState));
}
}
if (mouseState.Position != _previousMouseState.Position)
{
MouseMove?.Invoke(this, new MouseMoveEventArgs(mouseState, _previousMouseState.Position));
}
if (mouseState.ScrollWheelValue != _previousMouseState.ScrollWheelValue)
{
MouseWheel?.Invoke(this, new MouseWheelEventArgs(mouseState, mouseState.ScrollWheelValue - _previousMouseState.ScrollWheelValue));
}
_previousMouseState = mouseState;
}
private void OnMouseWheel(object sender, MouseEventArgs e)
{
var now = DateTime.Now;
var time = now - _referenceStartTime;
var mouseWheel = new MouseWheel
{
Time = time,
Delta = e.Delta
};
Notify(mouseWheel);
}
public void CatchMouseWheelActivity(MouseWheel mw)
{
mw.Catched = true;
mw.StateString = judge.CurState.ToString();
judge.ResetDormantTimer();
}
