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

data/ext/gtk2/rbgdkregion.c

@@ -1,18 +1,30 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003 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
+ */
 
-  rbgdkregion.c -
-
-  $Author: ggc $
-  $Date: 2007/07/13 16:07:31 $
-
-  Copyright (C) 2002,2003 Masao Mutoh
-  Copyright (C) 1998-2000 Yukihiro Matsumoto,
-                          Daisuke Kanda,
-                          Hiroshi Igarashi
-************************************************/
 #include "global.h"
 
+#define RG_TARGET_NAMESPACE cRegion
 #define _SELF(r) ((GdkRegion*)RVAL2BOXED(r, GDK_TYPE_REGION))
 
 /**********************************/
@@ -29,30 +41,23 @@ gdk_region_get_type(void)
 }
 /**********************************/
 static VALUE
-gdkregion_initialize(int argc, VALUE *argv, VALUE self)
+rg_initialize(int argc, VALUE *argv, VALUE self)
 {
-    VALUE points_or_rectangle, fill_rule;
-    GdkRegion* region;
-    GdkPoint *gpoints;
-    int i;
+    VALUE points_or_rectangle, rbfill_rule;
+    GdkRegion *region;
 
-    rb_scan_args(argc, argv, "02", &points_or_rectangle, &fill_rule);
-    if (NIL_P(points_or_rectangle)){
+    rb_scan_args(argc, argv, "02", &points_or_rectangle, &rbfill_rule);
+    if (NIL_P(points_or_rectangle)) {
         region = gdk_region_new();
-    } else if (TYPE(points_or_rectangle) == T_ARRAY){
-        gpoints = ALLOCA_N(GdkPoint, RARRAY_LEN(points_or_rectangle));
-
-        for (i = 0; i < RARRAY_LEN(points_or_rectangle); i++) {
-            Check_Type(RARRAY_PTR(points_or_rectangle)[i], T_ARRAY);
-            if (RARRAY_LEN(RARRAY_PTR(points_or_rectangle)[i]) < 2) {
-                rb_raise(rb_eArgError, "point %d should be array of size 2", i);
-            }
-            gpoints[i].x = NUM2INT(RARRAY_PTR(RARRAY_PTR(points_or_rectangle)[i])[0]);
-            gpoints[i].y = NUM2INT(RARRAY_PTR(RARRAY_PTR(points_or_rectangle)[i])[1]);
-        }
-        region = gdk_region_polygon(gpoints, RARRAY_LEN(points_or_rectangle),
-                                    RVAL2GENUM(fill_rule, GDK_TYPE_FILL_RULE));
-    } else if (RVAL2GTYPE(points_or_rectangle) == GDK_TYPE_RECTANGLE){
+    } else if (TYPE(points_or_rectangle) == T_ARRAY) {
+        GdkFillRule fill_rule = RVAL2GENUM(rbfill_rule, GDK_TYPE_FILL_RULE);
+        long n;
+        GdkPoint *points = RVAL2GDKPOINTS(points_or_rectangle, &n);
+
+        region = gdk_region_polygon(points, n, fill_rule);
+
+        g_free(points);
+    } else if (RVAL2GTYPE(points_or_rectangle) == GDK_TYPE_RECTANGLE) {
         region = gdk_region_rectangle((GdkRectangle*)RVAL2BOXED(points_or_rectangle, 
                                                                 GDK_TYPE_RECTANGLE));
     } else {
@@ -62,11 +67,12 @@ gdkregion_initialize(int argc, VALUE *argv, VALUE self)
     }
 
     G_INITIALIZE(self, region);
+
     return Qnil;
 }
 
 static VALUE
-gdkregion_get_rectangles(VALUE self)
+rg_rectangles(VALUE self)
 {
     GdkRectangle* rectangles;
     gint n_rect, i;
@@ -88,27 +94,87 @@ gdkregion_span_func(GdkSpan *span, gpointer func)
                INT2NUM(span->x), INT2NUM(span->y), INT2NUM(span->width));
 }
 
+struct rbgdk_rval2gdkspans_args {
+    VALUE ary;
+    long n;
+    GdkSpan *result;
+};
+
 static VALUE
-gdkregion_spans_intersect_foreach(VALUE self, VALUE spans, VALUE sorted)
+rbgdk_rval2gdkspans_body(VALUE value)
 {
-    int i;
-    GdkSpan* gspans = ALLOCA_N(GdkSpan, RARRAY_LEN(spans));
-    volatile VALUE func = rb_block_proc();
+    long i;
+    struct rbgdk_rval2gdkspans_args *args = (struct rbgdk_rval2gdkspans_args *)value;
 
-    G_RELATIVE(self, func);
-    for (i = 0; i < RARRAY_LEN(spans); i++) {
-        gspans[i].x = NUM2INT(RARRAY_PTR(RARRAY_PTR(spans)[i])[0]);
-        gspans[i].y = NUM2INT(RARRAY_PTR(RARRAY_PTR(spans)[i])[1]);
-        gspans[i].width = NUM2INT(RARRAY_PTR(RARRAY_PTR(spans)[i])[2]);
+    for (i = 0; i < args->n; i++) {
+        VALUE points = rb_ary_to_ary(RARRAY_PTR(args->ary)[i]);
+
+        if (RARRAY_LEN(points) != 2)
+            rb_raise(rb_eArgError, "point %ld should be array of size 3", i);
+
+        args->result[i].x = NUM2INT(RARRAY_PTR(points)[0]);
+        args->result[i].y = NUM2INT(RARRAY_PTR(points)[1]);
+        args->result[i].width = NUM2INT(RARRAY_PTR(points)[1]);
     }
-    gdk_region_spans_intersect_foreach(_SELF(self),
-                                       gspans, RARRAY_LEN(spans), RVAL2CBOOL(sorted),
-                                       (GdkSpanFunc)gdkregion_span_func, (gpointer)func);
+
+    return Qnil;
+}
+
+static G_GNUC_NORETURN VALUE
+rbgdk_rval2gdkspans_rescue(VALUE value)
+{
+    g_free(((struct rbgdk_rval2gdkspans_args *)value)->result);
+
+    rb_exc_raise(rb_errinfo());
+}
+
+static GdkSpan *
+rbgdk_rval2gdkspans(VALUE value, long *n)
+{
+    struct rbgdk_rval2gdkspans_args args;
+
+    args.ary = rb_ary_to_ary(value);
+    args.n = RARRAY_LEN(args.ary);
+    args.result = g_new(GdkSpan, args.n + 1);
+
+    rb_rescue(rbgdk_rval2gdkspans_body, (VALUE)&args,
+              rbgdk_rval2gdkspans_rescue, (VALUE)&args);
+
+    if (n != NULL)
+        *n = args.n;
+
+    return args.result;
+}
+
+#define RVAL2GDKSPANS(value, n) rbgdk_rval2gdkspans(value, n)
+
+static VALUE
+rg_spans_intersect_each(VALUE self, VALUE rbspans, VALUE rbsorted)
+{
+    GdkRegion *region = _SELF(self);
+    gboolean sorted = RVAL2CBOOL(rbsorted);
+    VALUE func = rb_block_proc();
+    long n;
+    GdkSpan *spans;
+
+    G_RELATIVE(self, func);
+
+    spans = RVAL2GDKSPANS(rbspans, &n);
+
+    gdk_region_spans_intersect_foreach(region,
+                                       spans,
+                                       n,
+                                       sorted,
+                                       (GdkSpanFunc)gdkregion_span_func,
+                                       (gpointer)func);
+
+    g_free(spans);
+
     return self;
 }
 
 static VALUE
-gdkregion_get_clipbox(VALUE self)
+rg_clipbox(VALUE self)
 {
     GdkRectangle rect;
     gdk_region_get_clipbox(_SELF(self), &rect);
@@ -116,13 +182,13 @@ gdkregion_get_clipbox(VALUE self)
 }
 
 static VALUE
-gdkregion_empty(VALUE self)
+rg_empty_p(VALUE self)
 {
     return CBOOL2RVAL(gdk_region_empty(_SELF(self)));
 }
 
 static VALUE
-gdkregion_equal(VALUE self, VALUE obj)
+rg_operator_equal(VALUE self, VALUE obj)
 {
     if (!rb_obj_is_instance_of(obj, GTYPE2CLASS(GDK_TYPE_REGION))) {
         return Qnil;
@@ -131,14 +197,14 @@ gdkregion_equal(VALUE self, VALUE obj)
 }
 
 static VALUE
-gdkregion_point_in(VALUE self, VALUE x, VALUE y)
+rg_point_in_p(VALUE self, VALUE x, VALUE y)
 {
     return CBOOL2RVAL(gdk_region_point_in(_SELF(self), NUM2INT(x),
                                           NUM2INT(y)));
 }
 
 static VALUE
-gdkregion_rect_in(VALUE self, VALUE rect)
+rg_rect_in(VALUE self, VALUE rect)
 {
     return GENUM2RVAL(gdk_region_rect_in(
                           _SELF(self),
@@ -147,28 +213,28 @@ gdkregion_rect_in(VALUE self, VALUE rect)
 }
 
 static VALUE
-gdkregion_offset(VALUE self, VALUE dx, VALUE dy)
+rg_offset(VALUE self, VALUE dx, VALUE dy)
 {
     gdk_region_offset(_SELF(self), NUM2INT(dx), NUM2INT(dy));
     return self;
 }
 
 static VALUE
-gdkregion_shrink(VALUE self, VALUE dx, VALUE dy)
+rg_shrink(VALUE self, VALUE dx, VALUE dy)
 {
     gdk_region_shrink(_SELF(self), NUM2INT(dx), NUM2INT(dy));
     return self;
 }
 
 static VALUE
-gdkregion_intersect(VALUE self, VALUE region)
+rg_intersect(VALUE self, VALUE region)
 {
     gdk_region_intersect(_SELF(self), _SELF(region));
     return self;
 }
 
 static VALUE
-gdkregion_union(VALUE self, VALUE other)
+rg_union(VALUE self, VALUE other)
 {
     if (RVAL2GTYPE(other) == GDK_TYPE_RECTANGLE){
         gdk_region_union_with_rect(_SELF(self),
@@ -180,45 +246,44 @@ gdkregion_union(VALUE self, VALUE other)
 }
 
 static VALUE
-gdkregion_subtract(VALUE self, VALUE region)
+rg_subtract(VALUE self, VALUE region)
 {
     gdk_region_subtract(_SELF(self), _SELF(region));
     return self;
 }
 
 static VALUE
-gdkregion_xor(VALUE self, VALUE region)
+rg_xor(VALUE self, VALUE region)
 {
     gdk_region_xor(_SELF(self), _SELF(region));
     return self;
 }
 
-
 void
-Init_gtk_gdk_region()
-{
-    VALUE gdkRegion = G_DEF_CLASS(GDK_TYPE_REGION, "Region", mGdk);
-
-    rb_define_method(gdkRegion, "initialize", gdkregion_initialize, -1);
-    rb_define_method(gdkRegion, "rectangles", gdkregion_get_rectangles, 0);
-    rb_define_method(gdkRegion, "spans_intersect_each", gdkregion_spans_intersect_foreach, 2);
-    rb_define_method(gdkRegion, "clipbox", gdkregion_get_clipbox, 0);
-    rb_define_method(gdkRegion, "empty?", gdkregion_empty, 0);
-    rb_define_method(gdkRegion, "==", gdkregion_equal, 1);
-    rb_define_method(gdkRegion, "point_in?", gdkregion_point_in, 2);
-    rb_define_method(gdkRegion, "rect_in", gdkregion_rect_in, 1);
-    rb_define_method(gdkRegion, "offset", gdkregion_offset, 2);
-    rb_define_method(gdkRegion, "shrink", gdkregion_shrink, 2);
-    rb_define_method(gdkRegion, "intersect", gdkregion_intersect, 1);
-    rb_define_method(gdkRegion, "union", gdkregion_union, 1);
-    rb_define_method(gdkRegion, "subtract", gdkregion_subtract, 1);
-    rb_define_method(gdkRegion, "xor", gdkregion_xor, 1);
+Init_gtk_gdk_region(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_REGION, "Region", mGdk);
+
+    RG_DEF_METHOD(initialize, -1);
+    RG_DEF_METHOD(rectangles, 0);
+    RG_DEF_METHOD(spans_intersect_each, 2);
+    RG_DEF_METHOD(clipbox, 0);
+    RG_DEF_METHOD_P(empty, 0);
+    RG_DEF_METHOD_OPERATOR("==", equal, 1);
+    RG_DEF_METHOD_P(point_in, 2);
+    RG_DEF_METHOD(rect_in, 1);
+    RG_DEF_METHOD(offset, 2);
+    RG_DEF_METHOD(shrink, 2);
+    RG_DEF_METHOD(intersect, 1);
+    RG_DEF_METHOD(union, 1);
+    RG_DEF_METHOD(subtract, 1);
+    RG_DEF_METHOD(xor, 1);
 
     /* GdkOverlapType */
-    G_DEF_CLASS(GDK_TYPE_OVERLAP_TYPE, "OverlapType", gdkRegion);
-    G_DEF_CONSTANTS(gdkRegion, GDK_TYPE_OVERLAP_TYPE, "GDK_");
+    G_DEF_CLASS(GDK_TYPE_OVERLAP_TYPE, "OverlapType", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_OVERLAP_TYPE, "GDK_");
 
     /* GdkFillRule */
-    G_DEF_CLASS(GDK_TYPE_FILL_RULE, "FillRule", gdkRegion);
-    G_DEF_CONSTANTS(gdkRegion, GDK_TYPE_FILL_RULE, "GDK_");
+    G_DEF_CLASS(GDK_TYPE_FILL_RULE, "FillRule", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_FILL_RULE, "GDK_");
 }

data/ext/gtk2/rbgdkrgb.c

@@ -1,24 +1,34 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbgdkrgb.c -
-
-  $Author: ggc $
-  $Date: 2007/07/13 16:07:31 $
-
-  Copyright (C) 2002,2003 Ruby-GNOME2 Project Team
-  Copyright (C) 1998-2000 Yukihiro Matsumoto,
-                          Daisuke Kanda,
-                          Hiroshi Igarashi
-************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003 Ruby-GNOME2 Project Team
+ *  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"
 
+#define RG_TARGET_NAMESPACE mRGB
 #define RVAL2DRAW(s) GDK_DRAWABLE(RVAL2GOBJ(s))
 
-
 static VALUE
-rgb_draw_rgb_image(int argc, VALUE *argv, VALUE self)
+rg_m_draw_rgb_image(int argc, VALUE *argv, VALUE self)
 {
     VALUE win, gc, x, y, w, h, dither, buf, rowstride, xdith, ydith;
 
@@ -46,36 +56,42 @@ rgb_draw_rgb_image(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-rgb_draw_indexed_image(VALUE self, VALUE win, VALUE gc, VALUE x, VALUE y, VALUE w, VALUE h, VALUE dither, VALUE buf, VALUE rowstride, VALUE colors)
+rg_m_draw_indexed_image(VALUE self, VALUE win, VALUE rbgc, VALUE rbx, VALUE rby,
+                       VALUE rbwidth, VALUE rbheight, VALUE rbdither,
+                       VALUE rbbuf, VALUE rbrowstride, VALUE rbcolors)
 {
-    GdkRgbCmap* cmap;
-    guint32* gcolors;
-    gint i, n_colors;
+    GdkDrawable *drawable = RVAL2DRAW(win);
+    GdkGC *gc = GDK_GC(RVAL2GOBJ(rbgc));
+    gint x = NUM2INT(rbx);
+    gint y = NUM2INT(rby);
+    gint width = NUM2INT(rbwidth);
+    gint height = NUM2INT(rbheight);
+    GdkRgbDither dither = RVAL2GENUM(rbdither, GDK_TYPE_RGB_DITHER);
+    const guchar *buf = (const guchar *)RVAL2CSTR(rbbuf);
+    gint rowstride = NUM2INT(rbrowstride);
+    long n;
+    guint32 *colors = RVAL2GUINT32S(rbcolors, n);
+    GdkRgbCmap *cmap;
+
+    if (n < 0 || n > 255) {
+        g_free(colors);
 
-    n_colors = RARRAY_LEN(colors);
-
-    if (n_colors > 255)
         rb_raise(rb_eArgError, "colors: out of range (0 - 255)");
-
-    gcolors = g_new(guint32, n_colors);
-    for (i = 0; i < n_colors; i++) {
-        gcolors[i] = NUM2UINT(RARRAY_PTR(colors)[i]);
     }
 
-    cmap = gdk_rgb_cmap_new(gcolors, n_colors);
-    
-    gdk_draw_indexed_image(RVAL2DRAW(win), GDK_GC(RVAL2GOBJ(gc)),
-                           NUM2INT(x), NUM2INT(y),
-                           NUM2INT(w), NUM2INT(h),
-                           RVAL2GENUM(dither, GDK_TYPE_RGB_DITHER),
-                           (guchar*)RVAL2CSTR(buf), 
-                           NUM2INT(rowstride), cmap);
+    cmap = gdk_rgb_cmap_new(colors, n);
+
+    g_free(colors);
+
+    gdk_draw_indexed_image(drawable, gc, x, y, width, height, dither, buf, rowstride, cmap);
+
     gdk_rgb_cmap_free(cmap);
+
     return self;
 }
 
 static VALUE
-rgb_draw_gray_image(VALUE self, VALUE win, VALUE gc, VALUE x, VALUE y, VALUE w, VALUE h, VALUE dither, VALUE buf, VALUE rowstride)
+rg_m_draw_gray_image(VALUE self, VALUE win, VALUE gc, VALUE x, VALUE y, VALUE w, VALUE h, VALUE dither, VALUE buf, VALUE rowstride)
 {
     gdk_draw_gray_image(RVAL2DRAW(win), GDK_GC(RVAL2GOBJ(gc)),
                         NUM2INT(x), NUM2INT(y),
@@ -87,7 +103,7 @@ rgb_draw_gray_image(VALUE self, VALUE win, VALUE gc, VALUE x, VALUE y, VALUE w,
 }
 
 static VALUE
-rgb_draw_rgb_32_image(int argc, VALUE *argv, VALUE self)
+rg_m_draw_rgb_32_image(int argc, VALUE *argv, VALUE self)
 {
     VALUE win, gc, x, y, w, h, dither, buf, rowstride, xdith, ydith;
 
@@ -113,7 +129,7 @@ rgb_draw_rgb_32_image(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-rgb_find_color(VALUE self, VALUE colormap, VALUE color)
+rg_m_find_color(VALUE self, VALUE colormap, VALUE color)
 {
     gdk_rgb_find_color(GDK_COLORMAP(RVAL2GOBJ(colormap)),
                        RVAL2GDKCOLOR(color));
@@ -121,62 +137,62 @@ rgb_find_color(VALUE self, VALUE colormap, VALUE color)
 }
 
 static VALUE
-rgb_set_install(VALUE self, VALUE install)
+rg_m_set_install(VALUE self, VALUE install)
 {
     gdk_rgb_set_install(RVAL2CBOOL(install));
     return self;
 }
 
 static VALUE
-rgb_set_min_colors(VALUE self, VALUE min_colors)
+rg_m_set_min_colors(VALUE self, VALUE min_colors)
 {
     gdk_rgb_set_min_colors(NUM2INT(min_colors));
     return self;
 }
 
 static VALUE
-rgb_get_visual(VALUE self)
+rg_m_visual(G_GNUC_UNUSED VALUE self)
 {
     return GOBJ2RVAL(gdk_rgb_get_visual());
 }
 
 static VALUE
-rgb_get_cmap(VALUE self)
+rg_m_colormap(G_GNUC_UNUSED VALUE self)
 {
     return GOBJ2RVAL(gdk_rgb_get_colormap());
 }
 
 static VALUE
-rgb_ditherable(VALUE self)
+rg_m_ditherable_p(G_GNUC_UNUSED VALUE self)
 {
     return CBOOL2RVAL(gdk_rgb_ditherable());
 }
 
 static VALUE
-rgb_set_verbose(VALUE self, VALUE verbose)
+rg_m_set_verbose(VALUE self, VALUE verbose)
 {
     gdk_rgb_set_verbose(RVAL2CBOOL(verbose));
     return self;
 }
 
 void
-Init_gtk_gdk_rgb()
+Init_gtk_gdk_rgb(VALUE mGdk)
 {
-    VALUE mGdkRgb = rb_define_module_under(mGdk, "RGB");
-
-    rb_define_module_function(mGdkRgb, "draw_rgb_image", rgb_draw_rgb_image, -1);
-    rb_define_module_function(mGdkRgb, "draw_indexed_image", rgb_draw_indexed_image, 10);
-    rb_define_module_function(mGdkRgb, "draw_gray_image", rgb_draw_gray_image, 9);
-    rb_define_module_function(mGdkRgb, "draw_rgb_32_image", rgb_draw_rgb_32_image, -1);
-    rb_define_module_function(mGdkRgb, "find_color", rgb_find_color, 2);
-    rb_define_module_function(mGdkRgb, "set_install", rgb_set_install, 1);
-    rb_define_module_function(mGdkRgb, "set_min_colors", rgb_set_min_colors, 0);
-    rb_define_module_function(mGdkRgb, "visual", rgb_get_visual, 0);
-    rb_define_module_function(mGdkRgb, "colormap", rgb_get_cmap, 0);
-    rb_define_module_function(mGdkRgb, "ditherable?", rgb_ditherable, 0);
-    rb_define_module_function(mGdkRgb, "set_verbose", rgb_set_verbose, 1);
+    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGdk, "RGB");
+
+    RG_DEF_MODFUNC(draw_rgb_image, -1);
+    RG_DEF_MODFUNC(draw_indexed_image, 10);
+    RG_DEF_MODFUNC(draw_gray_image, 9);
+    RG_DEF_MODFUNC(draw_rgb_32_image, -1);
+    RG_DEF_MODFUNC(find_color, 2);
+    RG_DEF_MODFUNC(set_install, 1);
+    RG_DEF_MODFUNC(set_min_colors, 0);
+    RG_DEF_MODFUNC(visual, 0);
+    RG_DEF_MODFUNC(colormap, 0);
+    RG_DEF_MODFUNC_P(ditherable, 0);
+    RG_DEF_MODFUNC(set_verbose, 1);
 
     /* GdkRgbDither */
-    G_DEF_CLASS(GDK_TYPE_RGB_DITHER, "Dither", mGdkRgb);
-    G_DEF_CONSTANTS(mGdkRgb, GDK_TYPE_RGB_DITHER, "GDK_RGB_");
+    G_DEF_CLASS(GDK_TYPE_RGB_DITHER, "Dither", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GDK_TYPE_RGB_DITHER, "GDK_RGB_");
 }