glib2 0.20.0

data/src/rbgobj_boxed.c

@@ -0,0 +1,251 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/**********************************************************************
+
+  rbgobj_boxed.c -
+
+  $Author: sakai $
+  $Date: 2007/07/14 13:33:07 $
+  created at: Sat Jul 27 16:56:01 JST 2002
+
+  Copyright (C) 2002,2003  Masahiro Sakai
+
+**********************************************************************/
+
+#include "rbgprivate.h"
+
+VALUE rbgobj_cBoxed;
+
+static void
+boxed_mark(boxed_holder *holder)
+{
+    const RGObjClassInfo *cinfo;
+
+    cinfo = GTYPE2CINFO_NO_CREATE(holder->type);
+    if (cinfo && cinfo->mark)
+        cinfo->mark(holder->boxed);
+}
+
+static void
+boxed_free(boxed_holder *holder)
+{
+    const RGObjClassInfo *cinfo;
+
+    cinfo = GTYPE2CINFO_NO_CREATE(holder->type);
+    if (cinfo && cinfo->free)
+        cinfo->free(holder->boxed);
+
+    if (holder->own && holder->boxed)
+        g_boxed_free(holder->type, holder->boxed);
+
+    free(holder);
+}
+
+/**********************************************************************/
+
+static VALUE
+rbgobj_boxed_s_allocate(klass)
+    VALUE klass;
+{
+    const RGObjClassInfo* cinfo = rbgobj_lookup_class(klass);
+    boxed_holder* holder;
+    VALUE result;
+
+    if (cinfo->gtype == G_TYPE_BOXED)
+        rb_raise(rb_eTypeError, "abstract class");
+
+    result = Data_Make_Struct(klass, boxed_holder, 
+                              boxed_mark, boxed_free, holder);
+    holder->type  = cinfo->gtype;
+    holder->boxed = NULL;
+    holder->own   = FALSE;
+
+    return result;
+}
+
+static VALUE
+rbgobj_boxed_init(self)
+    VALUE self;
+{
+    rb_raise(rb_eTypeError, "can't initialize %s",
+             rb_class2name(CLASS_OF(self)));
+}
+
+static VALUE
+rbgobj_boxed_inspect(self)
+    VALUE self;
+{
+    boxed_holder* holder;
+    gchar* s;
+    VALUE result;
+
+    Data_Get_Struct(self, boxed_holder, holder);
+
+    s = g_strdup_printf("#<%s:%p ptr=%p own=%s>",
+                        rb_class2name(CLASS_OF(self)),
+                        (void *)self,
+                        holder->boxed,
+                        holder->own ? "true" : "false");
+
+    result = rb_str_new2(s);
+    g_free(s);
+
+    return result;
+}
+
+static VALUE
+rbgobj_boxed_init_copy(self, orig)
+    VALUE self, orig;
+{
+    boxed_holder* holder1;
+    boxed_holder* holder2;
+
+    if (self == orig) return self;
+
+    if (!rb_obj_is_instance_of(orig, rb_obj_class(self))) {
+	rb_raise(rb_eTypeError, "wrong argument class");
+    }
+
+    Data_Get_Struct(self, boxed_holder, holder1);
+    Data_Get_Struct(orig, boxed_holder, holder2);
+
+    holder1->boxed = g_boxed_copy(holder2->type, holder2->boxed);
+    holder1->own   = TRUE;
+
+    if (!holder1->boxed)
+      rb_raise(rb_eRuntimeError, "g_boxed_copy() failed");
+
+    return self;
+}
+
+/* deprecated */
+VALUE
+rbgobj_boxed_create(klass)
+    VALUE klass;
+{
+    return rbgobj_boxed_s_allocate(klass);
+}
+
+/**********************************************************************/
+
+void
+rbgobj_boxed_initialize(obj, boxed)
+    VALUE obj;
+    gpointer boxed;
+{ 
+    boxed_holder* holder;
+    Data_Get_Struct(obj, boxed_holder, holder);
+    holder->boxed = g_boxed_copy(holder->type, boxed);
+    holder->own   = TRUE;
+}
+
+gpointer
+rbgobj_boxed_get(obj, gtype)
+    VALUE obj;
+    GType gtype;
+{
+    boxed_holder* holder;
+
+    if (NIL_P(obj))
+        return NULL;
+
+    if (!RVAL2CBOOL(rb_obj_is_kind_of(obj, GTYPE2CLASS(gtype))))
+        rb_raise(rb_eArgError, "invalid argument %s (expect %s)",
+                 rb_class2name(CLASS_OF(obj)), 
+                 rb_class2name(GTYPE2CLASS(gtype)));
+
+    Data_Get_Struct(obj, boxed_holder, holder);
+    if (!holder->boxed)
+        rb_raise(rb_eArgError, "uninitialize %s", rb_class2name(CLASS_OF(obj)));
+
+    return holder->boxed;
+}
+
+VALUE
+rbgobj_make_boxed(p, gtype)
+    gpointer p;
+    GType gtype;
+{
+    const RGObjClassInfo* cinfo;
+    VALUE result;
+    boxed_holder* holder;
+
+    if (!p)
+        return Qnil;
+    
+    cinfo = GTYPE2CINFO(gtype);
+    result = rbgobj_boxed_s_allocate(cinfo->klass);
+    
+    Data_Get_Struct(result, boxed_holder, holder);
+    
+    if (cinfo->flags & RBGOBJ_BOXED_NOT_COPY){
+        holder->boxed = p;
+        holder->own   = FALSE;
+    } else {
+        holder->boxed = g_boxed_copy(gtype, p);
+        holder->own   = TRUE;
+    }
+
+    return result;
+}
+
+void
+rbgobj_boxed_not_copy_obj(gtype)
+    GType gtype;
+{
+    RGObjClassInfo* cinfo = (RGObjClassInfo*)GTYPE2CINFO(gtype);
+    cinfo->flags |= RBGOBJ_BOXED_NOT_COPY;
+}
+
+/**********************************************************************/
+
+static VALUE
+boxed_to_ruby(const GValue* from)
+{
+    gpointer boxed = g_value_get_boxed(from);
+    if (!boxed)
+        return Qnil;
+    else
+        return rbgobj_make_boxed(boxed, G_VALUE_TYPE(from));
+}
+
+static void
+boxed_from_ruby(VALUE from, GValue* to)
+{
+    boxed_holder* holder;
+
+    if (NIL_P(from)) {
+        g_value_set_boxed(to, NULL);
+        return;
+    }
+
+    Data_Get_Struct(from, boxed_holder, holder);
+
+    if (g_type_is_a(holder->type, G_VALUE_TYPE(to)))
+        g_value_set_boxed(to, holder->boxed);
+    else
+        rb_raise(rb_eRuntimeError, "%s is not a subtype of %s",
+                 g_type_name(holder->type),
+                 g_type_name(G_VALUE_TYPE(to)));
+}
+
+/**********************************************************************/
+
+void
+Init_gobject_gboxed()
+{
+    VALUE gBoxed;
+
+    rbgobj_cBoxed = G_DEF_CLASS(G_TYPE_BOXED, "Boxed", mGLib);
+    gBoxed = rbgobj_cBoxed;
+
+    rbgobj_register_g2r_func(G_TYPE_BOXED, boxed_to_ruby);
+    rbgobj_register_r2g_func(G_TYPE_BOXED, boxed_from_ruby);
+
+    rb_define_alloc_func(gBoxed, (VALUE(*)_((VALUE)))rbgobj_boxed_s_allocate);
+    rb_define_singleton_method(gBoxed, "gtype", generic_s_gtype, 0);
+    rb_define_method(gBoxed, "gtype", generic_gtype, 0);
+    rb_define_method(gBoxed, "initialize", rbgobj_boxed_init, 0);
+    rb_define_method(gBoxed, "inspect", rbgobj_boxed_inspect, 0);
+    rb_define_method(gBoxed, "initialize_copy", rbgobj_boxed_init_copy, 1);
+    rb_define_alias(gBoxed, "copy", "dup");
+}

data/src/rbgobj_closure.c

@@ -0,0 +1,337 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/**********************************************************************
+
+  rbgobj_closure.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 14:27:06 $
+
+  Copyright (C) 2002-2006  Ruby-GNOME2 Project
+  Copyright (C) 2002,2003  Masahiro Sakai
+
+**********************************************************************/
+
+#include "rbgprivate.h"
+
+static ID id_call, id_closures;
+static gboolean rclosure_initialized = FALSE;
+
+#define TAG_SIZE 64
+typedef struct _GRClosure GRClosure;
+struct _GRClosure
+{
+    GClosure closure;
+    VALUE callback;
+    VALUE extra_args;
+    VALUE rb_holder;
+    gint count;
+    GList *objects;
+    GValToRValSignalFunc g2r_func;
+    gchar tag[TAG_SIZE];
+};
+
+static VALUE
+rclosure_default_g2r_func(num, values)
+    guint num;
+    const GValue* values;
+{
+    int i;
+    VALUE args = rb_ary_new2(num);
+    for (i = 0; i < num; i++)
+        rb_ary_store(args, i, GVAL2RVAL(&values[i]));
+    return args;
+}
+
+struct marshal_arg
+{
+    GClosure*       closure;
+    GValue*         return_value;
+    guint           n_param_values;
+    const GValue*   param_values;
+    gpointer        invocation_hint;
+    gpointer        marshal_data;
+};
+
+static int
+rclosure_alive_p(GRClosure *rclosure)
+{
+    return (rclosure->count > 0 && !NIL_P(rclosure->rb_holder));
+}
+
+static VALUE
+rclosure_marshal_do(VALUE arg_)
+{
+    struct marshal_arg *arg;
+    GRClosure*      rclosure;
+    GValue*         return_value;
+    guint           n_param_values;
+    const GValue*   param_values;
+    /* gpointer        invocation_hint;*/
+    /* gpointer        marshal_data; */
+
+    VALUE ret = Qnil;
+    VALUE args;
+    GValToRValSignalFunc func;
+
+    arg = (struct marshal_arg*)arg_;
+    rclosure        = (GRClosure *)(arg->closure);
+    return_value    = arg->return_value;   
+    n_param_values  = arg->n_param_values; 
+    param_values    = arg->param_values;
+    /* invocation_hint = arg->invocation_hint; */
+    /* marshal_data    = arg->marshal_data; */
+
+    if (rclosure->g2r_func){
+        func = (GValToRValSignalFunc)rclosure->g2r_func;
+    } else { 
+        func = (GValToRValSignalFunc)rclosure_default_g2r_func;
+    }
+    args = (*func)(n_param_values, param_values);
+
+    if (rclosure_alive_p(rclosure)) {
+        VALUE callback, extra_args;
+        callback = rclosure->callback;
+        extra_args = rclosure->extra_args;
+
+        if (!NIL_P(extra_args)) {
+            args = rb_ary_concat(args, extra_args);
+        }
+
+        ret = rb_apply(callback, id_call, args);
+    } else {
+        rb_warn("GRClosure invoking callback: already destroyed: %s",
+                rclosure->tag[0] ? rclosure->tag : "(anonymous)");
+    }
+
+    if (return_value && G_VALUE_TYPE(return_value))
+        rbgobj_rvalue_to_gvalue(ret, return_value);
+
+    return Qnil;
+}
+
+static void
+rclosure_marshal(GClosure*       closure,
+                 GValue*         return_value,
+                 guint           n_param_values,
+                 const GValue*   param_values,
+                 gpointer        invocation_hint,
+                 gpointer        marshal_data)
+{
+    struct marshal_arg arg;
+
+    if (!rclosure_initialized) {
+        g_closure_invalidate(closure);
+        return;
+    }
+
+    arg.closure         = closure;
+    arg.return_value    = return_value;
+    arg.n_param_values  = n_param_values;
+    arg.param_values    = param_values;
+    arg.invocation_hint = invocation_hint;
+    arg.marshal_data    = marshal_data;
+
+    G_PROTECT_CALLBACK(rclosure_marshal_do, &arg);
+}
+
+static void rclosure_weak_notify(gpointer data, GObject* where_the_object_was);
+
+static void
+rclosure_unref(GRClosure *rclosure)
+{
+    rclosure->count--;
+
+    if (!rclosure_alive_p(rclosure)) {
+        GList *next;
+        for (next = rclosure->objects; next; next = next->next) {
+            GObject *object = G_OBJECT(next->data);
+            g_object_weak_unref(object, rclosure_weak_notify, rclosure);
+        }
+        g_list_free(rclosure->objects);
+        rclosure->objects = NULL;
+        if (!NIL_P(rclosure->rb_holder)) {
+            RDATA(rclosure->rb_holder)->dmark = NULL;
+            RDATA(rclosure->rb_holder)->dfree = NULL;
+            rclosure->rb_holder = Qnil;
+        }
+    }
+}
+
+static void
+rclosure_invalidate(gpointer data, GClosure* closure)
+{
+    GRClosure *rclosure = (GRClosure*)closure;
+
+    if (rclosure->count > 0) {
+        GList *next;
+
+        rclosure->count = 1;
+        for (next = rclosure->objects; next; next = next->next) {
+            GObject *object = G_OBJECT(next->data);
+            VALUE obj = rbgobj_ruby_object_from_instance2(object, FALSE);
+            if (!NIL_P(rclosure->rb_holder) && !NIL_P(obj))
+                G_REMOVE_RELATIVE(obj, id_closures, rclosure->rb_holder);
+        }
+
+        rclosure_unref(rclosure);
+    }
+}
+
+static void
+gr_closure_holder_mark(GRClosure *rclosure)
+{
+    rb_gc_mark(rclosure->callback);
+    rb_gc_mark(rclosure->extra_args);
+}
+
+static void
+gr_closure_holder_free(GRClosure *rclosure)
+{
+    if (rclosure->count > 0) {
+        rclosure->count = 1;
+
+        /* No need to remove us from the relatives hash of our objects, as
+         * those aren't alive anymore anyway */
+        rclosure_unref(rclosure);
+    }
+}
+
+GClosure*
+g_rclosure_new(VALUE callback_proc, VALUE extra_args, GValToRValSignalFunc g2r_func)
+{
+    GRClosure* closure;
+
+    closure = (GRClosure*)g_closure_new_simple(sizeof(GRClosure), NULL);
+
+    closure->count      = 1;
+    closure->g2r_func   = g2r_func;
+    closure->objects    = NULL;
+    closure->callback   = callback_proc;
+    closure->extra_args = extra_args;
+    closure->rb_holder  = Data_Wrap_Struct(rb_cData,
+                                           gr_closure_holder_mark,
+                                           gr_closure_holder_free,
+                                           closure);
+    closure->tag[0]     = '\0';
+
+    g_closure_set_marshal((GClosure*)closure, &rclosure_marshal);
+    g_closure_add_invalidate_notifier((GClosure*)closure, NULL,
+                                      &rclosure_invalidate);
+
+    return (GClosure*)closure;
+}
+
+static void
+rclosure_weak_notify(gpointer data, GObject* where_the_object_was)
+{
+    GRClosure *rclosure = data;
+    if (rclosure_alive_p(rclosure)) {
+        rclosure->objects =
+            g_list_remove(rclosure->objects, where_the_object_was);
+        rclosure_unref(rclosure);
+    }
+}
+
+void
+g_rclosure_attach(GClosure *closure, VALUE object)
+{
+    static VALUE mGLibObject = (VALUE)NULL;
+    GRClosure *rclosure = (GRClosure *)closure;
+
+    G_RELATIVE2(object, Qnil, id_closures, rclosure->rb_holder);
+
+    if (!mGLibObject) {
+        mGLibObject = rb_const_get(mGLib, rb_intern("Object"));
+    }
+    if (rb_obj_is_kind_of(object, mGLibObject)) {
+        GObject *gobject;
+        gobject = RVAL2GOBJ(object);
+        rclosure->count++;
+        g_object_weak_ref(gobject, rclosure_weak_notify, rclosure);
+        rclosure->objects = g_list_prepend(rclosure->objects, gobject);
+    }
+}
+
+void
+g_rclosure_set_tag(GClosure *closure, const gchar *tag)
+{
+    GRClosure *rclosure = (GRClosure *)closure;
+
+    if (tag) {
+        strncpy(rclosure->tag, tag, TAG_SIZE);
+        rclosure->tag[TAG_SIZE - 1] = '\0';
+    } else {
+        rclosure->tag[0] = '\0';
+    }
+}
+
+static void
+rclosure_end_proc(VALUE _)
+{
+    rclosure_initialized = FALSE;
+}
+
+static void
+Init_rclosure()
+{
+    id_call = rb_intern("call");
+    id_closures = rb_intern("closures");
+    rclosure_initialized = TRUE;
+    rb_set_end_proc(rclosure_end_proc, Qnil);
+}
+
+/**********************************************************************/
+
+static VALUE
+closure_initialize(self)
+    VALUE self;
+{
+    GClosure* closure = g_rclosure_new(rb_block_proc(), Qnil, NULL);
+    G_INITIALIZE(self, closure);
+    g_closure_sink(closure);
+    return self;
+}
+
+static VALUE
+closure_in_marshal(self)
+    VALUE self;
+{
+    GClosure* closure = RVAL2BOXED(self, G_TYPE_CLOSURE);
+    return CBOOL2RVAL(closure->in_marshal);
+}
+
+static VALUE
+closure_is_invalid(self)
+    VALUE self;
+{
+    GClosure* closure = RVAL2BOXED(self, G_TYPE_CLOSURE);
+    return CBOOL2RVAL(closure->is_invalid);
+}
+
+static VALUE
+closure_invalidate(self)
+    VALUE self;
+{
+    GClosure* closure = RVAL2BOXED(self, G_TYPE_CLOSURE);
+    g_closure_invalidate(closure);
+    return self;
+}
+
+static void
+Init_closure()
+{
+    VALUE cClosure = G_DEF_CLASS(G_TYPE_CLOSURE, "Closure", mGLib);
+    rb_define_method(cClosure, "initialize", closure_initialize, 0);
+    rb_define_method(cClosure, "in_marshal?", closure_in_marshal, 0);
+    rb_define_method(cClosure, "invalid?", closure_is_invalid, 0);
+    rb_define_method(cClosure, "invalidate", closure_invalidate, 0);
+}
+
+/**********************************************************************/
+
+void Init_gobject_gclosure()
+{
+    Init_rclosure();
+    Init_closure();
+}
+