gdk3 1.2.0

data/ext/gdk3/rbgdkdisplaymanager.c

@@ -0,0 +1,55 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  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 "rbgdk3private.h"
+
+#define RG_TARGET_NAMESPACE cDisplayManager
+#define _SELF(obj) RVAL2GDKDISPLAYMANAGER(obj)
+
+static VALUE
+rg_s_get(G_GNUC_UNUSED VALUE self)
+{
+    return GOBJ2RVAL(gdk_display_manager_get());
+}
+
+static VALUE
+rg_displays(VALUE self)
+{
+    return GOBJGSLIST2RVAL_FREE(gdk_display_manager_list_displays(_SELF(self)),
+                                g_slist_free, NULL);
+}
+
+/* Move to Gdk::Display.
+static VALUE
+gdkdisplaymanager_get_core_pointer(VALUE self)
+{
+    return GOBJ2RVAL(gdk_display_get_core_pointer(_SELF(self)));
+}
+*/
+
+void 
+Init_gdk_display_manager(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_DISPLAY_MANAGER, "DisplayManager", mGdk);
+
+    RG_DEF_SMETHOD(get, 0);
+    RG_DEF_METHOD(displays, 0);
+}

data/ext/gdk3/rbgdkdragcontext.c

@@ -0,0 +1,191 @@
+/* -*- 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
+ */
+
+#include "rbgdk3private.h"
+
+#define RG_TARGET_NAMESPACE cDragContext
+#define _SELF(self) (RVAL2GDKDRAGCONTEXT(self))
+
+static VALUE
+rg_protocol(VALUE self)
+{
+    return GDKDRAGPROTOCOL2RVAL(gdk_drag_context_get_protocol(_SELF(self)));
+}
+
+static VALUE
+rg_source_window(VALUE self)
+{
+    return GOBJ2RVAL(gdk_drag_context_get_source_window(_SELF(self)));
+}
+
+static VALUE
+rg_dest_window(VALUE self)
+{
+    return GOBJ2RVAL(gdk_drag_context_get_dest_window(_SELF(self)));
+}
+
+static VALUE
+rg_targets(VALUE self)
+{
+    GList *list, *cur;
+    VALUE ary = rb_ary_new();
+
+    list = gdk_drag_context_list_targets(_SELF(self));
+    for (cur = list; cur != NULL; cur = cur->next) {
+        rb_ary_push(ary, GDKATOM2RVAL((GdkAtom)cur->data));
+    }
+    return ary;
+}
+
+static VALUE
+rg_actions(VALUE self)
+{
+    return GDKDRAGACTION2RVAL(gdk_drag_context_get_actions(_SELF(self)));
+}
+
+static VALUE
+rg_suggested_action(VALUE self)
+{
+    return GDKDRAGACTION2RVAL(gdk_drag_context_get_suggested_action(_SELF(self)));
+}
+
+static VALUE
+rg_selected_action(VALUE self)
+{
+    return GDKDRAGACTION2RVAL(gdk_drag_context_get_selected_action(_SELF(self)));
+}
+
+static VALUE
+rg_selection(VALUE self)
+{
+    return GDKATOM2RVAL(gdk_drag_get_selection(_SELF(self)));
+}
+
+static VALUE
+rg_drag_abort(VALUE self, VALUE time)
+{
+    gdk_drag_abort(_SELF(self), NUM2UINT(time));
+    return self;
+}
+
+static VALUE
+rg_drop_reply(VALUE self, VALUE ok, VALUE time)
+{
+    gdk_drop_reply(_SELF(self), RVAL2CBOOL(ok), NUM2UINT(time));
+    return self;
+}
+
+static VALUE
+rg_drag_drop(VALUE self, VALUE time)
+{
+    gdk_drag_drop(_SELF(self), NUM2UINT(time));
+    return self;
+}
+
+static VALUE
+rg_find_window(int argc, VALUE *argv, VALUE self)
+{
+    VALUE drag_window, x_root, y_root;
+    GdkWindow *dest_window;
+    GdkDragProtocol prot;
+
+    if (argc == 3) {
+/* deprecated
+        rb_scan_args(argc, argv, "30", &drag_window, &x_root, &y_root);
+        gdk_drag_find_window(_SELF(self),
+                             RVAL2GDKWINDOW(drag_window), 
+                             NUM2INT(x_root), NUM2INT(y_root),
+                             &dest_window, &prot);
+*/
+    } else {
+        VALUE screen;
+        rb_scan_args(argc, argv, "40", &drag_window, &screen, &x_root, &y_root);
+        gdk_drag_find_window_for_screen(_SELF(self),
+                                        RVAL2GDKWINDOW(drag_window), 
+                                        RVAL2GDKSCREEN(screen),
+                                        NUM2INT(x_root), NUM2INT(y_root),
+                                        &dest_window, &prot);
+    }
+
+    return rb_ary_new3(2, GOBJ2RVAL(dest_window), 
+                       GDKDRAGPROTOCOL2RVAL(prot));
+}
+
+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), 
+                                   RVAL2GDKWINDOW(dest_window), 
+                                   RVAL2GDKDRAGPROTOCOL(protocol), 
+                                   NUM2INT(x_root), NUM2INT(y_root), 
+                                   RVAL2GDKDRAGACTION(suggested_action), 
+                                   RVAL2GDKDRAGACTION(possible_actions), 
+                                   NUM2UINT(time));
+    return CBOOL2RVAL(ret);
+}
+
+static VALUE
+rg_drop_finish(VALUE self, VALUE success, VALUE time)
+{
+    gdk_drop_finish(_SELF(self), RVAL2CBOOL(success), NUM2UINT(time));
+    return self;
+}
+
+static VALUE
+rg_drag_status(VALUE self, VALUE action, VALUE time)
+{
+    gdk_drag_status(_SELF(self), 
+                    RVAL2GDKDRAGACTION(action), NUM2UINT(time));
+    return self;
+}
+
+static VALUE
+rg_drag_drop_succeeded_p(VALUE self)
+{
+    return CBOOL2RVAL(gdk_drag_drop_succeeded(_SELF(self)));
+}
+
+void
+Init_gdk_dragcontext(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_DRAG_CONTEXT, "DragContext", mGdk);
+
+    RG_DEF_METHOD(protocol, 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(selected_action, 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);
+    RG_DEF_METHOD_P(drag_drop_succeeded, 0);
+
+    G_DEF_CLASS(GDK_TYPE_DRAG_PROTOCOL, "Protocol", RG_TARGET_NAMESPACE);
+    G_DEF_CLASS(GDK_TYPE_DRAG_ACTION, "Action", RG_TARGET_NAMESPACE);
+}

data/ext/gdk3/rbgdkdraw.c

@@ -0,0 +1,520 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  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
+ */
+
+/* deprecated
+#include "rbgdk3private.h"
+#include "rbpango.h"
+#ifdef GDK_WINDOWING_X11
+#include <gdk/gdkx.h>
+#endif
+#ifdef HAVE_RB_CAIRO_H
+#include <rb_cairo.h>
+#endif
+
+#define RG_TARGET_NAMESPACE cDrawable
+#define _SELF(s) RVAL2GDKDRAWABLE(s)
+
+static VALUE
+rg_visual(VALUE self)
+{
+    return GOBJ2RVAL(_SELF(self));
+}
+
+static VALUE
+rg_set_colormap(VALUE self, VALUE colormap)
+{
+    VALUE old_colormap;
+
+    old_colormap = GOBJ2RVAL(gdk_drawable_get_colormap(_SELF(self)));
+    G_CHILD_REMOVE(self, old_colormap);
+
+    G_CHILD_ADD(self, colormap);
+    gdk_drawable_set_colormap(_SELF(self), RVAL2GDKCOLORMAP(colormap));
+    return self;
+}
+
+static VALUE
+rg_colormap(VALUE self)
+{
+    VALUE rb_colormap;
+
+    rb_colormap = GOBJ2RVAL(gdk_drawable_get_colormap(_SELF(self)));
+    G_CHILD_ADD(self, rb_colormap);
+    return rb_colormap;
+}
+
+static VALUE
+rg_depth(VALUE self)
+{
+    return INT2NUM(gdk_drawable_get_depth(_SELF(self)));
+}
+
+static VALUE
+rg_size(VALUE self)
+{
+    gint width, height;
+    gdk_drawable_get_size(_SELF(self), &width, &height);
+    return rb_ary_new3(2, INT2NUM(width), INT2NUM(height));
+}
+
+static VALUE
+rg_clip_region(VALUE self)
+{
+    return GDKREGION2RVAL(gdk_drawable_get_clip_region(_SELF(self)));
+}
+
+static VALUE
+rg_visible_region(VALUE self)
+{
+    return GDKREGION2RVAL(gdk_drawable_get_visible_region(_SELF(self)));
+}
+
+static VALUE
+rg_draw_point(VALUE self, VALUE gc, VALUE x, VALUE y)
+{
+    gdk_draw_point(_SELF(self), RVAL2GDKGC(gc),
+                   NUM2INT(x), NUM2INT(y));
+    return self;
+}
+
+static VALUE
+rg_draw_points(VALUE self, VALUE rbgc, VALUE rbpoints)
+{
+    GdkDrawable *drawable = _SELF(self);
+    GdkGC *gc = RVAL2GDKGC(rbgc);
+    long n;
+    GdkPoint *points = RVAL2GDKPOINTS(rbpoints, &n);
+
+    gdk_draw_points(drawable, gc, points, n);
+
+    g_free(points);
+
+    return self;
+}
+
+static VALUE
+rg_draw_line(VALUE self, VALUE gc, VALUE x1, VALUE y1, VALUE x2, VALUE y2)
+{
+    gdk_draw_line(_SELF(self), RVAL2GDKGC(gc),
+                  NUM2INT(x1), NUM2INT(y1),
+                  NUM2INT(x2), NUM2INT(y2));
+    return self;
+}
+
+static VALUE
+rg_draw_lines(VALUE self, VALUE rbgc, VALUE rbpoints)
+{
+    GdkDrawable *drawable = _SELF(self);
+    GdkGC *gc = RVAL2GDKGC(rbgc);
+    long n;
+    GdkPoint *points = RVAL2GDKPOINTS(rbpoints, &n);
+
+    gdk_draw_lines(drawable, gc, points, n);
+
+    g_free(points);
+
+    return self;
+}
+
+static VALUE
+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),
+                    RVAL2GDKGC(gc),
+                    RVAL2GDKPIXBUF(pixbuf),
+                    NUM2INT(src_x), NUM2INT(src_y), 
+                    NUM2INT(dest_x), NUM2INT(dest_y),
+                    NUM2INT(width), NUM2INT(height),
+                    RVAL2GDKRGBDITHER(dither),
+                    NUM2INT(x_dither), NUM2INT(y_dither));
+    return self;
+}
+
+struct rbgdk_rval2gdksegments_args {
+    VALUE ary;
+    long n;
+    GdkSegment *result;
+};
+
+static VALUE
+rbgdk_rval2gdksegments_body(VALUE value)
+{
+    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]);
+
+        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]);
+    }
+
+    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 = RVAL2GDKGC(rbgc);
+    long n;
+    GdkSegment *segments = RVAL2GDKSEGMENTS(rbsegments, &n);
+
+    gdk_draw_segments(drawable, gc, segments, n);
+
+    g_free(segments);
+
+    return self;
+}
+
+static VALUE
+rg_draw_rectangle(VALUE self, VALUE gc, VALUE filled, VALUE x, VALUE y, VALUE w, VALUE h)
+{
+    gdk_draw_rectangle(_SELF(self), RVAL2GDKGC(gc),
+                       RVAL2CBOOL(filled),
+                       NUM2INT(x), NUM2INT(y),
+                       NUM2INT(w), NUM2INT(h));
+    return self;
+}
+
+static VALUE
+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), RVAL2GDKGC(gc),
+                 RVAL2CBOOL(filled),
+                 NUM2INT(x), NUM2INT(y),
+                 NUM2INT(w), NUM2INT(h),
+                 NUM2INT(a1), NUM2INT(a2));
+    return self;
+}
+
+static VALUE
+rg_draw_polygon(VALUE self, VALUE rbgc, VALUE rbfilled, VALUE rbpoints)
+{
+    GdkDrawable *drawable = _SELF(self);
+    GdkGC *gc = RVAL2GDKGC(rbgc);
+    gboolean filled = RVAL2CBOOL(rbfilled);
+    long n;
+    GdkPoint *points = RVAL2GDKPOINTS(rbpoints, &n);
+
+    gdk_draw_polygon(drawable, gc, filled, points, n);
+
+    g_free(points);
+
+    return self;
+}
+
+struct rbgdk_rval2gdktrapezoids_args {
+    VALUE ary;
+    long n;
+    GdkTrapezoid *result;
+};
+
+static VALUE
+rbgdk_rval2gdktrapezoids_body(VALUE value)
+{
+    long i;
+    struct rbgdk_rval2gdktrapezoids_args *args = (struct rbgdk_rval2gdktrapezoids_args *)value;
+
+    for (i = 0; i < args->n; i++) {
+        VALUE trapezoids = rb_ary_to_ary(RARRAY_PTR(args->ary)[i]);
+
+        if (RARRAY_LEN(trapezoids) != 6)
+            rb_raise(rb_eArgError, "trapezoid %ld should be array of size 6", i);
+
+        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]);
+    }
+
+    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 = RVAL2GDKGC(rbgc);
+    long n;
+    GdkTrapezoid *trapezoids = RVAL2GDKTRAPEZOIDS(rbtrapezoids, &n);
+
+    gdk_draw_trapezoids(drawable, gc, trapezoids, n);
+
+    g_free(trapezoids);
+
+    return self;
+}
+
+static VALUE
+rg_draw_glyphs(VALUE self, VALUE gc, VALUE font, VALUE x, VALUE y, VALUE glyphs)
+{
+    gdk_draw_glyphs(_SELF(self), RVAL2GDKGC(gc), RVAL2PANGOFONT(font),
+                    NUM2INT(x), NUM2INT(y), 
+                    RVAL2PANGOGLYPHSTRING(glyphs));
+    return self;
+}
+
+static VALUE
+rg_draw_glyphs_transformed(VALUE self, VALUE gc, VALUE matrix, VALUE font, VALUE x, VALUE y, VALUE glyphs)
+{
+    gdk_draw_glyphs_transformed(_SELF(self), RVAL2GDKGC(gc), 
+                                NIL_P(matrix) ? (PangoMatrix*)NULL : RVAL2PANGOMATRIX(matrix),
+                                RVAL2PANGOFONT(font),
+                                NUM2INT(x), NUM2INT(y), 
+                                RVAL2PANGOGLYPHSTRING(glyphs));
+    return self;
+}
+
+static VALUE
+rg_draw_layout_line(int argc, VALUE *argv, VALUE self)
+{
+    VALUE gc, x, y, line, fg, bg;
+
+    rb_scan_args(argc, argv, "42", &gc, &x, &y, &line, &fg, &bg);
+
+    gdk_draw_layout_line_with_colors(_SELF(self), RVAL2GDKGC(gc),
+                                     NUM2INT(x), NUM2INT(y),
+                                     RVAL2PANGOLAYOUTLINE(line),
+                                     RVAL2GDKCOLOR(fg),
+                                     RVAL2GDKCOLOR(bg));
+
+    return self;
+}
+
+static VALUE
+rg_draw_layout(int argc, VALUE *argv, VALUE self)
+{
+    VALUE gc, x, y, layout, fg, bg;
+
+    rb_scan_args(argc, argv, "42", &gc, &x, &y, &layout, &fg, &bg);
+
+    gdk_draw_layout_with_colors(_SELF(self), RVAL2GDKGC(gc),
+                                NUM2INT(x), NUM2INT(y), RVAL2PANGOLAYOUT(layout),
+                                RVAL2GDKCOLOR(fg),
+                                RVAL2GDKCOLOR(bg));
+
+    return self;
+}
+
+static VALUE
+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), RVAL2GDKGC(gc), _SELF(src),
+                      NUM2INT(xsrc), NUM2INT(ysrc),
+                      NUM2INT(xdst), NUM2INT(ydst),
+                      NUM2INT(w), NUM2INT(h));
+    return self;
+}
+
+static VALUE
+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), RVAL2GDKGC(gc),
+                   RVAL2GDKIMAGE(image),
+                   NUM2INT(xsrc), NUM2INT(ysrc),
+                   NUM2INT(xdst), NUM2INT(ydst),
+                   NUM2INT(w), NUM2INT(h));
+    return self;
+}
+
+static VALUE
+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), 
+                                            NUM2INT(w), NUM2INT(h)));
+}
+
+static VALUE
+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), 
+                                                RVAL2GDKIMAGE(image),
+                                                NUM2INT(xsrc), NUM2INT(ysrc),
+                                                NUM2INT(xdst), NUM2INT(ydst),
+                                                NUM2INT(w), NUM2INT(h)));
+}
+
+#ifdef GDK_WINDOWING_X11
+static VALUE
+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
+
+static VALUE
+rg_display(VALUE self)
+{
+    return GOBJ2RVAL(gdk_drawable_get_display(_SELF(self)));
+}
+
+static VALUE
+rg_screen(VALUE self)
+{
+    return GOBJ2RVAL(gdk_drawable_get_screen(_SELF(self)));
+}
+
+#ifdef HAVE_RB_CAIRO_H
+static VALUE
+rg_create_cairo_context(VALUE self)
+{
+    VALUE rb_cr;
+    cairo_t *cr;
+    cr = gdk_cairo_create(_SELF(self));
+    rb_cairo_check_status(cairo_status(cr));
+    rb_cr = CRCONTEXT2RVAL(cr);
+    cairo_destroy (cr);
+    return rb_cr;
+}
+#endif
+
+void
+Init_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);
+    RG_DEF_METHOD(draw_pixbuf, 11);
+    RG_DEF_METHOD(draw_segments, 2);
+    RG_DEF_METHOD(draw_rectangle, 6);
+    RG_DEF_METHOD(draw_arc, 8);
+    RG_DEF_METHOD(draw_polygon, 3);
+    RG_DEF_METHOD(draw_trapezoids, 2);
+    RG_DEF_METHOD(draw_glyphs, 5);
+    RG_DEF_METHOD(draw_glyphs_transformed, 6);
+    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);
+    RG_DEF_METHOD(copy_to_image, 7);
+
+#ifdef GDK_WINDOWING_X11
+    RG_DEF_METHOD(xid, 0);
+#endif
+#ifdef GDK_WINDOWING_WIN32
+    RG_DEF_METHOD(handle, 0);
+#endif
+    RG_DEF_METHOD(display, 0);
+    RG_DEF_METHOD(screen, 0);
+
+#ifdef HAVE_RB_CAIRO_H
+    RG_DEF_METHOD(create_cairo_context, 0);
+#endif
+
+#ifdef GDK_WINDOWING_X11
+    G_DEF_CLASS3("GdkDrawableImplX11", "DrawableImplX11", mGdk);
+#elif defined(GDK_WINDOWING_WIN32)
+    G_DEF_CLASS3("GdkDrawableImplWin32", "DrawableImplWin32", mGdk);
+#elif defined(GDK_WINDOWING_FB)
+    G_DEF_CLASS3("GdkDrawableFB", "DrawableFB", mGdk);
+#endif
+}
+*/
+