/// <summary>
/// Function to dispatch the raw input to a keyboard device.
/// </summary>
/// <param name="device">The device that will receive the data.</param>
/// <param name="rawData">Raw input data to translate.</param>
public static void Dispatch(IRawInputDeviceData <GorgonRawKeyboardData> device, ref RAWINPUTKEYBOARD rawData)
{
KeyboardDataFlags flags = KeyboardDataFlags.KeyDown;
if ((rawData.Flags & RawKeyboardFlags.KeyBreak) == RawKeyboardFlags.KeyBreak)
{
flags = KeyboardDataFlags.KeyUp;
}
if ((rawData.Flags & RawKeyboardFlags.KeyE0) == RawKeyboardFlags.KeyE0)
{
flags |= KeyboardDataFlags.LeftKey;
}
if ((rawData.Flags & RawKeyboardFlags.KeyE1) == RawKeyboardFlags.KeyE1)
{
flags |= KeyboardDataFlags.RightKey;
}
// Shift has to be handled in a special case since it doesn't actually detect left/right from raw input.
if (rawData.VirtualKey == VirtualKeys.Shift)
{
flags |= rawData.MakeCode == 0x36 ? KeyboardDataFlags.RightKey : KeyboardDataFlags.LeftKey;
}
var data = new GorgonRawKeyboardData
{
ScanCode = rawData.MakeCode,
Key = (Keys)rawData.VirtualKey,
Flags = flags
};
device.ProcessData(ref data);
}
/// <summary>
/// Function to dispatch the raw input data to a HID.
/// </summary>
/// <param name="device">The device that will receive the data.</param>
/// <param name="rawData">Raw input data to translate.</param>
public static void Dispatch(IRawInputDeviceData <GorgonRawHIDData> device, ref RAWINPUTHID rawData)
{
unsafe
{
var data = new GorgonRawHIDData
{
HidData = new GorgonReadOnlyPointer(rawData.Data.ToPointer(), rawData.Size * rawData.Count),
ItemCount = rawData.Count,
HIDDataSize = rawData.Size
};
device.ProcessData(ref data);
}
}
/// <summary>
/// Function to dispatch the raw input to a mouse device.
/// </summary>
/// <param name="device">The device that will receive the data.</param>
/// <param name="rawData">Raw input data to translate.</param>
public static void Dispatch(IRawInputDeviceData <GorgonRawMouseData> device, ref RAWINPUTMOUSE rawData)
{
short wheelDelta = 0;
MouseButtonState state = MouseButtonState.None;
if ((rawData.ButtonFlags & RawMouseButtons.MouseWheel) == RawMouseButtons.MouseWheel)
{
wheelDelta = (short)rawData.ButtonData;
}
if ((rawData.ButtonFlags & RawMouseButtons.LeftDown) == RawMouseButtons.LeftDown)
{
state = MouseButtonState.ButtonLeftDown;
}
if ((rawData.ButtonFlags & RawMouseButtons.RightDown) == RawMouseButtons.RightDown)
{
state = MouseButtonState.ButtonRightDown;
}
if ((rawData.ButtonFlags & RawMouseButtons.MiddleDown) == RawMouseButtons.MiddleDown)
{
state = MouseButtonState.ButtonMiddleDown;
}
if ((rawData.ButtonFlags & RawMouseButtons.Button4Down) == RawMouseButtons.Button4Down)
{
state = MouseButtonState.Button4Down;
}
if ((rawData.ButtonFlags & RawMouseButtons.Button5Down) == RawMouseButtons.Button5Down)
{
state = MouseButtonState.Button5Down;
}
if ((rawData.ButtonFlags & RawMouseButtons.LeftUp) == RawMouseButtons.LeftUp)
{
state = MouseButtonState.ButtonLeftUp;
}
if ((rawData.ButtonFlags & RawMouseButtons.RightUp) == RawMouseButtons.RightUp)
{
state = MouseButtonState.ButtonRightUp;
}
if ((rawData.ButtonFlags & RawMouseButtons.MiddleUp) == RawMouseButtons.MiddleUp)
{
state = MouseButtonState.ButtonMiddleUp;
}
if ((rawData.ButtonFlags & RawMouseButtons.Button4Up) == RawMouseButtons.Button4Up)
{
state = MouseButtonState.Button4Up;
}
if ((rawData.ButtonFlags & RawMouseButtons.Button5Up) == RawMouseButtons.Button5Up)
{
state = MouseButtonState.Button5Up;
}
var processedData = new GorgonRawMouseData
{
ButtonState = state,
MouseWheelDelta = wheelDelta,
Position = new Point(rawData.LastX, rawData.LastY),
IsRelative = ((rawData.Flags & RawMouseFlags.MoveAbsolute) != RawMouseFlags.MoveAbsolute)
};
device.ProcessData(ref processedData);
}
/// <summary>
/// Function to provide filtering of window messages for the application.
/// </summary>
/// <param name="m">Window message to filter.</param>
/// <returns><b>true</b> if the message is processed by this method, or <b>false</b> if not.</returns>
public bool PreFilterMessage(ref Message m)
{
if ((m.Msg != RawInputApi.WmRawInput) || (m.HWnd != _hwnd))
{
if (!NoLegacyMouse)
{
return(false);
}
// If we have no legacy messages turned on for the mouse, then do not process them.
switch (m.Msg)
{
/*case WM_XBUTTONDBLCLK:
* case WM_XBUTTONDOWN:
* case WM_XBUTTONUP:
* case WM_RBUTTONDBLCLK:
* case WM_RBUTTONDOWN:*/
case WM_RBUTTONUP:
/*case WM_NCRBUTTONDBLCLK:
* case WM_NCRBUTTONDOWN:
* case WM_NCRBUTTONUP:
* case WM_NCXBUTTONDBLCLK:
* case WM_NCXBUTTONDOWN:
* case WM_NCXBUTTONUP:
* case WM_NCMOUSEHOVER:
* case WM_NCMOUSELEAVE:
* case WM_NCMOUSEMOVE:
* case WM_NCLBUTTONDBLCLK:
* case WM_NCLBUTTONDOWN:
* case WM_NCLBUTTONUP:
* case WM_NCMBUTTONDBLCLK:
* case WM_NCMBUTTONDOWN:
* case WM_NCMBUTTONUP:
* case WM_MOUSELEAVE:
* case WM_MOUSEMOVE:
* case WM_MOUSEWHEEL:
* case WM_MOUSEHWHEEL:
* case WM_MOUSEHOVER:
* case WM_MOUSEACTIVATE:
* case WM_LBUTTONDBLCLK:
* case WM_LBUTTONDOWN:
* case WM_LBUTTONUP:
* case WM_MBUTTONDBLCLK:
* case WM_MBUTTONDOWN:
* case WM_MBUTTONUP:
* case WM_CAPTURECHANGED:*/
return(true);
default:
return(false);
}
}
RAWINPUT data = RawInputApi.GetRawInputData(m.LParam);
var key = new DeviceKey
{
DeviceType = data.Header.Type,
DeviceHandle = IntPtr.Zero
};
switch (data.Header.Type)
{
case RawInputType.Keyboard:
IRawInputDeviceData <GorgonRawKeyboardData> keyboard = GetRawInputKeyboardDevice(key, data.Header.Device);
if (keyboard == null)
{
return(false);
}
RawInputDispatcher.Dispatch(keyboard, ref data.Union.Keyboard);
break;
case RawInputType.Mouse:
IRawInputDeviceData <GorgonRawMouseData> mouse = GetRawInputMouseDevice(key, data.Header.Device);
if (mouse == null)
{
return(false);
}
RawInputDispatcher.Dispatch(mouse, ref data.Union.Mouse);
break;
case RawInputType.HID:
IRawInputDeviceData <GorgonRawHIDData> hid = GetRawInputHid(key, data.Header.Device);
if (hid == null)
{
return(false);
}
RawInputDispatcher.Dispatch(hid, ref data.Union.HID);
break;
}
return(true);
}
