gtk2 1.0.3-x86-mingw32 → 1.1.0-x86-mingw32

data/ext/gtk2/rbgdkwindowattr.c

@@ -1,13 +1,23 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbgdkwindowattr.c -
-
-  $Author: ggc $
-  $Date: 2007/07/13 16:07:31 $
-
-  Copyright (C) 2003 Masao Mutoh
-************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2003  Masao Mutoh
+ *
+ *  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 "global.h"
 
@@ -34,11 +44,12 @@ gdk_windowattr_get_type(void)
 }
 /*****************************************/
 
+#define RG_TARGET_NAMESPACE cWindowAttr
 #define _SELF(w) ((GdkWindowAttr*)RVAL2BOXED(w, GDK_TYPE_WINDOW_ATTR))
 
 static VALUE
-attr_initialize(VALUE self, VALUE width, VALUE height, VALUE wclass,
-		VALUE window_type)
+rg_initialize(VALUE self, VALUE width, VALUE height, VALUE wclass,
+        VALUE window_type)
 {
     GdkWindowAttr w;
     w.width = NUM2INT(width);
@@ -83,60 +94,60 @@ ATTR_INT(width);
 ATTR_INT(height);
 
 static VALUE
-attr_get_wclass(VALUE self)
+rg_wclass(VALUE self)
 {
     return GENUM2RVAL(_SELF(self)->wclass, GDK_TYPE_WINDOW_CLASS);
 }
 static VALUE
-attr_set_wclass(VALUE self, VALUE val)
+rg_set_wclass(VALUE self, VALUE val)
 {
     _SELF(self)->wclass = RVAL2GENUM(val, GDK_TYPE_WINDOW_CLASS);
     return self;
 }
 
 static VALUE
-attr_get_visual(VALUE self)
+rg_visual(VALUE self)
 {
     return GOBJ2RVAL(_SELF(self)->visual);
 }
 static VALUE
-attr_set_visual(VALUE self, VALUE val)
+rg_set_visual(VALUE self, VALUE val)
 {
     _SELF(self)->visual = GDK_VISUAL(RVAL2GOBJ(val));
     return self;
 }
 
 static VALUE
-attr_get_colormap(VALUE self)
+rg_colormap(VALUE self)
 {
     return GOBJ2RVAL(_SELF(self)->colormap);
 }
 static VALUE
-attr_set_colormap(VALUE self, VALUE val)
+rg_set_colormap(VALUE self, VALUE val)
 {
     _SELF(self)->colormap = GDK_COLORMAP(RVAL2GOBJ(val));
     return self;
 }
 
 static VALUE
-attr_get_window_type(VALUE self)
+rg_window_type(VALUE self)
 {
     return GENUM2RVAL(_SELF(self)->window_type, GDK_TYPE_WINDOW_TYPE);
 }
 static VALUE
-attr_set_window_type(VALUE self, VALUE val)
+rg_set_window_type(VALUE self, VALUE val)
 {
     _SELF(self)->window_type = RVAL2GENUM(val, GDK_TYPE_WINDOW_TYPE);
     return self;
 }
 
 static VALUE
-attr_get_cursor(VALUE self)
+rg_cursor(VALUE self)
 {
     return BOXED2RVAL(_SELF(self)->cursor, GDK_TYPE_CURSOR);
 }
 static VALUE
-attr_set_cursor(VALUE self, VALUE val)
+rg_set_cursor(VALUE self, VALUE val)
 {
     _SELF(self)->cursor = (GdkCursor*)(RVAL2BOXED(val, GDK_TYPE_CURSOR));
     return self;
@@ -146,52 +157,52 @@ ATTR_STR(wmclass_name);
 ATTR_STR(wmclass_class);
 
 static VALUE
-attr_get_override_redirect(VALUE self)
+rg_override_redirect(VALUE self)
 {
     return CBOOL2RVAL(_SELF(self)->override_redirect);
 }
 static VALUE
-attr_set_override_redirect(VALUE self, VALUE val)
+rg_set_override_redirect(VALUE self, VALUE val)
 {
     _SELF(self)->override_redirect = RVAL2CBOOL(val);
     return self;
 }
 
 void 
-Init_gtk_gdk_windowattr()
-{
-    VALUE gWindowAttr = G_DEF_CLASS(GDK_TYPE_WINDOW_ATTR, "WindowAttr", mGdk);
-
-    rb_define_method(gWindowAttr, "initialize", attr_initialize, 4);
-    rb_define_method(gWindowAttr, "title", attr_get_title, 0);
-    rb_define_method(gWindowAttr, "set_title", attr_set_title, 1);
-    rb_define_method(gWindowAttr, "event_mask", attr_get_event_mask, 0);
-    rb_define_method(gWindowAttr, "set_event_mask", attr_set_event_mask, 1);
-    rb_define_method(gWindowAttr, "x", attr_get_x, 0);
-    rb_define_method(gWindowAttr, "set_x", attr_set_x, 1);
-    rb_define_method(gWindowAttr, "y", attr_get_y, 0);
-    rb_define_method(gWindowAttr, "set_y", attr_set_y, 1);
-    rb_define_method(gWindowAttr, "width", attr_get_width, 0);
-    rb_define_method(gWindowAttr, "set_width", attr_set_width, 1);
-    rb_define_method(gWindowAttr, "height", attr_get_height, 0);
-    rb_define_method(gWindowAttr, "set_height", attr_set_height, 1);
-    rb_define_method(gWindowAttr, "wclass", attr_get_wclass, 0);
-    rb_define_method(gWindowAttr, "set_wclass", attr_set_wclass, 1);
-    rb_define_method(gWindowAttr, "visual", attr_get_visual, 0);
-    rb_define_method(gWindowAttr, "set_visual", attr_set_visual, 1);
-    rb_define_method(gWindowAttr, "colormap", attr_get_colormap, 0);
-    rb_define_method(gWindowAttr, "set_colormap", attr_set_colormap, 1);
-    rb_define_method(gWindowAttr, "window_type", attr_get_window_type, 0);
-    rb_define_method(gWindowAttr, "set_window_type", attr_set_window_type, 1);
-    rb_define_method(gWindowAttr, "cursor", attr_get_cursor, 0);
-    rb_define_method(gWindowAttr, "set_cursor", attr_set_cursor, 1);
-    rb_define_method(gWindowAttr, "wmclass_name", attr_get_wmclass_name, 0);
-    rb_define_method(gWindowAttr, "set_wmclass_name", attr_set_wmclass_name, 1);
-    rb_define_method(gWindowAttr, "wmclass_class", attr_get_wmclass_class, 0);
-    rb_define_method(gWindowAttr, "set_wmclass_class", attr_set_wmclass_class, 1);
-    rb_define_method(gWindowAttr, "override_redirect", attr_get_override_redirect, 0);
-    rb_define_method(gWindowAttr, "set_override_redirect", attr_set_override_redirect, 1);
-
-    G_DEF_SETTERS(gWindowAttr);
+Init_gtk_gdk_windowattr(VALUE mGdk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_WINDOW_ATTR, "WindowAttr", mGdk);
+
+    RG_DEF_METHOD(initialize, 4);
+    rb_define_method(RG_TARGET_NAMESPACE, "title", attr_get_title, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "set_title", attr_set_title, 1);
+    rb_define_method(RG_TARGET_NAMESPACE, "event_mask", attr_get_event_mask, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "set_event_mask", attr_set_event_mask, 1);
+    rb_define_method(RG_TARGET_NAMESPACE, "x", attr_get_x, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "set_x", attr_set_x, 1);
+    rb_define_method(RG_TARGET_NAMESPACE, "y", attr_get_y, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "set_y", attr_set_y, 1);
+    rb_define_method(RG_TARGET_NAMESPACE, "width", attr_get_width, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "set_width", attr_set_width, 1);
+    rb_define_method(RG_TARGET_NAMESPACE, "height", attr_get_height, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "set_height", attr_set_height, 1);
+    RG_DEF_METHOD(wclass, 0);
+    RG_DEF_METHOD(set_wclass, 1);
+    RG_DEF_METHOD(visual, 0);
+    RG_DEF_METHOD(set_visual, 1);
+    RG_DEF_METHOD(colormap, 0);
+    RG_DEF_METHOD(set_colormap, 1);
+    RG_DEF_METHOD(window_type, 0);
+    RG_DEF_METHOD(set_window_type, 1);
+    RG_DEF_METHOD(cursor, 0);
+    RG_DEF_METHOD(set_cursor, 1);
+    rb_define_method(RG_TARGET_NAMESPACE, "wmclass_name", attr_get_wmclass_name, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "set_wmclass_name", attr_set_wmclass_name, 1);
+    rb_define_method(RG_TARGET_NAMESPACE, "wmclass_class", attr_get_wmclass_class, 0);
+    rb_define_method(RG_TARGET_NAMESPACE, "set_wmclass_class", attr_set_wmclass_class, 1);
+    RG_DEF_METHOD(override_redirect, 0);
+    RG_DEF_METHOD(set_override_redirect, 1);
+
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
 
 }

data/ext/gtk2/rbgdkx11.c

@@ -1,16 +1,29 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbgdkx11.c -
-
-  $Author $
-  $Date: 2005/03/05 18:30:12 $
-
-  Copyright (C) 2005 Masao Mutoh
-************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2005  Masao Mutoh
+ *
+ *  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 "global.h"
 #ifdef GDK_WINDOWING_X11
+
+#define RG_TARGET_NAMESPACE mX11
+
 /* Can't implement
 #define     GDK_ROOT_WINDOW                 ()
 */
@@ -77,26 +90,26 @@ GdkWindow*  gdk_window_foreign_new_for_display
 */
 
 static VALUE
-rbx11_xid_table_lookup(int argc, VALUE *argv, VALUE self)
+rg_m_xid_table_lookup(int argc, VALUE *argv, VALUE self)
 {
     VALUE arg[2];
     GdkPixmap* win = NULL;
-    
+
     rb_scan_args(argc, argv, "11", &arg[0], &arg[1]);
 
     switch(argc)
     {
       case 1:
-    	win = gdk_xid_table_lookup(NUM2UINT(arg[0]));
-	break;
+        win = gdk_xid_table_lookup(NUM2UINT(arg[0]));
+        break;
       case 2:
 #if GTK_CHECK_VERSION(2,2,0)
-    	win = gdk_xid_table_lookup_for_display(RVAL2GOBJ(arg[0]), NUM2UINT(arg[1])); 
+        win = gdk_xid_table_lookup_for_display(RVAL2GOBJ(arg[0]), NUM2UINT(arg[1])); 
 #else
-    	win = gdk_xid_table_lookup(NUM2UINT(arg[1])); 
+        win = gdk_xid_table_lookup(NUM2UINT(arg[1])); 
         rb_warn("Not supported in GTK+-2.0.x.");
 #endif
-    	break;
+        break;
     }
     if (win == NULL)
         return Qnil;
@@ -127,7 +140,7 @@ guint32     gdk_x11_get_server_time         (GdkWindow *window);
 */
 
 static VALUE
-rbx11_net_wm_supports(VALUE self, VALUE property)
+rg_m_net_wm_supports_p(VALUE self, VALUE property)
 {
     return CBOOL2RVAL(gdk_net_wm_supports(RVAL2ATOM(property)));
 }
@@ -178,7 +191,7 @@ Window      gdk_x11_get_default_root_xwindow
 */
 
 static VALUE
-rbx11_get_default_screen(VALUE self)
+rg_m_default_screen(VALUE self)
 {
     return INT2NUM(gdk_x11_get_default_screen());
 }
@@ -187,7 +200,7 @@ Display*    gdk_x11_get_default_xdisplay    (void);
 */
 
 static VALUE
-rbx11_grab_server(VALUE self)
+rg_m_grab_server(VALUE self)
 {
     gdk_x11_grab_server();
     return Qnil;
@@ -205,7 +218,7 @@ Screen*     gdk_x11_screen_get_xscreen      (GdkScreen *screen);
 */
 
 static VALUE
-rbx11_ungrab_server(VALUE self)
+rg_m_ungrab_server(VALUE self)
 {
     gdk_x11_ungrab_server();
     return Qnil;
@@ -233,17 +246,17 @@ G_CONST_RETURN gchar* gdk_x11_get_xatom_name_for_display
 */
 #endif
 void
-Init_gtk_gdk_x11()
+Init_gtk_gdk_x11(VALUE mGdk)
 {
 #ifdef GDK_WINDOWING_X11
-    VALUE mX11 = rb_define_module_under(mGdk, "X11");
+    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGdk, "X11");
+
+    RG_DEF_MODFUNC(xid_table_lookup, -1);
+    RG_DEF_MODFUNC_P(net_wm_supports, 1);
 
-    rb_define_module_function(mX11, "xid_table_lookup", rbx11_xid_table_lookup, -1);
-    rb_define_module_function(mX11, "net_wm_supports?", rbx11_net_wm_supports, 1);
+    RG_DEF_MODFUNC(default_screen, 0);
+    RG_DEF_MODFUNC(grab_server, 0);
 
-    rb_define_module_function(mX11, "default_screen", rbx11_get_default_screen, 0);
-    rb_define_module_function(mX11, "grab_server", rbx11_grab_server, 0);
-                                                                                
-    rb_define_module_function(mX11, "ungrab_server", rbx11_ungrab_server, 0);
+    RG_DEF_MODFUNC(ungrab_server, 0);
 #endif
 }

data/ext/gtk2/rbgtk.c

@@ -1,30 +1,54 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbgtk.c -
-
-  $Author: sakai $
-  $Date: 2007/07/04 13:33:17 $
-
-  Copyright (C) 2002-2006 Ruby-GNOME2 Project Team
-  Copyright (C) 1998-2001 Yukihiro Matsumoto,
-                          Daisuke Kanda,
-                          Hiroshi Igarashi
-************************************************/
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2006 Ruby-GNOME2 Project Team
+ *  Copyright (C) 1998-2001 Yukihiro Matsumoto,
+ *                          Daisuke Kanda,
+ *                          Hiroshi Igarashi
+ *
+ *  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 "global.h"
 #ifdef HAVE_SYS_TIME_H
 # include <sys/time.h>
 #endif
+#include <locale.h>
+
+#define RG_TARGET_NAMESPACE mGtk
 
-VALUE mGtk;
+VALUE RG_TARGET_NAMESPACE;
+
+static VALUE rbgtk_eGtkInitError;
 
 ID id_relative_callbacks;
 ID id_call;
 static ID id__windows__;
+static ID id__quit_callbacks__, id__timeout_callbacks__;
+static ID id__idle_callbacks__, id__snooper_callbacks__;
+
+typedef struct _callback_info_t
+{
+    VALUE callback;
+    ID key;
+    guint id;
+} callback_info_t;
 
 static void
-remove_from_windows(GtkWidget *window, VALUE obj)
+remove_from_windows(G_GNUC_UNUSED GtkWidget *window, VALUE obj)
 {
     VALUE klass, windows;
 
@@ -70,23 +94,478 @@ exec_callback(GtkWidget *widget, gpointer proc)
 #define USE_POLL_FUNC
 
 static VALUE
-gtk_m_events_pending(VALUE self)
+rg_m_events_pending_p(G_GNUC_UNUSED VALUE self)
 {
    return CBOOL2RVAL(gtk_events_pending());
 }
 
+static VALUE
+gtk_m_function_body(VALUE data)
+{
+    callback_info_t *info = (callback_info_t *)data;
+    VALUE ret = rb_funcall(info->callback, id_call, 0);
+
+    if (info->key && !ret)
+        G_REMOVE_RELATIVE(RG_TARGET_NAMESPACE, info->key, UINT2NUM(info->id));
+    return ret;
+}
+
+static gboolean
+gtk_m_function(gpointer data)
+{ 
+    return RVAL2CBOOL(G_PROTECT_CALLBACK(gtk_m_function_body, data));
+}
+
+static VALUE
+gtk_m_function2_body(gpointer proc)
+{
+    rb_funcall((VALUE)proc, id_call, 0);
+    return Qnil;
+}
+
+static void
+gtk_m_function2(gpointer proc)
+{
+    G_PROTECT_CALLBACK(gtk_m_function2_body, proc);
+}
+
+static VALUE
+rg_m_set_locale(G_GNUC_UNUSED VALUE self)
+{
+    return CSTR2RVAL(gtk_set_locale());
+}
+
+static VALUE
+rg_m_disable_setlocale(G_GNUC_UNUSED VALUE self)
+{
+    gtk_disable_setlocale();
+    return Qnil;
+}
+
+static VALUE
+rg_m_default_language(G_GNUC_UNUSED VALUE self)
+{
+    return BOXED2RVAL(gtk_get_default_language(), PANGO_TYPE_LANGUAGE);
+}
+
+typedef void (*SignalFunc) (int);
+
+static gboolean _initialized = FALSE;
+
+static VALUE
+rg_m_init(int argc, VALUE *argv, VALUE self)
+{
+    gint i, gargc;
+    VALUE argary;
+    char** gargv;
+    VALUE progname;
+
+    if (_initialized)
+        return self;
+    else
+        _initialized = TRUE;
+
+    rb_scan_args(argc, argv, "01", &argary);
+
+    if (NIL_P(argary)){
+        argary = rb_const_get(rb_cObject, rb_intern("ARGV"));
+        gargc = RARRAY_LEN(argary);
+    } else {
+        Check_Type(argary, T_ARRAY);
+        gargc = RARRAY_LEN(argary);
+    }
+
+    gargv = ALLOCA_N(char *, gargc + 1);
+    progname = rb_gv_get("$0");
+    gargv[0] = (char *)RVAL2CSTR(progname);
+
+    for (i = 0; i < gargc; i++)
+        if (TYPE(RARRAY_PTR(argary)[i]) == T_STRING)
+            gargv[i+1] = (char *)RVAL2CSTR(RARRAY_PTR(argary)[i]);
+        else
+            gargv[i+1] = (char *)"";
+    gargc++;
+
+    {
+        gboolean is_initialized;
+        /* Gdk modifies sighandlers, sigh */
+#ifdef NT
+        RETSIGTYPE (*sigfunc[3])();
+#else
+        RETSIGTYPE (*sigfunc[7])();
+#endif
+
+#ifdef NT
+        sigfunc[0] = signal(SIGINT, SIG_IGN);
+        sigfunc[1] = signal(SIGSEGV, SIG_IGN);
+        sigfunc[2] = signal(SIGTERM, SIG_IGN);
+#else
+        sigfunc[0] = signal(SIGHUP, SIG_IGN);
+        sigfunc[1] = signal(SIGINT, SIG_IGN);
+        sigfunc[2] = signal(SIGQUIT, SIG_IGN);
+        sigfunc[3] = signal(SIGBUS, SIG_IGN);
+        sigfunc[4] = signal(SIGSEGV, SIG_IGN);
+        sigfunc[5] = signal(SIGPIPE, SIG_IGN);
+        sigfunc[6] = signal(SIGTERM, SIG_IGN);
+#endif
+
+        is_initialized = gtk_init_check(&gargc, &gargv);
+        if (! is_initialized) {
+            const char *display_name_arg = gdk_get_display_arg_name();
+            display_name_arg = display_name_arg ? display_name_arg : g_getenv("DISPLAY");
+            rb_raise(rbgtk_eGtkInitError, "Cannot open display: %s",
+                     display_name_arg ? display_name_arg : " ");
+        }
+
+        setlocale(LC_NUMERIC, "C");
+
+#ifdef NT
+        signal(SIGINT,  (SignalFunc)sigfunc[0]);
+        signal(SIGSEGV, (SignalFunc)sigfunc[1]);
+        signal(SIGTERM, (SignalFunc)sigfunc[2]);
+#else
+        signal(SIGHUP,  sigfunc[0]);
+        signal(SIGINT,  sigfunc[1]);
+        signal(SIGQUIT, sigfunc[2]);
+        signal(SIGBUS,  sigfunc[3]);
+        signal(SIGSEGV, sigfunc[4]);
+        signal(SIGPIPE, sigfunc[5]);
+        signal(SIGTERM, sigfunc[6]);
+#endif
+    }
+
+    return self;
+}
+
+/* We don't need them.
+gtk_init()
+gtk_exit()
+*/
+
+static VALUE
+rg_m_main(G_GNUC_UNUSED VALUE self)
+{
+    gtk_main();
+    return Qnil;
+}
+
+static VALUE
+rg_m_main_level(G_GNUC_UNUSED VALUE self)
+{
+    return INT2FIX(gtk_main_level());
+}
+
+static VALUE
+rg_m_main_quit(G_GNUC_UNUSED VALUE self)
+{
+    gtk_main_quit();
+    return Qnil;
+}
+
+static VALUE
+rg_m_main_iteration(G_GNUC_UNUSED VALUE self)
+{
+    return CBOOL2RVAL(gtk_main_iteration());
+}
+
+static VALUE
+rg_m_main_iteration_do(G_GNUC_UNUSED VALUE self, VALUE blocking)
+{
+    return CBOOL2RVAL(gtk_main_iteration_do(RVAL2CBOOL(blocking)));
+}
+
+static VALUE
+rg_m_main_do_event(G_GNUC_UNUSED VALUE self, VALUE event)
+{
+    gtk_main_do_event(RVAL2GEV(event));
+    return event;
+}
+
+/* We don't need them.
+gtk_true()
+gtk_false()
+*/
+
+static VALUE
+rg_m_grab_add(G_GNUC_UNUSED VALUE self, VALUE widget)
+{
+    gtk_grab_add(GTK_WIDGET(RVAL2GOBJ(widget)));
+    return Qnil;
+}
+
+static VALUE
+rg_m_current(G_GNUC_UNUSED VALUE self)
+{
+    return GOBJ2RVAL(gtk_grab_get_current());
+}
+
+static VALUE
+rg_m_grab_remove(G_GNUC_UNUSED VALUE self, VALUE widget)
+{
+    gtk_grab_remove(GTK_WIDGET(RVAL2GOBJ(widget)));
+    return Qnil;
+}
+
+static VALUE
+rg_m_init_add(VALUE self)
+{
+    volatile VALUE func = rb_block_proc();
+
+    gtk_init_add((GtkFunction)gtk_m_function2, (gpointer)func);
+    G_RELATIVE(self, func);
+    return Qnil;
+}
+
+static VALUE
+rg_m_quit_add(VALUE self, VALUE main_level)
+{
+    volatile VALUE func = rb_block_proc();
+    VALUE rb_id;
+    callback_info_t *info;
+    guint id;
+
+    info = ALLOC(callback_info_t);
+    info->callback = func;
+    info->key = id_relative_callbacks;
+    id = gtk_quit_add_full(NUM2UINT(main_level), (GtkFunction)gtk_m_function,
+                           NULL, (gpointer)info, g_free);
+    info->id = id;
+    rb_id = UINT2NUM(id);
+    G_RELATIVE2(self, func, id__quit_callbacks__, rb_id);
+    return rb_id;
+}
+
+static VALUE
+rg_m_quit_remove(VALUE self, VALUE quit_handler_id)
+{
+    gtk_quit_remove(NUM2UINT(quit_handler_id));
+    G_REMOVE_RELATIVE(self, id__quit_callbacks__, quit_handler_id);
+    return quit_handler_id;
+}
+
+/* We don't need this.
+gtk_quit_add_full ()
+gtk_quit_add_destroy()
+gtk_quit_remove_by_data()
+gtk_timeout_add_full()
+*/
+
+static VALUE
+rg_m_timeout_add(VALUE self, VALUE interval)
+{
+    VALUE func, rb_id;
+    callback_info_t *info;
+    guint id;
+
+    func = rb_block_proc();
+    info = ALLOC(callback_info_t);
+    info->callback = func;
+    info->key = id__timeout_callbacks__;
+    id = gtk_timeout_add_full(NUM2UINT(interval), (GtkFunction)gtk_m_function,
+                              NULL, (gpointer)info, g_free);
+    info->id = id;
+    rb_id = UINT2NUM(id);
+    G_RELATIVE2(self, func, id__timeout_callbacks__, rb_id);
+    return rb_id;
+}
+
+static VALUE
+rg_m_timeout_remove(VALUE self, VALUE id)
+{
+    gtk_timeout_remove(NUM2UINT(id));
+    G_REMOVE_RELATIVE(self, id__timeout_callbacks__, id);
+    return Qnil;
+}
+
+static VALUE
+rg_m_idle_add(VALUE self)
+{
+    VALUE func, rb_id;
+    callback_info_t *info;
+    guint id;
+
+    func = rb_block_proc();
+    info = ALLOC(callback_info_t);
+    info->callback = func;
+    info->key = id__idle_callbacks__;
+    id = gtk_idle_add_full(G_PRIORITY_DEFAULT_IDLE,
+                           (GtkFunction)gtk_m_function, NULL,
+                           (gpointer)info, g_free);
+    info->id = id;
+    rb_id = UINT2NUM(id);
+    G_RELATIVE2(self, func, id__idle_callbacks__, rb_id);
+    return rb_id;
+}
+
+static VALUE
+rg_m_idle_add_priority(VALUE self, VALUE priority)
+{
+    VALUE func, rb_id;
+    callback_info_t *info;
+    guint id;
+
+    func = rb_block_proc();
+    info = ALLOC(callback_info_t);
+    info->callback = func;
+    info->key = id__idle_callbacks__;
+    id = gtk_idle_add_full(NUM2INT(priority), (GtkFunction)gtk_m_function,
+                           NULL, (gpointer)info, g_free);
+    info->id = id;
+    rb_id = UINT2NUM(id);
+    G_RELATIVE2(self, func, id__idle_callbacks__, rb_id);
+    return rb_id;
+}
+
+static VALUE
+rg_m_idle_remove(VALUE self, VALUE id)
+{
+    gtk_idle_remove(NUM2UINT(id));
+    G_REMOVE_RELATIVE(self, id__idle_callbacks__, id);
+    return Qnil;
+}
+
+/* We don't need this.
+gtk_idle_remove_by_data()
+gtk_idle_add_full()
+
+Use Gdk::Input.add, remove
+gtk_input_add_full()
+gtk_input_remove()
+*/
+
+static gint
+gtk_m_key_snoop_func(GtkWidget *grab_widget, GdkEventKey *event, gpointer func)
+{
+    VALUE ret = rb_funcall((VALUE)func, id_call, 2, 
+                           GOBJ2RVAL(grab_widget), 
+                           GEV2RVAL((GdkEvent*)event));
+    return RVAL2CBOOL(ret);
+}
+
+static VALUE
+rg_m_key_snooper_install(VALUE self)
+{
+    VALUE func = rb_block_proc();
+    VALUE id = INT2FIX(gtk_key_snooper_install(
+                           (GtkKeySnoopFunc)gtk_m_key_snoop_func, 
+                           (gpointer)func));
+    G_RELATIVE2(self, func, id__snooper_callbacks__, id);
+    return id;
+}
+
+static VALUE
+rg_m_key_snooper_remove(VALUE self, VALUE id)
+{
+    gtk_key_snooper_remove(NUM2UINT(id));
+    G_REMOVE_RELATIVE(self, id__snooper_callbacks__, id);
+    return Qnil;
+}
+
+static VALUE
+rg_m_current_event(G_GNUC_UNUSED VALUE self)
+{
+    return GEV2RVAL(gtk_get_current_event());
+}
+
+static VALUE
+rg_m_current_event_time(G_GNUC_UNUSED VALUE self)
+{
+    return INT2NUM(gtk_get_current_event_time());
+}
+
+static VALUE
+rg_m_current_event_state(G_GNUC_UNUSED VALUE self)
+{
+    GdkModifierType state;
+    gboolean ret = gtk_get_current_event_state(&state);
+    return ret ? GFLAGS2RVAL(state, GDK_TYPE_MODIFIER_TYPE) : Qnil;
+}
+
+static VALUE
+rg_m_get_event_widget(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
+{
+    VALUE event;
+    rb_scan_args(argc, argv, "01", &event);
+
+    return GOBJ2RVAL(gtk_get_event_widget(NIL_P(event) ? NULL :RVAL2GEV(event)));
+}
+
+static VALUE
+rg_m_propagate_event(G_GNUC_UNUSED VALUE self, VALUE widget, VALUE event)
+{
+    gtk_propagate_event(GTK_WIDGET(RVAL2GOBJ(widget)), RVAL2GEV(event));
+    return Qnil;
+}
+
+/* From Version Information */
+static VALUE
+rg_m_check_version(G_GNUC_UNUSED VALUE self, VALUE major, VALUE minor, VALUE micro)
+{
+    const gchar *ret;
+    ret = gtk_check_version(FIX2INT(major), FIX2INT(minor), FIX2INT(micro));
+    return ret ? CSTR2RVAL(ret) : Qnil;
+}
+
+static VALUE
+rg_m_check_version_p(G_GNUC_UNUSED VALUE self, VALUE major, VALUE minor, VALUE micro)
+{
+    const gchar *ret;
+    ret = gtk_check_version(FIX2INT(major), FIX2INT(minor), FIX2INT(micro));
+    return CBOOL2RVAL(ret == NULL);
+}
+
 /*
  * Init
  */
 void 
-Init_gtk_gtk()
+Init_gtk_gtk(void)
 {
     id_call = rb_intern("call");
     id__windows__ = rb_intern("__windows__");
+    id__quit_callbacks__ = rb_intern("__quit_callbacks__");
+    id__timeout_callbacks__ = rb_intern("__timeout_callbacks__");
+    id__idle_callbacks__ = rb_intern("__idle_callbacks__");
+    id__snooper_callbacks__ = rb_intern("__snooper_callbacks__");
+
+    RG_TARGET_NAMESPACE = rb_define_module("Gtk");
+    rb_ivar_set(RG_TARGET_NAMESPACE, id_relative_callbacks, Qnil);
+
+    rbgtk_eGtkInitError = rb_define_class_under(RG_TARGET_NAMESPACE, "InitError",
+                                                rb_eRuntimeError);
+
+    RG_DEF_MODFUNC_P(events_pending, 0);
 
-    mGtk = rb_define_module("Gtk");
-    rb_ivar_set(mGtk, id_relative_callbacks, Qnil);
+    RG_DEF_MODFUNC(set_locale, 0);
+    RG_DEF_MODFUNC(disable_setlocale, 0);
+    RG_DEF_MODFUNC(default_language, 0);
+    RG_DEF_MODFUNC(init, -1);
+    RG_DEF_MODFUNC(main, 0);
+    RG_DEF_MODFUNC(main_level, 0);
+    RG_DEF_MODFUNC(main_quit, 0);
+    RG_DEF_MODFUNC(main_iteration, 0);
+    RG_DEF_MODFUNC(main_iteration_do, 1);
+    RG_DEF_MODFUNC(main_do_event, 1);
+    RG_DEF_MODFUNC(grab_add, 1);
+    RG_DEF_MODFUNC(current, 0);
+    RG_DEF_MODFUNC(grab_remove, 1);
+    RG_DEF_MODFUNC(init_add, 0);
+    RG_DEF_MODFUNC(quit_add, 1);
+    RG_DEF_MODFUNC(quit_remove, 1);
 
-    rb_define_module_function(mGtk, "events_pending?", gtk_m_events_pending, 0);
+    RG_DEF_MODFUNC(timeout_add, 1);
+    RG_DEF_MODFUNC(timeout_remove, 1);
+    RG_DEF_MODFUNC(idle_add, 0);
+    RG_DEF_MODFUNC(idle_add_priority, 1);
+    RG_DEF_MODFUNC(idle_remove, 1);
+    RG_DEF_MODFUNC(key_snooper_install, 0);
+    RG_DEF_MODFUNC(key_snooper_remove, 1);
+    RG_DEF_MODFUNC(current_event, 0);
+    RG_DEF_MODFUNC(current_event_time, 0);
+    RG_DEF_MODFUNC(current_event_state, 0);
+    RG_DEF_MODFUNC(get_event_widget, -1);
+    RG_DEF_MODFUNC(propagate_event, 2);
+    RG_DEF_MODFUNC(check_version, 3);
+    RG_DEF_MODFUNC_P(check_version, 3);
 
+    rb_define_const(RG_TARGET_NAMESPACE, "PRIORITY_RESIZE", INT2FIX(GTK_PRIORITY_RESIZE));
 }