gobject-introspection 1.1.9

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

@@ -0,0 +1,82 @@
+/* -*- 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_cGIConstructorInfo
+#define SELF(self) RVAL2GI_FUNCTION_INFO(self)
+
+GType
+gi_constructor_info_get_type(void)
+{
+    static GType type = 0;
+    if (type == 0) {
+	type = g_boxed_type_register_static("GIConstructorInfo",
+                                            (GBoxedCopyFunc)g_base_info_ref,
+                                            (GBoxedFreeFunc)g_base_info_unref);
+    }
+    return type;
+}
+
+static VALUE
+rg_invoke(int argc, VALUE *argv, VALUE self)
+{
+    GIFunctionInfo *info;
+    GICallableInfo *callable_info;
+    VALUE receiver;
+    GIArgument return_value;
+    GITypeInfo return_value_info;
+    GIBaseInfo *interface_info;
+    GIInfoType interface_type;
+
+    info = SELF(self);
+    callable_info = (GICallableInfo *)info;
+
+    /* TODO: check argc. */
+    receiver = argv[0];
+    rb_gi_function_info_invoke_raw(info, argc - 1, argv + 1, &return_value);
+    g_callable_info_load_return_type(callable_info, &return_value_info);
+
+    if (g_type_info_get_tag(&return_value_info) != GI_TYPE_TAG_INTERFACE) {
+        rb_raise(rb_eRuntimeError, "TODO: returned value isn't interface");
+    }
+    interface_info = g_type_info_get_interface(&return_value_info);
+    interface_type = g_base_info_get_type(interface_info);
+    if (interface_type != GI_INFO_TYPE_OBJECT) {
+        rb_raise(rb_eRuntimeError, "TODO: returned value isn't object");
+    }
+    g_object_ref_sink(return_value.v_pointer);
+    G_INITIALIZE(receiver, return_value.v_pointer);
+
+    return receiver;
+}
+
+void
+rb_gi_constructor_info_init(VALUE rb_mGI, VALUE rb_cGIFunctionInfo)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE =
+	G_DEF_CLASS_WITH_PARENT(GI_TYPE_CONSTRUCTOR_INFO,
+                                "ConstructorInfo", rb_mGI,
+				rb_cGIFunctionInfo);
+
+    RG_DEF_METHOD(invoke, -1);
+}

data/ext/gobject-introspection/rb-gi-conversions.h

@@ -0,0 +1,95 @@
+/* -*- 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
+ */
+
+#ifndef RB_GI_CONVERSIONS_H
+#define RB_GI_CONVERSIONS_H
+
+#define RVAL2GI_REPOSITORY(rb_object) (G_IREPOSITORY(RVAL2GOBJ(rb_object)))
+#define RVAL2GI_REPOSITORY_LOAD_FLAGS(rb_flags) \
+    (RVAL2GFLAGS(rb_flags, G_TYPE_I_REPOSITORY_LOAD_FLAGS))
+
+#define GI_BASE_INFO2RVAL(info)				\
+    (rb_gi_base_info_to_ruby((GIBaseInfo *)(info)))
+#define GI_BASE_INFO2RVAL_WITH_UNREF(info)		\
+    (rb_gi_base_info_to_ruby_with_unref((GIBaseInfo *)(info)))
+#define RVAL2GI_BASE_INFO(rb_object) (rb_gi_base_info_from_ruby(rb_object))
+
+#define GI_ARGUMENT2RVAL(argument, type_info)           \
+    (rb_gi_argument_to_ruby((argument), (type_info)))
+#define RVAL2GI_ARGUMENT(argument, type_info, rb_argument) \
+    (rb_gi_argument_from_ruby((argument), (type_info), (rb_argument)))
+
+
+#define RVAL2GI_REGISTERED_TYPE_INFO(rb_object)			\
+    ((GIRegisteredTypeInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_FUNCTION_INFO(rb_object)			\
+    ((GIFunctionInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_STRUCT_INFO(rb_object)			\
+    ((GIStructInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_ENUM_INFO(rb_object)			\
+    ((GIEnumInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_OBJECT_INFO(rb_object)			\
+    ((GIObjectInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_INTERFACE_INFO(rb_object)		\
+    ((GIInterfaceInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_CONSTANT_INFO(rb_object)		\
+    ((GIConstantInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_UNION_INFO(rb_object)			\
+    ((GIUnionInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_VALUE_INFO(rb_object)			\
+    ((GIValueInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_ARG_INFO(rb_object)		\
+    ((GIArgInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_FIELD_INFO(rb_object)                   \
+    ((GIFieldInfo *)RVAL2GI_BASE_INFO(rb_object))
+#define RVAL2GI_TYPE_INFO(rb_object)			\
+    ((GITypeInfo *)RVAL2GI_BASE_INFO(rb_object))
+
+#define GI_INFO_TYPE2RVAL(type)      (GENUM2RVAL(type, G_TYPE_I_INFO_TYPE))
+#define GI_TRANSFER2RVAL(transfer)   (GENUM2RVAL(transfer, G_TYPE_I_TRANSFER))
+#define GI_DIRECTION2RVAL(direction) (GENUM2RVAL(direction, G_TYPE_I_DIRECTION))
+#define GI_SCOPE_TYPE2RVAL(scope)    (GENUM2RVAL(scope, G_TYPE_I_SCOPE_TYPE))
+#define RVAL2GI_TYPE_TAG(rb_tag)     (RVAL2GENUM(rb_tag, G_TYPE_I_TYPE_TAG))
+#define GI_TYPE_TAG2RVAL(tag)        (GENUM2RVAL(tag, G_TYPE_I_TYPE_TAG))
+#define GI_ARRAY_TYPE2RVAL(type)     (rb_gi_array_type_to_ruby(type))
+
+#define GI_FUNCTION_INFO_FLAGS2RVAL(tag) \
+    (GFLAGS2RVAL(tag, G_TYPE_I_FUNCTION_INFO_FLAGS))
+#define GI_SIGNAL_FLAGS2RVAL(tag)          \
+    (GFLAGS2RVAL(tag, G_TYPE_SIGNAL_FLAGS))
+#define GI_VFUNC_INFO_FLAGS2RVAL(tag) \
+    (GFLAGS2RVAL(tag, G_TYPE_IV_FUNC_INFO_FLAGS))
+#define GI_FIELD_INFO_FLAGS2RVAL(tag)                   \
+    (GFLAGS2RVAL(tag, G_TYPE_I_FIELD_INFO_FLAGS))
+
+VALUE       rb_gi_base_info_to_ruby           (GIBaseInfo *info);
+VALUE       rb_gi_base_info_to_ruby_with_unref(GIBaseInfo *info);
+GIBaseInfo *rb_gi_base_info_from_ruby         (VALUE rb_info);
+
+VALUE       rb_gi_argument_to_ruby            (GIArgument *argument,
+                                               GITypeInfo *type_info);
+GIArgument *rb_gi_argument_from_ruby          (GIArgument *argument,
+                                               GITypeInfo *type_info,
+                                               VALUE       rb_argument);
+
+VALUE       rb_gi_array_type_to_ruby          (GIArrayType type);
+
+#endif
+

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

@@ -0,0 +1,145 @@
+/* -*- 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_cGIEnumInfo
+#define SELF(self) (RVAL2GI_ENUM_INFO(self))
+
+GType
+gi_enum_info_get_type(void)
+{
+    static GType type = 0;
+    if (type == 0) {
+	type = g_boxed_type_register_static("GIEnumInfo",
+                                            (GBoxedCopyFunc)g_base_info_ref,
+                                            (GBoxedFreeFunc)g_base_info_unref);
+    }
+    return type;
+}
+
+static VALUE
+rg_n_values(VALUE self)
+{
+    GIEnumInfo *info;
+
+    info = SELF(self);
+    return INT2NUM(g_enum_info_get_n_values(info));
+}
+
+static VALUE
+rg_get_value(VALUE self, VALUE rb_n)
+{
+    GIEnumInfo *info;
+    gint n;
+
+    info = SELF(self);
+    n = NUM2INT(rb_n);
+    return GI_BASE_INFO2RVAL_WITH_UNREF(g_enum_info_get_value(info, n));
+}
+
+static VALUE
+rg_values(VALUE self)
+{
+    GIEnumInfo *info;
+    gint i, n;
+    VALUE rb_values;
+
+    info = SELF(self);
+
+    rb_values = rb_ary_new();
+    n = g_enum_info_get_n_values(info);
+    for (i = 0; i < n; i++) {
+        GIValueInfo *value_info;
+        value_info = g_enum_info_get_value(info, i);
+        rb_ary_push(rb_values, GI_BASE_INFO2RVAL_WITH_UNREF(value_info));
+    }
+
+    return rb_values;
+}
+
+static VALUE
+rg_n_methods(VALUE self)
+{
+    GIEnumInfo *info;
+
+    info = SELF(self);
+    return INT2NUM(g_enum_info_get_n_methods(info));
+}
+
+static VALUE
+rg_get_method(VALUE self, VALUE rb_n)
+{
+    GIEnumInfo *info;
+    gint n;
+
+    info = SELF(self);
+    n = NUM2INT(rb_n);
+    return GI_BASE_INFO2RVAL_WITH_UNREF(g_enum_info_get_method(info, n));
+}
+
+static VALUE
+rg_methods(VALUE self)
+{
+    GIEnumInfo *info;
+    gint i, n;
+    VALUE rb_methods;
+
+    info = SELF(self);
+
+    rb_methods = rb_ary_new();
+    n = g_enum_info_get_n_methods(info);
+    for (i = 0; i < n; i++) {
+        GIFunctionInfo *function_info;
+        function_info = g_enum_info_get_method(info, i);
+        rb_ary_push(rb_methods, GI_BASE_INFO2RVAL_WITH_UNREF(function_info));
+    }
+
+    return rb_methods;
+}
+
+static VALUE
+rg_storage_type(VALUE self)
+{
+    GIEnumInfo *info;
+
+    info = SELF(self);
+    return GI_TYPE_TAG2RVAL(g_enum_info_get_storage_type(info));
+}
+
+void
+rb_gi_enum_info_init(VALUE rb_mGI, VALUE rb_cGIRegisteredTypeInfo)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE =
+	G_DEF_CLASS_WITH_PARENT(GI_TYPE_ENUM_INFO, "EnumInfo", rb_mGI,
+				rb_cGIRegisteredTypeInfo);
+
+    RG_DEF_METHOD(n_values, 0);
+    RG_DEF_METHOD(get_value, 1);
+    RG_DEF_METHOD(values, 0);
+    RG_DEF_METHOD(n_methods, 0);
+    RG_DEF_METHOD(get_method, 1);
+    RG_DEF_METHOD(methods, 0);
+    RG_DEF_METHOD(storage_type, 0);
+
+    rb_gi_flags_info_init(rb_mGI, RG_TARGET_NAMESPACE);
+}

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

@@ -0,0 +1,149 @@
+/* -*- 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_cGIFieldInfo
+#define SELF(self) (RVAL2GI_FIELD_INFO(self))
+
+GType
+gi_field_info_get_type(void)
+{
+    static GType type = 0;
+    if (type == 0) {
+	type = g_boxed_type_register_static("GIFieldInfo",
+                                            (GBoxedCopyFunc)g_base_info_ref,
+                                            (GBoxedFreeFunc)g_base_info_unref);
+    }
+    return type;
+}
+
+static VALUE
+rg_flags(VALUE self)
+{
+    GIFieldInfo *info;
+
+    info = SELF(self);
+    return GI_FIELD_INFO_FLAGS2RVAL(g_field_info_get_flags(info));
+}
+
+static VALUE
+rg_size(VALUE self)
+{
+    GIFieldInfo *info;
+
+    info = SELF(self);
+    return INT2NUM(g_field_info_get_size(info));
+}
+
+static VALUE
+rg_offset(VALUE self)
+{
+    GIFieldInfo *info;
+
+    info = SELF(self);
+    return INT2NUM(g_field_info_get_offset(info));
+}
+
+static VALUE
+rg_type(VALUE self)
+{
+    GIFieldInfo *info;
+
+    info = SELF(self);
+    return GI_BASE_INFO2RVAL_WITH_UNREF(g_field_info_get_type(info));
+}
+
+VALUE
+rb_gi_field_info_get_field_raw(GIFieldInfo *info, gpointer memory)
+{
+    GIArgument argument;
+    GITypeInfo *type_info;
+    VALUE rb_field_value;
+
+    if (!g_field_info_get_field(info, memory, &argument)) {
+        rb_raise(rb_eArgError, "failed to get field value");
+    }
+
+    type_info = g_field_info_get_type(info);
+    rb_field_value = GI_ARGUMENT2RVAL(&argument, type_info);
+    g_base_info_unref(type_info);
+
+    return rb_field_value;
+}
+
+void
+rb_gi_field_info_set_field_raw(GIFieldInfo *info, gpointer memory,
+                               VALUE rb_field_value)
+{
+    GIArgument field_value;
+    GITypeInfo *type_info;
+
+    type_info = g_field_info_get_type(info);
+    RVAL2GI_ARGUMENT(&field_value, type_info, rb_field_value);
+    g_base_info_unref(type_info);
+
+    if (!g_field_info_set_field(info, memory, &field_value)) {
+        rb_raise(rb_eArgError, "failed to set field value");
+    }
+}
+
+static VALUE
+rg_get_field(VALUE self, VALUE rb_memory)
+{
+    GIFieldInfo *info;
+    gpointer memory;
+
+    info = SELF(self);
+    memory = GUINT_TO_POINTER(NUM2ULONG(rb_memory));
+    return rb_gi_field_info_get_field_raw(info, memory);
+}
+
+static VALUE
+rg_set_field(VALUE self, VALUE rb_memory, VALUE rb_field_value)
+{
+    GIFieldInfo *info;
+    gpointer memory;
+
+    info = SELF(self);
+    memory = GUINT_TO_POINTER(NUM2ULONG(rb_memory));
+    rb_gi_field_info_set_field_raw(info, memory, rb_field_value);
+
+    return Qnil;
+}
+
+void
+rb_gi_field_info_init(VALUE rb_mGI, VALUE rb_cGIBaseInfo)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE =
+	G_DEF_CLASS_WITH_PARENT(GI_TYPE_FIELD_INFO, "FieldInfo", rb_mGI,
+				rb_cGIBaseInfo);
+
+    RG_DEF_METHOD(flags, 0);
+    RG_DEF_METHOD(size, 0);
+    RG_DEF_METHOD(offset, 0);
+    RG_DEF_METHOD(type, 0);
+    RG_DEF_METHOD(get_field, 1);
+    RG_DEF_METHOD(set_field, 2);
+
+    G_DEF_CLASS(G_TYPE_I_FIELD_INFO_FLAGS, "FieldInfoFlags", rb_mGI);
+}