gobject-introspection 2.1.0-x86-mingw32 → 2.2.0-x86-mingw32

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2013  Ruby-GNOME2 Project Team
+ *  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
@@ -33,14 +33,30 @@
 
 #define GI_ARGUMENT2RVAL(argument, type_info)           \
     (rb_gi_argument_to_ruby((argument), (type_info)))
+#define GI_ARRAY_ARGUMENT2RVAL(array_argument, length_argument,         \
+                               array_type_info, length_type_info)       \
+    (rb_gi_array_argument_to_ruby((array_argument),                     \
+                                  (length_argument),                    \
+                                  (array_type_info),                    \
+                                  (length_type_info)))
 #define GI_OUT_ARGUMENT2RVAL(argument, arg_info)                \
     (rb_gi_out_argument_to_ruby((argument), (arg_info)))
+#define GI_OUT_ARRAY_ARGUMENT2RVAL(array_argument, length_argument,     \
+                                   array_arg_info, length_arg_info)     \
+    (rb_gi_out_array_argument_to_ruby((array_argument), (length_argument), \
+                                      (array_arg_info), (length_arg_info)))
 #define GI_RETURN_ARGUMENT2RVAL(argument, callable_info)                \
     (rb_gi_return_argument_to_ruby((argument), (callable_info)))
 #define RVAL2GI_VALUE_ARGUMENT(argument, type_info, rb_argument)        \
     (rb_gi_value_argument_from_ruby((argument), (type_info), (rb_argument)))
 #define RVAL2GI_IN_ARGUMENT(argument, arg_info, rb_argument)            \
     (rb_gi_in_argument_from_ruby((argument), (arg_info), (rb_argument)))
+#define RVAL2GI_IN_ARRAY_ARGUMENT(array_argument, length_argument,      \
+                                  array_arg_info, length_arg_info,      \
+                                  rb_argument)                          \
+    (rb_gi_in_array_argument_from_ruby((array_argument), (length_argument), \
+                                       (array_arg_info), (length_arg_info), \
+                                       (rb_argument)))
 
 
 #define RVAL2GI_REGISTERED_TYPE_INFO(rb_object)			\
@@ -91,10 +107,18 @@ GIBaseInfo *rb_gi_base_info_from_ruby         (VALUE rb_info);
 
 VALUE       rb_gi_argument_to_ruby            (GIArgument     *argument,
                                                GITypeInfo     *type_info);
+VALUE       rb_gi_array_argument_to_ruby      (GIArgument     *array_argument,
+                                               GIArgument     *length_argument,
+                                               GITypeInfo     *array_type_info,
+                                               GITypeInfo     *length_type_info);
 void        rb_gi_out_argument_init           (GIArgument     *argument,
                                                GIArgInfo      *arg_info);
 VALUE       rb_gi_out_argument_to_ruby        (GIArgument     *argument,
                                                GIArgInfo      *arg_info);
+VALUE       rb_gi_out_array_argument_to_ruby  (GIArgument     *array_argument,
+                                               GIArgument     *length_argument,
+                                               GIArgInfo      *array_arg_info,
+                                               GIArgInfo      *length_arg_info);
 void        rb_gi_out_argument_fin            (GIArgument     *argument,
                                                GIArgInfo      *arg_info);
 VALUE       rb_gi_return_argument_to_ruby     (GIArgument     *argument,
@@ -105,6 +129,11 @@ GIArgument *rb_gi_value_argument_from_ruby    (GIArgument     *argument,
 GIArgument *rb_gi_in_argument_from_ruby       (GIArgument     *argument,
                                                GIArgInfo      *arg_info,
                                                VALUE           rb_argument);
+GIArgument *rb_gi_in_array_argument_from_ruby (GIArgument     *array_argument,
+                                               GIArgument     *length_argument,
+                                               GIArgInfo      *array_arg_info,
+                                               GIArgInfo      *length_arg_info,
+                                               VALUE           rb_argument);
 void        rb_gi_value_argument_free         (GIArgument     *argument,
                                                GITypeInfo     *type_info);
 void        rb_gi_in_argument_free            (GIArgument     *argument,

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012  Ruby-GNOME2 Project Team
+ *  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
@@ -124,6 +124,15 @@ rg_storage_type(VALUE self)
     return GI_TYPE_TAG2RVAL(g_enum_info_get_storage_type(info));
 }
 
+static VALUE
+rg_error_domain(VALUE self)
+{
+    GIEnumInfo *info;
+
+    info = SELF(self);
+    return CSTR2RVAL(g_enum_info_get_error_domain(info));
+}
+
 void
 rb_gi_enum_info_init(VALUE rb_mGI, VALUE rb_cGIRegisteredTypeInfo)
 {
@@ -140,6 +149,7 @@ rb_gi_enum_info_init(VALUE rb_mGI, VALUE rb_cGIRegisteredTypeInfo)
     RG_DEF_METHOD(get_method, 1);
     RG_DEF_METHOD(methods, 0);
     RG_DEF_METHOD(storage_type, 0);
+    RG_DEF_METHOD(error_domain, 0);
 
     rb_gi_flags_info_init(rb_mGI, RG_TARGET_NAMESPACE);
 }

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2013  Ruby-GNOME2 Project Team
+ *  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
@@ -44,7 +44,7 @@ gi_function_info_get_type(void)
 {
     static GType type = 0;
     if (type == 0) {
-	type = g_boxed_type_register_static("GIFunctionInfo",
+        type = g_boxed_type_register_static("GIFunctionInfo",
                                             (GBoxedCopyFunc)g_base_info_ref,
                                             (GBoxedFreeFunc)g_base_info_unref);
     }
@@ -112,13 +112,16 @@ allocate_arguments(GICallableInfo *info,
         metadata->callback_p = (metadata->scope_type != GI_SCOPE_TYPE_INVALID);
         metadata->closure_p = FALSE;
         metadata->destroy_p = FALSE;
-        metadata->inout_argv_p = FALSE;
+        metadata->array_p = FALSE;
+        metadata->array_length_p = FALSE;
         metadata->in_arg_index = -1;
         metadata->closure_in_arg_index = -1;
         metadata->destroy_in_arg_index = -1;
+        metadata->array_in_arg_index = -1;
+        metadata->array_length_in_arg_index = -1;
+        metadata->array_length_arg_index = -1;
         metadata->rb_arg_index = -1;
         metadata->out_arg_index = -1;
-        metadata->inout_argc_arg_index = -1;
 
         direction = metadata->direction;
         if (direction == GI_DIRECTION_IN || direction == GI_DIRECTION_INOUT) {
@@ -135,32 +138,6 @@ allocate_arguments(GICallableInfo *info,
     }
 }
 
-static void
-fill_metadata_inout_argv(GPtrArray *args_metadata)
-{
-    guint i;
-    gint inout_argc_arg_index = -1;
-
-    for (i = 0; i < args_metadata->len; i++) {
-        RBGIArgMetadata *metadata;
-        GIArgInfo *arg_info;
-        const gchar *name;
-
-        metadata = g_ptr_array_index(args_metadata, i);
-        if (metadata->direction != GI_DIRECTION_INOUT) {
-            continue;
-        }
-        arg_info = &(metadata->arg_info);
-        name = g_base_info_get_name(arg_info);
-        if (strcmp(name, "argc") == 0) {
-            inout_argc_arg_index = i;
-        } else if (strcmp(name, "argv") == 0) {
-            metadata->inout_argv_p = TRUE;
-            metadata->inout_argc_arg_index = inout_argc_arg_index;
-        }
-    }
-}
-
 static void
 fill_metadata_callback(GPtrArray *args_metadata)
 {
@@ -198,11 +175,49 @@ fill_metadata_callback(GPtrArray *args_metadata)
     }
 }
 
+static void
+fill_metadata_array(GPtrArray *args_metadata)
+{
+    guint i;
+
+    for (i = 0; i < args_metadata->len; i++) {
+        RBGIArgMetadata *metadata;
+        RBGIArgMetadata *array_length_metadata;
+        GIArgInfo *arg_info;
+        GITypeInfo type_info;
+        gint array_length_index = -1;
+
+        metadata = g_ptr_array_index(args_metadata, i);
+        arg_info = &(metadata->arg_info);
+
+        g_arg_info_load_type(arg_info, &type_info);
+        if (g_type_info_get_tag(&type_info) != GI_TYPE_TAG_ARRAY) {
+            continue;
+        }
+        metadata->array_p = TRUE;
+
+        array_length_index = g_type_info_get_array_length(&type_info);
+        if (array_length_index == -1) {
+            continue;
+        }
+
+        array_length_metadata = g_ptr_array_index(args_metadata,
+                                                  array_length_index);
+        array_length_metadata->array_length_p = TRUE;
+        array_length_metadata->rb_arg_index = -1;
+        array_length_metadata->array_in_arg_index =
+            metadata->in_arg_index;
+        metadata->array_length_in_arg_index =
+            array_length_metadata->in_arg_index;
+        metadata->array_length_arg_index = array_length_index;
+    }
+}
+
 static void
 fill_metadata(GPtrArray *args_metadata)
 {
-    fill_metadata_inout_argv(args_metadata);
     fill_metadata_callback(args_metadata);
+    fill_metadata_array(args_metadata);
 }
 
 static void
@@ -385,7 +400,7 @@ in_callback_argument_from_ruby(RBGIArgMetadata *metadata, GArray *in_args)
 
 static void
 in_argument_from_ruby(RBGIArgMetadata *metadata, VALUE rb_arguments,
-                      GArray *in_args)
+                      GArray *in_args, GPtrArray *args_metadata)
 {
     if (metadata->rb_arg_index == -1) {
         return;
@@ -393,6 +408,34 @@ in_argument_from_ruby(RBGIArgMetadata *metadata, VALUE rb_arguments,
 
     if (metadata->callback_p) {
         in_callback_argument_from_ruby(metadata, in_args);
+    } else if (metadata->array_p) {
+        GIArgument *array_argument;
+        GIArgument *length_argument = NULL;
+        GIArgInfo *length_arg_info = NULL;
+        VALUE rb_argument = Qnil;
+
+        if (RARRAY_LEN(rb_arguments) > metadata->rb_arg_index) {
+            rb_argument = RARRAY_PTR(rb_arguments)[metadata->rb_arg_index];
+        }
+        array_argument = &(g_array_index(in_args,
+                                         GIArgument,
+                                         metadata->in_arg_index));
+        if (metadata->array_length_in_arg_index != -1) {
+            RBGIArgMetadata *length_metadata;
+            length_argument =
+                &(g_array_index(in_args,
+                                GIArgument,
+                                metadata->array_length_in_arg_index));
+            length_metadata =
+                g_ptr_array_index(args_metadata,
+                                  metadata->array_length_arg_index);
+            length_arg_info = &(length_metadata->arg_info);
+        }
+        RVAL2GI_IN_ARRAY_ARGUMENT(array_argument,
+                                  length_argument,
+                                  &(metadata->arg_info),
+                                  length_arg_info,
+                                  rb_argument);
     } else {
         GIArgument *argument;
         VALUE rb_argument = Qnil;
@@ -443,35 +486,14 @@ arguments_from_ruby(GICallableInfo *info, VALUE rb_arguments,
 
         metadata = g_ptr_array_index(args_metadata, i);
         if (metadata->in_arg_index != -1) {
-            in_argument_from_ruby(metadata, rb_arguments, in_args);
+            in_argument_from_ruby(metadata, rb_arguments,
+                                  in_args, args_metadata);
         } else {
             out_argument_from_ruby(metadata, out_args);
         }
     }
 }
 
-static VALUE
-inout_argv_argument_to_ruby(GArray *in_args, RBGIArgMetadata *metadata)
-{
-    GIArgument *inout_argc_argument;
-    GIArgument *inout_argv_argument;
-    gint i, argc;
-    gchar **argv;
-    VALUE rb_argv_argument;
-
-    inout_argc_argument = &g_array_index(in_args, GIArgument,
-                                         metadata->inout_argc_arg_index);
-    inout_argv_argument = &g_array_index(in_args, GIArgument,
-                                         metadata->in_arg_index);
-    argc = *((gint *)(inout_argc_argument->v_pointer));
-    argv = *((gchar ***)(inout_argv_argument->v_pointer));
-    rb_argv_argument = rb_ary_new2(argc);
-    for (i = 0; i < argc; i++) {
-        rb_ary_push(rb_argv_argument, CSTR2RVAL(argv[i]));
-    }
-    return rb_argv_argument;
-}
-
 static VALUE
 out_arguments_to_ruby(GICallableInfo *callable_info,
                       GArray *in_args, GArray *out_args,
@@ -488,6 +510,10 @@ out_arguments_to_ruby(GICallableInfo *callable_info,
         VALUE rb_argument;
 
         metadata = g_ptr_array_index(args_metadata, i);
+        if (metadata->array_length_p) {
+            continue;
+        }
+
         switch (metadata->direction) {
           case GI_DIRECTION_IN:
             break;
@@ -508,8 +534,30 @@ out_arguments_to_ruby(GICallableInfo *callable_info,
             continue;
         }
 
-        if (metadata->inout_argv_p) {
-            rb_argument = inout_argv_argument_to_ruby(in_args, metadata);
+        if (metadata->array_p) {
+            GIArgument *length_argument = NULL;
+            GIArgInfo *length_arg_info = NULL;
+
+            if (metadata->array_length_in_arg_index != -1) {
+                RBGIArgMetadata *length_metadata;
+                length_metadata =
+                    g_ptr_array_index(args_metadata,
+                                      metadata->array_length_arg_index);
+                if (length_metadata->direction == GI_DIRECTION_OUT) {
+                    length_argument =
+                        &g_array_index(in_args, GIArgument,
+                                       length_metadata->out_arg_index);
+                } else {
+                    length_argument =
+                        &g_array_index(in_args, GIArgument,
+                                       length_metadata->in_arg_index);
+                }
+                length_arg_info = &(length_metadata->arg_info);
+            }
+            rb_argument = GI_OUT_ARRAY_ARGUMENT2RVAL(argument,
+                                                     length_argument,
+                                                     &(metadata->arg_info),
+                                                     length_arg_info);
         } else {
             rb_argument = GI_OUT_ARGUMENT2RVAL(argument, &(metadata->arg_info));
         }
@@ -576,9 +624,9 @@ rb_gi_function_info_invoke_raw_call(InvokeData *data)
 {
     data->succeeded =
         g_function_info_invoke(data->info,
-                               (GIArgument *)(data->in_args->data),
+                               (GIArgument *)((void *)(data->in_args->data)),
                                data->in_args->len,
-                               (GIArgument *)(data->out_args->data),
+                               (GIArgument *)((void *)(data->out_args->data)),
                                data->out_args->len,
                                data->return_value,
                                data->error);
@@ -695,7 +743,7 @@ rb_gi_function_info_invoke_raw(GIFunctionInfo *info, VALUE rb_options,
     if (!NIL_P(rb_out_args) && RARRAY_LEN(rb_out_args) == 1) {
         VALUE rb_out_arg;
         rb_out_arg = RARRAY_PTR(rb_out_args)[0];
-        if (rb_obj_is_kind_of(rb_out_arg, rb_cGLibError)) {
+        if (rb_obj_is_kind_of(rb_out_arg, rb_eException)) {
             rb_exc_raise(rb_out_arg);
         }
     }

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2013  Ruby-GNOME2 Project Team
+ *  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
@@ -87,6 +87,46 @@ rg_s_define_struct(int argc, VALUE *argv, G_GNUC_UNUSED VALUE klass)
     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;
@@ -162,6 +202,7 @@ rb_gi_loader_init(VALUE rb_mGI)
     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(start_callback_dispatch_thread, 0);
 }

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

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2013  Ruby-GNOME2 Project Team
+ *  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
@@ -36,13 +36,16 @@ typedef struct
     gboolean callback_p;
     gboolean closure_p;
     gboolean destroy_p;
-    gboolean inout_argv_p;
+    gboolean array_p;
+    gboolean array_length_p;
     gint in_arg_index;
     gint closure_in_arg_index;
     gint destroy_in_arg_index;
+    gint array_in_arg_index;
+    gint array_length_in_arg_index;
+    gint array_length_arg_index;
     gint rb_arg_index;
     gint out_arg_index;
-    gint inout_argc_arg_index;
 } RBGIArgMetadata;
 
 typedef struct {