gtk3 2.2.4-x64-mingw32

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 71fd94e67d7dfa13fd56548df98b986fba3698bd
+  data.tar.gz: f13c15eeafba80b8588ace89c8399753199f715f
+SHA512:
+  metadata.gz: 5f2726c70c22b9a2c0a3474829549779af281ce664bc0fd1256aeb8be5facd3958705b5c680ffb471475cf7e8f1ff576f7c9ed8a11506509d7a1d0a41217c7b2
+  data.tar.gz: 87d8b3b2cc4f233ada4788fc3c6c03a62e1145652b5ab0c563d1da26f9706cc6ff30bc5e1f72aed2403e818dea2185d59a88b8cbe38b9ba06c85958f242dfa4c

data/Rakefile

@@ -0,0 +1,20 @@
+# -*- ruby -*-
+
+$LOAD_PATH.unshift("./../glib2/lib")
+require 'gnome2/rake/package-task'
+
+package_task = GNOME2::Rake::PackageTask.new do |package|
+  package.summary = "Ruby/GTK3 is a Ruby binding of GTK+-3.x."
+  package.description = "Ruby/GTK3 is a Ruby binding of GTK+-3.x."
+  package.dependency.gem.runtime = [
+    "glib2",
+    "gio2",
+    "atk",
+    "pango",
+    "gdk_pixbuf2",
+    "gdk3",
+  ]
+  package.windows.packages = []
+  package.windows.dependencies = []
+end
+package_task.define

data/ext/gtk3/conversions.c

@@ -0,0 +1,34 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2012  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 "rbgtk3private.h"
+
+static VALUE
+cairo_context_gvalue2rvalue(const GValue *value)
+{
+    return CRCONTEXT2RVAL(g_value_get_boxed(value));
+}
+
+void
+Init_conversions(void)
+{
+    rbgobj_register_g2r_func(CAIRO_GOBJECT_TYPE_CONTEXT, cairo_context_gvalue2rvalue);
+}
+

data/ext/gtk3/depend

@@ -0,0 +1,11 @@
+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			\
+	  $(MAKEDIRS) $(pkgconfigdir);				\
+	  $(INSTALL_DATA) ruby-gtk3.pc $(pkgconfigdir);		\
+	fi

data/ext/gtk3/extconf.rb

@@ -0,0 +1,99 @@
+=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
+top_build_dir = Pathname(".").parent.parent.parent.expand_path
+
+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
+    version_suffix = $1
+    mkmf_gnome2_dir = top_dir + "glib2#{version_suffix}" + 'lib'
+  end
+end
+
+$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(/-/, "_")
+  directory = "#{package}#{version_suffix}"
+  build_dir = "#{directory}/tmp/#{RUBY_PLATFORM}/#{depended_module_name}/#{RUBY_VERSION}"
+  add_depend_package(package, "#{directory}/ext/#{package}",
+                     top_dir.to_s,
+                     :top_build_dir => top_build_dir.to_s,
+                     :target_build_dir => build_dir)
+end
+
+unless check_cairo(:top_dir => top_dir)
+  exit(false)
+end
+
+setup_windows(module_name, base_dir)
+
+unless required_pkg_config_package(package_id,
+                                   :debian => "libgtk-3-dev",
+                                   :fedora => "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")
+end
+
+create_pkg_config_file("Ruby/GTK3", package_id, ruby_gnome2_version)
+
+ensure_objs
+
+$defs << "-DRUBY_GTK3_COMPILATION"
+create_makefile(module_name)
+
+pkg_config_dir = with_config("pkg-config-dir")
+if pkg_config_dir.is_a?(String)
+  File.open("Makefile", "ab") do |makefile|
+    makefile.puts
+    makefile.puts("pkgconfigdir=#{pkg_config_dir}")
+  end
+end

data/ext/gtk3/gtk3.def

@@ -0,0 +1,10 @@
+EXPORTS
+    Init_gtk3
+    rbgtk_initialize_gtkobject
+    gtk_accel_group_entry_get_type
+    gtk_accel_key_get_type
+    gtk_allocation_get_type
+    gtk_bindingset_get_type
+    gtk_recent_data_get_type
+    gtk_recent_filter_info_get_type
+    gtk_text_appearance_get_type

data/ext/gtk3/init.c

@@ -0,0 +1,34 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  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 "rbgtk3private.h"
+
+extern void Init_gtk3(void);
+
+void
+Init_gtk3(void)
+{
+    Init_gtk();
+    Init_conversions();
+}

data/ext/gtk3/rbgtk-about-dialog.c

@@ -0,0 +1,113 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE cAboutDialog
+#define _SELF(self) (RVAL2GTKABOUTDIALOG(self))
+
+static VALUE
+rg_initialize(VALUE self)
+{
+    RBGTK_INITIALIZE(self, gtk_about_dialog_new());
+    return Qnil;
+}
+
+typedef struct {
+    const char *name;
+    gpointer value;
+} prop_data;
+
+#define ABOUT_PROP_NUM (15)
+
+static VALUE
+rg_s_show(VALUE self, VALUE parent, VALUE props)
+{
+    int i;
+    VALUE ary;
+    prop_data pd[ABOUT_PROP_NUM];
+
+    Check_Type(props, T_HASH);
+
+    ary = rb_funcall(props, rb_intern("to_a"), 0);
+
+    if (RARRAY_LEN(ary) > ABOUT_PROP_NUM)
+        rb_raise(rb_eArgError, "Too many args.");
+
+    for (i = 0; i < ABOUT_PROP_NUM; i++){
+        pd[i].name = (const char*)NULL;
+        pd[i].value = (gpointer)NULL;
+    }
+    for (i = 0; i < RARRAY_LEN(ary); i++){
+        if (TYPE(RARRAY_PTR(RARRAY_PTR(ary)[i])[0]) == T_SYMBOL){
+            pd[i].name = rb_id2name(SYM2ID(RARRAY_PTR(RARRAY_PTR(ary)[i])[0]));
+        } else {
+            pd[i].name = RVAL2CSTR(RARRAY_PTR(RARRAY_PTR(ary)[i])[0]);
+        }
+        if (strncmp(pd[i].name, "artists", strlen("artists")) == 0||
+            strncmp(pd[i].name, "authors", strlen("authors")) == 0||
+            strncmp(pd[i].name, "documenters", strlen("documenters")) == 0){
+            GValue gval = G_VALUE_INIT;
+            g_value_init(&gval, G_TYPE_STRV);
+            rbgobj_rvalue_to_gvalue(RARRAY_PTR(RARRAY_PTR(ary)[i])[1], &gval);
+
+            pd[i].value = g_boxed_copy(G_TYPE_STRV, g_value_get_boxed(&gval));
+        } else if (strncmp(pd[i].name, "logo", strlen("logo")) == 0 &&
+                   strlen(pd[i].name) == strlen("logo")){
+            pd[i].value = g_object_ref(RVAL2GOBJ(RARRAY_PTR(RARRAY_PTR(ary)[i])[1]));
+        } else if (strncmp(pd[i].name, "wrap_license", strlen("wrap_license")) == 0){
+            pd[i].value = GINT_TO_POINTER(RVAL2CBOOL(RARRAY_PTR(RARRAY_PTR(ary)[i])[1]));
+        } else if (strncmp(pd[i].name, "license_type", strlen("license_type")) == 0){
+            pd[i].value = GINT_TO_POINTER(RVAL2GTKLICENSE(RARRAY_PTR(RARRAY_PTR(ary)[i])[1]));
+        } else {
+            pd[i].value = g_strdup(RVAL2CSTR(RARRAY_PTR(RARRAY_PTR(ary)[i])[1]));
+        }
+    }
+
+    gtk_show_about_dialog(RVAL2GTKWINDOW(parent), 
+                          pd[0].name, pd[0].value,
+                          pd[1].name, pd[1].value,
+                          pd[2].name, pd[2].value,
+                          pd[3].name, pd[3].value,
+                          pd[4].name, pd[4].value,
+                          pd[5].name, pd[5].value,
+                          pd[6].name, pd[6].value,
+                          pd[7].name, pd[7].value,
+                          pd[8].name, pd[8].value,
+                          pd[9].name, pd[9].value,
+                          pd[10].name, pd[10].value,
+                          pd[11].name, pd[11].value,
+                          pd[12].name, pd[12].value,
+                          pd[13].name, pd[13].value,
+                          pd[14].name, pd[14].value,
+                          NULL);
+    return self;
+}
+
+void
+Init_gtk_aboutdialog(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_ABOUT_DIALOG, "AboutDialog", mGtk);
+    G_DEF_CLASS(GTK_TYPE_LICENSE, "License", RG_TARGET_NAMESPACE);
+
+    RG_DEF_METHOD(initialize, 0);
+    RG_DEF_SMETHOD(show, 2);
+}

data/ext/gtk3/rbgtk-accel-group-entry.c

@@ -0,0 +1,94 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011-2013  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003 OGASAWARA, Takeshi
+ *
+ *  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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE cAccelGroupEntry
+#define _SELF(s) (RVAL2GTKACCELGROUPENTRY(s))
+
+static GtkAccelGroupEntry *
+agentry_copy(const GtkAccelGroupEntry *agentry)
+{
+    GtkAccelGroupEntry *new_agentry;
+    g_return_val_if_fail (agentry != NULL, NULL);
+    new_agentry = g_new(GtkAccelGroupEntry, 1);
+    *new_agentry = *agentry;
+    return new_agentry;
+}
+
+GType
+gtk_accel_group_entry_get_type(void)
+{
+    static GType our_type = 0;
+    if(our_type == 0)
+        our_type = g_boxed_type_register_static("GtkAccelGroupEntry",
+                                                (GBoxedCopyFunc)agentry_copy,
+                                                (GBoxedFreeFunc)g_free);
+    return our_type;
+}
+
+/*
+struct _GtkAccelGroupEntry
+{
+  GtkAccelKey  key;
+  GClosure    *closure;
+  GQuark       accel_path_quark;
+};
+*/
+static VALUE
+rg_initialize(VALUE self)
+{
+    GtkAccelGroupEntry key;
+    memset(&key, 0, sizeof(GtkAccelGroupEntry));
+    G_INITIALIZE(self, g_boxed_copy(GTK_TYPE_ACCEL_GROUP_ENTRY, &key));
+    return Qnil;
+}
+
+static VALUE
+rg_accel_key(VALUE self)
+{
+    return GTKACCELKEY2RVAL(&_SELF(self)->key);
+}
+
+static VALUE
+rg_closure(VALUE self)
+{
+    return GCLOSURE2RVAL(_SELF(self)->closure);
+}
+
+static VALUE
+rg_accel_path(VALUE self)
+{
+    const gchar *quark_str = g_quark_to_string(_SELF(self)->accel_path_quark);
+    return quark_str ? CSTR2RVAL(quark_str) : Qnil;
+}
+
+void
+Init_gtk_accel_group_entry(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_ACCEL_GROUP_ENTRY, "AccelGroupEntry", mGtk);
+
+    RG_DEF_METHOD(initialize, 0);
+
+    RG_DEF_METHOD(accel_key, 0);
+    RG_DEF_METHOD(closure, 0);
+    RG_DEF_METHOD(accel_path, 0);
+}

data/ext/gtk3/rbgtk-accel-group.c

@@ -0,0 +1,199 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003 Ruby-GNOME2 Project Team
+ *  Copyright (C) 1998-2000 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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE cAccelGroup
+#define _SELF(w) RVAL2GTKACCELGROUP(w)
+#define RVAL2MOD(mods) (NIL_P(mods) ? 0 : RVAL2GDKMODIFIERTYPE(mods))
+
+static VALUE
+rg_initialize(VALUE self)
+{
+    G_INITIALIZE(self, gtk_accel_group_new());
+    return Qnil;
+}
+
+static VALUE
+rg_connect(int argc, VALUE *argv, VALUE self)
+{
+    VALUE key, mods, flags, path, closure;
+    GClosure *rclosure;
+
+    if (argc > 2){
+        rb_scan_args(argc, argv, "31", &key, &mods, &flags, &closure);
+        if (NIL_P(closure)){
+            rclosure = g_rclosure_new(rb_block_proc(), Qnil, NULL);
+        } else {
+            rclosure = RVAL2GCLOSURE(closure);
+        }
+        g_rclosure_attach(rclosure, self);
+        gtk_accel_group_connect(_SELF(self), NUM2UINT(key),
+                                RVAL2MOD(mods), 
+                                RVAL2GTKACCELFLAGS(flags),
+                                rclosure);
+    } else {
+        rb_scan_args(argc, argv, "11", &path, &closure);
+        if (NIL_P(closure)){
+            rclosure = g_rclosure_new(rb_block_proc(), Qnil, NULL);
+        } else {
+            rclosure = RVAL2GCLOSURE(closure);
+        }
+        g_rclosure_attach(rclosure, self);
+        gtk_accel_group_connect_by_path(_SELF(self), RVAL2CSTR(path), rclosure);
+    }
+    return self;
+}
+
+static VALUE
+rg_disconnect_key(VALUE self, VALUE key, VALUE mods)
+{
+    return CBOOL2RVAL(gtk_accel_group_disconnect_key(_SELF(self), NUM2UINT(key),
+                                                     RVAL2MOD(mods)));
+}
+
+static VALUE
+rg_query(VALUE self, VALUE key, VALUE mods)
+{
+    GtkAccelGroupEntry *entries;
+    guint n_entries;
+    guint cnt;
+    VALUE result;
+
+    entries = gtk_accel_group_query(_SELF(self), NUM2UINT(key),
+                                    RVAL2MOD(mods), &n_entries);
+    if(n_entries == 0){
+        return Qnil;
+    }
+    else{
+        result = rb_ary_new2(n_entries);
+        for(cnt=0; cnt<n_entries; cnt++, entries++)
+            rb_ary_push(result, GTKACCELGROUPENTRY2RVAL(entries));
+        return result;
+    }
+}
+
+static VALUE
+rg_disconnect(VALUE self, VALUE closure)
+{
+    return CBOOL2RVAL(gtk_accel_group_disconnect(_SELF(self),
+                                                 RVAL2GCLOSURE(closure)));
+}
+
+static VALUE
+rg_s_from_accel_closure(G_GNUC_UNUSED VALUE self, VALUE closure)
+{
+    return GOBJ2RVAL(gtk_accel_group_from_accel_closure(
+                         RVAL2GCLOSURE(closure)));
+}
+
+static gboolean
+gaccelgrp_find_func(GtkAccelKey *key, GClosure *closure, gpointer func)
+{
+    return RVAL2CBOOL(rb_funcall((VALUE)func, id_call, 2,
+                            GTKACCELKEY2RVAL(key),
+                            GCLOSURE2RVAL(closure)));
+}
+
+static VALUE
+rg_find(VALUE self)
+{
+    GtkAccelKey *result;
+    volatile VALUE func = rb_block_proc();
+
+    result = gtk_accel_group_find(_SELF(self),
+                                  (GtkAccelGroupFindFunc)gaccelgrp_find_func,
+                                  (gpointer)func);
+    return GTKACCELKEY2RVAL(result);
+}
+
+static VALUE
+rg_activate(VALUE self, VALUE accel_quark, VALUE acceleratable, VALUE accel_key, VALUE accel_mods)
+{
+    GQuark quark = 0;
+    if (TYPE(accel_quark) == T_STRING){
+        quark = g_quark_from_string(RVAL2CSTR(accel_quark));
+    } else {
+        quark = NUM2UINT(quark);
+    }
+    return CBOOL2RVAL(gtk_accel_group_activate(_SELF(self), quark, RVAL2GOBJ(acceleratable),
+                                               NUM2UINT(accel_key), RVAL2MOD(accel_mods)));
+}
+
+static VALUE
+_gaccelgrp_lock_ensure(VALUE self)
+{
+    gtk_accel_group_unlock(_SELF(self));
+    return Qnil;
+}
+
+static VALUE
+rg_lock(VALUE self)
+{
+    gtk_accel_group_lock(_SELF(self));
+    if (rb_block_given_p()){
+        rb_ensure(rb_yield, self, _gaccelgrp_lock_ensure , self);
+    }
+    return self;
+}
+
+static VALUE
+rg_unlock(VALUE self)
+{
+    gtk_accel_group_unlock(_SELF(self));
+    return self;
+}
+
+static VALUE
+rg_s_activate(G_GNUC_UNUSED VALUE self, VALUE obj, VALUE key, VALUE modtype)
+{
+    return CBOOL2RVAL(gtk_accel_groups_activate(RVAL2GOBJ(obj),
+                                                NUM2UINT(key),
+                                                RVAL2MOD(modtype)));
+}
+
+static VALUE
+rg_s_from_object(G_GNUC_UNUSED VALUE self, VALUE object)
+{
+    return GOBJGSLIST2RVAL(gtk_accel_groups_from_object(RVAL2GOBJ(object)));
+}
+
+void
+Init_gtk_accel_group(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_ACCEL_GROUP, "AccelGroup", mGtk);
+
+    RG_DEF_SMETHOD(activate, 3);
+    RG_DEF_SMETHOD(from_object, 1);
+    RG_DEF_SMETHOD(from_accel_closure, 1);
+    RG_DEF_METHOD(initialize, 0);
+    RG_DEF_METHOD(activate, 4);
+    RG_DEF_METHOD(lock, 0);
+    RG_DEF_METHOD(unlock, 0);
+    RG_DEF_METHOD(connect, -1);
+    RG_DEF_METHOD(disconnect, 1);
+    RG_DEF_METHOD(disconnect_key, 2);
+    RG_DEF_METHOD(query, 2);
+    RG_DEF_METHOD(find, 0);
+}