special_input_device 0.0.0 → 0.0.1

data/ext/special_input_device/image.c

@@ -0,0 +1,728 @@
+#include "special_input_device.h"
+#include "color.h"
+
+#define BI_RGB 0L
+#define BI_BITFIELDS 3L
+#define BI_ALPHABITFIELDS 6L
+
+#define PixelAt(x, y) (cData->pixelTable[cData->height + ~y][x])
+
+static VALUE ruby__alloc(VALUE self);
+
+typedef struct {
+	UINT    height;
+	RGBQUAD **pixelTable;
+} SID_IMAGE_DATA;
+
+VALUE ruby___image_new(UINT cWidth, UINT cHeight) {
+	VALUE          instance = ruby__alloc(specialInputDevice_image);
+	SID_IMAGE_DATA *cData   = GET_DATA_OBJECT(instance);
+	UINT           cT;
+	cData->height     = cHeight;
+	cData->pixelTable = ALLOC_N(LPRGBQUAD, cHeight);
+	rb_iv_set(instance, "@width", UINT2NUM(cWidth));
+	rb_iv_set(instance, "@height", UINT2NUM(cHeight));
+	for (cT = 0; cT < cHeight; cT++)
+		cData->pixelTable[cT] = ALLOC_N(RGBQUAD, cWidth);
+	return instance;
+}
+
+VALUE ruby___image_new_from_bitmap(HBITMAP cHBitmap) {
+	VALUE          instance;
+	SID_IMAGE_DATA *cData;
+	HDC            cScreenDC = GetDC(NULL);
+	BITMAP         cBitmap;
+	UINT           cWidth;
+	UINT           cHeight;
+	BITMAPINFO     cBitmapInfo;
+	UINT           cT0;
+	UINT           cT1;
+	GetObject(cHBitmap, sizeof(BITMAP), &cBitmap);
+	cWidth   = (UINT) abs(cBitmap.bmWidth);
+	cHeight  = (UINT) abs(cBitmap.bmHeight);
+	instance = ruby___image_new(cWidth, cHeight);
+	cData    = GET_DATA_OBJECT(instance);
+	cBitmapInfo.bmiHeader.biSize          = sizeof(BITMAPINFOHEADER);
+	cBitmapInfo.bmiHeader.biWidth         = (LONG) cWidth;
+	cBitmapInfo.bmiHeader.biHeight        = (LONG) cHeight;
+	cBitmapInfo.bmiHeader.biPlanes        = 1;
+	cBitmapInfo.bmiHeader.biBitCount      = 32;
+	cBitmapInfo.bmiHeader.biCompression   = BI_RGB;
+	cBitmapInfo.bmiHeader.biSizeImage     = 0;
+	cBitmapInfo.bmiHeader.biXPelsPerMeter = 0;
+	cBitmapInfo.bmiHeader.biYPelsPerMeter = 0;
+	cBitmapInfo.bmiHeader.biClrUsed       = 0;
+	cBitmapInfo.bmiHeader.biClrImportant  = 0;
+	for (cT0 = 0; cT0 < cHeight; cT0++) {
+		GetDIBits(cScreenDC, cHBitmap, cT0, 1, cData->pixelTable[cT0], &cBitmapInfo, DIB_RGB_COLORS);
+		for (cT1 = 0; cT1 < cWidth; cT1++)
+			cData->pixelTable[cT0][cT1].rgbReserved = 0xFF;
+	}
+	return instance;
+}
+
+typedef union {
+	BITMAPINFOHEADER v1;
+	BITMAPV4HEADER   v4;
+	BITMAPV5HEADER   v5;
+} DIB_HEADER;
+
+/*
+ * Load an image from a file.
+ * @overload load(path)
+ *   @param [String] path a path of file
+ * @return [SpecialInputDevice::Image] a new image
+ */
+static VALUE ruby__load(VALUE self, VALUE path) {
+	LPCTSTR          cPath = RUBY_VALUE_TO_LPCTSTR(path);
+	VALUE            image;
+	SID_IMAGE_DATA   *cData;
+	FILE             *cFile;
+	BITMAPFILEHEADER cFileHeader;
+	DIB_HEADER       cDIBHeader;
+	RGBQUAD          *cColorTable;
+	BYTE             *cPixelArray;
+	LARGE_INTEGER    cSystemFileSize;
+	UINT             cWidth;
+	UINT             cHeight;
+	UINT             cRowSize;
+	DWORD            cByteRead;
+	UINT             cT0;
+	UINT             cT1;
+	UINT             cT2;
+	UINT             cT3;
+	cFile = CreateFile(cPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
+	                   FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
+	if (cFile == INVALID_HANDLE_VALUE)
+		RAISE_WIN32_ERROR();
+	if (!ReadFile(cFile, &cFileHeader, sizeof(cFileHeader), &cByteRead, NULL))
+		RAISE_WIN32_ERROR();
+	switch (cFileHeader.bfType) {
+		case 0x4D42: // BM
+		case 0x4142: // BA
+		case 0x4943: // CI
+		case 0x5043: // CP
+		case 0x4349: // IC
+		case 0x5450: // PT
+			break;
+		default:
+			rb_raise(rb_eArgError, "The path does not point to a bitmap file.");
+	}
+	if (!GetFileSizeEx(cFile, &cSystemFileSize))
+		RAISE_WIN32_ERROR();
+	if (cSystemFileSize.QuadPart != cFileHeader.bfSize)
+		rb_raise(rb_eArgError, "The size of the file should be %lu bytes, but the image only has %lli bytes.",
+		         cFileHeader.bfSize, cSystemFileSize.QuadPart);
+	if (!ReadFile(cFile, &cDIBHeader.v1.biSize, sizeof(DWORD), &cByteRead, NULL))
+		RAISE_WIN32_ERROR();
+	switch (cDIBHeader.v1.biSize) {
+		case sizeof(BITMAPINFOHEADER):
+		case sizeof(BITMAPV4HEADER):
+		case sizeof(BITMAPV5HEADER):
+			break;
+		default:
+			rb_raise(rb_eArgError, "The bitmap file is using an unsupported DIB header.");
+	}
+	if (!ReadFile(cFile, &cDIBHeader.v1.biSize + 1, cDIBHeader.v1.biSize - sizeof(DWORD), &cByteRead, NULL))
+		RAISE_WIN32_ERROR();
+	cWidth  = (UINT) abs(cDIBHeader.v1.biWidth);
+	cHeight = (UINT) abs(cDIBHeader.v1.biHeight);
+	cRowSize =
+			(cDIBHeader.v1.biBitCount * cWidth + (8 * sizeof(RGBQUAD) - 1)) / (8 * sizeof(RGBQUAD)) * sizeof(RGBQUAD);
+	if (cDIBHeader.v1.biWidth < 0)
+		rb_raise(rb_eArgError, "The bitmap file has been damaged. (width < 0)");
+	if (cDIBHeader.v1.biPlanes != 1)
+		rb_raise(rb_eArgError, "The bitmap file has been damaged. (planes != 1)");
+	switch (cDIBHeader.v1.biCompression) {
+		case BI_RGB:
+			break;
+		case BI_BITFIELDS:
+		case BI_ALPHABITFIELDS:
+			switch (cDIBHeader.v1.biBitCount) {
+				case 16:
+				case 24:
+				case 32:
+					break;
+				default:
+					rb_raise(rb_eArgError, "The bitmap file is using an unsupported compression method.");
+			}
+			break;
+		default:
+			rb_raise(rb_eArgError, "The bitmap file is using an unsupported compression method.");
+	}
+	if (cDIBHeader.v1.biSizeImage != cRowSize * cHeight)
+		rb_raise(rb_eArgError, "The bitmap file has been damaged. (incorrect sizeImage)");
+	switch (cDIBHeader.v1.biSize) {
+		case sizeof(BITMAPINFOHEADER):
+			switch (cDIBHeader.v1.biCompression) {
+				case BI_BITFIELDS:
+					if (!ReadFile(cFile, &cDIBHeader.v5.bV5RedMask, sizeof(DWORD) * 3, &cByteRead, NULL))
+						RAISE_WIN32_ERROR();
+					cDIBHeader.v5.bV5AlphaMask = 0x00000000;
+					break;
+				case BI_ALPHABITFIELDS:
+					if (!ReadFile(cFile, &cDIBHeader.v5.bV5RedMask, sizeof(DWORD) * 4, &cByteRead, NULL))
+						RAISE_WIN32_ERROR();
+					break;
+				default:
+					switch (cDIBHeader.v1.biBitCount) {
+						case 1:
+						case 4:
+						case 8:
+							cDIBHeader.v5.bV5RedMask   = 0;
+							cDIBHeader.v5.bV5GreenMask = 0;
+							cDIBHeader.v5.bV5BlueMask  = 0;
+							cDIBHeader.v5.bV5AlphaMask = 0;
+						case 16:
+							cDIBHeader.v5.bV5RedMask   = 0x7C00;
+							cDIBHeader.v5.bV5GreenMask = 0x03E0;
+							cDIBHeader.v5.bV5BlueMask  = 0x001F;
+							cDIBHeader.v5.bV5AlphaMask = 0x0000;
+						case 24:
+							cDIBHeader.v5.bV5RedMask   = 0xFF0000;
+							cDIBHeader.v5.bV5GreenMask = 0x00FF00;
+							cDIBHeader.v5.bV5BlueMask  = 0x0000FF;
+							cDIBHeader.v5.bV5AlphaMask = 0x000000;
+							break;
+						case 32:
+							cDIBHeader.v5.bV5RedMask   = 0x00FF0000;
+							cDIBHeader.v5.bV5GreenMask = 0x0000FF00;
+							cDIBHeader.v5.bV5BlueMask  = 0x000000FF;
+							cDIBHeader.v5.bV5AlphaMask = 0x00000000;
+							break;
+						default:
+							break;
+					}
+					break;
+			}
+			cDIBHeader.v5.bV5CSType                        = LCS_WINDOWS_COLOR_SPACE;
+			cDIBHeader.v5.bV5Endpoints.ciexyzRed.ciexyzX   = 0;
+			cDIBHeader.v5.bV5Endpoints.ciexyzRed.ciexyzY   = 0;
+			cDIBHeader.v5.bV5Endpoints.ciexyzRed.ciexyzZ   = 0;
+			cDIBHeader.v5.bV5Endpoints.ciexyzGreen.ciexyzX = 0;
+			cDIBHeader.v5.bV5Endpoints.ciexyzGreen.ciexyzY = 0;
+			cDIBHeader.v5.bV5Endpoints.ciexyzGreen.ciexyzZ = 0;
+			cDIBHeader.v5.bV5Endpoints.ciexyzBlue.ciexyzX  = 0;
+			cDIBHeader.v5.bV5Endpoints.ciexyzBlue.ciexyzY  = 0;
+			cDIBHeader.v5.bV5Endpoints.ciexyzBlue.ciexyzZ  = 0;
+			cDIBHeader.v5.bV5GammaRed                      = 0;
+			cDIBHeader.v5.bV5GammaGreen                    = 0;
+			cDIBHeader.v5.bV5GammaBlue                     = 0;
+		case sizeof(BITMAPV4HEADER):
+			cDIBHeader.v5.bV5Intent                        = LCS_GM_ABS_COLORIMETRIC;
+			cDIBHeader.v5.bV5ProfileData                   = 0;
+			cDIBHeader.v5.bV5ProfileSize                   = 0;
+			cDIBHeader.v5.bV5Reserved                      = 0;
+		case sizeof(BITMAPV5HEADER):
+			break;
+		default:
+			break;
+	}
+
+	cColorTable = NULL;
+	switch (cDIBHeader.v1.biBitCount) {
+		case 1:
+		case 4:
+		case 8: {
+			UINT cColorTableSize    = cDIBHeader.v1.biClrUsed;
+			UINT cMaxColorTableSize = (UINT) (1 << cDIBHeader.v1.biBitCount);
+			if (cColorTableSize > cMaxColorTableSize)
+				rb_raise(rb_eArgError, "The bitmap file has been damaged. (clrUsed too large)");
+			if (cColorTableSize == 0)
+				cColorTableSize     = cMaxColorTableSize;
+			cColorTable             = ALLOC_N(RGBQUAD, cColorTableSize);
+			ReadFile(cFile, cColorTable, sizeof(RGBQUAD) * cColorTableSize, &cByteRead, NULL);
+			break;
+		}
+		case 16:
+		case 24:
+		case 32:
+			break;
+		default:
+			rb_raise(rb_eArgError, "The bitmap file is using unsupported color depth.");
+	}
+
+	if (!SetFilePointer(cFile, cFileHeader.bfOffBits, NULL, FILE_BEGIN))
+		RAISE_WIN32_ERROR();
+
+	image = ruby___image_new(cWidth, cHeight);
+	cData = GET_DATA_OBJECT(image);
+
+	cPixelArray = ALLOC_N(BYTE, cRowSize);
+	for (cT0    = 0; cT0 < cHeight; cT0++) {
+		UINT cPixelY = cDIBHeader.v1.biHeight >= 0 ? cT0 : cHeight + ~cT0;
+		if (!ReadFile(cFile, cPixelArray, cRowSize, &cByteRead, NULL))
+			RAISE_WIN32_ERROR();
+		switch (cDIBHeader.v1.biBitCount) {
+			case 1:
+			case 4:
+			case 8: {
+				INT cPixelPerByte = 8 / cDIBHeader.v1.biBitCount;
+				for (cT1 = 0; cT1 < cWidth; cT1++) {
+					INT cByteIndex  = cT1 / cPixelPerByte;
+					INT cBitsIndex  = (cPixelPerByte + ~(cT1 % cPixelPerByte)) * cDIBHeader.v1.biBitCount;
+					INT cBitsFilter = (1 << cDIBHeader.v1.biBitCount) - 1;
+					INT cColorIndex = (cPixelArray[cByteIndex] >> cBitsIndex) & cBitsFilter;
+					cData->pixelTable[cPixelY][cT1] = cColorTable[cColorIndex];
+					cData->pixelTable[cPixelY][cT1].rgbReserved = 0xFF;
+				}
+				break;
+			}
+			case 16:
+			case 24:
+			case 32: {
+				BYTE *cPixel;
+				INT  cBytePrePixel = cDIBHeader.v1.biBitCount / 8;
+				LONG cValue;
+				LONG cMask;
+				LONG cBuffer;
+				LONG cBitIndex;
+				LONG cBit;
+
+				for (cT1 = 0; cT1 < cWidth; cT1++) {
+
+					cPixel = (BYTE *) &cData->pixelTable[cPixelY][cT1];
+
+					cValue   = 0;
+					for (cT2 = 0; cT2 < cBytePrePixel; cT2++)
+						cValue += ((LONG) cPixelArray[cT1 * cBytePrePixel + cT2]) << (cT2 * 8);
+
+					for (cT2 = 0; cT2 < 4; cT2++) {
+						switch (cT2) {
+							case 0:
+								cMask = cDIBHeader.v5.bV5BlueMask;
+								break;
+							case 1:
+								cMask = cDIBHeader.v5.bV5GreenMask;
+								break;
+							case 2:
+								cMask = cDIBHeader.v5.bV5RedMask;
+								break;
+							case 3:
+								cMask = cDIBHeader.v5.bV5AlphaMask;
+								break;
+							default:
+								cMask = 0;
+								break;
+						}
+						if (cMask) {
+							cBuffer   = 0;
+							cBitIndex = 0;
+							for (cT3  = 0; cT3 < cDIBHeader.v1.biBitCount; cT3++) {
+								cBit = 1 << cT3;
+								if (cMask & cBit)
+									cBuffer += (cValue & cBit) >> (cT3 - cBitIndex++);
+							}
+							cPixel[cT2] = (BYTE) (cBuffer * 0xFF / ((1 << cBitIndex) - 1));
+						} else
+							cPixel[cT2] = 0xFF;
+					}
+				}
+				break;
+			}
+			default:
+				break;
+		}
+	}
+
+	xfree(cPixelArray);
+	if (cColorTable)
+		xfree(cColorTable);
+
+	return image;
+}
+
+static VOID callback_image_free(SID_IMAGE_DATA *cData) {
+	UINT cT;
+	for (cT = 0; cT < cData->height; cT++)
+		xfree(cData->pixelTable[cT]);
+	xfree(cData->pixelTable);
+	xfree(cData);
+}
+
+static VALUE ruby__alloc(VALUE self) {
+	return NEW_DATA_OBJECT(specialInputDevice_image, SID_IMAGE_DATA, NULL, callback_image_free);
+}
+
+/*
+ * @!scope class
+ * @overload new(width, height)
+ *   @param [Integer] width the width of table
+ *   @param [Integer] height the height of table
+ */
+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;
+	cData->height     = cHeight;
+	cData->pixelTable = ALLOC_N(LPRGBQUAD, cHeight);
+	for (cT0 = 0; cT0 < cHeight; cT0++) {
+		cData->pixelTable[cT0] = ALLOC_N(RGBQUAD, cWidth);
+		for (cT1 = 0; cT1 < cWidth; cT1++) {
+			cData->pixelTable[cT0][cT1].rgbBlue     = 0;
+			cData->pixelTable[cT0][cT1].rgbGreen    = 0;
+			cData->pixelTable[cT0][cT1].rgbRed      = 0;
+			cData->pixelTable[cT0][cT1].rgbReserved = 0;
+		}
+	}
+	rb_iv_set(self, "@width", width);
+	rb_iv_set(self, "@height", height);
+	return Qnil;
+}
+
+/*
+ * Save this image to a file.
+ * @overload save(path)
+ *   @param [String] path a path to target file
+ * @return [SpecialInputDevice::Image] self
+ */
+static VALUE ruby_save(VALUE self, VALUE path) {
+	VALUE            width       = rb_iv_get(self, "@width");
+	UINT             cWidth      = NUM2UINT(width);
+	LPCTSTR          cPath       = RUBY_VALUE_TO_LPCTSTR(path);
+	SID_IMAGE_DATA   *cData      = GET_SELF_DATA_OBJECT();
+	size_t           cHeaderSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPV5HEADER);
+	INT              cDataSize   = sizeof(RGBQUAD) * cWidth * cData->height;
+	FILE             *cFile;
+	BITMAPFILEHEADER cFileHeader;
+	BITMAPV5HEADER   cDIBHeader;
+	DWORD            cByteWritten;
+	INT              cT;
+	cFile = CreateFile(cPath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
+	                   FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
+	if (cFile == INVALID_HANDLE_VALUE)
+		RAISE_WIN32_ERROR();
+	cFileHeader.bfType                          = 0x4D42;
+	cFileHeader.bfSize                          = cHeaderSize + cDataSize;
+	cFileHeader.bfReserved1                     = 0;
+	cFileHeader.bfReserved2                     = 0;
+	cFileHeader.bfOffBits                       = cHeaderSize;
+	cDIBHeader.bV5Size                          = sizeof(BITMAPV5HEADER);
+	cDIBHeader.bV5Width                         = (LONG) cWidth;
+	cDIBHeader.bV5Height                        = (LONG) cData->height;
+	cDIBHeader.bV5Planes                        = 1;
+	cDIBHeader.bV5BitCount                      = 8 * sizeof(RGBQUAD);
+	cDIBHeader.bV5Compression                   = BI_BITFIELDS;
+	cDIBHeader.bV5SizeImage                     = (DWORD) cDataSize;
+	cDIBHeader.bV5XPelsPerMeter                 = 0;
+	cDIBHeader.bV5YPelsPerMeter                 = 0;
+	cDIBHeader.bV5ClrUsed                       = 0;
+	cDIBHeader.bV5ClrImportant                  = 0;
+	cDIBHeader.bV5RedMask                       = 0x00FF0000;
+	cDIBHeader.bV5GreenMask                     = 0x0000FF00;
+	cDIBHeader.bV5BlueMask                      = 0x000000FF;
+	cDIBHeader.bV5AlphaMask                     = 0xFF000000;
+	cDIBHeader.bV5CSType                        = LCS_WINDOWS_COLOR_SPACE;
+	cDIBHeader.bV5Endpoints.ciexyzRed.ciexyzX   = 0;
+	cDIBHeader.bV5Endpoints.ciexyzRed.ciexyzY   = 0;
+	cDIBHeader.bV5Endpoints.ciexyzRed.ciexyzZ   = 0;
+	cDIBHeader.bV5Endpoints.ciexyzGreen.ciexyzX = 0;
+	cDIBHeader.bV5Endpoints.ciexyzGreen.ciexyzY = 0;
+	cDIBHeader.bV5Endpoints.ciexyzGreen.ciexyzZ = 0;
+	cDIBHeader.bV5Endpoints.ciexyzBlue.ciexyzX  = 0;
+	cDIBHeader.bV5Endpoints.ciexyzBlue.ciexyzY  = 0;
+	cDIBHeader.bV5Endpoints.ciexyzBlue.ciexyzZ  = 0;
+	cDIBHeader.bV5GammaRed                      = 0;
+	cDIBHeader.bV5GammaGreen                    = 0;
+	cDIBHeader.bV5GammaBlue                     = 0;
+	cDIBHeader.bV5Intent                        = LCS_GM_ABS_COLORIMETRIC;
+	cDIBHeader.bV5ProfileData                   = 0;
+	cDIBHeader.bV5ProfileSize                   = 0;
+	cDIBHeader.bV5Reserved                      = 0;
+	WriteFile(cFile, &cFileHeader, sizeof(cFileHeader), &cByteWritten, NULL);
+	WriteFile(cFile, &cDIBHeader, sizeof(cDIBHeader), &cByteWritten, NULL);
+	for (cT = 0; cT < cData->height; cT++)
+		WriteFile(cFile, cData->pixelTable[cT], (DWORD) (sizeof(RGBQUAD) * cWidth), &cByteWritten, NULL);
+	return self;
+}
+
+/*
+ * @overload [](x, y)
+ *   @param [Integer] x the x coordinate, can be negative
+ *   @param [Integer] y the y coordinate, can be negative
+ * @return [SpecialInputDevice::Color] the color of pixel at the specific coordinate
+ */
+static VALUE ruby_OS_CS(VALUE self, VALUE x, VALUE y) {
+	INT            cWidth = NUM2INT(rb_iv_get(self, "@width"));
+	INT            cX     = NUM2INT(x);
+	INT            cY     = NUM2INT(y);
+	SID_IMAGE_DATA *cData = GET_SELF_DATA_OBJECT();
+	if (cX < -cWidth || cX >= cWidth)
+		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)
+		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;
+	return ruby___color_new_from_rgb_quad(&PixelAt(cX, cY));
+}
+
+/*
+ * @overload []=(x, y, value)
+ *   @param [Integer] x the x coordinate, can be negative
+ *   @param [Integer] y the y coordinate, can be negative
+ *   @param [SpecialInputDevice::Color] value the new color
+ * @return [SpecialInputDevice::Color] the new color
+ */
+static VALUE ruby_OS_CS_EQ(VALUE self, VALUE x, VALUE y, VALUE value) {
+	INT            cWidth = NUM2INT(rb_iv_get(self, "@width"));
+	INT            cX     = NUM2INT(x);
+	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)
+		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)
+		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;
+	PixelAt(cX, cY)       = cVALUE;
+	return value;
+}
+
+/*
+ * @overload try_get(x, y)
+ *   @param [Integer] x the x coordinate, can be negative
+ *   @param [Integer] y the y coordinate, can be negative
+ * @return [NilClass, SpecialInputDevice::Color] the color of pixel at the specific coordinate or nil if out of range
+ */
+static VALUE ruby_try_get(VALUE self, VALUE x, VALUE y) {
+	INT            cWidth = NUM2INT(rb_iv_get(self, "@width"));
+	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)
+		return Qnil;
+	if (cX < 0)
+		cX += cWidth;
+	if (cY < 0)
+		cY += cData->height;
+	return ruby___color_new_from_rgb_quad(&PixelAt(cX, cY));
+}
+
+/*
+ * @overload try_set(x, y, value)
+ *   @param [Integer] x the x coordinate, can be negative
+ *   @param [Integer] y the y coordinate, can be negative
+ *   @param [SpecialInputDevice::Color] value the new color
+ * @return [SpecialInputDevice::Color] the new color
+ */
+static VALUE ruby_try_set(VALUE self, VALUE x, VALUE y, VALUE value) {
+	INT            cWidth = NUM2INT(rb_iv_get(self, "@width"));
+	INT            cX     = NUM2INT(x);
+	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 < 0)
+			cX += cWidth;
+		if (cY < 0)
+			cY += cData->height;
+		PixelAt(cX, cY) = cVALUE;
+	}
+	return value;
+}
+
+/*
+ * @overload each(&block)
+ *   @param [Proc] block the action
+ *   @yield [value] the action
+ *   @yieldparam [SpecialInputDevice::Color] value the value
+ *   @yieldreturn [Object] value will be ignored
+ * @return [Enumerator, SpecialInputDevice::Image] a Enumerator if no block gavin, self otherwise.
+ */
+static VALUE ruby_each(VARIABLE_ARGUMENTS_C) {
+	VALUE          block;
+	SID_IMAGE_DATA *cData = GET_SELF_DATA_OBJECT();
+	UINT           cWidth = NUM2UINT(rb_iv_get(self, "@width"));
+	SCAN_ARGUMENTS("&", &block);
+	if (RTEST(block)) {
+		UINT cT0;
+		UINT cT1;
+		for (cT0 = 0; cT0 < cData->height; cT0++) {
+			for (cT1 = 0; cT1 < cWidth; cT1++) {
+				RGBQUAD *cColor = &PixelAt(cT1, cT0);
+				VALUE   color   = ruby___color_new_from_rgb_quad(cColor);
+				rb_yield(color);
+			}
+		}
+		return self;
+	} else {
+		VALUE newEnumeratorArguments[1];
+		newEnumeratorArguments[0] = self;
+		return rb_class_new_instance(1, newEnumeratorArguments, rb_cEnumerator);
+	}
+}
+
+/*
+ * @overload each_row(&block)
+ *   @param [Proc] block the action
+ *   @yield [row] the action
+ *   @yieldparam [Array<SpecialInputDevice::Color>] row the row
+ *   @yieldreturn [Object] value will be ignored
+ * @return [Enumerator, SpecialInputDevice::Image] a Enumerator if no block gavin, self otherwise.
+ */
+static VALUE ruby_each_row(VARIABLE_ARGUMENTS_C) {
+	VALUE          block;
+	SID_IMAGE_DATA *cData = GET_SELF_DATA_OBJECT();
+	LONG           cWidth = NUM2LONG(rb_iv_get(self, "@width"));
+	SCAN_ARGUMENTS("&", &block);
+	if (RTEST(block)) {
+		UINT  cT0;
+		UINT  cT1;
+		VALUE *cRow = ALLOC_N(VALUE, cWidth);
+		for (cT0 = 0; cT0 < cData->height; cT0++) {
+			for (cT1 = 0; cT1 < cWidth; cT1++) {
+				cRow[cT1] = ruby___color_new_from_rgb_quad(&PixelAt(cT1, cT0));
+				rb_yield(rb_ary_new_from_values(cWidth, cRow));
+			}
+		}
+		return self;
+	} else {
+		VALUE newEnumeratorArguments[2];
+		newEnumeratorArguments[0] = self;
+		newEnumeratorArguments[1] = NEW_SYMBOL("each_row");
+		return rb_class_new_instance(2, newEnumeratorArguments, rb_cEnumerator);
+	}
+}
+
+/*
+ * @overload each_column(&block)
+ *   @param [Proc] block the action
+ *   @yield [row] the action
+ *   @yieldparam [Array<SpecialInputDevice::Color>] column the column
+ *   @yieldreturn [Object] value will be ignored
+ * @return [Enumerator, SpecialInputDevice::Image] a Enumerator if no block gavin, self otherwise.
+ */
+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"));
+	SCAN_ARGUMENTS("&", &block);
+	if (RTEST(block)) {
+		UINT  cT0;
+		UINT  cT1;
+		VALUE *cColumn = ALLOC_N(VALUE, cData->height);
+		for (cT0 = 0; cT0 < cWidth; cT0++) {
+			for (cT1 = 0; cT1 < cData->height; cT1++) {
+				cColumn[cT1] = ruby___color_new_from_rgb_quad(&PixelAt(cT0, cT1));
+				rb_yield(rb_ary_new_from_values((LONG) cData->height, cColumn));
+			}
+		}
+		return self;
+	} else {
+		VALUE newEnumeratorArguments[2];
+		newEnumeratorArguments[0] = self;
+		newEnumeratorArguments[1] = NEW_SYMBOL("each_column");
+		return rb_class_new_instance(2, newEnumeratorArguments, rb_cEnumerator);
+	}
+}
+
+/*
+ * @overload each_in_row(y, &block)
+ *   @param [Integer] y specific which row, can be negative
+ *   @param [Proc] block the action
+ *   @yield [pixel] the action
+ *   @yieldparam [SpecialInputDevice::Color] pixel the pixel
+ *   @yieldreturn [Object] value will be ignored
+ * @return [Enumerator, SpecialInputDevice::Image] a Enumerator if no block gavin, self otherwise.
+ */
+static VALUE ruby_each_in_row(VARIABLE_ARGUMENTS_C) {
+	VALUE          y;
+	VALUE          block;
+	SID_IMAGE_DATA *cData = GET_SELF_DATA_OBJECT();
+	INT            cY;
+	LONG           cWidth = NUM2LONG(rb_iv_get(self, "@width"));
+	SCAN_ARGUMENTS("1&", &y, &block);
+	cY = NUM2INT(y);
+	if (cY < (INT) -cData->height || cY >= 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;
+		VALUE cPixel;
+		for (cT = 0; cT < cWidth; cT++) {
+			cPixel = ruby___color_new_from_rgb_quad(&PixelAt(cT, cY));
+			rb_yield(cPixel);
+		}
+		return self;
+	} else {
+		VALUE newEnumeratorArguments[3];
+		newEnumeratorArguments[0] = self;
+		newEnumeratorArguments[1] = NEW_SYMBOL("each_in_row");
+		newEnumeratorArguments[2] = y;
+		return rb_class_new_instance(3, newEnumeratorArguments, rb_cEnumerator);
+	}
+}
+
+/*
+ * @overload each_in_column(x, &block)
+ *   @param [Integer] x specific which column, can be negative
+ *   @param [Proc] block the action
+ *   @yield [pixel] the action
+ *   @yieldparam [SpecialInputDevice::Color] pixel the pixel
+ *   @yieldreturn [Object] value will be ignored
+ * @return [Enumerator, SpecialInputDevice::Image] a Enumerator if no block gavin, self otherwise.
+ */
+static VALUE ruby_each_in_column(VARIABLE_ARGUMENTS_C) {
+	VALUE          x;
+	VALUE          block;
+	SID_IMAGE_DATA *cData = GET_SELF_DATA_OBJECT();
+	INT            cX;
+	LONG           cWidth = NUM2LONG(rb_iv_get(self, "@width"));
+	SCAN_ARGUMENTS("1&", &x, &block);
+	cX = NUM2INT(x);
+	if (cX < -cWidth || cX >= cWidth)
+		rb_raise(rb_eRangeError, "The image only has %d columns. x = %d is out of range.", (INT) cWidth, cX);
+	if (cX < 0)
+		cX += cWidth;
+	if (RTEST(block)) {
+		UINT  cT;
+		VALUE cPixel;
+		for (cT = 0; cT < cData->height; cT++) {
+			cPixel = ruby___color_new_from_rgb_quad(&PixelAt(cX, cT));
+			rb_yield(cPixel);
+		}
+		return self;
+	} else {
+		VALUE newEnumeratorArguments[3];
+		newEnumeratorArguments[0] = self;
+		newEnumeratorArguments[1] = NEW_SYMBOL("each_column");
+		newEnumeratorArguments[2] = x;
+		return rb_class_new_instance(3, newEnumeratorArguments, rb_cEnumerator);
+	}
+}
+
+VOID Init_image() {
+#ifdef YARD
+	specialInputDevice = rb_define_module("SpecialInputDevice");
+	specialInputDevice_image = rb_define_class_under(specialInputDevice, "Image", rb_cData);
+#endif
+	rb_define_singleton_method(specialInputDevice_image, "load", ruby__load, 1);
+	rb_define_alloc_func(specialInputDevice_image, (rb_alloc_func_t) ruby__alloc);
+	/*
+	 * @return [Integer] the width of the bitmap
+	 */
+	rb_define_attr(specialInputDevice_image, "width", TRUE, FALSE);
+	/*
+	 * @return [Integer] the height of the bitmap
+	 */
+	rb_define_attr(specialInputDevice_image, "height", TRUE, FALSE);
+	rb_define_method(specialInputDevice_image, "initialize", ruby_initialize, 2);
+	rb_define_method(specialInputDevice_image, "save", ruby_save, 1);
+	rb_define_method(specialInputDevice_image, "[]", ruby_OS_CS, 2);
+	rb_define_method(specialInputDevice_image, "[]=", ruby_OS_CS_EQ, 3);
+	rb_define_method(specialInputDevice_image, "try_get", ruby_try_get, 2);
+	rb_define_method(specialInputDevice_image, "try_set", ruby_try_set, 3);
+	rb_define_method(specialInputDevice_image, "each", ruby_each, -1);
+	rb_define_method(specialInputDevice_image, "each_row", ruby_each_row, -1);
+	rb_define_method(specialInputDevice_image, "each_column", ruby_each_column, -1);
+	rb_define_method(specialInputDevice_image, "each_in_row", ruby_each_in_row, -1);
+	rb_define_method(specialInputDevice_image, "each_in_column", ruby_each_in_column, -1);
+}