gtk3 2.2.5-x64-mingw32 → 3.0.0-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f2508a56f89405e67d945164c012dd8d4bc6948f
-  data.tar.gz: eb824dc82daa5db0bf313737c6e6a83ae5966365
+  metadata.gz: 68f5fe89fda2496abb0db878b88e51398f7fd03a
+  data.tar.gz: be37e36d87505e9df5ea486b66084c1267c796e9
 SHA512:
-  metadata.gz: 2f1d367903b7b78d7c60db6266773d883894c5e11a8563ce0619d7502cb760612f894033acbae0fbbbe3904de16d370ca5ea3e419fd0a3d72f3fe314272cbc4e
-  data.tar.gz: b077a284c9810937a053b95f1bd0a4cc18c30d12dcc13790908bad88ac953bd1ca71d0fc148d4323e728911e609402cb705a37ac9b3bf6b4e6bc6c10dc0cff38
+  metadata.gz: 7101c7139306b9e661c58ffe9302ad07286f9dc7053d39503547c1f1b690c526199fc926acc7f5e8eed785a12d29c2f98c4a323a1157696bc76a75c5b03bf744
+  data.tar.gz: e74038a4ca34391eb0b44a26774e53f37c35be5c9917eaef3b70082f096a8dd9fd33473f1fac86a99bb2921c270416035b5dfd0fa1eafec231fe4ee99d906160

data/Rakefile

@@ -13,6 +13,7 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
     "pango",
     "gdk_pixbuf2",
     "gdk3",
+    "gobject-introspection",
   ]
   package.windows.packages = []
   package.windows.dependencies = []

data/ext/gtk3/depend

@@ -1,8 +1,3 @@
-install-so: install-headers
-install-headers:
-	$(INSTALL_DATA) $(srcdir)/rbgtk3.h $(RUBYARCHDIR)
-	$(INSTALL_DATA) $(srcdir)/rbgtk3conversions.h $(RUBYARCHDIR)
-
 install: install-pc
 install-pc:
 	if test -n "$(pkgconfigdir)"; then			\

data/ext/gtk3/extconf.rb

@@ -1,20 +1,33 @@
-=begin
-extconf.rb for Ruby/GTK extention library
-=end
-
-require 'pathname'
-
-source_dir = Pathname(__FILE__).dirname
-base_dir = source_dir.parent.parent.expand_path
-top_dir = base_dir.parent.expand_path
+#!/usr/bin/env ruby
+#
+# Copyright (C) 2015  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
+
+require "pathname"
+
+base_dir = Pathname(__FILE__).dirname.parent.parent.expand_path
+top_dir = base_dir.parent
 top_build_dir = Pathname(".").parent.parent.parent.expand_path
 
-mkmf_gnome2_dir = top_dir + "glib2" + 'lib'
+mkmf_gnome2_dir = top_dir + "glib2" + "lib"
 version_suffix = ""
 unless mkmf_gnome2_dir.exist?
-  if /(-\d+\.\d+\.\d+)(?:\.\d+)?\z/ =~ base_dir.basename.to_s
+  if /(-\d+\.\d+\.\d+)\z/ =~ base_dir.basename.to_s
     version_suffix = $1
-    mkmf_gnome2_dir = top_dir + "glib2#{version_suffix}" + 'lib'
+    mkmf_gnome2_dir = top_dir + "glib2#{version_suffix}" + "lib"
   end
 end
 
@@ -23,20 +36,21 @@ $LOAD_PATH.unshift(mkmf_gnome2_dir.to_s)
 module_name = "gtk3"
 package_id = "gtk+-3.0"
 
-begin
-  require 'mkmf-gnome2'
-rescue LoadError
-  require 'rubygems'
-  gem 'glib2'
-  require 'mkmf-gnome2'
-end
-
-have_func("rb_errinfo")
-
-["glib2", "cairo-gobject", "atk", "pango", "gdk_pixbuf2", "gdk3"].each do |package|
-  depended_module_name = package.gsub(/-/, "_")
+require "mkmf-gnome2"
+
+depended_packages = [
+  "glib2",
+  "gobject-introspection",
+  "cairo-gobject",
+  "atk",
+  "pango",
+  "gdk_pixbuf2",
+  "gdk3",
+].each do |package|
   directory = "#{package}#{version_suffix}"
-  build_dir = "#{directory}/tmp/#{RUBY_PLATFORM}/#{depended_module_name}/#{RUBY_VERSION}"
+  build_base_path = "#{directory}/tmp/#{RUBY_PLATFORM}"
+  package_library_name = package.gsub(/-/, "_")
+  build_dir = "#{build_base_path}/#{package_library_name}/#{RUBY_VERSION}"
   add_depend_package(package, "#{directory}/ext/#{package}",
                      top_dir.to_s,
                      :top_build_dir => top_build_dir.to_s,
@@ -51,41 +65,17 @@ setup_windows(module_name, base_dir)
 
 unless required_pkg_config_package(package_id,
                                    :debian => "libgtk-3-dev",
-                                   :fedora => "gtk3-devel",
+                                   :redhat => "gtk3-devel",
                                    :homebrew => "gtk+3",
                                    :macports => "gtk3")
   exit(false)
 end
 
-have_header("st.h")
-have_header("ruby/st.h")
-
-STDOUT.print("checking for targets... ")
-STDOUT.flush
-targets = PKGConfig.variable(package_id, "targets").split(/\s+/)
-STDOUT.print(targets.join(" "), "\n")
-
-gtk_header = "gtk/gtk.h"
-have_func('gtk_plug_get_type', gtk_header)
-have_func('gtk_socket_get_type', gtk_header)
-have_func('pango_render_part_get_type', gtk_header)
-have_header('gtk/gtkfilesystem.h') do |src|
-  "#define GTK_FILE_SYSTEM_ENABLE_UNSUPPORTED\n#{src}"
-end
-
-xlib_header = "X11/Xlib.h"
-if targets.include?("x11") and have_header('X11/Xlib.h') and have_library("X11")
-  have_func("XReadBitmapFileData", xlib_header)
-  have_func("XGetErrorText", xlib_header)
-end
-
-if !targets.include?("win32") and PKGConfig.have_package('gtk+-unix-print-3.0')
-  $defs.push("-DHAVE_GTK_UNIX_PRINT")
+unless PKGConfig.have_package("gobject-introspection-1.0")
+  exit(false)
 end
 
-create_pkg_config_file("Ruby/GTK3", package_id, ruby_gnome2_version)
-
-ensure_objs
+create_pkg_config_file("Ruby/GTK3", package_id)
 
 $defs << "-DRUBY_GTK3_COMPILATION"
 create_makefile(module_name)

data/ext/gtk3/rb-gtk3-container.c

@@ -0,0 +1,159 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2015  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-gtk3-private.h"
+
+#define RG_TARGET_NAMESPACE cContainer
+#define _SELF(self) (RVAL2GTKCONTAINER(self))
+
+static GQuark q_ruby_setter;
+static GQuark q_ruby_getter;
+
+static void rb_gtk3_container_mark(gpointer object);
+
+static void
+rb_gtk3_container_mark_callback(GtkWidget *widget,
+                                G_GNUC_UNUSED gpointer data)
+{
+    if (rbgobj_gc_mark_instance(widget))
+        return;
+
+    if (GTK_IS_CONTAINER(widget))
+        rb_gtk3_container_mark(widget);
+}
+
+static void
+rb_gtk3_container_mark(gpointer object)
+{
+    gtk_container_forall(GTK_CONTAINER(object),
+                         rb_gtk3_container_mark_callback,
+                         NULL);
+}
+
+/* FIXME: use rb_protect */
+static void
+get_child_prop_func(GtkContainer *container,
+                    GtkWidget *child,
+                    G_GNUC_UNUSED guint property_id,
+                    GValue *value,
+                    GParamSpec *pspec)
+{
+    ID ruby_getter = (ID)g_param_spec_get_qdata(pspec, q_ruby_getter);
+    if (!ruby_getter) {
+        gchar *name = g_strconcat("get_", g_param_spec_get_name(pspec), NULL);
+        gchar *p;
+        for (p = name; *p; p++) {
+          if (*p == '-')
+            *p = '_';
+        }
+        ruby_getter = rb_intern(name);
+        g_param_spec_set_qdata(pspec, q_ruby_getter, (gpointer)ruby_getter);
+        g_free(name);
+    }
+
+    {
+        VALUE ret = rb_funcall(GOBJ2RVAL(container), ruby_getter, 1, GOBJ2RVAL(child));
+        rbgobj_rvalue_to_gvalue(ret, value);
+    }
+}
+
+/* FIXME: use rb_protect */
+static void
+set_child_prop_func(GtkContainer *container,
+                    GtkWidget *child,
+                    G_GNUC_UNUSED guint property_id,
+                    const GValue *value,
+                    GParamSpec *pspec)
+{
+    ID ruby_setter = (ID)g_param_spec_get_qdata(pspec, q_ruby_setter);
+    if (!ruby_setter) {
+        gchar *name = g_strconcat("set_", g_param_spec_get_name(pspec), NULL);
+        gchar *p;
+        for (p = name; *p; p++) {
+          if (*p == '-')
+            *p = '_';
+        }
+        ruby_setter = rb_intern(name);
+        g_param_spec_set_qdata(pspec, q_ruby_setter, (gpointer)ruby_setter);
+        g_free(name);
+    }
+
+    rb_funcall(GOBJ2RVAL(container), ruby_setter,
+               2,
+               GOBJ2RVAL(child), GVAL2RVAL(value));
+}
+
+static void
+class_init_func(gpointer g_class, gpointer class_data)
+{
+    GtkContainerClass *g_container_class = GTK_CONTAINER_CLASS(g_class);
+
+    rbgobj_class_init_func(g_class, class_data);
+
+    g_container_class->set_child_property = set_child_prop_func;
+    g_container_class->get_child_property = get_child_prop_func;
+
+    rbgtk3_class_init_func(g_class, class_data);
+}
+
+static VALUE
+rg_initialize(int argc, VALUE *argv, VALUE self)
+{
+    rb_call_super(argc, argv);
+    rbgtk3_initialize(self);
+    return Qnil;
+}
+
+static VALUE
+rg_s_type_register(int argc, VALUE *argv, VALUE klass)
+{
+    VALUE type_name;
+
+    rb_scan_args(argc, argv, "01", &type_name);
+
+    rbgobj_register_type(klass, type_name, class_init_func);
+
+    {
+        VALUE initialize_module;
+        initialize_module = rb_define_module_under(klass, "ContainerHook");
+        rbg_define_method(initialize_module,
+                          "initialize", rg_initialize, -1);
+        rb_include_module(klass, initialize_module);
+    }
+
+    return Qnil;
+}
+
+void
+rbgtk3_container_init(void)
+{
+    VALUE mGtk;
+    VALUE RG_TARGET_NAMESPACE;
+
+    q_ruby_getter = g_quark_from_static_string("__ruby_getter");
+    q_ruby_setter = g_quark_from_static_string("__ruby_setter");
+
+    mGtk = rb_const_get(rb_cObject, rb_intern("Gtk"));
+    RG_TARGET_NAMESPACE = rb_const_get(mGtk, rb_intern("Container"));
+
+    rbgobj_register_mark_func(GTK_TYPE_CONTAINER, rb_gtk3_container_mark);
+
+    RG_DEF_SMETHOD(type_register, -1);
+}

data/ext/gtk3/{rbgtk3util.h → rb-gtk3-private.h}

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2015  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
@@ -18,15 +18,15 @@
  *  MA  02110-1301  USA
  */
 
-#ifndef __RBGTK3UTIL_H__
-#define __RBGTK3UTIL_H__
+#ifndef RB_GTK3_PRIVATE_H
+#define RB_GTK3_PRIVATE_H
 
-G_BEGIN_DECLS
+#include "rb-gtk3.h"
 
-typedef VALUE (*RBGTKAddButtonFunc)(VALUE self, VALUE button_text, VALUE response_id);
+G_GNUC_INTERNAL void rbgtk3_class_init_func(gpointer g_class, gpointer class_data);
+G_GNUC_INTERNAL void rbgtk3_initialize(VALUE self);
 
-G_GNUC_INTERNAL VALUE rbgtk_add_buttons(VALUE self, VALUE buttons, RBGTKAddButtonFunc add_button);
+G_GNUC_INTERNAL void rbgtk3_container_init(void);
+G_GNUC_INTERNAL void rbgtk3_widget_init(void);
 
-G_END_DECLS
-
-#endif /* __RBGTK3UTIL_H__ */
+#endif

data/ext/gtk3/rb-gtk3-widget.c

@@ -0,0 +1,71 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2015  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-gtk3-private.h"
+
+#define RG_TARGET_NAMESPACE cWidget
+#define _SELF(self) (RVAL2GTKWIDGET(self))
+
+static void
+class_init_func(gpointer g_class, gpointer class_data)
+{
+    rbgobj_class_init_func(g_class, class_data);
+    rbgtk3_class_init_func(g_class, class_data);
+}
+
+static VALUE
+rg_initialize(int argc, VALUE *argv, VALUE self)
+{
+    rb_call_super(argc, argv);
+    rbgtk3_initialize(self);
+    return Qnil;
+}
+
+static VALUE
+rg_s_type_register(int argc, VALUE *argv, VALUE klass)
+{
+    VALUE type_name;
+
+    rb_scan_args(argc, argv, "01", &type_name);
+
+    rbgobj_register_type(klass, type_name, class_init_func);
+
+    {
+        VALUE initialize_module;
+        initialize_module = rb_define_module_under(klass, "WidgetHook");
+        rbg_define_method(initialize_module,
+                          "initialize", rg_initialize, -1);
+        rb_include_module(klass, initialize_module);
+    }
+
+    return Qnil;
+}
+
+void
+rbgtk3_widget_init(void)
+{
+    VALUE mGtk;
+    VALUE RG_TARGET_NAMESPACE;
+
+    mGtk = rb_const_get(rb_cObject, rb_intern("Gtk"));
+    RG_TARGET_NAMESPACE = rb_const_get(mGtk, rb_intern("Widget"));
+
+    RG_DEF_SMETHOD(type_register, -1);
+}

data/ext/gtk3/rb-gtk3.c

@@ -0,0 +1,407 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2015  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-gtk3-private.h"
+
+/*
+#if GTK_CHECK_VERSION(3, 10, 0)
+#    define RB_GTK_ACTION_IS_DEPRECATED
+#    define RB_GTK_ACTION_GROUP_IS_DEPRECATED
+#    define RB_GTK_UI_MANAGER_IS_DEPRECATED
+#endif
+*/
+
+static gboolean
+name_equal(GIArgInfo *info, const gchar *target_name)
+{
+    GITypeInfo type_info;
+    GIBaseInfo *interface_info;
+    const gchar *namespace;
+    const gchar *name;
+    gboolean equal_name_p = FALSE;
+
+    g_arg_info_load_type(info, &type_info);
+    interface_info = g_type_info_get_interface(&type_info);
+    namespace = g_base_info_get_namespace(interface_info);
+    name = g_base_info_get_name(interface_info);
+    if (strcmp(namespace, "Gtk") == 0 && strcmp(name, target_name) == 0) {
+        equal_name_p = TRUE;
+    }
+    g_base_info_unref(interface_info);
+
+    return equal_name_p;
+}
+
+static void
+rb_gtk3_callback_callback(GtkWidget *widget, gpointer user_data)
+{
+    RBGICallbackData *callback_data = user_data;
+    ID id_call;
+
+    CONST_ID(id_call, "call");
+    rb_funcall(callback_data->rb_callback, id_call, 1,
+               GOBJ2RVAL(widget));
+}
+
+static gint
+rb_gtk3_assistant_page_func_callback(gint current_page, gpointer user_data)
+{
+    RBGICallbackData *callback_data = user_data;
+    ID id_call;
+    VALUE rb_next_page;
+
+    CONST_ID(id_call, "call");
+    rb_next_page = rb_funcall(callback_data->rb_callback, id_call, 1,
+                              INT2NUM(current_page));
+    return NUM2INT(rb_next_page);
+}
+
+static void
+rb_gtk3_builder_connect_func_callback(GtkBuilder *builder,
+                                      GObject *object,
+                                      const gchar *signal_name,
+                                      const gchar *handler_name,
+                                      GObject *connect_object,
+                                      GConnectFlags flags,
+                                      gpointer user_data)
+{
+    RBGICallbackData *callback_data = user_data;
+    ID id___connect_signals__;
+    VALUE rb_object;
+
+    CONST_ID(id___connect_signals__, "__connect_signals__");
+    rb_object = GOBJ2RVAL(object);
+    G_RELATIVE(rb_object, callback_data->rb_callback);
+    rb_funcall(GOBJ2RVAL(builder), id___connect_signals__, 6,
+               callback_data->rb_callback,
+               rb_object,
+               CSTR2RVAL(signal_name),
+               CSTR2RVAL(handler_name),
+               GOBJ2RVAL(connect_object),
+               GCONNECTFLAGS2RVAL(flags));
+}
+
+static const gchar *
+rb_gtk3_translate_func_callback(const gchar *path,
+                                gpointer user_data)
+{
+    RBGICallbackData *callback_data = user_data;
+    ID id_call;
+    VALUE rb_translated;
+
+    CONST_ID(id_call, "call");
+    rb_translated = rb_funcall(callback_data->rb_callback,
+                               id_call,
+                               1,
+                               CSTR2RVAL(path));
+    return RVAL2CSTR(rb_translated);
+}
+
+static void
+rb_gtk3_tree_cell_data_func_callback(GtkTreeViewColumn *column,
+                                     GtkCellRenderer *cell,
+                                     GtkTreeModel *model,
+                                     GtkTreeIter *iter,
+                                     gpointer user_data)
+{
+    RBGICallbackData *callback_data = user_data;
+    ID id_set_model;
+    ID id_call;
+    VALUE rb_model;
+    VALUE rb_iter;
+
+    CONST_ID(id_set_model, "model=");
+    rb_model = GOBJ2RVAL(model);
+    rb_iter = BOXED2RVAL(iter, GTK_TYPE_TREE_ITER);
+    rb_funcall(rb_iter, id_set_model, 1, rb_model);
+
+    CONST_ID(id_call, "call");
+    rb_funcall(callback_data->rb_callback,
+               id_call,
+               4,
+               GOBJ2RVAL(column),
+               GOBJ2RVAL(cell),
+               rb_model,
+               rb_iter);
+}
+
+static void
+rb_gtk3_tree_model_filter_modify_func_callback(GtkTreeModel *model,
+                                               GtkTreeIter *iter,
+                                               GValue *value,
+                                               gint column,
+                                               gpointer user_data)
+{
+    RBGICallbackData *callback_data = user_data;
+    ID id_set_model;
+    ID id_call;
+    VALUE rb_model;
+    VALUE rb_iter;
+    VALUE rb_value;
+    VALUE rb_column;
+
+    CONST_ID(id_set_model, "model=");
+    rb_model = GOBJ2RVAL(model);
+    rb_iter = BOXED2RVAL(iter, GTK_TYPE_TREE_ITER);
+    rb_funcall(rb_iter, id_set_model, 1, rb_model);
+    rb_column = INT2NUM(column);
+
+    CONST_ID(id_call, "call");
+    rb_value = rb_funcall(callback_data->rb_callback,
+                          id_call,
+                          3,
+                          rb_model,
+                          rb_iter,
+                          rb_column);
+    rbgobj_rvalue_to_gvalue(rb_value, value);
+}
+
+static gboolean
+rb_gtk3_tree_model_filter_visible_func_callback(GtkTreeModel *model,
+                                                GtkTreeIter *iter,
+                                                gpointer user_data)
+{
+    RBGICallbackData *callback_data = user_data;
+    ID id_set_model;
+    ID id_call;
+    VALUE rb_model;
+    VALUE rb_iter;
+    VALUE rb_visible;
+    gboolean visible = FALSE;
+
+    CONST_ID(id_set_model, "model=");
+    rb_model = GOBJ2RVAL(model);
+    rb_iter = BOXED2RVAL(iter, GTK_TYPE_TREE_ITER);
+    rb_funcall(rb_iter, id_set_model, 1, rb_model);
+
+    CONST_ID(id_call, "call");
+    rb_visible = rb_funcall(callback_data->rb_callback,
+                            id_call,
+                            2,
+                            rb_model,
+                            rb_iter);
+    visible = RVAL2CBOOL(rb_visible);
+
+    return visible;
+}
+
+static gboolean
+rb_gtk3_tree_model_foreach_func_callback(GtkTreeModel *model,
+                                         GtkTreePath *path,
+                                         GtkTreeIter *iter,
+                                         gpointer user_data)
+{
+    RBGICallbackData *callback_data = user_data;
+    ID id_set_model;
+    ID id_call;
+    VALUE rb_model;
+    VALUE rb_iter;
+    gboolean stop = FALSE;
+
+    CONST_ID(id_set_model, "model=");
+    rb_model = GOBJ2RVAL(model);
+    rb_iter = BOXED2RVAL(iter, GTK_TYPE_TREE_ITER);
+    rb_funcall(rb_iter, id_set_model, 1, rb_model);
+
+    CONST_ID(id_call, "call");
+    rb_funcall(callback_data->rb_callback,
+               id_call,
+               3,
+               rb_model,
+               BOXED2RVAL(path, GTK_TYPE_TREE_PATH),
+               rb_iter);
+
+    return stop;
+}
+
+static void
+rb_gtk3_tree_selection_foreach_func_callback(GtkTreeModel *model,
+                                             GtkTreePath *path,
+                                             GtkTreeIter *iter,
+                                             gpointer user_data)
+{
+    RBGICallbackData *callback_data = user_data;
+    ID id_set_model;
+    ID id_call;
+    VALUE rb_model;
+    VALUE rb_iter;
+
+    CONST_ID(id_set_model, "model=");
+    rb_model = GOBJ2RVAL(model);
+    rb_iter = BOXED2RVAL(iter, GTK_TYPE_TREE_ITER);
+    rb_funcall(rb_iter, id_set_model, 1, rb_model);
+
+    CONST_ID(id_call, "call");
+    rb_funcall(callback_data->rb_callback,
+               id_call,
+               3,
+               rb_model,
+               BOXED2RVAL(path, GTK_TYPE_TREE_PATH),
+               rb_iter);
+}
+
+static void
+rb_gtk3_tree_view_mapping_func_callback(GtkTreeView *tree_view,
+                                        GtkTreePath *path,
+                                        gpointer user_data)
+{
+    RBGICallbackData *callback_data = user_data;
+    ID id_call;
+
+    CONST_ID(id_call, "call");
+    rb_funcall(callback_data->rb_callback,
+               id_call,
+               2,
+               GOBJ2RVAL(tree_view),
+               BOXED2RVAL(path, GTK_TYPE_TREE_PATH));
+}
+
+static gpointer
+rb_gtk3_callback_finder(GIArgInfo *info)
+{
+    if (name_equal(info, "Callback")) {
+        return rb_gtk3_callback_callback;
+    } else if (name_equal(info, "AssistantPageFunc")) {
+        return rb_gtk3_assistant_page_func_callback;
+    } else if (name_equal(info, "BuilderConnectFunc")) {
+        return rb_gtk3_builder_connect_func_callback;
+    } else if (name_equal(info, "TranslateFunc")) {
+        return rb_gtk3_translate_func_callback;
+    } else if (name_equal(info, "TreeCellDataFunc")) {
+        return rb_gtk3_tree_cell_data_func_callback;
+    } else if (name_equal(info, "TreeModelFilterModifyFunc")) {
+        return rb_gtk3_tree_model_filter_modify_func_callback;
+    } else if (name_equal(info, "TreeModelFilterVisibleFunc")) {
+        return rb_gtk3_tree_model_filter_visible_func_callback;
+    } else if (name_equal(info, "TreeModelForeachFunc")) {
+        return rb_gtk3_tree_model_foreach_func_callback;
+    } else if (name_equal(info, "TreeSelectionForeachFunc")) {
+        return rb_gtk3_tree_selection_foreach_func_callback;
+    } else if (name_equal(info, "TreeViewMappingFunc")) {
+        return rb_gtk3_tree_view_mapping_func_callback;
+    } else {
+        return NULL;
+    }
+}
+
+#ifndef RB_GTK_ACTION_IS_DEPRECATED
+static void
+rb_gtk3_action_mark(gpointer object)
+{
+    GtkAction *action;
+    GSList *proxies, *node;
+
+    action = GTK_ACTION(object);
+    proxies = gtk_action_get_proxies(action);
+    for (node = proxies; node; node = g_slist_next(node)) {
+        GtkWidget *proxy = node->data;
+        rbgobj_gc_mark_instance(proxy);
+    }
+}
+#endif
+
+static void
+rb_gtk3_builder_mark(gpointer object)
+{
+    GtkBuilder *builder;
+    GSList *objects;
+
+    builder = GTK_BUILDER(object);
+    objects = gtk_builder_get_objects(builder);
+    g_slist_foreach(objects, (GFunc)rbgobj_gc_mark_instance, NULL);
+    g_slist_free(objects);
+}
+
+#ifndef RB_GTK_ACTION_GROUP_IS_DEPRECATED
+static void
+rb_gtk3_action_group_mark(gpointer object)
+{
+    GtkActionGroup *group;
+    GList *actions, *node;
+
+    group = GTK_ACTION_GROUP(object);
+    actions = gtk_action_group_list_actions(group);
+    for (node = actions; node; node = g_list_next(node)) {
+        GtkWidget *action = node->data;
+        rbgobj_gc_mark_instance(action);
+    }
+    g_list_free(actions);
+}
+#endif
+
+#ifndef RB_GTK_UI_MANAGER_IS_DEPRECATED
+static void
+rb_gtk3_ui_manager_mark(gpointer object)
+{
+    GtkUIManager *manager;
+    GList *action_groups, *node;
+
+    manager = GTK_UI_MANAGER(object);
+    action_groups = gtk_ui_manager_get_action_groups(manager);
+    for (node = action_groups; node; node = g_list_next(node)) {
+        GtkWidget *action_group = node->data;
+        rbgobj_gc_mark_instance(action_group);
+    }
+
+    rbgobj_gc_mark_instance(gtk_ui_manager_get_accel_group(manager));
+}
+#endif
+
+void
+rbgtk3_class_init_func(gpointer g_class, G_GNUC_UNUSED gpointer class_data)
+{
+    VALUE rb_class;
+
+    rb_class = GTYPE2CLASS(G_TYPE_FROM_CLASS(g_class));
+    rb_funcall(rb_class, rb_intern("init"), 0);
+}
+
+void
+rbgtk3_initialize(VALUE self)
+{
+    GObject *object;
+
+    object = RVAL2GOBJ(self);
+    g_object_ref_sink(object);
+
+    rb_funcall(self, rb_intern("initialize_post"), 0);
+}
+
+void
+Init_gtk3(void)
+{
+    rb_gi_callback_register_finder(rb_gtk3_callback_finder);
+
+#ifndef RB_GTK_ACTION_IS_DEPRECATED
+    rbgobj_register_mark_func(GTK_TYPE_ACTION, rb_gtk3_action_mark);
+#endif
+    rbgobj_register_mark_func(GTK_TYPE_BUILDER, rb_gtk3_builder_mark);
+#ifndef RB_GTK_ACTION_GROUP_IS_DEPRECATED
+    rbgobj_register_mark_func(GTK_TYPE_ACTION_GROUP, rb_gtk3_action_group_mark);
+#endif
+#ifndef RB_GTK_UI_MANAGER_IS_DEPRECATED
+    rbgobj_register_mark_func(GTK_TYPE_UI_MANAGER, rb_gtk3_ui_manager_mark);
+#endif
+
+    rbgtk3_container_init();
+    rbgtk3_widget_init();
+
+    rbgobj_boxed_not_copy_obj(GTK_TYPE_SELECTION_DATA);
+}