search bar: Stop using ::key-press-event

Use a key event controller instead.

demos/gtk-demo/font-features.ui

@@ -132,7 +132,6 @@
 Разъяренный чтец эгоистично бьёт пятью жердями шустрого фехтовальщика. Наш банк вчера же выплатил Ф.Я. Эйхгольду комиссию за ценные вещи. Эх, чужак, общий съём цен шляп (юфть) – вдрызг! В чащах юга жил бы цитрус? Да, но фальшивый экземпляр!
 
 Τάχιστη αλώπηξ βαφής ψημένη γη, δρασκελίζει υπέρ νωθρού κυνός</property>
-                    <signal name="key-press-event" handler="entry_key_press"/>
                     <signal name="activate" handler="stop_edit"/>
                     <property name="valign">start</property>
                     <property name="width-chars">50</property>

demos/gtk-demo/font_features.c

@@ -1669,12 +1669,12 @@ stop_edit (void)
 }
 
 static gboolean
-entry_key_press (GtkEntry *entry, GdkEventKey *event)
+entry_key_press (GtkEventController *controller,
+                 guint               keyval,
+                 guint               keycode,
+                 GdkModifierType     modifiers,
+                 GtkEntry           *entry)
 {
-  guint keyval;
-
-  gdk_event_get_keyval ((GdkEvent *)event, &keyval);
-
   if (keyval == GDK_KEY_Escape)
     {
       gtk_entry_set_text (GTK_ENTRY (entry), text);
@@ -1694,6 +1694,7 @@ do_font_features (GtkWidget *do_widget)
     {
       GtkBuilder *builder;
       GtkWidget *feature_list;
+      GtkEventController *controller;
 
       builder = gtk_builder_new_from_resource ("/font_features/font-features.ui");
 
@@ -1703,7 +1704,6 @@ do_font_features (GtkWidget *do_widget)
       gtk_builder_add_callback_symbol (builder, "reset", reset_features);
       gtk_builder_add_callback_symbol (builder, "stop_edit", G_CALLBACK (stop_edit));
       gtk_builder_add_callback_symbol (builder, "toggle_edit", G_CALLBACK (toggle_edit));
-      gtk_builder_add_callback_symbol (builder, "entry_key_press", G_CALLBACK (entry_key_press));
       gtk_builder_connect_signals (builder, NULL);
 
       window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
@@ -1718,6 +1718,10 @@ do_font_features (GtkWidget *do_widget)
       entry = GTK_WIDGET (gtk_builder_get_object (builder, "entry"));
       edit_toggle = GTK_WIDGET (gtk_builder_get_object (builder, "edit_toggle"));
 
+      controller = gtk_event_controller_key_new (entry);
+      g_object_set_data_full (G_OBJECT (entry), "controller", controller, g_object_unref);
+      g_signal_connect (controller, "key-pressed", G_CALLBACK (entry_key_press), entry);
+
       add_check_group (feature_list, _("Kerning"), (const char *[]){ "kern", NULL });
       add_check_group (feature_list, _("Ligatures"), (const char *[]){ "liga",
                                                                        "dlig",

demos/gtk-demo/hypertext.c

@@ -105,14 +105,14 @@ follow_if_link (GtkWidget   *text_view,
 /* Links can be activated by pressing Enter.
  */
 static gboolean
-key_press_event (GtkWidget *text_view,
-                 GdkEventKey *event)
+key_pressed (GtkEventController *controller,
+             guint               keyval,
+             guint               keycode,
+             GdkModifierType     modifiers,
+             GtkWidget          *text_view)
 {
   GtkTextIter iter;
   GtkTextBuffer *buffer;
-  guint keyval;
-
-  gdk_event_get_keyval ((GdkEvent *)event, &keyval);
 
   switch (keyval)
     {
@@ -128,7 +128,7 @@ key_press_event (GtkWidget *text_view,
         break;
     }
 
-  return FALSE;
+  return GDK_EVENT_PROPAGATE;
 }
 
 static void set_cursor_if_appropriate (GtkTextView *text_view,
@@ -241,6 +241,7 @@ do_hypertext (GtkWidget *do_widget)
       GtkWidget *view;
       GtkWidget *sw;
       GtkTextBuffer *buffer;
+      GtkEventController *controller;
 
       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
       gtk_window_set_title (GTK_WINDOW (window), "Hypertext");
@@ -255,8 +256,9 @@ do_hypertext (GtkWidget *do_widget)
       gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view), GTK_WRAP_WORD);
       gtk_text_view_set_left_margin (GTK_TEXT_VIEW (view), 20);
       gtk_text_view_set_right_margin (GTK_TEXT_VIEW (view), 20);
-      g_signal_connect (view, "key-press-event",
-                        G_CALLBACK (key_press_event), NULL);
+      controller = gtk_event_controller_key_new (view);
+      g_object_set_data_full (G_OBJECT (view), "controller", controller, g_object_unref);
+      g_signal_connect (controller, "key-pressed", G_CALLBACK (key_pressed), view);
       g_signal_connect (view, "event",
                         G_CALLBACK (event_cb), NULL);
 

demos/gtk-demo/search_entry2.c

@@ -31,7 +31,10 @@ window_key_press_event_cb (GtkWidget    *widget,
 			   GdkEvent     *event,
 			   GtkSearchBar *bar)
 {
-  return gtk_search_bar_handle_event (bar, event);
+  if (gdk_event_get_event_type (event) == GDK_KEY_PRESS)
+    return gtk_search_bar_handle_event (bar, event);
+
+  return GDK_EVENT_PROPAGATE;
 }
 
 static void
@@ -99,8 +102,7 @@ do_search_entry2 (GtkWidget *do_widget)
       gtk_box_pack_start (GTK_BOX (vbox), searchbar);
 
       /* Hook the search bar to key presses */
-      g_signal_connect (window, "key-press-event",
-                        G_CALLBACK (window_key_press_event_cb), searchbar);
+      g_signal_connect (window, "event", G_CALLBACK (window_key_press_event_cb), searchbar);
 
       /* Help */
       label = gtk_label_new ("Start Typing to search");

demos/icon-browser/iconbrowserwin.c

@@ -54,6 +54,7 @@ struct _IconBrowserWindow
   GtkWidget *image6;
   GtkWidget *label6;
   GtkWidget *description;
+  GtkEventController *controller;
 };
 
 struct _IconBrowserWindowClass
@@ -286,13 +287,16 @@ populate (IconBrowserWindow *win)
 }
 
 static gboolean
-key_press_event_cb (GtkWidget *widget,
-                    GdkEvent  *event,
-                    gpointer   data)
+key_event_cb (GtkEventController *controller,
+              guint               keyval,
+              guint               keycode,
+              GdkModifierType     state,
+              gpointer            data)
 {
   IconBrowserWindow *win = data;
 
-  return gtk_search_bar_handle_event (GTK_SEARCH_BAR (win->searchbar), event);
+  return gtk_search_bar_handle_event (GTK_SEARCH_BAR (win->searchbar),
+                                      gtk_get_current_event ());
 }
 
 static void
@@ -480,12 +484,31 @@ icon_browser_window_init (IconBrowserWindow *win)
 
   symbolic_toggled (GTK_TOGGLE_BUTTON (win->symbolic_radio), win);
 
+  win->controller = gtk_event_controller_key_new (GTK_WIDGET (win));
+  g_signal_connect (win->controller, "key-pressed", G_CALLBACK (key_event_cb), win);
+
   populate (win);
 }
 
+static void
+icon_browser_window_finalize (GObject *object)
+{
+  IconBrowserWindow *win = ICON_BROWSER_WINDOW (win);
+
+  g_hash_table_unref (win->contexts);
+
+  g_object_unref (win->controller);
+
+  G_OBJECT_CLASS (icon_browser_window_parent_class)->finalize (object);
+}
+
 static void
 icon_browser_window_class_init (IconBrowserWindowClass *class)
 {
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+  object_class->finalize = icon_browser_window_finalize;
+
   g_type_ensure (ICON_STORE_TYPE);
 
   gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (class),
@@ -516,7 +539,6 @@ icon_browser_window_class_init (IconBrowserWindowClass *class)
   gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (class), item_activated);
   gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (class), selected_context_changed);
   gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (class), symbolic_toggled);
-  gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (class), key_press_event_cb);
   gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (class), copy_to_clipboard);
 }
 

demos/icon-browser/window.ui

@@ -9,7 +9,6 @@
     <property name="title" translatable="yes">Icon Browser</property>
     <property name="default-width">1024</property>
     <property name="default-height">768</property>
-    <signal name="key-press-event" handler="key_press_event_cb"/>
     <child type="titlebar">
       <object class="GtkHeaderBar" id="header">
         <property name="title" translatable="yes">Icon Browser</property>

examples/search-bar.c

@@ -1,11 +1,14 @@
 #include <gtk/gtk.h>
 
 static gboolean
-window_key_press_event_cb (GtkWidget *window,
-    GdkEvent *event,
-    GtkSearchBar *search_bar)
+window_key_pressed (GtkEventController *controller,
+                    guint               keyval,
+                    guint               keycode,
+                    GdkModifierType     state,
+                    GtkSearchBar       *search_bar)
 {
-  return gtk_search_bar_handle_event (search_bar, event);
+  return gtk_search_bar_handle_event (search_bar,
+                                      gtk_get_current_event ());
 }
 
 static void
@@ -17,6 +20,7 @@ activate_cb (GtkApplication *app,
   GtkWidget *box;
   GtkWidget *entry;
   GtkWidget *menu_button;
+  GtkEventController *controller;
 
   window = gtk_application_window_new (app);
   gtk_widget_show (window);
@@ -37,8 +41,10 @@ activate_cb (GtkApplication *app,
 
   gtk_search_bar_connect_entry (GTK_SEARCH_BAR (search_bar), GTK_ENTRY (entry));
 
-  g_signal_connect (window, "key-press-event",
-      G_CALLBACK (window_key_press_event_cb), search_bar);
+  controller = gtk_event_controller_key_new (window);
+  g_object_set_data_full (G_OBJECT (window), "controller", controller, g_object_unref);
+  g_signal_connect (controller, "key-pressed",
+                    G_CALLBACK (window_key_pressed), search_bar);
 }
 
 gint

gtk/gtk.h

@@ -93,6 +93,7 @@
 #include <gtk/gtkentrycompletion.h>
 #include <gtk/gtkenums.h>
 #include <gtk/gtkeventcontroller.h>
+#include <gtk/gtkeventcontrollerkey.h>
 #include <gtk/gtkeventcontrollermotion.h>
 #include <gtk/gtkeventcontrollerscroll.h>
 #include <gtk/gtkexpander.h>

gtk/gtkaboutdialog.c

@@ -60,6 +60,7 @@
 #include "gtkintl.h"
 #include "gtkdialogprivate.h"
 #include "gtkeventcontrollermotion.h"
+#include "gtkeventcontrollerkey.h"
 #include "gtkgesturemultipress.h"
 
 
@@ -188,6 +189,8 @@ struct _GtkAboutDialogPrivate
   GtkGesture *system_press;
   GtkEventController *license_motion;
   GtkEventController *system_motion;
+  GtkEventController *license_key;
+  GtkEventController *system_key;
 
   GtkLicense license_type;
 
@@ -244,8 +247,10 @@ static gboolean             gtk_about_dialog_activate_link  (GtkAboutDialog
                                                              const gchar        *uri);
 static gboolean             emit_activate_link              (GtkAboutDialog     *about,
 							     const gchar        *uri);
-static gboolean             text_view_key_press_event       (GtkWidget          *text_view,
-							     GdkEventKey        *event,
+static gboolean             text_view_key_pressed           (GtkEventController *controller,
+                                                             guint               keyval,
+                                                             guint               keycode,
+                                                             GdkModifierType     state,
 							     GtkAboutDialog     *about);
 static void                 text_view_released              (GtkGestureMultiPress *press,
                                                              int                   n,
@@ -609,7 +614,6 @@ gtk_about_dialog_class_init (GtkAboutDialogClass *klass)
   gtk_widget_class_bind_template_child_private (widget_class, GtkAboutDialog, system_view);
 
   gtk_widget_class_bind_template_callback (widget_class, emit_activate_link);
-  gtk_widget_class_bind_template_callback (widget_class, text_view_key_press_event);
   gtk_widget_class_bind_template_callback (widget_class, stack_visible_child_notify);
 }
 
@@ -781,6 +785,10 @@ gtk_about_dialog_init (GtkAboutDialog *about)
   g_signal_connect (priv->license_motion, "motion", G_CALLBACK (text_view_motion), about);
   priv->system_motion = gtk_event_controller_motion_new (priv->system_view);
   g_signal_connect (priv->system_motion, "motion", G_CALLBACK (text_view_motion), about);
+  priv->license_key = gtk_event_controller_key_new (priv->license_view);
+  g_signal_connect (priv->license_key, "key-pressed", G_CALLBACK (text_view_key_pressed), about);
+  priv->system_key = gtk_event_controller_key_new (priv->system_view);
+  g_signal_connect (priv->system_key, "key-pressed", G_CALLBACK (text_view_key_pressed), about);
 
   /* force defaults */
   gtk_about_dialog_set_program_name (about, NULL);
@@ -822,6 +830,8 @@ gtk_about_dialog_finalize (GObject *object)
   g_object_unref (priv->system_press);
   g_object_unref (priv->license_motion);
   g_object_unref (priv->system_motion);
+  g_object_unref (priv->license_key);
+  g_object_unref (priv->system_key);
 
   G_OBJECT_CLASS (gtk_about_dialog_parent_class)->finalize (object);
 }
@@ -1928,16 +1938,17 @@ follow_if_link (GtkAboutDialog *about,
 }
 
 static gboolean
-text_view_key_press_event (GtkWidget      *text_view,
-                           GdkEventKey    *event,
-                           GtkAboutDialog *about)
+text_view_key_pressed (GtkEventController *controller,
+                       guint               keyval,
+                       guint               keycode,
+                       GdkModifierType     state,
+                       GtkAboutDialog     *about)
 {
+  GtkWidget *text_view;
   GtkTextIter iter;
   GtkTextBuffer *buffer;
-  guint keyval;
 
-  if (!gdk_event_get_keyval ((GdkEvent *) event, &keyval))
-    return GDK_EVENT_PROPAGATE;
+  text_view = gtk_event_controller_get_widget (controller);
 
   switch (keyval)
     {

gtk/gtkappchooserdialog.c

@@ -331,11 +331,14 @@ widget_populate_popup_cb (GtkAppChooserWidget *widget,
 }
 
 static gboolean
-key_press_event_cb (GtkWidget    *widget,
-                    GdkEvent     *event,
-                    GtkSearchBar *bar)
+event_cb (GtkWidget    *widget,
+          GdkEvent     *event,
+          GtkSearchBar *bar)
 {
-  return gtk_search_bar_handle_event (bar, event);
+  if (gdk_event_get_event_type (event) == GDK_KEY_PRESS)
+    return gtk_search_bar_handle_event (bar, event);
+
+  return GDK_EVENT_PROPAGATE;
 }
 
 static void
@@ -372,8 +375,8 @@ construct_appchooser_widget (GtkAppChooserDialog *self)
 
   _gtk_app_chooser_widget_set_search_entry (GTK_APP_CHOOSER_WIDGET (self->priv->app_chooser_widget),
                                             GTK_ENTRY (self->priv->search_entry));
-  g_signal_connect (self, "key-press-event",
-                    G_CALLBACK (key_press_event_cb), self->priv->search_bar);
+  g_signal_connect (self, "event",
+                    G_CALLBACK (event_cb), self->priv->search_bar);
 }
 
 static void

gtk/gtkcoloreditor.c

@@ -33,6 +33,7 @@
 #include "gtklabel.h"
 #include "gtkspinbutton.h"
 #include "gtkstylecontext.h"
+#include "gtkeventcontrollerkey.h"
 
 #include <math.h>
 
@@ -60,6 +61,11 @@ struct _GtkColorEditorPrivate
   GtkAdjustment *v_adj;
   GtkAdjustment *a_adj;
 
+  GtkEventController *h_key;
+  GtkEventController *s_key;
+  GtkEventController *v_key;
+  GtkEventController *a_key;
+
   gint popup_position;
 
   guint text_changed : 1;
@@ -227,14 +233,13 @@ popup_edit (GtkWidget      *widget,
 }
 
 static gboolean
-popup_key_press (GtkWidget      *popup,
-                 GdkEventKey    *event,
-                 GtkColorEditor *editor)
+popup_key_pressed (GtkEventController *controller,
+                   guint               keyval,
+                   guint               keycode,
+                   GdkModifierType     state,
+                   GtkColorEditor     *editor)
 {
-  guint keyval;
-
-  if (gdk_event_get_keyval ((GdkEvent *) event, &keyval) &&
-      keyval == GDK_KEY_Escape)
+  if (keyval == GDK_KEY_Escape)
     {
       dismiss_current_popup (editor);
       return TRUE;
@@ -369,6 +374,15 @@ gtk_color_editor_init (GtkColorEditor *editor)
   gtk_overlay_add_overlay (GTK_OVERLAY (editor->priv->overlay), editor->priv->h_popup);
   gtk_overlay_add_overlay (GTK_OVERLAY (editor->priv->overlay), editor->priv->a_popup);
 
+  editor->priv->h_key = gtk_event_controller_key_new (editor->priv->h_entry);
+  g_signal_connect (editor->priv->h_key, "key-pressed", G_CALLBACK (popup_key_pressed), editor);
+  editor->priv->s_key = gtk_event_controller_key_new (editor->priv->s_entry);
+  g_signal_connect (editor->priv->s_key, "key-pressed", G_CALLBACK (popup_key_pressed), editor);
+  editor->priv->v_key = gtk_event_controller_key_new (editor->priv->v_entry);
+  g_signal_connect (editor->priv->v_key, "key-pressed", G_CALLBACK (popup_key_pressed), editor);
+  editor->priv->a_key = gtk_event_controller_key_new (editor->priv->a_entry);
+  g_signal_connect (editor->priv->a_key, "key-pressed", G_CALLBACK (popup_key_pressed), editor);
+
   gtk_style_context_remove_class (gtk_widget_get_style_context (editor->priv->swatch), "activatable");
 }
 
@@ -379,6 +393,11 @@ gtk_color_editor_dispose (GObject *object)
 
   dismiss_current_popup (editor);
 
+  g_clear_object (&editor->priv->h_key);
+  g_clear_object (&editor->priv->s_key);
+  g_clear_object (&editor->priv->v_key);
+  g_clear_object (&editor->priv->a_key);
+
   G_OBJECT_CLASS (gtk_color_editor_parent_class)->dispose (object);
 }
 
@@ -482,7 +501,6 @@ gtk_color_editor_class_init (GtkColorEditorClass *class)
   gtk_widget_class_bind_template_child_private (widget_class, GtkColorEditor, a_adj);
 
   gtk_widget_class_bind_template_callback (widget_class, hsv_changed);
-  gtk_widget_class_bind_template_callback (widget_class, popup_key_press);
   gtk_widget_class_bind_template_callback (widget_class, dismiss_current_popup);
   gtk_widget_class_bind_template_callback (widget_class, get_child_position);
   gtk_widget_class_bind_template_callback (widget_class, entry_text_changed);

gtk/gtkcombobox.c

@@ -280,8 +280,8 @@ static void     gtk_combo_box_menu_activate        (GtkWidget        *menu,
                                                     const gchar      *path,
                                                     GtkComboBox      *combo_box);
 static void     gtk_combo_box_update_sensitivity   (GtkComboBox      *combo_box);
-static gboolean gtk_combo_box_menu_key_press       (GtkWidget        *widget,
-                                                    GdkEventKey      *event,
+static gboolean gtk_combo_box_menu_event           (GtkWidget        *widget,
+                                                    GdkEvent         *event,
                                                     gpointer          data);
 static void     gtk_combo_box_menu_popup           (GtkComboBox      *combo_box);
 
@@ -849,7 +849,7 @@ gtk_combo_box_class_init (GtkComboBoxClass *klass)
   gtk_widget_class_bind_template_child_internal_private (widget_class, GtkComboBox, popup_widget);
   gtk_widget_class_bind_template_callback (widget_class, gtk_combo_box_button_toggled);
   gtk_widget_class_bind_template_callback (widget_class, gtk_combo_box_menu_activate);
-  gtk_widget_class_bind_template_callback (widget_class, gtk_combo_box_menu_key_press);
+  gtk_widget_class_bind_template_callback (widget_class, gtk_combo_box_menu_event);
   gtk_widget_class_bind_template_callback (widget_class, gtk_combo_box_menu_show);
   gtk_widget_class_bind_template_callback (widget_class, gtk_combo_box_menu_hide);
 
@@ -1940,18 +1940,18 @@ gtk_combo_box_model_row_changed (GtkTreeModel     *model,
 }
 
 static gboolean
-gtk_combo_box_menu_key_press (GtkWidget   *widget,
-                              GdkEventKey *event,
-                              gpointer     data)
+gtk_combo_box_menu_event (GtkWidget *widget,
+                          GdkEvent  *event,
+                          gpointer   data)
 {
   GtkComboBox *combo_box = GTK_COMBO_BOX (data);
 
-  if (!gtk_bindings_activate_event (G_OBJECT (widget), event))
+  if (!gtk_bindings_activate_event (G_OBJECT (widget), (GdkEventKey *)event))
     {
       /* The menu hasn't managed the
        * event, forward it to the combobox
        */
-      gtk_bindings_activate_event (G_OBJECT (combo_box), event);
+      gtk_bindings_activate_event (G_OBJECT (combo_box), (GdkEventKey *)event);
     }
 
   return TRUE;
@@ -2741,14 +2741,17 @@ gtk_combo_box_dispose (GObject* object)
 }
 
 static gboolean
-gtk_cell_editable_key_press (GtkWidget   *widget,
-                             GdkEventKey *event,
-                             gpointer     data)
+gtk_cell_editable_event (GtkWidget *widget,
+                         GdkEvent  *event,
+                         gpointer   data)
 {
   GtkComboBox *combo_box = GTK_COMBO_BOX (data);
   guint keyval;
 
-  if (!gdk_event_get_keyval ((GdkEvent *) event, &keyval))
+  if (gdk_event_get_event_type (event) != GDK_KEY_PRESS)
+    return GDK_EVENT_PROPAGATE;
+
+  if (!gdk_event_get_keyval (event, &keyval))
     return GDK_EVENT_PROPAGATE;
 
   if (keyval == GDK_KEY_Escape)
@@ -2786,8 +2789,8 @@ gtk_combo_box_start_editing (GtkCellEditable *cell_editable,
 
   if (priv->cell_view)
     {
-      g_signal_connect_object (priv->button, "key-press-event",
-                               G_CALLBACK (gtk_cell_editable_key_press),
+      g_signal_connect_object (priv->button, "event",
+                               G_CALLBACK (gtk_cell_editable_event),
                                cell_editable, 0);
 
       gtk_widget_grab_focus (priv->button);
@@ -2796,8 +2799,8 @@ gtk_combo_box_start_editing (GtkCellEditable *cell_editable,
     {
       child = gtk_bin_get_child (GTK_BIN (combo_box));
 
-      g_signal_connect_object (child, "key-press-event",
-                               G_CALLBACK (gtk_cell_editable_key_press),
+      g_signal_connect_object (child, "event",
+                               G_CALLBACK (gtk_cell_editable_event),
                                cell_editable, 0);
 
       gtk_widget_grab_focus (child);

gtk/gtkentry.c

@@ -4507,14 +4507,17 @@ gtk_cell_editable_entry_activated (GtkEntry *entry, gpointer data)
 }
 
 static gboolean
-gtk_cell_editable_key_press_event (GtkEntry    *entry,
-				   GdkEventKey *key_event,
-				   gpointer     data)
+gtk_cell_editable_event (GtkEntry *entry,
+                         GdkEvent *event,
+                         gpointer  data)
 {
   GtkEntryPrivate *priv = entry->priv;
   guint keyval;
 
-  if (!gdk_event_get_keyval ((GdkEvent *) key_event, &keyval))
+  if (gdk_event_get_event_type (event) != GDK_KEY_PRESS)
+    return GDK_EVENT_PROPAGATE;
+
+  if (!gdk_event_get_keyval (event, &keyval))
     return GDK_EVENT_PROPAGATE;
 
   if (keyval == GDK_KEY_Escape)
@@ -4544,8 +4547,8 @@ gtk_entry_start_editing (GtkCellEditable *cell_editable,
 {
   g_signal_connect (cell_editable, "activate",
 		    G_CALLBACK (gtk_cell_editable_entry_activated), NULL);
-  g_signal_connect (cell_editable, "key-press-event",
-		    G_CALLBACK (gtk_cell_editable_key_press_event), NULL);
+  g_signal_connect (cell_editable, "event",
+		    G_CALLBACK (gtk_cell_editable_event), NULL);
 }
 
 static void

gtk/gtkentrycompletion.c

@@ -2060,16 +2060,19 @@ keyval_is_cursor_move (guint keyval)
 }
 
 static gboolean
-gtk_entry_completion_key_press (GtkWidget   *widget,
-                                GdkEventKey *event,
-                                gpointer     user_data)
+gtk_entry_completion_event (GtkWidget *widget,
+                            GdkEvent  *event,
+                            gpointer   user_data)
 {
   gint matches, actions = 0;
   GtkEntryCompletion *completion = GTK_ENTRY_COMPLETION (user_data);
   guint keyval;
 
+  if (gdk_event_get_event_type (event) != GDK_KEY_PRESS)
+    return FALSE;
+
   if (!completion->priv->popup_completion ||
-      !gdk_event_get_keyval ((GdkEvent *) event, &keyval))
+      !gdk_event_get_keyval (event, &keyval))
     return FALSE;
 
   if (keyval == GDK_KEY_Return ||
@@ -2473,8 +2476,8 @@ connect_completion_signals (GtkEntryCompletion *completion)
   completion->priv->changed_id =
     g_signal_connect (completion->priv->entry, "changed",
                       G_CALLBACK (gtk_entry_completion_changed), completion);
-  g_signal_connect (completion->priv->entry, "key-press-event",
-                    G_CALLBACK (gtk_entry_completion_key_press), completion);
+  g_signal_connect (completion->priv->entry, "event",
+                    G_CALLBACK (gtk_entry_completion_event), completion);
 
     completion->priv->insert_text_id =
       g_signal_connect (completion->priv->entry, "insert-text",
@@ -2529,7 +2532,7 @@ disconnect_completion_signals (GtkEntryCompletion *completion)
       completion->priv->changed_id = 0;
     }
   g_signal_handlers_disconnect_by_func (completion->priv->entry,
-                                        G_CALLBACK (gtk_entry_completion_key_press), completion);
+                                        G_CALLBACK (gtk_entry_completion_event), completion);
   if (completion->priv->insert_text_id > 0 &&
       g_signal_handler_is_connected (completion->priv->entry,
                                      completion->priv->insert_text_id))

gtk/gtkeventcontrollerkey.c

@@ -0,0 +1,123 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2017, Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author(s): Carlos Garnacho <carlosg@gnome.org>
+ */
+
+#include "config.h"
+
+#include "gtkintl.h"
+#include "gtkprivate.h"
+#include "gtkwidget.h"
+#include "gtkeventcontrollerprivate.h"
+#include "gtkeventcontrollerkey.h"
+#include "gtkbindings.h"
+
+#include <gdk/gdk.h>
+
+struct _GtkEventControllerKey
+{
+  GtkEventController parent_instance;
+};
+
+struct _GtkEventControllerKeyClass
+{
+  GtkEventControllerClass parent_class;
+};
+
+enum {
+  KEY_PRESSED,
+  KEY_RELEASED,
+  N_SIGNALS
+};
+
+static guint signals[N_SIGNALS] = { 0 };
+
+G_DEFINE_TYPE (GtkEventControllerKey, gtk_event_controller_key,
+               GTK_TYPE_EVENT_CONTROLLER)
+
+static gboolean
+gtk_event_controller_key_handle_event (GtkEventController *controller,
+                                       const GdkEvent     *event)
+{
+  GdkEventType event_type = gdk_event_get_event_type (event);
+  gboolean handled;
+  GdkModifierType state;
+  guint16 keycode;
+  guint keyval;
+
+  if (event_type != GDK_KEY_PRESS && event_type != GDK_KEY_RELEASE)
+    return FALSE;
+
+  gdk_event_get_state (event, &state);
+  gdk_event_get_keycode (event, &keycode);
+  gdk_event_get_keyval (event, &keyval);
+
+  if (event_type == GDK_KEY_PRESS)
+    {
+      g_signal_emit (controller, signals[KEY_PRESSED], 0,
+                     keyval, keycode, state, &handled);
+    }
+  else if (event_type == GDK_KEY_RELEASE)
+    {
+      g_signal_emit (controller, signals[KEY_RELEASED], 0,
+                     keyval, keycode, state, &handled);
+    }
+  else
+    handled = TRUE;
+
+  if (!handled)
+    handled = gtk_bindings_activate_event (G_OBJECT (gtk_event_controller_get_widget (controller)),
+                                           (GdkEventKey *)event);
+
+  return handled;
+}
+
+static void
+gtk_event_controller_key_class_init (GtkEventControllerKeyClass *klass)
+{
+  GtkEventControllerClass *controller_class = GTK_EVENT_CONTROLLER_CLASS (klass);
+
+  controller_class->handle_event = gtk_event_controller_key_handle_event;
+
+  signals[KEY_PRESSED] =
+    g_signal_new (I_("key-pressed"),
+                  GTK_TYPE_EVENT_CONTROLLER_KEY,
+                  G_SIGNAL_RUN_LAST,
+                  0, _gtk_boolean_handled_accumulator, NULL, NULL,
+                  G_TYPE_BOOLEAN, 3, G_TYPE_UINT, G_TYPE_UINT, GDK_TYPE_MODIFIER_TYPE);
+  signals[KEY_RELEASED] =
+    g_signal_new (I_("key-released"),
+                  GTK_TYPE_EVENT_CONTROLLER_KEY,
+                  G_SIGNAL_RUN_LAST,
+                  0, _gtk_boolean_handled_accumulator, NULL, NULL,
+                  G_TYPE_BOOLEAN, 3, G_TYPE_UINT, G_TYPE_UINT, GDK_TYPE_MODIFIER_TYPE);
+}
+
+static void
+gtk_event_controller_key_init (GtkEventControllerKey *controller)
+{
+}
+
+GtkEventController *
+gtk_event_controller_key_new (GtkWidget *widget)
+{
+  g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+
+  return g_object_new (GTK_TYPE_EVENT_CONTROLLER_KEY,
+                       "widget", widget,
+                       NULL);
+}

gtk/gtkeventcontrollerkey.h

@@ -0,0 +1,50 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2017, Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author(s): Carlos Garnacho <carlosg@gnome.org>
+ */
+
+#ifndef __GTK_EVENT_CONTROLLER_KEY_H__
+#define __GTK_EVENT_CONTROLLER_KEY_H__
+
+#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#include <gdk/gdk.h>
+#include <gtk/gtkeventcontroller.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_EVENT_CONTROLLER_KEY         (gtk_event_controller_key_get_type ())
+#define GTK_EVENT_CONTROLLER_KEY(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_EVENT_CONTROLLER_KEY, GtkEventControllerKey))
+#define GTK_EVENT_CONTROLLER_KEY_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_EVENT_CONTROLLER_KEY, GtkEventControllerKeyClass))
+#define GTK_IS_EVENT_CONTROLLER_KEY(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_EVENT_CONTROLLER_KEY))
+#define GTK_IS_EVENT_CONTROLLER_KEY_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_EVENT_CONTROLLER_KEY))
+#define GTK_EVENT_CONTROLLER_KEY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_EVENT_CONTROLLER_KEY, GtkEventControllerKeyClass))
+
+typedef struct _GtkEventControllerKey GtkEventControllerKey;
+typedef struct _GtkEventControllerKeyClass GtkEventControllerKeyClass;
+
+GDK_AVAILABLE_IN_ALL
+GType               gtk_event_controller_key_get_type  (void) G_GNUC_CONST;
+
+GDK_AVAILABLE_IN_ALL
+GtkEventController *gtk_event_controller_key_new (GtkWidget *widget);
+
+G_END_DECLS
+
+#endif /* __GTK_EVENT_CONTROLLER_KEY_H__ */

gtk/gtkfilechooserwidget.c

@@ -78,6 +78,7 @@
 #include "gtkmodelbutton.h"
 #include "gtkgesturelongpress.h"
 #include "gtkgesturemultipress.h"
+#include "gtkeventcontrollerkey.h"
 #include "gtkdebug.h"
 #include "gtkfilechoosererrorstackprivate.h"
 
@@ -252,6 +253,7 @@ struct _GtkFileChooserWidgetPrivate {
 
   GtkGesture *long_press_gesture;
   GtkGesture *multipress_gesture;
+  GtkEventController *key_controller;
 
   GtkFileSystemModel *browse_files_model;
   char *browse_files_last_selected_name;
@@ -1264,12 +1266,12 @@ places_sidebar_show_error_message_cb (GtkPlacesSidebar *sidebar,
 }
 
 static gboolean
-key_is_left_or_right (GdkEventKey *event)
+key_is_left_or_right (const GdkEvent *event)
 {
   guint modifiers, keyval, state;
 
-  if (!gdk_event_get_keyval ((GdkEvent *) event, &keyval) ||
-      !gdk_event_get_state ((GdkEvent *) event, &state))
+  if (!gdk_event_get_keyval (event, &keyval) ||
+      !gdk_event_get_state (event, &state))
     return FALSE;
 
   modifiers = gtk_accelerator_get_default_mod_mask ();
@@ -1283,14 +1285,12 @@ key_is_left_or_right (GdkEventKey *event)
 
 static gboolean
 should_trigger_location_entry (GtkFileChooserWidget *impl,
-                               GdkEventKey          *event)
+                               guint                 keyval,
+                               GdkModifierType       state)
 {
   GdkModifierType no_text_input_mask;
-  guint keyval, state;
 
-  if (impl->priv->operation_mode == OPERATION_MODE_SEARCH ||
-      !gdk_event_get_keyval ((GdkEvent *) event, &keyval) ||
-      !gdk_event_get_state ((GdkEvent *) event, &state))
+  if (impl->priv->operation_mode == OPERATION_MODE_SEARCH)
     return FALSE;
 
   no_text_input_mask =
@@ -1313,15 +1313,19 @@ should_trigger_location_entry (GtkFileChooserWidget *impl,
  * pressed.
  */
 static gboolean
-browse_files_key_press_event_cb (GtkWidget   *widget,
-                                 GdkEventKey *event,
-                                 gpointer     data)
+key_press_cb (GtkEventController *controller,
+              guint               keyval,
+              guint               keycode,
+              GdkModifierType     state,
+              gpointer            data)
 {
   GtkFileChooserWidget *impl = (GtkFileChooserWidget *) data;
   GtkFileChooserWidgetPrivate *priv = impl->priv;
-  guint keyval, state;
+  const GdkEvent *event;
 
-  if (should_trigger_location_entry (impl, event) &&
+  event = gtk_get_current_event ();
+
+  if (should_trigger_location_entry (impl, keyval, state) &&
       (priv->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
        priv->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER))
     {
@@ -1329,17 +1333,16 @@ browse_files_key_press_event_cb (GtkWidget   *widget,
 
       gdk_event_get_string ((GdkEvent *)event, &string);
       location_popup_handler (impl, string);
-      return TRUE;
+      return GDK_EVENT_STOP;
     }
 
   if (key_is_left_or_right (event))
     {
       if (gtk_widget_child_focus (priv->places_sidebar, GTK_DIR_LEFT))
-        return TRUE;
+        return GDK_EVENT_STOP;
     }
 
-  if (!gdk_event_get_keyval ((GdkEvent *) event, &keyval) ||
-      !gdk_event_get_state ((GdkEvent *) event, &state))
+  if (!gdk_event_get_state (event, &state))
     return GDK_EVENT_PROPAGATE;
 
   if ((keyval == GDK_KEY_Return
@@ -1351,6 +1354,7 @@ browse_files_key_press_event_cb (GtkWidget   *widget,
       && !(priv->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
            priv->action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER))
     {
+      GtkWidget *widget = GTK_WIDGET (impl);
       GtkWindow *window;
 
       window = get_toplevel (widget);
@@ -1366,7 +1370,7 @@ browse_files_key_press_event_cb (GtkWidget   *widget,
             {
               gtk_window_activate_default (window);
 
-              return TRUE;
+              return GDK_EVENT_STOP;
             }
         }
     }
@@ -1375,10 +1379,10 @@ browse_files_key_press_event_cb (GtkWidget   *widget,
       priv->operation_mode == OPERATION_MODE_SEARCH)
     {
       gtk_search_entry_handle_event (GTK_SEARCH_ENTRY (priv->search_entry), (GdkEvent *)event);
-      return TRUE;
+      return GDK_EVENT_STOP;
     }
 
-  return FALSE;
+  return GDK_EVENT_PROPAGATE;
 }
 
 static gboolean
@@ -1387,8 +1391,12 @@ gtk_file_chooser_widget_key_press_event (GtkWidget   *widget,
 {
   GtkFileChooserWidget *impl = (GtkFileChooserWidget *) widget;
   GtkFileChooserWidgetPrivate *priv = impl->priv;
+  guint keyval, state;
 
-  if (should_trigger_location_entry (impl, event))
+  gdk_event_get_keyval ((GdkEvent *)event, &keyval);
+  gdk_event_get_state ((GdkEvent *)event, &state);
+
+  if (should_trigger_location_entry (impl, keyval, state))
     {
       if (priv->action == GTK_FILE_CHOOSER_ACTION_OPEN ||
           priv->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
@@ -3548,6 +3556,7 @@ gtk_file_chooser_widget_dispose (GObject *object)
 
   g_clear_object (&priv->long_press_gesture);
   g_clear_object (&priv->multipress_gesture);
+  g_clear_object (&priv->key_controller);
 
   G_OBJECT_CLASS (gtk_file_chooser_widget_parent_class)->dispose (object);
 }
@@ -8382,7 +8391,6 @@ gtk_file_chooser_widget_class_init (GtkFileChooserWidgetClass *class)
   gtk_widget_class_bind_template_child_private (widget_class, GtkFileChooserWidget, box);
 
   /* And a *lot* of callbacks to bind ... */
-  gtk_widget_class_bind_template_callback (widget_class, browse_files_key_press_event_cb);
   gtk_widget_class_bind_template_callback (widget_class, file_list_drag_drop_cb);
   gtk_widget_class_bind_template_callback (widget_class, file_list_drag_data_received_cb);
   gtk_widget_class_bind_template_callback (widget_class, list_popup_menu_cb);
@@ -8552,8 +8560,12 @@ gtk_file_chooser_widget_init (GtkFileChooserWidget *impl)
   g_signal_connect (priv->multipress_gesture, "pressed",
                     G_CALLBACK (multi_press_cb), impl);
 
+  priv->key_controller = gtk_event_controller_key_new (priv->browse_files_tree_view);
+  g_signal_connect (priv->key_controller, "key-pressed",
+                    G_CALLBACK (key_press_cb), impl);
+
   /* Setup various attributes and callbacks in the UI
-   * which cannot be done with GtkBuilder.
+   * which cannot be done with GtkBuilder
    */
   post_process_ui (impl);
 

gtk/gtkmenu.c

@@ -39,47 +39,33 @@
  * Other composite widgets such as the #GtkNotebook can pop up a
  * #GtkMenu as well.
  *
- * Applications can display a #GtkMenu as a popup menu by calling the 
+ * Applications can display a #GtkMenu as a popup menu by calling the
  * gtk_menu_popup() function.  The example below shows how an application
- * can pop up a menu when the 3rd mouse button is pressed.  
+ * can pop up a menu when the 3rd mouse button is pressed.
  *
  * ## Connecting the popup signal handler.
  *
  * |[<!-- language="C" -->
  *   // connect our handler which will popup the menu
- *   g_signal_connect_swapped (window, "event",
- *	G_CALLBACK (my_popup_handler), menu);
+ *   gesture = gtk_gesture_multi_press_new (window);
+ *   gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture),
+ *                                  GDK_BUTTON_SECONDARY);
+ *   g_signal_connect (gesture, "event", G_CALLBACK (my_popup_handler), menu);
  * ]|
  *
  * ## Signal handler which displays a popup menu.
  *
  * |[<!-- language="C" -->
- * static gint
- * my_popup_handler (GtkWidget *widget, GdkEvent *event)
+ * static void
+ * my_popup_handler (GtkGesture *gesture,
+ *                   guint       n_press,
+ *                   double      x,
+ *                   double      y,
+ *                   gpointer    data)
  * {
- *   GtkMenu *menu;
- *   guint button;
+ *   GtkMenu *menu = data;
  *
- *   g_return_val_if_fail (widget != NULL, FALSE);
- *   g_return_val_if_fail (GTK_IS_MENU (widget), FALSE);
- *   g_return_val_if_fail (event != NULL, FALSE);
- *
- *   // The "widget" is the menu that was supplied when
- *   // g_signal_connect_swapped() was called.
- *   menu = GTK_MENU (widget);
- *
- *   if (gdk_event_get_event_type (event) == GDK_BUTTON_PRESS)
- *     {
- *       gdk_event_get_button (event, &button);
- *       if (button == GDK_BUTTON_SECONDARY)
- *         {
- *           gtk_menu_popup (menu, NULL, NULL, NULL, NULL,
- *                           button, gdk_event_get_time (event));
- *           return TRUE;
- *         }
- *     }
- *
- *   return FALSE;
+ *   gtk_menu_popup (menu, NULL, NULL, NULL, NULL, button, GDK_CURRENT_TIME);
  * }
  * ]|
  *

gtk/gtkplacessidebar.c

@@ -3386,17 +3386,19 @@ stop_shortcut_cb (GSimpleAction *action,
 }
 
 static gboolean
-on_key_press_event (GtkWidget        *widget,
-                    GdkEventKey      *event,
-                    GtkPlacesSidebar *sidebar)
+on_event (GtkWidget        *widget,
+          GdkEvent         *event,
+          GtkPlacesSidebar *sidebar)
 {
   guint modifiers;
   GtkListBoxRow *row;
   guint keyval, state;
 
-  if (event &&
-      gdk_event_get_keyval ((GdkEvent *) event, &keyval) &&
-      gdk_event_get_state ((GdkEvent *) event, &state))
+  if (gdk_event_get_event_type (event) != GDK_KEY_PRESS)
+    return GDK_EVENT_PROPAGATE;
+
+  if (gdk_event_get_keyval (event, &keyval) &&
+      gdk_event_get_state (event, &state))
     {
       row = gtk_list_box_get_selected_row (GTK_LIST_BOX (sidebar->list_box));
       if (row)
@@ -4051,8 +4053,8 @@ gtk_places_sidebar_init (GtkPlacesSidebar *sidebar)
 
   g_signal_connect (sidebar->list_box, "row-activated",
                     G_CALLBACK (on_row_activated), sidebar);
-  g_signal_connect (sidebar->list_box, "key-press-event",
-                    G_CALLBACK (on_key_press_event), sidebar);
+  g_signal_connect (sidebar->list_box, "event",
+                    G_CALLBACK (on_event), sidebar);
 
   sidebar->long_press_gesture = gtk_gesture_long_press_new (GTK_WIDGET (sidebar));
   gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (sidebar->long_press_gesture), TRUE);

gtk/gtkplacesview.c

@@ -28,6 +28,7 @@
 #include "gtkplacesviewprivate.h"
 #include "gtkplacesviewrowprivate.h"
 #include "gtktypebuiltins.h"
+#include "gtkeventcontrollerkey.h"
 
 /*
  * SECTION:gtkplacesview
@@ -81,6 +82,7 @@ struct _GtkPlacesViewPrivate
 
   GtkEntryCompletion            *address_entry_completion;
   GtkListStore                  *completion_store;
+  GtkEventController            *key_controller;
 
   GCancellable                  *networks_fetching_cancellable;
 
@@ -414,6 +416,7 @@ gtk_places_view_finalize (GObject *object)
   g_clear_object (&priv->networks_fetching_cancellable);
   g_clear_object (&priv->path_size_group);
   g_clear_object (&priv->space_size_group);
+  g_clear_object (&priv->key_controller);
 
   G_OBJECT_CLASS (gtk_places_view_parent_class)->finalize (object);
 }
@@ -1687,51 +1690,46 @@ on_row_popup_menu (GtkPlacesViewRow *row)
 }
 
 static gboolean
-on_key_press_event (GtkWidget     *widget,
-                    GdkEventKey   *event,
-                    GtkPlacesView *view)
+on_key_press_event (GtkEventController *controller,
+                    guint               keyval,
+                    guint               keycode,
+                    GdkModifierType     state,
+                    GtkPlacesView      *view)
 {
   GtkPlacesViewPrivate *priv;
-  guint keyval, state;
+  GdkModifierType modifiers;
 
   priv = gtk_places_view_get_instance_private (view);
 
-  if (event &&
-      gdk_event_get_keyval ((GdkEvent *) event, &keyval) &&
-      gdk_event_get_state ((GdkEvent *) event, &state))
+  modifiers = gtk_accelerator_get_default_mod_mask ();
+
+  if (keyval == GDK_KEY_Return ||
+      keyval == GDK_KEY_KP_Enter ||
+      keyval == GDK_KEY_ISO_Enter ||
+      keyval == GDK_KEY_space)
     {
-      guint modifiers;
+      GtkWidget *focus_widget;
+      GtkWindow *toplevel;
 
-      modifiers = gtk_accelerator_get_default_mod_mask ();
+      priv->current_open_flags = GTK_PLACES_OPEN_NORMAL;
+      toplevel = get_toplevel (GTK_WIDGET (view));
 
-      if (keyval == GDK_KEY_Return ||
-          keyval == GDK_KEY_KP_Enter ||
-          keyval == GDK_KEY_ISO_Enter ||
-          keyval == GDK_KEY_space)
-        {
-          GtkWidget *focus_widget;
-          GtkWindow *toplevel;
+      if (!toplevel)
+        return FALSE;
 
-          priv->current_open_flags = GTK_PLACES_OPEN_NORMAL;
-          toplevel = get_toplevel (GTK_WIDGET (view));
+      focus_widget = gtk_window_get_focus (toplevel);
 
-          if (!toplevel)
-            return FALSE;
+      if (!GTK_IS_PLACES_VIEW_ROW (focus_widget))
+        return FALSE;
 
-          focus_widget = gtk_window_get_focus (toplevel);
+      if ((state & modifiers) == GDK_SHIFT_MASK)
+        priv->current_open_flags = GTK_PLACES_OPEN_NEW_TAB;
+      else if ((state & modifiers) == GDK_CONTROL_MASK)
+        priv->current_open_flags = GTK_PLACES_OPEN_NEW_WINDOW;
 
-          if (!GTK_IS_PLACES_VIEW_ROW (focus_widget))
-            return FALSE;
+      activate_row (view, GTK_PLACES_VIEW_ROW (focus_widget), priv->current_open_flags);
 
-          if ((state & modifiers) == GDK_SHIFT_MASK)
-            priv->current_open_flags = GTK_PLACES_OPEN_NEW_TAB;
-          else if ((state & modifiers) == GDK_CONTROL_MASK)
-            priv->current_open_flags = GTK_PLACES_OPEN_NEW_WINDOW;
-
-          activate_row (view, GTK_PLACES_VIEW_ROW (focus_widget), priv->current_open_flags);
-
-          return TRUE;
-        }
+      return TRUE;
     }
 
   return FALSE;
@@ -2255,7 +2253,6 @@ gtk_places_view_class_init (GtkPlacesViewClass *klass)
   gtk_widget_class_bind_template_callback (widget_class, on_address_entry_text_changed);
   gtk_widget_class_bind_template_callback (widget_class, on_address_entry_show_help_pressed);
   gtk_widget_class_bind_template_callback (widget_class, on_connect_button_clicked);
-  gtk_widget_class_bind_template_callback (widget_class, on_key_press_event);
   gtk_widget_class_bind_template_callback (widget_class, on_listbox_row_activated);
   gtk_widget_class_bind_template_callback (widget_class, on_recent_servers_listbox_row_activated);
 
@@ -2273,6 +2270,8 @@ gtk_places_view_init (GtkPlacesView *self)
   priv->open_flags = GTK_PLACES_OPEN_NORMAL;
   priv->path_size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
   priv->space_size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+  priv->key_controller = gtk_event_controller_key_new (GTK_WIDGET (self));
+  g_signal_connect (priv->key_controller, "key-pressed", G_CALLBACK (on_key_press_event), self);
 
   gtk_widget_init_template (GTK_WIDGET (self));
 }

gtk/gtkshortcutswindow.c

@@ -26,6 +26,7 @@
 #include "gtksearchbar.h"
 #include "gtksearchentry.h"
 #include "gtkwidgetprivate.h"
+#include "gtkeventcontrollerkey.h"
 #include "gtkprivate.h"
 #include "gtkintl.h"
 
@@ -98,6 +99,7 @@ typedef struct
   GtkListBox     *list_box;
   GtkBox         *search_gestures;
   GtkBox         *search_shortcuts;
+  GtkEventController *controller;
 
   GtkWindow      *window;
   gulong          keys_changed_id;
@@ -633,6 +635,7 @@ gtk_shortcuts_window_finalize (GObject *object)
 
   g_clear_object (&priv->search_image_group);
   g_clear_object (&priv->search_text_group);
+  g_clear_object (&priv->controller);
 
   G_OBJECT_CLASS (gtk_shortcuts_window_parent_class)->finalize (object);
 }
@@ -839,14 +842,16 @@ gtk_shortcuts_window_class_init (GtkShortcutsWindowClass *klass)
 }
 
 static gboolean
-window_key_press_event_cb (GtkWidget *window,
-                           GdkEvent  *event,
-                           gpointer   data)
+window_key_pressed (GtkEventController *controller,
+                    guint               keyval,
+                    guint               keycode,
+                    GdkModifierType     state,
+                    gpointer            data)
 {
-  GtkShortcutsWindow *self = GTK_SHORTCUTS_WINDOW (window);
+  GtkShortcutsWindow *self = GTK_SHORTCUTS_WINDOW (gtk_event_controller_get_widget (controller));
   GtkShortcutsWindowPrivate *priv = gtk_shortcuts_window_get_instance_private (self);
 
-  return gtk_search_bar_handle_event (priv->search_bar, event);
+  return gtk_search_bar_handle_event (priv->search_bar, gtk_get_current_event ());
 }
 
 static void
@@ -865,8 +870,9 @@ gtk_shortcuts_window_init (GtkShortcutsWindow *self)
   gtk_window_set_resizable (GTK_WINDOW (self), FALSE);
   gtk_window_set_type_hint (GTK_WINDOW (self), GDK_WINDOW_TYPE_HINT_DIALOG);
 
-  g_signal_connect (self, "key-press-event",
-                    G_CALLBACK (window_key_press_event_cb), NULL);
+  priv->controller = gtk_event_controller_key_new (GTK_WIDGET (self));
+  g_signal_connect (priv->controller, "key-pressed",
+                    G_CALLBACK (window_key_pressed), NULL);
 
   priv->keywords = g_hash_table_new_full (NULL, NULL, NULL, g_free);
   priv->search_items_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);

gtk/inspector/object-tree.c

@@ -48,6 +48,7 @@
 #include "gtkstylecontext.h"
 #include "gtksearchbar.h"
 #include "gtksearchentry.h"
+#include "gtkeventcontrollerkey.h"
 #include "treewalk.h"
 
 enum
@@ -700,15 +701,13 @@ move_search_to_row (GtkInspectorObjectTree *wt,
 }
 
 static gboolean
-key_press_event (GtkWidget              *window,
-                 GdkEvent               *event,
-                 GtkInspectorObjectTree *wt)
+key_pressed (GtkEventController     *controller,
+             guint                   keyval,
+             guint                   keycode,
+             GdkModifierType         state,
+             GtkInspectorObjectTree *wt)
 {
-  guint keyval, state;
-
-  if (gtk_widget_get_mapped (GTK_WIDGET (wt)) &&
-      gdk_event_get_keyval (event, &keyval) &&
-      gdk_event_get_state (event, &state))
+  if (gtk_widget_get_mapped (GTK_WIDGET (wt)))
     {
       GdkModifierType default_accel;
       gboolean search_started;
@@ -772,7 +771,8 @@ key_press_event (GtkWidget              *window,
           return GDK_EVENT_STOP;
         }
 
-      return gtk_search_bar_handle_event (GTK_SEARCH_BAR (wt->priv->search_bar), event);
+      return gtk_search_bar_handle_event (GTK_SEARCH_BAR (wt->priv->search_bar),
+                                          gtk_get_current_event ());
     }
   else
     return GDK_EVENT_PROPAGATE;
@@ -782,10 +782,16 @@ static void
 on_hierarchy_changed (GtkWidget *widget,
                       GtkWidget *previous_toplevel)
 {
+  GtkEventController *controller;
+  GtkWidget *toplevel;
+
   if (previous_toplevel)
-    g_signal_handlers_disconnect_by_func (previous_toplevel, key_press_event, widget);
-  g_signal_connect (gtk_widget_get_toplevel (widget), "key-press-event",
-                    G_CALLBACK (key_press_event), widget);
+    g_object_set_data (G_OBJECT (previous_toplevel), "controller", NULL);
+
+  toplevel = gtk_widget_get_toplevel (widget);
+  controller = gtk_event_controller_key_new (toplevel);
+  g_object_set_data_full (G_OBJECT (toplevel), "controller", controller, g_object_unref);
+  g_signal_connect (controller, "key-pressed", G_CALLBACK (key_pressed), widget);
 }
 
 static void

gtk/inspector/prop-list.c

@@ -35,7 +35,9 @@
 #include "gtkpopover.h"
 #include "gtksearchentry.h"
 #include "gtklabel.h"
+#include "gtkmain.h"
 #include "gtkstack.h"
+#include "gtkeventcontrollerkey.h"
 
 enum
 {
@@ -82,18 +84,22 @@ search_close_clicked (GtkWidget            *button,
 }
 
 static gboolean
-key_press_event (GtkWidget            *window,
-                 GdkEvent             *event,
-                 GtkInspectorPropList *pl)
+key_pressed (GtkEventController   *controller,
+             guint                 keyval,
+             guint                 keycode,
+             GdkModifierType       state,
+             GtkInspectorPropList *pl)
 {
   if (!gtk_widget_get_mapped (GTK_WIDGET (pl)))
     return GDK_EVENT_PROPAGATE;
 
-  if (gtk_search_entry_handle_event (GTK_SEARCH_ENTRY (pl->priv->search_entry), event))
+  if (gtk_search_entry_handle_event (GTK_SEARCH_ENTRY (pl->priv->search_entry),
+                                     gtk_get_current_event ()))
     {
       gtk_stack_set_visible_child (GTK_STACK (pl->priv->search_stack), pl->priv->search_entry);
       return GDK_EVENT_STOP;
     }
+
   return GDK_EVENT_PROPAGATE;
 }
 
@@ -101,10 +107,16 @@ static void
 hierarchy_changed (GtkWidget *widget,
                    GtkWidget *previous_toplevel)
 {
+  GtkEventController *controller;
+  GtkWidget *toplevel;
+
   if (previous_toplevel)
-    g_signal_handlers_disconnect_by_func (previous_toplevel, key_press_event, widget);
-  g_signal_connect (gtk_widget_get_toplevel (widget), "key-press-event",
-                    G_CALLBACK (key_press_event), widget);
+    g_object_set_data (G_OBJECT (previous_toplevel), "controller", NULL);
+
+  toplevel = gtk_widget_get_toplevel (widget);
+  controller = gtk_event_controller_key_new (toplevel);
+  g_object_set_data_full (G_OBJECT (toplevel), "controller", controller, g_object_unref);
+  g_signal_connect (controller, "key-pressed", G_CALLBACK (key_pressed), widget);
 }
 
 static void

gtk/inspector/resource-list.c

@@ -391,15 +391,13 @@ move_search_to_row (GtkInspectorResourceList *sl,
 }
 
 static gboolean
-key_press_event (GtkWidget                *window,
-                 GdkEvent                 *event,
-                 GtkInspectorResourceList *sl)
+key_pressed (GtkEventController       *controller,
+             guint                     keyval,
+             guint                     keycode,
+             GdkModifierType           state,
+             GtkInspectorResourceList *sl)
 {
-  guint keyval, state;
-
-  if (gtk_widget_get_mapped (GTK_WIDGET (sl)) &&
-      gdk_event_get_keyval (event, &keyval) &&
-      gdk_event_get_state (event, &state))
+  if (gtk_widget_get_mapped (GTK_WIDGET (sl)))
     {
       GdkModifierType default_accel;
       gboolean search_started;
@@ -463,7 +461,8 @@ key_press_event (GtkWidget                *window,
           return GDK_EVENT_STOP;
         }
 
-      return gtk_search_bar_handle_event (GTK_SEARCH_BAR (sl->priv->search_bar), event);
+      return gtk_search_bar_handle_event (GTK_SEARCH_BAR (sl->priv->search_bar),
+                                          gtk_get_current_event ());
     }
   else
     return GDK_EVENT_PROPAGATE;
@@ -473,10 +472,16 @@ static void
 on_hierarchy_changed (GtkWidget *widget,
                       GtkWidget *previous_toplevel)
 {
+  GtkEventController *controller;
+  GtkWidget *toplevel;
+
   if (previous_toplevel)
-    g_signal_handlers_disconnect_by_func (previous_toplevel, key_press_event, widget);
-  g_signal_connect (gtk_widget_get_toplevel (widget), "key-press-event",
-                    G_CALLBACK (key_press_event), widget);
+    g_object_set_data (G_OBJECT (previous_toplevel), "controller", NULL);
+
+  toplevel = gtk_widget_get_toplevel (widget);
+  controller = gtk_event_controller_key_new (toplevel);
+  g_object_set_data_full (G_OBJECT (toplevel), "controller", controller, g_object_unref);
+  g_signal_connect (controller, "key-pressed", G_CALLBACK (key_pressed), widget);
 }
 
 static void

gtk/inspector/statistics.c

@@ -246,15 +246,13 @@ type_data_free (gpointer data)
 }
 
 static gboolean
-key_press_event (GtkWidget              *window,
-                 GdkEvent               *event,
-                 GtkInspectorStatistics *sl)
+key_pressed (GtkEventController     *controller,
+             guint                   keyval,
+             guint                   keycode,
+             GdkModifierType         state,
+             GtkInspectorStatistics *sl)
 {
-  guint keyval, state;
-
-  if (gtk_widget_get_mapped (GTK_WIDGET (sl)) &&
-      gdk_event_get_keyval (event, &keyval) &&
-      gdk_event_get_state (event, &state))
+  if (gtk_widget_get_mapped (GTK_WIDGET (sl)))
     {
       if (keyval == GDK_KEY_Return ||
           keyval == GDK_KEY_ISO_Enter ||
@@ -278,7 +276,8 @@ key_press_event (GtkWidget              *window,
             return GDK_EVENT_PROPAGATE;
         }
 
-      return gtk_search_bar_handle_event (GTK_SEARCH_BAR (sl->priv->search_bar), event);
+      return gtk_search_bar_handle_event (GTK_SEARCH_BAR (sl->priv->search_bar),
+                                          gtk_get_current_event ());
     }
   else
     return GDK_EVENT_PROPAGATE;
@@ -324,10 +323,16 @@ static void
 hierarchy_changed (GtkWidget *widget,
                    GtkWidget *previous_toplevel)
 {
+  GtkEventController *controller;
+  GtkWidget *toplevel;
+
   if (previous_toplevel)
-    g_signal_handlers_disconnect_by_func (previous_toplevel, key_press_event, widget);
-  g_signal_connect (gtk_widget_get_toplevel (widget), "key-press-event",
-                    G_CALLBACK (key_press_event), widget);
+    g_object_set_data (G_OBJECT (previous_toplevel), "controller", NULL);
+
+  toplevel = gtk_widget_get_toplevel (widget);
+  controller = gtk_event_controller_key_new (toplevel);
+  g_object_set_data_full (G_OBJECT (toplevel), "controller", controller, g_object_unref);
+  g_signal_connect (controller, "key-pressed", G_CALLBACK (key_pressed), widget);
 }
 
 static void

gtk/meson.build

@@ -201,6 +201,8 @@ gtk_public_sources = files([
   'gtkentrybuffer.c',
   'gtkentrycompletion.c',
   'gtkeventcontroller.c',
+  'gtkeventcontrollerkey.c',
+  'gtkeventcontrollerlegacy.c',
   'gtkeventcontrollermotion.c',
   'gtkeventcontrollerscroll.c',
   'gtkexpander.c',
@@ -432,6 +434,7 @@ gtk_public_headers = files([
   'gtkentrycompletion.h',
   'gtkenums.h',
   'gtkeventcontroller.h',
+  'gtkeventcontrollerkey.h',
   'gtkeventcontrollerscroll.h',
   'gtkeventcontrollermotion.h',
   'gtkexpander.h',

gtk/ui/gtkaboutdialog.ui

@@ -157,7 +157,6 @@
                             <property name="left-margin">8</property>
                             <property name="right-margin">8</property>
                             <property name="cursor-visible">0</property>
-                            <signal name="key-press-event" handler="text_view_key_press_event" swapped="no"/>
                           </object>
                         </child>
                       </object>
@@ -184,7 +183,6 @@
                             <property name="left-margin">8</property>
                             <property name="right-margin">8</property>
                             <property name="cursor-visible">0</property>
-                            <signal name="key-press-event" handler="text_view_key_press_event" swapped="no"/>
                           </object>
                         </child>
                       </object>

gtk/ui/gtkcoloreditor.ui

@@ -157,7 +157,6 @@
                 <property name="AtkObject::accessible-name" translatable="yes">Alpha</property>
               </object>
             </child>
-            <signal name="key-press-event" handler="popup_key_press" swapped="no"/>
           </object>
           <packing>
             <property name="left-attach">1</property>
@@ -200,7 +199,6 @@
                 <property name="AtkObject::accessible-name" translatable="yes">Hue</property>
               </object>
             </child>
-            <signal name="key-press-event" handler="popup_key_press" swapped="no"/>
           </object>
           <packing>
             <property name="left-attach">1</property>
@@ -253,7 +251,6 @@
                 <property name="AtkObject::accessible-name" translatable="yes">Saturation</property>
               </object>
             </child>
-            <signal name="key-press-event" handler="popup_key_press" swapped="no"/>
           </object>
           <packing>
             <property name="left-attach">1</property>
@@ -271,7 +268,6 @@
                 <property name="AtkObject::accessible-name" translatable="yes">Value</property>
               </object>
             </child>
-            <signal name="key-press-event" handler="popup_key_press" swapped="no"/>
           </object>
           <packing>
             <property name="left-attach">1</property>

gtk/ui/gtkcombobox.ui

@@ -34,7 +34,7 @@
   <object class="GtkTreeMenu" id="popup_widget">
     <property name="cell-area">area</property>
     <signal name="menu-activate" handler="gtk_combo_box_menu_activate" swapped="no"/>
-    <signal name="key-press-event" handler="gtk_combo_box_menu_key_press" swapped="no"/>
+    <signal name="event" handler="gtk_combo_box_menu_event" swapped="no"/>
     <signal name="show" handler="gtk_combo_box_menu_show" swapped="no"/>
     <signal name="hide" handler="gtk_combo_box_menu_hide" swapped="no"/>
   </object>

gtk/ui/gtkfilechooserwidget.ui

@@ -148,7 +148,6 @@
                                         <signal name="drag-begin" handler="file_list_drag_begin_cb" swapped="no"/>
                                         <signal name="drag-motion" handler="file_list_drag_motion_cb" swapped="no"/>
                                         <signal name="drag-end" handler="file_list_drag_end_cb" swapped="no"/>
-                                        <signal name="key-press-event" handler="browse_files_key_press_event_cb" swapped="no"/>
                                         <signal name="popup-menu" handler="list_popup_menu_cb" swapped="no"/>
                                         <signal name="query-tooltip" handler="file_list_query_tooltip_cb" swapped="no"/>
                                         <signal name="row-activated" handler="list_row_activated" swapped="no"/>

gtk/ui/gtkplacesview.ui

@@ -303,7 +303,6 @@
   <template class="GtkPlacesView" parent="GtkBox">
     <property name="can-focus">False</property>
     <property name="orientation">vertical</property>
-    <signal name="key-press-event" handler="on_key_press_event" object="GtkPlacesView" swapped="no"/>
     <child>
       <object class="GtkStack" id="stack">
         <property name="vhomogeneous">0</property>

tests/testgtk.c

@@ -4504,98 +4504,6 @@ create_display_screen (GtkWidget *widget)
   gtk_widget_show (window);
 }
 
-/* Event Watcher
- */
-static gulong event_watcher_id = 0;
-
-static gboolean
-event_watcher (GSignalInvocationHint *ihint,
-	       guint                  n_param_values,
-	       const GValue          *param_values,
-	       gpointer               data)
-{
-  GObject *object;
-  GdkEvent *event;
-
-  object = g_value_get_object (param_values + 0);
-  event = g_value_get_object (param_values + 1);
-  if (gdk_event_get_event_type (event) == GDK_ENTER_NOTIFY ||
-      gdk_event_get_event_type (event) == GDK_LEAVE_NOTIFY)
-    g_print ("Watch: \"%s\" emitted for %s\n",
-             g_enum_to_string (GDK_TYPE_EVENT_TYPE, gdk_event_get_event_type (event)),
-             G_OBJECT_TYPE_NAME (object));
-
-  return TRUE;
-}
-
-static void
-event_watcher_down (void)
-{
-  if (event_watcher_id)
-    {
-      guint signal_id;
-
-      signal_id = g_signal_lookup ("event", GTK_TYPE_WIDGET);
-      g_signal_remove_emission_hook (signal_id, event_watcher_id);
-      event_watcher_id = 0;
-    }
-}
-
-static void
-event_watcher_toggle (void)
-{
-  if (event_watcher_id)
-    event_watcher_down ();
-  else
-    {
-      guint signal_id;
-
-      signal_id = g_signal_lookup ("event", GTK_TYPE_WIDGET);
-      event_watcher_id = g_signal_add_emission_hook (signal_id, 0, event_watcher, NULL, NULL);
-    }
-}
-
-static void
-create_event_watcher (GtkWidget *widget)
-{
-  GtkWidget *content_area;
-  GtkWidget *button;
-
-  if (!dialog_window)
-    {
-      dialog_window = gtk_dialog_new ();
-      gtk_window_set_display (GTK_WINDOW (dialog_window),
-			      gtk_widget_get_display (widget));
-
-      g_signal_connect (dialog_window, "destroy",
-			G_CALLBACK (gtk_widget_destroyed),
-			&dialog_window);
-      g_signal_connect (dialog_window, "destroy",
-			G_CALLBACK (event_watcher_down),
-			NULL);
-
-      content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog_window));
-
-      gtk_window_set_title (GTK_WINDOW (dialog_window), "Event Watcher");
-      gtk_widget_set_size_request (dialog_window, 200, 110);
-
-      button = gtk_toggle_button_new_with_label ("Activate Watch");
-      g_signal_connect (button, "clicked",
-			G_CALLBACK (event_watcher_toggle),
-			NULL);
-      gtk_box_pack_start (GTK_BOX (content_area), button);
-      gtk_widget_show (button);
-
-      gtk_dialog_add_button (GTK_DIALOG (dialog_window), "Close", GTK_RESPONSE_CLOSE);
-      g_signal_connect (dialog_window, "response", G_CALLBACK (gtk_widget_destroy), NULL);
-    }
-
-  if (!gtk_widget_get_visible (dialog_window))
-    gtk_widget_show (dialog_window);
-  else
-    gtk_widget_destroy (dialog_window);
-}
-
 /*
  * GtkRange
  */
@@ -6702,316 +6610,6 @@ create_progress_bar (GtkWidget *widget)
     gtk_widget_destroy (pdata->window);
 }
 
-/*
- * Properties
- */
-
-typedef struct {
-  int x;
-  int y;
-  gboolean found;
-  gboolean first;
-  GtkWidget *res_widget;
-} FindWidgetData;
-
-static void
-find_widget (GtkWidget *widget, FindWidgetData *data)
-{
-  GtkAllocation new_allocation;
-  gint x_offset = 0;
-  gint y_offset = 0;
-
-  gtk_widget_get_allocation (widget, &new_allocation);
-
-  if (data->found || !gtk_widget_get_mapped (widget))
-    return;
-
-  /* Note that in the following code, we only count the
-   * position as being inside a WINDOW widget if it is inside
-   * widget->window; points that are outside of widget->window
-   * but within the allocation are not counted. This is consistent
-   * with the way we highlight drag targets.
-   */
-  if (gtk_widget_get_has_window (widget))
-    {
-      new_allocation.x = 0;
-      new_allocation.y = 0;
-    }
-
-  if (gtk_widget_get_parent (widget) && !data->first)
-    {
-      GdkWindow *window = gtk_widget_get_window (widget);
-      while (window != gtk_widget_get_window (gtk_widget_get_parent (widget)))
-	{
-	  gint tx, ty, twidth, theight;
-	  
-          twidth = gdk_window_get_width (window);
-          theight = gdk_window_get_height (window);
-
-	  if (new_allocation.x < 0)
-	    {
-	      new_allocation.width += new_allocation.x;
-	      new_allocation.x = 0;
-	    }
-	  if (new_allocation.y < 0)
-	    {
-	      new_allocation.height += new_allocation.y;
-	      new_allocation.y = 0;
-	    }
-	  if (new_allocation.x + new_allocation.width > twidth)
-	    new_allocation.width = twidth - new_allocation.x;
-	  if (new_allocation.y + new_allocation.height > theight)
-	    new_allocation.height = theight - new_allocation.y;
-
-	  gdk_window_get_position (window, &tx, &ty);
-	  new_allocation.x += tx;
-	  x_offset += tx;
-	  new_allocation.y += ty;
-	  y_offset += ty;
-
-	  window = gdk_window_get_parent (window);
-	}
-    }
-
-  if ((data->x >= new_allocation.x) && (data->y >= new_allocation.y) &&
-      (data->x < new_allocation.x + new_allocation.width) && 
-      (data->y < new_allocation.y + new_allocation.height))
-    {
-      /* First, check if the drag is in a valid drop site in
-       * one of our children 
-       */
-      if (GTK_IS_CONTAINER (widget))
-	{
-	  FindWidgetData new_data = *data;
-	  
-	  new_data.x -= x_offset;
-	  new_data.y -= y_offset;
-	  new_data.found = FALSE;
-	  new_data.first = FALSE;
-	  
-	  gtk_container_forall (GTK_CONTAINER (widget),
-				(GtkCallback)find_widget,
-				&new_data);
-	  
-	  data->found = new_data.found;
-	  if (data->found)
-	    data->res_widget = new_data.res_widget;
-	}
-
-      /* If not, and this widget is registered as a drop site, check to
-       * emit "drag_motion" to check if we are actually in
-       * a drop site.
-       */
-      if (!data->found)
-	{
-	  data->found = TRUE;
-	  data->res_widget = widget;
-	}
-    }
-}
-
-static GtkWidget *
-find_widget_at_pointer (GdkDevice *device)
-{
-  GtkWidget *widget = NULL;
-  GdkWindow *pointer_window;
-  gint x, y;
-  FindWidgetData data;
- 
- pointer_window = gdk_device_get_window_at_position (device, NULL, NULL);
- 
- if (pointer_window)
-   {
-     gpointer widget_ptr;
-
-     gdk_window_get_user_data (pointer_window, &widget_ptr);
-     widget = widget_ptr;
-   }
-
- if (widget)
-   {
-     gdk_window_get_device_position (gtk_widget_get_window (widget),
-                                     device,
-			             &x, &y, NULL);
-     
-     data.x = x;
-     data.y = y;
-     data.found = FALSE;
-     data.first = TRUE;
-
-     find_widget (widget, &data);
-     if (data.found)
-       return data.res_widget;
-     return widget;
-   }
- return NULL;
-}
-
-struct SnapshotData {
-  GtkWidget *toplevel_button;
-  GtkWidget **window;
-  GdkCursor *cursor;
-  gboolean in_query;
-  gboolean is_toplevel;
-  gint handler;
-};
-
-static void
-destroy_snapshot_data (GtkWidget             *widget,
-		       struct SnapshotData *data)
-{
-  if (*data->window)
-    *data->window = NULL;
-  
-  if (data->cursor)
-    {
-      g_object_unref (data->cursor);
-      data->cursor = NULL;
-    }
-
-  if (data->handler)
-    {
-      g_signal_handler_disconnect (widget, data->handler);
-      data->handler = 0;
-    }
-
-  g_free (data);
-}
-
-static gint
-snapshot_widget_event (GtkWidget	       *widget,
-		       GdkEvent	       *event,
-		       struct SnapshotData *data)
-{
-  GtkWidget *res_widget = NULL;
-
-  if (!data->in_query)
-    return FALSE;
-  
-  if (gdk_event_get_event_type (event) == GDK_BUTTON_RELEASE)
-    {
-      gtk_grab_remove (widget);
-      gdk_seat_ungrab (gdk_event_get_seat (event));
-
-      res_widget = find_widget_at_pointer (gdk_event_get_device (event));
-      if (data->is_toplevel && res_widget)
-	res_widget = gtk_widget_get_toplevel (res_widget);
-      if (res_widget)
-	{
-	  cairo_surface_t *surface;
-	  GtkWidget *window, *image;
-          GdkPixbuf *pixbuf;
-          int width, height;
-          cairo_t *cr;
-
-          width = gtk_widget_get_allocated_width (res_widget);
-          height = gtk_widget_get_allocated_height (res_widget);
-
-          surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
-
-          cr = cairo_create (surface);
-          gtk_widget_draw (res_widget, cr);
-          cairo_destroy (cr);
-
-          pixbuf = gdk_pixbuf_get_from_surface (surface,
-                                                0, 0,
-                                                width, height);
-          cairo_surface_destroy (surface);
-
-	  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
-          image = gtk_image_new_from_pixbuf (pixbuf);
-          g_object_unref (pixbuf);
-
-	  gtk_container_add (GTK_CONTAINER (window), image);
-	  gtk_widget_show (window);
-	}
-
-      data->in_query = FALSE;
-    }
-  return FALSE;
-}
-
-
-static void
-snapshot_widget (GtkButton *button,
-		 struct SnapshotData *data)
-{
-  GtkWidget *widget = GTK_WIDGET (button);
-  GdkDevice *device;
-
-  device = gtk_get_current_event_device ();
-  if (device == NULL)
-    return;
-
-  data->is_toplevel = widget == data->toplevel_button;
-
-  if (!data->cursor)
-    data->cursor = gdk_cursor_new_from_name ("crosshair", NULL);
-
-  gdk_seat_grab (gdk_device_get_seat (device),
-                 gtk_widget_get_window (widget),
-                 GDK_SEAT_CAPABILITY_ALL_POINTING,
-                 TRUE, data->cursor, NULL, NULL, NULL);
-
-  g_signal_connect (button, "event",
-		    G_CALLBACK (snapshot_widget_event), data);
-
-  gtk_grab_add (widget);
-
-  data->in_query = TRUE;
-}
-
-static void
-create_snapshot (GtkWidget *widget)
-{
-  static GtkWidget *window = NULL;
-  GtkWidget *button;
-  GtkWidget *vbox;
-  struct SnapshotData *data;
-
-  data = g_new (struct SnapshotData, 1);
-  data->window = &window;
-  data->in_query = FALSE;
-  data->cursor = NULL;
-  data->handler = 0;
-
-  if (!window)
-    {
-      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
-
-      gtk_window_set_display (GTK_WINDOW (window),
-			      gtk_widget_get_display (widget));      
-
-      data->handler = g_signal_connect (window, "destroy",
-					G_CALLBACK (destroy_snapshot_data),
-					data);
-
-      gtk_window_set_title (GTK_WINDOW (window), "test snapshot");
-
-      vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);
-      gtk_container_add (GTK_CONTAINER (window), vbox);
-
-      button = gtk_button_new_with_label ("Snapshot widget");
-      gtk_box_pack_start (GTK_BOX (vbox), button);
-      g_signal_connect (button, "clicked",
-			G_CALLBACK (snapshot_widget),
-			data);
-
-      button = gtk_button_new_with_label ("Snapshot toplevel");
-      data->toplevel_button = button;
-      gtk_box_pack_start (GTK_BOX (vbox), button);
-      g_signal_connect (button, "clicked",
-			G_CALLBACK (snapshot_widget),
-			data);
-    }
-
-  if (!gtk_widget_get_visible (window))
-    gtk_widget_show (window);
-  else
-    gtk_widget_destroy (window);
-  
-}
-
 /*
  * Test scrolling
  */
@@ -7849,7 +7447,6 @@ struct {
   { "dialog", create_dialog },
   { "display", create_display_screen, TRUE },
   { "entry", create_entry },
-  { "event watcher", create_event_watcher },
   { "expander", create_expander },
   { "flipping", create_flipping },
   { "focus", create_focus },
@@ -7874,7 +7471,6 @@ struct {
   { "saved position", create_saved_position },
   { "scrolled windows", create_scrolled_windows },
   { "size groups", create_size_groups },
-  { "snapshot", create_snapshot },
   { "spinbutton", create_spins },
   { "statusbar", create_statusbar },
   { "test mainloop", create_mainloop, TRUE },

testsuite/gtk/window.c

@@ -40,11 +40,13 @@ on_draw (GtkDrawingArea *da,
 }
 
 static gboolean
-on_keypress (GtkWidget *widget)
+on_keypress (GtkWidget *widget,
+             GdkEvent  *event)
 {
-  gtk_main_quit ();
+  if (gdk_event_get_event_type (event) == GDK_KEY_PRESS)
+    gtk_main_quit ();
 
-  return TRUE;
+  return GDK_EVENT_PROPAGATE;
 }
 
 static void
@@ -56,7 +58,7 @@ test_default_size (void)
 
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   if (interactive)
-    g_signal_connect (window, "key-press-event", G_CALLBACK (on_keypress), NULL);
+    g_signal_connect (window, "event", G_CALLBACK (on_keypress), NULL);
 
   da = gtk_drawing_area_new ();
   gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (da), on_draw, NULL, NULL);
@@ -133,7 +135,7 @@ test_resize (void)
 
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   if (interactive)
-    g_signal_connect (window, "key-press-event", G_CALLBACK (on_keypress), NULL);
+    g_signal_connect (window, "event", G_CALLBACK (on_keypress), NULL);
 
   da = gtk_drawing_area_new ();
   gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (da), on_draw, NULL, NULL);