Merge branch 'kill-key-events' into 'master'

Kill key events

See merge request GNOME/gtk!160

9 files changed, 108 insertions, 232 deletions

diff --git a/gtk/gtkbutton.c b/gtk/gtkbutton.c
index 8bc976f146..4879aeb9f5 100644
--- a/gtk/gtkbutton.c
+++ b/gtk/gtkbutton.c
@@ -136,7 +136,7 @@ static void gtk_button_get_property   (GObject            *object,
 static void gtk_button_display_changed (GtkWidget         *widget,
 				        GdkDisplay        *previous_display);
 static void gtk_button_unrealize (GtkWidget * widget);
-static gint gtk_button_key_release (GtkWidget * widget, GdkEventKey * event);
+static gint gtk_button_event (GtkWidget * widget, GdkEvent * event);
 static void gtk_real_button_clicked (GtkButton * button);
 static void gtk_real_button_activate  (GtkButton          *button);
 static void gtk_button_update_state   (GtkButton          *button);
@@ -220,7 +220,7 @@ gtk_button_class_init (GtkButtonClass *klass)
   widget_class->measure = gtk_button_measure_;
   widget_class->display_changed = gtk_button_display_changed;
   widget_class->unrealize = gtk_button_unrealize;
-  widget_class->key_release_event = gtk_button_key_release;
+  widget_class->event = gtk_button_event;
   widget_class->state_flags_changed = gtk_button_state_flags_changed;
   widget_class->grab_notify = gtk_button_grab_notify;
   widget_class->unmap = gtk_button_unmap;
@@ -762,21 +762,24 @@ gtk_button_do_release (GtkButton *button,
 }
 
 static gboolean
-gtk_button_key_release (GtkWidget   *widget,
-			GdkEventKey *event)
+gtk_button_event (GtkWidget *widget,
+                  GdkEvent  *event)
 {
   GtkButton *button = GTK_BUTTON (widget);
   GtkButtonPrivate *priv = gtk_button_get_instance_private (button);
 
+  if (gdk_event_get_event_type (event) != GDK_KEY_RELEASE)
+    return GDK_EVENT_PROPAGATE;
+
   if (priv->activate_timeout)
     {
       gtk_button_finish_activate (button, TRUE);
-      return TRUE;
+      return GDK_EVENT_STOP;
     }
-  else if (GTK_WIDGET_CLASS (gtk_button_parent_class)->key_release_event)
-    return GTK_WIDGET_CLASS (gtk_button_parent_class)->key_release_event (widget, event);
+  else if (GTK_WIDGET_CLASS (gtk_button_parent_class)->event)
+    return GTK_WIDGET_CLASS (gtk_button_parent_class)->event (widget, event);
   else
-    return FALSE;
+    return GDK_EVENT_PROPAGATE;
 }
 
 static void
diff --git a/gtk/gtkentry.c b/gtk/gtkentry.c
index 6ca8eec087..7a7ce7268e 100644
--- a/gtk/gtkentry.c
+++ b/gtk/gtkentry.c
@@ -4432,14 +4432,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 = gtk_entry_get_instance_private (entry);
   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)
@@ -4469,8 +4472,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
diff --git a/gtk/gtkfilechooserentry.c b/gtk/gtkfilechooserentry.c
index 05478e3aed..1b17f2aec3 100644
--- a/gtk/gtkfilechooserentry.c
+++ b/gtk/gtkfilechooserentry.c
@@ -85,7 +85,7 @@ static void     gtk_file_chooser_entry_finalize       (GObject          *object)
 static void     gtk_file_chooser_entry_dispose        (GObject          *object);
 static void     gtk_file_chooser_entry_grab_focus     (GtkWidget        *widget);
 static gboolean gtk_file_chooser_entry_tab_handler    (GtkWidget        *widget,
-                                                       GdkEventKey      *event);
+                                                       GdkEvent         *event);
 static gboolean gtk_file_chooser_entry_event          (GtkWidget       *widget,
                                                        GdkEvent        *event);
 
@@ -295,7 +295,7 @@ _gtk_file_chooser_entry_init (GtkFileChooserEntry *chooser_entry)
   g_object_unref (comp);
   /* NB: This needs to happen after the completion is set, so this handler
    * runs before the handler installed by entrycompletion */
-  g_signal_connect (chooser_entry, "key-press-event",
+  g_signal_connect (chooser_entry, "event",
                     G_CALLBACK (gtk_file_chooser_entry_tab_handler), NULL);
 
 #ifdef G_OS_WIN32
@@ -497,7 +497,7 @@ start_explicit_completion (GtkFileChooserEntry *chooser_entry)
 
 static gboolean
 gtk_file_chooser_entry_tab_handler (GtkWidget *widget,
-				    GdkEventKey *event)
+				    GdkEvent  *event)
 {
   GtkFileChooserEntry *chooser_entry;
   GtkEditable *editable;
@@ -508,25 +508,28 @@ gtk_file_chooser_entry_tab_handler (GtkWidget *widget,
   chooser_entry = GTK_FILE_CHOOSER_ENTRY (widget);
   editable = GTK_EDITABLE (widget);
 
-  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 &&
       chooser_entry->eat_escape)
     {
       g_signal_emit (widget, signals[HIDE_ENTRY], 0);
-      return TRUE;
+      return GDK_EVENT_STOP;
     }
 
   if (!chooser_entry->eat_tabs)
-    return FALSE;
+    return GDK_EVENT_PROPAGATE;
 
   if (keyval != GDK_KEY_Tab)
-    return FALSE;
+    return GDK_EVENT_PROPAGATE;
 
   if (gtk_get_current_event_state (&state) &&
       (state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
-    return FALSE;
+    return GDK_EVENT_PROPAGATE;
 
   /* This is a bit evil -- it makes Tab never leave the entry. It basically
    * makes it 'safe' for people to hit. */
@@ -537,7 +540,7 @@ gtk_file_chooser_entry_tab_handler (GtkWidget *widget,
   else
     start_explicit_completion (chooser_entry);
 
-  return TRUE;
+  return GDK_EVENT_STOP;
 }
 
 static gboolean
diff --git a/gtk/gtkfilechooserwidget.c b/gtk/gtkfilechooserwidget.c
index aa4c3966d1..91fc5363b7 100644
--- a/gtk/gtkfilechooserwidget.c
+++ b/gtk/gtkfilechooserwidget.c
@@ -456,8 +456,8 @@ static void     gtk_file_chooser_widget_hierarchy_changed (GtkWidget          *w
 static void     gtk_file_chooser_widget_style_updated   (GtkWidget             *widget);
 static void     gtk_file_chooser_widget_display_changed (GtkWidget            *widget,
                                                          GdkDisplay           *previous_display);
-static gboolean gtk_file_chooser_widget_key_press_event (GtkWidget            *widget,
-                                                         GdkEventKey          *event);
+static gboolean gtk_file_chooser_widget_event (GtkWidget            *widget,
+                                               GdkEvent             *event);
 
 static gboolean       gtk_file_chooser_widget_set_current_folder           (GtkFileChooser    *chooser,
                                                                             GFile             *folder,
@@ -1382,15 +1382,18 @@ key_press_cb (GtkEventController *controller,
 }
 
 static gboolean
-gtk_file_chooser_widget_key_press_event (GtkWidget   *widget,
-                                         GdkEventKey *event)
+gtk_file_chooser_widget_event (GtkWidget *widget,
+                               GdkEvent  *event)
 {
   GtkFileChooserWidget *impl = (GtkFileChooserWidget *) widget;
   GtkFileChooserWidgetPrivate *priv = impl->priv;
   guint keyval, state;
 
-  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;
+
+  gdk_event_get_keyval (event, &keyval);
+  gdk_event_get_state (event, &state);
 
   if (should_trigger_location_entry (impl, keyval, state))
     {
@@ -1399,22 +1402,22 @@ gtk_file_chooser_widget_key_press_event (GtkWidget   *widget,
         {
           const char *string;
 
-          gdk_event_get_string ((GdkEvent *)event, &string);
+          gdk_event_get_string (event, &string);
           location_popup_handler (impl, string);
-          return TRUE;
+          return GDK_EVENT_STOP;
         }
     }
-  else if (gtk_search_entry_handle_event (GTK_SEARCH_ENTRY (priv->search_entry), (GdkEvent *)event))
+  else if (gtk_search_entry_handle_event (GTK_SEARCH_ENTRY (priv->search_entry), event))
     {
       if (priv->operation_mode != OPERATION_MODE_SEARCH)
         operation_mode_set (impl, OPERATION_MODE_SEARCH);
-      return TRUE;
+      return GDK_EVENT_STOP;
     }
 
-  if (GTK_WIDGET_CLASS (gtk_file_chooser_widget_parent_class)->key_press_event (widget, event))
-    return TRUE;
+  if (GTK_WIDGET_CLASS (gtk_file_chooser_widget_parent_class)->event (widget, event))
+    return GDK_EVENT_STOP;
 
-  return FALSE;
+  return GDK_EVENT_PROPAGATE;
 }
 
 /* Callback used from gtk_tree_selection_selected_foreach(); adds a bookmark for
@@ -2537,14 +2540,17 @@ location_entry_create (GtkFileChooserWidget *impl)
 }
 
 static gboolean
-external_entry_key_press (GtkWidget            *entry,
-                          GdkEventKey          *event,
-                          GtkFileChooserWidget *impl)
+external_entry_event (GtkWidget            *entry,
+                      GdkEvent             *event,
+                      GtkFileChooserWidget *impl)
 {
   /* Since the entry is not a descendent of the file chooser widget
    * in this case, we need to manually make our bindings apply.
    */
-  return gtk_bindings_activate_event (G_OBJECT (impl), event);
+  if (gdk_event_get_event_type (event) != GDK_KEY_PRESS)
+    return GDK_EVENT_PROPAGATE;
+
+  return gtk_bindings_activate_event (G_OBJECT (impl), (GdkEventKey *)event);
 }
 
 /* Creates the widgets specific to Save mode */
@@ -2569,8 +2575,8 @@ save_widgets_create (GtkFileChooserWidget *impl)
       priv->location_entry = priv->external_entry;
       location_entry_setup (impl);
 
-      g_signal_connect_after (priv->external_entry, "key-press-event",
-                              G_CALLBACK (external_entry_key_press), impl);
+      g_signal_connect_after (priv->external_entry, "event",
+                              G_CALLBACK (external_entry_event), impl);
       return;
     }
 
@@ -2611,7 +2617,7 @@ save_widgets_destroy (GtkFileChooserWidget *impl)
 
   if (priv->external_entry && priv->external_entry == priv->location_entry)
     {
-      g_signal_handlers_disconnect_by_func (priv->external_entry, external_entry_key_press, impl);
+      g_signal_handlers_disconnect_by_func (priv->external_entry, external_entry_event, impl);
 
       location_entry_disconnect (impl);
       priv->location_entry = NULL;
@@ -7980,7 +7986,7 @@ gtk_file_chooser_widget_class_init (GtkFileChooserWidgetClass *class)
   widget_class->hierarchy_changed = gtk_file_chooser_widget_hierarchy_changed;
   widget_class->style_updated = gtk_file_chooser_widget_style_updated;
   widget_class->display_changed = gtk_file_chooser_widget_display_changed;
-  widget_class->key_press_event = gtk_file_chooser_widget_key_press_event;
+  widget_class->event = gtk_file_chooser_widget_event;
   widget_class->measure = gtk_file_chooser_widget_measure;
   widget_class->size_allocate = gtk_file_chooser_widget_size_allocate;
   widget_class->snapshot = gtk_file_chooser_widget_snapshot;
diff --git a/gtk/gtkfontchooserdialog.c b/gtk/gtkfontchooserdialog.c
index 185ea38e26..0208040ef7 100644
--- a/gtk/gtkfontchooserdialog.c
+++ b/gtk/gtkfontchooserdialog.c
@@ -124,16 +124,19 @@ font_activated_cb (GtkFontChooser *fontchooser,
 }
 
 static gboolean
-gtk_font_chooser_dialog_key_press_event (GtkWidget   *dialog,
-                                         GdkEventKey *event)
+gtk_font_chooser_dialog_event (GtkWidget *dialog,
+                               GdkEvent  *event)
 {
   GtkFontChooserDialog *fdialog = GTK_FONT_CHOOSER_DIALOG (dialog);
   gboolean handled = FALSE;
 
-  handled = GTK_WIDGET_CLASS (gtk_font_chooser_dialog_parent_class)->key_press_event (dialog, event);
+  if (gdk_event_get_event_type (event) != GDK_KEY_PRESS)
+    return GDK_EVENT_PROPAGATE;
+
+  handled = GTK_WIDGET_CLASS (gtk_font_chooser_dialog_parent_class)->event (dialog, event);
 
   if (!handled)
-    handled = gtk_font_chooser_widget_handle_event (fdialog->priv->fontchooser, event);
+    handled = gtk_font_chooser_widget_handle_event (fdialog->priv->fontchooser, (GdkEventKey *)event);
 
   return handled;
 }
@@ -205,7 +208,7 @@ gtk_font_chooser_dialog_class_init (GtkFontChooserDialogClass *klass)
   gobject_class->get_property = gtk_font_chooser_dialog_get_property;
   gobject_class->set_property = gtk_font_chooser_dialog_set_property;
 
-  widget_class->key_press_event = gtk_font_chooser_dialog_key_press_event;
+  widget_class->event = gtk_font_chooser_dialog_event;
   widget_class->map = gtk_font_chooser_dialog_map;
 
   _gtk_font_chooser_install_properties (gobject_class);
diff --git a/gtk/gtkspinbutton.c b/gtk/gtkspinbutton.c
index 0639fee044..7b5cd7c5ca 100644
--- a/gtk/gtkspinbutton.c
+++ b/gtk/gtkspinbutton.c
@@ -268,8 +268,6 @@ static gboolean gtk_spin_button_timer          (GtkSpinButton      *spin_button)
 static gboolean gtk_spin_button_stop_spinning  (GtkSpinButton      *spin);
 static void gtk_spin_button_value_changed  (GtkAdjustment      *adjustment,
                                             GtkSpinButton      *spin_button);
-static gint gtk_spin_button_key_release    (GtkWidget          *widget,
-                                            GdkEventKey        *event);
 
 static void gtk_spin_button_activate       (GtkEntry           *entry,
                                             gpointer            user_data);
@@ -320,7 +318,6 @@ gtk_spin_button_class_init (GtkSpinButtonClass *class)
   widget_class->realize = gtk_spin_button_realize;
   widget_class->measure = gtk_spin_button_measure;
   widget_class->size_allocate = gtk_spin_button_size_allocate;
-  widget_class->key_release_event = gtk_spin_button_key_release;
   widget_class->event = gtk_spin_button_event;
   widget_class->grab_notify = gtk_spin_button_grab_notify;
   widget_class->state_flags_changed = gtk_spin_button_state_flags_changed;
@@ -1089,6 +1086,14 @@ gtk_spin_button_event (GtkWidget *widget,
   GtkSpinButton *spin_button = GTK_SPIN_BUTTON (widget);
   GtkSpinButtonPrivate *priv = gtk_spin_button_get_instance_private (spin_button);
 
+  if (gdk_event_get_event_type (event) == GDK_KEY_RELEASE)
+    {
+      /* We only get a release at the end of a key repeat run, so reset the timer_step */
+      priv->timer_step = gtk_adjustment_get_step_increment (priv->adjustment);
+      priv->timer_calls = 0;
+
+      return GDK_EVENT_STOP;
+    }
   if (gdk_event_get_event_type (event) == GDK_FOCUS_CHANGE)
     {
       gboolean focus_in;
@@ -1298,20 +1303,6 @@ gtk_spin_button_real_change_value (GtkSpinButton *spin,
     gtk_widget_error_bell (GTK_WIDGET (spin));
 }
 
-static gint
-gtk_spin_button_key_release (GtkWidget   *widget,
-                             GdkEventKey *event)
-{
-  GtkSpinButton *spin = GTK_SPIN_BUTTON (widget);
-  GtkSpinButtonPrivate *priv = gtk_spin_button_get_instance_private (spin);
-
-  /* We only get a release at the end of a key repeat run, so reset the timer_step */
-  priv->timer_step = gtk_adjustment_get_step_increment (priv->adjustment);
-  priv->timer_calls = 0;
-
-  return TRUE;
-}
-
 static void
 gtk_spin_button_snap (GtkSpinButton *spin_button,
                       gdouble        val)
diff --git a/gtk/gtktreeview.c b/gtk/gtktreeview.c
index 083c6ce33a..7364a2dab0 100644
--- a/gtk/gtktreeview.c
+++ b/gtk/gtktreeview.c
@@ -599,10 +599,6 @@ static void     gtk_tree_view_size_allocate        (GtkWidget           *widget,
                                                     int                  baseline);
 static void     gtk_tree_view_snapshot             (GtkWidget        *widget,
                                                     GtkSnapshot      *snapshot);
-static gboolean gtk_tree_view_key_press            (GtkWidget        *widget,
-						    GdkEventKey      *event);
-static gboolean gtk_tree_view_key_release          (GtkWidget        *widget,
-						    GdkEventKey      *event);
 
 static void     gtk_tree_view_set_focus_child      (GtkContainer     *container,
 						    GtkWidget        *child);
@@ -815,8 +811,8 @@ static void     gtk_tree_view_search_scroll_event       (GtkWidget        *entry
 							 gdouble           dx,
                                                          gdouble           dy,
 							 GtkTreeView      *tree_view);
-static gboolean gtk_tree_view_search_key_press_event    (GtkWidget        *entry,
-							 GdkEventKey      *event,
+static gboolean gtk_tree_view_search_event              (GtkWidget        *entry,
+							 GdkEvent         *event,
 							 GtkTreeView      *tree_view);
 static gboolean gtk_tree_view_search_move               (GtkWidget        *window,
 							 GtkTreeView      *tree_view,
@@ -972,8 +968,6 @@ gtk_tree_view_class_init (GtkTreeViewClass *class)
   widget_class->measure = gtk_tree_view_measure;
   widget_class->size_allocate = gtk_tree_view_size_allocate;
   widget_class->snapshot = gtk_tree_view_snapshot;
-  widget_class->key_press_event = gtk_tree_view_key_press;
-  widget_class->key_release_event = gtk_tree_view_key_release;
   widget_class->event = gtk_tree_view_event;
   widget_class->drag_begin = gtk_tree_view_drag_begin;
   widget_class->drag_end = gtk_tree_view_drag_end;
@@ -2101,7 +2095,7 @@ gtk_tree_view_destroy (GtkWidget *widget)
                                             G_CALLBACK (gtk_tree_view_search_init),
                                             tree_view);
       g_signal_handlers_disconnect_by_func (tree_view->priv->search_entry,
-                                            G_CALLBACK (gtk_tree_view_search_key_press_event),
+                                            G_CALLBACK (gtk_tree_view_search_event),
                                             tree_view);
 
       g_object_unref (tree_view->priv->search_entry);
@@ -5593,8 +5587,11 @@ gtk_tree_view_key_press (GtkWidget   *widget,
     }
 
   /* Chain up to the parent class.  It handles the keybindings. */
-  if (GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_press_event (widget, event))
-    return TRUE;
+  if (GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->event)
+    {
+      if (GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->event (widget, (GdkEvent *)event))
+        return TRUE;
+    }
 
   if (tree_view->priv->search_entry_avoid_unhandled_binding)
     {
@@ -5680,9 +5677,13 @@ gtk_tree_view_key_release (GtkWidget   *widget,
   GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
 
   if (tree_view->priv->rubber_band_status)
-    return TRUE;
+    return GDK_EVENT_STOP;
+
+  /* Chain up to the parent class.  It handles the keybindings. */
+  if (GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->event)
+    return GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->event (widget, (GdkEvent *)event);
 
-  return GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->key_release_event (widget, event);
+  return GDK_EVENT_PROPAGATE;
 }
 
 static void
@@ -5736,7 +5737,11 @@ gtk_tree_view_event (GtkWidget *widget,
 
   tree_view = GTK_TREE_VIEW (widget);
 
-  if (gdk_event_get_event_type (event) == GDK_FOCUS_CHANGE)
+  if (gdk_event_get_event_type (event) == GDK_KEY_PRESS)
+    return gtk_tree_view_key_press (widget, (GdkEventKey *)event);
+  else if (gdk_event_get_event_type (event) == GDK_KEY_RELEASE)
+    return gtk_tree_view_key_release (widget, (GdkEventKey *)event);
+  else if (gdk_event_get_event_type (event) == GDK_FOCUS_CHANGE)
     {
       gboolean focus_in;
 
@@ -10514,8 +10519,8 @@ gtk_tree_view_ensure_interactive_directory (GtkTreeView *tree_view)
   gtk_window_set_transient_for (GTK_WINDOW (tree_view->priv->search_window),
                                 GTK_WINDOW (toplevel));
 
-  g_signal_connect (tree_view->priv->search_window, "key-press-event",
-		    G_CALLBACK (gtk_tree_view_search_key_press_event),
+  g_signal_connect (tree_view->priv->search_window, "event",
+		    G_CALLBACK (gtk_tree_view_search_event),
 		    tree_view);
   gesture = gtk_gesture_multi_press_new ();
   g_signal_connect (gesture, "pressed",
@@ -13976,7 +13981,7 @@ gtk_tree_view_set_search_entry (GtkTreeView *tree_view,
 	  tree_view->priv->search_entry_changed_id = 0;
 	}
       g_signal_handlers_disconnect_by_func (tree_view->priv->search_entry,
-					    G_CALLBACK (gtk_tree_view_search_key_press_event),
+					    G_CALLBACK (gtk_tree_view_search_event),
 					    tree_view);
 
       g_object_unref (tree_view->priv->search_entry);
@@ -13999,8 +14004,8 @@ gtk_tree_view_set_search_entry (GtkTreeView *tree_view,
 			      tree_view);
 	}
       
-        g_signal_connect (tree_view->priv->search_entry, "key-press-event",
-		          G_CALLBACK (gtk_tree_view_search_key_press_event),
+        g_signal_connect (tree_view->priv->search_entry, "event",
+		          G_CALLBACK (gtk_tree_view_search_event),
 		          tree_view);
 
 	gtk_tree_view_search_init (tree_view->priv->search_entry, tree_view);
@@ -14260,9 +14265,9 @@ gtk_tree_view_search_scroll_event (GtkWidget   *widget,
 }
 
 static gboolean
-gtk_tree_view_search_key_press_event (GtkWidget *widget,
-				      GdkEventKey *event,
-				      GtkTreeView *tree_view)
+gtk_tree_view_search_event (GtkWidget   *widget,
+                            GdkEvent    *event,
+                            GtkTreeView *tree_view)
 {
   GdkModifierType default_accel;
   gboolean        retval = FALSE;
@@ -14271,8 +14276,11 @@ gtk_tree_view_search_key_press_event (GtkWidget *widget,
   g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
   g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
 
-  if (!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))
     return GDK_EVENT_PROPAGATE;
 
   /* close window and cancel the search */
@@ -14280,7 +14288,7 @@ gtk_tree_view_search_key_press_event (GtkWidget *widget,
       && gtk_tree_view_search_key_cancels_search (keyval))
     {
       gtk_tree_view_search_window_hide (widget, tree_view,
-                                        gdk_event_get_device ((GdkEvent *) event));
+                                        gdk_event_get_device (event));
       return TRUE;
     }
 
diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c
index 57e52d0091..c2aba61e97 100644
--- a/gtk/gtkwidget.c
+++ b/gtk/gtkwidget.c
@@ -483,8 +483,6 @@ enum {
   MOVE_FOCUS,
   KEYNAV_FAILED,
   EVENT,
-  KEY_PRESS_EVENT,
-  KEY_RELEASE_EVENT,
   DRAG_BEGIN,
   DRAG_END,
   DRAG_DATA_DELETE,
@@ -594,10 +592,6 @@ static void     gtk_widget_real_style_updated    (GtkWidget         *widget);
 static void	gtk_widget_dispatch_child_properties_changed	(GtkWidget        *object,
 								 guint             n_pspecs,
 								 GParamSpec      **pspecs);
-static gboolean		gtk_widget_real_key_press_event   	(GtkWidget        *widget,
-								 GdkEventKey      *event);
-static gboolean		gtk_widget_real_key_release_event 	(GtkWidget        *widget,
-								 GdkEventKey      *event);
 static gboolean		gtk_widget_real_focus			(GtkWidget        *widget,
 								 GtkDirectionType  direction);
 static void             gtk_widget_real_move_focus              (GtkWidget        *widget,
@@ -922,8 +916,6 @@ gtk_widget_class_init (GtkWidgetClass *klass)
   klass->move_focus = gtk_widget_real_move_focus;
   klass->keynav_failed = gtk_widget_real_keynav_failed;
   klass->event = NULL;
-  klass->key_press_event = gtk_widget_real_key_press_event;
-  klass->key_release_event = gtk_widget_real_key_release_event;
   klass->drag_begin = NULL;
   klass->drag_end = NULL;
   klass->drag_data_delete = NULL;
@@ -1723,61 +1715,6 @@ gtk_widget_class_init (GtkWidgetClass *klass)
                               _gtk_marshal_BOOLEAN__OBJECTv);
 
   /**
-   * GtkWidget::key-press-event:
-   * @widget: the object which received the signal
-   * @event: (type Gdk.EventKey): the #GdkEventKey which triggered this signal.
-   *
-   * The ::key-press-event signal is emitted when a key is pressed. The signal
-   * emission will reoccur at the key-repeat rate when the key is kept pressed.
-   *
-   * To receive this signal, the #GdkSurface associated to the widget needs
-   * to enable the #GDK_KEY_PRESS_MASK mask.
-   *
-   * This signal will be sent to the grab widget if there is one.
-   *
-   * Returns: %TRUE to stop other handlers from being invoked for the event.
-   *   %FALSE to propagate the event further.
-   */
-  widget_signals[KEY_PRESS_EVENT] =
-    g_signal_new (I_("key-press-event"),
-		  G_TYPE_FROM_CLASS (klass),
-		  G_SIGNAL_RUN_LAST,
-		  G_STRUCT_OFFSET (GtkWidgetClass, key_press_event),
-		  _gtk_boolean_handled_accumulator, NULL,
-		  _gtk_marshal_BOOLEAN__OBJECT,
-		  G_TYPE_BOOLEAN, 1,
-		  GDK_TYPE_EVENT);
-  g_signal_set_va_marshaller (widget_signals[KEY_PRESS_EVENT], G_TYPE_FROM_CLASS (klass),
-                              _gtk_marshal_BOOLEAN__OBJECTv);
-
-  /**
-   * GtkWidget::key-release-event:
-   * @widget: the object which received the signal
-   * @event: (type Gdk.EventKey): the #GdkEventKey which triggered this signal.
-   *
-   * The ::key-release-event signal is emitted when a key is released.
-   *
-   * To receive this signal, the #GdkSurface associated to the widget needs
-   * to enable the #GDK_KEY_RELEASE_MASK mask.
-   *
-   * This signal will be sent to the grab widget if there is one.
-   *
-   * Returns: %TRUE to stop other handlers from being invoked for the event.
-   *   %FALSE to propagate the event further.
-   */
-  widget_signals[KEY_RELEASE_EVENT] =
-    g_signal_new (I_("key-release-event"),
-		  G_TYPE_FROM_CLASS (klass),
-		  G_SIGNAL_RUN_LAST,
-		  G_STRUCT_OFFSET (GtkWidgetClass, key_release_event),
-		  _gtk_boolean_handled_accumulator, NULL,
-		  _gtk_marshal_BOOLEAN__OBJECT,
-		  G_TYPE_BOOLEAN, 1,
-		  GDK_TYPE_EVENT);
-  g_signal_set_va_marshaller (widget_signals[KEY_RELEASE_EVENT], G_TYPE_FROM_CLASS (klass),
-                              _gtk_marshal_BOOLEAN__OBJECTv);
-
-  /**
    * GtkWidget::drag-leave:
    * @widget: the object which received the signal.
    * @context: the drag context
@@ -5123,20 +5060,6 @@ gtk_widget_get_renderer (GtkWidget *widget)
   return NULL;
 }
 
-static gboolean
-gtk_widget_real_key_press_event (GtkWidget         *widget,
-				 GdkEventKey       *event)
-{
-  return FALSE;
-}
-
-static gboolean
-gtk_widget_real_key_release_event (GtkWidget         *widget,
-				   GdkEventKey       *event)
-{
-  return FALSE;
-}
-
 #define WIDGET_REALIZED_FOR_EVENT(widget, event) \
      (event->any.type == GDK_FOCUS_CHANGE || _gtk_widget_get_realized(widget))
 
@@ -5405,64 +5328,6 @@ gtk_widget_emit_event_signals (GtkWidget      *widget,
 
   g_signal_emit (widget, widget_signals[EVENT], 0, event, &handled);
   return_val |= handled | !WIDGET_REALIZED_FOR_EVENT (widget, event);
-  if (!return_val)
-    {
-      gint signal_num;
-
-      switch (event->any.type)
-	{
-        case GDK_DRAG_ENTER:
-        case GDK_DRAG_LEAVE:
-        case GDK_DRAG_MOTION:
-        case GDK_DROP_START:
-        case GDK_EVENT_LAST:
-        case GDK_TOUCHPAD_SWIPE:
-        case GDK_TOUCHPAD_PINCH:
-        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_PROXIMITY_IN:
-	case GDK_PROXIMITY_OUT:
-	case GDK_SCROLL:
-        case GDK_TOUCH_BEGIN:
-        case GDK_TOUCH_UPDATE:
-        case GDK_TOUCH_END:
-        case GDK_TOUCH_CANCEL:
-	case GDK_EXPOSE:
-	case GDK_DELETE:
-	case GDK_DESTROY:
-	case GDK_MAP:
-	case GDK_UNMAP:
-	case GDK_CONFIGURE:
-	case GDK_ENTER_NOTIFY:
-	case GDK_LEAVE_NOTIFY:
-	case GDK_GRAB_BROKEN:
-	case GDK_FOCUS_CHANGE:
-	case GDK_MOTION_NOTIFY:
-	case GDK_BUTTON_PRESS:
-	case GDK_BUTTON_RELEASE:
-	case GDK_NOTHING:
-	  signal_num = -1;
-	  break;
-	case GDK_KEY_PRESS:
-	  signal_num = KEY_PRESS_EVENT;
-	  break;
-	case GDK_KEY_RELEASE:
-	  signal_num = KEY_RELEASE_EVENT;
-	  break;
-	default:
-	  g_warning ("gtk_widget_event(): unhandled event type: %d", event->any.type);
-	  signal_num = -1;
-	  break;
-	}
-      if (signal_num != -1)
-        {
-	  g_signal_emit (widget, widget_signals[signal_num], 0, event, &handled);
-          return_val |= handled;
-        }
-    }
 
   g_object_unref (widget);
 
diff --git a/gtk/gtkwidget.h b/gtk/gtkwidget.h
index 66bbcb2e4b..219c1ef597 100644
--- a/gtk/gtkwidget.h
+++ b/gtk/gtkwidget.h
@@ -190,8 +190,6 @@ struct _GtkWidget
  * @keynav_failed: Signal emitted if keyboard navigation fails.
  * @event: The GTK+ main loop will emit this signal for each GDK
  *   event delivered to a widget.
- * @key_press_event: Signal emitted when a key is pressed.
- * @key_release_event: Signal is emitted when a key is released.
  * @drag_begin: Signal emitted on the drag source when a drag is
  *   started.
  * @drag_end: Signal emitted on the drag source when a drag is
@@ -293,10 +291,6 @@ struct _GtkWidgetClass
   /* events */
   gboolean (* event)                    (GtkWidget           *widget,
                                          GdkEvent            *event);
-  gboolean (* key_press_event)          (GtkWidget           *widget,
-                                         GdkEventKey         *event);
-  gboolean (* key_release_event)        (GtkWidget           *widget,
-                                         GdkEventKey         *event);
 
   /* Source side drag signals */
   void     (* drag_begin)          (GtkWidget         *widget,