pango 1.0.3 → 1.1.0

data/ext/pango/extconf.rb

@@ -30,6 +30,9 @@ rescue LoadError
   require 'mkmf-gnome2'
 end
 
+ruby_header = "ruby.h"
+have_func("rb_errinfo", ruby_header)
+
 ["glib2"].each do |package|
   directory = "#{package}#{version_suffix}"
   build_dir = "#{directory}/tmp/#{RUBY_PLATFORM}/#{package}/#{RUBY_VERSION}"

data/ext/pango/rbpango.c

@@ -1,27 +1,327 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
+/*
+ *  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
+ */
 
-  rbpango.c -
+#include "rbpangoprivate.h"
 
-  $Author: mutoh $
-  $Date: 2005/09/28 18:04:21 $
+#define RG_TARGET_NAMESPACE mPango
 
-  Copyright (C) 2002-2005 Masao Mutoh
-************************************************/
+VALUE RG_TARGET_NAMESPACE;
 
-#include "rbpango.h"
+extern void Init_pango(void);
 
-VALUE mPango;
+/*
+ * Rendering
+ */
+
+struct rpango_reorder_items_args {
+    PangoItem *item;
+    VALUE ary;
+    long n;
+    GList *result;
+};
+
+static VALUE
+rpango_reorder_items_body(VALUE value)
+{
+    struct rpango_reorder_items_args *args = (struct rpango_reorder_items_args *)value;
+    long i;
+    GList *result;
+
+    for (i = 0; i < args->n; i++)
+        args->result = g_list_append(args->result,
+                                     RVAL2PANGOITEM(RARRAY_PTR(args->ary)[i]));
+
+    result = pango_reorder_items(args->result);
+    g_list_free(args->result);
+
+    return GLIST2ARY2(result, PANGO_TYPE_ITEM);
+}
+
+static VALUE
+rpango_reorder_items_ensure(VALUE value)
+{
+    g_list_free(((struct rpango_reorder_items_args *)value)->result);
+
+    return Qnil;
+}
+
+static VALUE
+rg_m_reorder_items(G_GNUC_UNUSED VALUE self, VALUE attrs)
+{
+    struct rpango_reorder_items_args args;
+    args.ary = rb_ary_to_ary(attrs);
+    args.n = RARRAY_LEN(args.ary);
+    args.result = NULL;
+
+    return rb_ensure(rpango_reorder_items_body, (VALUE)&args,
+                     rpango_reorder_items_ensure, (VALUE)&args);
+}
+
+#if PANGO_CHECK_VERSION(1,4,0)
+static VALUE
+rg_m_unichar_direction(G_GNUC_UNUSED VALUE self, VALUE ch)
+{
+    return PANGODIRECTION2RVAL(pango_unichar_direction(NUM2UINT(ch)));
+}
+
+static VALUE
+rg_m_find_base_dir(G_GNUC_UNUSED VALUE self, VALUE text)
+{
+    StringValue(text);
+    return PANGODIRECTION2RVAL(pango_find_base_dir(RSTRING_PTR(text), RSTRING_LEN(text)));
+}
+#endif
+
+struct rbg_pangologattrs2rval_free_args {
+    PangoLogAttr *attrs;
+    long n;
+};
+
+static VALUE
+rbg_pangologattrs2rval_free_body(VALUE value)
+{
+    struct rbg_pangologattrs2rval_free_args *args = (struct rbg_pangologattrs2rval_free_args *)value;
+    long i;
+    VALUE ary = rb_ary_new();
+
+    for (i = 0; i < args->n; i++)
+        rb_ary_push(ary, PANGOLOGATTR2RVAL(&args->attrs[i]));
+
+    return ary;
+}
+
+static VALUE
+rbg_pangologattrs2rval_free_ensure(VALUE value)
+{
+    g_free(((struct rbg_pangologattrs2rval_free_args *)value)->attrs);
+
+    return Qnil;
+}
+
+static VALUE
+rbg_pangologattrs2rval_free(PangoLogAttr *attrs, long n)
+{
+    struct rbg_pangologattrs2rval_free_args args = { attrs, n };
+
+    return rb_ensure(rbg_pangologattrs2rval_free_body, (VALUE)&args,
+                     rbg_pangologattrs2rval_free_ensure, (VALUE)&args);
+}
+
+#define PANGOLOGATTRS2RVAL_FREE(attrs, n) rbg_pangologattrs2rval_free(attrs, n)
+
+static VALUE
+rg_m_break(G_GNUC_UNUSED VALUE self, VALUE rbtext, VALUE rbanalysis)
+{
+    const gchar *text = RVAL2CSTR(rbtext);
+    long length = RSTRING_LEN(rbtext);
+    PangoAnalysis *analysis = RVAL2PANGOANALYSIS(rbanalysis);
+    long n = g_utf8_strlen(text, length) + 1;
+    PangoLogAttr *attrs = g_new(PangoLogAttr, n);
+
+    pango_break(text, length, analysis, attrs, n);
+
+    return PANGOLOGATTRS2RVAL_FREE(attrs, n);
+}
+
+static VALUE
+rg_m_get_log_attrs(G_GNUC_UNUSED VALUE self, VALUE rbtext, VALUE rblevel, VALUE rblanguage)
+{
+    const gchar *text = RVAL2CSTR(rbtext);
+    long length = RSTRING_LEN(rbtext);
+    int level = NUM2INT(rblevel);
+    PangoLanguage *language = RVAL2PANGOLANGUAGE(rblanguage);
+    long n = g_utf8_strlen(text, length) + 1;
+    PangoLogAttr *attrs = g_new(PangoLogAttr, n);
+
+    pango_get_log_attrs(text, length, level, language, attrs, n);
+
+    return PANGOLOGATTRS2RVAL_FREE(attrs, n);
+}
+
+static VALUE
+rg_m_find_paragraph_boundary(G_GNUC_UNUSED VALUE self, VALUE text)
+{
+    gint paragraph_delimiter_index, next_paragraph_start;
+
+    StringValue(text);
+    pango_find_paragraph_boundary(RSTRING_PTR(text), RSTRING_LEN(text),
+                                  &paragraph_delimiter_index,
+                                  &next_paragraph_start);
+    return rb_ary_new3(2, INT2NUM(paragraph_delimiter_index), 
+                       INT2NUM(next_paragraph_start));
+}
+
+/*
+Don't need to implement this. Use pango_break instead.
+void        pango_default_break             (const gchar *text,
+                                             int length,
+                                             PangoAnalysis *analysis,
+                                             PangoLogAttr *attrs,
+                                             int attrs_len);
+*/
+
+static VALUE
+rpango_shape_result(VALUE value)
+{
+    return PANGOGLYPHSTRING2RVAL((PangoGlyphString *)value);
+}
+
+static VALUE
+rpango_shape_ensure(VALUE value)
+{
+    pango_glyph_string_free((PangoGlyphString *)value);
+
+    return Qnil;
+}
+
+static VALUE
+rg_m_shape(G_GNUC_UNUSED VALUE self, VALUE rbtext, VALUE rbanalysis)
+{
+    const gchar *text = RVAL2CSTR(rbtext);
+    long length = RSTRING_LEN(rbtext);
+    PangoAnalysis *analysis = RVAL2PANGOANALYSIS(rbanalysis);
+    PangoGlyphString *glyphs = pango_glyph_string_new();
+
+    pango_shape(text, length, analysis, glyphs);
+
+    return rb_ensure(rpango_shape_result, (VALUE)glyphs,
+                     rpango_shape_ensure, (VALUE)glyphs);
+}
+
+/* This method is from rbpangoattribute.c */
+static VALUE
+rg_m_parse_markup(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
+{
+    VALUE markup_text, accel_marker;
+    PangoAttrList *pattr_list;
+    gchar* gtext;
+    gunichar accel_char;
+    GError *error = NULL;
+    gboolean ret;
+    char c;
+    VALUE text = Qnil;
+    VALUE attr_list = Qnil;
+
+    rb_scan_args(argc, argv, "11", &markup_text, &accel_marker);
+
+    if (NIL_P(markup_text)) rb_raise(rb_eRuntimeError, "1st argument can't accept nil");
+
+    StringValue(markup_text);
+    ret = pango_parse_markup(RSTRING_PTR(markup_text),
+                             RSTRING_LEN(markup_text),
+                             NIL_P(accel_marker) ? 0 : NUM2CHR(accel_marker),
+                             &pattr_list, &gtext, &accel_char, &error);
+
+    if (!ret) RAISE_GERROR(error);
+
+    if (pattr_list){
+        attr_list = PANGOATTRLIST2RVAL(pattr_list); 
+        pango_attr_list_unref(pattr_list);
+    }
+
+    c = (char)accel_char;
+    if (text){
+        text = CSTR2RVAL(gtext);
+        g_free(gtext);
+    }
+    return rb_ary_new3(3, attr_list, text,
+                       accel_char ? rb_str_new(&c, 1) : Qnil);
+}
+
+static VALUE
+rg_m_pixels(G_GNUC_UNUSED VALUE self, VALUE pixels)
+{
+    return rb_float_new(PANGO_PIXELS(NUM2DBL(pixels)));
+}
+
+static VALUE
+rg_m_cairo_available_p(G_GNUC_UNUSED VALUE self)
+{
+#ifdef CAIRO_AVAILABLE
+    return Qtrue;
+#else
+    return Qfalse;
+#endif
+}
 
 void
-Init_pango()
+Init_pango(void)
 {
-    mPango = rb_define_module("Pango");
+    RG_TARGET_NAMESPACE = rb_define_module("Pango");
 
-    rb_define_const(mPango, "BUILD_VERSION", 
+    rb_define_const(RG_TARGET_NAMESPACE, "BUILD_VERSION", 
                     rb_ary_new3(3, 
                                 INT2FIX(PANGO_MAJOR_VERSION), 
                                 INT2FIX(PANGO_MINOR_VERSION), 
                                 INT2FIX(PANGO_MICRO_VERSION)));
-    Init_pango_inits();
+
+    RG_DEF_MODFUNC(reorder_items, 1);
+
+#if PANGO_CHECK_VERSION(1,4,0)
+    RG_DEF_MODFUNC(unichar_direction, 1);
+    RG_DEF_MODFUNC(find_base_dir, 1);
+#endif
+    RG_DEF_MODFUNC(break, 2);
+    RG_DEF_MODFUNC(get_log_attrs, 3);
+    RG_DEF_MODFUNC(find_paragraph_boundary, 1);
+    RG_DEF_MODFUNC(shape, 2);
+    RG_DEF_MODFUNC(parse_markup, -1);
+    RG_DEF_MODFUNC(pixels, 1);
+
+    rb_define_const(RG_TARGET_NAMESPACE, "SCALE", INT2FIX(PANGO_SCALE));
+
+    RG_DEF_MODFUNC_P(cairo_available, 0);
+
+    Init_pango_analysis(RG_TARGET_NAMESPACE);
+    Init_pango_attribute(RG_TARGET_NAMESPACE);
+    Init_pango_attriterator(RG_TARGET_NAMESPACE);
+    Init_pango_attrlist(RG_TARGET_NAMESPACE);
+    Init_pango_cairo(RG_TARGET_NAMESPACE);
+    Init_pango_cairo_context(RG_TARGET_NAMESPACE);
+    Init_pango_color(RG_TARGET_NAMESPACE);
+    Init_pango_context(RG_TARGET_NAMESPACE);
+    Init_pango_coverage(RG_TARGET_NAMESPACE);
+    Init_pango_engine(RG_TARGET_NAMESPACE);
+    Init_pango_font(RG_TARGET_NAMESPACE);
+    Init_pango_font_description(RG_TARGET_NAMESPACE);
+    Init_pango_font_face(RG_TARGET_NAMESPACE);
+    Init_pango_font_family(RG_TARGET_NAMESPACE);
+    Init_pango_font_map(RG_TARGET_NAMESPACE);
+    Init_pango_font_metrics(RG_TARGET_NAMESPACE);
+    Init_pango_fontset(RG_TARGET_NAMESPACE);
+    Init_pango_fontset_simple(RG_TARGET_NAMESPACE);
+    Init_pango_glyph_info(RG_TARGET_NAMESPACE);
+    Init_pango_glyph_item(RG_TARGET_NAMESPACE);
+    Init_pango_glyph_string(RG_TARGET_NAMESPACE);
+    Init_pango_gravity(RG_TARGET_NAMESPACE);
+    Init_pango_item(RG_TARGET_NAMESPACE);
+    Init_pango_language(RG_TARGET_NAMESPACE);
+    Init_pango_layout(RG_TARGET_NAMESPACE);
+    Init_pango_layout_iter(RG_TARGET_NAMESPACE);
+    Init_pango_layout_line(RG_TARGET_NAMESPACE);
+    Init_pango_logattr(RG_TARGET_NAMESPACE);
+    Init_pango_matrix(RG_TARGET_NAMESPACE);
+    Init_pango_rectangle(RG_TARGET_NAMESPACE);
+    Init_pangorenderer(RG_TARGET_NAMESPACE);
+    Init_pango_script(RG_TARGET_NAMESPACE);
+    Init_pango_script_iter(RG_TARGET_NAMESPACE);
+    Init_pango_array(RG_TARGET_NAMESPACE);
 }

data/ext/pango/rbpango.h

@@ -1,29 +1,40 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbpango.h -
-
-  $Author: ktou $
-  $Date: 2005/10/05 11:16:26 $
-
-  Copyright (C) 2002-2005 Masao Mutoh
-************************************************/
+/*
+ *  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 "ruby.h"
 #define PANGO_ENABLE_ENGINE
 #define PANGO_ENABLE_BACKEND
 #include <pango/pango.h>
 
-#if HAVE_FREETYPE2
+#ifdef HAVE_FREETYPE2
 #include <pango/pangofc-font.h>
 #endif
 
 #include "rbgobject.h"
 #include "rbpangoversion.h"
+#include "rbpangoconversions.h"
 
 #if PANGO_CHECK_VERSION(1,10,0)
 #include <pango/pangocairo.h>
-#  if HAVE_RB_CAIRO_H
+#  ifdef HAVE_RB_CAIRO_H
 #include <rb_cairo.h>
 #  endif
 #endif
@@ -72,21 +83,21 @@ RUBY_PANGO_VAR VALUE mPango;
 extern VALUE pango_make_attribute(PangoAttribute* attr);
 extern PangoAttribute* pango_get_attribute(VALUE attr);
 
-extern GType pango_item_get_type();
-extern GType pango_analysis_get_type();
-extern GType pango_log_attr_get_type();
-extern GType pango_layout_iter_get_type();
-extern GType pango_layout_line_get_type();
-extern GType pango_rectangle_get_type();
-extern GType pango_attr_iter_get_type();
-extern GType pango_coverage_get_type();
-extern GType pango_glyph_info_get_type();
+extern GType pango_item_get_type(void);
+extern GType pango_analysis_get_type(void);
+extern GType pango_log_attr_get_type(void);
+extern GType pango_layout_iter_get_type(void);
+extern GType pango_layout_line_get_type(void);
+extern GType pango_rectangle_get_type(void);
+extern GType pango_attr_iter_get_type(void);
+extern GType pango_coverage_get_type(void);
+extern GType pango_glyph_info_get_type(void);
 #ifndef HAVE_PANGO_GLYPH_ITEM_GET_TYPE
-extern GType pango_glyph_item_get_type();
+extern GType pango_glyph_item_get_type(void);
 #endif
 
 #if PANGO_CHECK_VERSION(1,4,0)
-extern GType pango_script_iter_get_type();
+extern GType pango_script_iter_get_type(void);
 #endif
 
 extern VALUE pango_get_attribute_klass(VALUE attr_type);

data/ext/pango/rbpangoanalysis.c

@@ -1,17 +1,28 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbpangoanalysis.c -
-
-  $Author: mutoh $
-  $Date: 2005/09/17 17:09:13 $
-
-  Copyright (C) 2003-2005 Masao Mutoh
-************************************************/
-
-#include "rbpango.h"
-
-#define _SELF(s) ((PangoAnalysis*)RVAL2BOXED(s, PANGO_TYPE_ANALYSIS))
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2003-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 cAnalysis
+#define _SELF(s) (RVAL2PANGOANALYSIS(s))
 
 /**********************************/
 static PangoAnalysis*
@@ -23,12 +34,12 @@ ana_copy(const PangoAnalysis* val)
     *new_val = *val;
     return new_val;
 }
-                                                                                     
+
 GType
 pango_analysis_get_type(void)
 {
     static GType our_type = 0;
-                                                                                     
+
     if (our_type == 0)
         our_type = g_boxed_type_register_static ("PangoAnalysis",
                     (GBoxedCopyFunc)ana_copy,
@@ -38,22 +49,22 @@ pango_analysis_get_type(void)
 /**********************************/
 
 static VALUE
-ana_initialize(VALUE self)
+rg_initialize(VALUE self)
 {
-    PangoAnalysis ana = { NULL, NULL, NULL, 0 };
+    PangoAnalysis ana = { NULL, NULL, NULL, 0, 0, 0, 0, NULL, NULL };
     G_INITIALIZE(self, &ana);
     return Qnil;
 }
 
 #if PANGO_CHECK_VERSION(1,4,0)
 static VALUE
-ana_set_shape_engine(VALUE self, VALUE engine)
+rg_set_shape_engine(VALUE self, VALUE engine)
 {
-    _SELF(self)->shape_engine = PANGO_ENGINE_SHAPE(RVAL2GOBJ(engine));
+    _SELF(self)->shape_engine = RVAL2PANGOENGINESHAPE(engine);
     return self;
 }
 static VALUE
-ana_get_shape_engine(VALUE self)
+rg_shape_engine(VALUE self)
 {
     VALUE ret;
     if (_SELF(self)->shape_engine){
@@ -69,13 +80,13 @@ ana_get_shape_engine(VALUE self)
 }
 
 static VALUE
-ana_set_lang_engine(VALUE self, VALUE engine)
+rg_set_lang_engine(VALUE self, VALUE engine)
 {
-    _SELF(self)->lang_engine = PANGO_ENGINE_LANG(RVAL2GOBJ(engine));
+    _SELF(self)->lang_engine = RVAL2PANGOENGINELANG(engine);
     return self;
 }
 static VALUE
-ana_get_lang_engine(VALUE self)
+rg_lang_engine(VALUE self)
 {
     VALUE ret;
     if (_SELF(self)->lang_engine){
@@ -92,61 +103,90 @@ ana_get_lang_engine(VALUE self)
 #endif
 
 static VALUE
-ana_set_font(VALUE self, VALUE font)
+rg_set_font(VALUE self, VALUE font)
 {
-    _SELF(self)->font = PANGO_FONT(RVAL2GOBJ(font));
+    _SELF(self)->font = RVAL2PANGOFONT(font);
     return self;
 }
 
 static VALUE
-ana_get_font(VALUE self)
+rg_font(VALUE self)
 {
     return GOBJ2RVAL(_SELF(self)->font);
 }
 
 static VALUE
-ana_set_level(VALUE self, VALUE level)
+rg_set_level(VALUE self, VALUE level)
 {
     _SELF(self)->level = NUM2UINT(level);
     return self;
 }
 
 static VALUE
-ana_get_level(VALUE self)
+rg_level(VALUE self)
 {
     return UINT2NUM(_SELF(self)->level);
 }
 
 static VALUE
-ana_set_language(VALUE self, VALUE lang)
+rg_set_language(VALUE self, VALUE lang)
 {
-    _SELF(self)->language = RVAL2BOXED(lang, PANGO_TYPE_LANGUAGE);
+    _SELF(self)->language = RVAL2PANGOLANGUAGE(lang);
     return self;
 }
 
 static VALUE
-ana_get_language(VALUE self)
+rg_language(VALUE self)
 {
-    return BOXED2RVAL(_SELF(self)->language, PANGO_TYPE_LANGUAGE);
+    return PANGOLANGUAGE2RVAL(_SELF(self)->language);
 }
 
+struct ana_set_extra_attrs_args {
+    PangoAnalysis *analysis;
+    VALUE ary;
+    long n;
+    GSList *result;
+};
+
 static VALUE
-ana_set_extra_attrs(VALUE self, VALUE attrs)
+ana_set_extra_attrs_body(VALUE value)
 {
-    gint i;
-    gint len = RARRAY_LEN(attrs);
-    GSList* gattrs = NULL;
+    struct ana_set_extra_attrs_args *args = (struct ana_set_extra_attrs_args *)value;
+    long i;
 
-    for (i = 0; i < len; i++){
-        gattrs = g_slist_append(gattrs, RVAL2ATTR(RARRAY_PTR(attrs)[i]));
-    }
+    for (i = 0; i < args->n; i++)
+        args->result = g_slist_append(args->result, RVAL2ATTR(RARRAY_PTR(args->ary)[i]));
+
+    args->analysis->extra_attrs = args->result;
+
+    return Qnil;
+}
+
+static G_GNUC_NORETURN VALUE
+ana_set_extra_attrs_rescue(VALUE value)
+{
+    g_slist_free(((struct ana_set_extra_attrs_args *)value)->result);
+
+    rb_exc_raise(rb_errinfo());
+}
+
+static VALUE
+rg_set_extra_attrs(VALUE self, VALUE attrs)
+{
+    struct ana_set_extra_attrs_args args;
+    args.analysis = _SELF(self);
+    args.ary = rb_ary_to_ary(attrs);
+    args.n = RARRAY_LEN(args.ary);
+    args.result = NULL;
+
+    rb_rescue(ana_set_extra_attrs_body, (VALUE)&args,
+              ana_set_extra_attrs_rescue, (VALUE)&args);
 
-    _SELF(self)->extra_attrs = gattrs;
     return self;
 }
 
 static VALUE
-ana_get_extra_attrs(VALUE self)
+rg_extra_attrs(VALUE self)
 {
     VALUE ary = rb_ary_new();
     GSList* list = _SELF(self)->extra_attrs;
@@ -159,26 +199,26 @@ ana_get_extra_attrs(VALUE self)
 }
 
 void
-Init_pango_analysis()
+Init_pango_analysis(VALUE mPango)
 {
-    VALUE pana = G_DEF_CLASS(PANGO_TYPE_ANALYSIS, "Analysis", mPango);
-    
-    rb_define_method(pana, "initialize", ana_initialize, 0);
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(PANGO_TYPE_ANALYSIS, "Analysis", mPango);
+
+    RG_DEF_METHOD(initialize, 0);
 #if PANGO_CHECK_VERSION(1,4,0)
-    rb_define_method(pana, "set_shape_engine", ana_set_shape_engine, 1);
-    rb_define_method(pana, "shape_engine", ana_get_shape_engine, 0);
-    rb_define_method(pana, "set_lang_engine", ana_set_lang_engine, 1);
-    rb_define_method(pana, "lang_engine", ana_get_lang_engine, 0);
+    RG_DEF_METHOD(set_shape_engine, 1);
+    RG_DEF_METHOD(shape_engine, 0);
+    RG_DEF_METHOD(set_lang_engine, 1);
+    RG_DEF_METHOD(lang_engine, 0);
 #endif
-    rb_define_method(pana, "set_font", ana_set_font, 1);
-    rb_define_method(pana, "font", ana_get_font, 0);
-    rb_define_method(pana, "set_level", ana_set_level, 1);
-    rb_define_method(pana, "level", ana_get_level, 0);
-    rb_define_method(pana, "set_language", ana_set_language, 1);
-    rb_define_method(pana, "language", ana_get_language, 0);
+    RG_DEF_METHOD(set_font, 1);
+    RG_DEF_METHOD(font, 0);
+    RG_DEF_METHOD(set_level, 1);
+    RG_DEF_METHOD(level, 0);
+    RG_DEF_METHOD(set_language, 1);
+    RG_DEF_METHOD(language, 0);
 
-    rb_define_method(pana, "set_extra_attrs", ana_set_extra_attrs, 1);
-    rb_define_method(pana, "extra_attrs", ana_get_extra_attrs, 0);
+    RG_DEF_METHOD(set_extra_attrs, 1);
+    RG_DEF_METHOD(extra_attrs, 0);
 
-    G_DEF_SETTERS(pana);
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
 }