special_input_device 0.0.0

data/ext/special_input_device/color.c

@@ -0,0 +1,25 @@
+#include "special_input_device.h"
+#include "color.h"
+
+VALUE ruby___color_new(INT cRed, INT cGreen, INT cBlue) {
+	VALUE newColorArguments[3];
+	newColorArguments[0] = INT2NUM(cRed);
+	newColorArguments[1] = INT2NUM(cGreen);
+	newColorArguments[2] = INT2NUM(cBlue);
+	return rb_class_new_instance(3, newColorArguments, specialInputDevice_color);
+}
+
+VALUE ruby___color_new_from_color_ref(COLORREF cColor) {
+	VALUE newColorArguments[3];
+	newColorArguments[0] = INT2NUM(GetRValue(cColor));
+	newColorArguments[1] = INT2NUM(GetGValue(cColor));
+	newColorArguments[2] = INT2NUM(GetBValue(cColor));
+	return rb_class_new_instance(3, newColorArguments, specialInputDevice_color);
+}
+
+COLORREF ruby___color_to_color_ref(VALUE color) {
+	BYTE cRed   = (BYTE) FIX2UINT(rb_iv_get(color, "@red"));
+	BYTE cGreen = (BYTE) FIX2UINT(rb_iv_get(color, "@green"));
+	BYTE cBlue  = (BYTE) FIX2UINT(rb_iv_get(color, "@blue"));
+	return RGB(cRed, cGreen, cBlue);
+}

data/ext/special_input_device/color.h

@@ -0,0 +1,10 @@
+#ifndef SPECIAL_INPUT_DEVICE_COLOR_H
+#define SPECIAL_INPUT_DEVICE_COLOR_H
+
+VALUE ruby___color_new(INT cRed, INT cGreen, INT cBlue);
+
+VALUE ruby___color_new_from_color_ref(COLORREF cColor);
+
+COLORREF ruby___color_to_color_ref(VALUE color);
+
+#endif //SPECIAL_INPUT_DEVICE_COLOR_H

data/ext/special_input_device/extconf.rb

@@ -0,0 +1,6 @@
+require('mkmf')
+abort('only for windows.') unless have_header('windows.h')
+abort('gdi32.lib not found.') unless have_library('gdi32')
+$defs.push('-DINTERCEPTION_STATIC')
+$defs.push('-DUNICODE')
+create_makefile('special_input_device')

data/ext/special_input_device/interception_connector.c

@@ -0,0 +1,75 @@
+#include "special_input_device.h"
+#include "_vendor__interception.h"
+
+#define MAXIMUM_HARDWARE_IDENTIFIER_LENGTH 512
+
+typedef struct {
+	InterceptionContext context;
+	InterceptionDevice  keyboard;
+	InterceptionDevice  mouse;
+} SID_INTERCEPTION_DATA;
+
+static SID_INTERCEPTION_DATA *cData;
+
+inline InterceptionContext ruby___interception_get_context() {
+	return cData->context;
+}
+
+InterceptionDevice ruby___interception_find_keyboard() {
+	TCHAR cHardwareIdentifier[MAXIMUM_HARDWARE_IDENTIFIER_LENGTH];
+	if (interceptionGetHardwareIdentifier(cData->context, cData->keyboard, cHardwareIdentifier,
+                                          MAXIMUM_HARDWARE_IDENTIFIER_LENGTH))
+		return cData->keyboard;
+	for (cData->keyboard = INTERCEPTION_KEYBOARD(0);
+	     cData->keyboard < INTERCEPTION_KEYBOARD(INTERCEPTION_MAX_KEYBOARD); cData->keyboard++) {
+		if (interceptionGetHardwareIdentifier(cData->context, cData->keyboard, cHardwareIdentifier,
+                                              MAXIMUM_HARDWARE_IDENTIFIER_LENGTH))
+			return cData->keyboard;
+	}
+	rb_raise(rb_eRuntimeError, "Can not find any keyboard connected.");
+}
+
+InterceptionDevice ruby___interception_find_mouse() {
+	TCHAR cHardwareIdentifier[MAXIMUM_HARDWARE_IDENTIFIER_LENGTH];
+	if (interceptionGetHardwareIdentifier(cData->context, cData->mouse, cHardwareIdentifier,
+                                          MAXIMUM_HARDWARE_IDENTIFIER_LENGTH))
+		return cData->mouse;
+	for (cData->mouse = INTERCEPTION_MOUSE(0);
+	     cData->mouse < INTERCEPTION_MOUSE(INTERCEPTION_MAX_MOUSE); cData->mouse++) {
+		if (interceptionGetHardwareIdentifier(cData->context, cData->mouse, cHardwareIdentifier,
+                                              MAXIMUM_HARDWARE_IDENTIFIER_LENGTH))
+			return cData->mouse;
+	}
+	rb_raise(rb_eRuntimeError, "Can not find any mouse connected.");
+}
+
+static VOID callback_interception_free(SID_INTERCEPTION_DATA *cData) {
+	interceptionDestroyContext(cData->context);
+	free(cData);
+}
+
+static VALUE ruby__alloc(VALUE self) {
+	VALUE instance = Data_Make_Struct(self, SID_INTERCEPTION_DATA, NULL, callback_interception_free, cData);
+	cData->context = interceptionCreateContext();
+	return instance;
+}
+
+VOID Init_interception() {
+#ifdef YARD
+	specialInputDevice = rb_define_module("SpecialInputDevice");
+#endif
+	VALUE singleton;
+	/*
+	 * Document-module: SpecialInputDevice::Interception
+	 *
+	 * The <code>Interception</code> module contain some important data about interception library. Do not touch this
+	 * module.
+	 */
+	VALUE specialInputDevice_interception = rb_define_class_under(specialInputDevice, "Interception", rb_cData);
+	rb_define_alloc_func(specialInputDevice_interception, (rb_alloc_func_t) ruby__alloc);
+
+	rb_require("singleton");
+	singleton = RUBY_MODULE_CONST_GET(rb_mKernel, rb_intern_const("Singleton"));
+	rb_funcall(singleton, rb_intern_const("included"), 1, specialInputDevice_interception);
+	rb_funcall(specialInputDevice_interception, rb_intern_const("instance"), 0);
+}

data/ext/special_input_device/interception_connector.h

@@ -0,0 +1,13 @@
+#include <windows.h>
+#include "_vendor__interception.h"
+
+#ifndef SPECIAL_INPUT_DEVICE_INTERCEPTION_H
+#define SPECIAL_INPUT_DEVICE_INTERCEPTION_H
+
+InterceptionContext ruby___interception_get_context();
+
+InterceptionDevice ruby___interception_find_keyboard();
+
+InterceptionDevice ruby___interception_find_mouse();
+
+#endif //SPECIAL_INPUT_DEVICE_INTERCEPTION_H

data/ext/special_input_device/keyboard.c

@@ -0,0 +1,152 @@
+#include "special_input_device.h"
+#include "interception_connector.h"
+
+/*
+ * @overload hold(key_code)
+ *   Simulate holding the specified key down.
+ *   @param [Integer] key_code virtual key code. Use a value of constant in {SpecialInputDevice::KeyCode}.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#key_hold
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__hold(VALUE self, VALUE keyCode) {
+	WORD cKeyCode  = NUM2USHORT(keyCode);
+	UINT cScanCode = MapVirtualKeyA(cKeyCode, MAPVK_VK_TO_VSC);
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext   cContext = ruby___interception_get_context();
+			InterceptionDevice    cDevice  = ruby___interception_find_keyboard();
+			InterceptionKeyStroke cStroke;
+			cStroke.code        = (USHORT) cScanCode;
+			cStroke.information = 0;
+			cStroke.state       = INTERCEPTION_KEY_DOWN;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) &cStroke, 1);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT cInput;
+			cInput.type           = INPUT_KEYBOARD;
+			cInput.ki.dwExtraInfo = (ULONG_PTR) GetMessageExtraInfo();
+			cInput.ki.dwFlags     = 0;
+			cInput.ki.time        = 0;
+			cInput.ki.wScan       = (WORD) cScanCode;
+			cInput.ki.wVk         = cKeyCode;
+			if (SendInput(1, &cInput, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+/*
+ * @overload press(key_code)
+ *   Simulate pressing the specified key.
+ *   @param [Integer] key_code virtual key code. Use a value of constant in {SpecialInputDevice::KeyCode}.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#key_press
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__press(VALUE self, VALUE keyCode) {
+	WORD cKeyCode  = NUM2USHORT(keyCode);
+	UINT cScanCode = MapVirtualKeyA(cKeyCode, MAPVK_VK_TO_VSC);
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext   cContext = ruby___interception_get_context();
+			InterceptionDevice    cDevice  = ruby___interception_find_keyboard();
+			InterceptionKeyStroke cStroke[2];
+			cStroke[0].code        = (USHORT) cScanCode;
+			cStroke[0].information = 0;
+			cStroke[0].state       = INTERCEPTION_KEY_DOWN;
+			cStroke[1].code        = (USHORT) cScanCode;
+			cStroke[1].information = 0;
+			cStroke[1].state       = INTERCEPTION_KEY_UP;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) cStroke, 2);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT cInput[2];
+			cInput[0].type           = INPUT_KEYBOARD;
+			cInput[0].ki.dwExtraInfo = (ULONG_PTR) GetMessageExtraInfo();
+			cInput[0].ki.dwFlags     = 0;
+			cInput[0].ki.time        = 0;
+			cInput[0].ki.wScan       = (WORD) cScanCode;
+			cInput[0].ki.wVk         = cKeyCode;
+			cInput[1].type           = INPUT_KEYBOARD;
+			cInput[1].ki.dwExtraInfo = (ULONG_PTR) GetMessageExtraInfo();
+			cInput[1].ki.dwFlags     = KEYEVENTF_KEYUP;
+			cInput[1].ki.time        = 0;
+			cInput[1].ki.wScan       = (WORD) cScanCode;
+			cInput[1].ki.wVk         = cKeyCode;
+			if (SendInput(2, cInput, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+/*
+ * @overload release(key_code)
+ *   Simulate releasing the specified key.
+ *   @param [Integer] key_code virtual key code. Use a value of constant in {SpecialInputDevice::KeyCode}.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#key_release
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__release(VALUE self, VALUE keyCode) {
+	WORD cKeyCode  = NUM2USHORT(keyCode);
+	UINT cScanCode = MapVirtualKeyA(cKeyCode, MAPVK_VK_TO_VSC);
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext   cContext = ruby___interception_get_context();
+			InterceptionDevice    cDevice  = ruby___interception_find_keyboard();
+			InterceptionKeyStroke cStroke;
+			cStroke.code        = (USHORT) cScanCode;
+			cStroke.information = 0;
+			cStroke.state       = INTERCEPTION_KEY_UP;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) &cStroke, 2);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT cInput;
+			cInput.type           = INPUT_KEYBOARD;
+			cInput.ki.dwExtraInfo = (ULONG_PTR) GetMessageExtraInfo();
+			cInput.ki.dwFlags     = KEYEVENTF_KEYUP;
+			cInput.ki.time        = 0;
+			cInput.ki.wScan       = (WORD) cScanCode;
+			cInput.ki.wVk         = cKeyCode;
+			if (SendInput(1, &cInput, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+VOID Init_keyboard() {
+#ifdef YARD
+	specialInputDevice = rb_define_module("SpecialInputDevice");
+#endif
+	/*
+	 * Document-module: SpecialInputDevice::Keyboard
+	 *
+	 * The <code>Keyboard</code> module provides an interface to simulate the signal form keyboard.
+	 */
+	VALUE specialInputDevice_keyboard = rb_define_module_under(specialInputDevice, "Keyboard");
+	rb_define_singleton_method(specialInputDevice_keyboard, "hold", ruby__hold, 1);
+	rb_define_singleton_method(specialInputDevice_keyboard, "press", ruby__press, 1);
+	rb_define_singleton_method(specialInputDevice_keyboard, "release", ruby__release, 1);
+}

data/ext/special_input_device/mouse.c

@@ -0,0 +1,1137 @@
+#include "special_input_device.h"
+#include "_screen.h"
+#include "interception_connector.h"
+#include "point.h"
+
+//<editor-fold desc="cursor">
+
+/*
+ * Lock the mouse.
+ * @return [Module] self
+ */
+static VALUE ruby__lock(VALUE self) {
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext cContext = ruby___interception_get_context();
+			interceptionSetFilter(cContext, interceptionIsMouse, INTERCEPTION_FILTER_MOUSE_ALL);
+			break;
+		}
+		case MODE_WIN_API: {
+			rb_raise(rb_eRuntimeError, "WinAPI mode does not support lock mouse function.");
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+/*
+ * Unlock the mouse.
+ * @return [Module] self
+ */
+static VALUE ruby__unlock(VALUE self) {
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext cContext = ruby___interception_get_context();
+			interceptionSetFilter(cContext, interceptionIsMouse, INTERCEPTION_FILTER_MOUSE_NONE);
+			break;
+		}
+		case MODE_WIN_API: {
+			rb_raise(rb_eRuntimeError, "WinAPI mode does not support lock mouse function.");
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+/*
+ * @return [SpecialInputDevice::Point] the point of cursor position
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__cursor_position(VALUE self) {
+	POINT cPoint;
+	if (!GetCursorPos(&cPoint))
+		RAISE_WIN32_ERROR;
+	return ruby___point_new_from_point(&cPoint);
+}
+
+/*
+ * @overload move_relatively(x, y)
+ *   Move the cursor position relative to current position.
+ *   @param [Integer] x the amount of horizontal motion specified as the number of pixels.
+ *   @param [Integer] y the amount of vertical motion specified as the number of pixels.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_move_relatively
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__move_relatively(VALUE self, VALUE x, VALUE y) {
+	LONG cX = NUM2LONG(x);
+	LONG cY = NUM2LONG(y);
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke;
+			cStroke.flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke.information = 0;
+			cStroke.rolling     = 0;
+			cStroke.state       = 0;
+			cStroke.x           = cX;
+			cStroke.y           = cY;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) &cStroke, 1);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input;
+			input.type           = INPUT_MOUSE;
+			input.mi.dwExtraInfo = 0;
+			input.mi.dwFlags     = MOUSEEVENTF_MOVE;
+			input.mi.dx          = cX;
+			input.mi.dy          = cY;
+			input.mi.mouseData   = 0;
+			input.mi.time        = 0;
+			if (SendInput(1, &input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+/*
+ * @overload move_to_primary(x, y)
+ *   Move the cursor position relative to the upper-left corner of primary screen.
+ *   @param [Integer] x the x-coordinate of position specified as the number of pixels.
+ *   @param [Integer] y the y-coordinate of position specified as the number of pixels.
+ * @return [Module] self
+ * @see SpecialInputDevice::Mouse.move_to_virtual
+ * @see SpecialInputDevice::Screen.primary_screen
+ * @see SpecialInputDevice::Window#mouse_move_to
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__move_to_primary(VALUE self, VALUE x, VALUE y) {
+	LONG cX = NUM2LONG(x) * 0xFFFF / getPrimaryScreenWidth();
+	LONG cY = NUM2LONG(y) * 0xFFFF / getPrimaryScreenHeight();
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke;
+			cStroke.flags       = INTERCEPTION_MOUSE_MOVE_ABSOLUTE;
+			cStroke.information = 0;
+			cStroke.rolling     = 0;
+			cStroke.state       = 0;
+			cStroke.x           = cX;
+			cStroke.y           = cY;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) &cStroke, 1);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input;
+			input.type           = INPUT_MOUSE;
+			input.mi.dwExtraInfo = 0;
+			input.mi.dwFlags     = MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE;
+			input.mi.dx          = cX;
+			input.mi.dy          = cY;
+			input.mi.mouseData   = 0;
+			input.mi.time        = 0;
+			if (SendInput(1, &input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+/*
+ * @overload move_to_virtual(x, y)
+ *   Move the cursor position relative to the upper-left corner of virtual screen. If the position of virtual screen is
+ *   inaccessible, the cursor will move to the closest point to the specified position.
+ *   @param [Integer] x the x-coordinate of position specified as the number of pixels.
+ *   @param [Integer] y the y-coordinate of position specified as the number of pixels.
+ * @return [Module] self
+ * @see SpecialInputDevice::Mouse.move_to_primary
+ * @see SpecialInputDevice::Screen.virtual_screen
+ * @see SpecialInputDevice::Window#mouse_move_to
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__move_to_virtual(VALUE self, VALUE x, VALUE y) {
+	LONG cX = NUM2LONG(x) * 0xFFFF / getVirtualScreenWidth();
+	LONG cY = NUM2LONG(y) * 0xFFFF / getVirtualScreenHeight();
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke;
+			cStroke.flags       = INTERCEPTION_MOUSE_MOVE_ABSOLUTE | INTERCEPTION_MOUSE_VIRTUAL_DESKTOP;
+			cStroke.information = 0;
+			cStroke.rolling     = 0;
+			cStroke.state       = 0;
+			cStroke.x           = cX;
+			cStroke.y           = cY;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) &cStroke, 1);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input;
+			input.type           = INPUT_MOUSE;
+			input.mi.dwExtraInfo = 0;
+			input.mi.dwFlags     = MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_VIRTUALDESK | MOUSEEVENTF_MOVE;
+			input.mi.dx          = cX;
+			input.mi.dy          = cY;
+			input.mi.mouseData   = 0;
+			input.mi.time        = 0;
+			if (SendInput(1, &input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+//</editor-fold>
+
+//<editor-fold desc="left_button">
+
+/*
+ * Simulate clicking the left button on the mouse.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_left_click
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__left_click(VALUE self) {
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke[2];
+			cStroke[0].flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke[0].information = 0;
+			cStroke[0].rolling     = 0;
+			cStroke[0].state       = INTERCEPTION_MOUSE_LEFT_BUTTON_DOWN;
+			cStroke[0].x           = 0;
+			cStroke[0].y           = 0;
+			cStroke[1].flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke[1].information = 0;
+			cStroke[1].rolling     = 0;
+			cStroke[1].state       = INTERCEPTION_MOUSE_LEFT_BUTTON_UP;
+			cStroke[1].x           = 0;
+			cStroke[1].y           = 0;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) cStroke, 2);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input[2];
+			input[0].type           = INPUT_MOUSE;
+			input[0].mi.dwExtraInfo = 0;
+			input[0].mi.dwFlags     = MOUSEEVENTF_LEFTDOWN;
+			input[0].mi.dx          = 0;
+			input[0].mi.dy          = 0;
+			input[0].mi.mouseData   = 0;
+			input[0].mi.time        = 0;
+			input[1].type           = INPUT_MOUSE;
+			input[1].mi.dwExtraInfo = 0;
+			input[1].mi.dwFlags     = MOUSEEVENTF_LEFTUP;
+			input[1].mi.dx          = 0;
+			input[1].mi.dy          = 0;
+			input[1].mi.mouseData   = 0;
+			input[1].mi.time        = 0;
+			if (SendInput(2, input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+/*
+ * Simulate holding the left button on the mouse down.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_left_down
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__left_down(VALUE self) {
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke;
+			cStroke.flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke.information = 0;
+			cStroke.rolling     = 0;
+			cStroke.state       = INTERCEPTION_MOUSE_LEFT_BUTTON_DOWN;
+			cStroke.x           = 0;
+			cStroke.y           = 0;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) &cStroke, 1);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input;
+			input.type           = INPUT_MOUSE;
+			input.mi.dwExtraInfo = 0;
+			input.mi.dwFlags     = MOUSEEVENTF_LEFTDOWN;
+			input.mi.dx          = 0;
+			input.mi.dy          = 0;
+			input.mi.mouseData   = 0;
+			input.mi.time        = 0;
+			if (SendInput(1, &input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+/*
+ * Simulate releasing the left button on the mouse.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_left_up
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__left_up(VALUE self) {
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke;
+			cStroke.flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke.information = 0;
+			cStroke.rolling     = 0;
+			cStroke.state       = INTERCEPTION_MOUSE_LEFT_BUTTON_UP;
+			cStroke.x           = 0;
+			cStroke.y           = 0;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) &cStroke, 1);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input;
+			input.type           = INPUT_MOUSE;
+			input.mi.dwExtraInfo = 0;
+			input.mi.dwFlags     = MOUSEEVENTF_LEFTUP;
+			input.mi.dx          = 0;
+			input.mi.dy          = 0;
+			input.mi.mouseData   = 0;
+			input.mi.time        = 0;
+			if (SendInput(1, &input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+//</editor-fold>
+
+//<editor-fold desc="right_button">
+
+/*
+ * Simulate clicking the right button on the mouse.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_right_click
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__right_click(VALUE self) {
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke[2];
+			cStroke[0].flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke[0].information = 0;
+			cStroke[0].rolling     = 0;
+			cStroke[0].state       = INTERCEPTION_MOUSE_RIGHT_BUTTON_DOWN;
+			cStroke[0].x           = 0;
+			cStroke[0].y           = 0;
+			cStroke[1].flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke[1].information = 0;
+			cStroke[1].rolling     = 0;
+			cStroke[1].state       = INTERCEPTION_MOUSE_RIGHT_BUTTON_UP;
+			cStroke[1].x           = 0;
+			cStroke[1].y           = 0;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) cStroke, 2);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input[2];
+			input[0].type           = INPUT_MOUSE;
+			input[0].mi.dwExtraInfo = 0;
+			input[0].mi.dwFlags     = MOUSEEVENTF_RIGHTDOWN;
+			input[0].mi.dx          = 0;
+			input[0].mi.dy          = 0;
+			input[0].mi.mouseData   = 0;
+			input[0].mi.time        = 0;
+			input[1].type           = INPUT_MOUSE;
+			input[1].mi.dwExtraInfo = 0;
+			input[1].mi.dwFlags     = MOUSEEVENTF_RIGHTUP;
+			input[1].mi.dx          = 0;
+			input[1].mi.dy          = 0;
+			input[1].mi.mouseData   = 0;
+			input[1].mi.time        = 0;
+			if (SendInput(2, input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+/*
+ * Simulate holding the right button on the mouse down.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_right_down
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__right_down(VALUE self) {
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke;
+			cStroke.flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke.information = 0;
+			cStroke.rolling     = 0;
+			cStroke.state       = INTERCEPTION_MOUSE_RIGHT_BUTTON_DOWN;
+			cStroke.x           = 0;
+			cStroke.y           = 0;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) &cStroke, 1);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input;
+			input.type           = INPUT_MOUSE;
+			input.mi.dwExtraInfo = 0;
+			input.mi.dwFlags     = MOUSEEVENTF_RIGHTDOWN;
+			input.mi.dx          = 0;
+			input.mi.dy          = 0;
+			input.mi.mouseData   = 0;
+			input.mi.time        = 0;
+			if (SendInput(1, &input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+/*
+ * Simulate releasing the right button on the mouse.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_right_up
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__right_up(VALUE self) {
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke;
+			cStroke.flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke.information = 0;
+			cStroke.rolling     = 0;
+			cStroke.state       = INTERCEPTION_MOUSE_RIGHT_BUTTON_UP;
+			cStroke.x           = 0;
+			cStroke.y           = 0;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) &cStroke, 1);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input;
+			input.type           = INPUT_MOUSE;
+			input.mi.dwExtraInfo = 0;
+			input.mi.dwFlags     = MOUSEEVENTF_RIGHTUP;
+			input.mi.dx          = 0;
+			input.mi.dy          = 0;
+			input.mi.mouseData   = 0;
+			input.mi.time        = 0;
+			if (SendInput(1, &input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+//</editor-fold>
+
+//<editor-fold desc="middle_button">
+
+/*
+ * Simulate clicking the middle button on the mouse.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_middle_click
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__middle_click(VALUE self) {
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke[2];
+			cStroke[0].flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke[0].information = 0;
+			cStroke[0].rolling     = 0;
+			cStroke[0].state       = INTERCEPTION_MOUSE_MIDDLE_BUTTON_DOWN;
+			cStroke[0].x           = 0;
+			cStroke[0].y           = 0;
+			cStroke[1].flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke[1].information = 0;
+			cStroke[1].rolling     = 0;
+			cStroke[1].state       = INTERCEPTION_MOUSE_MIDDLE_BUTTON_UP;
+			cStroke[1].x           = 0;
+			cStroke[1].y           = 0;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) cStroke, 2);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input[2];
+			input[0].type           = INPUT_MOUSE;
+			input[0].mi.dwExtraInfo = 0;
+			input[0].mi.dwFlags     = MOUSEEVENTF_MIDDLEDOWN;
+			input[0].mi.dx          = 0;
+			input[0].mi.dy          = 0;
+			input[0].mi.mouseData   = 0;
+			input[0].mi.time        = 0;
+			input[1].type           = INPUT_MOUSE;
+			input[1].mi.dwExtraInfo = 0;
+			input[1].mi.dwFlags     = MOUSEEVENTF_MIDDLEUP;
+			input[1].mi.dx          = 0;
+			input[1].mi.dy          = 0;
+			input[1].mi.mouseData   = 0;
+			input[1].mi.time        = 0;
+			if (SendInput(2, input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+/*
+ * Simulate holding the middle button on the mouse down.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_middle_down
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__middle_down(VALUE self) {
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke;
+			cStroke.flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke.information = 0;
+			cStroke.rolling     = 0;
+			cStroke.state       = INTERCEPTION_MOUSE_MIDDLE_BUTTON_DOWN;
+			cStroke.x           = 0;
+			cStroke.y           = 0;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) &cStroke, 1);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input;
+			input.type           = INPUT_MOUSE;
+			input.mi.dwExtraInfo = 0;
+			input.mi.dwFlags     = MOUSEEVENTF_MIDDLEDOWN;
+			input.mi.dx          = 0;
+			input.mi.dy          = 0;
+			input.mi.mouseData   = 0;
+			input.mi.time        = 0;
+			if (SendInput(1, &input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+/*
+ * Simulate releasing the middle button on the mouse.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_middle_up
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__middle_up(VALUE self) {
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke;
+			cStroke.flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke.information = 0;
+			cStroke.rolling     = 0;
+			cStroke.state       = INTERCEPTION_MOUSE_MIDDLE_BUTTON_UP;
+			cStroke.x           = 0;
+			cStroke.y           = 0;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) &cStroke, 1);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input;
+			input.type           = INPUT_MOUSE;
+			input.mi.dwExtraInfo = 0;
+			input.mi.dwFlags     = MOUSEEVENTF_MIDDLEUP;
+			input.mi.dx          = 0;
+			input.mi.dy          = 0;
+			input.mi.mouseData   = 0;
+			input.mi.time        = 0;
+			if (SendInput(1, &input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+//</editor-fold>
+
+//<editor-fold desc="x_button">
+
+/*
+ * Simulate clicking the x1 button on the mouse.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_x1_click
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__x1_click(VALUE self) {
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke[2];
+			cStroke[0].flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke[0].information = 0;
+			cStroke[0].rolling     = 0;
+			cStroke[0].state       = INTERCEPTION_MOUSE_BUTTON_4_DOWN;
+			cStroke[0].x           = 0;
+			cStroke[0].y           = 0;
+			cStroke[1].flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke[1].information = 0;
+			cStroke[1].rolling     = 0;
+			cStroke[1].state       = INTERCEPTION_MOUSE_BUTTON_4_UP;
+			cStroke[1].x           = 0;
+			cStroke[1].y           = 0;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) cStroke, 2);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input[2];
+			input[0].type           = INPUT_MOUSE;
+			input[0].mi.dwExtraInfo = 0;
+			input[0].mi.dwFlags     = MOUSEEVENTF_XDOWN;
+			input[0].mi.dx          = 0;
+			input[0].mi.dy          = 0;
+			input[0].mi.mouseData   = XBUTTON1;
+			input[0].mi.time        = 0;
+			input[1].type           = INPUT_MOUSE;
+			input[1].mi.dwExtraInfo = 0;
+			input[1].mi.dwFlags     = MOUSEEVENTF_XUP;
+			input[1].mi.dx          = 0;
+			input[1].mi.dy          = 0;
+			input[1].mi.mouseData   = XBUTTON1;
+			input[1].mi.time        = 0;
+			if (SendInput(2, input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+/*
+ * Simulate holding the x1 button on the mouse down.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_x1_down
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__x1_down(VALUE self) {
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke;
+			cStroke.flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke.information = 0;
+			cStroke.rolling     = 0;
+			cStroke.state       = INTERCEPTION_MOUSE_BUTTON_4_DOWN;
+			cStroke.x           = 0;
+			cStroke.y           = 0;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) &cStroke, 1);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input;
+			input.type           = INPUT_MOUSE;
+			input.mi.dwExtraInfo = 0;
+			input.mi.dwFlags     = MOUSEEVENTF_XDOWN;
+			input.mi.dx          = 0;
+			input.mi.dy          = 0;
+			input.mi.mouseData   = XBUTTON1;
+			input.mi.time        = 0;
+			if (SendInput(1, &input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+/*
+ * Simulate releasing the x1 button on the mouse.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_x1_up
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__x1_up(VALUE self) {
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke;
+			cStroke.flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke.information = 0;
+			cStroke.rolling     = 0;
+			cStroke.state       = INTERCEPTION_MOUSE_BUTTON_4_UP;
+			cStroke.x           = 0;
+			cStroke.y           = 0;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) &cStroke, 1);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input;
+			input.type           = INPUT_MOUSE;
+			input.mi.dwExtraInfo = 0;
+			input.mi.dwFlags     = MOUSEEVENTF_XUP;
+			input.mi.dx          = 0;
+			input.mi.dy          = 0;
+			input.mi.mouseData   = XBUTTON1;
+			input.mi.time        = 0;
+			if (SendInput(1, &input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+/*
+ * Simulate clicking the x2 button on the mouse.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_x2_click
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__x2_click(VALUE self) {
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke[2];
+			cStroke[0].flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke[0].information = 0;
+			cStroke[0].rolling     = 0;
+			cStroke[0].state       = INTERCEPTION_MOUSE_BUTTON_5_DOWN;
+			cStroke[0].x           = 0;
+			cStroke[0].y           = 0;
+			cStroke[1].flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke[1].information = 0;
+			cStroke[1].rolling     = 0;
+			cStroke[1].state       = INTERCEPTION_MOUSE_BUTTON_5_UP;
+			cStroke[1].x           = 0;
+			cStroke[1].y           = 0;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) cStroke, 2);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input[2];
+			input[0].type           = INPUT_MOUSE;
+			input[0].mi.dwExtraInfo = 0;
+			input[0].mi.dwFlags     = MOUSEEVENTF_XDOWN;
+			input[0].mi.dx          = 0;
+			input[0].mi.dy          = 0;
+			input[0].mi.mouseData   = XBUTTON2;
+			input[0].mi.time        = 0;
+			input[1].type           = INPUT_MOUSE;
+			input[1].mi.dwExtraInfo = 0;
+			input[1].mi.dwFlags     = MOUSEEVENTF_XUP;
+			input[1].mi.dx          = 0;
+			input[1].mi.dy          = 0;
+			input[1].mi.mouseData   = XBUTTON2;
+			input[1].mi.time        = 0;
+			if (SendInput(2, input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+/*
+ * Simulate holding the x2 button on the mouse down.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_x2_down
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__x2_down(VALUE self) {
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke;
+			cStroke.flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke.information = 0;
+			cStroke.rolling     = 0;
+			cStroke.state       = INTERCEPTION_MOUSE_BUTTON_5_DOWN;
+			cStroke.x           = 0;
+			cStroke.y           = 0;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) &cStroke, 1);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input;
+			input.type           = INPUT_MOUSE;
+			input.mi.dwExtraInfo = 0;
+			input.mi.dwFlags     = MOUSEEVENTF_XDOWN;
+			input.mi.dx          = 0;
+			input.mi.dy          = 0;
+			input.mi.mouseData   = XBUTTON2;
+			input.mi.time        = 0;
+			if (SendInput(1, &input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+/*
+ * Simulate releasing the x2 button on the mouse.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_x2_up
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__x2_up(VALUE self) {
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke;
+			cStroke.flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke.information = 0;
+			cStroke.rolling     = 0;
+			cStroke.state       = INTERCEPTION_MOUSE_BUTTON_5_UP;
+			cStroke.x           = 0;
+			cStroke.y           = 0;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) &cStroke, 1);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input;
+			input.type           = INPUT_MOUSE;
+			input.mi.dwExtraInfo = 0;
+			input.mi.dwFlags     = MOUSEEVENTF_XUP;
+			input.mi.dx          = 0;
+			input.mi.dy          = 0;
+			input.mi.mouseData   = XBUTTON2;
+			input.mi.time        = 0;
+			if (SendInput(1, &input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+//</editor-fold>
+
+//<editor-fold desc="wheel">
+
+/*
+ * Simulate wheeling the scroll backward.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_scroll_wheel_backward
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__scroll_wheel_backward(VALUE self) {
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke;
+			cStroke.flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke.information = 0;
+			cStroke.rolling     = -WHEEL_DELTA;
+			cStroke.state       = INTERCEPTION_MOUSE_WHEEL;
+			cStroke.x           = 0;
+			cStroke.y           = 0;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) &cStroke, 1);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input;
+			input.type           = INPUT_MOUSE;
+			input.mi.dwExtraInfo = 0;
+			input.mi.dwFlags     = MOUSEEVENTF_WHEEL;
+			input.mi.dx          = 0;
+			input.mi.dy          = 0;
+			input.mi.mouseData   = (DWORD) -WHEEL_DELTA;
+			input.mi.time        = 0;
+			if (SendInput(1, &input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+/*
+ * Simulate wheeling the scroll forward.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_scroll_wheel_forward
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__scroll_wheel_forward(VALUE self) {
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke;
+			cStroke.flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke.information = 0;
+			cStroke.rolling     = WHEEL_DELTA;
+			cStroke.state       = INTERCEPTION_MOUSE_WHEEL;
+			cStroke.x           = 0;
+			cStroke.y           = 0;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) &cStroke, 1);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input;
+			input.type           = INPUT_MOUSE;
+			input.mi.dwExtraInfo = 0;
+			input.mi.dwFlags     = MOUSEEVENTF_WHEEL;
+			input.mi.dx          = 0;
+			input.mi.dy          = 0;
+			input.mi.mouseData   = WHEEL_DELTA;
+			input.mi.time        = 0;
+			if (SendInput(1, &input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+}
+
+/*
+ * Simulate wheeling the scroll to left hand side.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_scroll_wheel_to_left
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__scroll_wheel_to_left(VALUE self) {
+#ifdef MOUSEEVENTF_HWHEEL
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke;
+			cStroke.flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke.information = 0;
+			cStroke.rolling     = -WHEEL_DELTA;
+			cStroke.state       = INTERCEPTION_MOUSE_HWHEEL;
+			cStroke.x           = 0;
+			cStroke.y           = 0;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) &cStroke, 1);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input;
+			input.type = INPUT_MOUSE;
+			input.mi.dwExtraInfo = 0;
+			input.mi.dwFlags = MOUSEEVENTF_HWHEEL;
+			input.mi.dx = 0;
+			input.mi.dy = 0;
+			input.mi.mouseData = (DWORD) -WHEEL_DELTA;
+			input.mi.time = 0;
+			if (SendInput(1, &input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+#else
+	rb_raise(rb_eRuntimeError, "Error! Your system not support horizontal wheel.");
+#endif
+}
+
+/*
+ * Simulate wheeling the scroll to right hand side.
+ * @return [Module] self
+ * @see SpecialInputDevice::Window#mouse_scroll_wheel_to_right
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646310.aspx Windows Dev Center - SendInput function
+ */
+static VALUE ruby__scroll_wheel_to_right(VALUE self) {
+#ifdef MOUSEEVENTF_HWHEEL
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION: {
+			InterceptionContext     cContext = ruby___interception_get_context();
+			InterceptionDevice      cDevice  = ruby___interception_find_mouse();
+			InterceptionMouseStroke cStroke;
+			cStroke.flags       = INTERCEPTION_MOUSE_MOVE_RELATIVE;
+			cStroke.information = 0;
+			cStroke.rolling     = WHEEL_DELTA;
+			cStroke.state       = INTERCEPTION_MOUSE_HWHEEL;
+			cStroke.x           = 0;
+			cStroke.y           = 0;
+			interceptionSend(cContext, cDevice, (InterceptionStroke const *) &cStroke, 1);
+			break;
+		}
+		case MODE_WIN_API: {
+			INPUT input;
+			input.type = INPUT_MOUSE;
+			input.mi.dwExtraInfo = 0;
+			input.mi.dwFlags = MOUSEEVENTF_HWHEEL;
+			input.mi.dx = 0;
+			input.mi.dy = 0;
+			input.mi.mouseData = WHEEL_DELTA;
+			input.mi.time = 0;
+			if (SendInput(1, &input, sizeof(INPUT)) == 0)
+				RAISE_WIN32_ERROR;
+			break;
+		}
+		default: {
+			PCHAR cModeName = ruby___special_input_device_get_mode_name();
+			rb_raise(rb_eRuntimeError, "Undefined mode '%s'.", cModeName);
+		}
+	}
+	return self;
+#else
+	rb_raise(rb_eRuntimeError, "Error! Your system not support horizontal wheel.");
+#endif
+}
+
+//</editor-fold>
+
+VOID Init_mouse() {
+#ifdef YARD
+	specialInputDevice = rb_define_module("SpecialInputDevice");
+#endif
+	/*
+	 * Document-module: SpecialInputDevice::Mouse
+	 *
+	 * The <code>Mouse</code> module provides an interface to simulate the signal form mouse.
+	 */
+	VALUE specialInputDevice_mouse = rb_define_module_under(specialInputDevice, "Mouse");
+	rb_define_singleton_method(specialInputDevice_mouse, "lock", ruby__lock, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "unlock", ruby__unlock, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "cursor_position", ruby__cursor_position, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "move_relatively", ruby__move_relatively, 2);
+	rb_define_singleton_method(specialInputDevice_mouse, "move_to_primary", ruby__move_to_primary, 2);
+	rb_define_singleton_method(specialInputDevice_mouse, "move_to_virtual", ruby__move_to_virtual, 2);
+	rb_define_singleton_method(specialInputDevice_mouse, "left_click", ruby__left_click, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "left_down", ruby__left_down, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "left_up", ruby__left_up, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "right_click", ruby__right_click, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "right_down", ruby__right_down, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "right_up", ruby__right_up, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "middle_click", ruby__middle_click, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "middle_down", ruby__middle_down, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "middle_up", ruby__middle_up, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "x1_click", ruby__x1_click, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "x1_down", ruby__x1_down, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "x1_up", ruby__x1_up, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "x2_click", ruby__x2_click, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "x2_down", ruby__x2_down, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "x2_up", ruby__x2_up, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "scroll_wheel_backward", ruby__scroll_wheel_backward, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "scroll_wheel_forward", ruby__scroll_wheel_forward, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "scroll_wheel_to_left", ruby__scroll_wheel_to_left, 0);
+	rb_define_singleton_method(specialInputDevice_mouse, "scroll_wheel_to_right", ruby__scroll_wheel_to_right, 0);
+}