special_input_device 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ef8f13accf6820c844dd6e53dcc893ef9ffd75a6
+  data.tar.gz: bfcb2590e5bacab820f881f9b7b208f177420319
+SHA512:
+  metadata.gz: 9fb1a9fe52cd87db760c2ebcd55386fddc11cedf369590d7d2347926e91b37fd468f2a1d85cf57f3876cbf564a3f185d52968712d41e1eff9a6b2ec145a72162
+  data.tar.gz: 6be975f6a7d6d6436ece1215155586cc27d86184accaddf003def672008a3094f36ef32e08fe84081da818da1d7f2f7881081fadae71622eefac1cb75fa77db8

data/ext/special_input_device/_screen.c

@@ -0,0 +1,25 @@
+#include <windows.h>
+
+INT getPrimaryScreenWidth() {
+	return GetSystemMetrics(SM_CXSCREEN);
+}
+
+INT getPrimaryScreenHeight() {
+	return GetSystemMetrics(SM_CYSCREEN);
+}
+
+INT getVirtualScreenX() {
+	return GetSystemMetrics(SM_XVIRTUALSCREEN);
+}
+
+INT getVirtualScreenY() {
+	return GetSystemMetrics(SM_YVIRTUALSCREEN);
+}
+
+INT getVirtualScreenWidth() {
+	return GetSystemMetrics(SM_CXVIRTUALSCREEN);
+}
+
+INT getVirtualScreenHeight() {
+	return GetSystemMetrics(SM_CYVIRTUALSCREEN);
+}

data/ext/special_input_device/_screen.h

@@ -0,0 +1,16 @@
+#ifndef SPECIAL_INPUT_DEVICE_SCREEN_H
+#define SPECIAL_INPUT_DEVICE_SCREEN_H
+
+INT getPrimaryScreenWidth();
+
+INT getPrimaryScreenHeight();
+
+INT getVirtualScreenX();
+
+INT getVirtualScreenY();
+
+INT getVirtualScreenWidth();
+
+INT getVirtualScreenHeight();
+
+#endif //SPECIAL_INPUT_DEVICE_SCREEN_H

data/ext/special_input_device/_system_time.c

@@ -0,0 +1,10 @@
+#include <windows.h>
+
+ULONGLONG getSystemTimeIdentifier() {
+	FILETIME       cFileTime;
+	ULARGE_INTEGER cInteger;
+	GetSystemTimeAsFileTime(&cFileTime);
+	cInteger.LowPart  = cFileTime.dwLowDateTime;
+	cInteger.HighPart = cFileTime.dwHighDateTime;
+	return cInteger.QuadPart;
+}

data/ext/special_input_device/_system_time.h

@@ -0,0 +1,6 @@
+#ifndef SPECIAL_INPUT_DEVICE_EXT_SYSTEM_TIME_H
+#define SPECIAL_INPUT_DEVICE_EXT_SYSTEM_TIME_H
+
+ULONGLONG getSystemTimeIdentifier();
+
+#endif //SPECIAL_INPUT_DEVICE_EXT_SYSTEM_TIME_H

data/ext/special_input_device/_vendor__interception.c

@@ -0,0 +1,331 @@
+// Interception
+// https://github.com/oblitum/Interception
+// commit 16 Oct 2016 b76a4741fbad583c566d468a00e653fc4946eae2
+
+#include <stdio.h>
+#include <windows.h>
+
+#include "_vendor__interception.h"
+
+#define IOCTL_SET_PRECEDENCE    CTL_CODE(FILE_DEVICE_UNKNOWN, 0x801, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_GET_PRECEDENCE    CTL_CODE(FILE_DEVICE_UNKNOWN, 0x802, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_SET_FILTER        CTL_CODE(FILE_DEVICE_UNKNOWN, 0x804, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_GET_FILTER        CTL_CODE(FILE_DEVICE_UNKNOWN, 0x808, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_SET_EVENT         CTL_CODE(FILE_DEVICE_UNKNOWN, 0x810, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_WRITE             CTL_CODE(FILE_DEVICE_UNKNOWN, 0x820, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_READ              CTL_CODE(FILE_DEVICE_UNKNOWN, 0x840, METHOD_BUFFERED, FILE_ANY_ACCESS)
+#define IOCTL_GET_HARDWARE_ID   CTL_CODE(FILE_DEVICE_UNKNOWN, 0x880, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+typedef struct _KEYBOARD_INPUT_DATA {
+	USHORT UnitId;
+	USHORT MakeCode;
+	USHORT Flags;
+	USHORT Reserved;
+	ULONG  ExtraInformation;
+} KEYBOARD_INPUT_DATA, *PKEYBOARD_INPUT_DATA;
+
+typedef struct _MOUSE_INPUT_DATA {
+	USHORT UnitId;
+	USHORT Flags;
+	USHORT ButtonFlags;
+	USHORT ButtonData;
+	ULONG  RawButtons;
+	LONG   LastX;
+	LONG   LastY;
+	ULONG  ExtraInformation;
+} MOUSE_INPUT_DATA, *PMOUSE_INPUT_DATA;
+
+typedef struct {
+	VOID *handle;
+	VOID *unempty;
+} *InterceptionDeviceArray;
+
+InterceptionContext interceptionCreateContext() {
+	InterceptionDeviceArray deviceArray;
+	CHAR                    deviceName[] = "\\\\.\\interception00";
+	DWORD                   bytesReturned;
+	InterceptionDevice      t;
+
+	deviceArray = (InterceptionDeviceArray) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+	                                                  INTERCEPTION_MAX_DEVICE *
+	                                                  sizeof(*((InterceptionDeviceArray) 0)));
+	if (!deviceArray)
+		return 0;
+
+	for (t = 0; t < INTERCEPTION_MAX_DEVICE; t++) {
+		HANDLE zero_padded_handle[2] = {0};
+
+		sprintf(&deviceName[sizeof(deviceName) - 3], "%02d", t);
+
+		deviceArray[t].handle = CreateFileA(deviceName, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
+
+		if (deviceArray[t].handle == INVALID_HANDLE_VALUE)
+			continue;
+
+		deviceArray[t].unempty = CreateEvent(NULL, TRUE, FALSE, NULL);
+
+		if (!deviceArray[t].unempty) {
+			interceptionDestroyContext(deviceArray);
+			return 0;
+		}
+
+		zero_padded_handle[0] = deviceArray[t].unempty;
+
+		if (!DeviceIoControl(deviceArray[t].handle, IOCTL_SET_EVENT, zero_padded_handle, sizeof(zero_padded_handle),
+		                     NULL, 0, &bytesReturned, NULL)) {
+			interceptionDestroyContext(deviceArray);
+			return 0;
+		}
+	}
+
+	return deviceArray;
+}
+
+VOID interceptionDestroyContext(InterceptionContext context) {
+	InterceptionDeviceArray deviceArray = (InterceptionDeviceArray) context;
+	UINT                    t;
+	if (!context)
+		return;
+
+	for (t = 0; t < INTERCEPTION_MAX_DEVICE; t++) {
+		if (deviceArray[t].handle != INVALID_HANDLE_VALUE)
+			CloseHandle(deviceArray[t].handle);
+
+		if (deviceArray[t].unempty)
+			CloseHandle(deviceArray[t].unempty);
+	}
+
+	HeapFree(GetProcessHeap(), 0, context);
+}
+
+InterceptionPrecedence interceptionGetPrecedence(InterceptionContext context, InterceptionDevice device) {
+	InterceptionDeviceArray deviceArray = (InterceptionDeviceArray) context;
+	InterceptionPrecedence  precedence  = 0;
+	DWORD                   bytesReturned;
+
+	if (context && deviceArray[device - 1].handle)
+		DeviceIoControl(deviceArray[device - 1].handle, IOCTL_GET_PRECEDENCE, NULL, 0, (LPVOID) &precedence,
+		                sizeof(InterceptionPrecedence), &bytesReturned, NULL);
+
+	return precedence;
+}
+
+VOID
+interceptionSetPrecedence(InterceptionContext context, InterceptionDevice device, InterceptionPrecedence precedence) {
+	InterceptionDeviceArray deviceArray = (InterceptionDeviceArray) context;
+	DWORD                   bytesReturned;
+
+	if (context && deviceArray[device - 1].handle)
+		DeviceIoControl(deviceArray[device - 1].handle, IOCTL_SET_PRECEDENCE, (LPVOID) &precedence,
+		                sizeof(InterceptionPrecedence), NULL, 0, &bytesReturned, NULL);
+}
+
+InterceptionFilter interceptionGetFilter(InterceptionContext context, InterceptionDevice device) {
+	InterceptionDeviceArray deviceArray = (InterceptionDeviceArray) context;
+	InterceptionFilter      filter      = 0;
+	DWORD                   bytesReturned;
+
+	if (context && deviceArray[device - 1].handle)
+		DeviceIoControl(deviceArray[device - 1].handle, IOCTL_GET_FILTER, NULL, 0, (LPVOID) &filter,
+		                sizeof(InterceptionFilter), &bytesReturned, NULL);
+
+	return filter;
+}
+
+VOID interceptionSetFilter(InterceptionContext context, InterceptionPredicate interception_predicate,
+                           InterceptionFilter filter) {
+	InterceptionDeviceArray deviceArray = (InterceptionDeviceArray) context;
+	DWORD                   bytesReturned;
+	InterceptionDevice      t;
+
+	if (context) {
+		for (t = 0; t < INTERCEPTION_MAX_DEVICE; t++) {
+			if (deviceArray[t].handle && interception_predicate(t + 1))
+				DeviceIoControl(deviceArray[t].handle, IOCTL_SET_FILTER, (LPVOID) &filter, sizeof(InterceptionFilter),
+				                NULL, 0, &bytesReturned, NULL);
+		}
+	}
+}
+
+InterceptionDevice interceptionWait(InterceptionContext context) {
+	return interceptionWaitWithTimeout(context, INFINITE);
+}
+
+InterceptionDevice interceptionWaitWithTimeout(InterceptionContext context, ULONG milliseconds) {
+	InterceptionDeviceArray deviceArray = (InterceptionDeviceArray) context;
+	HANDLE                  waitHandles[INTERCEPTION_MAX_DEVICE];
+	DWORD                   index       = 0;
+	DWORD                   waitResult;
+	DWORD                   t;
+
+	if (!context)
+		return 0;
+
+	for (t = 0; t < INTERCEPTION_MAX_DEVICE; t++) {
+		if (deviceArray[t].unempty)
+			waitHandles[index++] = deviceArray[t].unempty;
+	}
+
+	waitResult = WaitForMultipleObjects(index, waitHandles, FALSE, milliseconds);
+
+	if (waitResult == WAIT_FAILED || waitResult == WAIT_TIMEOUT)
+		return 0;
+
+	index  = 0;
+	for (t = 0; t < INTERCEPTION_MAX_DEVICE; t++) {
+		if (deviceArray[t].unempty && waitResult == index++)
+			return (InterceptionDevice) t + 1;
+	}
+
+	return 0;
+}
+
+INT interceptionSend(InterceptionContext context, InterceptionDevice device, const InterceptionStroke *strokeValue,
+                     UINT strokeCount) {
+	InterceptionDeviceArray deviceArray    = (InterceptionDeviceArray) context;
+	DWORD                   strokesWritten = 0;
+	UINT                    t;
+
+	if (!context || !strokeCount || interceptionIsInvalid(device) || !deviceArray[device - 1].handle)
+		return 0;
+
+	if (interceptionIsKeyboard(device)) {
+		PKEYBOARD_INPUT_DATA rawStrokes = (PKEYBOARD_INPUT_DATA) HeapAlloc(GetProcessHeap(), 0,
+		                                                                   strokeCount * sizeof(KEYBOARD_INPUT_DATA));
+
+		if (!rawStrokes)
+			return 0;
+
+		for (t = 0; t < strokeCount; t++) {
+			InterceptionKeyStroke *key_stroke = (InterceptionKeyStroke *) strokeValue;
+
+			rawStrokes[t].UnitId           = 0;
+			rawStrokes[t].MakeCode         = key_stroke[t].code;
+			rawStrokes[t].Flags            = key_stroke[t].state;
+			rawStrokes[t].Reserved         = 0;
+			rawStrokes[t].ExtraInformation = key_stroke[t].information;
+		}
+
+		DeviceIoControl(deviceArray[device - 1].handle, IOCTL_WRITE, rawStrokes,
+		                (DWORD) strokeCount * sizeof(KEYBOARD_INPUT_DATA), NULL, 0, &strokesWritten, NULL);
+
+		HeapFree(GetProcessHeap(), 0, rawStrokes);
+
+		strokesWritten /= sizeof(KEYBOARD_INPUT_DATA);
+	} else {
+		PMOUSE_INPUT_DATA rawStrokes = (PMOUSE_INPUT_DATA) HeapAlloc(GetProcessHeap(), 0,
+		                                                             strokeCount * sizeof(MOUSE_INPUT_DATA));
+
+		if (!rawStrokes)
+			return 0;
+
+		for (t = 0; t < strokeCount; t++) {
+			InterceptionMouseStroke *mouse_stroke = (InterceptionMouseStroke *) strokeValue;
+
+			rawStrokes[t].UnitId           = 0;
+			rawStrokes[t].Flags            = mouse_stroke[t].flags;
+			rawStrokes[t].ButtonFlags      = mouse_stroke[t].state;
+			rawStrokes[t].ButtonData       = (USHORT) mouse_stroke[t].rolling;
+			rawStrokes[t].RawButtons       = 0;
+			rawStrokes[t].LastX            = mouse_stroke[t].x;
+			rawStrokes[t].LastY            = mouse_stroke[t].y;
+			rawStrokes[t].ExtraInformation = mouse_stroke[t].information;
+		}
+
+		DeviceIoControl(deviceArray[device - 1].handle, IOCTL_WRITE, rawStrokes,
+		                (DWORD) strokeCount * sizeof(MOUSE_INPUT_DATA), NULL, 0, &strokesWritten, NULL);
+
+		HeapFree(GetProcessHeap(), 0, rawStrokes);
+
+		strokesWritten /= sizeof(MOUSE_INPUT_DATA);
+	}
+
+	return (INT) strokesWritten;
+}
+
+INT interceptionReceive(InterceptionContext context, InterceptionDevice device, InterceptionStroke *strokeValue,
+                        UINT strokeCount) {
+	InterceptionDeviceArray deviceArray = (InterceptionDeviceArray) context;
+	DWORD                   strokesRead = 0;
+
+	if (!context || !strokeCount || interceptionIsInvalid(device) || !deviceArray[device - 1].handle)
+		return 0;
+
+	if (interceptionIsKeyboard(device)) {
+		PKEYBOARD_INPUT_DATA rawStrokes = (PKEYBOARD_INPUT_DATA) HeapAlloc(GetProcessHeap(), 0,
+		                                                                   strokeCount * sizeof(KEYBOARD_INPUT_DATA));
+		UINT                 t;
+
+		if (!rawStrokes)
+			return 0;
+
+		DeviceIoControl(deviceArray[device - 1].handle, IOCTL_READ, NULL, 0, rawStrokes,
+		                (DWORD) strokeCount * sizeof(KEYBOARD_INPUT_DATA), &strokesRead, NULL);
+
+		strokesRead /= sizeof(KEYBOARD_INPUT_DATA);
+
+		for (t = 0; t < (UINT) strokesRead; t++) {
+			InterceptionKeyStroke *key_stroke = (InterceptionKeyStroke *) strokeValue;
+
+			key_stroke[t].code        = rawStrokes[t].MakeCode;
+			key_stroke[t].state       = rawStrokes[t].Flags;
+			key_stroke[t].information = rawStrokes[t].ExtraInformation;
+		}
+
+		HeapFree(GetProcessHeap(), 0, rawStrokes);
+	} else {
+		PMOUSE_INPUT_DATA rawStrokes = (PMOUSE_INPUT_DATA) HeapAlloc(GetProcessHeap(), 0,
+		                                                             strokeCount * sizeof(MOUSE_INPUT_DATA));
+		UINT              t;
+
+		if (!rawStrokes)
+			return 0;
+
+		DeviceIoControl(deviceArray[device - 1].handle, IOCTL_READ, NULL, 0, rawStrokes,
+		                (DWORD) strokeCount * sizeof(MOUSE_INPUT_DATA), &strokesRead, NULL);
+
+		strokesRead /= sizeof(MOUSE_INPUT_DATA);
+
+		for (t = 0; t < (UINT) strokesRead; t++) {
+			InterceptionMouseStroke *mouse_stroke = (InterceptionMouseStroke *) strokeValue;
+
+			mouse_stroke[t].flags       = rawStrokes[t].Flags;
+			mouse_stroke[t].state       = rawStrokes[t].ButtonFlags;
+			mouse_stroke[t].rolling     = rawStrokes[t].ButtonData;
+			mouse_stroke[t].x           = rawStrokes[t].LastX;
+			mouse_stroke[t].y           = rawStrokes[t].LastY;
+			mouse_stroke[t].information = rawStrokes[t].ExtraInformation;
+		}
+
+		HeapFree(GetProcessHeap(), 0, rawStrokes);
+	}
+
+	return (INT) strokesRead;
+}
+
+UINT
+interceptionGetHardwareIdentifier(InterceptionContext context, InterceptionDevice device,
+                                  VOID *hardwareIdentifierBuffer, UINT bufferSize) {
+	InterceptionDeviceArray deviceArray = (InterceptionDeviceArray) context;
+	DWORD                   outputSize  = 0;
+
+	if (!context || interceptionIsInvalid(device) || !deviceArray[device - 1].handle)
+		return 0;
+
+	DeviceIoControl(deviceArray[device - 1].handle, IOCTL_GET_HARDWARE_ID, NULL, 0, hardwareIdentifierBuffer,
+	                bufferSize, &outputSize, NULL);
+
+	return outputSize;
+}
+
+INT interceptionIsInvalid(InterceptionDevice device) {
+	return !interceptionIsKeyboard(device) && !interceptionIsMouse(device);
+}
+
+INT interceptionIsKeyboard(InterceptionDevice device) {
+	return device >= INTERCEPTION_KEYBOARD(0) && device <= INTERCEPTION_KEYBOARD(INTERCEPTION_MAX_KEYBOARD - 1);
+}
+
+INT interceptionIsMouse(InterceptionDevice device) {
+	return device >= INTERCEPTION_MOUSE(0) && device <= INTERCEPTION_MOUSE(INTERCEPTION_MAX_MOUSE - 1);
+}

data/ext/special_input_device/_vendor__interception.h

@@ -0,0 +1,196 @@
+#ifndef _INTERCEPTION_H_
+#define _INTERCEPTION_H_
+
+#ifdef INTERCEPTION_STATIC
+# define INTERCEPTION_API
+#else
+# if defined _WIN32 || defined __CYGWIN__
+#  ifdef INTERCEPTION_EXPORT
+#   ifdef __GNUC__
+#    define INTERCEPTION_API __attribute__((dllexport))
+#   else
+#    define INTERCEPTION_API __declspec(dllexport)
+#   endif
+#  else
+#   ifdef __GNUC__
+#    define INTERCEPTION_API __attribute__((dllimport))
+#   else
+#    define INTERCEPTION_API __declspec(dllimport)
+#   endif
+#  endif
+# else
+#  if __GNUC__ >= 4
+#   define INTERCEPTION_API __attribute__ ((visibility("default")))
+#  else
+#   define INTERCEPTION_API
+#  endif
+# endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define INTERCEPTION_MAX_KEYBOARD 10
+
+#define INTERCEPTION_MAX_MOUSE 10
+
+#define INTERCEPTION_MAX_DEVICE ((INTERCEPTION_MAX_KEYBOARD) + (INTERCEPTION_MAX_MOUSE))
+
+#define INTERCEPTION_KEYBOARD(index) ((index) + 1)
+
+#define INTERCEPTION_MOUSE(index) ((INTERCEPTION_MAX_KEYBOARD) + (index) + 1)
+
+typedef VOID *InterceptionContext;
+
+typedef INT InterceptionDevice;
+
+typedef INT InterceptionPrecedence;
+
+typedef USHORT InterceptionFilter;
+
+typedef INT (*InterceptionPredicate)(InterceptionDevice device);
+
+enum InterceptionKeyState {
+	INTERCEPTION_KEY_DOWN             = 0x00,
+	INTERCEPTION_KEY_UP               = 0x01,
+	INTERCEPTION_KEY_E0               = 0x02,
+	INTERCEPTION_KEY_E1               = 0x04,
+	INTERCEPTION_KEY_TERMSRV_SET_LED  = 0x08,
+	INTERCEPTION_KEY_TERMSRV_SHADOW   = 0x10,
+	INTERCEPTION_KEY_TERMSRV_VKPACKET = 0x20
+};
+
+enum InterceptionFilterKeyState {
+	INTERCEPTION_FILTER_KEY_NONE             = 0x0000,
+	INTERCEPTION_FILTER_KEY_ALL              = 0xFFFF,
+	INTERCEPTION_FILTER_KEY_DOWN             = INTERCEPTION_KEY_UP,
+	INTERCEPTION_FILTER_KEY_UP               = INTERCEPTION_KEY_UP << 1,
+	INTERCEPTION_FILTER_KEY_E0               = INTERCEPTION_KEY_E0 << 1,
+	INTERCEPTION_FILTER_KEY_E1               = INTERCEPTION_KEY_E1 << 1,
+	INTERCEPTION_FILTER_KEY_TERMSRV_SET_LED  = INTERCEPTION_KEY_TERMSRV_SET_LED << 1,
+	INTERCEPTION_FILTER_KEY_TERMSRV_SHADOW   = INTERCEPTION_KEY_TERMSRV_SHADOW << 1,
+	INTERCEPTION_FILTER_KEY_TERMSRV_VKPACKET = INTERCEPTION_KEY_TERMSRV_VKPACKET << 1
+};
+
+enum InterceptionMouseState {
+	INTERCEPTION_MOUSE_LEFT_BUTTON_DOWN   = 0x001,
+	INTERCEPTION_MOUSE_LEFT_BUTTON_UP     = 0x002,
+	INTERCEPTION_MOUSE_RIGHT_BUTTON_DOWN  = 0x004,
+	INTERCEPTION_MOUSE_RIGHT_BUTTON_UP    = 0x008,
+	INTERCEPTION_MOUSE_MIDDLE_BUTTON_DOWN = 0x010,
+	INTERCEPTION_MOUSE_MIDDLE_BUTTON_UP   = 0x020,
+
+	INTERCEPTION_MOUSE_BUTTON_1_DOWN = INTERCEPTION_MOUSE_LEFT_BUTTON_DOWN,
+	INTERCEPTION_MOUSE_BUTTON_1_UP   = INTERCEPTION_MOUSE_LEFT_BUTTON_UP,
+	INTERCEPTION_MOUSE_BUTTON_2_DOWN = INTERCEPTION_MOUSE_RIGHT_BUTTON_DOWN,
+	INTERCEPTION_MOUSE_BUTTON_2_UP   = INTERCEPTION_MOUSE_RIGHT_BUTTON_UP,
+	INTERCEPTION_MOUSE_BUTTON_3_DOWN = INTERCEPTION_MOUSE_MIDDLE_BUTTON_DOWN,
+	INTERCEPTION_MOUSE_BUTTON_3_UP   = INTERCEPTION_MOUSE_MIDDLE_BUTTON_UP,
+
+	INTERCEPTION_MOUSE_BUTTON_4_DOWN = 0x040,
+	INTERCEPTION_MOUSE_BUTTON_4_UP   = 0x080,
+	INTERCEPTION_MOUSE_BUTTON_5_DOWN = 0x100,
+	INTERCEPTION_MOUSE_BUTTON_5_UP   = 0x200,
+
+	INTERCEPTION_MOUSE_WHEEL  = 0x400,
+	INTERCEPTION_MOUSE_HWHEEL = 0x800
+};
+
+enum InterceptionFilterMouseState {
+	INTERCEPTION_FILTER_MOUSE_NONE = 0x0000,
+	INTERCEPTION_FILTER_MOUSE_ALL  = 0xFFFF,
+
+	INTERCEPTION_FILTER_MOUSE_LEFT_BUTTON_DOWN   = INTERCEPTION_MOUSE_LEFT_BUTTON_DOWN,
+	INTERCEPTION_FILTER_MOUSE_LEFT_BUTTON_UP     = INTERCEPTION_MOUSE_LEFT_BUTTON_UP,
+	INTERCEPTION_FILTER_MOUSE_RIGHT_BUTTON_DOWN  = INTERCEPTION_MOUSE_RIGHT_BUTTON_DOWN,
+	INTERCEPTION_FILTER_MOUSE_RIGHT_BUTTON_UP    = INTERCEPTION_MOUSE_RIGHT_BUTTON_UP,
+	INTERCEPTION_FILTER_MOUSE_MIDDLE_BUTTON_DOWN = INTERCEPTION_MOUSE_MIDDLE_BUTTON_DOWN,
+	INTERCEPTION_FILTER_MOUSE_MIDDLE_BUTTON_UP   = INTERCEPTION_MOUSE_MIDDLE_BUTTON_UP,
+
+	INTERCEPTION_FILTER_MOUSE_BUTTON_1_DOWN = INTERCEPTION_MOUSE_BUTTON_1_DOWN,
+	INTERCEPTION_FILTER_MOUSE_BUTTON_1_UP   = INTERCEPTION_MOUSE_BUTTON_1_UP,
+	INTERCEPTION_FILTER_MOUSE_BUTTON_2_DOWN = INTERCEPTION_MOUSE_BUTTON_2_DOWN,
+	INTERCEPTION_FILTER_MOUSE_BUTTON_2_UP   = INTERCEPTION_MOUSE_BUTTON_2_UP,
+	INTERCEPTION_FILTER_MOUSE_BUTTON_3_DOWN = INTERCEPTION_MOUSE_BUTTON_3_DOWN,
+	INTERCEPTION_FILTER_MOUSE_BUTTON_3_UP   = INTERCEPTION_MOUSE_BUTTON_3_UP,
+
+	INTERCEPTION_FILTER_MOUSE_BUTTON_4_DOWN = INTERCEPTION_MOUSE_BUTTON_4_DOWN,
+	INTERCEPTION_FILTER_MOUSE_BUTTON_4_UP   = INTERCEPTION_MOUSE_BUTTON_4_UP,
+	INTERCEPTION_FILTER_MOUSE_BUTTON_5_DOWN = INTERCEPTION_MOUSE_BUTTON_5_DOWN,
+	INTERCEPTION_FILTER_MOUSE_BUTTON_5_UP   = INTERCEPTION_MOUSE_BUTTON_5_UP,
+
+	INTERCEPTION_FILTER_MOUSE_WHEEL  = INTERCEPTION_MOUSE_WHEEL,
+	INTERCEPTION_FILTER_MOUSE_HWHEEL = INTERCEPTION_MOUSE_HWHEEL,
+
+	INTERCEPTION_FILTER_MOUSE_MOVE = 0x1000
+};
+
+enum InterceptionMouseFlag {
+	INTERCEPTION_MOUSE_MOVE_RELATIVE      = 0x000,
+	INTERCEPTION_MOUSE_MOVE_ABSOLUTE      = 0x001,
+	INTERCEPTION_MOUSE_VIRTUAL_DESKTOP    = 0x002,
+	INTERCEPTION_MOUSE_ATTRIBUTES_CHANGED = 0x004,
+	INTERCEPTION_MOUSE_MOVE_NOCOALESCE    = 0x008,
+	INTERCEPTION_MOUSE_TERMSRV_SRC_SHADOW = 0x100
+};
+
+typedef struct {
+	USHORT state;
+	USHORT flags;
+	SHORT  rolling;
+	INT    x;
+	INT    y;
+	UINT   information;
+}           InterceptionMouseStroke;
+
+typedef struct {
+	USHORT code;
+	USHORT state;
+	UINT   information;
+}           InterceptionKeyStroke;
+
+typedef CHAR InterceptionStroke[sizeof(InterceptionMouseStroke)];
+
+InterceptionContext INTERCEPTION_API interceptionCreateContext();
+
+VOID INTERCEPTION_API interceptionDestroyContext(InterceptionContext context);
+
+InterceptionPrecedence INTERCEPTION_API
+interceptionGetPrecedence(InterceptionContext context, InterceptionDevice device);
+
+VOID INTERCEPTION_API
+interceptionSetPrecedence(InterceptionContext context, InterceptionDevice device, InterceptionPrecedence precedence);
+
+InterceptionFilter INTERCEPTION_API interceptionGetFilter(InterceptionContext context, InterceptionDevice device);
+
+VOID INTERCEPTION_API
+interceptionSetFilter(InterceptionContext context, InterceptionPredicate predicate, InterceptionFilter filter);
+
+InterceptionDevice INTERCEPTION_API interceptionWait(InterceptionContext context);
+
+InterceptionDevice INTERCEPTION_API interceptionWaitWithTimeout(InterceptionContext context, ULONG milliseconds);
+
+INT INTERCEPTION_API
+interceptionSend(InterceptionContext context, InterceptionDevice device, const InterceptionStroke *strokeValue,
+                 UINT strokeCount);
+
+INT INTERCEPTION_API
+interceptionReceive(InterceptionContext context, InterceptionDevice device, InterceptionStroke *strokeValue,
+                    UINT strokeCount);
+
+UINT INTERCEPTION_API
+interceptionGetHardwareIdentifier(InterceptionContext context, InterceptionDevice device,
+                                  VOID *hardwareIdentifierBuffer, UINT bufferSize);
+
+INT INTERCEPTION_API interceptionIsInvalid(InterceptionDevice device);
+
+INT INTERCEPTION_API interceptionIsKeyboard(InterceptionDevice device);
+
+INT INTERCEPTION_API interceptionIsMouse(InterceptionDevice device);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif