glib2 0.90.2-x86-mingw32

data/ext/glib2/rbglib_completion.c

@@ -0,0 +1,192 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbglib_completion.c -
+
+  $Author: sakai $
+  $Date: 2007/07/08 02:40:12 $
+
+  Copyright (C) 2005,2006  Masao Mutoh
+************************************************/
+
+#include "rbgprivate.h"
+
+static ID id_compfunc;
+static ID id_call;
+static ID id_to_s;
+static ID id_clear;
+static ID id_items_internal;
+
+/*****************************************/
+static GCompletion*
+completion_copy(comp)
+    GCompletion* comp;
+{
+  GCompletion* new_comp;
+  g_return_val_if_fail (comp != NULL, NULL);
+
+  new_comp = g_new(GCompletion, 1);
+  *new_comp = *comp;
+  return new_comp;
+}
+
+GType
+g_completion_get_type(void)
+{
+    static GType our_type = 0;
+    if (our_type == 0)
+        our_type = g_boxed_type_register_static ("GCompletion",
+                                                 (GBoxedCopyFunc)completion_copy,
+                                                 (GBoxedFreeFunc)g_completion_free);
+    return our_type;
+}
+/*****************************************/
+
+#define G_TYPE_COMPLETION (g_completion_get_type())
+
+#define _SELF(s) ((GCompletion*)RVAL2BOXED(s, G_TYPE_COMPLETION))
+
+/* data should be [self, data] */
+static gchar*
+comp_func(compdata)
+    gpointer compdata;
+{
+    VALUE ret;
+    VALUE self = RARRAY_PTR((VALUE)compdata)[0];
+    VALUE data = RARRAY_PTR((VALUE)compdata)[1];
+    
+    VALUE func = rb_ivar_get(self, id_compfunc);
+    
+    if (NIL_P(func)){
+        ret = rb_funcall(data, id_to_s, 0);
+    } else {
+        ret = rb_funcall(func, id_call, 1, data);
+    }
+    return RVAL2CSTR(ret);
+}
+
+static VALUE
+comp_initialize(self)
+    VALUE self;
+{
+    VALUE block = Qnil;
+
+    if (rb_block_given_p()) {
+        block = rb_block_proc();
+    }
+
+    rb_ivar_set(self, id_compfunc, block);
+    /* This is used for memory management(GC) */
+    rb_ivar_set(self, id_items_internal, rb_hash_new());
+
+    G_INITIALIZE(self, g_completion_new((GCompletionFunc)comp_func));
+
+    return Qnil;
+}
+
+static VALUE
+comp_add_items(self, items)
+    VALUE self, items;
+{
+    gint i, len;
+    GList* list = (GList*)NULL;
+    VALUE items_internal = rb_ivar_get(self, id_items_internal);
+
+    Check_Type(items, T_ARRAY);
+    len = RARRAY_LEN(items);
+    for (i = 0; i < len; i ++){
+        VALUE data = RARRAY_PTR(items)[i];
+        VALUE item = rb_assoc_new(self, data);
+        list = g_list_append(list, (gpointer)item);
+        rb_hash_aset(items_internal, data, item);
+    }
+    g_completion_add_items(_SELF(self), list);
+
+    return self;
+}
+
+static VALUE
+comp_remove_items(self, items)
+    VALUE self, items;
+{
+    gint i, len;
+    GList* list = (GList*)NULL;
+    VALUE items_internal = rb_ivar_get(self, id_items_internal);
+
+    Check_Type(items, T_ARRAY);
+    len = RARRAY_LEN(items);
+    for (i = 0; i < len; i ++){
+        VALUE data = RARRAY_PTR(items)[i];
+        VALUE item = rb_hash_aref(items_internal, data);
+        list = g_list_append(list, (gpointer)item);
+        rb_hash_delete(items_internal, data);
+    }
+    g_completion_remove_items(_SELF(self), list);
+
+    return self;
+}
+
+static VALUE
+comp_clear_items(self)
+    VALUE self;
+{
+    VALUE items_internal = rb_ivar_get(self, id_items_internal);
+    rb_funcall(items_internal, id_clear, 0);
+    g_completion_clear_items(_SELF(self));
+    return self;
+}
+
+static VALUE
+comp_items(self)
+    VALUE self;
+{
+    return rb_ivar_get(self, id_items_internal);
+}
+
+static VALUE
+comp_complete(self, prefix)
+    VALUE self, prefix;
+{
+    gchar* new_prefix;
+    VALUE ary = rb_ary_new();
+#if GLIB_CHECK_VERSION(2,4,0)
+    GList* list = g_completion_complete_utf8(_SELF(self),
+                                            (const gchar*)RVAL2CSTR(prefix),
+                                            &new_prefix);
+#else
+    GList* list = g_completion_complete(_SELF(self),
+                                        RVAL2CSTR(prefix),
+                                        &new_prefix);
+#endif
+    while (list) {
+        rb_ary_push(ary, RARRAY_PTR((VALUE)list->data)[1]);
+        list = list->next;
+    }
+
+    return rb_assoc_new(ary, new_prefix ? CSTR2RVAL(new_prefix) : Qnil);
+}
+
+/* We don't use this.
+void        g_completion_set_compare        (GCompletion *cmp,
+                                             GCompletionStrncmpFunc strncmp_func);
+*/
+
+void
+Init_glib_completion()
+{
+    VALUE comp = G_DEF_CLASS(G_TYPE_COMPLETION, "Completion", mGLib); 
+
+    id_call = rb_intern("call");
+    id_to_s = rb_intern("to_s");
+    id_clear = rb_intern("clear");
+    id_compfunc = rb_intern("completion_proc");
+    id_items_internal = rb_intern("items_internal");
+
+    rb_define_method(comp, "initialize", comp_initialize, 0);
+    rb_define_method(comp, "add_items", comp_add_items, 1);
+    rb_define_method(comp, "remove_items", comp_remove_items, 1);
+    rb_define_method(comp, "clear_items", comp_clear_items, 0);
+    rb_define_method(comp, "complete", comp_complete, 1);
+
+    rb_define_method(comp, "items", comp_items, 0);
+}

data/ext/glib2/rbglib_convert.c

@@ -0,0 +1,195 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/**********************************************************************
+
+  rbglib_convert.c -
+
+  $Author: sakai $
+  $Date: 2007/06/16 02:46:28 $
+
+  Copyright (C) 2002,2003 KUBO Takehiro
+  Copyright (C) 2009 Ruby-GNOME2 Project Team
+
+**********************************************************************/
+#include "rbgprivate.h"
+#include "rbglib.h"
+
+static VALUE
+rbglib_m_convert(self, str, to, from)
+    VALUE self, str, to, from;
+{
+    GError *err = NULL;
+    gchar* ret;
+    gsize written;
+    VALUE s = Qnil;
+
+    StringValue(str);
+    ret = g_convert(RSTRING_PTR(str), RSTRING_LEN(str),
+                    StringValuePtr(to), StringValuePtr(from),
+                    NULL, &written, &err);
+    
+    if (err != NULL)
+        RAISE_GERROR(err);
+    s = rb_str_new(ret, written);
+    g_free(ret);
+    return s;
+}
+
+static VALUE
+rbglib_m_locale_to_utf8(self, str)
+    VALUE self, str;
+{
+    GError *err = NULL;
+    VALUE s = Qnil;
+    gchar* ret;
+    gsize written;
+
+    StringValue(str);
+    ret = g_locale_to_utf8(RSTRING_PTR(str), RSTRING_LEN(str),
+                           NULL, &written, &err);
+
+    if (err != NULL)
+        RAISE_GERROR(err);
+    s = rb_str_new(ret, written);
+    g_free(ret);
+    return s;
+}
+
+static VALUE
+rbglib_m_locale_from_utf8(self, str)
+    VALUE self, str;
+{
+    GError *err = NULL;
+    VALUE s = Qnil;
+    gchar* ret;
+    gsize written;
+
+    StringValue(str);
+    ret = g_locale_from_utf8(RSTRING_PTR(str), RSTRING_LEN(str),
+                       NULL, &written, &err);
+
+    if (err != NULL)
+        RAISE_GERROR(err);
+    s = rb_str_new(ret, written);
+    g_free(ret);
+    return s;
+}
+
+static VALUE
+rbglib_m_filename_to_utf8(self, str)
+    VALUE self, str;
+{
+    GError *err = NULL;
+    VALUE s = Qnil;
+    gchar* ret;
+    gsize written;
+
+    StringValue(str);
+    ret = g_filename_to_utf8(RSTRING_PTR(str), RSTRING_LEN(str),
+                             NULL, &written, &err);
+
+    if (err != NULL)
+        RAISE_GERROR(err);
+    s = rb_str_new(ret, written);
+    g_free(ret);
+    return s;
+}
+
+static VALUE
+rbglib_m_filename_from_utf8(self, str)
+    VALUE self, str;
+{
+    GError *err = NULL;
+    VALUE s = Qnil;
+    gchar* ret;
+    gsize written;
+
+    StringValue(str);
+    ret = g_filename_from_utf8(RSTRING_PTR(str), RSTRING_LEN(str),
+                               NULL, &written, &err);
+
+    if (err != NULL)
+        RAISE_GERROR(err);
+    s = rb_str_new(ret, written);
+    g_free(ret);
+    return s;
+}
+
+static VALUE
+rbglib_m_filename_to_uri(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE filename, hostname, s;
+    GError *err = NULL;
+    gchar* ret;
+
+    rb_scan_args(argc, argv, "11", &filename, &hostname);
+
+    ret = g_filename_to_uri(StringValuePtr(filename),
+                            NIL_P(hostname) ? NULL : StringValuePtr(hostname),
+                            &err);
+
+    if (err)
+        RAISE_GERROR(err);
+    s = rb_str_new2(ret);
+    g_free(ret);
+    return s;
+}
+
+static VALUE
+rbglib_m_filename_from_uri(self, str)
+    VALUE self, str;
+{
+    GError *err = NULL;
+    VALUE s;
+    gchar* filename;
+    char* hostname;
+
+    filename = g_filename_from_uri(StringValuePtr(str), &hostname, &err);
+
+    if (err)
+        RAISE_GERROR(err);
+    s = rb_ary_new3(2, rb_str_new2(filename),
+                    hostname ? rb_str_new2(hostname) : Qnil);
+    g_free(filename);
+    g_free(hostname);
+    return s;
+}
+
+static VALUE
+rbglib_m_utf8_validate(self, str)
+    VALUE self, str;
+{
+    rb_warning("GLib.utf8_validate is deprecated. Use GLib::UTF8.validate instead.");
+    StringValue(str);
+    return CBOOL2RVAL(g_utf8_validate(RSTRING_PTR(str), RSTRING_LEN(str), NULL));
+}
+
+void
+Init_glib_convert()
+{
+    VALUE cCharError = G_DEF_ERROR2(G_CONVERT_ERROR, "ConvertError", mGLib, rb_eIOError);
+
+    rb_define_const(cCharError, "NO_CONVERSION", INT2NUM(G_CONVERT_ERROR_NO_CONVERSION));
+    rb_define_const(cCharError, "ILLEGAL_SEQUENCE", INT2NUM(G_CONVERT_ERROR_ILLEGAL_SEQUENCE));
+    rb_define_const(cCharError, "FAILED", INT2NUM(G_CONVERT_ERROR_FAILED));
+    rb_define_const(cCharError, "PARTIAL_INPUT", INT2NUM(G_CONVERT_ERROR_PARTIAL_INPUT));
+    rb_define_const(cCharError, "BAD_URI", INT2NUM(G_CONVERT_ERROR_BAD_URI));
+    rb_define_const(cCharError, "NOT_ABSOLUTE_PATH", INT2NUM(G_CONVERT_ERROR_NOT_ABSOLUTE_PATH));
+
+    /* glib/gunicode.h */
+    /* just for backward compatibility.
+       Use GLib::UTF8.validate instead. */
+    rb_define_module_function(mGLib, "utf8_validate", rbglib_m_utf8_validate, 1);
+
+    /* glib/gconvert.h */
+    rb_define_module_function(mGLib, "convert", rbglib_m_convert, 3);
+    rb_define_module_function(mGLib, "locale_to_utf8", rbglib_m_locale_to_utf8, 1);
+    rb_define_module_function(mGLib, "locale_from_utf8", rbglib_m_locale_from_utf8, 1);
+    rb_define_module_function(mGLib, "filename_to_utf8", rbglib_m_filename_to_utf8, 1);
+    rb_define_module_function(mGLib, "filename_from_utf8", rbglib_m_filename_from_utf8, 1);
+
+    rb_define_module_function(mGLib, "filename_to_uri", rbglib_m_filename_to_uri, -1);
+    rb_define_module_function(mGLib, "filename_from_uri", rbglib_m_filename_from_uri, 1);
+}

data/ext/glib2/rbglib_error.c

@@ -0,0 +1,95 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgerror.c -
+
+  $Author: mutoh $
+  $Date: 2004/08/22 13:27:47 $
+
+  Copyright (C) 2004 Masao Mutoh
+************************************************/
+
+#include "rbgprivate.h"
+#include <ctype.h>
+
+static ID id_code;
+static ID id_domain;
+static VALUE gerror_table;
+static VALUE generic_error;
+
+VALUE
+rbgerr_gerror2exception(error)
+    GError *error;
+{
+    VALUE exc = Qnil;
+    VALUE klass = Qnil;
+
+    if (! error){
+        return rb_exc_new2(rb_eRuntimeError, "GError parameter doesn't have a value.");
+    }
+
+    klass = rb_hash_aref(gerror_table, UINT2NUM(error->domain));
+    if NIL_P(klass){
+        exc = rb_exc_new2(generic_error, error->message);
+        rb_ivar_set(exc, id_domain, CSTR2RVAL(g_quark_to_string(error->domain)));
+        rb_ivar_set(exc, id_code, INT2NUM(error->code));
+    } else {
+        exc = rb_exc_new2(klass, error->message);
+        rb_ivar_set(exc, id_domain, CSTR2RVAL(g_quark_to_string(error->domain)));
+        rb_ivar_set(exc, id_code, INT2NUM(error->code));
+    }
+    g_error_free(error);
+    return exc;
+}
+
+VALUE
+rbgerr_define_gerror(domain, name, module, parent, gtype)
+    GQuark domain;
+    const gchar* name;
+    VALUE module;
+    VALUE parent;
+    VALUE gtype;
+{
+    VALUE klass = rb_define_class_under(module, name, parent);
+    rb_funcall(klass, rbgutil_id_module_eval, 1, CSTR2RVAL("def code; @code; end\n"));
+    rb_funcall(klass, rbgutil_id_module_eval, 1, CSTR2RVAL("def domain; @domain; end\n"));
+
+    rb_hash_aset(gerror_table, UINT2NUM(domain), klass);
+
+    if (! NIL_P(gtype)){
+        GEnumClass* gclass = g_type_class_ref(gtype);
+        int i;
+
+        for (i = 0; i < gclass->n_values; i++) {
+            GEnumValue* entry = &(gclass->values[i]);
+            gchar* nick = g_strdup(entry->value_nick);
+            gchar* p;
+            
+            for (p = nick; *p; p++) {
+                if (*p == '-')
+                    *p = '_';
+                else
+                    *p = g_ascii_toupper(*p);
+            }
+            rbgobj_define_const(klass, nick, INT2NUM(i));
+            g_free(nick);
+        }
+        
+        g_type_class_unref(gclass);        
+    }
+
+    return klass;
+}
+
+void
+Init_glib_error()
+{
+    id_code = rb_intern("@code");
+    id_domain = rb_intern("@domain");
+    gerror_table = rb_hash_new();
+    rb_global_variable(&gerror_table);
+
+    generic_error = rb_define_class_under(mGLib, "Error", rb_eRuntimeError);
+    rb_funcall(generic_error, rbgutil_id_module_eval, 1, CSTR2RVAL("def code; @code; end\n"));
+    rb_funcall(generic_error, rbgutil_id_module_eval, 1, CSTR2RVAL("def domain; @domain; end\n"));
+}

data/ext/glib2/rbglib_fileutils.c

@@ -0,0 +1,83 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/**********************************************************************
+
+  rbglib_fileutils.c -
+
+  $Author: mutoh $
+  $Date: 2004/09/17 15:09:07 $
+
+  Copyright (C) 2004 Masao Mutoh
+
+**********************************************************************/
+
+#include "rbgprivate.h"
+#include "rbglib.h"
+
+/* Use Ruby standard libraries.
+enum        GFileTest;
+GFileError  g_file_error_from_errno         (gint err_no);
+gboolean    g_file_get_contents             (const gchar *filename,
+                                             gchar **contents,
+                                             gsize *length,
+                                             GError **error);
+gboolean    g_file_test                     (const gchar *filename,
+                                             GFileTest test);
+gint        g_mkstemp                       (gchar *tmpl);
+gint        g_file_open_tmp                 (const gchar *tmpl,
+                                             gchar **name_used,
+                                             GError **error);
+gchar*      g_file_read_link                (const gchar *filename,
+                                             GError **error);
+
+struct      GDir;
+GDir*       g_dir_open                      (const gchar *path,
+                                             guint flags,
+                                             GError **error);
+G_CONST_RETURN gchar* g_dir_read_name       (GDir *dir);
+void        g_dir_rewind                    (GDir *dir);
+void        g_dir_close                     (GDir *dir);
+*/
+
+#if GLIB_CHECK_VERSION(2, 16, 0)
+static VALUE
+rbglib_m_format_size_for_display(VALUE self, VALUE size)
+{
+    return CSTR2RVAL_FREE(g_format_size_for_display(NUM2INT(size)));
+}
+#endif
+
+void
+Init_glib_fileutils()
+{
+    VALUE cFileError = G_DEF_ERROR2(G_FILE_ERROR, "FileError", mGLib, rb_eIOError);
+
+    rb_define_const(cFileError, "EXIST", INT2NUM(G_FILE_ERROR_EXIST));
+    rb_define_const(cFileError, "ISDIR", INT2NUM(G_FILE_ERROR_ISDIR));
+    rb_define_const(cFileError, "ACCES", INT2NUM(G_FILE_ERROR_ACCES));
+    rb_define_const(cFileError, "NAMETOOLONG", INT2NUM(G_FILE_ERROR_NAMETOOLONG));
+    rb_define_const(cFileError, "NOENT", INT2NUM(G_FILE_ERROR_NOENT));
+    rb_define_const(cFileError, "NOTDIR", INT2NUM(G_FILE_ERROR_NOTDIR));
+    rb_define_const(cFileError, "NXIO", INT2NUM(G_FILE_ERROR_NXIO));
+    rb_define_const(cFileError, "NODEV", INT2NUM(G_FILE_ERROR_NODEV));
+    rb_define_const(cFileError, "ROFS", INT2NUM(G_FILE_ERROR_ROFS));
+    rb_define_const(cFileError, "TXTBSY", INT2NUM(G_FILE_ERROR_TXTBSY));
+    rb_define_const(cFileError, "FAULT", INT2NUM(G_FILE_ERROR_FAULT));
+    rb_define_const(cFileError, "LOOP", INT2NUM(G_FILE_ERROR_LOOP));
+    rb_define_const(cFileError, "NOSPC", INT2NUM(G_FILE_ERROR_NOSPC));
+    rb_define_const(cFileError, "NOMEM", INT2NUM(G_FILE_ERROR_NOMEM));
+    rb_define_const(cFileError, "MFILE", INT2NUM(G_FILE_ERROR_MFILE));
+    rb_define_const(cFileError, "NFILE", INT2NUM(G_FILE_ERROR_NFILE));
+    rb_define_const(cFileError, "BADF", INT2NUM(G_FILE_ERROR_BADF));
+    rb_define_const(cFileError, "INVAL", INT2NUM(G_FILE_ERROR_INVAL));
+    rb_define_const(cFileError, "PIPE", INT2NUM(G_FILE_ERROR_PIPE));
+    rb_define_const(cFileError, "AGAIN", INT2NUM(G_FILE_ERROR_AGAIN));
+    rb_define_const(cFileError, "INTR", INT2NUM(G_FILE_ERROR_INTR));
+    rb_define_const(cFileError, "IO", INT2NUM(G_FILE_ERROR_IO));
+    rb_define_const(cFileError, "PERM", INT2NUM(G_FILE_ERROR_PERM));
+    rb_define_const(cFileError, "FAILED", INT2NUM(G_FILE_ERROR_FAILED));
+
+#if GLIB_CHECK_VERSION(2, 16, 0)
+    rb_define_module_function(mGLib, "format_size_for_display",
+			      rbglib_m_format_size_for_display, 1);
+#endif
+}

data/ext/glib2/rbglib_i18n.c

@@ -0,0 +1,44 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/**********************************************************************
+
+  rbglib_i18n.c -
+
+  $Author: ktou $
+  $Date: 2006/02/08 14:54:51 $
+
+  Copyright (C) 2006 Kouhei Sutou
+
+**********************************************************************/
+
+#include "rbgprivate.h"
+#include "rbglib.h"
+#undef _
+#include <glib/gi18n.h>
+
+#if GLIB_CHECK_VERSION(2,6,0)
+static VALUE
+rbglib_m_language_names(self)
+    VALUE self;
+{
+    const gchar * const *languages;
+    const gchar *language;
+    VALUE rb_languages = rb_ary_new();
+
+    languages = g_get_language_names();
+    for (language = *languages; *languages; language = *(++languages)) {
+        rb_ary_push(rb_languages, CSTR2RVAL(language));
+    }
+
+    return rb_languages;
+}
+#endif
+
+void
+Init_glib_i18n()
+{
+    /* glib/gi18n.h */
+#if GLIB_CHECK_VERSION(2,6,0)
+    rb_define_module_function(mGLib, "language_names",
+                              rbglib_m_language_names, 0);
+#endif
+}