public static RawInputModifiers ParseButtonState(int len, byte *buttons)
{
RawInputModifiers rv = default;
if (len > 0)
{
if (XIMaskIsSet(buttons, 1))
{
rv |= RawInputModifiers.LeftMouseButton;
}
if (XIMaskIsSet(buttons, 2))
{
rv |= RawInputModifiers.MiddleMouseButton;
}
if (XIMaskIsSet(buttons, 3))
{
rv |= RawInputModifiers.RightMouseButton;
}
if (len > 1)
{
if (XIMaskIsSet(buttons, 8))
{
rv |= RawInputModifiers.XButton1MouseButton;
}
if (XIMaskIsSet(buttons, 9))
{
rv |= RawInputModifiers.XButton2MouseButton;
}
}
}
return(rv);
}
void IHeadlessWindow.MouseUp(Point point, int button, RawInputModifiers modifiers)
{
Input?.Invoke(new RawPointerEventArgs(MouseDevice, Timestamp, InputRoot,
button == 0 ? RawPointerEventType.LeftButtonUp :
button == 1 ? RawPointerEventType.MiddleButtonUp : RawPointerEventType.RightButtonUp,
point, modifiers));
}
public static void KeyUp(IInputRoot inputRoot, Key key, RawInputModifiers modifiers = RawInputModifiers.None)
{
KeyboardDevice.Instance.ProcessRawEvent(
new RawKeyEventArgs(
KeyboardDevice.Instance, 0, inputRoot,
RawKeyEventType.KeyUp, key, modifiers));
}
public PointerPointProperties(RawInputModifiers modifiers, PointerUpdateKind kind)
{
PointerUpdateKind = kind;
IsLeftButtonPressed = modifiers.HasFlag(RawInputModifiers.LeftMouseButton);
IsMiddleButtonPressed = modifiers.HasFlag(RawInputModifiers.MiddleMouseButton);
IsRightButtonPressed = modifiers.HasFlag(RawInputModifiers.RightMouseButton);
// The underlying input source might be reporting the previous state,
// so make sure that we reflect the current state
if (kind == PointerUpdateKind.LeftButtonPressed)
{
IsLeftButtonPressed = true;
}
if (kind == PointerUpdateKind.LeftButtonReleased)
{
IsLeftButtonPressed = false;
}
if (kind == PointerUpdateKind.MiddleButtonPressed)
{
IsMiddleButtonPressed = true;
}
if (kind == PointerUpdateKind.MiddleButtonReleased)
{
IsMiddleButtonPressed = false;
}
if (kind == PointerUpdateKind.RightButtonPressed)
{
IsRightButtonPressed = true;
}
if (kind == PointerUpdateKind.RightButtonReleased)
{
IsRightButtonPressed = false;
}
}
private void ProcessModifierKeys(RawInputEventArgs args)
{
if (args is RawKeyEventArgs keyArgs)
{
currentModifiers = keyArgs.Modifiers;
}
}
public static MouseButtons ToMouseButtons(this RawInputModifiers modifiers)
{
var buttons = MouseButtons.None;
if (modifiers.HasFlag(RawInputModifiers.LeftMouseButton))
{
buttons |= MouseButtons.Left;
}
if (modifiers.HasFlag(RawInputModifiers.RightMouseButton))
{
buttons |= MouseButtons.Right;
}
if (modifiers.HasFlag(RawInputModifiers.MiddleMouseButton))
{
buttons |= MouseButtons.Middle;
}
if (modifiers.HasFlag(RawInputModifiers.XButton1MouseButton))
{
buttons |= MouseButtons.XButton1;
}
if (modifiers.HasFlag(RawInputModifiers.XButton2MouseButton))
{
buttons |= MouseButtons.XButton2;
}
return(buttons);
}
public RawTouchEventArgs(IInputDevice device, ulong timestamp, IInputRoot root,
RawPointerEventType type, Point position, RawInputModifiers inputModifiers,
long rawPointerId)
: base(device, timestamp, root, type, position, inputModifiers)
{
RawPointerId = rawPointerId;
}
public PointerPointProperties(RawInputModifiers modifiers, PointerUpdateKind kind,
float twist, float pressure, float xTilt, float yTilt
) : this(modifiers, kind)
{
Twist = twist;
Pressure = pressure;
XTilt = xTilt;
YTilt = yTilt;
}
public PointerPointProperties(RawInputModifiers modifiers, PointerUpdateKind kind)
{
PointerUpdateKind = kind;
IsLeftButtonPressed = modifiers.HasAllFlags(RawInputModifiers.LeftMouseButton);
IsMiddleButtonPressed = modifiers.HasAllFlags(RawInputModifiers.MiddleMouseButton);
IsRightButtonPressed = modifiers.HasAllFlags(RawInputModifiers.RightMouseButton);
IsXButton1Pressed = modifiers.HasAllFlags(RawInputModifiers.XButton1MouseButton);
IsXButton2Pressed = modifiers.HasAllFlags(RawInputModifiers.XButton2MouseButton);
IsInverted = modifiers.HasAllFlags(RawInputModifiers.PenInverted);
IsEraser = modifiers.HasAllFlags(RawInputModifiers.PenEraser);
IsBarrelButtonPressed = modifiers.HasAllFlags(RawInputModifiers.PenBarrelButton);
// The underlying input source might be reporting the previous state,
// so make sure that we reflect the current state
if (kind == PointerUpdateKind.LeftButtonPressed)
{
IsLeftButtonPressed = true;
}
if (kind == PointerUpdateKind.LeftButtonReleased)
{
IsLeftButtonPressed = false;
}
if (kind == PointerUpdateKind.MiddleButtonPressed)
{
IsMiddleButtonPressed = true;
}
if (kind == PointerUpdateKind.MiddleButtonReleased)
{
IsMiddleButtonPressed = false;
}
if (kind == PointerUpdateKind.RightButtonPressed)
{
IsRightButtonPressed = true;
}
if (kind == PointerUpdateKind.RightButtonReleased)
{
IsRightButtonPressed = false;
}
if (kind == PointerUpdateKind.XButton1Pressed)
{
IsXButton1Pressed = true;
}
if (kind == PointerUpdateKind.XButton1Released)
{
IsXButton1Pressed = false;
}
if (kind == PointerUpdateKind.XButton2Pressed)
{
IsXButton2Pressed = true;
}
if (kind == PointerUpdateKind.XButton2Released)
{
IsXButton2Pressed = false;
}
}
public RawMouseWheelEventArgs(
IInputDevice device,
ulong timestamp,
// IInputRoot root,
Point position,
Vector delta, RawInputModifiers inputModifiers)
: base(device, timestamp, /*root,*/ RawPointerEventType.Wheel, position, inputModifiers)
{
Delta = delta;
}
RawInputModifiers GetModifiers(RawInputModifiers modifiers, bool isLeftButtonDown)
{
var rv = modifiers &= RawInputModifiers.KeyboardMask;
if (isLeftButtonDown)
{
rv |= RawInputModifiers.LeftMouseButton;
}
return(rv);
}
public RawKeyEventArgs(
IKeyboardDevice device,
ulong timestamp,
RawKeyEventType type,
Key key, RawInputModifiers modifiers)
: base(device, timestamp)
{
Key = key;
Type = type;
Modifiers = modifiers;
}
public RawTextInputEventArgs(
IKeyboardDevice device,
ulong timestamp,
IInputRoot root,
string text,
RawInputModifiers modifiers)
: base(device, timestamp, root)
{
Text = text;
Modifiers = modifiers;
}
public RawPointerGestureEventArgs(
IInputDevice device,
ulong timestamp,
IInputRoot root,
RawPointerEventType gestureType,
Point position,
Vector delta, RawInputModifiers inputModifiers)
: base(device, timestamp, root, gestureType, position, inputModifiers)
{
Delta = delta;
}
public RawPointerEventArgs(
IInputDevice device,
ulong timestamp,
IInputRoot root,
RawPointerEventType type,
Point position,
RawInputModifiers inputModifiers)
: base(device, timestamp, root)
{
//Contract.Requires<ArgumentNullException>(device != null);
//Contract.Requires<ArgumentNullException>(root != null);
Position = position;
Type = type;
InputModifiers = inputModifiers;
}
private DragDropEffects GetPreferredEffect(DragDropEffects effect, RawInputModifiers modifiers)
{
if (effect == DragDropEffects.Copy || effect == DragDropEffects.Move || effect == DragDropEffects.Link || effect == DragDropEffects.None)
{
return(effect); // No need to check for the modifiers.
}
if (effect.HasFlag(DragDropEffects.Link) && modifiers.HasFlag(RawInputModifiers.Alt))
{
return(DragDropEffects.Link);
}
if (effect.HasFlag(DragDropEffects.Copy) && modifiers.HasFlag(RawInputModifiers.Control))
{
return(DragDropEffects.Copy);
}
return(DragDropEffects.Move);
}
private void RawKeyDown(RawKeyEventArgs e)
{
const RawInputModifiers modifiers = RawInputModifiers.Control | RawInputModifiers.Shift;
if (e.Modifiers == modifiers)
{
var point = (Root.VisualRoot as IInputRoot)?.MouseDevice?.GetPosition(Root) ?? default(Point);
var control = Root.GetVisualsAt(point, x => (!(x is AdornerLayer) && x.IsVisible))
.FirstOrDefault();
if (control != null)
{
var vm = (DevToolsViewModel)DataContext;
vm.SelectControl((IControl)control);
}
}
}
public static Keys AddModifiers(Keys keys, RawInputModifiers modifiers)
{
if (modifiers.HasFlag(RawInputModifiers.Alt))
{
keys |= Modern.Forms.Keys.Alt;
}
if (modifiers.HasFlag(RawInputModifiers.Control))
{
keys |= Modern.Forms.Keys.Control;
}
if (modifiers.HasFlag(RawInputModifiers.Shift))
{
keys |= Modern.Forms.Keys.Shift;
}
return(keys);
}
public RawDragEvent(IDragDropDevice inputDevice, RawDragEventType type,
IInputRoot root, Point location, IDataObject data, DragDropEffects effects, RawInputModifiers modifiers)
: base(inputDevice, 0, root)
{
Type = type;
Location = location;
Data = data;
Effects = effects;
Modifiers = (InputModifiers)modifiers;
}
private DragDropEffects RaiseEventAndUpdateCursor(RawDragEventType type, IInputRoot root, Point pt, RawInputModifiers modifiers)
{
_lastPosition = pt;
RawDragEvent rawEvent = new RawDragEvent(_dragDrop, type, root, pt, _draggedData, _allowedEffects, modifiers);
var tl = root.GetSelfAndVisualAncestors().OfType <TopLevel>().FirstOrDefault();
tl.PlatformImpl?.Input(rawEvent);
var effect = GetPreferredEffect(rawEvent.Effects & _allowedEffects, modifiers);
UpdateCursor(root, effect);
return(effect);
}
public static void PressKey(IInputRoot inputRoot, Key key, RawInputModifiers modifiers = RawInputModifiers.None)
{
KeyDown(inputRoot, key, modifiers);
KeyUp(inputRoot, key, modifiers);
}
KeyModifiers GetKeyModifiers(RawInputModifiers modifiers) => (KeyModifiers)(modifiers & RawInputModifiers.KeyboardMask);
void IHeadlessWindow.MouseMove(Point point, RawInputModifiers modifiers)
{
Input?.Invoke(new RawPointerEventArgs(MouseDevice, Timestamp, InputRoot,
RawPointerEventType.Move, point, modifiers));
}
void IHeadlessWindow.KeyRelease(Key key, RawInputModifiers modifiers)
{
Input?.Invoke(new RawKeyEventArgs(_keyboard, Timestamp, InputRoot, RawKeyEventType.KeyUp, key, modifiers));
}
public static KeyModifiers ToKeyModifiers(this RawInputModifiers modifiers) => (KeyModifiers)(modifiers & RawInputModifiers.KeyboardMask);
public static KeyModifiers ConvertToKey(RawInputModifiers modifiers) => (KeyModifiers)(modifiers & RawInputModifiers.KeyboardMask);
public RawDragEvent(IDragDropDevice inputDevice, RawDragEventType type,
IInputRoot root, Point location, IDataObject data, DragDropEffects effects, RawInputModifiers modifiers)
: base(inputDevice, 0, root)
{
Type = type;
Location = location;
Data = data;
Effects = effects;
KeyModifiers = modifiers.ToKeyModifiers();
#pragma warning disable CS0618 // Type or member is obsolete
Modifiers = (InputModifiers)modifiers;
#pragma warning restore CS0618 // Type or member is obsolete
}
