gtk2 0.20.0

data/src/rbgtkcellrendererprogress.c

@@ -0,0 +1,37 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkcellrendererprogress.c -
+
+  $Author: mutoh $
+  $Date: 2004/12/27 16:32:56 $
+
+  Copyright (C) 2004 Darren Willis
+************************************************/
+
+#include "global.h"
+
+#if GTK_CHECK_VERSION(2,6,0)
+
+static VALUE
+crprogress_initialize(self)
+    VALUE self;
+{
+    RBGTK_INITIALIZE(self, gtk_cell_renderer_progress_new());
+    return Qnil;
+}
+
+#endif
+
+void
+Init_gtk_cellrendererprogress()
+{
+#if GTK_CHECK_VERSION(2,6,0)
+    VALUE renderer = G_DEF_CLASS(GTK_TYPE_CELL_RENDERER_PROGRESS, "CellRendererProgress", mGtk);
+    rb_define_method(renderer, "initialize", crprogress_initialize, 0);
+#endif
+}
+
+
+ 
+

data/src/rbgtkcellrendererspin.c

@@ -0,0 +1,38 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkcellrendererspin.c -
+
+  $Author: mutoh $
+  $Date: 2006/10/21 16:58:00 $
+
+  Copyright (C) 2006 Ruby-GNOME2 Team
+************************************************/
+
+#include "global.h"
+
+#if GTK_CHECK_VERSION(2,10,0)
+
+#define _SELF(s) (GTK_CELL_RENDERER_SPIN(RVAL2GOBJ(s)))
+
+static VALUE
+crspin_initialize(self)
+    VALUE self;
+{
+    RBGTK_INITIALIZE(self, gtk_cell_renderer_spin_new());
+    return Qnil;
+}
+
+#endif
+
+void
+Init_gtk_cellrendererspin()
+{
+#if GTK_CHECK_VERSION(2,10,0)
+    VALUE renderer = G_DEF_CLASS(GTK_TYPE_CELL_RENDERER_SPIN, "CellRendererSpin", mGtk);
+    rb_define_method(renderer, "initialize", crspin_initialize, 0);
+#endif
+}
+
+
+ 

data/src/rbgtkcellrenderertext.c

@@ -0,0 +1,45 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkcellrenderertext.c -
+
+  $Author: mutoh $
+  $Date: 2003/01/19 14:28:24 $
+
+  Copyright (C) 2002,2003 Masao Mutoh
+************************************************/
+
+#include "global.h"
+
+
+#define _SELF(s) (GTK_CELL_RENDERER_TEXT(RVAL2GOBJ(s)))
+
+static VALUE
+crtext_initialize(self)
+    VALUE self;
+{
+    RBGTK_INITIALIZE(self, gtk_cell_renderer_text_new());
+    return Qnil;
+}
+
+static VALUE
+crtext_set_fixed_height_from_font(self, number_of_rows)
+    VALUE self, number_of_rows;
+{
+    gtk_cell_renderer_text_set_fixed_height_from_font(_SELF(self), NUM2INT(number_of_rows));
+    return self;
+}
+
+void
+Init_gtk_cellrenderertext()
+{
+    VALUE renderer = G_DEF_CLASS(GTK_TYPE_CELL_RENDERER_TEXT, "CellRendererText", mGtk);
+    
+    rb_define_method(renderer, "initialize", crtext_initialize, 0);
+    rb_define_method(renderer, "set_fixed_height_from_font", crtext_set_fixed_height_from_font, 1);
+
+    G_DEF_SETTERS(renderer);
+}
+
+
+ 

data/src/rbgtkcellrenderertoggle.c

@@ -0,0 +1,32 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkcellrenderertoggle.c -
+
+  $Author: mutoh $
+  $Date: 2003/01/19 14:28:24 $
+
+  Copyright (C) 2002,2003 Masao Mutoh
+************************************************/
+
+#include "global.h"
+
+#define _SELF(s) (GTK_CELL_RENDERER_TOGGLE(RVAL2GOBJ(s)))
+
+static VALUE
+crtoggle_initialize(self)
+    VALUE self;
+{
+    RBGTK_INITIALIZE(self, gtk_cell_renderer_toggle_new());
+    return Qnil;
+}
+
+void
+Init_gtk_cellrenderertoggle()
+{
+    VALUE renderer = G_DEF_CLASS(GTK_TYPE_CELL_RENDERER_TOGGLE, "CellRendererToggle", mGtk);
+    rb_define_method(renderer, "initialize", crtoggle_initialize, 0);
+}
+
+
+ 

data/src/rbgtkcellview.c

@@ -0,0 +1,134 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkcellview.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:31 $
+
+  Copyright (C) 2005,2006 Masao Mutoh
+************************************************/
+
+#include "global.h"
+
+#if GTK_CHECK_VERSION(2,6,0)
+
+#define _SELF(self) (GTK_CELL_VIEW(RVAL2GOBJ(self)))
+
+static ID id_model;
+static ID id_text;
+
+static VALUE
+cview_initialize(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE text;
+    VALUE with_markup = Qnil;
+    GtkWidget *widget = NULL;
+
+    rb_scan_args(argc, argv, "02", &text, &with_markup);
+    
+    if (NIL_P(text)) {
+        widget = gtk_cell_view_new();
+    } else {
+        G_CHILD_SET(self, id_text, text);
+        if (TYPE(text) == T_STRING){
+            if (NIL_P(with_markup) || RVAL2CBOOL(with_markup)){
+                widget = gtk_cell_view_new_with_markup(RVAL2CSTR(text));
+            } else {
+                widget = gtk_cell_view_new_with_text(RVAL2CSTR(text));
+            }
+        } else if (rb_obj_is_kind_of(text, GTYPE2CLASS(GDK_TYPE_PIXBUF))){
+            widget = gtk_cell_view_new_with_pixbuf(GDK_PIXBUF(RVAL2GOBJ(text)));
+        } else {
+            rb_raise(rb_eArgError, 
+                     "invalid argument %s (expect String or Gdk::Pixbuf)", 
+                     rb_class2name(CLASS_OF(text)));
+        }
+    }
+
+    RBGTK_INITIALIZE(self, widget);
+
+    return Qnil;
+}
+
+static VALUE
+cview_set_model(self, model)
+    VALUE self, model;
+{
+    G_CHILD_SET(self, id_model, model);
+    gtk_cell_view_set_model(_SELF(self), 
+                            NIL_P(model) ? (GtkTreeModel*)NULL : GTK_TREE_MODEL(RVAL2GOBJ(model)));
+    return self;
+}
+
+static VALUE
+cview_set_displayed_row(self, path)
+    VALUE self, path;
+{
+    gtk_cell_view_set_displayed_row(_SELF(self),  
+                                    NIL_P(path) ? (GtkTreePath*)NULL :
+                                    RVAL2GTKTREEPATH(path));
+    return self;
+}
+
+static VALUE
+cview_get_displayed_row(self)
+    VALUE self;
+{
+    return GTKTREEPATH2RVAL(gtk_cell_view_get_displayed_row(_SELF(self)));
+}
+
+static VALUE
+cview_get_size_of_row(self, path)
+    VALUE self, path;
+{
+    GtkRequisition req;
+    gboolean ret = gtk_cell_view_get_size_of_row(_SELF(self),  
+                                                 RVAL2GTKTREEPATH(path),
+                                                 &req);
+    if (! ret)
+        rb_raise(rb_eRuntimeError, "Can't get the value");
+
+    return rb_ary_assoc(INT2NUM(req.width), INT2NUM(req.height));
+}
+
+/* Use Gtk::CellView#background_gdk(Gdk::Color) instead.
+void        gtk_cell_view_set_background_color
+                                            (GtkCellView *cell_view,
+                                             const GdkColor *color);
+*/
+
+static VALUE
+cview_get_cell_renderers(self)
+    VALUE self;
+{
+    return GLIST2ARYF(gtk_cell_view_get_cell_renderers(_SELF(self)));
+}
+#endif
+
+void
+Init_gtk_cellview()
+{
+#if GTK_CHECK_VERSION(2,6,0)
+    VALUE cview = G_DEF_CLASS(GTK_TYPE_CELL_VIEW, "CellView", mGtk);
+
+    id_model = rb_intern("model");
+    id_text = rb_intern("text");
+
+    rb_define_method(cview, "initialize", cview_initialize, -1);
+    rb_define_method(cview, "set_model", cview_set_model, 1);
+    rb_define_method(cview, "set_displayed_row", cview_set_displayed_row, 1);
+    rb_define_method(cview, "displayed_row", cview_get_displayed_row, 0);
+    rb_define_method(cview, "get_size_of_row", cview_get_size_of_row, 1);
+    rb_define_method(cview, "cell_renderers", cview_get_cell_renderers, 0);
+
+    G_DEF_SETTERS(cview);
+#endif
+}
+
+
+ 
+

data/src/rbgtkcheckbutton.c

@@ -0,0 +1,55 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkcheckbutton.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:31 $
+
+  Copyright (C) 2002,2003 Ruby-GNOME2 Project Team
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+
+#include "global.h"
+
+static VALUE
+cbtn_initialize(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE label, use_underline;
+    GtkWidget *widget;
+
+    if (rb_scan_args(argc, argv, "02", &label, &use_underline) > 0) {
+        if (TYPE(label) == T_STRING){
+            if (NIL_P(use_underline) || RVAL2CBOOL(use_underline)){
+                widget = gtk_check_button_new_with_mnemonic(RVAL2CSTR(label));
+            } else {
+                widget = gtk_check_button_new_with_label(RVAL2CSTR(label));
+            }
+        } else if (TYPE(label) == T_SYMBOL){
+            widget = gtk_check_button_new_with_label(rb_id2name(SYM2ID(label)));
+            gtk_button_set_use_stock(GTK_BUTTON(widget), TRUE);
+        } else {
+            rb_raise(rb_eArgError, "invalid argument %s (expect Symbol(Gtk::Stock constants) or String)", 
+                     rb_class2name(CLASS_OF(label)));
+        }
+    }
+    else {
+        widget = gtk_check_button_new();
+    }
+
+    RBGTK_INITIALIZE(self, widget);
+    return Qnil;
+}
+
+void 
+Init_gtk_check_button()
+{
+    VALUE gCButton = G_DEF_CLASS(GTK_TYPE_CHECK_BUTTON, "CheckButton", mGtk);
+
+    rb_define_method(gCButton, "initialize", cbtn_initialize, -1);
+}

data/src/rbgtkcheckmenuitem.c

@@ -0,0 +1,56 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkcheckmenuitem.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:31 $
+
+  Copyright (C) 2002,2003 Ruby-GNOME2 Project Team
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+
+#include "global.h"
+
+static VALUE
+cmitem_initialize(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE label, use_underline;
+    GtkWidget *widget = NULL;
+
+    if (rb_scan_args(argc, argv, "02", &label, &use_underline) > 0) {
+        if (NIL_P(use_underline) || RVAL2CBOOL(use_underline)){
+            widget = gtk_check_menu_item_new_with_mnemonic(RVAL2CSTR(label));
+        } else {
+            widget = gtk_check_menu_item_new_with_label(RVAL2CSTR(label));
+        }
+    }
+    else {
+	widget = gtk_check_menu_item_new();
+    }
+
+    RBGTK_INITIALIZE(self, widget);
+    return Qnil;
+}
+
+static VALUE
+cmitem_toggled(self)
+    VALUE self;
+{
+    gtk_check_menu_item_toggled(GTK_CHECK_MENU_ITEM(RVAL2GOBJ(self)));
+    return self;
+}
+
+void 
+Init_gtk_check_menu_item()
+{
+    VALUE gCMenuItem = G_DEF_CLASS(GTK_TYPE_CHECK_MENU_ITEM, "CheckMenuItem", mGtk);
+
+    rb_define_method(gCMenuItem, "initialize", cmitem_initialize, -1);
+    rb_define_method(gCMenuItem, "toggled", cmitem_toggled, 0);
+}

data/src/rbgtkclipboard.c

@@ -0,0 +1,473 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkclipboard.c -
+ 
+  $Author: ggc $
+  $Date: 2007/07/13 14:27:09 $
+
+  Copyright (C) 2004,2006 Ruby-GNOME2 Project
+  Copyright (C) 2002,2003 OGASAWARA, Takeshi
+************************************************/
+#include "global.h"
+
+#define _SELF(s) RVAL2CLIPBOARD(s)
+
+#ifndef GTK_TYPE_CLIPBOARD
+static GtkClipboard*
+clipboard_copy(const GtkClipboard *clipboard)
+{
+    /* I don't know how to copy this object ... */
+    return (GtkClipboard*)clipboard;
+}
+
+GType
+rbgtk_clipboard_get_type()
+{
+    static GType our_type = 0;
+    if(our_type == 0)
+        our_type = g_boxed_type_register_static("GtkClipboard",
+                                                (GBoxedCopyFunc)clipboard_copy,
+                                                (GBoxedFreeFunc)g_free);
+    return our_type;
+}
+
+GtkClipboard*
+rbgtk_get_clipboard(obj)
+    VALUE obj;
+{
+    return GTK_CLIPBOARD(RVAL2GOBJ(obj));
+}
+
+VALUE
+rbgtk_make_clipboard(gobj)
+    GtkClipboard* gobj;
+{
+    return GOBJ2RVAL(gobj);
+}
+#endif
+
+static VALUE
+clipboard_get(argc, argv, self)
+    int argc;
+    VALUE* argv;
+    VALUE self;
+{
+    GtkClipboard *clipboard;
+
+    if (argc == 1){
+        VALUE selection;
+        rb_scan_args(argc, argv, "10", &selection);
+        clipboard = gtk_clipboard_get(RVAL2ATOM(selection));
+    } else {
+#if GTK_CHECK_VERSION(2,2,0)
+        VALUE display, selection;
+        rb_scan_args(argc, argv, "20", &display, &selection);
+        clipboard = gtk_clipboard_get_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
+                                                  RVAL2ATOM(selection));
+#else
+        rb_raise(rb_eArgError, "Wrong number of arguments: %d", argc);
+#endif
+    } 
+    return CLIPBOARD2RVAL(clipboard);
+}
+
+static VALUE
+clipboard_get_display(self)
+    VALUE self;
+{
+#if GTK_CHECK_VERSION(2,2,0)
+    return GOBJ2RVAL(gtk_clipboard_get_display(_SELF(self)));
+#else
+	 return Qnil;
+#endif
+}
+
+static void
+clipboard_get_func(clipboard, selection_data, info, func)
+    GtkClipboard *clipboard;
+    GtkSelectionData* selection_data;
+    gpointer func;
+{
+    rb_funcall((VALUE)func, id_call, 2, CLIPBOARD2RVAL(clipboard),
+               BOXED2RVAL(selection_data, GTK_TYPE_SELECTION_DATA));
+}
+
+static VALUE
+clipboard_set(self, targets)
+    VALUE self, targets;
+{
+    const GtkTargetEntry* gtargets = (const GtkTargetEntry*)rbgtk_get_target_entry(targets);
+    VALUE func = rb_block_proc();
+    G_RELATIVE(self, func);
+    return CBOOL2RVAL(gtk_clipboard_set_with_data(_SELF(self), 
+                                                  gtargets,
+                                                  RARRAY_LEN(targets),
+                                                  (GtkClipboardGetFunc)clipboard_get_func,
+                                                  (GtkClipboardClearFunc)NULL,
+                                                  (gpointer)func));
+}
+/*
+Do not implement this. Use Gtk::Clipboard#set_with_data instead.
+gboolean    gtk_clipboard_set_with_owner    (GtkClipboard *clipboard,
+                                             const GtkTargetEntry *targets,
+                                             guint n_targets,
+                                             GtkClipboardGetFunc get_func,
+                                             GtkClipboardClearFunc clear_func,
+                                             GObject *owner);
+
+static VALUE
+clipboard_get_owner(self)
+    VALUE self;
+{
+    GObject *gobj;
+    gobj = gtk_clipboard_get_owner(_SELF(self));
+    return gobj ? GOBJ2RVAL(gobj) : Qnil;
+}
+*/
+
+static VALUE
+clipboard_clear(self)
+    VALUE self;
+{
+    gtk_clipboard_clear(_SELF(self));
+    return self;
+}
+
+static VALUE
+clipboard_set_text(self, text)
+    VALUE self, text;
+{
+    StringValue(text);
+    gtk_clipboard_set_text(_SELF(self), RVAL2CSTR(text), RSTRING_LEN(text));
+    return self;
+}
+
+#if GTK_CHECK_VERSION(2,6,0)
+static VALUE
+clipboard_set_image(self, pixbuf)
+    VALUE self, pixbuf;
+{
+    gtk_clipboard_set_image(_SELF(self), GDK_PIXBUF(RVAL2GOBJ(pixbuf)));
+    return self;
+}
+#endif
+
+static void
+clipboard_received_func(clipboard, selection_data, func)
+    GtkClipboard *clipboard;
+    GtkSelectionData* selection_data;
+    gpointer func;
+{
+    rb_funcall((VALUE)func, id_call, 2, CLIPBOARD2RVAL(clipboard),
+               BOXED2RVAL(selection_data, GTK_TYPE_SELECTION_DATA));
+}
+
+static VALUE
+clipboard_request_contents(self, target)
+    VALUE self, target;
+{
+    VALUE func = rb_block_proc();
+    G_RELATIVE(self, func);
+    gtk_clipboard_request_contents(_SELF(self), RVAL2ATOM(target),
+                                   (GtkClipboardReceivedFunc)clipboard_received_func,
+                                   (gpointer)func);
+    return self;
+}
+
+static void
+clipboard_text_received_func(GtkClipboard *clipboard, const gchar *text,
+                             gpointer func)
+{
+    VALUE vtext = Qnil;
+    if (text) {
+        vtext = CSTR2RVAL(text);
+        RBG_STRING_SET_UTF8_ENCODING(vtext);
+    }
+
+    rb_funcall((VALUE)func, id_call, 2, CLIPBOARD2RVAL(clipboard), vtext);
+}
+
+static VALUE
+clipboard_request_text(self)
+    VALUE self;
+{
+    VALUE func = rb_block_proc();
+    G_RELATIVE(self, func);
+    gtk_clipboard_request_text(_SELF(self),
+                               (GtkClipboardTextReceivedFunc)clipboard_text_received_func,
+                               (gpointer)func);
+    return self;
+}
+
+#if GTK_CHECK_VERSION(2,6,0)
+static void
+clipboard_image_received_func(clipboard, pixbuf, func)
+    GtkClipboard* clipboard;
+    GdkPixbuf* pixbuf;
+    gpointer func;
+{
+    rb_funcall((VALUE)func, id_call, 2, CLIPBOARD2RVAL(clipboard),
+               GOBJ2RVAL(pixbuf));
+}
+
+static VALUE
+clipboard_request_image(self)
+    VALUE self;
+{
+    VALUE func = rb_block_proc();
+    G_RELATIVE(self, func);
+    gtk_clipboard_request_image(_SELF(self),
+                               (GtkClipboardImageReceivedFunc)clipboard_image_received_func,
+                               (gpointer)func);
+    return self;
+}
+#endif
+
+#if GTK_CHECK_VERSION(2,4,0)
+static void
+clipboard_target_received_func(clipboard, atoms, n_atoms, func)
+    GtkClipboard* clipboard;
+    GdkAtom* atoms;
+    gint n_atoms;
+    gpointer func;
+{
+    gint i;
+    VALUE ary = rb_ary_new();
+    for (i = 0; i < n_atoms; i++){
+        rb_ary_push(ary, BOXED2RVAL(atoms[i], GDK_TYPE_ATOM));
+    }
+        
+    rb_funcall((VALUE)func, id_call, 2, CLIPBOARD2RVAL(clipboard), ary);
+}
+
+static VALUE
+clipboard_request_targets(self)
+    VALUE self;
+{
+    VALUE func = rb_block_proc();
+    G_RELATIVE(self, func);
+
+    gtk_clipboard_request_targets(_SELF(self),
+                                  (GtkClipboardTargetsReceivedFunc)clipboard_target_received_func, 
+                                  (gpointer)func);
+    return self;
+}
+#endif
+
+#if GTK_CHECK_VERSION(2,10,0)
+static void
+clipboard_rich_text_received_func(clipboard, format, text, length, func)
+    GtkClipboard* clipboard;
+    GdkAtom format;
+    const guint8 *text;
+    gsize length;
+    gpointer func;
+{
+    rb_funcall((VALUE)func, id_call, 3, CLIPBOARD2RVAL(clipboard), 
+               BOXED2RVAL(format, GDK_TYPE_ATOM), rb_str_new((char*)text, length));
+}
+
+static VALUE
+clipboard_request_rich_text(self, buffer)
+    VALUE self, buffer;
+{
+    VALUE func = rb_block_proc();
+    G_RELATIVE(self, func);
+
+    gtk_clipboard_request_rich_text(_SELF(self), GTK_TEXT_BUFFER(RVAL2GOBJ(buffer)),
+                                    (GtkClipboardRichTextReceivedFunc)clipboard_rich_text_received_func,
+                                    (gpointer)func);
+    return self;
+}
+#endif
+
+static VALUE
+clipboard_wait_for_contents(self, target)
+    VALUE self, target;
+{
+    return BOXED2RVAL(gtk_clipboard_wait_for_contents(
+                          _SELF(self), 
+                          RVAL2ATOM(target)), 
+                      GTK_TYPE_SELECTION_DATA);
+}
+
+static VALUE
+clipboard_wait_for_text(self)
+    VALUE self;
+{
+    gchar *str;
+    str = gtk_clipboard_wait_for_text(_SELF(self));
+    return str ? CSTR2RVAL(str) : Qnil;
+}
+
+#if GTK_CHECK_VERSION(2,6,0)
+static VALUE
+clipboard_wait_for_image(self)
+    VALUE self;
+{
+    GdkPixbuf* pixbuf = gtk_clipboard_wait_for_image(_SELF(self));
+    return GOBJ2RVAL(pixbuf);
+}
+#endif
+
+#if GTK_CHECK_VERSION(2,10,0)
+static VALUE
+clipboard_wait_for_rich_text(self, buffer)
+    VALUE self, buffer;
+{
+    GdkAtom format;
+    gsize length;
+    guint8* data = gtk_clipboard_wait_for_rich_text(_SELF(self), 
+                                                    GTK_TEXT_BUFFER(RVAL2GOBJ(buffer)),
+                                                                    &format, &length);
+    if (data){
+        VALUE str = rb_str_new((char*)data, length);
+        g_free(data);
+        return rb_assoc_new(str, BOXED2RVAL(format, GDK_TYPE_ATOM));
+    } else {
+        return rb_assoc_new(Qnil, BOXED2RVAL(format, GDK_TYPE_ATOM));
+    }
+    
+}
+#endif
+
+static VALUE
+clipboard_wait_is_text_available(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gtk_clipboard_wait_is_text_available(_SELF(self)));
+}
+
+#if GTK_CHECK_VERSION(2,6,0)
+static VALUE
+clipboard_wait_is_image_available(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gtk_clipboard_wait_is_image_available(_SELF(self)));
+}
+#endif
+
+#if GTK_CHECK_VERSION(2,10,0)
+static VALUE
+clipboard_wait_is_rich_text_available(self, buffer)
+    VALUE self, buffer;
+{
+    return CBOOL2RVAL(gtk_clipboard_wait_is_rich_text_available(_SELF(self), GTK_TEXT_BUFFER(RVAL2GOBJ(buffer))));
+}
+#endif
+
+#if GTK_CHECK_VERSION(2,4,0)
+static VALUE
+clipboard_wait_for_targets(self)
+    VALUE self;
+{
+    gint i;
+    VALUE ary = Qnil;
+    GdkAtom* targets;
+    gint n_targets = 0;
+    gboolean ret = gtk_clipboard_wait_for_targets(_SELF(self), &targets, &n_targets);
+
+    if (ret){
+        ary = rb_ary_new();
+        for (i = 0; i < n_targets; i++){
+            if ((GdkAtom)targets == (GdkAtom)GDK_NONE){
+                rb_ary_push(ary, rb_eval_string("Gdk::Atom::NONE"));
+            }
+            else
+                rb_ary_push(ary, BOXED2RVAL(targets, GDK_TYPE_ATOM));
+            targets++;
+        } 
+        /* How can I this ?
+        g_free(&o_targets);
+        */
+    }
+    return ary;
+}
+#endif
+
+#if GTK_CHECK_VERSION(2,6,0)
+static VALUE
+clipboard_wait_is_target_available(self, target)
+    VALUE self, target;
+{
+    return CBOOL2RVAL(gtk_clipboard_wait_is_target_available(_SELF(self), RVAL2ATOM(target)));
+}
+
+static VALUE
+clipboard_set_can_store(self, targets)
+    VALUE self, targets;
+{
+    gint n_targets = 0;
+    GtkTargetEntry* entries = (GtkTargetEntry*)NULL;
+
+    if (!NIL_P(targets)){
+        n_targets = RARRAY_LEN(targets);
+        entries = rbgtk_get_target_entry(targets);
+    }
+    gtk_clipboard_set_can_store(_SELF(self), entries, n_targets);
+    return self;
+}
+
+static VALUE
+clipboard_store(self)
+    VALUE self;
+{
+    gtk_clipboard_store(_SELF(self));
+    return self;
+}
+#endif
+
+void 
+Init_gtk_clipboard()
+{
+    VALUE gClipboard = G_DEF_CLASS(GTK_TYPE_CLIPBOARD, "Clipboard", mGtk);
+
+    rb_define_singleton_method(gClipboard, "get", clipboard_get, -1);
+    rb_define_method(gClipboard, "display", clipboard_get_display, 0);
+    rb_define_method(gClipboard, "set", clipboard_set, 1);
+/*
+  rb_define_method(gClipboard, "owner", clipboard_get_owner, 0);
+*/
+    rb_define_method(gClipboard, "clear", clipboard_clear, 0);
+    rb_define_method(gClipboard, "set_text", clipboard_set_text, 1);
+#if GTK_CHECK_VERSION(2,6,0)
+    rb_define_method(gClipboard, "set_image", clipboard_set_image, 1);
+#endif
+    rb_define_method(gClipboard, "request_contents", clipboard_request_contents, 1);
+    rb_define_method(gClipboard, "request_text", clipboard_request_text, 0);
+#if GTK_CHECK_VERSION(2,6,0)
+    rb_define_method(gClipboard, "request_image", clipboard_request_image, 0);
+#endif
+#if GTK_CHECK_VERSION(2,4,0)
+    rb_define_method(gClipboard, "request_targets", clipboard_request_targets, 0);
+#endif
+#if GTK_CHECK_VERSION(2,10,0)
+    rb_define_method(gClipboard, "request_rich_text", clipboard_request_rich_text, 1);
+#endif
+    rb_define_method(gClipboard, "wait_for_contents", clipboard_wait_for_contents, 1);
+    rb_define_method(gClipboard, "wait_for_text", clipboard_wait_for_text, 0);
+#if GTK_CHECK_VERSION(2,6,0)
+    rb_define_method(gClipboard, "wait_for_image", clipboard_wait_for_image, 0);
+#endif
+#if GTK_CHECK_VERSION(2,10,0)
+    rb_define_method(gClipboard, "wait_for_rich_text", clipboard_wait_for_rich_text, 1);
+#endif
+    rb_define_method(gClipboard, "wait_is_text_available?", clipboard_wait_is_text_available, 0);
+#if GTK_CHECK_VERSION(2,6,0)
+    rb_define_method(gClipboard, "wait_is_image_available?", clipboard_wait_is_image_available, 0);
+#endif
+#if GTK_CHECK_VERSION(2,10,0)
+    rb_define_method(gClipboard, "wait_is_rich_text_available?", clipboard_wait_is_rich_text_available, 1);
+#endif
+#if GTK_CHECK_VERSION(2,4,0)
+    rb_define_method(gClipboard, "wait_for_targets", clipboard_wait_for_targets, 0);
+#endif
+#if GTK_CHECK_VERSION(2,6,0)
+    rb_define_method(gClipboard, "wait_is_target_available?", clipboard_wait_is_target_available, 1);
+    rb_define_method(gClipboard, "set_can_store", clipboard_set_can_store, 1);
+    rb_define_method(gClipboard, "store", clipboard_store, 0);
+#endif
+
+    G_DEF_SETTERS(gClipboard);
+}