atk 0.90.2-x86-mingw32

data/ext/atk/rbatktext.c

@@ -0,0 +1,364 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbatktext.c -
+
+  $Author: sakai $
+  $Date: 2006/05/26 14:12:06 $
+
+  Copyright (C) 2004 Masao Mutoh
+************************************************/
+
+#include "rbatk.h"
+
+#define _SELF(s) (ATK_TEXT(RVAL2GOBJ(s)))
+
+static VALUE
+rbatk_text_get_text(self, start_offset, end_offset)
+    VALUE self, start_offset, end_offset;
+{
+    VALUE ret;
+    gchar* text = atk_text_get_text(_SELF(self), 
+                                    NUM2INT(start_offset), 
+                                    NUM2INT(end_offset));
+    ret = CSTR2RVAL(text);
+    g_free(text);
+    return ret;
+}
+
+static VALUE
+rbatk_text_get_character_at_offset(self, offset)
+    VALUE self, offset;
+{
+    gchar buf[10];
+    gint len = g_unichar_to_utf8(atk_text_get_character_at_offset
+                                 (_SELF(self), NUM2INT(offset)), buf);
+    buf[len] = '\0';
+    return rb_str_new2(buf);
+}
+
+static VALUE
+rbatk_text_get_text_after_offset(self, offset, boundary_type)
+    VALUE self, offset, boundary_type;
+{
+    gchar* ret;
+    VALUE result;
+    gint start_offset, end_offset;
+
+    ret = atk_text_get_text_after_offset(_SELF(self), NUM2INT(offset),
+                                         RVAL2GENUM(boundary_type, ATK_TYPE_TEXT_BOUNDARY),
+                                         &start_offset, &end_offset);
+    result = rb_ary_new3(3, CSTR2RVAL(ret), 
+                         INT2NUM(start_offset), INT2NUM(end_offset));
+    g_free(ret);
+
+    return result;
+}
+
+static VALUE
+rbatk_text_get_text_at_offset(self, offset, boundary_type)
+    VALUE self, offset, boundary_type;
+{
+    gchar* ret;
+    VALUE result;
+    gint start_offset, end_offset;
+
+    ret = atk_text_get_text_at_offset(_SELF(self), NUM2INT(offset),
+                                      RVAL2GENUM(boundary_type, ATK_TYPE_TEXT_BOUNDARY),
+                                      &start_offset, &end_offset);
+    result = rb_ary_new3(3, CSTR2RVAL(ret), 
+                         INT2NUM(start_offset), INT2NUM(end_offset));
+    g_free(ret);
+
+    return result;
+}
+
+static VALUE
+rbatk_text_get_text_before_offset(self, offset, boundary_type)
+    VALUE self, offset, boundary_type;
+{
+    gchar* ret;
+    VALUE result;
+    gint start_offset, end_offset;
+
+    ret = atk_text_get_text_before_offset(_SELF(self), NUM2INT(offset),
+                                          RVAL2GENUM(boundary_type, ATK_TYPE_TEXT_BOUNDARY),
+                                          &start_offset, &end_offset);
+    result = rb_ary_new3(3, CSTR2RVAL(ret), 
+                         INT2NUM(start_offset), INT2NUM(end_offset));
+    g_free(ret);
+
+    return result;
+}
+
+static VALUE
+rbatk_text_get_caret_offset(self)
+    VALUE self;
+{
+    return INT2NUM(atk_text_get_caret_offset(_SELF(self)));
+}
+
+static VALUE
+rbatk_text_get_character_extents(self, offset, coords)
+    VALUE self, offset, coords;
+{
+    gint x, y, width, height;
+    atk_text_get_character_extents(_SELF(self), NUM2INT(offset), 
+                                   &x, &y, &width, &height, 
+                                   RVAL2GENUM(coords, ATK_TYPE_COORD_TYPE));
+    return rb_ary_new3(4, INT2NUM(x), INT2NUM(y), INT2NUM(width), INT2NUM(height));
+}
+
+static VALUE
+rbatk_text_get_run_attributes(self, offset)
+    VALUE self, offset;
+{
+    gint start_offset, end_offset;
+    AtkAttributeSet* list;
+    VALUE ary;
+
+    list = atk_text_get_run_attributes(_SELF(self), NUM2INT(offset),
+                                       &start_offset, &end_offset);
+
+    ary = rb_ary_new();
+  
+    while (list) {
+        AtkAttribute* data = (AtkAttribute*)list->data;
+        rb_ary_push(ary, rb_assoc_new(CSTR2RVAL(data->name), 
+                                      CSTR2RVAL(data->value)));
+        list = list->next;
+    }
+    atk_attribute_set_free(list);
+    return ary;
+}
+
+static VALUE
+rbatk_text_get_default_attributes(self)
+    VALUE self;
+{
+    AtkAttributeSet* list;
+    VALUE ary;
+
+    list = atk_text_get_default_attributes(_SELF(self));
+    ary = rb_ary_new();
+  
+    while (list) {
+        AtkAttribute* data = (AtkAttribute*)list->data;
+        rb_ary_push(ary, rb_assoc_new(CSTR2RVAL(data->name), 
+                                      CSTR2RVAL(data->value)));
+        list = list->next;
+    }
+    atk_attribute_set_free(list);
+    return ary;
+}
+
+static VALUE
+rbatk_text_get_character_count(self)
+    VALUE self;
+{
+    return INT2NUM(atk_text_get_character_count(_SELF(self)));
+}
+
+static VALUE
+rbatk_text_get_offset_at_point(self, x, y, coords)
+    VALUE self, x, y, coords;
+{
+    return INT2NUM(atk_text_get_offset_at_point(_SELF(self), 
+                                                NUM2INT(x), NUM2INT(y),
+                                                RVAL2GENUM(coords, ATK_TYPE_COORD_TYPE)));
+}
+
+#ifdef HAVE_ATK_TEXT_GET_BOUNDED_RANGES
+#ifdef HAVE_ATK_TEXT_CLIP_TYPE_GET_TYPE
+static VALUE
+rbatk_text_get_bounded_ranges(self, rect, coord_type, x_clip_type, y_clip_type)
+    VALUE self, rect, coord_type, x_clip_type, y_clip_type;
+{
+    AtkTextRange** ranges;
+    int i = 0;
+    VALUE ary;
+    ranges = atk_text_get_bounded_ranges(_SELF(self),
+                                         RVAL2BOXED(rect, ATK_TYPE_TEXT_RECTANGLE),
+                                         RVAL2GENUM(coord_type, ATK_TYPE_COORD_TYPE),
+                                         RVAL2GENUM(x_clip_type, ATK_TYPE_TEXT_CLIP_TYPE),
+                                         RVAL2GENUM(y_clip_type, ATK_TYPE_TEXT_CLIP_TYPE));
+    ary = rb_ary_new();
+    while(ranges[i]){
+        rb_ary_push(ary, BOXED2RVAL(ranges[i], ATK_TYPE_TEXT_RANGE));
+        i++;
+    }
+#ifdef HAVE_ATK_TEXT_FREE_RANGES
+    atk_text_free_ranges(ranges);
+#endif
+    return ary;
+}
+#endif
+
+static VALUE
+rbatk_text_get_range_extents(self, start_offset, end_offset, coord_type)
+    VALUE self, start_offset, end_offset, coord_type;
+{
+    AtkTextRectangle rect;
+    atk_text_get_range_extents(_SELF(self), NUM2INT(start_offset),
+                               NUM2INT(end_offset), 
+                               RVAL2GENUM(coord_type, ATK_TYPE_COORD_TYPE),
+                               &rect);
+    return BOXED2RVAL(&rect, ATK_TYPE_TEXT_RECTANGLE);
+}
+
+/* Don't need this
+void        atk_text_free_ranges            (AtkTextRange **ranges);
+*/
+#endif
+
+static VALUE
+rbatk_text_get_n_selections(self)
+    VALUE self;
+{
+    return INT2NUM(atk_text_get_n_selections(_SELF(self)));
+}
+
+static VALUE
+rbatk_text_get_selection(self, selection_num)
+    VALUE self, selection_num;
+{
+    gint start_offset, end_offset;
+    VALUE ret;
+    gchar* text = atk_text_get_selection(_SELF(self), NUM2INT(selection_num),
+                                         &start_offset, &end_offset);
+    ret = CSTR2RVAL(text);
+    g_free(text);
+
+    return ret;
+}
+
+static VALUE
+rbatk_text_add_selection(self, start_offset, end_offset)
+    VALUE self, start_offset, end_offset;
+{
+    gboolean ret = atk_text_add_selection(_SELF(self), NUM2INT(start_offset),
+                                          NUM2INT(end_offset));
+    if (! ret) rb_raise(rb_eRuntimeError, "Can't add selection");
+    return self;
+}
+
+static VALUE
+rbatk_text_remove_selection(self, selection_num)
+    VALUE self, selection_num;
+{
+    gint num;
+    gboolean ret;
+
+    num = NUM2INT(selection_num);
+    ret = atk_text_remove_selection(_SELF(self), num);
+    if (! ret)
+        rb_raise(rb_eRuntimeError, "Can't remove selection. num = %d", num);
+    return self;
+}
+
+static VALUE
+rbatk_text_set_selection(self, selection_num, start_offset, end_offset)
+    VALUE self, selection_num, start_offset, end_offset;
+{
+    gboolean ret = atk_text_set_selection(_SELF(self), NUM2INT(selection_num),
+                                          NUM2INT(start_offset),
+                                          NUM2INT(end_offset));
+    if (! ret) rb_raise(rb_eRuntimeError, "Can't set selection");
+    return self;
+}
+
+static VALUE
+rbatk_text_set_caret_offset(self, offset)
+    VALUE self, offset;
+{
+    gboolean ret = atk_text_set_caret_offset(_SELF(self), NUM2INT(offset));
+    if (! ret) rb_raise(rb_eRuntimeError, "Can't set caret offset");
+    return self;
+}
+
+
+/* We don't need them.
+    void        atk_attribute_set_free          (AtkAttributeSet *attrib_set);
+*/
+
+/*
+ * Atk::TextAttribute
+ */
+static VALUE
+rbatk_tattr_s_register(self, name)
+    VALUE self, name;
+{
+    return GENUM2RVAL(atk_text_attribute_register(RVAL2CSTR(name)), ATK_TYPE_TEXT_ATTRIBUTE);
+}
+
+/* We don't need this.
+G_CONST_RETURN gchar* atk_textattribute_type_get_name
+                                            (AtkTextattributeType type);
+*/
+
+static VALUE
+rbatk_tattr_s_for_name(self, name)
+    VALUE self, name;
+{
+    return GENUM2RVAL(atk_text_attribute_for_name(RVAL2CSTR(name)), ATK_TYPE_TEXT_ATTRIBUTE);
+}
+
+static VALUE
+rbatk_tattr_get_value(self, index)
+    VALUE self, index;
+{
+    return CSTR2RVAL(atk_text_attribute_get_value(RVAL2GENUM(self, ATK_TYPE_TEXT_ATTRIBUTE), 
+                                                  NUM2INT(index)));
+}
+void
+Init_atk_text()
+{
+    VALUE tattr;
+    VALUE mText = G_DEF_INTERFACE(ATK_TYPE_TEXT, "Text", mAtk);
+
+    rb_define_method(mText, "get_text", rbatk_text_get_text, 2);
+    rb_define_method(mText, "get_character_at_offset", rbatk_text_get_character_at_offset, 1);
+    rb_define_method(mText, "get_text_after_offset", rbatk_text_get_text_after_offset, 2);
+    rb_define_method(mText, "get_text_at_offset", rbatk_text_get_text_at_offset, 2);
+    rb_define_method(mText, "get_text_before_offset", rbatk_text_get_text_before_offset, 2);
+    rb_define_method(mText, "caret_offset", rbatk_text_get_caret_offset, 0);
+    rb_define_method(mText, "get_character_extents", rbatk_text_get_character_extents, 2);
+    rb_define_method(mText, "get_run_attributes", rbatk_text_get_run_attributes, 1);
+    rb_define_method(mText, "default_attributes", rbatk_text_get_default_attributes, 0);
+    rb_define_method(mText, "character_count", rbatk_text_get_character_count, 0);
+    rb_define_method(mText, "get_offset_at_point", rbatk_text_get_offset_at_point, 3);
+#ifdef HAVE_ATK_TEXT_GET_BOUNDED_RANGES
+#ifdef HAVE_ATK_TEXT_CLIP_TYPE_GET_TYPE
+    rb_define_method(mText, "get_bounded_ranges", rbatk_text_get_bounded_ranges, 4);
+    rb_define_method(mText, "get_range_extents", rbatk_text_get_range_extents, 3);
+#endif
+#endif
+    rb_define_method(mText, "n_selections", rbatk_text_get_n_selections, 0);
+    rb_define_method(mText, "get_selection", rbatk_text_get_selection, 1);
+    rb_define_method(mText, "add_selection", rbatk_text_add_selection, 2);
+    rb_define_method(mText, "remove_selection", rbatk_text_remove_selection, 1);
+    rb_define_method(mText, "set_selection", rbatk_text_set_selection, 3);
+    rb_define_method(mText, "set_caret_offset", rbatk_text_set_caret_offset, 1);
+
+    G_DEF_SETTERS(mText);
+    
+    /* AtkTextBoundary */
+#ifdef ATK_TYPE_TEXT_BOUNDARY
+    G_DEF_CLASS(ATK_TYPE_TEXT_BOUNDARY, "Boundary", mText);
+    G_DEF_CONSTANTS(mText, ATK_TYPE_TEXT_BOUNDARY, "ATK_TEXT_");
+#endif    
+    /* AtkTextClipType */
+#ifdef HAVE_ATK_TEXT_GET_BOUNDED_RANGES
+#ifdef HAVE_ATK_TEXT_CLIP_TYPE_GET_TYPE
+    G_DEF_CLASS(ATK_TYPE_TEXT_CLIP_TYPE, "ClipType", mText);
+    G_DEF_CONSTANTS(mText, ATK_TYPE_TEXT_CLIP_TYPE, "ATK_TEXT_");
+#endif
+#endif
+
+    tattr = G_DEF_CLASS(ATK_TYPE_TEXT_ATTRIBUTE, "Attribute", mText);
+    G_DEF_CONSTANTS(mText, ATK_TYPE_TEXT_ATTRIBUTE, "ATK_TEXT_");
+
+    rb_define_singleton_method(tattr, "type_register", rbatk_tattr_s_register, 1);
+    rb_define_singleton_method(tattr, "for_name", rbatk_tattr_s_for_name, 1);
+    rb_define_method(tattr, "get_value", rbatk_tattr_get_value, 1);   
+}

data/ext/atk/rbatktextrange.c

@@ -0,0 +1,91 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbatktextrange.c -
+
+  $Author: sakai $
+  $Date: 2007/07/16 03:01:02 $
+
+  Copyright (C) 2004 Masao Mutoh
+
+  This file is derived from rbgdkrange.c.
+  rbgdkrange.c -
+  Copyright (C) 2002,2003 Masao Mutoh
+
+  rbgdkrange.c file is derived from rbgdkregion.c.
+  rbgdkregion.c -
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+
+#include "rbatk.h"
+
+#ifdef HAVE_ATK_TEXT_GET_BOUNDED_RANGES
+#define _SELF(r) ((AtkTextRange*)RVAL2BOXED(r, ATK_TYPE_TEXT_RANGE))
+
+/**********************************/
+static AtkTextRange*
+atk_text_range_copy(const AtkTextRange* val)
+{
+    AtkTextRange* new_val;
+    g_return_val_if_fail (val != NULL, NULL);
+    new_val = g_new(AtkTextRange, 1);
+    *new_val = *val;
+    return new_val;
+}
+
+GType
+atk_text_range_get_type(void)
+{
+    static GType our_type = 0;
+                                                                                
+    if (our_type == 0)
+        our_type = g_boxed_type_register_static ("AtkTextRange",
+                    (GBoxedCopyFunc)atk_text_range_copy,
+                    (GBoxedFreeFunc)g_free);
+    return our_type;
+}
+/**********************************/
+/* Struct accessors */
+static VALUE
+atktextrange_bounds(self)
+    VALUE self;
+{
+    return BOXED2RVAL(&_SELF(self)->bounds, ATK_TYPE_TEXT_RECTANGLE);
+}
+
+static VALUE
+atktextrange_start_offset(self)
+    VALUE self;
+{
+    return INT2NUM(_SELF(self)->start_offset);
+}
+
+static VALUE
+atktextrange_end_offset(self)
+    VALUE self;
+{
+    return INT2NUM(_SELF(self)->end_offset);
+}
+
+static VALUE
+atktextrange_content(self)
+    VALUE self;
+{
+    return CSTR2RVAL(_SELF(self)->content);
+}
+#endif
+
+void
+Init_atk_text_range()
+{
+#ifdef HAVE_ATK_TEXT_GET_BOUNDED_RANGES
+    VALUE range = G_DEF_CLASS(ATK_TYPE_TEXT_RANGE, "TextRange",  mAtk);
+
+    rb_define_method(range, "bounds", atktextrange_bounds, 0);
+    rb_define_method(range, "start_offset", atktextrange_start_offset, 0);
+    rb_define_method(range, "end_offset", atktextrange_end_offset, 0);
+    rb_define_method(range, "content", atktextrange_content, 0);
+#endif
+}

data/ext/atk/rbatktextrectangle.c

@@ -0,0 +1,156 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbatktextrectangle.c -
+
+  $Author: mutoh $
+  $Date: 2004/10/19 13:33:43 $
+
+  Copyright (C) 2004 Masao Mutoh
+
+  This file is derived from rbgdkrectangle.c.
+  rbgdkrectangle.c -
+  Copyright (C) 2002,2003 Masao Mutoh
+
+  rbgdkrectangle.c file is derived from rbgdkregion.c.
+  rbgdkregion.c -
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+
+#include "rbatk.h"
+
+#ifdef HAVE_ATK_TEXT_GET_BOUNDED_RANGES
+#define _SELF(r) ((AtkTextRectangle*)RVAL2BOXED(r, ATK_TYPE_TEXT_RECTANGLE))
+
+/**********************************/
+static AtkTextRectangle*
+atk_text_rectangle_copy(const AtkTextRectangle* val)
+{
+    AtkTextRectangle* new_val;
+    g_return_val_if_fail (val != NULL, NULL);
+    new_val = g_new(AtkTextRectangle, 1);
+    *new_val = *val;
+    return new_val;
+}
+
+GType
+atk_text_rectangle_get_type(void)
+{
+    static GType our_type = 0;
+                                                                                
+    if (our_type == 0)
+        our_type = g_boxed_type_register_static ("AtkTextRectangle",
+                    (GBoxedCopyFunc)atk_text_rectangle_copy,
+                    (GBoxedFreeFunc)g_free);
+    return our_type;
+}
+/**********************************/
+
+static VALUE
+atktextrect_initialize(self, x, y, width, height)
+    VALUE self, x, y, width, height;
+{
+    AtkTextRectangle new;
+
+    new.x = NUM2INT(x);
+    new.y = NUM2INT(y);
+    new.width = NUM2INT(width);
+    new.height = NUM2INT(height);
+
+    G_INITIALIZE(self, &new);
+    return Qnil;
+}
+
+/* Struct accessors */
+static VALUE
+atktextrect_x(self)
+    VALUE self;
+{
+    return INT2NUM(_SELF(self)->x);
+}
+
+static VALUE
+atktextrect_y(self)
+    VALUE self;
+{
+    return INT2NUM(_SELF(self)->y);
+}
+
+static VALUE
+atktextrect_w(self)
+    VALUE self;
+{
+    return INT2NUM(_SELF(self)->width);
+}
+
+static VALUE
+atktextrect_h(self)
+    VALUE self;
+{
+    return INT2NUM(_SELF(self)->height);
+}
+
+static VALUE
+atktextrect_set_x(self, x)
+    VALUE self, x;
+{
+    _SELF(self)->x = NUM2INT(x);
+    return self;
+}
+
+static VALUE
+atktextrect_set_y(self, y)
+    VALUE self, y;
+{
+    _SELF(self)->y = NUM2INT(y);
+    return self;
+}
+
+static VALUE
+atktextrect_set_w(self, width)
+    VALUE self, width;
+{
+    _SELF(self)->width = NUM2INT(width);
+    return self;
+}
+
+static VALUE
+atktextrect_set_h(self, height)
+    VALUE self, height;
+{
+    _SELF(self)->height = NUM2INT(height);
+    return self;
+}
+
+static VALUE
+atktextrect_to_a(self)
+    VALUE self;
+{
+  AtkTextRectangle* a = _SELF(self);
+  return rb_ary_new3(4, INT2FIX(a->x), INT2FIX(a->y),
+                     INT2FIX(a->width), INT2FIX(a->height));
+}
+#endif
+
+void
+Init_atk_text_rectangle()
+{
+#ifdef HAVE_ATK_TEXT_GET_BOUNDED_RANGES
+    VALUE rect = G_DEF_CLASS(ATK_TYPE_TEXT_RECTANGLE, "TextRectangle", mAtk);
+
+    rb_define_method(rect, "initialize", atktextrect_initialize, 4);
+    rb_define_method(rect, "x", atktextrect_x, 0);
+    rb_define_method(rect, "y", atktextrect_y, 0);
+    rb_define_method(rect, "width", atktextrect_w, 0);
+    rb_define_method(rect, "height", atktextrect_h, 0);
+    rb_define_method(rect, "set_x", atktextrect_set_x, 1);
+    rb_define_method(rect, "set_y", atktextrect_set_y, 1);
+    rb_define_method(rect, "set_width", atktextrect_set_w, 1);
+    rb_define_method(rect, "set_height", atktextrect_set_h, 1);
+    rb_define_method(rect, "to_a", atktextrect_to_a, 0);
+
+    G_DEF_SETTERS(rect);
+#endif
+}