gtk2 0.20.0

data/src/rbgtkconversions.h

@@ -0,0 +1,26 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkconversions.h -
+
+  Copyright (C) 2008 Ruby-GNOME2 Project Team
+************************************************/
+
+#ifndef _RBGTKCONVERSIONS_H
+#define _RBGTKCONVERSIONS_H
+
+#include <rbgobject.h>
+#include <gtk/gtk.h>
+
+#include <rbgdkconversions.h>
+
+#define GTKTREEPATH2RVAL(t) (BOXED2RVAL(t, GTK_TYPE_TREE_PATH))
+#define RVAL2GTKTREEPATH(t) ((GtkTreePath *)RVAL2BOXED(t, GTK_TYPE_TREE_PATH))
+#define GTKTREEITER2RVAL(i) (BOXED2RVAL(i, GTK_TYPE_TREE_ITER))
+#define RVAL2GTKTREEITER(i) ((GtkTreeIter *)RVAL2BOXED(i, GTK_TYPE_TREE_ITER))
+
+#define RVAL2GTKSTATETYPE(type) (RVAL2GENUM(type, GTK_TYPE_STATE_TYPE))
+#define GTKRCFLAGS2RVAL(flags) (GFLAGS2RVAL(flags, GTK_TYPE_RC_FLAGS))
+#define RVAL2GTKRCFLAGS(flags) (RVAL2GFLAGS(flags, GTK_TYPE_RC_FLAGS))
+
+#endif /* _RBGTKCONVERSIONS_H */

data/src/rbgtkcurve.c

@@ -0,0 +1,105 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkcurve.c -
+
+  $Author: mutoh $
+  $Date: 2006/05/07 23:51:20 $
+
+  Copyright (C) 2002,2003 Ruby-GNOME2 Project Team
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+
+#include "global.h"
+
+static VALUE
+curve_initialize(self)
+    VALUE self;
+{
+    RBGTK_INITIALIZE(self, gtk_curve_new());
+    return Qnil;
+}
+
+static VALUE
+curve_reset(self)
+    VALUE self;
+{
+    gtk_curve_reset(GTK_CURVE(RVAL2GOBJ(self)));
+    return self;
+}
+
+static VALUE
+curve_set_gamma(self, gamma)
+    VALUE self, gamma;
+{
+    gtk_curve_set_gamma(GTK_CURVE(RVAL2GOBJ(self)), NUM2DBL(gamma));
+    return self;
+}
+
+static VALUE
+curve_set_range(self, min_x, max_x, min_y, max_y)
+    VALUE self, min_x, max_x, min_y, max_y;
+{
+    gtk_curve_set_range(GTK_CURVE(RVAL2GOBJ(self)),
+			NUM2DBL(min_x), NUM2DBL(max_x),
+			NUM2DBL(min_y), NUM2DBL(max_y));
+    return self;
+}
+
+static VALUE
+curve_set_vector(self, length, vector)
+    VALUE self, length, vector;
+{
+    gint len = NUM2INT(length);
+    gfloat *c_vec;
+    gint i;
+
+    c_vec = ALLOCA_N(gfloat, len);
+    for (i = 0; i < len; i++)
+      c_vec[i] = NUM2DBL(RARRAY_PTR(vector)[i]);
+
+    gtk_curve_set_vector(GTK_CURVE(RVAL2GOBJ(self)), len, c_vec);
+
+    return self;
+}
+
+static VALUE
+curve_get_vector(self, length)
+    VALUE self, length;
+{
+    gint len = NUM2INT(length);
+    gfloat *c_vec;
+    gint i;
+    VALUE vector = rb_ary_new2(len);
+
+    c_vec = ALLOCA_N(gfloat, len);
+    gtk_curve_get_vector(GTK_CURVE(RVAL2GOBJ(self)), len, c_vec);
+    for (i = 0; i < len; i++)
+      rb_ary_push(vector, rb_float_new(c_vec[i]));
+
+    return vector;
+}
+
+void 
+Init_gtk_curve()
+{
+    VALUE gCurve = G_DEF_CLASS(GTK_TYPE_CURVE, "Curve", mGtk);
+
+    rb_define_method(gCurve, "initialize", curve_initialize, 0);
+    rb_define_method(gCurve, "reset", curve_reset, 0);
+    rb_define_method(gCurve, "set_gamma", curve_set_gamma, 1);
+    rb_define_method(gCurve, "set_range", curve_set_range, 4);
+    rb_define_method(gCurve, "set_vector", curve_set_vector, 2);
+    rb_define_method(gCurve, "get_vector", curve_get_vector, 1);
+
+    /* GtkCurveType(from standard constants) */
+
+    G_DEF_CLASS(GTK_TYPE_CURVE_TYPE, "Type", gCurve);
+    G_DEF_CONSTANTS(gCurve, GTK_TYPE_CURVE_TYPE, "GTK_CURVE_");
+
+    G_DEF_SETTERS(gCurve);
+}
+
+

data/src/rbgtkdialog.c

@@ -0,0 +1,244 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkdialog.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:31 $
+
+  Copyright (C) 2002-2005 Ruby-GNOME2 Project Team
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+
+#include "global.h"
+
+#define _SELF(self) (GTK_DIALOG(RVAL2GOBJ(self)))
+
+static ID id_to_a;
+
+static VALUE
+dialog_add_button(self, button_text, response_id)
+    VALUE self, button_text, response_id;
+{
+    const gchar *name;
+    if (SYMBOL_P(button_text)) {
+        name = rb_id2name(SYM2ID(button_text));
+    } else {
+        name = RVAL2CSTR(button_text);
+    }
+    return GOBJ2RVAL(gtk_dialog_add_button(_SELF(self), name, 
+                                           RVAL2GENUM(response_id, GTK_TYPE_RESPONSE_TYPE)));
+}
+
+VALUE
+rbgtk_dialog_add_buttons_internal(self, button_ary)
+    VALUE self, button_ary;
+{
+    int i;
+    GObject* obj = RVAL2GOBJ(self);
+    if (RARRAY_PTR(button_ary)[0] != Qnil){
+        g_object_freeze_notify(obj);
+        for (i = 0; i < RARRAY_LEN(button_ary); i++) {
+            Check_Type(RARRAY_PTR(button_ary)[i], T_ARRAY);
+            dialog_add_button(self, RARRAY_PTR(RARRAY_PTR(button_ary)[i])[0],
+                              RARRAY_PTR(RARRAY_PTR(button_ary)[i])[1]);
+        }
+        g_object_thaw_notify(obj);
+    }
+    return self;
+}    
+
+static VALUE
+dialog_add_buttons(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE button_ary;
+    rb_scan_args(argc, argv, "*", &button_ary);
+    rbgtk_dialog_add_buttons_internal(self, button_ary);
+    return self;
+}    
+
+static VALUE
+dialog_initialize(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE title, parent, flags, button_ary;
+    rb_scan_args(argc, argv, "03*", &title, &parent, &flags, &button_ary);
+
+    if (argc == 0){
+        RBGTK_INITIALIZE(self, gtk_dialog_new());
+    } else if (argc > 0){
+        GtkDialog* dialog = GTK_DIALOG(g_object_new(GTK_TYPE_DIALOG, NULL));
+        GtkDialogFlags gflags = NIL_P(flags) ? 0 : RVAL2GFLAGS(flags, GTK_TYPE_DIALOG_FLAGS);
+        if (! NIL_P(title))
+            gtk_window_set_title(GTK_WINDOW(dialog), RVAL2CSTR(title));
+        if (! NIL_P(parent))
+            gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(RVAL2GOBJ(parent)));
+        
+        if (gflags & GTK_DIALOG_MODAL)
+            gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
+        if (gflags & GTK_DIALOG_DESTROY_WITH_PARENT)
+            gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE);
+        if (gflags & GTK_DIALOG_NO_SEPARATOR)
+            gtk_dialog_set_has_separator(dialog, FALSE);
+
+        RBGTK_INITIALIZE(self, dialog);
+        if (! NIL_P(button_ary))
+            rbgtk_dialog_add_buttons_internal(self, button_ary);
+    } else {
+        rb_raise(rb_eArgError, "invalid argument number");
+    }
+    return Qnil;
+}
+
+static VALUE
+dialog_run(self)
+    VALUE self;
+{
+    if (rb_block_given_p()){
+        VALUE ret = INT2NUM(gtk_dialog_run(_SELF(self)));
+        rb_yield(ret);
+        return ret;
+    } else {
+        return INT2NUM(gtk_dialog_run(_SELF(self)));
+    }
+}
+
+static VALUE
+dialog_response(self, response_id)
+    VALUE self, response_id;
+{
+    gtk_dialog_response(_SELF(self), NUM2INT(response_id));
+    return self;
+}
+
+static VALUE
+dialog_add_action_widget(self, child, response_id)
+    VALUE self, child, response_id;
+{
+    gtk_dialog_add_action_widget(_SELF(self), GTK_WIDGET(RVAL2GOBJ(child)), 
+                                 NUM2INT(response_id));
+    return self;
+}
+
+static VALUE
+dialog_set_default_response(self, response_id)
+    VALUE self, response_id;
+{
+    gtk_dialog_set_default_response(_SELF(self), NUM2INT(response_id));
+    return self;
+}
+
+static VALUE
+dialog_set_response_sensitive(self, response_id, setting)
+    VALUE self, response_id, setting;
+{
+    gtk_dialog_set_response_sensitive(_SELF(self), NUM2INT(response_id), RVAL2CBOOL(setting));
+    return self;
+}
+
+#if GTK_CHECK_VERSION(2,6,0)
+static VALUE
+dialog_s_alternative_dialog_button_order(self, screen)
+    VALUE self, screen;
+{
+    gboolean ret = gtk_alternative_dialog_button_order(NIL_P(screen) ? NULL : 
+                                                       GDK_SCREEN(RVAL2GOBJ(screen)));
+    return CBOOL2RVAL(ret);
+}
+
+/* Use gtk_dialog_set_alternative_button_order_from_array() instead.
+void        gtk_dialog_set_alternative_button_order
+                                            (GtkDialog *dialog,
+                                             gint first_response_id,
+                                             ...);
+*/
+
+static VALUE
+dialog_set_alternative_button_order(self, new_order)
+    VALUE self, new_order;
+{
+    gint i;
+    gint len = RARRAY_LEN(new_order);
+    gint* gnew_order = g_new(gint, len);
+
+    for (i = 0; i < len; i++){
+        gnew_order[i] = NUM2INT(RARRAY_PTR(new_order)[i]);
+    }
+
+    gtk_dialog_set_alternative_button_order_from_array(_SELF(self), len, gnew_order);
+    g_free(gnew_order);
+    return self;
+}
+
+#endif
+
+static VALUE
+dialog_vbox(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(_SELF(self)->vbox);
+}
+
+static VALUE
+dialog_action_area(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(_SELF(self)->action_area);
+}
+
+#if GTK_CHECK_VERSION(2,8,0)
+static VALUE
+dialog_get_response_for_widget(self, widget)
+    VALUE self, widget;
+{
+    return INT2NUM(gtk_dialog_get_response_for_widget(_SELF(self), RVAL2GOBJ(widget)));
+}
+#endif
+
+void 
+Init_gtk_dialog()
+{
+    VALUE gDialog = G_DEF_CLASS(GTK_TYPE_DIALOG, "Dialog", mGtk);
+
+    id_to_a = rb_intern("to_a");
+
+    rb_define_method(gDialog, "initialize", dialog_initialize, -1);
+    rb_define_method(gDialog, "run", dialog_run, 0);
+    rb_define_method(gDialog, "response", dialog_response, 1);
+    rb_define_method(gDialog, "add_button", dialog_add_button, 2);
+    rb_define_method(gDialog, "add_buttons", dialog_add_buttons, -1);
+    rb_define_method(gDialog, "add_action_widget", dialog_add_action_widget, 2);
+    rb_define_method(gDialog, "set_default_response", dialog_set_default_response, 1);
+
+#if GTK_CHECK_VERSION(2,6,0)
+    rb_define_singleton_method(gDialog, "alternative_dialog_button_order?", 
+                               dialog_s_alternative_dialog_button_order, 1);
+    rb_define_method(gDialog, "set_alternative_button_order", dialog_set_alternative_button_order, 1);
+#endif
+
+    rb_define_method(gDialog, "set_response_sensitive", dialog_set_response_sensitive, 2);
+    rb_define_method(gDialog, "vbox", dialog_vbox, 0);
+    rb_define_method(gDialog, "action_area", dialog_action_area, 0);
+
+#if GTK_CHECK_VERSION(2,8,0)
+    rb_define_method(gDialog, "get_response", dialog_get_response_for_widget, 1);
+    rb_define_method(gDialog, "get_response_for_widget", dialog_get_response_for_widget, 1);
+#endif
+   
+    G_DEF_SETTERS(gDialog);
+   
+    /* GtkDialogFlags */
+    G_DEF_CLASS(GTK_TYPE_DIALOG_FLAGS, "Flags", gDialog);
+    G_DEF_CONSTANTS(gDialog, GTK_TYPE_DIALOG_FLAGS, "GTK_DIALOG_");
+
+    /* GtkResponseType */
+    G_DEF_CLASS(GTK_TYPE_RESPONSE_TYPE, "ResponseType", gDialog);
+    G_DEF_CONSTANTS(gDialog, GTK_TYPE_RESPONSE_TYPE, "GTK_");
+}

data/src/rbgtkdrag.c

@@ -0,0 +1,436 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgtkdrag.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 16:07:31 $
+
+  Copyright (C) 2002-2006 Masao Mutoh
+************************************************/
+
+
+#include "global.h"
+
+#define RVAL2DC(c) (GDK_DRAG_CONTEXT(RVAL2GOBJ(c)))
+#define RVAL2WIDGET(w) (GTK_WIDGET(RVAL2GOBJ(w)))
+
+GtkTargetEntry*
+rbgtk_get_target_entry(targets)
+	VALUE targets;
+{
+    VALUE ary;
+    VALUE e_target, e_flags, e_info;
+    GtkTargetEntry *entries;
+    int i, n_targets;
+    
+    if (NIL_P(targets)) return NULL;
+    Check_Type(targets, T_ARRAY);
+    
+    n_targets = RARRAY_LEN(targets);
+    entries = ALLOC_N(GtkTargetEntry, n_targets);
+    
+    for (i = 0; i < n_targets; i++) {
+        ary = rb_ary_entry(targets, i);
+        Check_Type(ary, T_ARRAY);
+        e_target = rb_ary_entry(ary, 0);
+        e_flags = rb_ary_entry(ary, 1);
+        e_info = rb_ary_entry(ary, 2);
+        
+        entries[i].target = NIL_P(e_target) ? NULL:RVAL2CSTR(e_target);
+        entries[i].flags = NIL_P(e_flags) ? 0:RVAL2GFLAGS(e_flags, GTK_TYPE_TARGET_FLAGS);
+        entries[i].info = NIL_P(e_info) ? 0:NUM2INT(e_info);
+
+    }
+    return entries;
+}
+
+static VALUE
+gtkdrag_dest_set(self, widget, flags, targets, actions)
+    VALUE self, widget, flags, targets, actions;
+{
+    int num;
+    GtkTargetEntry* entries = rbgtk_get_target_entry(targets);
+    if (entries){
+        num = RARRAY_LEN(targets);
+        
+        gtk_drag_dest_set(RVAL2WIDGET(widget), RVAL2GFLAGS(flags, GTK_TYPE_DEST_DEFAULTS), 
+                          entries, 
+                          num, RVAL2GFLAGS(actions, GDK_TYPE_DRAG_ACTION));
+    }
+    else
+    {
+        gtk_drag_dest_set(RVAL2WIDGET(widget), RVAL2GFLAGS(flags, GTK_TYPE_DEST_DEFAULTS), 
+                          NULL, 0, RVAL2GFLAGS(actions, GDK_TYPE_DRAG_ACTION));
+    }
+    return self;
+}
+
+static VALUE
+gtkdrag_dest_set_proxy(self, widget, proxy_window, protocol, use_coordinates)
+    VALUE self, widget, proxy_window, protocol, use_coordinates;
+{
+    gtk_drag_dest_set_proxy(RVAL2WIDGET(widget), 
+                            GDK_WINDOW(RVAL2GOBJ(proxy_window)),
+                            RVAL2GENUM(protocol, GDK_TYPE_DRAG_PROTOCOL), 
+                            RVAL2CBOOL(use_coordinates)); 
+    return self;
+}
+
+static VALUE
+gtkdrag_dest_unset(self, widget)
+    VALUE self,widget;
+{
+    gtk_drag_dest_unset(RVAL2WIDGET(widget));
+    return self;
+}
+
+static VALUE
+gtkdrag_dest_find_target(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE widget, context, target_list;
+    GdkAtom ret;
+    rb_scan_args(argc, argv, "21", &widget, &context, &target_list);
+
+    ret = gtk_drag_dest_find_target(
+        RVAL2WIDGET(widget), RVAL2DC(context),
+        NIL_P(target_list) ? NULL : RVAL2BOXED(target_list, GTK_TYPE_TARGET_LIST));
+ 
+    return BOXED2RVAL(ret, GDK_TYPE_ATOM);
+}
+
+static VALUE
+gtkdrag_dest_get_target_list(self, widget)
+    VALUE self, widget;
+{
+    GtkTargetList* list = gtk_drag_dest_get_target_list(RVAL2WIDGET(widget));
+    return BOXED2RVAL(list, GTK_TYPE_TARGET_LIST);
+}
+
+static VALUE
+gtkdrag_dest_set_target_list(self, widget, target_list)
+    VALUE self, widget, target_list;
+{
+    gtk_drag_dest_set_target_list(
+        RVAL2WIDGET(widget), 
+        NIL_P(target_list) ? NULL : RVAL2BOXED(target_list, GTK_TYPE_TARGET_LIST));
+
+    return self;
+}
+
+
+#if GTK_CHECK_VERSION(2,6,0)
+static VALUE
+gtkdrag_dest_add_text_targets(self, widget)
+    VALUE self, widget;
+{
+    gtk_drag_dest_add_text_targets(RVAL2WIDGET(widget));
+    return self;
+}
+static VALUE
+gtkdrag_dest_add_image_targets(self, widget)
+    VALUE self, widget;
+{
+    gtk_drag_dest_add_image_targets(RVAL2WIDGET(widget));
+    return self;
+}
+static VALUE
+gtkdrag_dest_add_uri_targets(self, widget)
+    VALUE self, widget;
+{
+    gtk_drag_dest_add_uri_targets(RVAL2WIDGET(widget));
+    return self;
+}
+#endif
+
+#if GTK_CHECK_VERSION(2,10,0)
+static VALUE
+gtkdrag_dest_set_track_motion(self, widget, track_motion)
+    VALUE self, widget, track_motion;
+{
+    gtk_drag_dest_set_track_motion(RVAL2WIDGET(widget), RVAL2CBOOL(track_motion));
+    return self;
+}
+
+static VALUE
+gtkdrag_dest_get_track_motion(self, widget)
+    VALUE self, widget;
+{
+    return CBOOL2RVAL(gtk_drag_dest_get_track_motion(RVAL2WIDGET(widget)));
+}
+#endif
+
+static VALUE
+gtkdrag_finish(self, context, success, del, time)
+    VALUE self, context, success, del, time;
+{
+    gtk_drag_finish(RVAL2DC(context), RVAL2CBOOL(success),
+                    RVAL2CBOOL(del), NUM2UINT(time));
+    return self;
+}
+
+static VALUE
+gtkdrag_get_data(self, widget, context, target, time)
+    VALUE self, widget, context, target, time;
+{
+    gtk_drag_get_data(RVAL2WIDGET(widget), RVAL2DC(context), RVAL2ATOM(target),
+                      NUM2UINT(time));
+    return self;
+}
+
+static VALUE
+gtkdrag_get_source_widget(self, context)
+    VALUE self, context;
+{
+    return GOBJ2RVAL(gtk_drag_get_source_widget(RVAL2DC(context)));
+}
+
+static VALUE
+gtkdrag_highlight(self, widget)
+    VALUE self, widget;
+{
+    gtk_drag_highlight(RVAL2WIDGET(widget));
+    return self;
+}
+
+static VALUE
+gtkdrag_unhighlight(self, widget)
+    VALUE self, widget;
+{
+    gtk_drag_unhighlight(RVAL2WIDGET(widget));
+    return self;
+}
+
+static VALUE
+gtkdrag_begin(self, widget, target_list, actions, button, event)
+    VALUE self, widget, target_list, actions, button, event;
+{
+    return GOBJ2RVAL(gtk_drag_begin(RVAL2WIDGET(widget),
+                                    RVAL2BOXED(target_list, GTK_TYPE_TARGET_LIST),
+                                    RVAL2GFLAGS(actions, GDK_TYPE_DRAG_ACTION),
+                                    NUM2INT(button),
+                                    RVAL2GEV(event)));
+}
+
+static VALUE
+gtkdrag_set_icon(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE context, obj, pixmap = Qnil, mask = Qnil, hot_x, hot_y;
+
+    if (argc == 6) {
+        rb_scan_args(argc, argv, "60", &context, &obj, &pixmap, &mask, &hot_x, &hot_y);
+        gtk_drag_set_icon_pixmap(RVAL2DC(context),
+                                 GDK_COLORMAP(RVAL2GOBJ(obj)), 
+                                 GDK_PIXMAP(RVAL2GOBJ(pixmap)),
+                                 GDK_BITMAP(RVAL2GOBJ(mask)), 
+                                 NUM2INT(hot_x), NUM2INT(hot_y));
+    } else {
+        rb_scan_args(argc, argv, "40", &context, &obj, &hot_x, &hot_y);
+
+        if (TYPE(obj) == T_SYMBOL){
+            gtk_drag_set_icon_stock(RVAL2DC(context), rb_id2name(SYM2ID(obj)),
+                                    NUM2INT(hot_x), NUM2INT(hot_y));
+        } else if (rb_obj_is_kind_of(obj, GTYPE2CLASS(GTK_TYPE_WIDGET))){
+            gtk_drag_set_icon_widget(RVAL2DC(context), RVAL2WIDGET(obj),
+                                     NUM2INT(hot_x), NUM2INT(hot_y));
+        } else if (rb_obj_is_kind_of(obj, GTYPE2CLASS(GDK_TYPE_PIXBUF))){
+            gtk_drag_set_icon_pixbuf(RVAL2DC(context),
+                                     GDK_PIXBUF(RVAL2GOBJ(obj)),
+                                     NUM2INT(hot_x), NUM2INT(hot_y));
+        } else {
+            rb_raise(rb_eArgError, "invalid argument %s", rb_class2name(CLASS_OF(obj)));
+        }
+    }
+    return self;
+}
+
+#if GTK_CHECK_VERSION(2,8,0)
+static VALUE
+gtkdrag_set_icon_name(self, context, name, hot_x, hot_y)
+    VALUE self, context, name, hot_x, hot_y;
+{
+    gtk_drag_set_icon_name(RVAL2DC(context), RVAL2CSTR(name), NUM2INT(hot_x), NUM2INT(hot_y));
+    return self;
+}
+#endif
+
+static VALUE
+gtkdrag_set_icon_default(self, context)
+    VALUE self, context;
+{
+    gtk_drag_set_icon_default(RVAL2DC(context));
+    return self;
+}
+
+static VALUE
+gtkdrag_check_threshold(self, widget, start_x, start_y, current_x, current_y)
+    VALUE self, widget, start_x, start_y, current_x, current_y;
+{
+    return CBOOL2RVAL(gtk_drag_check_threshold(RVAL2WIDGET(widget), 
+                                               NUM2INT(start_x), NUM2INT(start_y),
+                                               NUM2INT(current_x), NUM2INT(current_y)));
+}
+
+static VALUE
+gtkdrag_source_set(self, widget, flags, targets, actions)
+    VALUE self, widget, flags, targets, actions;
+{
+    gtk_drag_source_set(RVAL2WIDGET(widget), RVAL2GFLAGS(flags, GDK_TYPE_MODIFIER_TYPE),
+                        rbgtk_get_target_entry(targets), 
+                        RARRAY_LEN(targets), 
+                        RVAL2GFLAGS(actions, GDK_TYPE_DRAG_ACTION));
+    return self;
+}
+
+static VALUE
+gtkdrag_source_set_icon(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE widget, obj, pixmap = Qnil, mask = Qnil;
+
+    rb_scan_args(argc, argv, "22", &widget, &obj, &pixmap, &mask);
+    if (argc == 4){
+        gtk_drag_source_set_icon(RVAL2WIDGET(widget), GDK_COLORMAP(RVAL2GOBJ(obj)),
+                                 GDK_PIXMAP(RVAL2GOBJ(pixmap)), 
+                                 GDK_BITMAP(RVAL2GOBJ(mask)));
+    } else if (argc == 2){
+        if (TYPE(obj) == T_SYMBOL){
+            gtk_drag_source_set_icon_stock(RVAL2WIDGET(widget), rb_id2name(SYM2ID(obj)));
+        } else {
+            gtk_drag_source_set_icon_pixbuf(RVAL2WIDGET(widget), GDK_PIXBUF(RVAL2GOBJ(obj)));
+        }
+    } else {
+        rb_raise(rb_eArgError, "need 2 or 4 arguments");
+    }
+    return self;
+}
+
+#if GTK_CHECK_VERSION(2,8,0)
+static VALUE
+gtkdrag_source_set_icon_name(self, widget, icon_name)
+    VALUE self, widget, icon_name;
+{
+    gtk_drag_source_set_icon_name(RVAL2WIDGET(widget), RVAL2CSTR(icon_name));
+    return self;
+}
+#endif
+
+static VALUE
+gtkdrag_source_unset(self, widget)
+    VALUE self, widget;
+{
+    gtk_drag_source_unset(RVAL2WIDGET(widget));
+    return self;
+}
+
+#if GTK_CHECK_VERSION(2,4,0)
+static VALUE
+gtkdrag_source_set_target_list(self, widget, targetlist)
+    VALUE self, widget, targetlist;
+{
+    GtkTargetList* tlist = NULL;
+    if (! NIL_P(targetlist))
+        tlist = (GtkTargetList*)RVAL2BOXED(targetlist, GTK_TYPE_TARGET_LIST);
+
+    gtk_drag_source_set_target_list(RVAL2WIDGET(widget),tlist);
+    return self;
+}
+
+static VALUE
+gtkdrag_source_get_target_list(self, widget)
+    VALUE self, widget;
+{
+    GtkTargetList* ret = gtk_drag_source_get_target_list(RVAL2WIDGET(widget));
+    return NIL_P(ret) ? Qnil : BOXED2RVAL(ret, GTK_TYPE_TARGET_LIST);
+}
+#endif
+
+#if GTK_CHECK_VERSION(2,6,0)
+static VALUE
+gtkdrag_source_add_text_targets(self, widget)
+    VALUE self, widget;
+{
+    gtk_drag_source_add_text_targets(RVAL2WIDGET(widget));
+    return self;
+}
+static VALUE
+gtkdrag_source_add_image_targets(self, widget)
+    VALUE self, widget;
+{
+    gtk_drag_source_add_image_targets(RVAL2WIDGET(widget));
+    return self;
+}
+static VALUE
+gtkdrag_source_add_uri_targets(self, widget)
+    VALUE self, widget;
+{
+    gtk_drag_source_add_uri_targets(RVAL2WIDGET(widget));
+    return self;
+}
+#endif
+
+void
+Init_gtk_drag()
+{
+    VALUE mGtkDrag = rb_define_module_under(mGtk, "Drag");
+
+    rb_define_module_function(mGtkDrag, "dest_set", gtkdrag_dest_set, 4);
+    rb_define_module_function(mGtkDrag, "dest_set_proxy", gtkdrag_dest_set_proxy, 4);
+    rb_define_module_function(mGtkDrag, "dest_unset", gtkdrag_dest_unset, 1);
+    rb_define_module_function(mGtkDrag, "dest_find_target", gtkdrag_dest_find_target, -1);
+    rb_define_module_function(mGtkDrag, "dest_get_target_list", gtkdrag_dest_get_target_list, 1);
+    rb_define_module_function(mGtkDrag, "dest_set_target_list", gtkdrag_dest_set_target_list, 2);
+#if GTK_CHECK_VERSION(2,6,0)
+    rb_define_module_function(mGtkDrag, "dest_add_text_targets", gtkdrag_dest_add_text_targets, 1);
+    rb_define_module_function(mGtkDrag, "dest_add_image_targets", gtkdrag_dest_add_image_targets, 1);
+    rb_define_module_function(mGtkDrag, "dest_add_uri_targets", gtkdrag_dest_add_uri_targets, 1);
+#endif
+#if GTK_CHECK_VERSION(2,10,0)
+    rb_define_module_function(mGtkDrag, "dest_set_track_motion", gtkdrag_dest_set_track_motion, 2);
+    rb_define_module_function(mGtkDrag, "dest_get_track_motion", gtkdrag_dest_get_track_motion, 1);
+#endif
+    rb_define_module_function(mGtkDrag, "finish", gtkdrag_finish, 4);
+    rb_define_module_function(mGtkDrag, "get_data", gtkdrag_get_data, 4);
+    rb_define_module_function(mGtkDrag, "get_source_widget", gtkdrag_get_source_widget, 1);
+    rb_define_module_function(mGtkDrag, "highlight", gtkdrag_highlight, 1);
+    rb_define_module_function(mGtkDrag, "unhighlight", gtkdrag_unhighlight, 1);
+    rb_define_module_function(mGtkDrag, "begin", gtkdrag_begin, 5);
+    rb_define_module_function(mGtkDrag, "threshold?", gtkdrag_check_threshold, 5);
+    rb_define_module_function(mGtkDrag, "set_icon", gtkdrag_set_icon, -1);
+#if GTK_CHECK_VERSION(2,8,0)
+    rb_define_module_function(mGtkDrag, "set_icon_name", gtkdrag_set_icon_name, 4);
+#endif
+    rb_define_module_function(mGtkDrag, "set_icon_default", gtkdrag_set_icon_default, 1);
+    rb_define_module_function(mGtkDrag, "source_set", gtkdrag_source_set, 4);
+    rb_define_module_function(mGtkDrag, "source_set_icon", gtkdrag_source_set_icon, -1);
+#if GTK_CHECK_VERSION(2,8,0)
+    rb_define_module_function(mGtkDrag, "source_set_icon_name", gtkdrag_source_set_icon_name, 2);
+#endif
+    rb_define_module_function(mGtkDrag, "source_unset", gtkdrag_source_unset, 1);
+#if GTK_CHECK_VERSION(2,4,0)
+    rb_define_module_function(mGtkDrag, "source_set_target_list", gtkdrag_source_set_target_list, 2);
+    rb_define_module_function(mGtkDrag, "source_get_target_list", gtkdrag_source_get_target_list, 1);
+#endif
+#if GTK_CHECK_VERSION(2,6,0)
+    rb_define_module_function(mGtkDrag, "source_add_text_targets", gtkdrag_source_add_text_targets, 1);
+    rb_define_module_function(mGtkDrag, "source_add_image_targets", gtkdrag_source_add_image_targets, 1);
+    rb_define_module_function(mGtkDrag, "source_add_uri_targets", gtkdrag_source_add_uri_targets, 1);
+#endif
+    G_DEF_SETTERS(mGtkDrag);
+
+    /* GtkDestDefaults */
+    G_DEF_CLASS(GTK_TYPE_DEST_DEFAULTS, "DestDefaults", mGtkDrag);
+    G_DEF_CONSTANTS(mGtkDrag, GTK_TYPE_DEST_DEFAULTS, "GTK_");
+
+    /* GtkTargetFlags */
+    G_DEF_CLASS(GTK_TYPE_TARGET_FLAGS, "TargetFlags", mGtkDrag);
+    G_DEF_CONSTANTS(mGtkDrag, GTK_TYPE_TARGET_FLAGS, "GTK_");
+}