gobject-introspection 1.1.9

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

@@ -0,0 +1,48 @@
+/* -*- 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-gobject-introspection.h"
+
+#define RG_TARGET_NAMESPACE rb_cGIFlagsInfo
+
+GType
+gi_flags_info_get_type(void)
+{
+    static GType type = 0;
+    if (type == 0) {
+	type = g_boxed_type_register_static("GIFlagsInfo",
+                                            (GBoxedCopyFunc)g_base_info_ref,
+                                            (GBoxedFreeFunc)g_base_info_unref);
+    }
+    return type;
+}
+
+void
+rb_gi_flags_info_init(VALUE rb_mGI, VALUE rb_cGIEnumInfo)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE =
+	G_DEF_CLASS_WITH_PARENT(GI_TYPE_FLAGS_INFO, "FlagsInfo", rb_mGI,
+				rb_cGIEnumInfo);
+
+    /* Suppress a warning. */
+    (void)RG_TARGET_NAMESPACE;
+}

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

@@ -0,0 +1,199 @@
+/* -*- 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-gobject-introspection.h"
+
+#define RG_TARGET_NAMESPACE rb_cGIFunctionInfo
+#define SELF(self) RVAL2GI_FUNCTION_INFO(self)
+
+GType
+gi_function_info_get_type(void)
+{
+    static GType type = 0;
+    if (type == 0) {
+	type = g_boxed_type_register_static("GIFunctionInfo",
+                                            (GBoxedCopyFunc)g_base_info_ref,
+                                            (GBoxedFreeFunc)g_base_info_unref);
+    }
+    return type;
+}
+
+static VALUE
+rg_symbol(VALUE self)
+{
+    GIFunctionInfo *info;
+
+    info = SELF(self);
+    return CSTR2RVAL(g_function_info_get_symbol(info));
+}
+
+static VALUE
+rg_flags(VALUE self)
+{
+    GIFunctionInfo *info;
+
+    info = SELF(self);
+    return GI_FUNCTION_INFO_FLAGS2RVAL(g_function_info_get_flags(info));
+}
+
+static VALUE
+rg_property(VALUE self)
+{
+    GIFunctionInfo *info;
+
+    info = SELF(self);
+    return GI_BASE_INFO2RVAL(g_function_info_get_property(info));
+}
+
+static VALUE
+rg_vfunc(VALUE self)
+{
+    GIFunctionInfo *info;
+
+    info = SELF(self);
+    return GI_BASE_INFO2RVAL(g_function_info_get_vfunc(info));
+}
+
+static void
+fill_gi_argument_by_ruby(GIArgument *argument, GIArgInfo *arg_info,
+                         VALUE rb_argument)
+{
+    GITypeInfo type_info;
+
+    g_arg_info_load_type(arg_info, &type_info);
+    RVAL2GI_ARGUMENT(argument, &type_info, rb_argument);
+}
+
+static void
+fill_in_argument(GIArgInfo *arg_info, GArray *in_args, int argc, VALUE *argv)
+{
+    VALUE rb_argument;
+    GIArgument argument;
+
+    /* TODO: check argc */
+    rb_argument = argv[in_args->len];
+    fill_gi_argument_by_ruby(&argument, arg_info, rb_argument);
+    g_array_append_val(in_args, argument);
+}
+
+static void
+fill_out_argument(G_GNUC_UNUSED GIArgInfo *arg_info, GArray *out_args)
+{
+    GIArgument argument;
+    g_array_append_val(out_args, argument);
+}
+
+static void
+fill_argument(GIArgInfo *arg_info, GArray *in_args, GArray *out_args,
+              int argc, VALUE *argv)
+{
+    switch (g_arg_info_get_direction(arg_info)) {
+      case GI_DIRECTION_IN:
+        fill_in_argument(arg_info, in_args, argc, argv);
+        break;
+      case GI_DIRECTION_OUT:
+        fill_out_argument(arg_info, out_args);
+        break;
+      case GI_DIRECTION_INOUT:
+        fill_in_argument(arg_info, in_args, argc, argv);
+        fill_out_argument(arg_info, out_args);
+        break;
+      default:
+        g_assert_not_reached();
+        break;
+    }
+}
+
+void
+rb_gi_function_info_invoke_raw(GIFunctionInfo *info, int argc, VALUE *argv,
+                               GIArgument *return_value)
+{
+    GICallableInfo *callable_info;
+    gint i, n_args;
+    GArray *in_args, *out_args;
+    gboolean succeeded;
+    GError *error = NULL;
+
+    callable_info = (GICallableInfo *)info;
+    n_args = g_callable_info_get_n_args(callable_info);
+    in_args = g_array_new(FALSE, FALSE, sizeof(GIArgument));
+    out_args = g_array_new(FALSE, FALSE, sizeof(GIArgument));
+    if (g_function_info_get_flags(callable_info) & GI_FUNCTION_IS_METHOD) {
+        GIArgument argument;
+        /* TODO: check argc */
+        argument.v_pointer = RVAL2GOBJ(argv[0]);
+        g_array_append_val(in_args, argument);
+    }
+    for (i = 0; i < n_args; i++) {
+        GIArgInfo arg_info;
+        g_callable_info_load_arg(callable_info, i, &arg_info);
+        fill_argument(&arg_info, in_args, out_args, argc, argv);
+    }
+    succeeded = g_function_info_invoke(info,
+                                       (GIArgument *)(in_args->data),
+                                       in_args->len,
+                                       (GIArgument *)(out_args->data),
+                                       out_args->len,
+                                       return_value,
+                                       &error);
+    g_array_unref(in_args);
+    g_array_unref(out_args);
+    if (!succeeded) {
+        RG_RAISE_ERROR(error);
+    }
+}
+
+static VALUE
+rg_invoke(int argc, VALUE *argv, VALUE self)
+{
+    GIFunctionInfo *info;
+    GICallableInfo *callable_info;
+    GIArgument return_value;
+    GITypeInfo return_value_info;
+
+    info = SELF(self);
+    callable_info = (GICallableInfo *)info;
+
+    rb_gi_function_info_invoke_raw(info, argc, argv, &return_value);
+    g_callable_info_load_return_type(callable_info, &return_value_info);
+
+    return GI_ARGUMENT2RVAL(&return_value, &return_value_info);
+}
+
+void
+rb_gi_function_info_init(VALUE rb_mGI, VALUE rb_cGICallableInfo)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE =
+	G_DEF_CLASS_WITH_PARENT(GI_TYPE_FUNCTION_INFO, "FunctionInfo", rb_mGI,
+				rb_cGICallableInfo);
+
+    RG_DEF_METHOD(symbol, 0);
+    RG_DEF_METHOD(flags, 0);
+    RG_DEF_METHOD(property, 0);
+    RG_DEF_METHOD(vfunc, 0);
+    RG_DEF_METHOD(invoke, -1);
+
+    G_DEF_CLASS(G_TYPE_I_FUNCTION_INFO_FLAGS, "FunctionInfoFlags", rb_mGI);
+
+    rb_gi_method_info_init(rb_mGI, RG_TARGET_NAMESPACE);
+    rb_gi_constructor_info_init(rb_mGI, RG_TARGET_NAMESPACE);
+}

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-gobject-introspection.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);
+}