[gtk/readonly-events-1: 72/74] events: reorganize getters



commit e6a6ba21ab84b36651b98ded644cb840f9af28e1
Author: Matthias Clasen <mclasen redhat com>
Date:   Sun Feb 16 11:58:33 2020 -0500

    events: reorganize getters
    
    Restructure the getters for event fields to
    be more targeted at particular event types.
    
    Update all callers, and replace all direct
    event struct access with getters.
    
    As a side-effect, this drops some unused getters,
    and unused functionality such as a separate API
    to turn on event debugging.

 demos/gtk-demo/popover.c         |    2 +-
 demos/gtk-demo/themes.c          |    2 +-
 gdk/gdkapplaunchcontext.c        |    2 +-
 gdk/gdkevents.c                  | 2997 +++++++++++++++++---------------------
 gdk/gdkevents.h                  |  181 +--
 gdk/gdkeventsprivate.h           |   50 +-
 gdk/gdkkeys.c                    |   11 +-
 gdk/gdksurface.c                 |   87 +-
 gdk/wayland/gdkdevice-wayland.c  |   92 +-
 gdk/wayland/gdksurface-wayland.c |    2 +-
 gdk/win32/gdkevents-win32.c      |   92 +-
 gdk/win32/gdksurface-win32.c     |    2 +-
 gdk/x11/gdkdevicemanager-xi2.c   |   42 +-
 gdk/x11/gdkdrag-x11.c            |   15 +-
 gdk/x11/gdkeventsource.c         |    4 +-
 gdk/x11/gdksurface-x11.c         |    2 +-
 gtk/a11y/gtkaccessibilityutil.c  |    6 +-
 gtk/gtkbindings.c                |   13 +-
 gtk/gtkbutton.c                  |    2 +-
 gtk/gtkcellarea.c                |   10 +-
 gtk/gtkdragdest.c                |    4 +-
 gtk/gtkdragsource.c              |    2 +-
 gtk/gtkeventcontrollerkey.c      |   14 +-
 gtk/gtkeventcontrollerscroll.c   |   11 +-
 gtk/gtkgesture.c                 |   41 +-
 gtk/gtkgestureclick.c            |    6 +-
 gtk/gtkgesturedrag.c             |    2 +-
 gtk/gtkgesturerotate.c           |    9 +-
 gtk/gtkgesturesingle.c           |    9 +-
 gtk/gtkgesturestylus.c           |    2 +-
 gtk/gtkgestureswipe.c            |    2 +-
 gtk/gtkgesturezoom.c             |    6 +-
 gtk/gtkiconview.c                |    6 +-
 gtk/gtkimcontextsimple.c         |   35 +-
 gtk/gtkimmulticontext.c          |    7 +-
 gtk/gtklabel.c                   |    2 +-
 gtk/gtkmain.c                    |  175 ++-
 gtk/gtkmountoperation.c          |    4 +-
 gtk/gtkpadcontroller.c           |    6 +-
 gtk/gtkrange.c                   |    2 +-
 gtk/gtkscrolledwindow.c          |    2 +-
 gtk/gtktext.c                    |    2 +-
 gtk/gtktextview.c                |   10 +-
 gtk/gtktooltip.c                 |    4 +-
 gtk/gtktreeview.c                |    2 +-
 gtk/gtkwidget.c                  |  142 +-
 gtk/gtkwindow.c                  |   36 +-
 gtk/gtkwindow.h                  |    4 +-
 gtk/inspector/inspect-button.c   |    2 +-
 tests/testwindowdrag.c           |   10 +-
 50 files changed, 1883 insertions(+), 2290 deletions(-)
---
diff --git a/demos/gtk-demo/popover.c b/demos/gtk-demo/popover.c
index 03652f6d39..860df60416 100644
--- a/demos/gtk-demo/popover.c
+++ b/demos/gtk-demo/popover.c
@@ -105,7 +105,7 @@ day_selected_cb (GtkCalendar *calendar,
   if (gdk_event_get_event_type (event) != GDK_BUTTON_PRESS)
     return;
 
-  gdk_event_get_coords (event, &x, &y);
+  gdk_event_get_position (event, &x, &y);
   gtk_widget_translate_coordinates (gtk_get_event_widget (event),
                                     GTK_WIDGET (calendar),
                                     x, y,
diff --git a/demos/gtk-demo/themes.c b/demos/gtk-demo/themes.c
index 1ad98b14e7..0627ebe076 100644
--- a/demos/gtk-demo/themes.c
+++ b/demos/gtk-demo/themes.c
@@ -141,7 +141,7 @@ clicked (GtkGestureClick *gesture,
   window = gtk_widget_get_ancestor (gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture)), 
GTK_TYPE_WINDOW);
 
   event = gtk_gesture_get_last_event (GTK_GESTURE (gesture), NULL);
-  gdk_event_get_state (event, &state);
+  state = gdk_event_get_modifier_state (event);
 
   if (state & GDK_CONTROL_MASK)
     {
diff --git a/gdk/gdkapplaunchcontext.c b/gdk/gdkapplaunchcontext.c
index c82bcf0034..97c72aad4f 100644
--- a/gdk/gdkapplaunchcontext.c
+++ b/gdk/gdkapplaunchcontext.c
@@ -43,7 +43,7 @@
  * context = gdk_display_get_app_launch_context (display);
  *
  * gdk_app_launch_context_set_display (display);
- * gdk_app_launch_context_set_timestamp (event->time);
+ * gdk_app_launch_context_set_timestamp (gdk_event_get_time (event));
  *
  * if (!g_app_info_launch_default_for_uri ("http://www.gtk.org";, context, &error))
  *   g_warning ("Launching failed: %s\n", error->message);
diff --git a/gdk/gdkevents.c b/gdk/gdkevents.c
index 7864f7ac3c..83d29b76fc 100644
--- a/gdk/gdkevents.c
+++ b/gdk/gdkevents.c
@@ -264,8 +264,8 @@ _gdk_event_unqueue (GdkDisplay *display)
 }
 
 static void
-gdk_event_push_history (GdkEvent       *event,
-                        GdkEvent       *history_event)
+gdk_event_push_history (GdkEvent *event,
+                        GdkEvent *history_event)
 {
   GdkTimeCoord *hist;
   GdkDevice *device;
@@ -460,2036 +460,1647 @@ gdk_event_free (GdkEvent *event)
 }
 
 /**
- * gdk_event_get_surface:
+ * gdk_event_get_axis:
  * @event: a #GdkEvent
+ * @axis_use: the axis use to look for
+ * @value: (out): location to store the value found
  *
- * Extracts the #GdkSurface associated with an event.
+ * Extract the axis value for a particular axis use from
+ * an event structure.
  *
- * Returns: (transfer none): The #GdkSurface associated with the event
- */
-GdkSurface *
-gdk_event_get_surface (GdkEvent       *event)
+ * Returns: %TRUE if the specified axis was found, otherwise %FALSE
+ **/
+gboolean
+gdk_event_get_axis (GdkEvent   *event,
+                   GdkAxisUse  axis_use,
+                   double     *value)
 {
-  g_return_val_if_fail (event != NULL, NULL);
+  double *axes;
 
-  return event->any.surface;
-}
+  if (axis_use == GDK_AXIS_X || axis_use == GDK_AXIS_Y)
+    {
+      gdouble x, y;
 
-/**
- * gdk_event_get_time:
- * @event: a #GdkEvent
- * 
- * Returns the time stamp from @event, if there is one; otherwise
- * returns #GDK_CURRENT_TIME. If @event is %NULL, returns #GDK_CURRENT_TIME.
- * 
- * Returns: time stamp field from @event
- **/
-guint32
-gdk_event_get_time (GdkEvent       *event)
-{
-  if (event)
-    switch (event->any.type)
-      {
-      case GDK_MOTION_NOTIFY:
-       return event->motion.time;
-      case GDK_BUTTON_PRESS:
-      case GDK_BUTTON_RELEASE:
-       return event->button.time;
-      case GDK_TOUCH_BEGIN:
-      case GDK_TOUCH_UPDATE:
-      case GDK_TOUCH_END:
-      case GDK_TOUCH_CANCEL:
-        return event->touch.time;
-      case GDK_TOUCHPAD_SWIPE:
-        return event->touchpad_swipe.time;
-      case GDK_TOUCHPAD_PINCH:
-        return event->touchpad_pinch.time;
-      case GDK_SCROLL:
-        return event->scroll.time;
-      case GDK_KEY_PRESS:
-      case GDK_KEY_RELEASE:
-       return event->key.time;
-      case GDK_ENTER_NOTIFY:
-      case GDK_LEAVE_NOTIFY:
-       return event->crossing.time;
-      case GDK_PROXIMITY_IN:
-      case GDK_PROXIMITY_OUT:
-       return event->proximity.time;
-      case GDK_DRAG_ENTER:
-      case GDK_DRAG_LEAVE:
-      case GDK_DRAG_MOTION:
-      case GDK_DROP_START:
-       return event->dnd.time;
-      case GDK_PAD_BUTTON_PRESS:
-      case GDK_PAD_BUTTON_RELEASE:
-        return event->pad_button.time;
-      case GDK_PAD_RING:
-      case GDK_PAD_STRIP:
-        return event->pad_axis.time;
-      case GDK_PAD_GROUP_MODE:
-        return event->pad_group_mode.time;
-      case GDK_CONFIGURE:
-      case GDK_FOCUS_CHANGE:
-      case GDK_DELETE:
-      case GDK_GRAB_BROKEN:
-      case GDK_EVENT_LAST:
-      default:
-        /* return current time */
-        break;
-      }
-  
-  return GDK_CURRENT_TIME;
+      switch ((guint) event->any.type)
+       {
+        case GDK_MOTION_NOTIFY:
+         x = event->motion.x;
+         y = event->motion.y;
+         break;
+       case GDK_BUTTON_PRESS:
+       case GDK_BUTTON_RELEASE:
+         x = event->button.x;
+         y = event->button.y;
+         break;
+        case GDK_TOUCH_BEGIN:
+        case GDK_TOUCH_UPDATE:
+        case GDK_TOUCH_END:
+        case GDK_TOUCH_CANCEL:
+         x = event->touch.x;
+         y = event->touch.y;
+         break;
+       case GDK_ENTER_NOTIFY:
+       case GDK_LEAVE_NOTIFY:
+         x = event->crossing.x;
+         y = event->crossing.y;
+         break;
+       default:
+         return FALSE;
+       }
+
+      if (axis_use == GDK_AXIS_X && value)
+       *value = x;
+      if (axis_use == GDK_AXIS_Y && value)
+       *value = y;
+
+      return TRUE;
+    }
+  else if (event->any.type == GDK_BUTTON_PRESS ||
+          event->any.type == GDK_BUTTON_RELEASE)
+    {
+      axes = event->button.axes;
+    }
+  else if (event->any.type == GDK_TOUCH_BEGIN ||
+           event->any.type == GDK_TOUCH_UPDATE ||
+           event->any.type == GDK_TOUCH_END ||
+           event->any.type == GDK_TOUCH_CANCEL)
+    {
+      axes = event->touch.axes;
+    }
+  else if (event->any.type == GDK_MOTION_NOTIFY)
+    {
+      axes = event->motion.axes;
+    }
+  else
+    return FALSE;
+
+  return gdk_device_get_axis (event->any.device, axes, axis_use, value);
 }
 
 /**
- * gdk_event_get_state:
- * @event: (allow-none): a #GdkEvent or %NULL
- * @state: (out): return location for state
+ * gdk_event_triggers_context_menu:
+ * @event: a #GdkEvent, currently only button events are meaningful values
  *
- * If the event contains a “state” field, puts that field in @state.
+ * This function returns whether a #GdkEventButton should trigger a
+ * context menu, according to platform conventions. The right mouse
+ * button always triggers context menus. Additionally, if
+ * gdk_keymap_get_modifier_mask() returns a non-0 mask for
+ * %GDK_MODIFIER_INTENT_CONTEXT_MENU, then the left mouse button will
+ * also trigger a context menu if this modifier is pressed.
  *
- * Otherwise stores an empty state (0).
- * @event may be %NULL, in which case it’s treated
- * as if the event had no state field.
+ * This function should always be used instead of simply checking for
+ * event->button == %GDK_BUTTON_SECONDARY.
  *
- * Returns: %TRUE if there was a state field in the event
+ * Returns: %TRUE if the event should trigger a context menu.
  **/
 gboolean
-gdk_event_get_state (GdkEvent        *event,
-                     GdkModifierType *state)
+gdk_event_triggers_context_menu (GdkEvent *event)
 {
-  g_return_val_if_fail (state != NULL, FALSE);
-  
-  if (event)
-    switch (event->any.type)
-      {
-      case GDK_MOTION_NOTIFY:
-       *state = event->motion.state;
-        return TRUE;
-      case GDK_BUTTON_PRESS:
-      case GDK_BUTTON_RELEASE:
-        *state = event->button.state;
-        return TRUE;
-      case GDK_TOUCH_BEGIN:
-      case GDK_TOUCH_UPDATE:
-      case GDK_TOUCH_END:
-      case GDK_TOUCH_CANCEL:
-        *state = event->touch.state;
-        return TRUE;
-      case GDK_TOUCHPAD_SWIPE:
-        *state = event->touchpad_swipe.state;
-        return TRUE;
-      case GDK_TOUCHPAD_PINCH:
-        *state = event->touchpad_pinch.state;
-        return TRUE;
-      case GDK_SCROLL:
-       *state =  event->scroll.state;
-        return TRUE;
-      case GDK_KEY_PRESS:
-      case GDK_KEY_RELEASE:
-       *state =  event->key.state;
+  g_return_val_if_fail (event != NULL, FALSE);
+
+  if (event->any.type == GDK_BUTTON_PRESS)
+    {
+      GdkEventButton *bevent = (GdkEventButton *) event;
+      GdkDisplay *display;
+      GdkModifierType modifier;
+
+      g_return_val_if_fail (GDK_IS_SURFACE (bevent->any.surface), FALSE);
+
+      if (bevent->button == GDK_BUTTON_SECONDARY &&
+          ! (bevent->state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK)))
         return TRUE;
-      case GDK_ENTER_NOTIFY:
-      case GDK_LEAVE_NOTIFY:
-       *state =  event->crossing.state;
+
+      display = gdk_surface_get_display (bevent->any.surface);
+
+      modifier = gdk_keymap_get_modifier_mask (gdk_display_get_keymap (display),
+                                               GDK_MODIFIER_INTENT_CONTEXT_MENU);
+
+      if (modifier != 0 &&
+          bevent->button == GDK_BUTTON_PRIMARY &&
+          ! (bevent->state & (GDK_BUTTON2_MASK | GDK_BUTTON3_MASK)) &&
+          (bevent->state & modifier))
         return TRUE;
-      case GDK_CONFIGURE:
-      case GDK_FOCUS_CHANGE:
-      case GDK_PROXIMITY_IN:
-      case GDK_PROXIMITY_OUT:
-      case GDK_DRAG_ENTER:
-      case GDK_DRAG_LEAVE:
-      case GDK_DRAG_MOTION:
-      case GDK_DROP_START:
-      case GDK_DELETE:
-      case GDK_GRAB_BROKEN:
-      case GDK_PAD_BUTTON_PRESS:
-      case GDK_PAD_BUTTON_RELEASE:
-      case GDK_PAD_RING:
-      case GDK_PAD_STRIP:
-      case GDK_PAD_GROUP_MODE:
-      case GDK_EVENT_LAST:
-      default:
-        /* no state field */
-        break;
-      }
+    }
 
-  *state = 0;
   return FALSE;
 }
 
-/**
- * gdk_event_get_coords:
- * @event: a #GdkEvent
- * @x_win: (out) (optional): location to put event surface x coordinate
- * @y_win: (out) (optional): location to put event surface y coordinate
- *
- * Extract the event surface relative x/y coordinates from an event.
- *
- * Returns: %TRUE if the event delivered event surface coordinates
- **/
-gboolean
-gdk_event_get_coords (GdkEvent       *event,
-                     gdouble        *x_win,
-                     gdouble        *y_win)
+static gboolean
+gdk_events_get_axis_distances (GdkEvent *event1,
+                               GdkEvent *event2,
+                               gdouble  *x_distance,
+                               gdouble  *y_distance,
+                               gdouble  *distance)
 {
-  gdouble x = 0, y = 0;
-  gboolean fetched = TRUE;
+  gdouble x1, x2, y1, y2;
+  gdouble xd, yd;
 
-  g_return_val_if_fail (event != NULL, FALSE);
+  if (!gdk_event_get_position (event1, &x1, &y1) ||
+      !gdk_event_get_position (event2, &x2, &y2))
+    return FALSE;
 
-  switch ((guint) event->any.type)
-    {
-    case GDK_CONFIGURE:
-      x = event->configure.x;
-      y = event->configure.y;
-      break;
-    case GDK_ENTER_NOTIFY:
-    case GDK_LEAVE_NOTIFY:
-      x = event->crossing.x;
-      y = event->crossing.y;
-      break;
-    case GDK_SCROLL:
-      x = event->scroll.x;
-      y = event->scroll.y;
-      break;
-    case GDK_BUTTON_PRESS:
-    case GDK_BUTTON_RELEASE:
-      x = event->button.x;
-      y = event->button.y;
-      break;
-    case GDK_TOUCH_BEGIN:
-    case GDK_TOUCH_UPDATE:
-    case GDK_TOUCH_END:
-    case GDK_TOUCH_CANCEL:
-      x = event->touch.x;
-      y = event->touch.y;
-      break;
-    case GDK_MOTION_NOTIFY:
-      x = event->motion.x;
-      y = event->motion.y;
-      break;
-    case GDK_TOUCHPAD_SWIPE:
-      x = event->touchpad_swipe.x;
-      y = event->touchpad_swipe.y;
-      break;
-    case GDK_TOUCHPAD_PINCH:
-      x = event->touchpad_pinch.x;
-      y = event->touchpad_pinch.y;
-      break;
-    case GDK_DRAG_ENTER:
-    case GDK_DRAG_LEAVE:
-    case GDK_DRAG_MOTION:
-    case GDK_DROP_START:
-      x = event->dnd.x;
-      y = event->dnd.y;
-      break;
-    default:
-      fetched = FALSE;
-      break;
-    }
+  xd = x2 - x1;
+  yd = y2 - y1;
 
-  if (x_win)
-    *x_win = x;
-  if (y_win)
-    *y_win = y;
+  if (x_distance)
+    *x_distance = xd;
+
+  if (y_distance)
+    *y_distance = yd;
+
+  if (distance)
+    *distance = sqrt ((xd * xd) + (yd * yd));
 
-  return fetched;
+  return TRUE;
 }
 
 /**
- * gdk_event_get_button:
- * @event: a #GdkEvent
- * @button: (out): location to store mouse button number
+ * gdk_events_get_distance:
+ * @event1: first #GdkEvent
+ * @event2: second #GdkEvent
+ * @distance: (out): return location for the distance
  *
- * Extract the button number from an event.
+ * If both events have X/Y information, the distance between both coordinates
+ * (as in a straight line going from @event1 to @event2) will be returned.
  *
- * Returns: %TRUE if the event delivered a button number
+ * Returns: %TRUE if the distance could be calculated.
  **/
 gboolean
-gdk_event_get_button (GdkEvent       *event,
-                      guint *button)
+gdk_events_get_distance (GdkEvent *event1,
+                         GdkEvent *event2,
+                         gdouble  *distance)
 {
-  gboolean fetched = TRUE;
-  guint number = 0;
-
-  g_return_val_if_fail (event != NULL, FALSE);
-  
-  switch ((guint) event->any.type)
-    {
-    case GDK_BUTTON_PRESS:
-    case GDK_BUTTON_RELEASE:
-      number = event->button.button;
-      break;
-    case GDK_PAD_BUTTON_PRESS:
-    case GDK_PAD_BUTTON_RELEASE:
-      number = event->pad_button.button;
-      break;
-    default:
-      fetched = FALSE;
-      break;
-    }
-
-  if (button)
-    *button = number;
-
-  return fetched;
+  return gdk_events_get_axis_distances (event1, event2,
+                                        NULL, NULL,
+                                        distance);
 }
 
 /**
- * gdk_event_get_click_count:
- * @event: a #GdkEvent
- * @click_count: (out): location to store click count
+ * gdk_events_get_angle:
+ * @event1: first #GdkEvent
+ * @event2: second #GdkEvent
+ * @angle: (out): return location for the relative angle between both events
  *
- * Extracts the click count from an event.
+ * If both events contain X/Y information, this function will return %TRUE
+ * and return in @angle the relative angle from @event1 to @event2. The rotation
+ * direction for positive angles is from the positive X axis towards the positive
+ * Y axis.
  *
- * Returns: %TRUE if the event delivered a click count
- */
+ * Returns: %TRUE if the angle could be calculated.
+ **/
 gboolean
-gdk_event_get_click_count (GdkEvent       *event,
-                           guint *click_count)
+gdk_events_get_angle (GdkEvent *event1,
+                      GdkEvent *event2,
+                      gdouble  *angle)
 {
-  gboolean fetched = TRUE;
-  guint number = 0;
+  gdouble x_distance, y_distance, distance;
 
-  g_return_val_if_fail (event != NULL, FALSE);
+  if (!gdk_events_get_axis_distances (event1, event2,
+                                      &x_distance, &y_distance,
+                                      &distance))
+    return FALSE;
 
-  switch ((guint) event->any.type)
+  if (angle)
     {
-    case GDK_BUTTON_PRESS:
-    case GDK_BUTTON_RELEASE:
-      number = 1;
-      break;
-    default:
-      fetched = FALSE;
-      break;
-    }
+      *angle = atan2 (x_distance, y_distance);
+
+      /* Invert angle */
+      *angle = (2 * G_PI) - *angle;
 
-  if (click_count)
-    *click_count = number;
+      /* Shift it 90° */
+      *angle += G_PI / 2;
+
+      /* And constraint it to 0°-360° */
+      *angle = fmod (*angle, 2 * G_PI);
+    }
 
-  return fetched;
+  return TRUE;
 }
 
 /**
- * gdk_event_get_keyval:
- * @event: a #GdkEvent
- * @keyval: (out): location to store the keyval
+ * gdk_events_get_center:
+ * @event1: first #GdkEvent
+ * @event2: second #GdkEvent
+ * @x: (out): return location for the X coordinate of the center
+ * @y: (out): return location for the Y coordinate of the center
  *
- * Extracts the keyval from an event.
+ * If both events contain X/Y information, the center of both coordinates
+ * will be returned in @x and @y.
  *
- * Returns: %TRUE if the event delivered a key symbol
- */
+ * Returns: %TRUE if the center could be calculated.
+ **/
 gboolean
-gdk_event_get_keyval (GdkEvent       *event,
-                      guint *keyval)
+gdk_events_get_center (GdkEvent *event1,
+                       GdkEvent *event2,
+                       gdouble  *x,
+                       gdouble  *y)
 {
-  gboolean fetched = TRUE;
-  guint number = 0;
-
-  switch ((guint) event->any.type)
-    {
-    case GDK_KEY_PRESS:
-    case GDK_KEY_RELEASE:
-      number = event->key.keyval;
-      break;
-    default:
-      fetched = FALSE;
-      break;
-    }
-
-  if (keyval)
-    *keyval = number;
-
-  return fetched;
-}
+  gdouble x1, x2, y1, y2;
 
-/**
- * gdk_event_get_keycode:
- * @event: a #GdkEvent
- * @keycode: (out): location to store the keycode
- *
- * Extracts the hardware keycode from an event.
- *
- * Also see gdk_event_get_scancode().
- *
- * Returns: %TRUE if the event delivered a hardware keycode
- */
-gboolean
-gdk_event_get_keycode (GdkEvent       *event,
-                       guint16 *keycode)
-{
-  gboolean fetched = TRUE;
-  guint16 number = 0;
+  if (!gdk_event_get_position (event1, &x1, &y1) ||
+      !gdk_event_get_position (event2, &x2, &y2))
+    return FALSE;
 
-  switch ((guint) event->any.type)
-    {
-    case GDK_KEY_PRESS:
-    case GDK_KEY_RELEASE:
-      number = event->key.hardware_keycode;
-      break;
-    default:
-      fetched = FALSE;
-      break;
-    }
+  if (x)
+    *x = (x2 + x1) / 2;
 
-  if (keycode)
-    *keycode = number;
+  if (y)
+    *y = (y2 + y1) / 2;
 
-  return fetched;
+  return TRUE;
 }
 
-/**
- * gdk_event_get_key_group:
- * @event: a #GdkEvent
- * @group: (out): return location for the key group
- *
- * Extracts the key group from an event.
- *
- * Returns: %TRUE on success, otherwise %FALSE
- **/
-gboolean
-gdk_event_get_key_group (GdkEvent       *event,
-                         guint          *group)
+static GdkEventSequence *
+gdk_event_sequence_copy (GdkEventSequence *sequence)
 {
-  gboolean fetched = TRUE;
-
-  switch ((guint) event->any.type)
-    {
-    case GDK_KEY_PRESS:
-    case GDK_KEY_RELEASE:
-      *group = event->key.group;
-      break;
-    default:
-      *group = 0;
-      fetched = FALSE;
-      break;
-    }
-
-  return fetched;
+  return sequence;
 }
 
-/**
- * gdk_event_get_key_is_modifier:
- * @event: a #GdkEvent
- * @is_modifier: (out): return location for the value
- *
- * Extracts whether the event is a key event for
- * a modifier key.
- *
- * Returns: %TRUE on success, otherwise %FALSE
- **/
-gboolean
-gdk_event_get_key_is_modifier (GdkEvent       *event,
-                               gboolean       *is_modifier)
+static void
+gdk_event_sequence_free (GdkEventSequence *sequence)
 {
-  gboolean fetched = TRUE;
-
-  switch ((guint) event->any.type)
-    {
-    case GDK_KEY_PRESS:
-    case GDK_KEY_RELEASE:
-      *is_modifier = event->key.is_modifier;
-      break;
-    default:
-      *is_modifier = FALSE;
-      fetched = FALSE;
-      break;
-    }
-
-  return fetched;
+  /* Nothing to free here */
 }
 
-/**
- * gdk_event_get_scroll_direction:
- * @event: a #GdkEvent
- * @direction: (out): location to store the scroll direction
- *
- * Extracts the scroll direction from an event.
- *
- * Returns: %TRUE if the event delivered a scroll direction
- */
-gboolean
-gdk_event_get_scroll_direction (GdkEvent       *event,
-                                GdkScrollDirection *direction)
-{
-  gboolean fetched = TRUE;
-  GdkScrollDirection dir = 0;
-
-  switch ((guint) event->any.type)
-    {
-    case GDK_SCROLL:
-      if (event->scroll.direction == GDK_SCROLL_SMOOTH)
-        fetched = FALSE;
-      else
-        dir = event->scroll.direction;
-      break;
-    default:
-      fetched = FALSE;
-      break;
-    }
+G_DEFINE_BOXED_TYPE (GdkEventSequence, gdk_event_sequence,
+                     gdk_event_sequence_copy,
+                     gdk_event_sequence_free)
 
-  if (direction)
-    *direction = dir;
 
-  return fetched;
-}
 
 /**
- * gdk_event_get_scroll_deltas:
+ * gdk_event_get_axes:
  * @event: a #GdkEvent
- * @delta_x: (out): return location for X delta
- * @delta_y: (out): return location for Y delta
+ * @axes: (transfer none) (out) (array length=n_axes): the array of values for all axes
+ * @n_axes: (out): the length of array
  *
- * Retrieves the scroll deltas from a #GdkEvent
+ * Extracts all axis values from an event.
  *
- * Returns: %TRUE if the event contains smooth scroll information
+ * Returns: %TRUE on success, otherwise %FALSE
  **/
 gboolean
-gdk_event_get_scroll_deltas (GdkEvent       *event,
-                             gdouble        *delta_x,
-                             gdouble        *delta_y)
+gdk_event_get_axes (GdkEvent  *event,
+                    double   **axes,
+                    guint     *n_axes)
 {
-  gboolean fetched = TRUE;
-  gdouble dx = 0.0;
-  gdouble dy = 0.0;
-
-  switch ((guint) event->any.type)
-    {
-    case GDK_SCROLL:
-      if (event->scroll.direction == GDK_SCROLL_SMOOTH)
-        {
-          dx = event->scroll.delta_x;
-          dy = event->scroll.delta_y;
-        }
-      else
-        fetched = FALSE;
-      break;
-    default:
-      fetched = FALSE;
-      break;
-    }
-
-  if (delta_x)
-    *delta_x = dx;
-
-  if (delta_y)
-    *delta_y = dy;
-
-  return fetched;
-}
+  GdkDevice *source_device;
 
-/**
- * gdk_event_is_scroll_stop_event
- * @event: a #GdkEvent
- *
- * Check whether a scroll event is a stop scroll event. Scroll sequences
- * with smooth scroll information may provide a stop scroll event once the
- * interaction with the device finishes, e.g. by lifting a finger. This
- * stop scroll event is the signal that a widget may trigger kinetic
- * scrolling based on the current velocity.
- *
- * Stop scroll events always have a delta of 0/0.
- *
- * Returns: %TRUE if the event is a scroll stop event
- */
-gboolean
-gdk_event_is_scroll_stop_event (GdkEvent       *event)
-{
-  return event->scroll.is_stop;
-}
+  if (!event)
+    return FALSE;
 
-/**
- * gdk_event_get_axis:
- * @event: a #GdkEvent
- * @axis_use: the axis use to look for
- * @value: (out): location to store the value found
- *
- * Extract the axis value for a particular axis use from
- * an event structure.
- *
- * Returns: %TRUE if the specified axis was found, otherwise %FALSE
- **/
-gboolean
-gdk_event_get_axis (GdkEvent       *event,
-                   GdkAxisUse      axis_use,
-                   gdouble        *value)
-{
-  gdouble *axes;
+  source_device = gdk_event_get_source_device (event);
 
-  g_return_val_if_fail (event != NULL, FALSE);
+  if (!source_device)
+    return FALSE;
 
-  if (axis_use == GDK_AXIS_X || axis_use == GDK_AXIS_Y)
+  if (event->any.type == GDK_MOTION_NOTIFY)
     {
-      gdouble x, y;
-
-      switch ((guint) event->any.type)
-       {
-        case GDK_MOTION_NOTIFY:
-         x = event->motion.x;
-         y = event->motion.y;
-         break;
-       case GDK_SCROLL:
-         x = event->scroll.x;
-         y = event->scroll.y;
-         break;
-       case GDK_BUTTON_PRESS:
-       case GDK_BUTTON_RELEASE:
-         x = event->button.x;
-         y = event->button.y;
-         break;
-        case GDK_TOUCH_BEGIN:
-        case GDK_TOUCH_UPDATE:
-        case GDK_TOUCH_END:
-        case GDK_TOUCH_CANCEL:
-         x = event->touch.x;
-         y = event->touch.y;
-         break;
-       case GDK_ENTER_NOTIFY:
-       case GDK_LEAVE_NOTIFY:
-         x = event->crossing.x;
-         y = event->crossing.y;
-         break;
-       default:
-         return FALSE;
-       }
-
-      if (axis_use == GDK_AXIS_X && value)
-       *value = x;
-      if (axis_use == GDK_AXIS_Y && value)
-       *value = y;
-
+      *axes = event->motion.axes;
+      *n_axes = gdk_device_get_n_axes (source_device);
       return TRUE;
     }
   else if (event->any.type == GDK_BUTTON_PRESS ||
-          event->any.type == GDK_BUTTON_RELEASE)
+           event->any.type == GDK_BUTTON_RELEASE)
     {
-      axes = event->button.axes;
+      *axes = event->button.axes;
+      *n_axes = gdk_device_get_n_axes (source_device);
+      return TRUE;
     }
   else if (event->any.type == GDK_TOUCH_BEGIN ||
            event->any.type == GDK_TOUCH_UPDATE ||
            event->any.type == GDK_TOUCH_END ||
            event->any.type == GDK_TOUCH_CANCEL)
     {
-      axes = event->touch.axes;
-    }
-  else if (event->any.type == GDK_MOTION_NOTIFY)
-    {
-      axes = event->motion.axes;
+      *axes = event->touch.axes;
+      *n_axes = gdk_device_get_n_axes (source_device);
+      return TRUE;
     }
-  else
-    return FALSE;
 
-  return gdk_device_get_axis (event->any.device, axes, axis_use, value);
+  return FALSE;
 }
 
 /**
- * gdk_event_get_device:
- * @event: a #GdkEvent.
+ * gdk_event_get_motion_history:
+ * @event: a #GdkEvent of type %GDK_MOTION_NOTIFY
  *
- * If the event contains a “device” field, this function will return
- * it, else it will return %NULL.
+ * Retrieves the history of the @event motion, as a list of time and
+ * coordinates.
  *
- * Returns: (nullable) (transfer none): a #GdkDevice, or %NULL.
- **/
-GdkDevice *
-gdk_event_get_device (GdkEvent       *event)
+ * Returns: (transfer container) (element-type GdkTimeCoord) (nullable): a list
+ *   of time and coordinates
+ */
+GList *
+gdk_event_get_motion_history (GdkEvent       *event)
 {
-  g_return_val_if_fail (event != NULL, NULL);
-
-  return event->any.device;
+  if (event->any.type != GDK_MOTION_NOTIFY)
+    return NULL;
+  return g_list_reverse (g_list_copy (event->motion.history));
 }
 
-/**
- * gdk_event_get_source_device:
- * @event: a #GdkEvent
- *
- * This function returns the hardware (slave) #GdkDevice that has
- * triggered the event, falling back to the virtual (master) device
- * (as in gdk_event_get_device()) if the event wasn’t caused by
- * interaction with a hardware device. This may happen for example
- * in synthesized crossing events after a #GdkSurface updates its
- * geometry or a grab is acquired/released.
- *
- * If the event does not contain a device field, this function will
- * return %NULL.
- *
- * Returns: (nullable) (transfer none): a #GdkDevice, or %NULL.
- **/
-GdkDevice *
-gdk_event_get_source_device (GdkEvent       *event)
+GdkEvent *
+gdk_event_button_new (GdkEventType     type,
+                      GdkSurface      *surface,
+                      GdkDevice       *device,
+                      GdkDevice       *source_device,
+                      GdkDeviceTool   *tool,
+                      guint32          time,
+                      GdkModifierType  state,
+                      guint            button,
+                      double           x,
+                      double           y,
+                      double          *axes)
 {
-  g_return_val_if_fail (event != NULL, NULL);
+  GdkEventButton *event;
 
-  if (event->any.source_device)
-    return event->any.source_device;
+  g_return_val_if_fail (type == GDK_BUTTON_PRESS || 
+                        type == GDK_BUTTON_RELEASE, NULL);
+
+  event = g_new0 (GdkEventButton, 1);
+  event->any.ref_count = 1;
+  event->any.type = type;
+  event->any.surface = g_object_ref (surface);
+  event->any.device = g_object_ref (device);
+  event->any.source_device = g_object_ref (source_device);
+  event->tool = tool ? g_object_ref (tool) : NULL;
+  event->time = time;
+  event->axes = NULL;
+  event->state = state;
+  event->button = button;
+  event->x = x;
+  event->y = y;
+  event->axes = axes;
 
-  /* Fallback to event device */
-  return gdk_event_get_device (event);
+  return (GdkEvent *)event;
 }
 
-/**
- * gdk_event_triggers_context_menu:
- * @event: a #GdkEvent, currently only button events are meaningful values
- *
- * This function returns whether a #GdkEventButton should trigger a
- * context menu, according to platform conventions. The right mouse
- * button always triggers context menus. Additionally, if
- * gdk_keymap_get_modifier_mask() returns a non-0 mask for
- * %GDK_MODIFIER_INTENT_CONTEXT_MENU, then the left mouse button will
- * also trigger a context menu if this modifier is pressed.
- *
- * This function should always be used instead of simply checking for
- * event->button == %GDK_BUTTON_SECONDARY.
- *
- * Returns: %TRUE if the event should trigger a context menu.
- **/
-gboolean
-gdk_event_triggers_context_menu (GdkEvent       *event)
+GdkEvent *
+gdk_event_motion_new (GdkSurface      *surface,
+                      GdkDevice       *device,
+                      GdkDevice       *source_device,
+                      GdkDeviceTool   *tool,
+                      guint32          time,
+                      GdkModifierType  state,
+                      double           x,
+                      double           y,
+                      double          *axes)
 {
-  g_return_val_if_fail (event != NULL, FALSE);
+  GdkEventMotion *event = g_new0 (GdkEventMotion, 1);
 
-  if (event->any.type == GDK_BUTTON_PRESS)
-    {
-      GdkEventButton *bevent = (GdkEventButton *) event;
-      GdkDisplay *display;
-      GdkModifierType modifier;
+  event->any.ref_count = 1;
+  event->any.type = GDK_MOTION_NOTIFY;
+  event->any.surface = g_object_ref (surface);
+  event->any.device = g_object_ref (device);
+  event->any.source_device = g_object_ref (source_device);
+  event->tool = tool ? g_object_ref (tool) : NULL;
+  event->time = time;
+  event->state = state;
+  event->x = x;
+  event->y = y;
+  event->axes = axes;
+  event->state = state;
 
-      g_return_val_if_fail (GDK_IS_SURFACE (bevent->any.surface), FALSE);
+  return (GdkEvent *)event;
+}
 
-      if (bevent->button == GDK_BUTTON_SECONDARY &&
-          ! (bevent->state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK)))
-        return TRUE;
+GdkEvent *
+gdk_event_crossing_new (GdkEventType     type,
+                        GdkSurface      *surface,
+                        GdkDevice       *device,
+                        GdkDevice       *source_device,
+                        guint32          time,
+                        GdkModifierType  state,
+                        double           x,
+                        double           y,
+                        GdkCrossingMode  mode,
+                        GdkNotifyType    detail)
+{
+  GdkEventCrossing *event;
 
-      display = gdk_surface_get_display (bevent->any.surface);
+  g_return_val_if_fail (type == GDK_ENTER_NOTIFY ||
+                        type == GDK_LEAVE_NOTIFY, NULL);
 
-      modifier = gdk_keymap_get_modifier_mask (gdk_display_get_keymap (display),
-                                               GDK_MODIFIER_INTENT_CONTEXT_MENU);
+  event = g_new0 (GdkEventCrossing, 1);
 
-      if (modifier != 0 &&
-          bevent->button == GDK_BUTTON_PRIMARY &&
-          ! (bevent->state & (GDK_BUTTON2_MASK | GDK_BUTTON3_MASK)) &&
-          (bevent->state & modifier))
-        return TRUE;
-    }
+  event->any.ref_count = 1;
+  event->any.type = type;
+  event->any.surface = g_object_ref (surface);
+  event->any.device = g_object_ref (device);
+  event->any.source_device = g_object_ref (source_device);
+  event->time = time;
+  event->state = state;
+  event->x = x;
+  event->y = y;
+  event->mode = mode;
+  event->detail = detail;
 
-  return FALSE;
+  return (GdkEvent *)event;
 }
 
-static gboolean
-gdk_events_get_axis_distances (GdkEvent *event1,
-                               GdkEvent *event2,
-                               gdouble  *x_distance,
-                               gdouble  *y_distance,
-                               gdouble  *distance)
+GdkEvent *
+gdk_event_proximity_new (GdkEventType   type,
+                         GdkSurface    *surface,
+                         GdkDevice     *device,
+                         GdkDevice     *source_device,
+                         GdkDeviceTool *tool,
+                         guint32        time)
 {
-  gdouble x1, x2, y1, y2;
-  gdouble xd, yd;
+  GdkEventProximity *event;
 
-  if (!gdk_event_get_coords (event1, &x1, &y1) ||
-      !gdk_event_get_coords (event2, &x2, &y2))
-    return FALSE;
+  g_return_val_if_fail (type == GDK_PROXIMITY_IN ||
+                        type == GDK_PROXIMITY_OUT, NULL);
 
-  xd = x2 - x1;
-  yd = y2 - y1;
+  event = g_new0 (GdkEventProximity, 1);
 
-  if (x_distance)
-    *x_distance = xd;
+  event->any.ref_count = 1;
+  event->any.type = type;
+  event->any.surface = g_object_ref (surface);
+  event->any.device = g_object_ref (device);
+  event->any.source_device = g_object_ref (source_device);
+  event->tool = tool ? g_object_ref (tool) : NULL;
+  event->time = time;
 
-  if (y_distance)
-    *y_distance = yd;
+  return (GdkEvent *)event;
+}
 
-  if (distance)
-    *distance = sqrt ((xd * xd) + (yd * yd));
+GdkEvent *
+gdk_event_key_new (GdkEventType     type,
+                   GdkSurface      *surface,
+                   GdkDevice       *device,
+                   GdkDevice       *source_device,
+                   guint32          time,
+                   GdkModifierType  state,
+                   guint            keyval,
+                   guint16          keycode,
+                   guint16          scancode,
+                   guint8           group,
+                   gboolean         is_modifier)
+{
+  GdkEventKey *event;
 
-  return TRUE;
+  g_return_val_if_fail (type == GDK_KEY_PRESS ||
+                        type == GDK_KEY_RELEASE, NULL);
+
+  event = g_new0 (GdkEventKey, 1);
+  
+  event->any.ref_count = 1;
+  event->any.type = type;
+  event->any.surface = g_object_ref (surface);
+  event->any.device = g_object_ref (device);
+  event->any.source_device = g_object_ref (source_device);
+  event->time = time;
+  event->state = state;
+  event->keyval = keyval;
+  event->hardware_keycode = keycode;
+  event->key_scancode = scancode;
+  event->group = group;
+  event->is_modifier = is_modifier;
+
+  return (GdkEvent *)event;
 }
 
-/**
- * gdk_events_get_distance:
- * @event1: first #GdkEvent
- * @event2: second #GdkEvent
- * @distance: (out): return location for the distance
- *
- * If both events have X/Y information, the distance between both coordinates
- * (as in a straight line going from @event1 to @event2) will be returned.
- *
- * Returns: %TRUE if the distance could be calculated.
- **/
-gboolean
-gdk_events_get_distance (GdkEvent *event1,
-                         GdkEvent *event2,
-                         gdouble  *distance)
+GdkEvent *
+gdk_event_configure_new (GdkSurface *surface,
+                         int         width,
+                         int         height)
 {
-  return gdk_events_get_axis_distances (event1, event2,
-                                        NULL, NULL,
-                                        distance);
+  GdkEventConfigure *event = g_new0 (GdkEventConfigure, 1);
+
+  event->any.ref_count = 1;
+  event->any.type = GDK_CONFIGURE;
+  event->any.surface = g_object_ref (surface);
+  event->width = width;
+  event->height = height;
+
+  return (GdkEvent *)event;
 }
 
-/**
- * gdk_events_get_angle:
- * @event1: first #GdkEvent
- * @event2: second #GdkEvent
- * @angle: (out): return location for the relative angle between both events
- *
- * If both events contain X/Y information, this function will return %TRUE
- * and return in @angle the relative angle from @event1 to @event2. The rotation
- * direction for positive angles is from the positive X axis towards the positive
- * Y axis.
- *
- * Returns: %TRUE if the angle could be calculated.
- **/
-gboolean
-gdk_events_get_angle (GdkEvent *event1,
-                      GdkEvent *event2,
-                      gdouble  *angle)
+GdkEvent *
+gdk_event_delete_new (GdkSurface *surface)
 {
-  gdouble x_distance, y_distance, distance;
+  GdkEventAny *event = g_new0 (GdkEventAny, 1);
 
-  if (!gdk_events_get_axis_distances (event1, event2,
-                                      &x_distance, &y_distance,
-                                      &distance))
-    return FALSE;
+  event->ref_count = 1;
+  event->type = GDK_DELETE;
+  event->surface = g_object_ref (surface);
 
-  if (angle)
-    {
-      *angle = atan2 (x_distance, y_distance);
-
-      /* Invert angle */
-      *angle = (2 * G_PI) - *angle;
-
-      /* Shift it 90° */
-      *angle += G_PI / 2;
-
-      /* And constraint it to 0°-360° */
-      *angle = fmod (*angle, 2 * G_PI);
-    }
-
-  return TRUE;
+  return (GdkEvent *)event;
 }
 
-/**
- * gdk_events_get_center:
- * @event1: first #GdkEvent
- * @event2: second #GdkEvent
- * @x: (out): return location for the X coordinate of the center
- * @y: (out): return location for the Y coordinate of the center
- *
- * If both events contain X/Y information, the center of both coordinates
- * will be returned in @x and @y.
- *
- * Returns: %TRUE if the center could be calculated.
- **/
-gboolean
-gdk_events_get_center (GdkEvent *event1,
-                       GdkEvent *event2,
-                       gdouble  *x,
-                       gdouble  *y)
+GdkEvent *
+gdk_event_focus_new (GdkSurface *surface,
+                     GdkDevice  *device,
+                     GdkDevice  *source_device,
+                     gboolean    focus_in)
 {
-  gdouble x1, x2, y1, y2;
-
-  if (!gdk_event_get_coords (event1, &x1, &y1) ||
-      !gdk_event_get_coords (event2, &x2, &y2))
-    return FALSE;
-
-  if (x)
-    *x = (x2 + x1) / 2;
+  GdkEventFocus *event = g_new0 (GdkEventFocus, 1);
 
-  if (y)
-    *y = (y2 + y1) / 2;
+  event->any.ref_count = 1;
+  event->any.type = GDK_FOCUS_CHANGE;
+  event->any.surface = g_object_ref (surface);
+  event->any.device = g_object_ref (device);
+  event->any.source_device = g_object_ref (source_device);
+  event->in = focus_in;
 
-  return TRUE;
+  return  (GdkEvent *)event;
 }
 
-/**
- * gdk_event_get_display:
- * @event: a #GdkEvent
- *
- * Retrieves the #GdkDisplay associated to the @event.
- *
- * Returns: (transfer none) (nullable): a #GdkDisplay
- */
-GdkDisplay *
-gdk_event_get_display (GdkEvent       *event)
+GdkEvent *
+gdk_event_scroll_new (GdkSurface      *surface,
+                      GdkDevice       *device,
+                      GdkDevice       *source_device,
+                      GdkDeviceTool   *tool,
+                      guint32          time,
+                      GdkModifierType  state,
+                      double           delta_x,
+                      double           delta_y,
+                      gboolean         is_stop)
 {
-  if (event->any.display)
-    return event->any.display;
+  GdkEventScroll *event = g_new0 (GdkEventScroll, 1);
 
-  if (event->any.surface)
-    return gdk_surface_get_display (event->any.surface);
+  event->any.ref_count = 1;
+  event->any.type = GDK_SCROLL;
+  event->any.surface = g_object_ref (surface);
+  event->any.device = g_object_ref (device);
+  event->any.source_device = g_object_ref (source_device);
+  event->tool = tool ? g_object_ref (tool) : NULL;
+  event->time = time;
+  event->state = state;
+  event->x = NAN;
+  event->y = NAN;
+  event->direction = GDK_SCROLL_SMOOTH;
+  event->delta_x = delta_x;
+  event->delta_y = delta_y;
+  event->is_stop = is_stop;
 
-  return NULL;
+  return (GdkEvent *)event;
 }
 
-/**
- * gdk_event_get_event_sequence:
- * @event: a #GdkEvent
- *
- * If @event if of type %GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE,
- * %GDK_TOUCH_END or %GDK_TOUCH_CANCEL, returns the #GdkEventSequence
- * to which the event belongs. Otherwise, return %NULL.
- *
- * Returns: (transfer none): the event sequence that the event belongs to
- */
-GdkEventSequence *
-gdk_event_get_event_sequence (GdkEvent       *event)
+GdkEvent *
+gdk_event_discrete_scroll_new (GdkSurface         *surface,
+                               GdkDevice          *device,
+                               GdkDevice          *source_device,
+                               GdkDeviceTool      *tool,
+                               guint32             time,
+                               GdkModifierType     state,
+                               GdkScrollDirection  direction,
+                               gboolean            emulated)
 {
-  if (!event)
-    return NULL;
-
-  if (event->any.type == GDK_TOUCH_BEGIN ||
-      event->any.type == GDK_TOUCH_UPDATE ||
-      event->any.type == GDK_TOUCH_END ||
-      event->any.type == GDK_TOUCH_CANCEL)
-    return event->touch.sequence;
-
-  return NULL;
-}
+  GdkEventScroll *event = g_new0 (GdkEventScroll, 1);
 
-/**
- * gdk_set_show_events:
- * @show_events:  %TRUE to output event debugging information.
- * 
- * Sets whether a trace of received events is output.
- * Note that GTK+ must be compiled with debugging (that is,
- * configured using the `--enable-debug` option)
- * to use this option.
- **/
-void
-gdk_set_show_events (gboolean show_events)
-{
-  if (show_events)
-    _gdk_debug_flags |= GDK_DEBUG_EVENTS;
-  else
-    _gdk_debug_flags &= ~GDK_DEBUG_EVENTS;
-}
+  event->any.ref_count = 1;
+  event->any.type = GDK_SCROLL;
+  event->any.surface = g_object_ref (surface);
+  event->any.device = g_object_ref (device);
+  event->any.source_device = g_object_ref (source_device);
+  event->tool = tool ? g_object_ref (tool) : NULL;
+  event->time = time;
+  event->state = state;
+  event->x = NAN;
+  event->y = NAN;
+  event->direction = direction;
+  if (emulated)
+    event->any.flags = GDK_EVENT_POINTER_EMULATED;
 
-/**
- * gdk_get_show_events:
- * 
- * Gets whether event debugging output is enabled.
- * 
- * Returns: %TRUE if event debugging output is enabled.
- **/
-gboolean
-gdk_get_show_events (void)
-{
-  return (_gdk_debug_flags & GDK_DEBUG_EVENTS) != 0;
+  return (GdkEvent *)event;
 }
 
-static GdkEventSequence *
-gdk_event_sequence_copy (GdkEventSequence *sequence)
+GdkEvent *
+gdk_event_touch_new (GdkEventType      type,
+                     GdkEventSequence *sequence,
+                     GdkSurface       *surface,
+                     GdkDevice        *device,
+                     GdkDevice        *source_device,
+                     guint32           time,
+                     GdkModifierType   state,
+                     double            x,
+                     double            y,
+                     double           *axes,
+                     gboolean          emulating)
 {
-  return sequence;
-}
+  GdkEventTouch *event;
 
-static void
-gdk_event_sequence_free (GdkEventSequence *sequence)
-{
-  /* Nothing to free here */
-}
+  g_return_val_if_fail (type == GDK_TOUCH_BEGIN ||
+                        type == GDK_TOUCH_END ||
+                        type == GDK_TOUCH_UPDATE ||
+                        type == GDK_TOUCH_CANCEL, NULL);
 
-G_DEFINE_BOXED_TYPE (GdkEventSequence, gdk_event_sequence,
-                     gdk_event_sequence_copy,
-                     gdk_event_sequence_free)
+  event = g_new0 (GdkEventTouch, 1);
 
-/**
- * gdk_event_get_event_type:
- * @event: a #GdkEvent
- *
- * Retrieves the type of the event.
- *
- * Returns: a #GdkEventType
- */
-GdkEventType
-gdk_event_get_event_type (GdkEvent       *event)
-{
-  g_return_val_if_fail (event != NULL, 0);
+  event->any.ref_count = 1;
+  event->any.type = type;
+  event->any.surface = g_object_ref (surface);
+  event->any.device = g_object_ref (device);
+  event->any.source_device = g_object_ref (source_device);
+  event->sequence = sequence;
+  event->time = time;
+  event->state = state;
+  event->x = x;
+  event->y = y;
+  event->axes = axes;
+  event->emulating_pointer = emulating;
+  if (emulating)
+    event->any.flags = GDK_EVENT_POINTER_EMULATED;
 
-  return event->any.type;
+  return (GdkEvent *)event;
 }
 
-/**
- * gdk_event_get_seat:
- * @event: a #GdkEvent
- *
- * Returns the #GdkSeat this event was generated for.
- *
- * Returns: (transfer none): The #GdkSeat of this event
- **/
-GdkSeat *
-gdk_event_get_seat (GdkEvent       *event)
+GdkEvent *
+gdk_event_touchpad_swipe_new (GdkSurface *surface,
+                              GdkDevice  *device,
+                              GdkDevice  *source_device,
+                              guint32     time,
+                              GdkModifierType state,
+                              GdkTouchpadGesturePhase phase,
+                              double      x,
+                              double      y,
+                              int         n_fingers,
+                              double      dx,
+                              double      dy)
 {
-  GdkDevice *device;
+  GdkEventTouchpadSwipe *event = g_new0 (GdkEventTouchpadSwipe, 1);
 
-  device = gdk_event_get_device (event);
+  event->any.ref_count = 1;
+  event->any.type = GDK_TOUCHPAD_SWIPE;
+  event->any.surface = g_object_ref (surface);
+  event->any.device = g_object_ref (device);
+  event->any.source_device = g_object_ref (source_device);
+  event->time = time;
+  event->state = state;
+  event->phase = phase;
+  event->x = x;
+  event->y = y;
+  event->dx = dx;
+  event->dy = dy;
+  event->n_fingers = n_fingers;
 
-  return device ? gdk_device_get_seat (device) : NULL;
+  return (GdkEvent *)event;
 }
 
-/**
- * gdk_event_get_device_tool:
- * @event: a #GdkEvent
- *
- * If the event was generated by a device that supports
- * different tools (eg. a tablet), this function will
- * return a #GdkDeviceTool representing the tool that
- * caused the event. Otherwise, %NULL will be returned.
- *
- * Note: the #GdkDeviceTool<!-- -->s will be constant during
- * the application lifetime, if settings must be stored
- * persistently across runs, see gdk_device_tool_get_serial()
- *
- * Returns: (transfer none): The current device tool, or %NULL
- **/
-GdkDeviceTool *
-gdk_event_get_device_tool (GdkEvent       *event)
-{
-  if (event->any.type == GDK_BUTTON_PRESS ||
-      event->any.type == GDK_BUTTON_RELEASE)
-    return event->button.tool;
-  else if (event->any.type == GDK_MOTION_NOTIFY)
-    return event->motion.tool;
-  else if (event->any.type == GDK_PROXIMITY_IN ||
-           event->any.type == GDK_PROXIMITY_OUT)
-    return event->proximity.tool;
-  else if (event->any.type == GDK_SCROLL)
-    return event->scroll.tool;
+GdkEvent *
+gdk_event_touchpad_pinch_new (GdkSurface *surface,
+                              GdkDevice  *device,
+                              GdkDevice  *source_device,
+                              guint32     time,
+                              GdkModifierType state,
+                              GdkTouchpadGesturePhase phase,
+                              double      x,
+                              double      y,
+                              int         n_fingers,
+                              double      dx,
+                              double      dy,
+                              double      scale,
+                              double      angle_delta)
+{
+  GdkEventTouchpadPinch *event = g_new0 (GdkEventTouchpadPinch, 1);
 
-  return NULL;
+  event->any.ref_count = 1;
+  event->any.type = GDK_TOUCHPAD_PINCH;
+  event->any.surface = g_object_ref (surface);
+  event->any.device = g_object_ref (device);
+  event->any.source_device = g_object_ref (source_device);
+  event->time = time;
+  event->state = state;
+  event->phase = phase;
+  event->x = x;
+  event->y = y;
+  event->dx = dx;
+  event->dy = dy;
+  event->n_fingers = n_fingers;
+  event->scale = scale;
+  event->angle_delta = angle_delta;
+
+  return (GdkEvent *)event;
 }
 
-/**
- * gdk_event_get_scancode:
- * @event: a #GdkEvent
- *
- * Gets the keyboard low-level scancode of a key event.
- *
- * This is usually hardware_keycode. On Windows this is the high
- * word of WM_KEY{DOWN,UP} lParam which contains the scancode and
- * some extended flags.
- *
- * Returns: The associated keyboard scancode or 0
- **/
-int
-gdk_event_get_scancode (GdkEvent *event)
+GdkEvent *
+gdk_event_pad_ring_new (GdkSurface *surface,
+                        GdkDevice  *device,
+                        GdkDevice  *source_device,
+                        guint32     time,
+                        guint       group,
+                        guint       index,
+                        guint       mode,
+                        double      value)
 {
-  if (event->any.type == GDK_KEY_PRESS ||
-      event->any.type == GDK_KEY_RELEASE)
-    return event->key.key_scancode;
+  GdkEventPadAxis *event = g_new0 (GdkEventPadAxis, 1);
 
-  return 0;
+  event->any.ref_count = 1;
+  event->any.type = GDK_PAD_RING;
+  event->any.surface = g_object_ref (surface);
+  event->any.device = g_object_ref (device);
+  event->any.source_device = g_object_ref (source_device);
+  event->time = time;
+  event->group = group;
+  event->index = index;
+  event->mode = mode;
+  event->value = value;
+
+  return (GdkEvent *)event;
 }
 
-/**
- * gdk_event_is_sent:
- * @event: a #GdkEvent
- *
- * Returns whether the event was sent explicitly.
- *
- * Returns: %TRUE if the event was sent explicitly
- */
-gboolean
-gdk_event_is_sent (GdkEvent       *event)
+GdkEvent *
+gdk_event_pad_strip_new (GdkSurface *surface,
+                         GdkDevice  *device,
+                         GdkDevice  *source_device,
+                         guint32     time,
+                         guint       group,
+                         guint       index,
+                         guint       mode,
+                         double      value)
 {
-  if (!event)
-    return FALSE;
+  GdkEventPadAxis *event = g_new0 (GdkEventPadAxis, 1);
+
+  event->any.ref_count = 1;
+  event->any.type = GDK_PAD_STRIP;
+  event->any.surface = g_object_ref (surface);
+  event->any.device = g_object_ref (device);
+  event->any.source_device = g_object_ref (source_device);
+  event->time = time;
+  event->group = group;
+  event->index = index;
+  event->mode = mode;
+  event->value = value;
 
-  return event->any.send_event;
+  return (GdkEvent *)event;
 }
 
-/**
- * gdk_event_get_drop:
- * @event: a #GdkEvent
- *
- * Gets the #GdkDrop from a DND event.
- *
- * Returns: (transfer none) (nullable): the drop
- **/
-GdkDrop *
-gdk_event_get_drop (GdkEvent       *event)
+GdkEvent *
+gdk_event_pad_button_new (GdkEventType  type,
+                          GdkSurface   *surface,
+                          GdkDevice    *device,
+                          GdkDevice    *source_device,
+                          guint32       time,
+                          guint         group,
+                          guint         button,
+                          guint         mode)
 {
-  if (!event)
-    return FALSE;
+  GdkEventPadButton *event;
 
-  if (event->any.type == GDK_DRAG_ENTER ||
-      event->any.type == GDK_DRAG_LEAVE ||
-      event->any.type == GDK_DRAG_MOTION ||
-      event->any.type == GDK_DROP_START)
-    {
-      return event->dnd.drop;
-    }
+  g_return_val_if_fail (type == GDK_PAD_BUTTON_PRESS ||
+                        type == GDK_PAD_BUTTON_RELEASE, NULL);
 
-  return NULL;
+  event = g_new0 (GdkEventPadButton, 1);
+
+  event->any.ref_count = 1;
+  event->any.type = type;
+  event->any.surface = g_object_ref (surface);
+  event->any.device = g_object_ref (device);
+  event->any.source_device = g_object_ref (source_device);
+  event->time = time;
+  event->group = group;
+  event->button = button;
+  event->mode = mode;
+
+  return (GdkEvent *)event;
 }
 
-/**
- * gdk_event_get_crossing_mode:
- * @event: a #GdkEvent
- * @mode: (out): return location for the crossing mode
- *
- * Extracts the crossing mode from an event.
- *
- * Returns: %TRUE on success, otherwise %FALSE
- **/
-gboolean
-gdk_event_get_crossing_mode (GdkEvent        *event,
-                             GdkCrossingMode *mode)
+GdkEvent *
+gdk_event_pad_group_mode_new (GdkSurface *surface,
+                              GdkDevice  *device,
+                              GdkDevice  *source_device,
+                              guint32     time,
+                              guint       group,
+                              guint       mode)
 {
-  if (!event)
-    return FALSE;
+  GdkEventPadGroupMode *event = g_new0 (GdkEventPadGroupMode, 1);
 
-  if (event->any.type == GDK_ENTER_NOTIFY ||
-      event->any.type == GDK_LEAVE_NOTIFY)
-    {
-      *mode = event->crossing.mode;
-      return TRUE;
-    }
-  else if (event->any.type == GDK_FOCUS_CHANGE)
-    {
-      *mode = event->focus_change.mode;
-      return TRUE;
-    }
+  event->any.ref_count = 1;
+  event->any.type = GDK_PAD_GROUP_MODE;
+  event->any.surface = g_object_ref (surface);
+  event->any.device = g_object_ref (device);
+  event->any.source_device = g_object_ref (source_device);
+  event->time = time;
+  event->group = group;
+  event->mode = mode;
 
-  return FALSE;
+  return (GdkEvent *)event;
 }
 
-/**
- * gdk_event_get_crossing_detail:
- * @event: a #GdkEvent
- * @detail: (out): return location for the crossing detail
- *
- * Extracts the crossing detail from an event.
- *
- * Returns: %TRUE on success, otherwise %FALSE
- **/
-gboolean
-gdk_event_get_crossing_detail (GdkEvent       *event,
-                               GdkNotifyType  *detail)
+GdkEvent *
+gdk_event_drag_new (GdkEventType  type,
+                    GdkSurface   *surface,
+                    GdkDevice    *device,
+                    GdkDrop      *drop,
+                    guint32       time,
+                    double        x,
+                    double        y)
 {
-  if (!event)
-    return FALSE;
+  GdkEventDND *event;
 
-  if (event->any.type == GDK_ENTER_NOTIFY ||
-      event->any.type == GDK_LEAVE_NOTIFY)
-    {
-      *detail = event->crossing.detail;
-      return TRUE;
-    }
-  else if (event->any.type == GDK_FOCUS_CHANGE)
-    {
-      *detail = event->focus_change.detail;
-      return TRUE;
-    }
+  g_return_val_if_fail (type == GDK_DRAG_ENTER ||
+                        type == GDK_DRAG_MOTION ||
+                        type == GDK_DRAG_LEAVE ||
+                        type == GDK_DROP_START, NULL);
 
-  return FALSE;
+  event = g_new0 (GdkEventDND, 1);
+
+  event->any.ref_count = 1;
+  event->any.type = type;
+  event->any.surface = g_object_ref (surface);
+  event->any.device = g_object_ref (device);
+  event->drop = g_object_ref (drop);
+  event->time = time;
+  event->x = x;
+  event->y = y;
+
+  return (GdkEvent *)event;
 }
 
-/**
- * gdk_event_get_touchpad_gesture_phase:
- * @event: a #GdkEvent
- * @phase: (out): Return location for the gesture phase
- *
- * Extracts the touchpad gesture phase from a touchpad event.
- *
- * Returns: %TRUE on success, otherwise %FALSE
- **/
-gboolean
-gdk_event_get_touchpad_gesture_phase (GdkEvent                *event,
-                                      GdkTouchpadGesturePhase *phase)
+GdkEvent *
+gdk_event_grab_broken_new (GdkSurface *surface,
+                           GdkDevice  *device,
+                           GdkDevice  *source_device,
+                           GdkSurface *grab_surface,
+                           gboolean    implicit)
 {
-  if (!event)
-    return FALSE;
+  GdkEventGrabBroken *event = g_new0 (GdkEventGrabBroken, 1);
 
-  if (event->any.type == GDK_TOUCHPAD_PINCH)
-    {
-      *phase = event->touchpad_pinch.phase;
-      return TRUE;
-    }
-  else if (event->any.type == GDK_TOUCHPAD_SWIPE)
-    {
-      *phase = event->touchpad_swipe.phase;
-      return TRUE;
-    }
+  event->any.ref_count = 1;
+  event->any.type = GDK_GRAB_BROKEN;
+  event->any.surface = g_object_ref (surface);
+  event->any.device = g_object_ref (device);
+  event->any.source_device = g_object_ref (source_device);
+  event->grab_surface = grab_surface;
+  event->implicit = implicit;
+  event->keyboard = gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD;
 
-  return FALSE;
+  return (GdkEvent *)event;
 }
 
 /**
- * gdk_event_get_touchpad_gesture_n_fingers:
+ * gdk_event_get_event_type:
  * @event: a #GdkEvent
- * @n_fingers: (out): return location for the number of fingers
  *
- * Extracts the number of fingers from a touchpad event.
+ * Retrieves the type of the event.
  *
- * Returns: %TRUE on success, otherwise %FALSE
- **/
-gboolean
-gdk_event_get_touchpad_gesture_n_fingers (GdkEvent       *event,
-                                          guint          *n_fingers)
-{
-  if (!event)
-    return FALSE;
-
-  if (event->any.type == GDK_TOUCHPAD_PINCH)
-    {
-      *n_fingers = event->touchpad_pinch.n_fingers;
-      return TRUE;
-    }
-  else if (event->any.type == GDK_TOUCHPAD_SWIPE)
-    {
-      *n_fingers = event->touchpad_swipe.n_fingers;
-      return TRUE;
-    }
-
-  return FALSE;
-}
-
-/**
- * gdk_event_get_touchpad_deltas:
- * @event: a #GdkEvent
- * @dx: (out): return location for x
- * @dy: (out): return location for y
- *
- * Extracts delta information from a touchpad event.
- *
- * Returns: %TRUE on success, otherwise %FALSE
- **/
-gboolean
-gdk_event_get_touchpad_deltas (GdkEvent       *event,
-                               double         *dx,
-                               double         *dy)
+ * Returns: a #GdkEventType
+ */
+GdkEventType
+gdk_event_get_event_type (GdkEvent *event)
 {
-  if (!event)
-    return FALSE;
-
-  if (event->any.type == GDK_TOUCHPAD_PINCH)
-    {
-      *dx = event->touchpad_pinch.dx;
-      *dy = event->touchpad_pinch.dy;
-      return TRUE;
-    }
-  else if (event->any.type == GDK_TOUCHPAD_SWIPE)
-    {
-      *dx = event->touchpad_swipe.dx;
-      *dy = event->touchpad_swipe.dy;
-      return TRUE;
-    }
-
-  return FALSE;
+  return event->any.type;
 }
 
 /**
- * gdk_event_get_touchpad_angle_delta:
+ * gdk_event_get_surface:
  * @event: a #GdkEvent
- * @delta: (out): Return location for angle
  *
- * Extracts the angle from a touchpad event.
+ * Extracts the #GdkSurface associated with an event.
  *
- * Returns: %TRUE on success, otherwise %FALSE
- **/
-gboolean
-gdk_event_get_touchpad_angle_delta (GdkEvent       *event,
-                                    double         *delta)
+ * Returns: (transfer none): The #GdkSurface associated with the event
+ */
+GdkSurface *
+gdk_event_get_surface (GdkEvent *event)
 {
-  if (!event)
-    return FALSE;
-
-  if (event->any.type == GDK_TOUCHPAD_PINCH)
-    {
-      *delta = event->touchpad_pinch.angle_delta;
-      return TRUE;
-    }
-
-  return FALSE;
+  return event->any.surface;
 }
 
 /**
- * gdk_event_get_touchpad_scale:
- * @event: a #GdkEvent
- * @scale: (out): Return location for scale
+ * gdk_event_get_device:
+ * @event: a #GdkEvent.
  *
- * Extracts the scale from a touchpad event.
+ * Returns the device of an event.
  *
- * Returns: %TRUE on success, otherwise %FALSE
+ * Returns: (nullable) (transfer none): a #GdkDevice, or %NULL.
  **/
-gboolean
-gdk_event_get_touchpad_scale (GdkEvent       *event,
-                              double         *scale)
+GdkDevice *
+gdk_event_get_device (GdkEvent *event)
 {
-  if (!event)
-    return FALSE;
-
-  if (event->any.type == GDK_TOUCHPAD_PINCH)
-    {
-      *scale = event->touchpad_pinch.scale;
-      return TRUE;
-    }
-
-  return FALSE;
+  return event->any.device;
 }
 
 /**
- * gdk_event_get_touch_emulating_pointer:
+ * gdk_event_get_source_device:
  * @event: a #GdkEvent
- * @emulating: (out): Return location for information
  *
- * Extracts whether a touch event is emulating a pointer event.
+ * This function returns the hardware (slave) #GdkDevice that has
+ * triggered the event, falling back to the virtual (master) device
+ * (as in gdk_event_get_device()) if the event wasn’t caused by
+ * interaction with a hardware device. This may happen for example
+ * in synthesized crossing events after a #GdkSurface updates its
+ * geometry or a grab is acquired/released.
  *
- * Returns: %TRUE on success, otherwise %FALSE
+ * If the event does not contain a device field, this function will
+ * return %NULL.
+ *
+ * Returns: (nullable) (transfer none): a #GdkDevice, or %NULL.
  **/
-gboolean
-gdk_event_get_touch_emulating_pointer (GdkEvent       *event,
-                                       gboolean       *emulating)
+GdkDevice *
+gdk_event_get_source_device (GdkEvent *event)
 {
-  if (!event)
-    return FALSE;
-
-  if (event->any.type == GDK_TOUCH_BEGIN ||
-      event->any.type == GDK_TOUCH_UPDATE ||
-      event->any.type == GDK_TOUCH_END)
-    {
-      *emulating = event->touch.emulating_pointer;
-      return TRUE;
-    }
+  if (event->any.source_device)
+    return event->any.source_device;
 
-  return FALSE;
+  return event->any.device;
 }
 
 /**
- * gdk_event_get_grab_surface:
+ * gdk_event_get_device_tool:
  * @event: a #GdkEvent
- * @surface: (out) (transfer none): Return location for the grab surface
  *
- * Extracts the grab surface from a grab broken event.
+ * If the event was generated by a device that supports
+ * different tools (eg. a tablet), this function will
+ * return a #GdkDeviceTool representing the tool that
+ * caused the event. Otherwise, %NULL will be returned.
  *
- * Returns: %TRUE on success, otherwise %FALSE
+ * Note: the #GdkDeviceTools will be constant during
+ * the application lifetime, if settings must be stored
+ * persistently across runs, see gdk_device_tool_get_serial()
+ *
+ * Returns: (transfer none): The current device tool, or %NULL
  **/
-gboolean
-gdk_event_get_grab_surface (GdkEvent        *event,
-                            GdkSurface     **surface)
+GdkDeviceTool *
+gdk_event_get_device_tool (GdkEvent *event)
 {
-  if (!event)
-    return FALSE;
-
-  if (event->any.type == GDK_GRAB_BROKEN)
-    {
-      *surface = event->grab_broken.grab_surface;
-      return TRUE;
-    }
+  if (event->any.type == GDK_BUTTON_PRESS ||
+      event->any.type == GDK_BUTTON_RELEASE)
+    return event->button.tool;
+  else if (event->any.type == GDK_MOTION_NOTIFY)
+    return event->motion.tool;
+  else if (event->any.type == GDK_PROXIMITY_IN ||
+           event->any.type == GDK_PROXIMITY_OUT)
+    return event->proximity.tool;
+  else if (event->any.type == GDK_SCROLL)
+    return event->scroll.tool;
 
-  return FALSE;
+  return NULL;
 }
 
 /**
- * gdk_event_get_focus_in:
+ * gdk_event_get_time:
  * @event: a #GdkEvent
- * @focus_in: (out): return location for focus direction
- *
- * Extracts whether this is a focus-in or focus-out event.
- *
- * Returns: %TRUE on success, otherwise %FALSE
+ * 
+ * Returns the time stamp from @event, if there is one; otherwise
+ * returns #GDK_CURRENT_TIME.
+ * 
+ * Returns: time stamp field from @event
  **/
-gboolean
-gdk_event_get_focus_in (GdkEvent       *event,
-                        gboolean       *focus_in)
+guint32
+gdk_event_get_time (GdkEvent *event)
 {
-  if (!event)
-    return FALSE;
-
-  if (event->any.type == GDK_FOCUS_CHANGE)
+  switch (event->any.type)
     {
-      *focus_in = event->focus_change.in;
-      return TRUE;
+    case GDK_MOTION_NOTIFY:
+      return event->motion.time;
+    case GDK_BUTTON_PRESS:
+    case GDK_BUTTON_RELEASE:
+      return event->button.time;
+    case GDK_TOUCH_BEGIN:
+    case GDK_TOUCH_UPDATE:
+    case GDK_TOUCH_END:
+    case GDK_TOUCH_CANCEL:
+      return event->touch.time;
+    case GDK_TOUCHPAD_SWIPE:
+      return event->touchpad_swipe.time;
+    case GDK_TOUCHPAD_PINCH:
+      return event->touchpad_pinch.time;
+    case GDK_SCROLL:
+      return event->scroll.time;
+    case GDK_KEY_PRESS:
+    case GDK_KEY_RELEASE:
+      return event->key.time;
+    case GDK_ENTER_NOTIFY:
+    case GDK_LEAVE_NOTIFY:
+      return event->crossing.time;
+    case GDK_PROXIMITY_IN:
+    case GDK_PROXIMITY_OUT:
+      return event->proximity.time;
+    case GDK_DRAG_ENTER:
+    case GDK_DRAG_LEAVE:
+    case GDK_DRAG_MOTION:
+    case GDK_DROP_START:
+      return event->dnd.time;
+    case GDK_PAD_BUTTON_PRESS:
+    case GDK_PAD_BUTTON_RELEASE:
+      return event->pad_button.time;
+    case GDK_PAD_RING:
+    case GDK_PAD_STRIP:
+      return event->pad_axis.time;
+    case GDK_PAD_GROUP_MODE:
+      return event->pad_group_mode.time;
+    case GDK_CONFIGURE:
+    case GDK_FOCUS_CHANGE:
+    case GDK_DELETE:
+    case GDK_GRAB_BROKEN:
+    case GDK_EVENT_LAST:
+    default:
+      /* return current time */
+      break;
     }
-
-  return FALSE;
+  
+  return GDK_CURRENT_TIME;
 }
 
 /**
- * gdk_event_get_pad_group_mode:
+ * gdk_event_get_display:
  * @event: a #GdkEvent
- * @group: (out): return location for the group
- * @mode: (out): return location for the mode
  *
- * Extracts group and mode information from a pad event.
+ * Retrieves the #GdkDisplay associated to the @event.
  *
- * Returns: %TRUE on success, otherwise %FALSE
- **/
-gboolean
-gdk_event_get_pad_group_mode (GdkEvent       *event,
-                              guint          *group,
-                              guint          *mode)
+ * Returns: (transfer none) (nullable): a #GdkDisplay
+ */
+GdkDisplay *
+gdk_event_get_display (GdkEvent *event)
 {
-  if (!event)
-    return FALSE;
-
-  if (event->any.type == GDK_PAD_GROUP_MODE)
-    {
-      *group = event->pad_group_mode.group;
-      *mode = event->pad_group_mode.mode;
-      return TRUE;
-    }
-  else if (event->any.type == GDK_PAD_BUTTON_PRESS ||
-           event->any.type == GDK_PAD_BUTTON_RELEASE)
-    {
-      *group = event->pad_button.group;
-      *mode = event->pad_button.mode;
-      return TRUE;
-    }
-  else if (event->any.type == GDK_PAD_RING ||
-           event->any.type == GDK_PAD_STRIP)
-    {
-      *group = event->pad_axis.group;
-      *mode = event->pad_axis.mode;
-      return TRUE;
-    }
+  if (event->any.surface)
+    return gdk_surface_get_display (event->any.surface);
 
-  return FALSE;
+  return NULL;
 }
 
 /**
- * gdk_event_get_pad_button:
+ * gdk_event_get_event_sequence:
  * @event: a #GdkEvent
- * @button: (out): Return location for the button
  *
- * Extracts information about the pressed button from
- * a pad event.
+ * If @event is a touch event, returns the #GdkEventSequence
+ * to which the event belongs. Otherwise, return %NULL.
  *
- * Returns: %TRUE on success, otherwise %FALSE
- **/
-gboolean
-gdk_event_get_pad_button (GdkEvent       *event,
-                          guint          *button)
+ * Returns: (transfer none): the event sequence that the event belongs to
+ */
+GdkEventSequence *
+gdk_event_get_event_sequence (GdkEvent *event)
 {
-  if (!event)
-    return FALSE;
-
-  if (event->any.type == GDK_PAD_BUTTON_PRESS ||
-      event->any.type == GDK_PAD_BUTTON_RELEASE)
-    {
-      *button = event->pad_button.button;
-      return TRUE;
-    }
+  if (event->any.type == GDK_TOUCH_BEGIN ||
+      event->any.type == GDK_TOUCH_UPDATE ||
+      event->any.type == GDK_TOUCH_END ||
+      event->any.type == GDK_TOUCH_CANCEL)
+    return event->touch.sequence;
 
-  return FALSE;
+  return NULL;
 }
 
 /**
- * gdk_event_get_pad_axis_value:
+ * gdk_event_get_modifier_state:
  * @event: a #GdkEvent
- * @index: (out): Return location for the axis index
- * @value: (out): Return location for the axis value
  *
- * Extracts the information from a pad event.
+ * Returns the modifier state field of an event.
  *
- * Returns: %TRUE on success, otherwise %FALSE
+ * Returns: the modifier state of @event
  **/
-gboolean
-gdk_event_get_pad_axis_value (GdkEvent       *event,
-                              guint          *index,
-                              gdouble        *value)
-{
-  if (!event)
-    return FALSE;
-
-  if (event->any.type == GDK_PAD_RING ||
-      event->any.type == GDK_PAD_STRIP)
+GdkModifierType
+gdk_event_get_modifier_state (GdkEvent *event)
+{
+#if 0
+  g_return_val_if_fail (event->any.type == GDK_ENTER_NOTIFY ||
+                        event->any.type == GDK_LEAVE_NOTIFY ||
+                        event->any.type == GDK_BUTTON_PRESS ||
+                        event->any.type == GDK_BUTTON_RELEASE ||
+                        event->any.type == GDK_MOTION_NOTIFY ||
+                        event->any.type == GDK_TOUCH_BEGIN ||
+                        event->any.type == GDK_TOUCH_UPDATE ||
+                        event->any.type == GDK_TOUCH_END ||
+                        event->any.type == GDK_TOUCH_CANCEL ||
+                        event->any.type == GDK_TOUCHPAD_SWIPE ||
+                        event->any.type == GDK_TOUCHPAD_PINCH||
+                        event->any.type == GDK_SCROLL ||
+                        event->any.type == GDK_KEY_PRESS ||
+                        event->any.type == GDK_KEY_RELEASE, 0);
+#endif
+
+  switch ((int)event->any.type)
     {
-      *index = event->pad_axis.index;
-      *value = event->pad_axis.value;
-      return TRUE;
+    case GDK_ENTER_NOTIFY:
+    case GDK_LEAVE_NOTIFY:
+      return event->crossing.state;
+    case GDK_BUTTON_PRESS:
+    case GDK_BUTTON_RELEASE:
+      return event->button.state;
+    case GDK_MOTION_NOTIFY:
+      return event->motion.state;
+    case GDK_TOUCH_BEGIN:
+    case GDK_TOUCH_UPDATE:
+    case GDK_TOUCH_END:
+    case GDK_TOUCH_CANCEL:
+      return event->touch.state;
+    case GDK_TOUCHPAD_SWIPE:
+      return event->touchpad_swipe.state;
+    case GDK_TOUCHPAD_PINCH:
+      return event->touchpad_pinch.state;
+    case GDK_SCROLL:
+      return event->scroll.state;
+    case GDK_KEY_PRESS:
+    case GDK_KEY_RELEASE:
+      return event->key.state;
+    default:
+      /* no state field */
+      break;
     }
 
-  return FALSE;
+  return 0;
 }
 
 /**
- * gdk_event_get_axes:
+ * gdk_event_get_position:
  * @event: a #GdkEvent
- * @axes: (transfer none) (out) (array length=n_axes): the array of values for all axes
- * @n_axes: (out): the length of array
+ * @x_win: (out): location to put event surface x coordinate
+ * @y_win: (out): location to put event surface y coordinate
  *
- * Extracts all axis values from an event.
- *
- * Returns: %TRUE on success, otherwise %FALSE
+ * Extract the event surface relative x/y coordinates from an event.
  **/
 gboolean
-gdk_event_get_axes (GdkEvent  *event,
-                    gdouble  **axes,
-                    guint     *n_axes)
-{
-  GdkDevice *source_device;
-
-  if (!event)
-    return FALSE;
-
-  source_device = gdk_event_get_source_device (event);
-
-  if (!source_device)
-    return FALSE;
-
-  if (event->any.type == GDK_MOTION_NOTIFY)
+gdk_event_get_position (GdkEvent *event,
+                        double   *x,
+                        double   *y)
+{
+#if 0
+  g_return_if_fail (event->any.type == GDK_ENTER_NOTIFY ||
+                    event->any.type == GDK_LEAVE_NOTIFY ||
+                    event->any.type == GDK_BUTTON_PRESS ||
+                    event->any.type == GDK_BUTTON_RELEASE ||
+                    event->any.type == GDK_MOTION_NOTIFY ||
+                    event->any.type == GDK_TOUCH_BEGIN ||
+                    event->any.type == GDK_TOUCH_UPDATE ||
+                    event->any.type == GDK_TOUCH_END ||
+                    event->any.type == GDK_TOUCH_CANCEL ||
+                    event->any.type == GDK_TOUCHPAD_SWIPE ||
+                    event->any.type == GDK_TOUCHPAD_PINCH||
+                    event->any.type == GDK_DRAG_ENTER ||
+                    event->any.type == GDK_DRAG_LEAVE ||
+                    event->any.type == GDK_DRAG_MOTION ||
+                    event->any.type == GDK_DROP_START);
+#endif
+
+  switch ((int)event->any.type)
     {
-      *axes = event->motion.axes;
-      *n_axes = gdk_device_get_n_axes (source_device);
-      return TRUE;
-    }
-  else if (event->any.type == GDK_BUTTON_PRESS ||
-           event->any.type == GDK_BUTTON_RELEASE)
-    {
-      *axes = event->button.axes;
-      *n_axes = gdk_device_get_n_axes (source_device);
-      return TRUE;
-    }
-
-  return FALSE;
-}
-
-/**
- * gdk_event_get_motion_history:
- * @event: a #GdkEvent of type %GDK_MOTION_NOTIFY
- *
- * Retrieves the history of the @event motion, as a list of time and
- * coordinates.
- *
- * Returns: (transfer container) (element-type GdkTimeCoord) (nullable): a list
- *   of time and coordinates
- */
-GList *
-gdk_event_get_motion_history (GdkEvent       *event)
-{
-  if (event->any.type != GDK_MOTION_NOTIFY)
-    return NULL;
-  return g_list_reverse (g_list_copy (event->motion.history));
-}
-
-GdkEvent *
-gdk_event_button_new (GdkEventType     type,
-                      GdkSurface      *surface,
-                      GdkDevice       *device,
-                      GdkDevice       *source_device,
-                      GdkDeviceTool   *tool,
-                      guint32          time,
-                      GdkModifierType  state,
-                      guint            button,
-                      double           x,
-                      double           y,
-                      double          *axes)
-{
-  GdkEventButton *event;
-
-  g_return_val_if_fail (type == GDK_BUTTON_PRESS || 
-                        type == GDK_BUTTON_RELEASE, NULL);
-
-  event = g_new0 (GdkEventButton, 1);
-  event->any.ref_count = 1;
-  event->any.type = type;
-  event->any.surface = g_object_ref (surface);
-  event->any.device = g_object_ref (device);
-  event->any.source_device = g_object_ref (source_device);
-  event->tool = tool ? g_object_ref (tool) : NULL;
-  event->time = time;
-  event->axes = NULL;
-  event->state = state;
-  event->button = button;
-  event->x = x;
-  event->y = y;
-  event->axes = axes;
-
-  return (GdkEvent *)event;
-}
-
-GdkEvent *
-gdk_event_motion_new (GdkSurface      *surface,
-                      GdkDevice       *device,
-                      GdkDevice       *source_device,
-                      GdkDeviceTool   *tool,
-                      guint32          time,
-                      GdkModifierType  state,
-                      double           x,
-                      double           y,
-                      double          *axes)
-{
-  GdkEventMotion *event = g_new0 (GdkEventMotion, 1);
-
-  event->any.ref_count = 1;
-  event->any.type = GDK_MOTION_NOTIFY;
-  event->any.surface = g_object_ref (surface);
-  event->any.device = g_object_ref (device);
-  event->any.source_device = g_object_ref (source_device);
-  event->tool = tool ? g_object_ref (tool) : NULL;
-  event->time = time;
-  event->state = state;
-  event->x = x;
-  event->y = y;
-  event->axes = axes;
-  event->state = state;
-
-  return (GdkEvent *)event;
-}
-
-GdkEvent *
-gdk_event_crossing_new (GdkEventType     type,
-                        GdkSurface      *surface,
-                        GdkDevice       *device,
-                        GdkDevice       *source_device,
-                        guint32          time,
-                        GdkModifierType  state,
-                        double           x,
-                        double           y,
-                        GdkCrossingMode  mode,
-                        GdkNotifyType    detail)
-{
-  GdkEventCrossing *event;
-
-  g_return_val_if_fail (type == GDK_ENTER_NOTIFY ||
-                        type == GDK_LEAVE_NOTIFY, NULL);
-
-  event = g_new0 (GdkEventCrossing, 1);
-
-  event->any.ref_count = 1;
-  event->any.type = type;
-  event->any.surface = g_object_ref (surface);
-  event->any.device = g_object_ref (device);
-  event->any.source_device = g_object_ref (source_device);
-  event->time = time;
-  event->state = state;
-  event->x = x;
-  event->y = y;
-  event->mode = mode;
-  event->detail = detail;
-
-  return (GdkEvent *)event;
-}
-
-GdkEvent *
-gdk_event_proximity_new (GdkEventType   type,
-                         GdkSurface    *surface,
-                         GdkDevice     *device,
-                         GdkDevice     *source_device,
-                         GdkDeviceTool *tool,
-                         guint32        time)
-{
-  GdkEventProximity *event;
-
-  g_return_val_if_fail (type == GDK_PROXIMITY_IN ||
-                        type == GDK_PROXIMITY_OUT, NULL);
-
-  event = g_new0 (GdkEventProximity, 1);
-
-  event->any.ref_count = 1;
-  event->any.type = type;
-  event->any.surface = g_object_ref (surface);
-  event->any.device = g_object_ref (device);
-  event->any.source_device = g_object_ref (source_device);
-  event->tool = tool ? g_object_ref (tool) : NULL;
-  event->time = time;
+    case GDK_ENTER_NOTIFY:
+    case GDK_LEAVE_NOTIFY:
+      *x = event->crossing.x;
+      *y = event->crossing.y;
+      break;
+    case GDK_BUTTON_PRESS:
+    case GDK_BUTTON_RELEASE:
+      *x = event->button.x;
+      *y = event->button.y;
+      break;
+    case GDK_MOTION_NOTIFY:
+      *x = event->motion.x;
+      *y = event->motion.y;
+      break;
+    case GDK_TOUCH_BEGIN:
+    case GDK_TOUCH_UPDATE:
+    case GDK_TOUCH_END:
+    case GDK_TOUCH_CANCEL:
+      *x = event->touch.x;
+      *y = event->touch.y;
+      break;
+    case GDK_TOUCHPAD_SWIPE:
+      *x = event->touchpad_swipe.x;
+      *y = event->touchpad_swipe.y;
+      break;
+    case GDK_TOUCHPAD_PINCH:
+      *x = event->touchpad_pinch.x;
+      *y = event->touchpad_pinch.y;
+      break;
+    case GDK_DRAG_ENTER:
+    case GDK_DRAG_LEAVE:
+    case GDK_DRAG_MOTION:
+    case GDK_DROP_START:
+      *x = event->dnd.x;
+      *y = event->dnd.y;
+      break;
+    default:
+      /* no position */
+      *x = NAN;
+      *y = NAN;
+      return FALSE;
+    }
 
-  return (GdkEvent *)event;
+  return TRUE;
 }
 
-GdkEvent *
-gdk_event_key_new (GdkEventType     type,
-                   GdkSurface      *surface,
-                   GdkDevice       *device,
-                   GdkDevice       *source_device,
-                   guint32          time,
-                   GdkModifierType  state,
-                   guint            keyval,
-                   guint16          keycode,
-                   guint16          scancode,
-                   guint8           group,
-                   gboolean         is_modifier)
+/**
+ * gdk_button_event_get_button:
+ * @event: a button event
+ *
+ * Extract the button number from a button event.
+ *
+ * Returns: the button of @event
+ **/
+guint
+gdk_button_event_get_button (GdkEvent *event)
 {
-  GdkEventKey *event;
-
-  g_return_val_if_fail (type == GDK_KEY_PRESS ||
-                        type == GDK_KEY_RELEASE, NULL);
-
-  event = g_new0 (GdkEventKey, 1);
+  g_return_val_if_fail (event->any.type == GDK_BUTTON_PRESS ||
+                        event->any.type == GDK_BUTTON_RELEASE, 0);
   
-  event->any.ref_count = 1;
-  event->any.type = type;
-  event->any.surface = g_object_ref (surface);
-  event->any.device = g_object_ref (device);
-  event->any.source_device = g_object_ref (source_device);
-  event->time = time;
-  event->state = state;
-  event->keyval = keyval;
-  event->hardware_keycode = keycode;
-  event->key_scancode = scancode;
-  event->group = group;
-  event->is_modifier = is_modifier;
-
-  return (GdkEvent *)event;
+  return event->button.button;
 }
 
-GdkEvent *
-gdk_event_configure_new (GdkSurface *surface,
-                         int         width,
-                         int         height)
+/**
+ * gdk_key_event_get_keyval:
+ * @event: a key event
+ *
+ * Extracts the keyval from a key event.
+ *
+ * Returns: the keyval of @event
+ */
+guint
+gdk_key_event_get_keyval (GdkEvent *event)
 {
-  GdkEventConfigure *event = g_new0 (GdkEventConfigure, 1);
+  g_return_val_if_fail (event->any.type == GDK_KEY_PRESS ||
+                        event->any.type == GDK_KEY_RELEASE, 0);
 
-  event->any.ref_count = 1;
-  event->any.type = GDK_CONFIGURE;
-  event->any.surface = g_object_ref (surface);
-  event->width = width;
-  event->height = height;
-
-  return (GdkEvent *)event;
+  return event->key.keyval;
 }
 
-GdkEvent *
-gdk_event_delete_new (GdkSurface *surface)
+/**
+ * gdk_key_event_get_keycode:
+ * @event: a key event
+ *
+ * Extracts the keycode from a key event.
+ *
+ * Returns: the keycode of @event
+ */
+guint
+gdk_key_event_get_keycode (GdkEvent *event)
 {
-  GdkEventAny *event = g_new0 (GdkEventAny, 1);
-
-  event->ref_count = 1;
-  event->type = GDK_DELETE;
-  event->surface = g_object_ref (surface);
+  g_return_val_if_fail (event->any.type == GDK_KEY_PRESS ||
+                        event->any.type == GDK_KEY_RELEASE, 0);
 
-  return (GdkEvent *)event;
+  return event->key.hardware_keycode;
 }
 
-GdkEvent *
-gdk_event_focus_new (GdkSurface *surface,
-                     GdkDevice  *device,
-                     GdkDevice  *source_device,
-                     gboolean    focus_in)
+/**
+ * gdk_key_event_get_scancode:
+ * @event: a key event
+ *
+ * Extracts the scancode from a key event.
+ *
+ * Returns: the scancode of @event
+ */
+guint
+gdk_key_event_get_scancode (GdkEvent *event)
 {
-  GdkEventFocus *event = g_new0 (GdkEventFocus, 1);
-
-  event->any.ref_count = 1;
-  event->any.type = GDK_FOCUS_CHANGE;
-  event->any.surface = g_object_ref (surface);
-  event->any.device = g_object_ref (device);
-  event->any.source_device = g_object_ref (source_device);
-  event->in = focus_in;
+  g_return_val_if_fail (event->any.type == GDK_KEY_PRESS ||
+                        event->any.type == GDK_KEY_RELEASE, 0);
 
-  return  (GdkEvent *)event;
+  return event->key.key_scancode;
 }
 
-GdkEvent *
-gdk_event_scroll_new (GdkSurface      *surface,
-                      GdkDevice       *device,
-                      GdkDevice       *source_device,
-                      GdkDeviceTool   *tool,
-                      guint32          time,
-                      GdkModifierType  state,
-                      double           delta_x,
-                      double           delta_y,
-                      gboolean         is_stop)
+/**
+ * gdk_key_event_get_group:
+ * @event: a key event
+ *
+ * Extracts the group from a key event.
+ *
+ * Returns: the group of @event
+ */
+guint
+gdk_key_event_get_group (GdkEvent *event)
 {
-  GdkEventScroll *event = g_new0 (GdkEventScroll, 1);
-
-  event->any.ref_count = 1;
-  event->any.type = GDK_SCROLL;
-  event->any.surface = g_object_ref (surface);
-  event->any.device = g_object_ref (device);
-  event->any.source_device = g_object_ref (source_device);
-  event->tool = tool ? g_object_ref (tool) : NULL;
-  event->time = time;
-  event->state = state;
-  event->x = NAN;
-  event->y = NAN;
-  event->direction = GDK_SCROLL_SMOOTH;
-  event->delta_x = delta_x;
-  event->delta_y = delta_y;
-  event->is_stop = is_stop;
+  g_return_val_if_fail (event->any.type == GDK_KEY_PRESS ||
+                        event->any.type == GDK_KEY_RELEASE, 0);
 
-  return (GdkEvent *)event;
+  return event->key.group;
 }
 
-GdkEvent *
-gdk_event_discrete_scroll_new (GdkSurface         *surface,
-                               GdkDevice          *device,
-                               GdkDevice          *source_device,
-                               GdkDeviceTool      *tool,
-                               guint32             time,
-                               GdkModifierType     state,
-                               GdkScrollDirection  direction,
-                               gboolean            emulated)
+/**
+ * gdk_key_event_is_modifier:
+ * @event: a key event
+ *
+ * Extracts whether the key event is for a modifier key.
+ *
+ * Returns: %TRUE if the @event is for a modifier key
+ */
+gboolean
+gdk_key_event_is_modifier (GdkEvent *event)
 {
-  GdkEventScroll *event = g_new0 (GdkEventScroll, 1);
-
-  event->any.ref_count = 1;
-  event->any.type = GDK_SCROLL;
-  event->any.surface = g_object_ref (surface);
-  event->any.device = g_object_ref (device);
-  event->any.source_device = g_object_ref (source_device);
-  event->tool = tool ? g_object_ref (tool) : NULL;
-  event->time = time;
-  event->state = state;
-  event->x = NAN;
-  event->y = NAN;
-  event->direction = direction;
-  if (emulated)
-    event->any.flags = GDK_EVENT_POINTER_EMULATED;
+  g_return_val_if_fail (event->any.type == GDK_KEY_PRESS ||
+                        event->any.type == GDK_KEY_RELEASE, FALSE);
 
-  return (GdkEvent *)event;
+  return event->key.is_modifier;
 }
 
-GdkEvent *
-gdk_event_touch_new (GdkEventType      type,
-                     GdkEventSequence *sequence,
-                     GdkSurface       *surface,
-                     GdkDevice        *device,
-                     GdkDevice        *source_device,
-                     guint32           time,
-                     GdkModifierType   state,
-                     double            x,
-                     double            y,
-                     double           *axes,
-                     gboolean          emulating)
+void
+gdk_configure_event_get_size (GdkEvent *event,
+                              int      *width,
+                              int      *height)
 {
-  GdkEventTouch *event;
+  g_return_if_fail (event->any.type == GDK_CONFIGURE);
 
-  g_return_val_if_fail (type == GDK_TOUCH_BEGIN ||
-                        type == GDK_TOUCH_END ||
-                        type == GDK_TOUCH_UPDATE ||
-                        type == GDK_TOUCH_CANCEL, NULL);
-
-  event = g_new0 (GdkEventTouch, 1);
-
-  event->any.ref_count = 1;
-  event->any.type = type;
-  event->any.surface = g_object_ref (surface);
-  event->any.device = g_object_ref (device);
-  event->any.source_device = g_object_ref (source_device);
-  event->sequence = sequence;
-  event->time = time;
-  event->state = state;
-  event->x = x;
-  event->y = y;
-  event->axes = axes;
-  event->emulating_pointer = emulating;
-  if (emulating)
-    event->any.flags = GDK_EVENT_POINTER_EMULATED;
-
-  return (GdkEvent *)event;
+  *width = event->configure.width;
+  *height = event->configure.height;
 }
 
-GdkEvent *
-gdk_event_touchpad_swipe_new (GdkSurface *surface,
-                              GdkDevice  *device,
-                              GdkDevice  *source_device,
-                              guint32     time,
-                              GdkModifierType state,
-                              GdkTouchpadGesturePhase phase,
-                              double      x,
-                              double      y,
-                              int         n_fingers,
-                              double      dx,
-                              double      dy)
+/**
+ * gdk_touch_event_get_emulating_pointer:
+ * @event: a touch event
+ *
+ * Extracts whether a touch event is emulating a pointer event.
+ *
+ * Returns: %TRUE if @event is emulating
+ **/
+gboolean
+gdk_touch_event_get_emulating_pointer (GdkEvent *event)
 {
-  GdkEventTouchpadSwipe *event = g_new0 (GdkEventTouchpadSwipe, 1);
-
-  event->any.ref_count = 1;
-  event->any.type = GDK_TOUCHPAD_SWIPE;
-  event->any.surface = g_object_ref (surface);
-  event->any.device = g_object_ref (device);
-  event->any.source_device = g_object_ref (source_device);
-  event->time = time;
-  event->state = state;
-  event->phase = phase;
-  event->x = x;
-  event->y = y;
-  event->dx = dx;
-  event->dy = dy;
-  event->n_fingers = n_fingers;
+  g_return_val_if_fail (event->any.type == GDK_TOUCH_BEGIN ||
+                        event->any.type == GDK_TOUCH_UPDATE ||
+                        event->any.type == GDK_TOUCH_END ||
+                        event->any.type == GDK_TOUCH_CANCEL, FALSE);
 
-  return (GdkEvent *)event;
+  return event->touch.emulating_pointer;
 }
 
-GdkEvent *
-gdk_event_touchpad_pinch_new (GdkSurface *surface,
-                              GdkDevice  *device,
-                              GdkDevice  *source_device,
-                              guint32     time,
-                              GdkModifierType state,
-                              GdkTouchpadGesturePhase phase,
-                              double      x,
-                              double      y,
-                              int         n_fingers,
-                              double      dx,
-                              double      dy,
-                              double      scale,
-                              double      angle_delta)
+/**
+ * gdk_crossing_event_get_mode:
+ * @event: a crossing event
+ *
+ * Extracts the crossing mode from a crossing event.
+ *
+ * Returns: the mode of @event
+ */
+GdkCrossingMode
+gdk_crossing_event_get_mode (GdkEvent *event)
 {
-  GdkEventTouchpadPinch *event = g_new0 (GdkEventTouchpadPinch, 1);
+  g_return_val_if_fail (event->any.type == GDK_ENTER_NOTIFY ||
+                        event->any.type == GDK_LEAVE_NOTIFY, 0);
 
-  event->any.ref_count = 1;
-  event->any.type = GDK_TOUCHPAD_PINCH;
-  event->any.surface = g_object_ref (surface);
-  event->any.device = g_object_ref (device);
-  event->any.source_device = g_object_ref (source_device);
-  event->time = time;
-  event->state = state;
-  event->phase = phase;
-  event->x = x;
-  event->y = y;
-  event->dx = dx;
-  event->dy = dy;
-  event->n_fingers = n_fingers;
-  event->scale = scale;
-  event->angle_delta = angle_delta;
+  return event->crossing.mode;
+}
+
+/**
+ * gdk_crossing_event_get_detail:
+ * @event: a crossing event
+ *
+ * Extracts the notify detail from a crossing event.
+ *
+ * Returns: the notify detail of @event
+ */
+GdkNotifyType
+gdk_crossing_event_get_detail (GdkEvent *event)
+{
+  g_return_val_if_fail (event->any.type == GDK_ENTER_NOTIFY ||
+                        event->any.type == GDK_LEAVE_NOTIFY, 0);
 
-  return (GdkEvent *)event;
+  return event->crossing.detail;
 }
 
-GdkEvent *
-gdk_event_pad_ring_new (GdkSurface *surface,
-                        GdkDevice  *device,
-                        GdkDevice  *source_device,
-                        guint32     time,
-                        guint       group,
-                        guint       index,
-                        guint       mode,
-                        double      value)
+gboolean
+gdk_focus_event_get_in (GdkEvent *event)
 {
-  GdkEventPadAxis *event = g_new0 (GdkEventPadAxis, 1);
+  g_return_val_if_fail (event->any.type == GDK_FOCUS_CHANGE, FALSE);
 
-  event->any.ref_count = 1;
-  event->any.type = GDK_PAD_RING;
-  event->any.surface = g_object_ref (surface);
-  event->any.device = g_object_ref (device);
-  event->any.source_device = g_object_ref (source_device);
-  event->time = time;
-  event->group = group;
-  event->index = index;
-  event->mode = mode;
-  event->value = value;
+  return event->focus_change.in;
+}
 
-  return (GdkEvent *)event;
+GdkScrollDirection
+gdk_scroll_event_get_direction (GdkEvent *event)
+{
+  g_return_val_if_fail (event->any.type == GDK_SCROLL, 0);
+
+  return event->scroll.direction;
 }
 
-GdkEvent *
-gdk_event_pad_strip_new (GdkSurface *surface,
-                         GdkDevice  *device,
-                         GdkDevice  *source_device,
-                         guint32     time,
-                         guint       group,
-                         guint       index,
-                         guint       mode,
-                         double      value)
+void
+gdk_scroll_event_get_deltas (GdkEvent *event,
+                             double   *delta_x,
+                             double   *delta_y)
 {
-  GdkEventPadAxis *event = g_new0 (GdkEventPadAxis, 1);
+  g_return_if_fail (event->any.type == GDK_SCROLL);
 
-  event->any.ref_count = 1;
-  event->any.type = GDK_PAD_STRIP;
-  event->any.surface = g_object_ref (surface);
-  event->any.device = g_object_ref (device);
-  event->any.source_device = g_object_ref (source_device);
-  event->time = time;
-  event->group = group;
-  event->index = index;
-  event->mode = mode;
-  event->value = value;
+  *delta_x = event->scroll.delta_x;
+  *delta_y = event->scroll.delta_y;
+}
 
-  return (GdkEvent *)event;
+/**
+ * gdk_scroll_event_is_stop:
+ * @event: a scroll event
+ *
+ * Check whether a scroll event is a stop scroll event. Scroll sequences
+ * with smooth scroll information may provide a stop scroll event once the
+ * interaction with the device finishes, e.g. by lifting a finger. This
+ * stop scroll event is the signal that a widget may trigger kinetic
+ * scrolling based on the current velocity.
+ *
+ * Stop scroll events always have a delta of 0/0.
+ *
+ * Returns: %TRUE if the event is a scroll stop event
+ */
+gboolean
+gdk_scroll_event_is_stop (GdkEvent *event)
+{
+  g_return_val_if_fail (event->any.type == GDK_SCROLL, FALSE);
+
+  return event->scroll.is_stop;
 }
 
-GdkEvent *
-gdk_event_pad_button_new (GdkEventType  type,
-                          GdkSurface   *surface,
-                          GdkDevice    *device,
-                          GdkDevice    *source_device,
-                          guint32       time,
-                          guint         group,
-                          guint         button,
-                          guint         mode)
+/**
+ * gdk_touchpad_event_get_gesture_phase:
+ * @event: a touchpad #GdkEvent
+ *
+ * Extracts the touchpad gesture phase from a touchpad event.
+ *
+ * Returns: the gesture phase of @event
+ **/
+GdkTouchpadGesturePhase
+gdk_touchpad_event_get_gesture_phase (GdkEvent *event)
 {
-  GdkEventPadButton *event;
+  g_return_val_if_fail (event->any.type == GDK_TOUCHPAD_PINCH ||
+                        event->any.type == GDK_TOUCHPAD_SWIPE, 0);
 
-  g_return_val_if_fail (type == GDK_PAD_BUTTON_PRESS ||
-                        type == GDK_PAD_BUTTON_RELEASE, NULL);
+  if (event->any.type == GDK_TOUCHPAD_PINCH)
+    return event->touchpad_pinch.phase;
+  else if (event->any.type == GDK_TOUCHPAD_SWIPE)
+    return event->touchpad_swipe.phase;
 
-  event = g_new0 (GdkEventPadButton, 1);
+  return 0;
+}
 
-  event->any.ref_count = 1;
-  event->any.type = type;
-  event->any.surface = g_object_ref (surface);
-  event->any.device = g_object_ref (device);
-  event->any.source_device = g_object_ref (source_device);
-  event->time = time;
-  event->group = group;
-  event->button = button;
-  event->mode = mode;
+/**
+ * gdk_touchpad_event_get_n_fingers:
+ * @event: a touchpad event
+ *
+ * Extracts the number of fingers from a touchpad event.
+ *
+ * Returns: the number of fingers for @event
+ **/
+guint
+gdk_touchpad_event_get_n_fingers (GdkEvent *event)
+{
+  g_return_val_if_fail (event->any.type == GDK_TOUCHPAD_PINCH ||
+                        event->any.type == GDK_TOUCHPAD_SWIPE, 0);
 
-  return (GdkEvent *)event;
+  if (event->any.type == GDK_TOUCHPAD_PINCH)
+    return event->touchpad_pinch.n_fingers;
+  else if (event->any.type == GDK_TOUCHPAD_SWIPE)
+    return event->touchpad_swipe.n_fingers;
+
+  return 0;
 }
 
-GdkEvent *
-gdk_event_pad_group_mode_new (GdkSurface *surface,
-                              GdkDevice  *device,
-                              GdkDevice  *source_device,
-                              guint32     time,
-                              guint       group,
-                              guint       mode)
+/**
+ * gdk_touchpad_event_get_deltas:
+ * @event: a touchpad event
+ * @dx: (out): return location for x
+ * @dy: (out): return location for y
+ *
+ * Extracts delta information from a touchpad event.
+ **/
+void
+gdk_touchpad_event_get_deltas (GdkEvent *event,
+                               double   *dx,
+                               double   *dy)
 {
-  GdkEventPadGroupMode *event = g_new0 (GdkEventPadGroupMode, 1);
+  g_return_if_fail (event->any.type == GDK_TOUCHPAD_PINCH ||
+                    event->any.type == GDK_TOUCHPAD_SWIPE);
 
-  event->any.ref_count = 1;
-  event->any.type = GDK_PAD_GROUP_MODE;
-  event->any.surface = g_object_ref (surface);
-  event->any.device = g_object_ref (device);
-  event->any.source_device = g_object_ref (source_device);
-  event->time = time;
-  event->group = group;
-  event->mode = mode;
+  if (event->any.type == GDK_TOUCHPAD_PINCH)
+    {
+      *dx = event->touchpad_pinch.dx;
+      *dy = event->touchpad_pinch.dy;
+    }
+  else if (event->any.type == GDK_TOUCHPAD_SWIPE)
+    {
+      *dx = event->touchpad_swipe.dx;
+      *dy = event->touchpad_swipe.dy;
+    }
+  else
+    {
+      *dx = NAN;
+      *dy = NAN;
+    }
+}
 
-  return (GdkEvent *)event;
+/**
+ * gdk_touchpad_pinch_event_get_angle_delta:
+ * @event: a touchpad pinch event
+ *
+ * Extracts the angle delta from a touchpad pinch event.
+ *
+ * Returns: the angle delta of @event
+ */
+double
+gdk_touchpad_pinch_event_get_angle_delta (GdkEvent *event)
+{
+  g_return_val_if_fail (event->any.type == GDK_TOUCHPAD_PINCH, 0);
+
+  return event->touchpad_pinch.angle_delta;
 }
 
-GdkEvent *
-gdk_event_drag_new (GdkEventType  type,
-                    GdkSurface   *surface,
-                    GdkDevice    *device,
-                    GdkDrop      *drop,
-                    guint32       time,
-                    double        x,
-                    double        y)
+/**
+ * gdk_touchpad_pinch_event_get_scale:
+ * @event: a touchpad pinch event
+ *
+ * Extracts the scale from a touchpad pinch event.
+ *
+ * Returns: the scale of @event
+ **/
+double
+gdk_touchpad_pinch_event_get_scale (GdkEvent *event)
 {
-  GdkEventDND *event;
+  g_return_val_if_fail (event->any.type == GDK_TOUCHPAD_PINCH, 0);
 
-  g_return_val_if_fail (type == GDK_DRAG_ENTER ||
-                        type == GDK_DRAG_MOTION ||
-                        type == GDK_DRAG_LEAVE ||
-                        type == GDK_DROP_START, NULL);
+  return event->touchpad_pinch.scale;
+}
 
-  event = g_new0 (GdkEventDND, 1);
+/**
+ * gdk_pad_button_event_get_button:
+ * @event: a pad button event
+ *
+ * Extracts information about the pressed button from
+ * a pad event.
+ *
+ * Returns: the button of @event
+ **/
+guint
+gdk_pad_button_event_get_button (GdkEvent *event)
+{
+  g_return_val_if_fail (event->any.type == GDK_PAD_BUTTON_PRESS ||
+                        event->any.type == GDK_PAD_BUTTON_RELEASE, 0);
 
-  event->any.ref_count = 1;
-  event->any.type = type;
-  event->any.surface = g_object_ref (surface);
-  event->any.device = g_object_ref (device);
-  event->drop = g_object_ref (drop);
-  event->time = time;
-  event->x = x;
-  event->y = y;
+  return  event->pad_button.button;
+}
 
-  return (GdkEvent *)event;
+/**
+ * gdk_pad_axis_event_get_value:
+ * @event: a pad strip or ring event
+ * @index: (out): Return location for the axis index
+ * @value: (out): Return location for the axis value
+ *
+ * Extracts the information from a pad strip or ring event.
+ **/
+void
+gdk_pad_axis_event_get_value (GdkEvent       *event,
+                              guint          *index,
+                              gdouble        *value)
+{
+  g_return_if_fail (event->any.type == GDK_PAD_RING ||
+                    event->any.type == GDK_PAD_STRIP);
+
+  *index = event->pad_axis.index;
+  *value = event->pad_axis.value;
 }
 
-GdkEvent *
-gdk_event_grab_broken_new (GdkSurface *surface,
-                           GdkDevice  *device,
-                           GdkDevice  *source_device,
-                           GdkSurface *grab_surface,
-                           gboolean    implicit)
+/**
+ * gdk_pad_event_group_mode:
+ * @event: a pad event
+ * @group: (out): return location for the group
+ * @mode: (out): return location for the mode
+ *
+ * Extracts group and mode information from a pad event.
+ **/
+void
+gdk_pad_event_get_group_mode (GdkEvent *event,
+                              guint    *group,
+                              guint    *mode)
 {
-  GdkEventGrabBroken *event = g_new0 (GdkEventGrabBroken, 1);
+  g_return_if_fail (event->any.type == GDK_PAD_GROUP_MODE ||
+                    event->any.type == GDK_PAD_BUTTON_PRESS ||
+                    event->any.type == GDK_PAD_BUTTON_RELEASE ||
+                    event->any.type == GDK_PAD_RING ||
+                    event->any.type == GDK_PAD_STRIP);
 
-  event->any.ref_count = 1;
-  event->any.type = GDK_GRAB_BROKEN;
-  event->any.surface = g_object_ref (surface);
-  event->any.device = g_object_ref (device);
-  event->any.source_device = g_object_ref (source_device);
-  event->grab_surface = grab_surface;
-  event->implicit = implicit;
-  event->keyboard = gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD;
+  switch ((guint)event->any.type)
+    {
+    case GDK_PAD_GROUP_MODE:
+      *group = event->pad_group_mode.group;
+      *mode = event->pad_group_mode.mode;
+      break;
+    case GDK_PAD_BUTTON_PRESS:
+    case GDK_PAD_BUTTON_RELEASE:
+      *group = event->pad_button.group;
+      *mode = event->pad_button.mode;
+      break;
+    case GDK_PAD_RING:
+    case GDK_PAD_STRIP:
+      *group = event->pad_axis.group;
+      *mode = event->pad_axis.mode;
+      break;
+    default:
+      g_assert_not_reached ();
+    }
+}
 
-  return (GdkEvent *)event;
+/**
+ * gdk_drag_event_get_drop:
+ * @event: a DND event
+ *
+ * Gets the #GdkDrop from a DND event.
+ *
+ * Returns: (transfer none) (nullable): the drop
+ **/
+GdkDrop *
+gdk_drag_event_get_drop (GdkEvent *event)
+{
+  g_return_val_if_fail (event->any.type == GDK_DRAG_ENTER ||
+                        event->any.type == GDK_DRAG_LEAVE ||
+                        event->any.type == GDK_DRAG_MOTION ||
+                        event->any.type == GDK_DROP_START, NULL);
+
+  return event->dnd.drop;
+}
+
+/**
+ * gdk_grab_broken_event_get_grab_surface:
+ * @event: a grab broken event
+ *
+ * Extracts the grab surface from a grab broken event.
+ *
+ * Returns: the grab surface of @event
+ **/
+GdkSurface *
+gdk_grab_broken_event_get_grab_surface (GdkEvent *event)
+{
+  g_return_val_if_fail (event->any.type == GDK_GRAB_BROKEN, NULL);
+
+  return event->grab_broken.grab_surface;
 }
diff --git a/gdk/gdkevents.h b/gdk/gdkevents.h
index b574044ccd..6b4baf6821 100644
--- a/gdk/gdkevents.h
+++ b/gdk/gdkevents.h
@@ -330,164 +330,137 @@ typedef enum
 } GdkCrossingMode;
 
 GDK_AVAILABLE_IN_ALL
-GType     gdk_event_get_type            (void) G_GNUC_CONST;
+GType                   gdk_event_get_type              (void) G_GNUC_CONST;
 
 GDK_AVAILABLE_IN_ALL
-GType     gdk_event_sequence_get_type   (void) G_GNUC_CONST;
+GType                   gdk_event_sequence_get_type     (void) G_GNUC_CONST;
 
 GDK_AVAILABLE_IN_ALL
-GdkEvent * gdk_event_ref   (GdkEvent *event);
+GdkEvent *              gdk_event_ref                   (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-void       gdk_event_unref (GdkEvent *event);
+void                    gdk_event_unref                 (GdkEvent *event);
 
 GDK_AVAILABLE_IN_ALL
-GdkSurface *gdk_event_get_surface       (GdkEvent       *event);
+GdkEventType            gdk_event_get_event_type        (GdkEvent *event);
 
 GDK_AVAILABLE_IN_ALL
-guint32   gdk_event_get_time            (GdkEvent        *event);
-GDK_AVAILABLE_IN_ALL
-gboolean  gdk_event_get_state           (GdkEvent        *event,
-                                         GdkModifierType *state);
-GDK_AVAILABLE_IN_ALL
-gboolean  gdk_event_get_coords         (GdkEvent        *event,
-                                        gdouble         *x_win,
-                                        gdouble         *y_win);
-GDK_AVAILABLE_IN_ALL
-gboolean  gdk_event_get_button          (GdkEvent       *event,
-                                         guint          *button);
-GDK_AVAILABLE_IN_ALL
-gboolean  gdk_event_get_click_count     (GdkEvent       *event,
-                                         guint          *click_count);
+GdkSurface *            gdk_event_get_surface           (GdkEvent *event);
+
 GDK_AVAILABLE_IN_ALL
-gboolean  gdk_event_get_keyval          (GdkEvent       *event,
-                                         guint          *keyval);
+GdkDevice *             gdk_event_get_device            (GdkEvent *event);
 
 GDK_AVAILABLE_IN_ALL
-gboolean  gdk_event_get_keycode         (GdkEvent       *event,
-                                         guint16        *keycode);
+GdkDevice *             gdk_event_get_source_device     (GdkEvent *event);
+
 GDK_AVAILABLE_IN_ALL
-gboolean  gdk_event_get_key_is_modifier (GdkEvent       *event,
-                                         gboolean       *is_modifier);
+GdkDeviceTool *         gdk_event_get_device_tool       (GdkEvent *event);
+
 GDK_AVAILABLE_IN_ALL
-gboolean  gdk_event_get_key_group       (GdkEvent       *event,
-                                         guint          *group);
+guint32                 gdk_event_get_time              (GdkEvent *event);
 
 GDK_AVAILABLE_IN_ALL
-gboolean gdk_event_get_scroll_direction (GdkEvent       *event,
-                                         GdkScrollDirection *direction);
+GdkDisplay *            gdk_event_get_display           (GdkEvent *event);
+
 GDK_AVAILABLE_IN_ALL
-gboolean  gdk_event_get_scroll_deltas   (GdkEvent       *event,
-                                         gdouble         *delta_x,
-                                         gdouble         *delta_y);
+GdkEventSequence *      gdk_event_get_event_sequence    (GdkEvent *event);
 
 GDK_AVAILABLE_IN_ALL
-gboolean  gdk_event_is_scroll_stop_event (GdkEvent       *event);
+GdkModifierType         gdk_event_get_modifier_state    (GdkEvent *event);
 
 GDK_AVAILABLE_IN_ALL
-gboolean  gdk_event_get_axis            (GdkEvent        *event,
-                                         GdkAxisUse       axis_use,
-                                         gdouble         *value);
+gboolean                gdk_event_get_position          (GdkEvent  *event,
+                                                        double    *x,
+                                                        double    *y);
 GDK_AVAILABLE_IN_ALL
-GdkDevice* gdk_event_get_device         (GdkEvent        *event);
+gboolean                gdk_event_get_axes              (GdkEvent  *event,
+                                                         double   **axes,
+                                                         guint     *n_axes);
 GDK_AVAILABLE_IN_ALL
-GdkDevice* gdk_event_get_source_device  (GdkEvent        *event);
+gboolean                gdk_event_get_axis              (GdkEvent   *event,
+                                                         GdkAxisUse  axis_use,
+                                                         double     *value);
 GDK_AVAILABLE_IN_ALL
-gboolean   gdk_event_triggers_context_menu (GdkEvent       *event);
+gboolean                gdk_event_get_pointer_emulated (GdkEvent *event);
 
 GDK_AVAILABLE_IN_ALL
-gboolean  gdk_events_get_distance       (GdkEvent        *event1,
-                                         GdkEvent        *event2,
-                                         gdouble         *distance);
+guint                   gdk_button_event_get_button     (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-gboolean  gdk_events_get_angle          (GdkEvent        *event1,
-                                         GdkEvent        *event2,
-                                         gdouble         *angle);
+GdkScrollDirection      gdk_scroll_event_get_direction  (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-gboolean  gdk_events_get_center         (GdkEvent        *event1,
-                                         GdkEvent        *event2,
-                                         gdouble         *x,
-                                         gdouble         *y);
+void                    gdk_scroll_event_get_deltas     (GdkEvent *event,
+                                                         double   *delta_x,
+                                                         double   *delta_y);
 GDK_AVAILABLE_IN_ALL
-GdkDisplay *gdk_event_get_display       (GdkEvent        *event);
-
+gboolean                gdk_scroll_event_is_stop        (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-GdkEventSequence *gdk_event_get_event_sequence (GdkEvent       *event);
-
+guint                   gdk_key_event_get_keyval        (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-GdkEventType gdk_event_get_event_type   (GdkEvent       *event);
-
+guint                   gdk_key_event_get_keycode       (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-GdkSeat  *gdk_event_get_seat            (GdkEvent       *event);
-
+guint                   gdk_key_event_get_scancode      (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-void     gdk_set_show_events           (gboolean        show_events);
+guint                   gdk_key_event_get_group         (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-gboolean  gdk_get_show_events          (void);
-
+gboolean                gdk_key_event_is_modifier       (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-GdkDeviceTool *gdk_event_get_device_tool (GdkEvent       *event);
-
+gboolean                gdk_focus_event_get_in          (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-int            gdk_event_get_scancode    (GdkEvent *event);
-
+gboolean                gdk_touch_event_get_emulating_pointer (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-gboolean       gdk_event_get_pointer_emulated (GdkEvent *event);
-
+GdkCrossingMode         gdk_crossing_event_get_mode     (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-gboolean       gdk_event_is_sent       (GdkEvent       *event);
-
+GdkNotifyType           gdk_crossing_event_get_detail   (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-GdkDrop *      gdk_event_get_drop (GdkEvent        *event);
-
+void                    gdk_configure_event_get_size    (GdkEvent *event,
+                                                         int      *width,
+                                                         int      *height);
 GDK_AVAILABLE_IN_ALL
-gboolean       gdk_event_get_crossing_mode (GdkEvent        *event,
-                                            GdkCrossingMode *mode);
+GdkTouchpadGesturePhase
+                        gdk_touchpad_event_get_gesture_phase (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-gboolean       gdk_event_get_crossing_detail (GdkEvent       *event,
-                                              GdkNotifyType  *detail);
+guint                   gdk_touchpad_event_get_n_fingers     (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-gboolean       gdk_event_get_touchpad_gesture_phase (GdkEvent                *event,
-                                                     GdkTouchpadGesturePhase *phase);
+void                    gdk_touchpad_event_get_deltas        (GdkEvent *event,
+                                                              double   *dx,
+                                                              double   *dy);
 GDK_AVAILABLE_IN_ALL
-gboolean       gdk_event_get_touchpad_gesture_n_fingers (GdkEvent       *event,
-                                                         guint          *n_fingers);
+double                  gdk_touchpad_pinch_event_get_angle_delta (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-gboolean       gdk_event_get_touchpad_deltas (GdkEvent       *event,
-                                              double         *dx,
-                                              double         *dy);
+double                  gdk_touchpad_pinch_event_get_scale       (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-gboolean       gdk_event_get_touchpad_angle_delta (GdkEvent       *event,
-                                                   double         *delta);
+guint                   gdk_pad_button_event_get_button  (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-gboolean       gdk_event_get_touchpad_scale (GdkEvent       *event,
-                                             double         *scale);
-
+void                    gdk_pad_axis_event_get_value     (GdkEvent *event,
+                                                          guint    *index,
+                                                          double   *value);
 GDK_AVAILABLE_IN_ALL
-gboolean       gdk_event_get_touch_emulating_pointer (GdkEvent       *event,
-                                                      gboolean       *emulating);
+void                    gdk_pad_event_get_group_mode (GdkEvent *event,
+                                                      guint    *group,
+                                                      guint    *mode);
 GDK_AVAILABLE_IN_ALL
-gboolean       gdk_event_get_grab_surface (GdkEvent        *event,
-                                           GdkSurface      **surface);
+GdkDrop *               gdk_drag_event_get_drop (GdkEvent *event);
 GDK_AVAILABLE_IN_ALL
-gboolean       gdk_event_get_focus_in (GdkEvent       *event,
-                                       gboolean       *focus_in);
+GdkSurface *            gdk_grab_broken_event_get_grab_surface (GdkEvent *event);
+
 GDK_AVAILABLE_IN_ALL
-gboolean       gdk_event_get_pad_group_mode (GdkEvent       *event,
-                                             guint          *group,
-                                             guint          *mode);
+GList *                 gdk_event_get_motion_history    (GdkEvent *event);
+
 GDK_AVAILABLE_IN_ALL
-gboolean       gdk_event_get_pad_button (GdkEvent       *event,
-                                         guint          *button);
+gboolean                gdk_event_triggers_context_menu (GdkEvent *event);
+
 GDK_AVAILABLE_IN_ALL
-gboolean       gdk_event_get_pad_axis_value (GdkEvent       *event,
-                                             guint          *index,
-                                             gdouble        *value);
+gboolean                gdk_events_get_distance         (GdkEvent *event1,
+                                                         GdkEvent *event2,
+                                                         double   *distance);
 GDK_AVAILABLE_IN_ALL
-gboolean       gdk_event_get_axes      (GdkEvent  *event,
-                                        gdouble  **axes,
-                                        guint     *n_axes);
+gboolean                gdk_events_get_angle            (GdkEvent *event1,
+                                                         GdkEvent *event2,
+                                                         double   *angle);
 GDK_AVAILABLE_IN_ALL
-GList        * gdk_event_get_motion_history (GdkEvent        *event);
+gboolean                gdk_events_get_center           (GdkEvent *event1,
+                                                         GdkEvent *event2,
+                                                         double   *x,
+                                                         double   *y);
 
 G_END_DECLS
 
diff --git a/gdk/gdkeventsprivate.h b/gdk/gdkeventsprivate.h
index cb2cfea839..c8006961c2 100644
--- a/gdk/gdkeventsprivate.h
+++ b/gdk/gdkeventsprivate.h
@@ -521,55 +521,9 @@ struct _GdkEventPadGroupMode {
 
 /*
  * GdkEvent:
- * @type: the #GdkEventType
- * @any: a #GdkEventAny
- * @motion: a #GdkEventMotion
- * @button: a #GdkEventButton
- * @touch: a #GdkEventTouch
- * @scroll: a #GdkEventScroll
- * @key: a #GdkEventKey
- * @crossing: a #GdkEventCrossing
- * @focus_change: a #GdkEventFocus
- * @configure: a #GdkEventConfigure
- * @proximity: a #GdkEventProximity
- * @dnd: a #GdkEventDND
- * @grab_broken: a #GdkEventGrabBroken
- * @touchpad_swipe: a #GdkEventTouchpadSwipe
- * @touchpad_pinch: a #GdkEventTouchpadPinch
- * @pad_button: a #GdkEventPadButton
- * @pad_axis: a #GdkEventPadAxis
- * @pad_group_mode: a #GdkEventPadGroupMode
  *
- * A #GdkEvent contains a union of all of the event types,
- * and allows access to the data fields in a number of ways.
- *
- * The event type is always the first field in all of the event types, and
- * can always be accessed with the following code, no matter what type of
- * event it is:
- * |[<!-- language="C" -->
- *   GdkEvent *event;
- *   GdkEventType type;
- *
- *   type = event->type;
- * ]|
- *
- * To access other fields of the event, the pointer to the event
- * can be cast to the appropriate event type, or the union member
- * name can be used. For example if the event type is %GDK_BUTTON_PRESS
- * then the x coordinate of the button press can be accessed with:
- * |[<!-- language="C" -->
- *   GdkEvent *event;
- *   gdouble x;
- *
- *   x = ((GdkEventButton*)event)->x;
- * ]|
- * or:
- * |[<!-- language="C" -->
- *   GdkEvent *event;
- *   gdouble x;
- *
- *   x = event->button.x;
- * ]|
+ * The GdkEvent struct is private and should only be accessed
+ * using the accessor functions.
  */
 union _GdkEvent
 {
diff --git a/gdk/gdkkeys.c b/gdk/gdkkeys.c
index a60a33be3e..25e9284e3c 100644
--- a/gdk/gdkkeys.c
+++ b/gdk/gdkkeys.c
@@ -559,11 +559,14 @@ gdk_keymap_lookup_key (GdkKeymap          *keymap,
  * |[<!-- language="C" -->
  * // We want to ignore irrelevant modifiers like ScrollLock
  * #define ALL_ACCELS_MASK (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK)
- * gdk_keymap_translate_keyboard_state (keymap, event->hardware_keycode,
- *                                      event->state, event->group,
+ * state = gdk_event_get_modifier_state (event);
+ * gdk_keymap_translate_keyboard_state (keymap,
+ *                                      gdk_key_event_get_keycode (event),
+ *                                      state,
+ *                                      gdk_key_event_get_group (event),
  *                                      &keyval, NULL, NULL, &consumed);
  * if (keyval == GDK_PLUS &&
- *     (event->state & ~consumed & ALL_ACCELS_MASK) == GDK_CONTROL_MASK)
+ *     (state & ~consumed & ALL_ACCELS_MASK) == GDK_CONTROL_MASK)
  *   // Control was pressed
  * ]|
  * 
@@ -574,7 +577,7 @@ gdk_keymap_lookup_key (GdkKeymap          *keymap,
  * |[<!-- language="C" -->
  * // XXX Don’t do this XXX
  * if (keyval == accel_keyval &&
- *     (event->state & ~consumed & ALL_ACCELS_MASK) == (accel_mods & ~consumed))
+ *     (state & ~consumed & ALL_ACCELS_MASK) == (accel_mods & ~consumed))
  *   // Accelerator was pressed
  * ]|
  *
diff --git a/gdk/gdksurface.c b/gdk/gdksurface.c
index 1ad61e5ef3..976327e317 100644
--- a/gdk/gdksurface.c
+++ b/gdk/gdksurface.c
@@ -2689,6 +2689,7 @@ _gdk_windowing_got_event (GdkDisplay *display,
   GdkDeviceGrabInfo *button_release_grab;
   GdkPointerSurfaceInfo *pointer_info = NULL;
   GdkDevice *device, *source_device;
+  GdkEventType type;
 
   _gdk_display_update_last_event (display, event);
 
@@ -2722,21 +2723,21 @@ _gdk_windowing_got_event (GdkDisplay *display,
         }
     }
 
-  event_surface = event->any.surface;
+  event_surface = gdk_event_get_surface (event);
   if (!event_surface)
     goto out;
 
-  if (event->any.type == GDK_ENTER_NOTIFY)
+  type = gdk_event_get_event_type (event);
+  if (type == GDK_ENTER_NOTIFY)
     _gdk_display_set_surface_under_pointer (display, device, event_surface);
-  else if (event->any.type == GDK_LEAVE_NOTIFY)
+  else if (type == GDK_LEAVE_NOTIFY)
     _gdk_display_set_surface_under_pointer (display, device, NULL);
 
-  if ((event->any.type == GDK_BUTTON_RELEASE ||
-       event->any.type == GDK_TOUCH_CANCEL ||
-       event->any.type == GDK_TOUCH_END) &&
-      !event->any.send_event)
+  if (type == GDK_BUTTON_RELEASE ||
+      type == GDK_TOUCH_CANCEL ||
+      type == GDK_TOUCH_END)
     {
-      if (event->any.type == GDK_BUTTON_RELEASE ||
+      if (type == GDK_BUTTON_RELEASE ||
           gdk_event_get_pointer_emulated (event))
         {
           button_release_grab =
@@ -2744,7 +2745,7 @@ _gdk_windowing_got_event (GdkDisplay *display,
 
           if (button_release_grab &&
               button_release_grab->implicit &&
-              (event->button.state & GDK_ANY_BUTTON_MASK & ~(GDK_BUTTON1_MASK << (event->button.button - 
1))) == 0)
+              (gdk_event_get_modifier_state (event) & GDK_ANY_BUTTON_MASK & ~(GDK_BUTTON1_MASK << 
(gdk_button_event_get_button (event) - 1))) == 0)
             {
               button_release_grab->serial_end = serial;
               button_release_grab->implicit_ungrab = FALSE;
@@ -4009,16 +4010,29 @@ is_key_event (GdkEvent *event)
   return FALSE;
 }
 
-static void
+static GdkEvent *
 rewrite_event_for_toplevel (GdkEvent *event)
 {
   GdkSurface *surface;
 
   surface = gdk_event_get_surface (event);
+  if (!surface->parent)
+    return gdk_event_ref (event);
+
   while (surface->parent)
     surface = surface->parent;
 
-  g_set_object (&event->any.surface, surface);
+  return gdk_event_key_new (gdk_event_get_event_type (event),
+                            surface,
+                            gdk_event_get_device (event),
+                            gdk_event_get_source_device (event),
+                            gdk_event_get_time (event),
+                            gdk_event_get_modifier_state (event),
+                            gdk_key_event_get_keyval (event),
+                            gdk_key_event_get_keycode (event),
+                            gdk_key_event_get_scancode (event),
+                            gdk_key_event_get_group (event),
+                            gdk_key_event_is_modifier (event));
 }
 
 static void
@@ -4039,49 +4053,44 @@ add_event_mark (GdkEvent *event,
     {
     case GDK_MOTION_NOTIFY:
       {
-        GdkEventMotion *motion = (GdkEventMotion *)event;
+        double x, y;
+        gdk_event_get_position (event, &x, &y);
         message = g_strdup_printf ("{x=%lf, y=%lf, state=0x%x}",
-                                   motion->x, motion->y, motion->state);
+                                   x, y,
+                                   gdk_event_get_modifier_state (event));
         break;
       }
 
     case GDK_BUTTON_PRESS:
-      {
-        GdkEventButton *button = (GdkEventButton *)event;
-        message = g_strdup_printf ("{button=%u, x=%lf, y=%lf, state=0x%x}",
-                                   button->button, button->x, button->y, button->state);
-        break;
-      }
-
     case GDK_BUTTON_RELEASE:
       {
-        GdkEventButton *button = (GdkEventButton *)event;
+        double x, y;
+        gdk_event_get_position (event, &x, &y);
         message = g_strdup_printf ("{button=%u, x=%lf, y=%lf, state=0x%x}",
-                                   button->button, button->x, button->y, button->state);
+                                   gdk_button_event_get_button (event),
+                                   x, y,
+                                   gdk_event_get_modifier_state (event));
         break;
       }
 
     case GDK_KEY_PRESS:
-      {
-        GdkEventKey *key = (GdkEventKey *)event;
-        message = g_strdup_printf ("{keyval=%u, state=0x%x, hardware_keycode=%u key_scancode=%u group=%u 
is_modifier=%u}",
-                                   key->keyval, key->state, key->hardware_keycode, key->key_scancode, 
key->group, key->is_modifier);
-        break;
-      }
-
     case GDK_KEY_RELEASE:
       {
-        GdkEventKey *key = (GdkEventKey *)event;
         message = g_strdup_printf ("{keyval=%u, state=0x%x, hardware_keycode=%u key_scancode=%u group=%u 
is_modifier=%u}",
-                                   key->keyval, key->state, key->hardware_keycode, key->key_scancode, 
key->group, key->is_modifier);
+                                   gdk_key_event_get_keyval (event),
+                                   gdk_event_get_modifier_state (event),
+                                   gdk_key_event_get_keycode (event),
+                                   gdk_key_event_get_scancode (event),
+                                   gdk_key_event_get_group (event),
+                                   gdk_key_event_is_modifier (event));
         break;
       }
 
     case GDK_CONFIGURE:
       {
-        GdkEventConfigure *config = (GdkEventConfigure *)event;
-        message = g_strdup_printf ("{x=%d, y=%d, width=%d, height=%d}",
-                                   config->x, config->y, config->width, config->height);
+        int width, height;
+        gdk_configure_event_get_size (event, &width, &height);
+        message = g_strdup_printf ("{width=%d, height=%d}", width, height);
         break;
       }
 
@@ -4141,9 +4150,15 @@ gdk_surface_handle_event (GdkEvent *event)
     }
   else
     {
+      GdkEvent *emitted;
+
       if (is_key_event (event))
-        rewrite_event_for_toplevel (event);
-      g_signal_emit (gdk_event_get_surface (event), signals[EVENT], 0, event, &handled);
+        emitted = rewrite_event_for_toplevel (event);
+      else
+        emitted = gdk_event_ref (event);
+
+      g_signal_emit (gdk_event_get_surface (emitted), signals[EVENT], 0, emitted, &handled);
+      gdk_event_unref (emitted);
     }
 
   if (GDK_PROFILER_IS_RUNNING)
diff --git a/gdk/wayland/gdkdevice-wayland.c b/gdk/wayland/gdkdevice-wayland.c
index 82e34ab47a..bdaae4cd0f 100644
--- a/gdk/wayland/gdkdevice-wayland.c
+++ b/gdk/wayland/gdkdevice-wayland.c
@@ -1478,7 +1478,7 @@ gdk_wayland_seat_set_frame_event (GdkWaylandSeat *seat,
                                   GdkEvent       *event)
 {
   if (seat->pointer_info.frame.event &&
-      seat->pointer_info.frame.event->any.type != event->any.type)
+      gdk_event_get_event_type (seat->pointer_info.frame.event) != gdk_event_get_event_type (event))
     gdk_wayland_seat_flush_frame_event (seat);
 
   seat->pointer_info.frame.event = event;
@@ -1612,10 +1612,13 @@ pointer_handle_motion (void              *data,
                                 NULL);
   gdk_wayland_seat_set_frame_event (seat, event);
 
-  GDK_SEAT_NOTE (seat, EVENTS,
-            g_message ("motion %f %f, seat %p state %d",
-                       event->motion.x, event->motion.y,
-                      seat, event->motion.state));
+  if (GDK_DISPLAY_DEBUG_CHECK (gdk_seat_get_display (GDK_SEAT (seat)), EVENTS))
+    {
+      double x, y;
+      gdk_event_get_position (event, &x, &y);
+      g_message ("motion %f %f, seat %p state %d",
+                 x, y, seat, gdk_event_get_modifier_state (event));
+    }
 
   if (display->seat_version < WL_POINTER_HAS_FRAME)
     gdk_wayland_seat_flush_frame_event (seat);
@@ -1683,10 +1686,10 @@ pointer_handle_button (void              *data,
 
   GDK_SEAT_NOTE (seat, EVENTS,
            g_message ("button %d %s, seat %p state %d",
-                      event->button.button,
+                      gdk_button_event_get_button (event),
                       state ? "press" : "release",
                        seat,
-                       event->button.state));
+                       gdk_event_get_modifier_state (event)));
 
   if (display->seat_version < WL_POINTER_HAS_FRAME)
     gdk_wayland_seat_flush_frame_event (seat);
@@ -1950,7 +1953,7 @@ keyboard_handle_leave (void               *data,
 
   GDK_SEAT_NOTE (seat, EVENTS,
             g_message ("focus out, seat %p surface %p",
-                       seat, event->any.surface));
+                       seat, gdk_event_get_surface (event)));
 
   _gdk_wayland_display_deliver_event (seat->display, event);
 }
@@ -2048,9 +2051,10 @@ deliver_key_event (GdkWaylandSeat *seat,
                        "mods 0x%x",
                        (state ? "press" : "release"),
                        (from_key_repeat ? " (repeat)" : ""),
-                       event->any.surface,
-                       event->key.hardware_keycode, event->key.keyval,
-                       event->key.state));
+                       gdk_event_get_surface (event),
+                       gdk_key_event_get_keycode (event),
+                       gdk_key_event_get_keyval (event),
+                       gdk_event_get_modifier_state (event)));
 
   if (!xkb_keymap_key_repeats (xkb_keymap, key))
     return;
@@ -2304,8 +2308,12 @@ touch_handle_down (void              *data,
       mimic_pointer_emulating_touch_info (seat->touch_master, touch);
     }
 
-  GDK_SEAT_NOTE (seat, EVENTS,
-            g_message ("touch begin %f %f", event->touch.x, event->touch.y));
+  if (GDK_DISPLAY_DEBUG_CHECK (gdk_seat_get_display (GDK_SEAT (seat)), EVENTS))
+    {
+      double xx, yy;
+      gdk_event_get_position (event, &xx, &yy);
+      g_message ("touch begin %f %f", xx, yy);
+    }
 
   _gdk_wayland_display_deliver_event (seat->display, event);
 }
@@ -2336,8 +2344,12 @@ touch_handle_up (void            *data,
                                NULL,
                                touch->initial_touch);
 
-  GDK_SEAT_NOTE (seat, EVENTS,
-            g_message ("touch end %f %f", event->touch.x, event->touch.y));
+  if (GDK_DISPLAY_DEBUG_CHECK (gdk_seat_get_display (GDK_SEAT (seat)), EVENTS))
+    {
+      double x, y;
+      gdk_event_get_position (event, &x, &y);
+      g_message ("touch end %f %f", x, y);
+    }
 
   _gdk_wayland_display_deliver_event (seat->display, event);
 
@@ -2377,8 +2389,12 @@ touch_handle_motion (void            *data,
                                NULL,
                                touch->initial_touch);
 
-  GDK_SEAT_NOTE (seat, EVENTS,
-            g_message ("touch update %f %f", event->touch.x, event->touch.y));
+  if (GDK_DISPLAY_DEBUG_CHECK (gdk_seat_get_display (GDK_SEAT (seat)), EVENTS))
+    {
+      double xx, yy;
+      gdk_event_get_position (event, &xx, &yy);
+      g_message ("touch update %f %f", xx, yy);
+    }
 
   _gdk_wayland_display_deliver_event (seat->display, event);
 }
@@ -2451,11 +2467,14 @@ emit_gesture_swipe_event (GdkWaylandSeat          *seat,
                                         n_fingers,
                                         dx, dy);
 
-  GDK_SEAT_NOTE (seat, EVENTS,
-            g_message ("swipe event %d, coords: %f %f, seat %p state %d",
-                       event->any.type, event->touchpad_swipe.x,
-                       event->touchpad_swipe.y, seat,
-                       event->touchpad_swipe.state));
+  if (GDK_DISPLAY_DEBUG_CHECK (gdk_seat_get_display (GDK_SEAT (seat)), EVENTS))
+    {
+      double x, y;
+      gdk_event_get_position (event, &x, &y);
+      g_message ("swipe event %d, coords: %f %f, seat %p state %d",
+                 gdk_event_get_event_type (event), x, y, seat,
+                 gdk_event_get_modifier_state (event));
+    }
 
   _gdk_wayland_display_deliver_event (seat->display, event);
 }
@@ -2546,11 +2565,15 @@ emit_gesture_pinch_event (GdkWaylandSeat          *seat,
                                         dx, dy,
                                         scale, angle_delta * G_PI / 180);
 
-  GDK_SEAT_NOTE (seat, EVENTS,
-            g_message ("pinch event %d, coords: %f %f, seat %p state %d",
-                       event->any.type, event->touchpad_pinch.x,
-                       event->touchpad_pinch.y, seat,
-                       event->touchpad_pinch.state));
+  if (GDK_DISPLAY_DEBUG_CHECK (gdk_seat_get_display (GDK_SEAT (seat)), EVENTS))
+    {
+      double x, y;
+      gdk_event_get_position (event, &x, &y);
+      g_message ("pinch event %d, coords: %f %f, seat %p state %d",
+                       gdk_event_get_event_type (event),
+                       x, y, seat,
+                       gdk_event_get_modifier_state (event));
+    }
 
   _gdk_wayland_display_deliver_event (seat->display, event);
 }
@@ -3217,6 +3240,7 @@ gdk_wayland_tablet_flush_frame_event (GdkWaylandTabletData *tablet,
                                       guint32               time)
 {
   GdkEvent *event;
+  GdkEventType type;
 
   event = tablet->pointer_info.frame.event;
   tablet->pointer_info.frame.event = NULL;
@@ -3226,16 +3250,18 @@ gdk_wayland_tablet_flush_frame_event (GdkWaylandTabletData *tablet,
 
   gdk_event_ref (event);
 
-  if (event->any.type == GDK_PROXIMITY_OUT)
-    emulate_crossing (event->any.surface, NULL,
+  type = gdk_event_get_event_type (event);
+
+  if (type == GDK_PROXIMITY_OUT)
+    emulate_crossing (gdk_event_get_surface (event), NULL,
                       tablet->master, GDK_LEAVE_NOTIFY,
                       GDK_CROSSING_NORMAL, time);
 
   _gdk_wayland_display_deliver_event (gdk_seat_get_display (tablet->seat),
                                       event);
 
-  if (event->any.type == GDK_PROXIMITY_IN)
-    emulate_crossing (event->any.surface, NULL,
+  if (type == GDK_PROXIMITY_IN)
+    emulate_crossing (gdk_event_get_surface (event), NULL,
                       tablet->master, GDK_ENTER_NOTIFY,
                       GDK_CROSSING_NORMAL, time);
 
@@ -3247,7 +3273,7 @@ gdk_wayland_tablet_set_frame_event (GdkWaylandTabletData *tablet,
                                     GdkEvent             *event)
 {
   if (tablet->pointer_info.frame.event &&
-      tablet->pointer_info.frame.event->any.type != event->any.type)
+      gdk_event_get_event_type (tablet->pointer_info.frame.event) != gdk_event_get_event_type (event))
     gdk_wayland_tablet_flush_frame_event (tablet, GDK_CURRENT_TIME);
 
   tablet->pointer_info.frame.event = event;
@@ -3703,7 +3729,7 @@ tablet_tool_handle_frame (void                      *data,
 
   frame_event = tablet->pointer_info.frame.event;
 
-  if (frame_event && frame_event->any.type == GDK_PROXIMITY_OUT)
+  if (frame_event && gdk_event_get_event_type (frame_event) == GDK_PROXIMITY_OUT)
     {
       tool->current_tablet = NULL;
       tablet->current_tool = NULL;
diff --git a/gdk/wayland/gdksurface-wayland.c b/gdk/wayland/gdksurface-wayland.c
index b340e04c86..b0220744c1 100644
--- a/gdk/wayland/gdksurface-wayland.c
+++ b/gdk/wayland/gdksurface-wayland.c
@@ -3775,7 +3775,7 @@ gdk_wayland_surface_show_window_menu (GdkSurface *surface,
 
   device = GDK_WAYLAND_DEVICE (gdk_event_get_device (event));
   seat = gdk_wayland_device_get_wl_seat (GDK_DEVICE (device));
-  gdk_event_get_coords (event, &x, &y);
+  gdk_event_get_position (event, &x, &y);
 
   serial = _gdk_wayland_device_get_implicit_grab_serial (device, event);
 
diff --git a/gdk/win32/gdkevents-win32.c b/gdk/win32/gdkevents-win32.c
index 1b8f4cae91..8980d0de26 100644
--- a/gdk/win32/gdkevents-win32.c
+++ b/gdk/win32/gdkevents-win32.c
@@ -758,13 +758,16 @@ void
 _gdk_win32_print_event (GdkEvent *event)
 {
   const char *kvname;
+  double x, y;
+  GdkCrossingMode mode;
+  GdkNotifyType detail;
+  GdkScrollDirection direction;
 
   g_print ("%s%*s===> ", (debug_indent > 0 ? "\n" : ""), debug_indent, "");
-  switch (event->any.type)
+  switch (gdk_event_get_event_type (event))
     {
 #define CASE(x) case x: g_print (#x); break;
     CASE (GDK_DELETE);
-    CASE (GDK_DESTROY);
     CASE (GDK_MOTION_NOTIFY);
     CASE (GDK_BUTTON_PRESS);
     CASE (GDK_BUTTON_RELEASE);
@@ -786,81 +789,72 @@ _gdk_win32_print_event (GdkEvent *event)
     }
 
   g_print (" %p @ %ums ",
-           event->any.surface ? GDK_SURFACE_HWND (event->any.surface) : NULL,
+           GDK_SURFACE_HWND (gdk_event_get_surface (event)),
            gdk_event_get_time (event));
 
-  switch (event->any.type)
+  switch (gdk_event_get_event_type (event))
     {
     case GDK_MOTION_NOTIFY:
-      g_print ("(%.4g,%.4g) (%.4g,%.4g)",
-              event->motion.x, event->motion.y,
-              event->motion.x_root, event->motion.y_root);
-      print_event_state (event->motion.state);
+      gdk_event_get_position (event, &x, &y);
+      g_print ("(%.4g,%.4g) ", x, y);
+      print_event_state (gdk_event_get_modifier_state (event));
       break;
     case GDK_BUTTON_PRESS:
     case GDK_BUTTON_RELEASE:
-      g_print ("%d (%.4g,%.4g) (%.4g,%.4g) ",
-              event->button.button,
-              event->button.x, event->button.y,
-              event->button.x_root, event->button.y_root);
-      print_event_state (event->button.state);
+      gdk_event_get_position (event, &x, &y);
+      g_print ("%d (%.4g,%.4g) ", gdk_button_event_get_button (event), x, y);
+      print_event_state (gdk_event_get_modifier_state (event));
       break;
     case GDK_KEY_PRESS:
     case GDK_KEY_RELEASE:
-      kvname = gdk_keyval_name (event->key.keyval);
+      kvname = gdk_keyval_name (gdk_key_event_get_keyval (event));
       g_print ("%#.02x group:%d %s",
-              event->key.hardware_keycode, event->key.group,
+               gdk_key_event_get_keycode (event),
+               gdk_key_event_get_group (event),
               (kvname ? kvname : "??"));
-      print_event_state (event->key.state);
+      print_event_state (gdk_event_get_modifier_state (event));
       break;
     case GDK_ENTER_NOTIFY:
     case GDK_LEAVE_NOTIFY:
-      g_print ("%p (%.4g,%.4g) (%.4g,%.4g) %s %s%s",
-              event->crossing.child_surface == NULL ? NULL : GDK_SURFACE_HWND 
(event->crossing.child_surface),
-              event->crossing.x, event->crossing.y,
-              event->crossing.x_root, event->crossing.y_root,
-              (event->crossing.mode == GDK_CROSSING_NORMAL ? "NORMAL" :
-               (event->crossing.mode == GDK_CROSSING_GRAB ? "GRAB" :
-                (event->crossing.mode == GDK_CROSSING_UNGRAB ? "UNGRAB" :
+      gdk_event_get_position (event, &x, &y);
+      mode = gdk_crossing_event_get_mode (event);
+      detail = gdk_crossing_event_get_detail (event);
+      g_print ("(%.4g,%.4g) %s %s",
+              x, y,
+              (mode == GDK_CROSSING_NORMAL ? "NORMAL" :
+               (mode == GDK_CROSSING_GRAB ? "GRAB" :
+                (mode == GDK_CROSSING_UNGRAB ? "UNGRAB" :
                  "???"))),
-              (event->crossing.detail == GDK_NOTIFY_ANCESTOR ? "ANCESTOR" :
-               (event->crossing.detail == GDK_NOTIFY_VIRTUAL ? "VIRTUAL" :
-                (event->crossing.detail == GDK_NOTIFY_INFERIOR ? "INFERIOR" :
-                 (event->crossing.detail == GDK_NOTIFY_NONLINEAR ? "NONLINEAR" :
-                  (event->crossing.detail == GDK_NOTIFY_NONLINEAR_VIRTUAL ? "NONLINEAR_VIRTUAL" :
-                   (event->crossing.detail == GDK_NOTIFY_UNKNOWN ? "UNKNOWN" :
-                    "???")))))),
-              event->crossing.focus ? " FOCUS" : "");
-      print_event_state (event->crossing.state);
+              (detail == GDK_NOTIFY_ANCESTOR ? "ANCESTOR" :
+               (detail == GDK_NOTIFY_VIRTUAL ? "VIRTUAL" :
+                (detail == GDK_NOTIFY_INFERIOR ? "INFERIOR" :
+                 (detail == GDK_NOTIFY_NONLINEAR ? "NONLINEAR" :
+                  (detail == GDK_NOTIFY_NONLINEAR_VIRTUAL ? "NONLINEAR_VIRTUAL" :
+                   (detail == GDK_NOTIFY_UNKNOWN ? "UNKNOWN" :
+                    "???")))))));
+      print_event_state (gdk_event_get_modifier_state (event));
       break;
     case GDK_FOCUS_CHANGE:
-      g_print ("%s", (event->focus_change.in ? "IN" : "OUT"));
+      g_print ("%s", (gdk_focus_event_get_in (event) ? "IN" : "OUT"));
       break;
     case GDK_DRAG_ENTER:
     case GDK_DRAG_LEAVE:
     case GDK_DRAG_MOTION:
     case GDK_DROP_START:
-      if (event->dnd.drop != NULL)
-       g_print ("ctx:%p: %s",
-                event->dnd.drop,
-                _gdk_win32_drag_protocol_to_string (GDK_WIN32_DRAG (event->dnd.drop)->protocol));
+      g_print ("DND");
       break;
     case GDK_SCROLL:
-      g_print ("(%.4g,%.4g) (%.4g,%.4g) %s ",
-              event->scroll.x, event->scroll.y,
-              event->scroll.x_root, event->scroll.y_root,
-              (event->scroll.direction == GDK_SCROLL_UP ? "UP" :
-               (event->scroll.direction == GDK_SCROLL_DOWN ? "DOWN" :
-                (event->scroll.direction == GDK_SCROLL_LEFT ? "LEFT" :
-                 (event->scroll.direction == GDK_SCROLL_RIGHT ? "RIGHT" :
+      direction = gdk_scroll_event_get_direction (event);
+      g_print (" %s ",
+              (direction == GDK_SCROLL_UP ? "UP" :
+               (direction == GDK_SCROLL_DOWN ? "DOWN" :
+                (direction == GDK_SCROLL_LEFT ? "LEFT" :
+                 (direction == GDK_SCROLL_RIGHT ? "RIGHT" :
                   "???")))));
-      print_event_state (event->scroll.state);
+      print_event_state (gdk_event_get_modifier_state (event));
       break;
     case GDK_GRAB_BROKEN:
-      g_print ("%s %s %p",
-              (event->grab_broken.keyboard ? "KEYBOARD" : "POINTER"),
-              (event->grab_broken.implicit ? "IMPLICIT" : "EXPLICIT"),
-              (event->grab_broken.grab_surface ? GDK_SURFACE_HWND (event->grab_broken.grab_surface) : 0));
+      g_print ("Grab broken");
     default:
       /* Nothing */
       break;
diff --git a/gdk/win32/gdksurface-win32.c b/gdk/win32/gdksurface-win32.c
index eda9325bd5..d70101f214 100644
--- a/gdk/win32/gdksurface-win32.c
+++ b/gdk/win32/gdksurface-win32.c
@@ -4937,7 +4937,7 @@ gdk_win32_surface_show_window_menu (GdkSurface *window,
       return FALSE;
     }
 
-  gdk_event_get_coords (event, &event_x, &event_y);
+  gdk_event_get_position (event, &event_x, &event_y);
   x = round (event_x);
   y = round (event_y);
 
diff --git a/gdk/x11/gdkdevicemanager-xi2.c b/gdk/x11/gdkdevicemanager-xi2.c
index ae3714c10a..0132f11d15 100644
--- a/gdk/x11/gdkdevicemanager-xi2.c
+++ b/gdk/x11/gdkdevicemanager-xi2.c
@@ -1183,7 +1183,7 @@ set_user_time (GdkEvent *event)
   GdkSurface *surface;
   guint32 time;
 
-  surface = event->any.surface;
+  surface = gdk_event_get_surface (event);
   g_return_if_fail (GDK_IS_SURFACE (surface));
 
   time = gdk_event_get_time (event);
@@ -1656,16 +1656,16 @@ gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
                                                  GUINT_TO_POINTER (xev->sourceid));
 
             axes = translate_axes (device,
-                                   event->button.x,
-                                   event->button.y,
-                                   event->any.surface,
+                                   (double) xev->event_x / scale,
+                                   (double) xev->event_y / scale,
+                                   surface,
                                    &xev->valuators);
 
             if (gdk_device_get_mode (device) == GDK_MODE_SURFACE)
               {
                 /* Update event coordinates from axes */
-                gdk_device_get_axis (device, event->button.axes, GDK_AXIS_X, &x);
-                gdk_device_get_axis (device, event->button.axes, GDK_AXIS_Y, &y);
+                gdk_device_get_axis (device, axes, GDK_AXIS_X, &x);
+                gdk_device_get_axis (device, axes, GDK_AXIS_Y, &y);
               }
             else
               {
@@ -1741,16 +1741,16 @@ gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
           }
 
         axes = translate_axes (device,
-                               event->motion.x,
-                               event->motion.y,
-                               event->any.surface,
+                               (double) xev->event_x / scale,
+                               (double) xev->event_y / scale,
+                               surface,
                                &xev->valuators);
 
         if (gdk_device_get_mode (device) == GDK_MODE_SURFACE)
           {
             /* Update event coordinates from axes */
-            gdk_device_get_axis (device, event->motion.axes, GDK_AXIS_X, &x);
-            gdk_device_get_axis (device, event->motion.axes, GDK_AXIS_Y, &y);
+            gdk_device_get_axis (device, axes, GDK_AXIS_X, &x);
+            gdk_device_get_axis (device, axes, GDK_AXIS_Y, &y);
           }
         else
           {
@@ -1798,16 +1798,16 @@ gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
           state |= GDK_BUTTON1_MASK;
 
         axes = translate_axes (device,
-                               event->touch.x,
-                               event->touch.y,
-                               event->any.surface,
+                               (double) xev->event_x / scale,
+                               (double) xev->event_y / scale,
+                               surface,
                                &xev->valuators);
 
         if (gdk_device_get_mode (device) == GDK_MODE_SURFACE)
           {
             /* Update event coordinates from axes */
-            gdk_device_get_axis (device, event->touch.axes, GDK_AXIS_X, &x);
-            gdk_device_get_axis (device, event->touch.axes, GDK_AXIS_Y, &y);
+            gdk_device_get_axis (device, axes, GDK_AXIS_X, &x);
+            gdk_device_get_axis (device, axes, GDK_AXIS_Y, &y);
           }
         else
           {
@@ -1856,16 +1856,16 @@ gdk_x11_device_manager_xi2_translate_event (GdkEventTranslator *translator,
         state |= GDK_BUTTON1_MASK;
 
         axes = translate_axes (device,
-                               event->touch.x,
-                               event->touch.y,
-                               event->any.surface,
+                               (double) xev->event_x / scale,
+                               (double) xev->event_y / scale,
+                               surface,
                                &xev->valuators);
 
         if (gdk_device_get_mode (device) == GDK_MODE_SURFACE)
           {
             /* Update event coordinates from axes */
-            gdk_device_get_axis (device, event->touch.axes, GDK_AXIS_X, &x);
-            gdk_device_get_axis (device, event->touch.axes, GDK_AXIS_Y, &y);
+            gdk_device_get_axis (device, axes, GDK_AXIS_X, &x);
+            gdk_device_get_axis (device, axes, GDK_AXIS_Y, &y);
           }
         else
           {
diff --git a/gdk/x11/gdkdrag-x11.c b/gdk/x11/gdkdrag-x11.c
index 313aac0ed0..c29304e818 100644
--- a/gdk/x11/gdkdrag-x11.c
+++ b/gdk/x11/gdkdrag-x11.c
@@ -2244,16 +2244,15 @@ static gboolean
 gdk_dnd_handle_motion_event (GdkDrag        *drag,
                              GdkEvent       *event)
 {
-  GdkModifierType state;
+  double x, y;
   int x_root, y_root;
 
-  if (!gdk_event_get_state ((GdkEvent *) event, &state))
-    return FALSE;
-
-  x_root = event->any.surface->x + event->motion.x;
-  y_root = event->any.surface->y + event->motion.y;
-  gdk_drag_update (drag, x_root, y_root, state,
-                   gdk_event_get_time ((GdkEvent *) event));
+  gdk_event_get_position (event, &x, &y);
+  x_root = event->any.surface->x + x;
+  y_root = event->any.surface->y + y;
+  gdk_drag_update (drag, x_root, y_root,
+                   gdk_event_get_modifier_state (event),
+                   gdk_event_get_time (event));
   return TRUE;
 }
 
diff --git a/gdk/x11/gdkeventsource.c b/gdk/x11/gdkeventsource.c
index 828313100a..1fa659d9d2 100644
--- a/gdk/x11/gdkeventsource.c
+++ b/gdk/x11/gdkeventsource.c
@@ -135,8 +135,8 @@ create_synth_crossing_event (GdkEventType     evtype,
 
   g_assert (evtype == GDK_ENTER_NOTIFY || evtype == GDK_LEAVE_NOTIFY);
 
-  gdk_event_get_state (real_event, &state);
-  gdk_event_get_coords (real_event, &x, &y);
+  state = gdk_event_get_modifier_state (real_event);
+  gdk_event_get_position (real_event, &x, &y);
   event = gdk_event_crossing_new (evtype,
                                   real_event->any.surface,
                                   gdk_event_get_device (real_event),
diff --git a/gdk/x11/gdksurface-x11.c b/gdk/x11/gdksurface-x11.c
index b9e122a91a..c64d2d420f 100644
--- a/gdk/x11/gdksurface-x11.c
+++ b/gdk/x11/gdksurface-x11.c
@@ -4619,7 +4619,7 @@ gdk_x11_surface_show_window_menu (GdkSurface *surface,
                                             g_intern_static_string ("_GTK_SHOW_WINDOW_MENU")))
     return FALSE;
 
-  gdk_event_get_coords (event, &x, &y);
+  gdk_event_get_position (event, &x, &y);
   gdk_x11_surface_get_root_coords (surface, x, y, &x_root, &y_root);
   device = gdk_event_get_device (event);
   g_object_get (G_OBJECT (device),
diff --git a/gtk/a11y/gtkaccessibilityutil.c b/gtk/a11y/gtkaccessibilityutil.c
index beaae3a50e..61656857b1 100644
--- a/gtk/a11y/gtkaccessibilityutil.c
+++ b/gtk/a11y/gtkaccessibilityutil.c
@@ -118,9 +118,9 @@ atk_key_event_from_gdk_event_key (GdkEventKey       *key,
   guint16 keycode;
 
   type = gdk_event_get_event_type ((GdkEvent *)key);
-  gdk_event_get_state ((GdkEvent *)key, &state);
-  gdk_event_get_keyval ((GdkEvent *)key, &keyval);
-  gdk_event_get_keycode ((GdkEvent *)key, &keycode);
+  state = gdk_event_get_modifier_state ((GdkEvent *)key);
+  keyval = gdk_key_event_get_keyval ((GdkEvent *)key);
+  keycode = gdk_key_event_get_keycode ((GdkEvent *)key);
 
   if (type == GDK_KEY_PRESS)
     event->type = ATK_KEY_EVENT_PRESS;
diff --git a/gtk/gtkbindings.c b/gtk/gtkbindings.c
index fd4d62b0b0..949c8cf65a 100644
--- a/gtk/gtkbindings.c
+++ b/gtk/gtkbindings.c
@@ -1771,9 +1771,6 @@ gtk_bindings_activate_event (GObject     *object,
   GdkDisplay *display;
   GtkKeyHash *key_hash;
   gboolean handled = FALSE;
-  guint16 keycode;
-  GdkModifierType state;
-  guint group;
 
   if (!GTK_IS_WIDGET (object))
     return FALSE;
@@ -1781,15 +1778,11 @@ gtk_bindings_activate_event (GObject     *object,
   display = gtk_widget_get_display (GTK_WIDGET (object));
   key_hash = binding_key_hash_for_keymap (gdk_display_get_keymap (display));
 
-  gdk_event_get_keycode ((GdkEvent *)event, &keycode);
-  gdk_event_get_state ((GdkEvent *)event, &state);
-  gdk_event_get_key_group ((GdkEvent *)event, &group);
-
   entries = _gtk_key_hash_lookup (key_hash,
-                                  keycode,
-                                  state,
+                                  gdk_key_event_get_keycode ((GdkEvent *)event),
+                                  gdk_event_get_modifier_state ((GdkEvent *)event),
                                   BINDING_MOD_MASK () & ~GDK_RELEASE_MASK,
-                                  group);
+                                  gdk_key_event_get_group((GdkEvent *)event));
 
   handled = gtk_bindings_activate_list (object, entries,
                                         gdk_event_get_event_type ((GdkEvent *) event) == GDK_KEY_RELEASE);
diff --git a/gtk/gtkbutton.c b/gtk/gtkbutton.c
index b8ee4dd2f6..7da11fb7d5 100644
--- a/gtk/gtkbutton.c
+++ b/gtk/gtkbutton.c
@@ -322,7 +322,7 @@ touch_release_in_button (GtkButton *button)
       return FALSE;
     }
 
-  gdk_event_get_coords (event, &x, &y);
+  gdk_event_get_position (event, &x, &y);
 
   gdk_event_unref (event);
 
diff --git a/gtk/gtkcellarea.c b/gtk/gtkcellarea.c
index b8945d6544..e9b10bd355 100644
--- a/gtk/gtkcellarea.c
+++ b/gtk/gtkcellarea.c
@@ -1024,12 +1024,9 @@ gtk_cell_area_real_event (GtkCellArea          *area,
 
   if (event_type == GDK_KEY_PRESS && (flags & GTK_CELL_RENDERER_FOCUSED) != 0)
     {
-      guint keyval;
-
       /* Cancel any edits in progress */
       if (priv->edited_cell &&
-          gdk_event_get_keyval (event, &keyval) &&
-          keyval == GDK_KEY_Escape)
+          gdk_key_event_get_keyval (event) == GDK_KEY_Escape)
         {
           gtk_cell_area_stop_editing (area, TRUE);
           retval = TRUE;
@@ -1039,7 +1036,8 @@ gtk_cell_area_real_event (GtkCellArea          *area,
     {
       guint button;
 
-      if (gdk_event_get_button (event, &button) && button == GDK_BUTTON_PRIMARY)
+      button = gdk_button_event_get_button (event);
+      if (button == GDK_BUTTON_PRIMARY)
         {
           GtkCellRenderer *renderer = NULL;
           GtkCellRenderer *focus_renderer;
@@ -1048,7 +1046,7 @@ gtk_cell_area_real_event (GtkCellArea          *area,
 
           /* We may need some semantics to tell us the offset of the event
            * window we are handling events for (i.e. GtkTreeView has a bin_window) */
-          gdk_event_get_coords (event, &event_x, &event_y);
+          gdk_event_get_position (event, &event_x, &event_y);
 
           /* Dont try to search for an event coordinate that is not in the area, that will
            * trigger a runtime warning.
diff --git a/gtk/gtkdragdest.c b/gtk/gtkdragdest.c
index 6c52bff2eb..125cc373ae 100644
--- a/gtk/gtkdragdest.c
+++ b/gtk/gtkdragdest.c
@@ -756,7 +756,7 @@ gtk_drop_target_handle_event (GtkEventController *controller,
   GtkDropStatus status;
   gboolean found = FALSE;
 
-  drop = gdk_event_get_drop (event);
+  drop = gdk_drag_event_get_drop (event);
 
   status = gtk_drop_target_get_drop_status (dest, drop);
   if (status == GTK_DROP_STATUS_DENIED)
@@ -808,7 +808,7 @@ gtk_drag_dest_handle_event (GtkWidget *toplevel,
   g_return_if_fail (event != NULL);
 
   event_type = gdk_event_get_event_type (event);
-  drop = gdk_event_get_drop (event);
+  drop = gdk_drag_event_get_drop (event);
 
   switch ((guint) event_type)
     {
diff --git a/gtk/gtkdragsource.c b/gtk/gtkdragsource.c
index 2de0dcc5e6..155c7cc84a 100644
--- a/gtk/gtkdragsource.c
+++ b/gtk/gtkdragsource.c
@@ -207,7 +207,7 @@ gtk_drag_source_filter_event (GtkEventController *controller,
       guint n_fingers;
 
       g_object_get (G_OBJECT (controller), "n-points", &n_points, NULL);
-      gdk_event_get_touchpad_gesture_n_fingers (event, &n_fingers);
+      n_fingers = gdk_touchpad_event_get_n_fingers (event);
 
       if (n_fingers == n_points)
         return FALSE;
diff --git a/gtk/gtkeventcontrollerkey.c b/gtk/gtkeventcontrollerkey.c
index 5c6765b222..a8a5912d33 100644
--- a/gtk/gtkeventcontrollerkey.c
+++ b/gtk/gtkeventcontrollerkey.c
@@ -120,7 +120,7 @@ gtk_event_controller_key_handle_event (GtkEventController *controller,
 
   key->current_event = event;
 
-  gdk_event_get_state (event, &state);
+  state = gdk_event_get_modifier_state (event);
   if (key->state != state)
     {
       gboolean unused;
@@ -129,8 +129,8 @@ gtk_event_controller_key_handle_event (GtkEventController *controller,
       g_signal_emit (controller, signals[MODIFIERS], 0, state, &unused);
     }
 
-  gdk_event_get_keycode (event, &keycode);
-  gdk_event_get_keyval (event, &keyval);
+  keycode = gdk_key_event_get_keycode (event);
+  keyval = gdk_key_event_get_keyval (event);
 
   if (event_type == GDK_KEY_PRESS)
     {
@@ -495,21 +495,17 @@ gtk_event_controller_key_forward (GtkEventControllerKey *controller,
  * @controller: a #GtkEventControllerKey
  *
  * Gets the key group of the current event of this @controller.
- * See gdk_event_get_key_group().
+ * See gdk_key_event_get_group().
  *
  * Returns: the key group
  **/
 guint
 gtk_event_controller_key_get_group (GtkEventControllerKey *controller)
 {
-  guint group;
-
   g_return_val_if_fail (GTK_IS_EVENT_CONTROLLER_KEY (controller), FALSE);
   g_return_val_if_fail (controller->current_event != NULL, FALSE);
 
-  gdk_event_get_key_group (controller->current_event, &group);
-
-  return group;
+  return gdk_key_event_get_group (controller->current_event);
 }
 
 /**
diff --git a/gtk/gtkeventcontrollerscroll.c b/gtk/gtkeventcontrollerscroll.c
index 07d44c4b44..d1e43491de 100644
--- a/gtk/gtkeventcontrollerscroll.c
+++ b/gtk/gtkeventcontrollerscroll.c
@@ -249,17 +249,20 @@ gtk_event_controller_scroll_handle_event (GtkEventController *controller,
 
   if (gdk_event_get_event_type (event) != GDK_SCROLL)
     return FALSE;
+
   if ((scroll->flags & (GTK_EVENT_CONTROLLER_SCROLL_VERTICAL |
                         GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL)) == 0)
     return FALSE;
 
   /* FIXME: Handle device changes */
-
-  if (gdk_event_get_scroll_deltas (event, &dx, &dy))
+  direction = gdk_scroll_event_get_direction (event);
+  if (direction == GDK_SCROLL_SMOOTH)
     {
       GdkDevice *device = gdk_event_get_source_device (event);
       GdkInputSource input_source = gdk_device_get_source (device);
 
+      gdk_scroll_event_get_deltas (event, &dx, &dy);
+
       if (!scroll->active &&
           (input_source == GDK_SOURCE_TRACKPOINT ||
            input_source == GDK_SOURCE_TOUCHPAD))
@@ -297,7 +300,7 @@ gtk_event_controller_scroll_handle_event (GtkEventController *controller,
             }
         }
     }
-  else if (gdk_event_get_scroll_direction (event, &direction))
+  else
     {
       switch (direction)
         {
@@ -333,7 +336,7 @@ gtk_event_controller_scroll_handle_event (GtkEventController *controller,
         scroll_history_push (scroll, dx, dy, gdk_event_get_time (event));
     }
 
-  if (scroll->active && gdk_event_is_scroll_stop_event (event))
+  if (scroll->active && gdk_scroll_event_is_stop (event))
     {
       g_signal_emit (controller, signals[SCROLL_END], 0);
       scroll->active = FALSE;
diff --git a/gtk/gtkgesture.c b/gtk/gtkgesture.c
index bb5d438212..d06a09c5ac 100644
--- a/gtk/gtkgesture.c
+++ b/gtk/gtkgesture.c
@@ -236,7 +236,7 @@ _gtk_gesture_get_n_touchpad_points (GtkGesture *gesture,
   GtkGesturePrivate *priv;
   PointData *data;
   GdkEventType event_type;
-  GdkTouchpadGesturePhase phase;
+  GdkTouchpadGesturePhase phase = 0;
   guint n_fingers = 0;
 
   priv = gtk_gesture_get_instance_private (gesture);
@@ -251,7 +251,11 @@ _gtk_gesture_get_n_touchpad_points (GtkGesture *gesture,
 
   event_type = gdk_event_get_event_type (data->event);
 
-  gdk_event_get_touchpad_gesture_phase (data->event, &phase);
+  if (EVENT_IS_TOUCHPAD_GESTURE (data->event))
+    {
+      phase = gdk_touchpad_event_get_gesture_phase (data->event);
+      n_fingers = gdk_touchpad_event_get_n_fingers (data->event);
+    }
 
   if (only_active &&
       (data->state == GTK_EVENT_SEQUENCE_DENIED ||
@@ -259,9 +263,6 @@ _gtk_gesture_get_n_touchpad_points (GtkGesture *gesture,
        (event_type == GDK_TOUCHPAD_PINCH && phase == GDK_TOUCHPAD_GESTURE_PHASE_END)))
     return 0;
 
-  if (!gdk_event_get_touchpad_gesture_n_fingers (data->event, &n_fingers))
-    return 0;
-
   return n_fingers;
 }
 
@@ -390,7 +391,6 @@ static void
 _update_touchpad_deltas (PointData *data)
 {
   GdkEvent *event = data->event;
-  GdkEventType event_type;
   GdkTouchpadGesturePhase phase;
   double dx;
   double dy;
@@ -398,13 +398,10 @@ _update_touchpad_deltas (PointData *data)
   if (!event)
     return;
 
-  event_type = gdk_event_get_event_type (event);
-  gdk_event_get_touchpad_gesture_phase (event, &phase);
-  gdk_event_get_touchpad_deltas (event, &dx, &dy);
-
-  if (event_type == GDK_TOUCHPAD_SWIPE ||
-      event_type == GDK_TOUCHPAD_PINCH)
+  if (EVENT_IS_TOUCHPAD_GESTURE (event))
     {
+      phase = gdk_touchpad_event_get_gesture_phase (event);
+      gdk_touchpad_event_get_deltas (event, &dx, &dy);
       if (phase == GDK_TOUCHPAD_GESTURE_PHASE_BEGIN)
         data->accum_dx = data->accum_dy = 0;
       else if (phase == GDK_TOUCHPAD_GESTURE_PHASE_UPDATE)
@@ -452,9 +449,6 @@ _gtk_gesture_update_point (GtkGesture     *gesture,
   gboolean existed, touchpad;
   PointData *data;
 
-  if (!gdk_event_get_coords (event, NULL, NULL))
-    return FALSE;
-
   device = gdk_event_get_device (event);
 
   if (!device)
@@ -612,7 +606,7 @@ gtk_gesture_handle_event (GtkEventController *controller,
   GdkDevice *source_device;
   gboolean was_recognized;
   GdkEventType event_type;
-  GdkTouchpadGesturePhase phase;
+  GdkTouchpadGesturePhase phase = 0;
   GdkModifierType state;
   GtkWidget *target;
 
@@ -625,8 +619,9 @@ gtk_gesture_handle_event (GtkEventController *controller,
   sequence = gdk_event_get_event_sequence (event);
   was_recognized = gtk_gesture_is_recognized (gesture);
   event_type = gdk_event_get_event_type (event);
-  gdk_event_get_state (event, &state);
-  gdk_event_get_touchpad_gesture_phase (event, &phase);
+  state = gdk_event_get_modifier_state (event);
+  if (EVENT_IS_TOUCHPAD_GESTURE (event))
+    phase = gdk_touchpad_event_get_gesture_phase (event);
 
   target = gtk_event_controller_get_target (controller);
 
@@ -714,9 +709,9 @@ gtk_gesture_handle_event (GtkEventController *controller,
     }
   else if (event_type == GDK_GRAB_BROKEN)
     {
-      GdkSurface *surface = NULL;
+      GdkSurface *surface;
 
-      gdk_event_get_grab_surface (event, &surface);
+      surface = gdk_grab_broken_event_get_grab_surface (event);
       if (!surface || !gesture_within_surface (gesture, surface))
         _gtk_gesture_cancel_all (gesture);
 
@@ -1298,7 +1293,7 @@ gtk_gesture_get_bounding_box (GtkGesture   *gesture,
           event_type == GDK_BUTTON_RELEASE)
         continue;
 
-      gdk_event_get_coords (data->event, &x, &y);
+      gdk_event_get_position (data->event, &x, &y);
       n_points++;
       x1 = MIN (x1, x);
       y1 = MIN (y1, y);
@@ -1620,7 +1615,6 @@ _gtk_gesture_get_pointer_emulating_sequence (GtkGesture        *gesture,
   GdkEventSequence *seq;
   GHashTableIter iter;
   PointData *data;
-  gboolean emulating;
 
   g_return_val_if_fail (GTK_IS_GESTURE (gesture), FALSE);
 
@@ -1634,8 +1628,7 @@ _gtk_gesture_get_pointer_emulating_sequence (GtkGesture        *gesture,
         case GDK_TOUCH_BEGIN:
         case GDK_TOUCH_UPDATE:
         case GDK_TOUCH_END:
-          gdk_event_get_touch_emulating_pointer (data->event, &emulating);
-          if (!emulating)
+          if (!gdk_touch_event_get_emulating_pointer (data->event))
             continue;
           /* Fall through */
         case GDK_BUTTON_PRESS:
diff --git a/gtk/gtkgestureclick.c b/gtk/gtkgestureclick.c
index ba815e4eb8..9d8e95404f 100644
--- a/gtk/gtkgestureclick.c
+++ b/gtk/gtkgestureclick.c
@@ -213,7 +213,7 @@ gtk_gesture_click_begin (GtkGesture       *gesture,
   event_type = gdk_event_get_event_type (event);
 
   if (event_type == GDK_BUTTON_PRESS)
-    gdk_event_get_button (event, &button);
+    button = gdk_button_event_get_button (event);
   else if (event_type == GDK_TOUCH_BEGIN)
     button = 1;
   else
@@ -325,7 +325,9 @@ gtk_gesture_click_handle_event (GtkEventController *controller,
       (gdk_event_get_event_type (event) == GDK_BUTTON_RELEASE ||
        gdk_event_get_event_type (event) == GDK_TOUCH_END))
     {
-      if (!gdk_event_get_button (event, &button))
+      if (gdk_event_get_event_type (event) == GDK_BUTTON_RELEASE)
+        button = gdk_button_event_get_button (event);
+      else
         button = 0;
       g_signal_emit (controller, signals[UNPAIRED_RELEASE], 0,
                      x, y, button, sequence);
diff --git a/gtk/gtkgesturedrag.c b/gtk/gtkgesturedrag.c
index fa63ba8f45..be03a7a291 100644
--- a/gtk/gtkgesturedrag.c
+++ b/gtk/gtkgesturedrag.c
@@ -69,7 +69,7 @@ gtk_gesture_drag_filter_event (GtkEventController *controller,
       guint n_fingers;
 
       g_object_get (G_OBJECT (controller), "n-points", &n_points, NULL);
-      gdk_event_get_touchpad_gesture_n_fingers (event, &n_fingers);
+      n_fingers = gdk_touchpad_event_get_n_fingers (event);
 
       if (n_fingers == n_points)
         return FALSE;
diff --git a/gtk/gtkgesturerotate.c b/gtk/gtkgesturerotate.c
index fa0568fb70..2f0541ab78 100644
--- a/gtk/gtkgesturerotate.c
+++ b/gtk/gtkgesturerotate.c
@@ -97,7 +97,7 @@ _gtk_gesture_rotate_get_angle (GtkGestureRotate *rotate,
     goto out;
 
   last_event = gtk_gesture_get_last_event (gesture, sequences->data);
-  gdk_event_get_touchpad_gesture_phase (last_event, &phase);
+  phase = gdk_touchpad_event_get_gesture_phase (last_event);
 
   if (gdk_event_get_event_type (last_event) == GDK_TOUCHPAD_PINCH &&
       (phase == GDK_TOUCHPAD_GESTURE_PHASE_BEGIN ||
@@ -179,7 +179,7 @@ gtk_gesture_rotate_filter_event (GtkEventController *controller,
     {
       guint n_fingers;
 
-      gdk_event_get_touchpad_gesture_n_fingers (event, &n_fingers);
+      n_fingers = gdk_touchpad_event_get_n_fingers (event);
 
       if (n_fingers == 2)
         return FALSE;
@@ -203,11 +203,10 @@ gtk_gesture_rotate_handle_event (GtkEventController *controller,
 
   priv = gtk_gesture_rotate_get_instance_private (rotate);
 
-  gdk_event_get_touchpad_gesture_phase (event, &phase);
-  gdk_event_get_touchpad_angle_delta (event, &delta);
-
   if (gdk_event_get_event_type (event) == GDK_TOUCHPAD_PINCH)
     {
+      phase = gdk_touchpad_event_get_gesture_phase (event);
+      delta = gdk_touchpad_pinch_event_get_angle_delta (event);
       if (phase == GDK_TOUCHPAD_GESTURE_PHASE_BEGIN ||
           phase == GDK_TOUCHPAD_GESTURE_PHASE_END)
         priv->accum_touchpad_angle = 0;
diff --git a/gtk/gtkgesturesingle.c b/gtk/gtkgesturesingle.c
index b99eee1823..6e3dd3b406 100644
--- a/gtk/gtkgesturesingle.c
+++ b/gtk/gtkgesturesingle.c
@@ -142,7 +142,6 @@ gtk_gesture_single_handle_event (GtkEventController *controller,
   guint button = 0, state, i;
   gboolean retval, test_touchscreen = FALSE;
   GdkEventType event_type;
-  gboolean emulating;
 
   source_device = gdk_event_get_source_device (event);
 
@@ -162,8 +161,7 @@ gtk_gesture_single_handle_event (GtkEventController *controller,
     case GDK_TOUCH_BEGIN:
     case GDK_TOUCH_END:
     case GDK_TOUCH_UPDATE:
-      gdk_event_get_touch_emulating_pointer (event, &emulating);
-      if (priv->exclusive && !emulating)
+      if (priv->exclusive && !gdk_touch_event_get_emulating_pointer (event))
         return FALSE;
 
       sequence = gdk_event_get_event_sequence (event);
@@ -174,15 +172,14 @@ gtk_gesture_single_handle_event (GtkEventController *controller,
       if (priv->touch_only && !test_touchscreen && source != GDK_SOURCE_TOUCHSCREEN)
         return FALSE;
 
-      gdk_event_get_button (event, &button);
+      button = gdk_button_event_get_button (event);
       break;
     case GDK_MOTION_NOTIFY:
       if (!gtk_gesture_handles_sequence (GTK_GESTURE (controller), sequence))
         return FALSE;
       if (priv->touch_only && !test_touchscreen && source != GDK_SOURCE_TOUCHSCREEN)
         return FALSE;
-      if (!gdk_event_get_state (event, &state))
-        return FALSE;
+      state = gdk_event_get_modifier_state (event);
 
       if (priv->current_button > 0 && priv->current_button <= 5 &&
           (state & (GDK_BUTTON1_MASK << (priv->current_button - 1))))
diff --git a/gtk/gtkgesturestylus.c b/gtk/gtkgesturestylus.c
index 610c7fb6ae..5d98a08b24 100644
--- a/gtk/gtkgesturestylus.c
+++ b/gtk/gtkgesturestylus.c
@@ -70,7 +70,7 @@ gtk_gesture_stylus_handle_event (GtkEventController *controller,
       n_signal = UP;
       break;
     case GDK_MOTION_NOTIFY:
-      gdk_event_get_state (event, &modifiers);
+      modifiers = gdk_event_get_modifier_state (event);
 
       if (modifiers & GDK_BUTTON1_MASK)
         n_signal = MOTION;
diff --git a/gtk/gtkgestureswipe.c b/gtk/gtkgestureswipe.c
index eb0a04a195..5aba66dd70 100644
--- a/gtk/gtkgestureswipe.c
+++ b/gtk/gtkgestureswipe.c
@@ -92,7 +92,7 @@ gtk_gesture_swipe_filter_event (GtkEventController *controller,
 
       g_object_get (G_OBJECT (controller), "n-points", &n_points, NULL);
 
-      gdk_event_get_touchpad_gesture_n_fingers (event, &n_fingers);
+      n_fingers = gdk_touchpad_event_get_n_fingers (event);
 
       if (n_fingers == n_points)
         return FALSE;
diff --git a/gtk/gtkgesturezoom.c b/gtk/gtkgesturezoom.c
index 402d313912..3eefa3f60a 100644
--- a/gtk/gtkgesturezoom.c
+++ b/gtk/gtkgesturezoom.c
@@ -94,7 +94,7 @@ _gtk_gesture_zoom_get_distance (GtkGestureZoom *zoom,
     goto out;
 
   last_event = gtk_gesture_get_last_event (gesture, sequences->data);
-  gdk_event_get_touchpad_gesture_phase (last_event, &phase);
+  phase = gdk_touchpad_event_get_gesture_phase (last_event);
 
   if (gdk_event_get_event_type (last_event) == GDK_TOUCHPAD_PINCH &&
       (phase == GDK_TOUCHPAD_GESTURE_PHASE_BEGIN ||
@@ -104,7 +104,7 @@ _gtk_gesture_zoom_get_distance (GtkGestureZoom *zoom,
       double scale;
       /* Touchpad pinch */
 
-      gdk_event_get_touchpad_scale (last_event, &scale);
+      scale = gdk_touchpad_pinch_event_get_scale (last_event);
       *distance = scale;
     }
   else
@@ -156,7 +156,7 @@ gtk_gesture_zoom_filter_event (GtkEventController *controller,
     {
       guint n_fingers;
 
-      gdk_event_get_touchpad_gesture_n_fingers (event, &n_fingers);
+      n_fingers = gdk_touchpad_event_get_n_fingers (event);
 
       if (n_fingers == 2)
         return FALSE;
diff --git a/gtk/gtkiconview.c b/gtk/gtkiconview.c
index 3f0de76ca6..520f869dec 100644
--- a/gtk/gtkiconview.c
+++ b/gtk/gtkiconview.c
@@ -2134,12 +2134,12 @@ gtk_icon_view_button_press (GtkGestureClick *gesture,
   if (!gtk_widget_has_focus (widget))
     gtk_widget_grab_focus (widget);
 
-  if (button == GDK_BUTTON_PRIMARY &&
-      gdk_event_get_state ((GdkEvent *) event, &state))
+  if (button == GDK_BUTTON_PRIMARY)
     {
       GdkModifierType extend_mod_mask;
       GdkModifierType modify_mod_mask;
 
+      state = gdk_event_get_modifier_state ((GdkEvent *)event);
       extend_mod_mask =
         gtk_widget_get_modifier_mask (widget, GDK_MODIFIER_INTENT_EXTEND_SELECTION);
 
@@ -2280,7 +2280,7 @@ button_event_modifies_selection (GdkEventButton *event)
 {
   guint state;
 
-  gdk_event_get_state ((GdkEvent *) event, &state);
+  state = gdk_event_get_modifier_state ((GdkEvent *) event);
   return (state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) != 0;
 }
 
diff --git a/gtk/gtkimcontextsimple.c b/gtk/gtkimcontextsimple.c
index f2cd39d9ed..5fdcc8533d 100644
--- a/gtk/gtkimcontextsimple.c
+++ b/gtk/gtkimcontextsimple.c
@@ -893,7 +893,7 @@ beep_surface (GdkSurface *surface)
 static gboolean
 no_sequence_matches (GtkIMContextSimple *context_simple,
                      gint                n_compose,
-                     GdkEventKey        *event)
+                     GdkEvent           *event)
 {
   GtkIMContextSimplePrivate *priv = context_simple->priv;
   GtkIMContext *context;
@@ -917,11 +917,11 @@ no_sequence_matches (GtkIMContextSimple *context_simple,
        {
           guint tmp_keyval = priv->compose_buffer[len + i];
           GdkEvent *tmp_event = gdk_event_key_new (GDK_KEY_PRESS,
-                                                   event->any.surface,
-                                                   event->any.device,
-                                                   event->any.source_device,
-                                                   event->time,
-                                                   event->state,
+                                                   gdk_event_get_surface (event),
+                                                   gdk_event_get_device (event),
+                                                   gdk_event_get_source_device (event),
+                                                   gdk_event_get_time (event),
+                                                   gdk_event_get_modifier_state (event),
                                                    tmp_keyval,
                                                    tmp_keyval,
                                                    tmp_keyval,
@@ -932,14 +932,16 @@ no_sequence_matches (GtkIMContextSimple *context_simple,
          g_object_unref (tmp_event);
        }
 
-      return gtk_im_context_filter_keypress (context, event);
+      return gtk_im_context_filter_keypress (context, (GdkEventKey *)event);
     }
-  else if (gdk_event_get_keyval ((GdkEvent *) event, &keyval))
+  else
     {
+      keyval = gdk_key_event_get_keyval (event);
+
       priv->compose_buffer[0] = 0;
       if (n_compose > 1)               /* Invalid sequence */
        {
-         beep_surface (gdk_event_get_surface ((GdkEvent *) event));
+         beep_surface (gdk_event_get_surface (event));
          return TRUE;
        }
   
@@ -952,8 +954,7 @@ no_sequence_matches (GtkIMContextSimple *context_simple,
       else
        return FALSE;
     }
-  else
-    return FALSE;
+  return FALSE;
 }
 
 static gboolean
@@ -974,8 +975,7 @@ canonical_hex_keyval (GdkEventKey *event)
   gint n_vals = 0;
   gint i;
 
-  if (!gdk_event_get_keyval ((GdkEvent *) event, &event_keyval))
-    return 0;
+  event_keyval = gdk_key_event_get_keyval ((GdkEvent *)event);
 
   /* See if the keyval is already a hex digit */
   if (is_hex_keyval (event_keyval))
@@ -985,7 +985,7 @@ canonical_hex_keyval (GdkEventKey *event)
    * any other state, and return that hex keyval if so
    */
   gdk_keymap_get_entries_for_keycode (keymap,
-                                      gdk_event_get_scancode ((GdkEvent *) event),
+                                      gdk_key_event_get_scancode ((GdkEvent *) event),
                                      NULL,
                                      &keyvals, &n_vals);
 
@@ -1039,9 +1039,8 @@ gtk_im_context_simple_filter_keypress (GtkIMContext *context,
   while (priv->compose_buffer[n_compose] != 0)
     n_compose++;
 
-  if (!gdk_event_get_keyval ((GdkEvent *) event, &keyval) ||
-      !gdk_event_get_state ((GdkEvent *) event, &state))
-    return GDK_EVENT_PROPAGATE;
+  keyval = gdk_key_event_get_keyval ((GdkEvent *)event);
+  state = gdk_event_get_modifier_state ((GdkEvent *)event);
 
   if (gdk_event_get_event_type ((GdkEvent *) event) == GDK_KEY_RELEASE)
     {
@@ -1355,7 +1354,7 @@ gtk_im_context_simple_filter_keypress (GtkIMContext *context,
     }
   
   /* The current compose_buffer doesn't match anything */
-  return no_sequence_matches (context_simple, n_compose, event);
+  return no_sequence_matches (context_simple, n_compose, (GdkEvent *)event);
 }
 
 static void
diff --git a/gtk/gtkimmulticontext.c b/gtk/gtkimmulticontext.c
index 0ab67eddf2..2818241e11 100644
--- a/gtk/gtkimmulticontext.c
+++ b/gtk/gtkimmulticontext.c
@@ -353,13 +353,14 @@ gtk_im_multicontext_filter_keypress (GtkIMContext *context,
     {
       return gtk_im_context_filter_keypress (slave, event);
     }
-  else if (gdk_event_get_keyval ((GdkEvent *) event, &keyval) &&
-           gdk_event_get_state ((GdkEvent *) event, &state))
+  else
     {
       GdkDisplay *display;
       GdkModifierType no_text_input_mask;
 
-      display = gdk_surface_get_display (gdk_event_get_surface ((GdkEvent *) event));
+      keyval = gdk_key_event_get_keyval ((GdkEvent *) event);
+      state = gdk_event_get_modifier_state ((GdkEvent *) event);
+      display = gdk_event_get_display ((GdkEvent *) event);
 
       no_text_input_mask =
         gdk_keymap_get_modifier_mask (gdk_display_get_keymap (display),
diff --git a/gtk/gtklabel.c b/gtk/gtklabel.c
index 60d3898c18..1c7d1ba130 100644
--- a/gtk/gtklabel.c
+++ b/gtk/gtklabel.c
@@ -4648,7 +4648,7 @@ gtk_label_drag_gesture_begin (GtkGestureDrag *gesture,
 
   sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
   event = gtk_gesture_get_last_event (GTK_GESTURE (gesture), sequence);
-  gdk_event_get_state (event, &state_mask);
+  state_mask = gdk_event_get_modifier_state (event);
 
   if ((info->selection_anchor != info->selection_end) &&
       (state_mask & GDK_SHIFT_MASK))
diff --git a/gtk/gtkmain.c b/gtk/gtkmain.c
index c46f389849..c17636beff 100644
--- a/gtk/gtkmain.c
+++ b/gtk/gtkmain.c
@@ -1078,75 +1078,92 @@ static GdkEvent *
 rewrite_event_for_surface (GdkEvent  *event,
                           GdkSurface *new_surface)
 {
+  GdkEventType type;
   double x, y;
+  double dx, dy;
 
-  if (!gdk_event_get_coords (event, &x, &y) ||
-      !gdk_surface_translate_coordinates (event->any.surface, new_surface, &x, &y))
+  type = gdk_event_get_event_type (event);
+
+  switch ((guint) type)
     {
+    case GDK_BUTTON_PRESS:
+    case GDK_BUTTON_RELEASE:
+    case GDK_MOTION_NOTIFY:
+    case GDK_TOUCH_BEGIN:
+    case GDK_TOUCH_UPDATE:
+    case GDK_TOUCH_END:
+    case GDK_TOUCH_CANCEL:
+    case GDK_TOUCHPAD_SWIPE:
+    case GDK_TOUCHPAD_PINCH:
+      gdk_event_get_position (event, &x, &y);
+      gdk_surface_translate_coordinates (gdk_event_get_surface (event), new_surface, &x, &y);
+      break;
+    default:
       x = y = 0;
+      break;
     }
 
-  switch ((guint) event->any.type)
+  switch ((guint) type)
     {
     case GDK_BUTTON_PRESS:
     case GDK_BUTTON_RELEASE:
-      return gdk_event_button_new (event->any.type,
+      return gdk_event_button_new (type,
                                    new_surface,
-                                   event->any.device,
-                                   event->any.source_device,
-                                   event->button.tool,
-                                   event->button.time,
-                                   event->button.state,
-                                   event->button.button,
+                                   gdk_event_get_device (event),
+                                   gdk_event_get_source_device (event),
+                                   gdk_event_get_device_tool (event),
+                                   gdk_event_get_time (event),
+                                   gdk_event_get_modifier_state (event),
+                                   gdk_button_event_get_button (event),
                                    x, y,
                                    NULL); // FIXME copy axes
     case GDK_MOTION_NOTIFY:
       return gdk_event_motion_new (new_surface,
-                                   event->any.device,
-                                   event->any.source_device,
-                                   event->motion.tool,
-                                   event->motion.time,
-                                   event->motion.state,
+                                   gdk_event_get_device (event),
+                                   gdk_event_get_source_device (event),
+                                   gdk_event_get_device_tool (event),
+                                   gdk_event_get_time (event),
+                                   gdk_event_get_modifier_state (event),
                                    x, y,
                                    NULL); // FIXME copy axes
     case GDK_TOUCH_BEGIN:
     case GDK_TOUCH_UPDATE:
     case GDK_TOUCH_END:
     case GDK_TOUCH_CANCEL:
-      return gdk_event_touch_new (event->any.type,
-                                  event->touch.sequence,
+      return gdk_event_touch_new (type,
+                                  gdk_event_get_event_sequence (event),
                                   new_surface,
-                                  event->any.device,
-                                  event->any.source_device,
-                                  event->touch.time,
-                                  event->touch.state,
+                                  gdk_event_get_device (event),
+                                  gdk_event_get_source_device (event),
+                                  gdk_event_get_time (event),
+                                  gdk_event_get_modifier_state (event),
                                   x, y,
                                   NULL, // FIXME copy axes
-                                  event->touch.emulating_pointer);
+                                  gdk_touch_event_get_emulating_pointer (event));
     case GDK_TOUCHPAD_SWIPE:
+      gdk_touchpad_event_get_deltas (event, &dx, &dy);
       return gdk_event_touchpad_swipe_new (new_surface,
-                                           event->any.device,
-                                           event->any.source_device,
-                                           event->touchpad_swipe.time,
-                                           event->touchpad_swipe.state,
-                                           event->touchpad_swipe.phase,
+                                           gdk_event_get_device (event),
+                                           gdk_event_get_source_device (event),
+                                           gdk_event_get_time (event),
+                                           gdk_event_get_modifier_state (event),
+                                           gdk_touchpad_event_get_gesture_phase (event),
                                            x, y,
-                                           event->touchpad_swipe.n_fingers,
-                                           event->touchpad_swipe.dx,
-                                           event->touchpad_swipe.dy);
+                                           gdk_touchpad_event_get_n_fingers (event),
+                                           dx, dy);
     case GDK_TOUCHPAD_PINCH:
+      gdk_touchpad_event_get_deltas (event, &dx, &dy);
       return gdk_event_touchpad_pinch_new (new_surface,
-                                           event->any.device,
-                                           event->any.source_device,
-                                           event->touchpad_pinch.time,
-                                           event->touchpad_pinch.state,
-                                           event->touchpad_pinch.phase,
+                                           gdk_event_get_device (event),
+                                           gdk_event_get_source_device (event),
+                                           gdk_event_get_time (event),
+                                           gdk_event_get_modifier_state (event),
+                                           gdk_touchpad_event_get_gesture_phase (event),
                                            x, y,
-                                           event->touchpad_pinch.n_fingers,
-                                           event->touchpad_pinch.dx,
-                                           event->touchpad_pinch.dy,
-                                           event->touchpad_pinch.scale,
-                                           event->touchpad_pinch.angle_delta);
+                                           gdk_touchpad_event_get_n_fingers (event),
+                                           dx, dy,
+                                           gdk_touchpad_pinch_event_get_scale (event),
+                                           gdk_touchpad_pinch_event_get_angle_delta (event));
     default:
       break;
     }
@@ -1170,7 +1187,7 @@ rewrite_event_for_grabs (GdkEvent *event)
   GdkDisplay *display;
   GdkDevice *device;
 
-  switch ((guint) event->any.type)
+  switch ((guint) gdk_event_get_event_type (event))
     {
     case GDK_SCROLL:
     case GDK_BUTTON_PRESS:
@@ -1186,7 +1203,7 @@ rewrite_event_for_grabs (GdkEvent *event)
     case GDK_TOUCH_CANCEL:
     case GDK_TOUCHPAD_SWIPE:
     case GDK_TOUCHPAD_PINCH:
-      display = gdk_surface_get_display (event->any.surface);
+      display = gdk_event_get_display (event);
       device = gdk_event_get_device (event);
 
       if (!gdk_device_grab_info (display, device, &grab_surface, &owner_events) ||
@@ -1267,7 +1284,7 @@ translate_event_coordinates (GdkEvent  *event,
 
   *x = *y = 0;
 
-  if (!gdk_event_get_coords (event, &event_x, &event_y))
+  if (!gdk_event_get_position (event, &event_x, &event_y))
     return FALSE;
 
   event_widget = gtk_get_event_widget (event);
@@ -1349,7 +1366,7 @@ update_pointer_focus_state (GtkWindow *toplevel,
   if (old_target == new_target)
     return old_target;
 
-  gdk_event_get_coords (event, &x, &y);
+  gdk_event_get_position (event, &x, &y);
   gtk_window_update_pointer_focus (toplevel, device, sequence,
                                    new_target, x, y);
 
@@ -1359,7 +1376,7 @@ update_pointer_focus_state (GtkWindow *toplevel,
 static gboolean
 is_pointing_event (GdkEvent *event)
 {
-  switch ((guint) event->any.type)
+  switch ((guint) gdk_event_get_event_type (event))
     {
     case GDK_MOTION_NOTIFY:
     case GDK_ENTER_NOTIFY:
@@ -1383,7 +1400,7 @@ is_pointing_event (GdkEvent *event)
 static gboolean
 is_key_event (GdkEvent *event)
 {
-  switch ((guint) event->any.type)
+  switch ((guint) gdk_event_get_event_type (event))
     {
     case GDK_KEY_PRESS:
     case GDK_KEY_RELEASE:
@@ -1397,7 +1414,7 @@ is_key_event (GdkEvent *event)
 static gboolean
 is_focus_event (GdkEvent *event)
 {
-  switch ((guint) event->any.type)
+  switch ((guint) gdk_event_get_event_type (event))
     {
     case GDK_FOCUS_CHANGE:
       return TRUE;
@@ -1410,7 +1427,7 @@ is_focus_event (GdkEvent *event)
 static gboolean
 is_dnd_event (GdkEvent *event)
 {
-  switch ((guint) event->any.type)
+  switch ((guint) gdk_event_get_event_type (event))
     {
     case GDK_DRAG_ENTER:
     case GDK_DRAG_LEAVE:
@@ -1449,21 +1466,22 @@ handle_pointing_event (GdkEvent *event)
   GdkDevice *device;
   gdouble x, y;
   GtkWidget *native;
+  GdkEventType type;
 
   event_widget = gtk_get_event_widget (event);
   device = gdk_event_get_device (event);
-  if (!device || !gdk_event_get_coords (event, &x, &y))
-    return event_widget;
+  gdk_event_get_position (event, &x, &y);
 
   toplevel = GTK_WINDOW (gtk_widget_get_root (event_widget));
   native = GTK_WIDGET (gtk_widget_get_native (event_widget));
 
+  type = gdk_event_get_event_type (event);
   sequence = gdk_event_get_event_sequence (event);
 
-  switch ((guint) event->any.type)
+  switch ((guint) type)
     {
     case GDK_LEAVE_NOTIFY:
-      if (event->crossing.mode == GDK_CROSSING_NORMAL &&
+      if (gdk_crossing_event_get_mode (event) == GDK_CROSSING_NORMAL &&
           gtk_window_lookup_pointer_focus_implicit_grab (toplevel, device, NULL))
         {
           /* We have an implicit grab, wait for the corresponding
@@ -1475,14 +1493,13 @@ handle_pointing_event (GdkEvent *event)
     case GDK_TOUCH_END:
     case GDK_TOUCH_CANCEL:
       old_target = update_pointer_focus_state (toplevel, event, NULL);
-
-      if (event->any.type == GDK_LEAVE_NOTIFY)
+      if (type == GDK_LEAVE_NOTIFY)
         gtk_synthesize_crossing_events (GTK_ROOT (toplevel), old_target, NULL,
-                                        event, event->crossing.mode);
+                                        event, gdk_crossing_event_get_mode (event));
       break;
     case GDK_ENTER_NOTIFY:
-      if (event->crossing.mode == GDK_CROSSING_GRAB ||
-          event->crossing.mode == GDK_CROSSING_UNGRAB)
+      if (gdk_crossing_event_get_mode (event) == GDK_CROSSING_GRAB ||
+          gdk_crossing_event_get_mode (event) == GDK_CROSSING_UNGRAB)
         break;
       G_GNUC_FALLTHROUGH;
     case GDK_TOUCH_BEGIN:
@@ -1498,7 +1515,7 @@ handle_pointing_event (GdkEvent *event)
 
       old_target = update_pointer_focus_state (toplevel, event, target);
 
-      if (event->any.type == GDK_MOTION_NOTIFY || event->any.type == GDK_ENTER_NOTIFY)
+      if (type == GDK_MOTION_NOTIFY || type == GDK_ENTER_NOTIFY)
         {
           if (!gtk_window_lookup_pointer_focus_implicit_grab (toplevel, device,
                                                               sequence))
@@ -1510,7 +1527,7 @@ handle_pointing_event (GdkEvent *event)
           gtk_window_maybe_update_cursor (toplevel, NULL, device);
         }
 
-      if (event->any.type == GDK_TOUCH_BEGIN)
+      if (type == GDK_TOUCH_BEGIN)
         gtk_window_set_pointer_focus_grab (toplevel, device, sequence, target);
 
       /* Let it take the effective pointer focus anyway, as it may change due
@@ -1524,10 +1541,10 @@ handle_pointing_event (GdkEvent *event)
                                                                  device,
                                                                  sequence);
       gtk_window_set_pointer_focus_grab (toplevel, device, sequence,
-                                         event->any.type == GDK_BUTTON_PRESS ?
+                                         type == GDK_BUTTON_PRESS ?
                                          target : NULL);
 
-      if (event->any.type == GDK_BUTTON_RELEASE)
+      if (type == GDK_BUTTON_RELEASE)
         {
           GtkWidget *new_target;
           new_target = gtk_widget_pick (GTK_WIDGET (native), x, y, GTK_PICK_DEFAULT);
@@ -1538,7 +1555,7 @@ handle_pointing_event (GdkEvent *event)
           gtk_window_maybe_update_cursor (toplevel, NULL, device);
         }
 
-      set_widget_active_state (target, event->any.type == GDK_BUTTON_RELEASE);
+      set_widget_active_state (target, type == GDK_BUTTON_RELEASE);
 
       break;
     case GDK_SCROLL:
@@ -1578,9 +1595,7 @@ handle_dnd_event (GdkEvent *event)
 
   event_widget = gtk_get_event_widget (event);
 
-  if (!gdk_event_get_coords (event, &x, &y))
-    return event_widget;
-
+  gdk_event_get_position (event, &x, &y);
   native = GTK_WIDGET (gtk_widget_get_native (event_widget));
   target = gtk_widget_pick (native, x, y, GTK_PICK_DEFAULT);
 
@@ -1630,9 +1645,9 @@ gtk_main_do_event (GdkEvent *event)
     target_widget = handle_pointing_event (event);
   else if (is_key_event (event))
     {
-      if (event->any.type == GDK_KEY_PRESS &&
+      if (gdk_event_get_event_type (event) == GDK_KEY_PRESS &&
           GTK_IS_WINDOW (target_widget) &&
-          gtk_window_activate_key (GTK_WINDOW (target_widget), (GdkEventKey *) event))
+          gtk_window_activate_key (GTK_WINDOW (target_widget), event))
         goto cleanup;
 
       target_widget = handle_key_event (event);
@@ -1666,7 +1681,7 @@ gtk_main_do_event (GdkEvent *event)
    * This is the key to implementing modality.
    */
   if (!grab_widget ||
-      ((gtk_widget_is_sensitive (target_widget) || event->any.type == GDK_SCROLL) &&
+      ((gtk_widget_is_sensitive (target_widget) || gdk_event_get_event_type (event) == GDK_SCROLL) &&
        gtk_widget_is_ancestor (target_widget, grab_widget)))
     grab_widget = target_widget;
 
@@ -1695,7 +1710,7 @@ gtk_main_do_event (GdkEvent *event)
    * Drag events are also not redirected, since it isn't
    * clear what the semantics of that would be.
    */
-  switch ((guint)event->any.type)
+  switch ((guint)gdk_event_get_event_type (event))
     {
     case GDK_DELETE:
       g_object_ref (target_widget);
@@ -2162,7 +2177,10 @@ gtk_get_current_event_state (GdkModifierType *state)
   g_return_val_if_fail (state != NULL, FALSE);
 
   if (current_events)
-    return gdk_event_get_state (current_events->data, state);
+    {
+      *state = gdk_event_get_modifier_state (current_events->data);
+      return TRUE;
+    }
   else
     {
       *state = 0;
@@ -2198,17 +2216,16 @@ gtk_get_current_event_device (void)
  * Returns: (transfer none) (nullable): the widget that originally
  *     received @event, or %NULL
  */
-GtkWidget*
+GtkWidget *
 gtk_get_event_widget (GdkEvent *event)
 {
-  GtkWidget *widget;
+  GdkSurface *surface;
 
-  widget = NULL;
-  if (event && event->any.surface &&
-      (!gdk_surface_is_destroyed (event->any.surface)))
-    widget = gtk_native_get_for_surface (event->any.surface);
+  surface = gdk_event_get_surface (event);
+  if (surface && !gdk_surface_is_destroyed (surface))
+    return gtk_native_get_for_surface (surface);
 
-  return widget;
+  return NULL;
 }
 
 static gboolean
@@ -2235,7 +2252,7 @@ propagate_event_up (GtkWidget *widget,
        * event
        */
       if (!gtk_widget_is_sensitive (widget))
-        handled_event = event->any.type != GDK_SCROLL;
+        handled_event = gdk_event_get_event_type (event) != GDK_SCROLL;
       else if (gtk_widget_get_realized (widget))
         handled_event = gtk_widget_event (widget, event, target);
 
@@ -2288,7 +2305,7 @@ propagate_event_down (GtkWidget *widget,
           /* stop propagating on SCROLL, but don't handle the event, so it
            * can propagate up again and reach its handling widget
            */
-          if (event->any.type == GDK_SCROLL)
+          if (gdk_event_get_event_type (event) == GDK_SCROLL)
             break;
           else
             handled_event = TRUE;
diff --git a/gtk/gtkmountoperation.c b/gtk/gtkmountoperation.c
index 3be232061c..a9feb8dde5 100644
--- a/gtk/gtkmountoperation.c
+++ b/gtk/gtkmountoperation.c
@@ -1424,12 +1424,12 @@ do_popup_menu_for_process_tree_view (GtkWidget         *widget,
                     op);
   gtk_container_add (GTK_CONTAINER (menu), item);
 
-  if (event && gdk_event_triggers_context_menu (event) &&
-      gdk_event_get_coords (event, &x, &y))
+  if (event && gdk_event_triggers_context_menu (event))
     {
       GtkTreePath *path;
       GtkTreeSelection *selection;
 
+      gdk_event_get_position (event, &x, &y);
       if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (op->priv->process_tree_view),
                                          (gint) x,
                                          (gint) y,
diff --git a/gtk/gtkpadcontroller.c b/gtk/gtkpadcontroller.c
index 455d538982..d3efc61426 100644
--- a/gtk/gtkpadcontroller.c
+++ b/gtk/gtkpadcontroller.c
@@ -240,7 +240,7 @@ gtk_pad_controller_handle_event (GtkEventController *controller,
   guint index, mode, group;
   gdouble value = 0;
 
-  gdk_event_get_pad_group_mode (event, &group, &mode);
+  gdk_pad_event_get_group_mode (event, &group, &mode);
   if (event_type == GDK_PAD_GROUP_MODE)
     {
       gtk_pad_controller_handle_mode_switch (pad_controller,
@@ -254,13 +254,13 @@ gtk_pad_controller_handle_event (GtkEventController *controller,
     {
     case GDK_PAD_BUTTON_PRESS:
       type = GTK_PAD_ACTION_BUTTON;
-      gdk_event_get_pad_button (event, &index);
+      index = gdk_pad_button_event_get_button (event);
       break;
     case GDK_PAD_RING:
     case GDK_PAD_STRIP:
       type = event_type == GDK_PAD_RING ?
         GTK_PAD_ACTION_RING : GTK_PAD_ACTION_STRIP;
-      gdk_event_get_pad_axis_value (event, &index, &value);
+      gdk_pad_axis_event_get_value (event, &index, &value);
       break;
     default:
       return GDK_EVENT_PROPAGATE;
diff --git a/gtk/gtkrange.c b/gtk/gtkrange.c
index 8987ed62ca..a09d8b6e8a 100644
--- a/gtk/gtkrange.c
+++ b/gtk/gtkrange.c
@@ -1866,7 +1866,7 @@ gtk_range_click_gesture_pressed (GtkGestureClick *gesture,
   sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
   button = gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture));
   event = gtk_gesture_get_last_event (GTK_GESTURE (gesture), sequence);
-  gdk_event_get_state (event, &state_mask);
+  state_mask = gdk_event_get_modifier_state (event);
   shift_pressed = (state_mask & GDK_SHIFT_MASK) != 0;
 
   source_device = gdk_event_get_source_device ((GdkEvent *) event);
diff --git a/gtk/gtkscrolledwindow.c b/gtk/gtkscrolledwindow.c
index f9190e4a15..ca035f5c2b 100644
--- a/gtk/gtkscrolledwindow.c
+++ b/gtk/gtkscrolledwindow.c
@@ -1200,7 +1200,7 @@ captured_motion (GtkScrolledWindow *sw,
   if (priv->vscrollbar_visible)
     indicator_start_fade (&priv->vindicator, 1.0);
 
-  gdk_event_get_state (event, &state);
+  state = gdk_event_get_modifier_state (event);
 
   target = gtk_widget_pick (GTK_WIDGET (sw), x, y, GTK_PICK_DEFAULT);
 
diff --git a/gtk/gtktext.c b/gtk/gtktext.c
index 85c0f6bc37..00c07d6d3f 100644
--- a/gtk/gtktext.c
+++ b/gtk/gtktext.c
@@ -2624,7 +2624,7 @@ gtk_text_click_gesture_pressed (GtkGestureClick *gesture,
       priv->select_words = FALSE;
       priv->select_lines = FALSE;
 
-      gdk_event_get_state (event, &state);
+      state = gdk_event_get_modifier_state (event);
 
       extend_selection =
         (state &
diff --git a/gtk/gtktextview.c b/gtk/gtktextview.c
index 4d1ef31c72..c161237831 100644
--- a/gtk/gtktextview.c
+++ b/gtk/gtktextview.c
@@ -5178,14 +5178,6 @@ gtk_text_view_click_gesture_pressed (GtkGestureClick *gesture,
                                   GTK_EVENT_SEQUENCE_CLAIMED);
   gtk_text_view_reset_blink_time (text_view);
 
-#if 0
-  /* debug hack */
-  if (event->button == GDK_BUTTON_SECONDARY && (event->state & GDK_CONTROL_MASK) != 0)
-    _gtk_text_buffer_spew (GTK_TEXT_VIEW (widget)->buffer);
-  else if (event->button == GDK_BUTTON_SECONDARY)
-    gtk_text_layout_spew (GTK_TEXT_VIEW (widget)->layout);
-#endif
-
   device = gdk_event_get_source_device ((GdkEvent *) event);
   is_touchscreen = gtk_simulate_touchscreen () ||
                    gdk_device_get_source (device) == GDK_SOURCE_TOUCHSCREEN;
@@ -5218,7 +5210,7 @@ gtk_text_view_click_gesture_pressed (GtkGestureClick *gesture,
       gboolean extends = FALSE;
       GdkModifierType state;
 
-      gdk_event_get_state (event, &state);
+      state = gdk_event_get_modifier_state (event);
 
       if (state &
           gtk_widget_get_modifier_mask (GTK_WIDGET (text_view),
diff --git a/gtk/gtktooltip.c b/gtk/gtktooltip.c
index dd04c19e4e..f611b4f562 100644
--- a/gtk/gtktooltip.c
+++ b/gtk/gtktooltip.c
@@ -851,7 +851,7 @@ tooltips_enabled (GdkEvent *event)
       return FALSE;
     }
 
-  gdk_event_get_state (event, &event_state);
+  event_state = gdk_event_get_modifier_state (event);
   if ((event_state &
        (GDK_BUTTON1_MASK |
         GDK_BUTTON2_MASK |
@@ -886,7 +886,7 @@ _gtk_tooltip_handle_event (GtkWidget *target,
 
   event_type = gdk_event_get_event_type (event);
   surface = gdk_event_get_surface (event);
-  gdk_event_get_coords (event, &dx, &dy);
+  gdk_event_get_position (event, &dx, &dy);
 
   gtk_tooltip_handle_event_internal (event_type, surface, target, dx, dy);
 }
diff --git a/gtk/gtktreeview.c b/gtk/gtktreeview.c
index ed40f73377..7a0585c645 100644
--- a/gtk/gtktreeview.c
+++ b/gtk/gtktreeview.c
@@ -2947,7 +2947,7 @@ gtk_tree_view_click_gesture_pressed (GtkGestureClick *gesture,
 
   sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
   event = gtk_gesture_get_last_event (GTK_GESTURE (gesture), sequence);
-  gdk_event_get_state (event, &modifiers);
+  modifiers = gdk_event_get_modifier_state (event);
 
   /* decide if we edit */
   if (button == GDK_BUTTON_PRIMARY &&
diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c
index 591086d8f1..cfb0708a6d 100644
--- a/gtk/gtkwidget.c
+++ b/gtk/gtkwidget.c
@@ -2074,70 +2074,84 @@ _gtk_widget_emulate_press (GtkWidget      *widget,
   if (event_widget == widget)
     return;
 
-  gdk_event_get_coords (event, &x, &y);
-  if (!gtk_widget_compute_point (event_widget,
-                                 GTK_WIDGET (gtk_widget_get_root (event_widget)),
-                                 &GRAPHENE_POINT_INIT (x, y),
-                                 &p))
+  switch ((guint) gdk_event_get_event_type (event))
+    {
+    case GDK_TOUCH_BEGIN:
+    case GDK_TOUCH_UPDATE:
+    case GDK_TOUCH_END:
+    case GDK_BUTTON_PRESS:
+    case GDK_BUTTON_RELEASE:
+    case GDK_MOTION_NOTIFY:
+      gdk_event_get_position (event, &x, &y);
+      if (!gtk_widget_compute_point (event_widget,
+                                     GTK_WIDGET (gtk_widget_get_root (event_widget)),
+                                     &GRAPHENE_POINT_INIT (x, y),
+                                     &p))
+        return;
+      break;
+    default:
       return;
+    }
 
-  if (event->any.type == GDK_TOUCH_BEGIN ||
-      event->any.type == GDK_TOUCH_UPDATE ||
-      event->any.type == GDK_TOUCH_END)
+  switch ((guint) gdk_event_get_event_type (event))
     {
+    case GDK_TOUCH_BEGIN:
+    case GDK_TOUCH_UPDATE:
+    case GDK_TOUCH_END:
       press = gdk_event_touch_new (GDK_TOUCH_BEGIN,
-                                   event->touch.sequence,
-                                   event->any.surface,
-                                   event->any.device,
-                                   event->any.source_device,
-                                   event->touch.time,
-                                   event->touch.state,
+                                   gdk_event_get_event_sequence (event),
+                                   gdk_event_get_surface (event),
+                                   gdk_event_get_device (event),
+                                   gdk_event_get_source_device (event),
+                                   gdk_event_get_time (event),
+                                   gdk_event_get_modifier_state (event),
                                    p.x, p.y,
                                    NULL,
-                                   event->touch.emulating_pointer);
-    }
-  else if (event->any.type == GDK_BUTTON_PRESS ||
-           event->any.type == GDK_BUTTON_RELEASE)
-    {
-      press = gdk_event_button_new (GDK_BUTTON_PRESS,
-                                    event->any.surface,
-                                    event->any.device,
-                                    event->any.source_device,
-                                    event->button.tool,
-                                    event->button.time,
-                                    event->button.state,
-                                    event->button.button,
-                                    p.x, p.y,
-                                    NULL);
-    }
-  else if (event->any.type == GDK_MOTION_NOTIFY)
-    {
-      int button;
-      if (event->motion.state & GDK_BUTTON3_MASK)
-        button = 3;
-      else if (event->motion.state & GDK_BUTTON2_MASK)
-        button = 2;
-      else
-        {
-          if ((event->motion.state & GDK_BUTTON1_MASK) == 0)
-            g_critical ("Guessing button number 1 on generated button press event");
-
-          button = 1;
-        }
-
+                                   gdk_touch_event_get_emulating_pointer (event));
+      break;
+    case GDK_BUTTON_PRESS:
+    case GDK_BUTTON_RELEASE:
       press = gdk_event_button_new (GDK_BUTTON_PRESS,
-                                    event->any.surface,
-                                    event->any.device,
-                                    event->any.source_device,
-                                    NULL,
-                                    event->motion.time,
-                                    event->motion.state,
-                                    button,
+                                    gdk_event_get_surface (event),
+                                    gdk_event_get_device (event),
+                                    gdk_event_get_source_device (event),
+                                    gdk_event_get_device_tool (event),
+                                    gdk_event_get_time (event),
+                                    gdk_event_get_modifier_state (event),
+                                    gdk_button_event_get_button (event),
                                     p.x, p.y,
                                     NULL);
+      break;
+    case GDK_MOTION_NOTIFY:
+      {
+        GdkModifierType state = gdk_event_get_modifier_state (event);
+        int button;
+        if (state & GDK_BUTTON3_MASK)
+          button = 3;
+        else if (state & GDK_BUTTON2_MASK)
+          button = 2;
+        else
+          {
+            if ((state & GDK_BUTTON1_MASK) == 0)
+              g_critical ("Guessing button number 1 on generated button press event");
+            button = 1;
+          }
+
+        press = gdk_event_button_new (GDK_BUTTON_PRESS,
+                                      gdk_event_get_surface (event),
+                                      gdk_event_get_device (event),
+                                      gdk_event_get_source_device (event),
+                                      gdk_event_get_device_tool (event),
+                                      gdk_event_get_time (event),
+                                      gdk_event_get_modifier_state (event),
+                                      button,
+                                      p.x, p.y,
+                                      NULL);
+      }
+      break;
+    default:
+      g_assert_not_reached ();
     }
-  else
-    return;
 
   next_child = event_widget;
   parent = _gtk_widget_get_parent (next_child);
@@ -2200,10 +2214,10 @@ _gtk_widget_get_emulating_sequence (GtkWidget         *widget,
       last_event = _gtk_widget_get_last_event (widget, sequence, &target);
 
       if (last_event &&
-          (last_event->any.type == GDK_TOUCH_BEGIN ||
-           last_event->any.type == GDK_TOUCH_UPDATE ||
-           last_event->any.type == GDK_TOUCH_END) &&
-          last_event->touch.emulating_pointer)
+          (gdk_event_get_event_type (last_event) == GDK_TOUCH_BEGIN ||
+           gdk_event_get_event_type (last_event) == GDK_TOUCH_UPDATE ||
+           gdk_event_get_event_type (last_event) == GDK_TOUCH_END) &&
+           gdk_touch_event_get_emulating_pointer (last_event))
         return TRUE;
     }
   else
@@ -4770,7 +4784,7 @@ gtk_widget_real_mnemonic_activate (GtkWidget *widget,
 }
 
 #define WIDGET_REALIZED_FOR_EVENT(widget, event) \
-     (event->any.type == GDK_FOCUS_CHANGE || _gtk_widget_get_realized(widget))
+     (gdk_event_get_event_type (event) == GDK_FOCUS_CHANGE || _gtk_widget_get_realized (widget))
 
 /**
  * gtk_widget_event:
@@ -4917,7 +4931,7 @@ event_surface_is_still_viewable (GdkEvent *event)
    * at the last moment, since the event may have been queued
    * up behind other events, held over a recursive main loop, etc.
    */
-  switch ((guint) event->any.type)
+  switch ((guint) gdk_event_get_event_type (event))
     {
     case GDK_MOTION_NOTIFY:
     case GDK_BUTTON_PRESS:
@@ -4925,7 +4939,7 @@ event_surface_is_still_viewable (GdkEvent *event)
     case GDK_ENTER_NOTIFY:
     case GDK_PROXIMITY_IN:
     case GDK_SCROLL:
-      return event->any.surface && gdk_surface_is_viewable (event->any.surface);
+      return gdk_surface_is_viewable (gdk_event_get_surface (event));
 
 #if 0
     /* The following events are the second half of paired events;
@@ -4958,7 +4972,7 @@ translate_event_coordinates (GdkEvent  *event,
 
   *x = *y = 0;
 
-  if (!gdk_event_get_coords (event, &event_x, &event_y))
+  if (!gdk_event_get_position (event, &event_x, &event_y))
     return FALSE;
 
   event_widget = gtk_get_event_widget (event);
@@ -5003,8 +5017,8 @@ gtk_widget_event_internal (GtkWidget *widget,
     return_val |= gtk_widget_run_controllers (widget, event, target, x, y, GTK_PHASE_BUBBLE);
 
   if (return_val == FALSE &&
-      (event->any.type == GDK_KEY_PRESS ||
-       event->any.type == GDK_KEY_RELEASE))
+      (gdk_event_get_event_type (event) == GDK_KEY_PRESS ||
+       gdk_event_get_event_type (event) == GDK_KEY_RELEASE))
     return_val |= gtk_bindings_activate_event (G_OBJECT (widget), (GdkEventKey *) event);
 
   return return_val;
diff --git a/gtk/gtkwindow.c b/gtk/gtkwindow.c
index 6e742f1257..ecfc9cc718 100644
--- a/gtk/gtkwindow.c
+++ b/gtk/gtkwindow.c
@@ -1430,7 +1430,7 @@ click_gesture_pressed_cb (GtkGestureClick *gesture,
           double tx, ty;
           gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
 
-          gdk_event_get_coords (event, &tx, &ty);
+          gdk_event_get_position (event, &tx, &ty);
           gdk_surface_begin_resize_drag_for_device (priv->surface,
                                                    (GdkSurfaceEdge) region,
                                                    gdk_event_get_device ((GdkEvent *) event),
@@ -5997,7 +5997,7 @@ _gtk_window_query_nonaccels (GtkWindow      *window,
 /**
  * gtk_window_propagate_key_event:
  * @window:  a #GtkWindow
- * @event:   a #GdkEventKey
+ * @event:   a #GdkEvent
  *
  * Propagate a key press or release event to the focus widget and
  * up the focus container chain until a widget handles @event.
@@ -6009,8 +6009,8 @@ _gtk_window_query_nonaccels (GtkWindow      *window,
  * Returns: %TRUE if a widget in the focus chain handled the event.
  */
 gboolean
-gtk_window_propagate_key_event (GtkWindow        *window,
-                                GdkEventKey      *event)
+gtk_window_propagate_key_event (GtkWindow *window,
+                                GdkEvent  *event)
 {
   GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
   gboolean handled = FALSE;
@@ -8187,8 +8187,8 @@ _gtk_window_set_window_group (GtkWindow      *window,
 }
 
 static gboolean
-gtk_window_activate_menubar (GtkWindow   *window,
-                             GdkEventKey *event)
+gtk_window_activate_menubar (GtkWindow *window,
+                             GdkEvent  *event)
 {
   GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
   guint keyval = 0;
@@ -8202,12 +8202,16 @@ gtk_window_activate_menubar (GtkWindow   *window,
       return FALSE;
     }
 
+  if (!(gdk_event_get_event_type (event) == GDK_KEY_PRESS ||
+        gdk_event_get_event_type (event) == GDK_KEY_RELEASE))
+    return FALSE;
+
   /* FIXME this is wrong, needs to be in the global accel resolution
    * thing, to properly consider i18n etc., but that probably requires
    * AccelGroup changes etc.
    */
-  if (event->keyval == keyval &&
-      ((event->state & gtk_accelerator_get_default_mod_mask ()) ==
+  if (gdk_key_event_get_keyval (event) == keyval &&
+      ((gdk_event_get_modifier_state (event) & gtk_accelerator_get_default_mod_mask ()) ==
        (mods & gtk_accelerator_get_default_mod_mask ())))
     {
       GList *tmp_menubars, *l;
@@ -8391,7 +8395,7 @@ gtk_window_free_key_hash (GtkWindow *window)
 /**
  * gtk_window_activate_key:
  * @window:  a #GtkWindow
- * @event:   a #GdkEventKey
+ * @event:   a #GdkEvent
  *
  * Activates mnemonics and accelerators for this #GtkWindow. This is normally
  * called by the default ::key_press_event handler for toplevel windows,
@@ -8401,8 +8405,8 @@ gtk_window_free_key_hash (GtkWindow *window)
  * Returns: %TRUE if a mnemonic or accelerator was found and activated.
  */
 gboolean
-gtk_window_activate_key (GtkWindow   *window,
-                        GdkEventKey *event)
+gtk_window_activate_key (GtkWindow *window,
+                        GdkEvent  *event)
 {
   GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
   GtkKeyHash *key_hash;
@@ -8412,16 +8416,20 @@ gtk_window_activate_key (GtkWindow   *window,
   g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
 
+  if (!(gdk_event_get_event_type (event) == GDK_KEY_PRESS ||
+        gdk_event_get_event_type (event) == GDK_KEY_RELEASE))
+    return FALSE;
+
   key_hash = gtk_window_get_key_hash (window);
 
   if (key_hash)
     {
       GSList *tmp_list;
       GSList *entries = _gtk_key_hash_lookup (key_hash,
-                                             event->hardware_keycode,
-                                             event->state,
+                                             gdk_key_event_get_keycode (event),
+                                              gdk_event_get_modifier_state (event),
                                              gtk_accelerator_get_default_mod_mask (),
-                                             event->group);
+                                             gdk_key_event_get_group (event));
 
       g_object_get (gtk_widget_get_settings (GTK_WIDGET (window)),
                     "gtk-enable-accels", &enable_accels,
diff --git a/gtk/gtkwindow.h b/gtk/gtkwindow.h
index eedbc5df2f..a9274bbaac 100644
--- a/gtk/gtkwindow.h
+++ b/gtk/gtkwindow.h
@@ -230,10 +230,10 @@ GdkModifierType gtk_window_get_mnemonic_modifier (GtkWindow *window);
 
 GDK_AVAILABLE_IN_ALL
 gboolean gtk_window_activate_key          (GtkWindow        *window,
-                                          GdkEventKey      *event);
+                                          GdkEvent         *event);
 GDK_AVAILABLE_IN_ALL
 gboolean gtk_window_propagate_key_event   (GtkWindow        *window,
-                                          GdkEventKey      *event);
+                                          GdkEvent         *event);
 
 GDK_AVAILABLE_IN_ALL
 void     gtk_window_present            (GtkWindow *window);
diff --git a/gtk/inspector/inspect-button.c b/gtk/inspector/inspect-button.c
index ce74517ae9..9ecb168dd8 100644
--- a/gtk/inspector/inspect-button.c
+++ b/gtk/inspector/inspect-button.c
@@ -135,7 +135,7 @@ handle_event (GtkInspectorWindow *iw, GdkEvent *event)
       {
         guint keyval = 0;
 
-        gdk_event_get_keyval (event, &keyval);
+        keyval = gdk_key_event_get_keyval (event);
         if (keyval == GDK_KEY_Escape)
           {
             g_signal_handlers_disconnect_by_func (iw, handle_event, NULL);
diff --git a/tests/testwindowdrag.c b/tests/testwindowdrag.c
index 578462f705..90dc9766b6 100644
--- a/tests/testwindowdrag.c
+++ b/tests/testwindowdrag.c
@@ -20,7 +20,10 @@ start_resize (GtkGestureClick *gesture,
 
   surface = gtk_native_get_surface (gtk_widget_get_native (widget));
   event = gtk_get_current_event ();
-  gdk_event_get_button (event, &button);  
+  if (gdk_event_get_event_type (event) == GDK_BUTTON_PRESS)
+    button = gdk_button_event_get_button (event);  
+  else
+    button = 0;
   timestamp = gdk_event_get_time (event);
 
   gtk_widget_translate_coordinates (widget, GTK_WIDGET (gtk_widget_get_root (widget)),
@@ -65,7 +68,10 @@ start_move (GtkGestureClick *gesture,
 
   surface = gtk_native_get_surface (gtk_widget_get_native (widget));
   event = gtk_get_current_event ();
-  gdk_event_get_button (event, &button);  
+  if (gdk_event_get_event_type (event) == GDK_BUTTON_PRESS)
+    button = gdk_button_event_get_button (event);  
+  else
+    button = 0;
   timestamp = gdk_event_get_time (event);
 
   gtk_widget_translate_coordinates (widget, GTK_WIDGET (gtk_widget_get_root (widget)),


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]