gobject-introspection 2.2.4-x64-mingw32

data/ext/gobject-introspection/rb-gi-interface-info.c

@@ -0,0 +1,222 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2012  Ruby-GNOME2 Project Team
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rb-gi-private.h"
+
+#define RG_TARGET_NAMESPACE rb_cGIInterfaceInfo
+#define SELF(self) (RVAL2GI_INTERFACE_INFO(self))
+
+GType
+gi_interface_info_get_type(void)
+{
+    static GType type = 0;
+    if (type == 0) {
+	type = g_boxed_type_register_static("GIInterfaceInfo",
+                                            (GBoxedCopyFunc)g_base_info_ref,
+                                            (GBoxedFreeFunc)g_base_info_unref);
+    }
+    return type;
+}
+
+static VALUE
+rg_n_prerequisites(VALUE self)
+{
+    GIInterfaceInfo *info;
+
+    info = SELF(self);
+    return INT2NUM(g_interface_info_get_n_prerequisites(info));
+}
+
+static VALUE
+rg_get_prerequisite(VALUE self, VALUE rb_n)
+{
+    GIInterfaceInfo *info;
+    gint n;
+
+    info = SELF(self);
+    n = NUM2INT(rb_n);
+    return GI_BASE_INFO2RVAL_WITH_UNREF(g_interface_info_get_prerequisite(info, n));
+}
+
+static VALUE
+rg_n_properties(VALUE self)
+{
+    GIInterfaceInfo *info;
+
+    info = SELF(self);
+    return INT2NUM(g_interface_info_get_n_properties(info));
+}
+
+static VALUE
+rg_get_property(VALUE self, VALUE rb_n)
+{
+    GIInterfaceInfo *info;
+    gint n;
+
+    info = SELF(self);
+    n = NUM2INT(rb_n);
+    return GI_BASE_INFO2RVAL_WITH_UNREF(g_interface_info_get_property(info, n));
+}
+
+static VALUE
+rg_n_methods(VALUE self)
+{
+    GIInterfaceInfo *info;
+
+    info = SELF(self);
+    return INT2NUM(g_interface_info_get_n_methods(info));
+}
+
+static VALUE
+rg_get_method(VALUE self, VALUE rb_n_or_name)
+{
+    GIInterfaceInfo *info;
+    GIFunctionInfo *function_info;
+
+    info = SELF(self);
+    if (RB_TYPE_P(rb_n_or_name, T_FIXNUM)) {
+        gint n;
+        n = NUM2INT(rb_n_or_name);
+        function_info = g_interface_info_get_method(info, n);
+    } else {
+        const char *name;
+        name = RVAL2CSTR(rb_n_or_name);
+        function_info = g_interface_info_find_method(info, name);
+    }
+
+    return GI_BASE_INFO2RVAL_WITH_UNREF(function_info);
+}
+
+static VALUE
+rg_n_signals(VALUE self)
+{
+    GIInterfaceInfo *info;
+
+    info = SELF(self);
+    return INT2NUM(g_interface_info_get_n_signals(info));
+}
+
+static VALUE
+rg_get_signal(VALUE self, VALUE rb_n_or_name)
+{
+    GIInterfaceInfo *info;
+    GISignalInfo *signal_info;
+
+    info = SELF(self);
+    if (RB_TYPE_P(rb_n_or_name, T_FIXNUM)) {
+        gint n;
+        n = NUM2INT(rb_n_or_name);
+        signal_info = g_interface_info_get_signal(info, n);
+    } else {
+#ifdef HAVE_G_INTERFACE_INFO_FIND_SIGNAL
+        const char *name;
+        name = RVAL2CSTR(rb_n_or_name);
+        signal_info = g_interface_info_find_signal(info, name);
+#else
+        rb_raise(rb_eArgError,
+                 "g_interface_info_find_signal() is defined "
+                 "since GObjectIntrospection 1.34");
+#endif
+    }
+
+    return GI_BASE_INFO2RVAL_WITH_UNREF(signal_info);
+}
+
+static VALUE
+rg_n_vfuncs(VALUE self)
+{
+    GIInterfaceInfo *info;
+
+    info = SELF(self);
+    return INT2NUM(g_interface_info_get_n_vfuncs(info));
+}
+
+static VALUE
+rg_get_vfunc(VALUE self, VALUE rb_n_or_name)
+{
+    GIInterfaceInfo *info;
+    GIVFuncInfo *vfunc_info;
+
+    info = SELF(self);
+    if (RB_TYPE_P(rb_n_or_name, T_FIXNUM)) {
+        gint n;
+        n = NUM2INT(rb_n_or_name);
+        vfunc_info = g_interface_info_get_vfunc(info, n);
+    } else {
+        const gchar *name;
+        name = RVAL2CSTR(rb_n_or_name);
+        vfunc_info = g_interface_info_find_vfunc(info, name);
+    }
+
+    return GI_BASE_INFO2RVAL_WITH_UNREF(vfunc_info);
+}
+
+static VALUE
+rg_n_constants(VALUE self)
+{
+    GIInterfaceInfo *info;
+
+    info = SELF(self);
+    return INT2NUM(g_interface_info_get_n_constants(info));
+}
+
+static VALUE
+rg_get_constant(VALUE self, VALUE rb_n)
+{
+    GIInterfaceInfo *info;
+    gint n;
+
+    info = SELF(self);
+    n = NUM2INT(rb_n);
+    return GI_BASE_INFO2RVAL_WITH_UNREF(g_interface_info_get_constant(info, n));
+}
+
+static VALUE
+rg_iface_struct(VALUE self)
+{
+    GIInterfaceInfo *info;
+
+    info = SELF(self);
+    return GI_BASE_INFO2RVAL_WITH_UNREF(g_interface_info_get_iface_struct(info));
+}
+
+void
+rb_gi_interface_info_init(VALUE rb_mGI, VALUE rb_cGIRegisteredTypeInfo)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE =
+	G_DEF_CLASS_WITH_PARENT(GI_TYPE_INTERFACE_INFO, "InterfaceInfo", rb_mGI,
+				rb_cGIRegisteredTypeInfo);
+
+    RG_DEF_METHOD(n_prerequisites, 0);
+    RG_DEF_METHOD(get_prerequisite, 1);
+    RG_DEF_METHOD(n_properties, 0);
+    RG_DEF_METHOD(get_property, 1);
+    RG_DEF_METHOD(n_methods, 0);
+    RG_DEF_METHOD(get_method, 1);
+    RG_DEF_METHOD(n_signals, 0);
+    RG_DEF_METHOD(get_signal, 1);
+    RG_DEF_METHOD(n_vfuncs, 0);
+    RG_DEF_METHOD(get_vfunc, 1);
+    RG_DEF_METHOD(n_constants, 0);
+    RG_DEF_METHOD(get_constant, 1);
+    RG_DEF_METHOD(iface_struct, 0);
+}

data/ext/gobject-introspection/rb-gi-loader.c

@@ -0,0 +1,224 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2012-2014  Ruby-GNOME2 Project Team
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rb-gi-private.h"
+
+#define RG_TARGET_NAMESPACE rb_cGILoader
+
+static const gchar *boxed_class_converters_name = "@@boxed_class_converters";
+
+static VALUE
+rg_s_define_class(int argc, VALUE *argv, G_GNUC_UNUSED VALUE klass)
+{
+    VALUE rb_class;
+    VALUE rb_gtype, rb_name, rb_module;
+    VALUE rb_options, rb_parent, rb_size;
+    GType gtype;
+
+    rb_scan_args(argc, argv, "31", &rb_gtype, &rb_name, &rb_module, &rb_options);
+    rbg_scan_options(rb_options,
+                     "parent", &rb_parent,
+                     "size", &rb_size,
+                     NULL);
+
+    gtype = NUM2ULONG(rb_to_int(rb_gtype));
+    rb_class = G_DEF_CLASS_WITH_PARENT(gtype, RVAL2CSTR(rb_name),
+                                       rb_module, rb_parent);
+    if (!NIL_P(rb_size)) {
+        rb_iv_set(rb_class, "@size", rb_size);
+    }
+    return rb_class;
+}
+
+static VALUE
+rg_s_define_interface(G_GNUC_UNUSED VALUE klass,
+                      VALUE rb_gtype, VALUE rb_name, VALUE rb_module)
+{
+    GType gtype;
+
+    gtype = NUM2ULONG(rb_to_int(rb_gtype));
+    return G_DEF_INTERFACE(gtype, RVAL2CSTR(rb_name), rb_module);
+}
+
+static VALUE
+struct_alloc(VALUE klass)
+{
+    VALUE rb_size;
+    size_t size;
+    gpointer instance;
+
+    rb_size = rb_iv_get(klass, "@size");
+    size = NUM2ULONG(rb_size);
+    instance = xmalloc(size);
+    memset(instance, 0, size);
+    return Data_Wrap_Struct(klass, NULL, xfree, instance);
+}
+
+static VALUE
+rg_s_define_struct(int argc, VALUE *argv, G_GNUC_UNUSED VALUE klass)
+{
+    VALUE rb_size, rb_name, rb_module;
+    VALUE rb_options, rb_parent;
+    VALUE rb_class;
+
+    rb_scan_args(argc, argv, "31", &rb_size, &rb_name, &rb_module, &rb_options);
+    rbg_scan_options(rb_options,
+                     "parent", &rb_parent,
+                     NULL);
+
+    rb_size = rb_to_int(rb_size);
+    if (NIL_P(rb_parent)) {
+        rb_parent = rb_cObject;
+    }
+    rb_class = rb_define_class_under(rb_module, RVAL2CSTR(rb_name), rb_parent);
+    rb_iv_set(rb_class, "@size", rb_size);
+    rb_define_alloc_func(rb_class, struct_alloc);
+    return rb_class;
+}
+
+static VALUE
+rg_s_define_error(int argc, VALUE *argv, G_GNUC_UNUSED VALUE klass)
+{
+    VALUE rb_domain, rb_name, rb_module;
+    VALUE rb_options, rb_parent, rb_gtype;
+    GQuark domain;
+    const gchar *name;
+    GType gtype = G_TYPE_INVALID;
+
+    rb_scan_args(argc, argv, "31",
+                 &rb_domain, &rb_name, &rb_module, &rb_options);
+    rbg_scan_options(rb_options,
+                     "parent", &rb_parent,
+                     "gtype", &rb_gtype,
+                     NULL);
+
+    if (RB_TYPE_P(rb_domain, RUBY_T_STRING)) {
+        domain = g_quark_from_string(RVAL2CSTR(rb_domain));
+        if (domain == 0) {
+            rb_raise(rb_eArgError,
+                     "invalid domain name: <%s>",
+                     rbg_inspect(rb_domain));
+        }
+    } else {
+        domain = NUM2UINT(rb_domain);
+    }
+
+    name = RVAL2CSTR(rb_name);
+
+    if (NIL_P(rb_parent)) {
+        rb_parent = rb_eStandardError;
+    }
+
+    if (!NIL_P(rb_gtype)) {
+        gtype = NUM2ULONG(rb_funcall(rb_gtype, rb_intern("to_i"), 0));
+    }
+
+    return G_DEF_ERROR(domain, name, rb_module, rb_parent, gtype);
+}
+
+typedef struct {
+    GType type;
+    VALUE rb_converters;
+    VALUE rb_converter;
+} BoxedInstance2RObjData;
+
+static void
+boxed_class_converter_free(gpointer user_data)
+{
+    BoxedInstance2RObjData *data = user_data;
+    rb_ary_delete(data->rb_converters, data->rb_converter);
+    g_free(data);
+}
+
+static VALUE
+boxed_instance2robj(gpointer instance, gpointer user_data)
+{
+    BoxedInstance2RObjData *data = user_data;
+    VALUE default_rb_instance;
+    VALUE klass;
+    gint flags = 0;
+    ID id_call;
+
+    default_rb_instance = rbgobj_make_boxed_default(instance, data->type);
+    CONST_ID(id_call, "call");
+    klass = rb_funcall(data->rb_converter, id_call, 1, default_rb_instance);
+    return rbgobj_make_boxed_raw(instance, data->type, klass, flags);
+}
+
+static VALUE
+rg_s_register_boxed_class_converter(VALUE klass, VALUE rb_gtype)
+{
+    RGConvertTable table;
+    BoxedInstance2RObjData *data;
+    ID id_to_i;
+    VALUE boxed_class_converters;
+
+    memset(&table, 0, sizeof(RGConvertTable));
+    CONST_ID(id_to_i, "to_i");
+    table.type = NUM2ULONG(rb_funcall(rb_gtype, id_to_i, 0));
+    table.klass = Qnil;
+    table.instance2robj = boxed_instance2robj;
+
+    data = g_new(BoxedInstance2RObjData, 1);
+    data->type = table.type;
+    data->rb_converter = rb_block_proc();
+    boxed_class_converters = rb_cv_get(klass, boxed_class_converters_name);
+    rb_ary_push(boxed_class_converters, data->rb_converter);
+    table.user_data = data;
+    table.notify = boxed_class_converter_free;
+
+    rbgobj_convert_define(&table);
+
+    return Qnil;
+}
+
+static VALUE
+rg_s_register_constant_rename_map(G_GNUC_UNUSED VALUE klass,
+                                  VALUE rb_original,
+                                  VALUE rb_renamed)
+{
+    G_RENAME_CONSTANT(RVAL2CSTR(rb_original), RVAL2CSTR(rb_renamed));
+    return Qnil;
+}
+
+static VALUE
+rg_s_start_callback_dispatch_thread(G_GNUC_UNUSED VALUE klass)
+{
+    rbgutil_start_callback_dispatch_thread();
+    return Qnil;
+}
+
+void
+rb_gi_loader_init(VALUE rb_mGI)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE = rb_define_class_under(rb_mGI, "Loader", rb_cObject);
+
+    rb_cv_set(RG_TARGET_NAMESPACE, boxed_class_converters_name, rb_ary_new());
+
+    RG_DEF_SMETHOD(define_class, -1);
+    RG_DEF_SMETHOD(define_interface, 3);
+    RG_DEF_SMETHOD(define_struct, -1);
+    RG_DEF_SMETHOD(define_error, -1);
+    RG_DEF_SMETHOD(register_boxed_class_converter, 1);
+    RG_DEF_SMETHOD(register_constant_rename_map, 2);
+    RG_DEF_SMETHOD(start_callback_dispatch_thread, 0);
+}

data/ext/gobject-introspection/rb-gi-method-info.c

@@ -0,0 +1,83 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2012-2013  Ruby-GNOME2 Project Team
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rb-gi-private.h"
+
+#define RG_TARGET_NAMESPACE rb_cGIMethodInfo
+#define SELF(self) RVAL2GI_FUNCTION_INFO(self)
+
+GType
+gi_method_info_get_type(void)
+{
+    static GType type = 0;
+    if (type == 0) {
+	type = g_boxed_type_register_static("GIMethodInfo",
+                                            (GBoxedCopyFunc)g_base_info_ref,
+                                            (GBoxedFreeFunc)g_base_info_unref);
+    }
+    return type;
+}
+
+static VALUE
+rg_invoke(VALUE self, VALUE rb_options)
+{
+    GIFunctionInfo *info;
+    GICallableInfo *callable_info;
+    GIArgument return_value;
+    VALUE rb_out_args;
+    VALUE rb_return_value;
+
+    info = SELF(self);
+
+    /* TODO: use rb_protect */
+    rb_out_args = rb_gi_function_info_invoke_raw(info,
+                                                 rb_options,
+                                                 &return_value);
+
+    callable_info = (GICallableInfo *)info;
+    rb_return_value = GI_RETURN_ARGUMENT2RVAL(&return_value, callable_info);
+
+    if (NIL_P(rb_out_args)) {
+        return rb_return_value;
+    } else {
+        GITypeInfo return_value_info;
+        g_callable_info_load_return_type(callable_info, &return_value_info);
+        if (g_type_info_get_tag(&return_value_info) != GI_TYPE_TAG_VOID) {
+            rb_ary_unshift(rb_out_args, rb_return_value);
+        }
+        if (RARRAY_LEN(rb_out_args) == 1) {
+            return RARRAY_PTR(rb_out_args)[0];
+        } else {
+            return rb_out_args;
+        }
+    }
+}
+
+void
+rb_gi_method_info_init(VALUE rb_mGI, VALUE rb_cGIFunctionInfo)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE =
+	G_DEF_CLASS_WITH_PARENT(GI_TYPE_METHOD_INFO, "MethodInfo", rb_mGI,
+				rb_cGIFunctionInfo);
+
+    RG_DEF_METHOD(invoke, 1);
+}