gobject-introspection 2.0.0-x86-mingw32

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

@@ -0,0 +1,77 @@
+/* -*- 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_cGIPropertyInfo
+#define SELF(self) RVAL2GI_BASE_INFO(self)
+
+GType
+gi_property_info_get_type(void)
+{
+    static GType type = 0;
+    if (type == 0) {
+	type = g_boxed_type_register_static("GIPropertyInfo",
+                                            (GBoxedCopyFunc)g_base_info_ref,
+                                            (GBoxedFreeFunc)g_base_info_unref);
+    }
+    return type;
+}
+
+static VALUE
+rg_flags(VALUE self)
+{
+    GIPropertyInfo *info;
+
+    info = SELF(self);
+    return INT2NUM(g_property_info_get_flags(info));
+}
+
+static VALUE
+rg_type(VALUE self)
+{
+    GIPropertyInfo *info;
+
+    info = SELF(self);
+    return GI_BASE_INFO2RVAL_WITH_UNREF(g_property_info_get_type(info));
+}
+
+static VALUE
+rg_ownership_transfer(VALUE self)
+{
+    GIPropertyInfo *info;
+
+    info = SELF(self);
+    return GI_TRANSFER2RVAL(g_property_info_get_ownership_transfer(info));
+}
+
+void
+rb_gi_property_info_init(VALUE rb_mGI, VALUE rb_cGICallableInfo)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE =
+	G_DEF_CLASS_WITH_PARENT(GI_TYPE_PROPERTY_INFO, "PropertyInfo", rb_mGI,
+				rb_cGICallableInfo);
+
+    RG_DEF_METHOD(flags, 0);
+    RG_DEF_METHOD(type, 0);
+    RG_DEF_METHOD(ownership_transfer, 0);
+}

data/ext/gobject-introspection/rb-gi-registered-type-info.c

@@ -0,0 +1,86 @@
+/* -*- 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_cGIRegisteredTypeInfo
+#define SELF(self) (RVAL2GI_REGISTERED_TYPE_INFO(self))
+
+GType
+gi_registered_type_info_get_type(void)
+{
+    static GType type = 0;
+    if (type == 0) {
+	type = g_boxed_type_register_static("GIRegisteredTypeInfo",
+                                            (GBoxedCopyFunc)g_base_info_ref,
+                                            (GBoxedFreeFunc)g_base_info_unref);
+    }
+    return type;
+}
+
+static VALUE
+rg_type_name(VALUE self)
+{
+    GIRegisteredTypeInfo *info;
+
+    info = SELF(self);
+    return CSTR2RVAL(g_registered_type_info_get_type_name(info));
+}
+
+static VALUE
+rg_type_init(VALUE self)
+{
+    GIRegisteredTypeInfo *info;
+
+    info = SELF(self);
+    return CSTR2RVAL(g_registered_type_info_get_type_init(info));
+}
+
+static VALUE
+rg_gtype(VALUE self)
+{
+    GIRegisteredTypeInfo *info;
+
+    info = SELF(self);
+    return rbgobj_gtype_new(g_registered_type_info_get_g_type(info));
+}
+
+void
+rb_gi_registered_type_info_init(VALUE rb_mGI, VALUE rb_cGIBaseInfo)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE =
+	G_DEF_CLASS_WITH_PARENT(GI_TYPE_REGISTERED_TYPE_INFO,
+				"RegisteredTypeInfo",
+				rb_mGI,
+				rb_cGIBaseInfo);
+
+    RG_DEF_METHOD(type_name, 0);
+    RG_DEF_METHOD(type_init, 0);
+    RG_DEF_METHOD(gtype, 0);
+
+    rb_gi_struct_info_init(rb_mGI, RG_TARGET_NAMESPACE);
+    rb_gi_boxed_info_init(rb_mGI, RG_TARGET_NAMESPACE);
+    rb_gi_enum_info_init(rb_mGI, RG_TARGET_NAMESPACE);
+    rb_gi_object_info_init(rb_mGI, RG_TARGET_NAMESPACE);
+    rb_gi_interface_info_init(rb_mGI, RG_TARGET_NAMESPACE);
+    rb_gi_union_info_init(rb_mGI, RG_TARGET_NAMESPACE);
+}

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

@@ -0,0 +1,164 @@
+/* -*- 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_cGIRepository
+#define SELF(self) RVAL2GI_REPOSITORY(self)
+
+static VALUE
+rg_s_default(G_GNUC_UNUSED VALUE klass)
+{
+    return GOBJ2RVAL(g_irepository_get_default());
+}
+
+static VALUE
+rg_require(int argc, VALUE *argv, VALUE self)
+{
+    VALUE rb_namespace, rb_version, rb_flags;
+    const gchar *namespace_, *version;
+    GIRepositoryLoadFlags flags = 0;
+    GError *error = NULL;
+
+    rb_scan_args(argc, argv, "12", &rb_namespace, &rb_version, &rb_flags);
+
+    namespace_ = RVAL2CSTR(rb_namespace);
+    version = RVAL2CSTR_ACCEPT_NIL(rb_version);
+    if (!NIL_P(rb_flags)) {
+	flags = RVAL2GI_REPOSITORY_LOAD_FLAGS(rb_flags);
+    }
+
+    g_irepository_require(SELF(self), namespace_, version, flags, &error);
+    if (error) {
+	RG_RAISE_ERROR(error);
+    }
+
+    return Qnil;
+}
+
+static VALUE
+rg_get_dependencies(VALUE self, VALUE rb_namespace)
+{
+    GIRepository *repository;
+    const gchar *namespace_;
+    VALUE rb_dependencies;
+    gchar **dependencies;
+    gint i;
+
+    repository = SELF(self);
+    namespace_ = RVAL2CSTR(rb_namespace);
+    dependencies = g_irepository_get_dependencies(repository, namespace_);
+    rb_dependencies = rb_ary_new();
+    for (i = 0; dependencies[i]; i++) {
+        rb_ary_push(rb_dependencies, CSTR2RVAL(dependencies[i]));
+    }
+    g_strfreev(dependencies);
+
+    return rb_dependencies;
+}
+
+static VALUE
+rg_loaded_namespaces(VALUE self)
+{
+    GIRepository *repository;
+    VALUE rb_namespaces;
+    gchar **namespaces;
+    gint i;
+
+    repository = SELF(self);
+    namespaces = g_irepository_get_loaded_namespaces(repository);
+    rb_namespaces = rb_ary_new();
+    for (i = 0; namespaces[i]; i++) {
+        rb_ary_push(rb_namespaces, CSTR2RVAL(namespaces[i]));
+    }
+    g_strfreev(namespaces);
+
+    return rb_namespaces;
+}
+
+static VALUE
+rg_get_n_infos(VALUE self, VALUE rb_namespace)
+{
+    const gchar *namespace_;
+    gint n_infos;
+
+    namespace_ = RVAL2CSTR(rb_namespace);
+    n_infos = g_irepository_get_n_infos(SELF(self), namespace_);
+
+    return INT2NUM(n_infos);
+}
+
+static VALUE
+rg_get_info(VALUE self, VALUE rb_namespace, VALUE rb_n)
+{
+    GIRepository *repository;
+    const gchar *namespace_;
+    gint n;
+    GIBaseInfo *info;
+
+    repository = SELF(self);
+    namespace_ = RVAL2CSTR(rb_namespace);
+    n = NUM2INT(rb_n);
+    info = g_irepository_get_info(repository, namespace_, n);
+    return GI_BASE_INFO2RVAL_WITH_UNREF(info);
+}
+
+static VALUE
+rg_find(int argc, VALUE *argv, VALUE self)
+{
+    GIBaseInfo *info;
+
+    if (argc == 1) {
+	VALUE rb_gtype;
+	GType gtype;
+	rb_gtype = argv[0];
+	gtype = NUM2UINT(rb_gtype);
+	info = g_irepository_find_by_gtype(SELF(self), gtype);
+    } else {
+	VALUE rb_namespace, rb_name;
+	const gchar *namespace_, *name;
+
+	rb_scan_args(argc, argv, "2", &rb_namespace, &rb_name);
+	namespace_ = RVAL2CSTR(rb_namespace);
+	name = RVAL2CSTR(rb_name);
+	info = g_irepository_find_by_name(SELF(self), namespace_, name);
+    }
+
+    return GI_BASE_INFO2RVAL(info);
+}
+
+void
+rb_gi_repository_init(VALUE rb_mGI)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_IREPOSITORY, "Repository", rb_mGI);
+
+    RG_DEF_SMETHOD(default, 0);
+    RG_DEF_METHOD(require, -1);
+    RG_DEF_METHOD(get_dependencies, 1);
+    RG_DEF_METHOD(loaded_namespaces, 0);
+    RG_DEF_METHOD(get_n_infos, 1);
+    RG_DEF_METHOD(get_info, 2);
+    RG_DEF_METHOD(find, -1);
+
+    G_DEF_CLASS(G_TYPE_I_REPOSITORY_LOAD_FLAGS, "RepositoryLoadFlags", rb_mGI);
+    G_DEF_CLASS(G_TYPE_I_REPOSITORY_ERROR, "RepositoryError", rb_mGI);
+}

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

@@ -0,0 +1,77 @@
+/* -*- 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_cGISignalInfo
+#define SELF(self) RVAL2GI_BASE_INFO(self)
+
+GType
+gi_signal_info_get_type(void)
+{
+    static GType type = 0;
+    if (type == 0) {
+	type = g_boxed_type_register_static("GISignalInfo",
+                                            (GBoxedCopyFunc)g_base_info_ref,
+                                            (GBoxedFreeFunc)g_base_info_unref);
+    }
+    return type;
+}
+
+static VALUE
+rg_flags(VALUE self)
+{
+    GISignalInfo *info;
+
+    info = SELF(self);
+    return GI_SIGNAL_FLAGS2RVAL(g_signal_info_get_flags(info));
+}
+
+static VALUE
+rg_class_closure(VALUE self)
+{
+    GISignalInfo *info;
+
+    info = SELF(self);
+    return GI_BASE_INFO2RVAL_WITH_UNREF(g_signal_info_get_class_closure(info));
+}
+
+static VALUE
+rg_true_stops_emit_p(VALUE self)
+{
+    GISignalInfo *info;
+
+    info = SELF(self);
+    return CBOOL2RVAL(g_signal_info_true_stops_emit(info));
+}
+
+void
+rb_gi_signal_info_init(VALUE rb_mGI, VALUE rb_cGICallableInfo)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE =
+	G_DEF_CLASS_WITH_PARENT(GI_TYPE_SIGNAL_INFO, "SignalInfo", rb_mGI,
+				rb_cGICallableInfo);
+
+    RG_DEF_METHOD(flags, 0);
+    RG_DEF_METHOD(class_closure, 0);
+    RG_DEF_METHOD_P(true_stops_emit, 0);
+}

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

@@ -0,0 +1,190 @@
+/* -*- 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_cGIStructInfo
+#define SELF(self) (RVAL2GI_STRUCT_INFO(self))
+
+GType
+gi_struct_info_get_type(void)
+{
+    static GType type = 0;
+    if (type == 0) {
+	type = g_boxed_type_register_static("GIStructInfo",
+                                            (GBoxedCopyFunc)g_base_info_ref,
+                                            (GBoxedFreeFunc)g_base_info_unref);
+    }
+    return type;
+}
+
+static VALUE
+rg_n_fields(VALUE self)
+{
+    GIStructInfo *info;
+
+    info = SELF(self);
+    return INT2NUM(g_struct_info_get_n_fields(info));
+}
+
+static VALUE
+rg_get_field(VALUE self, VALUE rb_n)
+{
+    GIStructInfo *info;
+    gint n;
+
+    info = SELF(self);
+    n = NUM2INT(rb_n);
+    return GI_BASE_INFO2RVAL_WITH_UNREF(g_struct_info_get_field(info, n));
+}
+
+static VALUE
+rg_get_field_value(VALUE self, VALUE rb_struct, VALUE rb_n)
+{
+    GIStructInfo *info;
+    gint n;
+    GIFieldInfo *field_info;
+    VALUE rb_value;
+    gpointer instance;
+
+    info = SELF(self);
+    n = NUM2INT(rb_n);
+    field_info = g_struct_info_get_field(info, n);
+    if (rb_respond_to(rb_struct, rb_intern("gtype"))) {
+        VALUE rb_gtype;
+        GType gtype;
+        rb_gtype = rb_funcall(rb_struct, rb_intern("gtype"), 0);
+        gtype = NUM2UINT(rb_funcall(rb_gtype, rb_intern("to_i"), 0));
+        instance = RVAL2BOXED(rb_struct, gtype);
+    } else {
+        Data_Get_Struct(rb_struct, void, instance);
+    }
+    rb_value = rb_gi_field_info_get_field_raw(field_info, instance);
+    g_base_info_unref(field_info);
+
+    return rb_value;
+}
+
+static VALUE
+rg_set_field_value(VALUE self, VALUE rb_struct, VALUE rb_n, VALUE rb_value)
+{
+    GIStructInfo *info;
+    gint n;
+    GIFieldInfo *field_info;
+    GType gtype;
+
+    info = SELF(self);
+    n = NUM2INT(rb_n);
+    field_info = g_struct_info_get_field(info, n);
+    gtype = g_registered_type_info_get_g_type(info);
+    rb_gi_field_info_set_field_raw(field_info,
+                                   RVAL2BOXED(rb_struct, gtype),
+                                   rb_value);
+    /* TODO: use rb_ensure() to unref field_info. */
+    g_base_info_unref(field_info);
+
+    return Qnil;
+}
+
+static VALUE
+rg_n_methods(VALUE self)
+{
+    GIStructInfo *info;
+
+    info = SELF(self);
+    return INT2NUM(g_struct_info_get_n_methods(info));
+}
+
+static VALUE
+rg_get_method(VALUE self, VALUE rb_n_or_name)
+{
+    GIStructInfo *info;
+    GIFunctionInfo *function_info;
+
+    info = SELF(self);
+    if (RB_TYPE_P(rb_n_or_name, RUBY_T_FIXNUM)) {
+        gint n;
+        n = NUM2INT(rb_n_or_name);
+        function_info = g_struct_info_get_method(info, n);
+    } else {
+        const gchar *name;
+        name = RVAL2CSTR(rb_n_or_name);
+        function_info = g_struct_info_find_method(info, name);
+    }
+
+    return GI_BASE_INFO2RVAL_WITH_UNREF(function_info);
+}
+
+static VALUE
+rg_size(VALUE self)
+{
+    GIStructInfo *info;
+
+    info = SELF(self);
+    return UINT2NUM(g_struct_info_get_size(info));
+}
+
+static VALUE
+rg_alignment(VALUE self)
+{
+    GIStructInfo *info;
+
+    info = SELF(self);
+    return UINT2NUM(g_struct_info_get_alignment(info));
+}
+
+static VALUE
+rg_gtype_struct_p(VALUE self)
+{
+    GIStructInfo *info;
+
+    info = SELF(self);
+    return CBOOL2RVAL(g_struct_info_is_gtype_struct(info));
+}
+
+static VALUE
+rg_foreign_p(VALUE self)
+{
+    GIStructInfo *info;
+
+    info = SELF(self);
+    return CBOOL2RVAL(g_struct_info_is_foreign(info));
+}
+
+void
+rb_gi_struct_info_init(VALUE rb_mGI, VALUE rb_cGIRegisteredTypeInfo)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE =
+	G_DEF_CLASS_WITH_PARENT(GI_TYPE_STRUCT_INFO, "StructInfo", rb_mGI,
+				rb_cGIRegisteredTypeInfo);
+
+    RG_DEF_METHOD(n_fields, 0);
+    RG_DEF_METHOD(get_field, 1);
+    RG_DEF_METHOD(get_field_value, 2);
+    RG_DEF_METHOD(set_field_value, 3);
+    RG_DEF_METHOD(n_methods, 0);
+    RG_DEF_METHOD(get_method, 1);
+    RG_DEF_METHOD(size, 0);
+    RG_DEF_METHOD(alignment, 0);
+    RG_DEF_METHOD_P(gtype_struct, 0);
+    RG_DEF_METHOD_P(foreign, 0);
+}