gtk3 0.0.1 → 1.2.0

data/ext/gtk3/rbgtkselectiondata.c

@@ -0,0 +1,282 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-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 cSelectionData
+#define _SELF(d) (RVAL2GTKSELECTIONDATA(d))
+
+static GdkAtom compound_text;
+
+/************************************************************************/
+void
+rbgtk_atom2selectiondata(VALUE type, VALUE size, VALUE src, GdkAtom *gtype,
+                         void **data, gint *format, gint *length)
+{
+    void* dat = NULL;
+    gint fmt, len;
+    GdkAtom ntype = RVAL2ATOM(type);
+
+    if(ntype == GDK_SELECTION_TYPE_INTEGER){
+        int *i;
+        i = ALLOC(int);
+        *i = NUM2INT(src);
+        dat = i;
+        fmt = sizeof(int) * 8;
+        len = 1;
+    } else if(ntype == GDK_SELECTION_TYPE_STRING) {
+        dat = (void *)RVAL2CSTR(src);
+        if (NIL_P(size)) {
+            fmt = sizeof(char) * 8;
+            len = RSTRING_LEN(src);
+        } else {
+            len = NUM2UINT(size);
+            fmt = (RSTRING_LEN(src) / len) * 8;
+        }
+/* TODO
+    } else if(ntype == compound_text){
+        guchar* str = (guchar*)dat;
+        gdk_string_to_compound_text(RVAL2CSTR(src), &ntype, &fmt, &str, &len);
+*/
+    } else if(type != Qnil && size != Qnil && src != Qnil) {
+        dat = (void *)RVAL2CSTR(src);
+        fmt = NUM2INT(size);
+        len = (RSTRING_LEN(src) * sizeof(char) / fmt);
+    } else {
+        rb_raise(rb_eArgError, "no supported type.");
+    }
+
+    *gtype = ntype;
+    *data = dat;
+    *format = fmt;
+    *length = len;
+}
+
+void
+rbgtk_atom2selectiondata_free(GdkAtom type, void *dat)
+{
+    if (type == GDK_SELECTION_TYPE_INTEGER ||
+        type == GDK_SELECTION_TYPE_ATOM) {
+        xfree(dat);
+/* TODO
+    } else if(type == compound_text) {
+        gdk_free_compound_text(dat);
+*/
+    }
+}    
+/************************************************************************/
+
+static VALUE
+rg_selection(VALUE self)
+{
+    return GDKATOM2RVAL(gtk_selection_data_get_selection(_SELF(self)));
+}
+
+static VALUE
+rg_target(VALUE self)
+{
+    return GDKATOM2RVAL(gtk_selection_data_get_target(_SELF(self)));
+}
+
+static VALUE
+rg_data_type(VALUE self)
+{
+    return GDKATOM2RVAL(gtk_selection_data_get_data_type(_SELF(self)));
+}
+
+static VALUE
+rg_format(VALUE self)
+{
+    return INT2NUM(gtk_selection_data_get_format(_SELF(self)));
+}
+
+static VALUE
+rg_data(VALUE self)
+{
+    return RBG_STRING_SET_UTF8_ENCODING(rb_str_new((const gchar *)gtk_selection_data_get_data(_SELF(self)),
+                                                   gtk_selection_data_get_length(_SELF(self))));
+}
+
+static VALUE
+rg_display(VALUE self)
+{
+    return GOBJ2RVAL(gtk_selection_data_get_display(_SELF(self)));
+}
+
+static VALUE
+rg_set(int argc, VALUE *argv, VALUE self)
+{
+    void* dat;
+    VALUE type, src;
+    gint fmt, len;
+    GdkAtom ntype;
+    VALUE size = Qnil;
+
+    if(3 == argc)
+        rb_scan_args(argc, argv, "30", &type, &size, &src);
+    else
+        rb_scan_args(argc, argv, "20", &type, &src);
+
+    rbgtk_atom2selectiondata(type, size, src, &ntype, &dat, &fmt, &len);
+
+    gtk_selection_data_set(_SELF(self), ntype, fmt, dat, len);
+
+    rbgtk_atom2selectiondata_free(ntype, dat);
+
+    return self;
+}
+
+static VALUE
+rg_set_text(VALUE self, VALUE str)
+{
+    StringValue(str);
+
+    if (!gtk_selection_data_set_text(_SELF(self), RSTRING_PTR(str), RSTRING_LEN(str)))
+        rb_raise(rb_eRuntimeError, "the selection wasn't successfully set");
+
+    return self;
+}
+
+static VALUE
+rg_text(VALUE self)
+{
+    return CSTR2RVAL_FREE((gchar *)gtk_selection_data_get_text(_SELF(self)));
+}
+
+static VALUE
+rg_set_pixbuf(VALUE self, VALUE pixbuf)
+{
+    if (!gtk_selection_data_set_pixbuf(_SELF(self), RVAL2GDKPIXBUF(pixbuf)))
+        rb_raise(rb_eRuntimeError, "the selection wasn't successfully set");
+
+    return self;
+}
+
+static VALUE
+rg_pixbuf(VALUE self)
+{
+    return GOBJ2RVAL(gtk_selection_data_get_pixbuf(_SELF(self)));
+}
+
+static VALUE
+rg_set_uris(VALUE self, VALUE uris)
+{
+    gboolean ret;
+    gchar **guris;
+
+    guris = (gchar **)RVAL2STRV(uris);
+    ret = gtk_selection_data_set_uris(_SELF(self), guris);
+    g_free(guris);
+    if (!ret) 
+        rb_raise(rb_eRuntimeError, "the selection wasn't successfully.");
+
+    return self;
+}
+
+static VALUE
+rg_uris(VALUE self)
+{
+    VALUE ary = rb_ary_new();
+    gchar** uris = gtk_selection_data_get_uris(_SELF(self));
+
+    if (uris) {
+        gchar **uri = uris;
+        while (*uri) {
+            rb_ary_push(ary, CSTR2RVAL(*uri));
+            uri++;
+        }
+        g_strfreev(uris);
+    }
+    return ary;
+}
+
+static VALUE
+rg_targets(VALUE self)
+{
+    GdkAtom* targets;
+    gint n_atoms;
+    VALUE result = Qnil;
+    gboolean ret = gtk_selection_data_get_targets(_SELF(self),
+                                                  &targets, &n_atoms);
+    if (ret) {
+        int i;
+        result = rb_ary_new2(n_atoms);
+        for (i = 0; i < n_atoms; i++){
+            rb_ary_push(result, GDKATOM2RVAL(targets[i]));
+        }
+    }
+    g_free(targets);
+    return result;
+}
+
+static VALUE
+rg_targets_include_image(VALUE self, VALUE writable)
+{
+    return CBOOL2RVAL(gtk_selection_data_targets_include_image(_SELF(self), RVAL2CBOOL(writable)));
+}
+
+static VALUE
+rg_targets_include_text(VALUE self)
+{
+    return CBOOL2RVAL(gtk_selection_data_targets_include_text(_SELF(self)));
+}
+
+static VALUE
+rg_targets_include_uri(VALUE self)
+{
+    return CBOOL2RVAL(gtk_selection_data_targets_include_uri(_SELF(self)));
+}
+
+static VALUE
+rg_targets_include_rich_text(VALUE self, VALUE buffer)
+{
+    return CBOOL2RVAL(gtk_selection_data_targets_include_rich_text(_SELF(self),
+                                                                   RVAL2GTKTEXTBUFFER(buffer)));
+}
+
+void
+Init_gtk_selectiondata(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_SELECTION_DATA, "SelectionData", mGtk);
+
+    rbgobj_boxed_not_copy_obj(GTK_TYPE_SELECTION_DATA);
+
+    compound_text = gdk_atom_intern("COMPOUND_TEXT", FALSE);
+
+    RG_DEF_METHOD(selection, 0);
+    RG_DEF_METHOD(target, 0);
+    RG_DEF_METHOD(data_type, 0);
+    RG_DEF_METHOD(format, 0);
+    RG_DEF_METHOD(data, 0);
+    RG_DEF_METHOD(display, 0);
+    RG_DEF_METHOD(set, -1);
+    RG_DEF_METHOD(text, 0);
+    RG_DEF_METHOD(set_text, 1);
+    RG_DEF_METHOD(pixbuf, 0);
+    RG_DEF_METHOD(set_pixbuf, 1);
+    RG_DEF_METHOD(uris, 0);
+    RG_DEF_METHOD(set_uris, 1);
+    RG_DEF_METHOD(targets_include_image, 1);
+    RG_DEF_METHOD(targets, 0);
+    RG_DEF_METHOD(targets_include_text, 0);
+    RG_DEF_METHOD(targets_include_uri, 0);
+    RG_DEF_METHOD(targets_include_rich_text, 1);
+} 

data/ext/gtk3/rbgtkseparator.c

@@ -0,0 +1,44 @@
+/* -*- 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 cSeparator
+#define _SELF(self) (RVAL2GTKSEPARATOR(self))
+
+static VALUE
+rg_initialize(VALUE self, VALUE orientation)
+{
+    RBGTK_INITIALIZE(self, gtk_separator_new(RVAL2GTKORIENTATION(orientation)));
+
+    return Qnil;
+}
+
+void
+Init_gtk_separator(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_SEPARATOR, "Separator", mGtk);
+
+    RG_DEF_METHOD(initialize, 1);
+}

data/ext/gtk3/rbgtkseparatormenuitem.c

@@ -0,0 +1,39 @@
+/* -*- 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 cSeparatorMenuItem
+
+static VALUE
+rg_initialize(VALUE self)
+{
+    RBGTK_INITIALIZE(self, gtk_separator_menu_item_new());
+    return Qnil;
+}
+
+void 
+Init_gtk_separator_menu_item(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_SEPARATOR_MENU_ITEM, "SeparatorMenuItem", mGtk);
+
+    RG_DEF_METHOD(initialize, 0);
+}

data/ext/gtk3/rbgtkseparatortoolitem.c

@@ -0,0 +1,38 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2004  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 cSeparatorToolItem
+
+static VALUE
+rg_initialize(VALUE self)
+{
+    RBGTK_INITIALIZE(self, gtk_separator_tool_item_new());
+    return Qnil;
+}
+
+void 
+Init_gtk_separatortoolitem(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_SEPARATOR_TOOL_ITEM, "SeparatorToolItem", mGtk);
+    RG_DEF_METHOD(initialize, 0);
+}

data/ext/gtk3/rbgtksettings.c

@@ -0,0 +1,229 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2003,2004 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 "rbgtk3private.h"
+
+#define RG_TARGET_NAMESPACE cSettings
+
+static VALUE prop_func_table;
+
+static VALUE
+rg_s_default(G_GNUC_UNUSED VALUE self)
+{
+    return GOBJ2RVAL(gtk_settings_get_default());
+}
+
+static VALUE
+rg_s_get_for_screen(G_GNUC_UNUSED VALUE self, VALUE screen)
+{
+    return GOBJ2RVAL(gtk_settings_get_for_screen(RVAL2GDKSCREEN(screen)));
+}
+
+/*
+ * Gtk::Settings.install_property(...) do |spec, str|
+ *   #parse str
+ *   new_val = ....   # parse value from string.
+ *   new_val          # return new_val or nil if you can't convert the value.
+ * end
+ */
+static gboolean
+rc_property_parser(const GParamSpec *pspec, const GString *rc_string, GValue *property_value)
+{
+    VALUE spec = GOBJ2RVAL((gpointer)pspec);
+    VALUE func = rb_hash_aref(prop_func_table, spec);
+    VALUE ret = rb_funcall(func, id_call, 2, spec, CSTR2RVAL(rc_string->str));
+    if (NIL_P(ret)) {
+        return FALSE;
+    } else if (RVAL2CBOOL(ret)){
+        rbgobj_rvalue_to_gvalue(ret, property_value);
+        return TRUE;
+    } else {
+        rb_raise(rb_eArgError, "Gtk::Settings#install_property() block should return new value or nil");
+    }
+}
+
+static VALUE
+rg_s_install_property(VALUE self, VALUE spec)
+{
+    GParamSpec* pspec = RVAL2GPARAMSPEC(spec);
+    if (rb_block_given_p()){
+        VALUE func = rb_block_proc();
+        rb_hash_aset(prop_func_table, spec, func);
+        gtk_settings_install_property_parser(pspec, (GtkRcPropertyParser)rc_property_parser);
+    } else {
+        gtk_settings_install_property(pspec);
+    }
+    return self;
+}
+
+static VALUE
+settings_rc_property_parse(G_GNUC_UNUSED VALUE self, VALUE rbspec, VALUE rbstring, GtkRcPropertyParser parser)
+{
+    GParamSpec *spec = RVAL2GPARAMSPEC(rbspec);
+    GString *string = g_string_new(RVAL2CSTR(rbstring));
+    GValue property = G_VALUE_INIT;
+    gboolean parsed;
+
+    g_value_init(&property, spec->value_type);
+
+    parsed = parser(spec, string, &property);
+
+    g_string_free(string, TRUE);
+
+    return parsed ? GVAL2RVAL_UNSET(&property) : Qnil;
+}
+
+static VALUE
+rg_s_rc_property_parse_color(VALUE self, VALUE rbspec, VALUE rbstring)
+{
+    return settings_rc_property_parse(self, rbspec, rbstring, gtk_rc_property_parse_color);
+}
+
+static VALUE
+rg_s_rc_property_parse_enum(VALUE self, VALUE rbspec, VALUE rbstring)
+{
+    return settings_rc_property_parse(self, rbspec, rbstring, gtk_rc_property_parse_enum);
+}
+
+static VALUE
+rg_s_rc_property_parse_flags(VALUE self, VALUE rbspec, VALUE rbstring)
+{
+    return settings_rc_property_parse(self, rbspec, rbstring, gtk_rc_property_parse_flags);
+}
+
+static VALUE
+rg_s_rc_property_parse_requisition(G_GNUC_UNUSED VALUE self, VALUE rbspec, VALUE rbstring)
+{
+    GParamSpec *spec = RVAL2GPARAMSPEC(rbspec);
+    GString *string = g_string_new(RVAL2CSTR(rbstring));
+    GValue property = G_VALUE_INIT;
+    gboolean parsed;
+    GtkRequisition *requisition;
+    gint width;
+    gint height;
+
+    g_value_init(&property, GTK_TYPE_REQUISITION);
+
+    parsed = gtk_rc_property_parse_requisition(spec, string, &property);
+
+    g_string_free(string, TRUE);
+
+    if (!parsed)
+        return Qnil;
+
+    requisition = g_value_get_boxed(&property);
+    width = requisition->width;
+    height = requisition->height;
+
+    g_value_unset(&property);
+
+    return rb_assoc_new(INT2NUM(width), INT2NUM(height));
+}
+
+static VALUE
+settings_rc_property_parse_border_result(VALUE value)
+{
+    return GTKBORDER2RVAL(g_value_get_boxed((GValue *)value));
+}
+
+static VALUE
+settings_rc_property_parse_border_ensure(VALUE value)
+{
+    g_value_unset((GValue *)value);
+
+    return Qnil;
+}
+
+static VALUE
+rg_s_rc_property_parse_border(G_GNUC_UNUSED VALUE self, VALUE rbspec, VALUE rbstring)
+{
+    GParamSpec *spec = RVAL2GPARAMSPEC(rbspec);
+    GString *string = g_string_new(RVAL2CSTR(rbstring));
+    GValue property = G_VALUE_INIT;
+    gboolean parsed;
+
+    g_value_init(&property, GTK_TYPE_BORDER);
+
+    parsed = gtk_rc_property_parse_border(spec, string, &property);
+
+    g_string_free(string, TRUE);
+
+    if (!parsed)
+        return Qnil;
+
+    return rb_ensure(settings_rc_property_parse_border_result, (VALUE)&property,
+                     settings_rc_property_parse_border_ensure, (VALUE)&property);
+}
+
+static VALUE
+rg_set_property_value(VALUE self, VALUE rbname, VALUE rbvalue, VALUE origin)
+{
+    GtkSettings *settings = RVAL2GTKSETTINGS(self);
+    GtkSettingsValue svalue = { (gchar *)RVAL2CSTR(origin), G_VALUE_INIT };
+    const gchar *name = RVAL2CSTR(rbname);
+    g_value_init(&svalue.value, RVAL2GTYPE(rbvalue));
+    rbgobj_rvalue_to_gvalue(rbvalue, &svalue.value);
+
+    gtk_settings_set_property_value(settings, name, &svalue);
+
+    g_value_unset(&svalue.value);
+
+    return self;
+}
+
+/* We don't need them, Use set_property_value() instead.
+void        gtk_settings_set_string_property
+                                            (GtkSettings *settings,
+                                             const gchar *name,
+                                             const gchar *v_string,
+                                             const gchar *origin);
+void        gtk_settings_set_long_property  (GtkSettings *settings,
+                                             const gchar *name,
+                                             glong v_long,
+                                             const gchar *origin);
+void        gtk_settings_set_double_property
+                                            (GtkSettings *settings,
+                                             const gchar *name,
+                                             gdouble v_double,
+                                             const gchar *origin);
+*/
+
+void 
+Init_gtk_settings(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_SETTINGS, "Settings", mGtk);
+
+    rb_global_variable(&prop_func_table);
+    prop_func_table = rb_hash_new();
+
+    RG_DEF_SMETHOD(default, 0);
+    RG_DEF_SMETHOD(get_for_screen, 1);
+    RG_DEF_SMETHOD(install_property, 1);
+
+    RG_DEF_SMETHOD(rc_property_parse_color, 2);
+    RG_DEF_SMETHOD(rc_property_parse_enum, 2);
+    RG_DEF_SMETHOD(rc_property_parse_flags, 2);
+    RG_DEF_SMETHOD(rc_property_parse_requisition, 2);
+    RG_DEF_SMETHOD(rc_property_parse_border, 2);
+
+    RG_DEF_METHOD(set_property_value, 3);
+}