atk 0.20.0

data/src/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/src/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
+}

data/src/rbatkutil.c

@@ -0,0 +1,125 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbatkutil.c -
+
+  $Author: sakai $
+  $Date: 2007/07/08 02:51:52 $
+
+  Copyright (C) 2004 Masao Mutoh
+************************************************/
+
+#include "rbatk.h"
+
+static ID id_call;
+
+/* How can I implement them?
+guint       atk_add_focus_tracker           (AtkEventListener focus_tracker);
+void        atk_remove_focus_tracker        (guint tracker_id);
+void        atk_focus_tracker_init          (AtkEventListenerInit add_function);
+void        (*AtkEventListener)             (AtkObject*);
+void        (*AtkEventListenerInit)         (void);
+guint       atk_add_global_event_listener   (GSignalEmissionHook listener,
+                                             const gchar *event_type);
+void        atk_remove_global_event_listener
+                                            (guint listener_id);
+*/
+
+static VALUE
+rbatk_focus_tracker_notify(self, obj)
+    VALUE self, obj;
+{
+    atk_focus_tracker_notify(ATK_OBJECT(RVAL2GOBJ(obj)));
+    return self;
+}
+
+static gint
+key_snoop_func(AtkKeyEventStruct* event, gpointer func)
+{
+    VALUE ret = rb_funcall((VALUE)func, id_call, 7,
+                           INT2NUM(event->type), UINT2NUM(event->state),
+                           UINT2NUM(event->keyval), INT2NUM(event->length),
+                           CSTR2RVAL(event->string), UINT2NUM(event->keycode),
+                           UINT2NUM(event->timestamp));
+    return NUM2INT(ret);
+}
+
+static VALUE
+rbatk_add_key_event_listener(self)
+    VALUE self;
+{
+    guint ret;
+    VALUE func = rb_block_proc();
+    G_RELATIVE(self, func);
+    ret = atk_add_key_event_listener((AtkKeySnoopFunc)key_snoop_func, (gpointer)func);
+    return UINT2NUM(ret);
+}
+
+static VALUE
+rbatk_remove_key_event_listener(self, id)
+    VALUE self, id;
+{
+    atk_remove_key_event_listener(NUM2UINT(id));
+    return self;
+}
+
+static VALUE
+rbatk_get_root(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(atk_get_root());
+}
+
+#if ATK_CHECK_VERSION(1,6,0)
+static VALUE
+rbatk_get_focus_object(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(atk_get_focus_object());
+}
+#endif
+
+static VALUE
+rbatk_get_toolkit_name(self)
+    VALUE self;
+{
+    return CSTR2RVAL(atk_get_toolkit_name());
+}
+
+static VALUE
+rbatk_get_toolkit_version(self)
+    VALUE self;
+{
+    return CSTR2RVAL(atk_get_toolkit_version());
+}
+
+void
+Init_atk_util()
+{
+    VALUE coord;
+
+    VALUE util = G_DEF_CLASS(ATK_TYPE_UTIL, "Util", mAtk);
+
+    id_call = rb_intern("call");
+
+    rb_define_singleton_method(util, "focus_tracker_notify", rbatk_focus_tracker_notify, 1);
+    rb_define_singleton_method(util, "add_key_event_listener", rbatk_add_key_event_listener, 0);
+    rb_define_singleton_method(util, "remove_key_event_listener", rbatk_remove_key_event_listener, 1);
+
+    rb_define_singleton_method(util, "root", rbatk_get_root, 0);
+#if ATK_CHECK_VERSION(1,6,0)
+    rb_define_singleton_method(util, "focus_object", rbatk_get_focus_object, 0);
+#endif
+    rb_define_singleton_method(util, "toolkit_name", rbatk_get_toolkit_name, 0);
+    rb_define_singleton_method(util, "toolkit_version", rbatk_get_toolkit_version, 0);
+    rb_define_singleton_method(util, "toolkit_version", rbatk_get_toolkit_version, 0);
+
+    /* AtkCoordType */
+    coord = G_DEF_CLASS(ATK_TYPE_COORD_TYPE, "CoordType", util);
+    G_DEF_CONSTANTS(util, ATK_TYPE_COORD_TYPE, "ATK_");
+
+    /* AtkKeyEventType */
+    coord = G_DEF_CLASS(ATK_TYPE_KEY_EVENT_TYPE, "KeyEventType", util);
+    G_DEF_CONSTANTS(util, ATK_TYPE_KEY_EVENT_TYPE, "ATK_");
+
+}

data/src/rbatkvalue.c

@@ -0,0 +1,74 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbatkvalue.c -
+
+  $Author: mutoh $
+  $Date: 2003/12/23 15:59:28 $
+
+  Copyright (C) 2003 Masao Mutoh
+************************************************/
+
+#include "rbatk.h"
+
+#define _SELF(s) (ATK_VALUE(RVAL2GOBJ(s)))
+
+static VALUE
+rbatk_value_get_current_value(self)
+    VALUE self;
+{
+    GValue gval = {0,};
+    atk_value_get_current_value(_SELF(self), &gval);
+
+    return GVAL2RVAL(&gval);
+}
+
+
+static VALUE
+rbatk_value_get_maximum_value(self)
+    VALUE self;
+{
+    GValue gval = {0,};
+    atk_value_get_maximum_value(_SELF(self), &gval);
+
+    return GVAL2RVAL(&gval);
+}
+
+static VALUE
+rbatk_value_get_minimum_value(self)
+    VALUE self;
+{
+    GValue gval = {0,};
+    atk_value_get_minimum_value(_SELF(self), &gval);
+
+    return GVAL2RVAL(&gval);
+}
+
+static VALUE
+rbatk_value_set_current_value(self, value)
+    VALUE self, value;
+{
+    GValue gval = {0,};
+    g_value_init(&gval, RVAL2GTYPE(value));
+
+    rbgobj_rvalue_to_gvalue(value, &gval);
+
+    if (! atk_value_set_current_value(_SELF(self), &gval)){
+        rb_raise(rb_eRuntimeError, "Can't set the current value.");
+    }
+
+    return self;
+}
+
+void
+Init_atk_value()
+{
+    VALUE mValue = G_DEF_INTERFACE(ATK_TYPE_VALUE, "Value", mAtk);
+
+    rb_define_method(mValue, "current", rbatk_value_get_current_value, 0);
+    rb_define_method(mValue, "max", rbatk_value_get_maximum_value, 0);
+    rb_define_method(mValue, "min", rbatk_value_get_minimum_value, 0);
+    rb_define_method(mValue, "set_current", rbatk_value_set_current_value, 1);
+
+    G_DEF_SETTERS(mValue);
+}

data/src/rbatkversion.h

@@ -0,0 +1,24 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbatkversion.h -
+
+  This file was generated by mkmf-gnome2.rb.
+
+************************************************/
+
+#ifndef __RBATK_VERSION_H__
+#define __RBATK_VERSION_H__
+
+#define ATK_MAJOR_VERSION (1)
+#define ATK_MINOR_VERSION (26)
+#define ATK_MICRO_VERSION (0)
+
+#define ATK_CHECK_VERSION(major,minor,micro)    \
+    (ATK_MAJOR_VERSION > (major) || \
+     (ATK_MAJOR_VERSION == (major) && ATK_MINOR_VERSION > (minor)) || \
+     (ATK_MAJOR_VERSION == (major) && ATK_MINOR_VERSION == (minor) && \
+      ATK_MICRO_VERSION >= (micro)))
+
+
+#endif /* __RBATK_VERSION_H__ */