gtk3 0.0.1 → 1.2.0

data/ext/gtk3/rbgtk3util.c

@@ -0,0 +1,67 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  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"
+
+struct add_buttons_args {
+    VALUE self;
+    VALUE buttons;
+    RBGTKAddButtonFunc add_button;
+};
+
+static VALUE
+add_buttons_body(VALUE value)
+{
+    struct add_buttons_args *args = (struct add_buttons_args *)value;
+    VALUE button;
+    long i;
+    long n = RARRAY_LEN(args->buttons);
+
+    for (i = 0; i < n; i++) {
+        button = rb_ary_to_ary(RARRAY_PTR(args->buttons)[i]);
+
+        args->add_button(args->self, RARRAY_PTR(button)[0], RARRAY_PTR(button)[1]);
+    }
+
+    return args->self;
+}
+
+static VALUE
+add_buttons_ensure(VALUE value)
+{
+    g_object_thaw_notify(RVAL2GOBJ(((struct add_buttons_args *)value)->self));
+
+    return Qnil;
+}
+
+VALUE
+rbgtk_add_buttons(VALUE self, VALUE buttons, RBGTKAddButtonFunc add_button)
+{
+    struct add_buttons_args args = { self, buttons, add_button };
+
+    if (NIL_P(RARRAY_PTR(buttons)[0]))
+        return self;
+
+    g_object_freeze_notify(RVAL2GOBJ(self));
+
+    return rb_ensure(add_buttons_body, (VALUE)&args,
+                     add_buttons_ensure, (VALUE)&args);
+}
+

data/ext/gtk3/rbgtk3util.h

@@ -0,0 +1,32 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  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
+ */
+
+#ifndef __RBGTK3UTIL_H__
+#define __RBGTK3UTIL_H__
+
+G_BEGIN_DECLS
+
+typedef VALUE (*RBGTKAddButtonFunc)(VALUE self, VALUE button_text, VALUE response_id);
+
+G_GNUC_INTERNAL VALUE rbgtk_add_buttons(VALUE self, VALUE buttons, RBGTKAddButtonFunc add_button);
+
+G_END_DECLS
+
+#endif /* __RBGTK3UTIL_H__ */

data/ext/gtk3/rbgtkaboutdialog.c

@@ -0,0 +1,117 @@
+/* -*- 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;
+}
+
+static void
+activate_link_func(GtkAboutDialog *about, const gchar *link, gpointer func)
+{
+    rb_funcall((VALUE)func, id_call, 2, GOBJ2RVAL(about), CSTR2RVAL(link));
+}
+
+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(ary)[i]));
+        } 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/rbgtkaccelerator.c

@@ -0,0 +1,78 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE mAccelerator
+
+static VALUE
+rg_s_valid(G_GNUC_UNUSED VALUE self, VALUE keyval, VALUE modifiers)
+{
+    return CBOOL2RVAL(gtk_accelerator_valid(NUM2UINT(keyval), RVAL2GDKMODIFIERTYPE(modifiers)));
+}
+
+static VALUE
+rg_s_parse(G_GNUC_UNUSED VALUE self, VALUE accelerator)
+{
+    guint key;
+    GdkModifierType mods;
+    gtk_accelerator_parse(RVAL2CSTR(accelerator), &key, &mods);
+    return rb_ary_new3(2, UINT2NUM(key), GDKMODIFIERTYPE2RVAL(mods));
+}
+
+static VALUE
+rg_s_to_name(G_GNUC_UNUSED VALUE self, VALUE key, VALUE mods)
+{
+    return CSTR2RVAL(gtk_accelerator_name(NUM2UINT(key), RVAL2GDKMODIFIERTYPE(mods)));
+}
+
+static VALUE
+rg_s_get_label(G_GNUC_UNUSED VALUE self, VALUE key, VALUE mods)
+{
+    return CSTR2RVAL(gtk_accelerator_get_label(NUM2UINT(key), RVAL2GDKMODIFIERTYPE(mods)));
+}
+
+static VALUE
+rg_s_set_default_mod_mask(VALUE self, VALUE default_mod_mask)
+{
+    gtk_accelerator_set_default_mod_mask(RVAL2GDKMODIFIERTYPE(default_mod_mask));
+    return self;
+}
+
+static VALUE
+rg_s_default_mod_mask(G_GNUC_UNUSED VALUE self)
+{
+    return GDKMODIFIERTYPE2RVAL(gtk_accelerator_get_default_mod_mask());
+}
+
+void
+Init_gtk_accelerator(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = rb_define_module_under(mGtk, "Accelerator");
+
+    RG_DEF_SMETHOD(valid, 2);
+    RG_DEF_SMETHOD(parse, 1);
+    /* name is reserved by Ruby */
+    RG_DEF_SMETHOD(to_name, 2);
+    RG_DEF_SMETHOD(get_label, 2);
+    RG_DEF_SMETHOD(set_default_mod_mask, 1);
+    RG_DEF_SMETHOD(default_mod_mask, 0);
+}

data/ext/gtk3/rbgtkaccelgroup.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);
+}