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

data/ext/gtk2/rbgtkprintoperation.c

@@ -1,30 +1,42 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbgtkprintoperation.c -
-
-  $Author: sakai $
-  $Date: 2007/07/08 03:00:49 $
-
-  Copyright (C) 2006 Ruby-GNOME2 Project Team
-************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 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,10,0)
+
+#define RG_TARGET_NAMESPACE cPrintOperation
 #define _SELF(s) (GTK_PRINT_OPERATION(RVAL2GOBJ(s)))
 
-static VALUE gPrintOperation;
+static VALUE RG_TARGET_NAMESPACE;
 
 static VALUE
-po_initialize(VALUE self)
+rg_initialize(VALUE self)
 {
     G_INITIALIZE(self, gtk_print_operation_new());
     return Qnil;
 }
 
 static VALUE
-po_run(int argc, VALUE *argv, VALUE self)
+rg_run(int argc, VALUE *argv, VALUE self)
 {
     VALUE action, parent, rb_result;
     GtkPrintOperationResult result;
@@ -47,7 +59,7 @@ po_run(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-po_get_error(VALUE self)
+rg_error(VALUE self)
 {
     GError *error = NULL;
     gtk_print_operation_get_error(_SELF(self), &error);
@@ -55,13 +67,13 @@ po_get_error(VALUE self)
 }
 
 static VALUE
-po_is_finished(VALUE self)
+rg_finished_p(VALUE self)
 {
     return CBOOL2RVAL(gtk_print_operation_is_finished(_SELF(self)));
 }
 
 static VALUE
-po_cancel(VALUE self)
+rg_cancel(VALUE self)
 {
     gtk_print_operation_cancel(_SELF(self));
     return self;
@@ -86,7 +98,7 @@ page_setup_done_cb(GtkPageSetup *page_setup, gpointer data)
     VALUE callback = (VALUE)data;
     struct callback_arg arg;
 
-    G_CHILD_UNSET(gPrintOperation, rb_intern("setup_done_cb"));
+    G_CHILD_UNSET(RG_TARGET_NAMESPACE, rb_intern("setup_done_cb"));
 
     arg.callback = callback;
     arg.page_setup = GOBJ2RVAL(page_setup);
@@ -95,14 +107,14 @@ page_setup_done_cb(GtkPageSetup *page_setup, gpointer data)
 }
 
 static VALUE
-po_run_page_setup_dialog(int argc, VALUE *argv, VALUE self)
+rg_s_run_page_setup_dialog(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
 {
     VALUE parent, page_setup, settings;
     rb_scan_args(argc, argv, "03", &parent, &page_setup, &settings);
 
     if (rb_block_given_p()) {
         volatile VALUE func = rb_block_proc();
-        G_CHILD_SET(gPrintOperation, rb_intern("setup_done_cb"), func);
+        G_CHILD_SET(RG_TARGET_NAMESPACE, rb_intern("setup_done_cb"), func);
         gtk_print_run_page_setup_dialog_async(RVAL2GOBJ(parent),
                                               RVAL2GOBJ(page_setup),
                                               RVAL2GOBJ(settings),
@@ -118,33 +130,32 @@ po_run_page_setup_dialog(int argc, VALUE *argv, VALUE self)
 #endif
 
 void
-Init_gtk_print_operation()
+Init_gtk_print_operation(VALUE mGtk)
 {
 #if GTK_CHECK_VERSION(2,10,0)
-    gPrintOperation = G_DEF_CLASS(GTK_TYPE_PRINT_OPERATION, "PrintOperation", mGtk);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_PRINT_OPERATION, "PrintOperation", mGtk);
 
     G_DEF_ERROR(GTK_PRINT_ERROR, "PrintError", mGtk, rb_eRuntimeError,
                 GTK_TYPE_PRINT_ERROR);
 
-    rb_define_method(gPrintOperation, "initialize", po_initialize, 0);
-    rb_define_method(gPrintOperation, "run", po_run, -1);
-    rb_define_method(gPrintOperation, "error", po_get_error, 0);
-    rb_define_method(gPrintOperation, "finished?", po_is_finished, 0);
-    rb_define_method(gPrintOperation, "cancel", po_cancel, 0);
+    RG_DEF_METHOD(initialize, 0);
+    RG_DEF_METHOD(run, -1);
+    RG_DEF_METHOD(error, 0);
+    RG_DEF_METHOD_P(finished, 0);
+    RG_DEF_METHOD(cancel, 0);
 
-    rb_define_singleton_method(gPrintOperation, "run_page_setup_dialog",
-                               po_run_page_setup_dialog, -1);
+    RG_DEF_SMETHOD(run_page_setup_dialog, -1);
 
     /* GtkPrintStatus */
-    G_DEF_CLASS(GTK_TYPE_PRINT_STATUS, "Status", gPrintOperation);
-    G_DEF_CONSTANTS(gPrintOperation, GTK_TYPE_PRINT_STATUS, "GTK_PRINT_");
+    G_DEF_CLASS(GTK_TYPE_PRINT_STATUS, "Status", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_PRINT_STATUS, "GTK_PRINT_");
 
     /* GtkPrintOperationAction */
-    G_DEF_CLASS(GTK_TYPE_PRINT_OPERATION_ACTION,"Action", gPrintOperation);
-    G_DEF_CONSTANTS(gPrintOperation, GTK_TYPE_PRINT_OPERATION_ACTION, "GTK_PRINT_OPERATION_");
+    G_DEF_CLASS(GTK_TYPE_PRINT_OPERATION_ACTION,"Action", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_PRINT_OPERATION_ACTION, "GTK_PRINT_OPERATION_");
 
     /* GtkPrintOperationResult */
-    G_DEF_CLASS(GTK_TYPE_PRINT_OPERATION_RESULT, "Result", gPrintOperation);
-    G_DEF_CONSTANTS(gPrintOperation, GTK_TYPE_PRINT_OPERATION_RESULT, "GTK_PRINT_OPERATION_");
+    G_DEF_CLASS(GTK_TYPE_PRINT_OPERATION_RESULT, "Result", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_PRINT_OPERATION_RESULT, "GTK_PRINT_OPERATION_");
 #endif
 }

data/ext/gtk2/rbgtkprintoperationpreview.c

@@ -1,35 +1,47 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbgtkprintoperationpreview.c -
-
-  $Author: mutoh $
-  $Date: 2006/11/03 19:40:44 $
-
-  Copyright (C) 2006 Ruby-GNOME2 Project Team
-************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 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,10,0)
+
+#define RG_TARGET_NAMESPACE cPrintOperationPreview
 #define _SELF(s) (GTK_PRINT_OPERATION_PREVIEW(RVAL2GOBJ(s)))
 
 static VALUE
-pop_render_page(VALUE self, VALUE page_number)
+rg_render_page(VALUE self, VALUE page_number)
 {
     gtk_print_operation_preview_render_page(_SELF(self), NUM2INT(page_number));
     return self;
 }
 
 static VALUE
-pop_end_preview(VALUE self)
+rg_end_preview(VALUE self)
 {
     gtk_print_operation_preview_end_preview(_SELF(self));
     return self;
 }
 
 static VALUE
-pop_is_selected(VALUE self, VALUE page_number)
+rg_selected_p(VALUE self, VALUE page_number)
 {
     gboolean selected;
     selected = gtk_print_operation_preview_is_selected(_SELF(self),
@@ -39,16 +51,16 @@ pop_is_selected(VALUE self, VALUE page_number)
 #endif
 
 void
-Init_gtk_print_operation_preview()
+Init_gtk_print_operation_preview(VALUE mGtk)
 {
 #if GTK_CHECK_VERSION(2,10,0)
-    VALUE gPrintOperationPreview = G_DEF_CLASS(GTK_TYPE_PRINT_OPERATION_PREVIEW,
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_PRINT_OPERATION_PREVIEW,
                                                "PrintOperationPreview", mGtk);
 
-    rb_define_method(gPrintOperationPreview, "render_page", pop_render_page, 1);
-    rb_define_method(gPrintOperationPreview, "end_preview", pop_end_preview, 0);
-    rb_define_method(gPrintOperationPreview, "selected?", pop_is_selected, 1);
+    RG_DEF_METHOD(render_page, 1);
+    RG_DEF_METHOD(end_preview, 0);
+    RG_DEF_METHOD_P(selected, 1);
 
-    G_DEF_SETTERS(gPrintOperationPreview);
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
 #endif
 }

data/ext/gtk2/rbgtkprintsettings.c

@@ -1,18 +1,29 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbgtkprintsettings.c -
-
-  $Author: ggc $
-  $Date: 2007/07/13 16:07:31 $
-
-  Copyright (C) 2006 Ruby-GNOME2 Project Team
-************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 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,10,0)
 
+#define RG_TARGET_NAMESPACE cPrintSettings
 #define _SELF(s) (GTK_PRINT_SETTINGS(RVAL2GOBJ(s)))
 
 #define RVAL2UNIT(o) (RVAL2GENUM(o, GTK_TYPE_UNIT))
@@ -21,7 +32,7 @@ static VALUE s_string, s_bool, s_double, s_length, s_int;
 
 #if GTK_CHECK_VERSION(2,12,0)
 static VALUE
-ps_initialize(int argc, VALUE *argv, VALUE self)
+rg_initialize(int argc, VALUE *argv, VALUE self)
 {
     VALUE arg1, arg2;
     GtkPrintSettings* settings = NULL;
@@ -55,13 +66,13 @@ ps_initialize(VALUE self)
 #endif
 
 static VALUE
-ps_copy(VALUE self)
+rg_dup(VALUE self)
 {
     return GOBJ2RVALU(gtk_print_settings_copy(_SELF(self)));
 }
 
 static VALUE
-ps_has_key(VALUE self, VALUE key)
+rg_has_key_p(VALUE self, VALUE key)
 {
     return CBOOL2RVAL(gtk_print_settings_has_key(_SELF(self), RVAL2CSTR(key)));
 }
@@ -80,7 +91,7 @@ ps_set(VALUE self, VALUE key, VALUE value)
 }
 
 static VALUE
-ps_unset(VALUE self, VALUE key)
+rg_unset(VALUE self, VALUE key)
 {
     gtk_print_settings_unset(_SELF(self), RVAL2CSTR(key));
     return self;
@@ -93,7 +104,7 @@ ps_foreach_cb(const gchar *key, const gchar *value, gpointer data)
 }
 
 static VALUE
-ps_foreach(VALUE self)
+rg_each(VALUE self)
 {
     gtk_print_settings_foreach(_SELF(self), ps_foreach_cb,
                                (gpointer)rb_block_proc());
@@ -101,7 +112,7 @@ ps_foreach(VALUE self)
 }
 
 static VALUE
-ps_get_bool(VALUE self, VALUE key)
+rg_get_bool(VALUE self, VALUE key)
 {
     return CBOOL2RVAL(gtk_print_settings_get_bool(_SELF(self), RVAL2CSTR(key)));
 }
@@ -114,7 +125,7 @@ ps_set_bool(VALUE self, VALUE key, VALUE value)
 }
 
 static VALUE
-ps_get_double(int argc, VALUE *argv, VALUE self)
+rg_get_double(int argc, VALUE *argv, VALUE self)
 {
     VALUE key, default_value;
     gdouble value;
@@ -138,7 +149,7 @@ ps_set_double(VALUE self, VALUE key, VALUE value)
 }
 
 static VALUE
-ps_get_length(VALUE self, VALUE key, VALUE unit)
+rg_get_length(VALUE self, VALUE key, VALUE unit)
 {
     return rb_float_new(gtk_print_settings_get_length(_SELF(self),
                                                       RVAL2CSTR(key),
@@ -154,7 +165,7 @@ ps_set_length(VALUE self, VALUE key, VALUE value, VALUE unit)
 }
 
 static VALUE
-ps_get_int(int argc, VALUE *argv, VALUE self)
+rg_get_int(int argc, VALUE *argv, VALUE self)
 {
     VALUE key, default_value;
     gint value;
@@ -178,7 +189,7 @@ ps_set_int(VALUE self, VALUE key, VALUE value)
 }
 
 static VALUE
-ps_get_generic(int argc, VALUE *argv, VALUE self)
+rg_get(int argc, VALUE *argv, VALUE self)
 {
     VALUE key, type, unit_or_default, result;
 
@@ -187,19 +198,19 @@ ps_get_generic(int argc, VALUE *argv, VALUE self)
     if (NIL_P(type) || (RVAL2CBOOL(rb_equal(type, s_string)))) {
         result = ps_get(self, key);
     } else if (RVAL2CBOOL(rb_equal(type, s_bool))) {
-        result = ps_get_bool(self, key);
+        result = rg_get_bool(self, key);
     } else if (RVAL2CBOOL(rb_equal(type, s_double))) {
         VALUE double_argv[2];
         double_argv[0] = key;
         double_argv[1] = unit_or_default;
-        result = ps_get_double(2, double_argv, self);
+        result = rg_get_double(2, double_argv, self);
     } else if (RVAL2CBOOL(rb_equal(type, s_length))) {
-        result = ps_get_length(self, key, unit_or_default);
+        result = rg_get_length(self, key, unit_or_default);
     } else if (RVAL2CBOOL(rb_equal(type, s_int))) {
         VALUE int_argv[2];
         int_argv[0] = key;
         int_argv[1] = unit_or_default;
-        result = ps_get_int(2, int_argv, self);
+        result = rg_get_int(2, int_argv, self);
     } else {
         VALUE inspected_type;
         inspected_type = rb_inspect(type);
@@ -212,7 +223,7 @@ ps_get_generic(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-ps_set_generic(int argc, VALUE *argv, VALUE self)
+rg_set(int argc, VALUE *argv, VALUE self)
 {
     VALUE key, value, unit;
 
@@ -237,7 +248,7 @@ ps_set_generic(int argc, VALUE *argv, VALUE self)
         }
         break;
       case T_NIL:
-        ps_unset(self, key);
+        rg_unset(self, key);
         break;
       default:
       {
@@ -253,48 +264,47 @@ ps_set_generic(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-ps_set_generic_indexer(int argc, VALUE *argv, VALUE self)
+rg_operator_ps_set_generic_indexer(int argc, VALUE *argv, VALUE self)
 {
     if (argc == 3) {
         VALUE swapped_argv[3];
         swapped_argv[0] = argv[0];
         swapped_argv[1] = argv[2];
         swapped_argv[2] = argv[1];
-        ps_set_generic(argc, swapped_argv, self);
+        rg_set(argc, swapped_argv, self);
     } else if (argc == 2) {
-        ps_set_generic(argc, argv, self);
+        rg_set(argc, argv, self);
     } else {
-	rb_raise(rb_eArgError,
+        rb_raise(rb_eArgError,
                  "wrong number of arguments (%d for 2 or 3)", argc);
     }
 
     return argv[2];
 }
 
-
 /* Helpers: */
 static VALUE
-ps_get_printer(VALUE self)
+rg_printer(VALUE self)
 {
     return CSTR2RVAL(gtk_print_settings_get_printer(_SELF(self)));
 }
 
 static VALUE
-ps_set_printer(VALUE self, VALUE printer)
+rg_set_printer(VALUE self, VALUE printer)
 {
     gtk_print_settings_set_printer(_SELF(self), RVAL2CSTR_ACCEPT_NIL(printer));
     return self;
 }
 
 static VALUE
-ps_get_orientation(VALUE self)
+rg_orientation(VALUE self)
 {
     return GENUM2RVAL(gtk_print_settings_get_orientation(_SELF(self)), 
                       GTK_TYPE_PAGE_ORIENTATION);
 }
 
 static VALUE
-ps_set_orientation(VALUE self, VALUE orientation)
+rg_set_orientation(VALUE self, VALUE orientation)
 {
     gtk_print_settings_set_orientation(_SELF(self),
                                        RVAL2GENUM(orientation, GTK_TYPE_PAGE_ORIENTATION));
@@ -302,13 +312,13 @@ ps_set_orientation(VALUE self, VALUE orientation)
 }
 
 static VALUE
-ps_get_paper_size(VALUE self)
+rg_paper_size(VALUE self)
 {
     return GOBJ2RVAL(gtk_print_settings_get_paper_size(_SELF(self)));
 }
 
 static VALUE
-ps_set_paper_size(VALUE self, VALUE paper_size)
+rg_set_paper_size(VALUE self, VALUE paper_size)
 {
     gtk_print_settings_set_paper_size(_SELF(self), 
                                       RVAL2BOXED(paper_size, GTK_TYPE_PAPER_SIZE));
@@ -316,14 +326,14 @@ ps_set_paper_size(VALUE self, VALUE paper_size)
 }
 
 static VALUE
-ps_get_paper_width(VALUE self, VALUE unit)
+rg_paper_width(VALUE self, VALUE unit)
 {
     return rb_float_new(gtk_print_settings_get_paper_width(_SELF(self),
                                                            RVAL2UNIT(unit)));
 }
 
 static VALUE
-ps_set_paper_width(VALUE self, VALUE paper_width, VALUE unit)
+rg_set_paper_width(VALUE self, VALUE paper_width, VALUE unit)
 {
     gtk_print_settings_set_paper_width(_SELF(self), NUM2DBL(paper_width),
                                        RVAL2UNIT(unit));
@@ -331,14 +341,14 @@ ps_set_paper_width(VALUE self, VALUE paper_width, VALUE unit)
 }
 
 static VALUE
-ps_get_paper_height(VALUE self, VALUE unit)
+rg_paper_height(VALUE self, VALUE unit)
 {
     return rb_float_new(gtk_print_settings_get_paper_height(_SELF(self),
                                                             RVAL2UNIT(unit)));
 }
 
 static VALUE
-ps_set_paper_height(VALUE self, VALUE paper_height, VALUE unit)
+rg_set_paper_height(VALUE self, VALUE paper_height, VALUE unit)
 {
     gtk_print_settings_set_paper_height(_SELF(self), NUM2DBL(paper_height),
                                         RVAL2UNIT(unit));
@@ -346,53 +356,53 @@ ps_set_paper_height(VALUE self, VALUE paper_height, VALUE unit)
 }
 
 static VALUE
-ps_get_use_color(VALUE self)
+rg_use_color_p(VALUE self)
 {
     return CBOOL2RVAL(gtk_print_settings_get_use_color(_SELF(self)));
 }
 
 static VALUE
-ps_set_use_color(VALUE self, VALUE use_color)
+rg_set_use_color(VALUE self, VALUE use_color)
 {
     gtk_print_settings_set_use_color(_SELF(self), RVAL2CBOOL(use_color));
     return self;
 }
 
 static VALUE
-ps_get_collate(VALUE self)
+rg_collate_p(VALUE self)
 {
     return CBOOL2RVAL(gtk_print_settings_get_collate(_SELF(self)));
 }
 
 static VALUE
-ps_set_collate(VALUE self, VALUE collate)
+rg_set_collate(VALUE self, VALUE collate)
 {
     gtk_print_settings_set_collate(_SELF(self), RVAL2CBOOL(collate));
     return self;
 }
 
 static VALUE
-ps_get_reverse(VALUE self)
+rg_reverse_p(VALUE self)
 {
     return CBOOL2RVAL(gtk_print_settings_get_reverse(_SELF(self)));
 }
 
 static VALUE
-ps_set_reverse(VALUE self, VALUE reverse)
+rg_set_reverse(VALUE self, VALUE reverse)
 {
     gtk_print_settings_set_reverse(_SELF(self), RVAL2CBOOL(reverse));
     return self;
 }
 
 static VALUE
-ps_get_duplex(VALUE self)
+rg_duplex(VALUE self)
 {
     return GENUM2RVAL(gtk_print_settings_get_duplex(_SELF(self)), 
                       GTK_TYPE_PRINT_DUPLEX);
 }
 
 static VALUE
-ps_set_duplex(VALUE self, VALUE duplex)
+rg_set_duplex(VALUE self, VALUE duplex)
 {
     gtk_print_settings_set_duplex(_SELF(self), 
                                   RVAL2GENUM(duplex, GTK_TYPE_PRINT_DUPLEX));
@@ -400,14 +410,14 @@ ps_set_duplex(VALUE self, VALUE duplex)
 }
 
 static VALUE
-ps_get_quality(VALUE self)
+rg_quality(VALUE self)
 {
     return GENUM2RVAL(gtk_print_settings_get_quality(_SELF(self)), 
                       GTK_TYPE_PRINT_QUALITY);
 }
 
 static VALUE
-ps_set_quality(VALUE self, VALUE quality)
+rg_set_quality(VALUE self, VALUE quality)
 {
     gtk_print_settings_set_quality(_SELF(self), 
                                    RVAL2GENUM(quality, GTK_TYPE_PRINT_QUALITY));
@@ -415,73 +425,73 @@ ps_set_quality(VALUE self, VALUE quality)
 }
 
 static VALUE
-ps_get_n_copies(VALUE self)
+rg_n_copies(VALUE self)
 {
     return INT2NUM(gtk_print_settings_get_n_copies(_SELF(self)));
 }
 
 static VALUE
-ps_set_n_copies(VALUE self, VALUE n_copies)
+rg_set_n_copies(VALUE self, VALUE n_copies)
 {
     gtk_print_settings_set_n_copies(_SELF(self), NUM2INT(n_copies));
     return self;
 }
 
 static VALUE
-ps_get_number_up(VALUE self)
+rg_number_up(VALUE self)
 {
     return INT2NUM(gtk_print_settings_get_number_up(_SELF(self)));
 }
 
 static VALUE
-ps_set_number_up(VALUE self, VALUE number_up)
+rg_set_number_up(VALUE self, VALUE number_up)
 {
     gtk_print_settings_set_number_up(_SELF(self), NUM2INT(number_up));
     return self;
 }
 
 static VALUE
-ps_get_resolution(VALUE self)
+rg_resolution(VALUE self)
 {
     return INT2NUM(gtk_print_settings_get_resolution(_SELF(self)));
 }
 
 static VALUE
-ps_set_resolution(VALUE self, VALUE resolution)
+rg_set_resolution(VALUE self, VALUE resolution)
 {
     gtk_print_settings_set_resolution(_SELF(self), NUM2INT(resolution));
     return self;
 }
 
 static VALUE
-ps_get_scale(VALUE self)
+rg_scale(VALUE self)
 {
     return rb_float_new(gtk_print_settings_get_scale(_SELF(self)));
 }
 
 static VALUE
-ps_set_scale(VALUE self, VALUE scale)
+rg_set_scale(VALUE self, VALUE scale)
 {
     gtk_print_settings_set_scale(_SELF(self), NUM2DBL(scale));
     return self;
 }
 
 static VALUE
-ps_get_print_pages(VALUE self)
+rg_print_pages(VALUE self)
 {
     return GENUM2RVAL(gtk_print_settings_get_print_pages(_SELF(self)), 
                       GTK_TYPE_PRINT_PAGES);
 }
 
 static VALUE
-ps_set_print_pages(VALUE self, VALUE print_pages)
+rg_set_print_pages(VALUE self, VALUE print_pages)
 {
     gtk_print_settings_set_print_pages(_SELF(self), RVAL2GENUM(print_pages, GTK_TYPE_PRINT_PAGES));
     return self;
 }
 
 static VALUE
-ps_get_page_ranges(VALUE self)
+rg_page_ranges(VALUE self)
 {
     VALUE rb_ranges;
     GtkPageRange *ranges;
@@ -500,33 +510,82 @@ ps_get_page_ranges(VALUE self)
     return rb_ranges;
 }
 
+struct rbgtk_rval2gtkpageranges_args {
+    VALUE ary;
+    long n;
+    GtkPageRange *result;
+};
+
 static VALUE
-ps_set_page_ranges(VALUE self, VALUE rb_page_ranges)
+rbgtk_rval2gtkpageranges_body(VALUE value)
 {
-    GtkPageRange *page_ranges;
-    gint i, num_ranges;
+    long i;
+    struct rbgtk_rval2gtkpageranges_args *args = (struct rbgtk_rval2gtkpageranges_args *)value;
 
-    num_ranges = RARRAY_LEN(rb_page_ranges);
-    page_ranges = ALLOCA_N(GtkPageRange, num_ranges);
-    for (i = 0; i < num_ranges; i++) {
-        VALUE page_range;
-        page_range = RARRAY_PTR(rb_page_ranges)[i];
-        page_ranges[i].start = NUM2INT(RARRAY_PTR(page_range)[0]);
-        page_ranges[i].end = NUM2INT(RARRAY_PTR(page_range)[1]);
+    for (i = 0; i < args->n; i++) {
+        VALUE ary = rb_ary_to_ary(RARRAY_PTR(args->ary)[i]);
+
+        if (RARRAY_LEN(ary) != 2)
+            rb_raise(rb_eArgError, "range %ld should be array of size 2", i);
+
+        args->result[i].start = NUM2INT(RARRAY_PTR(ary)[0]);
+        args->result[i].end = NUM2INT(RARRAY_PTR(ary)[1]);
     }
-    gtk_print_settings_set_page_ranges(_SELF(self), page_ranges, num_ranges);
+
+    return Qnil;
+}
+
+static G_GNUC_NORETURN VALUE
+rbgtk_rval2gtkpageranges_rescue(VALUE value)
+{
+    g_free(((struct rbgtk_rval2gtkpageranges_args *)value)->result);
+
+    rb_exc_raise(rb_errinfo());
+}
+
+static GtkPageRange *
+rbgtk_rval2gtkpageranges(VALUE value, long *n)
+{
+    struct rbgtk_rval2gtkpageranges_args args;
+
+    args.ary = rb_ary_to_ary(value);
+    args.n = RARRAY_LEN(args.ary);
+    args.result = g_new(GtkPageRange, args.n + 1);
+
+    rb_rescue(rbgtk_rval2gtkpageranges_body, (VALUE)&args,
+              rbgtk_rval2gtkpageranges_rescue, (VALUE)&args);
+
+    if (n != NULL)
+        *n = args.n;
+
+    return args.result;
+}
+
+#define RVAL2GTKPAGERANGES(value, n) rbgtk_rval2gtkpageranges(value, n)
+
+static VALUE
+rg_set_page_ranges(VALUE self, VALUE rbpage_ranges)
+{
+    GtkPrintSettings *settings = _SELF(self);
+    long n;
+    GtkPageRange *page_ranges = RVAL2GTKPAGERANGES(rbpage_ranges, &n);
+
+    gtk_print_settings_set_page_ranges(settings, page_ranges, n);
+
+    g_free(page_ranges);
+
     return self;
 }
 
 static VALUE
-ps_get_page_set(VALUE self)
+rg_page_set(VALUE self)
 {
     return GENUM2RVAL(gtk_print_settings_get_page_set(_SELF(self)), 
                       GTK_TYPE_PAGE_SET);
 }
 
 static VALUE
-ps_set_page_set(VALUE self, VALUE page_set)
+rg_set_page_set(VALUE self, VALUE page_set)
 {
     gtk_print_settings_set_page_set(_SELF(self), 
                                     RVAL2GENUM(page_set, GTK_TYPE_PAGE_SET));
@@ -534,13 +593,13 @@ ps_set_page_set(VALUE self, VALUE page_set)
 }
 
 static VALUE
-ps_get_default_source(VALUE self)
+rg_default_source(VALUE self)
 {
     return CSTR2RVAL(gtk_print_settings_get_default_source(_SELF(self)));
 }
 
 static VALUE
-ps_set_default_source(VALUE self, VALUE default_source)
+rg_set_default_source(VALUE self, VALUE default_source)
 {
     gtk_print_settings_set_default_source(_SELF(self),
                                           RVAL2CSTR_ACCEPT_NIL(default_source));
@@ -548,52 +607,52 @@ ps_set_default_source(VALUE self, VALUE default_source)
 }
 
 static VALUE
-ps_get_media_type(VALUE self)
+rg_media_type(VALUE self)
 {
     return CSTR2RVAL(gtk_print_settings_get_media_type(_SELF(self)));
 }
 
 static VALUE
-ps_set_media_type(VALUE self, VALUE media_type)
+rg_set_media_type(VALUE self, VALUE media_type)
 {
     gtk_print_settings_set_media_type(_SELF(self), RVAL2CSTR_ACCEPT_NIL(media_type));
     return self;
 }
 
 static VALUE
-ps_get_dither(VALUE self)
+rg_dither(VALUE self)
 {
     return CSTR2RVAL(gtk_print_settings_get_dither(_SELF(self)));
 }
 
 static VALUE
-ps_set_dither(VALUE self, VALUE dither)
+rg_set_dither(VALUE self, VALUE dither)
 {
     gtk_print_settings_set_dither(_SELF(self), RVAL2CSTR_ACCEPT_NIL(dither));
     return self;
 }
 
 static VALUE
-ps_get_finishings(VALUE self)
+rg_finishings(VALUE self)
 {
     return CSTR2RVAL(gtk_print_settings_get_finishings(_SELF(self)));
 }
 
 static VALUE
-ps_set_finishings(VALUE self, VALUE finishings)
+rg_set_finishings(VALUE self, VALUE finishings)
 {
     gtk_print_settings_set_finishings(_SELF(self), RVAL2CSTR_ACCEPT_NIL(finishings));
     return self;
 }
 
 static VALUE
-ps_get_output_bin(VALUE self)
+rg_output_bin(VALUE self)
 {
     return CSTR2RVAL(gtk_print_settings_get_output_bin(_SELF(self)));
 }
 
 static VALUE
-ps_set_output_bin(VALUE self, VALUE output_bin)
+rg_set_output_bin(VALUE self, VALUE output_bin)
 {
     gtk_print_settings_set_output_bin(_SELF(self), RVAL2CSTR_ACCEPT_NIL(output_bin));
     return self;
@@ -602,7 +661,7 @@ ps_set_output_bin(VALUE self, VALUE output_bin)
 
 #if GTK_CHECK_VERSION(2,12,0)
 static VALUE
-ps_to_file(VALUE self, VALUE file_name)
+rg_to_file(VALUE self, VALUE file_name)
 {
     GError *error = NULL;
     if (!gtk_print_settings_to_file(_SELF(self), RVAL2CSTR(file_name), &error)) {
@@ -611,7 +670,7 @@ ps_to_file(VALUE self, VALUE file_name)
     return self;
 }
 static VALUE
-ps_to_key_file(int argc, VALUE *argv, VALUE self)
+rg_to_key_file(int argc, VALUE *argv, VALUE self)
 {
     VALUE key_file, group_name;
     rb_scan_args(argc, argv, "11", &key_file, &group_name);
@@ -623,10 +682,10 @@ ps_to_key_file(int argc, VALUE *argv, VALUE self)
 #endif
 
 void
-Init_gtk_print_settings()
+Init_gtk_print_settings(VALUE mGtk)
 {
 #if GTK_CHECK_VERSION(2,10,0)
-    VALUE gPrintSettings;
+    VALUE RG_TARGET_NAMESPACE;
 
     s_string = ID2SYM(rb_intern("string"));
     s_bool = ID2SYM(rb_intern("bool"));
@@ -634,158 +693,155 @@ Init_gtk_print_settings()
     s_length = ID2SYM(rb_intern("length"));
     s_int = ID2SYM(rb_intern("int"));
 
-    gPrintSettings = G_DEF_CLASS(GTK_TYPE_PRINT_SETTINGS,
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_PRINT_SETTINGS,
                                  "PrintSettings", mGtk);
 
-    rb_include_module(gPrintSettings, rb_mEnumerable);
+    rb_include_module(RG_TARGET_NAMESPACE, rb_mEnumerable);
 
 #if GTK_CHECK_VERSION(2,12,0)
-    rb_define_method(gPrintSettings, "initialize", ps_initialize, -1);
+    RG_DEF_METHOD(initialize, -1);
 #else
-    rb_define_method(gPrintSettings, "initialize", ps_initialize, 0);
+    RG_DEF_METHOD(initialize, 0);
 #endif
-    rb_define_method(gPrintSettings, "dup", ps_copy, 0);
-    rb_define_method(gPrintSettings, "has_key?", ps_has_key, 1);
+    RG_DEF_METHOD(dup, 0);
+    RG_DEF_METHOD_P(has_key, 1);
 
-    rb_define_method(gPrintSettings, "get", ps_get_generic, -1);
-    rb_define_alias(gPrintSettings, "[]", "get");
-    rb_define_method(gPrintSettings, "get_bool", ps_get_bool, 1);
-    rb_define_method(gPrintSettings, "get_double", ps_get_double, -1);
-    rb_define_method(gPrintSettings, "get_length", ps_get_length, 2);
-    rb_define_method(gPrintSettings, "get_int", ps_get_int, -1);
+    RG_DEF_METHOD(get, -1);
+    RG_DEF_ALIAS("[]", "get");
+    RG_DEF_METHOD(get_bool, 1);
+    RG_DEF_METHOD(get_double, -1);
+    RG_DEF_METHOD(get_length, 2);
+    RG_DEF_METHOD(get_int, -1);
 
-    rb_define_method(gPrintSettings, "set", ps_set_generic, -1);
-    rb_define_method(gPrintSettings, "[]=", ps_set_generic_indexer, -1);
+    RG_DEF_METHOD(set, -1);
+    RG_DEF_METHOD_OPERATOR("[]=", ps_set_generic_indexer, -1);
 
-    rb_define_method(gPrintSettings, "unset", ps_unset, -1);
-    rb_define_alias(gPrintSettings, "delete", "unset");
+    RG_DEF_METHOD(unset, -1);
+    RG_DEF_ALIAS("delete", "unset");
 
-    rb_define_method(gPrintSettings, "each", ps_foreach, 0);
+    RG_DEF_METHOD(each, 0);
 
-    rb_define_const(gPrintSettings, "PRINTER",
+    rb_define_const(RG_TARGET_NAMESPACE, "PRINTER",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_PRINTER));
-    rb_define_const(gPrintSettings, "ORIENTATION",
+    rb_define_const(RG_TARGET_NAMESPACE, "ORIENTATION",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_ORIENTATION));
-    rb_define_const(gPrintSettings, "PAPER_FORMAT",
+    rb_define_const(RG_TARGET_NAMESPACE, "PAPER_FORMAT",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_PAPER_FORMAT));
-    rb_define_const(gPrintSettings, "PAPER_WIDTH",
+    rb_define_const(RG_TARGET_NAMESPACE, "PAPER_WIDTH",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_PAPER_WIDTH));
-    rb_define_const(gPrintSettings, "PAPER_HEIGHT",
+    rb_define_const(RG_TARGET_NAMESPACE, "PAPER_HEIGHT",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_PAPER_HEIGHT));
-    rb_define_const(gPrintSettings, "N_COPIES",
+    rb_define_const(RG_TARGET_NAMESPACE, "N_COPIES",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_N_COPIES));
-    rb_define_const(gPrintSettings, "DEFAULT_SOURCE",
+    rb_define_const(RG_TARGET_NAMESPACE, "DEFAULT_SOURCE",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_DEFAULT_SOURCE));
-    rb_define_const(gPrintSettings, "QUALITY",
+    rb_define_const(RG_TARGET_NAMESPACE, "QUALITY",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_QUALITY));
-    rb_define_const(gPrintSettings, "RESOLUTION",
+    rb_define_const(RG_TARGET_NAMESPACE, "RESOLUTION",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_RESOLUTION));
-    rb_define_const(gPrintSettings, "USE_COLOR",
+    rb_define_const(RG_TARGET_NAMESPACE, "USE_COLOR",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_USE_COLOR));
-    rb_define_const(gPrintSettings, "DUPLEX",
+    rb_define_const(RG_TARGET_NAMESPACE, "DUPLEX",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_DUPLEX));
-    rb_define_const(gPrintSettings, "COLLATE",
+    rb_define_const(RG_TARGET_NAMESPACE, "COLLATE",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_COLLATE));
-    rb_define_const(gPrintSettings, "REVERSE",
+    rb_define_const(RG_TARGET_NAMESPACE, "REVERSE",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_REVERSE));
-    rb_define_const(gPrintSettings, "MEDIA_TYPE",
+    rb_define_const(RG_TARGET_NAMESPACE, "MEDIA_TYPE",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_MEDIA_TYPE));
-    rb_define_const(gPrintSettings, "DITHER",
+    rb_define_const(RG_TARGET_NAMESPACE, "DITHER",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_DITHER));
-    rb_define_const(gPrintSettings, "SCALE",
+    rb_define_const(RG_TARGET_NAMESPACE, "SCALE",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_SCALE));
-    rb_define_const(gPrintSettings, "PRINT_PAGES",
+    rb_define_const(RG_TARGET_NAMESPACE, "PRINT_PAGES",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_PRINT_PAGES));
-    rb_define_const(gPrintSettings, "PAGE_RANGES",
+    rb_define_const(RG_TARGET_NAMESPACE, "PAGE_RANGES",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_PAGE_RANGES));
-    rb_define_const(gPrintSettings, "PAGE_SET",
+    rb_define_const(RG_TARGET_NAMESPACE, "PAGE_SET",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_PAGE_SET));
-    rb_define_const(gPrintSettings, "FINISHINGS",
+    rb_define_const(RG_TARGET_NAMESPACE, "FINISHINGS",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_FINISHINGS));
-    rb_define_const(gPrintSettings, "NUMBER_UP",
+    rb_define_const(RG_TARGET_NAMESPACE, "NUMBER_UP",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_NUMBER_UP));
-    rb_define_const(gPrintSettings, "OUTPUT_BIN",
+    rb_define_const(RG_TARGET_NAMESPACE, "OUTPUT_BIN",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_OUTPUT_BIN));
 
-    rb_define_const(gPrintSettings, "OUTPUT_FILE_FORMAT",
+    rb_define_const(RG_TARGET_NAMESPACE, "OUTPUT_FILE_FORMAT",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT));
-    rb_define_const(gPrintSettings, "OUTPUT_URI",
+    rb_define_const(RG_TARGET_NAMESPACE, "OUTPUT_URI",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_OUTPUT_URI));
 
-    rb_define_const(gPrintSettings, "WIN32_DRIVER_VERSION",
+    rb_define_const(RG_TARGET_NAMESPACE, "WIN32_DRIVER_VERSION",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_WIN32_DRIVER_VERSION));
-    rb_define_const(gPrintSettings, "WIN32_DRIVER_EXTRA",
+    rb_define_const(RG_TARGET_NAMESPACE, "WIN32_DRIVER_EXTRA",
                     CSTR2RVAL(GTK_PRINT_SETTINGS_WIN32_DRIVER_EXTRA));
 
     /* Helpers: */
-    rb_define_method(gPrintSettings, "printer", ps_get_printer, 0);
-    rb_define_method(gPrintSettings, "set_printer", ps_set_printer, 1);
-    rb_define_method(gPrintSettings, "orientation", ps_get_orientation, 0);
-    rb_define_method(gPrintSettings, "set_orientation", ps_set_orientation, 1);
-    rb_define_method(gPrintSettings, "paper_size", ps_get_paper_size, 0);
-    rb_define_method(gPrintSettings, "set_paper_size", ps_set_paper_size, 1);
-    rb_define_method(gPrintSettings, "paper_width", ps_get_paper_width, 1);
-    rb_define_method(gPrintSettings, "set_paper_width", ps_set_paper_width, 2);
-    rb_define_method(gPrintSettings, "paper_height", ps_get_paper_height, 1);
-    rb_define_method(gPrintSettings, "set_paper_height",
-                     ps_set_paper_height, 2);
-    rb_define_method(gPrintSettings, "use_color?", ps_get_use_color, 0);
-    rb_define_method(gPrintSettings, "set_use_color", ps_set_use_color, 1);
-    rb_define_method(gPrintSettings, "collate?", ps_get_collate, 0);
-    rb_define_method(gPrintSettings, "set_collate", ps_set_collate, 1);
-    rb_define_method(gPrintSettings, "reverse?", ps_get_reverse, 0);
-    rb_define_method(gPrintSettings, "set_reverse", ps_set_reverse, 1);
-    rb_define_method(gPrintSettings, "duplex", ps_get_duplex, 0);
-    rb_define_method(gPrintSettings, "set_duplex", ps_set_duplex, 1);
-    rb_define_method(gPrintSettings, "quality", ps_get_quality, 0);
-    rb_define_method(gPrintSettings, "set_quality", ps_set_quality, 1);
-    rb_define_method(gPrintSettings, "n_copies", ps_get_n_copies, 0);
-    rb_define_method(gPrintSettings, "set_n_copies", ps_set_n_copies, 1);
-    rb_define_method(gPrintSettings, "number_up", ps_get_number_up, 0);
-    rb_define_method(gPrintSettings, "set_number_up", ps_set_number_up, 1);
-    rb_define_method(gPrintSettings, "resolution", ps_get_resolution, 0);
-    rb_define_method(gPrintSettings, "set_resolution", ps_set_resolution, 1);
-    rb_define_method(gPrintSettings, "scale", ps_get_scale, 0);
-    rb_define_method(gPrintSettings, "set_scale", ps_set_scale, 1);
-    rb_define_method(gPrintSettings, "print_pages", ps_get_print_pages, 0);
-    rb_define_method(gPrintSettings, "set_print_pages", ps_set_print_pages, 1);
-    rb_define_method(gPrintSettings, "page_ranges", ps_get_page_ranges, 0);
-    rb_define_method(gPrintSettings, "set_page_ranges", ps_set_page_ranges, 1);
-    rb_define_method(gPrintSettings, "page_set", ps_get_page_set, 0);
-    rb_define_method(gPrintSettings, "set_page_set", ps_set_page_set, 1);
-    rb_define_method(gPrintSettings, "default_source",
-                     ps_get_default_source, 0);
-    rb_define_method(gPrintSettings, "set_default_source",
-                     ps_set_default_source, 1);
-    rb_define_method(gPrintSettings, "media_type", ps_get_media_type, 0);
-    rb_define_method(gPrintSettings, "set_media_type", ps_set_media_type, 1);
-    rb_define_method(gPrintSettings, "dither", ps_get_dither, 0);
-    rb_define_method(gPrintSettings, "set_dither", ps_set_dither, 1);
-    rb_define_method(gPrintSettings, "finishings", ps_get_finishings, 0);
-    rb_define_method(gPrintSettings, "set_finishings", ps_set_finishings, 1);
-    rb_define_method(gPrintSettings, "output_bin", ps_get_output_bin, 0);
-    rb_define_method(gPrintSettings, "set_output_bin", ps_set_output_bin, 1);
-
-    G_DEF_SETTERS(gPrintSettings);
+    RG_DEF_METHOD(printer, 0);
+    RG_DEF_METHOD(set_printer, 1);
+    RG_DEF_METHOD(orientation, 0);
+    RG_DEF_METHOD(set_orientation, 1);
+    RG_DEF_METHOD(paper_size, 0);
+    RG_DEF_METHOD(set_paper_size, 1);
+    RG_DEF_METHOD(paper_width, 1);
+    RG_DEF_METHOD(set_paper_width, 2);
+    RG_DEF_METHOD(paper_height, 1);
+    RG_DEF_METHOD(set_paper_height, 2);
+    RG_DEF_METHOD_P(use_color, 0);
+    RG_DEF_METHOD(set_use_color, 1);
+    RG_DEF_METHOD_P(collate, 0);
+    RG_DEF_METHOD(set_collate, 1);
+    RG_DEF_METHOD_P(reverse, 0);
+    RG_DEF_METHOD(set_reverse, 1);
+    RG_DEF_METHOD(duplex, 0);
+    RG_DEF_METHOD(set_duplex, 1);
+    RG_DEF_METHOD(quality, 0);
+    RG_DEF_METHOD(set_quality, 1);
+    RG_DEF_METHOD(n_copies, 0);
+    RG_DEF_METHOD(set_n_copies, 1);
+    RG_DEF_METHOD(number_up, 0);
+    RG_DEF_METHOD(set_number_up, 1);
+    RG_DEF_METHOD(resolution, 0);
+    RG_DEF_METHOD(set_resolution, 1);
+    RG_DEF_METHOD(scale, 0);
+    RG_DEF_METHOD(set_scale, 1);
+    RG_DEF_METHOD(print_pages, 0);
+    RG_DEF_METHOD(set_print_pages, 1);
+    RG_DEF_METHOD(page_ranges, 0);
+    RG_DEF_METHOD(set_page_ranges, 1);
+    RG_DEF_METHOD(page_set, 0);
+    RG_DEF_METHOD(set_page_set, 1);
+    RG_DEF_METHOD(default_source, 0);
+    RG_DEF_METHOD(set_default_source, 1);
+    RG_DEF_METHOD(media_type, 0);
+    RG_DEF_METHOD(set_media_type, 1);
+    RG_DEF_METHOD(dither, 0);
+    RG_DEF_METHOD(set_dither, 1);
+    RG_DEF_METHOD(finishings, 0);
+    RG_DEF_METHOD(set_finishings, 1);
+    RG_DEF_METHOD(output_bin, 0);
+    RG_DEF_METHOD(set_output_bin, 1);
+
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
 
     /* GtkPageOrientation */
-    G_DEF_CLASS(GTK_TYPE_PAGE_ORIENTATION, "PageOrientation", gPrintSettings);
-    G_DEF_CONSTANTS(gPrintSettings, GTK_TYPE_PAGE_ORIENTATION, "GTK_PAGE_");
+    G_DEF_CLASS(GTK_TYPE_PAGE_ORIENTATION, "PageOrientation", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_PAGE_ORIENTATION, "GTK_PAGE_");
     /* GtkPrintDuplex */
-    G_DEF_CLASS(GTK_TYPE_PRINT_DUPLEX, "PrintDuplex", gPrintSettings);
-    G_DEF_CONSTANTS(gPrintSettings, GTK_TYPE_PRINT_DUPLEX, "GTK_PRINT_");
+    G_DEF_CLASS(GTK_TYPE_PRINT_DUPLEX, "PrintDuplex", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_PRINT_DUPLEX, "GTK_PRINT_");
     /* GtkPrintQuality */
-    G_DEF_CLASS(GTK_TYPE_PRINT_QUALITY, "PrintQuality", gPrintSettings);
-    G_DEF_CONSTANTS(gPrintSettings, GTK_TYPE_PRINT_QUALITY, "GTK_PRINT_");
+    G_DEF_CLASS(GTK_TYPE_PRINT_QUALITY, "PrintQuality", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_PRINT_QUALITY, "GTK_PRINT_");
     /* GtkPrintPages */
-    G_DEF_CLASS(GTK_TYPE_PRINT_PAGES, "PrintPages", gPrintSettings);
-    G_DEF_CONSTANTS(gPrintSettings, GTK_TYPE_PRINT_PAGES, "GTK_PRINT_");
+    G_DEF_CLASS(GTK_TYPE_PRINT_PAGES, "PrintPages", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_PRINT_PAGES, "GTK_PRINT_");
     /* GtkPageSet */
-    G_DEF_CLASS(GTK_TYPE_PAGE_SET, "PageSet", gPrintSettings);
-    G_DEF_CONSTANTS(gPrintSettings, GTK_TYPE_PAGE_SET, "GTK_");
+    G_DEF_CLASS(GTK_TYPE_PAGE_SET, "PageSet", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GTK_TYPE_PAGE_SET, "GTK_");
 #endif
 #if GTK_CHECK_VERSION(2,12,0)
-    rb_define_method(gPrintSettings, "to_file", ps_to_file, 1);
-    rb_define_method(gPrintSettings, "to_key_file", ps_to_key_file, -1);
+    RG_DEF_METHOD(to_file, 1);
+    RG_DEF_METHOD(to_key_file, -1);
 #endif
 }