GNOME.org
 

[gtk+/xi2] Add gdk_event_set_device().

commit 0db2591776594907de33b7f77a9227a70a7427cf
Author: Carlos Garnacho <carlos gnome org>
Date:   Sun Jan 10 21:12:03 2010 +0100

    Add gdk_event_set_device().
    
    GdkDevice data in GdkEvent has been moved to GdkEventPrivate for all the
    events that were modified due to XInput2 (key press/release, enter/leave,
    focus in/out, grab broken and DnD events), so the ABI break due to
    GdkEvent having grown in size is now fixed.
    
    All code accessing the GdkDevice field in these event types have been
    modified to use gdk_event_get_device(), events are now allocated instead
    of in-stack where necessary.

 gdk/gdkdisplay.c                         |   21 +++++----
 gdk/gdkevents.c                          |   38 ++++++++-------
 gdk/gdkevents.h                          |    7 +--
 gdk/gdkinternals.h                       |    1 +
 gdk/gdkwindow.c                          |    2 +-
 gdk/x11/gdkdevicemanager-core.c          |   21 ++++----
 gdk/x11/gdkdevicemanager-xi2.c           |   13 ++++--
 gdk/x11/gdkdnd-x11.c                     |   77 ++++++++++++++++--------------
 gdk/x11/gdkeventsource.c                 |   15 +++---
 gtk/gtkdnd.c                             |    2 +-
 gtk/gtkmain.c                            |    8 ++-
 gtk/gtkmenu.c                            |    6 +-
 gtk/gtkplug-x11.c                        |    2 +-
 gtk/gtkspinbutton.c                      |    4 +-
 gtk/gtktreeview.c                        |   17 ++++---
 gtk/gtkwidget.c                          |    4 +-
 gtk/gtkwindow.c                          |    2 +-
 tests/multidevice/testangle.c            |    8 ++-
 tests/multidevice/testcoordinatewidget.c |   12 +++--
 19 files changed, 147 insertions(+), 113 deletions(-)
---
diff --git a/gdk/gdkdisplay.c b/gdk/gdkdisplay.c
index d4c87c5..8174f04 100644
--- a/gdk/gdkdisplay.c
+++ b/gdk/gdkdisplay.c
@@ -1098,15 +1098,18 @@ generate_grab_broken_event (GdkWindow *window,
 
   if (!GDK_WINDOW_DESTROYED (window))
     {
-      GdkEvent event;
-      event.type = GDK_GRAB_BROKEN;
-      event.grab_broken.window = window;
-      event.grab_broken.send_event = 0;
-      event.grab_broken.keyboard = (device->source == GDK_SOURCE_KEYBOARD) ? TRUE : FALSE;
-      event.grab_broken.implicit = implicit;
-      event.grab_broken.grab_window = grab_window;
-      event.grab_broken.device = device;
-      gdk_event_put (&event);
+      GdkEvent *event;
+
+      event = gdk_event_new (GDK_GRAB_BROKEN);
+      event->grab_broken.window = g_object_ref (window);
+      event->grab_broken.send_event = FALSE;
+      event->grab_broken.implicit = implicit;
+      event->grab_broken.grab_window = grab_window;
+      gdk_event_set_device (event, device);
+      event->grab_broken.keyboard = (device->source == GDK_SOURCE_KEYBOARD) ? TRUE : FALSE;
+
+      gdk_event_put (event);
+      gdk_event_free (event);
     }
 }
 
diff --git a/gdk/gdkevents.c b/gdk/gdkevents.c
index e114a2c..4758330 100644
--- a/gdk/gdkevents.c
+++ b/gdk/gdkevents.c
@@ -918,6 +918,19 @@ gdk_event_get_axis (const GdkEvent *event,
   return gdk_device_get_axis (device, axes, axis_use, value);
 }
 
+void
+gdk_event_set_device (GdkEvent  *event,
+                      GdkDevice *device)
+{
+  GdkEventPrivate *private;
+  
+  g_return_if_fail (gdk_event_is_allocated (event));
+
+  private = (GdkEventPrivate *) event;
+  
+  private->device = device;
+}
+
 /**
  * gdk_event_get_device:
  * @event: a #GdkEvent.
@@ -932,6 +945,14 @@ gdk_event_get_device (const GdkEvent *event)
 {
   g_return_val_if_fail (event != NULL, NULL);
 
+  if (gdk_event_is_allocated (event))
+    {
+      GdkEventPrivate *private = (GdkEventPrivate *) event;
+
+      if (private->device)
+        return private->device;
+    }
+
   switch (event->type)
     {
     case GDK_MOTION_NOTIFY:
@@ -941,28 +962,11 @@ gdk_event_get_device (const GdkEvent *event)
     case GDK_3BUTTON_PRESS:
     case GDK_BUTTON_RELEASE:
       return event->button.device;
-    case GDK_KEY_PRESS:
-    case GDK_KEY_RELEASE:
-      return event->key.device;
-    case GDK_FOCUS_CHANGE:
-      return event->focus_change.device;
-    case GDK_ENTER_NOTIFY:
-    case GDK_LEAVE_NOTIFY:
-      return event->crossing.device;
     case GDK_SCROLL:
       return event->scroll.device;
-    case GDK_GRAB_BROKEN:
-      return event->grab_broken.device;
     case GDK_PROXIMITY_IN:
     case GDK_PROXIMITY_OUT:
       return event->proximity.device;
-    case GDK_DRAG_ENTER:
-    case GDK_DRAG_LEAVE:
-    case GDK_DRAG_MOTION:
-    case GDK_DRAG_STATUS:
-    case GDK_DROP_START:
-    case GDK_DROP_FINISHED:
-      return event->dnd.device;
     default:
       return NULL;
     }
diff --git a/gdk/gdkevents.h b/gdk/gdkevents.h
index f379fa9..cccf1ca 100644
--- a/gdk/gdkevents.h
+++ b/gdk/gdkevents.h
@@ -352,7 +352,6 @@ struct _GdkEventKey
   guint16 hardware_keycode;
   guint8 group;
   guint is_modifier : 1;
-  GdkDevice *device;
 };
 
 struct _GdkEventCrossing
@@ -370,7 +369,6 @@ struct _GdkEventCrossing
   GdkNotifyType detail;
   gboolean focus;
   guint state;
-  GdkDevice *device;
 };
 
 struct _GdkEventFocus
@@ -379,7 +377,6 @@ struct _GdkEventFocus
   GdkWindow *window;
   gint8 send_event;
   gint16 in;
-  GdkDevice *device;
 };
 
 struct _GdkEventConfigure
@@ -477,7 +474,6 @@ struct _GdkEventGrabBroken {
   gboolean keyboard;
   gboolean implicit;
   GdkWindow *grab_window;
-  GdkDevice *device;
 };
 
 /* Event types for DND */
@@ -490,7 +486,6 @@ struct _GdkEventDND {
 
   guint32 time;
   gshort x_root, y_root;
-  GdkDevice *device;
 };
 
 union _GdkEvent
@@ -545,6 +540,8 @@ gboolean  gdk_event_get_root_coords	(const GdkEvent  *event,
 gboolean  gdk_event_get_axis            (const GdkEvent  *event,
                                          GdkAxisUse       axis_use,
                                          gdouble         *value);
+void       gdk_event_set_device         (GdkEvent        *event,
+                                         GdkDevice       *device);
 GdkDevice* gdk_event_get_device         (const GdkEvent  *event);
 void      gdk_event_request_motions     (const GdkEventMotion *event);
 
diff --git a/gdk/gdkinternals.h b/gdk/gdkinternals.h
index 32cc15b..7afa723 100644
--- a/gdk/gdkinternals.h
+++ b/gdk/gdkinternals.h
@@ -169,6 +169,7 @@ struct _GdkEventPrivate
   guint      flags;
   GdkScreen *screen;
   gpointer   windowing_data;
+  GdkDevice *device;
 };
 
 /* Tracks information about the pointer grab on this display */
diff --git a/gdk/gdkwindow.c b/gdk/gdkwindow.c
index db9996a..c1a2b6a 100644
--- a/gdk/gdkwindow.c
+++ b/gdk/gdkwindow.c
@@ -9753,8 +9753,8 @@ send_crossing_event (GdkDisplay                 *display,
   if (window_event_mask & type_event_mask)
     {
       event = _gdk_make_event ((GdkWindow *)window, type, event_in_queue, TRUE);
+      gdk_event_set_device (event, device);
       event->crossing.time = time_;
-      event->crossing.device = device;
       event->crossing.subwindow = subwindow;
       if (subwindow)
 	g_object_ref (subwindow);
diff --git a/gdk/x11/gdkdevicemanager-core.c b/gdk/x11/gdkdevicemanager-core.c
index a1ec416..5d59522 100644
--- a/gdk/x11/gdkdevicemanager-core.c
+++ b/gdk/x11/gdkdevicemanager-core.c
@@ -146,7 +146,7 @@ translate_key_event (GdkDisplay           *display,
 
   event->key.type = xevent->xany.type == KeyPress ? GDK_KEY_PRESS : GDK_KEY_RELEASE;
   event->key.time = xevent->xkey.time;
-  event->key.device = device_manager->core_keyboard;
+  gdk_event_set_device (event, device_manager->core_keyboard);
 
   event->key.state = (GdkModifierType) xevent->xkey.state;
   event->key.group = _gdk_x11_get_group_for_state (display, xevent->xkey.state);
@@ -284,15 +284,16 @@ generate_focus_event (GdkDeviceManagerCore *device_manager,
                       GdkWindow            *window,
 		      gboolean              in)
 {
-  GdkEvent event;
+  GdkEvent *event;
 
-  event.type = GDK_FOCUS_CHANGE;
-  event.focus_change.window = window;
-  event.focus_change.send_event = FALSE;
-  event.focus_change.in = in;
-  event.focus_change.device = device_manager->core_keyboard;
+  event = gdk_event_new (GDK_FOCUS_CHANGE);
+  event->focus_change.window = g_object_ref (window);
+  event->focus_change.send_event = FALSE;
+  event->focus_change.in = in;
+  gdk_event_set_device (event, device_manager->core_keyboard);
 
-  gdk_event_put (&event);
+  gdk_event_put (event);
+  gdk_event_free (event);
 }
 
 static gboolean
@@ -670,7 +671,7 @@ gdk_device_manager_core_translate_event (GdkEventTranslator *translator,
 
       event->crossing.type = GDK_ENTER_NOTIFY;
       event->crossing.window = window;
-      event->crossing.device = device_manager->core_pointer;
+      gdk_event_set_device (event, device_manager->core_pointer);
 
       /* If the subwindow field of the XEvent is non-NULL, then
        *  lookup the corresponding GdkWindow.
@@ -714,7 +715,7 @@ gdk_device_manager_core_translate_event (GdkEventTranslator *translator,
 
       event->crossing.type = GDK_LEAVE_NOTIFY;
       event->crossing.window = window;
-      event->crossing.device = device_manager->core_pointer;
+      gdk_event_set_device (event, device_manager->core_pointer);
 
       /* If the subwindow field of the XEvent is non-NULL, then
        *  lookup the corresponding GdkWindow.
diff --git a/gdk/x11/gdkdevicemanager-xi2.c b/gdk/x11/gdkdevicemanager-xi2.c
index ca25185..ee1e025 100644
--- a/gdk/x11/gdkdevicemanager-xi2.c
+++ b/gdk/x11/gdkdevicemanager-xi2.c
@@ -882,6 +882,7 @@ gdk_device_manager_xi2_translate_event (GdkEventTranslator *translator,
       {
         XIDeviceEvent *xev = (XIDeviceEvent *) ev;
         GdkKeymap *keymap = gdk_keymap_get_for_display (display);
+        GdkDevice *device;
 
         event->key.type = xev->evtype == XI_KeyPress ? GDK_KEY_PRESS : GDK_KEY_RELEASE;
 
@@ -894,8 +895,9 @@ gdk_device_manager_xi2_translate_event (GdkEventTranslator *translator,
         event->key.hardware_keycode = xev->detail;
         event->key.is_modifier = _gdk_keymap_key_is_modifier (keymap, event->key.hardware_keycode);
 
-        event->key.device = g_hash_table_lookup (device_manager->id_table,
-                                                 GUINT_TO_POINTER (xev->deviceid));
+        device = g_hash_table_lookup (device_manager->id_table,
+                                      GUINT_TO_POINTER (xev->deviceid));
+        gdk_event_set_device (event, device);
 
         _gdk_keymap_add_virtual_modifiers (keymap, &event->key.state);
 
@@ -1037,6 +1039,7 @@ gdk_device_manager_xi2_translate_event (GdkEventTranslator *translator,
     case XI_Leave:
       {
         XIEnterEvent *xev = (XIEnterEvent *) ev;
+        GdkDevice *device;
 
         event->crossing.type = (ev->evtype == XI_Enter) ? GDK_ENTER_NOTIFY : GDK_LEAVE_NOTIFY;
 
@@ -1049,8 +1052,10 @@ gdk_device_manager_xi2_translate_event (GdkEventTranslator *translator,
 
         event->crossing.window = window;
         event->crossing.subwindow = gdk_window_lookup_for_display (display, xev->child);
-        event->crossing.device = g_hash_table_lookup (device_manager->id_table,
-                                                      GINT_TO_POINTER (xev->deviceid));
+
+        device = g_hash_table_lookup (device_manager->id_table,
+                                      GINT_TO_POINTER (xev->deviceid));
+        gdk_event_set_device (event, device);
 
         event->crossing.mode = translate_crossing_mode (xev->mode);
         event->crossing.detail = translate_notify_type (xev->detail);
diff --git a/gdk/x11/gdkdnd-x11.c b/gdk/x11/gdkdnd-x11.c
index 4fe3f5f..3daf056 100644
--- a/gdk/x11/gdkdnd-x11.c
+++ b/gdk/x11/gdkdnd-x11.c
@@ -2025,7 +2025,7 @@ xdnd_status_filter (GdkXEvent *xev,
       event->dnd.send_event = FALSE;
       event->dnd.type = GDK_DRAG_STATUS;
       event->dnd.context = context;
-      event->dnd.device = gdk_drag_context_get_device (context);
+      gdk_event_set_device (event, gdk_drag_context_get_device (context));
       g_object_ref (context);
 
       event->dnd.time = GDK_CURRENT_TIME; /* FIXME? */
@@ -2073,7 +2073,7 @@ xdnd_finished_filter (GdkXEvent *xev,
       
       event->dnd.type = GDK_DROP_FINISHED;
       event->dnd.context = context;
-      event->dnd.device = gdk_drag_context_get_device (context);
+      gdk_event_set_device (event, gdk_drag_context_get_device (context));
       g_object_ref (context);
 
       event->dnd.time = GDK_CURRENT_TIME; /* FIXME? */
@@ -2181,7 +2181,7 @@ send_client_message_async_cb (Window   window,
       context->dest_window &&
       window == GDK_WINDOW_XID (context->dest_window))
     {
-      GdkEvent temp_event;
+      GdkEvent *temp_event;
       GdkDragContextPrivateX11 *private = PRIVATE_DATA (context);
 
       g_object_unref (context->dest_window);
@@ -2190,14 +2190,16 @@ send_client_message_async_cb (Window   window,
 
       private->drag_status = GDK_DRAG_STATUS_DRAG;
 
-      temp_event.dnd.type = GDK_DRAG_STATUS;
-      temp_event.dnd.window = context->source_window;
-      temp_event.dnd.send_event = TRUE;
-      temp_event.dnd.context = context;
-      temp_event.dnd.time = GDK_CURRENT_TIME;
-      temp_event.dnd.device = gdk_drag_context_get_device (context);
+      temp_event = gdk_event_new (GDK_DRAG_STATUS);
+      temp_event->dnd.window = g_object_ref (context->source_window);
+      temp_event->dnd.send_event = TRUE;
+      temp_event->dnd.context = g_object_ref (context);
+      temp_event->dnd.time = GDK_CURRENT_TIME;
+      gdk_event_set_device (temp_event, gdk_drag_context_get_device (context));
 
-      gdk_event_put (&temp_event);
+      gdk_event_put (temp_event);
+
+      gdk_event_free (temp_event);
     }
 
   g_object_unref (context);
@@ -2254,13 +2256,15 @@ xdnd_send_xevent (GdkDragContext *context,
 	  if (gdk_x11_get_xatom_by_name_for_display (display, xdnd_filters[i].atom_name) ==
 	      event_send->xclient.message_type)
 	    {
-	      GdkEvent temp_event;
-	      temp_event.any.window = window;
+	      GdkEvent *temp_event;
+
+              temp_event = gdk_event_new (GDK_NOTHING);
+              temp_event->any.window = g_object_ref (window);
 
-	      if ((*xdnd_filters[i].func) (event_send, &temp_event, NULL) == GDK_FILTER_TRANSLATE)
+	      if ((*xdnd_filters[i].func) (event_send, temp_event, NULL) == GDK_FILTER_TRANSLATE)
 		{
-		  gdk_event_put (&temp_event);
-		  g_object_unref (temp_event.dnd.context);
+		  gdk_event_put (temp_event);
+                  gdk_event_free (temp_event);
 		}
 	      
 	      return TRUE;
@@ -2817,7 +2821,7 @@ xdnd_enter_filter (GdkXEvent *xev,
 
   event->dnd.type = GDK_DRAG_ENTER;
   event->dnd.context = new_context;
-  event->dnd.device = gdk_drag_context_get_device (new_context);
+  gdk_event_set_device (event, gdk_drag_context_get_device (new_context));
   g_object_ref (new_context);
 
   display_x11->current_dest_drag = new_context;
@@ -2855,7 +2859,7 @@ xdnd_leave_filter (GdkXEvent *xev,
       event->dnd.type = GDK_DRAG_LEAVE;
       /* Pass ownership of context to the event */
       event->dnd.context = display_x11->current_dest_drag;
-      event->dnd.device = gdk_drag_context_get_device (event->dnd.context);
+      gdk_event_set_device (event, gdk_drag_context_get_device (event->dnd.context));
 
       display_x11->current_dest_drag = NULL;
 
@@ -2899,7 +2903,7 @@ xdnd_position_filter (GdkXEvent *xev,
     {
       event->dnd.type = GDK_DRAG_MOTION;
       event->dnd.context = display_x11->current_dest_drag;
-      event->dnd.device = gdk_drag_context_get_device (event->dnd.context);
+      gdk_event_set_device (event, gdk_drag_context_get_device (event->dnd.context));
       g_object_ref (display_x11->current_dest_drag);
 
       event->dnd.time = time;
@@ -2955,7 +2959,7 @@ xdnd_drop_filter (GdkXEvent *xev,
       event->dnd.type = GDK_DROP_START;
 
       event->dnd.context = display_x11->current_dest_drag;
-      event->dnd.device = gdk_drag_context_get_device (event->dnd.context);
+      gdk_event_set_device (event, gdk_drag_context_get_device (event->dnd.context));
       g_object_ref (display_x11->current_dest_drag);
 
       event->dnd.time = time;
@@ -3376,7 +3380,7 @@ gdk_drag_motion (GdkDragContext *context,
 
   if (context->dest_window != dest_window)
     {
-      GdkEvent temp_event;
+      GdkEvent *temp_event;
 
       /* Send a leave to the last destination */
       gdk_drag_do_leave (context, time);
@@ -3420,19 +3424,19 @@ gdk_drag_motion (GdkDragContext *context,
       /* Push a status event, to let the client know that
        * the drag changed 
        */
-
-      temp_event.dnd.type = GDK_DRAG_STATUS;
-      temp_event.dnd.window = context->source_window;
+      temp_event = gdk_event_new (GDK_DRAG_STATUS);
+      temp_event->dnd.window = g_object_ref (context->source_window);
       /* We use this to signal a synthetic status. Perhaps
        * we should use an extra field...
        */
-      temp_event.dnd.send_event = TRUE;
+      temp_event->dnd.send_event = TRUE;
 
-      temp_event.dnd.context = context;
-      temp_event.dnd.time = time;
-      temp_event.dnd.device = gdk_drag_context_get_device (context);
+      temp_event->dnd.context = g_object_ref (context);
+      temp_event->dnd.time = time;
+      gdk_event_set_device (temp_event, gdk_drag_context_get_device (context));
 
-      gdk_event_put (&temp_event);
+      gdk_event_put (temp_event);
+      gdk_event_free (temp_event);
     }
   else
     {
@@ -3461,7 +3465,7 @@ gdk_drag_motion (GdkDragContext *context,
 
 	    case GDK_DRAG_PROTO_ROOTWIN:
 	      {
-		GdkEvent temp_event;
+		GdkEvent *temp_event;
 		/* GTK+ traditionally has used application/x-rootwin-drop,
 		 * but the XDND spec specifies x-rootwindow-drop.
 		 */
@@ -3476,14 +3480,15 @@ gdk_drag_motion (GdkDragContext *context,
 		else
 		  context->action = 0;
 
-		temp_event.dnd.type = GDK_DRAG_STATUS;
-		temp_event.dnd.window = context->source_window;
-		temp_event.dnd.send_event = FALSE;
-		temp_event.dnd.context = context;
-		temp_event.dnd.time = time;
-                temp_event.dnd.device = gdk_drag_context_get_device (context);
+                temp_event = gdk_event_new (GDK_DRAG_STATUS);
+		temp_event->dnd.window = g_object_ref (context->source_window);
+		temp_event->dnd.send_event = FALSE;
+		temp_event->dnd.context = g_object_ref (context);
+		temp_event->dnd.time = time;
+                gdk_event_set_device (temp_event, gdk_drag_context_get_device (context));
 
-		gdk_event_put (&temp_event);
+		gdk_event_put (temp_event);
+                gdk_event_free (temp_event);
 	      }
 	      break;
 	    case GDK_DRAG_PROTO_NONE:
diff --git a/gdk/x11/gdkeventsource.c b/gdk/x11/gdkeventsource.c
index b1caa8f..e0ab3be 100644
--- a/gdk/x11/gdkeventsource.c
+++ b/gdk/x11/gdkeventsource.c
@@ -114,15 +114,16 @@ handle_focus_change (GdkEventCrossing *event)
 
   if (HAS_FOCUS (toplevel) != had_focus)
     {
-      GdkEvent focus_event;
+      GdkEvent *focus_event;
 
-      focus_event.type = GDK_FOCUS_CHANGE;
-      focus_event.focus_change.window = event->window;
-      focus_event.focus_change.send_event = FALSE;
-      focus_event.focus_change.in = focus_in;
-      focus_event.focus_change.device = event->device;
+      focus_event = gdk_event_new (GDK_FOCUS_CHANGE);
+      focus_event->focus_change.window = g_object_ref (event->window);
+      focus_event->focus_change.send_event = FALSE;
+      focus_event->focus_change.in = focus_in;
+      gdk_event_set_device (focus_event, gdk_event_get_device ((GdkEvent *) event));
 
-      gdk_event_put (&focus_event);
+      gdk_event_put (focus_event);
+      gdk_event_free (focus_event);
     }
 }
 
diff --git a/gtk/gtkdnd.c b/gtk/gtkdnd.c
index ec068d3..e989102 100644
--- a/gtk/gtkdnd.c
+++ b/gtk/gtkdnd.c
@@ -4283,7 +4283,7 @@ gtk_drag_key_cb (GtkWidget         *widget,
 
   dx = dy = 0;
   state = event->state & gtk_accelerator_get_default_mod_mask ();
-  pointer = gdk_device_get_associated_device (event->device);
+  pointer = gdk_device_get_associated_device (gdk_event_get_device ((GdkEvent *) event));
 
   if (event->type == GDK_KEY_PRESS)
     {
diff --git a/gtk/gtkmain.c b/gtk/gtkmain.c
index de9aab0..6c9ef75 100644
--- a/gtk/gtkmain.c
+++ b/gtk/gtkmain.c
@@ -1616,13 +1616,17 @@ gtk_main_do_event (GdkEvent *event)
       break;
       
     case GDK_ENTER_NOTIFY:
-      _gtk_widget_set_device_window (event_widget, event->crossing.device, event->any.window);
+      _gtk_widget_set_device_window (event_widget,
+                                     gdk_event_get_device (event),
+                                     event->any.window);
       if (GTK_WIDGET_IS_SENSITIVE (grab_widget))
 	gtk_widget_event (grab_widget, event);
       break;
       
     case GDK_LEAVE_NOTIFY:
-      _gtk_widget_set_device_window (event_widget, event->crossing.device, NULL);
+      _gtk_widget_set_device_window (event_widget,
+                                     gdk_event_get_device (event),
+                                     NULL);
       if (GTK_WIDGET_IS_SENSITIVE (grab_widget))
 	gtk_widget_event (grab_widget, event);
       break;
diff --git a/gtk/gtkmenu.c b/gtk/gtkmenu.c
index 3ef9061..5fedb18 100644
--- a/gtk/gtkmenu.c
+++ b/gtk/gtkmenu.c
@@ -3376,7 +3376,7 @@ gtk_menu_motion_notify (GtkWidget      *widget,
 	  send_event->crossing.x = event->x;
 	  send_event->crossing.y = event->y;
           send_event->crossing.state = event->state;
-          send_event->crossing.device = event->device;
+          gdk_event_set_device (send_event, gdk_event_get_device ((GdkEvent *) event));
 
 	  /* We send the event to 'widget', the currently active menu,
 	   * instead of 'menu', the menu that the pointer is in. This
@@ -4070,7 +4070,7 @@ gtk_menu_stop_navigating_submenu_cb (gpointer user_data)
 	  send_event->crossing.window = g_object_ref (child_window);
 	  send_event->crossing.time = GDK_CURRENT_TIME; /* Bogus */
 	  send_event->crossing.send_event = TRUE;
-          send_event->crossing.device = popdown_data->device;
+          gdk_event_set_device (send_event, popdown_data->device);
 
 	  GTK_WIDGET_CLASS (gtk_menu_parent_class)->enter_notify_event (GTK_WIDGET (menu), (GdkEventCrossing *)send_event);
 
@@ -4254,7 +4254,7 @@ gtk_menu_set_submenu_navigation_region (GtkMenu          *menu,
 
       popdown_data = g_new (GtkMenuPopdownData, 1);
       popdown_data->menu = menu;
-      popdown_data->device = event->device;
+      popdown_data->device = gdk_event_get_device ((GdkEvent *) event);
 
       menu->navigation_timeout = gdk_threads_add_timeout_full (G_PRIORITY_DEFAULT,
                                                                popdown_delay,
diff --git a/gtk/gtkplug-x11.c b/gtk/gtkplug-x11.c
index 7c4b081..d0df6f5 100644
--- a/gtk/gtkplug-x11.c
+++ b/gtk/gtkplug-x11.c
@@ -388,7 +388,7 @@ _gtk_plug_windowing_filter_func (GdkXEvent *gdk_xevent,
                                          NULL);
 
         translated_event = gdk_event_translator_translate (GDK_EVENT_TRANSLATOR (core_device_manager), display, xevent);
-        translated_event->key.device = keyboard;
+        gdk_event_set_device (translated_event, keyboard);
 
         gtk_main_do_event (translated_event);
         gdk_event_free (translated_event);
diff --git a/gtk/gtkspinbutton.c b/gtk/gtkspinbutton.c
index 589f047..8ab8abf 100644
--- a/gtk/gtkspinbutton.c
+++ b/gtk/gtkspinbutton.c
@@ -903,10 +903,12 @@ gtk_spin_button_enter_notify (GtkWidget        *widget,
 
   if (event->window == spin->panel)
     {
+      GdkDevice *device;
       gint x;
       gint y;
 
-      gdk_window_get_device_position (spin->panel, event->device, &x, &y, NULL);
+      device = gdk_event_get_device ((GdkEvent *) event);
+      gdk_window_get_device_position (spin->panel, device, &x, &y, NULL);
 
       if (y <= widget->requisition.height / 2)
 	spin->in_child = GTK_ARROW_UP;
diff --git a/gtk/gtktreeview.c b/gtk/gtktreeview.c
index caad990..4e91d60 100644
--- a/gtk/gtktreeview.c
+++ b/gtk/gtktreeview.c
@@ -5450,7 +5450,9 @@ gtk_tree_view_key_press (GtkWidget   *widget,
       if (tree_view->priv->imcontext_changed ||    /* we're in a preedit */
 	  (retval && text_modified))               /* ...or the text was modified */
 	{
-	  if (gtk_tree_view_real_start_interactive_search (tree_view, event->device, FALSE))
+	  if (gtk_tree_view_real_start_interactive_search (tree_view,
+                                                           gdk_event_get_device ((GdkEvent *) event),
+                                                           FALSE))
 	    {
 	      gtk_widget_grab_focus (GTK_WIDGET (tree_view));
 	      return TRUE;
@@ -5553,8 +5555,8 @@ gtk_tree_view_focus_out (GtkWidget     *widget,
 
   /* destroy interactive search dialog */
   if (tree_view->priv->search_window)
-    gtk_tree_view_search_dialog_hide (tree_view->priv->search_window,
-                                      tree_view, event->device);
+    gtk_tree_view_search_dialog_hide (tree_view->priv->search_window, tree_view,
+                                      gdk_event_get_device ((GdkEvent *) event));
 
   return FALSE;
 }
@@ -9270,7 +9272,7 @@ _gtk_tree_view_column_start_drag (GtkTreeView       *tree_view,
   send_event->crossing.subwindow = NULL;
   send_event->crossing.detail = GDK_NOTIFY_ANCESTOR;
   send_event->crossing.time = GDK_CURRENT_TIME;
-  send_event->crossing.device = device;
+  gdk_event_set_device (send_event, device);
 
   gtk_propagate_event (column->button, send_event);
   gdk_event_free (send_event);
@@ -9286,7 +9288,7 @@ _gtk_tree_view_column_start_drag (GtkTreeView       *tree_view,
   send_event->button.button = 1;
   send_event->button.x_root = 0;
   send_event->button.y_root = 0;
-  send_event->button.device = device;
+  gdk_event_set_device (send_event, device);
 
   gtk_propagate_event (column->button, send_event);
   gdk_event_free (send_event);
@@ -10253,7 +10255,7 @@ send_focus_change (GtkWidget *widget,
       fevent->focus_change.type = GDK_FOCUS_CHANGE;
       fevent->focus_change.window = g_object_ref (widget->window);
       fevent->focus_change.in = in;
-      fevent->focus_change.device = device;
+      gdk_event_set_device (fevent, device);
 
       gtk_widget_event (widget, fevent);
 
@@ -14359,7 +14361,8 @@ gtk_tree_view_search_key_press_event (GtkWidget *widget,
 	    event->keyval == GDK_KP_Tab ||
 	    event->keyval == GDK_ISO_Left_Tab))
     {
-      gtk_tree_view_search_dialog_hide (widget, tree_view, event->device);
+      gtk_tree_view_search_dialog_hide (widget, tree_view,
+                                        gdk_event_get_device ((GdkEvent *) event));
       return TRUE;
     }
 
diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c
index dd77772..5c09a61 100644
--- a/gtk/gtkwidget.c
+++ b/gtk/gtkwidget.c
@@ -8817,7 +8817,7 @@ synth_crossing (GtkWidget       *widget,
   event->crossing.detail = detail;
   event->crossing.focus = FALSE;
   event->crossing.state = 0;
-  event->crossing.device = device;
+  gdk_event_set_device (event, device);
 
   if (!widget)
     widget = gtk_get_event_widget (event);
@@ -11192,9 +11192,9 @@ convert_event_to_motion (GdkEvent *event)
       new_event->axes = NULL; /* FIXME: not ideal for non-mice */
       new_event->state = 0; /* FIXME */
       new_event->is_hint = FALSE;
-      new_event->device = event->crossing.device;
       new_event->x_root = event->crossing.x_root;
       new_event->y_root = event->crossing.y_root;
+      gdk_event_set_device ((GdkEvent *) new_event, gdk_event_get_device ((GdkEvent *) event));
       break;
     default:
       g_warning ("Event with type %d can not be transformed to GdkEventMotion", event->type);
diff --git a/gtk/gtkwindow.c b/gtk/gtkwindow.c
index 8eff180..597fff8 100644
--- a/gtk/gtkwindow.c
+++ b/gtk/gtkwindow.c
@@ -5275,7 +5275,7 @@ do_focus_change (GtkWidget *widget,
       if (widget->window)
         g_object_ref (widget->window);
       fevent->focus_change.in = in;
-      fevent->focus_change.device = dev;
+      gdk_event_set_device (fevent, dev);
 
       gtk_widget_event (widget, fevent);
 
diff --git a/tests/multidevice/testangle.c b/tests/multidevice/testangle.c
index eb44b26..76a417a 100644
--- a/tests/multidevice/testangle.c
+++ b/tests/multidevice/testangle.c
@@ -46,7 +46,9 @@ enter_notify_cb (GtkWidget        *widget,
   devices = gtk_device_group_get_devices (data->group);
 
   if (g_list_length (devices) < 2)
-    gtk_device_group_add_device (data->group, event->device);
+    gtk_device_group_add_device (data->group, gdk_event_get_device ((GdkEvent *) event));
+
+  return FALSE;
 }
 
 static gboolean
@@ -58,7 +60,9 @@ leave_notify_cb (GtkWidget        *widget,
 
   data = (Data *) user_data;
 
-  gtk_device_group_remove_device (data->group, event->device);
+  gtk_device_group_remove_device (data->group, gdk_event_get_device ((GdkEvent *) event));
+
+  return FALSE;
 }
 
 static void
diff --git a/tests/multidevice/testcoordinatewidget.c b/tests/multidevice/testcoordinatewidget.c
index 91ba1fa..d3285eb 100644
--- a/tests/multidevice/testcoordinatewidget.c
+++ b/tests/multidevice/testcoordinatewidget.c
@@ -119,18 +119,20 @@ test_coordinate_widget_enter_notify (GtkWidget        *widget,
                                      GdkEventCrossing *event)
 {
   TestCoordinateWidgetPrivate *priv;
+  GdkDevice *device;
   GdkPoint *point;
 
   priv = TEST_COORDINATE_WIDGET_GET_PRIVATE (widget);
+  device = gdk_event_get_device ((GdkEvent *) event);
 
-  gtk_device_group_add_device (priv->group, event->device);
+  gtk_device_group_add_device (priv->group, device);
 
   point = g_new (GdkPoint, 1);
   point->x = event->x;
   point->y = event->y;
 
   g_hash_table_insert (priv->coordinates,
-                       g_object_ref (event->device),
+                       g_object_ref (device),
                        point);
 
   gtk_widget_queue_draw (widget);
@@ -143,11 +145,13 @@ test_coordinate_widget_leave_notify (GtkWidget        *widget,
                                      GdkEventCrossing *event)
 {
   TestCoordinateWidgetPrivate *priv;
+  GdkDevice *device;
 
   priv = TEST_COORDINATE_WIDGET_GET_PRIVATE (widget);
+  device = gdk_event_get_device ((GdkEvent *) event);
 
-  gtk_device_group_add_device (priv->group, event->device);
-  g_hash_table_remove (priv->coordinates, event->device);
+  gtk_device_group_remove_device (priv->group, device);
+  g_hash_table_remove (priv->coordinates, device);
 
   gtk_widget_queue_draw (widget);
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]