wrb 2.0.0

data/ext/rwin/rw_graphics.c

@@ -0,0 +1,1583 @@
+/*
+# 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"
+
+/* Canvas */
+VALUE cRwCanvas;
+
+void RwCanvas_free(void *ptr){
+    if(ptr){
+	RwCanvas *cv = ptr;
+	if(cv->hwnd && cv->hdc) ReleaseDC(cv->hwnd, cv->hdc);
+	free(cv);
+    }
+}
+
+
+#ifdef HAVE_TYPE_RB_DATA_TYPE_T
+static size_t
+swdc_memsize(const void *ptr){
+    return ptr ? sizeof(RwCanvas) : 0;
+}
+
+const rb_data_type_t
+rwcanvas_data_type = { 
+    "Canvas", {NULL, RwCanvas_free, swdc_memsize}, NULL, NULL
+};
+
+#else
+#error "Need RB_DATA_TYPE_T"
+#endif
+
+static VALUE
+rwcvs_alloc(VALUE klass){
+    RwCanvas *cv;
+    VALUE obj = RwCanvas_Data_Make_Struct(klass, cv);
+    cv->hdc = 0;
+    cv->hwnd = 0;
+    cv->rx = 1.0;
+    cv->ry = 1.0;
+    return obj;
+}
+
+VALUE /* RwWindow uses this */
+rwcvs_new_from_hdc(VALUE klass, HDC hdc){
+    RwCanvas *cv;
+    VALUE obj = RwCanvas_Data_Make_Struct(klass, cv);
+    cv->hwnd = 0;
+    cv->hdc = hdc;
+    cv->rx = 1.0;
+    cv->ry = 1.0;
+    return obj;
+}
+
+static VALUE
+rwcvs1_draw(VALUE klass, VALUE arg){
+    RwCanvas *cv;
+    RwWindow *rw;
+    VALUE obj = RwCanvas_Data_Make_Struct(klass, cv);
+    switch (TYPE(arg)){
+      case T_FIXNUM:
+      case T_BIGNUM:
+	cv->hdc = (HDC)NUM2HANDLE(arg);
+	break;
+      default:
+	RwWindow_Data_Get_Struct(arg, rw);
+	RwCheckWindow(rw);
+	cv->hwnd = rw->hwnd;
+	cv->hdc = GetDC(rw->hwnd);
+	break;
+    }
+    if(!rb_block_given_p()){
+	rb_raise(rb_eArgError, "Need block");
+    } else{
+	rb_yield(obj);
+	if (cv->hwnd){
+	    ReleaseDC(cv->hwnd, cv->hdc);
+	    cv->hdc = NULL;
+	}
+    }
+    return obj;
+}
+
+static VALUE
+rwcvs_initialize(VALUE self, VALUE arg){
+    RwWindow *rw;
+    RwCanvas *cv = DATA_PTR(self);
+    switch (TYPE(arg)){
+      case T_FIXNUM:
+      case T_BIGNUM:
+	cv->hdc = (HDC)NUM2HANDLE(arg);
+	break;
+      default:
+	RwWindow_Data_Get_Struct(arg, rw);
+	RwCheckWindow(rw);
+	cv->hwnd = rw->hwnd;
+	cv->hdc = GetDC(rw->hwnd);
+	break;
+    }
+    return self;
+}
+
+static VALUE
+rwcvs_release(VALUE self){
+    RwCanvas *cv = DATA_PTR(self);
+    if(cv->hwnd && cv->hdc){
+	ReleaseDC(cv->hwnd, cv->hdc);
+	cv->hdc = NULL;
+	return Qtrue;
+    }
+    return Qfalse;
+}
+
+static VALUE
+rwcvs_gethdc(VALUE self){
+    RwCanvas *cv = DATA_PTR(self);
+    return INT2NUM((ULONG_PTR)cv->hdc);
+}
+
+/* Lines */
+static VALUE
+rwcvs_anglearc(VALUE self, VALUE v_x, VALUE v_y,
+		VALUE v_radius, VALUE v_startangle, VALUE v_sweepangle){
+    int r;
+    RwCanvas *cv = DATA_PTR(self);
+    r = AngleArc(cv->hdc, FIX2INT(v_x), FIX2INT(v_y), FIX2INT(v_radius),
+		 NUM2DBL(v_startangle), NUM2DBL(v_sweepangle));
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwcvs_arc(VALUE self, VALUE v_left, VALUE v_top, VALUE v_right, VALUE v_bottom,
+	   VALUE v_xstartarc, VALUE v_ystartarc, VALUE v_xendarc, VALUE v_yendarc){
+    int r;
+    RwCanvas *cv = DATA_PTR(self);
+    r = Arc(cv->hdc, FIX2INT(v_left), FIX2INT(v_top), FIX2INT(v_right), FIX2INT(v_bottom),
+	FIX2INT(v_xstartarc), FIX2INT(v_ystartarc), FIX2INT(v_xendarc), FIX2INT(v_yendarc));
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwcvs_arcto(VALUE self, VALUE v_left, VALUE v_top, VALUE v_right, VALUE v_bottom,
+	   VALUE v_xradial1, VALUE v_yradial1, VALUE v_xradial2, VALUE v_yrasial2){
+    int r;
+    RwCanvas *cv = DATA_PTR(self);
+    r = ArcTo(cv->hdc, FIX2INT(v_left), FIX2INT(v_top), FIX2INT(v_right), FIX2INT(v_bottom),
+	FIX2INT(v_xradial1), FIX2INT(v_yradial1), FIX2INT(v_xradial2), FIX2INT(v_yrasial2));
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwcvs_getarcdir(VALUE self){
+    RwCanvas *cv = DATA_PTR(self);
+    return INT2FIX(GetArcDirection(cv->hdc));
+}
+
+static VALUE
+rwcvs_moveto(VALUE self, VALUE v_x, VALUE v_y){
+    POINT pt;
+    RwCanvas *cv = DATA_PTR(self);
+    MoveToEx(cv->hdc, FIX2INT(v_x), FIX2INT(v_y), &pt);
+    return rb_ary_new3(2, INT2FIX(pt.x), INT2FIX(pt.y));
+}
+
+static VALUE
+rwcvs_lineto(VALUE self, VALUE v_x, VALUE v_y){
+    int r;
+    RwCanvas *cv = DATA_PTR(self);
+    r = LineTo(cv->hdc, FIX2INT(v_x), FIX2INT(v_y));
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwcvs_polybezier(int argc, VALUE* argv, VALUE self){
+    int r = 0;
+    RwCanvas *cv = DATA_PTR(self);
+    if (argc > 2){
+	int i;
+	POINT *pts = alloca(argc*sizeof(POINT));
+	for (i=0; i<argc; i++){
+	    VALUE ar = argv[i];
+	    pts[i].x = FIX2INT(rb_ary_entry(ar, 0));
+	    pts[i].y = FIX2INT(rb_ary_entry(ar, 1));
+	}
+	r = PolyBezier(cv->hdc, (POINT*)&pts, (DWORD)argc);
+    }
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwcvs_polybezierto(int argc, VALUE* argv, VALUE self){
+    int r = 0;
+    RwCanvas *cv = DATA_PTR(self);
+    if (argc > 2){
+	int i;
+	POINT *pts = alloca(argc*sizeof(POINT));
+	for (i=0; i<argc; i++){
+	    VALUE ar = argv[i];
+	    pts[i].x = FIX2INT(rb_ary_entry(ar, 0));
+	    pts[i].y = FIX2INT(rb_ary_entry(ar, 1));
+	}
+	r = PolyBezierTo(cv->hdc, (POINT*)&pts, (DWORD)argc);
+    }
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwcvs_polydraw(int argc, VALUE* argv, VALUE self){
+    int r = 0;
+    RwCanvas *cv = DATA_PTR(self);
+    if (argc > 0){
+	int i;
+	POINT *pts = alloca(argc*sizeof(POINT));
+	BYTE *types = alloca(argc);
+	for (i=0; i<argc; i++){
+	    VALUE ar = argv[i];
+	    pts[i].x = FIX2INT(rb_ary_entry(ar, 0));
+	    pts[i].y = FIX2INT(rb_ary_entry(ar, 1));
+	    types[i] = (BYTE)FIX2INT(rb_ary_entry(ar, 2));
+	}
+	r = PolyDraw(cv->hdc, (POINT*)&pts, (BYTE*)&types, (DWORD)argc);
+    }
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwcvs_polyline(int argc, VALUE* argv, VALUE self){
+    int r = 0;
+    RwCanvas *cv = DATA_PTR(self);
+    if (argc>0){
+	int i;
+	POINT *pts = alloca(argc*sizeof(POINT));
+	for (i=0; i<argc; i++){
+	    VALUE ar = argv[i];
+	    pts[i].x = FIX2INT(rb_ary_entry(ar, 0));
+	    pts[i].y = FIX2INT(rb_ary_entry(ar, 1));
+	}
+	r = Polyline(cv->hdc, (POINT*)&pts, argc);
+    }
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwcvs_polylineto(int argc, VALUE* argv, VALUE self){
+    int r = 0;
+    RwCanvas *cv = DATA_PTR(self);
+    if (argc>0){
+	int i;
+	POINT *pts = alloca(argc*sizeof(POINT));
+	for (i=0; i<argc; i++){
+	    VALUE ar = argv[i];
+	    pts[i].x = FIX2INT(rb_ary_entry(ar, 0));
+	    pts[i].y = FIX2INT(rb_ary_entry(ar, 1));
+	}
+	r = PolylineTo(cv->hdc, (POINT*)&pts, argc);
+    }
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwcvs_polypolyline(int argc, VALUE* argv, VALUE self){
+    if(argc > 0){
+	int i;
+	int *polycounts = alloca(argc*sizeof(int));
+	int npoints = 0;
+	RwCanvas *cv = DATA_PTR(self);
+	for (i=0; i<argc; i++){
+	    polycounts[i] = RARRAY_LEN(argv[i]);
+	    npoints += polycounts[i];
+	}
+	if(npoints){
+	    int r;
+	    POINT *pts = alloca(npoints*sizeof(POINT));
+	    int n = 0;
+	    for (i=0; i<argc; i++){
+		int j;
+		VALUE ar = argv[i];
+		for (j=0; j<polycounts[i]; j++){
+		    VALUE a = rb_ary_entry(ar, j);
+		    pts[n].x = FIX2INT(rb_ary_entry(a, 0));
+		    pts[n].y = FIX2INT(rb_ary_entry(a, 1));
+		    n++;
+		}
+	    }
+	    
+	    r = PolyPolyline(cv->hdc, (POINT*)&pts, (DWORD*)&polycounts, argc);
+	    return r ? Qtrue : Qfalse;
+	}
+    }
+    return Qfalse;
+}
+
+static VALUE
+rwcvs_setarcdir(VALUE self, VALUE v_arcdir){
+    int r;
+    RwCanvas *cv = DATA_PTR(self);
+    r = SetArcDirection(cv->hdc, FIX2INT(v_arcdir));
+    return INT2FIX(r);
+}
+
+/* Filled Shapes */
+
+static VALUE
+rwcvs_chord(VALUE self, VALUE v_left, VALUE v_top, VALUE v_right, VALUE v_bottom,
+	     VALUE v_xradial1, VALUE v_yradial1, VALUE v_xradial2, VALUE v_yradial2){
+    int r;
+    RwCanvas *cv = DATA_PTR(self);
+    r = Chord(cv->hdc, FIX2INT(v_left), FIX2INT(v_top), FIX2INT(v_right), FIX2INT(v_bottom),
+	      FIX2INT(v_xradial1), FIX2INT(v_yradial1), FIX2INT(v_xradial2), FIX2INT(v_yradial2));
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwcvs_ellipse(VALUE self, VALUE v_left, VALUE v_top, VALUE v_right, VALUE v_bottom){
+    int r;
+    RwCanvas *cv = DATA_PTR(self);
+    r = Ellipse(cv->hdc, FIX2INT(v_left), FIX2INT(v_top), FIX2INT(v_right), FIX2INT(v_bottom));
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwcvs_fillrect(VALUE self, VALUE v_left, VALUE v_top, VALUE v_right, VALUE v_bottom,
+		VALUE v_brush){
+    int r;
+    RECT rct;
+    HBRUSH hbrush;
+    RwCanvas *cv = DATA_PTR(self);
+    rct.left = FIX2INT(v_left);
+    rct.top = FIX2INT(v_top);
+    rct.right = FIX2INT(v_right);
+    rct.bottom = FIX2INT(v_bottom);
+    if(rb_typeddata_is_kind_of(v_brush, &rwbrush_data_type)){
+	RwBrush *rb;
+	RwBrush_Data_Get_Struct(v_brush, rb);
+	hbrush = rb->hbrush;
+    } else {
+	hbrush = (HBRUSH)NUM2HANDLE(v_brush);
+    }
+    r = FillRect(cv->hdc, &rct, hbrush);
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwcvs_framerect(VALUE self, VALUE v_left, VALUE v_top, VALUE v_right, VALUE v_bottom,
+		VALUE v_hbrush){
+    int r;
+    RECT rct;
+    RwCanvas *cv = DATA_PTR(self);
+    rct.left = FIX2INT(v_left);
+    rct.top = FIX2INT(v_top);
+    rct.right = FIX2INT(v_right);
+    rct.bottom = FIX2INT(v_bottom);
+    r = FrameRect(cv->hdc, &rct, (HBRUSH)NUM2HANDLE(v_hbrush));
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwcvs_invertrect(VALUE self, VALUE v_left, VALUE v_top, VALUE v_right, VALUE v_bottom){
+    int r;
+    RECT rct;
+    RwCanvas *cv = DATA_PTR(self);
+    rct.left = FIX2INT(v_left);
+    rct.top = FIX2INT(v_top);
+    rct.right = FIX2INT(v_right);
+    rct.bottom = FIX2INT(v_bottom);
+    r = InvertRect(cv->hdc, &rct);
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwcvs_pie(VALUE self, VALUE v_left, VALUE v_top, VALUE v_right, VALUE v_bottom,
+	     VALUE v_xradial1, VALUE v_yradial1, VALUE v_xradial2, VALUE v_yradial2){
+    int r;
+    RwCanvas *cv = DATA_PTR(self);
+    r = Pie(cv->hdc, FIX2INT(v_left), FIX2INT(v_top), FIX2INT(v_right), FIX2INT(v_bottom),
+	      FIX2INT(v_xradial1), FIX2INT(v_yradial1), FIX2INT(v_xradial2), FIX2INT(v_yradial2));
+    return r ? Qtrue : Qfalse;
+}
+
+
+static VALUE
+rwcvs_polygon(int argc, VALUE* argv, VALUE self){
+    if(argc > 1){
+	int r;
+	int i;
+	POINT *pt = alloca(argc*sizeof(POINT));
+	RwCanvas *cv = DATA_PTR(self);
+	for (i=0; i<argc; i++){
+	    VALUE v_pt = argv[i];
+	    pt[i].x = FIX2INT(rb_ary_entry(v_pt, 0));
+	    pt[i].y = FIX2INT(rb_ary_entry(v_pt, 1));
+	}
+	r = Polygon(cv->hdc, (POINT*)&pt, argc);
+	return r ? Qtrue : Qfalse;
+    }
+    return Qfalse;
+}
+
+static VALUE
+rwcvs_polypolygon(int argc, VALUE* argv, VALUE self){ // Not tested
+    if(argc > 0){
+	int i;
+	int *polycounts = alloca(argc*sizeof(int));
+	int npoints = 0;
+	RwCanvas *cv = DATA_PTR(self);
+	for (i=0; i<argc; i++){
+	    polycounts[i] = RARRAY_LEN(argv[i]);
+	    npoints += polycounts[i];
+	}
+	if(npoints){
+	    int r;
+	    POINT *pts = alloca(npoints*sizeof(POINT));
+	    int n = 0;
+	    for (i=0; i<argc; i++){
+		int j;
+		VALUE ar = argv[i];
+		for (j=0; j<polycounts[i]; j++){
+		    VALUE a = rb_ary_entry(ar, j);
+		    pts[n].x = FIX2INT(rb_ary_entry(a, 0));
+		    pts[n].y = FIX2INT(rb_ary_entry(a, 1));
+		    n++;
+		}
+	    }
+	    
+	    r = PolyPolygon(cv->hdc, (POINT*)&pts, (int*)&polycounts, argc);
+	    return r ? Qtrue : Qfalse;
+	}
+    }
+    return Qfalse;
+}
+
+static VALUE
+rwcvs_rectangle(VALUE self, VALUE v_left, VALUE v_top, VALUE v_right, VALUE v_bottom){
+    int r;
+    RwCanvas *cv = DATA_PTR(self);
+    r = Rectangle(cv->hdc, FIX2INT(v_left), FIX2INT(v_top),
+		  FIX2INT(v_right), FIX2INT(v_bottom));
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwcvs_roundrect(VALUE self, VALUE v_left, VALUE v_top, VALUE v_right, VALUE v_bottom,
+		 VALUE v_width, VALUE v_height){
+    int r;
+    RwCanvas *cv = DATA_PTR(self);
+    r = RoundRect(cv->hdc, FIX2INT(v_left), FIX2INT(v_top), FIX2INT(v_right), FIX2INT(v_bottom),
+		  FIX2INT(v_width), FIX2INT(v_height));
+    return r ? Qtrue : Qfalse;
+}
+
+/* Pens and Brushes */
+
+static VALUE
+rwcvs_setpen(VALUE self, VALUE v_pen){
+    RwCanvas *cv = DATA_PTR(self);
+    if (FIXNUM_P(v_pen)) { // RGB (Fastest!)
+	COLORREF clr = SetDCPenColor(cv->hdc, FIX2INT(v_pen));
+	SelectObject(cv->hdc, GetStockObject(DC_PEN));
+	return INT2FIX(clr);
+    } else { //SWin::Pen
+	RwPen *pen;
+	HPEN hporig;
+	RwPen_Data_Get_Struct(v_pen, pen);
+	hporig = SelectObject(cv->hdc, pen->hpen);
+	return (VALUE)aaGetval(rsclist, (ULONG_PTR)hporig);
+    }
+}
+
+static VALUE
+rwcvs_sethpen(VALUE self, VALUE v_hpen){
+    RwCanvas *cv = DATA_PTR(self);
+    SelectObject(cv->hdc, (HPEN)NUM2HANDLE(v_hpen));
+    return Qtrue;
+}
+
+
+static VALUE
+rwcvs_setbrush(VALUE self, VALUE v_brush){
+    RwCanvas *cv = DATA_PTR(self);
+    if (FIXNUM_P(v_brush)) { // RGB (Fastest!)
+	COLORREF clr = SetDCBrushColor(cv->hdc, FIX2INT(v_brush));
+	SelectObject(cv->hdc, GetStockObject(DC_BRUSH));
+	return INT2FIX(clr);
+    } else { // RWin::Brush
+	RwBrush *brush;
+	HPEN hborig;
+	RwBrush_Data_Get_Struct(v_brush, brush);
+	hborig = SelectObject(cv->hdc, brush->hbrush);
+	return (VALUE)aaGetval(rsclist, (ULONG_PTR)hborig);
+    }
+}
+
+static VALUE
+rwcvs_sethbrush(VALUE self, VALUE v_hbrush){
+    RwCanvas *cv = DATA_PTR(self);
+    SelectObject(cv->hdc, (HBRUSH)NUM2HANDLE(v_hbrush));
+    return Qtrue;
+}
+
+
+/* Fonts */
+
+static VALUE
+rwcvs_setfont(VALUE self, VALUE v_font){
+    RwFont *rf;
+    HFONT hforig;
+    RwCanvas *cv = DATA_PTR(self);
+    RwFont_Data_Get_Struct(v_font, rf);
+    hforig = SelectObject(cv->hdc, rf->hfont);
+    return (VALUE)aaGetval(rsclist, (ULONG_PTR)hforig);
+}
+
+static VALUE
+rwcvs_sethfont(VALUE self, VALUE v_hfont){
+    RwCanvas *cv = DATA_PTR(self);
+    SelectObject(cv->hdc, (HFONT)NUM2HANDLE(v_hfont));
+    return Qtrue;
+}
+
+/* Texts */
+static VALUE
+rwcvs_drawtext(int argc, VALUE *argv, VALUE self){
+    int r;
+    size_t n;
+    VALUE v_text, v_format;
+    RECT rc;
+    RECT *rect;
+    TCHAR* text;
+    RwCanvas *cv = DATA_PTR(self);
+    v_text = argv[0];
+    if(TYPE(v_text)!=T_STRING) rb_raise(rb_eTypeError, "1st argument must be string");
+    text = rw_str2tchar2(v_text, &n);
+    n = n/sizeof(TCHAR);
+    if (rb_typeddata_is_kind_of(argv[1], &cstruct_data_type)){
+	VALUE v_rect;
+	CStructData *cs;
+	rb_scan_args(argc, argv, "21", &v_text, &v_rect, &v_format);
+	CStruct_Data_Get_Struct(v_rect, cs);
+	rect = (RECT*)(cs->dtstr + cs->dtoffset);
+    } else if(argc<5){
+	VALUE v_x, v_y;
+	rb_scan_args(argc, argv, "31", &v_text, &v_x, &v_y, &v_format);
+	rc.left = FIX2INT(v_x);
+	rc.top  = FIX2INT(v_y);
+	DrawText(cv->hdc, text, n, &rc, DT_CALCRECT);
+	rect = &rc;
+    }else{
+	VALUE v_left, v_top, v_right, v_bottom;
+	rb_scan_args(argc, argv, "51", &v_text, &v_left, &v_top, &v_right, &v_bottom, &v_format);
+	rc.left = FIX2INT(v_left);
+	rc.top = FIX2INT(v_top);
+	rc.right = FIX2INT(v_right);
+	rc.bottom = FIX2INT(v_bottom);
+	rect = &rc;
+    }
+    r = DrawText(cv->hdc, text, n, rect, NIL_P(v_format) ? DT_LEFT : FIX2INT(v_format));
+    return r ? v_text : Qnil;    
+}
+
+static VALUE
+rwcvs_textout(VALUE self, VALUE v_x, VALUE v_y, VALUE v_txt){
+    TCHAR *txt;
+    size_t len;
+    RwCanvas *cv = DATA_PTR(self);
+    if(TYPE(v_txt)!=T_STRING) rb_raise(rb_eTypeError, "3rd argument must be string");
+    txt = rw_str2tchar2(v_txt, &len);
+    TextOut(cv->hdc, FIX2INT(v_x), FIX2INT(v_y), txt, len/sizeof(TCHAR));
+    return v_txt;
+}
+
+static VALUE
+rwcvs_settextcolor(VALUE self, VALUE color){
+    RwCanvas *cv = DATA_PTR(self);
+    SetTextColor(cv->hdc, FIX2INT(color));
+    return color;
+}
+
+static VALUE
+rwcvs_gettextcolor(VALUE self){
+    RwCanvas *cv = DATA_PTR(self);
+    return INT2FIX(GetTextColor(cv->hdc));
+}
+
+static VALUE
+rwcvs_setbkcolor(VALUE self, VALUE color){
+    RwCanvas *cv = DATA_PTR(self);
+    SetBkColor(cv->hdc, NUM2UINT(color));
+    return color;
+}
+
+static VALUE
+rwcvs_getbkcolor(VALUE self){
+    RwCanvas *cv = DATA_PTR(self);
+    return UINT2NUM(GetBkColor(cv->hdc));
+}
+
+static VALUE
+swingdi_gettextextent(VALUE self, VALUE v_text){
+    VALUE v_ret;
+    TCHAR *text;
+    SIZE sz;
+    int n;
+    RwCanvas *cv = DATA_PTR(self);
+    text = rw_str2tchar(v_text);
+    n = RSTRING_LEN(v_text);
+    GetTextExtentPoint(cv->hdc, text, n, &sz);
+    v_ret = rb_ary_new2(2);
+    rb_ary_store(v_ret, 0, INT2FIX(sz.cx));
+    rb_ary_store(v_ret, 1, INT2FIX(sz.cy));
+    return v_ret;
+}
+
+
+/* Back mode */
+static VALUE
+rwcvs_bkmode_transparent(VALUE self){
+    RwCanvas *cv = DATA_PTR(self);
+    return SetBkMode(cv->hdc, TRANSPARENT) ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwcvs_bkmode_opaque(VALUE self){
+    RwCanvas *cv = DATA_PTR(self);
+    return SetBkMode(cv->hdc, OPAQUE) ? Qtrue : Qfalse;
+}
+
+/* SysColor */
+
+static VALUE
+rwcvs_getsyscolor(VALUE self, VALUE v_index){
+    return INT2FIX(GetSysColor(NUM2INT(v_index)));
+}
+
+/* Bitmaps */
+
+static VALUE
+rwcvs_floodfill(int argc, VALUE *argv, VALUE self){
+    int r;
+    UINT filltype;
+    VALUE v_x, v_y, v_color, v_filltype;
+    RwCanvas *cv = DATA_PTR(self);
+    rb_scan_args(argc, argv, "31", &v_x, &v_y, &v_color, &v_filltype);
+    filltype = (NIL_P(v_filltype) || !v_filltype)? FLOODFILLBORDER : FLOODFILLSURFACE;
+    r = ExtFloodFill(cv->hdc, FIX2INT(v_x), FIX2INT(v_y), FIX2INT(v_color), filltype);
+    return r ? Qtrue : Qfalse;
+}
+
+/* BitBlts */
+
+/* BitBlt
+  Usage:
+  BitBlt(dst_x, dst_y, src_obj, rop=SRCCOPY) #or
+  BitBlt(dst_x, dst_y, dst_w, dst_h, src_obj, src_x, src_y, rop=SRCCOPY)
+*/
+static VALUE
+rwcvs_bitblt(int argc, VALUE *argv, VALUE self){
+    VALUE v_src;
+    int r;
+    BITMAP bmp;
+    HDC hdcsrc;
+    int xdst, ydst, wdst, hdst, xsrc, ysrc;
+    DWORD rop = SRCCOPY;
+    BOOL src_is_canvas = FALSE;
+    RwCanvas *cv = DATA_PTR(self);
+    xdst = ydst = xsrc = ysrc = wdst = hdst = 0;
+    
+    if(argc > 6){
+	xdst = FIX2INT(*argv++);
+	ydst = FIX2INT(*argv++);
+	wdst = FIX2INT(*argv++);
+	hdst = FIX2INT(*argv++);
+	v_src = *argv++;
+	xsrc = FIX2INT(*argv++);
+	ysrc = FIX2INT(*argv++);
+	if (argc==8) rop = NUM2UINT(*argv++);
+    } else {
+	if (argc>4)  rb_raise(rb_eArgError, "Illegal num of args: %d", argc);
+	if (src_is_canvas) rb_raise(rb_eArgError, "x, y, w, h needed when source is Canvas");
+	xdst = FIX2INT(*argv++);
+	ydst = FIX2INT(*argv++);
+	v_src = *argv++;
+	if (argc==4) rop = NUM2UINT(*argv++);
+	xsrc = 0;
+	ysrc = 0;
+    }
+    
+    if(rb_typeddata_is_kind_of(v_src, &rwbitmap_data_type)){
+	HBITMAP hbmp;
+	RwBitmap *bmsrc;
+	RwBitmap_Data_Get_Struct(v_src, bmsrc);
+	hbmp = bmsrc->hbitmap;
+	hdcsrc = bmsrc->hdc;
+	GetObject(hbmp, sizeof(BITMAP), &bmp);
+	wdst = bmp.bmWidth;
+	hdst = bmp.bmHeight;
+    }else if(rb_typeddata_is_kind_of(v_src, &rwcanvas_data_type)){
+	RwCanvas *cvsrc;
+	RwCanvas_Data_Get_Struct(v_src, cvsrc);
+	hdcsrc = cvsrc->hdc;
+	src_is_canvas = TRUE;
+    } else {
+	rb_raise(rb_eArgError, "Source is Neither Bitmap nor Canvas");
+    }
+    
+    r = BitBlt(cv->hdc, xdst, ydst, wdst, hdst, hdcsrc, xsrc, ysrc, rop);
+    return r ? Qtrue : Qfalse;
+}
+
+/* MaskBlt
+  Usage:
+  # default_rop = MAKEROP4(SRCCOPY, 0xAA0029) #(background is transparent)
+  MaskBlt(dst_x, dst_y, src_obj, mask_obj, rop=default_rop) # or
+  MaskBlt(dst_x, dst_y, dst_w, dst_h, src_obj, src_x, src_y, mask_obj, rop=default_rop)
+*/
+static VALUE
+rwcvs_maskblt(int argc, VALUE *argv, VALUE self){
+    int r;
+    HBITMAP hbmask;
+    HDC hdcsrc;
+    int xdst, ydst, wdst, hdst, xsrc, ysrc, xmask, ymask;
+    BOOL src_is_canvas = FALSE;
+    DWORD rop = MAKEROP4(SRCCOPY, 0xAA0029); // background is transparent
+    VALUE v_src, v_mask; 
+    RwCanvas *cv = DATA_PTR(self);
+    xdst = ydst = wdst = hdst = xsrc = ysrc = xmask = ymask = 0;
+    
+    if(argc > 7){
+	xdst = FIX2INT(*argv++);
+	ydst = FIX2INT(*argv++);
+	wdst = FIX2INT(*argv++);
+	hdst = FIX2INT(*argv++);
+	v_src = *argv++;
+	xsrc = FIX2INT(*argv++);
+	ysrc = FIX2INT(*argv++);
+	v_mask = *argv++; 
+	if (argc==9) rop = NUM2UINT(*argv++);
+    } else {
+	if(argc > 5) rb_raise(rb_eArgError, "Illegal num of args: %d", argc);
+	if (src_is_canvas) rb_raise(rb_eArgError, "x, y, w, h needed when source is Canvas");
+	xdst = FIX2INT(*argv++);
+	ydst = FIX2INT(*argv++);
+	v_src = *argv++;
+	v_mask = *argv++; 
+	if (argc==5) rop = NUM2UINT(*argv++);
+    }
+    
+    if(rb_typeddata_is_kind_of(v_src, &rwbitmap_data_type)){
+	BITMAP bmp;
+	HBITMAP hbmp;
+	RwBitmap *bmsrc;
+	RwBitmap_Data_Get_Struct(v_src, bmsrc);
+	hbmp = bmsrc->hbitmap;
+	hdcsrc = bmsrc->hdc;
+	GetObject(hbmp, sizeof(BITMAP), &bmp);
+	wdst = bmp.bmWidth;
+	hdst = bmp.bmHeight;
+    }else if(rb_typeddata_is_kind_of(v_src, &rwcanvas_data_type)){
+	RwCanvas *cvsrc;
+	RwCanvas_Data_Get_Struct(v_src, cvsrc);
+	hdcsrc = cvsrc->hdc;
+	src_is_canvas = TRUE;
+    } else {
+	rb_raise(rb_eArgError, "Source is Neither Bitmap nor Canvas");
+    }
+
+    if (NIL_P(v_mask)){
+	hbmask = 0;
+    } else if(rb_typeddata_is_kind_of(v_mask, &rwbitmap_data_type)){
+	BITMAP bmm;
+	RwBitmap *bmmask;
+	RwBitmap_Data_Get_Struct(v_mask, bmmask);
+	hbmask = bmmask->hbitmap;
+	GetObject(hbmask, sizeof(BITMAP), &bmm);
+	if(bmm.bmBitsPixel>1) rb_raise(rb_eArgError, "Mask isn't monochrome");
+    } else {
+	rb_raise(rb_eArgError, "Mask isn't Bitmap");
+    }
+    
+    r = MaskBlt(cv->hdc, xdst, ydst, wdst, hdst, hdcsrc, xsrc, ysrc, hbmask, xmask, ymask, rop);
+    return r ? Qtrue : Qfalse;
+}
+
+/* PatBlt
+  Usage:
+  PatBlt(x, y, w, h, rop=PATCOPY)
+*/
+static VALUE
+rwcvs_patblt(int argc, VALUE *argv, VALUE self){
+    int r;
+    VALUE v_x, v_y, v_w, v_h, v_rop;
+    RwCanvas *cv = DATA_PTR(self);
+    rb_scan_args(argc, argv, "41", &v_x, &v_y, &v_w, &v_h, &v_rop);
+    r = PatBlt(cv->hdc, FIX2INT(v_x), FIX2INT(v_y), FIX2INT(v_w), FIX2INT(v_h),
+	       NIL_P(v_rop) ? PATCOPY : NUM2UINT(v_rop));
+    return r ? Qtrue : Qfalse;
+}
+
+/* StretchBlt
+  Usage:
+  StretchBlt(dst_x, dst_y, dst_w, dst_h, src_obj, rop=SRCCOPY) # or
+  StretchBlt(dst_x, dst_y, dst_w, dst_h, src_obj, src_x, src_y, src_w, src_h, rop=SRCCOPY)
+*/
+static VALUE
+rwcvs_stretchblt(int argc, VALUE *argv, VALUE self){
+    int r;
+    BITMAP bmp;
+    VALUE v_src;
+    HDC hdcsrc;
+    int xdst, ydst, wdst, hdst, xsrc, ysrc, wsrc, hsrc;
+    BOOL src_is_canvas = FALSE;
+    DWORD rop = SRCCOPY;
+    RwCanvas *cv = DATA_PTR(self);
+    xdst = ydst = xsrc = ysrc = wdst= hdst = wsrc = hsrc = 0;
+    
+    if(argc < 5 || argc > 10){
+	rb_raise(rb_eArgError, "Illegal num of args: %d", argc);
+    }
+    if(argc > 8){ // This rayout must be change to set next of v_src.
+	xdst = FIX2INT(*argv++);
+	ydst = FIX2INT(*argv++);
+	wdst = FIX2INT(*argv++);
+	hdst = FIX2INT(*argv++);
+	v_src = *argv++;
+	xsrc = FIX2INT(*argv++);
+	ysrc = FIX2INT(*argv++);
+	wsrc = FIX2INT(*argv++);
+	hsrc = FIX2INT(*argv++);
+	if (argc==10) rop = FIX2INT(*argv++);
+    } else if(argc > 4){
+	if(src_is_canvas) rb_raise(rb_eArgError, "x, y, w, h needed when source is Canvas");
+	xdst = FIX2INT(*argv++);
+	ydst = FIX2INT(*argv++);
+	wdst = FIX2INT(*argv++);
+	hdst = FIX2INT(*argv++);
+	v_src = *argv++;
+	if (argc==6) rop = FIX2INT(*argv++);
+	wsrc = wdst;
+	hsrc = hdst;
+    }
+    if (!wdst || !hdst) rb_raise(rb_eRuntimeError, "Need x, y, w, h");
+    
+    if(rb_typeddata_is_kind_of(v_src, &rwbitmap_data_type)){
+	HBITMAP hbmp;
+	RwBitmap *bmsrc;
+	RwBitmap_Data_Get_Struct(v_src, bmsrc);
+	hbmp = bmsrc->hbitmap;
+	hdcsrc = bmsrc->hdc;
+	GetObject(hbmp, sizeof(BITMAP), &bmp);
+	wdst = wsrc = bmp.bmWidth;
+	hdst = hsrc = bmp.bmHeight;
+    }else if(rb_typeddata_is_kind_of(v_src, &rwcanvas_data_type)){
+	RwCanvas *cvsrc;
+	RwCanvas_Data_Get_Struct(v_src, cvsrc);
+	hdcsrc = cvsrc->hdc;
+	src_is_canvas = TRUE;
+    } else {
+	rb_raise(rb_eArgError, "Source is Neither Bitmap nor Canvas");
+    }
+    
+    r = StretchBlt(cv->hdc, xdst, ydst, wdst, hdst, hdcsrc, xsrc, ysrc, wsrc, hsrc, rop);
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwcvs_getstretchmode(VALUE self){
+    RwCanvas *cv = DATA_PTR(self);
+    return INT2NUM(GetStretchBltMode(cv->hdc));
+}
+
+static VALUE
+rwcvs_setstretchmode(VALUE self, VALUE v_mode){
+    int r;
+    RwCanvas *cv = DATA_PTR(self);
+    r = SetStretchBltMode(cv->hdc, NUM2INT(v_mode));    
+    return r ? Qtrue : Qfalse;
+}
+
+/* PlgBlt
+  Usage:
+  PlgBlt(dst_pt1, dst_pt2, dst_pt3, src_obj, mask=nil) # or
+  PlgBlt(dst_pt1, dst_pt2, dst_pt3, src_obj, src_x, src_y, src_w, src_h, mask=nil)
+*/
+static VALUE
+rwcvs_plgblt(int argc, VALUE *argv, VALUE self){
+    POINT pt[3];
+    BITMAP bmp;
+    HBITMAP hbmask;
+    VALUE v_src;
+    VALUE v_pt1, v_pt2, v_pt3;
+    HDC hdcsrc;
+    int xsrc, ysrc, wsrc, hsrc, r;
+    BOOL src_is_canvas = FALSE;
+    VALUE v_mask = Qnil;
+//    VALUE v_src = *argv++;
+    RwCanvas *cv = DATA_PTR(self);
+    xsrc = ysrc =  wsrc = hsrc = 0;
+    
+    if (argc > 7){
+	v_pt1 = *argv++;
+	v_pt2 = *argv++;
+	v_pt3 = *argv++;
+	v_src = *argv++;
+	xsrc = FIX2INT(*argv++);
+	ysrc = FIX2INT(*argv++);
+	wsrc = FIX2INT(*argv++);
+	hsrc = FIX2INT(*argv++);
+	if (argc==9) v_mask = *argv++;
+    } else if(argc > 3) {
+	if (src_is_canvas) rb_raise(rb_eArgError, "x, y, w, h needed when source is Canvas");
+	v_pt1 = *argv++;
+	v_pt2 = *argv++;
+	v_pt3 = *argv++;
+	v_src = *argv++;
+	if (argc==5) v_mask = *argv++;
+    }else{
+	rb_raise(rb_eArgError, "Illegal num of args: %d", argc);
+    }
+    if(TYPE(v_pt1)!=T_ARRAY || TYPE(v_pt2)!=T_ARRAY || TYPE(v_pt3)!=T_ARRAY){
+	rb_raise(rb_eArgError, "First 3 arguments msut be arrays");
+    }
+    if(rb_typeddata_is_kind_of(v_src, &rwbitmap_data_type)){
+	HBITMAP hbmp;
+	RwBitmap *bmsrc;
+	RwBitmap_Data_Get_Struct(v_src, bmsrc);
+	hbmp = bmsrc->hbitmap;
+	hdcsrc = bmsrc->hdc;
+	GetObject(hbmp, sizeof(BITMAP), &bmp);
+	wsrc = bmp.bmWidth;
+	hsrc = bmp.bmHeight;
+    }else if(rb_typeddata_is_kind_of(v_src, &rwcanvas_data_type)){
+	RwCanvas *cvsrc;
+	RwCanvas_Data_Get_Struct(v_src, cvsrc);
+	hdcsrc = cvsrc->hdc;
+	src_is_canvas = TRUE;
+    } else {
+	rb_raise(rb_eArgError, "Source is Neither Bitmap nor Canvas");
+    }
+    
+    pt[0].x = FIX2INT(rb_ary_entry(v_pt1, 0));
+    pt[0].y = FIX2INT(rb_ary_entry(v_pt1, 1));
+    pt[1].x = FIX2INT(rb_ary_entry(v_pt2, 0));
+    pt[1].y = FIX2INT(rb_ary_entry(v_pt2, 1));
+    pt[2].x = FIX2INT(rb_ary_entry(v_pt3, 0));
+    pt[2].y = FIX2INT(rb_ary_entry(v_pt3, 1));
+    
+    if (NIL_P(v_mask)){
+	hbmask = 0;
+    } else if(rb_typeddata_is_kind_of(v_mask, &rwbitmap_data_type)){
+	BITMAP bmm;
+	RwBitmap *bmmask;
+	RwBitmap_Data_Get_Struct(v_mask, bmmask);
+	hbmask = bmmask->hbitmap;
+	GetObject(hbmask, sizeof(BITMAP), &bmm);
+	if(bmm.bmBitsPixel>1) rb_raise(rb_eArgError, "Mask isn't monochrome");
+    } else {
+	rb_raise(rb_eArgError, "Mask isn't Bitmap");
+    }
+    
+    r = PlgBlt(cv->hdc, pt, hdcsrc, xsrc, ysrc, wsrc, hsrc, hbmask, 0, 0);
+    return r ? Qtrue : Qfalse;
+}
+
+static VALUE
+rwcvs_drawicon(VALUE self, VALUE v_icon, VALUE v_x, VALUE v_y){
+    RwIcon *ri;
+    RwCanvas *cv = DATA_PTR(self);
+    if (!rb_typeddata_is_kind_of(v_icon, &rwicon_data_type)){
+	rb_raise(rb_eArgError,"RWin::Icon required.");
+    }
+    RwIcon_Data_Get_Struct(v_icon, ri);
+    return DrawIcon(cv->hdc, FIX2INT(v_x), FIX2INT(v_y), ri->hicon) ? Qtrue : Qnil;
+}
+
+static VALUE
+rwcvs_drawimagelist(int argc, VALUE *argv, VALUE self){
+    VALUE v_imglist, v_idx, v_x, v_y, v_style;
+    int style;
+    RwImagelist *ri;
+    RwCanvas *cv = DATA_PTR(self);
+    rb_scan_args(argc, argv, "41", &v_imglist, &v_idx, &v_x, &v_y, &v_style);
+    if (!rb_typeddata_is_kind_of(v_imglist, &rwimagelist_data_type)){
+	rb_raise(rb_eArgError,"RWin::Imagelist required.");
+    }
+    RwImagelist_Data_Get_Struct(v_imglist, ri);
+    style = NIL_P(v_style) ? ILD_NORMAL : FIX2INT(v_style);
+   return ImageList_Draw(ri->himagelist, FIX2INT(v_idx),
+			 cv->hdc, FIX2INT(v_x), FIX2INT(v_y),style) ? Qtrue : Qnil;
+}
+
+/* DeviceCaps */
+static VALUE
+rwcvs_getdevcaps(VALUE self, VALUE v_idx){
+    RwCanvas *cv = DATA_PTR(self);
+    return INT2NUM(GetDeviceCaps(cv->hdc, FIX2INT(v_idx)));
+}
+
+static VALUE
+rwcvs_getlogpixels(VALUE self){
+    RwCanvas *cv = DATA_PTR(self);
+    return rb_ary_new3(2, INT2FIX(GetDeviceCaps(cv->hdc,LOGPIXELSX)),
+		       INT2FIX(GetDeviceCaps(cv->hdc,LOGPIXELSX)));
+}
+
+/* RaterOperations */
+static VALUE
+rwcvs_setrop2(VALUE self, VALUE v_rop){
+    RwCanvas *cv = DATA_PTR(self);
+    return INT2FIX(SetROP2(cv->hdc, FIX2INT(v_rop)));
+}
+
+VALUE
+rwcvs_getrop2(VALUE self){
+    RwCanvas *cv = DATA_PTR(self);
+    return INT2FIX(GetROP2(cv->hdc));
+}
+
+/* #################################################################### */
+
+static void
+rw_init_RwCanvas(){
+    cRwCanvas = rb_define_class_under(mRwin, "Canvas", rb_cData);
+    rb_define_alloc_func(cRwCanvas, rwcvs_alloc);
+
+    rb_define_singleton_method(cRwCanvas, "draw", rwcvs1_draw, 1);
+    
+    rb_define_method(cRwCanvas, "initialize", rwcvs_initialize, 1);
+    rb_define_method(cRwCanvas, "release", rwcvs_release, 0);
+    rb_define_method(cRwCanvas, "_hdc", rwcvs_gethdc, 0);
+
+    /* Lines and Curves */
+    rb_define_method(cRwCanvas, "AngleArc", rwcvs_anglearc, 5);
+    rb_define_method(cRwCanvas, "Arc", rwcvs_arc, 8);
+    rb_define_method(cRwCanvas, "ArcTo", rwcvs_arcto, 8);
+    rb_define_method(cRwCanvas, "GetArcDirection", rwcvs_getarcdir, 0);
+    rb_define_method(cRwCanvas, "LineTo", rwcvs_lineto, 2);
+    rb_define_method(cRwCanvas, "MoveTo", rwcvs_moveto, 2);
+    rb_define_method(cRwCanvas, "PolyBezier", rwcvs_polybezier, -1);
+    rb_define_method(cRwCanvas, "PolyBezierTo", rwcvs_polybezierto, -1);
+    rb_define_method(cRwCanvas, "PolyDraw", rwcvs_polydraw, -1);
+    rb_define_method(cRwCanvas, "Polyline", rwcvs_polyline, -1);
+    rb_define_method(cRwCanvas, "PolylineTo", rwcvs_polylineto, -1);
+    rb_define_method(cRwCanvas, "PolyPolyline", rwcvs_polypolyline, -1); // Not Tested
+    rb_define_method(cRwCanvas, "SetArcDirection", rwcvs_setarcdir, 1);
+
+    /* Filled Shapes */
+    rb_define_method(cRwCanvas, "Chord", rwcvs_chord, 8);
+    rb_define_method(cRwCanvas, "Ellipse", rwcvs_ellipse, 4);
+    rb_define_method(cRwCanvas, "FillRect", rwcvs_fillrect, 5);
+    rb_define_method(cRwCanvas, "FrameRect", rwcvs_framerect, 5);
+    rb_define_method(cRwCanvas, "InvertRect", rwcvs_invertrect, 4);
+    rb_define_method(cRwCanvas, "Pie", rwcvs_pie, 8);
+    rb_define_method(cRwCanvas, "Polygon", rwcvs_polygon, -1);
+    rb_define_method(cRwCanvas, "PolyPolygon", rwcvs_polypolygon, -1); // Not Tested
+    rb_define_method(cRwCanvas, "Rectangle", rwcvs_rectangle, 4);
+    rb_define_method(cRwCanvas, "RoundRect", rwcvs_roundrect, 6);
+
+    /* Pens and Brushes */
+    rb_define_method(cRwCanvas, "SetPen", rwcvs_setpen, 1);
+    rb_define_method(cRwCanvas, "SetHPen", rwcvs_sethpen, 1);
+    rb_define_method(cRwCanvas, "SetBrush", rwcvs_setbrush, 1);
+    rb_define_method(cRwCanvas, "SetHBrush", rwcvs_sethbrush, 1);
+
+    
+    /* Fonts */
+    rb_define_method(cRwCanvas, "SetFont", rwcvs_setfont, 1);
+    rb_define_method(cRwCanvas, "SetHFont", rwcvs_sethfont, 1);
+    
+    /* Texts */
+    rb_define_method(cRwCanvas, "DrawText", rwcvs_drawtext, -1);
+    rb_define_method(cRwCanvas, "TextOut", rwcvs_textout, 3);
+    rb_define_method(cRwCanvas, "SetTextColor", rwcvs_settextcolor, 1);
+    rb_define_method(cRwCanvas, "GetTextColor", rwcvs_gettextcolor, 0); 
+    rb_define_method(cRwCanvas, "SetBkColor", rwcvs_setbkcolor, 1);
+    rb_define_method(cRwCanvas, "GetBkColor", rwcvs_getbkcolor, 0);
+    rb_define_method(cRwCanvas, "GetTextExtent", swingdi_gettextextent, 1);
+
+    /* BackMode */
+    rb_define_method(cRwCanvas, "Transparent", rwcvs_bkmode_transparent, 0);
+    rb_define_method(cRwCanvas, "Opaque", rwcvs_bkmode_opaque, 0);
+    
+    /* SysColor */
+    rb_define_method(cRwCanvas, "GetSysColor", rwcvs_getsyscolor, 1);
+
+    /* Bitmaps */
+    rb_define_method(cRwCanvas, "FloodFill", rwcvs_floodfill, -1);
+
+    /* Bitblts */
+    rb_define_method(cRwCanvas, "BitBlt",  rwcvs_bitblt, -1);
+    rb_define_method(cRwCanvas, "MaskBlt", rwcvs_maskblt, -1);
+    rb_define_method(cRwCanvas, "PatBlt", rwcvs_patblt, -1);
+    rb_define_method(cRwCanvas, "StretchBlt", rwcvs_stretchblt, -1);
+    rb_define_method(cRwCanvas, "PlgBlt", rwcvs_plgblt, -1);
+    rb_define_method(cRwCanvas, "GetStretchBltMode", rwcvs_getstretchmode, 0);
+    rb_define_method(cRwCanvas, "SetStretchBltMode", rwcvs_setstretchmode, 1);
+    rb_define_method(cRwCanvas, "DrawIcon", rwcvs_drawicon, 3);
+    rb_define_method(cRwCanvas, "DrawImagelist", rwcvs_drawimagelist, -1);
+          /* This is not API function, but named like it. */
+    
+    /* DeviceCaps */
+    rb_define_method(cRwCanvas, "GetDeviceCaps", rwcvs_getdevcaps, 1);
+    rb_define_method(cRwCanvas, "GetLogPixels", rwcvs_getlogpixels, 0);
+
+    
+    /* Raster Operations */
+    rb_define_method(cRwCanvas, "GetROP2", rwcvs_getrop2, 0);
+    rb_define_method(cRwCanvas, "SetROP2", rwcvs_setrop2, 1);
+    
+    /* Ratios */
+//    rb_define_method(cRwCanvas, "SetRatio", rwcvs_setratio, -1);
+//    rb_define_method(cRwCanvas, "GetRatio", rwcvs_getratio, 0);
+    
+}
+
+/* GDI Plus (Wapper of gdiplusflat) */
+
+const GdiplusStartupInput gdip_startup_input = {1, 0, 0, 0};
+ULONG_PTR gdip_token;
+
+static void
+rwimage_free(void* ptr){
+    RwImage* ri = ptr;
+    Unregister_rsc(ri->himage);
+    if(gdip_token && ri->himage) GdipDisposeImage(ri->himage);
+    free(ri);
+}
+
+static size_t
+rwimage_memsize(const void *ptr){
+    return ptr ? sizeof(RwImage) : 0;
+}
+
+const rb_data_type_t rwimage_data_type = {
+    "Picture", {NULL, rwimage_free, rwimage_memsize}, NULL, NULL
+};
+
+extern void rwbitmap_free(RwCanvas *rc);
+extern void rwicon_free(RwIcon *ri);
+
+const GUID EncoderQuality ={0x1d5be4b5,0xfa4a,0x452d,{0x9c,0xdd,0x5d,0xb3,0x51,0x05,0xe7,0xeb}};
+const GUID EncoderSaveFlag={0x292266fc,0xac40,0x47bf,{0x8c,0xfc,0xa8,0x5b,0x89,0xa6,0x55,0xde}};
+const GUID EncoderVersion ={0x24d18c76,0x814a,0x41a4,{0xbf,0x53,0x1c,0x21,0x9c,0xcc,0xf7,0x97}};
+
+VALUE cRwImage;  /* holder of Image object */
+
+void
+rwgdiplus_startup(){
+    GdiplusStartup(&gdip_token, &gdip_startup_input, 0);
+}
+ 
+void
+rwgdiplus_shutdown(){
+    GdiplusShutdown(gdip_token);
+    gdip_token = 0;
+}
+
+static VALUE
+rwgdip1_picture_fromfilestream(VALUE klass, VALUE v_path){
+    RwImage *ri;
+    VALUE robj;
+    int r;
+    HANDLE hBuf;
+    FILE *fp;
+    BYTE *gmem;
+    size_t sz;
+    IStream *pstream;
+    HANDLE hbmp = NULL;
+    char path[RW_MAXPATH];
+    rwconv2absolute_path(path, RSTRING_PTR(v_path));
+#ifdef __CYGWIN__
+    if(!(fp=fopen(path, "r"))){
+#else
+    if(fopen_s(&fp, path, "rb")){
+#endif
+	rb_raise(rb_eIOError, "%s: file not found.", StringValuePtr(v_path));
+    }
+    fseek(fp, 0, SEEK_END);
+    sz = ftell(fp);
+    fseek(fp, 0, SEEK_SET);
+    hBuf=GlobalAlloc(GMEM_MOVEABLE, sz);
+    gmem = (BYTE*)GlobalLock(hBuf);
+    if(!hBuf || !gmem) {
+	fclose(fp);
+	rb_raise(rb_eIOError, "Failed to allocate and lock memory");
+    }
+    fread(gmem, sizeof(BYTE), sz, fp);
+    fclose(fp);
+    
+    pstream = 0;
+    if(CreateStreamOnHGlobal(hBuf, FALSE, &pstream)!=S_OK){
+	GlobalFree(hBuf);
+	rb_raise(rb_eIOError, "Failed to create memory stream");
+    }
+    if(r=GdipLoadImageFromStream(pstream, &hbmp)){
+	rb_raise(rb_eRuntimeError, "Failed to create Picture: error code=%d", r);
+    }
+    robj = RwImage_Data_Make_Struct(klass, ri);
+    ri->himage = hbmp;
+    Register_rsc(ri->himage, robj);
+    pstream->lpVtbl->Release(pstream);
+    GlobalFree(hBuf);
+    return robj;
+}
+
+/*
+static VALUE
+rwgdip1_picture_fromfile(VALUE klass, VALUE v_path){
+    RwImage *ri;
+    VALUE robj;
+    int r;
+    HANDLE hFile;
+    HANDLE hbmp = NULL;
+    
+    hFile = CreateFileA(RSTRING_PTR(v_path), GENERIC_READ, 0, NULL, 
+		       OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
+    if(hFile==INVALID_HANDLE_VALUE){
+	rb_raise(rb_eIOError, "%s: file not found.", StringValuePtr(v_path));
+    }
+    CloseHandle(hFile);
+    
+    robj = RwImage_Data_Make_Struct(klass, ri);
+    if(r=GdipLoadImageFromFile(rw_str2wchar(v_path), &hbmp)){
+	rb_raise(rb_eRuntimeError, "Failed to create Picture: error code=%d", r);
+    }
+    ri->himage = hbmp;
+    Register_rsc(ri->himage, robj);
+    return robj;
+}
+*/
+
+VALUE
+rwgdip1__load_core(VALUE klass, LPVOID lpdata, size_t len){
+    LPSTREAM pstream;
+    VALUE robj;
+    HGLOBAL hglobal = GlobalAlloc(GPTR, len);
+    if (!hglobal) rb_raise(rb_eRuntimeError, "can't allocate Global memory");
+    if(CreateStreamOnHGlobal(hglobal, TRUE, &pstream)==S_OK){
+	HANDLE himage = NULL;
+	char *buffer = GlobalLock(hglobal);
+	memcpy(buffer, lpdata, len);
+	if(GdipLoadImageFromStream(pstream, &himage)==Ok){
+	    RwImage *ri;
+	    robj = RwImage_Data_Make_Struct(klass, ri);
+	    ri->himage = himage;
+	    Register_rsc(himage, robj);
+	    pstream->lpVtbl->Release(pstream);
+	    GlobalFree(hglobal);
+	} else {
+	    pstream->lpVtbl->Release(pstream);
+	    GlobalFree(hglobal);
+	    rb_raise(rb_eRuntimeError, "failed to load Image");
+	}
+    } else {
+	rb_raise(rb_eRuntimeError, "failed to create stream");
+    }
+    return robj;
+}
+
+static VALUE
+rwgdip1__load(VALUE klass, VALUE str){
+    return rwgdip1__load_core(klass, RSTRING_PTR(str), RSTRING_LEN(str));
+}
+
+int
+GetEncoderClsid(const WCHAR* format, CLSID* pClsid){ /* from msdn */
+    UINT j;
+    UINT num = 0;          /* number of image encoders*/
+    UINT size = 0;         /* size of the image encoder array in bytes */
+    ImageCodecInfo* pImageCodecInfo = NULL;
+    
+    GdipGetImageEncodersSize(&num, &size);
+    if(size == 0) return -1;  /* Failure */
+    pImageCodecInfo = (ImageCodecInfo*)(malloc(size));
+    if(pImageCodecInfo == NULL) return -1;  /* Failure */
+    GdipGetImageEncoders(num, size, pImageCodecInfo);
+    
+    for(j = 0; j < num; ++j){
+	  if( wcscmp(pImageCodecInfo[j].MimeType, format) == 0 ){
+		*pClsid = pImageCodecInfo[j].Clsid;
+		free(pImageCodecInfo);
+		return j;  /* Success */
+	  }
+      }
+    free(pImageCodecInfo);
+    return -1;  /* Failure */
+}
+
+void
+set_encoder_params(EncoderParameters *encparams, int i_quality){
+    encparams->Count = 1;
+    memcpy(&encparams->Parameter[0].Guid, &EncoderQuality, sizeof(GUID));
+    encparams->Parameter[0].NumberOfValues = 1;
+    encparams->Parameter[0].Type = EncoderParameterValueTypeLong;
+    encparams->Parameter[0].Value = &i_quality;
+}
+
+VALUE
+stream2string(LPSTREAM pstream){
+    VALUE rstr;
+    HGLOBAL hglobal;
+    int len;
+    STATSTG stat;
+    char *buffer;
+    GetHGlobalFromStream(pstream, &hglobal);
+    pstream->lpVtbl->Stat(pstream, &stat, 0);
+    len = stat.cbSize.LowPart;
+    buffer = GlobalLock(hglobal);
+    rstr = rb_str_new(buffer, len);
+    pstream->lpVtbl->Release(pstream);
+    GlobalFree(hglobal);
+    return rstr;
+}
+
+static VALUE
+gdip_pic_save(VALUE self, VALUE v_encoder, VALUE v_encparam1, VALUE v_save2){
+    EncoderParameters *enc_params;
+    CLSID enc_clsid;
+    int r, i_quality;
+    VALUE robj;
+    RwImage *ri = DATA_PTR(self);
+    
+    if(TYPE(v_encoder)!=T_STRING)rb_raise(rb_eArgError, "Need encoder string sutch as \"image/png\"");
+    r = GetEncoderClsid(rw_str2wchar(v_encoder), &enc_clsid);
+    if(r<0) rb_raise(rb_eArgError, "No such encoder: %s", RSTRING_PTR(rb_inspect(v_encoder)));
+    
+    if(rb_typeddata_is_kind_of(v_encparam1, &cstruct_data_type)){
+	CStructData *cs;
+	CStruct_Data_Get_Struct(v_encparam1, cs);
+	enc_params = (EncoderParameters*)(cs->dtstr + cs->dtoffset);
+    } else {
+	enc_params = alloca(sizeof(EncoderParameters)); //+ 1*sizeof(EncoderParameter));
+	i_quality = NIL_P(v_encparam1) ? 100 : FIX2INT(v_encparam1);
+	set_encoder_params(enc_params, i_quality);
+    }
+    
+    if(NIL_P(v_save2)){
+	LPSTREAM pstream;
+	if(CreateStreamOnHGlobal(NULL, TRUE, &pstream)==S_OK){
+	    if(GdipSaveImageToStream(ri->himage, pstream, &enc_clsid, enc_params)==Ok){
+		robj = stream2string(pstream);
+	    } else{
+		pstream->lpVtbl->Release(pstream);
+		rb_raise(rb_eRuntimeError, "failed to dump picture");
+	    }
+	}else{
+	    rb_raise(rb_eRuntimeError, "failed to create stream");
+	}
+    } else {
+	wchar_t saveto[RW_MAXPATH];
+	wchar_t *path = rw_str2wchar(v_save2);
+	rwconv2absolute_pathW(saveto, path);
+	r = GdipSaveImageToFile(ri->himage, saveto, &enc_clsid, enc_params);
+	robj = r==0 ? Qtrue : Qfalse;
+    }
+    return robj;
+}
+
+/*
+  Sequence:
+  Picture#saveto(path, encoder, quality=100, save_flag=0)
+*/
+
+static VALUE
+rwgdip_picture_saveto_file(int argc, VALUE *argv, VALUE self){
+    VALUE v_path, v_encoder, v_quality;
+    rb_scan_args(argc, argv, "12", &v_path, &v_encoder, &v_quality);
+    if(NIL_P(v_encoder)) v_encoder=rb_str_new_literal("image/png");
+    return gdip_pic_save(self, v_encoder, v_quality, v_path);
+}
+
+/*
+  Sequence:
+  Picture#_dump(encoder, quality=100, save_flag=0)
+*/
+
+static VALUE
+rwgdip_picture__dump(int argc, VALUE *argv, VALUE self){
+    VALUE v_encoder, v_quality;
+    rb_scan_args(argc, argv, "02", &v_encoder, &v_quality);
+    if(NIL_P(v_encoder)) v_encoder=rb_str_new_literal("image/png");
+    return gdip_pic_save(self, v_encoder, v_quality, Qnil);
+}
+
+static VALUE
+rwgdip_himage(VALUE self){
+    RwImage *ri = DATA_PTR(self);
+    return UINT2NUM((ULONG_PTR)ri->himage);
+}
+
+static VALUE
+rwgdip_to_bitmap(int argc, VALUE *argv, VALUE self){
+    RwBitmap* rb;
+    VALUE robj;
+    HBITMAP hbitmap;
+    VALUE v_background;
+    DWORD background;
+    RwImage *ri = DATA_PTR(self);
+    rb_scan_args(argc, argv, "01", &v_background);
+    background = NIL_P(v_background) ? 0 : NUM2UINT(v_background);
+    
+    GdipCreateHBITMAPFromBitmap(ri->himage, &hbitmap, background);
+	
+    robj = RwBitmap_Data_Make_Struct(cRwBitmap, rb);
+    rb->hbitmap = hbitmap;
+    rb->shared = FALSE;
+    rb->hdc = CreateCompatibleDC(NULL);
+    SelectObject(rb->hdc, rb->hbitmap);
+    
+    Register_rsc(rb->hbitmap, robj);
+    return robj;
+}
+
+static VALUE
+rwgdip_to_icon(VALUE self){
+    int r;
+    VALUE robj;
+    RwIcon* ric;
+    HICON hicon;
+    RwImage *ri = DATA_PTR(self);
+    if(r=GdipCreateHICONFromBitmap(ri->himage, &hicon)){
+	rb_raise(rb_eRuntimeError, "Failed to create icon: error code=%d", r);
+    }
+    
+    robj = RwIcon_Data_Make_Struct(cRwIcon, ric);
+    ric->hicon = hicon;
+    ric->shared = FALSE;
+    Register_rsc(ric->hicon, robj);
+    return robj;
+}
+
+static VALUE
+rwgdip_rotateflip(VALUE self, VALUE v_rotate){
+    RwImage *ri = DATA_PTR(self);
+    if(GdipImageRotateFlip(ri->himage, FIX2INT(v_rotate))) return Qtrue;
+    return Qfalse;
+}
+
+static VALUE
+rwgdip_thumbnail(VALUE self, VALUE v_w, VALUE v_h){
+    int r;
+    HANDLE himage = NULL;
+    RwImage *ri = DATA_PTR(self);
+    r = GdipGetImageThumbnail(ri->himage,FIX2INT(v_w), FIX2INT(v_h), &himage, NULL, NULL);
+    if(r==S_OK){
+	RwImage *ri;
+	VALUE robj = RwImage_Data_Make_Struct(cRwImage, ri);
+	ri->himage = himage;
+	Register_rsc(himage, robj);
+	return robj;
+    }else{
+	return Qnil;
+    }
+}
+
+static VALUE
+rwgdip_getimagesize(VALUE self){
+    UINT w = 0;
+    UINT h = 0;
+    RwImage *ri = DATA_PTR(self);
+    GdipGetImageWidth(ri->himage, & w);
+    GdipGetImageHeight(ri->himage, & h);
+    return rb_ary_new3(2, INT2FIX(w), INT2FIX(h));
+}
+
+static VALUE
+rwgdip_getimageresolution(VALUE self){
+    REAL horiz = 0.0;
+    REAL vert = 0.0;
+    RwImage *ri = DATA_PTR(self);
+    GdipGetImageHorizontalResolution(ri->himage, & horiz);
+    GdipGetImageVerticalResolution(ri->himage, & vert);
+    return rb_ary_new3(2, DBL2NUM(horiz), DBL2NUM(vert));
+}
+
+static VALUE
+rwgdip_getpropertyitemlist(VALUE self){
+    unsigned count, i;
+    PROPID *propids;
+    VALUE robj;
+    RwImage *ri = DATA_PTR(self);
+    GdipGetPropertyCount(ri->himage, &count);
+    if(count==0) return Qnil;
+    propids = malloc(count * sizeof(PROPID));
+    GdipGetPropertyIdList(ri->himage, count, propids);
+    robj = rb_ary_new2(count);
+    for(i=0; i<count; i++){
+	rb_ary_store(robj, i, INT2NUM(propids[i]));
+    }
+    return robj;
+}
+
+static VALUE
+rwgdip_getproperty(VALUE self, VALUE v_id){
+    VALUE robj;
+    PropertyItem *pi;
+    UINT size = 0;
+    PROPID id = FIX2INT(v_id);
+    RwImage *ri = DATA_PTR(self);
+    GdipGetPropertyItemSize(ri->himage, id, &size);
+    if(!size) rb_raise(rb_eArgError, "property id:%#x not exists in this picture", (int)id);
+    pi = (PropertyItem*)malloc(size);
+    GdipGetPropertyItem(ri->himage, id, size, pi);
+    switch(pi->type){
+      case PropertyTagTypeByte:
+      case PropertyTagTypeShort:
+      case PropertyTagTypeLong:
+	robj = UINT2NUM(*(unsigned*)pi->value);
+	break;
+      case PropertyTagTypeASCII:
+	robj = rb_str_new2(pi->value);
+	break;
+      case PropertyTagTypeRational:
+      case PropertyTagTypeSRational:
+	robj = DBL2NUM(*(double*)pi->value);
+	break;
+      case PropertyTagTypeSLONG:
+	robj = INT2NUM(*(int*)pi->value);
+      case PropertyTagTypeUndefined:
+      default:
+	free(pi);
+	rb_raise(rb_eRuntimeError, "unknown type:%d", pi->type);
+    }
+    free(pi);
+    return robj;
+}
+
+static VALUE
+rwbitmap1_frompicture(int argc, VALUE *argv, VALUE klass){
+    VALUE picobj, v_background, robj;
+    RwBitmap *rb;
+    RwImage *ri;
+    DWORD background;
+    HBITMAP hbitmap;
+    
+    rb_scan_args(argc, argv, "11", &picobj, &v_background);
+    background = NIL_P(v_background) ? 0 : NUM2UINT(v_background);
+    RwImage_Data_Get_Struct(picobj, ri);
+    GdipCreateHBITMAPFromBitmap(ri->himage, &hbitmap, background);
+    robj = RwBitmap_Data_Make_Struct(klass, rb);
+    rb->hbitmap = hbitmap;
+    rb->shared = FALSE;
+    rb->hdc = CreateCompatibleDC(NULL);
+    SelectObject(rb->hdc, rb->hbitmap);
+    
+    Register_rsc(rb->hbitmap, robj);
+    return robj;
+}
+
+static void
+rw_init_RwGdiplus(){
+    rwgdiplus_startup();
+    cRwImage = rb_define_class_under(mRwin, "Picture", rb_cObject);
+    
+//    rb_define_singleton_method(cRwImage, "fromfile", rwgdip1_picture_fromfile, 1);
+    rb_define_singleton_method(cRwImage, "fromfile", rwgdip1_picture_fromfilestream, 1);
+    rb_define_singleton_method(cRwImage, "_load", rwgdip1__load, 1);
+    rb_define_method(cRwImage, "saveto", rwgdip_picture_saveto_file, -1);
+    rb_define_method(cRwImage, "_dump", rwgdip_picture__dump, -1);
+
+    rb_define_method(cRwImage, "_himage", rwgdip_himage, 0);
+    rb_define_method(cRwImage, "to_bitmap", rwgdip_to_bitmap, -1);
+    rb_define_method(cRwImage, "to_icon", rwgdip_to_icon, 0);
+    rb_define_method(cRwImage, "rotateflip", rwgdip_rotateflip, 1);
+    rb_define_method(cRwImage, "thumbnail", rwgdip_thumbnail, 2);
+    rb_define_method(cRwImage, "size", rwgdip_getimagesize, 0);
+    rb_define_method(cRwImage, "resolution", rwgdip_getimageresolution, 0);
+    rb_define_method(cRwImage, "getpropertylist", rwgdip_getpropertyitemlist, 0);
+    rb_define_method(cRwImage, "getproperty", rwgdip_getproperty, 1);
+//    rb_define_method(cRwImage, "setproperty", rwgdip_setproperty, 2);
+
+    rb_define_singleton_method(cRwBitmap, "frompicture", rwbitmap1_frompicture, -1);
+}
+
+/* Initializer */
+void
+Init_rw_graphics(){
+    rw_init_RwCanvas();
+    rw_init_RwGdiplus();
+}