wrb 2.0.0

data/ext/rwin/rw_resources.c

@@ -0,0 +1,1988 @@
+/*
+# Project WRB was forked from Project VisualuRuby(temp-name).
+# Author of this project: BANJO Koyu <banjokoyu at gmail.com>
+# The URL of this project: https://bitbucket.org/wrb/
+#
+# This is a ext-library part of WRB.
+*/
+
+#include "rwin.h"
+
+/* from https://msdn.microsoft.com/en-us/library/ms997538.aspx */
+typedef struct
+{
+    WORD           idReserved;   // Reserved (must be 0)
+    WORD           idType;       // Resource Type (1 for icons)
+    WORD           idCount;      // How many images?
+} ICONDIR;
+
+typedef struct
+{
+    BYTE        bWidth;          // Width, in pixels, of the image
+    BYTE        bHeight;         // Height, in pixels, of the image
+    BYTE        bColorCount;     // Number of colors in image (0 if >=8bpp)
+    BYTE        bReserved;       // Reserved ( must be 0)
+    WORD        wPlanes;         // Color Planes
+    WORD        wBitCount;       // Bits per pixel
+    DWORD       dwBytesInRes;    // How many bytes in this resource?
+    DWORD       dwImageOffset;   // Where in the file is this image?
+} ICONDIRENTRY;
+
+/* Bitmap */
+
+VALUE cRwBitmap;
+
+void
+rwbitmap_free(void* ptr){
+    RwBitmap* rb = ptr;
+    DeleteDC(rb->hdc);
+    DeleteObject(rb->hddbitmap);
+    if(!rb->shared) DeleteObject(rb->hbitmap);
+    free(rb);
+}
+
+static size_t
+rwbitmap_memsize(const void *ptr){
+    return ptr ? sizeof(RwBitmap) : 0;
+}
+
+const rb_data_type_t
+rwbitmap_data_type = {
+    "Bitmap", {NULL, rwbitmap_free, rwbitmap_memsize}, NULL, NULL
+};
+
+static VALUE
+alloc_rwbitmap(VALUE klass){
+    RwBitmap* rb;
+    VALUE robj = RwBitmap_Data_Make_Struct(klass, rb);
+    rb->type = RcBitmap;
+    rb->hbitmap = 0;
+    rb->hddbitmap = 0;
+    rb->hdc = 0;
+    rb->shared = FALSE;
+    return robj;
+}
+
+static void
+rw_setbihdr(BITMAPINFOHEADER *bih, int w, int h, int planes, int bitcount, size_t szimage){
+    bih->biSize = sizeof(BITMAPINFOHEADER);
+    bih->biWidth = w;
+    bih->biHeight = h;
+    bih->biPlanes = planes;
+    bih->biBitCount = bitcount;
+    bih->biCompression = BI_RGB; /* 0L */
+    bih->biSizeImage = szimage;
+    bih->biXPelsPerMeter = 0; /* not used */
+    bih->biYPelsPerMeter = 0; /* not used */
+    bih->biClrUsed = 0;
+    bih->biClrImportant = 0;
+}
+
+HBITMAP
+rw_dib2ddb(RwBitmap *rb){
+    BITMAP bmp;
+    BITMAPINFO *pbi;
+    void *dibdata;
+    size_t bisize = sizeof(BITMAPINFO);
+    
+    if(rb->hddbitmap) DeleteObject(rb->hddbitmap);
+    GetObject(rb->hbitmap, sizeof(BITMAP), &bmp);
+    switch(bmp.bmBitsPixel){
+      case 1:
+      case 4:
+      case 8:
+	bisize += (2<<(bmp.bmBitsPixel-1))*4;
+    }
+    RW_MALLOC(pbi, bisize);
+    rw_setbihdr((BITMAPINFOHEADER*)pbi, bmp.bmWidth, bmp.bmHeight, 1, bmp.bmBitsPixel, 0);
+    GetDIBits(rb->hdc, rb->hbitmap, 0, bmp.bmHeight, NULL, pbi, DIB_RGB_COLORS);
+    RW_MALLOC(dibdata, pbi->bmiHeader.biSizeImage);
+    GetDIBits(rb->hdc, rb->hbitmap, 0, bmp.bmHeight, dibdata, pbi, DIB_RGB_COLORS);
+    rb->hddbitmap = CreateDIBitmap(rb->hdc, &pbi->bmiHeader, CBM_INIT, dibdata,
+				   pbi, DIB_RGB_COLORS);
+    free(pbi);
+    free(dibdata);
+    return rb->hddbitmap;
+}
+
+void
+rw_bitmap_set_dc(RwBitmap *rb, int w, int h){
+    HDC hdctmp = GetDC(NULL);
+    rb->hbitmap = CreateCompatibleBitmap(hdctmp, w, h);
+    rb->hdc = CreateCompatibleDC(hdctmp);
+    SelectObject(rb->hdc, rb->hbitmap);
+    ReleaseDC(NULL, hdctmp);
+}
+
+static VALUE
+rwbitmap_initialize(int argc, VALUE *argv, VALUE self){
+    VALUE v_w, v_h, v_color;
+    int w, h;
+    RwBitmap *rb = DATA_PTR(self);
+    rb_scan_args(argc, argv, "21", &v_w, &v_h, &v_color);
+    w = FIX2INT(v_w); h = FIX2INT(v_h);
+    rw_bitmap_set_dc(rb, w, h);
+    if(!NIL_P(v_color)){
+	RECT rect;
+	COLORREF prevcolor = SetDCBrushColor(rb->hdc, FIX2INT(v_color));
+	rect.left = -1; rect.top = -1; rect.right = w + 1; rect.bottom = h + 1;
+	FillRect(rb->hdc, &rect, GetStockObject(DC_BRUSH));
+	SetDCBrushColor(rb->hdc, prevcolor);
+    }
+    Register_rsc(rb->hbitmap, self);
+    return self;
+}
+
+static VALUE
+rwbitmap1_fromfile(VALUE klass, VALUE fname){
+    char abspath[RW_MAXPATH];
+    RwBitmap* rb;
+    VALUE robj = RwBitmap_Data_Make_Struct(klass, rb);
+    rwconv2absolute_path(abspath, RSTRING_PTR(fname));
+    rb->hbitmap = LoadImageA(NULL, abspath, IMAGE_BITMAP, 0, 0, LR_DEFAULTSIZE | LR_LOADFROMFILE);
+    if(!rb->hbitmap){
+	char pwd[256];
+	getcwd(pwd, sizeof(pwd));
+	rb_raise(rb_eRuntimeError, "Bitmap load failed(%s), err=%d, pwd=%s.",
+		 abspath, (int)GetLastError(), pwd);
+    }
+    rb->shared = FALSE;
+    rb->type = RcBitmap;
+    rb->hdc = CreateCompatibleDC(NULL);
+    SelectObject(rb->hdc, rb->hbitmap);
+    
+    Register_rsc(rb->hbitmap, robj);
+    return robj;
+}
+
+static VALUE
+rwbitmap1_fromhandle_core(VALUE klass, HBITMAP hbitmap){
+    VALUE robj;
+    RwBitmap* rb;
+    HDC hdc = CreateCompatibleDC(NULL);
+    if (!SelectObject(hdc, hbitmap)) rb_raise(rb_eRuntimeError, "Bitmap create failed.");
+    robj = RwBitmap_Data_Make_Struct(klass, rb);
+    rb->hbitmap = hbitmap;
+    rb->hdc = hdc;
+    Register_rsc(rb->hbitmap, robj);
+    return robj;
+}
+
+static VALUE
+rwbitmap1_fromhandle(VALUE klass, VALUE v_hbitmap){
+    VALUE robj = Get_rsc(NUM2INT(v_hbitmap));
+    if (robj) return robj;
+    return rwbitmap1_fromhandle_core(klass, (HANDLE)NUM2ULONG_PTR(v_hbitmap));
+}
+
+static VALUE
+rwbitmap1_monochrome(VALUE klass, VALUE v_w, VALUE v_h){
+    RwBitmap* rb;
+    VALUE robj = RwBitmap_Data_Make_Struct(klass, rb);
+    rb->hbitmap = CreateBitmap(FIX2INT(v_w), FIX2INT(v_h), 1, 1, NULL);
+    rb->hdc = CreateCompatibleDC(NULL);
+    SelectObject(rb->hdc, rb->hbitmap);
+    Register_rsc(rb->hbitmap, robj);
+    return robj;
+}
+
+static VALUE
+rwbitmap_hbitmap(VALUE self){
+    RwBitmap *rb = DATA_PTR(self);
+    return ULONG_PTR2NUM((ULONG_PTR)rb->hbitmap);
+}
+
+static VALUE
+rwbitmap_hddbitmap(VALUE self){
+    RwBitmap *rb = DATA_PTR(self);
+    if(!rb->hddbitmap) rw_dib2ddb(rb);
+    return ULONG_PTR2NUM((ULONG_PTR)rb->hddbitmap);
+}
+
+
+static VALUE
+rwbitmap_hdc(VALUE self){
+    RwBitmap *rb = DATA_PTR(self);
+    return ULONG_PTR2NUM((ULONG_PTR)rb->hdc);
+}
+
+static VALUE
+rwbitmap_width(VALUE self){
+    BITMAP bmp;
+    RwBitmap *rb = DATA_PTR(self);
+    GetObject(rb->hbitmap, sizeof(BITMAP), &bmp);
+    return INT2FIX(bmp.bmWidth);
+}
+
+static VALUE
+rwbitmap_height(VALUE self){
+    BITMAP bmp;
+    RwBitmap *rb = DATA_PTR(self);
+    GetObject(rb->hbitmap, sizeof(BITMAP), &bmp);
+    return INT2FIX(bmp.bmHeight);
+}
+
+static VALUE
+rwbitmap_draw(int argc, VALUE *argv, VALUE self){
+    VALUE klass, obj;
+    RwCanvas *cv;
+    RwBitmap *rb = DATA_PTR(self);
+    rb_scan_args(argc, argv, "01", &klass);
+    if(!rb_block_given_p()) rb_raise(rb_eArgError, "Need block");
+    if (NIL_P(klass)) klass = cRwCanvas;
+    obj = RwCanvas_Data_Make_Struct(klass, cv);
+    cv->hdc = rb->hdc;
+    rb_yield(obj);
+    return self;
+}
+
+static VALUE
+rwbitmap_dispose(VALUE self){
+    RwBitmap *rb = DATA_PTR(self);
+    DeleteDC(rb->hdc);
+    if (rb->hbitmap) {
+	if(!rb->shared) DeleteObject(rb->hbitmap);
+	rb->hbitmap = NULL;
+	return Qtrue;
+    }
+    return Qnil;
+}
+/* moved to wrb/components/Bitmap.rb
+static VALUE
+rwbitmap_create_mask(VALUE self, VALUE v_mskclr){
+    COLORREF oldbkclr;
+    int w, h;
+    VALUE robj;
+    BITMAP bmp;
+    RwBitmap *rmsk;
+    RwBitmap *rb = DATA_PTR(self);
+    GetObject(rb->hbitmap, sizeof(BITMAP), &bmp);
+    w = bmp.bmWidth; h = bmp.bmHeight;
+    robj = RwBitmap_Data_Make_Struct(CLASS_OF(self), rmsk);
+    oldbkclr = SetBkColor(rb->hdc, NUM2INT(v_mskclr));
+    rmsk->hdc = CreateCompatibleDC(NULL);
+    rmsk->hbitmap = CreateBitmap(w, h, 1, 1, NULL);
+    SelectObject(rmsk->hdc, rmsk->hbitmap);
+    BitBlt(rmsk->hdc, 0, 0, w, h, rb->hdc, 0, 0, NOTSRCCOPY);
+    SetBkColor(rb->hdc, oldbkclr);
+    Register_rsc(rmsk->hbitmap, robj);
+    return robj;
+}
+
+static VALUE
+rwbitmap_create_maskimage(VALUE self, VALUE v_mskclr){
+    COLORREF oldbkclr;
+    int w, h;
+    VALUE robj;
+    BITMAP bmp;
+    HBITMAP hbmptmp;
+    HDC hdctmp;
+    RwBitmap *rmsk;
+    RwBitmap *rb = DATA_PTR(self);
+    GetObject(rb->hbitmap, sizeof(BITMAP), &bmp);
+    w = bmp.bmWidth; h = bmp.bmHeight;
+    robj = RwBitmap_Data_Make_Struct(CLASS_OF(self), rmsk);
+    oldbkclr = SetBkColor(rb->hdc, NUM2INT(v_mskclr));
+    hdctmp = CreateCompatibleDC(NULL);
+    hbmptmp = CreateBitmap(w, h, 1, 1, NULL);
+    SelectObject(hdctmp, hbmptmp);
+    BitBlt(hdctmp, 0, 0, w, h, rb->hdc, 0, 0, SRCCOPY);
+    SetBkColor(rb->hdc, oldbkclr);
+    
+    rw_bitmap_set_dc(rmsk, w, h);
+    SelectObject(rmsk->hdc, rmsk->hbitmap);
+    BitBlt(rmsk->hdc, 0, 0, w, h, hdctmp, 0, 0, SRCCOPY);
+    DeleteObject(hbmptmp);
+    ReleaseDC(NULL, hdctmp);
+    Register_rsc(rmsk->hbitmap, robj);
+    return robj;
+}
+*/
+  
+static VALUE
+rwbitmap_getpixel(VALUE self, VALUE v_x, VALUE v_y){
+    RwBitmap *rb = DATA_PTR(self);
+    return UINT2NUM(GetPixel(rb->hdc, FIX2INT(v_x), FIX2INT(v_y)));
+}
+
+static VALUE
+rwbitmap_setpixel(VALUE self, VALUE v_x, VALUE v_y, VALUE v_clr){
+    RwBitmap *rb = DATA_PTR(self);
+    return UINT2NUM(SetPixel(rb->hdc, FIX2INT(v_x), FIX2INT(v_y), (COLORREF)FIX2INT(v_clr)));
+}
+
+static VALUE
+rwbitmap_getdepth(VALUE self){
+    BITMAP bmp;
+    RwBitmap *rb = DATA_PTR(self);
+    GetObject(rb->hbitmap,sizeof(BITMAP), &bmp);
+    return INT2FIX(bmp.bmBitsPixel);
+}
+
+static VALUE
+rwbitmap1__load(VALUE klass, VALUE str){
+    RwBitmap* rb;
+    VALUE robj;
+    BITMAPINFO *bi;
+    int biw, bih;
+    char *ptr = RSTRING_PTR(str);
+    char *bits;
+    BITMAPFILEHEADER *bf = (BITMAPFILEHEADER*)ptr;
+    if(bf->bfType!=0x4d42) rb_raise(rb_eArgError, "Not a bitmap file");
+    bi = (BITMAPINFO*)(ptr + sizeof(BITMAPFILEHEADER));
+    bits = ptr + bf->bfOffBits;
+    biw = bi->bmiHeader.biWidth;
+    bih = bi->bmiHeader.biHeight;
+    
+    robj = RwBitmap_Data_Make_Struct(klass, rb);
+    rb->type = RcBitmap;
+    rw_bitmap_set_dc(rb, biw, bih);
+    SetDIBitsToDevice(rb->hdc, 0, 0, biw, bih, 0, 0, 0, bih, bits, bi, DIB_RGB_COLORS);
+    Register_rsc(rb->hbitmap, robj);
+    return robj;
+}
+
+static size_t
+rwbitmap__dump_core(VALUE self, LPVOID lpbmpdata, int cdpth, size_t szimage, int cctbl){
+    LPVOID lpvBits;
+    BITMAP bmp;
+    RwBitmap *rb = DATA_PTR(self);
+    
+    GetObject(rb->hbitmap, sizeof(BITMAP), &bmp);
+    if(!lpbmpdata){
+	BITMAPINFO *bi = alloca(sizeof(BITMAPINFOHEADER)+1024);
+	rw_setbihdr((BITMAPINFOHEADER*)bi, bmp.bmWidth, bmp.bmHeight, 1, cdpth, szimage);
+	GetDIBits(rb->hdc, rb->hbitmap, 0, bmp.bmHeight, NULL, bi, DIB_RGB_COLORS);
+	return bi->bmiHeader.biSizeImage;
+    } else {
+	BITMAPINFO *bi = (BITMAPINFO*)((char*)lpbmpdata + sizeof(BITMAPFILEHEADER));
+   	BITMAPFILEHEADER *bmifilehdr = (BITMAPFILEHEADER *)lpbmpdata;
+	bmifilehdr->bfType = 0x4d42; /* "BM" */
+	bmifilehdr->bfSize = szimage + sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
+	bmifilehdr->bfReserved1 = 0;
+	bmifilehdr->bfReserved2 = 0;
+	bmifilehdr->bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + cctbl;
+    
+	rw_setbihdr((BITMAPINFOHEADER*)bi, bmp.bmWidth, bmp.bmHeight, 1, cdpth, szimage);
+	lpvBits = (char*)lpbmpdata + sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + cctbl;
+	return GetDIBits(rb->hdc, rb->hbitmap, 0, bmp.bmHeight, lpvBits, bi, DIB_RGB_COLORS);
+    }
+}
+
+//    fprintf(stderr, "cdpth=%d, biSize=%d, biWidth=%d, biPlanes=%d, biBitCount=%d, biCompression=%d, biSizeImage=%d, biXPelsPerMeter=%d, biYPelsPerMeter=%d, biClrUsed=%d, biClrImportant=%d\n", cdpth, bi.bmiHeader.biSize, bi.bmiHeader.biWidth, bi.bmiHeader.biPlanes, bi.bmiHeader.biBitCount, bi.bmiHeader.biCompression, bi.bmiHeader.biSizeImage, bi.bmiHeader.biXPelsPerMeter, bi.bmiHeader.biYPelsPerMeter, bi.bmiHeader.biClrUsed, bi.bmiHeader.biClrImportant);
+
+static int
+rw_get_colortable_len(int clrdpth){
+    switch(clrdpth){
+      case 1: case 4: case 8:
+	return 4 * (2 << (clrdpth-1));
+      case 16: case 24: case 32:
+	return 0;
+      default:
+	rb_raise(rb_eArgError, "Color depth must be 1, 4, 8, 16, 24 or 32, but got %d.", clrdpth);
+    }
+}
+
+static VALUE
+rwbitmap__dump(int argc, VALUE* argv, VALUE self){
+    LPVOID lpbmpdata = NULL;
+    int offsetbits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
+    int cdpth = argc>0 ? FIX2INT(argv[0]) : 32;
+    int cctbl = rw_get_colortable_len(cdpth);
+    size_t szimage = rwbitmap__dump_core(self, NULL, cdpth, 0, cctbl);
+    RW_MALLOC(lpbmpdata, szimage + offsetbits + cctbl);
+    if(rwbitmap__dump_core(self, lpbmpdata, cdpth, szimage, cctbl)){
+	VALUE str = rb_str_new((char*)lpbmpdata, szimage + offsetbits + cctbl);
+	if(lpbmpdata) free(lpbmpdata);
+	return str;
+    } else {
+	if(lpbmpdata) free(lpbmpdata);
+	return  Qnil;
+    }
+}
+
+//VALUE rwgdip1__load_core(VALUE klass, LPVOID lpdata, size_t len); /* prottyping */
+/*
+static VALUE
+rwbitmap_to_image(VALUE self){
+    LPVOID lpbmpdata = NULL;
+    int offsetbits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
+    size_t szimage = rwbitmap__dump_core(self, lpbmpdata, 32, 0, 0);
+    RW_MALLOC(lpbmpdata, szimage + offsetbits);
+    if(rwbitmap__dump_core(self, lpbmpdata, 32, szimage, 0)){
+	VALUE robj=rwgdip1__load_core(cRwImage, lpbmpdata, szimage + offsetbits);
+	if(lpbmpdata) free(lpbmpdata);
+	return robj;
+    } else {
+	if(lpbmpdata) free(lpbmpdata);
+	return  Qnil;
+    }
+}*/
+
+static void
+rw_init_Bitmap(){
+    cRwBitmap = rb_define_class_under(mRwin, "Bitmap", rb_cData);
+    rb_define_alloc_func(cRwBitmap,  alloc_rwbitmap);
+    
+    rb_define_singleton_method(cRwBitmap, "fromfile", rwbitmap1_fromfile, 1);
+    rb_define_singleton_method(cRwBitmap, "fromhandle", rwbitmap1_fromhandle, 1);
+    rb_define_singleton_method(cRwBitmap, "monochrome", rwbitmap1_monochrome, 2);
+    
+    rb_define_method(cRwBitmap, "initialize", rwbitmap_initialize, -1);
+    rb_define_method(cRwBitmap, "_hbitmap", rwbitmap_hbitmap, 0);
+    rb_define_method(cRwBitmap, "_hddbitmap", rwbitmap_hddbitmap, 0);
+    rb_define_method(cRwBitmap, "_hdc", rwbitmap_hdc, 0);
+    rb_define_method(cRwBitmap, "width", rwbitmap_width, 0);
+    rb_define_method(cRwBitmap, "height", rwbitmap_height, 0);
+    rb_define_method(cRwBitmap, "depth", rwbitmap_getdepth, 0);
+    rb_define_method(cRwBitmap, "draw", rwbitmap_draw, -1);
+    rb_define_method(cRwBitmap, "dispose", rwbitmap_dispose, 0);
+//    rb_define_method(cRwBitmap, "to_mask", rwbitmap_create_mask, 1);
+//    rb_define_method(cRwBitmap, "to_maskimage", rwbitmap_create_maskimage, 1);
+//    rb_define_method(cRwBitmap, "to_maskimage", rwbitmap_create_maskimage, 1);
+    
+    /* GDI functions (except Canvas) */
+    rb_define_method(cRwBitmap, "GetPixel", rwbitmap_getpixel, 2);
+    rb_define_method(cRwBitmap, "SetPixel", rwbitmap_setpixel, 3);
+    
+    rb_define_singleton_method(cRwBitmap, "_load", rwbitmap1__load, 1);
+    rb_define_method(cRwBitmap, "_dump", rwbitmap__dump, -1);
+//    rb_define_method(cRwBitmap, "to_image", rwbitmap_to_image, 0);
+}
+
+/* Icon */
+
+VALUE cRwIcon;
+
+void
+rwicon_free(void* ptr){
+    RwIcon* ri = ptr;
+    if(!ri->shared) DestroyIcon(ri->hicon);
+    free(ri);
+}
+
+static size_t
+rwicon_memsize(const void *ptr){
+    return ptr ? sizeof(RwIcon) : 0;
+}
+
+const rb_data_type_t
+rwicon_data_type = {
+    "Icon", {NULL, rwicon_free, rwicon_memsize}, NULL, NULL
+};
+
+static VALUE
+alloc_rwicon(VALUE klass){
+    RwIcon* ri;
+    VALUE robj = RwIcon_Data_Make_Struct(klass, ri);
+    ri->type = RcIcon;
+    return robj;
+}
+
+static VALUE
+rwicon1_fromfile(int argc, VALUE* argv, VALUE klass){
+    char abspath[RW_MAXPATH];
+    RwIcon* ri;
+    VALUE robj, fname, disired_x, disired_y;
+    int dx, dy;
+    rb_scan_args(argc, argv, "12", &fname, &disired_x, &disired_y);
+    dx = NIL_P(disired_x) ? 0 : FIX2INT(disired_x);
+    dy = NIL_P(disired_y) ? dx : FIX2INT(disired_y);
+    robj = RwIcon_Data_Make_Struct(klass, ri);
+    ri->type = RcIcon;
+    rwconv2absolute_path(abspath, RSTRING_PTR(fname));
+    ri->hicon = LoadImageA(NULL, abspath, IMAGE_ICON, dx, dy, LR_LOADFROMFILE);
+    ri->shared = FALSE;
+    if(!ri->hicon){
+	rb_raise(rb_eRuntimeError, "Icon load failed(%s).", StringValuePtr(fname));
+    }
+    Register_rsc(ri->hicon, robj);
+    return robj;
+}
+
+static VALUE
+rwicon1_fromrsrc(VALUE klass, VALUE idicon){
+    RwIcon* ri;
+    VALUE robj = RwIcon_Data_Make_Struct(klass, ri);
+    ri->type = RcIcon;
+    ri->hicon = LoadImage(hInstance, MAKEINTRESOURCE(FIX2INT(idicon)), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
+    if(ri->hicon==NULL){
+	rb_raise(rb_eRuntimeError, "Icon load failed from resource (%d, %d).", FIX2INT(idicon), (int)GetLastError());
+    }
+    ri->shared = FALSE;
+    Register_rsc(ri->hicon, robj);
+    return robj;
+}
+
+static VALUE
+rwicon_initialize(VALUE self, VALUE v_bmmask, VALUE v_bmcolor){
+    RwBitmap *rbmask, *rbcolor;
+    ICONINFO iinfo;
+    RwIcon *ri = DATA_PTR(self);
+    iinfo.fIcon = TRUE;
+    iinfo.xHotspot = 0;
+    iinfo.xHotspot = 0;
+    RwBitmap_Data_Get_Struct(v_bmmask, rbmask);
+    iinfo.hbmMask = rw_dib2ddb(rbmask);
+    RwBitmap_Data_Get_Struct(v_bmcolor, rbcolor);
+    iinfo.hbmColor = rw_dib2ddb(rbcolor);
+    ri->hicon = CreateIconIndirect(&iinfo);
+    if (!ri->hicon) rb_raise(rb_eRuntimeError, "failed to create icon");
+    ri->shared = FALSE;
+    return self;
+}
+
+static VALUE
+rwicon_hicon(VALUE self){
+    RwIcon *ri = DATA_PTR(self);
+    return ULONG_PTR2NUM((ULONG_PTR)ri->hicon);
+}
+
+static VALUE
+rwicon_dispose(VALUE self){
+    RwIcon *ri = DATA_PTR(self);
+    if (ri->hicon) {
+	if(!ri->shared) DestroyIcon(ri->hicon);
+	ri->hicon = NULL;
+	return Qtrue;
+    }
+    return Qnil;
+}
+
+static VALUE
+rwicon_to_bmps(VALUE self){
+    ICONINFO iinfo;
+    VALUE v_bmmask, v_bmcolor;
+    RwIcon *ri = DATA_PTR(self);
+    GetIconInfo(ri->hicon, &iinfo);
+    v_bmmask = rwbitmap1_fromhandle_core(cRwBitmap, iinfo.hbmMask);
+    v_bmcolor = iinfo.hbmColor ? rwbitmap1_fromhandle_core(cRwBitmap, iinfo.hbmColor) : Qnil;
+    DeleteObject(iinfo.hbmMask);
+    DeleteObject(iinfo.hbmColor);
+    if(iinfo.fIcon) return rb_ary_new3(2, v_bmmask, v_bmcolor);
+    return rb_ary_new3(4, v_bmmask, v_bmcolor, INT2FIX(iinfo.xHotspot), INT2FIX(iinfo.yHotspot));
+}
+
+static VALUE
+rwicon__dump_core(ICONINFO *ii, ICONDIRENTRY *pid, int clrdpth){
+    int ccmsk, ccclr, ccalloc, cctable;
+    char *ptr, *pimage;
+    HANDLE hbmclr;
+    BITMAP bmmsk, bmclr;
+    BITMAPINFO *pbimsk, *pbiclr, *pbi;
+    VALUE res;
+    
+    HDC hdc = CreateCompatibleDC(NULL);
+    hbmclr = ii->hbmColor;
+    clrdpth = hbmclr ? clrdpth : 1;
+    cctable = rw_get_colortable_len(clrdpth);
+    ccclr = 0; 
+    GetObject(ii->hbmMask, sizeof(BITMAP), &bmmsk);
+    GetObject(ii->hbmColor, sizeof(BITMAP), &bmclr);
+    if(bmmsk.bmBitsPixel!=1) rb_raise(rb_eArgError, "Mask bitmap may be broken.");
+    
+    ccalloc = sizeof(BITMAPINFOHEADER) + cctable;
+    RW_CALLOC(pbimsk, sizeof(BITMAPINFOHEADER)+1024);
+    rw_setbihdr((BITMAPINFOHEADER*)pbimsk, bmmsk.bmWidth, bmmsk.bmHeight, 1, 1, 0);
+    GetDIBits(hdc, ii->hbmMask, 0, bmmsk.bmHeight, NULL, pbimsk, DIB_RGB_COLORS);
+    ccmsk = pbimsk->bmiHeader.biSizeImage;
+    free(pbimsk);
+    ccalloc += ccmsk;
+    if(hbmclr){
+	RW_CALLOC(pbiclr, sizeof(BITMAPINFOHEADER)+cctable);
+	rw_setbihdr((BITMAPINFOHEADER*)pbiclr, bmclr.bmWidth, bmclr.bmHeight, 1, clrdpth, 0);
+	GetDIBits(hdc, ii->hbmColor, 0, bmclr.bmHeight, NULL, pbiclr, DIB_RGB_COLORS);
+	ccclr = pbiclr->bmiHeader.biSizeImage;
+	free(pbiclr);
+	ccalloc += ccclr;
+    }
+    pid->bWidth = bmmsk.bmWidth;
+    pid->bHeight = hbmclr ?  bmclr.bmHeight : bmmsk.bmHeight/2;
+    pid->wPlanes = ii->fIcon ? 1 : ii->xHotspot;
+    pid->wBitCount = ii->fIcon ? clrdpth : (WORD)ii->yHotspot;
+    pid->dwBytesInRes = sizeof(BITMAPINFOHEADER) + cctable + ccmsk + ccclr;
+    pid->dwImageOffset = sizeof(ICONDIR) + sizeof(ICONDIRENTRY);
+//    fprintf(stderr, "w=%d, h=%d, cctable=%d, ccmsk=%d, ccclr=%d, clrdpth=%d, ccalloc=%d\n", pid->bWidth, pid->bHeight, cctable, ccmsk, ccclr, clrdpth, ccalloc);
+
+    RW_CALLOC(ptr, ccalloc);
+    pimage = ptr;
+    pbi = (BITMAPINFO*)pimage;
+    /* Set mask bits at first. */
+    rw_setbihdr((BITMAPINFOHEADER*)pbi, bmmsk.bmWidth, bmmsk.bmHeight, 1, 1, 0);
+    pimage += sizeof(BITMAPINFOHEADER) + cctable;
+    GetDIBits(hdc, ii->hbmMask, 0, bmmsk.bmHeight, pimage+ccclr, pbi, DIB_RGB_COLORS);
+    if(hbmclr){ /* Set color bits next. */
+	rw_setbihdr((BITMAPINFOHEADER*)pbi, bmclr.bmWidth, bmclr.bmHeight, 1, clrdpth, 0);
+	GetDIBits(hdc, ii->hbmColor, 0, bmclr.bmHeight, pimage, pbi, DIB_RGB_COLORS);
+	pimage += pbi->bmiHeader.biSizeImage;
+	pbi->bmiHeader.biHeight += bmmsk.bmHeight;
+    }
+    pbi->bmiHeader.biSizeImage = 0;
+    res = rb_str_new(ptr, ccalloc);
+    ReleaseDC(NULL, hdc);
+    free(ptr);
+    return res;
+}
+
+static VALUE
+rwicon__dump(int argc, VALUE *argv, VALUE self){
+    VALUE robj, rstr;
+    char *pstr;
+    ICONINFO ii;
+    ICONDIR *idir;
+    ICONDIRENTRY *idirent;
+    int clrdpth = argc>0 ? FIX2INT(argv[0]) : 24;
+    RwIcon *ri = DATA_PTR(self);
+    int ccalloc = sizeof(ICONDIR) + sizeof(ICONDIRENTRY);
+    RW_CALLOC(pstr, ccalloc);
+    GetIconInfo(ri->hicon, &ii);
+    idir = (ICONDIR*)pstr;
+    idir->idType = ii.fIcon ? 1 : 2;
+    idir->idCount = 1;
+    idirent = (ICONDIRENTRY*)(pstr+sizeof(ICONDIR));
+    rstr = rwicon__dump_core(&ii, idirent, clrdpth);
+    robj = rb_str_new(pstr, ccalloc);
+    rb_str_cat(robj, RSTRING_PTR(rstr), RSTRING_LEN(rstr));
+    return robj;
+}
+
+/* Obsolete
+static VALUE
+rwicon1__dump(int argc, VALUE *argv, VALUE klass){
+    VALUE robj, rstr;
+    char *pstr;
+    int i, ofst, ccalloc, clrdpth, imageoffset;
+    ICONDIR *idir;
+    ICONDIRENTRY *idirent;
+    if (FIXNUM_P(argv[0])){
+	clrdpth = FIX2INT(argv[0]);
+	argc --;
+	ofst = 1;
+    } else {
+	clrdpth = 24; 
+	ofst = 0;
+    }
+    ccalloc = sizeof(ICONDIR) + sizeof(ICONDIRENTRY)*argc;
+    RW_CALLOC(pstr, ccalloc);
+    idir = (ICONDIR*)pstr;
+    idir->idType = 1;
+    idir->idCount = argc;
+    rstr = rb_str_new(NULL, 0);
+    idirent = (ICONDIRENTRY*)(pstr + sizeof(ICONDIR));
+    imageoffset = ccalloc;
+    for(i=0; i<argc; i++){
+	VALUE rstr1;
+	ICONINFO ii;
+	RwIcon *ri;
+	RwIcon_Data_Get_Struct(argv[i+ofst], ri);
+	GetIconInfo(ri->hicon, &ii);
+	rstr1 = rwicon__dump_core(&ii, &idirent[i], clrdpth);
+	idirent[i].dwImageOffset = imageoffset;
+	imageoffset += RSTRING_LEN(rstr1);
+	rb_str_cat(rstr, RSTRING_PTR(rstr1), RSTRING_LEN(rstr1));
+    } //;fprintf(stderr, "argc=%d, ccalloc=%d", argc, ccalloc);
+    robj = rb_str_new(pstr, ccalloc);
+    rb_str_cat(robj, RSTRING_PTR(rstr), RSTRING_LEN(rstr));
+    return robj;
+}
+*/
+
+static HANDLE
+rwicon1__load_core(char *pstr, ICONDIRENTRY *idirent, BOOL ficon){
+    BITMAPINFOHEADER *bihdr;
+    BITMAPINFO *bimsk;
+    int w, h, bc, offset;
+    HBITMAP hbmmsk, hbmclr;
+    ICONINFO ii;
+    HDC hdc;
+    HANDLE hicon;
+    char *ptr;
+    ptr = pstr + idirent->dwImageOffset;
+    w = idirent->bWidth;
+    h = idirent->bHeight;
+    bihdr = (BITMAPINFOHEADER*) ptr;
+    bc = ficon ? idirent->wBitCount : bihdr->biBitCount;
+    offset = bc<=8 ? (2<<(bc-1))*4 : 0; /* size of color table */
+    ptr += sizeof(BITMAPINFOHEADER) + offset;
+    hdc = GetDC(NULL);
+    if(bc>1){
+	bihdr->biWidth = w;
+	bihdr->biHeight = h;
+	bihdr->biSizeImage = w*h*bc/8;
+	hbmclr = CreateDIBitmap(hdc, bihdr, CBM_INIT, ptr, (BITMAPINFO*)bihdr, DIB_RGB_COLORS);
+	ptr += bihdr->biSizeImage;
+    } else {
+	h = h*2;
+	hbmclr = NULL;
+    }
+    
+    RW_CALLOC(bimsk, sizeof(BITMAPINFOHEADER) + 1024);
+    rw_setbihdr((BITMAPINFOHEADER*)bimsk, w, h, 1, 1, 0);
+    bimsk->bmiColors[1].rgbBlue = 0xff;
+    bimsk->bmiColors[1].rgbGreen = 0xff;
+    bimsk->bmiColors[1].rgbRed = 0xff;
+    bimsk->bmiHeader.biSizeImage = w*h/8;
+    hbmmsk = CreateDIBitmap(hdc, (BITMAPINFOHEADER*)bimsk, CBM_INIT, ptr, bimsk, DIB_RGB_COLORS);
+    ReleaseDC(NULL, hdc);
+    free(bimsk);
+    
+    ii.fIcon = ficon;
+    ii.xHotspot = idirent->wPlanes;
+    ii.yHotspot = idirent->wBitCount;
+    ii.hbmMask = hbmmsk;
+    ii.hbmColor = hbmclr;
+    
+    hicon = CreateIconIndirect(&ii);
+    DeleteObject(hbmmsk);
+    DeleteObject(hbmclr);
+    return hicon;
+}
+
+static VALUE
+rwicon1__load(VALUE klass, VALUE str){
+    int i;
+    char *pstr = RSTRING_PTR(str);
+    ICONDIR *idir = (ICONDIR*)pstr;
+    VALUE ary = rb_ary_new();
+    for(i=0; i < idir->idCount; i++){
+	ICONDIRENTRY *idirent = (ICONDIRENTRY*)(pstr + sizeof(ICONDIR) + i*sizeof(ICONDIRENTRY));
+	HICON hicon = rwicon1__load_core(pstr, idirent, idir->idType==1);
+	if(hicon) {
+	    RwIcon *ri;
+	    VALUE robj;
+	    robj = RwIcon_Data_Make_Struct(klass, ri);
+	    ri->type = RcIcon;
+	    ri->hicon = hicon;
+	    Register_rsc(ri->hicon, robj);
+	    rb_ary_push(ary, robj);
+	} else rb_raise(rb_eRuntimeError, "Icon load failed.");
+    }
+    return ary;
+}
+
+static void
+rw_init_Icon(){
+    cRwIcon = rb_define_class_under(mRwin, "Icon", rb_cData);
+    rb_define_alloc_func(cRwIcon,  alloc_rwicon);
+    
+    rb_define_singleton_method(cRwIcon, "fromfile", rwicon1_fromfile, -1);
+    rb_define_singleton_method(cRwIcon, "fromresource", rwicon1_fromrsrc, 1); 
+//    rb_define_singleton_method(cRwIcon, "_dump", rwicon1__dump, -1);
+   
+    rb_define_method(cRwIcon, "initialize", rwicon_initialize, 2);
+    rb_define_method(cRwIcon, "_hicon", rwicon_hicon, 0);
+    rb_define_method(cRwIcon, "dispose", rwicon_dispose, 0);
+    rb_define_method(cRwIcon, "to_bmps", rwicon_to_bmps, 0);
+    rb_define_method(cRwIcon, "_dump", rwicon__dump, -1);
+    rb_define_singleton_method(cRwIcon, "_load", rwicon1__load, 1);
+}
+
+/* Cursor */
+VALUE cRwCursor;
+
+void
+rwcursor_free(void* ptr){
+    RwCursor *rc = ptr;
+    if(!rc->shared) DestroyCursor(rc->hcursor);
+    free(rc);
+}
+
+static size_t
+rwcursor_memsize(const void *ptr){
+    return ptr ? sizeof(RwCursor) : 0;
+}
+
+const rb_data_type_t
+rwcursor_data_type = {
+    "Cursor", {NULL, rwcursor_free, rwcursor_memsize}, NULL, NULL
+};
+
+static VALUE
+alloc_rwcursor(VALUE klass){
+    RwCursor *rc;
+    VALUE robj = RwCursor_Data_Make_Struct(klass, rc);
+    rc->type = RcCursor;
+    return robj;
+}
+
+static VALUE
+rwcursor_initialize(VALUE self, VALUE v_xhot, VALUE v_yhot, VALUE v_bmmask, VALUE v_bmcolor){
+    RwBitmap *rbmask, *rbcolor;
+    ICONINFO iinfo;
+    RwCursor *rc = DATA_PTR(self);
+    iinfo.fIcon = FALSE;
+    iinfo.xHotspot = FIX2INT(v_xhot);
+    iinfo.yHotspot = FIX2INT(v_yhot);
+    RwBitmap_Data_Get_Struct(v_bmmask, rbmask);
+    iinfo.hbmMask = rw_dib2ddb(rbmask);
+    RwBitmap_Data_Get_Struct(v_bmcolor, rbcolor);
+    iinfo.hbmColor = rw_dib2ddb(rbcolor);
+    rc->hcursor = CreateIconIndirect(&iinfo);
+    if (!rc->hcursor) rb_raise(rb_eRuntimeError, "failed to create cursor");
+    rc->shared = FALSE;
+    return self;
+}
+
+static VALUE
+rwcursor1_loadfromfile(VALUE klass, VALUE fname){
+    RwCursor* rc;
+    VALUE robj = RwCursor_Data_Make_Struct(klass, rc);
+
+    if(!FIXNUM_P(fname)){
+	char abspath[RW_MAXPATH];
+	rwconv2absolute_path(abspath, RSTRING_PTR(fname));
+	rc->hcursor = LoadImageA(NULL, abspath, IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE);
+    } else {
+	rc->hcursor = LoadCursor(NULL, MAKEINTRESOURCE(FIX2INT(fname)));
+    }
+    if(!rc->hcursor) rb_raise(rb_eRuntimeError, "failed to create cursor");
+    rc->type = RcCursor;
+    rc->shared = FIXNUM_P(fname) ? TRUE : FALSE;
+    return robj;
+}
+
+static VALUE
+rwcursor_delete(VALUE self){
+    RwCursor *rc = DATA_PTR(self);
+    Unregister_rsc(rc->hcursor);
+    DestroyCursor(rc->hcursor);
+    rc->hcursor = 0;
+    return Qtrue;
+}
+
+static VALUE
+rwcursor_hcursor(VALUE self){
+    RwCursor *rc = DATA_PTR(self);
+    return ULONG_PTR2NUM((ULONG_PTR)rc->hcursor);
+}
+
+static VALUE
+rwapp_setcursor(VALUE mod, VALUE v_cur){
+    HCURSOR hc;
+    RwCursor *rc;
+    switch(TYPE(v_cur)){
+      case T_FIXNUM: case T_BIGNUM:
+	hc = (HCURSOR)NUM2ULONG_PTR(v_cur);
+	break;
+      default:
+	RwCursor_Data_Get_Struct(v_cur, rc);
+	RwCheckResource(rc);
+	hc = rc->hcursor;
+    }
+    SetCursor(hc);
+    return v_cur;
+}
+
+static VALUE
+rwapp_getcursor(){
+    HANDLE hCursor = GetCursor();
+    VALUE v_cursor = Get_rsc(hCursor);
+    return NIL_P(v_cursor) ? ULONG_PTR2NUM((ULONG_PTR)hCursor) : v_cursor;
+}
+
+static VALUE
+rwapp_showcursor(VALUE mod, VALUE v_show){
+    BOOL bShow = (!v_show || NIL_P(v_show)) ? FALSE : TRUE;
+   return INT2FIX(ShowCursor(bShow));
+}
+
+static VALUE
+rwcursor1__load(VALUE klass, VALUE str){
+    char *pstr = RSTRING_PTR(str);
+    ICONDIR *idir = (ICONDIR*)pstr;
+    ICONDIRENTRY *idirent = (ICONDIRENTRY *)(pstr + sizeof(ICONDIR));
+    HCURSOR hcursor = rwicon1__load_core(pstr, idirent, idir->idType==1);
+    if(hcursor){
+	RwCursor *rc;
+	VALUE robj;
+	robj = RwCursor_Data_Make_Struct(klass, rc);
+	rc->type = RcCursor;
+	rc->hcursor = hcursor;
+	Register_rsc(rc->hcursor, robj);
+	return robj;
+    }
+    return Qnil;
+}
+
+void
+rw_init_Cursor(){
+    cRwCursor = rb_define_class_under(mRwin, "Cursor", rb_cData);
+    rb_define_alloc_func(cRwCursor, alloc_rwcursor);
+    rb_define_singleton_method(cRwCursor, "fromfile", rwcursor1_loadfromfile, 1);
+    rb_define_singleton_method(cRwCursor, "_load", rwcursor1__load, 1);
+    rb_define_method(cRwCursor, "initialize", rwcursor_initialize, 4);
+    rb_define_method(cRwCursor, "_hcursor", rwcursor_hcursor, 0);
+    rb_define_method(cRwCursor, "dispose", rwcursor_delete, 0);
+    rb_define_method(cRwCursor, "to_bmps", rwicon_to_bmps, 0);
+    rb_define_method(cRwCursor, "_dump", rwicon__dump, -1);
+	
+    rb_define_singleton_method(mRwApp, "SetCursor", rwapp_setcursor, 1);
+    rb_define_singleton_method(mRwApp, "GetCursor", rwapp_getcursor, 0);
+    rb_define_singleton_method(mRwApp, "ShowCursor", rwapp_showcursor, 1);
+}
+
+/*  Pen */
+
+VALUE cRwPen;
+
+void
+rwpen_free(void* ptr){
+    RwPen *rp = ptr;
+    if(rp->hpen) DeleteObject(rp->hpen);
+    free(rp);
+}
+
+static size_t
+rwpen_memsize(const void *ptr){
+    return ptr ? sizeof(RwPen) : 0;
+}
+
+const rb_data_type_t
+rwpen_data_type = {
+    "Pen", {NULL, rwpen_free, rwpen_memsize}, NULL, NULL
+};
+
+static VALUE
+alloc_rwpen(VALUE klass){
+    RwPen *rp;
+    VALUE robj = RwPen_Data_Make_Struct(klass, rp);
+    rp->type = RcPen;
+    return robj;
+}
+
+static void
+init_rwpen(int argc, VALUE *argv, RwPen *rp){
+    VALUE v_color, v_width, v_style;
+    if (argc<1) rb_raise(rb_eArgError, "need color");
+    rb_scan_args(argc, argv, "12", &v_color, &v_width, &v_style);
+    if(FIXNUM_P(v_color)){
+	int color = FIX2INT(v_color);
+	int width = NIL_P(v_width) ? 0 : FIX2INT(v_width);
+	int style = NIL_P(v_style) ? PS_SOLID : FIX2INT(v_style);
+	rp->hpen = CreatePen(style, width, (COLORREF)color);
+    } else {
+	CStructData *cslp;
+	CStruct_Data_Get_Struct(v_color, cslp);
+	rp->hpen = CreatePenIndirect((LOGPEN*)(cslp->dtstr + cslp->dtoffset));
+    }
+}
+
+static VALUE
+rwpen_initialize(int argc, VALUE *argv, VALUE self){
+    RwPen *rp = DATA_PTR(self);
+    init_rwpen(argc, argv, rp);
+    return self;	
+}
+
+static VALUE
+rwpen_hpen(VALUE self){
+    RwPen *rp = DATA_PTR(self);
+    return ULONG_PTR2NUM((ULONG_PTR)rp->hpen);
+}
+
+static VALUE
+rwpen_dispose(VALUE self){
+    RwPen *rp = DATA_PTR(self);
+    if (rp->hpen) {
+	DeleteObject(rp->hpen);
+	rp->hpen = NULL;
+	return Qtrue;
+    }
+    return Qnil;
+}
+
+void
+rw_init_Pen(){
+    cRwPen = rb_define_class_under(mRwin, "Pen", rb_cData);
+    rb_define_alloc_func(cRwPen, alloc_rwpen);
+    rb_define_method(cRwPen, "initialize", rwpen_initialize, -1);
+    rb_define_method(cRwPen, "_hpen", rwpen_hpen, 0);
+    rb_define_method(cRwPen, "dispose", rwpen_dispose, 0);
+}
+
+
+// Brush
+
+VALUE cRwBrush;
+
+void
+rwbrush_free(void* ptr){
+    RwBrush *rb = ptr;
+    if(rb->hbrush) DeleteObject(rb->hbrush);
+    free(rb);
+}
+
+static size_t
+rwbrush_memsize(const void *ptr){
+    return ptr ? sizeof(RwBrush) : 0;
+}
+
+const rb_data_type_t
+rwbrush_data_type = {
+    "Brush", {NULL, rwbrush_free, rwbrush_memsize}, NULL, NULL
+};
+
+static VALUE
+alloc_rwbrush(VALUE klass){
+    RwBrush *rb;
+    VALUE robj = RwBrush_Data_Make_Struct(klass, rb);
+    rb->type = RcBrush;
+    return robj;
+}
+
+static void
+init_rwbrush(int argc, VALUE *argv, RwBrush *rb){
+    VALUE v_color, v_style, v_hatch;
+    if (!argc) rb_raise(rb_eArgError,"need color or LOGBRUSH");
+    rb_scan_args(argc, argv, "12", &v_color, &v_style, &v_hatch);
+    if(FIXNUM_P(v_color)){
+	LOGBRUSH lb;
+	lb.lbColor = FIX2INT(v_color);
+	lb.lbStyle = NIL_P(v_style) ? BS_SOLID : NUM2INT(v_style);
+	lb.lbHatch = NIL_P(v_hatch) ? HS_DIAGCROSS : NUM2INT(v_hatch);
+	rb->hbrush = CreateBrushIndirect(&lb);
+    } else {
+	CStructData *cslb;
+	CStruct_Data_Get_Struct(v_color, cslb);
+	rb->hbrush = CreateBrushIndirect((LOGBRUSH*)(cslb->dtstr + cslb->dtoffset));
+    }
+}
+
+static VALUE
+rwbrush_initialize(int argc, VALUE *argv, VALUE obj){
+    RwBrush *rb;
+    RwBrush_Data_Get_Struct(obj, rb);
+    init_rwbrush(argc, argv, rb);
+    return obj;	
+}
+
+static VALUE
+rwbrush_hbrush(VALUE obj){
+    RwBrush *rb;
+    RwBrush_Data_Get_Struct(obj, rb);
+    return ULONG_PTR2NUM((ULONG_PTR)rb->hbrush);
+}
+
+static VALUE
+rwbrush_dispose(VALUE obj){
+    RwBrush *rb;
+    RwBrush_Data_Get_Struct(obj, rb);
+    if (rb->hbrush) {
+	DeleteObject(rb->hbrush);
+	rb->hbrush = NULL;
+	return Qtrue;
+    }
+    return Qnil;
+}
+
+void
+rw_init_Brush(){
+    cRwBrush = rb_define_class_under(mRwin, "Brush", rb_cData);
+    rb_define_alloc_func(cRwBrush, alloc_rwbrush);
+    rb_define_method(cRwBrush, "initialize", rwbrush_initialize, -1);
+    rb_define_method(cRwBrush, "_hbrush", rwbrush_hbrush, 0);
+    rb_define_method(cRwBrush, "dispose", rwbrush_dispose, 0);
+}
+
+/* ImageList */
+
+VALUE cRwImagelist;
+  
+void
+rwimagelist_free(void* ptr){
+    RwImagelist *ri = ptr;
+    if(ri->himagelist) ImageList_Destroy(ri->himagelist);
+    free(ri);
+}
+
+static size_t
+rwimagelist_memsize(const void *ptr){
+    return ptr ? sizeof(RwImagelist) : 0;
+}
+
+const rb_data_type_t
+rwimagelist_data_type = {
+    "Imagelist", {NULL, rwimagelist_free, rwimagelist_memsize}, NULL, NULL
+};
+
+static VALUE
+alloc_rwimagelist(VALUE klass){
+    RwImagelist *ri;
+    VALUE robj = RwImagelist_Data_Make_Struct(klass, ri);
+    ri->type = RcImagelist;
+    return robj;
+}
+
+static void
+init_imglist(int argc, VALUE *argv, RwImagelist *ri){
+    VALUE v_cx, v_cy, v_flag, v_initial, v_glow;
+    int cx, cy, flag,  initial, grow;
+    
+    rb_scan_args(argc, argv, "05", &v_cx, &v_cy, &v_flag, &v_initial, &v_glow);
+    cx = NIL_P(v_cx) ? 32 : FIX2INT(v_cx);
+    cy = NIL_P(v_cy) ? 32 : FIX2INT(v_cy);
+    flag = NIL_P(v_flag) ? ILC_COLOR : NUM2UINT(v_flag);
+    initial = (argc>3 && argv[3]!=Qnil)? NUM2UINT(argv[3]) : 0;
+    grow    = (argc>4 && argv[4]!=Qnil)? NUM2UINT(argv[4]) : 1;
+    ri->himagelist = ImageList_Create(cx, cy, flag, initial, grow);
+//    ri->flags = flag;
+    if (!ri->himagelist) rb_raise(rb_eRuntimeError,"ImageList_Create failed");
+}
+
+static VALUE
+rwimagelist_initialize(int argc,VALUE* argv, VALUE self){
+    RwImagelist *ri = DATA_PTR(self);
+    init_imglist(argc, argv, ri);
+    Register_rsc(ri->himagelist, self);
+    return self;
+}
+
+static VALUE
+rwimagelist_delete(VALUE self){
+    RwImagelist *ri = DATA_PTR(self);
+    RwCheckResource(ri);
+    Unregister_rsc(ri->himagelist);
+    ImageList_Destroy(ri->himagelist);
+    ri->himagelist = NULL;
+    return self;
+}
+
+static VALUE
+rwimagelist_add(int argc, VALUE* argv, VALUE self){
+    VALUE v_image, v_mask;
+    HBITMAP hbmimg, hbmmask;
+    int r;
+    RwImagelist *ri = DATA_PTR(self);
+    RwCheckResource(ri);
+    rb_scan_args(argc, argv, "11", &v_image, &v_mask);
+    
+    if(rb_typeddata_is_kind_of(v_image, &rwbitmap_data_type)){
+	RwBitmap* rb;
+	RwBitmap_Data_Get_Struct(v_image, rb);
+	RwCheckResource(rb);
+	hbmimg = rw_dib2ddb(rb);
+    } else {
+	rb_raise(rb_eArgError, "Not a Bitmap");
+    }
+    
+    if(NIL_P(v_mask)) {
+	hbmmask = NULL;
+    }else if(rb_typeddata_is_kind_of(v_mask, &rwbitmap_data_type)){
+	RwBitmap* rm;
+	RwBitmap_Data_Get_Struct(v_mask, rm);
+	RwCheckResource(rm);
+	hbmmask = rw_dib2ddb(rm);
+    } else {
+	DeleteObject(hbmimg);
+	rb_raise(rb_eArgError, "Not a Bitmap");
+    }
+    r = ImageList_Add(ri->himagelist, hbmimg, hbmmask);
+    
+    DeleteObject(hbmimg);
+    if(hbmmask) DeleteObject(hbmmask);
+    if(r==-1) rb_raise(rb_eRuntimeError, "ImageList_Add failed");
+    return self;
+}
+
+static VALUE
+rwimagelist_addmasked(VALUE self, VALUE v_bmi, VALUE maskcolor){
+    HBITMAP hbmimg;
+    int r;
+    RwImagelist *ri = DATA_PTR(self);
+    RwCheckResource(ri);
+    if(rb_typeddata_is_kind_of(v_bmi, &rwbitmap_data_type)){
+	RwBitmap* rb;
+	RwBitmap_Data_Get_Struct(v_bmi, rb);
+	RwCheckResource(rb);
+	hbmimg = rw_dib2ddb(rb);
+    } else {
+	rb_raise(rb_eArgError, "Not a Bitmap");
+    }
+    r = ImageList_AddMasked(ri->himagelist, hbmimg, NUM2UINT(maskcolor));
+    DeleteObject(hbmimg);
+
+    if(r<0) rb_raise(rb_eRuntimeError, "ImageList_AddMasked failed");
+    return self;
+}
+
+static VALUE
+rwimagelist_removeimage(VALUE self, VALUE idx){
+    int r;
+    RwImagelist *ri = DATA_PTR(self);
+    RwCheckResource(ri);
+    r = ImageList_Remove(ri->himagelist, FIX2INT(idx));
+    return r ? self : Qnil;
+}
+
+static VALUE
+rwimagelist_removeallimage(VALUE self){
+    int r;
+    RwImagelist *ri = DATA_PTR(self);
+    RwCheckResource(ri);
+    r = ImageList_RemoveAll(ri->himagelist);
+    return r ? self : Qnil;
+}
+
+static VALUE
+rwimagelist_countimage(VALUE self){
+    int r;
+    RwImagelist *ri = DATA_PTR(self);
+    RwCheckResource(ri);
+    r = ImageList_GetImageCount(ri->himagelist);
+    return INT2FIX(r);
+}
+
+static VALUE
+rwimagelist_himglist(VALUE self){
+    RwImagelist *ri = DATA_PTR(self);
+    RwCheckResource(ri);
+    return ULONG_PTR2NUM((ULONG_PTR)ri->himagelist);
+}
+
+static VALUE
+rwimagelist_geticon(int argc, VALUE* argv, VALUE self){
+    RwIcon *icon;
+    int idx;
+    UINT flags;
+    HICON hicon;
+    VALUE robj, v_idx, v_flags;
+    RwImagelist *ri = DATA_PTR(self);
+    RwCheckResource(ri);
+    rb_scan_args(argc, argv, "11", &v_idx, &v_flags);
+    idx = NUM2UINT(v_idx);
+    flags = NIL_P(v_flags) ? ILD_NORMAL : NUM2UINT(v_flags);
+
+    hicon = ImageList_GetIcon(ri->himagelist, idx, flags);
+    if(!hicon) rb_raise(rb_eRuntimeError, "ImageList_GetIcon failed");
+    robj = RwIcon_Data_Make_Struct(cRwIcon, icon);
+    Register_rsc(hicon, robj);
+    icon->hicon = hicon;
+    icon->shared = FALSE;
+    return robj;
+}
+
+static VALUE
+rwimagelist_getimageinfo(VALUE self, VALUE v_idx){
+    CStructData *cs;
+    IMAGEINFO iminfo;
+    int idx;
+    VALUE v_iminfo;
+    
+    RwImagelist *ri = DATA_PTR(self);
+    idx = NUM2INT(v_idx);
+    RwCheckResource(ri);
+    if(ImageList_GetImageInfo(ri->himagelist, idx, &iminfo)==0){
+	rb_raise(rb_eRuntimeError, "ImageList_GetImageInfo failed for idx:%d", idx);
+    }
+    
+    v_iminfo = CStruct_Data_Make_Struct(ccsIMAGEINFO, cs);
+//    cst_set_memory_to_struct(cs, (char*)&iminfo, (unsigned)sizeof(IMAGEINFO));
+    cs->dtstr = malloc(sizeof(IMAGEINFO));
+    if(!cs->dtstr) rb_raise(rb_eRuntimeError,"Failed to allocate memory");
+    memcpy(cs->dtstr, (char*)&iminfo, sizeof(IMAGEINFO));
+    
+    return v_iminfo;
+}
+
+static VALUE
+rwimagelist_getbkcolor(VALUE self){
+    COLORREF c;
+    RwImagelist *ri = DATA_PTR(self);
+    RwCheckResource(ri);
+    c = ImageList_GetBkColor(ri->himagelist);
+    return (c==CLR_NONE) ? Qnil : INT2FIX(c);
+}
+
+static VALUE
+rwimagelist_setbkcolor(VALUE self, VALUE v_bk){
+    COLORREF c;
+    RwImagelist *ri = DATA_PTR(self);
+    RwCheckResource(ri);
+    c = (NIL_P(v_bk)) ? CLR_NONE : (COLORREF)FIX2INT(v_bk);
+    ImageList_SetBkColor(ri->himagelist, c);
+    return self;
+}
+
+static VALUE
+rwimagelist_addicon(VALUE self, VALUE v_ico){
+    int r;
+    RwIcon *ico;
+    RwImagelist *ri = DATA_PTR(self);
+    RwCheckResource(ri);
+    RwIcon_Data_Get_Struct(v_ico, ico);
+    r = ImageList_AddIcon(ri->himagelist, ico->hicon); 
+    if(r<0)rb_raise(rb_eRuntimeError,"Imagelist_AddIcon failed(hicon=%#x)",
+		    (int)(ULONG_PTR)ico->hicon);
+    return self;
+}
+
+static VALUE
+rwimagelist_resize(VALUE self, VALUE newsize){
+    RwImagelist *ri = DATA_PTR(self);
+    int r = ImageList_SetImageCount(ri->himagelist, FIX2INT(newsize));
+    if(!r) rb_raise(rb_eRuntimeError, "failed to resize");
+    return self;
+}
+
+static VALUE
+rwimagelist_merge(VALUE self, int i1, VALUE other, int i2, int dx, int dy){
+    VALUE newimg;
+    RwImagelist *rio, *rinew;
+    RwImagelist *ri = DATA_PTR(self);
+    RwCheckResource(ri);
+    RwImagelist_Data_Get_Struct(other, rio);
+    RwCheckResource(rio);
+    newimg = RwImagelist_Data_Make_Struct(CLASS_OF(self), rinew);
+    rinew->himagelist = ImageList_Merge(ri->himagelist, FIX2INT(i1),
+					rio->himagelist, FIX2INT(i2), FIX2INT(dx), FIX2INT(dy));
+    if(!rinew->himagelist) rb_raise(rb_eRuntimeError, "failed to merge");
+    Register_rsc(rinew->himagelist, newimg);
+    return newimg;
+}
+
+static VALUE
+rwimagelist_replace(VALUE self,VALUE v_idx, VALUE v_bmp, VALUE v_mask){
+    int r;
+    RwBitmap *rb , *rm;
+    HBITMAP hbmp;
+    HBITMAP hmask = NULL;
+    RwImagelist *ri = DATA_PTR(self);
+    RwCheckResource(ri);
+    RwBitmap_Data_Get_Struct(v_bmp, rb);
+    hbmp = rw_dib2ddb(rb);
+    if(!NIL_P(v_mask)){
+	RwBitmap_Data_Get_Struct(v_mask, rm);
+	hmask = rw_dib2ddb(rm);
+    }
+    r = ImageList_Replace(ri->himagelist, FIX2INT(v_idx), hbmp, hmask);
+//    fprintf(stderr, "@1456: r=%d\n", r);
+    return r ? self : Qnil;
+}
+
+static VALUE
+rwimagelist_replace_icon(VALUE self,VALUE v_idx, VALUE v_icon){
+    int r;
+    RwIcon *rico;
+    RwImagelist *ri = DATA_PTR(self);
+    RwCheckResource(ri);
+    RwIcon_Data_Get_Struct(v_icon, rico);
+    r = ImageList_ReplaceIcon(ri->himagelist, FIX2INT(v_idx), rico->hicon);
+    return r ? self : Qnil;
+}
+
+static VALUE
+rwimagelist_geticonsize(VALUE self){
+    int cx, cy;
+    RwImagelist *ri = DATA_PTR(self);
+    RwCheckResource(ri);
+    ImageList_GetIconSize(ri->himagelist, &cx, &cy);
+    return rb_ary_new3(2, INT2FIX(cx), INT2FIX(cy));
+}
+
+static VALUE
+rwimagelist_duplicate(VALUE self){
+    VALUE robj;
+    RwImagelist *rinew;
+    HIMAGELIST himagelistnew;
+    RwImagelist *ri = DATA_PTR(self);
+    RwCheckResource(ri);
+    himagelistnew = ImageList_Duplicate(ri->himagelist);
+    robj = RwImagelist_Data_Make_Struct(rb_class_of(self), rinew);
+    rinew->himagelist = himagelistnew;
+    rinew->type = RcImagelist;
+    Register_rsc(himagelistnew, robj);
+    return robj;
+}
+
+/*
+  # Usage:
+  Imagelist#_dump(downlevel=nil)
+*/
+static VALUE
+rwimagelist_dump(int argc, VALUE* argv, VALUE self){
+    LPSTREAM pstream;
+    VALUE robj = Qnil;
+    if(CreateStreamOnHGlobal(NULL, TRUE, &pstream)==S_OK){
+	BOOL res;
+	DWORD flag;
+	RwImagelist *ri = DATA_PTR(self);
+	flag = (argc>0 && argv[0]==Qtrue) ? ILP_DOWNLEVEL : ILP_NORMAL;
+	if(FIX2INT(COMCTL_MAJOR_VERSION)==6){
+	    HANDLE hdll = LoadLibrary(TEXT("comctl32.dll"));
+	    FARPROC pImageList_WriteEx = GetProcAddress(hdll, "ImageList_WriteEx");
+	    res = (pImageList_WriteEx(ri->himagelist, flag, pstream)==S_OK);
+	} else {
+	    res = ImageList_Write(ri->himagelist, pstream);
+	}
+	if(res){
+	    robj = stream2string(pstream);
+	} else {
+	    pstream->lpVtbl->Release(pstream);
+	    rb_raise(rb_eRuntimeError, "failed to dump Imagelist");
+	}
+    } else {
+	rb_raise(rb_eRuntimeError, "failed to createstream");
+    }
+    return robj;
+}
+
+static VALUE
+rwimagelist1__load(VALUE klass, VALUE str){
+    VALUE fstring;
+    HGLOBAL hglobal;
+    HRESULT hres;
+    HIMAGELIST himagelist;
+    LPSTREAM pstream;
+    long len;
+    VALUE robj;
+
+    fstring = StringValue(str);
+    len = RSTRING_LEN(fstring);
+    hglobal = GlobalAlloc(GPTR, len);
+    if (!hglobal) rb_raise(rb_eRuntimeError, "can't allocate Global memory");
+    hres = CreateStreamOnHGlobal(hglobal, TRUE, &pstream);
+    if(hres==S_OK){
+	RwImagelist *ri;
+	char *buffer = GlobalLock(hglobal);
+	memcpy(buffer, RSTRING_PTR(fstring), len);
+	GlobalUnlock(hglobal);
+	if(himagelist = ImageList_Read(pstream)){
+	    robj = RwImagelist_Data_Make_Struct(klass, ri);
+	    ri->himagelist = himagelist;
+	    ri->type = RcImagelist;
+	    Register_rsc(himagelist, robj);
+	    pstream->lpVtbl->Release(pstream);
+	} else {
+	    pstream->lpVtbl->Release(pstream);
+	    rb_raise(rb_eRuntimeError, "failed to load Imagelist");
+	}
+    } else {
+	rb_raise(rb_eRuntimeError, "failed to create stream");
+    }
+    return robj;
+}
+
+static void
+rw_init_Imagelist(){
+    cRwImagelist = rb_define_class_under(mRwin,  "Imagelist",  rb_cData);
+    rb_define_alloc_func(cRwImagelist,  alloc_rwimagelist);
+    rb_define_method(cRwImagelist, "initialize",  rwimagelist_initialize,  -1);
+    rb_define_method(cRwImagelist, "delete", rwimagelist_delete, 0);
+    rb_define_method(cRwImagelist, "dispose", rwimagelist_delete, 0);
+    rb_define_method(cRwImagelist, "add", rwimagelist_add, -1);
+    rb_define_method(cRwImagelist, "addmasked", rwimagelist_addmasked, 2);
+    rb_define_method(cRwImagelist, "remove", rwimagelist_removeimage, 1);
+    rb_define_method(cRwImagelist, "clear", rwimagelist_removeallimage, 0);
+    rb_define_method(cRwImagelist, "size", rwimagelist_countimage, 0);
+    rb_define_method(cRwImagelist, "_himagelist", rwimagelist_himglist, 0);
+    rb_define_method(cRwImagelist, "icon", rwimagelist_geticon, -1);
+    rb_define_method(cRwImagelist, "imageinfo", rwimagelist_getimageinfo, 1);
+    rb_define_method(cRwImagelist, "bkcolor", rwimagelist_getbkcolor, 0);
+    rb_define_method(cRwImagelist, "bkcolor=", rwimagelist_setbkcolor, 1);
+    rb_define_method(cRwImagelist, "addicon", rwimagelist_addicon, 1);
+    rb_define_method(cRwImagelist, "resize", rwimagelist_resize, 1);
+    rb_define_method(cRwImagelist, "merge", rwimagelist_merge, 5);
+    rb_define_method(cRwImagelist, "replace", rwimagelist_replace, 3);
+    rb_define_method(cRwImagelist, "replaceicon", rwimagelist_replace_icon, 2);
+    rb_define_method(cRwImagelist, "iconsize", rwimagelist_geticonsize, 0);
+    rb_define_method(cRwImagelist, "dup", rwimagelist_duplicate, 0);
+    
+    rb_define_method(cRwImagelist, "_dump", rwimagelist_dump, -1);
+    rb_define_singleton_method(cRwImagelist, "_load", rwimagelist1__load, 1);
+}
+
+/* Font */
+
+VALUE cRwFont;
+static void
+rwfont_free(void* ptr){
+    RwFont* rf = ptr;
+    if (rf->hfont && !rf->external) DeleteObject(rf->hfont);
+    free(rf);
+}
+
+static size_t
+rwfont_memsize(const void *ptr){
+    return ptr ? sizeof(RwFont) : 0;
+}
+
+const rb_data_type_t
+rwfont_data_type = {
+    "Font", {NULL, rwfont_free, rwfont_memsize}, NULL, NULL
+};
+
+static VALUE
+alloc_rwfont(VALUE klass){
+    RwFont *rf;
+    VALUE robj = RwFont_Data_Make_Struct(klass, rf);
+    rf->type = RcFont;
+    return robj;
+}
+
+static VALUE
+rwfont_initialize(int argc, VALUE *argv, VALUE self){
+    RwFont *rf = DATA_PTR(self);
+    if (argc==1){
+	CStructData *cs;
+	LOGFONT *lf;
+	if(!rb_typeddata_is_kind_of(argv[0], &cstruct_data_type)){
+	    rb_raise(rb_eArgError, "Not CStruct");
+	}
+	CStruct_Data_Get_Struct(argv[0], cs);
+	lf = (LOGFONT*)(cs->dtstr + cs->dtoffset);
+	rf->hfont = CreateFontIndirect(lf);
+    } else {
+	LOGFONT lf;
+	TCHAR *fontname;
+	size_t n;
+	VALUE v_name, v_height, v_weight, v_italic, v_underline, v_strikeout;
+	rb_scan_args(argc, argv, "24",
+		     &v_name, &v_height, &v_weight, &v_italic, &v_underline, &v_strikeout);
+	fontname = rw_str2tchar2(v_name, &n);
+	if(n/sizeof(TCHAR) > LF_FACESIZE){
+	    rb_raise(rb_eArgError, "face name size over (>%d)", LF_FACESIZE);
+	}
+	ZeroMemory(&lf, sizeof(LOGFONT));
+	memcpy(lf.lfFaceName, fontname, n);
+	lf.lfHeight = FIX2INT(v_height);
+	lf.lfWeight = NIL_P(v_weight) ? FW_DONTCARE : FIX2INT(v_weight);
+	lf.lfItalic = (NIL_P(v_italic) || !v_italic) ? FALSE : TRUE;
+	lf.lfUnderline = (NIL_P(v_underline) || !v_underline) ? FALSE : TRUE;
+	lf.lfStrikeOut = (NIL_P(v_strikeout) || !v_strikeout) ? FALSE : TRUE;
+	lf.lfCharSet = DEFAULT_CHARSET;
+	rf->hfont = CreateFontIndirect(&lf);
+    }
+    if(!rf->hfont) rb_raise(rb_eRuntimeError, "CreateFont failed");
+    Register_rsc(rf->hfont, self);
+    return self;
+}
+
+static VALUE
+rwfont1_wrap_hfont(VALUE klass, VALUE v_hfont){
+    RwFont* rf;
+    VALUE robj = RwFont_Data_Make_Struct(klass, rf);
+    rf->hfont = (HANDLE)NUM2ULONG_PTR(v_hfont);
+    rf->type = RcFont;
+    rf->external = 1;
+    return robj;
+}
+
+static VALUE
+rwfont_fname(VALUE self){
+    LOGFONT lf;
+    RwFont *rf = DATA_PTR(self);
+    if(!rf->hfont) return Qnil;
+    GetObject(rf->hfont, sizeof(LOGFONT), &lf);
+    return rw_encode_external(lf.lfFaceName);
+}
+
+static VALUE
+rwfont_height(VALUE self){
+    LOGFONT lf;
+    RwFont *rf = DATA_PTR(self);
+    if(!rf->hfont) return Qnil;
+    GetObject(rf->hfont, sizeof(LOGFONT), &lf);
+    return INT2NUM(lf.lfHeight);
+}
+
+static VALUE
+rwfont_hfont(VALUE self){
+    RwFont *rf = DATA_PTR(self);
+    return ULONG_PTR2NUM((ULONG_PTR)rf->hfont);
+}
+
+static VALUE
+rwfont_delete(VALUE self){
+    RwFont *rf = DATA_PTR(self);
+    if (rf->external) rb_raise(rb_eRuntimeError, "external font can't be deleted");
+    Unregister_rsc(rf->hfont);
+    DeleteObject(rf->hfont);
+    rf->hfont=0;
+    return Qtrue;
+}
+
+static VALUE
+rwfont_logfont(VALUE self){
+    RwFont *rf = DATA_PTR(self);
+    if(!rf->hfont) {
+	return Qnil;
+    } else {
+	CStructData *cd;
+	VALUE v_lf = CStruct_Data_Make_Struct(ccsLOGFONT, cd);
+	cd->dtstr = malloc(sizeof(LOGFONT));
+	GetObject(rf->hfont, sizeof(LOGFONT), cd->dtstr);
+	cd->dtoffset = 0;
+	cd->dtlen = sizeof(LOGFONT);
+	cd->dtparent = 0;
+	cd->dtreferences = 0;
+	cd->dtwrapped = 0;
+	return v_lf;
+    }
+}
+
+static VALUE
+rwfont_external_p(VALUE self){
+    RwFont *rf = DATA_PTR(self);
+    return rf->external ? Qtrue : Qfalse;
+}
+
+static void
+rw_init_Font(){
+    cRwFont = rb_define_class_under(mRwin, "Font", rb_cData);
+    rb_define_alloc_func(cRwFont, alloc_rwfont);
+    rb_define_singleton_method(cRwFont,"wraphandle", rwfont1_wrap_hfont, 1);
+    
+    rb_define_method(cRwFont, "initialize", rwfont_initialize, -1);
+    rb_define_method(cRwFont, "facename", rwfont_fname, 0);
+    rb_define_method(cRwFont, "height", rwfont_height, 0);
+    rb_define_method(cRwFont, "_hfont", rwfont_hfont, 0);
+    rb_define_method(cRwFont, "dispose", rwfont_delete, 0);
+    rb_define_method(cRwFont, "logfont", rwfont_logfont, 0);
+    rb_define_method(cRwFont, "external?", rwfont_external_p, 0);
+}
+
+/* Menu */
+
+VALUE cRwMenu;
+
+void
+rwmenu_free(void* ptr){
+    RwMenu* rm = ptr;
+    if(rm->hmenu) {
+	Unregister_rsc(rm->hmenu); 
+	DestroyMenu(rm->hmenu);
+    }
+    free(rm);
+}
+
+static size_t
+rwmenu_memsize(const void *ptr){
+    return ptr ? sizeof(RwMenu) : 0;
+}
+
+const rb_data_type_t
+rwmenu_data_type = {
+    "Menu", {NULL, rwmenu_free, rwmenu_memsize}, NULL, NULL
+};
+
+static VALUE
+alloc_rwmenu(VALUE klass){
+    RwMenu *rm;
+    VALUE robj = RwMenu_Data_Make_Struct(klass, rm);
+    rm->type = RcMenu;
+    rm->hmenu = 0;
+    rm->hwnd = 0;
+    return robj;
+}
+
+static VALUE
+rwmenu_hmenu(VALUE self){
+    RwMenu *rm = DATA_PTR(self);
+    return ULONG_PTR2NUM((ULONG_PTR)rm->hmenu);
+}
+
+static VALUE
+rwmenu_alive_p(VALUE self){
+    RwMenu *rm = DATA_PTR(self);
+    return rm->hmenu ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwmenu_createmenu(VALUE self){
+    RwMenu *rm = DATA_PTR(self);
+    rm->hmenu = CreateMenu();
+    Register_rsc(rm->hmenu, self);
+    return self;
+}
+
+static VALUE
+rwmenu_createpopup(VALUE self){
+    RwMenu *rm = DATA_PTR(self);
+    rm->hmenu = CreatePopupMenu();
+    Register_rsc(rm->hmenu, self);
+    return self;
+}
+
+static VALUE
+rwmenu_insert(int argc, VALUE *argv, VALUE self){
+    int r;
+    VALUE v_next, v_byposition, v_item, v_type, v_idcmd;
+    BOOL fByPosition;
+    MENUITEMINFO *mii;
+    RwMenu *rm = DATA_PTR(self);
+    if(argc==3 && rb_class_of(argv[2])==ccsMENUITEMINFO){ /* if MENUITEMINFO */
+	CStructData *cs;
+	v_next = argv[0];
+	v_byposition = argv[1];
+	fByPosition = (NIL_P(v_byposition) || !v_byposition) ? FALSE : TRUE;
+	CStruct_Data_Get_Struct(argv[2], cs);
+	mii = (MENUITEMINFO*)(cs->dtstr + cs->dtoffset);
+	r = InsertMenuItem(rm->hmenu, FIX2INT(v_next), fByPosition, mii);
+    } else { /* if Array */
+	size_t len;
+	mii = calloc(sizeof(MENUITEMINFO), 1);
+	rb_scan_args(argc, argv, "41", &v_next, &v_byposition, &v_item, &v_idcmd, &v_type);
+	mii->cbSize = sizeof(MENUITEMINFO);
+	if(rb_typeddata_is_kind_of(v_idcmd, &rwmenu_data_type)){
+	    RwMenu* mi;
+	    RwMenu_Data_Get_Struct(v_idcmd, mi);
+	    RwCheckResource(mi);
+	    mii->fMask = MIIM_TYPE | MIIM_SUBMENU;
+	    mii->hSubMenu = mi->hmenu;
+	} else {
+	    mii->fMask = MIIM_TYPE | MIIM_ID;
+	    mii->wID = FIX2INT(v_idcmd);
+	}
+	mii->fType = NIL_P(v_type) ? MFT_STRING : NUM2INT(v_type);
+	mii->dwTypeData = rw_str2tchar2(v_item, &len);
+	mii->cch = len/sizeof(TCHAR);
+	fByPosition = (NIL_P(v_byposition) || !v_byposition) ? FALSE : TRUE;
+	r = InsertMenuItem(rm->hmenu, FIX2INT(v_next), fByPosition, mii);
+	free(mii);
+    }
+    if(!r) rb_raise(rb_eRuntimeError, "failed to insert menu");
+    if(rm->hwnd) DrawMenuBar(rm->hwnd);
+    return self;
+}
+
+/*static void
+rwmenu_do_destroy(RwMenu* rm){
+    int i;
+    for(i=0; i<GetMenuItemCount(rm->hmenu); i++){
+	HMENU hsubmenu = GetSubMenu(rm->hmenu, i);
+	if(hsubmenu){
+	    RwMenu* sm;
+	    VALUE v_sm = Get_rsc(hsubmenu);
+	    RwMenu_Data_Get_Struct(v_sm, sm);
+	    rwmenu_do_destroy(sm);
+	}
+    }
+    Unregister_rsc(rm->hmenu);
+    rm->hmenu = 0;
+}
+
+static VALUE
+rwmenu_destroy(VALUE self){
+    HMENU hmdispose;
+    RwMenu *rm = DATA_PTR(self);
+    RwCheckResource(rm);
+    hmdispose = rm->hmenu;
+    rwmenu_do_destroy(rm);
+    return DestroyMenu(hmdispose) ? Qtrue : Qfalse;
+}*/
+
+static void
+rwmenu_do_destroy(HMENU hm){
+    int i;
+    for(i=0; i<GetMenuItemCount(hm); i++){
+	HMENU hsubmenu = GetSubMenu(hm, i);
+	if(hsubmenu){
+	    RwMenu* sm;
+	    VALUE v_sm = Get_rsc(hsubmenu);
+	    RwMenu_Data_Get_Struct(v_sm, sm);
+	    rwmenu_do_destroy(sm->hmenu);
+	    sm->hmenu = NULL;
+	}
+    }
+    Unregister_rsc(hm);
+}
+
+static VALUE
+rwmenu_destroy(VALUE self){
+    int r;
+    RwMenu *rm = DATA_PTR(self);
+    RwCheckResource(rm);
+    rwmenu_do_destroy(rm->hmenu);
+    r = DestroyMenu(rm->hmenu);
+    rm->hmenu = NULL;
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwmenu_delete(VALUE self, VALUE v_item, VALUE v_flag){
+    int r;
+    UINT fByPosition;
+    RwMenu *rm = DATA_PTR(self);
+    RwCheckResource(rm);
+    fByPosition = (NIL_P(v_flag) || !v_flag) ? MF_BYCOMMAND : MF_BYPOSITION;
+    if(fByPosition){
+	HMENU hsubmenu = GetSubMenu(rm->hmenu, NUM2UINT(v_item));
+	if(hsubmenu){
+	    RwMenu* sm;
+	    VALUE v_sm = Get_rsc(hsubmenu);
+	    RwMenu_Data_Get_Struct(v_sm, sm);
+	    rwmenu_do_destroy(hsubmenu);
+	    sm->hmenu = NULL;
+	} 
+    }
+    r = DeleteMenu(rm->hmenu, NUM2UINT(v_item), fByPosition);
+    if(rm->hwnd) DrawMenuBar(rm->hwnd);
+    return r? Qtrue : Qfalse;
+}
+
+static VALUE
+rwmenu_getmenuitemcount(VALUE self){
+    RwMenu *rm = DATA_PTR(self);
+    RwCheckResource(rm);
+    return INT2NUM(GetMenuItemCount(rm->hmenu));
+}
+
+static VALUE
+rwmenu_getmenuiteminfo(VALUE self, VALUE v_item, VALUE v_flag, VALUE v_info){
+    int r;
+    CStructData *cs; MENUITEMINFO *pmii;
+    BOOL fByPosition;
+    RwMenu *rm = DATA_PTR(self);
+    RwCheckResource(rm);
+    if(rb_class_of(v_info)!=ccsMENUITEMINFO){
+	rb_raise(rb_eArgError, "Argument must be a MENUITEMINFO");
+    }
+    CStruct_Data_Get_Struct(v_info, cs); pmii = (MENUITEMINFO*)(cs->dtstr + cs->dtoffset);
+    pmii->cbSize = sizeof(MENUITEMINFO);
+    fByPosition = (NIL_P(v_flag) || !v_flag) ? MF_BYCOMMAND : MF_BYPOSITION;
+    r = GetMenuItemInfo(rm->hmenu, NUM2UINT(v_item), fByPosition, pmii);
+    return r ? v_info : Qnil;
+}
+
+static VALUE
+rwmenu_setmenuiteminfo(VALUE self, VALUE v_item, VALUE v_flag, VALUE v_info){
+    CStructData *cs; MENUITEMINFO *pmii;
+    BOOL fByPosition;
+    RwMenu *rm = DATA_PTR(self);
+    RwCheckResource(rm);
+    if(rb_class_of(v_info)!=ccsMENUITEMINFO){
+	rb_raise(rb_eArgError, "Argument must be a MENUITEMINFO");
+    }
+    CStruct_Data_Get_Struct(v_info, cs); pmii = (MENUITEMINFO*)(cs->dtstr + cs->dtoffset);
+    pmii->cbSize = sizeof(MENUITEMINFO);
+    fByPosition = (NIL_P(v_flag) || !v_flag) ? MF_BYCOMMAND : MF_BYPOSITION;
+    SetMenuItemInfo(rm->hmenu, NUM2UINT(v_item), fByPosition, pmii);
+    if(rm->hwnd) DrawMenuBar(rm->hwnd);
+    return self;
+}
+
+/* // Tnis is obsolate on MSC of WIN64
+static VALUE
+rwmenu_getmenustring(VALUE self, VALUE v_item, VALUE v_flag){
+    int r;
+    BOOL fByPosition;
+    TCHAR* buff;
+    RwMenu *rm = DATA_PTR(self);
+    RwCheckResource(rm);
+    fByPosition = (NIL_P(v_flag) || !v_flag) ? MF_BYCOMMAND : MF_BYPOSITION;
+    r = GetMenuString(rm->hmenu, NUM2INT(v_item), NULL, 0, fByPosition);
+    if (r==0) return rb_enc_str_new_literal("", rw_external_enc);
+    buff = alloca(r*sizeof(WCHAR));
+    GetMenuString(rm->hmenu, NUM2INT(v_item), buff, r*sizeof(TCHAR), fByPosition);
+    return rw_encode_external(buff);
+}*/
+
+static VALUE
+rwmenu_getmenuitemid(VALUE self, VALUE v_idx){
+    RwMenu *rm = DATA_PTR(self);
+    return INT2FIX(GetMenuItemID(rm->hmenu, FIX2INT(v_idx)));
+}
+
+static VALUE
+rwmenu_getsubmenu(VALUE self, VALUE v_idx){
+    HMENU hmenu;
+    RwMenu *rm = DATA_PTR(self);
+    hmenu = GetSubMenu(rm->hmenu, FIX2INT(v_idx));
+    return hmenu ? Get_rsc(hmenu) : Qnil;
+}
+
+static VALUE
+rwwin_setmenu(VALUE self, VALUE v_menu){
+    RwMenu *rm;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    if (NIL_P(v_menu)){
+	SetMenu(rw->hwnd, NULL);
+    } else {
+	RwMenu_Data_Get_Struct(v_menu, rm);
+	RwCheckResource(rm);
+	SetMenu(rw->hwnd, rm->hmenu);
+	rm->hwnd = rw->hwnd;
+    }
+    DrawMenuBar(rw->hwnd);
+    return self;
+}
+
+static VALUE
+rwwin_drawmenubar(VALUE self){
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    DrawMenuBar(rw->hwnd);
+    return self;
+}
+
+static VALUE
+rwwin_trackpopupmenu(int argc, VALUE *argv, VALUE self){
+    VALUE v_menu, v_x, v_y, v_align, v_exclude;
+    int falign, r;
+    RwMenu *rm;
+    POINT pos;
+    TPMPARAMS *lptpm;
+    RwWindow *rw = DATA_PTR(self);
+    RwCheckWindow(rw);
+    rb_scan_args(argc, argv, "32", &v_menu, &v_x, &v_y, &v_align, &v_exclude);
+    RwMenu_Data_Get_Struct(v_menu, rm);
+    RwCheckResource(rm);
+    falign = NIL_P(v_align) ? TPM_LEFTALIGN : FIX2INT(v_align);
+    if(NIL_P(v_exclude)){
+	lptpm = NULL;
+    } else {
+	CStructData *cs;
+	CStruct_Data_Get_Struct(v_exclude, cs);
+	if(cs->dtlen!=sizeof(TPMPARAMS)) {
+	    rb_raise(rb_eArgError, "last argument size is not  same as TPMPARAMS's");
+	}
+	lptpm = (TPMPARAMS*)(cs->dtstr + cs->dtoffset);
+    }
+    pos.x = FIX2INT(v_x);
+    pos.y = FIX2INT(v_y);
+    ClientToScreen(rw->hwnd, &pos);
+    r = TrackPopupMenuEx(rm->hmenu, falign, pos.x, pos.y, rw->hwnd, lptpm);
+    return r ? Qtrue : Qfalse;
+}		  
+
+static void
+rw_init_Menu(){
+    cRwMenu = rb_define_class_under(mRwin, "Menu", rb_cData);
+    rb_define_alloc_func(cRwMenu,  alloc_rwmenu);
+    
+    rb_define_method(cRwMenu, "_hmenu", rwmenu_hmenu, 0);
+    rb_define_method(cRwMenu, "alive?", rwmenu_alive_p, 0);
+    rb_define_method(cRwMenu, "createmenu", rwmenu_createmenu, 0);
+    rb_define_method(cRwMenu, "createpopup", rwmenu_createpopup, 0);
+    rb_define_method(cRwMenu, "insert", rwmenu_insert, -1);
+    rb_define_method(cRwMenu, "delete", rwmenu_delete, 2);
+    rb_define_method(cRwMenu, "destroy", rwmenu_destroy, 0);
+    
+
+    /* API Functions */
+    rb_define_method(cRwMenu, "GetMenuItemCount", rwmenu_getmenuitemcount, 0);
+    rb_define_method(cRwMenu, "GetMenuItemInfo", rwmenu_getmenuiteminfo, 3);
+    rb_define_method(cRwMenu, "SetMenuItemInfo", rwmenu_setmenuiteminfo, 3);
+//    rb_define_method(cRwMenu, "GetMenuString", rwmenu_getmenustring, 2);
+    rb_define_method(cRwMenu, "GetMenuItemID", rwmenu_getmenuitemid, 1);
+    rb_define_method(cRwMenu, "GetSubMenu", rwmenu_getsubmenu, 1);
+    
+    /* Window functions */
+    rb_define_method(cRwWindow, "SetMenu", rwwin_setmenu, 1);
+    rb_define_method(cRwWindow, "DrawMenuBar", rwwin_drawmenubar, 0);
+    rb_define_method(cRwWindow, "TrackPopupMenu", rwwin_trackpopupmenu, -1);
+}
+
+/* Initialize */
+void
+Init_rw_resources(){
+    rw_init_Bitmap();
+    rw_init_Icon();
+    rw_init_Cursor();
+    rw_init_Pen();
+    rw_init_Brush();
+    rw_init_Imagelist();
+    rw_init_Font();
+    rw_init_Menu();
+}