special_input_device 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b44c0a6bb776cfd6e6119e3bcfdbf996c4f171bc
-  data.tar.gz: f7fd051facd9a1e21472ab1d20e61a052d0276e2
+  metadata.gz: be0868fbceeb98ef86c51bf95099a3ba60e6ee80
+  data.tar.gz: 726061d79c40698e7bc9d09f3f2dd61fc564f2fa
 SHA512:
-  metadata.gz: 3f46cf44515c0ee093b00a3527cefe3776ddcddfa393a4f56e48ce90dd810400128dee1d3ea8e50ae44fc70bb5014ba269b1343766249526126d32767bcf6ee7
-  data.tar.gz: c131d93e96fc5e5193ba57a7b57ef88e99dce999d7faca7aeb7bb37798e996660467013a3087f5682391ba96452220c300e05d13be85aca6b5d0a9cc3f6b002e
+  metadata.gz: 94035fa8ecb71c41153232256ad261ecc4436aaef1a0f8fb721997c8b022c70758a10942d366084e8ba09894d6feaefde4ad5ae9caa080a5d1f740db063f80c3
+  data.tar.gz: d3eec4a2ba8c5f598a9c888a56b2529990fd1b9cb924cb3e7df607c0bac01a395ae95702ce03618ce5bdc59c0e006be9c05bde33a54d16d48637cb74a6fa0508

data/ext/special_input_device/image.c

@@ -272,7 +272,7 @@ static VALUE ruby__load(VALUE self, VALUE path) {
 			case 24:
 			case 32: {
 				BYTE *cPixel;
-				INT  cBytePrePixel = cDIBHeader.v1.biBitCount / 8;
+				UINT cBytePrePixel = (UINT) cDIBHeader.v1.biBitCount / 8;
 				LONG cValue;
 				LONG cMask;
 				LONG cBuffer;
@@ -354,8 +354,8 @@ static VALUE ruby_initialize(VALUE self, VALUE width, VALUE height) {
 	UINT           cWidth  = NUM2UINT(width);
 	UINT           cHeight = NUM2UINT(height);
 	SID_IMAGE_DATA *cData  = GET_SELF_DATA_OBJECT();
-	INT            cT0;
-	INT            cT1;
+	UINT           cT0;
+	UINT           cT1;
 	cData->height     = cHeight;
 	cData->pixelTable = ALLOC_N(LPRGBQUAD, cHeight);
 	for (cT0 = 0; cT0 < cHeight; cT0++) {
@@ -389,7 +389,7 @@ static VALUE ruby_save(VALUE self, VALUE path) {
 	BITMAPFILEHEADER cFileHeader;
 	BITMAPV5HEADER   cDIBHeader;
 	DWORD            cByteWritten;
-	INT              cT;
+	UINT             cT;
 	cFile = CreateFile(cPath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 	                   FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
 	if (cFile == INVALID_HANDLE_VALUE)
@@ -453,7 +453,7 @@ static VALUE ruby_OS_CS(VALUE self, VALUE x, VALUE y) {
 		rb_raise(rb_eRangeError, "The image only has %d columns. x = %d is out of range.", cWidth, cX);
 	if (cX < 0)
 		cX += cWidth;
-	if (cY < (INT) -cData->height || cY >= cData->height)
+	if (cY < (INT) -cData->height || cY >= (INT) cData->height)
 		rb_raise(rb_eRangeError, "The image only has %d rows. y = %d is out of range.", cData->height, cY);
 	if (cY < 0)
 		cY += cData->height;
@@ -477,7 +477,7 @@ static VALUE ruby_OS_CS_EQ(VALUE self, VALUE x, VALUE y, VALUE value) {
 		rb_raise(rb_eRangeError, "The image only has %d columns. x = %d is out of range.", cWidth, cX);
 	if (cX < 0)
 		cX += cWidth;
-	if (cY < (INT) -cData->height || cY >= cData->height)
+	if (cY < (INT) -cData->height || cY >= (INT) cData->height)
 		rb_raise(rb_eRangeError, "The image only has %d rows. y = %d is out of range.", cData->height, cY);
 	if (cY < 0)
 		cY += cData->height;
@@ -496,7 +496,7 @@ static VALUE ruby_try_get(VALUE self, VALUE x, VALUE y) {
 	INT            cX     = NUM2INT(x);
 	INT            cY     = NUM2INT(y);
 	SID_IMAGE_DATA *cData = GET_SELF_DATA_OBJECT();
-	if (cX < -cWidth || cX >= cWidth || cY < (INT) -cData->height || cY >= cData->height)
+	if (cX < -cWidth || cX >= cWidth || cY < (INT) -cData->height || cY >= (INT) cData->height)
 		return Qnil;
 	if (cX < 0)
 		cX += cWidth;
@@ -518,7 +518,7 @@ static VALUE ruby_try_set(VALUE self, VALUE x, VALUE y, VALUE value) {
 	INT            cY     = NUM2INT(y);
 	RGBQUAD        cVALUE = ruby___color_to_rgb_quad(value);
 	SID_IMAGE_DATA *cData = GET_SELF_DATA_OBJECT();
-	if (cX >= -cWidth && cX < cWidth && cY >= (INT) -cData->height && cY < cData->height) {
+	if (cX >= -cWidth && cX < cWidth && cY >= (INT) -cData->height && cY < (INT) cData->height) {
 		if (cX < 0)
 			cX += cWidth;
 		if (cY < 0)
@@ -574,7 +574,7 @@ static VALUE ruby_each_row(VARIABLE_ARGUMENTS_C) {
 	SCAN_ARGUMENTS("&", &block);
 	if (RTEST(block)) {
 		UINT  cT0;
-		UINT  cT1;
+		LONG  cT1;
 		VALUE *cRow = ALLOC_N(VALUE, cWidth);
 		for (cT0 = 0; cT0 < cData->height; cT0++) {
 			for (cT1 = 0; cT1 < cWidth; cT1++) {
@@ -602,7 +602,7 @@ static VALUE ruby_each_row(VARIABLE_ARGUMENTS_C) {
 static VALUE ruby_each_column(VARIABLE_ARGUMENTS_C) {
 	VALUE          block;
 	SID_IMAGE_DATA *cData = GET_SELF_DATA_OBJECT();
-	LONG           cWidth = NUM2LONG(rb_iv_get(self, "@width"));
+	UINT           cWidth = NUM2UINT(rb_iv_get(self, "@width"));
 	SCAN_ARGUMENTS("&", &block);
 	if (RTEST(block)) {
 		UINT  cT0;
@@ -637,15 +637,15 @@ static VALUE ruby_each_in_row(VARIABLE_ARGUMENTS_C) {
 	VALUE          block;
 	SID_IMAGE_DATA *cData = GET_SELF_DATA_OBJECT();
 	INT            cY;
-	LONG           cWidth = NUM2LONG(rb_iv_get(self, "@width"));
+	INT            cWidth = NUM2INT(rb_iv_get(self, "@width"));
 	SCAN_ARGUMENTS("1&", &y, &block);
 	cY = NUM2INT(y);
-	if (cY < (INT) -cData->height || cY >= cData->height)
+	if (cY < (INT) -cData->height || cY >= (INT) cData->height)
 		rb_raise(rb_eRangeError, "The image only has %d rows. y = %d is out of range.", cData->height, cY);
 	if (cY < 0)
 		cY += cWidth;
 	if (RTEST(block)) {
-		UINT  cT;
+		INT   cT;
 		VALUE cPixel;
 		for (cT = 0; cT < cWidth; cT++) {
 			cPixel = ruby___color_new_from_rgb_quad(&PixelAt(cT, cY));

data/ext/special_input_device/interception.c

@@ -1,5 +1,7 @@
 #include "special_input_device.h"
 #include "_vendor__interception.h"
+#include "keyboard.h"
+#include "mouse.h"
 
 #define MAXIMUM_HARDWARE_IDENTIFIER_LENGTH 512
 
@@ -7,9 +9,13 @@ typedef struct {
 	InterceptionContext context;
 	InterceptionDevice  keyboard;
 	InterceptionDevice  mouse;
+	BOOL lockMouse;
+	BOOL lockKeyboard;
 } SID_INTERCEPTION_DATA;
 
 static SID_INTERCEPTION_DATA *cData;
+static BOOL                  cCustomExitKeysDown[CUSTOM_EXIT_KEY_SIZE]   = {FALSE};
+static BOOL                  cDefaultExitKeysDown[DEFAULT_EXIT_KEY_SIZE] = {FALSE};
 
 inline InterceptionContext ruby___interception_get_context() {
 	return cData->context;
@@ -18,12 +24,12 @@ inline InterceptionContext ruby___interception_get_context() {
 InterceptionDevice ruby___interception_find_keyboard() {
 	TCHAR cHardwareIdentifier[MAXIMUM_HARDWARE_IDENTIFIER_LENGTH];
 	if (interceptionGetHardwareIdentifier(cData->context, cData->keyboard, cHardwareIdentifier,
-                                          MAXIMUM_HARDWARE_IDENTIFIER_LENGTH))
+	                                      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))
+		                                      MAXIMUM_HARDWARE_IDENTIFIER_LENGTH))
 			return cData->keyboard;
 	}
 	rb_raise(rb_eRuntimeError, "Can not find any keyboard connected. Make sure you have at least one keyboard connected"
@@ -34,12 +40,12 @@ InterceptionDevice ruby___interception_find_keyboard() {
 InterceptionDevice ruby___interception_find_mouse() {
 	TCHAR cHardwareIdentifier[MAXIMUM_HARDWARE_IDENTIFIER_LENGTH];
 	if (interceptionGetHardwareIdentifier(cData->context, cData->mouse, cHardwareIdentifier,
-                                          MAXIMUM_HARDWARE_IDENTIFIER_LENGTH))
+	                                      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))
+		                                      MAXIMUM_HARDWARE_IDENTIFIER_LENGTH))
 			return cData->mouse;
 	}
 	rb_raise(rb_eRuntimeError, "Can not find any mouse connected. Make sure you have at least one keyboard connected"
@@ -47,15 +53,152 @@ InterceptionDevice ruby___interception_find_mouse() {
 			" interception mode.");
 }
 
+VOID ruby___interception_exit_keys_updated() {
+	UINT *cExitKeys = ruby___special_input_device_get_exit_keys();
+	INT  cT;
+	for (cT = 0; cT < CUSTOM_EXIT_KEY_SIZE; cT++)
+		cCustomExitKeysDown[cT] = !cExitKeys[cT];
+}
+
 static VOID callback_interception_free(SID_INTERCEPTION_DATA *cData) {
 	interceptionDestroyContext(cData->context);
 	xfree(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;
+	return NEW_DATA_OBJECT(self, SID_INTERCEPTION_DATA, NULL, callback_interception_free);
+}
+
+static VALUE ruby_initialize_thread() {
+	InterceptionStroke cStroke;
+	InterceptionDevice cDevice;
+	UINT               *cCustomExitKeys;
+	INT                cT;
+	interceptionSetFilter(cData->context, interceptionIsKeyboard, INTERCEPTION_FILTER_KEY_ALL);
+	interceptionSetFilter(cData->context, interceptionIsMouse, INTERCEPTION_FILTER_MOUSE_ALL);
+	while (TRUE) {
+		cDevice = interceptionWait(cData->context);
+		if (!interceptionReceive(cData->context, cDevice, &cStroke, 1))
+			break;
+		cCustomExitKeys = ruby___special_input_device_get_exit_keys();
+		if (interceptionIsMouse(cDevice)) {
+			InterceptionMouseStroke *cMouseStroke = (InterceptionMouseStroke *) &cStroke;
+			for (cT                               = 0; cT < CUSTOM_EXIT_KEY_SIZE; cT++) {
+				switch (cCustomExitKeys[cT]) {
+					case VK_LBUTTON:
+						switch (cMouseStroke->state) {
+							case INTERCEPTION_MOUSE_BUTTON_1_DOWN:
+								cCustomExitKeysDown[cT] = TRUE;
+								break;
+							case INTERCEPTION_MOUSE_BUTTON_1_UP:
+								cCustomExitKeysDown[cT] = FALSE;
+								break;
+							default:
+								break;
+						}
+						break;
+					case VK_RBUTTON:
+						switch (cMouseStroke->state) {
+							case INTERCEPTION_MOUSE_BUTTON_2_DOWN:
+								cCustomExitKeysDown[cT] = TRUE;
+								break;
+							case INTERCEPTION_MOUSE_BUTTON_2_UP:
+								cCustomExitKeysDown[cT] = FALSE;
+								break;
+							default:
+								break;
+						}
+						break;
+					case VK_MBUTTON:
+						switch (cMouseStroke->state) {
+							case INTERCEPTION_MOUSE_BUTTON_3_DOWN:
+								cCustomExitKeysDown[cT] = TRUE;
+								break;
+							case INTERCEPTION_MOUSE_BUTTON_3_UP:
+								cCustomExitKeysDown[cT] = FALSE;
+								break;
+							default:
+								break;
+						}
+						break;
+					case VK_XBUTTON1:
+						switch (cMouseStroke->state) {
+							case INTERCEPTION_MOUSE_BUTTON_4_DOWN:
+								cCustomExitKeysDown[cT] = TRUE;
+								break;
+							case INTERCEPTION_MOUSE_BUTTON_4_UP:
+								cCustomExitKeysDown[cT] = FALSE;
+								break;
+							default:
+								break;
+						}
+						break;
+					case VK_XBUTTON2:
+						switch (cMouseStroke->state) {
+							case INTERCEPTION_MOUSE_BUTTON_5_DOWN:
+								cCustomExitKeysDown[cT] = TRUE;
+								break;
+							case INTERCEPTION_MOUSE_BUTTON_5_UP:
+								cCustomExitKeysDown[cT] = FALSE;
+								break;
+							default:
+								break;
+						}
+						break;
+					default:
+						break;
+				}
+			}
+			for (cT = 0; cT < CUSTOM_EXIT_KEY_SIZE; cT++) {
+				if (!cCustomExitKeysDown[cT])
+					break;
+			}
+			if (cT == CUSTOM_EXIT_KEY_SIZE)
+				rb_raise(rb_eSystemExit, "Exit keys pressed.");
+			if (!ruby___mouse_is_locked())
+				interceptionSend(cData->context, cDevice, (InterceptionStroke const *) &cStroke, 1);
+		}
+		if (interceptionIsKeyboard(cDevice)) {
+			InterceptionKeyStroke *cKeyStroke = (InterceptionKeyStroke *) (InterceptionMouseStroke *) &cStroke;
+			for (cT                           = 0; cT < DEFAULT_EXIT_KEY_SIZE; cT++) {
+				if (cKeyStroke->code == MapVirtualKeyA(cDefaultExitKeys[cT], MAPVK_VK_TO_VSC))
+					cDefaultExitKeysDown[cT] = !(cKeyStroke->state & INTERCEPTION_KEY_UP);
+			}
+			for (cT = 0; cT < DEFAULT_EXIT_KEY_SIZE; cT++) {
+				if (!cDefaultExitKeysDown[cT])
+					break;
+			}
+			if (cT == DEFAULT_EXIT_KEY_SIZE)
+				rb_raise(rb_eSystemExit, "Exit keys pressed.");
+			for (cT                           = 0; cT < CUSTOM_EXIT_KEY_SIZE; cT++) {
+				if (cKeyStroke->code == MapVirtualKeyA(cCustomExitKeys[cT], MAPVK_VK_TO_VSC))
+					cCustomExitKeysDown[cT] = !(cKeyStroke->state & INTERCEPTION_KEY_UP);
+			}
+			for (cT = 0; cT < CUSTOM_EXIT_KEY_SIZE; cT++) {
+				if (!cCustomExitKeysDown[cT])
+					break;
+			}
+			if (cT == CUSTOM_EXIT_KEY_SIZE)
+				rb_raise(rb_eSystemExit, "Exit keys pressed.");
+			if (!ruby___keyboard_is_locked())
+				interceptionSend(cData->context, cDevice, (InterceptionStroke const *) &cStroke, 1);
+		}
+	}
+	return Qnil;
+}
+
+/*
+ * @!visibility private
+ */
+static VALUE ruby_initialize(VALUE self) {
+	cData = GET_SELF_DATA_OBJECT();
+	cData->context      = interceptionCreateContext();
+	cData->mouse        = 0;
+	cData->keyboard     = 0;
+	cData->lockMouse    = FALSE;
+	cData->lockKeyboard = FALSE;
+	rb_thread_create(ruby_initialize_thread, NULL);
+	return Qnil;
 }
 
 VOID Init_interception() {
@@ -71,6 +214,7 @@ VOID Init_interception() {
 	 */
 	VALUE specialInputDevice_interception = rb_define_class_under(specialInputDevice, "Interception", rb_cData);
 	rb_define_alloc_func(specialInputDevice_interception, (rb_alloc_func_t) ruby__alloc);
+	rb_define_method(specialInputDevice_interception, "initialize", ruby_initialize, 0);
 
 	rb_require("singleton");
 	singleton = RUBY_MODULE_CONST_GET(rb_mKernel, rb_intern_const("Singleton"));

data/ext/special_input_device/interception.h

@@ -10,4 +10,6 @@ InterceptionDevice ruby___interception_find_keyboard();
 
 InterceptionDevice ruby___interception_find_mouse();
 
+VOID ruby___interception_exit_keys_updated();
+
 #endif //SPECIAL_INPUT_DEVICE_INTERCEPTION_H

data/ext/special_input_device/keyboard.c

@@ -1,6 +1,50 @@
 #include "special_input_device.h"
 #include "interception.h"
 
+static BOOL cLocked;
+
+inline BOOL ruby___keyboard_is_locked() {
+	return cLocked;
+}
+
+/*
+ * Lock the keyboard.
+ * @return [Module] self
+ */
+static VALUE ruby__lock(VALUE self) {
+	cLocked = TRUE;
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION:
+			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 keyboard.
+ * @return [Module] self
+ */
+static VALUE ruby__unlock(VALUE self) {
+	cLocked = FALSE;
+	switch (ruby___special_input_device_get_mode_identifier()) {
+		case MODE_INTERCEPTION:
+			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;
+}
+
 /*
  * @overload hold(key_code)
  *   Simulate holding the specified key down.

data/ext/special_input_device/keyboard.h

@@ -0,0 +1,6 @@
+#ifndef SPECIAL_INPUT_DEVICE_KEYBOARD_H
+#define SPECIAL_INPUT_DEVICE_KEYBOARD_H
+
+inline BOOL ruby___keyboard_is_locked();
+
+#endif //SPECIAL_INPUT_DEVICE_KEYBOARD_H

data/ext/special_input_device/mouse.c

@@ -3,19 +3,21 @@
 #include "interception.h"
 #include "point.h"
 
-//<editor-fold desc="cursor">
+static BOOL cLocked;
+
+inline BOOL ruby___mouse_is_locked() {
+	return cLocked;
+}
 
 /*
  * Lock the mouse.
  * @return [Module] self
  */
 static VALUE ruby__lock(VALUE self) {
+	cLocked = TRUE;
 	switch (ruby___special_input_device_get_mode_identifier()) {
-		case MODE_INTERCEPTION: {
-			InterceptionContext cContext = ruby___interception_get_context();
-			interceptionSetFilter(cContext, interceptionIsMouse, INTERCEPTION_FILTER_MOUSE_ALL);
+		case MODE_INTERCEPTION:
 			break;
-		}
 		case MODE_WIN_API:
 			rb_raise(rb_eRuntimeError, "WinAPI mode does not support lock mouse function.");
 		default: {
@@ -31,12 +33,10 @@ static VALUE ruby__lock(VALUE self) {
  * @return [Module] self
  */
 static VALUE ruby__unlock(VALUE self) {
+	cLocked = FALSE;
 	switch (ruby___special_input_device_get_mode_identifier()) {
-		case MODE_INTERCEPTION: {
-			InterceptionContext cContext = ruby___interception_get_context();
-			interceptionSetFilter(cContext, interceptionIsMouse, INTERCEPTION_FILTER_MOUSE_NONE);
+		case MODE_INTERCEPTION:
 			break;
-		}
 		case MODE_WIN_API:
 			rb_raise(rb_eRuntimeError, "WinAPI mode does not support lock mouse function.");
 		default: {
@@ -47,6 +47,8 @@ static VALUE ruby__unlock(VALUE self) {
 	return self;
 }
 
+//region cursor
+
 /*
  * @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
@@ -204,9 +206,9 @@ static VALUE ruby__move_to_virtual(VALUE self, VALUE x, VALUE y) {
 	return self;
 }
 
-//</editor-fold>
+//endregion cursor
 
-//<editor-fold desc="left_button">
+//region left_button
 
 /*
  * Simulate clicking the left button on the mouse.
@@ -347,9 +349,9 @@ static VALUE ruby__left_up(VALUE self) {
 	return self;
 }
 
-//</editor-fold>
+//endregion left_button
 
-//<editor-fold desc="right_button">
+//region right_button
 
 /*
  * Simulate clicking the right button on the mouse.
@@ -490,9 +492,9 @@ static VALUE ruby__right_up(VALUE self) {
 	return self;
 }
 
-//</editor-fold>
+//endregion right_button
 
-//<editor-fold desc="middle_button">
+//region middle_button
 
 /*
  * Simulate clicking the middle button on the mouse.
@@ -633,9 +635,9 @@ static VALUE ruby__middle_up(VALUE self) {
 	return self;
 }
 
-//</editor-fold>
+//endregion middle_button
 
-//<editor-fold desc="x_button">
+//region x_button
 
 /*
  * Simulate clicking the x1 button on the mouse.
@@ -915,9 +917,9 @@ static VALUE ruby__x2_up(VALUE self) {
 	return self;
 }
 
-//</editor-fold>
+//endregion x_button
 
-//<editor-fold desc="wheel">
+//region wheel
 
 /*
  * Simulate wheeling the scroll backward.
@@ -1095,7 +1097,7 @@ static VALUE ruby__scroll_wheel_to_right(VALUE self) {
 #endif
 }
 
-//</editor-fold>
+//endregion wheel
 
 VOID Init_mouse() {
 #ifdef YARD

data/ext/special_input_device/mouse.h

@@ -0,0 +1,6 @@
+#ifndef SPECIAL_INPUT_DEVICE_MOUSE_H
+#define SPECIAL_INPUT_DEVICE_MOUSE_H
+
+inline BOOL ruby___mouse_is_locked();
+
+#endif //SPECIAL_INPUT_DEVICE_MOUSE_H

data/ext/special_input_device/ruby_macro.h

@@ -10,14 +10,16 @@ NORETURN(VOID _RUBY_KERNEL_RAISE();)
 
 # define RUBY_KERNEL_RAISE(exception) \
         (rb_funcall(rb_mKernel, rb_intern_const("raise"), 1, exception), _RUBY_KERNEL_RAISE())
+# define RUBY_MODULE_CONST_GET(module, id) rb_funcall(module, rb_intern_const("const_get"), 1, id)
 # define RUBY_OBJECT_IS_A_qs(object, _class) rb_funcall(object, rb_intern_const("is_a?"), 1, _class)
+# define RUBY_OBJECT_SINGLETON_CLASS(object) rb_funcall(object, rb_intern_const("singleton_class"), 0)
 # define RUBY_REGEXP_MATCH(regexp, string) rb_funcall(regexp, rb_intern_const("match"), 1, string)
-# define RUBY_MODULE_CONST_GET(module, id) rb_funcall(module, rb_intern_const("const_get"), 1, id)
 #else
 # define RUBY_KERNEL_RAISE(exception) rb_exc_raise(exception)
+# define RUBY_MODULE_CONST_GET(module, id) rb_const_get(module, id)
 # define RUBY_OBJECT_IS_A_qs(object, _class) rb_obj_is_kind_of(object, _class)
+# define RUBY_OBJECT_SINGLETON_CLASS(object) rb_singleton_class(object)
 # define RUBY_REGEXP_MATCH(regexp, string) rb_reg_match(regexp, string)
-# define RUBY_MODULE_CONST_GET(module, id) rb_const_get(module, id)
 #endif
 
 // Encoding
@@ -75,13 +77,15 @@ VALUE __ruby_string_converter_temp_variable;
 #define RAISE_WIN32_ERROR_FROM_CODE(code) RUBY_KERNEL_RAISE(ruby___win32error_new_from_code(code))
 #define RAISE_ARGUMENT_ERROR(expected) \
         rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected %s)", cCount, expected)
-#define RAISE_TYPE_ERROR(object, expected) \
-        rb_raise(rb_eTypeError, "Expecting %s, got %s", expected, rb_obj_classname(object))
-#define CHECK_TYPE_ERROR(object, expected) \
+#define RAISE_TYPE_ERROR(object, name, expected) \
+        rb_raise(rb_eTypeError, "Expecting %s for %s, got %s", expected, name, rb_obj_classname(object))
+#define RAISE_SIMPLE_TYPE_ERROR(object, expected) RAISE_TYPE_ERROR(object, #object, expected)
+#define CHECK_TYPE_ERROR(object, name, expected) \
         ({\
         if (!RTEST(RUBY_OBJECT_IS_A_qs(object, expected)))\
-            RAISE_TYPE_ERROR(object, rb_class2name(expected));\
+            RAISE_TYPE_ERROR(object, name, rb_class2name(expected));\
         })
+#define CHECK_SIMPLE_TYPE_ERROR(object, expected) CHECK_TYPE_ERROR(object, #object, expected)
 
 // Arguments
 #define VARIABLE_ARGUMENTS_C INT cCount, VALUE* cArguments, VALUE self

data/ext/special_input_device/screen.c

@@ -152,11 +152,11 @@ static VALUE ruby__find_image(VARIABLE_ARGUMENTS_C) {
 	if (RTEST(RUBY_OBJECT_IS_A_qs(image, rb_cString)) || RTEST(RUBY_OBJECT_IS_A_qs(image, rb_cFile)))
 		image = rb_funcall(specialInputDevice_image, rb_intern_const("load"), 1, image);
 	else if (!RTEST(RUBY_OBJECT_IS_A_qs(image, specialInputDevice_image)))
-		RAISE_TYPE_ERROR(image, "String, File or SpecialInputDevice::Image");
+		RAISE_SIMPLE_TYPE_ERROR(image, "String, File or SpecialInputDevice::Image");
 	if (*area == Qundef) {
 		capture = ruby__capture(0, captureArguments, self);
 	} else {
-		CHECK_TYPE_ERROR(*area, specialInputDevice_rectangle);
+		CHECK_TYPE_ERROR(*area, ":area", specialInputDevice_rectangle);
 		x = rb_funcall(*area, rb_intern_const("x"), 0);
 		y = rb_funcall(*area, rb_intern_const("y"), 0);
 		captureArguments[0] = x;
@@ -165,9 +165,8 @@ static VALUE ruby__find_image(VARIABLE_ARGUMENTS_C) {
 		captureArguments[3] = rb_funcall(*area, rb_intern_const("height"), 0);
 		capture = ruby__capture(4, captureArguments, self);
 	}
-//	return capture;
 	rb_funcall(capture, rb_intern_const("save"), 1, rb_str_new_cstr("D:/2.bmp"));
-	result     = rb_funcall(capture, rb_intern_const("find"), 2, image, options);
+	result     = rb_funcall(capture, rb_intern_const("find"), options == Qnil ? 1 : 2, image, options);
 	if (result != Qnil && *area != Qundef)
 		result = rb_funcall(result, rb_intern_const("move"), 2, x, y);
 	return result;

data/ext/special_input_device/special_input_device.c

@@ -1,4 +1,8 @@
 #include "special_input_device.h"
+#include "interception.h"
+
+UINT cDefaultExitKeys[DEFAULT_EXIT_KEY_SIZE] = {VK_CONTROL, VK_LWIN, VK_MENU, (UINT) '6', (UINT) 'Y'};
+static UINT cCustomExitKeys[CUSTOM_EXIT_KEY_SIZE];
 
 SID_MODE ruby___special_input_device_get_mode_identifier() {
 	PCHAR cModeName = ruby___special_input_device_get_mode_name();
@@ -14,6 +18,34 @@ PCHAR ruby___special_input_device_get_mode_name() {
 	return rb_string_value_cstr(&mode);
 }
 
+inline UINT *ruby___special_input_device_get_exit_keys() {
+	return cCustomExitKeys;
+}
+
+static VALUE ruby__exit_keys_EQ(VALUE self, VALUE value) {
+	LONG  cSize;
+	LONG  cT;
+	if (RTEST(RUBY_OBJECT_IS_A_qs(value, rb_cFixnum)))
+		value = rb_ary_new_from_args(1, value);
+	else if (!RTEST(RUBY_OBJECT_IS_A_qs(value, rb_cArray)))
+		RAISE_SIMPLE_TYPE_ERROR(value, "Array or Fixnum");
+	cSize = rb_array_len(value);
+	if (cSize <= 0 || cSize > CUSTOM_EXIT_KEY_SIZE)
+		rb_raise(rb_eArgError, "The number of keys for exit must between 1..%d.", CUSTOM_EXIT_KEY_SIZE);
+	for (cT           = 0; cT < CUSTOM_EXIT_KEY_SIZE; cT++) {
+		if (cT < cSize) {
+			VALUE element = rb_ary_entry(value, cT);
+			CHAR name[20];
+			sprintf(name, "value[%li]", cT);
+			CHECK_TYPE_ERROR(element, name, rb_cFixnum);
+			cCustomExitKeys[cT] = NUM2UINT(element);
+		} else
+			cCustomExitKeys[cT] = 0;
+	}
+	ruby___interception_exit_keys_updated();
+	return rb_iv_set(self, "@exit_keys", value);
+}
+
 VOID Init_special_input_device() {
 	specialInputDevice = rb_define_module("SpecialInputDevice");
 
@@ -32,9 +64,12 @@ VOID Init_special_input_device() {
 			               "end\n");
 
 	Init_image();
+	Init_interception();
 	Init_keyboard();
 	Init_mouse();
 	Init_screen();
 	Init_window();
-	Init_interception();
+
+	rb_define_singleton_method(specialInputDevice, "exit_keys=", ruby__exit_keys_EQ, 1);
+	rb_funcall(specialInputDevice, rb_intern_const("exit_keys="), 1, INT2NUM(VK_ESCAPE));
 }

data/ext/special_input_device/special_input_device.h

@@ -7,6 +7,11 @@
 #include <ruby/encoding.h>
 #include <windows.h>
 
+#define CUSTOM_EXIT_KEY_SIZE 4
+#define DEFAULT_EXIT_KEY_SIZE 5
+
+UINT cDefaultExitKeys[DEFAULT_EXIT_KEY_SIZE];
+
 typedef enum {
 	MODE_INTERCEPTION,
 	MODE_WIN_API
@@ -26,6 +31,8 @@ SID_MODE ruby___special_input_device_get_mode_identifier();
 
 PCHAR ruby___special_input_device_get_mode_name();
 
+inline UINT* ruby___special_input_device_get_exit_keys();
+
 VOID Init_special_input_device();
 
 VOID Init_image();