pango 1.0.3-x86-mingw32 → 1.1.0-x86-mingw32

data/ext/pango/rbpangogravity.c

@@ -1,43 +1,54 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
+/*
+ *  Copyright (C) 2011  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 "rbpangoprivate.h"
 
-  rbpangogravity.c -
-
-  $Author: ito $
-  $Date: 2010/01/17 03:00:50 $
-
-************************************************/
-
-#include "rbpango.h"
+#if PANGO_CHECK_VERSION(1,16,0)
 
+#define RG_TARGET_NAMESPACE mGravity
 
-#if PANGO_CHECK_VERSION(1,16,0)
 static VALUE
-to_rotation(VALUE self, VALUE gravity)
+rg_s_to_rotation(G_GNUC_UNUSED VALUE self, VALUE gravity)
 {
-    return rb_float_new(pango_gravity_to_rotation(RVAL2GENUM(gravity, PANGO_TYPE_GRAVITY)));
+    return rb_float_new(pango_gravity_to_rotation(RVAL2PANGOGRAVITY(gravity)));
 }
 
 static VALUE
-is_vertical(VALUE self, VALUE gravity)
+rg_s_vertical_p(G_GNUC_UNUSED VALUE self, VALUE gravity)
 {
-    return CBOOL2RVAL(PANGO_GRAVITY_IS_VERTICAL(RVAL2GENUM(gravity, PANGO_TYPE_GRAVITY)));
+    return CBOOL2RVAL(PANGO_GRAVITY_IS_VERTICAL(RVAL2PANGOGRAVITY(gravity)));
 }
 #endif
 
 void
-Init_pango_gravity()
+Init_pango_gravity(VALUE mPango)
 {
 #if PANGO_CHECK_VERSION(1,16,0)
-    VALUE mGravity = rb_define_module_under(mPango, "Gravity");
+    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mPango, "Gravity");
 
-    rb_define_singleton_method(mGravity, "to_rotation", to_rotation, 1);
-    rb_define_singleton_method(mGravity, "vertical?", is_vertical, 1);
+    RG_DEF_SMETHOD(to_rotation, 1);
+    RG_DEF_SMETHOD_P(vertical, 1);
 
-    G_DEF_CLASS(PANGO_TYPE_GRAVITY, "Gravity", mGravity);
-    G_DEF_CONSTANTS(mGravity, PANGO_TYPE_GRAVITY, "PANGO_GRAVITY_");
-    G_DEF_CLASS(PANGO_TYPE_GRAVITY_HINT, "Hint", mGravity);
-    G_DEF_CONSTANTS(mGravity, PANGO_TYPE_GRAVITY_HINT, "PANGO_GRAVITY_");
+    G_DEF_CLASS(PANGO_TYPE_GRAVITY, "Gravity", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, PANGO_TYPE_GRAVITY, "PANGO_GRAVITY_");
+    G_DEF_CLASS(PANGO_TYPE_GRAVITY_HINT, "Hint", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, PANGO_TYPE_GRAVITY_HINT, "PANGO_GRAVITY_");
 #endif
 }
-

data/ext/pango/rbpangoitem.c

@@ -1,17 +1,28 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbpangoitem.c -
-
-  $Author: mutoh $
-  $Date: 2005/09/17 18:30:05 $
-
-  Copyright (C) 2002-2005 Masao Mutoh
-************************************************/
-
-#include "rbpango.h"
-
-#define _SELF(self) ((PangoItem*)RVAL2BOXED(self, PANGO_TYPE_ITEM))
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2005 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 "rbpangoprivate.h"
+
+#define RG_TARGET_NAMESPACE cItem
+#define _SELF(self) (RVAL2PANGOITEM(self))
 
 #define ATTR_INT(name)\
 static VALUE \
@@ -27,8 +38,8 @@ item_int_set_ ## name (VALUE self, VALUE val)\
 }
 
 #define DEF_INT_ACCESSOR(name)                                  \
-    rb_define_method(pItem, G_STRINGIFY(name), item_int_ ## name, 0);\
-    rb_define_method(pItem, G_STRINGIFY(set_ ## name), item_int_set_ ## name, 1);
+    rb_define_method(RG_TARGET_NAMESPACE, G_STRINGIFY(name), item_int_ ## name, 0);\
+    rb_define_method(RG_TARGET_NAMESPACE, G_STRINGIFY(set_ ## name), item_int_set_ ## name, 1);
 
 /**********************************/
 #if ! PANGO_CHECK_VERSION(1,9,0)
@@ -47,19 +58,18 @@ pango_item_get_type(void)
 /**********************************/
 
 static VALUE
-item_initialize(VALUE self)
+rg_initialize(VALUE self)
 {
     G_INITIALIZE(self, pango_item_new());
     return Qnil;
 }
 
 static VALUE
-item_split(VALUE self, VALUE split_index, VALUE split_offset)
+rg_split(VALUE self, VALUE split_index, VALUE split_offset)
 {
-    return BOXED2RVAL(pango_item_split(_SELF(self), 
-                                       NUM2INT(split_index), 
-                                       NUM2INT(split_offset)), 
-                      PANGO_TYPE_ITEM);
+    return PANGOITEM2RVAL(pango_item_split(_SELF(self), 
+                                           NUM2INT(split_index), 
+                                           NUM2INT(split_offset)));
 }
 /* Move to Pango module (rbpangomain.c)
 GList*      pango_reorder_items             (GList *logical_items);
@@ -69,36 +79,35 @@ ATTR_INT(offset);
 ATTR_INT(length);
 ATTR_INT(num_chars);
 
-
 static VALUE
-item_get_analysis(VALUE self)
+rg_analysis(VALUE self)
 {
     PangoAnalysis ana = _SELF(self)->analysis;
-    return BOXED2RVAL(&ana, PANGO_TYPE_ANALYSIS);
+    return PANGOANALYSIS2RVAL(&ana);
 }
 
 static VALUE
-item_set_analysis(VALUE self, VALUE val)
+rg_set_analysis(VALUE self, VALUE val)
 {
-    PangoAnalysis* ana = (PangoAnalysis*)RVAL2BOXED(val, PANGO_TYPE_ANALYSIS);
+    PangoAnalysis* ana = RVAL2PANGOANALYSIS(val);
     _SELF(self)->analysis = *ana;
     return self;
 }
 
 void
-Init_pango_item()
+Init_pango_item(VALUE mPango)
 {
-    VALUE pItem = G_DEF_CLASS(PANGO_TYPE_ITEM, "Item", mPango);
-    
-    rb_define_method(pItem, "initialize", item_initialize, 0);
-    rb_define_method(pItem, "split", item_split, 2);
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(PANGO_TYPE_ITEM, "Item", mPango);
+
+    RG_DEF_METHOD(initialize, 0);
+    RG_DEF_METHOD(split, 2);
 
     DEF_INT_ACCESSOR(offset);
     DEF_INT_ACCESSOR(length);
     DEF_INT_ACCESSOR(num_chars);
 
-    rb_define_method(pItem, "analysis", item_get_analysis, 0);
-    rb_define_method(pItem, "set_analysis", item_set_analysis, 1);
+    RG_DEF_METHOD(analysis, 0);
+    RG_DEF_METHOD(set_analysis, 1);
 
-    G_DEF_SETTERS(pItem);
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
 }

data/ext/pango/rbpangolanguage.c

@@ -1,52 +1,62 @@
-/* -*- c-file-style: "ruby" -*- */
-/************************************************
-
-  rbpangolanguage.c -
-
-  $Author: mutoh $
-  $Date: 2005/09/17 17:09:13 $
-
-  Copyright (C) 2009 Ruby-GNOME2 Project Team
-  Copyright (C) 2002,2003 Masao Mutoh <mutoh@highway.ne.jp>
-************************************************/
-
-#include "rbpango.h"
-
-#define _SELF(self) ((PangoLanguage*)RVAL2BOXED(self, PANGO_TYPE_LANGUAGE))
-#define LANG2RVAL(lang) (BOXED2RVAL(lang, PANGO_TYPE_LANGUAGE))
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2009  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003 Masao Mutoh <mutoh@highway.ne.jp>
+ *
+ *  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 "rbpangoprivate.h"
+
+#define RG_TARGET_NAMESPACE cLanguage
+#define _SELF(self) (RVAL2PANGOLANGUAGE(self))
 
 static VALUE
-language_s_default(VALUE self)
+rg_s_default(G_GNUC_UNUSED VALUE self)
 {
-    return LANG2RVAL(pango_language_get_default());
+    return PANGOLANGUAGE2RVAL(pango_language_get_default());
 }
 
 static VALUE
-language_initialize(VALUE self, VALUE language)
+rg_initialize(VALUE self, VALUE language)
 {
     G_INITIALIZE(self, pango_language_from_string(RVAL2CSTR(language)));
     return Qnil;
 }
 
 static VALUE
-language_s_to_string(VALUE self, VALUE language)
+rg_s_to_string(G_GNUC_UNUSED VALUE self, VALUE language)
 {
     return CSTR2RVAL(pango_language_to_string(RVAL2CSTR(language)));
 }
 
 static VALUE
-language_matches(int argc, VALUE *argv, VALUE self)
+rg_matches(int argc, VALUE *argv, VALUE self)
 {
     VALUE range_list;
 
     rb_scan_args(argc, argv, "01", &range_list);
 
     return CBOOL2RVAL(pango_language_matches(_SELF(self), 
-                                             NIL_P(range_list) ? NULL : RVAL2CSTR(range_list)));
+                                             RVAL2CSTR_ACCEPT_NIL(range_list)));
 }
 
 static VALUE
-language_to_str(VALUE self)
+rg_to_str(VALUE self)
 {
     return CSTR2RVAL(pango_language_to_string(_SELF(self)));
 }
@@ -54,28 +64,28 @@ language_to_str(VALUE self)
 #if PANGO_CHECK_VERSION(1,4,0)
 /* Moved from Pango::Script */
 static VALUE
-language_includes_script(VALUE self, VALUE script)
+rg_includes_script(VALUE self, VALUE script)
 {
     return CBOOL2RVAL(pango_language_includes_script(_SELF(self), 
-                                                     RVAL2GENUM(script, PANGO_TYPE_SCRIPT)));
+                                                     RVAL2PANGOSCRIPT(script)));
 }
 #endif
 
 void
-Init_pango_language()
+Init_pango_language(VALUE mPango)
 {
-    VALUE pLanguage = G_DEF_CLASS(PANGO_TYPE_LANGUAGE, "Language", mPango);
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(PANGO_TYPE_LANGUAGE, "Language", mPango);
 
-    rb_define_singleton_method(pLanguage, "default", language_s_default, 0);
+    RG_DEF_SMETHOD(default, 0);
 
-    rb_define_method(pLanguage, "initialize", language_initialize, 1);
-    rb_define_singleton_method(pLanguage, "to_string", language_s_to_string, 1);
-    rb_define_method(pLanguage, "matches", language_matches, -1);
-    rb_define_method(pLanguage, "to_str", language_to_str, 0);
-    rb_define_alias(pLanguage, "to_s", "to_str");
+    RG_DEF_METHOD(initialize, 1);
+    RG_DEF_SMETHOD(to_string, 1);
+    RG_DEF_METHOD(matches, -1);
+    RG_DEF_METHOD(to_str, 0);
+    RG_DEF_ALIAS("to_s", "to_str");
 
 #if PANGO_CHECK_VERSION(1,4,0)
-    rb_define_method(pLanguage, "includes_script", language_includes_script, 1);
+    RG_DEF_METHOD(includes_script, 1);
 #endif
 
 }

data/ext/pango/rbpangolayout.c

@@ -1,47 +1,57 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbpangolayout.c -
-
-  $Author: ggc $
-  $Date: 2007/07/13 16:07:33 $
-
-  Copyright (C) 2002-2005 Masao Mutoh
-************************************************/
-
-#include "rbpango.h"
-
-#define _SELF(self) (PANGO_LAYOUT(RVAL2GOBJ(self)))
-#define RVAL2CONTEXT(v) (PANGO_CONTEXT(RVAL2GOBJ(v)))
-
-static VALUE
-layout_initialize(VALUE self, VALUE context)
-{
-    G_INITIALIZE(self, pango_layout_new(RVAL2CONTEXT(context)));
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2005 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 "rbpangoprivate.h"
+
+#define RG_TARGET_NAMESPACE cLayout
+#define _SELF(self) (RVAL2PANGOLAYOUT(self))
+
+static VALUE
+rg_initialize(VALUE self, VALUE context)
+{
+    G_INITIALIZE(self, pango_layout_new(RVAL2PANGOCONTEXT(context)));
     return Qnil;
 }
 
 static VALUE
-layout_copy(VALUE self)
+rg_copy(VALUE self)
 {
     return GOBJ2RVAL_UNREF(pango_layout_copy(_SELF(self)));
 }
 
 static VALUE
-layout_get_context(VALUE self)
+rg_context(VALUE self)
 {
     return GOBJ2RVAL(pango_layout_get_context(_SELF(self)));
 }
 
 static VALUE
-layout_context_changed(VALUE self)
+rg_context_changed(VALUE self)
 {
     pango_layout_context_changed(_SELF(self));
     return Qnil;
 }
 
 static VALUE
-layout_set_text(VALUE self, VALUE text)
+rg_set_text(VALUE self, VALUE text)
 {
     StringValue(text);
 
@@ -51,13 +61,13 @@ layout_set_text(VALUE self, VALUE text)
 }
 
 static VALUE
-layout_get_text(VALUE self)
+rg_text(VALUE self)
 {
     return CSTR2RVAL(pango_layout_get_text(_SELF(self)));
 }
 
 static VALUE
-layout_set_markup(int argc, VALUE *argv, VALUE self)
+rg_set_markup(int argc, VALUE *argv, VALUE self)
 {
     VALUE markup, accel_marker;
     gunichar accel_char = 0;
@@ -80,7 +90,7 @@ layout_set_markup(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-layout_set_markup_eq(VALUE self, VALUE markup)
+rg_operator_layout_set_markup_eq(VALUE self, VALUE markup)
 {
     StringValue(markup);
 
@@ -90,191 +100,190 @@ layout_set_markup_eq(VALUE self, VALUE markup)
 }
 
 static VALUE
-layout_set_attributes(VALUE self, VALUE attrs)
+rg_set_attributes(VALUE self, VALUE attrs)
 {
     pango_layout_set_attributes(_SELF(self), 
-                                (PangoAttrList*)(RVAL2BOXED(attrs, PANGO_TYPE_ATTR_LIST)));
+                                RVAL2PANGOATTRLIST(attrs));
     return self;
 }
 
 static VALUE
-layout_get_attributes(VALUE self)
+rg_attributes(VALUE self)
 {
-    return BOXED2RVAL(pango_layout_get_attributes(_SELF(self)), PANGO_TYPE_ATTR_LIST);
+    return PANGOATTRLIST2RVAL(pango_layout_get_attributes(_SELF(self)));
 }
 
 static VALUE
-layout_set_font_description(VALUE self, VALUE rb_desc)
+rg_set_font_description(VALUE self, VALUE rb_desc)
 {
     PangoFontDescription *desc;
     gboolean desc_created = FALSE;
 
     if (RVAL2CBOOL(rb_obj_is_kind_of(rb_desc, rb_cString))) {
-	desc = pango_font_description_from_string(RVAL2CSTR(rb_desc));
-	desc_created = TRUE;
+        desc = pango_font_description_from_string(RVAL2CSTR(rb_desc));
+        desc_created = TRUE;
     } else {
-	desc = RVAL2BOXED(rb_desc, PANGO_TYPE_FONT_DESCRIPTION);
+        desc = RVAL2PANGOFONTDESCRIPTION(rb_desc);
     }
 
     pango_layout_set_font_description(_SELF(self), desc);
 
     if (desc_created)
-	pango_font_description_free(desc);
+        pango_font_description_free(desc);
 
     return self;
 }
 
 #ifdef HAVE_PANGO_LAYOUT_GET_FONT_DESCRIPTION
 static VALUE
-layout_get_font_description(VALUE self)
+rg_font_description(VALUE self)
 {
     const PangoFontDescription* desc = pango_layout_get_font_description(_SELF(self));
-    return BOXED2RVAL((gpointer)desc, PANGO_TYPE_FONT_DESCRIPTION);
+    return PANGOFONTDESCRIPTION2RVAL((gpointer)desc);
 }
 #endif
 
 static VALUE
-layout_set_width(VALUE self, VALUE width)
+rg_set_width(VALUE self, VALUE width)
 {
     pango_layout_set_width(_SELF(self), NUM2INT(width));
     return self;
 }
 
 static VALUE
-layout_get_width(VALUE self)
+rg_width(VALUE self)
 {
     return INT2NUM(pango_layout_get_width(_SELF(self)));
 }
 
 static VALUE
-layout_set_wrap(VALUE self, VALUE wrap)
+rg_set_wrap(VALUE self, VALUE wrap)
 {
-    pango_layout_set_wrap(_SELF(self), RVAL2GENUM(wrap, PANGO_TYPE_WRAP_MODE));
+    pango_layout_set_wrap(_SELF(self), RVAL2PANGOWRAPMODE(wrap));
     return self;
 }
 
 static VALUE
-layout_get_wrap(VALUE self)
+rg_wrap(VALUE self)
 {
-    return GENUM2RVAL(pango_layout_get_wrap(_SELF(self)), PANGO_TYPE_WRAP_MODE);
+    return PANGOWRAPMODE2RVAL(pango_layout_get_wrap(_SELF(self)));
 }
 
 #ifdef HAVE_PANGO_LAYOUT_SET_ELLIPSIZE
 static VALUE
-layout_set_ellipsize(VALUE self, VALUE ellipsize)
+rg_set_ellipsize(VALUE self, VALUE ellipsize)
 {
-    pango_layout_set_ellipsize(_SELF(self), RVAL2GENUM(ellipsize, 
-                                                       PANGO_TYPE_ELLIPSIZE_MODE));
+    pango_layout_set_ellipsize(_SELF(self), RVAL2PANGOELLIPSIZEMODE(ellipsize));
     return self;
 }
 static VALUE
-layout_get_ellipsize(VALUE self)
+rg_ellipsize(VALUE self)
 {
-    return GENUM2RVAL(pango_layout_get_ellipsize(_SELF(self)), PANGO_TYPE_ELLIPSIZE_MODE);
+    return PANGOELLIPSIZEMODE2RVAL(pango_layout_get_ellipsize(_SELF(self)));
 }
 #endif
 
 static VALUE
-layout_set_indent(VALUE self, VALUE indent)
+rg_set_indent(VALUE self, VALUE indent)
 {
     pango_layout_set_indent(_SELF(self), NUM2INT(indent));
     return self;
 }
 
 static VALUE
-layout_get_indent(VALUE self)
+rg_indent(VALUE self)
 {
     return INT2NUM(pango_layout_get_indent(_SELF(self)));
 }
 
 static VALUE
-layout_get_spacing(VALUE self)
+rg_spacing(VALUE self)
 {
     return INT2NUM(pango_layout_get_spacing(_SELF(self)));
 }
 
 static VALUE
-layout_set_spacing(VALUE self, VALUE spacing)
+rg_set_spacing(VALUE self, VALUE spacing)
 {
     pango_layout_set_spacing(_SELF(self), NUM2INT(spacing));
     return self;
 }
 
 static VALUE
-layout_set_justify(VALUE self, VALUE justify)
+rg_set_justify(VALUE self, VALUE justify)
 {
     pango_layout_set_justify(_SELF(self), RVAL2CBOOL(justify));
     return self;
 }
 static VALUE
-layout_get_justify(VALUE self)
+rg_justify_p(VALUE self)
 {
     return CBOOL2RVAL(pango_layout_get_justify(_SELF(self)));
 }
 
 #if PANGO_CHECK_VERSION(1,4,0)
 static VALUE
-layout_set_auto_dir(VALUE self, VALUE auto_dir)
+rg_set_auto_dir(VALUE self, VALUE auto_dir)
 {
     pango_layout_set_auto_dir(_SELF(self), RVAL2CBOOL(auto_dir));
     return self;
 }
 static VALUE
-layout_get_auto_dir(VALUE self)
+rg_auto_dir_p(VALUE self)
 {
     return CBOOL2RVAL(pango_layout_get_auto_dir(_SELF(self)));
 }
 #endif
 
 static VALUE
-layout_set_alignment(VALUE self, VALUE align)
+rg_set_alignment(VALUE self, VALUE align)
 {
-    pango_layout_set_alignment(_SELF(self), RVAL2GENUM(align, PANGO_TYPE_ALIGNMENT));
+    pango_layout_set_alignment(_SELF(self), RVAL2PANGOALIGNMENT(align));
     return self;
 }
 
 static VALUE
-layout_get_alignment(VALUE self)
+rg_alignment(VALUE self)
 {
-    return GENUM2RVAL(pango_layout_get_alignment(_SELF(self)), PANGO_TYPE_ALIGNMENT);
+    return PANGOALIGNMENT2RVAL(pango_layout_get_alignment(_SELF(self)));
 }
 
 static VALUE
-layout_set_tabs(VALUE self, VALUE tabs)
+rg_set_tabs(VALUE self, VALUE tabs)
 {
     pango_layout_set_tabs(_SELF(self), 
-                          (PangoTabArray*)RVAL2BOXED(self, PANGO_TYPE_TAB_ARRAY));
+                          RVAL2PANGOTABARRAY(tabs));
     return self;
 }
 
 static VALUE
-layout_get_tabs(VALUE self)
+rg_tabs(VALUE self)
 {
     VALUE ret = Qnil;
     PangoTabArray* tabs = pango_layout_get_tabs(_SELF(self));
 
     if (tabs) {
-        ret = BOXED2RVAL(tabs, PANGO_TYPE_TAB_ARRAY);
+        ret = PANGOTABARRAY2RVAL(tabs);
         pango_tab_array_free(tabs);
     }
     return ret;
 }
 
 static VALUE
-layout_set_single_paragraph_mode(VALUE self, VALUE setting)
+rg_set_single_paragraph_mode(VALUE self, VALUE setting)
 {
     pango_layout_set_single_paragraph_mode(_SELF(self), RVAL2CBOOL(setting));
     return self;
 }
 
 static VALUE
-layout_get_single_paragraph_mode(VALUE self)
+rg_single_paragraph_mode_p(VALUE self)
 {
     return CBOOL2RVAL(pango_layout_get_single_paragraph_mode(_SELF(self)));
 }
 
 static VALUE
-layout_get_log_attrs(VALUE self)
+rg_log_attrs(VALUE self)
 {
     PangoLogAttr* attrs;
     gint i, n_attrs;
@@ -285,7 +294,7 @@ layout_get_log_attrs(VALUE self)
     ary = rb_ary_new();
 
     for (i = 0; i < n_attrs; i++) {
-        rb_ary_assoc(ary, BOXED2RVAL(&attrs[i], PANGO_TYPE_LOG_ATTR));
+        rb_ary_assoc(ary, PANGOLOGATTR2RVAL(&attrs[i]));
     }
     g_free(attrs);
 
@@ -293,7 +302,7 @@ layout_get_log_attrs(VALUE self)
 }
 
 static VALUE
-layout_xy_to_index(VALUE self, VALUE x, VALUE y)
+rg_xy_to_index(VALUE self, VALUE x, VALUE y)
 {
     int index, trailing;
     gboolean ret = pango_layout_xy_to_index(_SELF(self), 
@@ -304,24 +313,24 @@ layout_xy_to_index(VALUE self, VALUE x, VALUE y)
 }
 
 static VALUE
-layout_index_to_pos(VALUE self, VALUE index)
+rg_index_to_pos(VALUE self, VALUE index)
 {
     PangoRectangle pos;
     pango_layout_index_to_pos(_SELF(self), NUM2INT(index), &pos);
-    return BOXED2RVAL(&pos, PANGO_TYPE_RECTANGLE);
+    return PANGORECTANGLE2RVAL(&pos);
 }
 
 static VALUE
-layout_get_cursor_pos(VALUE self, VALUE index)
+rg_get_cursor_pos(VALUE self, VALUE index)
 {
     PangoRectangle strong_pos, weak_pos;
     pango_layout_get_cursor_pos(_SELF(self), NUM2INT(index), &strong_pos, &weak_pos);
-    return rb_ary_new3(2, BOXED2RVAL(&strong_pos, PANGO_TYPE_RECTANGLE),
-                       BOXED2RVAL(&weak_pos, PANGO_TYPE_RECTANGLE));
+    return rb_ary_new3(2, PANGORECTANGLE2RVAL(&strong_pos),
+                       PANGORECTANGLE2RVAL(&weak_pos));
 }
 
 static VALUE
-layout_move_cursor_visually(VALUE self, VALUE strong, VALUE old_index, VALUE old_trailing, VALUE direction)
+rg_move_cursor_visually(VALUE self, VALUE strong, VALUE old_index, VALUE old_trailing, VALUE direction)
 {
     int new_index, new_trailing;
     pango_layout_move_cursor_visually(_SELF(self), RVAL2CBOOL(strong),
@@ -332,7 +341,7 @@ layout_move_cursor_visually(VALUE self, VALUE strong, VALUE old_index, VALUE old
 }
 
 static VALUE
-layout_get_extents(int argc, VALUE *argv, VALUE self)
+rg_get_extents(int argc, VALUE *argv, VALUE self)
 {
     VALUE ink_rect, logical_rect;
     PangoRectangle rink, rlog;
@@ -345,7 +354,7 @@ layout_get_extents(int argc, VALUE *argv, VALUE self)
         rink.width = 0;
         rink.height = 0;
     } else {
-        PangoRectangle* rect = (PangoRectangle*)RVAL2BOXED(ink_rect, PANGO_TYPE_RECTANGLE);
+        PangoRectangle* rect = RVAL2PANGORECTANGLE(ink_rect);
         rink.x = rect->x;
         rink.y = rect->y;
         rink.width = rect->width;
@@ -357,7 +366,7 @@ layout_get_extents(int argc, VALUE *argv, VALUE self)
         rlog.width = 0;
         rlog.height = 0;
     } else {
-        PangoRectangle* rect = (PangoRectangle*)RVAL2BOXED(logical_rect, PANGO_TYPE_RECTANGLE);
+        PangoRectangle* rect = RVAL2PANGORECTANGLE(logical_rect);
         rlog.x = rect->x;
         rlog.y = rect->y;
         rlog.width = rect->width;
@@ -366,23 +375,23 @@ layout_get_extents(int argc, VALUE *argv, VALUE self)
 
     pango_layout_get_extents(_SELF(self), &rink, &rlog);
 
-    return rb_assoc_new(BOXED2RVAL(&rink, PANGO_TYPE_RECTANGLE),
-                        BOXED2RVAL(&rlog, PANGO_TYPE_RECTANGLE));
+    return rb_assoc_new(PANGORECTANGLE2RVAL(&rink),
+                        PANGORECTANGLE2RVAL(&rlog));
 }
 
 static VALUE
-layout_extents(VALUE self)
+rg_extents(VALUE self)
 {
     PangoRectangle rink = {0, 0, 0, 0};
     PangoRectangle rlog = {0, 0, 0, 0};
 
     pango_layout_get_extents(_SELF(self), &rink, &rlog);
-    return rb_assoc_new(BOXED2RVAL(&rink, PANGO_TYPE_RECTANGLE),
-                        BOXED2RVAL(&rlog, PANGO_TYPE_RECTANGLE));
+    return rb_assoc_new(PANGORECTANGLE2RVAL(&rink),
+                        PANGORECTANGLE2RVAL(&rlog));
 }
 
 static VALUE
-layout_get_pixel_extents(int argc, VALUE *argv, VALUE self)
+rg_get_pixel_extents(int argc, VALUE *argv, VALUE self)
 {
     VALUE ink_rect, logical_rect;
     PangoRectangle rink, rlog;
@@ -395,7 +404,7 @@ layout_get_pixel_extents(int argc, VALUE *argv, VALUE self)
         rink.width = 0;
         rink.height = 0;
     } else {
-        PangoRectangle* rect = (PangoRectangle*)RVAL2BOXED(ink_rect, PANGO_TYPE_RECTANGLE);
+        PangoRectangle* rect = RVAL2PANGORECTANGLE(ink_rect);
         rink.x = rect->x;
         rink.y = rect->y;
         rink.width = rect->width;
@@ -407,7 +416,7 @@ layout_get_pixel_extents(int argc, VALUE *argv, VALUE self)
         rlog.width = 0;
         rlog.height = 0;
     } else {
-        PangoRectangle* rect = (PangoRectangle*)RVAL2BOXED(logical_rect, PANGO_TYPE_RECTANGLE);
+        PangoRectangle* rect = RVAL2PANGORECTANGLE(logical_rect);
         rlog.x = rect->x;
         rlog.y = rect->y;
         rlog.width = rect->width;
@@ -416,23 +425,23 @@ layout_get_pixel_extents(int argc, VALUE *argv, VALUE self)
 
     pango_layout_get_pixel_extents(_SELF(self), &rink, &rlog);
 
-    return rb_assoc_new(BOXED2RVAL(&rink, PANGO_TYPE_RECTANGLE),
-                        BOXED2RVAL(&rlog, PANGO_TYPE_RECTANGLE));
+    return rb_assoc_new(PANGORECTANGLE2RVAL(&rink),
+                        PANGORECTANGLE2RVAL(&rlog));
 }
 
 static VALUE
-layout_pixel_extents(VALUE self)
+rg_pixel_extents(VALUE self)
 {
     PangoRectangle rink = {0, 0, 0, 0};
     PangoRectangle rlog = {0, 0, 0, 0};
 
     pango_layout_get_pixel_extents(_SELF(self), &rink, &rlog);
-    return rb_assoc_new(BOXED2RVAL(&rink, PANGO_TYPE_RECTANGLE),
-                        BOXED2RVAL(&rlog, PANGO_TYPE_RECTANGLE));
+    return rb_assoc_new(PANGORECTANGLE2RVAL(&rink),
+                        PANGORECTANGLE2RVAL(&rlog));
 }
 
 static VALUE
-layout_get_size(VALUE self)
+rg_size(VALUE self)
 {
     int width, height;
     pango_layout_get_size(_SELF(self), &width, &height);
@@ -440,7 +449,7 @@ layout_get_size(VALUE self)
 }
 
 static VALUE
-layout_get_pixel_size(VALUE self)
+rg_pixel_size(VALUE self)
 {
     int width, height;
     pango_layout_get_pixel_size(_SELF(self), &width, &height);
@@ -448,103 +457,101 @@ layout_get_pixel_size(VALUE self)
 }
 
 static VALUE
-layout_get_line_count(VALUE self)
+rg_line_count(VALUE self)
 {
     return INT2NUM(pango_layout_get_line_count(_SELF(self)));
 }
 
 static VALUE
-layout_get_line(VALUE self, VALUE line)
+rg_get_line(VALUE self, VALUE line)
 {
-    return BOXED2RVAL(pango_layout_get_line(_SELF(self), NUM2INT(line)), PANGO_TYPE_LAYOUT_LINE);
+    return PANGOLAYOUTLINE2RVAL(pango_layout_get_line(_SELF(self), NUM2INT(line)));
 }
 
 static VALUE
-layout_get_lines(VALUE self)
+rg_lines(VALUE self)
 {
     return GSLIST2ARY2(pango_layout_get_lines(_SELF(self)), PANGO_TYPE_LAYOUT_LINE);
 }
 
-
 static VALUE
-layout_get_iter(VALUE self)
+rg_iter(VALUE self)
 {
-    return BOXED2RVAL(pango_layout_get_iter(_SELF(self)), 
-                      PANGO_TYPE_LAYOUT_ITER);
+    return PANGOLAYOUTITER2RVAL(pango_layout_get_iter(_SELF(self)));
 }
 
 void
-Init_pango_layout()
-{
-    VALUE pLayout = G_DEF_CLASS(PANGO_TYPE_LAYOUT, "Layout", mPango);
-
-    rb_define_method(pLayout, "initialize", layout_initialize, 1);
-    rb_define_method(pLayout, "copy", layout_copy, 0);
-    rb_define_method(pLayout, "context", layout_get_context, 0);
-    rb_define_method(pLayout, "context_changed", layout_context_changed, 0);
-    rb_define_method(pLayout, "set_text", layout_set_text, 1);
-    rb_define_method(pLayout, "text", layout_get_text, 0);
-    rb_define_method(pLayout, "set_markup", layout_set_markup, -1);
-    rb_define_method(pLayout, "markup=", layout_set_markup_eq, 1);
-    rb_define_method(pLayout, "set_attributes", layout_set_attributes, 1);
-    rb_define_method(pLayout, "attributes", layout_get_attributes, 0);
-    rb_define_method(pLayout, "set_font_description", layout_set_font_description, 1);
+Init_pango_layout(VALUE mPango)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(PANGO_TYPE_LAYOUT, "Layout", mPango);
+
+    RG_DEF_METHOD(initialize, 1);
+    RG_DEF_METHOD(copy, 0);
+    RG_DEF_METHOD(context, 0);
+    RG_DEF_METHOD(context_changed, 0);
+    RG_DEF_METHOD(set_text, 1);
+    RG_DEF_METHOD(text, 0);
+    RG_DEF_METHOD(set_markup, -1);
+    RG_DEF_METHOD_OPERATOR("markup=", layout_set_markup_eq, 1);
+    RG_DEF_METHOD(set_attributes, 1);
+    RG_DEF_METHOD(attributes, 0);
+    RG_DEF_METHOD(set_font_description, 1);
 #ifdef HAVE_PANGO_LAYOUT_GET_FONT_DESCRIPTION
-    rb_define_method(pLayout, "font_description", layout_get_font_description, 0);
+    RG_DEF_METHOD(font_description, 0);
 #endif
-    rb_define_method(pLayout, "set_width", layout_set_width, 1);
-    rb_define_method(pLayout, "width", layout_get_width, 0);
-    rb_define_method(pLayout, "set_wrap", layout_set_wrap, 1);
-    rb_define_method(pLayout, "wrap", layout_get_wrap, 0);
+    RG_DEF_METHOD(set_width, 1);
+    RG_DEF_METHOD(width, 0);
+    RG_DEF_METHOD(set_wrap, 1);
+    RG_DEF_METHOD(wrap, 0);
 #ifdef HAVE_PANGO_LAYOUT_SET_ELLIPSIZE
-    rb_define_method(pLayout, "set_ellipsize", layout_set_ellipsize, 1);
-    rb_define_method(pLayout, "ellipsize", layout_get_ellipsize, 0);
+    RG_DEF_METHOD(set_ellipsize, 1);
+    RG_DEF_METHOD(ellipsize, 0);
 #endif
-    rb_define_method(pLayout, "set_indent", layout_set_indent, 1);
-    rb_define_method(pLayout, "indent", layout_get_indent, 0);
-    rb_define_method(pLayout, "spacing", layout_get_spacing, 0);
-    rb_define_method(pLayout, "set_spacing", layout_set_spacing, 1);
-    rb_define_method(pLayout, "set_justify", layout_set_justify, 1);
-    rb_define_method(pLayout, "justify?", layout_get_justify, 0);
+    RG_DEF_METHOD(set_indent, 1);
+    RG_DEF_METHOD(indent, 0);
+    RG_DEF_METHOD(spacing, 0);
+    RG_DEF_METHOD(set_spacing, 1);
+    RG_DEF_METHOD(set_justify, 1);
+    RG_DEF_METHOD_P(justify, 0);
 #if PANGO_CHECK_VERSION(1,4,0)
-    rb_define_method(pLayout, "set_auto_dir", layout_set_auto_dir, 1);
-    rb_define_method(pLayout, "auto_dir?", layout_get_auto_dir, 0);
+    RG_DEF_METHOD(set_auto_dir, 1);
+    RG_DEF_METHOD_P(auto_dir, 0);
 #endif
-    rb_define_method(pLayout, "set_alignment", layout_set_alignment, 1);
-    rb_define_method(pLayout, "alignment", layout_get_alignment, 0);
-    rb_define_method(pLayout, "set_tabs", layout_set_tabs, 1);
-    rb_define_method(pLayout, "tabs", layout_get_tabs, 0);
-    rb_define_method(pLayout, "set_single_paragraph_mode", layout_set_single_paragraph_mode, 1);
-    rb_define_method(pLayout, "single_paragraph_mode?", layout_get_single_paragraph_mode, 0);
-    rb_define_method(pLayout, "log_attrs", layout_get_log_attrs, 0);
-    rb_define_method(pLayout, "xy_to_index", layout_xy_to_index, 2);
-    rb_define_method(pLayout, "index_to_pos", layout_index_to_pos, 1);
-    rb_define_method(pLayout, "get_cursor_pos", layout_get_cursor_pos, 1);
-    rb_define_method(pLayout, "move_cursor_visually", layout_move_cursor_visually, 4);
-    rb_define_method(pLayout, "get_extents", layout_get_extents, -1);
-    rb_define_method(pLayout, "extents", layout_extents, 0);
-    rb_define_method(pLayout, "get_pixel_extents", layout_get_pixel_extents, -1);
-    rb_define_method(pLayout, "pixel_extents", layout_pixel_extents, 0);
-    rb_define_method(pLayout, "size", layout_get_size, 0);
-    rb_define_method(pLayout, "pixel_size", layout_get_pixel_size, 0);
-    rb_define_method(pLayout, "line_count", layout_get_line_count, 0);
-    rb_define_method(pLayout, "get_line", layout_get_line, 1);
-    rb_define_method(pLayout, "lines", layout_get_lines, 0);
-    rb_define_method(pLayout, "iter", layout_get_iter, 0);
-
-    G_DEF_SETTERS(pLayout);
+    RG_DEF_METHOD(set_alignment, 1);
+    RG_DEF_METHOD(alignment, 0);
+    RG_DEF_METHOD(set_tabs, 1);
+    RG_DEF_METHOD(tabs, 0);
+    RG_DEF_METHOD(set_single_paragraph_mode, 1);
+    RG_DEF_METHOD_P(single_paragraph_mode, 0);
+    RG_DEF_METHOD(log_attrs, 0);
+    RG_DEF_METHOD(xy_to_index, 2);
+    RG_DEF_METHOD(index_to_pos, 1);
+    RG_DEF_METHOD(get_cursor_pos, 1);
+    RG_DEF_METHOD(move_cursor_visually, 4);
+    RG_DEF_METHOD(get_extents, -1);
+    RG_DEF_METHOD(extents, 0);
+    RG_DEF_METHOD(get_pixel_extents, -1);
+    RG_DEF_METHOD(pixel_extents, 0);
+    RG_DEF_METHOD(size, 0);
+    RG_DEF_METHOD(pixel_size, 0);
+    RG_DEF_METHOD(line_count, 0);
+    RG_DEF_METHOD(get_line, 1);
+    RG_DEF_METHOD(lines, 0);
+    RG_DEF_METHOD(iter, 0);
+
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
 
     /* PangoWrapMode */
-    G_DEF_CLASS(PANGO_TYPE_WRAP_MODE, "WrapMode", pLayout);
-    G_DEF_CONSTANTS(pLayout, PANGO_TYPE_WRAP_MODE, "PANGO_");
+    G_DEF_CLASS(PANGO_TYPE_WRAP_MODE, "WrapMode", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, PANGO_TYPE_WRAP_MODE, "PANGO_");
 
     /* PangoAlignment */
-    G_DEF_CLASS(PANGO_TYPE_ALIGNMENT, "Alignment", pLayout);
-    G_DEF_CONSTANTS(pLayout, PANGO_TYPE_ALIGNMENT, "PANGO_");
+    G_DEF_CLASS(PANGO_TYPE_ALIGNMENT, "Alignment", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, PANGO_TYPE_ALIGNMENT, "PANGO_");
 
 #ifdef HAVE_PANGO_LAYOUT_SET_ELLIPSIZE
     /* PangoEllipsizeMode */
-    G_DEF_CLASS(PANGO_TYPE_ELLIPSIZE_MODE, "EllipsizeMode", pLayout);
-    G_DEF_CONSTANTS(pLayout, PANGO_TYPE_ELLIPSIZE_MODE, "PANGO_");
+    G_DEF_CLASS(PANGO_TYPE_ELLIPSIZE_MODE, "EllipsizeMode", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, PANGO_TYPE_ELLIPSIZE_MODE, "PANGO_");
 #endif
 }