pango 2.2.4-x64-mingw32

data/ext/pango/rbpangocontext.c

@@ -0,0 +1,309 @@
+/* -*- 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
+ */
+
+#include "rbpangoprivate.h"
+
+#define RG_TARGET_NAMESPACE cContext
+#define _SELF(self) (RVAL2PANGOCONTEXT(self))
+
+static VALUE
+rg_itemize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE arg1, arg2, arg3, arg4, arg5, arg6;
+    GList* list;
+
+    rb_scan_args(argc, argv, "42", &arg1, &arg2, &arg3, &arg4, &arg5, &arg6);
+
+    if (TYPE(arg1) == T_STRING) {
+        list = pango_itemize(_SELF(self), 
+                             RVAL2CSTR(arg1),      /* text */ 
+                             NUM2INT(arg2),        /* start_index */ 
+                             NUM2INT(arg3),        /* length */
+                             RVAL2PANGOATTRLIST(arg4), /* attrs */
+                             NIL_P(arg5) ? NULL : RVAL2PANGOATTRITERATOR(arg5)); /* cached_iter */
+    } else {
+#ifdef HAVE_PANGO_ITEMIZE_WITH_BASE_DIR
+        list = pango_itemize_with_base_dir(_SELF(self), 
+                                           RVAL2PANGODIRECTION(arg1), /* base_dir */
+                                           RVAL2CSTR(arg2),      /* text */ 
+                                           NUM2INT(arg3),        /* start_index */ 
+                                           NUM2INT(arg4),        /* length */
+                                           RVAL2PANGOATTRLIST(arg5), /* attrs */
+                                           NIL_P(arg6) ? NULL : RVAL2PANGOATTRITERATOR(arg6)); /* cached_iter */
+#else
+        rb_warn("Pango::Context#itemize(base_dir, text, start_index, length, attrs, cached_iter) isn't supported on this environment.");
+        list = pango_itemize(_SELF(self), 
+                             RVAL2CSTR(arg1),      /* text */ 
+                             NUM2INT(arg2),        /* start_index */ 
+                             NUM2INT(arg3),        /* length */
+                             RVAL2PANGOATTRLIST(arg4), /* attrs */
+                             NIL_P(arg5) ? NULL : RVAL2PANGOATTRITERATOR(arg5)); /* cached_iter */
+#endif
+    }
+    return GLIST2ARY2F(list, PANGO_TYPE_ITEM);
+}
+
+/* Move to Pango module (rbpangomain.c)
+GList*      pango_reorder_items             (GList *logical_items);
+*/
+
+#ifdef PANGO_ENABLE_BACKEND
+static VALUE
+rg_initialize(VALUE self)
+{
+    G_INITIALIZE(self, pango_context_new());
+    return Qnil;
+}
+
+static VALUE
+rg_set_font_map(VALUE self, VALUE font_map)
+{
+    pango_context_set_font_map(_SELF(self), RVAL2PANGOFONTMAP(font_map));
+    return self;
+}
+
+static VALUE
+rg_font_map(VALUE self)
+{
+    return GOBJ2RVAL(pango_context_get_font_map(_SELF(self)));
+}
+#endif /* PANGO_ENABLE_BACKEND */
+
+static VALUE
+rg_font_description(VALUE self)
+{
+    PangoFontDescription* ret = pango_context_get_font_description(_SELF(self));
+    return PANGOFONTDESCRIPTION2RVAL(ret);
+}
+
+static VALUE
+rg_set_font_description(VALUE self, VALUE desc)
+{
+    pango_context_set_font_description(_SELF(self), RVAL2PANGOFONTDESCRIPTION(desc));
+    return self;
+}
+
+static VALUE
+rg_language(VALUE self)
+{
+    PangoLanguage* ret = pango_context_get_language(_SELF(self));
+    return PANGOLANGUAGE2RVAL(ret);
+}
+
+static VALUE
+rg_set_language(VALUE self, VALUE lang)
+{
+    pango_context_set_language(_SELF(self), 
+                               RVAL2PANGOLANGUAGE(lang));
+    return self;
+}
+
+static VALUE
+rg_base_dir(VALUE self)
+{
+    return PANGODIRECTION2RVAL(pango_context_get_base_dir(_SELF(self)));
+}
+
+static VALUE
+rg_set_base_dir(VALUE self, VALUE direction)
+{
+    pango_context_set_base_dir(_SELF(self), RVAL2PANGODIRECTION(direction));
+    return self;
+}
+
+#if PANGO_CHECK_VERSION(1,16,0)
+static VALUE
+rg_base_gravity(VALUE self)
+{
+    return PANGOGRAVITY2RVAL(pango_context_get_base_gravity(_SELF(self)));
+}
+
+static VALUE
+rg_set_base_gravity(VALUE self, VALUE gravity)
+{
+    pango_context_set_base_gravity(_SELF(self), RVAL2PANGOGRAVITY(gravity));
+    return self;
+}
+
+static VALUE
+rg_gravity_hint(VALUE self)
+{
+    return PANGOGRAVITYHINT2RVAL(pango_context_get_gravity_hint(_SELF(self)));
+}
+
+static VALUE
+rg_set_gravity_hint(VALUE self, VALUE gravity_hint)
+{
+    pango_context_set_gravity_hint(_SELF(self), RVAL2PANGOGRAVITYHINT(gravity_hint));
+    return self;
+}
+#endif
+
+static VALUE
+rg_matrix(VALUE self)
+{
+    const PangoMatrix* matrix = pango_context_get_matrix(_SELF(self));
+    return PANGOMATRIX2RVAL((PangoMatrix*)matrix);
+}
+
+static VALUE
+rg_set_matrix(VALUE self, VALUE matrix)
+{
+    pango_context_set_matrix(_SELF(self), 
+                             RVAL2PANGOMATRIX(matrix));
+    return self;
+}
+
+static VALUE
+rg_load_font(VALUE self, VALUE desc)
+{
+    return GOBJ2RVAL(pango_context_load_font(_SELF(self), RVAL2PANGOFONTDESCRIPTION(desc)));
+}
+
+static VALUE
+rg_load_fontset(VALUE self, VALUE desc, VALUE lang)
+{
+    return GOBJ2RVAL(pango_context_load_fontset(_SELF(self),
+                                                RVAL2PANGOFONTDESCRIPTION(desc), RVAL2PANGOLANGUAGE(lang)));
+}
+
+static VALUE
+rg_get_metrics(int argc, VALUE *argv, VALUE self)
+{
+    VALUE desc, lang;
+
+    rb_scan_args(argc, argv, "11", &desc, &lang);
+
+    return PANGOFONTMETRICS2RVAL(pango_context_get_metrics(_SELF(self), 
+                                                           RVAL2PANGOFONTDESCRIPTION(desc), 
+                                                           NIL_P(lang) ? NULL : RVAL2PANGOLANGUAGE(lang)));
+}
+
+static VALUE
+rg_families(VALUE self)
+{
+    int n_families;
+    PangoFontFamily** families;
+    int i;
+    VALUE result;
+
+    pango_context_list_families(_SELF(self),
+                                &families,
+                                &n_families);
+
+    result = rb_ary_new2(n_families);
+    for (i = 0; i < n_families; i++)
+      rb_ary_store(result, i, GOBJ2RVAL(families[i]));
+
+    g_free(families);
+
+    return result;
+}
+
+#ifdef HAVE_RB_CAIRO_H
+static VALUE
+rg_set_font_options(VALUE self, VALUE options)
+{
+    if (NIL_P(options))
+        pango_cairo_context_set_font_options(_SELF(self), NULL);
+    else
+        pango_cairo_context_set_font_options(_SELF(self),
+                                             RVAL2CRFONTOPTIONS(options));
+    return self;
+}
+
+static VALUE
+rg_font_options(VALUE self)
+{
+    const cairo_font_options_t *options;
+    options = pango_cairo_context_get_font_options(_SELF(self));
+    if (options)
+        return CRFONTOPTIONS2RVAL(cairo_font_options_copy(options));
+    else
+        return Qnil;
+}
+
+static VALUE
+rg_set_resolution(VALUE self, VALUE dpi)
+{
+    pango_cairo_context_set_resolution(_SELF(self), NUM2DBL(dpi));
+    return self;
+}
+
+static VALUE
+rg_resolution(VALUE self)
+{
+    return rb_float_new(pango_cairo_context_get_resolution(_SELF(self)));
+}
+#endif
+
+static VALUE
+rg_list_families(VALUE self)
+{
+    rb_warn("Deprecated. Use Pango::Context#families instead.");
+    return rg_families(self);
+}
+
+void
+Init_pango_context(VALUE mPango)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(PANGO_TYPE_CONTEXT, "Context", mPango);
+
+    RG_DEF_METHOD(itemize, -1);
+
+#ifdef PANGO_ENABLE_BACKEND
+    RG_DEF_METHOD(initialize, 0);
+    RG_DEF_METHOD(set_font_map, 1);
+    RG_DEF_METHOD(font_map, 0);
+#endif /* PANGO_ENABLE_BACKEND */
+    RG_DEF_METHOD(font_description, 0);
+    RG_DEF_METHOD(set_font_description, 1);
+    RG_DEF_METHOD(language, 0);
+    RG_DEF_METHOD(set_language, 1);
+    RG_DEF_METHOD(base_dir, 0);
+    RG_DEF_METHOD(set_base_dir, 1);
+#if PANGO_CHECK_VERSION(1,16,0)
+    RG_DEF_METHOD(base_gravity, 0);
+    RG_DEF_METHOD(set_base_gravity, 1);
+    RG_DEF_METHOD(gravity_hint, 0);
+    RG_DEF_METHOD(set_gravity_hint, 1);
+#endif
+    RG_DEF_METHOD(matrix, 0);
+    RG_DEF_METHOD(set_matrix, 1);
+    RG_DEF_METHOD(load_font, 1);
+    RG_DEF_METHOD(load_fontset, 2);
+    RG_DEF_METHOD(get_metrics, -1);
+    RG_DEF_METHOD(families, 0);
+
+#ifdef HAVE_RB_CAIRO_H
+    RG_DEF_METHOD(set_font_options, 1);
+    RG_DEF_METHOD(font_options, 0);
+    RG_DEF_METHOD(set_resolution, 1);
+    RG_DEF_METHOD(resolution, 0);
+#endif
+
+    /* This will remove 2 or 3 releases later since 0.14.0. */
+    RG_DEF_METHOD(list_families, 0);
+
+    /* PangoDirection */
+    G_DEF_CLASS(PANGO_TYPE_DIRECTION, "Direction", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, PANGO_TYPE_DIRECTION, "PANGO_");
+}

data/ext/pango/rbpangoconversions.h

@@ -0,0 +1,111 @@
+/* -*- 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
+ */
+
+#ifndef __PANGOCONVERSIONS_H__
+#define __PANGOCONVERSIONS_H__
+
+#define RVAL2PANGOCAIROFONTMAP(o)          (PANGO_CAIRO_FONT_MAP(RVAL2GOBJ(o)))
+#define RVAL2PANGOCONTEXT(o)               (PANGO_CONTEXT(RVAL2GOBJ(o)))
+#define RVAL2PANGOENGINE(o)                (PANGO_ENGINE(RVAL2GOBJ(o)))
+#define RVAL2PANGOENGINELANG(o)            (PANGO_ENGINE_LANG(RVAL2GOBJ(o)))
+#define RVAL2PANGOENGINESHAPE(o)           (PANGO_ENGINE_SHAPE(RVAL2GOBJ(o)))
+#define RVAL2PANGOFONT(o)                  (PANGO_FONT(RVAL2GOBJ(o)))
+#define RVAL2PANGOFONTSET(o)               (PANGO_FONTSET(RVAL2GOBJ(o)))
+#define RVAL2PANGOFONTSETSIMPLE(o)         (PANGO_FONTSET_SIMPLE(RVAL2GOBJ(o)))
+#define RVAL2PANGOFONTFACE(o)              (PANGO_FONT_FACE(RVAL2GOBJ(o)))
+#define RVAL2PANGOFONTFAMILY(o)            (PANGO_FONT_FAMILY(RVAL2GOBJ(o)))
+#define RVAL2PANGOFONTMAP(o)               (PANGO_FONT_MAP(RVAL2GOBJ(o)))
+#define RVAL2PANGOLAYOUT(o)                (PANGO_LAYOUT(RVAL2GOBJ(o)))
+#define RVAL2PANGORENDERER(o)              (PANGO_RENDERER(RVAL2GOBJ(o)))
+
+#define RVAL2PANGOANALYSIS(o)              ((PangoAnalysis*)RVAL2BOXED(o, PANGO_TYPE_ANALYSIS))
+#define PANGOANALYSIS2RVAL(o)              (BOXED2RVAL(o, PANGO_TYPE_ANALYSIS))
+#define RVAL2PANGOATTRITERATOR(o)          ((PangoAttrIterator*)RVAL2BOXED(o, PANGO_TYPE_ATTR_ITERATOR))
+#define PANGOATTRITERATOR2RVAL(o)          (BOXED2RVAL(o, PANGO_TYPE_ATTR_ITERATOR))
+#define RVAL2PANGOATTRLIST(o)              ((PangoAttrList*)RVAL2BOXED(o, PANGO_TYPE_ATTR_LIST))
+#define PANGOATTRLIST2RVAL(o)              (BOXED2RVAL(o, PANGO_TYPE_ATTR_LIST))
+#define RVAL2PANGOCOLOR(o)                 ((PangoColor*)RVAL2BOXED(o, PANGO_TYPE_COLOR))
+#define PANGOCOLOR2RVAL(o)                 (BOXED2RVAL(o, PANGO_TYPE_COLOR))
+#define RVAL2PANGOCOVERAGE(o)              ((PangoCoverage*)RVAL2BOXED(o, PANGO_TYPE_COVERAGE))
+#define PANGOCOVERAGE2RVAL(o)              (BOXED2RVAL(o, PANGO_TYPE_COVERAGE))
+#define RVAL2PANGOFONTDESCRIPTION(o)       ((PangoFontDescription*)RVAL2BOXED(o, PANGO_TYPE_FONT_DESCRIPTION))
+#define PANGOFONTDESCRIPTION2RVAL(o)       (BOXED2RVAL(o, PANGO_TYPE_FONT_DESCRIPTION))
+#define RVAL2PANGOFONTMETRICS(o)           ((PangoFontMetrics*)RVAL2BOXED(o, PANGO_TYPE_FONT_METRICS))
+#define PANGOFONTMETRICS2RVAL(o)           (BOXED2RVAL(o, PANGO_TYPE_FONT_METRICS))
+#define RVAL2PANGOGLYPHINFO(o)             ((PangoGlyphInfo*)RVAL2BOXED(o, PANGO_TYPE_GLYPH_INFO))
+#define PANGOGLYPHINFO2RVAL(o)             (BOXED2RVAL(o, PANGO_TYPE_GLYPH_INFO))
+#define RVAL2PANGOGLYPHITEM(o)             ((PangoGlyphItem*)RVAL2BOXED(o, PANGO_TYPE_GLYPH_ITEM))
+#define PANGOGLYPHITEM2RVAL(o)             (BOXED2RVAL(o, PANGO_TYPE_GLYPH_ITEM))
+#define RVAL2PANGOGLYPHSTRING(o)           ((PangoGlyphString*)RVAL2BOXED(o, PANGO_TYPE_GLYPH_STRING))
+#define PANGOGLYPHSTRING2RVAL(o)           (BOXED2RVAL(o, PANGO_TYPE_GLYPH_STRING))
+#define RVAL2PANGOITEM(o)                  ((PangoItem*)RVAL2BOXED(o, PANGO_TYPE_ITEM))
+#define PANGOITEM2RVAL(o)                  (BOXED2RVAL(o, PANGO_TYPE_ITEM))
+#define RVAL2PANGOLANGUAGE(o)              ((PangoLanguage*)RVAL2BOXED(o, PANGO_TYPE_LANGUAGE))
+#define PANGOLANGUAGE2RVAL(o)              (BOXED2RVAL(o, PANGO_TYPE_LANGUAGE))
+#define RVAL2PANGOLAYOUTITER(o)            ((PangoLayoutIter*)RVAL2BOXED(o, PANGO_TYPE_LAYOUT_ITER))
+#define PANGOLAYOUTITER2RVAL(o)            (BOXED2RVAL(o, PANGO_TYPE_LAYOUT_ITER))
+#define RVAL2PANGOLAYOUTLINE(o)            ((PangoLayoutLine*)RVAL2BOXED(o, PANGO_TYPE_LAYOUT_LINE))
+#define PANGOLAYOUTLINE2RVAL(o)            (BOXED2RVAL(o, PANGO_TYPE_LAYOUT_LINE))
+#define RVAL2PANGOLOGATTR(o)               ((PangoLogAttr*)RVAL2BOXED(o, PANGO_TYPE_LOG_ATTR))
+#define PANGOLOGATTR2RVAL(o)               (BOXED2RVAL(o, PANGO_TYPE_LOG_ATTR))
+#define RVAL2PANGOMATRIX(o)                ((PangoMatrix*)RVAL2BOXED(o, PANGO_TYPE_MATRIX))
+#define PANGOMATRIX2RVAL(o)                (BOXED2RVAL(o, PANGO_TYPE_MATRIX))
+#define RVAL2PANGORECTANGLE(o)             ((PangoRectangle*)RVAL2BOXED(o, PANGO_TYPE_RECTANGLE))
+#define PANGORECTANGLE2RVAL(o)             (BOXED2RVAL(o, PANGO_TYPE_RECTANGLE))
+#define RVAL2PANGOSCRIPTITER(o)            ((PangoScriptIter*)RVAL2BOXED(o, PANGO_TYPE_SCRIPT_ITER))
+#define PANGOSCRIPTITER2RVAL(o)            (BOXED2RVAL(o, PANGO_TYPE_SCRIPT_ITER))
+#define RVAL2PANGOTABARRAY(o)              ((PangoTabArray*)RVAL2BOXED(o, PANGO_TYPE_TAB_ARRAY))
+#define PANGOTABARRAY2RVAL(o)              (BOXED2RVAL(o, PANGO_TYPE_TAB_ARRAY))
+
+#define RVAL2PANGOALIGNMENT(o)             (RVAL2GENUM(o, PANGO_TYPE_ALIGNMENT))
+#define PANGOALIGNMENT2RVAL(o)             (GENUM2RVAL(o, PANGO_TYPE_ALIGNMENT))
+#define RVAL2PANGOCOVERAGELEVEL(o)         (RVAL2GENUM(o, PANGO_TYPE_COVERAGE_LEVEL))
+#define PANGOCOVERAGELEVEL2RVAL(o)         (GENUM2RVAL(o, PANGO_TYPE_COVERAGE_LEVEL))
+#define RVAL2PANGODIRECTION(o)             (RVAL2GENUM(o, PANGO_TYPE_DIRECTION))
+#define PANGODIRECTION2RVAL(o)             (GENUM2RVAL(o, PANGO_TYPE_DIRECTION))
+#define RVAL2PANGOELLIPSIZEMODE(o)         (RVAL2GENUM(o, PANGO_TYPE_ELLIPSIZE_MODE))
+#define PANGOELLIPSIZEMODE2RVAL(o)         (GENUM2RVAL(o, PANGO_TYPE_ELLIPSIZE_MODE))
+#define RVAL2PANGOGRAVITY(o)               (RVAL2GENUM(o, PANGO_TYPE_GRAVITY))
+#define PANGOGRAVITY2RVAL(o)               (GENUM2RVAL(o, PANGO_TYPE_GRAVITY))
+#define RVAL2PANGOGRAVITYHINT(o)           (RVAL2GENUM(o, PANGO_TYPE_GRAVITY_HINT))
+#define PANGOGRAVITYHINT2RVAL(o)           (GENUM2RVAL(o, PANGO_TYPE_GRAVITY_HINT))
+#define RVAL2PANGORENDERPART(o)            (RVAL2GENUM(o, PANGO_TYPE_RENDER_PART))
+#define PANGORENDERPART2RVAL(o)            (GENUM2RVAL(o, PANGO_TYPE_RENDER_PART))
+#define RVAL2PANGOSCRIPT(o)                (RVAL2GENUM(o, PANGO_TYPE_SCRIPT))
+#define PANGOSCRIPT2RVAL(o)                (GENUM2RVAL(o, PANGO_TYPE_SCRIPT))
+#define RVAL2PANGOSTRETCH(o)               (RVAL2GENUM(o, PANGO_TYPE_STRETCH))
+#define PANGOSTRETCH2RVAL(o)               (GENUM2RVAL(o, PANGO_TYPE_STRETCH))
+#define RVAL2PANGOSTYLE(o)                 (RVAL2GENUM(o, PANGO_TYPE_STYLE))
+#define PANGOSTYLE2RVAL(o)                 (GENUM2RVAL(o, PANGO_TYPE_STYLE))
+#define RVAL2PANGOTABALIGN(o)              (RVAL2GENUM(o, PANGO_TYPE_TAB_ALIGN))
+#define PANGOTABALIGN2RVAL(o)              (GENUM2RVAL(o, PANGO_TYPE_TAB_ALIGN))
+#define RVAL2PANGOUNDERLINE(o)             (RVAL2GENUM(o, PANGO_TYPE_UNDERLINE))
+#define PANGOUNDERLINE2RVAL(o)             (GENUM2RVAL(o, PANGO_TYPE_UNDERLINE))
+#define RVAL2PANGOVARIANT(o)               (RVAL2GENUM(o, PANGO_TYPE_VARIANT))
+#define PANGOVARIANT2RVAL(o)               (GENUM2RVAL(o, PANGO_TYPE_VARIANT))
+#define RVAL2PANGOWEIGHT(o)                (RVAL2GENUM(o, PANGO_TYPE_WEIGHT))
+#define PANGOWEIGHT2RVAL(o)                (GENUM2RVAL(o, PANGO_TYPE_WEIGHT))
+#define RVAL2PANGOWRAPMODE(o)              (RVAL2GENUM(o, PANGO_TYPE_WRAP_MODE))
+#define PANGOWRAPMODE2RVAL(o)              (GENUM2RVAL(o, PANGO_TYPE_WRAP_MODE))
+
+#define RVAL2PANGOFONTMASK(o)              (RVAL2GFLAGS(o, PANGO_TYPE_FONT_MASK))
+#define PANGOFONTMASK2RVAL(o)              (GFLAGS2RVAL(o, PANGO_TYPE_FONT_MASK))
+
+#endif /* __PANGOCONVERSIONS_H__ */

data/ext/pango/rbpangocoverage.c

@@ -0,0 +1,106 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 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 cCoverage
+#define _SELF(self) (RVAL2PANGOCOVERAGE(self))
+
+/**********************************/
+GType
+pango_coverage_get_type(void)
+{
+    static GType our_type = 0;
+
+    if (our_type == 0)
+        our_type = g_boxed_type_register_static ("PangoCoverage",
+                    (GBoxedCopyFunc)pango_coverage_copy,
+                    (GBoxedFreeFunc)pango_coverage_unref);
+    return our_type;
+}
+/**********************************/
+
+static VALUE
+rg_initialize(VALUE self)
+{
+    G_INITIALIZE(self, pango_coverage_new());
+    return Qnil;
+}
+
+static VALUE
+rg_get_level(VALUE self, VALUE index_)
+{
+    return PANGOCOVERAGELEVEL2RVAL(pango_coverage_get(_SELF(self), NUM2INT(index_)));
+}
+
+static VALUE
+rg_max_bang(VALUE self, VALUE other)
+{
+    pango_coverage_max(_SELF(self), _SELF(other));
+    return self;
+}
+
+static VALUE
+rg_set(VALUE self, VALUE index_, VALUE level)
+{
+    pango_coverage_set(_SELF(self), NUM2INT(index_), 
+                       RVAL2PANGOCOVERAGELEVEL(level));
+    return self;
+}
+
+static VALUE
+rg_to_bytes(VALUE self)
+{
+    guchar* bytes;
+    int n_bytes;
+    VALUE ret;
+
+    pango_coverage_to_bytes(_SELF(self), &bytes, &n_bytes);
+    ret = rb_str_new((const char*)bytes, n_bytes);
+    g_free(bytes);
+
+    return ret;
+}
+
+static VALUE
+rg_s_from_bytes(G_GNUC_UNUSED VALUE self, VALUE bytes)
+{
+    StringValue(bytes);
+    return PANGOCOVERAGE2RVAL(pango_coverage_from_bytes((guchar *)RSTRING_PTR(bytes), 
+                                                        RSTRING_LEN(bytes)));
+}
+
+void
+Init_pango_coverage(VALUE mPango)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(PANGO_TYPE_COVERAGE, "Coverage", mPango);
+
+    RG_DEF_METHOD(initialize, 0);
+    RG_DEF_METHOD(get_level, 0);
+    RG_DEF_METHOD_BANG(max, 1);
+    RG_DEF_METHOD(set, 2);
+    RG_DEF_METHOD(to_bytes, 0);
+    RG_DEF_SMETHOD(from_bytes, 1);
+
+    /* PangoCoverageLevel */
+    G_DEF_CLASS(PANGO_TYPE_COVERAGE_LEVEL, "Level", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, PANGO_TYPE_COVERAGE_LEVEL, "PANGO_COVERAGE_");
+}

data/ext/pango/rbpangoengine.c

@@ -0,0 +1,73 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 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"
+
+#ifdef PANGO_TYPE_ENGINE
+
+#define _SELF(self) (RVAL2PANGOENGINE(self))
+
+/* FIXME
+static VALUE
+rbpango_s_engine_list(VALUE self)
+{
+    PangoEngineInfo* engines = g_new(PangoEngineInfo, 1);
+    int i, n;
+    VALUE ary;
+
+    script_engine_list(&engines, &n);
+    ary = rb_ary_new();
+
+    for(i = 0; i < n; i++){
+        rb_ary_push(ary, GOBJ2RVAL(&engines[i]));
+    }
+    return ary;
+}
+
+static VALUE
+rbpango_s_engine_create(VALUE self, VALUE id)
+{
+    return GOBJ2RVAL(script_engine_create(RVAL2CSTR(id)));
+}
+*/
+/*
+void        script_engine_init              (GTypeModule *module);
+void        script_engine_exit              (void);
+PangoEngine* script_engine_create           (const char *id);
+*/
+
+#endif
+
+void
+Init_pango_engine(VALUE mPango)
+{
+#ifdef PANGO_TYPE_ENGINE
+    G_DEF_CLASS(PANGO_TYPE_ENGINE, "Engine", mPango);
+
+/* FIXME
+    rb_define_singleton_method(engine, "engines", rbpango_s_engine_list, 0);
+    rb_define_singleton_method(engine, "create", rbpango_s_engine_create, 1);
+*/
+    G_DEF_CLASS(PANGO_TYPE_ENGINE_LANG, "EngineLang", mPango);
+    G_DEF_CLASS(PANGO_TYPE_ENGINE_SHAPE, "EngineShape", mPango);
+#endif
+}
+