gtk2 1.0.3-x86-mingw32 → 1.1.0-x86-mingw32

data/ext/gtk2/rbgdkdisplaymanager.c

@@ -1,27 +1,39 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbgdkdisplaymanager.c -
-
-  $Author: mutoh $
-  $Date: 2006/06/17 06:59:32 $
-
-  Copyright (C) 2002-2006 Ruby-GNOME2 Project Team
-************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2006 Ruby-GNOME2 Project Team
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
 
 #include "global.h"
 
 #if GTK_CHECK_VERSION(2,2,0)
+
+#define RG_TARGET_NAMESPACE cDisplayManager
 #define _SELF(obj) GDK_DISPLAY_MANAGER(RVAL2GOBJ(obj))
 
 static VALUE
-gdkdisplaymanager_get(VALUE self)
+rg_s_get(G_GNUC_UNUSED VALUE self)
 {
     return GOBJ2RVAL(gdk_display_manager_get());
 }
 
 static VALUE
-gdkdisplaymanager_list_displays(VALUE self)
+rg_displays(VALUE self)
 {
     return GSLIST2ARYF(gdk_display_manager_list_displays(_SELF(self)));
 }
@@ -36,12 +48,12 @@ gdkdisplaymanager_get_core_pointer(VALUE self)
 #endif
 
 void 
-Init_gtk_gdk_display_manager()
+Init_gtk_gdk_display_manager(VALUE mGdk)
 {
 #if GTK_CHECK_VERSION(2,2,0)
-    VALUE gdkDisplayManager = G_DEF_CLASS(GDK_TYPE_DISPLAY_MANAGER, "DisplayManager", mGdk);
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_DISPLAY_MANAGER, "DisplayManager", mGdk);
 
-    rb_define_singleton_method(gdkDisplayManager, "get", gdkdisplaymanager_get, 0);
-    rb_define_method(gdkDisplayManager, "displays", gdkdisplaymanager_list_displays, 0);
+    RG_DEF_SMETHOD(get, 0);
+    RG_DEF_METHOD(displays, 0);
 #endif
 }

data/ext/gtk2/rbgdkdragcontext.c

@@ -1,43 +1,55 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003 Masao Mutoh
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
 
-  rbgdkdnd.c -
-
-  $Author: ggc $
-  $Date: 2007/07/13 16:07:31 $
-
-  Copyright (C) 2002,2003 Masao Mutoh
-************************************************/
 #include "global.h"
 
+#define RG_TARGET_NAMESPACE cDragContext
 #define _SELF(self) (GDK_DRAG_CONTEXT(RVAL2GOBJ(self)))
 
 static VALUE
-gdkdragcontext_protocol(VALUE self)
+rg_protocol(VALUE self)
 {
     return GENUM2RVAL(_SELF(self)->protocol, GDK_TYPE_DRAG_PROTOCOL);
 }
 
 static VALUE
-gdkdragcontext_is_source(VALUE self)
+rg_source_p(VALUE self)
 {
     return CBOOL2RVAL(_SELF(self)->is_source);
 }
 
 static VALUE
-gdkdragcontext_source_window(VALUE self)
+rg_source_window(VALUE self)
 {
     return GOBJ2RVAL(_SELF(self)->source_window);
 }
 
 static VALUE
-gdkdragcontext_dest_window(VALUE self)
+rg_dest_window(VALUE self)
 {
     return GOBJ2RVAL(_SELF(self)->dest_window);
 }
 
 static VALUE
-gdkdragcontext_targets(VALUE self)
+rg_targets(VALUE self)
 {
     GList *list = _SELF(self)->targets, *cur;
     VALUE ary = rb_ary_new();
@@ -49,38 +61,38 @@ gdkdragcontext_targets(VALUE self)
 }
 
 static VALUE
-gdkdragcontext_actions(VALUE self)
+rg_actions(VALUE self)
 {
     return GFLAGS2RVAL(_SELF(self)->actions, GDK_TYPE_DRAG_ACTION);
 }
 
 static VALUE
-gdkdragcontext_suggested_action(VALUE self)
+rg_suggested_action(VALUE self)
 {
     return GFLAGS2RVAL(_SELF(self)->suggested_action, GDK_TYPE_DRAG_ACTION);
 }
 
 static VALUE
-gdkdragcontext_action(VALUE self)
+rg_action(VALUE self)
 {
     return GFLAGS2RVAL(_SELF(self)->action, GDK_TYPE_DRAG_ACTION);
 }
 
 static VALUE
-gdkdragcontext_start_time(VALUE self)
+rg_start_time(VALUE self)
 {
     return UINT2NUM(_SELF(self)->start_time);
 }
 
 static VALUE
-gdkdragcontext_initialize(VALUE self)
+rg_initialize(VALUE self)
 {   
     G_INITIALIZE(self, gdk_drag_context_new());
     return Qnil;
 }
 
 static VALUE
-gdkdragcontext_s_get_protocol(int argc, VALUE *argv, VALUE self)
+rg_s_get_protocol(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
 {
     VALUE xid;
     GdkDragProtocol prot;
@@ -106,34 +118,34 @@ gdkdragcontext_s_get_protocol(int argc, VALUE *argv, VALUE self)
 
 /* Instance Methods */
 static VALUE
-gdkdragcontext_get_selection(VALUE self)
+rg_selection(VALUE self)
 {
     return BOXED2RVAL(gdk_drag_get_selection(_SELF(self)), GDK_TYPE_ATOM);
 }
 
 static VALUE
-gdkdragcontext_drag_abort(VALUE self, VALUE time)
+rg_drag_abort(VALUE self, VALUE time)
 {
     gdk_drag_abort(_SELF(self), NUM2UINT(time));
     return self;
 }
 
 static VALUE
-gdkdragcontext_drop_reply(VALUE self, VALUE ok, VALUE time)
+rg_drop_reply(VALUE self, VALUE ok, VALUE time)
 {
     gdk_drop_reply(_SELF(self), RVAL2CBOOL(ok), NUM2UINT(time));
     return self;
 }
 
 static VALUE
-gdkdragcontext_drag_drop(VALUE self, VALUE time)
+rg_drag_drop(VALUE self, VALUE time)
 {
     gdk_drag_drop(_SELF(self), NUM2UINT(time));
     return self;
 }
 
 static VALUE
-gdkdragcontext_find_window(int argc, VALUE *argv, VALUE self)
+rg_find_window(int argc, VALUE *argv, VALUE self)
 {
     VALUE drag_window, x_root, y_root;
     GdkWindow *dest_window;
@@ -163,24 +175,63 @@ gdkdragcontext_find_window(int argc, VALUE *argv, VALUE self)
                        GENUM2RVAL(prot, GDK_TYPE_DRAG_PROTOCOL));
 }
 
+struct rbgdk_rval2gdkatomglist_args {
+    VALUE ary;
+    long n;
+    GList *result;
+};
+
 static VALUE
-gdkdragcontext_s_drag_begin(VALUE self, VALUE window, VALUE targets)
+rbgdk_rval2gdkatomglist_body(VALUE value)
 {
-    GList* list = NULL;
-    VALUE ret;
-    int i;
-    for (i = 0; i < RARRAY_LEN(targets); i++){
-        list = g_list_append(list, GINT_TO_POINTER(RVAL2ATOM(RARRAY_PTR(targets)[0])));
-    }
+    long i;
+    struct rbgdk_rval2gdkatomglist_args *args = (struct rbgdk_rval2gdkatomglist_args *)value;
+
+    for (i = 0; i < args->n; i++)
+        args->result = g_list_append(args->result, GINT_TO_POINTER(RVAL2ATOM(RARRAY_PTR(args->ary)[i])));
+
+    return Qnil;
+}
 
-    ret = GOBJ2RVAL(gdk_drag_begin(GDK_WINDOW(RVAL2GOBJ(window)), list));
-    g_list_free(list);
+static G_GNUC_NORETURN VALUE
+rbgdk_rval2gdkatomglist_rescue(VALUE value)
+{
+    g_free(((struct rbgdk_rval2gdkatomglist_args *)value)->result);
 
-    return ret;
+    rb_exc_raise(rb_errinfo());
 }
 
+static GList *
+rbgdk_rval2gdkatomglist(VALUE value)
+{
+    struct rbgdk_rval2gdkatomglist_args args;
+
+    args.ary = rb_ary_to_ary(value);
+    args.n = RARRAY_LEN(args.ary);
+    args.result = NULL;
+
+    rb_rescue(rbgdk_rval2gdkatomglist_body, (VALUE)&args,
+              rbgdk_rval2gdkatomglist_rescue, (VALUE)&args);
+
+    return args.result;
+}
+
+#define RVAL2GDKATOMGLIST(value) rbgdk_rval2gdkatomglist(value)
+
 static VALUE
-gdkdragcontext_drag_motion(VALUE self, VALUE dest_window, VALUE protocol, VALUE x_root, VALUE y_root, VALUE suggested_action, VALUE possible_actions, VALUE time)
+rg_s_drag_begin(G_GNUC_UNUSED VALUE self, VALUE rbwindow, VALUE rbtargets)
+{
+    GdkWindow *window = GDK_WINDOW(RVAL2GOBJ(rbwindow));
+    GList *targets = RVAL2GDKATOMGLIST(rbtargets);
+    GdkDragContext *result = gdk_drag_begin(window, targets);
+
+    g_list_free(targets);
+
+    return GOBJ2RVAL(result);
+}
+
+static VALUE
+rg_drag_motion(VALUE self, VALUE dest_window, VALUE protocol, VALUE x_root, VALUE y_root, VALUE suggested_action, VALUE possible_actions, VALUE time)
 {
     gboolean ret = gdk_drag_motion(_SELF(self), 
                                    GDK_WINDOW(RVAL2GOBJ(dest_window)), 
@@ -193,14 +244,14 @@ gdkdragcontext_drag_motion(VALUE self, VALUE dest_window, VALUE protocol, VALUE
 }
 
 static VALUE
-gdkdragcontext_drop_finish(VALUE self, VALUE success, VALUE time)
+rg_drop_finish(VALUE self, VALUE success, VALUE time)
 {
     gdk_drop_finish(_SELF(self), RVAL2CBOOL(success), NUM2UINT(time));
     return self;
 }
 
 static VALUE
-gdkdragcontext_drag_status(VALUE self, VALUE action, VALUE time)
+rg_drag_status(VALUE self, VALUE action, VALUE time)
 {
     gdk_drag_status(_SELF(self), 
                     RVAL2GFLAGS(action, GDK_TYPE_DRAG_ACTION), NUM2UINT(time));
@@ -209,45 +260,45 @@ gdkdragcontext_drag_status(VALUE self, VALUE action, VALUE time)
 
 #if GTK_CHECK_VERSION(2,6,0)
 static VALUE
-gdkdragcontext_drag_drop_succeeded(VALUE self)
+rg_drag_drop_succeeded_p(VALUE self)
 {
     return CBOOL2RVAL(gdk_drag_drop_succeeded(_SELF(self)));
 }
 #endif
 
 void
-Init_gtk_gdk_dragcontext()
-{
-    VALUE gdkDragContext = G_DEF_CLASS(GDK_TYPE_DRAG_CONTEXT, "DragContext", mGdk);
-
-    rb_define_singleton_method(gdkDragContext, "get_protocol", gdkdragcontext_s_get_protocol, -1);
-    rb_define_singleton_method(gdkDragContext, "drag_begin", gdkdragcontext_s_drag_begin, 1);
-
-    rb_define_method(gdkDragContext, "initialize", gdkdragcontext_initialize, 0);
-    rb_define_method(gdkDragContext, "protocol", gdkdragcontext_protocol, 0);
-    rb_define_method(gdkDragContext, "source?", gdkdragcontext_is_source, 0);
-    rb_define_method(gdkDragContext, "source_window", gdkdragcontext_source_window, 0);
-    rb_define_method(gdkDragContext, "dest_window", gdkdragcontext_dest_window, 0);
-    rb_define_method(gdkDragContext, "targets", gdkdragcontext_targets, 0);
-    rb_define_method(gdkDragContext, "actions", gdkdragcontext_actions, 0);
-    rb_define_method(gdkDragContext, "suggested_action", gdkdragcontext_suggested_action, 0);
-    rb_define_method(gdkDragContext, "action", gdkdragcontext_action, 0);
-    rb_define_method(gdkDragContext, "start_time", gdkdragcontext_start_time, 0);
-
-    rb_define_method(gdkDragContext, "selection", gdkdragcontext_get_selection, 0);
-    rb_define_method(gdkDragContext, "drag_abort", gdkdragcontext_drag_abort, 1);
-    rb_define_method(gdkDragContext, "drop_reply", gdkdragcontext_drop_reply, 2);
-    rb_define_method(gdkDragContext, "drag_drop", gdkdragcontext_drag_drop, 1);
-    rb_define_method(gdkDragContext, "find_window", gdkdragcontext_find_window, 4);
-    rb_define_method(gdkDragContext, "drag_motion", gdkdragcontext_drag_motion, 7);
-    rb_define_method(gdkDragContext, "drop_finish", gdkdragcontext_drop_finish, 2);
-    rb_define_method(gdkDragContext, "drag_status", gdkdragcontext_drag_status, 2);
+Init_gtk_gdk_dragcontext(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_DRAG_CONTEXT, "DragContext", mGdk);
+
+    RG_DEF_SMETHOD(get_protocol, -1);
+    RG_DEF_SMETHOD(drag_begin, 1);
+
+    RG_DEF_METHOD(initialize, 0);
+    RG_DEF_METHOD(protocol, 0);
+    RG_DEF_METHOD_P(source, 0);
+    RG_DEF_METHOD(source_window, 0);
+    RG_DEF_METHOD(dest_window, 0);
+    RG_DEF_METHOD(targets, 0);
+    RG_DEF_METHOD(actions, 0);
+    RG_DEF_METHOD(suggested_action, 0);
+    RG_DEF_METHOD(action, 0);
+    RG_DEF_METHOD(start_time, 0);
+
+    RG_DEF_METHOD(selection, 0);
+    RG_DEF_METHOD(drag_abort, 1);
+    RG_DEF_METHOD(drop_reply, 2);
+    RG_DEF_METHOD(drag_drop, 1);
+    RG_DEF_METHOD(find_window, 4);
+    RG_DEF_METHOD(drag_motion, 7);
+    RG_DEF_METHOD(drop_finish, 2);
+    RG_DEF_METHOD(drag_status, 2);
 #if GTK_CHECK_VERSION(2,6,0)
-    rb_define_method(gdkDragContext, "drag_drop_succeeded?", gdkdragcontext_drag_drop_succeeded, 0);
+    RG_DEF_METHOD_P(drag_drop_succeeded, 0);
 #endif
-	/* Constants */
-    G_DEF_CLASS(GDK_TYPE_DRAG_PROTOCOL, "Protocol", gdkDragContext);
-    G_DEF_CLASS(GDK_TYPE_DRAG_ACTION, "Action", gdkDragContext);
-    G_DEF_CONSTANTS(gdkDragContext, GDK_TYPE_DRAG_PROTOCOL, "GDK_DRAG_");
-    G_DEF_CONSTANTS(gdkDragContext, GDK_TYPE_DRAG_ACTION, "GDK_");
+    /* Constants */
+    G_DEF_CLASS(GDK_TYPE_DRAG_PROTOCOL, "Protocol", RG_TARGET_NAMESPACE);
+    G_DEF_CLASS(GDK_TYPE_DRAG_ACTION, "Action", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_DRAG_PROTOCOL, "GDK_DRAG_");
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_DRAG_ACTION, "GDK_");
 }

data/ext/gtk2/rbgdkdraw.c

@@ -1,16 +1,26 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbgdkdraw.c -
-
-  $Author: ggc $
-  $Date: 2007/07/13 16:07:31 $
-
-  Copyright (C) 2002-2005 Masao Mutoh
-  Copyright (C) 1998-2000 Yukihiro Matsumoto,
-                          Daisuke Kanda,
-                          Hiroshi Igarashi
-************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2005 Masao Mutoh
+ *  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+ *                          Daisuke Kanda,
+ *                          Hiroshi Igarashi
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
 
 #include "global.h"
 #include "rbpango.h"
@@ -21,16 +31,17 @@
 #include <rb_cairo.h>
 #endif
 
+#define RG_TARGET_NAMESPACE cDrawable
 #define _SELF(s) GDK_DRAWABLE(RVAL2GOBJ(s))
 
 static VALUE
-gdkdraw_get_visual(VALUE self)
+rg_visual(VALUE self)
 {
     return GOBJ2RVAL(_SELF(self));
 }
 
 static VALUE
-gdkdraw_set_colormap(VALUE self, VALUE colormap)
+rg_set_colormap(VALUE self, VALUE colormap)
 {
     VALUE old_colormap;
 
@@ -43,7 +54,7 @@ gdkdraw_set_colormap(VALUE self, VALUE colormap)
 }
 
 static VALUE
-gdkdraw_get_colormap(VALUE self)
+rg_colormap(VALUE self)
 {
     VALUE rb_colormap;
 
@@ -53,13 +64,13 @@ gdkdraw_get_colormap(VALUE self)
 }
 
 static VALUE
-gdkdraw_get_depth(VALUE self)
+rg_depth(VALUE self)
 {
     return INT2NUM(gdk_drawable_get_depth(_SELF(self)));
 }
 
 static VALUE
-gdkdraw_get_size(VALUE self)
+rg_size(VALUE self)
 {
     gint width, height;
     gdk_drawable_get_size(_SELF(self), &width, &height);
@@ -67,20 +78,19 @@ gdkdraw_get_size(VALUE self)
 }
 
 static VALUE
-gdkdraw_get_clip_region(VALUE self)
+rg_clip_region(VALUE self)
 {
     return BOXED2RVAL(gdk_drawable_get_clip_region(_SELF(self)), GDK_TYPE_REGION);
 }
 
 static VALUE
-gdkdraw_get_visible_region(VALUE self)
+rg_visible_region(VALUE self)
 {
     return BOXED2RVAL(gdk_drawable_get_visible_region(_SELF(self)), GDK_TYPE_REGION);
 }
 
-
 static VALUE
-gdkdraw_draw_point(VALUE self, VALUE gc, VALUE x, VALUE y)
+rg_draw_point(VALUE self, VALUE gc, VALUE x, VALUE y)
 {
     gdk_draw_point(_SELF(self), GDK_GC(RVAL2GOBJ(gc)),
                    NUM2INT(x), NUM2INT(y));
@@ -88,29 +98,22 @@ gdkdraw_draw_point(VALUE self, VALUE gc, VALUE x, VALUE y)
 }
 
 static VALUE
-gdkdraw_draw_points(VALUE self, VALUE gc, VALUE pnts)
+rg_draw_points(VALUE self, VALUE rbgc, VALUE rbpoints)
 {
-    GdkPoint *points;
-    int i;
+    GdkDrawable *drawable = _SELF(self);
+    GdkGC *gc = GDK_GC(RVAL2GOBJ(rbgc));
+    long n;
+    GdkPoint *points = RVAL2GDKPOINTS(rbpoints, &n);
+
+    gdk_draw_points(drawable, gc, points, n);
+
+    g_free(points);
 
-    Check_Type(pnts, T_ARRAY);
-    points = ALLOCA_N(GdkPoint,RARRAY_LEN(pnts));
-    for (i = 0; i < RARRAY_LEN(pnts); i++) {
-        Check_Type(RARRAY_PTR(pnts)[i], T_ARRAY);
-        if (RARRAY_LEN(RARRAY_PTR(pnts)[i]) < 2) {
-            rb_raise(rb_eArgError, "point %d should be array of size 2", i);
-        }
-        points[i].x = NUM2INT(RARRAY_PTR(RARRAY_PTR(pnts)[i])[0]);
-        points[i].y = NUM2INT(RARRAY_PTR(RARRAY_PTR(pnts)[i])[1]);
-    }
-    gdk_draw_points(_SELF(self), GDK_GC(RVAL2GOBJ(gc)),
-                    points,
-                    RARRAY_LEN(pnts));
     return self;
 }
 
 static VALUE
-gdkdraw_draw_line(VALUE self, VALUE gc, VALUE x1, VALUE y1, VALUE x2, VALUE y2)
+rg_draw_line(VALUE self, VALUE gc, VALUE x1, VALUE y1, VALUE x2, VALUE y2)
 {
     gdk_draw_line(_SELF(self), GDK_GC(RVAL2GOBJ(gc)),
                   NUM2INT(x1), NUM2INT(y1),
@@ -119,30 +122,23 @@ gdkdraw_draw_line(VALUE self, VALUE gc, VALUE x1, VALUE y1, VALUE x2, VALUE y2)
 }
 
 static VALUE
-gdkdraw_draw_lines(VALUE self, VALUE gc, VALUE pnts)
+rg_draw_lines(VALUE self, VALUE rbgc, VALUE rbpoints)
 {
-    GdkPoint *points;
-    int i;
+    GdkDrawable *drawable = _SELF(self);
+    GdkGC *gc = GDK_GC(RVAL2GOBJ(rbgc));
+    long n;
+    GdkPoint *points = RVAL2GDKPOINTS(rbpoints, &n);
+
+    gdk_draw_lines(drawable, gc, points, n);
+
+    g_free(points);
 
-    Check_Type(pnts, T_ARRAY);
-    points = ALLOCA_N(GdkPoint,RARRAY_LEN(pnts));
-    for (i = 0; i < RARRAY_LEN(pnts); i++) {
-        Check_Type(RARRAY_PTR(pnts)[i], T_ARRAY);
-        if (RARRAY_LEN(RARRAY_PTR(pnts)[i]) < 2) {
-            rb_raise(rb_eArgError, "point %d should be array of size 2", i);
-        }
-        points[i].x = NUM2INT(RARRAY_PTR(RARRAY_PTR(pnts)[i])[0]);
-        points[i].y = NUM2INT(RARRAY_PTR(RARRAY_PTR(pnts)[i])[1]);
-    }
-    gdk_draw_lines(_SELF(self), GDK_GC(RVAL2GOBJ(gc)),
-                   points,
-                   RARRAY_LEN(pnts));
     return self;
 }
 
 #if GTK_CHECK_VERSION(2,2,0)
 static VALUE
-gdkdraw_draw_pixbuf(VALUE self, VALUE gc, VALUE pixbuf, VALUE src_x, VALUE src_y, VALUE dest_x, VALUE dest_y, VALUE width, VALUE height, VALUE dither, VALUE x_dither, VALUE y_dither)
+rg_draw_pixbuf(VALUE self, VALUE gc, VALUE pixbuf, VALUE src_x, VALUE src_y, VALUE dest_x, VALUE dest_y, VALUE width, VALUE height, VALUE dither, VALUE x_dither, VALUE y_dither)
 {
     gdk_draw_pixbuf(_SELF(self),
                     GDK_GC(RVAL2GOBJ(gc)),
@@ -156,31 +152,78 @@ gdkdraw_draw_pixbuf(VALUE self, VALUE gc, VALUE pixbuf, VALUE src_x, VALUE src_y
 }
 #endif
 
+struct rbgdk_rval2gdksegments_args {
+    VALUE ary;
+    long n;
+    GdkSegment *result;
+};
+
 static VALUE
-gdkdraw_draw_segs(VALUE self, VALUE gc, VALUE segs)
+rbgdk_rval2gdksegments_body(VALUE value)
 {
-    GdkSegment *segments;
-    int i;
+    long i;
+    struct rbgdk_rval2gdksegments_args *args = (struct rbgdk_rval2gdksegments_args *)value;
+
+    for (i = 0; i < args->n; i++) {
+        VALUE segments = rb_ary_to_ary(RARRAY_PTR(args->ary)[i]);
 
-    Check_Type(segs, T_ARRAY);
-    segments = ALLOCA_N(GdkSegment,RARRAY_LEN(segs));
-    for (i = 0; i < RARRAY_LEN(segs); i++) {
-        Check_Type(RARRAY_PTR(segs)[i], T_ARRAY);
-        if (RARRAY_LEN(RARRAY_PTR(segs)[i]) < 4) {
-            rb_raise(rb_eArgError, "segment %d should be array of size 4", i);
-        }
-        segments[i].x1 = NUM2INT(RARRAY_PTR(RARRAY_PTR(segs)[i])[0]);
-        segments[i].y1 = NUM2INT(RARRAY_PTR(RARRAY_PTR(segs)[i])[1]);
-        segments[i].x2 = NUM2INT(RARRAY_PTR(RARRAY_PTR(segs)[i])[2]);
-        segments[i].y2 = NUM2INT(RARRAY_PTR(RARRAY_PTR(segs)[i])[3]);
+        if (RARRAY_LEN(segments) != 2)
+            rb_raise(rb_eArgError, "segment %ld should be array of size 4", i);
+
+        args->result[i].x1 = NUM2INT(RARRAY_PTR(segments)[0]);
+        args->result[i].y1 = NUM2INT(RARRAY_PTR(segments)[1]);
+        args->result[i].x2 = NUM2INT(RARRAY_PTR(segments)[2]);
+        args->result[i].y2 = NUM2INT(RARRAY_PTR(segments)[3]);
     }
-    gdk_draw_segments(_SELF(self), GDK_GC(RVAL2GOBJ(gc)),
-                      segments, RARRAY_LEN(segs));
+
+    return Qnil;
+}
+
+static G_GNUC_NORETURN VALUE
+rbgdk_rval2gdksegments_rescue(VALUE value)
+{
+    g_free(((struct rbgdk_rval2gdksegments_args *)value)->result);
+
+    rb_exc_raise(rb_errinfo());
+}
+
+static GdkSegment *
+rbgdk_rval2gdksegments(VALUE value, long *n)
+{
+    struct rbgdk_rval2gdksegments_args args;
+
+    args.ary = rb_ary_to_ary(value);
+    args.n = RARRAY_LEN(args.ary);
+    args.result = g_new(GdkSegment, args.n + 1);
+
+    rb_rescue(rbgdk_rval2gdksegments_body, (VALUE)&args,
+              rbgdk_rval2gdksegments_rescue, (VALUE)&args);
+
+    if (n != NULL)
+        *n = args.n;
+
+    return args.result;
+}
+
+#define RVAL2GDKSEGMENTS(value, n) rbgdk_rval2gdksegments(value, n)
+
+static VALUE
+rg_draw_segments(VALUE self, VALUE rbgc, VALUE rbsegments)
+{
+    GdkDrawable *drawable = _SELF(self);
+    GdkGC *gc = GDK_GC(RVAL2GOBJ(rbgc));
+    long n;
+    GdkSegment *segments = RVAL2GDKSEGMENTS(rbsegments, &n);
+
+    gdk_draw_segments(drawable, gc, segments, n);
+
+    g_free(segments);
+
     return self;
 }
 
 static VALUE
-gdkdraw_draw_rect(VALUE self, VALUE gc, VALUE filled, VALUE x, VALUE y, VALUE w, VALUE h)
+rg_draw_rectangle(VALUE self, VALUE gc, VALUE filled, VALUE x, VALUE y, VALUE w, VALUE h)
 {
     gdk_draw_rectangle(_SELF(self), GDK_GC(RVAL2GOBJ(gc)),
                        RVAL2CBOOL(filled),
@@ -190,7 +233,7 @@ gdkdraw_draw_rect(VALUE self, VALUE gc, VALUE filled, VALUE x, VALUE y, VALUE w,
 }
 
 static VALUE
-gdkdraw_draw_arc(VALUE self, VALUE gc, VALUE filled, VALUE x, VALUE y, VALUE w, VALUE h, VALUE a1, VALUE a2)
+rg_draw_arc(VALUE self, VALUE gc, VALUE filled, VALUE x, VALUE y, VALUE w, VALUE h, VALUE a1, VALUE a2)
 {
     gdk_draw_arc(_SELF(self), GDK_GC(RVAL2GOBJ(gc)),
                  RVAL2CBOOL(filled),
@@ -201,25 +244,18 @@ gdkdraw_draw_arc(VALUE self, VALUE gc, VALUE filled, VALUE x, VALUE y, VALUE w,
 }
 
 static VALUE
-gdkdraw_draw_poly(VALUE self, VALUE gc, VALUE filled, VALUE pnts)
+rg_draw_polygon(VALUE self, VALUE rbgc, VALUE rbfilled, VALUE rbpoints)
 {
-    GdkPoint *points;
-    int i;
+    GdkDrawable *drawable = _SELF(self);
+    GdkGC *gc = GDK_GC(RVAL2GOBJ(rbgc));
+    gboolean filled = RVAL2CBOOL(rbfilled);
+    long n;
+    GdkPoint *points = RVAL2GDKPOINTS(rbpoints, &n);
+
+    gdk_draw_polygon(drawable, gc, filled, points, n);
+
+    g_free(points);
 
-    Check_Type(pnts, T_ARRAY);
-    points = ALLOCA_N(GdkPoint,RARRAY_LEN(pnts));
-    for (i = 0; i < RARRAY_LEN(pnts); i++) {
-        Check_Type(RARRAY_PTR(pnts)[i], T_ARRAY);
-        if (RARRAY_LEN(RARRAY_PTR(pnts)[i]) < 2) {
-            rb_raise(rb_eArgError, "point %d should be array of size 2", i);
-        }
-        points[i].x = NUM2INT(RARRAY_PTR(RARRAY_PTR(pnts)[i])[0]);
-        points[i].y = NUM2INT(RARRAY_PTR(RARRAY_PTR(pnts)[i])[1]);
-    }
-    gdk_draw_polygon(_SELF(self), GDK_GC(RVAL2GOBJ(gc)),
-                     RVAL2CBOOL(filled),
-                     points,
-                     RARRAY_LEN(pnts));
     return self;
 }
 
@@ -227,36 +263,81 @@ gdkdraw_draw_poly(VALUE self, VALUE gc, VALUE filled, VALUE pnts)
 /*
   trapezoids = [[y1, x11, x21, y2, x12, x22], ...]
  */
+struct rbgdk_rval2gdktrapezoids_args {
+    VALUE ary;
+    long n;
+    GdkTrapezoid *result;
+};
+
 static VALUE
-gdkdraw_draw_trapezoids(VALUE self, VALUE gc, VALUE trapezoids)
+rbgdk_rval2gdktrapezoids_body(VALUE value)
 {
-    GdkTrapezoid *gtrapezoids;
-    gint i, len;
+    long i;
+    struct rbgdk_rval2gdktrapezoids_args *args = (struct rbgdk_rval2gdktrapezoids_args *)value;
 
-    Check_Type(trapezoids, T_ARRAY);
+    for (i = 0; i < args->n; i++) {
+        VALUE trapezoids = rb_ary_to_ary(RARRAY_PTR(args->ary)[i]);
 
-    len = RARRAY_LEN(trapezoids);
+        if (RARRAY_LEN(trapezoids) != 6)
+            rb_raise(rb_eArgError, "trapezoid %ld should be array of size 6", i);
 
-    gtrapezoids = ALLOCA_N(GdkTrapezoid, len);
-    for (i = 0; i < len; i++) {
-        Check_Type(RARRAY_PTR(trapezoids)[i], T_ARRAY);
-        if (RARRAY_LEN(RARRAY_PTR(trapezoids)[i]) < 6) {
-            rb_raise(rb_eArgError, "trapezoids %d should be array of size 6", i);
-        }
-        gtrapezoids[i].y1 = NUM2DBL(RARRAY_PTR(RARRAY_PTR(trapezoids)[i])[0]);
-        gtrapezoids[i].x11 = NUM2DBL(RARRAY_PTR(RARRAY_PTR(trapezoids)[i])[1]);
-        gtrapezoids[i].x21 = NUM2DBL(RARRAY_PTR(RARRAY_PTR(trapezoids)[i])[2]);
-        gtrapezoids[i].y2 = NUM2DBL(RARRAY_PTR(RARRAY_PTR(trapezoids)[i])[3]);
-        gtrapezoids[i].x12 = NUM2DBL(RARRAY_PTR(RARRAY_PTR(trapezoids)[i])[4]);
-        gtrapezoids[i].x22 = NUM2DBL(RARRAY_PTR(RARRAY_PTR(trapezoids)[i])[5]);
+        args->result[i].y1 = NUM2DBL(RARRAY_PTR(trapezoids)[0]);
+        args->result[i].x11 = NUM2DBL(RARRAY_PTR(trapezoids)[1]);
+        args->result[i].x21 = NUM2DBL(RARRAY_PTR(trapezoids)[2]);
+        args->result[i].y2 = NUM2DBL(RARRAY_PTR(trapezoids)[3]);
+        args->result[i].x12 = NUM2DBL(RARRAY_PTR(trapezoids)[4]);
+        args->result[i].x22 = NUM2DBL(RARRAY_PTR(trapezoids)[5]);
     }
-    gdk_draw_trapezoids(_SELF(self), GDK_GC(RVAL2GOBJ(gc)), gtrapezoids, len);
-    return self; 
+
+    return Qnil;
+}
+
+static G_GNUC_NORETURN VALUE
+rbgdk_rval2gdktrapezoids_rescue(VALUE value)
+{
+    g_free(((struct rbgdk_rval2gdktrapezoids_args *)value)->result);
+
+    rb_exc_raise(rb_errinfo());
+}
+
+static GdkTrapezoid *
+rbgdk_rval2gdktrapezoids(VALUE value, long *n)
+{
+    struct rbgdk_rval2gdktrapezoids_args args;
+
+    args.ary = rb_ary_to_ary(value);
+    args.n = RARRAY_LEN(args.ary);
+    args.result = g_new(GdkTrapezoid, args.n + 1);
+
+    rb_rescue(rbgdk_rval2gdktrapezoids_body, (VALUE)&args,
+              rbgdk_rval2gdktrapezoids_rescue, (VALUE)&args);
+
+    if (n != NULL)
+        *n = args.n;
+
+    return args.result;
+}
+
+#define RVAL2GDKTRAPEZOIDS(value, n) rbgdk_rval2gdktrapezoids(value, n)
+
+static VALUE
+rg_draw_trapezoids(VALUE self, VALUE rbgc, VALUE rbtrapezoids)
+{
+    GdkDrawable *drawable = _SELF(self);
+    GdkGC *gc = GDK_GC(RVAL2GOBJ(rbgc));
+    long n;
+    GdkTrapezoid *trapezoids = RVAL2GDKTRAPEZOIDS(rbtrapezoids, &n);
+
+    gdk_draw_trapezoids(drawable, gc, trapezoids, n);
+
+    g_free(trapezoids);
+
+    return self;
 }
 #endif
 
 static VALUE
-gdkdraw_glyphs(VALUE self, VALUE gc, VALUE font, VALUE x, VALUE y, VALUE glyphs)
+rg_draw_glyphs(VALUE self, VALUE gc, VALUE font, VALUE x, VALUE y, VALUE glyphs)
 {
     gdk_draw_glyphs(_SELF(self), GDK_GC(RVAL2GOBJ(gc)), PANGO_FONT(RVAL2GOBJ(font)),
                     NUM2INT(x), NUM2INT(y), 
@@ -266,7 +347,7 @@ gdkdraw_glyphs(VALUE self, VALUE gc, VALUE font, VALUE x, VALUE y, VALUE glyphs)
 
 #if GTK_CHECK_VERSION(2,6,0)
 static VALUE
-gdkdraw_glyphs_transformed(VALUE self, VALUE gc, VALUE matrix, VALUE font, VALUE x, VALUE y, VALUE glyphs)
+rg_draw_glyphs_transformed(VALUE self, VALUE gc, VALUE matrix, VALUE font, VALUE x, VALUE y, VALUE glyphs)
 {
     gdk_draw_glyphs_transformed(_SELF(self), GDK_GC(RVAL2GOBJ(gc)), 
                                 NIL_P(matrix) ? (PangoMatrix*)NULL : (PangoMatrix*)(RVAL2BOXED(matrix, PANGO_TYPE_MATRIX)),
@@ -278,7 +359,7 @@ gdkdraw_glyphs_transformed(VALUE self, VALUE gc, VALUE matrix, VALUE font, VALUE
 #endif
 
 static VALUE
-gdkdraw_layout_line(int argc, VALUE *argv, VALUE self)
+rg_draw_layout_line(int argc, VALUE *argv, VALUE self)
 {
     VALUE gc, x, y, line, fg, bg;
 
@@ -294,7 +375,7 @@ gdkdraw_layout_line(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-gdkdraw_layout(int argc, VALUE *argv, VALUE self)
+rg_draw_layout(int argc, VALUE *argv, VALUE self)
 {
     VALUE gc, x, y, layout, fg, bg;
 
@@ -309,7 +390,7 @@ gdkdraw_layout(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-gdkdraw_draw_drawable(VALUE self, VALUE gc, VALUE src, VALUE xsrc, VALUE ysrc, VALUE xdst, VALUE ydst, VALUE w, VALUE h)
+rg_draw_drawable(VALUE self, VALUE gc, VALUE src, VALUE xsrc, VALUE ysrc, VALUE xdst, VALUE ydst, VALUE w, VALUE h)
 {
     gdk_draw_drawable(_SELF(self), GDK_GC(RVAL2GOBJ(gc)), _SELF(src),
                       NUM2INT(xsrc), NUM2INT(ysrc),
@@ -319,7 +400,7 @@ gdkdraw_draw_drawable(VALUE self, VALUE gc, VALUE src, VALUE xsrc, VALUE ysrc, V
 }
 
 static VALUE
-gdkdraw_draw_image(VALUE self, VALUE gc, VALUE image, VALUE xsrc, VALUE ysrc, VALUE xdst, VALUE ydst, VALUE w, VALUE h)
+rg_draw_image(VALUE self, VALUE gc, VALUE image, VALUE xsrc, VALUE ysrc, VALUE xdst, VALUE ydst, VALUE w, VALUE h)
 {
     gdk_draw_image(_SELF(self), GDK_GC(RVAL2GOBJ(gc)),
                    GDK_IMAGE(RVAL2GOBJ(image)),
@@ -330,7 +411,7 @@ gdkdraw_draw_image(VALUE self, VALUE gc, VALUE image, VALUE xsrc, VALUE ysrc, VA
 }
 
 static VALUE
-gdkdraw_get_image(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h)
+rg_get_image(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h)
 {
     return GOBJ2RVAL(gdk_drawable_get_image(_SELF(self), 
                                             NUM2INT(x), NUM2INT(y), 
@@ -339,7 +420,7 @@ gdkdraw_get_image(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h)
 
 #if GTK_CHECK_VERSION(2,4,0)
 static VALUE
-gdkdraw_copy_to_image(VALUE self, VALUE image, VALUE xsrc, VALUE ysrc, VALUE xdst, VALUE ydst, VALUE w, VALUE h)
+rg_copy_to_image(VALUE self, VALUE image, VALUE xsrc, VALUE ysrc, VALUE xdst, VALUE ydst, VALUE w, VALUE h)
 {
     return GOBJ2RVAL(gdk_drawable_copy_to_image(_SELF(self), 
                                                 GDK_IMAGE(RVAL2GOBJ(image)),
@@ -351,21 +432,31 @@ gdkdraw_copy_to_image(VALUE self, VALUE image, VALUE xsrc, VALUE ysrc, VALUE xds
 
 #ifdef GDK_WINDOWING_X11
 static VALUE
-gdkdraw_get_xid(VALUE self)
+rg_xid(VALUE self)
 {
     return ULONG2NUM(GDK_DRAWABLE_XID(_SELF(self)));
 }
 #endif
 
+#ifdef GDK_WINDOWING_WIN32
+static VALUE
+rg_handle(VALUE self)
+{
+    HGDIOBJ handle;
+    handle = gdk_win32_drawable_get_handle(_SELF(self));
+    return ULONG2NUM(GPOINTER_TO_UINT(handle));
+}
+#endif
+
 #if GTK_CHECK_VERSION(2,2,0)
 static VALUE
-gdkdraw_get_display(VALUE self)
+rg_display(VALUE self)
 {
     return GOBJ2RVAL(gdk_drawable_get_display(_SELF(self)));
 }
 
 static VALUE
-gdkdraw_get_screen(VALUE self)
+rg_screen(VALUE self)
 {
     return GOBJ2RVAL(gdk_drawable_get_screen(_SELF(self)));
 }
@@ -374,7 +465,7 @@ gdkdraw_get_screen(VALUE self)
 #if GTK_CHECK_VERSION(2,8,0)
 #  ifdef HAVE_RB_CAIRO_H
 static VALUE
-gdkdraw_cairo_create(VALUE self)
+rg_create_cairo_context(VALUE self)
 {
     VALUE rb_cr;
     cairo_t *cr;
@@ -388,59 +479,61 @@ gdkdraw_cairo_create(VALUE self)
 #endif
 
 void
-Init_gtk_gdk_draw()
-{
-    VALUE gdkDrawable = G_DEF_CLASS(GDK_TYPE_DRAWABLE, "Drawable", mGdk);
-
-    rb_define_method(gdkDrawable, "visual", gdkdraw_get_visual, 0);
-    rb_define_method(gdkDrawable, "set_colormap", gdkdraw_set_colormap, 1);
-    rb_define_method(gdkDrawable, "colormap", gdkdraw_get_colormap, 0);
-    rb_define_method(gdkDrawable, "depth", gdkdraw_get_depth, 0);
-    rb_define_method(gdkDrawable, "size", gdkdraw_get_size, 0);
-    rb_define_method(gdkDrawable, "clip_region", gdkdraw_get_clip_region, 0);
-    rb_define_method(gdkDrawable, "visible_region", gdkdraw_get_visible_region, 0);
-    rb_define_method(gdkDrawable, "draw_point", gdkdraw_draw_point, 3);
-    rb_define_method(gdkDrawable, "draw_points", gdkdraw_draw_points, 2);
-    rb_define_method(gdkDrawable, "draw_line", gdkdraw_draw_line, 5);
-    rb_define_method(gdkDrawable, "draw_lines", gdkdraw_draw_lines, 2);
+Init_gtk_gdk_draw(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_DRAWABLE, "Drawable", mGdk);
+
+    RG_DEF_METHOD(visual, 0);
+    RG_DEF_METHOD(set_colormap, 1);
+    RG_DEF_METHOD(colormap, 0);
+    RG_DEF_METHOD(depth, 0);
+    RG_DEF_METHOD(size, 0);
+    RG_DEF_METHOD(clip_region, 0);
+    RG_DEF_METHOD(visible_region, 0);
+    RG_DEF_METHOD(draw_point, 3);
+    RG_DEF_METHOD(draw_points, 2);
+    RG_DEF_METHOD(draw_line, 5);
+    RG_DEF_METHOD(draw_lines, 2);
 #if GTK_CHECK_VERSION(2,2,0)
-    rb_define_method(gdkDrawable, "draw_pixbuf", gdkdraw_draw_pixbuf, 11);
+    RG_DEF_METHOD(draw_pixbuf, 11);
 #endif
-    rb_define_method(gdkDrawable, "draw_segments", gdkdraw_draw_segs, 2);
-    rb_define_method(gdkDrawable, "draw_rectangle", gdkdraw_draw_rect, 6);
-    rb_define_method(gdkDrawable, "draw_arc", gdkdraw_draw_arc, 8);
-    rb_define_method(gdkDrawable, "draw_polygon", gdkdraw_draw_poly, 3);
+    RG_DEF_METHOD(draw_segments, 2);
+    RG_DEF_METHOD(draw_rectangle, 6);
+    RG_DEF_METHOD(draw_arc, 8);
+    RG_DEF_METHOD(draw_polygon, 3);
 #if GTK_CHECK_VERSION(2,6,0)
-    rb_define_method(gdkDrawable, "draw_trapezoids", gdkdraw_draw_trapezoids, 2);
+    RG_DEF_METHOD(draw_trapezoids, 2);
 #endif
-    rb_define_method(gdkDrawable, "draw_glyphs", gdkdraw_glyphs, 5);
+    RG_DEF_METHOD(draw_glyphs, 5);
 #if GTK_CHECK_VERSION(2,6,0)
-    rb_define_method(gdkDrawable, "draw_glyphs_transformed", gdkdraw_glyphs_transformed, 6);
+    RG_DEF_METHOD(draw_glyphs_transformed, 6);
 #endif
-    rb_define_method(gdkDrawable, "draw_layout_line", gdkdraw_layout_line, -1);
-    rb_define_method(gdkDrawable, "draw_layout", gdkdraw_layout, -1);
-    rb_define_method(gdkDrawable, "draw_drawable", gdkdraw_draw_drawable, 8);
-    rb_define_method(gdkDrawable, "draw_image", gdkdraw_draw_image, 8);
-    rb_define_method(gdkDrawable, "get_image", gdkdraw_get_image, 4);
+    RG_DEF_METHOD(draw_layout_line, -1);
+    RG_DEF_METHOD(draw_layout, -1);
+    RG_DEF_METHOD(draw_drawable, 8);
+    RG_DEF_METHOD(draw_image, 8);
+    RG_DEF_METHOD(get_image, 4);
 #if GTK_CHECK_VERSION(2,4,0)
-    rb_define_method(gdkDrawable, "copy_to_image", gdkdraw_copy_to_image, 7);
+    RG_DEF_METHOD(copy_to_image, 7);
 #endif
 
 #ifdef GDK_WINDOWING_X11
-    rb_define_method(gdkDrawable, "xid", gdkdraw_get_xid, 0);
+    RG_DEF_METHOD(xid, 0);
+#endif
+#ifdef GDK_WINDOWING_WIN32
+    RG_DEF_METHOD(handle, 0);
 #endif
 #if GTK_CHECK_VERSION(2,2,0)
-    rb_define_method(gdkDrawable, "display", gdkdraw_get_display, 0);
-    rb_define_method(gdkDrawable, "screen", gdkdraw_get_screen, 0);
+    RG_DEF_METHOD(display, 0);
+    RG_DEF_METHOD(screen, 0);
 #endif
-    
+
 #if GTK_CHECK_VERSION(2,8,0)
 #  ifdef HAVE_RB_CAIRO_H
-    rb_define_method(gdkDrawable, "create_cairo_context",
-                     gdkdraw_cairo_create, 0);
+    RG_DEF_METHOD(create_cairo_context, 0);
 #  endif
 #endif
-    
+
 #ifdef GDK_WINDOWING_X11
     G_DEF_CLASS3("GdkDrawableImplX11", "DrawableImplX11", mGdk);
 #elif defined(GDK_WINDOWING_WIN32)
@@ -448,7 +541,6 @@ Init_gtk_gdk_draw()
 #elif defined(GDK_WINDOWING_FB)
     G_DEF_CLASS3("GdkDrawableFB", "DrawableFB", mGdk);
 #endif
-    
-    G_DEF_SETTERS(gdkDrawable);
-}
 
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
+}