glib2 0.20.0

data/src/rbglib_mainloop.c

@@ -0,0 +1,87 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbglib_mainloop.c -
+
+  $Author: ktou $
+  $Date: 2007/10/03 11:06:01 $
+
+  Copyright (C) 2005,2006 Masao Mutoh
+************************************************/
+
+#include "rbgprivate.h"
+
+/*****************************************/
+GType
+g_main_loop_get_type(void)
+{
+  static GType our_type = 0;
+  if (our_type == 0)
+    our_type = g_boxed_type_register_static ("GMainLoop",
+                    (GBoxedCopyFunc)g_main_loop_ref,
+                    (GBoxedFreeFunc)g_main_loop_unref);
+  return our_type;
+}
+/*****************************************/
+
+#define _SELF(s) ((GMainLoop*)RVAL2BOXED(s, G_TYPE_MAIN_LOOP))
+
+/*****************************************/
+
+static VALUE
+ml_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE context, is_running;
+    GMainLoop *loop;
+    GMainContext *main_context = NULL;
+
+    rb_scan_args(argc, argv, "02", &context, &is_running);
+
+    if (!NIL_P(context))
+        main_context = RVAL2BOXED(context, G_TYPE_MAIN_CONTEXT);
+    loop = g_main_loop_new(main_context, RVAL2CBOOL(is_running));
+    G_INITIALIZE(self, loop);
+    return Qnil;
+}
+
+static VALUE
+ml_run(self)
+    VALUE self;
+{
+    g_main_loop_run(_SELF(self));
+    return self;
+}
+
+static VALUE
+ml_quit(self)
+    VALUE self;
+{
+    g_main_loop_quit(_SELF(self));
+    return Qnil;
+}
+
+static VALUE
+ml_is_running(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(g_main_loop_is_running(_SELF(self)));
+}
+
+static VALUE
+ml_get_context(self)
+    VALUE self;
+{
+    return BOXED2RVAL(g_main_loop_get_context(_SELF(self)), G_TYPE_MAIN_CONTEXT);
+}
+
+void
+Init_glib_main_loop()
+{
+    VALUE ml = G_DEF_CLASS(G_TYPE_MAIN_LOOP, "MainLoop", mGLib);
+
+    rb_define_method(ml, "initialize", ml_initialize, -1);
+    rb_define_method(ml, "run", ml_run, 0);
+    rb_define_method(ml, "quit", ml_quit, 0);
+    rb_define_method(ml, "running?", ml_is_running, 0);
+    rb_define_method(ml, "context", ml_get_context, 0);
+}

data/src/rbglib_messages.c

@@ -0,0 +1,150 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbglib_messages.c -
+
+  $Author: sakai $
+  $Date: 2007/07/07 14:03:35 $
+
+  Copyright (C) 2002-2005 Masao Mutoh
+
+  This file is devided from rbgtkmain.c.
+  rbgtkmain.c -
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+
+#include "rbgprivate.h"
+
+#ifndef HAVE_RB_SOURCEFILE
+#define rb_sourcefile() (ruby_sourcefile)
+#endif
+
+#ifndef HAVE_RB_SOURCELINE
+#define rb_sourceline() (ruby_sourceline)
+#endif
+
+static VALUE rbglib_log_handler_procs;
+static ID id_call;
+static gboolean log_canceled;
+
+static gchar* logmessage(GLogLevelFlags level)
+{
+    if (level & G_LOG_LEVEL_ERROR){
+        return "ERROR";
+    } else if (level & G_LOG_LEVEL_CRITICAL){
+        return "CRITICAL";
+    } else if (level & G_LOG_LEVEL_WARNING){
+        return "WARNING";
+    } else if (level & G_LOG_LEVEL_MESSAGE){
+        return "MESSAGE";
+    } else if (level & G_LOG_LEVEL_INFO){
+        return "INFO";
+    } else if (level & G_LOG_LEVEL_DEBUG){
+        return "DEBUG";
+    }
+    return "UNKNOWN";
+}
+
+static void
+rbglib_log_handler(log_domain, log_level, message, user_data)
+    const gchar *log_domain;
+    GLogLevelFlags log_level;
+    const gchar *message;
+    gpointer user_data;
+{
+    if (! log_canceled){
+#ifdef HAVE_RUBY_SET_CURRENT_SOURCE
+        ruby_set_current_source();
+#endif
+        g_printerr("%s: line %d\n", rb_sourcefile(), rb_sourceline());
+        g_printerr("   %s-%s **:%s\n", log_domain, logmessage(log_level), message);
+    } else {
+        g_log_default_handler(log_domain, log_level, message, user_data);
+    }
+}
+
+/* Use Internal only */
+static VALUE
+rbglib_m_log_cancel_handler(self)
+    VALUE self;
+{
+    log_canceled = TRUE;
+    return Qnil;
+}
+
+static VALUE
+rbglib_m_log_set_handler(self, domain, levels)
+    VALUE self, domain, levels;
+{
+    guint handler_id = g_log_set_handler(NIL_P(domain) ? NULL : RVAL2CSTR(domain),
+                                         NUM2INT(levels),
+                                         (GLogFunc)rbglib_log_handler, (gpointer)self);
+    return UINT2NUM(handler_id);
+}
+
+static VALUE
+rbglib_m_log_remove_handler(self, domain, handler_id)
+    VALUE self, domain, handler_id;
+{
+    g_log_remove_handler(NIL_P(domain) ? NULL : RVAL2CSTR(domain),
+                         NUM2UINT(handler_id));
+    G_REMOVE_RELATIVE(self, handler_id, rbglib_log_handler_procs);
+    return Qnil;
+}
+
+static VALUE
+rbglib_m_log_set_always_fatal(self, fatal_mask)
+    VALUE self, fatal_mask;
+{
+    return INT2NUM(g_log_set_always_fatal(NUM2INT(fatal_mask)));
+}
+
+static VALUE
+rbglib_m_log_set_fatal_mask(self, domain, fatal_mask)
+    VALUE self, domain, fatal_mask;
+{
+    return INT2NUM(g_log_set_fatal_mask(NIL_P(domain) ? NULL : RVAL2CSTR(domain),
+                                        NUM2INT(fatal_mask)));
+}
+
+static VALUE
+rbglib_m_log(self, domain, level, str)
+    VALUE self, domain, level, str;
+{
+    g_log(NIL_P(domain) ? NULL : RVAL2CSTR(domain), NUM2INT(level), RVAL2CSTR(str), NULL);
+    return Qnil;
+}
+
+void
+Init_glib_messages()
+{
+    VALUE mGLog = rb_define_module_under(mGLib, "Log");
+
+    id_call = rb_intern("call");
+    log_canceled = FALSE;
+
+    rb_global_variable(&rbglib_log_handler_procs);
+    rbglib_log_handler_procs = rb_hash_new();
+    rb_define_module_function(mGLog, "set_handler", rbglib_m_log_set_handler, 2);
+    rb_define_module_function(mGLog, "remove_handler", rbglib_m_log_remove_handler, 2);
+    rb_define_module_function(mGLog, "cancel_handler", rbglib_m_log_cancel_handler, 0);
+    rb_define_module_function(mGLog, "set_always_fatal", rbglib_m_log_set_always_fatal, 1);
+    rb_define_module_function(mGLog, "set_fatal_mask", rbglib_m_log_set_fatal_mask, 2);
+    rb_define_module_function(mGLog, "log", rbglib_m_log, 3);
+
+    rb_define_const(mGLog, "FATAL_MASK", INT2NUM(G_LOG_FATAL_MASK));
+    rb_define_const(mGLog, "LEVEL_USER_SHIFT", INT2NUM(G_LOG_LEVEL_USER_SHIFT));
+
+    /* GLogLevelFlags */
+    rb_define_const(mGLog, "FLAG_RECURSION", INT2NUM(G_LOG_FLAG_RECURSION));
+    rb_define_const(mGLog, "FLAG_FATAL", INT2NUM(G_LOG_FLAG_FATAL));
+    rb_define_const(mGLog, "LEVEL_ERROR", INT2NUM(G_LOG_LEVEL_ERROR));
+    rb_define_const(mGLog, "LEVEL_CRITICAL", INT2NUM(G_LOG_LEVEL_CRITICAL));
+    rb_define_const(mGLog, "LEVEL_WARNING", INT2NUM(G_LOG_LEVEL_WARNING));
+    rb_define_const(mGLog, "LEVEL_MESSAGE", INT2NUM(G_LOG_LEVEL_MESSAGE));
+    rb_define_const(mGLog, "LEVEL_INFO", INT2NUM(G_LOG_LEVEL_INFO));
+    rb_define_const(mGLog, "LEVEL_DEBUG", INT2NUM(G_LOG_LEVEL_DEBUG));
+    rb_define_const(mGLog, "LEVEL_MASK", INT2NUM(G_LOG_LEVEL_MASK));
+}

data/src/rbglib_pollfd.c

@@ -0,0 +1,111 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbglib_pollfd.c -
+
+  $Author: mutoh $
+  $Date: 2005/03/12 18:03:56 $
+
+  Copyright (C) 2005 Masao Mutoh
+************************************************/
+
+#include "rbgprivate.h"
+
+/*****************************************/
+static GPollFD*
+pollfd_copy(const GPollFD* pollfd)
+{
+  GPollFD* new_pollfd;
+  g_return_val_if_fail (pollfd != NULL, NULL);
+
+  new_pollfd = g_new(GPollFD, 1);
+  *new_pollfd = *pollfd;
+  return new_pollfd;
+}
+
+GType
+g_poll_fd_get_type(void)
+{
+  static GType our_type = 0;
+  if (our_type == 0)
+    our_type = g_boxed_type_register_static ("GPollFD",
+                    (GBoxedCopyFunc)pollfd_copy,
+                    (GBoxedFreeFunc)g_free);
+  return our_type;
+}
+/*****************************************/
+
+#define _SELF(s) ((GPollFD*)RVAL2BOXED(s, G_TYPE_POLL_FD))
+
+static VALUE
+poll_initialize(self, fd, events, revents)
+    VALUE self, fd, events, revents;
+{
+    GPollFD gfd;
+    gfd.fd = NUM2INT(fd);
+    gfd.events = NUM2INT(events);
+    gfd.revents = NUM2INT(revents);
+
+    G_INITIALIZE(self, &gfd);
+    return Qnil;
+}
+
+static VALUE
+poll_set_fd(self, fd)
+    VALUE self, fd;
+{
+    _SELF(self)->fd = fd;
+    return self;
+}
+static VALUE
+poll_fd(self)
+    VALUE self;
+{
+    return INT2NUM(_SELF(self)->fd);
+}
+
+static VALUE
+poll_set_events(self, events)
+    VALUE self, events;
+{
+    _SELF(self)->events = events;
+    return self;
+}
+static VALUE
+poll_events(self)
+    VALUE self;
+{
+    return INT2NUM(_SELF(self)->events);
+}
+
+static VALUE
+poll_set_revents(self, revents)
+    VALUE self, revents;
+{
+    _SELF(self)->revents = revents;
+    return self;
+}
+static VALUE
+poll_revents(self)
+    VALUE self;
+{
+    return INT2NUM(_SELF(self)->revents);
+}
+
+void
+Init_glib_poll_fd()
+{
+    VALUE fd = G_DEF_CLASS(G_TYPE_POLL_FD, "PollFD", mGLib); 
+
+    rb_define_method(fd, "initialize", poll_initialize, 3);
+
+    rb_define_method(fd, "set_fd", poll_set_fd, 1);
+    rb_define_method(fd, "fd", poll_fd, 0);
+    rb_define_method(fd, "set_events", poll_set_events, 1);
+    rb_define_method(fd, "events", poll_events, 0);
+    rb_define_method(fd, "set_revents", poll_set_revents, 1);
+    rb_define_method(fd, "revents", poll_revents, 0);
+
+    G_DEF_SETTERS(fd);
+
+}

data/src/rbglib_shell.c

@@ -0,0 +1,68 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbglib_shell.c -
+
+  $Author: mutoh $
+  $Date: 2005/10/14 19:10:08 $
+
+  Copyright (C) 2005 Masao Mutoh
+************************************************/
+
+#include "rbgprivate.h"
+
+static VALUE
+shell_parse(self, command_line)
+    VALUE self, command_line;
+{
+    gint argc, i;
+    gchar** argv;
+    GError* err = NULL;
+    VALUE ary;
+
+    gboolean ret = g_shell_parse_argv(RVAL2CSTR(command_line),
+                                      &argc, &argv, &err);
+
+    if (! ret) RAISE_GERROR(err);
+
+    ary = rb_ary_new();
+    for (i = 0; i < argc; i++) {
+        rb_ary_push(ary, CSTR2RVAL(argv[i]));
+    }
+    g_strfreev (argv);
+    return ary;
+}
+
+static VALUE
+shell_quote(self, unquoted_string)
+    VALUE self, unquoted_string;
+{
+    return CSTR2RVAL2(g_shell_quote((const gchar*)RVAL2CSTR(unquoted_string)));
+}
+
+static VALUE
+shell_unquote(self, quoted_string)
+    VALUE self, quoted_string;
+{
+    GError* err = NULL;
+    gchar* str = g_shell_unquote((const gchar*)RVAL2CSTR(quoted_string), &err);
+
+    if (! str) RAISE_GERROR(err);
+
+    return CSTR2RVAL2(str);
+}
+
+void
+Init_glib_shell()
+{
+    VALUE mShell = rb_define_module_under(mGLib, "Shell");
+    VALUE cShellError = G_DEF_ERROR2(G_SHELL_ERROR, "ShellError", mGLib, rb_eRuntimeError);
+
+    rb_define_module_function(mShell, "parse", shell_parse, 1);
+    rb_define_module_function(mShell, "quote", shell_quote, 1);
+    rb_define_module_function(mShell, "unquote", shell_unquote, 1);
+
+    rb_define_const(cShellError, "BAD_QUOTING", INT2FIX(G_SHELL_ERROR_BAD_QUOTING));
+    rb_define_const(cShellError, "EMPTY_STRING", INT2FIX(G_SHELL_ERROR_EMPTY_STRING));
+    rb_define_const(cShellError, "FAILED", INT2FIX(G_SHELL_ERROR_FAILED));
+}

data/src/rbglib_source.c

@@ -0,0 +1,190 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbglib_source.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:28 $
+
+  Copyright (C) 2005 Masao Mutoh
+************************************************/
+
+#include "rbgprivate.h"
+
+static ID id_call;
+
+/*****************************************/
+static void
+source_free(source)
+    GSource* source;
+{
+    g_source_unref(source);
+    g_source_destroy(source);
+}
+
+GType
+g_source_get_type(void)
+{
+  static GType our_type = 0;
+  if (our_type == 0)
+    our_type = g_boxed_type_register_static ("GSource",
+                    (GBoxedCopyFunc)g_source_ref,
+                    (GBoxedFreeFunc)source_free);
+  return our_type;
+}
+/*****************************************/
+
+#define _SELF(s) ((GSource*)RVAL2BOXED(s, G_TYPE_SOURCE))
+
+/*
+GSource*    g_source_new                    (GSourceFuncs *source_funcs,
+                                             guint struct_size);
+*/
+
+static VALUE
+source_attach(self, context)
+    VALUE self, context;
+{
+    return UINT2NUM(g_source_attach(_SELF(self), 
+                                    RVAL2BOXED(context, G_TYPE_MAIN_CONTEXT)));
+}
+
+#if GLIB_CHECK_VERSION(2,12,0)
+static VALUE
+source_is_destroyed(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(g_source_is_destroyed(_SELF(self)));
+}
+#endif
+
+static VALUE
+source_set_priority(self, priority)
+    VALUE self, priority;
+{
+    g_source_set_priority(_SELF(self), NUM2INT(priority));
+    return self;
+}
+
+static VALUE
+source_get_priority(self)
+    VALUE self;
+{
+    return INT2NUM(g_source_get_priority(_SELF(self)));
+}
+
+static VALUE
+source_set_can_recurse(self, can_recurse)
+    VALUE self, can_recurse;
+{
+    g_source_set_can_recurse(_SELF(self), RVAL2CBOOL(can_recurse));
+    return self;
+}
+
+static VALUE
+source_get_can_recurse(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(g_source_get_can_recurse(_SELF(self)));
+}
+
+static VALUE
+source_get_id(self)
+    VALUE self;
+{
+    return UINT2NUM(g_source_get_id(_SELF(self)));
+}
+
+static VALUE
+source_get_context(self)
+    VALUE self;
+{
+    GMainContext* context = g_source_get_context(_SELF(self));
+    return BOXED2RVAL(context, G_TYPE_MAIN_CONTEXT);
+}
+
+static gboolean
+source_func(func)
+    gpointer func;
+{
+    return RVAL2CBOOL(rb_funcall((VALUE)func, id_call, 0));
+}
+
+static VALUE
+source_set_callback(self)
+    VALUE self;
+{
+    VALUE func = rb_block_proc();
+    G_RELATIVE(self, func);
+    g_source_set_callback(_SELF(self),
+                          (GSourceFunc)source_func,
+                          (gpointer)func, 
+                          (GDestroyNotify)NULL);
+    return self;
+}
+
+/*
+void        g_source_set_callback_indirect  (GSource *source,
+                                             gpointer callback_data,
+                                             GSourceCallbackFuncs *callback_funcs);
+*/
+
+static VALUE
+source_add_poll(self, fd)
+    VALUE self, fd;
+{
+    g_source_add_poll(_SELF(self), RVAL2BOXED(fd, G_TYPE_POLL_FD));
+    return self;
+}
+
+static VALUE
+source_remove_poll(self, fd)
+    VALUE self, fd;
+{
+    g_source_remove_poll(_SELF(self), RVAL2BOXED(fd, G_TYPE_POLL_FD));
+    return self;
+}
+
+static VALUE
+source_get_current_time(self)
+    VALUE self;
+{
+    GTimeVal timeval;
+    g_source_get_current_time(_SELF(self), &timeval);
+
+    return rb_assoc_new(LONG2NUM(timeval.tv_sec), LONG2NUM(timeval.tv_usec));
+}
+
+/* How can I implement them ?
+gboolean    g_source_remove_by_funcs_user_data
+                                            (GSourceFuncs *funcs,
+                                             gpointer user_data);
+gboolean    g_source_remove_by_user_data    (gpointer user_data);
+*/
+
+void
+Init_glib_source()
+{
+    VALUE src = G_DEF_CLASS(G_TYPE_SOURCE, "Source", mGLib); 
+
+    id_call = rb_intern("call");
+
+    rb_define_method(src, "attach", source_attach, 1);
+#if GLIB_CHECK_VERSION(2,12,0)
+    rb_define_method(src, "destroyed?", source_is_destroyed, 0);
+#endif
+    rb_define_method(src, "set_priority", source_set_priority, 1);
+    rb_define_method(src, "priority", source_get_priority, 0);
+    rb_define_method(src, "set_can_recurse", source_set_can_recurse, 1);
+    rb_define_method(src, "can_recurse?", source_get_can_recurse, 0);
+    rb_define_method(src, "id", source_get_id, 0);
+    rb_define_method(src, "context", source_get_context, 0);
+    rb_define_method(src, "set_callback", source_set_callback, 0);
+    rb_define_method(src, "add_poll", source_add_poll, 1);
+    rb_define_method(src, "remove_poll", source_remove_poll, 1);
+    rb_define_method(src, "current_time", source_get_current_time, 0);
+
+    /* GLib::Source.remove is moved to rbglib_maincontext.c */
+
+    G_DEF_SETTERS(src);
+}