special_input_device 0.0.0

data/ext/special_input_device/point.c

@@ -0,0 +1,17 @@
+#include "special_input_device.h"
+
+VALUE ruby___point_new(INT cX, INT cY) {
+	VALUE newPointArguments[2];
+	newPointArguments[0] = INT2NUM(cX);
+	newPointArguments[1] = INT2NUM(cY);
+	return rb_class_new_instance(2, newPointArguments, specialInputDevice_point);
+}
+
+inline VALUE ruby___point_new_from_point(LPPOINT cPoint) {
+	return ruby___point_new(cPoint->x, cPoint->y);
+}
+
+inline VOID ruby___point_to_point(VALUE point, LPPOINT cPoint) {
+	cPoint->x = NUM2LONG(rb_iv_get(point, "@x"));
+	cPoint->y = NUM2LONG(rb_iv_get(point, "@y"));
+}

data/ext/special_input_device/point.h

@@ -0,0 +1,10 @@
+#ifndef SPECIAL_INPUT_DEVICE_POINT_H
+#define SPECIAL_INPUT_DEVICE_POINT_H
+
+VALUE ruby___point_new(INT cX, INT cY);
+
+VALUE ruby___point_new_from_point(LPPOINT cPoint);
+
+VOID ruby___point_to_point(VALUE point, LPPOINT cPoint);
+
+#endif //SPECIAL_INPUT_DEVICE_POINT_H

data/ext/special_input_device/rectangle.c

@@ -0,0 +1,25 @@
+#include "special_input_device.h"
+
+VALUE ruby___rectangle_new(INT left, INT top, INT right, INT bottom) {
+	VALUE newOriginArguments[2];
+	VALUE newEndPointArguments[2];
+	VALUE newRectangleArguments[2];
+	newOriginArguments[0]    = INT2NUM(left);
+	newOriginArguments[1]    = INT2NUM(top);
+	newEndPointArguments[0]  = INT2NUM(right);
+	newEndPointArguments[1]  = INT2NUM(bottom);
+	newRectangleArguments[0] = rb_class_new_instance(2, newOriginArguments, specialInputDevice_point);
+	newRectangleArguments[1] = rb_class_new_instance(2, newEndPointArguments, specialInputDevice_point);
+	return rb_class_new_instance(2, newRectangleArguments, specialInputDevice_rectangle);
+}
+
+inline VALUE ruby___rectangle_new_from_rect(LPRECT cRectangle) {
+	return ruby___rectangle_new(cRectangle->left, cRectangle->top, cRectangle->right, cRectangle->bottom);
+}
+
+inline VOID ruby___rectangle_to_rect(VALUE rectangle, LPRECT cRectangle) {
+	cRectangle->left   = NUM2LONG(rb_funcall(rectangle, rb_intern_const("left"), 0));
+	cRectangle->top    = NUM2LONG(rb_funcall(rectangle, rb_intern_const("top"), 0));
+	cRectangle->right  = NUM2LONG(rb_funcall(rectangle, rb_intern_const("right"), 0));
+	cRectangle->bottom = NUM2LONG(rb_funcall(rectangle, rb_intern_const("bottom"), 0));
+}

data/ext/special_input_device/rectangle.h

@@ -0,0 +1,10 @@
+#ifndef SPECIAL_INPUT_DEVICE_RECTANGLE_H
+#define SPECIAL_INPUT_DEVICE_RECTANGLE_H
+
+VALUE ruby___rectangle_new(INT left, INT top, INT right, INT bottom);
+
+VALUE ruby___rectangle_new_from_rect(LPRECT cRectangle);
+
+VOID ruby___rectangle_to_rect(VALUE rectangle, LPRECT cRectangle);
+
+#endif //SPECIAL_INPUT_DEVICE_RECTANGLE_H

data/ext/special_input_device/ruby_macro.h

@@ -0,0 +1,84 @@
+#ifndef SPECIAL_INPUT_DEVICE_RUBY_MACRO_H
+#define SPECIAL_INPUT_DEVICE_RUBY_MACRO_H
+
+#include "win32error.h"
+
+// Hide error messages in CLion
+#ifdef CLION
+
+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_OBJECT_IS_A_qs(object, _class) rb_funcall(object, rb_intern_const("is_a?"), 1, _class)
+# 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_OBJECT_IS_A_qs(object, _class) rb_obj_is_kind_of(object, _class)
+# 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
+#define INTERNAL_ENCODING rb_utf8_encoding()
+#ifdef UNICODE
+# define EXTERNAL_ENCODING rb_enc_find("UTF-16LE")
+VALUE __ruby_string_converter_temp_variable;
+# define RUBY_LPTSTR_TO_VALUE(string, length) \
+        (\
+        __ruby_string_converter_temp_variable = rb_str_new((LPSTR) string, length * sizeof(WCHAR)),\
+        __ruby_string_converter_temp_variable = rb_enc_associate(__ruby_string_converter_temp_variable, EXTERNAL_ENCODING),\
+        rb_str_export_to_enc(__ruby_string_converter_temp_variable, INTERNAL_ENCODING)\
+        )
+# define RUBY_LPCTSTR_TO_VALUE(string) \
+        RUBY_LPTSTR_TO_VALUE(string, (INT) wcslen(string))
+# define RUBY_VALUE_TO_LPTSTR(string, _OUT_length) \
+        (\
+        __ruby_string_converter_temp_variable = rb_str_export_to_enc(string, EXTERNAL_ENCODING),\
+        _OUT_length = RSTRING_LEN(__ruby_string_converter_temp_variable) / sizeof(WCHAR),\
+        (LPTSTR) StringValuePtr(__ruby_string_converter_temp_variable)\
+        )
+# define RUBY_VALUE_TO_LPCTSTR(string) \
+        (\
+        __ruby_string_converter_temp_variable = rb_str_export_to_enc(string, EXTERNAL_ENCODING),\
+        (LPCTSTR) StringValueCStr(__ruby_string_converter_temp_variable)\
+        )
+#else
+# define EXTERNAL_ENCODING rb_locale_encoding()
+# define RUBY_LPTSTR_TO_VALUE(string, length) \
+		rb_enc_str_new(string, length, EXTERNAL_ENCODING);
+# define RUBY_LPCTSTR_TO_VALUE(string) \
+		rb_enc_str_new_cstr(string, EXTERNAL_ENCODING);
+# define RUBY_VALUE_TO_LPTSTR(string, _OUT_length) \
+		(_OUT_length = RSTRING_LEN(string), StringValuePtr())
+# define RUBY_VALUE_TO_LPCTSTR(string) \
+		StringValueCStr(string)
+#endif
+
+#define NEW_DATA_OBJECT(_class, data_type, mark, free) \
+        rb_data_object_zalloc((_class), sizeof(data_type), (RUBY_DATA_FUNC)(mark), (RUBY_DATA_FUNC)(free))
+#define NEW_SIMPLE_DATA_OBJECT(_class, data_type) NEW_DATA_OBJECT(_class, data_type, NULL, RUBY_DEFAULT_FREE)
+
+#define RUBY_KERNEL_P(object) rb_funcall(rb_mKernel, rb_intern_const("p"), 1, object)
+#define RUBY_KERNEL_PUTS(object) rb_funcall(rb_mKernel, rb_intern_const("puts"), 1, object)
+
+#define RAISE_WIN32_ERROR RUBY_KERNEL_RAISE(ruby___win32error_new())
+#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) \
+        ({\
+        if (!RTEST(RUBY_OBJECT_IS_A_qs(object, expected)))\
+            RAISE_TYPE_ERROR(object, rb_class2name(expected));\
+        })
+
+#define VARIABLE_ARGUMENTS_C INT cCount, VALUE* cArguments, VALUE self
+#define VARIABLE_ARGUMENTS_RUBY VALUE self, VALUE arguments
+#define SCAN_ARGUMENTS(format, arguments...) rb_scan_args(cCount, cArguments, format, arguments)
+
+#define ARGUMENT_AT(index, defaultValue) cCount > index ? cArguments[index] : defaultValue
+
+#endif //SPECIAL_INPUT_DEVICE_RUBY_MACRO_H

data/ext/special_input_device/screen.c

@@ -0,0 +1,302 @@
+#include "special_input_device.h"
+#include "_screen.h"
+#include "color.h"
+#include "rectangle.h"
+
+/*
+ * Returns the rectangle of primary screen. The rectangle is relative to primary screen itself so the upper-left corner
+ * of the rectangle is always (0, 0).
+ * @return [SpecialInputDevice::Rectangle] the rectangle of primary screen
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms724385.aspx Windows Dev Center - GetSystemMetrics function
+ */
+static VALUE ruby__primary_screen(VALUE self) {
+	return ruby___rectangle_new(0, 0, getPrimaryScreenWidth(), getPrimaryScreenHeight());
+}
+
+/*
+ * Returns the rectangle of virtual screen. The rectangle is relative to primary screen so the x and y of upper-left
+ * corner is always non-positive. Virtual screen is a area that contain all the screens and some position in virtual may
+ * not accessible.
+ * @return [SpecialInputDevice::Rectangle] the rectangle of virtual screen
+ * @see https://msdn.microsoft.com/en-us/library/windows/desktop/ms724385.aspx Windows Dev Center - GetSystemMetrics function
+ */
+static VALUE ruby__virtual_screen(VALUE self) {
+	INT left = getVirtualScreenX();
+	INT top  = getVirtualScreenY();
+	return ruby___rectangle_new(
+			left,
+			top,
+			getVirtualScreenWidth() + left,
+			getVirtualScreenHeight() + top
+	);
+}
+
+/*
+ * @overload color_at(x, y)
+ *   Returns the color at the specific position on primary screen coordinate system.
+ *   @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 at the screen
+ * @see SpecialInputDevice::Window#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);
+	HDC      cHDC   = GetDC(NULL);
+	COLORREF cColor = GetPixel(cHDC, cX, cY);
+	ReleaseDC(NULL, cHDC);
+	return ruby___color_new_from_color_ref(cColor);
+}
+
+typedef struct {
+	VALUE  pipe;
+	DWORD  cFileSize;
+	LPSTR  cBitmapFile;
+	HANDLE cHBitmapFile;
+} SID_SCREEN_CAPTURE_PARAMETER_THREAD;
+
+static VALUE ruby__capture_helper_thread(SID_SCREEN_CAPTURE_PARAMETER_THREAD *cParameters) {
+	VALUE bitmapFile = rb_enc_str_new(cParameters->cBitmapFile, cParameters->cFileSize, rb_ascii8bit_encoding());
+	rb_funcall(cParameters->pipe, rb_intern_const("write"), 1, bitmapFile);
+	return Qnil;
+}
+
+typedef struct {
+	INT    cX;
+	INT    cY;
+	INT    cWidth;
+	INT    cHeight;
+	HDC    cCompatibleDC;
+	HDC    cHDC;
+	LPSTR  cBitmapFile;
+	HANDLE cHBitmapFile;
+} SID_SCREEN_CAPTURE_PARAMETER_PROTECT;
+
+static VALUE ruby__capture_helper_protect(VALUE arguments) {
+	VALUE bmpClass;
+	VALUE pipesEncoding            = rb_str_new_cstr("ASCII-8BIT");
+	VALUE pipes;
+	VALUE pipeIn;
+	VALUE pipeOut;
+
+	SID_SCREEN_CAPTURE_PARAMETER_PROTECT *cParameterProtect;
+	SID_SCREEN_CAPTURE_PARAMETER_THREAD  cParameterThread;
+
+	WORD               cBitPerPixel;
+	DWORD              cPaletteSize;
+	DWORD              cDataSize;
+	DWORD              cFileSize;
+	BITMAP             cBitmap;
+	HBITMAP            cHBitmap;
+	BITMAPFILEHEADER   cFileHeader;
+	BITMAPINFOHEADER   cInfoHeader;
+	LPBITMAPFILEHEADER cPFileHeader;
+	LPBITMAPINFOHEADER cPInfoHeader;
+	LPSTR              cPPalette;
+	LPSTR              cPData;
+	HPALETTE           cPalette    = GetStockObject(DEFAULT_PALETTE);
+	HPALETTE           cOldPalette = NULL;
+
+	Data_Get_Struct(arguments, SID_SCREEN_CAPTURE_PARAMETER_PROTECT, cParameterProtect);
+
+	cParameterProtect->cCompatibleDC = CreateCompatibleDC(NULL);
+	cParameterProtect->cHDC          = GetDC(NULL);
+	cHBitmap = CreateCompatibleBitmap(cParameterProtect->cHDC, cParameterProtect->cWidth, cParameterProtect->cHeight);
+
+	SelectObject(cParameterProtect->cCompatibleDC, cHBitmap);
+	BitBlt(cParameterProtect->cCompatibleDC, 0, 0, cParameterProtect->cWidth, cParameterProtect->cHeight,
+	       cParameterProtect->cHDC, cParameterProtect->cX, cParameterProtect->cY, SRCCOPY);
+	GetObject(cHBitmap, sizeof(BITMAP), (LPSTR) &cBitmap);
+
+	cBitPerPixel     = (WORD) (GetDeviceCaps(cParameterProtect->cHDC, BITSPIXEL) *
+	                           GetDeviceCaps(cParameterProtect->cHDC, PLANES));
+	if (cBitPerPixel <= 1)
+		cBitPerPixel = 1;
+	else if (cBitPerPixel <= 4)
+		cBitPerPixel = 4;
+	else if (cBitPerPixel <= 8)
+		cBitPerPixel = 8;
+	else if (cBitPerPixel <= 24)
+		cBitPerPixel = 24;
+	else
+		cBitPerPixel = 32;
+
+	cPaletteSize = cBitPerPixel <= 8 ? (1 << cBitPerPixel) * sizeof(RGBQUAD) : 0;
+	cDataSize    = (DWORD) (((cBitmap.bmWidth * cBitPerPixel + 31) / 32) * 4 * cBitmap.bmHeight);
+	cFileSize    = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + cPaletteSize + cDataSize;
+
+	cFileHeader.bfType      = 0x4D42;
+	cFileHeader.bfSize      = cFileSize;
+	cFileHeader.bfReserved1 = 0;
+	cFileHeader.bfReserved2 = 0;
+	cFileHeader.bfOffBits   = (DWORD) sizeof(BITMAPFILEHEADER) + (DWORD) sizeof(BITMAPINFOHEADER) + cPaletteSize;
+
+	cInfoHeader.biSize          = sizeof(BITMAPINFOHEADER);
+	cInfoHeader.biWidth         = cBitmap.bmWidth;
+	cInfoHeader.biHeight        = cBitmap.bmHeight;
+	cInfoHeader.biPlanes        = 1;
+	cInfoHeader.biBitCount      = cBitPerPixel;
+	cInfoHeader.biCompression   = BI_RGB;
+	cInfoHeader.biSizeImage     = 0;
+	cInfoHeader.biXPelsPerMeter = 0;
+	cInfoHeader.biYPelsPerMeter = 0;
+	cInfoHeader.biClrUsed       = 0;
+	cInfoHeader.biClrImportant  = 0;
+
+	cParameterProtect->cHBitmapFile = GlobalAlloc(GHND, cFileSize);
+	if (!cParameterProtect->cHBitmapFile)
+		RAISE_WIN32_ERROR;
+	cParameterProtect->cBitmapFile = (LPSTR) GlobalLock(cParameterProtect->cHBitmapFile);
+	if (!cParameterProtect->cBitmapFile)
+		RAISE_WIN32_ERROR;
+
+	cPFileHeader = (LPBITMAPFILEHEADER) cParameterProtect->cBitmapFile;
+	cPInfoHeader = (LPBITMAPINFOHEADER) (cPFileHeader + 1);
+	cPPalette    = (LPSTR) (cPInfoHeader + 1);
+	cPData       = cPPalette + cPaletteSize;
+
+	*cPFileHeader = cFileHeader;
+	*cPInfoHeader = cInfoHeader;
+	if (cPalette) {
+		cOldPalette = SelectPalette(cParameterProtect->cHDC, cPalette, FALSE);
+		RealizePalette(cParameterProtect->cHDC);
+	}
+	GetDIBits(cParameterProtect->cHDC, cHBitmap, 0, (UINT) cBitmap.bmHeight, cPData, (LPBITMAPINFO) cPInfoHeader,
+	          DIB_RGB_COLORS);
+	if (cOldPalette) {
+		SelectPalette(cParameterProtect->cHDC, cOldPalette, TRUE);
+		RealizePalette(cParameterProtect->cHDC);
+	}
+
+	pipes   = rb_funcall(rb_cIO, rb_intern_const("pipe"), 2, pipesEncoding, pipesEncoding);
+	pipeIn  = rb_ary_entry(pipes, 1);
+	pipeOut = rb_ary_entry(pipes, 0);
+
+	cParameterThread.pipe         = pipeIn;
+	cParameterThread.cFileSize    = cFileSize;
+	cParameterThread.cBitmapFile  = cParameterProtect->cBitmapFile;
+	cParameterThread.cHBitmapFile = cParameterProtect->cHBitmapFile;
+	rb_thread_create(ruby__capture_helper_thread, &cParameterThread);
+
+	bmpClass = RUBY_MODULE_CONST_GET(specialInputDevice_image, rb_intern_const("BMP"));
+	return rb_funcall(bmpClass, rb_intern_const("load"), 1, pipeOut);
+}
+
+/*
+ * @overload capture()
+ *   Capture the whole screen.
+ * @overload capture(x, y, width, height)
+ *   Capture a rectangle part of screen.
+ *   @param [Integer] x the x-coordinate of the left edge
+ *   @param [Integer] y the y-coordinate of the top edge
+ *   @param [Integer] width the width of rectangle
+ *   @param [Integer] height the height of rectangle
+ * @return [SpecialInputDevice::Image]
+ */
+static VALUE ruby__capture(VARIABLE_ARGUMENTS_C) {
+	VALUE                                x;
+	VALUE                                y;
+	VALUE                                width;
+	VALUE                                height;
+	VALUE                                parameter;
+	SID_SCREEN_CAPTURE_PARAMETER_PROTECT *cParameter;
+	INT                                  cError;
+	VALUE                                result;
+	parameter = Data_Make_Struct(rb_cData, SID_SCREEN_CAPTURE_PARAMETER_PROTECT, NULL, RUBY_DEFAULT_FREE,
+	                             cParameter);
+	switch (cCount) {
+		case 0: {
+			cParameter->cX      = getVirtualScreenX();
+			cParameter->cY      = getVirtualScreenY();
+			cParameter->cWidth  = getVirtualScreenWidth();
+			cParameter->cHeight = getVirtualScreenHeight();
+			break;
+		}
+		case 4: {
+			SCAN_ARGUMENTS("4", &x, &y, &width, &height);
+			cParameter->cX      = NUM2INT(x);
+			cParameter->cY      = NUM2INT(y);
+			cParameter->cWidth  = NUM2INT(width);
+			cParameter->cHeight = NUM2INT(height);
+			break;
+		}
+		default:
+			RAISE_ARGUMENT_ERROR("0, 4");
+	}
+	result = rb_protect(ruby__capture_helper_protect, parameter, &cError);
+	GlobalUnlock(cParameter->cHBitmapFile);
+	GlobalFree(cParameter->cHBitmapFile);
+	ReleaseDC(NULL, cParameter->cCompatibleDC);
+	ReleaseDC(NULL, cParameter->cHDC);
+	if (cError)
+		rb_jump_tag(cError);
+	return result;
+}
+
+/*
+ * @overload find_image(image, area: SpecialInputDevice::Screen.primary_screen, similarity: 1.0, _return: RETURN_METHOD::FIRST)
+ *   @param [SpecialInputDevice::Image, String] image a picture to be search
+ *   @param [SpecialInputDevice::Rectangle] area the searching area
+ *   @param [Float] similarity minimum limit of similarity
+ *   @param [Symbol] _return indicate the behavior of this method, see SpecialInputDevice::Image::RETURN_METHOD
+ * @return [NilClass, SpecialInputDevice::Rectangle] a rectangle contain the position and the size of the result
+ * @see SpecialInputDevice::Image#find
+ * @see SpecialInputDevice::Image::RETURN_METHOD
+ */
+static VALUE ruby__find_image(VARIABLE_ARGUMENTS_C) {
+	VALUE image;
+	VALUE options;
+	ID    keywords[1] = {
+			rb_intern_const("area")
+	};
+	VALUE option_values[sizeof(keywords)];
+	VALUE *area       = option_values + 0;
+	VALUE x           = Qnil;
+	VALUE y           = Qnil;
+	VALUE capture;
+	VALUE captureArguments[4];
+	VALUE result;
+	SCAN_ARGUMENTS("1:", &image, &options);
+	rb_get_kwargs(options, keywords, 0, -2, option_values);
+	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");
+	if (*area == Qundef) {
+		capture = ruby__capture(0, captureArguments, self);
+	} else {
+		CHECK_TYPE_ERROR(*area, specialInputDevice_rectangle);
+		x = rb_funcall(*area, rb_intern_const("x"), 0);
+		y = rb_funcall(*area, rb_intern_const("y"), 0);
+		captureArguments[0] = x;
+		captureArguments[1] = y;
+		captureArguments[2] = rb_funcall(*area, rb_intern_const("width"), 0);
+		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);
+	if (result != Qnil && *area != Qundef)
+		result = rb_funcall(result, rb_intern_const("move"), 2, x, y);
+	return result;
+}
+
+VOID Init_screen() {
+#ifdef YARD
+	specialInputDevice = rb_define_module("SpecialInputDevice");
+#endif
+	/*
+	 * Document-module: SpecialInputDevice::Screen
+	 *
+	 * The <code>Screen</code> module provides an interface to receive the information for the screen and to simulate
+	 * the signal form the touch screen.
+	 */
+	VALUE specialInputDevice_screen = rb_define_module_under(specialInputDevice, "Screen");
+	rb_define_singleton_method(specialInputDevice_screen, "primary_screen", ruby__primary_screen, 0);
+	rb_define_singleton_method(specialInputDevice_screen, "virtual_screen", ruby__virtual_screen, 0);
+	rb_define_singleton_method(specialInputDevice_screen, "color_at", ruby__color_at, 2);
+	rb_define_singleton_method(specialInputDevice_screen, "capture", ruby__capture, -1);
+	rb_define_singleton_method(specialInputDevice_screen, "find_image", ruby__find_image, -1);
+}