pango 0.20.0

data/src/rbpangoglyphinfo.c

@@ -0,0 +1,119 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbpangoglyphinfo.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:33 $
+
+  Copyright (C) 2005 Masao Mutoh
+************************************************/
+
+#include "rbpango.h"
+
+#define _SELF(self) ((PangoGlyphInfo*)RVAL2BOXED(self, PANGO_TYPE_GLYPH_INFO))
+
+
+/**********************************/
+PangoGlyphInfo*
+pango_glyph_info_copy (const PangoGlyphInfo* info)
+{
+  PangoGlyphInfo* data;
+  g_return_val_if_fail (info != NULL, NULL);
+  data = g_new(PangoGlyphInfo, 1);
+  *data = *info;
+  return data;
+}
+
+GType
+pango_glyph_info_get_type(void)
+{
+    static GType our_type = 0;
+
+    if (our_type == 0)
+        our_type = g_boxed_type_register_static ("PangoGlyphInfo",
+                    (GBoxedCopyFunc)pango_glyph_info_copy,
+                    (GBoxedFreeFunc)g_free);
+    return our_type;
+}
+/**********************************/
+
+static VALUE
+gi_initialize(self)
+    VALUE self;
+{
+    G_INITIALIZE(self, g_new0(PangoGlyphInfo, 1));
+    return Qnil;
+}
+
+static VALUE
+gi_glyph(self)
+    VALUE self;
+{
+    return UINT2NUM(_SELF(self)->glyph);
+}
+
+static VALUE
+gi_set_glyph(self, val)
+    VALUE self, val;
+{
+    _SELF(self)->glyph = NUM2UINT(val);
+    return self;
+}
+
+static VALUE
+gi_geometry(self)
+    VALUE self;
+{
+    PangoGlyphGeometry geo = _SELF(self)->geometry;
+
+    return rb_ary_new3(3, INT2NUM(geo.width), 
+                       INT2NUM(geo.x_offset), INT2NUM(geo.y_offset));
+}
+
+static VALUE
+gi_set_geometry(self, width, x_offset, y_offset)
+    VALUE self;
+{
+    PangoGlyphGeometry geo = _SELF(self)->geometry;
+
+    geo.width = NUM2INT(width);
+    geo.x_offset = NUM2INT(x_offset);
+    geo.y_offset = NUM2INT(y_offset);
+
+    return self;
+}
+
+/*
+  This method may be changed in the future following Pango implementation.
+ */
+static VALUE
+gi_attr_is_cluster_start(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(_SELF(self)->attr.is_cluster_start);
+}
+
+static VALUE
+gi_attr_set_is_cluster_start(self, val)
+    VALUE self, val;
+{
+    _SELF(self)->attr.is_cluster_start = RVAL2CBOOL(val);
+    return self;
+}
+
+void
+Init_pango_glyph_info()
+{
+    VALUE pInfo = G_DEF_CLASS(PANGO_TYPE_GLYPH_INFO, "GlyphInfo", mPango);
+    
+    rb_define_method(pInfo, "initialize", gi_initialize, 0);
+    rb_define_method(pInfo, "glyph", gi_glyph, 0);
+    rb_define_method(pInfo, "set_glyph", gi_set_glyph, 1);
+    rb_define_method(pInfo, "geometry", gi_geometry, 0);
+    rb_define_method(pInfo, "set_geometry", gi_set_geometry, 3);
+    rb_define_method(pInfo, "cluster_start?", gi_attr_is_cluster_start, 0);
+    rb_define_method(pInfo, "set_cluster_start", gi_attr_set_is_cluster_start, 1);
+
+    G_DEF_SETTERS(pInfo);
+}

data/src/rbpangoglyphitem.c

@@ -0,0 +1,129 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbpangoglyphitem.c -
+
+  $Author: ggc $
+  $Date: 2006/06/22 19:52:54 $
+
+  Copyright (C) 2002-2005 Masao Mutoh
+************************************************/
+
+#include "rbpango.h"
+
+#if PANGO_CHECK_VERSION(1,2,0)
+#define _SELF(r) ((PangoGlyphItem*)RVAL2BOXED(r, PANGO_TYPE_GLYPH_ITEM))
+
+/**********************************/
+#ifndef HAVE_PANGO_GLYPH_ITEM_GET_TYPE
+static PangoGlyphItem*
+glyph_item_copy(ref)
+    const PangoGlyphItem* ref;
+{
+  PangoGlyphItem* new_ref;
+  g_return_val_if_fail (ref != NULL, NULL);
+  new_ref = g_new(PangoGlyphItem, 1);
+  *new_ref = *ref;
+  return new_ref;
+}
+
+#  ifndef HAVE_PANGO_GLYPH_ITEM_FREE
+void
+pango_glyph_item_free(PangoGlyphItem* glyph_item)
+{
+    if (glyph_item->item)
+        pango_item_free(glyph_item->item);
+    if (glyph_item->glyphs)
+        pango_glyph_string_free(glyph_item->glyphs);
+    g_free(glyph_item);
+}
+#  endif
+
+GType
+pango_glyph_item_get_type(void)
+{
+    static GType our_type = 0;
+
+    if (our_type == 0)
+        our_type = g_boxed_type_register_static ("PangoGlyphItem",
+                    (GBoxedCopyFunc)glyph_item_copy,
+                    (GBoxedFreeFunc)pango_glyph_item_free);
+    return our_type;
+}
+#endif
+/**********************************/
+
+static VALUE
+glyph_item_get_item(self)
+    VALUE self;
+{
+    PangoItem* item = _SELF(self)->item;
+    return BOXED2RVAL(item, PANGO_TYPE_ITEM);
+}
+
+static VALUE
+glyph_item_get_glyphs(self)
+    VALUE self;
+{
+    PangoGlyphString* glyphs = _SELF(self)->glyphs;
+    return BOXED2RVAL(glyphs, PANGO_TYPE_GLYPH_STRING);
+}
+
+static VALUE
+glyph_item_split(self, text, split_index)
+    VALUE self, text, split_index;
+{
+    return BOXED2RVAL(pango_glyph_item_split(_SELF(self), RVAL2CSTR(text),
+                                             NUM2INT(split_index)), PANGO_TYPE_GLYPH_ITEM);
+}
+
+static VALUE
+glyph_item_apply_attrs(self, text, attrs)
+    VALUE self, text, attrs;
+{
+    GSList* list = pango_glyph_item_apply_attrs(_SELF(self), RVAL2CSTR(text),
+                                                (PangoAttrList*)RVAL2BOXED(attrs, PANGO_TYPE_ATTR_LIST));
+
+    VALUE ret = rb_ary_new();
+
+    while (list) {
+        rb_ary_push(ret, BOXED2RVAL(list->data, PANGO_TYPE_GLYPH_ITEM));
+        pango_glyph_item_free(list->data); 
+        list = list->next;
+    }
+   
+    g_slist_free(list);
+    return ret;
+}
+
+#if PANGO_CHECK_VERSION(1,6,0)
+static VALUE
+glyph_item_letter_space(self, text, log_attrs, letter_spacing)
+    VALUE self, text, log_attrs, letter_spacing;
+{
+    pango_glyph_item_letter_space(_SELF(self), RVAL2CSTR(text),
+                                  (PangoLogAttr*)RVAL2BOXED(log_attrs, PANGO_TYPE_LOG_ATTR),
+                                  NUM2INT(letter_spacing));
+    return self;
+}
+#endif
+#endif
+
+void
+Init_pango_glyph_item()
+{
+#if PANGO_CHECK_VERSION(1,2,0)
+    VALUE pItem = G_DEF_CLASS(PANGO_TYPE_GLYPH_ITEM, "GlyphItem", mPango);
+
+    rb_define_method(pItem, "item", glyph_item_get_item, 0);
+    rb_define_method(pItem, "glyphs", glyph_item_get_glyphs, 0);
+
+    rb_define_method(pItem, "split", glyph_item_split, 2);
+    rb_define_method(pItem, "appy_attrs", glyph_item_apply_attrs, 2);
+
+#if PANGO_CHECK_VERSION(1,6,0)
+    rb_define_method(pItem, "letter_space", glyph_item_letter_space, 3);
+#endif
+#endif
+}
+

data/src/rbpangoglyphstring.c

@@ -0,0 +1,162 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbpangoglyphstring.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:33 $
+
+  Copyright (C) 2002-2006 Masao Mutoh
+************************************************/
+
+#include "rbpango.h"
+
+#define _SELF(self) ((PangoGlyphString*)(RVAL2BOXED(self, PANGO_TYPE_GLYPH_STRING)))
+
+static VALUE
+rglyph_initialize(self)
+    VALUE self;
+{
+    G_INITIALIZE(self, pango_glyph_string_new());
+    return Qnil;
+}
+
+static VALUE
+rglyph_set_size(self, len)
+    VALUE self, len;
+{
+    pango_glyph_string_set_size(_SELF(self), NUM2INT(len));
+    return self;
+}
+
+static VALUE
+rglyph_extents(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE font, start_index, end_index;
+    PangoRectangle ink_rect;
+    PangoRectangle logical_rect;
+
+    rb_scan_args(argc, argv, "12", &font, &start_index, &end_index);
+
+    if (NIL_P(start_index)){
+        pango_glyph_string_extents(_SELF(self), 
+                                   PANGO_FONT(RVAL2GOBJ(font)),
+                                   &ink_rect, &logical_rect);
+    } else {
+        pango_glyph_string_extents_range(_SELF(self), 
+                                         NUM2INT(start_index), NUM2INT(end_index),
+                                         PANGO_FONT(RVAL2GOBJ(font)),
+                                         &ink_rect, &logical_rect);
+    }
+
+    return rb_assoc_new(BOXED2RVAL(&ink_rect, PANGO_TYPE_RECTANGLE),
+                        BOXED2RVAL(&logical_rect, PANGO_TYPE_RECTANGLE));
+}
+
+#if PANGO_CHECK_VERSION(1,14,0)
+static VALUE
+rglyph_get_width(self)
+    VALUE self;
+{
+    return INT2NUM(pango_glyph_string_get_width(_SELF(self)));
+}
+#endif
+
+static VALUE
+rglyph_index_to_x(self, text, analysis, index, trailing)
+    VALUE self, text, analysis, index, trailing;
+{
+    int x_pos;
+    StringValue(text);
+
+    pango_glyph_string_index_to_x(_SELF(self),
+                                  RVAL2CSTR(text),
+                                  RSTRING_LEN(text),
+                                  (PangoAnalysis*)RVAL2BOXED(analysis, PANGO_TYPE_ANALYSIS),
+                                  NUM2INT(index), RVAL2CBOOL(trailing),
+                                  &x_pos);
+    return INT2NUM(x_pos);
+}
+
+static VALUE
+rglyph_x_to_index(self, text, analysis, x_pos)
+    VALUE self, text, analysis, x_pos;
+{
+    int index;
+    int trailing;
+
+    StringValue(text);
+    pango_glyph_string_x_to_index(_SELF(self),
+                                  RVAL2CSTR(text), RSTRING_LEN(text),
+                                  (PangoAnalysis*)RVAL2BOXED(analysis, PANGO_TYPE_ANALYSIS),
+                                  NUM2INT(x_pos),
+                                  &index, &trailing);
+    return rb_assoc_new(INT2NUM(index), CBOOL2RVAL(trailing));
+}
+
+static VALUE
+rglyph_get_logical_widgths(self, text, embedding_level)
+    VALUE self, text, embedding_level;
+{
+    int* logical_widths = NULL;
+    int len, array_len, i;
+    char* gtext;
+    VALUE ret;
+
+    gtext = RVAL2CSTR(text);
+    len = RSTRING_LEN(text);
+
+    array_len = g_utf8_strlen(gtext, len);
+
+    logical_widths = g_new(PangoGlyphUnit, array_len);
+
+    pango_glyph_string_get_logical_widths(_SELF(self), gtext, len,
+                                          NUM2INT(embedding_level),
+                                          logical_widths);
+
+    ret = rb_ary_new();
+    for (i = 0; i < array_len; i++){
+        rb_ary_push(ret, INT2NUM(logical_widths[i]));
+    }
+
+    return ret;
+}
+
+static VALUE
+rglyph_get_glyphs(self)
+    VALUE self;
+{
+    int i;
+    PangoGlyphInfo** glyphs = &_SELF(self)->glyphs;
+    gint* log_clusters = _SELF(self)->log_clusters;
+
+    VALUE ret = rb_ary_new();
+    for (i = 0; i < _SELF(self)->num_glyphs; i++) {
+        rb_ary_push(ret, 
+                    rb_assoc_new(BOXED2RVAL(glyphs[i], PANGO_TYPE_GLYPH_INFO),
+                                 INT2NUM(log_clusters[i])));
+    }
+    return ret;
+}
+
+void
+Init_pango_glyph_string()
+{
+    VALUE pGlyph = G_DEF_CLASS(PANGO_TYPE_GLYPH_STRING, "GlyphString", mPango);
+
+    rb_define_method(pGlyph, "initialize", rglyph_initialize, 0);
+    rb_define_method(pGlyph, "set_size", rglyph_set_size, 1);
+    rb_define_method(pGlyph, "extents", rglyph_extents, -1);
+#if PANGO_CHECK_VERSION(1,14,0)
+    rb_define_method(pGlyph, "width", rglyph_get_width, 0);
+#endif
+    rb_define_method(pGlyph, "index_to_x", rglyph_index_to_x, 4);
+    rb_define_method(pGlyph, "x_to_index", rglyph_x_to_index, 3);
+    rb_define_method(pGlyph, "get_logical_widths", rglyph_get_logical_widgths, 2);
+    rb_define_method(pGlyph, "glyphs", rglyph_get_glyphs, 0);
+
+    G_DEF_SETTERS(pGlyph);
+}

data/src/rbpangogravity.c

@@ -0,0 +1,43 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbpangogravity.c -
+
+  $Author: ito $
+  $Date: 2010/01/17 03:00:50 $
+
+************************************************/
+
+#include "rbpango.h"
+
+
+#if PANGO_CHECK_VERSION(1,16,0)
+static VALUE
+to_rotation(VALUE self, VALUE gravity)
+{
+    return rb_float_new(pango_gravity_to_rotation(RVAL2GENUM(gravity, PANGO_TYPE_GRAVITY)));
+}
+
+static VALUE
+is_vertical(VALUE self, VALUE gravity)
+{
+    return CBOOL2RVAL(PANGO_GRAVITY_IS_VERTICAL(RVAL2GENUM(gravity, PANGO_TYPE_GRAVITY)));
+}
+#endif
+
+void
+Init_pango_gravity()
+{
+#if PANGO_CHECK_VERSION(1,16,0)
+    VALUE mGravity = 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);
+
+    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_");
+#endif
+}
+