special_input_device 0.0.0

data/ext/special_input_device/special_input_device.c

@@ -0,0 +1,40 @@
+#include "special_input_device.h"
+
+SID_MODE ruby___special_input_device_get_mode_identifier() {
+	PCHAR cModeName = ruby___special_input_device_get_mode_name();
+	if (!strcmp(cModeName, "interception"))
+		return MODE_INTERCEPTION;
+	if (!strcmp(cModeName, "win_api"))
+		return MODE_WIN_API;
+	return (SID_MODE) -1;
+}
+
+PCHAR ruby___special_input_device_get_mode_name() {
+	VALUE mode = rb_sym2str(rb_iv_get(specialInputDevice, "@mode"));
+	return rb_string_value_cstr(&mode);
+}
+
+VOID Init_special_input_device() {
+	specialInputDevice = rb_define_module("SpecialInputDevice");
+
+	Init_win32error();
+
+	specialInputDevice_attributesEqualChecker = rb_define_module_under(specialInputDevice, "AttributesEqualChecker");
+	specialInputDevice_table2d                = rb_define_class_under(specialInputDevice, "Table2D", rb_cObject);
+	specialInputDevice_color                  = rb_define_class_under(specialInputDevice, "Color", rb_cObject);
+	specialInputDevice_image                  = rb_define_class_under(specialInputDevice, "Image", specialInputDevice_table2d);
+	specialInputDevice_point                  = rb_define_class_under(specialInputDevice, "Point", rb_cObject);
+	specialInputDevice_rectangle              = rb_define_class_under(specialInputDevice, "Rectangle", rb_cObject);
+	rb_eval_string(""
+			               "begin\n"
+			               "  require('special_input_device/special_input_device')\n"
+			               "rescue LoadError\n"
+			               "  raise LoadError.new('Cannot load the library of SpecialInputDevice. Reinstall may solve this problem.')\n"
+			               "end\n");
+
+	Init_keyboard();
+	Init_mouse();
+	Init_screen();
+	Init_window();
+	Init_interception();
+}

data/ext/special_input_device/special_input_device.h

@@ -0,0 +1,42 @@
+#ifdef YARD
+# define INTERCEPTION_STATIC
+# define UNICODE
+#endif
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <windows.h>
+
+typedef enum {
+	MODE_INTERCEPTION,
+	MODE_WIN_API
+} SID_MODE;
+
+VALUE specialInputDevice;
+VALUE specialInputDevice_attributesEqualChecker;
+VALUE specialInputDevice_table2d;
+VALUE specialInputDevice_color;
+VALUE specialInputDevice_image;
+VALUE specialInputDevice_point;
+VALUE specialInputDevice_rectangle;
+VALUE specialInputDevice_win32error;
+
+#include "ruby_macro.h"
+
+SID_MODE ruby___special_input_device_get_mode_identifier();
+
+PCHAR ruby___special_input_device_get_mode_name();
+
+VOID Init_special_input_device();
+
+VOID Init_interception();
+
+VOID Init_keyboard();
+
+VOID Init_mouse();
+
+VOID Init_screen();
+
+VOID Init_window();
+
+VOID Init_win32error();

data/ext/special_input_device/win32error.c

@@ -0,0 +1,69 @@
+#include "special_input_device.h"
+
+VALUE ruby___win32error_new() {
+	VALUE newWin32ErrorArguments[0];
+	return rb_class_new_instance(0, newWin32ErrorArguments, specialInputDevice_win32error);
+}
+
+VALUE ruby___win32error_new_from_code(DWORD cCode) {
+	VALUE newWin32ErrorArguments[1];
+	newWin32ErrorArguments[0] = UINT2NUM(cCode);
+	return rb_class_new_instance(1, newWin32ErrorArguments, specialInputDevice_win32error);
+}
+
+/*
+ * @!scope class
+ * @overload new(code = nil)
+ *   Returns a new instance of <code>Win32Error</code>.
+ *   @param [Integer] code the error code
+ * @return [SpecialInputDevice::Window] a new instance of <code>Win32Error</code>
+ */
+
+static VALUE ruby_initialize(VARIABLE_ARGUMENTS_C) {
+	VALUE  code;
+	VALUE  description;
+	VALUE  formatStringArguments[2];
+	VALUE  superArguments[1];
+	DWORD  cCode;
+	LPTSTR cMessage;
+	DWORD  cMessageLength;
+	SCAN_ARGUMENTS("01", &code);
+	cCode          = code == Qnil ? GetLastError() : NUM2USHORT(code);
+	cMessage       = (LPTSTR) VirtualAlloc((LPVOID) NULL, (SIZE_T) 256 * sizeof(TCHAR), MEM_COMMIT,
+	                                       PAGE_READWRITE);
+	cMessageLength = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, cCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+	                               cMessage, 256, NULL);
+	code           = UINT2NUM(cCode);
+	description    = RUBY_LPTSTR_TO_VALUE(cMessage, cMessageLength);
+	rb_iv_set(self, "@code", code);
+	rb_iv_set(self, "@description", description);
+	formatStringArguments[0] = code;
+	formatStringArguments[1] = description;
+	superArguments[0]        = rb_str_format(2, formatStringArguments, rb_str_new_literal("0x%04X %s"));
+	rb_call_super(1, superArguments);
+	return Qnil;
+}
+
+VOID Init_win32error() {
+#ifdef YARD
+	specialInputDevice = rb_define_module("SpecialInputDevice");
+#endif
+	/*
+	 * Document-class: SpecialInputDevice::Win32Error
+	 *
+	 * Raised when calling Win API failed.
+	 */
+	specialInputDevice_win32error = rb_define_class_under(specialInputDevice, "Win32Error", rb_eException);
+	/*
+	 * @return [Integer] the error code
+	 * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms679360.aspx Windows Dev Center - GetLastError function
+	 * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms681381.aspx Windows Dev Center - System Error Codes
+	 */
+	rb_define_attr(specialInputDevice_win32error, "code", TRUE, FALSE);
+	/*
+	 * @return [String] the error description
+	 * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms679351.aspx Windows Dev Center - FormatMessage function
+	 */
+	rb_define_attr(specialInputDevice_win32error, "description", TRUE, FALSE);
+	rb_define_method(specialInputDevice_win32error, "initialize", ruby_initialize, -1);
+}

data/ext/special_input_device/win32error.h

@@ -0,0 +1,8 @@
+#ifndef SPECIAL_INPUT_DEVICE_WIN32ERROR_H
+#define SPECIAL_INPUT_DEVICE_WIN32ERROR_H
+
+VALUE ruby___win32error_new();
+
+VALUE ruby___win32error_new_from_code(DWORD cCode);
+
+#endif //SPECIAL_INPUT_DEVICE_WIN32ERROR_H

data/ext/special_input_device/window.c

@@ -0,0 +1,1108 @@
+#include "special_input_device.h"
+#include "_system_time.h"
+#include "color.h"
+#include "rectangle.h"
+
+#define MAXIMUM_WINDOW_NAME_LENGTH 256
+
+#define FLAT_CONTROL 0x0001
+#define FLAT_CONTROL_LEFT 0x0002
+#define FLAT_CONTROL_RIGHT 0x0004
+#define FLAT_CONTROLS (FLAT_CONTROL | FLAT_CONTROL_LEFT | FLAT_CONTROL_RIGHT)
+#define FLAT_SHIFT 0x0008
+#define FLAT_SHIFT_LEFT 0x0010
+#define FLAT_SHIFT_RIGHT 0x0020
+#define FLAT_SHIFTS (FLAT_SHIFT | FLAT_SHIFT_LEFT | FLAT_SHIFT_RIGHT)
+#define FLAT_ALTERNATE 0x0040
+#define FLAT_ALTERNATE_LEFT 0x0080
+#define FLAT_ALTERNATE_RIGHT 0x0100
+#define FLAT_MOUSE_LEFT 0x0800
+#define FLAT_MOUSE_MIDDLE 0x1000
+#define FLAT_MOUSE_RIGHT 0x2000
+#define FLAT_MOUSE_X1 0x4000
+#define FLAT_MOUSE_X2 0x8000
+
+typedef struct {
+	WORD      flats;
+	SHORT     x;
+	SHORT     y;
+	ULONGLONG leftClick;
+	ULONGLONG middleClick;
+	ULONGLONG rightClick;
+	ULONGLONG x1Click;
+	ULONGLONG x2Click;
+} SID_WINDOW_DATA;
+
+static WPARAM createMouseMessageWParam(SID_WINDOW_DATA *cData) {
+	WPARAM cWParam = 0;
+	if (cData->flats & FLAT_CONTROLS)
+		cWParam |= MK_CONTROL;
+	if (cData->flats & FLAT_SHIFTS)
+		cWParam |= MK_SHIFT;
+	if (cData->flats & FLAT_MOUSE_LEFT)
+		cWParam |= MK_LBUTTON;
+	if (cData->flats & FLAT_MOUSE_MIDDLE)
+		cWParam |= MK_MBUTTON;
+	if (cData->flats & FLAT_MOUSE_RIGHT)
+		cWParam |= MK_RBUTTON;
+	if (cData->flats & FLAT_MOUSE_X1)
+		cWParam |= MK_XBUTTON1;
+	if (cData->flats & FLAT_MOUSE_X2)
+		cWParam |= MK_XBUTTON2;
+	return cWParam;
+}
+
+inline static LPARAM createMouseMessageLParam(SID_WINDOW_DATA *cData) {
+	return cData->x | cData->y << 16;
+}
+
+static VALUE specialInputDevice_window;
+
+static VALUE ruby___window_new(HWND cHandleCode) {
+	VALUE arguments = ULL2NUM((ULONGLONG) cHandleCode);
+	return rb_class_new_instance(1, &arguments, specialInputDevice_window);
+}
+
+/*
+ * Returns the desktop window. The desktop window covers the entire screen. The desktop window is the area on top of
+ * which other windows are painted.
+ * @return [SpecialInputDevice::Window] the desktop window.
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms633504.aspx Windows Dev Center - GetDesktopWindow function
+ */
+static VALUE ruby__desktop(VALUE self) {
+	return ruby___window_new(GetDesktopWindow());
+}
+
+typedef struct {
+	VALUE windowName;
+	VALUE className;
+	HWND  cHandleCode;
+}            SID_WINDOW_FIND_PARAMETER;
+
+static BOOLEAN callback_find_helper(VALUE pattern, LPTSTR cString) {
+	VALUE string;
+	if (pattern == Qnil)
+		return FALSE;
+	string = RUBY_LPCTSTR_TO_VALUE(cString);
+	if (RTEST(RUBY_OBJECT_IS_A_qs(pattern, rb_cRegexp))) {
+		if (RUBY_REGEXP_MATCH(pattern, string) == Qnil)
+			return TRUE;
+	} else {
+		if (!rb_str_equal(pattern, string))
+			return TRUE;
+	}
+	return FALSE;
+}
+
+static BOOL callback_find(HWND cHandleCode, LPARAM cArguments) {
+	SID_WINDOW_FIND_PARAMETER *cCallbackArguments = (SID_WINDOW_FIND_PARAMETER *) cArguments;
+	TCHAR                     cClassName[MAXIMUM_WINDOW_NAME_LENGTH * sizeof(TCHAR)];
+	INT                       cWindowNameLength   = GetWindowTextLength(cHandleCode) + 1;
+	LPTSTR                    cWindowName         = (LPTSTR) VirtualAlloc((LPVOID) NULL,
+	                                                                      (SIZE_T) (cWindowNameLength) * sizeof(TCHAR),
+	                                                                      MEM_COMMIT, PAGE_READWRITE);
+	GetClassName(cHandleCode, cClassName, MAXIMUM_WINDOW_NAME_LENGTH);
+	if (callback_find_helper(cCallbackArguments->className, cClassName))
+		return TRUE;
+	GetWindowText(cHandleCode, cWindowName, cWindowNameLength);
+	if (callback_find_helper(cCallbackArguments->windowName, cWindowName))
+		return TRUE;
+	cCallbackArguments->cHandleCode = cHandleCode;
+	SetLastError(0);
+	return FALSE;
+}
+
+/*
+ * @overload find(window_name = nil, class_name = nil)
+ *   Search the window with specified windows name and class_name. If this parameter is <i>nil</i>, all window pass. If
+ *   this parameter is a <code>Regexp</code>, window pass if its name match the pattern.If this parameter is a
+ *   <code>String</code>, this method perform a case-insensitive search and window pass only if its full name totally
+ *   matches.
+ *   @param [NilClass, Regex, String] window_name the title of window.
+ *   @param [NilClass, Regex, String] class_name the name class or class atom in windows.
+ * @return [SpecialInputDevice::Window, NilClass]
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms633497.aspx Windows Dev Center - EnumWindows function
+ */
+static VALUE ruby__find(VARIABLE_ARGUMENTS_C) {
+	VALUE                     windowName;
+	VALUE                     className;
+	HWND                      cHandleCode;
+	SID_WINDOW_FIND_PARAMETER cCallbackArguments;
+	SCAN_ARGUMENTS("02", &windowName, &className);
+	if (windowName != Qnil && !RTEST(RUBY_OBJECT_IS_A_qs(windowName, rb_cRegexp)) &&
+	    !RTEST(RUBY_OBJECT_IS_A_qs(windowName, rb_cString)))
+		RAISE_TYPE_ERROR(windowName, "nil, Regexp or String");
+	if (className != Qnil && !RTEST(RUBY_OBJECT_IS_A_qs(className, rb_cRegexp)) &&
+	    !RTEST(RUBY_OBJECT_IS_A_qs(className, rb_cString)))
+		RAISE_TYPE_ERROR(className, "nil, Regexp or String");
+	cCallbackArguments.className   = className;
+	cCallbackArguments.windowName  = windowName;
+	cCallbackArguments.cHandleCode = 0;
+	EnumWindows(callback_find, (LPARAM) &cCallbackArguments);
+	cHandleCode = cCallbackArguments.cHandleCode;
+	if (GetLastError())
+		RAISE_WIN32_ERROR;
+	return cHandleCode ? ruby___window_new(cHandleCode) : Qnil;
+}
+
+/*
+ * @return [SpecialInputDevice::Window] a window which the user is currently working.
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms633505.aspx Windows Dev Center - GetForegroundWindow function
+ */
+static VALUE ruby__foreground(VALUE self) {
+	return ruby___window_new(GetForegroundWindow());
+}
+
+inline static HWND ruby___window_get_handle_code(VALUE window) {
+	return (HWND) NUM2ULL(rb_iv_get(window, "@handle_code"));
+}
+
+static VALUE ruby_window_name_EQ(VALUE self, VALUE value) {
+	HWND    cHandleCode = ruby___window_get_handle_code(self);
+	LPCTSTR cWindowName = RUBY_VALUE_TO_LPCTSTR(value);
+	SetWindowText(cHandleCode, cWindowName);
+	return rb_iv_set(self, "@window_name", value);
+}
+
+static VALUE ruby__alloc(VALUE self) {
+	return NEW_SIMPLE_DATA_OBJECT(self, SID_WINDOW_DATA);
+}
+
+/*
+ * @!scope class
+ * @overload new(handle_code)
+ *   Returns a new instance of <code>Window</code>. Normally, use <code>::find</code> to get a window because it is not
+ *   easy to find out a handle code of the window directly.
+ *   @param [Integer] handle_code the handle code of the window. Handle code is an Integer for identifying windows.
+ * @return [SpecialInputDevice::Window] a new instance of <code>Window</code>
+ */
+static VALUE ruby_initialize(VALUE self, VALUE handleCode) {
+	HWND   cHandleCode       = (HWND) NUM2ULL(handleCode);
+	TCHAR  cClassName[MAXIMUM_WINDOW_NAME_LENGTH * sizeof(TCHAR)];
+	INT    cWindowNameLength = GetWindowTextLength(cHandleCode) + 1;
+	LPTSTR cWindowName       = (LPTSTR) VirtualAlloc((LPVOID) NULL, (SIZE_T) (cWindowNameLength) * sizeof(TCHAR),
+	                                                 MEM_COMMIT, PAGE_READWRITE);
+	VALUE  className;
+	VALUE  windowName;
+	if (!GetClassName(cHandleCode, cClassName, MAXIMUM_WINDOW_NAME_LENGTH))
+		RAISE_WIN32_ERROR;
+	if (!GetWindowText(cHandleCode, cWindowName, cWindowNameLength)) {
+		DWORD cError = GetLastError();
+		switch (cError) {
+			case ERROR_SUCCESS:
+			case ERROR_NOT_SUPPORTED:
+				break;
+			default:
+				RAISE_WIN32_ERROR_FROM_CODE(cError);
+		}
+	}
+	rb_iv_set(self, "@handle_code", handleCode);
+	className = RUBY_LPCTSTR_TO_VALUE(cClassName);
+	rb_iv_set(self, "@class_name", className);
+	windowName = RUBY_LPCTSTR_TO_VALUE(cWindowName);
+	rb_iv_set(self, "@window_name", windowName);
+	return Qnil;
+}
+
+//<editor-fold desc="relationship">
+
+/*
+ * @overload find_child(window_name = nil, class_name = nil, after = nil)
+ *   Search the window with specified windows name and class_name form the children of self. This method perform a
+ *   case-insensitive search.
+ *   @param [String] window_name the title of window. If this parameter is <i>nil</i>, all window names match.
+ *   @param [String] class_name the name of class or class atom in windows. If this parameter is <i>nil</i>, all class names match.
+ *   @param [SpecialInputDevice::Window] after a child window. The search begins with the next child window in the z-order. The child window must be a direct child window of hwndParent, not just a descendant window.
+ * @return [SpecialInputDevice::Window]
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms633500.aspx Windows Dev Center - FindWindowEX function
+ */
+static VALUE ruby_find_child(VARIABLE_ARGUMENTS_C) {
+	VALUE   windowName;
+	VALUE   className;
+	VALUE   after;
+	LPCTSTR cWindowName;
+	LPCTSTR cClassName;
+	HWND    cAfter;
+	HWND    cHandleCode;
+	SCAN_ARGUMENTS("03", &windowName, &className, &after);
+	cWindowName = windowName == Qnil ? NULL : RUBY_VALUE_TO_LPCTSTR(windowName);
+	cClassName  = className == Qnil ? NULL : RUBY_VALUE_TO_LPCTSTR(className);
+	cAfter      = after == Qnil ? NULL : ruby___window_get_handle_code(after);
+	cHandleCode = FindWindowEx(ruby___window_get_handle_code(self), cAfter, cClassName, cWindowName);
+	if (!cHandleCode)
+		RAISE_WIN32_ERROR;
+	return ruby___window_new(cHandleCode);
+}
+
+/*
+ * @overload parent(include_owner = false)
+ * @return [SpecialInputDevice::Window] the parent window of self.
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms633502.aspx Windows Dev Center - GetAncestor function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms633510.aspx Windows Dev Center - GetParent function
+ */
+static VALUE ruby_parent(VARIABLE_ARGUMENTS_C) {
+	VALUE includeOwner;
+	HWND  cHandleCode;
+	SCAN_ARGUMENTS("01", &includeOwner);
+	cHandleCode = ruby___window_get_handle_code(self);
+	return ruby___window_new(
+			includeOwner && includeOwner != Qnil ? GetAncestor(cHandleCode, GA_PARENT) : GetParent(cHandleCode));
+}
+
+/*
+ * @overload root(include_owner = false)
+ * @return [SpecialInputDevice::Window] the root window of self.
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms633502.aspx Windows Dev Center - GetAncestor function
+ */
+static VALUE ruby_root(VARIABLE_ARGUMENTS_C) {
+	VALUE includeOwner;
+	HWND  cHandleCode;
+	SCAN_ARGUMENTS("01", &includeOwner);
+	cHandleCode = ruby___window_get_handle_code(self);
+	return ruby___window_new(GetAncestor(cHandleCode, includeOwner && includeOwner != Qnil ? GA_ROOT : GA_ROOTOWNER));
+}
+
+//</editor-fold>
+
+//<editor-fold desc="size">
+
+/*
+ * Returns the rectangle of the window's client area. The coordinates of rectangle are relative to the client area
+ * itself so the upper-left corner are always (0, 0).
+ * @return [SpecialInputDevice::Rectangle] the rectangle of the window's client area.
+ * @see #window_rectangle
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms633503.aspx Windows Dev Center - GetClientRect function
+ */
+static VALUE ruby_client_rectangle(VALUE self) {
+	RECT cClientRectangle;
+	HWND cHandleCode = ruby___window_get_handle_code(self);
+	if (!GetClientRect(cHandleCode, &cClientRectangle))
+		RAISE_WIN32_ERROR;
+	if (!ClientToScreen(cHandleCode, (LPPOINT) &cClientRectangle))
+		RAISE_WIN32_ERROR;
+	cClientRectangle.right += cClientRectangle.left;
+	cClientRectangle.bottom += cClientRectangle.top;
+	return ruby___rectangle_new_from_rect(&cClientRectangle);
+}
+
+/*
+ * Returns the bounding rectangle of the window. The rectangle is given in screen coordinates.
+ * @return [SpecialInputDevice::Rectangle] the bounding rectangle of the window.
+ * @see #client_rectangle
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms633503.aspx Windows Dev Center - GetClientRect function
+ */
+static VALUE ruby_window_rectangle(VALUE self) {
+	RECT cWindowRectangle;
+	if (!GetWindowRect(ruby___window_get_handle_code(self), &cWindowRectangle))
+		RAISE_WIN32_ERROR;
+	return ruby___rectangle_new_from_rect(&cWindowRectangle);
+}
+
+//</editor-fold>
+
+//<editor-fold desc="control">
+
+/*
+ * Brings the window to the foreground.
+ * @return [SpecialInputDevice::Window] self
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms633539.aspx Windows Dev Center - SetForegroundWindow function
+ */
+static VALUE ruby_bring_to_foreground(VALUE self) {
+	if (!SetForegroundWindow(ruby___window_get_handle_code(self)))
+		RAISE_WIN32_ERROR;
+	return self;
+}
+
+/*
+ * Close the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ */
+static VALUE ruby_close(VALUE self) {
+	if (!PostMessage(ruby___window_get_handle_code(self), WM_CLOSE, 0, 0))
+		RAISE_WIN32_ERROR;
+	return self;
+}
+
+/*
+ * Hides the window. To show it again, call {#maximize}, {#minimize} or {#restore}.
+ * @return [SpecialInputDevice::Window] self
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms633548.aspx Windows Dev Center - ShowWindow function
+ */
+static VALUE ruby_hide(VALUE self) {
+	if (!ShowWindow(ruby___window_get_handle_code(self), SW_HIDE))
+		RAISE_WIN32_ERROR;
+	return self;
+}
+
+/*
+ * Maximizes the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms633548.aspx Windows Dev Center - ShowWindow function
+ */
+static VALUE ruby_maximize(VALUE self) {
+	if (!ShowWindow(ruby___window_get_handle_code(self), SW_SHOWMAXIMIZED))
+		RAISE_WIN32_ERROR;
+	return self;
+}
+
+/*
+ * Minimizes the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms633548.aspx Windows Dev Center - ShowWindow function
+ */
+static VALUE ruby_minimize(VALUE self) {
+	if (!ShowWindow(ruby___window_get_handle_code(self), SW_SHOWMINIMIZED))
+		RAISE_WIN32_ERROR;
+	return self;
+}
+
+/*
+ * Restore the window and then moves it to specific position.
+ * @overload move_to(x, y)
+ *   @param [Integer] x the x-coordinate of target
+ *   @param [Integer] y the y-coordinate of target
+ * @return [SpecialInputDevice::Window] self
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms633548.aspx Windows Dev Center - SetWindowPos function
+ */
+static VALUE ruby_move_to(VALUE self, VALUE x, VALUE y) {
+	INT cX = NUM2INT(x);
+	INT cY = NUM2INT(y);
+	if (!SetWindowPos(ruby___window_get_handle_code(self), NULL, cX, cY, 0, 0,
+	                  SWP_NOSIZE | SWP_NOOWNERZORDER | SWP_NOZORDER))
+		RAISE_WIN32_ERROR;
+	return self;
+}
+
+/*
+ * Restore the window and then change it to specific size.
+ * @overload resize_to(width, height)
+ *   @param [Integer] width the width of target size
+ *   @param [Integer] height the height of target size
+ * @return [SpecialInputDevice::Window] self
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms633545.aspx Windows Dev Center - SetWindowPos function
+ */
+static VALUE ruby_resize_to(VALUE self, VALUE width, VALUE height) {
+	INT cWidth  = NUM2INT(width);
+	INT cHeight = NUM2INT(height);
+	if (!SetWindowPos(ruby___window_get_handle_code(self), NULL, 0, 0, cWidth, cHeight,
+	                  SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOZORDER))
+		RAISE_WIN32_ERROR;
+	return self;
+}
+
+/*
+ * Restores the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms633548.aspx Windows Dev Center - ShowWindow function
+ */
+static VALUE ruby_restore(VALUE self) {
+	if (!ShowWindow(ruby___window_get_handle_code(self), SW_SHOWNORMAL))
+		RAISE_WIN32_ERROR;
+	return self;
+}
+
+//</editor-fold>
+
+//<editor-fold desc="display">
+
+/*
+ * @overload color_at(x, y)
+ *   @param [Fixnum] x the x coordinate of the point for get color
+ *   @param [Fixnum] y the y coordinate of the point for get color
+ * @return [SpecialInputDevice::Color] the color at the specified point in the client area of window
+ * @see SpecialInputDevice::Screen.color_at
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/dd144909.aspx Windows Dev Center - GetPixel function
+ */
+static VALUE ruby_color_at(VALUE self, VALUE x, VALUE y) {
+	INT      cX     = NUM2INT(x);
+	INT      cY     = NUM2INT(y);
+	COLORREF cColor = GetPixel(GetDC(ruby___window_get_handle_code(self)), cX, cY);
+	return ruby___color_new_from_color_ref(cColor);
+}
+
+//</editor-fold>
+
+//<editor-fold desc="input">
+
+//<editor-fold desc="keyboard">
+
+/*
+ * @overload key_hold(key_code)
+ *   Simulate holding the specified key down in the window. User would not lose the control of computer.
+ *   @param [Integer] key_code virtual key code. Use a value of constant in {SpecialInputDevice::KeyCode}.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Keyboard.hold
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646280.aspx Windows Dev Center - WM_KEYDOWN message
+ */
+static VALUE ruby_key_hold(VALUE self, VALUE keyCode) {
+	SID_WINDOW_DATA *cData;
+	HWND            cHWnd   = ruby___window_get_handle_code(self);
+	WPARAM          cWParam = NUM2USHORT(keyCode);
+	LPARAM          cLParam = 1 | (WORD) MapVirtualKeyA(cWParam, MAPVK_VK_TO_VSC) << 16;
+	PostMessage(cHWnd, WM_KEYDOWN, cWParam, cLParam);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	switch (cWParam) {
+		case VK_CONTROL:
+			cData->flats |= FLAT_CONTROL;
+			break;
+		case VK_LCONTROL:
+			cData->flats |= FLAT_CONTROL_LEFT;
+			break;
+		case VK_RCONTROL:
+			cData->flats |= FLAT_CONTROL_RIGHT;
+			break;
+		case VK_SHIFT:
+			cData->flats |= FLAT_SHIFT;
+			break;
+		case VK_LSHIFT:
+			cData->flats |= FLAT_SHIFT_LEFT;
+			break;
+		case VK_RSHIFT:
+			cData->flats |= FLAT_SHIFT_RIGHT;
+			break;
+		case VK_MENU:
+			cData->flats |= FLAT_ALTERNATE;
+			break;
+		case VK_LMENU:
+			cData->flats |= FLAT_ALTERNATE_LEFT;
+			break;
+		case VK_RMENU:
+			cData->flats |= FLAT_ALTERNATE_RIGHT;
+			break;
+		default:
+			break;
+	}
+	return self;
+}
+
+/*
+ * @overload key_release(key_code)
+ *   Simulate releasing the specified key in the window. User would not lose the control of computer.
+ *   @param [Integer] key_code virtual key code. Use a value of constant in {SpecialInputDevice::KeyCode}.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Keyboard.release
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646281.aspx Windows Dev Center - WM_KEYUP message
+ */
+static VALUE ruby_key_release(VALUE self, VALUE keyCode) {
+	SID_WINDOW_DATA *cData;
+	HWND            cHWnd   = ruby___window_get_handle_code(self);
+	WPARAM          cWParam = NUM2USHORT(keyCode);
+	LPARAM          cLParam = 1;
+	cLParam |= (WORD) MapVirtualKeyA(cWParam, MAPVK_VK_TO_VSC) << 16;
+	cLParam |= 0xA0000000;
+	PostMessage(cHWnd, WM_KEYUP, cWParam, cLParam);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	switch (cWParam) {
+		case VK_CONTROL:
+			cData->flats &= ~FLAT_CONTROL;
+			break;
+		case VK_LCONTROL:
+			cData->flats &= ~FLAT_CONTROL_LEFT;
+			break;
+		case VK_RCONTROL:
+			cData->flats &= ~FLAT_CONTROL_RIGHT;
+			break;
+		case VK_SHIFT:
+			cData->flats &= ~FLAT_SHIFT;
+			break;
+		case VK_LSHIFT:
+			cData->flats &= ~FLAT_SHIFT_LEFT;
+			break;
+		case VK_RSHIFT:
+			cData->flats &= ~FLAT_SHIFT_RIGHT;
+			break;
+		case VK_MENU:
+			cData->flats &= ~FLAT_ALTERNATE;
+			break;
+		case VK_LMENU:
+			cData->flats &= ~FLAT_ALTERNATE_LEFT;
+			break;
+		case VK_RMENU:
+			cData->flats &= ~FLAT_ALTERNATE_RIGHT;
+			break;
+		default:
+			break;
+	}
+	return self;
+}
+
+/*
+ * @overload key_press(key_code)
+ *   Simulate pressing the specified key in the window. User would not lose the control of computer.
+ *   @param [Integer] key_code virtual key code. Use a value of constant in {SpecialInputDevice::KeyCode}.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Keyboard.press
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646280.aspx Windows Dev Center - WM_KEYDOWN message
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646281.aspx Windows Dev Center - WM_KEYUP message
+ */
+static VALUE ruby_key_press(VALUE self, VALUE keyCode) {
+	SID_WINDOW_DATA *cData;
+	HWND            cHWnd   = ruby___window_get_handle_code(self);
+	WPARAM          cWParam = NUM2USHORT(keyCode);
+	LPARAM          cLParam = 1 | (WORD) MapVirtualKeyA(cWParam, MAPVK_VK_TO_VSC) << 16;
+	PostMessage(cHWnd, WM_KEYDOWN, cWParam, cLParam);
+	cLParam |= 0xA0000000;
+	PostMessage(cHWnd, WM_KEYUP, cWParam, cLParam);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	switch (cWParam) {
+		case VK_CONTROL:
+			cData->flats &= ~FLAT_CONTROL;
+			break;
+		case VK_LCONTROL:
+			cData->flats &= ~FLAT_CONTROL_LEFT;
+			break;
+		case VK_RCONTROL:
+			cData->flats &= ~FLAT_CONTROL_RIGHT;
+			break;
+		case VK_SHIFT:
+			cData->flats &= ~FLAT_SHIFT;
+			break;
+		case VK_LSHIFT:
+			cData->flats &= ~FLAT_SHIFT_LEFT;
+			break;
+		case VK_RSHIFT:
+			cData->flats &= ~FLAT_SHIFT_RIGHT;
+			break;
+		case VK_MENU:
+			cData->flats &= ~FLAT_ALTERNATE;
+			break;
+		case VK_LMENU:
+			cData->flats &= ~FLAT_ALTERNATE_LEFT;
+			break;
+		case VK_RMENU:
+			cData->flats &= ~FLAT_ALTERNATE_RIGHT;
+			break;
+		default:
+			break;
+	}
+	return self;
+}
+
+//</editor-fold>
+
+//<editor-fold desc="mouse">
+
+//<editor-fold desc="move">
+
+/*
+ * @overload mouse_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 [SpecialInputDevice::Window] self
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms645616.aspx Windows Dev Center - WM_MOUSEMOVE message
+ */
+static VALUE ruby_mouse_move_relatively(VALUE self, VALUE x, VALUE y) {
+	SID_WINDOW_DATA *cData;
+	HWND            cHWnd = ruby___window_get_handle_code(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	cData->x += NUM2SHORT(x);
+	cData->y += NUM2SHORT(y);
+	PostMessage(cHWnd, WM_MOUSEMOVE, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	return self;
+}
+
+/*
+ * @overload mouse_move_to(x, y)
+ *   Move the cursor position relative to the upper-left corner of client area of the window.
+ *   @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 [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.move_to_primary
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms645616.aspx Windows Dev Center - WM_MOUSEMOVE message
+ */
+static VALUE ruby_mouse_move_to(VALUE self, VALUE x, VALUE y) {
+	SID_WINDOW_DATA *cData;
+	HWND            cHWnd = ruby___window_get_handle_code(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	cData->x = NUM2SHORT(x);
+	cData->y = NUM2SHORT(y);
+	PostMessage(cHWnd, WM_MOUSEMOVE, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	return self;
+}
+
+//</editor-fold>
+
+//<editor-fold desc="left_button">
+
+/*
+ * Simulate clicking the left button on the mouse in the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.left_click
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms645606.aspx Windows Dev Center - WM_LBUTTONDBLCLK message
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms645607.aspx Windows Dev Center - WM_LBUTTONDOWN message
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms645608.aspx Windows Dev Center - WM_LBUTTONUP message
+ */
+static VALUE ruby_mouse_left_click(VALUE self) {
+	SID_WINDOW_DATA *cData;
+	ULONGLONG       cCurrentTime = getSystemTimeIdentifier();
+	HWND            cHWnd        = ruby___window_get_handle_code(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	cData->flats |= FLAT_MOUSE_LEFT;
+	PostMessage(cHWnd, WM_LBUTTONDOWN, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	if (cData->leftClick && cData->leftClick + GetDoubleClickTime() <= cCurrentTime)
+		PostMessage(cHWnd, WM_LBUTTONDBLCLK, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	cData->flats &= ~FLAT_MOUSE_LEFT;
+	PostMessage(cHWnd, WM_LBUTTONUP, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	cData->leftClick = cCurrentTime;
+	return self;
+}
+
+/*
+ * Simulate holding the left button on the mouse down in the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.left_down
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms645606.aspx Windows Dev Center - WM_LBUTTONDBLCLK message
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms645607.aspx Windows Dev Center - WM_LBUTTONDOWN message
+ */
+static VALUE ruby_mouse_left_down(VALUE self) {
+	SID_WINDOW_DATA *cData;
+	ULONGLONG       cCurrentTime = getSystemTimeIdentifier();
+	HWND            cHWnd        = ruby___window_get_handle_code(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	cData->flats |= FLAT_MOUSE_LEFT;
+	PostMessage(cHWnd, WM_LBUTTONDOWN, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	if (cData->leftClick && cData->leftClick + GetDoubleClickTime() <= cCurrentTime)
+		PostMessage(cHWnd, WM_LBUTTONDBLCLK, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	cData->leftClick = cCurrentTime;
+	return self;
+}
+
+/*
+ * Simulate releasing the left button on the mouse in the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.left_up
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms645608.aspx Windows Dev Center - WM_LBUTTONUP message
+ */
+static VALUE ruby_mouse_left_up(VALUE self) {
+	SID_WINDOW_DATA *cData;
+	HWND            cHWnd = ruby___window_get_handle_code(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	cData->flats &= ~FLAT_MOUSE_LEFT;
+	PostMessage(cHWnd, WM_LBUTTONUP, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	return self;
+}
+
+//</editor-fold>
+
+//<editor-fold desc="right_button">
+
+/*
+ * Simulate clicking the right button on the mouse in the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.right_click
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646241.aspx Windows Dev Center - WM_RBUTTONDBLCLK function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646242.aspx Windows Dev Center - WM_RBUTTONDOWN function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646243.aspx Windows Dev Center - WM_RBUTTONUP function
+ */
+static VALUE ruby_mouse_right_click(VALUE self) {
+	SID_WINDOW_DATA *cData;
+	ULONGLONG       cCurrentTime = getSystemTimeIdentifier();
+	HWND            cHWnd        = ruby___window_get_handle_code(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	cData->flats |= FLAT_MOUSE_RIGHT;
+	PostMessage(cHWnd, WM_RBUTTONDOWN, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	if (cData->rightClick && cData->rightClick + GetDoubleClickTime() <= cCurrentTime)
+		PostMessage(cHWnd, WM_LBUTTONDBLCLK, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	cData->flats &= ~FLAT_MOUSE_RIGHT;
+	PostMessage(cHWnd, WM_RBUTTONUP, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	cData->rightClick = cCurrentTime;
+	return self;
+}
+
+/*
+ * Simulate holding the right button on the mouse down in the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.right_down
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646241.aspx Windows Dev Center - WM_RBUTTONDBLCLK function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646242.aspx Windows Dev Center - WM_RBUTTONDOWN function
+ */
+static VALUE ruby_mouse_right_down(VALUE self) {
+	SID_WINDOW_DATA *cData;
+	ULONGLONG       cCurrentTime = getSystemTimeIdentifier();
+	HWND            cHWnd        = ruby___window_get_handle_code(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	cData->flats |= FLAT_MOUSE_RIGHT;
+	PostMessage(cHWnd, WM_RBUTTONDOWN, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	if (cData->rightClick && cData->rightClick + GetDoubleClickTime() <= cCurrentTime)
+		PostMessage(cHWnd, WM_LBUTTONDBLCLK, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	cData->rightClick = cCurrentTime;
+	return self;
+}
+
+/*
+ * Simulate releasing the right button on the mouse in the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.right_up
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646243.aspx Windows Dev Center - WM_RBUTTONUP function
+ */
+static VALUE ruby_mouse_right_up(VALUE self) {
+	SID_WINDOW_DATA *cData;
+	HWND            cHWnd = ruby___window_get_handle_code(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	cData->flats &= ~FLAT_MOUSE_RIGHT;
+	PostMessage(cHWnd, WM_RBUTTONUP, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	return self;
+}
+
+//</editor-fold>
+
+//<editor-fold desc="middle_button">
+
+/*
+ * Simulate clicking the middle button on the mouse in the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.middle_click
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms645609.aspx Windows Dev Center - WM_MBUTTONDBLCLK function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms645610.aspx Windows Dev Center - WM_MBUTTONDOWN function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms645611.aspx Windows Dev Center - WM_MBUTTONUP function
+ */
+static VALUE ruby_mouse_middle_click(VALUE self) {
+	SID_WINDOW_DATA *cData;
+	ULONGLONG       cCurrentTime = getSystemTimeIdentifier();
+	HWND            cHWnd        = ruby___window_get_handle_code(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	cData->flats |= FLAT_MOUSE_MIDDLE;
+	PostMessage(cHWnd, WM_MBUTTONDOWN, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	if (cData->middleClick && cData->middleClick + GetDoubleClickTime() <= cCurrentTime)
+		PostMessage(cHWnd, WM_LBUTTONDBLCLK, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	cData->flats &= ~FLAT_MOUSE_MIDDLE;
+	PostMessage(cHWnd, WM_MBUTTONUP, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	cData->middleClick = cCurrentTime;
+	return self;
+}
+
+/*
+ * Simulate holding the middle button on the mouse down in the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.middle_down
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms645609.aspx Windows Dev Center - WM_MBUTTONDBLCLK function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms645610.aspx Windows Dev Center - WM_MBUTTONDOWN function
+ */
+static VALUE ruby_mouse_middle_down(VALUE self) {
+	SID_WINDOW_DATA *cData;
+	ULONGLONG       cCurrentTime = getSystemTimeIdentifier();
+	HWND            cHWnd        = ruby___window_get_handle_code(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	cData->flats |= FLAT_MOUSE_MIDDLE;
+	PostMessage(cHWnd, WM_MBUTTONDOWN, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	if (cData->middleClick && cData->middleClick + GetDoubleClickTime() <= cCurrentTime)
+		PostMessage(cHWnd, WM_LBUTTONDBLCLK, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	cData->middleClick = cCurrentTime;
+	return self;
+}
+
+/*
+ * Simulate releasing the middle button on the mouse in the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.middle_up
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms645611.aspx Windows Dev Center - WM_MBUTTONUP function
+ */
+static VALUE ruby_mouse_middle_up(VALUE self) {
+	SID_WINDOW_DATA *cData;
+	HWND            cHWnd = ruby___window_get_handle_code(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	cData->flats &= ~FLAT_MOUSE_MIDDLE;
+	PostMessage(cHWnd, WM_MBUTTONUP, createMouseMessageWParam(cData), createMouseMessageLParam(cData));
+	return self;
+}
+
+//</editor-fold>
+
+//<editor-fold desc="x_button">
+
+/*
+ * Simulate clicking the x1 button on the mouse in the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.x1_click
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646244.aspx Windows Dev Center - WM_XBUTTONDBLCLK function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646245.aspx Windows Dev Center - WM_XBUTTONDOWN function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646246.aspx Windows Dev Center - WM_XBUTTONUP function
+ */
+static VALUE ruby_mouse_x1_click(VALUE self) {
+	SID_WINDOW_DATA *cData;
+	ULONGLONG       cCurrentTime = getSystemTimeIdentifier();
+	HWND            cHWnd        = ruby___window_get_handle_code(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	cData->flats |= FLAT_MOUSE_X1;
+	PostMessage(cHWnd, WM_XBUTTONDOWN, createMouseMessageWParam(cData) | XBUTTON1 << 16,
+	            createMouseMessageLParam(cData));
+	if (cData->x1Click && cData->x1Click + GetDoubleClickTime() <= cCurrentTime)
+		PostMessage(cHWnd, WM_LBUTTONDBLCLK, createMouseMessageWParam(cData) | XBUTTON1 << 16,
+		            createMouseMessageLParam(cData));
+	cData->flats &= ~FLAT_MOUSE_X1;
+	PostMessage(cHWnd, WM_XBUTTONUP, createMouseMessageWParam(cData) | XBUTTON1 << 16, createMouseMessageLParam(cData));
+	cData->x1Click = cCurrentTime;
+	return self;
+}
+
+/*
+ * Simulate holding the x1 button on the mouse down in the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.x1_down
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646244.aspx Windows Dev Center - WM_XBUTTONDBLCLK function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646245.aspx Windows Dev Center - WM_XBUTTONDOWN function
+ */
+static VALUE ruby_mouse_x1_down(VALUE self) {
+	SID_WINDOW_DATA *cData;
+	ULONGLONG       cCurrentTime = getSystemTimeIdentifier();
+	HWND            cHWnd        = ruby___window_get_handle_code(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	cData->flats |= FLAT_MOUSE_X1;
+	PostMessage(cHWnd, WM_XBUTTONDOWN, createMouseMessageWParam(cData) | XBUTTON1 << 16,
+	            createMouseMessageLParam(cData));
+	if (cData->x1Click && cData->x1Click + GetDoubleClickTime() <= cCurrentTime)
+		PostMessage(cHWnd, WM_LBUTTONDBLCLK, createMouseMessageWParam(cData) | XBUTTON1 << 16,
+		            createMouseMessageLParam(cData));
+	cData->x1Click = cCurrentTime;
+	return self;
+}
+
+/*
+ * Simulate releasing the x1 button on the mouse in the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.x1_up
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646246.aspx Windows Dev Center - WM_XBUTTONUP function
+ */
+static VALUE ruby_mouse_x1_up(VALUE self) {
+	SID_WINDOW_DATA *cData;
+	HWND            cHWnd = ruby___window_get_handle_code(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	cData->flats &= ~FLAT_MOUSE_X1;
+	PostMessage(cHWnd, WM_XBUTTONUP, createMouseMessageWParam(cData) | XBUTTON1 << 16, createMouseMessageLParam(cData));
+	return self;
+}
+
+/*
+ * Simulate clicking the x2 button on the mouse in the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.x2_click
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646244.aspx Windows Dev Center - WM_XBUTTONDBLCLK function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646245.aspx Windows Dev Center - WM_XBUTTONDOWN function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646246.aspx Windows Dev Center - WM_XBUTTONUP function
+ */
+static VALUE ruby_mouse_x2_click(VALUE self) {
+	SID_WINDOW_DATA *cData;
+	ULONGLONG       cCurrentTime = getSystemTimeIdentifier();
+	HWND            cHWnd        = ruby___window_get_handle_code(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	cData->flats |= FLAT_MOUSE_X2;
+	PostMessage(cHWnd, WM_XBUTTONDOWN, createMouseMessageWParam(cData) | XBUTTON2 << 16,
+	            createMouseMessageLParam(cData));
+	if (cData->x2Click && cData->x2Click + GetDoubleClickTime() <= cCurrentTime)
+		PostMessage(cHWnd, WM_LBUTTONDBLCLK, createMouseMessageWParam(cData) | XBUTTON2 << 16,
+		            createMouseMessageLParam(cData));
+	cData->flats &= ~FLAT_MOUSE_X2;
+	PostMessage(cHWnd, WM_XBUTTONUP, createMouseMessageWParam(cData) | XBUTTON2 << 16, createMouseMessageLParam(cData));
+	cData->x2Click = cCurrentTime;
+	return self;
+}
+
+/*
+ * Simulate holding the x2 button on the mouse down in the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.x2_down
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646244.aspx Windows Dev Center - WM_XBUTTONDBLCLK function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646245.aspx Windows Dev Center - WM_XBUTTONDOWN function
+ */
+static VALUE ruby_mouse_x2_down(VALUE self) {
+	SID_WINDOW_DATA *cData;
+	ULONGLONG       cCurrentTime = getSystemTimeIdentifier();
+	HWND            cHWnd        = ruby___window_get_handle_code(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	cData->flats |= FLAT_MOUSE_X2;
+	PostMessage(cHWnd, WM_XBUTTONDOWN, createMouseMessageWParam(cData) | XBUTTON2 << 16,
+	            createMouseMessageLParam(cData));
+	if (cData->x2Click && cData->x2Click + GetDoubleClickTime() <= cCurrentTime)
+		PostMessage(cHWnd, WM_LBUTTONDBLCLK, createMouseMessageWParam(cData) | XBUTTON2 << 16,
+		            createMouseMessageLParam(cData));
+	cData->x2Click = cCurrentTime;
+	return self;
+}
+
+/*
+ * Simulate releasing the x2 button on the mouse in the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.x2_up
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms646246.aspx Windows Dev Center - WM_XBUTTONUP function
+ */
+static VALUE ruby_mouse_x2_up(VALUE self) {
+	SID_WINDOW_DATA *cData;
+	HWND            cHWnd = ruby___window_get_handle_code(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	cData->flats &= ~FLAT_MOUSE_X2;
+	PostMessage(cHWnd, WM_XBUTTONUP, createMouseMessageWParam(cData) | XBUTTON2 << 16, createMouseMessageLParam(cData));
+	return self;
+}
+
+//</editor-fold>
+
+//<editor-fold desc="wheel">
+
+/*
+ * Simulate wheeling the scroll backward in the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.scroll_wheel_backward
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms645617.aspx Windows Dev Center - WM_MOUSEWHEEL function
+ */
+static VALUE ruby_mouse_scroll_wheel_backward(VALUE self) {
+	SID_WINDOW_DATA *cData;
+	HWND            cHWnd = ruby___window_get_handle_code(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	PostMessage(cHWnd, WM_MOUSEWHEEL, createMouseMessageWParam(cData) | -WHEEL_DELTA << 16,
+	            createMouseMessageLParam(cData));
+	return self;
+}
+
+/*
+ * Simulate wheeling the scroll forward in the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.scroll_wheel_forward
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms645617.aspx Windows Dev Center - WM_MOUSEWHEEL function
+ */
+static VALUE ruby_mouse_scroll_wheel_forward(VALUE self) {
+	SID_WINDOW_DATA *cData;
+	HWND            cHWnd = ruby___window_get_handle_code(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	PostMessage(cHWnd, WM_MOUSEWHEEL, createMouseMessageWParam(cData) | WHEEL_DELTA << 16,
+	            createMouseMessageLParam(cData));
+	return self;
+}
+
+/*
+ * Simulate wheeling the scroll to left hand side in the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.scroll_wheel_to_left
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms645614.aspx Windows Dev Center - WM_MOUSEHWHEEL function
+ */
+static VALUE ruby_mouse_scroll_wheel_to_left(VALUE self) {
+#ifdef MOUSEEVENTF_HWHEEL
+	SID_WINDOW_DATA *cData;
+	HWND            cHWnd = getHandleCode(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	PostMessage(cHWnd, WM_MOUSEHWHEEL, createMouseMessageWParam(cData) | -WHEEL_DELTA << 16, createMouseMessageLParam(cData));
+	return self;
+#else
+	rb_raise(rb_eRuntimeError, "Error! Your system does not support horizontal wheel.");
+#endif
+}
+
+/*
+ * Simulate wheeling the scroll to right hand side in the window.
+ * @return [SpecialInputDevice::Window] self
+ * @see SpecialInputDevice::Mouse.scroll_wheel_to_right
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms644944.aspx Windows Dev Center - PostMessage function
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms645614.aspx Windows Dev Center - WM_MOUSEHWHEEL function
+ */
+static VALUE ruby_mouse_scroll_wheel_to_right(VALUE self) {
+#ifdef MOUSEEVENTF_HWHEEL
+	SID_WINDOW_DATA *cData;
+	HWND            cHWnd = getHandleCode(self);
+	Data_Get_Struct(self, SID_WINDOW_DATA, cData);
+	PostMessage(cHWnd, WM_MOUSEHWHEEL, createMouseMessageWParam(cData) | WHEEL_DELTA << 16, createMouseMessageLParam(cData));
+	return self;
+#else
+	rb_raise(rb_eRuntimeError, "Error! Your system does not support horizontal wheel.");
+#endif
+}
+
+//</editor-fold>
+
+//</editor-fold>
+
+//</editor-fold>
+
+VOID Init_window() {
+#ifdef YARD
+	specialInputDevice = rb_define_module("SpecialInputDevice");
+#endif
+	/*
+	 * Document-class: SpecialInputDevice::Window
+	 *
+	 * A <code>Window</code> object represent a rectangular area for application displays output and receives inputs.
+	 * By using this class, you can control the window without losing the control of computer.
+	 * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms632595.aspx Windows Dev Center - Windows
+	 */
+	specialInputDevice_window = rb_define_class_under(specialInputDevice, "Window", rb_cData);
+	rb_define_singleton_method(specialInputDevice_window, "desktop", ruby__desktop, 0);
+	rb_define_singleton_method(specialInputDevice_window, "find", ruby__find, -1);
+	rb_define_singleton_method(specialInputDevice_window, "foreground", ruby__foreground, 0);
+	rb_define_alloc_func(specialInputDevice_window, (rb_alloc_func_t) ruby__alloc);
+	/*
+	 * @return [String] the name of class or class atom in windows.
+	 */
+	rb_define_attr(specialInputDevice_window, "class_name", TRUE, FALSE);
+	/*
+	 * The handle code of the window. Handle code is an Integer for identifying windows.
+	 * @return [Integer] the handle code of the window.
+	 */
+	rb_define_attr(specialInputDevice_window, "handle_code", TRUE, FALSE);
+	/*
+	 * @return [String] the title of window.
+	 */
+	rb_define_attr(specialInputDevice_window, "window_name", TRUE, TRUE);
+	rb_define_method(specialInputDevice_window, "window_name=", ruby_window_name_EQ, 1);
+	rb_define_method(specialInputDevice_window, "initialize", ruby_initialize, 1);
+	rb_define_method(specialInputDevice_window, "find_child", ruby_find_child, -1);
+	rb_define_method(specialInputDevice_window, "parent", ruby_parent, -1);
+	rb_define_method(specialInputDevice_window, "root", ruby_root, -1);
+	rb_define_method(specialInputDevice_window, "client_rectangle", ruby_client_rectangle, 0);
+	rb_define_method(specialInputDevice_window, "window_rectangle", ruby_window_rectangle, 0);
+	rb_define_method(specialInputDevice_window, "bring_to_foreground", ruby_bring_to_foreground, 0);
+	rb_define_method(specialInputDevice_window, "close", ruby_close, 0);
+	rb_define_method(specialInputDevice_window, "hide", ruby_hide, 0);
+	rb_define_method(specialInputDevice_window, "maximize", ruby_maximize, 0);
+	rb_define_method(specialInputDevice_window, "minimize", ruby_minimize, 0);
+	rb_define_method(specialInputDevice_window, "move_to", ruby_move_to, 2);
+	rb_define_method(specialInputDevice_window, "resize_to", ruby_resize_to, 2);
+	rb_define_method(specialInputDevice_window, "restore", ruby_restore, 0);
+	rb_define_method(specialInputDevice_window, "color_at", ruby_color_at, 2);
+	rb_define_method(specialInputDevice_window, "key_hold", ruby_key_hold, 1);
+	rb_define_method(specialInputDevice_window, "key_release", ruby_key_release, 1);
+	rb_define_method(specialInputDevice_window, "key_press", ruby_key_press, 1);
+	rb_define_method(specialInputDevice_window, "mouse_move_relatively", ruby_mouse_move_relatively, 2);
+	rb_define_method(specialInputDevice_window, "mouse_move_to", ruby_mouse_move_to, 2);
+	rb_define_method(specialInputDevice_window, "mouse_left_click", ruby_mouse_left_click, 0);
+	rb_define_method(specialInputDevice_window, "mouse_left_down", ruby_mouse_left_down, 0);
+	rb_define_method(specialInputDevice_window, "mouse_left_up", ruby_mouse_left_up, 0);
+	rb_define_method(specialInputDevice_window, "mouse_right_click", ruby_mouse_right_click, 0);
+	rb_define_method(specialInputDevice_window, "mouse_right_down", ruby_mouse_right_down, 0);
+	rb_define_method(specialInputDevice_window, "mouse_right_up", ruby_mouse_right_up, 0);
+	rb_define_method(specialInputDevice_window, "mouse_middle_click", ruby_mouse_middle_click, 0);
+	rb_define_method(specialInputDevice_window, "mouse_middle_down", ruby_mouse_middle_down, 0);
+	rb_define_method(specialInputDevice_window, "mouse_middle_up", ruby_mouse_middle_up, 0);
+	rb_define_method(specialInputDevice_window, "mouse_x1_click", ruby_mouse_x1_click, 0);
+	rb_define_method(specialInputDevice_window, "mouse_x1_down", ruby_mouse_x1_down, 0);
+	rb_define_method(specialInputDevice_window, "mouse_x1_up", ruby_mouse_x1_up, 0);
+	rb_define_method(specialInputDevice_window, "mouse_x2_click", ruby_mouse_x2_click, 0);
+	rb_define_method(specialInputDevice_window, "mouse_x2_down", ruby_mouse_x2_down, 0);
+	rb_define_method(specialInputDevice_window, "mouse_x2_up", ruby_mouse_x2_up, 0);
+	rb_define_method(specialInputDevice_window, "mouse_scroll_wheel_backward", ruby_mouse_scroll_wheel_backward, 0);
+	rb_define_method(specialInputDevice_window, "mouse_scroll_wheel_forward", ruby_mouse_scroll_wheel_forward, 0);
+	rb_define_method(specialInputDevice_window, "mouse_scroll_wheel_to_left", ruby_mouse_scroll_wheel_to_left, 0);
+	rb_define_method(specialInputDevice_window, "mouse_scroll_wheel_to_right", ruby_mouse_scroll_wheel_to_right, 0);
+}