gdk3 2.0.2-x86-mingw32 → 2.0.3-x86-mingw32

data/ext/gdk3/rbgdkwindow.c

@@ -1,7 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011  Ruby-GNOME2 Project Team
- *  Copyright (C) 2002-2006 Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2013 Ruby-GNOME2 Project Team
  *  Copyright (C) 1998-2000 Yukihiro Matsumoto,
  *                          Daisuke Kanda,
  *                          Hiroshi Igarashi
@@ -34,7 +33,7 @@
 static VALUE
 rg_initialize(VALUE self, VALUE parent, VALUE attributes, VALUE attributes_mask)
 {
-    GdkWindow* win;
+    GdkWindow *win;
     win = gdk_window_new(NIL_P(parent) ? NULL : _SELF(parent),
                          RVAL2GDKWINDOWATTR(attributes),
                          RVAL2GDKWINDOWATTRIBUTESTYPE(attributes_mask));
@@ -56,14 +55,6 @@ rg_window_type(VALUE self)
     return GDKWINDOWTYPE2RVAL(gdk_window_get_window_type(_SELF(self)));
 }
 
-static VALUE
-rg_s_at_pointer(G_GNUC_UNUSED VALUE self)
-{
-    gint x, y;
-    GdkWindow* win = gdk_window_at_pointer(&x, &y);
-    return rb_ary_new3(3, GOBJ2RVAL(win), INT2FIX(x), INT2FIX(y));
-}
-
 static VALUE
 rg_show(VALUE self)
 {
@@ -284,7 +275,7 @@ rg_s_constrain_size(G_GNUC_UNUSED VALUE self, VALUE geometry, VALUE flags, VALUE
 }
 
 static VALUE
-rg_beep(VALUE self) 
+rg_beep(VALUE self)
 {
     gdk_window_beep(_SELF(self));
     return self;
@@ -294,7 +285,7 @@ static VALUE
 rg_begin_paint(VALUE self, VALUE area)
 {
     if (rb_obj_is_kind_of(area, GTYPE2CLASS(GDK_TYPE_RECTANGLE))){
-        gdk_window_begin_paint_rect(_SELF(self), 
+        gdk_window_begin_paint_rect(_SELF(self),
                                     RVAL2GDKRECTANGLE(area));
     } else {
         gdk_window_begin_paint_region(_SELF(self), RVAL2CRREGION(area));
@@ -349,7 +340,7 @@ rg_invalidate_maybe_recurse(VALUE self, VALUE region)
 static VALUE
 rg_update_area(VALUE self)
 {
-    return CRREGION2RVAL(gdk_window_get_update_area(_SELF(self))); 
+    return CRREGION2RVAL(gdk_window_get_update_area(_SELF(self)));
 }
 
 static VALUE
@@ -415,7 +406,7 @@ rg_set_user_data(VALUE self, VALUE user_data)
 static VALUE
 rg_set_override_redirect(VALUE self, VALUE override_redirect)
 {
-    gdk_window_set_override_redirect(_SELF(self), 
+    gdk_window_set_override_redirect(_SELF(self),
                                      RVAL2CBOOL(override_redirect));
     return self;
 }
@@ -455,7 +446,7 @@ rg_merge_child_shapes(VALUE self)
 {
     gdk_window_merge_child_shapes(_SELF(self));
     return self;
-}   
+}
 
 static VALUE
 rg_input_shape_combine_region(VALUE self, VALUE shape_region, VALUE offset_x, VALUE offset_y)
@@ -526,7 +517,7 @@ rg_geometry(VALUE self)
 static VALUE
 rg_set_geometry_hints(VALUE self, VALUE geometry, VALUE geom_mask)
 {
-    gdk_window_set_geometry_hints(_SELF(self), 
+    gdk_window_set_geometry_hints(_SELF(self),
                                   NIL_P(geometry) ? (GdkGeometry*)NULL : RVAL2GDKGEOMETRY(geometry),
                                   RVAL2GDKWINDOWHINTS(geom_mask));
     return self;
@@ -630,15 +621,6 @@ rg_origin(VALUE self)
     return rb_assoc_new(INT2NUM(x), INT2NUM(y));
 }
 
-static VALUE
-rg_pointer(VALUE self)
-{
-    gint x, y;
-    GdkModifierType state;
-    GdkWindow* ret = gdk_window_get_pointer(_SELF(self), &x, &y, &state);
-    return rb_ary_new3(4, GOBJ2RVAL(ret), INT2NUM(x), INT2NUM(y), GDKMODIFIERTYPE2RVAL(state));
-}
-
 static VALUE
 rg_parent(VALUE self)
 {
@@ -655,7 +637,7 @@ static VALUE
 rg_children(VALUE self)
 {
     /* Don't use gdk_window_get_children() here */
-    GList* list = gdk_window_peek_children(_SELF(self));
+    GList *list = gdk_window_peek_children(_SELF(self));
     VALUE ary = rb_ary_new();
     while (list) {
         rb_ary_push(ary, GOBJ2RVAL(list->data));
@@ -800,7 +782,7 @@ rg_s_foreign_new(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
         break;
       case 2:
         win = gdk_window_foreign_new_for_display(RVAL2GOBJ(arg[0]),
-                                                 RVAL2GDKNATIVEWINDOW(arg[1])); 
+                                                 RVAL2GDKNATIVEWINDOW(arg[1]));
         break;
     default:
         break;
@@ -826,7 +808,7 @@ rg_s_lookup(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
         win = gdk_window_lookup(RVAL2GDKNATIVEWINDOW(arg[0]));
         break;
       case 2:
-        win = gdk_window_lookup_for_display(RVAL2GOBJ(arg[0]), RVAL2GDKNATIVEWINDOW(arg[1])); 
+        win = gdk_window_lookup_for_display(RVAL2GOBJ(arg[0]), RVAL2GDKNATIVEWINDOW(arg[1]));
         break;
     default:
         break;
@@ -907,6 +889,22 @@ rg_drag_protocol(VALUE self)
     return rb_ary_new3(2, GDKDRAGPROTOCOL2RVAL(prot), ary);
 }
 
+static VALUE
+rg_get_device_position(VALUE self, VALUE device)
+{
+    gint x, y;
+    GdkModifierType state;
+    GdkWindow *underneath_window;
+
+    underneath_window =
+        gdk_window_get_device_position(_SELF(self),
+                                       RVAL2GDKDEVICE(device),
+                                       &x, &y, &state);
+    return rb_ary_new3(4,
+                       GOBJ2RVAL(underneath_window),
+                       INT2NUM(x), INT2NUM(y), GDKMODIFIERTYPE2RVAL(state));
+}
+
 #ifdef HAVE_RB_CAIRO_H
 static VALUE
 rg_create_cairo_context(VALUE self)
@@ -932,7 +930,6 @@ Init_gdk_window(VALUE mGdk)
     RG_DEF_METHOD(initialize, 3);
     RG_DEF_METHOD(destroy, 0);
     RG_DEF_METHOD(window_type, 0);
-    RG_DEF_SMETHOD(at_pointer, 0);
     RG_DEF_SMETHOD(constrain_size, 4);
     RG_DEF_SMETHOD(process_all_updates, 0);
     RG_DEF_SMETHOD(set_debug_updates, 1);
@@ -1006,7 +1003,6 @@ Init_gdk_window(VALUE mGdk)
     RG_DEF_METHOD(root_origin, 0);
     RG_DEF_METHOD(frame_extents, 0);
     RG_DEF_METHOD(origin, 0);
-    RG_DEF_METHOD(pointer, 0);
     RG_DEF_METHOD(parent, 0);
     RG_DEF_METHOD(toplevel, 0);
     RG_DEF_SMETHOD(default_root_window, 0);
@@ -1035,6 +1031,7 @@ Init_gdk_window(VALUE mGdk)
 */
     RG_DEF_METHOD(drag_begin, 1);
     RG_DEF_METHOD(drag_protocol, 0);
+    RG_DEF_METHOD(get_device_position, 1);
 
 #ifdef HAVE_RB_CAIRO_H
     RG_DEF_METHOD(create_cairo_context, 0);
@@ -1053,7 +1050,7 @@ Init_gdk_window(VALUE mGdk)
     G_DEF_CLASS(GDK_TYPE_WM_DECORATION, "WMDecoration", RG_TARGET_NAMESPACE);
     G_DEF_CLASS(GDK_TYPE_WM_FUNCTION, "WMFunction", RG_TARGET_NAMESPACE);
 
-    rb_define_const(RG_TARGET_NAMESPACE, "PARENT_RELATIVE", INT2FIX(GDK_PARENT_RELATIVE));   
+    rb_define_const(RG_TARGET_NAMESPACE, "PARENT_RELATIVE", INT2FIX(GDK_PARENT_RELATIVE));
 
 #ifdef GDK_WINDOWING_X11
     G_DEF_CLASS3("GdkWindowImplX11", "WindowImplX11", mGdk);

data/lib/gdk3/deprecated.rb

@@ -6,6 +6,11 @@ module Gdk
   define_deprecated_const :Colormap, :raise => "Use 'Gdk::Visual' instead."
   define_deprecated_const :Input, :raise => "Use 'GLib::IOChannel' instead."
   define_deprecated_const :X11, 'GdkX11'
+  define_deprecated_singleton_method :pointer_grab, :raise => "Use 'Gdk::Device#grab'."
+  define_deprecated_singleton_method :pointer_ungrab, :raise => "Use 'Gdk::Device#ungrab'."
+  define_deprecated_singleton_method :keyboard_grab, :raise => "Use 'Gdk::Device#grab'."
+  define_deprecated_singleton_method :keyboard_ungrab, :raise => "Use 'Gdk::Device#ungrab'."
+  define_deprecated_singleton_method :pointer_is_grabbed?, :raise => "Use 'Gdk::Display#device_is_grabbed?'."
 
   class Cursor
     extend GLib::Deprecatable
@@ -33,6 +38,12 @@ module Gdk
     define_deprecated_method :button_number, :raise => "Don't use this method."
     define_deprecated_method :button_x, :raise => "Don't use this method."
     define_deprecated_method :button_y, :raise => "Don't use this method."
+    define_deprecated_method :pointer, :raise => "Use 'Gdk::Device#get_position'."
+    define_deprecated_method :pointer_ungrab, :raise => "Use 'Gdk::Device#ungrab'."
+    define_deprecated_method :pointer_grabbed_p, :raise => "Use 'Gdk::Display#device_is_grabbed?'."
+    define_deprecated_method :window_at_pointer, :raise => "Use 'Gdk::Device#get_window_at_position'."
+    define_deprecated_method :warp_pointer, :raise => "Use 'Gdk::Device#warp'."
+    define_deprecated_method :devices, :raise => "Use 'Gdk::DeviceManager#devices'."
   end
 
   class DragContext
@@ -141,6 +152,8 @@ module Gdk
     define_deprecated_method :shape_combine_mask, :warn => "Don't use this method."
     define_deprecated_method :input_shape_combine_mask, :warn => "Don't use this method."
     define_deprecated_method :set_back_pixmap, :warn => "Don't use this method."
+    define_deprecated_singleton_method :at_pointer, :raise => "Use 'Gdk::Device#get_window_at_position'."
+    define_deprecated_method :pointer, :raise => "Use 'Gdk::Device#get_device_position'."
   end
 
   class WindowAttr
@@ -150,4 +163,3 @@ module Gdk
     alias :colormap= :set_colormap
   end
 end
-

data/test/test-gdk-event.rb

@@ -0,0 +1,598 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013  Ruby-GNOME2 Project Team
+#
+# 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
+
+class TestGdkEvent < Test::Unit::TestCase
+  class TestAny < self
+    def setup
+      @event = Gdk::EventAny.new(:delete)
+    end
+
+    def test_delete
+      assert_equal("GDK_DELETE",
+                   Gdk::EventAny.new(:delete).event_type.name)
+    end
+
+    def test_destroy
+      assert_equal("GDK_DESTROY",
+                   Gdk::EventAny.new(:destroy).event_type.name)
+    end
+
+    def test_window
+      assert_nothing_raised do
+        @event.window
+      end
+    end
+
+    def test_send_event
+      assert_false(@event.send_event?)
+    end
+  end
+
+  class TestKey < self
+    def setup
+      @key = Gdk::EventKey.new(:key_press)
+    end
+
+    def test_key_press
+      assert_equal("GDK_KEY_PRESS",
+                   Gdk::EventKey.new(:key_press).event_type.name)
+    end
+
+    def test_key_release
+      assert_equal("GDK_KEY_RELEASE",
+                   Gdk::EventKey.new(:key_release).event_type.name)
+    end
+
+    def test_time
+      assert_kind_of(Integer, @key.time)
+    end
+
+    def test_state
+      assert_not_nil(@key.state)
+    end
+
+    def test_keyval
+      assert_kind_of(Integer, @key.keyval)
+    end
+  end
+
+  class TestButton < self
+    def setup
+      @button = Gdk::EventButton.new(:button_press)
+    end
+
+    def test_button_press
+      assert_equal("GDK_BUTTON_PRESS",
+                   Gdk::EventButton.new(:button_press).event_type.name)
+    end
+
+    def test_button2_press
+      assert_equal("GDK_2BUTTON_PRESS",
+                   Gdk::EventButton.new(:button2_press).event_type.name)
+    end
+
+    def test_button3_press
+      assert_equal("GDK_3BUTTON_PRESS",
+                   Gdk::EventButton.new(:button3_press).event_type.name)
+    end
+
+    def test_button_release
+      assert_equal("GDK_BUTTON_RELEASE",
+                   Gdk::EventButton.new(:button_release).event_type.name)
+    end
+
+    def test_time
+      assert_kind_of(Integer, @button.time)
+    end
+
+    def test_x
+      assert_kind_of(Float, @button.x)
+    end
+
+    def test_y
+      assert_kind_of(Float, @button.y)
+    end
+
+    def test_state
+      assert_not_nil(@button.state)
+    end
+
+    def test_button
+      assert_kind_of(Integer, @button.button)
+    end
+
+    def test_x_root
+      assert_kind_of(Float, @button.x_root)
+    end
+
+    def test_y_root
+      assert_kind_of(Float, @button.y_root)
+    end
+  end
+
+  class TestTouch < self
+    def setup
+      @touch = Gdk::EventTouch.new(:touch_begin)
+    end
+
+    def test_window
+      assert_nothing_raised do
+        @touch.window
+      end
+    end
+
+    def test_send_event
+      assert_false(@touch.send_event?)
+    end
+
+    def test_time
+      assert_kind_of(Integer, @touch.time)
+    end
+
+    def test_x
+      assert_kind_of(Float, @touch.x)
+    end
+
+    def test_y
+      assert_kind_of(Float, @touch.y)
+    end
+
+    def test_axes
+      assert_nothing_raised do
+        @touch.axes
+      end
+    end
+
+    def test_state
+      assert_not_nil(@touch.state)
+    end
+
+    def test_touch_begin
+      assert_equal("GDK_TOUCH_BEGIN",
+                   Gdk::EventTouch.new(:touch_begin).event_type.name)
+    end
+
+    def test_touch_update
+      assert_equal("GDK_TOUCH_UPDATE",
+                   Gdk::EventTouch.new(:touch_update).event_type.name)
+    end
+
+    def test_touch_cancel
+      assert_equal("GDK_TOUCH_CANCEL",
+                   Gdk::EventTouch.new(:touch_cancel).event_type.name)
+    end
+
+    def test_touch_end
+      assert_equal("GDK_TOUCH_END",
+                   Gdk::EventTouch.new(:touch_end).event_type.name)
+    end
+
+    def test_emulating_pointer
+      assert_nothing_raised do
+        @touch.emulating_pointer
+      end
+    end
+
+    def test_device
+      assert_nothing_raised do
+        @touch.device
+      end
+    end
+
+    def test_x_root
+      assert_kind_of(Float, @touch.x_root)
+    end
+
+    def test_y_root
+      assert_kind_of(Float, @touch.y_root)
+    end
+  end
+
+  class TestScroll < self
+    def setup
+      @scroll = Gdk::EventScroll.new
+    end
+
+    def test_time
+      assert_kind_of(Integer, @scroll.time)
+    end
+
+    def test_x
+      assert_kind_of(Float, @scroll.x)
+    end
+
+    def test_y
+      assert_kind_of(Float, @scroll.y)
+    end
+
+    def test_state
+      assert_not_nil(@scroll.state)
+    end
+
+    def test_direction
+      assert_kind_of(Gdk::EventScroll::Direction, @scroll.direction)
+    end
+
+    def test_x_root
+      assert_kind_of(Float, @scroll.x_root)
+    end
+
+    def test_y_root
+      assert_kind_of(Float, @scroll.y_root)
+    end
+  end
+
+  class TestMotion < self
+    def setup
+      @motion = Gdk::EventMotion.new
+    end
+
+    def test_time
+      assert_kind_of(Integer, @motion.time)
+    end
+
+    def test_x
+      assert_kind_of(Float, @motion.x)
+    end
+
+    def test_y
+      assert_kind_of(Float, @motion.y)
+    end
+
+    def test_state
+      assert_not_nil(@motion.state)
+    end
+
+    def test_x_root
+      assert_kind_of(Float, @motion.x_root)
+    end
+
+    def test_y_root
+      assert_kind_of(Float, @motion.y_root)
+    end
+
+    def test_request
+      assert_nothing_raised do
+        @motion.request
+      end
+    end
+  end
+
+  class TestVisibility < self
+    def setup
+      @visibility = Gdk::EventVisibility.new(:visibility_notify)
+    end
+
+    def test_state
+      assert_kind_of(Gdk::EventVisibility::State, @visibility.state)
+    end
+  end
+
+  class TestCrossing < self
+    def setup
+      @crossing = Gdk::EventCrossing.new(:enter_notify)
+    end
+
+    def test_enter_notify
+      assert_equal("GDK_ENTER_NOTIFY",
+                   Gdk::EventCrossing.new(:enter_notify).event_type.name)
+    end
+
+    def test_leave_notify
+      assert_equal("GDK_LEAVE_NOTIFY",
+                   Gdk::EventCrossing.new(:leave_notify).event_type.name)
+    end
+
+    def test_time
+      assert_kind_of(Integer, @crossing.time)
+    end
+
+    def test_x
+      # TODO: Is Float better?
+      assert_kind_of(Integer, @crossing.x)
+    end
+
+    def test_y
+      # TODO: Is Float better?
+      assert_kind_of(Integer, @crossing.y)
+    end
+
+    def test_x_root
+      assert_kind_of(Float, @crossing.x_root)
+    end
+
+    def test_y_root
+      assert_kind_of(Float, @crossing.y_root)
+    end
+
+    def test_mode
+      assert_kind_of(Gdk::EventCrossing::Mode, @crossing.mode)
+    end
+
+    def test_detail
+      assert_not_nil(@crossing.detail)
+    end
+
+    def test_state
+      assert_not_nil(@crossing.state)
+    end
+  end
+
+  class TestFocus < self
+    def setup
+      @focus = Gdk::EventFocus.new
+    end
+
+    def test_in
+      assert_false(@focus.in?)
+    end
+  end
+
+  class TestConfigure < self
+    def setup
+      @configure = Gdk::EventConfigure.new
+    end
+
+    def test_x
+      assert_kind_of(Integer, @configure.x)
+    end
+
+    def test_y
+      assert_kind_of(Integer, @configure.y)
+    end
+
+    def test_width
+      assert_kind_of(Integer, @configure.width)
+    end
+
+    def test_height
+      assert_kind_of(Integer, @configure.height)
+    end
+  end
+
+  class TestProperty < self
+    def setup
+      @property = Gdk::EventProperty.new
+    end
+
+    def test_atom
+      assert_nothing_raised do
+        @property.atom
+      end
+    end
+
+    def test_time
+      assert_kind_of(Integer, @property.time)
+    end
+
+    def test_state
+      assert_not_nil(Integer, @property.state)
+    end
+  end
+
+  class TestSelection < self
+    def setup
+      @selection = Gdk::EventSelection.new(:selection_clear)
+    end
+
+    def test_selection_clear
+      assert_equal("GDK_SELECTION_CLEAR",
+                   Gdk::EventSelection.new(:selection_clear).event_type.name)
+    end
+
+    def test_selection_notify
+      assert_equal("GDK_SELECTION_NOTIFY",
+                   Gdk::EventSelection.new(:selection_notify).event_type.name)
+    end
+
+    def test_selection_request
+      assert_equal("GDK_SELECTION_REQUEST",
+                   Gdk::EventSelection.new(:selection_request).event_type.name)
+    end
+
+    def test_selection
+      assert_nothing_raised do
+        @selection.selection
+      end
+    end
+
+    def test_target
+      assert_nothing_raised do
+        @selection.target
+      end
+    end
+
+    def test_property
+      assert_nothing_raised do
+        @selection.property
+      end
+    end
+
+    def test_time
+      assert_kind_of(Integer, @selection.time)
+    end
+  end
+
+  class TestDND < self
+    def setup
+      @dnd = Gdk::EventDND.new(:drag_enter)
+    end
+
+    def test_drag_enter
+      assert_equal("GDK_DRAG_ENTER",
+                   Gdk::EventDND.new(:drag_enter).event_type.name)
+    end
+
+    def test_drag_leave
+      assert_equal("GDK_DRAG_LEAVE",
+                   Gdk::EventDND.new(:drag_leave).event_type.name)
+    end
+
+    def test_drag_motion
+      assert_equal("GDK_DRAG_MOTION",
+                   Gdk::EventDND.new(:drag_motion).event_type.name)
+    end
+
+    def test_drag_status
+      assert_equal("GDK_DRAG_STATUS",
+                   Gdk::EventDND.new(:drag_status).event_type.name)
+    end
+
+    def test_drop_start
+      assert_equal("GDK_DROP_START",
+                   Gdk::EventDND.new(:drop_start).event_type.name)
+    end
+
+    def test_drop_finished
+      assert_equal("GDK_DROP_FINISHED",
+                   Gdk::EventDND.new(:drop_finished).event_type.name)
+    end
+
+    def test_context
+      assert_nothing_raised do
+        @dnd.context
+      end
+    end
+
+    def test_time
+      assert_kind_of(Integer, @dnd.time)
+    end
+
+    def test_x_root
+      assert_kind_of(Integer, @dnd.x_root)
+    end
+
+    def test_y_root
+      assert_kind_of(Integer, @dnd.y_root)
+    end
+  end
+
+  class TestProximity < self
+    def setup
+      @proximity = Gdk::EventProximity.new(:proximity_in)
+    end
+
+    def test_proximity_in
+      assert_equal("GDK_PROXIMITY_IN",
+                   Gdk::EventProximity.new(:proximity_in).event_type.name)
+    end
+
+    def test_proximity_out
+      assert_equal("GDK_PROXIMITY_OUT",
+                   Gdk::EventProximity.new(:proximity_out).event_type.name)
+    end
+
+    def test_time
+      assert_kind_of(Integer, @proximity.time)
+    end
+
+    def test_device
+      assert_nothing_raised do
+        @proximity.device
+      end
+    end
+  end
+
+  class TestWindowState < self
+    def setup
+      @window_state = Gdk::EventWindowState.new
+    end
+
+    def test_changed_mask
+      assert_nothing_raised do
+        @window_state.changed_mask
+      end
+    end
+
+    def test_new_window_state
+      assert_nothing_raised do
+        @window_state.new_window_state
+      end
+    end
+  end
+
+  class TestSetting < self
+    def setup
+      @setting = Gdk::EventSetting.new
+    end
+
+    def test_action
+      assert_nothing_raised do
+        @setting.action
+      end
+    end
+
+    def test_name
+      assert_nothing_raised do
+        @setting.name
+      end
+    end
+  end
+
+  class TestOwnerChange < self
+    def setup
+      @owner_change = Gdk::EventOwnerChange.new
+    end
+
+    def test_owner
+      assert_nothing_raised do
+        @owner_change.owner
+      end
+    end
+
+    def test_reason
+      assert_nothing_raised do
+        @owner_change.reason
+      end
+    end
+
+    def test_selection
+      assert_nothing_raised do
+        @owner_change.selection
+      end
+    end
+
+    def test_time
+      assert_kind_of(Integer, @owner_change.time)
+    end
+
+    def test_selection_time
+      assert_kind_of(Integer, @owner_change.selection_time)
+    end
+  end
+
+  class TestGrabBroken < self
+    def setup
+      @grab_broken = Gdk::EventGrabBroken.new
+    end
+
+    def test_keyboard
+      assert_boolean(@grab_broken.keyboard?)
+    end
+
+    def test_implicit
+      assert_boolean(@grab_broken.implicit?)
+    end
+
+    def test_grab_window
+      assert_nothing_raised do
+        @grab_broken.grab_window
+      end
+    end
+  end
+end