glib2 0.90.2-x86-mingw32

data/ext/glib2/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();
+}

data/ext/glib2/rbgobject.h

@@ -0,0 +1,265 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/**********************************************************************
+
+  rbgobject.h -
+
+  $Author: sakai $
+  $Date: 2007/07/19 22:03:44 $
+
+  Copyright (C) 2003,2006  Ruby-GNOME2 Project Team
+  Copyright (C) 2002,2003  Masahiro Sakai
+
+**********************************************************************/
+
+#ifndef __RBGOBJECT_H__
+#define __RBGOBJECT_H__
+
+#include <glib-object.h>
+#include "ruby.h"
+#include "rbglib.h"
+#include "rbgutil.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* macros */
+
+#define G_INITIALIZE(obj, cobj)\
+ (rbgobj_initialize_object(obj, (gpointer)cobj))
+
+#define G_DEF_CLASS(gtype, name, module)\
+    (rbgobj_define_class(gtype, name, module, 0, 0, Qnil))
+#define G_DEF_CLASS_WITH_GC_FUNC(gtype, name, module, mark, free)	\
+    (rbgobj_define_class(gtype, name, module, mark, free, Qnil))
+#define G_DEF_CLASS2(gtype, name, module, mark, free)			\
+    G_DEF_CLASS_WITH_GC_FUNC(gtype, name, module, mark, free)
+#define G_DEF_CLASS3(gtype_name, name, module)\
+    (rbgobj_define_class_dynamic(gtype_name, name, module, 0, 0))
+#define G_DEF_CLASS4(gtype, name, module, parent) \
+    (rbgobj_define_class(gtype, name, module, 0, 0, parent))
+
+#define G_DEF_INTERFACE(gtype, name, module)\
+    (rbgobj_define_class(gtype, name, module, 0, 0, Qnil))
+#define G_DEF_INTERFACE2(gtype, name, module, mark, free)\
+    (rbgobj_define_class(gtype, name, module, mark, free, Qnil))
+
+#define RG_DEF_CONVERSION(table) (rbgobj_convert_define(table))
+
+#define G_RELATIVE(obj, rel) (rbgobj_add_relative(obj, rel))
+
+/* G_RELATIVE2 is useless now. Try G_CHILD_ADD/REMOVE first. */
+#define G_RELATIVE2(obj, rel, id, hash_key)\
+ (rbgobj_add_relative_removable(obj, rel, id, hash_key))
+#define G_GET_RELATIVE(obj, id, hash_key)\
+ (rbgobj_get_relative_removable(obj, id, hash_key))
+#define G_REMOVE_RELATIVE(obj, id, hash_key)\
+ (rbgobj_remove_relative(obj, id, hash_key))
+
+RUBY_GLIB2_VAR  ID rbgobj_id_children;
+#define G_CHILD_SET(self, id, child)  (rb_ivar_set(self, id, child))
+#define G_CHILD_UNSET(self, id)  (rb_ivar_set(self, id, Qnil))
+
+/* G_CHILD_ADD is same as G_RELATIVE, but the macro name is more obviously
+   to use than G_RELATIVE, and also support "remove" operation with the key
+   which is the object itself.
+*/
+#define G_CHILD_ADD(self, child) \
+    (rbgobj_add_relative_removable(self, Qnil, rbgobj_id_children, child))
+#define G_CHILD_REMOVE(self, child) \
+    (rbgobj_remove_relative(self, rbgobj_id_children, child))
+#define G_CHILD_REMOVE_ALL(self) \
+    (rbgobj_remove_relative_all(self, rbgobj_id_children))
+
+#define G_DEF_SIGNAL_FUNC(klass, sig_name, func)\
+ (rbgobj_set_signal_func(klass, sig_name, func))
+
+#define CLASS2CINFO(klass) (rbgobj_lookup_class(klass))
+#define GTYPE2CINFO(gtype) (rbgobj_lookup_class_by_gtype(gtype, Qnil))
+#define GTYPE2CINFO_NO_CREATE(gtype) (rbgobj_lookup_class_by_gtype_full(gtype, Qnil, FALSE))
+#define RVAL2CINFO(obj)    (rbgobj_lookup_class(CLASS_OF(obj)))
+#define GTYPE2CLASS(gtype) (rbgobj_gtype_to_ruby_class(gtype))
+#define CLASS2GTYPE(klass) (rbgobj_lookup_class(klass)->gtype)
+#define RVAL2GTYPE(obj)    (CLASS2GTYPE(CLASS_OF(obj)))
+
+#define RVAL2GOBJ(obj)  (rbgobj_instance_from_ruby_object(obj))
+#define GOBJ2RVAL(gobj) (rbgobj_ruby_object_from_instance(gobj))
+#define GOBJ2RVAL_UNREF(gobj) (rbgobj_ruby_object_from_instance_with_unref(gobj))
+#define GOBJ2RVALU(gobj) GOBJ2RVAL_UNREF(gobj)
+#define GVAL2RVAL(v)    (rbgobj_gvalue_to_rvalue(v))
+
+#define RVAL2BOXED(obj, gtype)  (rbgobj_boxed_get(obj, gtype))
+#define BOXED2RVAL(cobj, gtype) (rbgobj_make_boxed(cobj, gtype))
+
+#define RVAL2GENUM(obj, gtype)  (rbgobj_get_enum(obj, gtype))
+#define RVAL2GFLAGS(obj, gtype) (rbgobj_get_flags(obj, gtype))
+#define GENUM2RVAL(n, gtype)    (rbgobj_make_enum(n, gtype))
+#define GFLAGS2RVAL(n, gtype)   (rbgobj_make_flags(n, gtype))
+
+#define RVAL2GPTR(object)       (rbgobj_ptr2cptr(object))
+#define GPTR2RVAL(ptr, gtype)   (rbgobj_ptr_new(gtype, ptr))
+
+#define G_DEF_CONSTANTS(mod, type, strip_prefix) \
+	rbgobj_add_constants(mod, type, strip_prefix)
+#define G_RENAME_CONSTANT(orig, alt) \
+	rbgobj_constant_remap(orig, alt)
+#define G_RENAME_NICK(orig, alt) \
+	rbgobj_constant_remap(orig, alt)
+
+typedef enum
+{
+    RBGOBJ_ABSTRACT_BUT_CREATABLE = 1 << 0, /* deprecated */
+    RBGOBJ_BOXED_NOT_COPY         = 1 << 1,
+    RBGOBJ_DEFINED_BY_RUBY        = 1 << 2,
+} RGObjClassFlag;
+    
+typedef struct {
+    VALUE klass;
+    GType gtype;
+    void (*mark)(gpointer);
+    void (*free)(gpointer);
+    int flags; /* RGObjClassFlag */
+} RGObjClassInfo;
+
+/* rbgobject.c */
+
+extern void rbgobj_initialize_object(VALUE obj, gpointer cobj);
+extern gpointer rbgobj_instance_from_ruby_object(VALUE obj);
+extern VALUE rbgobj_ruby_object_from_instance(gpointer instance);
+extern VALUE rbgobj_ruby_object_from_instance2(gpointer instance, gboolean alloc);
+extern VALUE rbgobj_ruby_object_from_instance_with_unref(gpointer instance);
+
+extern void rbgobj_add_relative(VALUE obj, VALUE relative);
+extern void rbgobj_invalidate_relatives(VALUE obj);
+extern void rbgobj_add_relative_removable(VALUE obj, VALUE relative,
+                                          ID obj_ivar_id, VALUE hash_key);
+extern VALUE rbgobj_get_relative_removable(VALUE obj, ID obj_ivar_id,
+                                           VALUE hash_key);
+extern void rbgobj_remove_relative(VALUE obj, ID obj_ivar_id, VALUE hash_key);
+extern void rbgobj_remove_relative_all(VALUE obj, ID obj_ivar_id);
+
+extern GObject* rbgobj_gobject_new(GType type, VALUE params_hash);
+extern VALUE rbgobj_create_object(VALUE klass); /* deprecated */
+
+extern VALUE rbgobj_get_ruby_object_from_gobject(GObject* gobj, gboolean alloc);
+
+/* deprecated */
+extern void rbgobj_add_abstract_but_create_instance_class(GType gtype);
+
+/* rbgobj_typeinstance.c */
+extern void rbgobj_gc_mark_instance(gpointer instance);
+
+
+/* rbgobj_type.c */
+extern const RGObjClassInfo *rbgobj_lookup_class(VALUE klass);
+extern const RGObjClassInfo *rbgobj_lookup_class_by_gtype(GType gtype, VALUE parent);
+extern const RGObjClassInfo *rbgobj_lookup_class_by_gtype_full(GType gtype,
+							       VALUE parent,
+							       gboolean create_object);
+extern VALUE rbgobj_gtype_to_ruby_class(GType gtype);
+extern VALUE rbgobj_define_class(GType gtype, const gchar* name, VALUE module,
+                                 void* mark, void* free, VALUE parent); 
+extern VALUE rbgobj_define_class_dynamic(const gchar* gtype_name, 
+                                         const gchar* name, VALUE module, 
+                                         void* mark, void* free); 
+extern void rbgobj_register_class(VALUE klass,
+                                  GType gtype,
+                                  gboolean klass2gtype,
+                                  gboolean gtype2klass);
+extern VALUE rbgobj_cType;
+extern VALUE rbgobj_gtype_new(GType gtype);
+extern GType rbgobj_gtype_get(VALUE obj);
+
+/* rbgobj_signal.c */
+typedef VALUE (*GValToRValSignalFunc)(guint num,const GValue* values);
+extern void rbgobj_set_signal_func(VALUE klass, gchar* sig_name, GValToRValSignalFunc func);
+extern GValToRValSignalFunc rbgobj_get_signal_func(guint signal_id);
+extern VALUE rbgobj_signal_wrap(guint sig_id);
+
+
+/* rbgobj_closure.c */
+extern GClosure* g_rclosure_new(VALUE callback_proc, VALUE extra_args,
+                                GValToRValSignalFunc func);
+extern void g_rclosure_attach(GClosure *closure, VALUE object);
+extern void g_rclosure_set_tag(GClosure *closure, const gchar *tag);
+
+/* rbgobj_value.c */
+extern VALUE rbgobj_gvalue_to_rvalue(const GValue* value);
+extern void rbgobj_rvalue_to_gvalue(VALUE val, GValue* result);
+extern void rbgobj_initialize_gvalue(GValue *result, VALUE value);
+
+typedef void (*RValueToGValueFunc)(VALUE from, GValue* to);
+typedef VALUE (*GValueToRValueFunc)(const GValue* from);
+extern void rbgobj_register_r2g_func(GType gtype, RValueToGValueFunc func);
+extern void rbgobj_register_g2r_func(GType gtype, GValueToRValueFunc func);
+
+extern void rbgobj_gc_mark_gvalue(GValue* value);
+
+/* rbgobj_valuetypes.c */
+extern VALUE rbgobj_ptr_new(GType type, gpointer ptr);
+extern gpointer rbgobj_ptr2cptr(VALUE ptr);
+
+#define RBGOBJ_TYPE_RUBY_VALUE (rbgobj_ruby_value_get_type())
+extern GType rbgobj_ruby_value_get_type();
+extern VALUE g_value_get_ruby_value(const GValue* value);
+extern void g_value_set_ruby_value(GValue* value, VALUE ruby);
+
+/* rbgobj_object.c */
+extern void rbgobj_register_property_setter(GType gtype, const char* prop_name, RValueToGValueFunc func);
+extern void rbgobj_register_property_getter(GType gtype, const char* prop_name, GValueToRValueFunc func);
+
+/* rbgobj_boxed.c */
+extern VALUE rbgobj_boxed_create(VALUE klass); /* deprecated */
+extern gpointer rbgobj_boxed_get(VALUE obj, GType gtype);
+extern VALUE rbgobj_make_boxed(gpointer data, GType gtype);
+extern void rbgobj_boxed_not_copy_obj(GType gtype);
+
+/* rbgobj_enums.c */
+extern void rbgobj_constant_remap(const char *original, const char *replacement);
+extern void rbgobj_add_constants(VALUE mod, GType type, const gchar *strip_prefix);
+extern VALUE rbgobj_make_enum(gint n, GType gtype);
+extern gint rbgobj_get_enum(VALUE obj, GType gtype);
+extern VALUE rbgobj_make_flags(guint n, GType gtype);
+extern guint rbgobj_get_flags(VALUE obj, GType gtype);
+extern void rbgobj_define_const(VALUE mod, const char *name, VALUE value);
+
+
+/* rbglib_mainloop.c */
+#define G_TYPE_MAIN_LOOP (g_main_loop_get_type())
+extern GType g_main_loop_get_type(void);
+
+/* rbglib_maincontext.c */
+#define G_TYPE_MAIN_CONTEXT (g_main_context_get_type())
+#define G_TYPE_SOURCE (g_source_get_type())
+#define G_TYPE_POLL_FD (g_poll_fd_get_type())
+extern GType g_main_context_get_type(void);
+extern GType g_source_get_type(void);
+extern GType g_poll_fd_get_type(void);
+
+/* rbglib_keyfile.c */
+#define G_TYPE_KEY_FILE (g_key_file_get_type())
+extern GType g_key_file_get_type(void);
+
+/* rbgobj_convert.c */
+typedef struct {
+    GType type;
+    VALUE klass;
+    VALUE (*get_superclass)(void);
+    void (*type_init_hook)(VALUE);
+    void (*rvalue2gvalue)(VALUE val, GValue *result);
+    VALUE (*gvalue2rvalue)(const GValue *);
+    void (*initialize)(VALUE, gpointer);
+    gpointer (*robj2instance)(VALUE);
+    VALUE (*instance2robj)(gpointer);
+    void (*unref)(gpointer instance);
+} RGConvertTable;
+
+extern void rbgobj_convert_define(RGConvertTable *table);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __RBGOBJECT_H__ */
+
+#include "rbgcompat.h"