/// <summary> /// Registers the devices that supply the raw input data. /// </summary> /// <param name="usagePage">The usage page.</param> /// <param name="usageId">The usage id.</param> /// <param name="flags">The flags.</param> /// <param name="target">The target.</param> /// <param name="options">The options.</param> public static void RegisterDevice(UsagePage usagePage, UsageId usageId, DeviceFlags flags, IntPtr target, RegisterDeviceOptions options = RegisterDeviceOptions.Default) { var rawInputDevices = new RawInputDevice[1]; rawInputDevices[0].UsagePage = (short)usagePage; rawInputDevices[0].Usage = (short)usageId; rawInputDevices[0].Flags = (int)flags; rawInputDevices[0].Target = target; // Register this device RawInputFunctions.RegisterRawInputDevices(rawInputDevices, 1, Utilities.SizeOf <RawInputDevice>()); if (options != RegisterDeviceOptions.NoFiltering && rawInputMessageFilter == null) { rawInputMessageFilter = new RawInputMessageFilter(); if (options == RegisterDeviceOptions.Default) { Application.AddMessageFilter(rawInputMessageFilter); } else { MessageFilterHook.AddMessageFilter(target, rawInputMessageFilter); } } }
public ProxyNativeWindow(Control form) { this._form = form; this._windowHandle = form.Handle; this._form.Disposed += new EventHandler(this._form_Disposed); MessageFilterHook.AddMessageFilter(this._windowHandle, (IMessageFilter)this); this._isAlive = true; }
/// <summary> /// Initializes a new instance of the <see cref="ProxyNativeWindow"/> class. /// </summary> public ProxyNativeWindow(Control form) { _form = form; _windowHandle = form.Handle; _form.Disposed += _form_Disposed; MessageFilterHook.AddMessageFilter(_windowHandle, this); _isAlive = true; }
protected override void OnLoad(EventArgs e) { m_isLoaded = true; if (EnableMessageBypass) { MessageFilterHook.AddMessageFilter(this.Handle, this); } base.OnLoad(e); }
// This allocates, however it should be used only when launching app public static void RegisterDevice(UsagePage usagePage, UsageId usageId, DeviceFlags flags, IntPtr target) { Device.RegisterDevice(usagePage, usageId, flags, target, false); if (m_filter == null) { m_filterWindow = target; m_filter = new RawInputMessageFilter(); MessageFilterHook.AddMessageFilter(m_filterWindow, m_filter); } }
public static void FixKeyboard(Game game) { IntPtr hWnd = game.Window.Handle; Device.RegisterDevice(UsagePage.Generic, UsageId.GenericKeyboard, DeviceFlags.None, hWnd, RegisterDeviceOptions.Default); var filter = new RawInputMessageFilter(); filterCache[hWnd] = filter; MessageFilterHook.AddMessageFilter(hWnd, filter); }
/// <summary> /// Calls this method on each frame. /// </summary> /// <returns><c>true</c> if if the control is still active, <c>false</c> otherwise.</returns> /// <exception cref="System.InvalidOperationException">An error occured </exception> public bool NextFrame() { // Setup new control // TODO this is not completely thread-safe. We should use a lock to handle this correctly if (switchControl && control != null) { controlHandle = control.Handle; control.Disposed += ControlDisposed; MessageFilterHook.AddMessageFilter(control.Handle, this); isControlAlive = true; switchControl = false; } if (isControlAlive) { if (UseCustomDoEvents) { var localHandle = controlHandle; if (localHandle != IntPtr.Zero) { // Previous code not compatible with Application.AddMessageFilter but faster then DoEvents Win32Native.NativeMessage msg; while (Win32Native.PeekMessage(out msg, localHandle, 0, 0, 0) != 0) { if (Win32Native.GetMessage(out msg, localHandle, 0, 0) == -1) { throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, "An error happened in rendering loop while processing windows messages. Error: {0}", Marshal.GetLastWin32Error())); } Win32Native.TranslateMessage(ref msg); Win32Native.DispatchMessage(ref msg); } } } else { // Revert back to Application.DoEvents in order to support Application.AddMessageFilter // Seems that DoEvents is compatible with Mono unlike Application.Run that was not running // correctly. Application.DoEvents(); } } return(isControlAlive || switchControl); }
/// <summary> /// Starts processing the raw input messages received by the application. /// </summary> /// <param name="windowHandle">Handle to the target window that will receive the messages.</param> /// <param name="options">The options for the processing and filtering of messages.</param> /// <remarks> /// Call this function to start filtering and processing raw input messages through the message pump of a target window. /// <para/> /// Using this function, the raw input data is processed one message at a time. In contrast, you can use buffered processing /// by calling <see cref="ProcessMessages"/> to process the queued raw input messages in bulk. /// <para/> /// This function installs a <see cref="IMessageFilter"/> that intercepts and processes the raw input messages received by /// the application. See <see cref="MessageProcessingOptions"/> enumeration for more information. /// </remarks> public static void StartProcessingMessages(IntPtr windowHandle = default, MessageProcessingOptions options = MessageProcessingOptions.Default) { if (rawInputMessageFilter != null) { return; } targetWindowHandle = windowHandle; rawInputMessageFilter = new RawInputMessageFilter(); if (options == MessageProcessingOptions.Default) { Application.AddMessageFilter(rawInputMessageFilter); } else { MessageFilterHook.AddMessageFilter(windowHandle, rawInputMessageFilter); } }
protected override void OnLoad(EventArgs e) { MessageFilterHook.AddMessageFilter(this.Handle, this); base.OnLoad(e); }
public static void SetWindow(IntPtr windowHandle) { m_windowHandle = windowHandle; MessageFilterHook.AddMessageFilter(windowHandle, new MouseMessageFilter()); }