glib2 0.20.0

data/src/rbgobj_typeinstance.c

@@ -0,0 +1,121 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/**********************************************************************
+
+  rbgobj_typeinstance.c -
+
+  $Author: sakai $
+  $Date: 2007/07/04 13:13:19 $
+  created at: Sat May 27 14:18:55 JST 2006
+ 
+  Copyright (C) 2002-2006  Ruby-GNOME2 Project Team
+  Copyright (C) 2002,2003  Masahiro Sakai
+
+**********************************************************************/
+
+#include "rbgprivate.h"
+
+VALUE cInstantiatable;
+
+typedef void (*ClassInfoCallbackFunc) (gpointer instance,
+				       const RGObjClassInfo *class_info,
+				       gpointer user_data);
+
+static VALUE
+instantiatable_s_allocate(klass)
+     VALUE klass;
+{
+     rb_raise(rb_eTypeError, "abstract class");
+}
+
+static VALUE
+instantiatable_get_gtype(self)
+    VALUE self;
+{
+    return rbgobj_gtype_new(G_TYPE_FROM_INSTANCE(rbgobj_instance_from_ruby_object(self)));
+}
+
+static VALUE
+instantiatable_clone(self)
+    VALUE self;
+{
+    rb_raise(rb_eTypeError, "can't clone %s", rb_class2name(CLASS_OF(self)));
+}
+
+/**********************************************************************/
+
+static void
+each_cinfo(gpointer instance, ClassInfoCallbackFunc func, gpointer user_data)
+{
+    const GType gtype = G_TYPE_FROM_INSTANCE(instance);
+    GType* interfaces;
+    guint n_interfaces = 0;
+
+    interfaces = g_type_interfaces(gtype, &n_interfaces);
+    {
+        guint i;
+        for (i = 0; i < n_interfaces; i++) {
+	    const RGObjClassInfo *info;
+
+	    info = GTYPE2CINFO_NO_CREATE(interfaces[i]);
+	    if (info)
+		func(instance, info, user_data);
+	}
+    }
+    g_free(interfaces);
+
+    {
+        GType type;
+        for (type = gtype; type != G_TYPE_INVALID; type = g_type_parent(type)) {
+	    const RGObjClassInfo *info;
+
+	    info = GTYPE2CINFO_NO_CREATE(type);
+	    if (info)
+		func(instance, info, user_data);
+	}
+    }
+}
+
+static void
+call_cinfo_free(gpointer instance, const RGObjClassInfo *cinfo, gpointer user_data)
+{
+    if (cinfo->free) cinfo->free(instance);
+}
+
+static void
+call_cinfo_mark(gpointer instance, const RGObjClassInfo *cinfo, gpointer user_data)
+{
+    if (cinfo->mark) cinfo->mark(instance);
+}
+
+void
+rbgobj_instance_call_cinfo_mark(gpointer instance)
+{
+    each_cinfo(instance, call_cinfo_mark, NULL);
+}
+
+void
+rbgobj_instance_call_cinfo_free(gpointer instance)
+{
+    each_cinfo(instance, call_cinfo_free, NULL);
+}
+
+void
+rbgobj_gc_mark_instance(gpointer instance)
+{
+    VALUE obj = rbgobj_ruby_object_from_instance2(instance, FALSE);
+    rb_gc_mark(obj);
+}
+
+/**********************************************************************/
+
+void
+Init_gobject_typeinstance()
+{
+    /* should be renamed to GLib::Instance? */
+    cInstantiatable = rb_define_class_under(mGLib, "Instantiatable", rb_cObject);
+    rb_extend_object(cInstantiatable, mMetaInterface);
+
+    rb_define_alloc_func(cInstantiatable, (VALUE(*)_((VALUE)))instantiatable_s_allocate);
+    rb_define_method(cInstantiatable, "gtype", instantiatable_get_gtype, 0);
+    rb_define_method(cInstantiatable, "clone", instantiatable_clone, 0);
+}

data/src/rbgobj_typeinterface.c

@@ -0,0 +1,148 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/**********************************************************************
+
+  rbgobj_typeinterface.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:28 $
+  created at: Sat May 27 16:04:13 JST 2006
+
+  Copyright (C) 2002-2006  Ruby-GNOME2 Project Team
+  Copyright (C) 2002,2003  Masahiro Sakai
+
+**********************************************************************/
+
+#include "rbgprivate.h"
+
+VALUE rbgobj_mInterface;
+VALUE mMetaInterface;
+
+static VALUE
+interface_s_append_features(self, klass)
+     VALUE self, klass;
+{
+    if (!rb_obj_is_kind_of(klass, cInstantiatable))
+        rb_raise(rb_eTypeError, "Not a subclass of GLib::Instantiatable");
+    return rb_call_super(1, &klass);
+}
+
+#if GLIB_CHECK_VERSION(2,4,0)
+
+static VALUE
+interface_s_install_property(self, pspec_obj)
+    VALUE self, pspec_obj;
+{
+    const RGObjClassInfo* cinfo = rbgobj_lookup_class(self);
+    gpointer ginterface;
+    GParamSpec* pspec;
+
+    if (cinfo->klass != self)
+        rb_raise(rb_eTypeError, "%s isn't registered class", rb_class2name(self));
+
+    pspec = G_PARAM_SPEC(RVAL2GOBJ(pspec_obj));
+    ginterface = g_type_default_interface_ref(cinfo->gtype);
+    g_object_interface_install_property(ginterface, pspec);
+    g_type_default_interface_unref(ginterface);
+
+    /* FIXME: define accessor methods */
+    return Qnil;
+}
+
+static VALUE
+interface_s_property(self, property_name)
+    VALUE self, property_name;
+{
+    gpointer ginterface;
+    const char* name;
+    GParamSpec* prop;
+    VALUE result;
+    GType gtype = CLASS2GTYPE(self);
+
+    if (SYMBOL_P(property_name))
+        name = rb_id2name(SYM2ID(property_name));
+    else
+        name = StringValuePtr(property_name);
+
+    if (!G_TYPE_IS_INTERFACE(gtype))
+        rb_raise(rb_eTypeError, "%s isn't interface module", rb_class2name(self));
+    /* XXX: g_type_default_interface_ref(G_TYPE_INTERFACE) causes SEGV. */
+    if (gtype == G_TYPE_INTERFACE) {
+        rb_raise(rb_const_get(mGLib, rb_intern("NoPropertyError")),
+                 "No such property: %s", name);
+    }
+
+    ginterface = g_type_default_interface_ref(gtype);
+    prop = g_object_interface_find_property(ginterface, name);
+    if (!prop){
+        g_type_default_interface_unref(ginterface);
+        rb_raise(rb_const_get(mGLib, rb_intern("NoPropertyError")),
+                 "No such property: %s", name);
+    }
+    result = GOBJ2RVAL(prop);
+    g_type_default_interface_unref(ginterface);
+
+    return result;
+}
+
+static VALUE
+interface_s_properties(int argc, VALUE* argv, VALUE self)
+{
+    guint n_properties;
+    GParamSpec** props;
+    VALUE inherited_too;
+    VALUE ary = rb_ary_new();
+    int i;
+    gpointer ginterface;
+    GType gtype = CLASS2GTYPE(self);
+
+    if (rb_scan_args(argc, argv, "01", &inherited_too) == 0)
+        inherited_too = Qtrue;
+
+    if (!G_TYPE_IS_INTERFACE(gtype))
+        rb_raise(rb_eTypeError, "%s isn't interface module", rb_class2name(self));
+    /* XXX: g_type_default_interface_ref(G_TYPE_INTERFACE) causes SEGV. */
+    if (gtype == G_TYPE_INTERFACE) return ary;
+
+    ginterface = g_type_default_interface_ref(gtype);
+    props = g_object_interface_list_properties(ginterface, &n_properties);
+    for (i = 0; i < n_properties; i++){
+        if (RVAL2CBOOL(inherited_too) || GTYPE2CLASS(props[i]->owner_type) == self)
+            rb_ary_push(ary, rb_str_new2(props[i]->name));
+    }
+    g_free(props);
+    g_type_default_interface_unref(ginterface);
+
+    return ary;
+}
+
+#endif
+
+void
+rbgobj_init_interface(VALUE interf)
+{
+    static VALUE rb_mGLibInterface = Qnil;
+
+    rb_extend_object(interf, mMetaInterface);
+    if (CLASS2GTYPE(interf) == G_TYPE_INTERFACE) {
+	rb_mGLibInterface = interf;
+    } else {
+        rb_extend_object(interf, rb_mGLibInterface);
+        rb_include_module(interf, rb_mGLibInterface);
+        rbgobj_define_property_accessors(interf);
+    }
+}
+
+void
+Init_gobject_typeinterface()
+{
+    mMetaInterface = rb_define_module_under(mGLib, "MetaInterface");
+    rb_define_method(mMetaInterface, "gtype", generic_s_gtype, 0);
+    rb_define_method(mMetaInterface, "append_features", interface_s_append_features, 1);
+#if GLIB_CHECK_VERSION(2,4,0)
+    rb_define_method(mMetaInterface, "install_property", interface_s_install_property, 1);
+    rb_define_method(mMetaInterface, "property", interface_s_property, 1);
+    rb_define_method(mMetaInterface, "properties", interface_s_properties, -1);
+#endif
+
+    rbgobj_mInterface = G_DEF_INTERFACE(G_TYPE_INTERFACE, "Interface", mGLib);
+}

data/src/rbgobj_typemodule.c

@@ -0,0 +1,66 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/**********************************************************************
+
+  rbgobj_typemodule.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 14:27:07 $
+  created at: Sat Jul 27 16:56:01 JST 2002
+
+  Copyright (C) 2002,2003  Masahiro Sakai
+
+**********************************************************************/
+
+#include "rbgprivate.h"
+
+static VALUE
+use(self)
+   VALUE self;
+{
+    return CBOOL2RVAL(g_type_module_use(G_TYPE_MODULE(RVAL2GOBJ(self))));
+}
+
+static VALUE
+unuse(self)
+   VALUE self;
+{
+    g_type_module_unuse(G_TYPE_MODULE(RVAL2GOBJ(self)));
+    return self;
+}
+
+static VALUE
+get_name(self)
+   VALUE self;
+{
+    return rb_str_new2(G_TYPE_MODULE(RVAL2GOBJ(self))->name);
+}
+
+static VALUE
+set_name(self, name)
+   VALUE self, name;
+{
+    g_type_module_set_name(G_TYPE_MODULE(RVAL2GOBJ(self)), StringValuePtr(name));
+    return name;
+}
+
+#if 0
+GType    g_type_module_register_type (GTypeModule     *module,
+				      GType            parent_type,
+				      const gchar     *type_name,
+				      const GTypeInfo *type_info,
+				      GTypeFlags       flags);
+void     g_type_module_add_interface (GTypeModule           *module,
+				      GType                  instance_type,
+				      GType                  interface_type,
+				      const GInterfaceInfo  *interface_info);
+#endif
+
+void
+Init_gobject_gtypemodule()
+{
+    VALUE cTypeModule = G_DEF_CLASS(G_TYPE_TYPE_MODULE, "TypeModule", mGLib);
+    rb_define_method(cTypeModule, "use", use, 0);
+    rb_define_method(cTypeModule, "unuse", unuse, 0);
+    rb_define_method(cTypeModule, "name", get_name, 0);
+    rb_define_method(cTypeModule, "name=", set_name, 1);
+}

data/src/rbgobj_typeplugin.c

@@ -0,0 +1,49 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/**********************************************************************
+
+  rbgobj_typeplugin.c -
+
+  $Author: mutoh $
+  $Date: 2003/02/01 16:03:09 $
+  created at: Mon Aug  5 00:42:09 JST 2002
+
+  Copyright (C) 2002,2003  Masahiro Sakai
+
+**********************************************************************/
+
+#include "rbgprivate.h"
+
+static VALUE
+use(self)
+   VALUE self;
+{
+    g_type_plugin_use(G_TYPE_PLUGIN(RVAL2GOBJ(self)));
+    return self;
+}
+
+static VALUE
+unuse(self)
+   VALUE self;
+{
+    g_type_plugin_unuse(G_TYPE_PLUGIN(RVAL2GOBJ(self)));
+    return self;
+}
+
+#if 0
+void	g_type_plugin_complete_type_info	(GTypePlugin     *plugin,
+						 GType            g_type,
+						 GTypeInfo       *info,
+						 GTypeValueTable *value_table);
+void	g_type_plugin_complete_interface_info	(GTypePlugin     *plugin,
+						 GType            interface_type,
+						 GType            instance_type,
+						 GInterfaceInfo  *info);
+#endif
+
+void
+Init_gobject_gtypeplugin()
+{
+    VALUE iTypePlugin = G_DEF_INTERFACE(G_TYPE_TYPE_PLUGIN, "TypePlugin", mGLib);
+    rb_define_method(iTypePlugin, "use", use, 0);
+    rb_define_method(iTypePlugin, "unuse", unuse, 0);
+}

data/src/rbgobj_value.c

@@ -0,0 +1,313 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/**********************************************************************
+
+  rbgobj_value.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:28 $
+
+  Copyright (C) 2002,2003  Masahiro Sakai
+
+**********************************************************************/
+
+#include "rbgprivate.h"
+
+/**********************************************************************/
+
+static ID id_to_s;
+static GQuark qRValueToGValueFunc;
+static GQuark qGValueToRValueFunc;
+
+void
+rbgobj_register_r2g_func(GType gtype, RValueToGValueFunc func)
+{
+    g_type_set_qdata(gtype, qRValueToGValueFunc, func);
+}
+
+void
+rbgobj_register_g2r_func(GType gtype, GValueToRValueFunc func)
+{
+    g_type_set_qdata(gtype, qGValueToRValueFunc, func);
+}
+
+/**********************************************************************/
+
+VALUE
+rbgobj_gvalue_to_rvalue(const GValue* value)
+{
+    GType type, fundamental_type;
+    VALUE rvalue;
+
+    if (!value)
+        return Qnil;
+
+    type = G_VALUE_TYPE(value);
+    if (rbgobj_convert_gvalue2rvalue(type, value, &rvalue))
+        return rvalue;
+
+    fundamental_type = G_TYPE_FUNDAMENTAL(type);
+    switch (fundamental_type) {
+      case G_TYPE_NONE:
+        return Qnil;
+      case G_TYPE_CHAR:
+        return CHR2FIX(g_value_get_char(value));
+      case G_TYPE_UCHAR:
+        return INT2FIX(g_value_get_uchar(value));
+      case G_TYPE_BOOLEAN:
+        return CBOOL2RVAL(g_value_get_boolean(value));
+      case G_TYPE_INT:
+        return INT2NUM(g_value_get_int(value));
+      case G_TYPE_UINT:
+        return UINT2NUM(g_value_get_uint(value));
+      case G_TYPE_LONG:
+        return LONG2NUM(g_value_get_long(value));
+      case G_TYPE_ULONG:
+        return ULONG2NUM(g_value_get_ulong(value));
+      case G_TYPE_INT64:
+        return rbglib_int64_to_num(g_value_get_int64(value));
+      case G_TYPE_UINT64:
+        return rbglib_uint64_to_num(g_value_get_uint64(value));
+      case G_TYPE_FLOAT:
+        return rb_float_new(g_value_get_float(value));
+      case G_TYPE_DOUBLE:
+        return rb_float_new(g_value_get_double(value));
+      case G_TYPE_STRING:
+        {
+            const char* str = g_value_get_string(value);
+            return str ? rb_str_new2(str) : Qnil;
+        }
+      case G_TYPE_ENUM:
+        return rbgobj_make_enum(g_value_get_enum(value), type);
+      case G_TYPE_FLAGS:
+        return rbgobj_make_flags(g_value_get_flags(value), type);
+      case G_TYPE_OBJECT:
+      case G_TYPE_INTERFACE:
+        {
+            GObject* gobj = g_value_get_object(value);
+            return gobj ? GOBJ2RVAL(gobj) : Qnil;
+        }
+      case G_TYPE_PARAM:
+        {
+            GParamSpec* pspec = g_value_get_param(value);
+            return pspec ? rbgobj_ruby_object_from_instance(pspec) : Qnil;
+        }
+      case G_TYPE_POINTER:
+        {
+            gpointer ptr = g_value_get_pointer(value);
+            if (!ptr)
+                return Qnil;
+            else
+                return rbgobj_ptr_new(type, ptr);
+        }
+
+      case G_TYPE_BOXED:
+        {
+            GType gtype;
+            for (gtype = type;
+                 gtype != G_TYPE_INVALID;
+                 gtype = g_type_parent(gtype))
+            {
+                GValueToRValueFunc func =
+                    g_type_get_qdata(gtype, qGValueToRValueFunc);
+                if (!func)
+                    continue;
+                return func(value);
+            }
+        }
+      default:
+        if (!rbgobj_convert_gvalue2rvalue(fundamental_type, value, &rvalue)) {
+            GValueToRValueFunc func;
+            func = g_type_get_qdata(type, qGValueToRValueFunc);
+            if (!func) {
+                g_warning("rbgobj_gvalue_to_rvalue: unsupported type: %s\n",
+                          g_type_name(type));
+            } else {
+                rvalue = func(value);
+            }
+        }
+        return rvalue;
+    }
+}
+
+void
+rbgobj_initialize_gvalue(GValue *result, VALUE value)
+{
+    GType type;
+
+    type = rbgobj_convert_rvalue2gtype(value);
+    if (type == 0) {
+        switch (TYPE(value)) {
+          case T_NONE:
+          case T_NIL:
+            type = G_TYPE_NONE;
+            break;
+          case T_FLOAT:
+            type = G_TYPE_DOUBLE;
+            break;
+          case T_STRING:
+          case T_SYMBOL:
+            type = G_TYPE_STRING;
+            break;
+          case T_FIXNUM:
+            type = G_TYPE_INT;
+            break;
+          case T_BIGNUM:
+            type = G_TYPE_INT64;
+            break;
+          case T_TRUE:
+          case T_FALSE:
+            type = G_TYPE_BOOLEAN;
+            break;
+          default:
+	    if (RVAL2CBOOL(rb_obj_is_kind_of(value, rbgobj_cEnum))) {
+		type = G_TYPE_ENUM;
+	    }
+	    else if (RVAL2CBOOL(rb_obj_is_kind_of(value, rbgobj_cFlags))) {
+		type = G_TYPE_FLAGS;
+	    }
+	    else if (RVAL2CBOOL(rb_obj_is_kind_of(value, rbgobj_cBoxed))) {
+		type = G_TYPE_BOXED;
+	    }
+	    else if (RVAL2CBOOL(rb_obj_is_kind_of(value, rbgobj_cParam))) {
+		type = G_TYPE_PARAM;
+	    }
+	    else if (RVAL2CBOOL(rb_obj_is_kind_of(value, rbgobj_cObject))) {
+		type = G_TYPE_OBJECT;
+	    }
+	    else if (RVAL2CBOOL(rb_obj_is_kind_of(value, rbgobj_mInterface))) {
+		/* should use rbgobj_mMetaInterface? */
+		type = G_TYPE_INTERFACE;
+	    }
+	    else {
+		VALUE inspected_value;
+		inspected_value = rb_funcall(value, rb_intern("inspect"), 0);
+		rb_raise(rb_eArgError,
+			 "unsupported value type: %s",
+			 RSTRING_PTR(inspected_value));
+	    }
+	    break;
+        }
+    }
+
+    g_value_init(result, type);
+    rbgobj_rvalue_to_gvalue(value, result);
+}
+
+void
+rbgobj_rvalue_to_gvalue(VALUE val, GValue* result)
+{
+    GType type, fundamental_type;
+
+    type = G_VALUE_TYPE(result);
+    if (rbgobj_convert_rvalue2gvalue(type, val, result))
+        return;
+
+    fundamental_type = G_TYPE_FUNDAMENTAL(type);
+    switch (fundamental_type) {
+      case G_TYPE_NONE:
+        return;
+      case G_TYPE_CHAR:
+        g_value_set_char(result, NUM2INT(val));
+        return;
+      case G_TYPE_UCHAR:
+        g_value_set_uchar(result, NUM2UINT(val));
+        return;
+      case G_TYPE_BOOLEAN:
+        g_value_set_boolean(result, RVAL2CBOOL(val));
+        return;
+      case G_TYPE_INT:
+        g_value_set_int(result, NUM2INT(val));
+        return;
+      case G_TYPE_UINT:
+        g_value_set_uint(result, NUM2UINT(val));
+        return;
+      case G_TYPE_LONG:
+        g_value_set_long(result, NUM2LONG(val));
+        return;
+      case G_TYPE_ULONG:
+        g_value_set_ulong(result, NUM2ULONG(val));
+        return;
+      case G_TYPE_INT64:
+        g_value_set_int64(result, rbglib_num_to_int64(val));
+        return;
+      case G_TYPE_UINT64:
+        g_value_set_uint64(result, rbglib_num_to_uint64(val));
+        return;
+      case G_TYPE_ENUM:
+        g_value_set_enum(result, rbgobj_get_enum(val, G_VALUE_TYPE(result)));
+        return;
+      case G_TYPE_FLAGS:
+        g_value_set_flags(result, rbgobj_get_flags(val, G_VALUE_TYPE(result)));
+        return;
+      case G_TYPE_FLOAT:
+        g_value_set_float(result, NUM2DBL(val));
+        return;
+      case G_TYPE_DOUBLE:
+        g_value_set_double(result, NUM2DBL(val));
+        return;
+      case G_TYPE_STRING:
+        {
+            if (SYMBOL_P(val))
+                val = rb_funcall(val, id_to_s, 0);
+            g_value_set_string(result, NIL_P(val) ? NULL : StringValuePtr(val));
+            return;
+        }
+      case G_TYPE_OBJECT:
+      case G_TYPE_INTERFACE:
+        g_value_set_object(result, NIL_P(val) ? NULL : RVAL2GOBJ(val));
+        return;
+      case G_TYPE_PARAM:
+        g_value_set_param(result, NIL_P(val) ? NULL : RVAL2GOBJ(val));
+        return;
+      case G_TYPE_POINTER:
+        g_value_set_pointer(result, NIL_P(val) ? NULL : rbgobj_ptr2cptr(val));
+        return;
+      case G_TYPE_BOXED:
+        {
+            GType gtype;
+            for (gtype = type;
+                 gtype != G_TYPE_INVALID;
+                 gtype = g_type_parent(gtype))
+            {
+                RValueToGValueFunc func =
+                    g_type_get_qdata(gtype, qRValueToGValueFunc);
+                if (!func)
+                    continue;
+                func(val, result);
+                return;
+            }
+        }
+
+      default:
+        if (!rbgobj_convert_rvalue2gvalue(fundamental_type, val, result)) {
+            RValueToGValueFunc func =
+                g_type_get_qdata(type, qRValueToGValueFunc);
+            if (!func){
+                g_warning("rbgobj_rvalue_to_gvalue: unsupported type: %s\n",
+                          g_type_name(type));
+            } else {
+                func(val, result);
+            }
+        }
+    }
+}
+
+/**********************************************************************/
+
+void
+rbgobj_gc_mark_gvalue(GValue* value)
+{
+    GType gtype = G_VALUE_TYPE(value);
+    /* FIXME */
+    if (G_TYPE_FUNDAMENTAL(gtype) == G_TYPE_OBJECT)
+        rbgobj_gc_mark_instance(g_value_get_object(value));
+}
+
+/**********************************************************************/
+
+void Init_gobject_gvalue()
+{
+    id_to_s = rb_intern("to_s");
+    qRValueToGValueFunc = g_quark_from_static_string("__ruby_r2g_func__");
+    qGValueToRValueFunc = g_quark_from_static_string("__ruby_g2r_func__");
+}