gtk3 2.2.4-x64-mingw32

data/ext/gtk3/rbgtk-cell-renderer-text.c

@@ -0,0 +1,48 @@
+/* -*- 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 cCellRendererText
+#define _SELF(s) (RVAL2GTKCELLRENDERERTEXT(s))
+
+static VALUE
+rg_initialize(VALUE self)
+{
+    RBGTK_INITIALIZE(self, gtk_cell_renderer_text_new());
+    return Qnil;
+}
+
+static VALUE
+rg_set_fixed_height_from_font(VALUE self, VALUE 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 mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_CELL_RENDERER_TEXT, "CellRendererText", mGtk);
+
+    RG_DEF_METHOD(initialize, 0);
+    RG_DEF_METHOD(set_fixed_height_from_font, 1);
+}

data/ext/gtk3/rbgtk-cell-renderer-toggle.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 cCellRendererToggle
+#define _SELF(s) (RVAL2GTKCELLRENDERERTOGGLE(s))
+
+static VALUE
+rg_initialize(VALUE self)
+{
+    RBGTK_INITIALIZE(self, gtk_cell_renderer_toggle_new());
+    return Qnil;
+}
+
+void
+Init_gtk_cellrenderertoggle(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_CELL_RENDERER_TOGGLE, "CellRendererToggle", mGtk);
+    RG_DEF_METHOD(initialize, 0);
+}

data/ext/gtk3/rbgtk-cell-renderer.c

@@ -0,0 +1,119 @@
+/* -*- 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 cCellRenderer
+#define _SELF(s) (RVAL2GTKCELLRENDERER(s))
+
+static VALUE
+rg_get_preferred_size(VALUE self, VALUE widget)
+{
+    GtkRequisition minimum_size, natural_size;
+
+    gtk_cell_renderer_get_preferred_size(_SELF(self),
+                                         RVAL2GTKWIDGET(widget),
+                                         &minimum_size, &natural_size);
+
+    return rb_ary_new3(2,
+                       GTKREQUISITION2RVAL(&minimum_size),
+                       GTKREQUISITION2RVAL(&natural_size));
+}
+
+/* TODO
+static VALUE
+rg_render(VALUE self, VALUE window, VALUE widget, VALUE background_area, VALUE cell_area, VALUE expose_area, VALUE flags)
+{
+    gtk_cell_renderer_render(_SELF(self), RVAL2GDKWINDOW(window),
+                             RVAL2GTKWIDGET(widget),
+                             RVAL2GDKRECTANGLE(background_area),
+                             RVAL2GDKRECTANGLE(cell_area),
+                             RVAL2GDKRECTANGLE(expose_area),
+                             RVAL2GTKCELLRENDERERSTATE(flags));
+    return self;
+}
+*/
+
+static VALUE
+rg_activate(VALUE self, VALUE event, VALUE widget, VALUE path, VALUE background_area, VALUE cell_area, VALUE flags)
+{
+    gboolean ret =
+    gtk_cell_renderer_activate(_SELF(self), (GdkEvent*)RVAL2GEV(event),
+                               RVAL2GTKWIDGET(widget),
+                               RVAL2CSTR(path), RVAL2GDKRECTANGLE(background_area),
+                               RVAL2GDKRECTANGLE(cell_area), 
+                               RVAL2GTKCELLRENDERERSTATE(flags));
+    return CBOOL2RVAL(ret);
+}
+
+static VALUE
+rg_start_editing(VALUE self, VALUE event, VALUE widget, VALUE path, VALUE background_area, VALUE cell_area, VALUE flags)
+{
+    GtkCellEditable* edit =
+    gtk_cell_renderer_start_editing(_SELF(self), (GdkEvent*)RVAL2GEV(event),
+                               RVAL2GTKWIDGET(widget),
+                               RVAL2CSTR(path), RVAL2GDKRECTANGLE(background_area),
+                               RVAL2GDKRECTANGLE(cell_area), 
+                               RVAL2GTKCELLRENDERERSTATE(flags));
+    return edit ? GOBJ2RVAL(edit) : Qnil;
+}
+
+static VALUE
+rg_stop_editing(VALUE self, VALUE canceled)
+{
+    gtk_cell_renderer_stop_editing(_SELF(self), RVAL2CBOOL(canceled));
+    return self;
+}
+
+static VALUE
+rg_fixed_size(VALUE self)
+{
+    int width, height;
+    gtk_cell_renderer_get_fixed_size(_SELF(self), &width, &height);
+    return rb_ary_new3(2, INT2NUM(width), INT2NUM(height));
+}
+
+static VALUE
+rg_set_fixed_size(VALUE self, VALUE width, VALUE height)
+{
+    gtk_cell_renderer_set_fixed_size(_SELF(self), NUM2INT(width), 
+                                     NUM2INT(height));
+    return self;
+}
+
+void
+Init_gtk_cellrenderer(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_CELL_RENDERER, "CellRenderer", mGtk);
+
+    RG_DEF_METHOD(get_preferred_size, 1);
+/* TODO
+    RG_DEF_METHOD(render, 6);
+*/
+    RG_DEF_METHOD(activate, 6);
+    RG_DEF_METHOD(start_editing, 6);
+    RG_DEF_METHOD(stop_editing, 1);
+    RG_DEF_METHOD(fixed_size, 0);
+    RG_DEF_METHOD(set_fixed_size, 2);
+
+    G_DEF_CLASS(GTK_TYPE_CELL_RENDERER_STATE, "State", RG_TARGET_NAMESPACE);
+    G_DEF_CLASS(GTK_TYPE_CELL_RENDERER_MODE, "Mode", RG_TARGET_NAMESPACE);
+}

data/ext/gtk3/rbgtk-cell-view.c

@@ -0,0 +1,95 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2005,2006 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 cCellView
+#define _SELF(self) (RVAL2GTKCELLVIEW(self))
+
+static ID id_model;
+static ID id_text;
+
+static VALUE
+rg_initialize(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(RVAL2GDKPIXBUF(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
+rg_set_displayed_row(VALUE self, VALUE path)
+{
+    gtk_cell_view_set_displayed_row(_SELF(self),  
+                                    NIL_P(path) ? (GtkTreePath*)NULL :
+                                    RVAL2GTKTREEPATH(path));
+    return self;
+}
+
+static VALUE
+rg_displayed_row(VALUE self)
+{
+    return GTKTREEPATH2RVAL(gtk_cell_view_get_displayed_row(_SELF(self)));
+}
+
+/* Use Gtk::CellView#background_gdk(Gdk::Color) instead.
+void        gtk_cell_view_set_background_color
+                                            (GtkCellView *cell_view,
+                                             const GdkColor *color);
+*/
+
+void
+Init_gtk_cellview(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_CELL_VIEW, "CellView", mGtk);
+
+    id_model = rb_intern("model");
+    id_text = rb_intern("text");
+
+    RG_DEF_METHOD(initialize, -1);
+    RG_DEF_METHOD(set_displayed_row, 1);
+    RG_DEF_METHOD(displayed_row, 0);
+}

data/ext/gtk3/rbgtk-check-button.c

@@ -0,0 +1,64 @@
+/* -*- 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 cCheckButton
+
+static VALUE
+rg_initialize(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 mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_CHECK_BUTTON, "CheckButton", mGtk);
+
+    RG_DEF_METHOD(initialize, -1);
+}

data/ext/gtk3/rbgtk-check-menu-item.c

@@ -0,0 +1,64 @@
+/* -*- 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 cCheckMenuItem
+
+static VALUE
+rg_initialize(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
+rg_toggled(VALUE self)
+{
+    gtk_check_menu_item_toggled(RVAL2GTKCHECKMENUITEM(self));
+    return self;
+}
+
+void
+Init_gtk_check_menu_item(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_CHECK_MENU_ITEM, "CheckMenuItem", mGtk);
+
+    RG_DEF_METHOD(initialize, -1);
+    RG_DEF_METHOD(toggled, 0);
+}

data/ext/gtk3/rbgtk-clip-board.c

@@ -0,0 +1,389 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2004,2006 Ruby-GNOME2 Project
+ *  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 cClipboard
+#define _SELF(s) RVAL2GTKCLIPBOARD(s)
+
+static VALUE
+rg_s_get(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
+{
+    GtkClipboard *clipboard;
+
+    if (argc == 1){
+        VALUE selection;
+        rb_scan_args(argc, argv, "10", &selection);
+        clipboard = gtk_clipboard_get(RVAL2ATOM(selection));
+    } else {
+        VALUE display, selection;
+        rb_scan_args(argc, argv, "20", &display, &selection);
+        clipboard = gtk_clipboard_get_for_display(RVAL2GDKDISPLAYOBJECT(display),
+                                                  RVAL2ATOM(selection));
+    } 
+    return GOBJ2RVAL(clipboard);
+}
+
+static VALUE
+rg_display(VALUE self)
+{
+    return GOBJ2RVAL(gtk_clipboard_get_display(_SELF(self)));
+}
+
+static void
+clipboard_get_func(GtkClipboard *clipboard, GtkSelectionData *selection_data, G_GNUC_UNUSED guint info, gpointer func)
+{
+    rb_funcall((VALUE)func, id_call, 2, GOBJ2RVAL(clipboard),
+               GTKSELECTIONDATA2RVAL(selection_data));
+}
+
+struct clipboard_set_args {
+    VALUE self;
+    VALUE targets;
+    VALUE func;
+};
+
+static VALUE
+clipboard_set_body(VALUE value)
+{
+    struct clipboard_set_args *args = (struct clipboard_set_args *)value;
+    GtkClipboard *clipboard = _SELF(args->self);
+    long n;
+    GtkTargetEntry *targets = RVAL2GTKTARGETENTRIES(args->targets, &n);
+    gboolean result = gtk_clipboard_set_with_data(clipboard,
+                                                  targets,
+                                                  n,
+                                                  (GtkClipboardGetFunc)clipboard_get_func,
+                                                  (GtkClipboardClearFunc)NULL,
+                                                  (gpointer)args->func);
+
+    g_free(targets);
+
+    return CBOOL2RVAL(result);
+}
+
+static G_GNUC_NORETURN VALUE
+clipboard_set_rescue(VALUE value)
+{
+    struct clipboard_set_args *args = (struct clipboard_set_args *)value;
+
+    G_CHILD_REMOVE(args->self, args->func);
+
+    rb_exc_raise(rb_errinfo());
+}
+
+static VALUE
+rg_set(VALUE self, VALUE targets)
+{
+    struct clipboard_set_args args = { self, targets, rb_block_proc() };
+
+    G_CHILD_ADD(self, args.func);
+
+    return rb_rescue(clipboard_set_body, (VALUE)&args,
+                     clipboard_set_rescue, (VALUE)&args);
+}
+
+/*
+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
+rg_owner(VALUE self)
+{
+    GObject *gobj;
+    gobj = gtk_clipboard_get_owner(_SELF(self));
+    return gobj ? GOBJ2RVAL(gobj) : Qnil;
+}
+*/
+
+static VALUE
+rg_clear(VALUE self)
+{
+    gtk_clipboard_clear(_SELF(self));
+    return self;
+}
+
+static VALUE
+rg_set_text(VALUE self, VALUE text)
+{
+    StringValue(text);
+    gtk_clipboard_set_text(_SELF(self), RVAL2CSTR(text), RSTRING_LEN(text));
+    return self;
+}
+
+static VALUE
+rg_set_image(VALUE self, VALUE pixbuf)
+{
+    gtk_clipboard_set_image(_SELF(self), RVAL2GDKPIXBUF(pixbuf));
+    return self;
+}
+
+static void
+clipboard_received_func(GtkClipboard *clipboard, GtkSelectionData *selection_data, gpointer func)
+{
+    rb_funcall((VALUE)func, id_call, 2, GOBJ2RVAL(clipboard),
+               GTKSELECTIONDATA2RVAL(selection_data));
+}
+
+static VALUE
+rg_request_contents(VALUE self, VALUE 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);
+    }
+
+    rb_funcall((VALUE)func, id_call, 2, GOBJ2RVAL(clipboard), vtext);
+}
+
+static VALUE
+rg_request_text(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;
+}
+
+static void
+clipboard_image_received_func(GtkClipboard *clipboard, GdkPixbuf *pixbuf, gpointer func)
+{
+    rb_funcall((VALUE)func, id_call, 2, GOBJ2RVAL(clipboard),
+               GOBJ2RVAL(pixbuf));
+}
+
+static VALUE
+rg_request_image(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;
+}
+
+static void
+clipboard_target_received_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, GDKATOM2RVAL(atoms[i]));
+    }
+
+    rb_funcall((VALUE)func, id_call, 2, GOBJ2RVAL(clipboard), ary);
+}
+
+static VALUE
+rg_request_targets(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;
+}
+
+static void
+clipboard_rich_text_received_func(GtkClipboard *clipboard, GdkAtom format, const guint8 *text, gsize length, gpointer func)
+{
+    rb_funcall((VALUE)func, id_call, 3, GOBJ2RVAL(clipboard), 
+               GDKATOM2RVAL(format), rb_str_new((char*)text, length));
+}
+
+static VALUE
+rg_request_rich_text(VALUE self, VALUE buffer)
+{
+    VALUE func = rb_block_proc();
+    G_RELATIVE(self, func);
+
+    gtk_clipboard_request_rich_text(_SELF(self), RVAL2GTKTEXTBUFFER(buffer),
+                                    (GtkClipboardRichTextReceivedFunc)clipboard_rich_text_received_func,
+                                    (gpointer)func);
+    return self;
+}
+
+static VALUE
+rg_wait_for_contents(VALUE self, VALUE target)
+{
+    return GTKSELECTIONDATA2RVAL(gtk_clipboard_wait_for_contents(_SELF(self),
+                                                                 RVAL2ATOM(target)));
+}
+
+static VALUE
+rg_wait_for_text(VALUE self)
+{
+    gchar *str;
+    str = gtk_clipboard_wait_for_text(_SELF(self));
+    return str ? CSTR2RVAL(str) : Qnil;
+}
+
+static VALUE
+rg_wait_for_image(VALUE self)
+{
+    GdkPixbuf* pixbuf = gtk_clipboard_wait_for_image(_SELF(self));
+    return GOBJ2RVAL(pixbuf);
+}
+
+static VALUE
+rg_wait_for_rich_text(VALUE self, VALUE buffer)
+{
+    GdkAtom format;
+    gsize length;
+    guint8* data = gtk_clipboard_wait_for_rich_text(_SELF(self), 
+                                                    RVAL2GTKTEXTBUFFER(buffer),
+                                                                    &format, &length);
+    if (data){
+        VALUE str = rb_str_new((char*)data, length);
+        g_free(data);
+        return rb_assoc_new(str, GDKATOM2RVAL(format));
+    } else {
+        return rb_assoc_new(Qnil, GDKATOM2RVAL(format));
+    }
+
+}
+
+static VALUE
+rg_wait_is_text_available_p(VALUE self)
+{
+    return CBOOL2RVAL(gtk_clipboard_wait_is_text_available(_SELF(self)));
+}
+
+static VALUE
+rg_wait_is_image_available_p(VALUE self)
+{
+    return CBOOL2RVAL(gtk_clipboard_wait_is_image_available(_SELF(self)));
+}
+
+static VALUE
+rg_wait_is_rich_text_available_p(VALUE self, VALUE buffer)
+{
+    return CBOOL2RVAL(gtk_clipboard_wait_is_rich_text_available(_SELF(self), RVAL2GTKTEXTBUFFER(buffer)));
+}
+
+static VALUE
+rg_wait_for_targets(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, GDKATOM2RVAL(targets));
+            targets++;
+        } 
+        /* How can I this ?
+        g_free(&o_targets);
+        */
+    }
+    return ary;
+}
+
+static VALUE
+rg_wait_is_target_available_p(VALUE self, VALUE target)
+{
+    return CBOOL2RVAL(gtk_clipboard_wait_is_target_available(_SELF(self), RVAL2ATOM(target)));
+}
+
+static VALUE
+rg_set_can_store(VALUE self, VALUE rbtargets)
+{
+    GtkClipboard *clipboard = _SELF(self);
+    long n = 0;
+    GtkTargetEntry *targets = RVAL2GTKTARGETENTRIES_ACCEPT_NIL(rbtargets, &n);
+
+    gtk_clipboard_set_can_store(clipboard, targets, n);
+
+    g_free(targets);
+
+    return self;
+}
+
+static VALUE
+rg_store(VALUE self)
+{
+    gtk_clipboard_store(_SELF(self));
+
+    return self;
+}
+
+void
+Init_gtk_clipboard(VALUE mGtk)
+{
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GTK_TYPE_CLIPBOARD, "Clipboard", mGtk);
+
+    RG_DEF_SMETHOD(get, -1);
+    RG_DEF_METHOD(display, 0);
+    RG_DEF_METHOD(set, 1);
+/*
+  RG_DEF_METHOD(owner, 0);
+*/
+    RG_DEF_METHOD(clear, 0);
+    RG_DEF_METHOD(set_text, 1);
+    RG_DEF_METHOD(set_image, 1);
+    RG_DEF_METHOD(request_contents, 1);
+    RG_DEF_METHOD(request_text, 0);
+    RG_DEF_METHOD(request_image, 0);
+    RG_DEF_METHOD(request_targets, 0);
+    RG_DEF_METHOD(request_rich_text, 1);
+    RG_DEF_METHOD(wait_for_contents, 1);
+    RG_DEF_METHOD(wait_for_text, 0);
+    RG_DEF_METHOD(wait_for_image, 0);
+    RG_DEF_METHOD(wait_for_rich_text, 1);
+    RG_DEF_METHOD_P(wait_is_text_available, 0);
+    RG_DEF_METHOD_P(wait_is_image_available, 0);
+    RG_DEF_METHOD_P(wait_is_rich_text_available, 1);
+    RG_DEF_METHOD(wait_for_targets, 0);
+    RG_DEF_METHOD_P(wait_is_target_available, 1);
+    RG_DEF_METHOD(set_can_store, 1);
+    RG_DEF_METHOD(store, 0);
+}