gtk2 0.20.0

data/src/rbgtkselectiondata.c

@@ -0,0 +1,333 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkselectiondata.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:32 $
+
+  Copyright (C) 2002-2005 Masao Mutoh
+************************************************/
+
+
+#include "global.h"
+
+#define _SELF(d) ((GtkSelectionData*)RVAL2BOXED(d, GTK_TYPE_SELECTION_DATA))
+
+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 = RVAL2CSTR(src);
+	if (NIL_P(size)) {
+	    fmt = sizeof(char) * 8;
+	    len = RSTRING_LEN(src);
+	} else {
+	    len = NUM2UINT(size);
+	    fmt = (RSTRING_LEN(src) / len) * 8;
+	}
+    } 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 = 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(type, dat)
+    GdkAtom type;
+    void* dat;
+{
+    if (type == GDK_SELECTION_TYPE_INTEGER ||
+        type == GDK_SELECTION_TYPE_ATOM) {
+        xfree(dat);
+    } else if(type == compound_text) {
+        gdk_free_compound_text(dat);
+    }
+}    
+/************************************************************************/
+
+static VALUE
+gtkselectiondata_selection(self)
+    VALUE self;
+{
+    GdkAtom selection = _SELF(self)->selection;
+    return BOXED2RVAL(&selection, GDK_TYPE_ATOM);
+}
+
+static VALUE
+gtkselectiondata_target(self)
+    VALUE self;
+{
+    return BOXED2RVAL(_SELF(self)->target, GDK_TYPE_ATOM);
+}
+
+static VALUE
+gtkselectiondata_type(self)
+    VALUE self;
+{
+    return BOXED2RVAL(_SELF(self)->type, GDK_TYPE_ATOM);
+}
+
+static VALUE
+gtkselectiondata_format(self)
+    VALUE self;
+{
+    return INT2NUM(_SELF(self)->format);
+}
+
+static VALUE
+gtkselectiondata_data(self)
+    VALUE self;
+{
+    return rb_str_new((const char*)_SELF(self)->data, _SELF(self)->length);
+}
+
+#if GTK_CHECK_VERSION(2,2,0)
+static VALUE
+gtkselectiondata_display(self)
+    VALUE self;
+{
+    return BOXED2RVAL(_SELF(self)->display, GDK_TYPE_DISPLAY);
+}
+#endif
+
+/* Instance Methods */
+static VALUE
+gtkselectiondata_set(argc, argv, self)
+    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
+gtkselectiondata_set_text(self, str)
+    VALUE self, str;
+{
+    gboolean ret;
+    StringValue(str);
+
+    ret = gtk_selection_data_set_text(_SELF(self), RVAL2CSTR(str),
+                                      RSTRING_LEN(str));
+
+    if (!ret) 
+        rb_raise(rb_eRuntimeError, "the selection wasn't successfully.");
+
+    return self;
+}
+
+static VALUE
+gtkselectiondata_get_text(self)
+    VALUE self;
+{
+    VALUE ret = Qnil;
+    guchar* text = gtk_selection_data_get_text(_SELF(self));
+    if (text) {
+        ret = CSTR2RVAL((const char*)text);
+        g_free(text);
+    }
+    return ret;
+}
+
+#if GTK_CHECK_VERSION(2,6,0)
+static VALUE
+gtkselectiondata_set_pixbuf(self, pixbuf)
+    VALUE self, pixbuf;
+{
+    gboolean ret = gtk_selection_data_set_pixbuf(_SELF(self), 
+                                                 GDK_PIXBUF(RVAL2GOBJ(pixbuf)));
+    if (!ret) 
+        rb_raise(rb_eRuntimeError, "the selection wasn't successfully.");
+
+    return self;
+}
+
+static VALUE
+gtkselectiondata_get_pixbuf(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gtk_selection_data_get_pixbuf(_SELF(self)));
+}
+
+static VALUE
+gtkselectiondata_set_uris(self, uris)
+    VALUE self, uris;
+{
+    gboolean ret;
+    gchar** guris;
+    int i, n_targets;
+    
+    Check_Type(uris, T_ARRAY);
+    n_targets = RARRAY_LEN(uris);
+ 
+    guris = g_new(gchar*, n_targets + 1);
+
+    for (i = 0; i < n_targets; i++) {
+        guris[i] = RVAL2CSTR(RARRAY_PTR(uris)[i]);
+    }
+    guris[n_targets] = NULL;
+
+    ret = gtk_selection_data_set_uris(_SELF(self), guris);
+
+    g_strfreev(guris);
+
+    if (!ret) 
+        rb_raise(rb_eRuntimeError, "the selection wasn't successfully.");
+
+    return self;
+}
+
+static VALUE
+gtkselectiondata_get_uris(self)
+    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;
+}
+#endif
+
+static VALUE
+gtkselectiondata_get_targets(self)
+    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, BOXED2RVAL(targets[i], GDK_TYPE_ATOM));
+        }
+    }
+    g_free(targets);
+    return result;
+}
+#if GTK_CHECK_VERSION(2,6,0)
+static VALUE
+gtkselectiondata_targets_include_image(self, writable)
+    VALUE self, writable;
+{
+    return CBOOL2RVAL(gtk_selection_data_targets_include_image(_SELF(self), RVAL2CBOOL(writable)));
+}
+#endif
+
+static VALUE
+gtkselectiondata_targets_include_text(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gtk_selection_data_targets_include_text(_SELF(self)));
+}
+
+#if GTK_CHECK_VERSION(2,10,0)
+static VALUE
+gtkselectiondata_targets_include_uri(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gtk_selection_data_targets_include_uri(_SELF(self)));
+}
+static VALUE
+gtkselectiondata_targets_include_rich_text(self, buffer)
+    VALUE self, buffer;
+{
+    return CBOOL2RVAL(gtk_selection_data_targets_include_rich_text(_SELF(self),
+                                                                   GTK_TEXT_BUFFER(RVAL2GOBJ(buffer))));
+}
+#endif
+
+void
+Init_gtk_selectiondata()
+{
+    VALUE gSelectionData = 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);
+
+    rb_define_method(gSelectionData, "selection", gtkselectiondata_selection, 0);
+    rb_define_method(gSelectionData, "target", gtkselectiondata_target, 0);
+    rb_define_method(gSelectionData, "type", gtkselectiondata_type, 0);
+    rb_define_method(gSelectionData, "format", gtkselectiondata_format, 0);
+    rb_define_method(gSelectionData, "data", gtkselectiondata_data, 0);
+#if GTK_CHECK_VERSION(2,2,0)
+    rb_define_method(gSelectionData, "display", gtkselectiondata_display, 0);
+#endif 
+
+    rb_define_method(gSelectionData, "set", gtkselectiondata_set, -1);
+    rb_define_method(gSelectionData, "text", gtkselectiondata_get_text, 0);
+    rb_define_method(gSelectionData, "set_text", gtkselectiondata_set_text, 1);
+
+#if GTK_CHECK_VERSION(2,6,0)
+    rb_define_method(gSelectionData, "pixbuf", gtkselectiondata_get_pixbuf, 0);
+    rb_define_method(gSelectionData, "set_pixbuf", gtkselectiondata_set_pixbuf, 1);
+    rb_define_method(gSelectionData, "uris", gtkselectiondata_get_uris, 0);
+    rb_define_method(gSelectionData, "set_uris", gtkselectiondata_set_uris, 1);
+    rb_define_method(gSelectionData, "targets_include_image", gtkselectiondata_targets_include_image, 1);
+#endif
+    rb_define_method(gSelectionData, "targets", gtkselectiondata_get_targets, 0);
+    rb_define_method(gSelectionData, "targets_include_text", gtkselectiondata_targets_include_text, 0);
+#if GTK_CHECK_VERSION(2,10,0)
+    rb_define_method(gSelectionData, "targets_include_uri", gtkselectiondata_targets_include_uri, 0);
+    rb_define_method(gSelectionData, "targets_include_rich_text", gtkselectiondata_targets_include_rich_text, 1);
+#endif
+
+    G_DEF_SETTERS(gSelectionData);
+
+} 
+

data/src/rbgtkseparator.c

@@ -0,0 +1,21 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkseparator.c -
+
+  $Author: mutoh $
+  $Date: 2003/02/01 16:46:24 $
+
+  Copyright (C) 2002,2003 Ruby-GNOME2 Project Team
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+
+#include "global.h"
+
+void 
+Init_gtk_separator()
+{
+    G_DEF_CLASS(GTK_TYPE_SEPARATOR, "Separator", mGtk);
+}

data/src/rbgtkseparatormenuitem.c

@@ -0,0 +1,28 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkseparatormenuitem.c -
+
+  $Author: mutoh $
+  $Date: 2003/02/22 17:23:39 $
+
+  Copyright (C) 2002,2003 Masao Mutoh
+************************************************/
+
+#include "global.h"
+
+static VALUE
+smitem_initialize(self)
+    VALUE self;
+{
+    RBGTK_INITIALIZE(self, gtk_separator_menu_item_new());
+    return Qnil;
+}
+
+void 
+Init_gtk_separator_menu_item()
+{
+    VALUE gSMenuItem = G_DEF_CLASS(GTK_TYPE_SEPARATOR_MENU_ITEM, "SeparatorMenuItem", mGtk);
+
+    rb_define_method(gSMenuItem, "initialize", smitem_initialize, 0);
+}

data/src/rbgtkseparatortoolitem.c

@@ -0,0 +1,40 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkseparatortoolitem.c -
+
+  $Author: mutoh $
+  $Date: 2005/01/29 15:49:24 $
+
+  Copyright (C) 2004 Masao Mutoh
+************************************************/
+
+#include "global.h"
+                                                                                
+#if GTK_CHECK_VERSION(2,4,0)
+
+static VALUE
+separatortoolitem_initialize(self)
+    VALUE self;
+{
+    RBGTK_INITIALIZE(self, gtk_separator_tool_item_new());
+    return Qnil;
+}
+
+/* Defined as Property.
+void        gtk_separator_tool_item_set_draw
+                                            (GtkSeparatorToolItem *item,
+                                             gboolean draw);
+gboolean    gtk_separator_tool_item_get_draw
+                                            (GtkSeparatorToolItem *item);
+ */
+#endif
+
+void 
+Init_gtk_separatortoolitem()
+{
+#if GTK_CHECK_VERSION(2,4,0)
+    VALUE st = G_DEF_CLASS(GTK_TYPE_SEPARATOR_TOOL_ITEM, "SeparatorToolItem", mGtk);
+    rb_define_method(st, "initialize", separatortoolitem_initialize, 0);
+#endif
+}

data/src/rbgtksettings.c

@@ -0,0 +1,225 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtksettings.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:32 $
+
+  Copyright (C) 2003,2004 Ruby-GNOME2 Project Team
+  Copyright (C) 2003 Masao Mutoh
+************************************************/
+
+#include "global.h"
+
+static VALUE prop_func_table;
+
+static VALUE
+settings_s_get_default(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gtk_settings_get_default());
+}
+
+#if GTK_CHECK_VERSION(2,2,0)
+static VALUE
+settings_s_get_for_screen(self, screen)
+    VALUE self, screen;
+{
+    return GOBJ2RVAL(gtk_settings_get_for_screen(GDK_SCREEN(RVAL2GOBJ(screen))));
+}
+#endif
+
+/*
+ * 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(pspec, rc_string, property_value)
+    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
+settings_s_install_property(self, spec)
+    VALUE self, spec;
+{
+    GParamSpec* pspec = G_PARAM_SPEC(RVAL2GOBJ(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_color(self, spec, str)
+    VALUE self, spec, str;
+{
+    gboolean ret; 
+    GValue prop = {0,};
+    VALUE val = Qnil;
+    GString* gstr = g_string_new(RVAL2CSTR(str));
+    g_value_init(&prop, GDK_TYPE_COLOR);
+    ret = gtk_rc_property_parse_color(G_PARAM_SPEC(RVAL2GOBJ(spec)), 
+                                      gstr, &prop);
+    if (ret) val = GVAL2RVAL(&prop);
+
+    g_string_free(gstr, TRUE);
+    g_value_unset(&prop);
+    return val;
+}
+
+static VALUE
+settings_rc_property_parse_enum(self, spec, str)
+    VALUE self, spec, str;
+{
+    gboolean ret; 
+    GValue prop = {0,};
+    VALUE val = Qnil;
+    GString* gstr = g_string_new(RVAL2CSTR(str));
+    GParamSpec* gspec = G_PARAM_SPEC(RVAL2GOBJ(spec));
+    g_value_init(&prop, gspec->value_type);
+    ret = gtk_rc_property_parse_enum(gspec, gstr, &prop);
+
+    if (ret) val = GVAL2RVAL(&prop);
+
+    g_string_free(gstr, TRUE);
+    g_value_unset(&prop);
+    return val;
+}
+
+static VALUE
+settings_rc_property_parse_flags(self, spec, str)
+    VALUE self, spec, str;
+{
+    gboolean ret; 
+    GValue prop = {0,};
+    VALUE val = Qnil;
+    GString* gstr = g_string_new(RVAL2CSTR(str));
+    GParamSpec* gspec = G_PARAM_SPEC(RVAL2GOBJ(spec));
+    g_value_init(&prop, gspec->value_type);
+    ret = gtk_rc_property_parse_flags(gspec, gstr, &prop);
+
+    if (ret) val = GVAL2RVAL(&prop);
+
+    g_string_free(gstr, TRUE);
+    g_value_unset(&prop);
+    return val;
+}
+
+static VALUE
+settings_rc_property_parse_requisition(self, spec, str)
+    VALUE self, spec, str;
+{
+    gboolean ret; 
+    GValue prop = {0,};
+    VALUE val = Qnil;
+    GString* gstr = g_string_new(RVAL2CSTR(str));
+    g_value_init(&prop, GTK_TYPE_REQUISITION);
+    ret = gtk_rc_property_parse_requisition(G_PARAM_SPEC(RVAL2GOBJ(spec)), 
+                                            gstr, &prop);
+    if (ret){
+        GtkRequisition* req = g_value_get_boxed(&prop);
+        val = rb_assoc_new(INT2NUM(req->width), INT2NUM(req->height));
+    }
+    g_string_free(gstr, TRUE);
+    g_value_unset(&prop);
+    return val;    
+}
+
+static VALUE
+settings_rc_property_parse_border(self, spec, str)
+    VALUE self, spec, str;
+{
+    gboolean ret; 
+    GValue prop = {0,};
+    VALUE val = Qnil;
+    GString* gstr = g_string_new(RVAL2CSTR(str));
+    g_value_init(&prop, GTK_TYPE_BORDER);
+    ret = gtk_rc_property_parse_border(G_PARAM_SPEC(RVAL2GOBJ(spec)), 
+                                      gstr, &prop);
+    if (ret){
+        GtkBorder* border = g_value_get_boxed(&prop);
+        val = BOXED2RVAL(border, GTK_TYPE_BORDER);
+    }
+    g_string_free(gstr, TRUE);
+    g_value_unset(&prop);
+    return val;
+}
+
+static VALUE
+settings_set_property_value(self, name, value, origin)
+    VALUE self, name, value, origin;
+{
+    GtkSettingsValue svalue = { NULL, { 0, }, };
+    g_value_init(&svalue.value, RVAL2GTYPE(value));
+    rbgobj_rvalue_to_gvalue(value, &svalue.value);
+
+    svalue.origin = RVAL2CSTR(origin);
+    gtk_settings_set_property_value(GTK_SETTINGS(RVAL2GOBJ(self)), 
+                                    RVAL2CSTR(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 gSettings = G_DEF_CLASS(GTK_TYPE_SETTINGS, "Settings", mGtk);
+
+    rb_global_variable(&prop_func_table);
+    prop_func_table = rb_hash_new();
+
+    rb_define_singleton_method(gSettings, "default", settings_s_get_default, 0);
+#if GTK_CHECK_VERSION(2,2,0)
+    rb_define_singleton_method(gSettings, "get_for_screen", settings_s_get_for_screen, 1);
+#endif
+    rb_define_singleton_method(gSettings, "install_property", settings_s_install_property, 1);
+
+    rb_define_singleton_method(gSettings, "rc_property_parse_color", settings_rc_property_parse_color, 2);
+    rb_define_singleton_method(gSettings, "rc_property_parse_enum", settings_rc_property_parse_enum, 2);
+    rb_define_singleton_method(gSettings, "rc_property_parse_flags", settings_rc_property_parse_flags, 2);
+    rb_define_singleton_method(gSettings, "rc_property_parse_requisition", settings_rc_property_parse_requisition, 2);
+    rb_define_singleton_method(gSettings, "rc_property_parse_border", settings_rc_property_parse_border, 2);
+
+    rb_define_method(gSettings, "set_property_value", settings_set_property_value, 3);
+}