gtk2 0.20.0

data/src/rbgdkdisplaymanager.c

@@ -0,0 +1,50 @@
+/* -*- 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
+************************************************/
+
+#include "global.h"
+
+#if GTK_CHECK_VERSION(2,2,0)
+#define _SELF(obj) GDK_DISPLAY_MANAGER(RVAL2GOBJ(obj))
+
+static VALUE
+gdkdisplaymanager_get(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gdk_display_manager_get());
+}
+
+static VALUE
+gdkdisplaymanager_list_displays(self)
+    VALUE self;
+{
+    return GSLIST2ARYF(gdk_display_manager_list_displays(_SELF(self)));
+}
+
+/* Move to Gdk::Display.
+static VALUE
+gdkdisplaymanager_get_core_pointer(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gdk_display_get_core_pointer(_SELF(self)));
+}
+*/
+#endif
+
+void 
+Init_gtk_gdk_display_manager()
+{
+#if GTK_CHECK_VERSION(2,2,0)
+    VALUE gdkDisplayManager = 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);
+#endif
+}

data/src/rbgdkdragcontext.c

@@ -0,0 +1,280 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdkdnd.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:31 $
+
+  Copyright (C) 2002,2003 Masao Mutoh
+************************************************/
+#include "global.h"
+
+#define _SELF(self) (GDK_DRAG_CONTEXT(RVAL2GOBJ(self)))
+
+static VALUE
+gdkdragcontext_protocol(self)
+    VALUE self;
+{
+    return GENUM2RVAL(_SELF(self)->protocol, GDK_TYPE_DRAG_PROTOCOL);
+}
+
+static VALUE
+gdkdragcontext_is_source(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(_SELF(self)->is_source);
+}
+
+static VALUE
+gdkdragcontext_source_window(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(_SELF(self)->source_window);
+}
+
+static VALUE
+gdkdragcontext_dest_window(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(_SELF(self)->dest_window);
+}
+
+static VALUE
+gdkdragcontext_targets(self)
+    VALUE self;
+{
+    GList *list = _SELF(self)->targets, *cur;
+    VALUE ary = rb_ary_new();
+
+    for (cur = list; cur != NULL; cur = cur->next) {
+        rb_ary_push(ary, BOXED2RVAL((GdkAtom)cur->data, GDK_TYPE_ATOM));
+    }
+    return ary;
+}
+
+static VALUE
+gdkdragcontext_actions(self)
+    VALUE self;
+{
+    return GFLAGS2RVAL(_SELF(self)->actions, GDK_TYPE_DRAG_ACTION);
+}
+
+static VALUE
+gdkdragcontext_suggested_action(self)
+    VALUE self;
+{
+    return GFLAGS2RVAL(_SELF(self)->suggested_action, GDK_TYPE_DRAG_ACTION);
+}
+
+static VALUE
+gdkdragcontext_action(self)
+    VALUE self;
+{
+    return GFLAGS2RVAL(_SELF(self)->action, GDK_TYPE_DRAG_ACTION);
+}
+
+static VALUE
+gdkdragcontext_start_time(self)
+    VALUE self;
+{
+    return UINT2NUM(_SELF(self)->start_time);
+}
+
+static VALUE
+gdkdragcontext_initialize(self)
+    VALUE self;
+{   
+    G_INITIALIZE(self, gdk_drag_context_new());
+    return Qnil;
+}
+
+static VALUE
+gdkdragcontext_s_get_protocol(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE xid;
+    GdkDragProtocol prot;
+    guint32 ret;
+
+    if (argc == 1) {
+        rb_scan_args(argc, argv, "10", &xid);
+        ret = gdk_drag_get_protocol(NUM2UINT(xid), &prot);
+    } else {
+#if GTK_CHECK_VERSION(2,2,0)
+        VALUE display;
+        rb_scan_args(argc, argv, "20", &display, &xid);
+        ret = gdk_drag_get_protocol_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
+                                                NUM2UINT(xid), &prot);
+#else
+        rb_warn("Not supported arguments for Gdk::Display in GTK+-2.0.x.");
+        ret = gdk_drag_get_protocol(NUM2UINT(xid), &prot);
+#endif
+    }
+
+    return rb_ary_new3(2, GENUM2RVAL(prot, GDK_TYPE_DRAG_PROTOCOL), UINT2NUM(ret));
+}
+
+/* Instance Methods */
+static VALUE
+gdkdragcontext_get_selection(self)
+    VALUE self;
+{
+    return BOXED2RVAL(gdk_drag_get_selection(_SELF(self)), GDK_TYPE_ATOM);
+}
+
+static VALUE
+gdkdragcontext_drag_abort(self, time)
+    VALUE self, time;
+{
+    gdk_drag_abort(_SELF(self), NUM2UINT(time));
+    return self;
+}
+
+static VALUE
+gdkdragcontext_drop_reply(self, ok, time)
+    VALUE self, ok, time;
+{
+    gdk_drop_reply(_SELF(self), RVAL2CBOOL(ok), NUM2UINT(time));
+    return self;
+}
+
+static VALUE
+gdkdragcontext_drag_drop(self, time)
+    VALUE self, time;
+{
+    gdk_drag_drop(_SELF(self), NUM2UINT(time));
+    return self;
+}
+
+static VALUE
+gdkdragcontext_find_window(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE drag_window, x_root, y_root;
+    GdkWindow *dest_window;
+    GdkDragProtocol prot;
+
+    if (argc == 3) {
+        rb_scan_args(argc, argv, "30", &drag_window, &x_root, &y_root);
+        gdk_drag_find_window(_SELF(self),
+                             GDK_WINDOW(RVAL2GOBJ(drag_window)), 
+                             NUM2INT(x_root), NUM2INT(y_root),
+                             &dest_window, &prot);
+    } else {
+#if GTK_CHECK_VERSION(2,2,0)
+        VALUE screen;
+        rb_scan_args(argc, argv, "40", &drag_window, &screen, &x_root, &y_root);
+        gdk_drag_find_window_for_screen(_SELF(self),
+                                        GDK_WINDOW(RVAL2GOBJ(drag_window)), 
+                                        GDK_SCREEN(RVAL2GOBJ(screen)),
+                                        NUM2INT(x_root), NUM2INT(y_root),
+                                        &dest_window, &prot);
+#else
+        rb_raise(rb_eArgError, "Wrong number of arguments: %d", argc);
+#endif
+    }
+
+    return rb_ary_new3(2, GOBJ2RVAL(dest_window), 
+                       GENUM2RVAL(prot, GDK_TYPE_DRAG_PROTOCOL));
+}
+
+static VALUE
+gdkdragcontext_s_drag_begin(self, window, targets)
+    VALUE self, window, targets;
+{
+    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])));
+    }
+
+    ret = GOBJ2RVAL(gdk_drag_begin(GDK_WINDOW(RVAL2GOBJ(window)), list));
+    g_list_free(list);
+
+    return ret;
+}
+
+static VALUE
+gdkdragcontext_drag_motion(self, dest_window, protocol, x_root, y_root, 
+                           suggested_action, possible_actions, time)
+    VALUE self, dest_window, protocol, x_root, y_root, 
+  		  suggested_action, possible_actions, time;
+{
+    gboolean ret = gdk_drag_motion(_SELF(self), 
+                                   GDK_WINDOW(RVAL2GOBJ(dest_window)), 
+                                   RVAL2GENUM(protocol, GDK_TYPE_DRAG_PROTOCOL), 
+                                   NUM2INT(x_root), NUM2INT(y_root), 
+                                   RVAL2GFLAGS(suggested_action, GDK_TYPE_DRAG_ACTION), 
+                                   RVAL2GFLAGS(possible_actions, GDK_TYPE_DRAG_ACTION), 
+                                   NUM2UINT(time));
+    return CBOOL2RVAL(ret);
+}
+
+static VALUE
+gdkdragcontext_drop_finish(self, success, time)
+    VALUE self, success, time;
+{
+    gdk_drop_finish(_SELF(self), RVAL2CBOOL(success), NUM2UINT(time));
+    return self;
+}
+
+static VALUE
+gdkdragcontext_drag_status(self, action, time)
+    VALUE self, action, time;
+{
+    gdk_drag_status(_SELF(self), 
+                    RVAL2GFLAGS(action, GDK_TYPE_DRAG_ACTION), NUM2UINT(time));
+    return self;
+}
+
+#if GTK_CHECK_VERSION(2,6,0)
+static VALUE
+gdkdragcontext_drag_drop_succeeded(self)
+    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);
+#if GTK_CHECK_VERSION(2,6,0)
+    rb_define_method(gdkDragContext, "drag_drop_succeeded?", gdkdragcontext_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_");
+}

data/src/rbgdkdraw.c

@@ -0,0 +1,487 @@
+/* -*- 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
+************************************************/
+
+#include "global.h"
+#include "rbpango.h"
+#ifdef GDK_WINDOWING_X11
+#include <gdk/gdkx.h>
+#endif
+#ifdef HAVE_RB_CAIRO_H
+#include <rb_cairo.h>
+#endif
+
+#define _SELF(s) GDK_DRAWABLE(RVAL2GOBJ(s))
+
+static VALUE
+gdkdraw_get_visual(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(_SELF(self));
+}
+
+static VALUE
+gdkdraw_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), GDK_COLORMAP(RVAL2GOBJ(colormap)));
+    return self;
+}
+
+static VALUE
+gdkdraw_get_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
+gdkdraw_get_depth(self)
+    VALUE self;
+{
+    return INT2NUM(gdk_drawable_get_depth(_SELF(self)));
+}
+
+static VALUE
+gdkdraw_get_size(self)
+    VALUE self;
+{
+    gint width, height;
+    gdk_drawable_get_size(_SELF(self), &width, &height);
+    return rb_ary_new3(2, INT2NUM(width), INT2NUM(height));
+}
+
+static VALUE
+gdkdraw_get_clip_region(self)
+    VALUE self;
+{
+    return BOXED2RVAL(gdk_drawable_get_clip_region(_SELF(self)), GDK_TYPE_REGION);
+}
+
+static VALUE
+gdkdraw_get_visible_region(self)
+    VALUE self;
+{
+    return BOXED2RVAL(gdk_drawable_get_visible_region(_SELF(self)), GDK_TYPE_REGION);
+}
+
+
+static VALUE
+gdkdraw_draw_point(self, gc, x, y)
+    VALUE self, gc, x, y;
+{
+    gdk_draw_point(_SELF(self), GDK_GC(RVAL2GOBJ(gc)),
+                   NUM2INT(x), NUM2INT(y));
+    return self;
+}
+
+static VALUE
+gdkdraw_draw_points(self, gc, pnts)
+    VALUE self, gc, pnts;
+{
+    GdkPoint *points;
+    int i;
+
+    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(self, gc, x1, y1, x2, y2)
+    VALUE self, gc, x1, y1, x2, y2;
+{
+    gdk_draw_line(_SELF(self), GDK_GC(RVAL2GOBJ(gc)),
+                  NUM2INT(x1), NUM2INT(y1),
+                  NUM2INT(x2), NUM2INT(y2));
+    return self;
+}
+
+static VALUE
+gdkdraw_draw_lines(self, gc, pnts)
+    VALUE self, gc, pnts;
+{
+    GdkPoint *points;
+    int i;
+
+    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(self, gc, pixbuf, src_x, src_y, dest_x, dest_y, 
+                    width, height, dither, x_dither, y_dither)
+    VALUE self, gc, pixbuf, src_x, src_y, dest_x, dest_y; 
+    VALUE width, height, dither, x_dither, y_dither;
+{
+    gdk_draw_pixbuf(_SELF(self),
+                    GDK_GC(RVAL2GOBJ(gc)),
+                    GDK_PIXBUF(RVAL2GOBJ(pixbuf)),
+                    NUM2INT(src_x), NUM2INT(src_y), 
+                    NUM2INT(dest_x), NUM2INT(dest_y),
+                    NUM2INT(width), NUM2INT(height),
+                    RVAL2GENUM(dither, GDK_TYPE_RGB_DITHER),
+                    NUM2INT(x_dither), NUM2INT(y_dither));
+    return self;
+}
+#endif
+
+static VALUE
+gdkdraw_draw_segs(self, gc, segs)
+    VALUE self, gc, segs;
+{
+    GdkSegment *segments;
+    int 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]);
+    }
+    gdk_draw_segments(_SELF(self), GDK_GC(RVAL2GOBJ(gc)),
+                      segments, RARRAY_LEN(segs));
+    return self;
+}
+
+static VALUE
+gdkdraw_draw_rect(self, gc, filled, x, y, w, h)
+    VALUE self, gc, filled, x, y, w, h;
+{
+    gdk_draw_rectangle(_SELF(self), GDK_GC(RVAL2GOBJ(gc)),
+                       RVAL2CBOOL(filled),
+                       NUM2INT(x), NUM2INT(y),
+                       NUM2INT(w), NUM2INT(h));
+    return self;
+}
+
+static VALUE
+gdkdraw_draw_arc(self, gc, filled, x, y, w, h, a1, a2)
+    VALUE self, gc, filled, x, y, w, h, a1, a2;
+{
+    gdk_draw_arc(_SELF(self), GDK_GC(RVAL2GOBJ(gc)),
+                 RVAL2CBOOL(filled),
+                 NUM2INT(x), NUM2INT(y),
+                 NUM2INT(w), NUM2INT(h),
+                 NUM2INT(a1), NUM2INT(a2));
+    return self;
+}
+
+static VALUE
+gdkdraw_draw_poly(self, gc, filled, pnts)
+    VALUE self, gc, filled, pnts;
+{
+    GdkPoint *points;
+    int i;
+
+    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;
+}
+
+#if GTK_CHECK_VERSION(2,6,0)
+/*
+  trapezoids = [[y1, x11, x21, y2, x12, x22], ...]
+ */
+static VALUE
+gdkdraw_draw_trapezoids(self, gc, trapezoids)
+    VALUE self, gc, trapezoids;
+{
+    GdkTrapezoid *gtrapezoids;
+    gint i, len;
+
+    Check_Type(trapezoids, T_ARRAY);
+
+    len = RARRAY_LEN(trapezoids);
+
+    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]);
+    }
+    gdk_draw_trapezoids(_SELF(self), GDK_GC(RVAL2GOBJ(gc)), gtrapezoids, len);
+    return self; 
+}
+#endif
+
+static VALUE
+gdkdraw_glyphs(self, gc, font, x, y, glyphs)
+    VALUE self, gc, font, x, y, glyphs;
+{
+    gdk_draw_glyphs(_SELF(self), GDK_GC(RVAL2GOBJ(gc)), PANGO_FONT(RVAL2GOBJ(font)),
+                    NUM2INT(x), NUM2INT(y), 
+                    (PangoGlyphString*)(RVAL2BOXED(glyphs, PANGO_TYPE_GLYPH_STRING)));
+    return self;
+}
+
+#if GTK_CHECK_VERSION(2,6,0)
+static VALUE
+gdkdraw_glyphs_transformed(self, gc, matrix, font, x, y, glyphs)
+    VALUE self, gc, matrix, font, x, y, glyphs;
+{
+    gdk_draw_glyphs_transformed(_SELF(self), GDK_GC(RVAL2GOBJ(gc)), 
+                                NIL_P(matrix) ? (PangoMatrix*)NULL : (PangoMatrix*)(RVAL2BOXED(matrix, PANGO_TYPE_MATRIX)),
+                                PANGO_FONT(RVAL2GOBJ(font)),
+                                NUM2INT(x), NUM2INT(y), 
+                                (PangoGlyphString*)(RVAL2BOXED(glyphs, PANGO_TYPE_GLYPH_STRING)));
+    return self;
+}
+#endif
+
+static VALUE
+gdkdraw_layout_line(argc, argv, self)
+    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), GDK_GC(RVAL2GOBJ(gc)),
+                                     NUM2INT(x), NUM2INT(y),
+                                     (PangoLayoutLine*)RVAL2BOXED(line, PANGO_TYPE_LAYOUT_LINE),
+                                     RVAL2GDKCOLOR(fg),
+                                     RVAL2GDKCOLOR(bg));
+
+    return self;
+}
+
+static VALUE
+gdkdraw_layout(argc, argv, self)
+    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), GDK_GC(RVAL2GOBJ(gc)),
+                                NUM2INT(x), NUM2INT(y), PANGO_LAYOUT(RVAL2GOBJ(layout)),
+                                RVAL2GDKCOLOR(fg),
+                                RVAL2GDKCOLOR(bg));
+
+    return self;
+}
+
+static VALUE
+gdkdraw_draw_drawable(self, gc, src, xsrc, ysrc, xdst, ydst, w, h)
+    VALUE self, gc, src, xsrc, ysrc, xdst, ydst, w, h;
+{
+    gdk_draw_drawable(_SELF(self), GDK_GC(RVAL2GOBJ(gc)), _SELF(src),
+                      NUM2INT(xsrc), NUM2INT(ysrc),
+                      NUM2INT(xdst), NUM2INT(ydst),
+                      NUM2INT(w), NUM2INT(h));
+    return self;
+}
+
+static VALUE
+gdkdraw_draw_image(self, gc, image, xsrc, ysrc, xdst, ydst, w, h)
+    VALUE self, gc, image, xsrc, ysrc, xdst, ydst, w, h;
+{
+    gdk_draw_image(_SELF(self), GDK_GC(RVAL2GOBJ(gc)),
+                   GDK_IMAGE(RVAL2GOBJ(image)),
+                   NUM2INT(xsrc), NUM2INT(ysrc),
+                   NUM2INT(xdst), NUM2INT(ydst),
+                   NUM2INT(w), NUM2INT(h));
+    return self;
+}
+
+static VALUE
+gdkdraw_get_image(self, x, y, w, h)
+    VALUE self, x, y, w, h;
+{
+    return GOBJ2RVAL(gdk_drawable_get_image(_SELF(self), 
+                                            NUM2INT(x), NUM2INT(y), 
+                                            NUM2INT(w), NUM2INT(h)));
+}
+
+#if GTK_CHECK_VERSION(2,4,0)
+static VALUE
+gdkdraw_copy_to_image(self, image, xsrc, ysrc, xdst, ydst, w, h)
+    VALUE self, image, xsrc, ysrc, xdst, ydst, w, h;
+{
+    return GOBJ2RVAL(gdk_drawable_copy_to_image(_SELF(self), 
+                                                GDK_IMAGE(RVAL2GOBJ(image)),
+                                                NUM2INT(xsrc), NUM2INT(ysrc),
+                                                NUM2INT(xdst), NUM2INT(ydst),
+                                                NUM2INT(w), NUM2INT(h)));
+}
+#endif
+
+#ifdef GDK_WINDOWING_X11
+static VALUE
+gdkdraw_get_xid(self)
+    VALUE self;
+{
+    return ULONG2NUM(GDK_DRAWABLE_XID(_SELF(self)));
+}
+#endif
+
+#if GTK_CHECK_VERSION(2,2,0)
+static VALUE
+gdkdraw_get_display(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gdk_drawable_get_display(_SELF(self)));
+}
+
+static VALUE
+gdkdraw_get_screen(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gdk_drawable_get_screen(_SELF(self)));
+}
+#endif
+
+#if GTK_CHECK_VERSION(2,8,0)
+#  ifdef HAVE_RB_CAIRO_H
+static VALUE
+gdkdraw_cairo_create(self)
+    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
+#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);
+#if GTK_CHECK_VERSION(2,2,0)
+    rb_define_method(gdkDrawable, "draw_pixbuf", gdkdraw_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);
+#if GTK_CHECK_VERSION(2,6,0)
+    rb_define_method(gdkDrawable, "draw_trapezoids", gdkdraw_draw_trapezoids, 2);
+#endif
+    rb_define_method(gdkDrawable, "draw_glyphs", gdkdraw_glyphs, 5);
+#if GTK_CHECK_VERSION(2,6,0)
+    rb_define_method(gdkDrawable, "draw_glyphs_transformed", gdkdraw_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);
+#if GTK_CHECK_VERSION(2,4,0)
+    rb_define_method(gdkDrawable, "copy_to_image", gdkdraw_copy_to_image, 7);
+#endif
+
+#ifdef GDK_WINDOWING_X11
+    rb_define_method(gdkDrawable, "xid", gdkdraw_get_xid, 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);
+#endif
+    
+#if GTK_CHECK_VERSION(2,8,0)
+#  ifdef HAVE_RB_CAIRO_H
+    rb_define_method(gdkDrawable, "create_cairo_context",
+                     gdkdraw_cairo_create, 0);
+#  endif
+#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
+    
+    G_DEF_SETTERS(gdkDrawable);
+}
+