gtk2 0.20.0

data/src/rbgdkconst.c

@@ -0,0 +1,29 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdkconst.c -
+
+  $Author: mutoh $
+  $Date: 2003/11/02 18:29:28 $
+
+  Copyright (C) 2002,2003 Ruby-GNOME2 Project Team
+  Copyright (C) 1998-2000 Yukihiro Matsumoto,
+                          Daisuke Kanda,
+                          Hiroshi Igarashi
+************************************************/
+
+#include "global.h"
+
+/*
+ * Gdk module constants
+ */
+void
+Init_gtk_gdk_const()
+{
+    /* GdkStatus */
+    G_DEF_CLASS(GDK_TYPE_STATUS, "Status", mGdk);
+    G_DEF_CONSTANTS(mGdk, GDK_TYPE_STATUS, "GDK_");
+
+}
+
+

data/src/rbgdkconversions.h

@@ -0,0 +1,18 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdkconversions.h -
+
+  Copyright (C) 2008 Ruby-GNOME2 Project Team
+************************************************/
+
+#ifndef __RB_GDK_CONVERSIONS_H__
+#define __RB_GDK_CONVERSIONS_H__
+
+#include <rbgobject.h>
+#include <gdk/gdk.h>
+
+#define RVAL2GDKCOLOR(color) ((GdkColor *)RVAL2BOXED(color, GDK_TYPE_COLOR))
+#define GDKCOLOR2RVAL(color) (BOXED2RVAL(color, GDK_TYPE_COLOR))
+
+#endif /* __RB_GDK_CONVERSIONS_H__ */

data/src/rbgdkcursor.c

@@ -0,0 +1,115 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdkcursor.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 14:27:08 $
+
+  Copyright (C) 2001-2004 Masao Mutoh
+************************************************/
+
+#include "global.h"
+
+static VALUE
+gdkcursor_initialize(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    GdkCursor* cursor = NULL;
+
+    if (argc == 1){
+        VALUE type;
+        rb_scan_args(argc, argv, "10", &type);
+        cursor = gdk_cursor_new(RVAL2GENUM(type, GDK_TYPE_CURSOR_TYPE));
+    } else if (argc == 2) {
+#if GTK_CHECK_VERSION(2,2,0)
+        VALUE display, type_or_name;
+        rb_scan_args(argc, argv, "20", &display, &type_or_name);
+#if GTK_CHECK_VERSION(2,8,0)
+        if (TYPE(type_or_name) == T_STRING)
+            cursor = gdk_cursor_new_from_name(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)),
+                                              RVAL2CSTR(type_or_name));
+        else
+#endif
+            cursor = gdk_cursor_new_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)), 
+                                                RVAL2GENUM(type_or_name, GDK_TYPE_CURSOR_TYPE));
+#else
+        rb_raise(rb_eRuntimeError, "Gdk::Cursor.new(display, cursor_type) has been supported since GTK+-2.2.");
+#endif
+    } else if (argc == 4) {
+#if GTK_CHECK_VERSION(2,4,0)
+        VALUE display, pixbuf, x, y;
+        rb_scan_args(argc, argv, "40", &display, &pixbuf, &x, &y);
+        cursor = gdk_cursor_new_from_pixbuf(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display)), 
+                                            GDK_PIXBUF(RVAL2GOBJ(pixbuf)), 
+                                            NUM2INT(x), NUM2INT(y));
+#else
+        rb_raise(rb_eRuntimeError, "Gdk::Cursor.new(pixbuf) has been supported since GTK+-2.4.");
+#endif
+    } else if (argc == 6) {
+        VALUE pixmap, mask, fg, bg, x, y;
+        rb_scan_args(argc, argv, "60", &pixmap, &mask, &fg, &bg, &x, &y);
+        cursor = gdk_cursor_new_from_pixmap(GDK_PIXMAP(RVAL2GOBJ(pixmap)), 
+                                            NIL_P(mask)?NULL:GDK_PIXMAP(RVAL2GOBJ(mask)), 
+                                            RVAL2GDKCOLOR(fg),
+                                            RVAL2GDKCOLOR(bg),
+					    NUM2INT(x), NUM2INT(y));
+    }
+    G_INITIALIZE(self, cursor);
+       
+    return Qnil;
+}
+
+#if GTK_CHECK_VERSION(2,2,0)
+static VALUE
+gdkcursor_get_display(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gdk_cursor_get_display((GdkCursor*)RVAL2BOXED(self, GDK_TYPE_CURSOR)));
+}
+#endif
+
+static VALUE
+gdkcursor_is_pixmap(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(((GdkCursor*)RVAL2BOXED(self, GDK_TYPE_COLOR))->type == 
+                      GDK_CURSOR_IS_PIXMAP);
+}
+
+static VALUE
+gdkcursor_cursor_type(self)
+    VALUE self;
+{
+    return GENUM2RVAL(((GdkCursor*)RVAL2BOXED(self, GDK_TYPE_CURSOR))->type, GDK_TYPE_CURSOR_TYPE);
+}
+
+#if GTK_CHECK_VERSION(2,8,0)
+static VALUE
+gdkcursor_get_image(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gdk_cursor_get_image((GdkCursor*)RVAL2BOXED(self, GDK_TYPE_CURSOR)));
+}
+#endif
+
+void
+Init_gtk_gdk_cursor()
+{
+    VALUE gdkCursor = G_DEF_CLASS(GDK_TYPE_CURSOR, "Cursor", mGdk);
+
+    rb_define_method(gdkCursor, "initialize", gdkcursor_initialize, -1);
+#if GTK_CHECK_VERSION(2,2,0)
+    rb_define_method(gdkCursor, "display", gdkcursor_get_display, 0);
+#endif
+    rb_define_method(gdkCursor, "pixmap?", gdkcursor_is_pixmap, 0);
+    rb_define_method(gdkCursor, "cursor_type", gdkcursor_cursor_type, 0);
+#if GTK_CHECK_VERSION(2,8,0)
+    rb_define_method(gdkCursor, "image", gdkcursor_get_image, 0);
+#endif
+
+    G_DEF_CLASS(GDK_TYPE_CURSOR_TYPE, "Type", gdkCursor);
+    G_DEF_CONSTANTS(gdkCursor, GDK_TYPE_CURSOR_TYPE, "GDK_");
+}

data/src/rbgdkdevice.c

@@ -0,0 +1,235 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdkdevice.c -
+
+  $Author: mutoh $
+  $Date: 2006/06/17 06:59:32 $
+
+  Copyright (C) 2003-2006 Masao Mutoh
+************************************************/
+
+#include "global.h"
+
+#define _SELF(self) (GDK_DEVICE(RVAL2GOBJ(self)))
+
+/* Methods */
+static VALUE
+device_s_list(self)
+    VALUE self;
+{
+    /* Owned by GDK */
+    return GLIST2ARY(gdk_devices_list());
+}
+
+static VALUE
+device_s_set_extension_events(self, window, mask, mode)
+    VALUE self, window, mask, mode;
+{
+    gdk_input_set_extension_events(GDK_WINDOW(RVAL2GOBJ(window)),
+                                   NUM2INT(mask), FIX2INT(mode));
+    return Qnil;
+}
+
+
+static VALUE
+device_set_source(self, source)
+    VALUE self, source;
+{
+    gdk_device_set_source(_SELF(self), RVAL2GENUM(source, GDK_TYPE_INPUT_SOURCE));
+    return self;
+}
+
+static VALUE
+device_set_mode(self, mode)
+    VALUE self, mode;
+{
+    return CBOOL2RVAL(gdk_device_set_mode(_SELF(self), RVAL2GENUM(mode, GDK_TYPE_INPUT_MODE)));
+}
+
+static VALUE
+device_set_key(self, index, keyval, modifiers)
+    VALUE self, index, keyval, modifiers;
+{
+    gdk_device_set_key(_SELF(self), NUM2UINT(index), NUM2UINT(keyval),
+                       RVAL2GFLAGS(modifiers, GDK_TYPE_MODIFIER_TYPE));
+    return self;
+}
+
+static VALUE
+device_set_axis_use(self, index, use)
+    VALUE self, index, use;
+{
+    gdk_device_set_axis_use(_SELF(self), NUM2UINT(index), 
+                            RVAL2GENUM(use, GDK_TYPE_AXIS_USE));
+    return self;
+}
+
+static VALUE
+device_s_get_core_pointer(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gdk_device_get_core_pointer());
+}
+
+static VALUE
+device_get_state(self, window)
+    VALUE self, window;
+{
+    gdouble axes[2];
+    GdkModifierType mask;
+
+    gdk_device_get_state(_SELF(self), GDK_WINDOW(RVAL2GOBJ(window)),
+                         axes, &mask);
+    return rb_ary_new3(3, rb_float_new(axes[0]), rb_float_new(axes[1]),
+                       GFLAGS2RVAL(mask, GDK_TYPE_MODIFIER_TYPE));
+}
+
+static VALUE
+device_get_history(self, window, start, stop)
+    VALUE self, window, start, stop;
+{
+    gboolean ret;
+    GdkTimeCoord** events;
+    gint i, n_events;
+    VALUE ary = Qnil;
+    ret = gdk_device_get_history(_SELF(self),
+                                 GDK_WINDOW(RVAL2GOBJ(window)),
+                                 NUM2UINT(start), NUM2UINT(stop),
+                                 &events, &n_events);
+    if (ret){
+        ary = rb_ary_new();
+        for (i = 0; i < n_events; i++){
+            rb_ary_push(ary, BOXED2RVAL(events, GDK_TYPE_TIME_COORD));
+        }
+        gdk_device_free_history(events, n_events);
+    }
+    return ary;
+}
+
+static VALUE
+device_get_axis(self, axes, use)
+    VALUE self, axes, use;
+{
+    gdouble value;
+    gboolean ret;
+    gdouble* gaxes;
+    gint i;
+    gint len = RARRAY_LEN(axes);
+
+    gaxes = g_new(gdouble, len);
+
+    for (i = 0; i < len; i++){
+        gaxes[i] = RARRAY_PTR(axes)[i];
+    }
+
+    ret = gdk_device_get_axis(_SELF(self), gaxes, RVAL2GENUM(use, GDK_TYPE_AXIS_USE),
+                              &value);
+
+    g_free(gaxes);
+
+    return ret ? rb_float_new(value) : Qnil;
+}
+
+/* Accessor */
+static VALUE
+device_name(self)
+    VALUE self;
+{
+    return CSTR2RVAL(_SELF(self)->name);
+}
+
+static VALUE
+device_source(self)
+    VALUE self;
+{
+    return GENUM2RVAL(_SELF(self)->source, GDK_TYPE_INPUT_SOURCE);
+}
+
+static VALUE
+device_mode(self)
+    VALUE self;
+{
+    return GENUM2RVAL(_SELF(self)->mode, GDK_TYPE_INPUT_MODE);
+}
+
+static VALUE
+device_has_cursor(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(_SELF(self)->has_cursor);
+}
+
+static VALUE
+device_axes(self)
+    VALUE self;
+{
+    gint i;
+    VALUE ary = rb_ary_new();
+    GdkDeviceAxis* axes = _SELF(self)->axes;
+
+    for (i = 0; i < _SELF(self)->num_axes; i++){
+        rb_ary_push(ary, rb_ary_new3(3, GENUM2RVAL(axes[i].use, GDK_TYPE_AXIS_USE), 
+                                     rb_float_new(axes[i].min), rb_float_new(axes[i].max)));
+    }
+    return ary;
+}
+
+static VALUE
+device_keys(self)
+    VALUE self;
+{
+    gint i;
+    VALUE ary = rb_ary_new();
+    GdkDeviceKey* keys = _SELF(self)->keys;
+
+    for (i = 0; i < _SELF(self)->num_keys; i++){
+        rb_ary_push(ary, rb_ary_new3(2, UINT2NUM(keys[i].keyval),
+                                     GFLAGS2RVAL(keys[i].modifiers, GDK_TYPE_MODIFIER_TYPE)));
+    }
+    return ary;
+}
+
+void 
+Init_gtk_gdk_device()
+{
+    VALUE dev = G_DEF_CLASS(GDK_TYPE_DEVICE, "Device", mGdk);
+
+    rb_define_singleton_method(dev, "list", device_s_list, 0);
+    rb_define_singleton_method(dev, "core_pointer", device_s_get_core_pointer, 0);
+    rb_define_singleton_method(dev, "set_extension_events", device_s_set_extension_events, 3);
+
+    rb_define_method(dev, "set_source", device_set_source, 1);
+    rb_define_method(dev, "set_mode", device_set_mode, 1);
+    rb_define_method(dev, "set_key", device_set_key, 3);
+    rb_define_method(dev, "set_axis_use", device_set_axis_use, 2);
+    rb_define_method(dev, "get_state", device_get_state, 1);
+    rb_define_method(dev, "get_history", device_get_history, 3);
+    rb_define_method(dev, "get_axis", device_get_axis, 2);
+
+    rb_define_method(dev, "name", device_name, 0);
+    rb_define_method(dev, "source", device_source, 0);
+    rb_define_method(dev, "mode", device_mode, 0);
+    rb_define_method(dev, "has_cursor?", device_has_cursor, 0);
+    rb_define_method(dev, "axes", device_axes, 0);
+    rb_define_method(dev, "keys", device_keys, 0);
+
+    G_DEF_SETTERS(dev);
+
+    /* GdkInputSource */
+    G_DEF_CLASS(GDK_TYPE_INPUT_SOURCE, "InputSource", dev);
+    G_DEF_CONSTANTS(dev, GDK_TYPE_INPUT_SOURCE, "GDK_");
+
+    /* GdkInputMode */
+    G_DEF_CLASS(GDK_TYPE_INPUT_MODE, "InputMode", dev);
+    G_DEF_CONSTANTS(dev, GDK_TYPE_INPUT_MODE, "GDK_");
+    
+    /* GdkAxisUse */
+    G_DEF_CLASS(GDK_TYPE_AXIS_USE, "AxisUse", dev);
+    G_DEF_CONSTANTS(dev, GDK_TYPE_AXIS_USE, "GDK_");
+
+    /* GdkExtensionMode */
+    G_DEF_CLASS(GDK_TYPE_EXTENSION_MODE, "ExtensionMode", dev);
+    G_DEF_CONSTANTS(dev, GDK_TYPE_EXTENSION_MODE, "GDK_");
+
+}

data/src/rbgdkdisplay.c

@@ -0,0 +1,634 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/************************************************
+
+  rbgdkdisplay.c -
+
+  $Author: ggc $
+  $Date: 2007/07/13 14:27:08 $
+
+  Copyright (C) 2002-2005 Ruby-GNOME2 Project Team
+************************************************/
+
+#include "global.h"
+
+#if GTK_CHECK_VERSION(2,2,0)
+#define _SELF(i) GDK_DISPLAY_OBJECT(RVAL2GOBJ(i))
+
+
+static VALUE
+gdkdisplay_close(self)
+    VALUE self;
+{
+    gdk_display_close(_SELF(self));
+    return self;
+}
+
+static VALUE
+gdkdisplay_s_open(self, display_name)
+    VALUE self, display_name;
+{
+    GdkDisplay* gdisplay = gdk_display_open(RVAL2CSTR(display_name));
+    if (! gdisplay) {
+        rb_raise(rb_eRuntimeError, "The display `%s' could not be opened.", 
+                 RVAL2CSTR(display_name));
+    } else {
+        VALUE display;
+        g_object_ref(gdisplay);
+        display = GOBJ2RVAL(gdisplay);
+
+        if (rb_block_given_p()) {
+            rb_ensure(rb_yield, display, gdkdisplay_close, display);
+            return Qnil;
+        } else {
+            return display;
+        }
+    }
+}
+
+static VALUE
+gdkdisplay_s_get_default(self)
+    VALUE self;
+{
+    GdkDisplay* gdisplay = gdk_display_get_default();
+     if (! gdisplay)
+        rb_raise(rb_eRuntimeError, "No default display is found.");
+    
+    return GOBJ2RVAL(gdisplay);
+}
+
+
+static VALUE
+gdkdisplay_name(self)
+    VALUE self;
+{
+    return CSTR2RVAL(gdk_display_get_name(_SELF(self)));
+}
+
+static VALUE
+gdkdisplay_n_screens(self)
+    VALUE self;
+{
+    return INT2NUM(gdk_display_get_n_screens(_SELF(self)));
+}
+
+static VALUE
+gdkdisplay_get_screen(self, num)
+    VALUE self, num;
+{
+    return GOBJ2RVAL(gdk_display_get_screen(_SELF(self), NUM2INT(num)));
+}
+
+static VALUE
+gdkdisplay_default_screen(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gdk_display_get_default_screen(_SELF(self)));
+}
+
+static VALUE
+gdkdisplay_pointer_ungrab(self, time)
+    VALUE self, time;
+{
+    gdk_display_pointer_ungrab(_SELF(self), NUM2ULONG(time));
+    return self;
+}
+
+static VALUE
+gdkdisplay_keyboard_ungrab(self, time)
+    VALUE self, time;
+{
+    gdk_display_keyboard_ungrab(_SELF(self), NUM2ULONG(time));
+    return self;
+}
+
+static VALUE
+gdkdisplay_pointer_grabbed(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gdk_display_pointer_is_grabbed(_SELF(self)));
+}
+
+static VALUE
+gdkdisplay_beep(self)
+    VALUE self;
+{
+    gdk_display_beep(_SELF(self));
+    return self;
+}
+
+static VALUE
+gdkdisplay_sync(self)
+    VALUE self;
+{
+    gdk_display_sync(_SELF(self));
+    return self;
+}
+
+#if GTK_CHECK_VERSION(2,4,0)
+static VALUE
+gdkdisplay_flush(self)
+    VALUE self;
+{
+    gdk_display_flush(_SELF(self));
+    return self;
+}
+#endif
+
+static VALUE
+gdkdisplay_list_devices(self)
+    VALUE self;
+{
+    return rbgutil_glist2ary(gdk_display_list_devices(_SELF(self)));
+}
+
+static VALUE
+gdkdisplay_get_event(self)
+    VALUE self;
+{
+    return GEV2RVAL(gdk_display_get_event(_SELF(self)));
+}
+
+static VALUE
+gdkdisplay_peek_event(self)
+    VALUE self;
+{
+    return GEV2RVAL(gdk_display_peek_event(_SELF(self)));
+}
+
+static VALUE
+gdkdisplay_put_event(self, event)
+    VALUE self, event;
+{
+    gdk_display_put_event(_SELF(self), RVAL2GEV(event));
+    return self;
+}
+
+/* Don't implement this.
+static GdkFilterReturn
+filter_func(xevent, event, func)
+    GdkXEvent xevent;
+    GdkEvent event;
+    gpointer func;
+{
+    return GENUM2RVAL(rb_funcall((VALUE)func, id_call, 2, 
+                                 ????, GEV2RVAL(event)), 
+                      GDK_TYPE_FILTER_RETURN);
+}
+
+static VALUE
+gdkdisplay_add_client_message_filter(self, message_type)
+    VALUE self, message_type;
+{
+    VALUE func = RB_BLOCK_PROC();
+    G_RELATIVE(self, func);
+    gdk_display_add_client_message_filter(_SELF(self), RVAL2ATOM(message_type),
+                                          filter_func, func);
+    return self;
+}
+*/
+
+static VALUE
+gdkdisplay_set_double_click_time(self, msec)
+    VALUE self, msec;
+{
+    gdk_display_set_double_click_time(_SELF(self), NUM2UINT(msec));
+    return self;
+}
+
+static VALUE
+gdkdisplay_get_double_click_time(self)
+    VALUE self;
+{
+    return UINT2NUM(_SELF(self)->double_click_time);
+}
+
+static VALUE
+gdkdisplay_get_button_click_time(self)
+    VALUE self;
+{
+    return rb_ary_new3(2,
+                       UINT2NUM(_SELF(self)->button_click_time[0]),
+                       UINT2NUM(_SELF(self)->button_click_time[1]));
+}
+
+static VALUE
+gdkdisplay_get_button_window(self)
+    VALUE self;
+{
+    return rb_ary_new3(2,
+                       GOBJ2RVAL(_SELF(self)->button_window[0]),
+                       GOBJ2RVAL(_SELF(self)->button_window[1]));
+}
+
+static VALUE
+gdkdisplay_get_button_number(self)
+    VALUE self;
+{
+    return rb_ary_new3(2,
+                       INT2NUM(_SELF(self)->button_number[0]),
+                       INT2NUM(_SELF(self)->button_number[1]));
+}
+
+static VALUE
+gdkdisplay_get_closed(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(_SELF(self)->closed);
+}
+
+#if GTK_CHECK_VERSION(2,4,0)
+static VALUE
+gdkdisplay_get_button_x(self)
+    VALUE self;
+{
+    return rb_ary_new3(2,
+                       INT2NUM(_SELF(self)->button_x[0]),
+                       INT2NUM(_SELF(self)->button_x[1]));
+}
+
+static VALUE
+gdkdisplay_get_button_y(self)
+    VALUE self;
+{
+    return rb_ary_new3(2,
+                       INT2NUM(_SELF(self)->button_y[0]),
+                       INT2NUM(_SELF(self)->button_y[1]));
+}
+
+static VALUE
+gdkdisplay_set_double_click_distance(self, distance)
+    VALUE self, distance;
+{
+    gdk_display_set_double_click_distance(_SELF(self), NUM2UINT(distance));
+    return self;
+}
+
+static VALUE
+gdkdisplay_get_double_click_distance(self, distance)
+    VALUE self;
+{
+    return UINT2NUM(_SELF(self)->double_click_distance);
+}
+#endif
+
+static VALUE
+gdkdisplay_get_pointer(self)
+    VALUE self;
+{
+    GdkScreen *screen;
+    int x,y;
+    GdkModifierType mask;
+    
+    gdk_display_get_pointer(_SELF(self), &screen, &x, &y, &mask);
+    
+    return rb_ary_new3(4, GOBJ2RVAL(screen), INT2NUM(x), INT2NUM(y), INT2NUM(mask));
+}
+static VALUE
+gdkdisplay_get_window_at_pointer(self)
+    VALUE self;
+{
+    GdkWindow *window;
+    int x,y;
+    
+    window = gdk_display_get_window_at_pointer(_SELF(self), &x, &y);
+    
+    return rb_ary_new3(3, GOBJ2RVAL(window), INT2NUM(x), INT2NUM(y));
+}
+
+/* Don't implement this.
+GdkDisplayPointerHooks* gdk_display_set_pointer_hooks
+                                            (GdkDisplay *display,
+                                             const GdkDisplayPointerHooks *new_hooks);
+ */
+
+#if GTK_CHECK_VERSION(2,4,0)
+static VALUE
+gdkdisplay_supports_cursor_color(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gdk_display_supports_cursor_color(_SELF(self)));
+}
+
+static VALUE
+gdkdisplay_supports_cursor_alpha(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gdk_display_supports_cursor_alpha(_SELF(self)));
+}
+
+static VALUE
+gdkdisplay_get_default_cursor_size(self)
+    VALUE self;
+{
+    return UINT2NUM(gdk_display_get_default_cursor_size(_SELF(self)));
+}
+
+static VALUE
+gdkdisplay_get_maximal_cursor_size(self)
+    VALUE self;
+{
+    guint width, height;
+    gdk_display_get_maximal_cursor_size(_SELF(self), &width, &height);
+    return rb_assoc_new(UINT2NUM(width), UINT2NUM(height));
+}
+
+static VALUE
+gdkdisplay_get_default_group(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gdk_display_get_default_group(_SELF(self)));
+}
+#endif
+
+#if GTK_CHECK_VERSION(2,6,0)
+static VALUE
+gdkdisplay_supports_selection_notification(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gdk_display_supports_selection_notification(_SELF(self)));
+}
+
+static VALUE
+gdkdisplay_request_selection_notification(self, selection)
+    VALUE self, selection;
+{
+    return CBOOL2RVAL(gdk_display_request_selection_notification(_SELF(self), 
+                                                                 RVAL2ATOM(selection)));
+}
+
+static VALUE
+gdkdisplay_supports_clipboard_persistence(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gdk_display_supports_clipboard_persistence(_SELF(self)));
+}
+
+static VALUE
+gdkdisplay_store_clipboard(self, clipboard_window, time_, targets)
+    VALUE self, clipboard_window, time_, targets;
+{
+    gint i;
+    gint n_targets = RARRAY_LEN(targets);
+    GdkAtom* gtargets = g_new(GdkAtom, n_targets);
+
+    for (i = 0; i < n_targets; i++){
+        gtargets[i] = RVAL2ATOM(RARRAY_PTR(targets)[i]);
+    }
+
+    gdk_display_store_clipboard(_SELF(self), GDK_WINDOW(RVAL2GOBJ(clipboard_window)),
+                                NUM2UINT(time_), gtargets, n_targets);
+    return self;
+}
+#endif
+
+static VALUE
+gdkdisplay_get_core_pointer(self)
+    VALUE self;
+{
+    return GOBJ2RVAL(gdk_display_get_core_pointer(_SELF(self)));
+}
+
+#if GTK_CHECK_VERSION(2,8,0)
+static VALUE
+gdkdisplay_warp_pointer(self, screen, x, y)
+    VALUE self, screen, x, y;
+{
+    gdk_display_warp_pointer(_SELF(self), RVAL2GOBJ(screen), NUM2INT(x), NUM2INT(y));
+    return self;
+}
+#endif
+
+#ifdef GDK_WINDOWING_X11
+static VALUE
+gdkdisplay_grab(self)
+    VALUE self;
+{
+    gdk_x11_display_grab(_SELF(self));
+    return self;
+}
+static VALUE
+gdkdisplay_ungrab(self)
+    VALUE self;
+{
+    gdk_x11_display_ungrab(_SELF(self));
+    return self;
+}
+#if GTK_CHECK_VERSION(2,4,0)
+static VALUE
+gdkdisplay_register_standard_event_type(self, event_base, n_events)
+    VALUE self, event_base, n_events;
+{
+    gdk_x11_register_standard_event_type(_SELF(self),
+                                         NUM2INT(event_base), NUM2INT(n_events));
+    return self;
+}
+#endif
+#if GTK_CHECK_VERSION(2,8,0)
+static VALUE
+gdkdisplay_get_user_time(self)
+    VALUE self;
+{
+    return UINT2NUM(gdk_x11_display_get_user_time(_SELF(self)));
+}
+
+static VALUE
+gdkdisplay_set_cursor_theme(self, theme, size)
+    VALUE self, theme, size;
+{
+    gdk_x11_display_set_cursor_theme(_SELF(self), RVAL2CSTR(theme), NUM2INT(size));
+    return self;
+}
+#endif
+
+#  if GTK_CHECK_VERSION(2, 12, 0)
+/*
+*** need gdk_x11_display_broadcast_startup_messagev() ***
+
+typedef struct _StartupMessageParameterData {
+    gchar **parameters;
+    guint i;
+} StartupMessageParameterData;
+
+static int
+collect_parameter(VALUE key, VALUE value, VALUE data)
+{
+    StartupMessageParameterData *parameter_data;
+    parameter_data = (StartupMessageParameterData *)data;
+
+    parameter_data->parameters[parameter_data->i] = RVAL2CSTR(key);
+    parameter_data->i++;
+    parameter_data->parameters[parameter_data->i] = RVAL2CSTR(value);
+    parameter_data->i++;
+
+    return ST_CONTINUE;
+}
+
+static VALUE
+gdkdisplay_broadcast_startup_message(int argc, VALUE *argv, VALUE self)
+{
+    VALUE rb_message_type, rb_parameters;
+    char *message_type;
+    guint n_parameters;
+    gchar **parameters;
+
+    rb_scan_args(argc, argv, "11", &rb_message_type, &rb_parameters);
+
+    message_type = RVAL2CSTR(rb_message_type);
+    if (NIL_P(rb_parameters)) {
+	n_parameters = 0;
+	parameters = NULL;
+    }
+    else {
+	StartupMessageParameterData data;
+
+	Check_Type(rb_parameters, T_HASH);
+	n_parameters = NUM2UINT(rb_funcall(rb_parameters, rb_intern("size"), 0));
+	parameters = ALLOCA_N(gchar *, n_parameters * 2);
+	data.i = 0;
+	data.parameters = parameters;
+	rb_hash_foreach(rb_parameters, collect_parameter, (VALUE)&data);
+    }
+
+    gdk_x11_display_broadcast_startup_messagev(_SELF(self),
+					       message_type,
+					       n_parameters,
+					       parameters);
+
+    return self;
+}
+*/
+
+static VALUE
+gdkdisplay_get_startup_notification_id(VALUE self)
+{
+    return CSTR2RVAL(gdk_x11_display_get_startup_notification_id(_SELF(self)));
+}
+#  endif
+
+#endif
+#endif
+
+#if GTK_CHECK_VERSION(2,10,0)
+static VALUE
+gdkdisplay_supports_shapes(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gdk_display_supports_shapes(_SELF(self)));
+}
+
+static VALUE
+gdkdisplay_supports_input_shapes(self)
+    VALUE self;
+{
+    return CBOOL2RVAL(gdk_display_supports_input_shapes(_SELF(self)));
+}
+#endif
+
+#if GTK_CHECK_VERSION(2, 12, 0)
+static VALUE
+gdkdisplay_supports_composite(VALUE self)
+{
+    return CBOOL2RVAL(gdk_display_supports_composite(_SELF(self)));
+}
+
+static VALUE
+gdkdisplay_trigger_tooltip_query(VALUE self)
+{
+    gtk_tooltip_trigger_tooltip_query(_SELF(self));
+    return self;
+}
+#endif
+
+void 
+Init_gtk_gdk_display()
+{
+#if GTK_CHECK_VERSION(2,2,0)
+    VALUE gdkDisplay = G_DEF_CLASS(GDK_TYPE_DISPLAY, "Display", mGdk);
+
+    rb_define_singleton_method(gdkDisplay, "open", gdkdisplay_s_open, 1);
+    rb_define_singleton_method(gdkDisplay, "default", gdkdisplay_s_get_default, 0);
+    rb_define_method(gdkDisplay, "name", gdkdisplay_name, 0);
+    rb_define_method(gdkDisplay, "n_screens", gdkdisplay_n_screens, 0);
+    rb_define_method(gdkDisplay, "get_screen", gdkdisplay_get_screen, 1);
+    rb_define_alias(gdkDisplay, "[]", "get_screen");
+    rb_define_method(gdkDisplay, "default_screen", gdkdisplay_default_screen, 0);
+    
+    rb_define_method(gdkDisplay, "pointer_ungrab", gdkdisplay_pointer_ungrab, 1);
+    rb_define_method(gdkDisplay, "keyboard_ungrab", gdkdisplay_keyboard_ungrab, 1);
+    rb_define_method(gdkDisplay, "pointer_grabbed?", gdkdisplay_pointer_grabbed, 0);
+    
+    rb_define_method(gdkDisplay, "beep", gdkdisplay_beep, 0);
+    rb_define_method(gdkDisplay, "sync", gdkdisplay_sync, 0);
+#if GTK_CHECK_VERSION(2,4,0)
+    rb_define_method(gdkDisplay, "flush", gdkdisplay_flush, 0);
+#endif
+    rb_define_method(gdkDisplay, "close", gdkdisplay_close, 0);
+    
+    rb_define_method(gdkDisplay, "devices", gdkdisplay_list_devices, 0);
+    rb_define_method(gdkDisplay, "event", gdkdisplay_get_event, 0);
+    rb_define_method(gdkDisplay, "peek_event", gdkdisplay_peek_event, 0);
+    rb_define_method(gdkDisplay, "put_event", gdkdisplay_put_event, 1);
+    rb_define_method(gdkDisplay, "set_double_click_time", gdkdisplay_set_double_click_time, 1);
+    rb_define_method(gdkDisplay, "double_click_time",  gdkdisplay_get_double_click_time, 0);
+    rb_define_method(gdkDisplay, "button_click_time",  gdkdisplay_get_button_click_time, 0);
+    rb_define_method(gdkDisplay, "button_window",  gdkdisplay_get_button_window, 0);
+    rb_define_method(gdkDisplay, "button_number",  gdkdisplay_get_button_number, 0);
+    rb_define_method(gdkDisplay, "closed?",  gdkdisplay_get_closed, 0);
+#if GTK_CHECK_VERSION(2,4,0)
+    rb_define_method(gdkDisplay, "button_x",  gdkdisplay_get_button_x, 0);
+    rb_define_method(gdkDisplay, "button_y",  gdkdisplay_get_button_y, 0);
+    rb_define_method(gdkDisplay, "set_double_click_distance", gdkdisplay_set_double_click_distance, 1);
+    rb_define_method(gdkDisplay, "double_click_distance", gdkdisplay_get_double_click_distance, 0);
+#endif
+    rb_define_method(gdkDisplay, "pointer", gdkdisplay_get_pointer, 0);
+    rb_define_method(gdkDisplay, "window_at_pointer", gdkdisplay_get_window_at_pointer, 0);
+#if GTK_CHECK_VERSION(2,4,0)
+    rb_define_method(gdkDisplay, "supports_cursor_color?", gdkdisplay_supports_cursor_color, 0);
+    rb_define_method(gdkDisplay, "supports_cursor_alpha?", gdkdisplay_supports_cursor_alpha, 0);
+    rb_define_method(gdkDisplay, "default_cursor_size", gdkdisplay_get_default_cursor_size, 0);
+    rb_define_method(gdkDisplay, "maximal_cursor_size", gdkdisplay_get_maximal_cursor_size, 0);
+    rb_define_method(gdkDisplay, "default_group", gdkdisplay_get_default_group, 0);
+#endif
+#if GTK_CHECK_VERSION(2,6,0)
+    rb_define_method(gdkDisplay, "supports_selection_notification?", gdkdisplay_supports_selection_notification, 0);
+    rb_define_method(gdkDisplay, "request_selection_notification?", gdkdisplay_request_selection_notification, 1);
+    rb_define_method(gdkDisplay, "supports_clipboard_persistence?", gdkdisplay_supports_clipboard_persistence, 0);
+    rb_define_method(gdkDisplay, "store_clipboard", gdkdisplay_store_clipboard, 3);
+#endif
+    rb_define_method(gdkDisplay, "core_pointer", gdkdisplay_get_core_pointer, 0);
+#if GTK_CHECK_VERSION(2,8,0)
+    rb_define_method(gdkDisplay, "warp_pointer", gdkdisplay_warp_pointer, 3);
+#endif
+
+    G_DEF_SETTERS(gdkDisplay);
+#ifdef GDK_WINDOWING_X11
+    rb_define_method(gdkDisplay, "grab", gdkdisplay_grab, 0);
+    rb_define_method(gdkDisplay, "ungrab", gdkdisplay_ungrab, 0);
+#if GTK_CHECK_VERSION(2,4,0)
+    rb_define_method(gdkDisplay, "register_standard_event_type", gdkdisplay_register_standard_event_type, 2);
+#endif
+#if GTK_CHECK_VERSION(2,8,0)
+    rb_define_method(gdkDisplay, "user_time", gdkdisplay_get_user_time, 0);
+    rb_define_method(gdkDisplay, "set_cursor_theme", gdkdisplay_set_cursor_theme, 2);
+#endif
+#  if GTK_CHECK_VERSION(2, 12, 0)
+/*
+    rb_define_method(gdkDisplay, "broadcast_startup_message",
+		     gdkdisplay_broadcast_startup_message, -1);
+*/
+    rb_define_method(gdkDisplay, "startup_notification_id",
+		     gdkdisplay_get_startup_notification_id, 0);
+#  endif
+    G_DEF_CLASS3("GdkDisplayX11", "DisplayX11", mGdk);
+#endif
+#endif
+
+#if GTK_CHECK_VERSION(2,10,0)
+    rb_define_method(gdkDisplay, "supports_shapes?", gdkdisplay_supports_shapes, 0);
+    rb_define_method(gdkDisplay, "supports_input_shapes?", gdkdisplay_supports_input_shapes, 0);
+#endif
+#if GTK_CHECK_VERSION(2, 12, 0)
+    rb_define_method(gdkDisplay, "supports_composite?", gdkdisplay_supports_composite, 0);
+    rb_define_method(gdkDisplay, "trigger_tooltip_query", gdkdisplay_trigger_tooltip_query, 0);
+#endif
+}