public static bool GetRawInputData(IntPtr hRawInput, ref RAWINPUTHEADER header, ref RAWMOUSE mouse, ref RAWKEYBOARD keyboard, ref RAWHID hid) { int iSize = 0; GetRawInputData(hRawInput, 0x10000003, IntPtr.Zero, ref iSize, Marshal.SizeOf <RAWINPUTHEADER>()); // RID_INPUT if (iSize == 0) { return(false); } IntPtr mem = Marshal.AllocHGlobal(iSize); if (mem == IntPtr.Zero) { return(false); } if (GetRawInputData(hRawInput, 0x10000003, mem, ref iSize, Marshal.SizeOf <RAWINPUTHEADER>()) != iSize) { Marshal.FreeHGlobal(mem); return(false); } if (Environment.Is64BitProcess) { var str = Marshal.PtrToStructure <RAWINPUT64>(mem); header = str.header; mouse = str.mouse; keyboard = str.keyboard; hid = str.hid; } else { var str = Marshal.PtrToStructure <RAWINPUT32>(mem); header = str.header; mouse = str.mouse; keyboard = str.keyboard; hid = str.hid; } Marshal.FreeHGlobal(mem); return(true); }
public void InputFromKeyboard_Heatmap(RAWINPUTHEADER riHeader, RAWKEYBOARD riKeyboard) { if (riKeyboard.Flags == 0x0) { return; } ; if (riKeyboard.Flags == 0x2 && Control.IsKeyLocked(Keys.NumLock)) { return; } ; int currentKey = keys.GetKeyCode(riKeyboard.MakeCode, riKeyboard.VKey, riKeyboard.Flags, Control.IsKeyLocked(Keys.NumLock)); keyMatrix[currentKey].NewStrike(); }
/// <summary> /// Retrieves the raw input header from the specified device. /// </summary> /// <remarks>See <see cref="GetRawInputData" /> for more information.</remarks> /// <param name="hRawInput"> /// A handle to the <see cref="RAWINPUT" /> structure. This comes from the /// <b>lParam</b> in <see cref="RawHidReading.Win32.WinMessage.WM.INPUT">WM_INPUT</see>. /// </param> /// <returns>The raw input header as <see cref="RAWINPUTHEADER" />.</returns> public static RAWINPUTHEADER GetRawInputDataHeader(HRAWINPUT hRawInput) { var size = RAWINPUTHEADER.SIZE; var ret = new RAWINPUTHEADER(); ret.dwSize = size; var err = GetRawInputDataH(hRawInput, RID.HEADER, ref ret, ref size, RAWINPUTHEADER.SIZE); if (err == uint.MaxValue) { throw new Exception(string.Format("Error getting header of WM_INPUT data. (Error code: 0x{0:X8})", WinKernel.GetLastError())); } return(ret); }
/// <summary> /// Processes WM_INPUT messages to retrieve information about any /// keyboard events that occur. /// </summary> /// <param name="message">The WM_INPUT message to process.</param> public void ProcessInputCommand(Message message) { uint dwSize = 0; // First call to GetRawInputData sets the value of dwSize // dwSize can then be used to allocate the appropriate amount of memory, // storing the pointer in "buffer". GetRawInputData(message.LParam, RID_HEADER, IntPtr.Zero, ref dwSize, (uint)Marshal.SizeOf(typeof(RAWINPUTHEADER))); IntPtr headerBuffer = Marshal.AllocHGlobal((int)dwSize); try { // Check that buffer points to something, and if so, // call GetRawInputData again to fill the allocated memory // with information about the input if (headerBuffer != IntPtr.Zero && GetRawInputData(message.LParam, RID_HEADER, headerBuffer, ref dwSize, (uint)Marshal.SizeOf(typeof(RAWINPUTHEADER))) == dwSize) { RAWINPUTHEADER header = (RAWINPUTHEADER)Marshal.PtrToStructure(headerBuffer, typeof(RAWINPUTHEADER)); if (header.dwType == RIM_TYPEHID) { DeviceInfo dInfo = null; if (deviceList.Contains(header.hDevice)) { dInfo = (DeviceInfo)deviceList[header.hDevice]; } else { // Device not in list. Reenumerate all of them again. Could warn the code with some sort of Connect/Disconnect event. EnumerateDevices(); dInfo = (DeviceInfo)deviceList[header.hDevice]; } // The header tells us the size of the actual event IntPtr eventBuffer = Marshal.AllocHGlobal(header.dwSize); uint eventSize = (uint)header.dwSize; if (eventBuffer != IntPtr.Zero && GetRawInputData(message.LParam, RID_INPUT, eventBuffer, ref eventSize, (uint)Marshal.SizeOf(typeof(RAWINPUTHEADER))) == header.dwSize) { RAW3DMOUSE_EVENTTYPE eventType = (RAW3DMOUSE_EVENTTYPE)Marshal.PtrToStructure(new IntPtr(eventBuffer.ToInt32() + Marshal.SizeOf(typeof(RAWINPUTHEADER))), typeof(RAW3DMOUSE_EVENTTYPE)); switch (eventType.eventType) { case (byte)RAW3DxMouseEventType.TranslationVector: if (header.dwSize == Marshal.SizeOf(typeof(RAWINPUTHEADER)) + SIZEOF_STANDARD_REPORT) // standard length T report { RAW3DMOUSEMOTION_T t = (RAW3DMOUSEMOTION_T)Marshal.PtrToStructure(new IntPtr(eventBuffer.ToInt32() + Marshal.SizeOf(typeof(RAWINPUTHEADER))), typeof(RAW3DMOUSEMOTION_T)); TranslationVector tv = new TranslationVector(t.X_lb, t.X_hb, t.Y_lb, t.Y_hb, t.Z_lb, t.Z_hb); // Console.Write("Motion Event = {0} {1} {2}", tv.X, tv.Y, tv.Z); MotionEvent(this, new MotionEventArgs(dInfo, tv)); } else // "High Speed" firmware version includes both T and R vector in the same report { RAW3DMOUSEMOTION_TR_COMBINED tr = (RAW3DMOUSEMOTION_TR_COMBINED)Marshal.PtrToStructure(new IntPtr(eventBuffer.ToInt32() + Marshal.SizeOf(typeof(RAWINPUTHEADER))), typeof(RAW3DMOUSEMOTION_TR_COMBINED)); TranslationVector tv = new TranslationVector(tr.X_lb, tr.X_hb, tr.Y_lb, tr.Y_hb, tr.Z_lb, tr.Z_hb); RotationVector rv = new RotationVector(tr.RX_lb, tr.RX_hb, tr.RY_lb, tr.RY_hb, tr.RZ_lb, tr.RZ_hb); // Console.WriteLine("6DOF Motion Event = {0} {1} {2} {3} {4} {5}", tv.X, tv.Y, tv.Z, rv.X, rv.Y, rv.Z); MotionEvent(this, new MotionEventArgs(dInfo, tv, rv)); } break; case (byte)RAW3DxMouseEventType.RotationVector: { RAW3DMOUSEMOTION_R r = (RAW3DMOUSEMOTION_R)Marshal.PtrToStructure(new IntPtr(eventBuffer.ToInt32() + Marshal.SizeOf(typeof(RAWINPUTHEADER))), typeof(RAW3DMOUSEMOTION_R)); RotationVector rv = new RotationVector(r.X_lb, r.X_hb, r.Y_lb, r.Y_hb, r.Z_lb, r.Z_hb); // Console.WriteLine(" {0} {1} {2}", rv.X, rv.Y, rv.Z); MotionEvent(this, new MotionEventArgs(dInfo, rv)); } break; case (byte)RAW3DxMouseEventType.ButtonReport: RAW3DMOUSEBUTTONS b = (RAW3DMOUSEBUTTONS)Marshal.PtrToStructure(new IntPtr(eventBuffer.ToInt32() + Marshal.SizeOf(typeof(RAWINPUTHEADER))), typeof(RAW3DMOUSEBUTTONS)); ButtonMask bm = new ButtonMask(b.b1, b.b2, b.b3, b.b4); //Console.WriteLine("raw.buttons = {0:X}", bm.Pressed); ButtonEvent(this, new ButtonEventArgs(dInfo, bm)); break; } } } } } finally { Marshal.FreeHGlobal(headerBuffer); } }
//TODO: keystate and modifier keys. private void ProcessRawKeyboardInput(RAWKEYBOARD keyboard, RAWINPUTHEADER rh) { KeyboardInput?.Invoke(this, new RawKeyboardInputEventArgs(rh, keyboard)); }
private void ProcessRawMouseInput(RAWMOUSE mouse, RAWINPUTHEADER rh) { MouseInput?.Invoke(this, new RawMouseInputEventArgs(rh, mouse)); }
public RawKeyboardInputEventArgs(RAWINPUTHEADER header, RAWKEYBOARD data) { Header = header; Data = data; }
private static extern uint GetRawInputDataH(HRAWINPUT hRawInput, RID uiCommand, ref RAWINPUTHEADER pData, ref uint pcbSize, uint cbSizeHeader);
/// <summary> /// Processes a <see cref="WM.INPUT">WM_INPUT</see> messages and raises the proper events. /// </summary> /// <param name="lParam">The handle to the raw input dataset.</param> /// <param name="size">The size, in bytes, of the raw input dataset.</param> public void ProcessInput(IntPtr lParam, uint size) { IntPtr buffer = Marshal.AllocHGlobal((int)size); uint dwSize = size; try { uint err = RawInput.GetRawInputData(lParam, RID.INPUT, buffer, ref dwSize, RAWINPUTHEADER.SIZE); if (err == uint.MaxValue) { throw new Exception(string.Format("Error getting WM_INPUT data. (Error code: 0x{0:X8})", WinKernel.GetLastError())); } RAWINPUTHEADER inputHeader = (RAWINPUTHEADER)Marshal.PtrToStructure(buffer, typeof(RAWINPUTHEADER)); SpaceMouseEventHeader eventHeader = (SpaceMouseEventHeader)Marshal.PtrToStructure(buffer + (int)RAWINPUTHEADER.SIZE, typeof(SpaceMouseEventHeader)); int eventHeaderSize = SpaceMouseEventHeader.SIZE + (int)RAWINPUTHEADER.SIZE; switch (eventHeader.eventType) { case SpaceMouseEventType.Translation: if (eventHeader.dwSizeHid == 7) // check report size for safety { EventHandler <SpaceMouseTranslationEventArgs> tEvt = Translation; if (tEvt != null) // no need to handle if nobody is listing { for (int i = 0; i < eventHeader.dwCount; i++) { SpaceMouseTranslationEventData translation = (SpaceMouseTranslationEventData)Marshal.PtrToStructure(buffer + eventHeaderSize + i * (int)eventHeader.dwSizeHid, typeof(SpaceMouseTranslationEventData)); tEvt(this, new SpaceMouseTranslationEventArgs(inputHeader.hDevice, translation.X, translation.Y, translation.Z)); } } } else if (eventHeader.dwSizeHid == 13) // "High Speed" firmware version includes both T and R vector in the same report { EventHandler <SpaceMouseTranslationEventArgs> tEvt = Translation; EventHandler <SpaceMouseRotationEventArgs> rEvt = Rotation; if (tEvt != null || rEvt != null) // no need to handle if nobody is listing { for (int i = 0; i < eventHeader.dwCount; i++) { SpaceMouseTranslationRotationEventData transRot = (SpaceMouseTranslationRotationEventData)Marshal.PtrToStructure(buffer + eventHeaderSize + i * (int)eventHeader.dwSizeHid, typeof(SpaceMouseTranslationRotationEventData)); if (tEvt != null) { tEvt(this, new SpaceMouseTranslationEventArgs(inputHeader.hDevice, transRot.X, transRot.Y, transRot.Z)); } if (rEvt != null) { rEvt(this, new SpaceMouseRotationEventArgs(inputHeader.hDevice, transRot.RX, transRot.RY, transRot.RZ)); } } } } break; case SpaceMouseEventType.Rotation: if (eventHeader.dwSizeHid == 7) // check report size for safety { EventHandler <SpaceMouseRotationEventArgs> rEvt = Rotation; if (rEvt != null) // no need to handle if nobody is listing { for (int i = 0; i < eventHeader.dwCount; i++) { SpaceMouseRotationEventData rotation = (SpaceMouseRotationEventData)Marshal.PtrToStructure(buffer + eventHeaderSize + i * (int)eventHeader.dwSizeHid, typeof(SpaceMouseRotationEventData)); rEvt(this, new SpaceMouseRotationEventArgs(inputHeader.hDevice, rotation.RX, rotation.RY, rotation.RZ)); } } } break; case SpaceMouseEventType.Buttons: if (eventHeader.dwSizeHid >= 5) // check report size for safety { EventHandler <SpaceMouseButtonsEventArgs> bEvt = Buttons; if (bEvt != null) // no need to handle if nobody is listing { if (!DeviceToProduct.ContainsKey(inputHeader.hDevice)) { var di = RawInput.GetRawInputDeviceInfo(inputHeader.hDevice); DeviceToProduct.Add(inputHeader.hDevice, di.hid.dwProductId); } uint product = DeviceToProduct[inputHeader.hDevice]; for (int i = 0; i < eventHeader.dwCount; i++) { SpaceMouseButtonsEventData tmpButtons = (SpaceMouseButtonsEventData)Marshal.PtrToStructure(buffer + eventHeaderSize + i * (int)eventHeader.dwSizeHid, typeof(SpaceMouseButtonsEventData)); SpaceMouseButtons buttons = SpaceMouseButtons.NONE; switch (product) { case ProductID.SpacePilot: buttons = FromSpacePilot(tmpButtons.ButtonState); break; case ProductID.SpaceExplorer: buttons = FromSpaceExplorer(tmpButtons.ButtonState); break; case ProductID.SpaceNavigator: case ProductID.SpaceNavigatorforNotebooks: case ProductID.SpaceMouse: case ProductID.SpaceMouseWireless: buttons = FromSpaceMouse(tmpButtons.ButtonState); break; case ProductID.SpacePilotPro: buttons = FromSpacePilotPro(tmpButtons.ButtonState); break; case ProductID.SpaceMousePro: case ProductID.SpaceMouseProWireless: buttons = FromSpaceMousePro(tmpButtons.ButtonState); break; case ProductID.SpaceMouseTouch: buttons = FromSpaceMouseTouch(tmpButtons.ButtonState); break; } bEvt(this, new SpaceMouseButtonsEventArgs(inputHeader.hDevice, buttons)); } } } break; } } finally { Marshal.FreeHGlobal(buffer); } }
public RawMouseInputEventArgs(RAWINPUTHEADER header, RAWMOUSE data) { Header = header; Data = data; }
public void InputFromKeyboard_SingleLight(RAWINPUTHEADER riHeader, RAWKEYBOARD riKeyboard) { if (riKeyboard.Flags == 0x0) { return; } ; if (riKeyboard.Flags == 0x2 && Control.IsKeyLocked(Keys.NumLock)) { return; } ; string s = ""; s = s + "0x" + riKeyboard.MakeCode.ToString("X4"); s = s + " 0x" + riKeyboard.VKey.ToString("X4"); // s = s + " Mssg: 0x" + riKeyboard.Message.ToString("X4"); s = s + " 0x" + riKeyboard.Flags.ToString("X4"); // s = s + " Rsrvd: 0x" + riKeyboard.Reserved.ToString("X4"); // s = s + " ExInf: 0x" + riKeyboard.ExtraInformation.ToString("X4"); // s = s + " Devc: 0x" + riHeader.hDevice.ToString("X4"); // s = s + " .Size: 0x" + riHeader.dwSize.ToString("X4"); // s = s + " .Type: 0x" + riHeader.dwType.ToString("X4"); // s = s + " wPara: 0x" + riHeader.wParam.ToString("X4"); System.Diagnostics.Debug.Write(s); UpdateStatusMessage.ShowStatusMessage(5, s); int currentKey = keys.GetKeyCode(riKeyboard.MakeCode, riKeyboard.VKey, riKeyboard.Flags, Control.IsKeyLocked(Keys.NumLock)); int sR = 0; int sG = 0; int sB = 0; int eR = 0; int eG = 0; int eB = 0; switch (Program.ReactTypeStart) { case 0: sR = Program.ReactColors.StartR; sG = Program.ReactColors.StartG; sB = Program.ReactColors.StartB; break; case 1: //Figure out how to make a rainbow here, probably going to need to rewrite SingleKeyFade classs break; case 2: sR = rnd.Next(Program.ReactColors.SRandRLow, Program.ReactColors.SRandRHigh); sG = rnd.Next(Program.ReactColors.SRandGLow, Program.ReactColors.SRandGHigh); sB = rnd.Next(Program.ReactColors.SRandBLow, Program.ReactColors.SRandBHigh); break; default: break; } switch (Program.ReactTypeEnd) { case 0: eR = Program.ReactColors.EndR; eG = Program.ReactColors.EndG; eB = Program.ReactColors.EndB; break; case 1: if (Program.StaticKeyColors[currentKey] != Color.Transparent) { eR = Program.StaticKeyColors[currentKey].R; eG = Program.StaticKeyColors[currentKey].G; eB = Program.StaticKeyColors[currentKey].B; } break; case 2: eR = rnd.Next(Program.ReactColors.ERandRLow, Program.ReactColors.ERandRHigh); eG = rnd.Next(Program.ReactColors.ERandGLow, Program.ReactColors.ERandGHigh); eB = rnd.Next(Program.ReactColors.ERandBLow, Program.ReactColors.ERandBHigh); break; default: break; } keyMatrix[currentKey] = new SingleKeyFade( Program.ReactSettings.Duration, (byte)sR, (byte)sG, (byte)sB, (byte)eR, (byte)eG, (byte)eB); }