private bool ProcessMouseInput(InputData rawBuffer)
{
ushort usFlags = rawBuffer.data.mouse.usFlags;
ushort usButtonFlags = rawBuffer.data.mouse.usButtonFlags;
short sButtonData = rawBuffer.data.mouse.usButtonData;
int lLastX = rawBuffer.data.mouse.lLastX;
int lLastY = rawBuffer.data.mouse.lLastY;
RawMouseDevice device;
lock (_lock)
{
if (!_mouseList.TryGetValue(rawBuffer.header.hDevice, out device))
{
Debug.WriteLine("Handle: {0} was not in the device list.", rawBuffer.header.hDevice);
return(false);
}
}
EventHandler <RawInputMouseEventArgs> mouseClicked = MouseClickedDelegate;
if (mouseClicked != null)
{
var rawInputEventArgs = new RawInputMouseEventArgs(device, usFlags, usButtonFlags, sButtonData, lLastX, lLastY);
mouseClicked(this, rawInputEventArgs);
if (rawInputEventArgs.Handled)
{
MSG msg;
Win32Methods.PeekMessage(out msg, IntPtr.Zero, Win32Consts.WM_MOUSEFIRST, Win32Consts.WM_MOUSELAST, Win32Consts.PM_REMOVE);
}
return(rawInputEventArgs.Handled);
}
return(false);
}
private bool ProcessRawInput(IntPtr hdevice)
{
if (_keyboardList.Count == 0 && _mouseList.Count == 0 && _hidList.Count == 0)
{
Debug.WriteLine("KeyboardCount: {0}, MouseCount: {1}, HidCount: {2}", _keyboardList.Count, _mouseList.Count, _hidList.Count);
return(false);
}
int size = 0;
Win32Methods.GetRawInputData(hdevice, DataCommand.RID_INPUT, IntPtr.Zero, ref size, Marshal.SizeOf(typeof(RawInputHeader)));
InputData rawBuffer;
if (Win32Methods.GetRawInputData(hdevice, DataCommand.RID_INPUT, out rawBuffer, ref size, Marshal.SizeOf(typeof(RawInputHeader))) != size)
{
Debug.WriteLine("Error getting the rawinput buffer");
return(false);
}
switch ((RawDeviceType)rawBuffer.header.dwType)
{
case RawDeviceType.Mouse:
return(ProcessMouseInput(rawBuffer));
case RawDeviceType.Hid:
return(ProcessHidInput(rawBuffer));
case RawDeviceType.Keyboard:
return(ProcessKeyboardInput(rawBuffer));
}
return(false);
}
protected RawInput(IntPtr handle, RawInputCaptureMode captureMode)
{
RawInputDevice[] array =
{
new RawInputDevice
{
UsagePage = HidUsagePage.GENERIC,
Usage = HidUsage.Keyboard,
Flags = (captureMode == RawInputCaptureMode.Foreground ? RawInputDeviceFlags.NONE : RawInputDeviceFlags.INPUTSINK) | RawInputDeviceFlags.DEVNOTIFY,
Target = IntPtr.Zero
},
new RawInputDevice
{
UsagePage = HidUsagePage.GENERIC,
Usage = HidUsage.Mouse,
Flags = (captureMode == RawInputCaptureMode.Foreground ? RawInputDeviceFlags.NONE : RawInputDeviceFlags.INPUTSINK) | RawInputDeviceFlags.DEVNOTIFY,
Target = IntPtr.Zero
},
new RawInputDevice
{
UsagePage = HidUsagePage.GENERIC,
Usage = HidUsage.Gamepad,
Flags = (captureMode == RawInputCaptureMode.Foreground ? RawInputDeviceFlags.NONE : RawInputDeviceFlags.INPUTSINK) | RawInputDeviceFlags.DEVNOTIFY,
Target = IntPtr.Zero
}
};
if (!Win32Methods.RegisterRawInputDevices(array, (uint)array.Length, (uint)Marshal.SizeOf(array[0])))
{
throw new ApplicationException("Failed to register raw input device(s).", new Win32Exception());
}
EnumerateDevices();
_devNotifyHandle = RegisterForDeviceNotifications(handle);
}
public void EnumerateHid()
{
lock (_lock)
{
_hidList.Clear();
uint devices = 0u;
int size = Marshal.SizeOf(typeof(RawInputDeviceList));
if (Win32Methods.GetRawInputDeviceList(IntPtr.Zero, ref devices, (uint)size) != 0u)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
IntPtr pRawInputDeviceList = Marshal.AllocHGlobal((int)(size * devices));
try
{
Win32Methods.GetRawInputDeviceList(pRawInputDeviceList, ref devices, (uint)size);
int index = 0;
while (index < devices)
{
RawHidDevice device = GetHid(pRawInputDeviceList, size, index);
if (device != null && !_hidList.ContainsKey(device.Handle))
{
Debug.WriteLine("Added Hid; Handle: {0}, Name: {1}, Type: {2}, Description: {3}", (uint)device.Handle, device.Name, device.Type, device.Description);
_hidList.Add(device.Handle, device);
}
index++;
}
}
finally
{
Marshal.FreeHGlobal(pRawInputDeviceList);
}
NumberOfHid = _hidList.Count;
}
}
InterceptKeys()
{
keyStream = Observable.Create <InterceptKeyEventArgs>(observer =>
{
Debug.Write("Subscribed to keys");
IntPtr hookId = IntPtr.Zero;
// Need to hold onto this callback, otherwise it will get GC'd as it is an unmanged callback
callback = (nCode, wParam, lParam) =>
{
if (nCode >= 0)
{
var eventArgs = CreateEventArgs(wParam, lParam);
observer.OnNext(eventArgs);
if (eventArgs.Handled)
{
return((IntPtr)1);
}
}
// ReSharper disable once AccessToModifiedClosure
return(Win32Methods.CallNextHookEx(hookId, nCode, wParam, lParam));
};
hookId = SetHook(callback);
return(Disposable.Create(() =>
{
Debug.Write("Unsubscribed from keys");
Win32Methods.UnhookWindowsHookEx(hookId);
callback = null;
}));
})
.Publish().RefCount();
}
public static IDictionary<IntPtr, RawKeyboardDevice> GetDevices()
{
var deviceList = new Dictionary<IntPtr, RawKeyboardDevice>();
var rawKeyboardDevice = new RawKeyboardDevice("Global Keyboard", RawDeviceType.Keyboard, IntPtr.Zero,
"Fake Keyboard. Some keys (ZOOM, MUTE, VOLUMEUP, VOLUMEDOWN) are sent to rawinput with a handle of zero.");
deviceList.Add(rawKeyboardDevice.Handle, rawKeyboardDevice);
uint devices = 0u;
int size = Marshal.SizeOf(typeof(RawInputDeviceList));
if (Win32Methods.GetRawInputDeviceList(IntPtr.Zero, ref devices, (uint)size) != 0u)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
IntPtr pRawInputDeviceList = Marshal.AllocHGlobal((int)(size * devices));
try
{
Win32Methods.GetRawInputDeviceList(pRawInputDeviceList, ref devices, (uint)size);
int index = 0;
while (index < devices)
{
RawKeyboardDevice device = GetDevice(pRawInputDeviceList, size, index);
if (device != null && !deviceList.ContainsKey(device.Handle))
{
deviceList.Add(device.Handle, device);
}
index++;
}
}
finally
{
Marshal.FreeHGlobal(pRawInputDeviceList);
}
return deviceList;
}
private static RawKeyboardDevice GetDevice(IntPtr pRawInputDeviceList, int dwSize, int index)
{
uint size = 0u;
// On Window 8 64bit when compiling against .Net > 3.5 using .ToInt32 you will generate an arithmetic overflow. Leave as it is for 32bit/64bit applications
var rawInputDeviceList = (RawInputDeviceList)Marshal.PtrToStructure(new IntPtr(pRawInputDeviceList.ToInt64() + dwSize * index), typeof(RawInputDeviceList));
Win32Methods.GetRawInputDeviceInfo(rawInputDeviceList.hDevice, RawInputDeviceInfo.RIDI_DEVICENAME, IntPtr.Zero, ref size);
if (size <= 0u)
{
return null;
}
IntPtr intPtr = Marshal.AllocHGlobal((int)size);
try
{
Win32Methods.GetRawInputDeviceInfo(rawInputDeviceList.hDevice, RawInputDeviceInfo.RIDI_DEVICENAME, intPtr, ref size);
string device = Marshal.PtrToStringAnsi(intPtr);
if (rawInputDeviceList.dwType == DeviceType.RimTypekeyboard ||
rawInputDeviceList.dwType == DeviceType.RimTypeHid)
{
string deviceDescription = Win32Methods.GetDeviceDescription(device);
return new RawKeyboardDevice(Marshal.PtrToStringAnsi(intPtr),
(RawDeviceType)rawInputDeviceList.dwType, rawInputDeviceList.hDevice, deviceDescription);
}
}
finally
{
if (intPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(intPtr);
}
}
return null;
}
public void EnumerateKeyboards()
{
lock (_lock)
{
_keyboardList.Clear();
var rawKeyboardDevice = new RawKeyboardDevice("Global Keyboard", RawDeviceType.Keyboard, IntPtr.Zero, "Fake Keyboard. Some keys (ZOOM, MUTE, VOLUMEUP, VOLUMEDOWN) are sent to rawinput with a handle of zero.");
_keyboardList.Add(rawKeyboardDevice.Handle, rawKeyboardDevice);
uint devices = 0u;
int size = Marshal.SizeOf(typeof(RawInputDeviceList));
if (Win32Methods.GetRawInputDeviceList(IntPtr.Zero, ref devices, (uint)size) != 0u)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
IntPtr pRawInputDeviceList = Marshal.AllocHGlobal((int)(size * devices));
try
{
Win32Methods.GetRawInputDeviceList(pRawInputDeviceList, ref devices, (uint)size);
int index = 0;
while (index < devices)
{
RawKeyboardDevice device = GetKeyboard(pRawInputDeviceList, size, index);
if (device != null && !_keyboardList.ContainsKey(device.Handle))
{
_keyboardList.Add(device.Handle, device);
}
index++;
}
}
finally
{
Marshal.FreeHGlobal(pRawInputDeviceList);
}
NumberOfKeyboards = _keyboardList.Count;
}
}
public void EnumerateMice()
{
lock (_lock)
{
_mouseList.Clear();
uint devices = 0u;
int size = Marshal.SizeOf(typeof(RawInputDeviceList));
if (Win32Methods.GetRawInputDeviceList(IntPtr.Zero, ref devices, (uint)size) != 0u)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
IntPtr pRawInputDeviceList = Marshal.AllocHGlobal((int)(size * devices));
try
{
Win32Methods.GetRawInputDeviceList(pRawInputDeviceList, ref devices, (uint)size);
int index = 0;
while (index < devices)
{
RawMouseDevice device = GetMouse(pRawInputDeviceList, size, index);
if (device != null && !_mouseList.ContainsKey(device.Handle))
{
_mouseList.Add(device.Handle, device);
}
index++;
}
}
finally
{
Marshal.FreeHGlobal(pRawInputDeviceList);
}
NumberOfMice = _mouseList.Count;
}
}
public void Activate(IntPtr hWndParent, RECT[] pRect, int bModal)
{
if (pane != null)
{
Win32Methods.SetParent(pane.Handle, hWndParent);
}
}
private static IntPtr RegisterForDeviceNotifications(IntPtr parent)
{
IntPtr notifyHandle = IntPtr.Zero;
BroadcastDeviceInterface broadcastDeviceInterface = default(BroadcastDeviceInterface);
broadcastDeviceInterface.dbcc_size = Marshal.SizeOf(broadcastDeviceInterface);
broadcastDeviceInterface.BroadcastDeviceType = BroadcastDeviceType.DBT_DEVTYP_DEVICEINTERFACE;
broadcastDeviceInterface.dbcc_classguid = DeviceInterfaceHid;
IntPtr interfacePtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(BroadcastDeviceInterface)));
try
{
Marshal.StructureToPtr(broadcastDeviceInterface, interfacePtr, false);
notifyHandle = Win32Methods.RegisterDeviceNotification(parent, interfacePtr,
DeviceNotification.DEVICE_NOTIFY_WINDOW_HANDLE);
}
catch (Exception ex)
{
Debug.Print("Registration for device notifications Failed. Error: {0}", Marshal.GetLastWin32Error());
Debug.Print(ex.StackTrace);
}
finally
{
Marshal.FreeHGlobal(interfacePtr);
}
if (notifyHandle == IntPtr.Zero)
{
Debug.Print("Registration for device notifications Failed. Error: {0}", Marshal.GetLastWin32Error());
}
return(notifyHandle);
}
protected override void OnSourceInitialized(EventArgs e)
{
base.OnSourceInitialized(e);
var hwnd = new WindowInteropHelper(this).Handle;
Win32Methods.SetWindowExTransparent(hwnd);
var timer = new Timer(100);
timer.Elapsed +=
(s, x) =>
{
SetWindowPos(hwnd,
HWND.TOPMOST,
0, 0, 0, 0,
(uint)(SWP.NOMOVE | SWP.NOSIZE | SWP.SHOWWINDOW));
};
timer.Start();
var vm = ((KeyShowViewModel)DataContext);
Left = vm.Settings.Left;
vm.Settings.LeftChanged += SettingsLeftChanged;
WindowState = WindowState.Maximized;
}
public int CreatePaneWindow(IntPtr hwndParent, int x, int y, int cx, int cy, out IntPtr hwnd)
{
Win32Methods.SetParent(Handle, hwndParent);
hwnd = Handle;
Size = new Size(cx - x, cy - y);
return(VSConstants.S_OK);
}
public Task ActivateAsync(IntPtr hWndParent, Rectangle rect, bool modal)
{
CreateControl();
Win32Methods.SetParent(Handle, hWndParent);
return(TplExtensions.CompletedTask);
}
private bool ProcessRawInput(IntPtr hdevice)
{
if (_deviceList.Count == 0)
{
return(false);
}
var size = 0;
Win32Methods.GetRawInputData(hdevice, DataCommand.RID_INPUT, IntPtr.Zero, ref size,
Marshal.SizeOf(typeof(RawInputHeader)));
InputData rawBuffer;
if (
Win32Methods.GetRawInputData(hdevice, DataCommand.RID_INPUT, out rawBuffer, ref size,
Marshal.SizeOf(typeof(RawInputHeader))) != size)
{
Debug.WriteLine("Error getting the rawinput buffer");
return(false);
}
int vKey = rawBuffer.data.keyboard.VKey;
int makecode = rawBuffer.data.keyboard.Makecode;
int flags = rawBuffer.data.keyboard.Flags;
if (vKey == Win32Consts.KEYBOARD_OVERRUN_MAKE_CODE)
{
return(false);
}
RawKeyboardDevice device;
lock (_lock)
{
if (!_deviceList.TryGetValue(rawBuffer.header.hDevice, out device))
{
Debug.WriteLine("Handle: {0} was not in the device list.", rawBuffer.header.hDevice);
return(false);
}
}
var isE0BitSet = (flags & Win32Consts.RI_KEY_E0) != 0;
var isBreakBitSet = (flags & Win32Consts.RI_KEY_BREAK) != 0;
var message = rawBuffer.data.keyboard.Message;
var key = KeyInterop.KeyFromVirtualKey(AdjustVirtualKey(rawBuffer, vKey, isE0BitSet, makecode));
var keyPressed = KeyPressed;
if (keyPressed != null)
{
var rawInputEventArgs = new RawInputEventArgs(device, isBreakBitSet ? KeyPressState.Up : KeyPressState.Down,
message, key, vKey);
keyPressed(this, rawInputEventArgs);
if (rawInputEventArgs.Handled)
{
MSG msg;
Win32Methods.PeekMessage(out msg, IntPtr.Zero, Win32Consts.WM_KEYDOWN, Win32Consts.WM_KEYUP, Win32Consts.PM_REMOVE);
}
return(rawInputEventArgs.Handled);
}
return(false);
}
public MpqArchive(MemoryMappedFile file, FileAccess accessType)
{
_accessType = accessType;
string fileName = Win32Methods.GetFileNameOfMemoryMappedFile(file);
if (fileName == null)
{
throw new ArgumentException("Could not retrieve the name of the file to initialize.");
}
SFileOpenArchiveFlags flags = SFileOpenArchiveFlags.TypeIsMemoryMapped;
if (accessType == FileAccess.Read)
{
flags |= SFileOpenArchiveFlags.AccessReadOnly;
}
else
{
flags |= SFileOpenArchiveFlags.AccessReadWriteShare;
}
// constant 2 = SFILE_OPEN_HARD_DISK_FILE
if (!NativeMethods.SFileOpenArchive(fileName, 2, flags, out _handle))
{
throw new Win32Exception(); // Implicitly calls GetLastError
}
}
public void Dispose()
{
GC.SuppressFinalize(this);
if (_devNotifyHandle != IntPtr.Zero)
{
Win32Methods.UnregisterDeviceNotification(_devNotifyHandle);
_devNotifyHandle = IntPtr.Zero;
}
}
private void GameWindow_Idle(object sender, EventArgs e)
{
Win32Message msg;
while (!Win32Methods.PeekMessage(out msg, IntPtr.Zero, 0, 0, 0))
{
Idle();
}
}
static IntPtr SetHook(Win32Methods.LowLevelKeyboardProc proc)
{
//TODO: This requires FullTrust to use the Process class - is there any options for doing this in MediumTrust?
//
using (Process curProcess = Process.GetCurrentProcess())
using (ProcessModule curModule = curProcess.MainModule)
{
return Win32Methods.SetWindowsHookEx(Win32Methods.WH_KEYBOARD_LL, proc, Win32Methods.GetModuleHandle(curModule.ModuleName), 0);
}
}
public Task <int> TranslateAcceleratorAsync(MSG msg)
{
if ((msg.message < WM.WM_KEYFIRST || msg.message > WM.WM_KEYLAST) &&
(msg.message < WM.WM_MOUSEFIRST || msg.message > WM.WM_MOUSELAST))
{
return(Task.FromResult(VSConstants.S_FALSE));
}
return(Task.FromResult(Win32Methods.IsDialogMessageA(Handle, ref msg).ToVSConstant()));
}
static IntPtr SetHook(Win32Methods.LowLevelKeyboardProc proc)
{
//TODO: This requires FullTrust to use the Process class - is there any options for doing this in MediumTrust?
//
using (Process curProcess = Process.GetCurrentProcess())
using (ProcessModule curModule = curProcess.MainModule)
{
return(Win32Methods.SetWindowsHookEx(Win32Methods.WH_KEYBOARD_LL, proc, Win32Methods.GetModuleHandle(curModule.ModuleName), 0));
}
}
public int CreatePaneWindow(IntPtr hwndParent, int x, int y, int cx, int cy, out IntPtr hwnd)
{
Win32Methods.SetParent(Handle, hwndParent);
hwnd = Handle;
Size = new System.Drawing.Size(cx - x, cy - y);
// Note, logical views map to the tab control panes.
return(VSConstants.S_OK);
}
///--------------------------------------------------------------------------------------------
/// <summary>
/// IPropertyPage
/// This is called before our form is shown but after SetObjects is called.
/// This is the place from which the form can populate itself using the information available
/// in CPS.
/// </summary>
///--------------------------------------------------------------------------------------------
public void Activate(IntPtr hWndParent, RECT[] pRect, int bModal)
{
AdviseDebugger();
SuspendLayout();
// Initialization can cause some events to be fired when we change some values
// so we use this flag (_ignoreEvents) to notify IsDirty to ignore
// any changes that happen during initialization
Win32Methods.SetParent(Handle, hWndParent);
ResumeLayout();
}
static IntPtr SetHook(Win32Methods.LowLevelKeyboardProc proc)
{
// NOTE: This requires FullTrust to use the Process class.
// There don't seem to be alternatives to achieving this in
// MediumTrust environment which is fine because that's a
// concept that has long been obsoleted. But just a warning
// if you ever try and run Carnac in that sort of way.
using (Process curProcess = Process.GetCurrentProcess())
using (ProcessModule curModule = curProcess.MainModule)
{
return(Win32Methods.SetWindowsHookEx(Win32Methods.WH_KEYBOARD_LL, proc, Win32Methods.GetModuleHandle(curModule.ModuleName), 0));
}
}
public static ChangeJournal Open(DriveInfo driveInfo)
{
if (driveInfo == null)
{
throw new ArgumentNullException(nameof(driveInfo));
}
var volume = VolumeHelper.GetValidVolumePath(driveInfo);
var handle = Win32Methods.CreateFile(volume, FileAccess.Read, FileShare.Read | FileShare.Write, IntPtr.Zero, FileMode.Open, 0, IntPtr.Zero);
if (handle.IsInvalid)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
return(new ChangeJournal(handle));
}
/// <summary>
/// Creates a window pane
/// </summary>
/// <returns>Return code</returns>
int IVsWindowPane.CreatePaneWindow(System.IntPtr hwndParent, int x, int y, int cx, int cy, out System.IntPtr hwnd)
{
Win32Methods.SetParent(Handle, hwndParent);
hwnd = Handle;
Debug.Assert(TrackSelection != null, "Unable to register in property window!");
if (TrackSelection != null)
{
TrackSelection.OnSelectChange(SelectionContainer);
}
Size = new System.Drawing.Size(cx - x, cy - y);
// Loading configuration settings
LoadSettings();
return(VSConstants.S_OK);
}
public NtStatus SetFileTime(string fileName, DateTime?creationTime, DateTime?lastAccessTime, DateTime?lastWriteTime, IDokanFileInfo info)
{
try
{
if (info.Context is FileStream stream)
{
var ct = creationTime?.ToFileTime() ?? 0;
var lat = lastAccessTime?.ToFileTime() ?? 0;
var lwt = lastWriteTime?.ToFileTime() ?? 0;
if (Win32Methods.SetFileTime(stream.SafeFileHandle, ref ct, ref lat, ref lwt))
{
return(DokanResult.Success);
}
throw Marshal.GetExceptionForHR(Marshal.GetLastWin32Error());
}
var filePath = GetDiskPath(fileName);
if (creationTime.HasValue)
{
File.SetCreationTime(filePath, creationTime.Value);
}
if (lastAccessTime.HasValue)
{
File.SetLastAccessTime(filePath, lastAccessTime.Value);
}
if (lastWriteTime.HasValue)
{
File.SetLastWriteTime(filePath, lastWriteTime.Value);
}
return(DokanResult.Success);
}
catch (UnauthorizedAccessException)
{
return(DokanResult.AccessDenied);
}
catch (FileNotFoundException)
{
return(DokanResult.FileNotFound);
}
}
public bool ProcessRawInput(IntPtr hdevice)
{
int size = 0;
Win32Methods.GetRawInputData(hdevice, DataCommand.RID_INPUT, IntPtr.Zero, ref size, Marshal.SizeOf(typeof(RawInputHeader)));
InputData rawBuffer;
if (Win32Methods.GetRawInputData(hdevice, DataCommand.RID_INPUT, out rawBuffer, ref size, Marshal.SizeOf(typeof(RawInputHeader))) != size)
{
Debug.WriteLine("Error getting the rawinput buffer");
return(false);
}
int vKey = rawBuffer.data.keyboard.VKey;
int makecode = rawBuffer.data.keyboard.Makecode;
int flags = rawBuffer.data.keyboard.Flags;
if (vKey == Win32Consts.KEYBOARD_OVERRUN_MAKE_CODE)
{
return(false);
}
var isE0BitSet = ((flags & Win32Consts.RI_KEY_E0) != 0);
bool isBreakBitSet = (flags & Win32Consts.RI_KEY_BREAK) != 0;
uint message = rawBuffer.data.keyboard.Message;
Key key = KeyInterop.KeyFromVirtualKey(AdjustVirtualKey(rawBuffer, vKey, isE0BitSet, makecode));
EventHandler <RawKeyEventArgs> keyPressed = KeyPressed;
if (keyPressed != null)
{
var rawInputEventArgs = new RawKeyEventArgs(rawBuffer.header.hDevice, isBreakBitSet ? KeyPressState.Up : KeyPressState.Down, message, key, vKey);
keyPressed(this, rawInputEventArgs);
if (rawInputEventArgs.Handled)
{
//Remove the message
MSG msg;
Win32Methods.PeekMessage(out msg, IntPtr.Zero, Win32Consts.WM_KEYDOWN, Win32Consts.WM_KEYUP, Win32Consts.PM_REMOVE);
}
return(rawInputEventArgs.Handled);
}
return(false);
}
public RawKeyboard(IntPtr hwnd, bool captureOnlyInForeground)
{
RawInputDevice[] array =
{
new RawInputDevice
{
UsagePage = HidUsagePage.GENERIC,
Usage = HidUsage.Keyboard,
Flags = (captureOnlyInForeground ? RawInputDeviceFlags.NONE : RawInputDeviceFlags.INPUTSINK) | RawInputDeviceFlags.DEVNOTIFY,
Target = hwnd
}
};
if (!Win32Methods.RegisterRawInputDevices(array, (uint)array.Length, (uint)Marshal.SizeOf(array[0])))
{
throw new ApplicationException("Failed to register raw input device(s).", new Win32Exception());
}
EnumerateDevices();
_devNotifyHandle = RegisterForDeviceNotifications(hwnd);
}
public IDisposable Subscribe(IObserver <InterceptKeyEventArgs> observer)
{
Debug.WriteLine("Subscribed");
IDisposable dispose = subject.Subscribe(observer);
subscriberCount++;
if (subscriberCount == 1)
{
hookId = SetHook(callback);
}
return(new DelegateDisposable(() =>
{
subscriberCount--;
if (subscriberCount == 0)
{
Win32Methods.UnhookWindowsHookEx(hookId);
}
dispose.Dispose();
}));
}
IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0)
{
bool alt = (Control.ModifierKeys & Keys.Alt) != 0;
bool control = (Control.ModifierKeys & Keys.Control) != 0;
bool shift = (Control.ModifierKeys & Keys.Shift) != 0;
bool keyDown = wParam == (IntPtr)Win32Methods.WM_KEYDOWN;
bool keyUp = wParam == (IntPtr)Win32Methods.WM_KEYUP;
int vkCode = Marshal.ReadInt32(lParam);
var key = (Keys)vkCode;
//http://msdn.microsoft.com/en-us/library/windows/desktop/ms646286(v=vs.85).aspx
if (key != Keys.RMenu && key != Keys.LMenu && wParam == (IntPtr)Win32Methods.WM_SYSKEYDOWN)
{
alt = true;
keyDown = true;
}
if (key != Keys.RMenu && key != Keys.LMenu && wParam == (IntPtr)Win32Methods.WM_SYSKEYUP)
{
alt = true;
keyUp = true;
}
var interceptKeyEventArgs = new InterceptKeyEventArgs(
key,
keyDown ?
KeyDirection.Down: keyUp
? KeyDirection.Up: KeyDirection.Unknown,
alt, control, shift);
subject.OnNext(interceptKeyEventArgs);
Debug.Write(key);
if (interceptKeyEventArgs.Handled)
{
Debug.WriteLine(" handled");
return((IntPtr)1); //handled
}
}
return(Win32Methods.CallNextHookEx(hookId, nCode, wParam, lParam));
}
