pango 0.90.2-x86-mingw32

data/ext/pango/rbpangocoverage.c

@@ -0,0 +1,104 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbpangocoverage.c -
+
+  $Author: sakai $
+  $Date: 2007/07/08 02:53:10 $
+
+  Copyright (C) 2005 Masao Mutoh
+************************************************/
+
+#include "rbpango.h"
+
+#define _SELF(self) ((PangoCoverage*)RVAL2BOXED(self, PANGO_TYPE_COVERAGE))
+
+
+/**********************************/
+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
+coverage_initialize(self)
+    VALUE self;
+{
+    G_INITIALIZE(self, pango_coverage_new());
+    return Qnil;
+}
+
+static VALUE
+coverage_get_level(self, index_)
+    VALUE self, index_;
+{
+    return GENUM2RVAL(pango_coverage_get(_SELF(self), NUM2INT(index_)), 
+                      PANGO_TYPE_COVERAGE_LEVEL);
+}
+
+static VALUE
+coverage_max(self, other)
+    VALUE self, other;
+{
+    pango_coverage_max(_SELF(self), _SELF(other));
+    return self;
+}
+
+static VALUE
+coverage_set(self, index_, level)
+    VALUE self, index_, level;
+{
+    pango_coverage_set(_SELF(self), NUM2INT(index_), 
+                       RVAL2GENUM(level, PANGO_TYPE_COVERAGE_LEVEL));
+    return self;
+}
+
+static VALUE
+coverage_to_bytes(self)
+    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
+coverage_s_from_bytes(self, bytes)
+    VALUE self, bytes;
+{
+    StringValue(bytes);
+    return BOXED2RVAL(pango_coverage_from_bytes((guchar*)RVAL2CSTR(bytes), 
+                                                RSTRING_LEN(bytes)),
+                      PANGO_TYPE_COVERAGE);
+}
+
+void
+Init_pango_coverage()
+{
+    VALUE pCoverage = G_DEF_CLASS(PANGO_TYPE_COVERAGE, "Coverage", mPango);
+    
+    rb_define_method(pCoverage, "initialize", coverage_initialize, 0);
+    rb_define_method(pCoverage, "get_level", coverage_get_level, 0);
+    rb_define_method(pCoverage, "max!", coverage_max, 1);
+    rb_define_method(pCoverage, "set", coverage_set, 2);
+    rb_define_method(pCoverage, "to_bytes", coverage_to_bytes, 0);
+    rb_define_singleton_method(pCoverage, "from_bytes", coverage_s_from_bytes, 1);
+
+    /* PangoCoverageLevel */
+    G_DEF_CLASS(PANGO_TYPE_COVERAGE_LEVEL, "Level", pCoverage);
+    G_DEF_CONSTANTS(pCoverage, PANGO_TYPE_COVERAGE_LEVEL, "PANGO_COVERAGE_");
+}

data/ext/pango/rbpangoengine.c

@@ -0,0 +1,65 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbpangoengine.c -
+
+  $Author: mutoh $
+  $Date: 2005/10/15 04:32:01 $
+
+  Copyright (C) 2005 Masao Mutoh
+************************************************/
+
+#include "rbpango.h"
+
+#ifdef PANGO_TYPE_ENGINE
+
+#define _SELF(self) (PANGO_ENGINE(RVAL2GOBJ(self)))
+
+/* FIXME
+static VALUE
+rbpango_s_engine_list(self)
+    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(self, id)
+    VALUE self, 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()
+{
+#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
+}
+

data/ext/pango/rbpangofont.c

@@ -0,0 +1,123 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbpangofont.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:33 $
+
+  Copyright (C) 2002-2006 Masao Mutoh
+************************************************/
+
+#include "rbpango.h"
+
+#define _SELF(self) (PANGO_FONT(RVAL2GOBJ(self)))
+
+static VALUE
+font_find_shaper(self, language, ch)
+    VALUE self, language, ch;
+{
+    return GOBJ2RVAL(pango_font_find_shaper(_SELF(self), 
+                                            (PangoLanguage*)RVAL2BOXED(language, PANGO_TYPE_LANGUAGE),
+                                            NUM2UINT(ch)));
+}
+
+static VALUE
+font_describe(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE desc, absolute_size;
+    rb_scan_args(argc, argv, "01", &absolute_size);
+
+    if (NIL_P(absolute_size) || ! RVAL2CBOOL(absolute_size)){
+        desc = BOXED2RVAL(pango_font_describe(_SELF(self)), PANGO_TYPE_FONT_DESCRIPTION);
+    } else {
+#if PANGO_CHECK_VERSION(1,14,0)
+        desc = BOXED2RVAL(pango_font_describe_with_absolute_size(_SELF(self)), 
+                          PANGO_TYPE_FONT_DESCRIPTION);
+#else
+        rb_warning("Pango::Font#describe(absolute) has been supported since GTK+-2.10.x. Use Pango::Font#describe() instead."); 
+        desc = BOXED2RVAL(pango_font_describe(_SELF(self)), PANGO_TYPE_FONT_DESCRIPTION);
+#endif
+    }
+    return desc;
+}
+
+static VALUE
+font_get_coverage(self, language)
+    VALUE self, language;
+{
+    PangoCoverage* c = pango_font_get_coverage(_SELF(self), 
+                                               (PangoLanguage*)RVAL2BOXED(language, PANGO_TYPE_LANGUAGE));
+    return BOXED2RVAL(c, PANGO_TYPE_COVERAGE);
+}
+
+static VALUE
+font_get_glyph_extents(self, glyph)
+    VALUE self, glyph;
+{
+    PangoRectangle ink_rect, logical_rect;
+    pango_font_get_glyph_extents(_SELF(self),
+                                 NUM2UINT(glyph),
+                                 &ink_rect, &logical_rect);
+
+    return rb_assoc_new(BOXED2RVAL(&ink_rect, PANGO_TYPE_RECTANGLE),
+                        BOXED2RVAL(&logical_rect, PANGO_TYPE_RECTANGLE));
+                    
+}
+
+static VALUE
+font_get_metrics(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE language;
+    PangoLanguage* lang = NULL;
+    
+    rb_scan_args(argc, argv, "01", &language);
+    
+    if (!NIL_P(language))
+        lang = (PangoLanguage*)RVAL2BOXED(language, PANGO_TYPE_LANGUAGE);
+
+    return BOXED2RVAL(pango_font_get_metrics(_SELF(self), lang), 
+                      PANGO_TYPE_FONT_METRICS);
+}
+
+#if PANGO_CHECK_VERSION(1,9,0)
+static VALUE
+font_get_font_map(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(pango_font_get_font_map(_SELF(self)));
+}
+#endif
+
+void
+Init_pango_font()
+{
+    VALUE pFont = G_DEF_CLASS(PANGO_TYPE_FONT, "Font", mPango);
+    
+    rb_define_method(pFont, "find_shaper", font_find_shaper, 2);
+    rb_define_method(pFont, "describe", font_describe, -1);
+    rb_define_method(pFont, "get_coverage", font_get_coverage, 1);
+    rb_define_method(pFont, "get_glyph_extents", font_get_glyph_extents, 1);
+    rb_define_method(pFont, "metrics", font_get_metrics, -1);
+
+#if PANGO_CHECK_VERSION(1,9,0)
+    rb_define_method(pFont, "font_map", font_get_font_map, 0);
+#endif
+
+    G_DEF_CLASS3("PangoXFont", "XFont", mPango);
+    G_DEF_CLASS3("PangoFT2Font", "FT2Font", mPango);
+    G_DEF_CLASS3("PangoFcFont", "FcFont", mPango);
+    G_DEF_CLASS3("PangoXftFont", "XftFont", mPango);
+    G_DEF_CLASS3("PangoCairoFcFont", "CairoFcFont", mPango);
+    G_DEF_CLASS3("PangoCairoFont", "CairoFont", mPango);
+    G_DEF_CLASS3("PangoCairoWin32Font", "CairoWin32Font", mPango);
+#if PANGO_CHECK_VERSION(1,12,0)
+    G_DEF_CLASS3("PangoATSUIFont", "ATSUIFont", mPango);
+#endif
+}

data/ext/pango/rbpangofontdescription.c

@@ -0,0 +1,300 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbpangofontdescription.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:33 $
+
+  Copyright (C) 2002-2005 Masao Mutoh
+************************************************/
+
+#include "rbpango.h"
+
+#define _SELF(self) ((PangoFontDescription*)RVAL2BOXED(self, PANGO_TYPE_FONT_DESCRIPTION))
+
+static VALUE
+font_desc_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE str;
+    PangoFontDescription *description;
+
+    rb_scan_args(argc, argv, "01", &str);
+
+    if (NIL_P(str)) {
+	description = pango_font_description_new();
+    } else {
+        description = pango_font_description_from_string(RVAL2CSTR(str));
+    }
+
+    G_INITIALIZE(self, description);
+    pango_font_description_free(description);
+
+    return Qnil;
+}
+/*
+PangoFontDescription* pango_font_description_copy
+                                            (const PangoFontDescription *desc);
+PangoFontDescription* pango_font_description_copy_static
+                                            (const PangoFontDescription *desc);
+*/
+
+static VALUE
+font_desc_hash(self)
+    VALUE self;
+{
+    return UINT2NUM(pango_font_description_hash(_SELF(self)));
+}
+
+static VALUE
+font_desc_equal(self, other)
+    VALUE self, other;
+{
+    return CBOOL2RVAL(pango_font_description_equal(_SELF(self), _SELF(other)));
+}
+
+/* Don't we need this?
+void        pango_font_descriptions_free    (PangoFontDescription **descs,
+                                             int n_descs);
+*/
+
+static VALUE
+font_desc_set_family(self, family)
+    VALUE self, family;
+{
+    pango_font_description_set_family(_SELF(self), RVAL2CSTR(family));
+    return self;
+}
+/* Don't we need this?
+void        pango_font_description_set_family_static
+                                            (PangoFontDescription *desc,
+                                             const char *family);
+*/
+
+static VALUE
+font_desc_get_family(self)
+    VALUE self;
+{
+    return CSTR2RVAL(pango_font_description_get_family(_SELF(self)));
+}
+
+static VALUE
+font_desc_set_style(self, style)
+    VALUE self, style;
+{
+    pango_font_description_set_style(_SELF(self), RVAL2GENUM(style, PANGO_TYPE_STYLE));
+    return self;
+}
+
+static VALUE
+font_desc_get_style(self)
+    VALUE self;
+{
+    return GENUM2RVAL(pango_font_description_get_style(_SELF(self)), PANGO_TYPE_STYLE);
+}
+
+static VALUE
+font_desc_set_variant(self, variant)
+    VALUE self, variant;
+{
+    pango_font_description_set_variant(_SELF(self), RVAL2GENUM(variant, PANGO_TYPE_VARIANT));
+    return self;
+}
+
+static VALUE
+font_desc_get_variant(self)
+    VALUE self;
+{
+    return GENUM2RVAL(pango_font_description_get_variant(_SELF(self)), PANGO_TYPE_VARIANT);
+}
+
+static VALUE
+font_desc_set_weight(VALUE self, VALUE weight)
+{
+    pango_font_description_set_weight(_SELF(self),
+				      RVAL2GENUM(weight, PANGO_TYPE_WEIGHT));
+    return self;
+}
+
+static VALUE
+font_desc_get_weight(self)
+    VALUE self;
+{
+    return GENUM2RVAL(pango_font_description_get_weight(_SELF(self)), PANGO_TYPE_WEIGHT);
+}
+
+static VALUE
+font_desc_set_stretch(self, stretch)
+    VALUE self, stretch;
+{
+    pango_font_description_set_stretch(_SELF(self), RVAL2GENUM(stretch, PANGO_TYPE_STRETCH));
+    return self;
+}
+
+static VALUE
+font_desc_get_stretch(self)
+    VALUE self;
+{
+    return GENUM2RVAL(pango_font_description_get_stretch(_SELF(self)), PANGO_TYPE_STRETCH);
+}
+
+static VALUE
+font_desc_set_size(self, size)
+    VALUE self, size;
+{
+    pango_font_description_set_size(_SELF(self), NUM2INT(size));
+    return self;
+}
+
+static VALUE
+font_desc_get_size(self)
+    VALUE self;
+{
+    return INT2NUM(pango_font_description_get_size(_SELF(self)));
+}
+
+#if PANGO_CHECK_VERSION(1,8,0)
+static VALUE
+font_desc_set_absolute_size(self, size)
+    VALUE self, size;
+{
+    pango_font_description_set_absolute_size(_SELF(self), NUM2INT(size));
+    return self;
+}
+
+static VALUE
+font_desc_get_size_is_absolute(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(pango_font_description_get_size_is_absolute(_SELF(self)));
+}
+#endif
+
+#if PANGO_CHECK_VERSION(1,16,0)
+static VALUE
+font_desc_get_gravity(VALUE self)
+{
+    return GENUM2RVAL(pango_font_description_get_gravity(_SELF(self)), PANGO_TYPE_GRAVITY);
+}
+
+static VALUE
+font_desc_set_gravity(VALUE self, VALUE gravity)
+{
+    pango_font_description_set_gravity(_SELF(self), RVAL2GENUM(gravity, PANGO_TYPE_GRAVITY));
+    return self;
+}
+#endif
+
+static VALUE
+font_desc_get_set_fields(self)
+    VALUE self;
+{
+    return GFLAGS2RVAL(pango_font_description_get_set_fields(_SELF(self)), PANGO_TYPE_FONT_MASK);
+}
+
+static VALUE
+font_desc_unset_fields(self, to_unset)
+    VALUE self, to_unset;
+{
+    pango_font_description_unset_fields(_SELF(self), RVAL2GFLAGS(to_unset, PANGO_TYPE_FONT_MASK));
+    return self;
+}
+
+static VALUE
+font_desc_merge(self, desc_to_merge, replace_existing)
+    VALUE self, desc_to_merge, replace_existing;
+{
+    pango_font_description_merge(_SELF(self), _SELF(desc_to_merge),
+                                 RVAL2CBOOL(replace_existing));
+    return self;
+}
+
+/* Don't we need this?
+void        pango_font_description_merge_static
+                                            (PangoFontDescription *desc,
+                                             const PangoFontDescription *desc_to_merge,
+                                             gboolean replace_existing);
+*/
+
+static VALUE
+font_desc_better_match(self, old_match, new_match)
+    VALUE self, old_match, new_match;
+{
+    return CBOOL2RVAL(pango_font_description_better_match(_SELF(self), 
+                                                          _SELF(old_match),
+                                                          _SELF(new_match)));
+}
+
+static VALUE
+font_desc_to_string(self)
+    VALUE self;
+{
+    return CSTR2RVAL(pango_font_description_to_string(_SELF(self)));
+}
+
+static VALUE
+font_desc_to_filename(self)
+    VALUE self;
+{
+    return CSTR2RVAL(pango_font_description_to_filename(_SELF(self)));
+}
+
+void
+Init_pango_font_description()
+{
+    VALUE pFontDesc = G_DEF_CLASS(PANGO_TYPE_FONT_DESCRIPTION, "FontDescription", mPango);
+
+    rb_define_method(pFontDesc, "initialize", font_desc_initialize, -1);
+    rb_define_method(pFontDesc, "hash", font_desc_hash, 0);
+    rb_define_method(pFontDesc, "==", font_desc_equal, 1);
+    rb_define_method(pFontDesc, "set_family", font_desc_set_family, 1);
+    rb_define_method(pFontDesc, "family", font_desc_get_family, 0);
+    rb_define_method(pFontDesc, "set_style", font_desc_set_style, 1);
+    rb_define_method(pFontDesc, "style", font_desc_get_style, 0);
+    rb_define_method(pFontDesc, "set_variant", font_desc_set_variant, 1);
+    rb_define_method(pFontDesc, "variant", font_desc_get_variant, 0);
+    rb_define_method(pFontDesc, "set_weight", font_desc_set_weight, 1);
+    rb_define_method(pFontDesc, "weight", font_desc_get_weight, 0);
+    rb_define_method(pFontDesc, "set_stretch", font_desc_set_stretch, 1);
+    rb_define_method(pFontDesc, "stretch", font_desc_get_stretch, 0);
+    rb_define_method(pFontDesc, "set_size", font_desc_set_size, 1);
+    rb_define_method(pFontDesc, "size", font_desc_get_size, 0);
+
+#if PANGO_CHECK_VERSION(1,8,0)
+    rb_define_method(pFontDesc, "set_absolute_size", font_desc_set_absolute_size, 1);
+    rb_define_method(pFontDesc, "size_is_absolute?", font_desc_get_size_is_absolute, 0);
+#endif
+#if PANGO_CHECK_VERSION(1,16,0)
+    rb_define_method(pFontDesc, "set_gravity", font_desc_set_gravity, 1);
+    rb_define_method(pFontDesc, "gravity", font_desc_get_gravity, 0);
+#endif
+    rb_define_method(pFontDesc, "set_fields", font_desc_get_set_fields, 0);
+    rb_define_method(pFontDesc, "unset_fields", font_desc_unset_fields, 1);
+    rb_define_method(pFontDesc, "merge", font_desc_merge, 2);
+    rb_define_method(pFontDesc, "better_match", font_desc_better_match, 2);
+    rb_define_method(pFontDesc, "to_str", font_desc_to_string, 0);
+    rb_define_alias(pFontDesc, "to_s", "to_str");
+    rb_define_method(pFontDesc, "to_filename", font_desc_to_filename, 0);
+
+    G_DEF_SETTERS(pFontDesc);
+
+    /* PangoStyle */
+    G_DEF_CLASS(PANGO_TYPE_STYLE, "Style", pFontDesc);
+    G_DEF_CONSTANTS(pFontDesc, PANGO_TYPE_STYLE, "PANGO_");
+
+    /* PangoWeight */
+    G_DEF_CLASS(PANGO_TYPE_WEIGHT, "Weight", pFontDesc);
+    G_DEF_CONSTANTS(pFontDesc, PANGO_TYPE_WEIGHT, "PANGO_");
+
+    /* PangoVariant */
+    G_DEF_CLASS(PANGO_TYPE_VARIANT, "Variant", pFontDesc);
+    G_DEF_CONSTANTS(pFontDesc, PANGO_TYPE_VARIANT, "PANGO_");
+
+    /* PangoStretch */
+    G_DEF_CLASS(PANGO_TYPE_STRETCH, "Stretch", pFontDesc);
+    G_DEF_CONSTANTS(pFontDesc, PANGO_TYPE_STRETCH, "PANGO_");
+
+    /* PangoFontMask */
+    G_DEF_CLASS(PANGO_TYPE_FONT_MASK, "FontMask", pFontDesc);
+    G_DEF_CONSTANTS(pFontDesc, PANGO_TYPE_FONT_MASK, "PANGO_");
+}