glib2 0.20.0

data/src/rbgobj_valuearray.c

@@ -0,0 +1,59 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/**********************************************************************
+
+  rbgobj_valuearray.c -
+
+  $Author: mutoh $
+  $Date: 2006/05/17 14:00:24 $
+
+  Copyright (C) 2006  Sjoerd Simons
+**********************************************************************/
+
+#include "rbgprivate.h"
+
+static VALUE
+value_array_to_ruby(const GValue* from)
+{
+    VALUE ary;
+    int i;
+    GValueArray *val_array = (GValueArray*)g_value_get_boxed(from);
+    if (!val_array)
+        return Qnil;
+  
+    ary = rb_ary_new();
+    for (i = 0 ;  i < val_array->n_values ; i++) {
+        rb_ary_push(ary, GVAL2RVAL(g_value_array_get_nth(val_array, i)));
+    }
+    return ary;
+}
+
+static void
+value_array_from_ruby(VALUE from, GValue* to)
+{
+    int i;
+    GValueArray * array;
+
+    if (NIL_P(from)) {
+        g_value_set_boxed(to, NULL);
+        return;
+    }
+
+    Check_Type(from, T_ARRAY);
+
+    array = g_value_array_new(0);
+
+    for (i = 0; i < RARRAY_LEN(from); i++) {
+      GValue v = { 0, };
+      g_value_init(&v, RVAL2GTYPE(RARRAY_PTR(from)[i]));
+      rbgobj_rvalue_to_gvalue(RARRAY_PTR(from)[i], &v);
+      g_value_array_append(array, &v);
+    }
+    g_value_set_boxed(to, array);
+}
+
+void Init_gobject_value_array()
+{
+    /* ValueArray is treated as Array */
+    rbgobj_register_g2r_func(G_TYPE_VALUE_ARRAY, value_array_to_ruby);
+    rbgobj_register_r2g_func(G_TYPE_VALUE_ARRAY, value_array_from_ruby);
+}

data/src/rbgobj_valuetypes.c

@@ -0,0 +1,298 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/**********************************************************************
+
+  rbgobj_valuetypes.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 14:27:07 $
+
+  Copyright (C) 2002,2003  Masahiro Sakai
+
+**********************************************************************/
+
+#include "rbgprivate.h"
+#ifdef RBGOBJ_USE_DLPTR
+#include "dl.h"
+#endif
+
+
+VALUE
+rbgobj_ptr_new(type, ptr)
+    GType type;
+    gpointer ptr;
+{
+#ifdef RBGOBJ_USE_DLPTR
+    return rb_dlptr_new2(GTYPE2CLASS(type), 0, NULL);
+#else
+    return Data_Wrap_Struct(GTYPE2CLASS(type), NULL, NULL, ptr);
+#endif
+}
+
+gpointer
+rbgobj_ptr2cptr(ptr)
+    VALUE ptr;
+{
+#ifdef RBGOBJ_USE_DLPTR
+    return rb_dlptr2cptr(ptr);
+#else
+    gpointer dest;
+    if (rb_obj_is_kind_of(ptr, GTYPE2CLASS(G_TYPE_POINTER))){
+        Data_Get_Struct(ptr, void, dest);
+    } else if (rb_obj_is_kind_of(ptr, rb_cObject)){
+        dest = (gpointer)ptr;
+    } else{
+        rb_raise(rb_eTypeError, "not a pointer object");
+    }
+    return dest;
+#endif
+}
+
+static VALUE
+ptr_s_gtype(klass)
+    VALUE klass;
+{
+    return rbgobj_gtype_new(rbgobj_lookup_class(klass)->gtype);
+}
+
+static VALUE
+ptr_gtype(self)
+    VALUE self;
+{
+    return ptr_s_gtype(CLASS_OF(self));
+}
+
+#ifndef RBGOBJ_USE_DLPTR
+static VALUE
+ptr_inspect(self)
+    VALUE self;
+{
+    gpointer ptr;
+    gchar* s;
+    VALUE result;
+
+    Data_Get_Struct(self, void, ptr);
+
+    s = g_strdup_printf("#<%s:%p ptr=%p>",
+                        rb_class2name(CLASS_OF(self)),
+                        (void *)self,
+                        ptr);
+
+    result = rb_str_new2(s);
+    g_free(s);
+
+    return result;
+}
+
+static VALUE
+ptr_eql(self, other)
+    VALUE self, other;
+{
+    gpointer ptr1, ptr2;
+    if (!rb_obj_is_kind_of(other, GTYPE2CLASS(G_TYPE_POINTER)))
+        return Qnil;
+    Data_Get_Struct(self, void, ptr1);
+    Data_Get_Struct(other, void, ptr2);
+    return CBOOL2RVAL(ptr1 == ptr2);
+}
+
+static VALUE
+ptr_hash(self)
+    VALUE self;
+{
+    gpointer ptr;
+    Data_Get_Struct(self, void, ptr);
+    return INT2FIX((long)ptr);
+}
+#endif
+
+static void
+Init_gtype_pointer()
+{
+    VALUE cPtr = G_DEF_CLASS(G_TYPE_POINTER, "Pointer", mGLib);
+    rb_define_singleton_method(cPtr, "gtype", ptr_s_gtype, 1);
+    rb_define_method(cPtr, "gtype", ptr_gtype, 1);
+#ifndef RBGOBJ_USE_DLPTR
+    rb_define_method(cPtr, "inspect", ptr_inspect, 0);
+    rb_define_method(cPtr, "==", ptr_eql, 1);
+    rb_define_method(cPtr, "eql?", ptr_eql, 1);
+    rb_define_method(cPtr, "hash", ptr_hash, 0);
+#endif
+}
+
+/**********************************************************************/
+
+static GHashTable* boxed_ruby_value_table;
+static VALUE boxed_ruby_value_table_wrapper;
+
+typedef struct {
+    VALUE obj;
+    guint ref_count;
+} boxed_ruby_value_counter;
+
+static void
+boxed_ruby_value_counter_mark(gpointer       key,
+                              gpointer       value,
+                              gpointer       user_data)
+{
+    boxed_ruby_value_counter* counter = value;
+    if (counter->ref_count)
+        rb_gc_mark(counter->obj);
+}
+
+static void
+boxed_ruby_value_table_mark(GHashTable* table)
+{
+    g_hash_table_foreach(table, boxed_ruby_value_counter_mark, NULL);
+}
+
+static VALUE
+boxed_ruby_value_ref(VALUE val)
+{
+    if (!SPECIAL_CONST_P(val)){
+        boxed_ruby_value_counter* counter;
+
+        counter = g_hash_table_lookup(boxed_ruby_value_table, (gpointer)val);
+
+        if (!counter){
+            counter = g_new(boxed_ruby_value_counter, 1);
+            counter->obj       = val;
+            counter->ref_count = 1;
+            g_hash_table_insert(boxed_ruby_value_table, (gpointer)val,
+                                counter);
+        } else {
+            counter->ref_count += 1;
+        }
+    }
+    return val;
+}
+
+static void
+boxed_ruby_value_unref(VALUE val)
+{
+    if (!SPECIAL_CONST_P(val)){
+        boxed_ruby_value_counter* counter;
+
+        counter = g_hash_table_lookup(boxed_ruby_value_table, (gpointer)val);
+        counter->ref_count -= 1;
+
+        if (!counter->ref_count)
+            g_hash_table_remove(boxed_ruby_value_table, (gpointer)val);
+    }
+}
+
+struct transform_arg {
+    const GValue *src_value;
+    GValue       *dest_value;
+};
+
+static VALUE
+value_transform_ruby_any_impl(VALUE arg_)
+{
+    struct transform_arg* arg = (struct transform_arg*)arg_;
+    rbgobj_rvalue_to_gvalue(g_value_get_ruby_value(arg->src_value),
+                            arg->dest_value);
+    return Qnil;
+}
+
+static void
+value_transform_ruby_any(const GValue *src_value,
+                         GValue       *dest_value)
+{
+    int state;
+    struct transform_arg arg;
+    arg.src_value = src_value;
+    arg.dest_value = dest_value;
+    rb_protect(&value_transform_ruby_any_impl, (VALUE)&arg, &state);
+}
+
+static void
+value_transform_any_ruby(const GValue *src_value,
+                         GValue       *dest_value)
+{
+    g_value_set_ruby_value(dest_value, GVAL2RVAL(src_value));
+}
+
+GType rbgobj_ruby_value_get_type()
+{
+  static GType our_type = 0;
+
+  if (!our_type){
+      const GType table[] = {
+          G_TYPE_CHAR,
+          G_TYPE_UCHAR,
+          G_TYPE_BOOLEAN,
+          G_TYPE_INT,
+          G_TYPE_UINT,
+          G_TYPE_LONG,
+          G_TYPE_ULONG,
+          G_TYPE_INT64,
+          G_TYPE_UINT64,
+          G_TYPE_ENUM,
+          G_TYPE_FLAGS,
+          G_TYPE_FLOAT,
+          G_TYPE_DOUBLE,
+          G_TYPE_STRING,
+          G_TYPE_POINTER,
+          //G_TYPE_BOXED,
+          G_TYPE_PARAM,
+          G_TYPE_OBJECT,
+      };
+      int i;
+
+      our_type = g_boxed_type_register_static(
+          "VALUE",
+          (GBoxedCopyFunc)boxed_ruby_value_ref,
+          (GBoxedFreeFunc)boxed_ruby_value_unref);
+
+      for (i = 0; i < sizeof(table)/sizeof(table[0]); i++){
+          g_value_register_transform_func(table[i], our_type,
+                                          value_transform_any_ruby);
+      }
+
+      g_value_register_transform_func(our_type, G_TYPE_BOOLEAN,
+                                      value_transform_ruby_any);
+  }
+  return our_type;
+}
+
+VALUE
+g_value_get_ruby_value(const GValue* value)
+{
+    return (VALUE)g_value_get_boxed(value);
+}
+
+void
+g_value_set_ruby_value(GValue* value, VALUE ruby)
+{
+    g_value_set_boxed(value, (gconstpointer)ruby);
+}
+
+static void
+ruby_value_r2g(VALUE from, GValue* to)
+{
+    g_value_set_ruby_value(to, from);
+}
+
+static void
+Init_boxed_ruby_value()
+{
+    boxed_ruby_value_table = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, g_free);
+
+    boxed_ruby_value_table_wrapper =
+      Data_Wrap_Struct(rb_cData,
+                       boxed_ruby_value_table_mark, NULL,
+                       boxed_ruby_value_table);
+    rb_global_variable(&boxed_ruby_value_table_wrapper);
+
+    rbgobj_register_g2r_func(RBGOBJ_TYPE_RUBY_VALUE, g_value_get_ruby_value);
+    rbgobj_register_r2g_func(RBGOBJ_TYPE_RUBY_VALUE, ruby_value_r2g);
+}
+
+/**********************************************************************/
+
+void
+Init_gobject_gvaluetypes()
+{
+    Init_gtype_pointer();
+    Init_boxed_ruby_value();
+}

data/src/rbgobject.c

@@ -0,0 +1,406 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/**********************************************************************
+
+  rbgobject.c -
+
+  $Author: ktou $
+  $Date: 2007/10/03 12:48:55 $
+
+  Copyright (C) 2003-2006  Ruby-GNOME2 Project Team
+  Copyright (C) 2002,2003  Masahiro Sakai
+
+  This file is derived from rbgtkobject.c in Ruby/Gtk distribution.
+  rbgtkobject.c -
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+
+**********************************************************************/
+
+#include "ruby.h"
+#include "rbgprivate.h"
+#include <ctype.h>
+
+#include "rbgprivate.h"
+
+static ID id_relatives;
+static ID id_delete;
+static ID id_module_eval;
+
+ID rbgobj_id_children;
+
+/**********************************************************************/
+
+void
+rbgobj_initialize_object(VALUE obj, gpointer cobj)
+{
+    GType type;
+    GType parent_type;
+
+    if (!cobj)
+        rb_raise(rb_eRuntimeError, "failed to initialize");
+
+    type = RVAL2GTYPE(obj);
+
+    for (parent_type = type;
+         parent_type != G_TYPE_INVALID;
+         parent_type = g_type_parent(parent_type)) {
+
+         if (rbgobj_convert_initialize(parent_type, obj, cobj))
+             return;
+    }
+
+    type = G_TYPE_FUNDAMENTAL(type);
+    switch (type){
+    case G_TYPE_OBJECT:
+        rbgobj_gobject_initialize(obj, cobj);
+        break;
+    case G_TYPE_PARAM:
+        rbgobj_param_spec_initialize(obj, cobj);
+        break;
+    case G_TYPE_BOXED:
+        rbgobj_boxed_initialize(obj, cobj);
+        break;
+    default:
+        rbgobj_convert_initialize(type, obj, cobj);
+    }
+}
+
+gpointer
+rbgobj_instance_from_ruby_object(VALUE obj)
+{
+    GType type;
+
+    if (NIL_P(obj))
+    	return NULL;
+
+    type = RVAL2GTYPE(obj);
+    if (rbgobj_convert_has_type(type)) {
+        gpointer instance;
+        if (rbgobj_convert_robj2instance(type, obj, &instance))
+            return instance;
+    }
+
+    type = G_TYPE_FUNDAMENTAL(type);
+    switch (type){
+    case G_TYPE_OBJECT:
+        return rbgobj_get_gobject(obj);
+    case G_TYPE_PARAM:
+        return rbgobj_get_param_spec(obj);
+    default:
+      {
+        gpointer instance;
+        if (!rbgobj_convert_robj2instance(type, obj, &instance)) {
+            rb_raise(rb_eTypeError, "%s isn't supported",
+                     rb_class2name(CLASS_OF(obj)));
+        }
+        return instance;
+      }
+    }
+}
+
+VALUE
+rbgobj_ruby_object_from_instance(gpointer instance)
+{
+    return rbgobj_ruby_object_from_instance2(instance, TRUE);
+}
+
+VALUE
+rbgobj_ruby_object_from_instance2(gpointer instance, gboolean alloc)
+{
+    VALUE object;
+    GType type;
+
+    if (!instance)
+    	return Qnil;
+
+    type = G_TYPE_FROM_INSTANCE(instance);
+    if (alloc) {
+        GType parent_type;
+        for (parent_type = type;
+             parent_type != G_TYPE_INVALID;
+             parent_type = g_type_parent(parent_type)) {
+            if (rbgobj_convert_instance2robj(parent_type, instance, &object))
+                return object;
+        }
+    }
+
+    switch (G_TYPE_FUNDAMENTAL(type)) {
+    case G_TYPE_OBJECT:
+        return rbgobj_get_ruby_object_from_gobject(instance, alloc);
+    case G_TYPE_PARAM:
+        return rbgobj_get_ruby_object_from_param_spec(instance, alloc);
+    default:
+        if (alloc) {
+            rb_raise(rb_eTypeError, "%s isn't supported", g_type_name(type));
+        } else {
+            return Qnil;
+        }
+    }
+}
+
+VALUE
+rbgobj_ruby_object_from_instance_with_unref(gpointer instance)
+{
+    VALUE result = rbgobj_ruby_object_from_instance(instance);
+    if (!NIL_P(result)) {
+        GType type;
+
+        type = G_TYPE_FROM_INSTANCE(instance);
+        if (!rbgobj_convert_unref(type, instance)) {
+            type = G_TYPE_FUNDAMENTAL(type);
+            switch (type) {
+              case G_TYPE_OBJECT:
+                g_object_unref(instance);
+                break;
+              default:
+                rbgobj_convert_unref(type, instance);
+                break;
+            }
+        }
+    }
+    return result;
+}
+
+/**********************************************************************/
+
+void
+rbgobj_add_relative(obj, relative)
+    VALUE obj, relative;
+{
+    VALUE hash = Qnil;
+
+    if (RVAL2CBOOL(rb_ivar_defined(obj, id_relatives)))
+        hash = rb_ivar_get(obj, id_relatives);
+
+    if (NIL_P(hash) || TYPE(hash) != T_HASH) {
+        hash = rb_hash_new();
+        rb_ivar_set(obj, id_relatives, hash);
+    }
+    rb_hash_aset(hash, relative, Qnil);
+}
+
+void
+rbgobj_invalidate_relatives(obj)
+    VALUE obj;
+{
+    if (RVAL2CBOOL(rb_ivar_defined(obj, id_relatives)))
+        rb_ivar_set(obj, id_relatives, Qnil);
+    if (RVAL2CBOOL(rb_ivar_defined(obj, rbgobj_id_children)))
+        rb_ivar_set(obj, rbgobj_id_children, Qnil);
+}
+
+void
+rbgobj_add_relative_removable(obj, relative, obj_ivar_id, hash_key)
+    VALUE obj, relative, hash_key;
+    ID    obj_ivar_id;
+{
+    VALUE hash = Qnil;
+
+    if (RVAL2CBOOL(rb_ivar_defined(obj, obj_ivar_id)))
+        hash = rb_ivar_get(obj, obj_ivar_id);
+
+    if (NIL_P(hash) || TYPE(hash) != T_HASH) {
+        hash = rb_hash_new();
+        rb_ivar_set(obj, obj_ivar_id, hash);
+    }
+    rb_hash_aset(hash, hash_key, relative);
+}
+
+VALUE
+rbgobj_get_relative_removable(obj, obj_ivar_id, hash_key)
+    VALUE obj, hash_key;
+    ID    obj_ivar_id;
+{
+    VALUE hash = Qnil;
+
+    if (RVAL2CBOOL(rb_ivar_defined(obj, obj_ivar_id)))
+        hash = rb_ivar_get(obj, obj_ivar_id);
+
+    if (NIL_P(hash) || TYPE(hash) != T_HASH) {
+        return Qnil;
+    }
+    return rb_hash_aref(hash, hash_key);
+}
+
+void
+rbgobj_remove_relative(obj, obj_ivar_id, hash_key)
+    VALUE obj, hash_key;
+    ID    obj_ivar_id;
+{
+    VALUE hash = Qnil;
+
+    if (RVAL2CBOOL(rb_ivar_defined(obj, obj_ivar_id)))
+        hash = rb_ivar_get(obj, obj_ivar_id);
+
+    if (NIL_P(hash) || TYPE(hash) != T_HASH) {
+        /* should not happen. */
+    } else {
+        rb_funcall(hash, id_delete, 1, hash_key);
+    }
+}
+
+void
+rbgobj_remove_relative_all(obj, obj_ivar_id)
+    VALUE obj;
+    ID    obj_ivar_id;
+{
+    rb_ivar_set(obj, obj_ivar_id, Qnil);
+}
+
+/**********************************************************************/
+
+static GHashTable* prop_exclude_list;
+
+#define IS_FLAG(bitmask, flag) (((bitmask) & (flag)) == (flag))
+
+void
+rbgobj_define_property_accessors(klass)
+    VALUE klass;
+{
+    GType gtype;
+    GParamSpec** pspecs = NULL;
+    int i;
+    GString* source;
+    guint n_properties = 0;
+    gtype = CLASS2GTYPE(klass);
+
+    if (G_TYPE_IS_INTERFACE(gtype)){
+#if GLIB_CHECK_VERSION(2,4,0)
+        gpointer iface = g_type_default_interface_ref(gtype);
+        pspecs = g_object_interface_list_properties(iface, &n_properties);
+        g_type_default_interface_unref(iface);
+#endif
+    } else {
+        GObjectClass* oclass = G_OBJECT_CLASS(g_type_class_ref(gtype));
+        pspecs = g_object_class_list_properties(oclass, &n_properties);
+        g_type_class_unref(oclass);
+    }
+
+    if (n_properties == 0)
+        return;
+
+    source = g_string_new(NULL);
+    for (i = 0; i < n_properties; i++){
+        GParamSpec* pspec = pspecs[i];
+        char* buf;
+        char* prop_name;
+        char* p;
+
+        if (pspec->owner_type != gtype)
+            continue;
+
+        buf = g_strdup(pspec->name);
+        for (p = buf; *p; p++)
+            if (*p == '-')
+                *p = '_';
+
+        if (!strncmp(buf, "is_", 3))
+            prop_name = buf + 3;
+        else
+            prop_name = buf;
+
+        if (g_hash_table_lookup(prop_exclude_list, prop_name)){
+            g_free(buf);
+            continue;
+        }
+
+        if (pspec->flags & G_PARAM_READABLE){
+            g_string_append_printf(
+                source, 
+                "def %s%s; get_property('%s'); end\n",
+                prop_name,
+                (G_PARAM_SPEC_VALUE_TYPE(pspec) == G_TYPE_BOOLEAN) ? "?" : "",
+                pspec->name);
+        }
+
+        if (IS_FLAG(pspec->flags, G_PARAM_WRITABLE) && !IS_FLAG(pspec->flags, G_PARAM_CONSTRUCT_ONLY)){
+            g_string_append_printf(source,
+                "def set_%s(val); set_property('%s', val); end\n",
+                prop_name, pspec->name);
+#ifdef HAVE_NODE_ATTRASGN
+            g_string_append_printf(source, "alias %s= set_%s\n",
+                                   prop_name, prop_name);
+#else
+            g_string_append_printf(source,
+                "def %s=(val); set_property('%s', val); val; end\n",
+                prop_name, pspec->name);
+#endif
+        }
+
+        g_free(buf);
+    }
+
+    if (source->len > 0)
+        rb_funcall(klass, id_module_eval, 1, rb_str_new2(source->str));
+    g_string_free(source, TRUE);
+}
+
+/**********************************************************************/
+
+void 
+Init_gobject()
+{
+    extern void Init_gobject_convert();
+    extern void Init_gobject_gtype();
+    extern void Init_gobject_typeinterface();
+    extern void Init_gobject_typeinstance();
+    extern void Init_gobject_gvalue();
+    extern void Init_gobject_gvaluetypes();
+    extern void Init_gobject_gboxed();
+#if GLIB_CHECK_VERSION(2,6,0)
+    extern void Init_gobject_gstrv();
+#endif
+    extern void Init_gobject_value_array();
+    extern void Init_gobject_genums();
+    extern void Init_gobject_gparam();
+    extern void Init_gobject_gparamspecs();
+    extern void Init_gobject_gclosure();
+    extern void Init_gobject_gobject();
+    extern void Init_gobject_gsignal();
+    extern void Init_gobject_gtypeplugin();
+    extern void Init_gobject_gtypemodule();
+
+    /* Not defined properties. They are already used as methods of Object */
+    prop_exclude_list = g_hash_table_new(g_str_hash, g_str_equal);
+    g_hash_table_insert(prop_exclude_list, "class", "class");
+    g_hash_table_insert(prop_exclude_list, "clone", "clone");
+    g_hash_table_insert(prop_exclude_list, "dup", "dup");
+    g_hash_table_insert(prop_exclude_list, "extend", "extend");
+    g_hash_table_insert(prop_exclude_list, "freeze", "freeze");
+    g_hash_table_insert(prop_exclude_list, "hash", "hash");
+    g_hash_table_insert(prop_exclude_list, "method", "method");
+    g_hash_table_insert(prop_exclude_list, "methods", "methods");
+    g_hash_table_insert(prop_exclude_list, "object_id", "object_id");
+    g_hash_table_insert(prop_exclude_list, "taint", "taint");
+    g_hash_table_insert(prop_exclude_list, "untaint", "untaint");
+
+    /* IDs */
+    id_relatives = rb_intern("__relatives__");
+    id_delete = rb_intern("delete");
+    id_module_eval = rb_intern("module_eval");
+
+    rbgobj_id_children = rb_intern("__stored_children__");
+
+    Init_gobject_convert();
+
+    Init_gobject_gtype();
+    Init_gobject_typeinterface();
+    Init_gobject_typeinstance();
+    Init_gobject_gvalue();
+    Init_gobject_gvaluetypes();
+    Init_gobject_gboxed();
+#if GLIB_CHECK_VERSION(2,6,0)
+    Init_gobject_gstrv();
+#endif
+    Init_gobject_value_array();
+    Init_gobject_genums();
+    Init_gobject_gparam();
+    Init_gobject_gparamspecs();
+    Init_gobject_gclosure();
+    Init_gobject_gobject();
+    Init_gobject_gsignal();
+
+    Init_gobject_gtypeplugin();
+    Init_gobject_gtypemodule();
+}