eventcontroller: Clarify filter_event()

The original intention with this function was to mark events that would
be filtered out - meaning one returns TRUE to skip and even and FALSE to
handle it. While this is docuemnted, it's not particularly clear and a few
controllers use it incorrectly. For example, GtkGesture intends to block
touchpad gesture events by default, yet in reality it allows them instead,
and otherwise chains up to GtkEventController that already enables
everything.

Instead, change it to work the way newer code uses it - skip everything by
default and have controllers explicitly allow events they need, and change
the return type from a boolean to a new enum with values HANDLE and SKIP.

17 files changed, 138 insertions, 69 deletions

diff --git a/gtk/gtkdragsource.c b/gtk/gtkdragsource.c
index e654729405..09c4199d42 100644
--- a/gtk/gtkdragsource.c
+++ b/gtk/gtkdragsource.c
@@ -243,7 +243,7 @@ gtk_drag_source_get_property (GObject    *object,
     }
 }
 
-static gboolean
+static GtkFilterEventStatus
 gtk_drag_source_filter_event (GtkEventController *controller,
                               GdkEvent           *event)
 {
@@ -257,9 +257,9 @@ gtk_drag_source_filter_event (GtkEventController *controller,
       n_fingers = gdk_touchpad_event_get_n_fingers (event);
 
       if (n_fingers == n_points)
-        return FALSE;
+        return GTK_EVENT_HANDLE;
       else
-        return TRUE;
+        return GTK_EVENT_SKIP;
     }
 
   return GTK_EVENT_CONTROLLER_CLASS (gtk_drag_source_parent_class)->filter_event (controller, event);
diff --git a/gtk/gtkdropcontrollermotion.c b/gtk/gtkdropcontrollermotion.c
index 75c816cb74..1510278a02 100644
--- a/gtk/gtkdropcontrollermotion.c
+++ b/gtk/gtkdropcontrollermotion.c
@@ -77,22 +77,27 @@ static guint signals[N_SIGNALS] = { 0 };
 
 G_DEFINE_TYPE (GtkDropControllerMotion, gtk_drop_controller_motion, GTK_TYPE_EVENT_CONTROLLER)
 
+static GtkFilterEventStatus
+gtk_drop_controller_motion_filter_event (GtkEventController *controller,
+                                         GdkEvent           *event)
+{
+  GdkEventType event_type = gdk_event_get_event_type (event);
+
+  if (event_type == GDK_DRAG_MOTION)
+    return GTK_EVENT_HANDLE;
+
+  return GTK_EVENT_SKIP;
+}
+
 static gboolean
 gtk_drop_controller_motion_handle_event (GtkEventController *controller,
                                          GdkEvent           *event,
                                          double              x,
                                          double              y)
 {
-  GtkEventControllerClass *parent_class;
-  GdkEventType type;
-
-  type = gdk_event_get_event_type (event);
-  if (type == GDK_DRAG_MOTION)
-    g_signal_emit (controller, signals[MOTION], 0, x, y);
-
-  parent_class = GTK_EVENT_CONTROLLER_CLASS (gtk_drop_controller_motion_parent_class);
+  g_signal_emit (controller, signals[MOTION], 0, x, y);
 
-  return parent_class->handle_event (controller, event, x, y);
+  return GDK_EVENT_PROPAGATE;
 }
 
 static void
@@ -204,6 +209,7 @@ gtk_drop_controller_motion_class_init (GtkDropControllerMotionClass *klass)
 
   object_class->get_property = gtk_drop_controller_motion_get_property;
 
+  controller_class->filter_event = gtk_drop_controller_motion_filter_event;
   controller_class->handle_event = gtk_drop_controller_motion_handle_event;
   controller_class->handle_crossing = gtk_drop_controller_motion_handle_crossing;
 
diff --git a/gtk/gtkdroptarget.c b/gtk/gtkdroptarget.c
index 477f167580..9272104aff 100644
--- a/gtk/gtkdroptarget.c
+++ b/gtk/gtkdroptarget.c
@@ -388,7 +388,7 @@ gtk_drop_target_drop (GtkDropTarget  *self,
   return FALSE;
 }
 
-static gboolean
+static GtkFilterEventStatus
 gtk_drop_target_filter_event (GtkEventController *controller,
                               GdkEvent           *event)
 {
@@ -398,12 +398,12 @@ gtk_drop_target_filter_event (GtkEventController *controller,
     case GDK_DRAG_LEAVE:
     case GDK_DRAG_MOTION:
     case GDK_DROP_START:
-      return GTK_EVENT_CONTROLLER_CLASS (gtk_drop_target_parent_class)->filter_event (controller, event);
+      return GTK_EVENT_HANDLE;
 
     default:;
     }
 
-  return TRUE;
+  return GTK_EVENT_SKIP;
 }
 
 static gboolean
diff --git a/gtk/gtkdroptargetasync.c b/gtk/gtkdroptargetasync.c
index 1afd86d922..5c224efc07 100644
--- a/gtk/gtkdroptargetasync.c
+++ b/gtk/gtkdroptargetasync.c
@@ -183,7 +183,7 @@ gtk_drop_target_async_drop (GtkDropTargetAsync  *self,
   return FALSE;
 }
 
-static gboolean
+static GtkFilterEventStatus
 gtk_drop_target_async_filter_event (GtkEventController *controller,
                                     GdkEvent           *event)
 {
@@ -193,12 +193,12 @@ gtk_drop_target_async_filter_event (GtkEventController *controller,
     case GDK_DRAG_LEAVE:
     case GDK_DRAG_MOTION:
     case GDK_DROP_START:
-      return GTK_EVENT_CONTROLLER_CLASS (gtk_drop_target_async_parent_class)->filter_event (controller, event);
+      return GTK_EVENT_HANDLE;
 
     default:;
     }
 
-  return TRUE;
+  return GTK_EVENT_SKIP;
 }
 
 static gboolean
diff --git a/gtk/gtkeventcontroller.c b/gtk/gtkeventcontroller.c
index 8666de4a87..faac399594 100644
--- a/gtk/gtkeventcontroller.c
+++ b/gtk/gtkeventcontroller.c
@@ -87,11 +87,11 @@ gtk_event_controller_unset_widget (GtkEventController *self)
   priv->widget = NULL;
 }
 
-static gboolean
+static GtkFilterEventStatus
 gtk_event_controller_filter_event_default (GtkEventController *self,
                                            GdkEvent           *event)
 {
-  return FALSE;
+  return GTK_EVENT_SKIP;
 }
 
 static gboolean
@@ -273,7 +273,7 @@ same_native (GtkWidget *widget,
   return native == native2;
 }
 
-static gboolean
+static GtkFilterEventStatus
 gtk_event_controller_filter_event (GtkEventController *controller,
                                    GdkEvent           *event,
                                    GtkWidget          *target)
@@ -284,11 +284,11 @@ gtk_event_controller_filter_event (GtkEventController *controller,
   priv = gtk_event_controller_get_instance_private (controller);
 
   if (priv->widget && !gtk_widget_is_sensitive (priv->widget))
-    return TRUE;
+    return GTK_EVENT_SKIP;
 
   if (priv->limit == GTK_LIMIT_SAME_NATIVE &&
       !same_native (priv->widget, target))
-    return TRUE;
+    return GTK_EVENT_SKIP;
 
   controller_class = GTK_EVENT_CONTROLLER_GET_CLASS (controller);
 
@@ -357,7 +357,7 @@ gtk_event_controller_handle_event (GtkEventController *controller,
   g_return_val_if_fail (GTK_IS_EVENT_CONTROLLER (controller), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
 
-  if (gtk_event_controller_filter_event (controller, event, target))
+  if (gtk_event_controller_filter_event (controller, event, target) == GTK_EVENT_SKIP)
     return retval;
 
   controller_class = GTK_EVENT_CONTROLLER_GET_CLASS (controller);
diff --git a/gtk/gtkeventcontrollerkey.c b/gtk/gtkeventcontrollerkey.c
index 49a149668b..b10575e977 100644
--- a/gtk/gtkeventcontrollerkey.c
+++ b/gtk/gtkeventcontrollerkey.c
@@ -80,6 +80,18 @@ gtk_event_controller_key_finalize (GObject *object)
   G_OBJECT_CLASS (gtk_event_controller_key_parent_class)->finalize (object);
 }
 
+static GtkFilterEventStatus
+gtk_event_controller_key_filter_event (GtkEventController *controller,
+                                       GdkEvent           *event)
+{
+  GdkEventType event_type = gdk_event_get_event_type (event);
+
+  if (event_type == GDK_KEY_PRESS || event_type == GDK_KEY_RELEASE)
+    return GTK_EVENT_HANDLE;
+
+  return GTK_EVENT_SKIP;
+}
+
 static gboolean
 gtk_event_controller_key_handle_event (GtkEventController *controller,
                                        GdkEvent           *event,
@@ -93,9 +105,6 @@ gtk_event_controller_key_handle_event (GtkEventController *controller,
   guint keyval;
   gboolean handled = FALSE;
 
-  if (event_type != GDK_KEY_PRESS && event_type != GDK_KEY_RELEASE)
-    return FALSE;
-
   if (key->im_context &&
       gtk_im_context_filter_keypress (key->im_context, event))
     {
@@ -186,6 +195,7 @@ gtk_event_controller_key_class_init (GtkEventControllerKeyClass *klass)
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
   object_class->finalize = gtk_event_controller_key_finalize;
+  controller_class->filter_event = gtk_event_controller_key_filter_event;
   controller_class->handle_event = gtk_event_controller_key_handle_event;
   controller_class->handle_crossing = gtk_event_controller_key_handle_crossing;
 
diff --git a/gtk/gtkeventcontrollerlegacy.c b/gtk/gtkeventcontrollerlegacy.c
index 63f7c385ea..fb353b326e 100644
--- a/gtk/gtkeventcontrollerlegacy.c
+++ b/gtk/gtkeventcontrollerlegacy.c
@@ -55,6 +55,13 @@ static guint signals[N_SIGNALS] = { 0, };
 G_DEFINE_TYPE (GtkEventControllerLegacy, gtk_event_controller_legacy,
                GTK_TYPE_EVENT_CONTROLLER)
 
+static GtkFilterEventStatus
+gtk_event_controller_legacy_filter_event (GtkEventController *controller,
+                                          GdkEvent           *event)
+{
+  return GTK_EVENT_HANDLE;
+}
+
 static gboolean
 gtk_event_controller_legacy_handle_event (GtkEventController *controller,
                                           GdkEvent           *event,
@@ -73,6 +80,7 @@ gtk_event_controller_legacy_class_init (GtkEventControllerLegacyClass *klass)
 {
   GtkEventControllerClass *controller_class = GTK_EVENT_CONTROLLER_CLASS (klass);
 
+  controller_class->filter_event = gtk_event_controller_legacy_filter_event;
   controller_class->handle_event = gtk_event_controller_legacy_handle_event;
 
   /**
diff --git a/gtk/gtkeventcontrollermotion.c b/gtk/gtkeventcontrollermotion.c
index 47aee49149..83978cfc48 100644
--- a/gtk/gtkeventcontrollermotion.c
+++ b/gtk/gtkeventcontrollermotion.c
@@ -73,22 +73,27 @@ static guint signals[N_SIGNALS] = { 0 };
 
 G_DEFINE_TYPE (GtkEventControllerMotion, gtk_event_controller_motion, GTK_TYPE_EVENT_CONTROLLER)
 
+static GtkFilterEventStatus
+gtk_event_controller_motion_filter_event (GtkEventController *controller,
+                                          GdkEvent           *event)
+{
+  GdkEventType event_type = gdk_event_get_event_type (event);
+
+  if (event_type == GDK_MOTION_NOTIFY)
+    return GTK_EVENT_HANDLE;
+
+  return GTK_EVENT_SKIP;
+}
+
 static gboolean
 gtk_event_controller_motion_handle_event (GtkEventController *controller,
                                           GdkEvent           *event,
                                           double              x,
                                           double              y)
 {
-  GtkEventControllerClass *parent_class;
-  GdkEventType type;
-
-  type = gdk_event_get_event_type (event);
-  if (type == GDK_MOTION_NOTIFY)
-    g_signal_emit (controller, signals[MOTION], 0, x, y);
-
-  parent_class = GTK_EVENT_CONTROLLER_CLASS (gtk_event_controller_motion_parent_class);
+  g_signal_emit (controller, signals[MOTION], 0, x, y);
 
-  return parent_class->handle_event (controller, event, x, y);
+  return GDK_EVENT_PROPAGATE;
 }
 
 static void
@@ -191,6 +196,7 @@ gtk_event_controller_motion_class_init (GtkEventControllerMotionClass *klass)
 
   object_class->get_property = gtk_event_controller_motion_get_property;
 
+  controller_class->filter_event = gtk_event_controller_motion_filter_event;
   controller_class->handle_event = gtk_event_controller_motion_handle_event;
   controller_class->handle_crossing = gtk_event_controller_motion_handle_crossing;
 
diff --git a/gtk/gtkeventcontrollerprivate.h b/gtk/gtkeventcontrollerprivate.h
index 8ca60b0218..0270f83a71 100644
--- a/gtk/gtkeventcontrollerprivate.h
+++ b/gtk/gtkeventcontrollerprivate.h
@@ -22,6 +22,16 @@
 
 #include "gtkeventcontroller.h"
 
+/*
+ * GtkFilterEventStatus:
+ * @GTK_EVENT_HANDLE: the event will be used by the controller
+ * @GTK_EVENT_SKIP: the event will be skipped
+ */
+typedef enum {
+  GTK_EVENT_HANDLE,
+  GTK_EVENT_SKIP
+} GtkFilterEventStatus;
+
 /* GdkCrossingType:
  * @GTK_CROSSING_FOCUS: Focus moved from one widget to another
  * @GTK_CROSSING_ACTIVE: The active window changed (the crossing
@@ -108,11 +118,11 @@ struct _GtkEventControllerClass
 
   /*<private>*/
 
-  /* Tells whether the event is filtered out, %TRUE makes
-   * the event unseen by the handle_event vfunc.
+  /* Tells whether the event will be processed or filtered out.
+   * By default all events are skipped, subclasses will need to list them.
    */
-  gboolean (* filter_event) (GtkEventController *controller,
-                             GdkEvent           *event);
+  GtkFilterEventStatus (* filter_event) (GtkEventController *controller,
+                                         GdkEvent           *event);
 
   gpointer padding[10];
 };
diff --git a/gtk/gtkeventcontrollerscroll.c b/gtk/gtkeventcontrollerscroll.c
index f40826cf7b..b855772312 100644
--- a/gtk/gtkeventcontrollerscroll.c
+++ b/gtk/gtkeventcontrollerscroll.c
@@ -337,6 +337,18 @@ gtk_event_controller_scroll_handle_hold_event (GtkEventController *controller,
   return GDK_EVENT_PROPAGATE;
 }
 
+static GtkFilterEventStatus
+gtk_event_controller_scroll_filter_event (GtkEventController *controller,
+                                          GdkEvent           *event)
+{
+  GdkEventType event_type = gdk_event_get_event_type (event);
+
+  if (event_type == GDK_SCROLL || event_type == GDK_TOUCHPAD_HOLD)
+    return GTK_EVENT_HANDLE;
+
+  return GTK_EVENT_SKIP;
+}
+
 static gboolean
 gtk_event_controller_scroll_handle_event (GtkEventController *controller,
                                           GdkEvent           *event,
@@ -355,9 +367,6 @@ gtk_event_controller_scroll_handle_event (GtkEventController *controller,
   if (event_type == GDK_TOUCHPAD_HOLD)
     return gtk_event_controller_scroll_handle_hold_event (controller, event);
 
-  if (event_type != GDK_SCROLL)
-    return FALSE;
-
   if ((scroll->flags & (GTK_EVENT_CONTROLLER_SCROLL_VERTICAL |
                         GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL)) == 0)
     return FALSE;
@@ -473,6 +482,7 @@ gtk_event_controller_scroll_class_init (GtkEventControllerScrollClass *klass)
   object_class->set_property = gtk_event_controller_scroll_set_property;
   object_class->get_property = gtk_event_controller_scroll_get_property;
 
+  controller_class->filter_event = gtk_event_controller_scroll_filter_event;
   controller_class->handle_event = gtk_event_controller_scroll_handle_event;
 
   /**
diff --git a/gtk/gtkgesture.c b/gtk/gtkgesture.c
index 59fee6bcbf..e87ea344c0 100644
--- a/gtk/gtkgesture.c
+++ b/gtk/gtkgesture.c
@@ -609,19 +609,28 @@ gesture_within_surface (GtkGesture *gesture,
   return surface == gtk_native_get_surface (gtk_widget_get_native (widget));
 }
 
-static gboolean
+static GtkFilterEventStatus
 gtk_gesture_filter_event (GtkEventController *controller,
                           GdkEvent           *event)
 {
-  /* Even though GtkGesture handles these events, we want
-   * touchpad gestures disabled by default, it will be
-   * subclasses which punch the holes in for the events
+  GdkEventType event_type = gdk_event_get_event_type (event);
+
+  /* Even though GtkGesture handles touchpad events, we want to skip them by
+   * default, it will be subclasses which punch the holes in for the events
    * they can possibly handle.
    */
-  if (EVENT_IS_TOUCHPAD_GESTURE (event))
-    return FALSE;
 
-  return GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_parent_class)->filter_event (controller, event);
+  if (event_type == GDK_BUTTON_PRESS ||
+      event_type == GDK_BUTTON_RELEASE ||
+      event_type == GDK_MOTION_NOTIFY ||
+      event_type == GDK_TOUCH_BEGIN ||
+      event_type == GDK_TOUCH_UPDATE ||
+      event_type == GDK_TOUCH_END ||
+      event_type == GDK_TOUCH_CANCEL ||
+      event_type == GDK_GRAB_BROKEN)
+    return GTK_EVENT_HANDLE;
+
+  return GTK_EVENT_SKIP;
 }
 
 static gboolean
diff --git a/gtk/gtkgesturedrag.c b/gtk/gtkgesturedrag.c
index 65b196ae7d..331189b433 100644
--- a/gtk/gtkgesturedrag.c
+++ b/gtk/gtkgesturedrag.c
@@ -58,7 +58,7 @@ static guint signals[N_SIGNALS] = { 0 };
 
 G_DEFINE_TYPE_WITH_PRIVATE (GtkGestureDrag, gtk_gesture_drag, GTK_TYPE_GESTURE_SINGLE)
 
-static gboolean
+static GtkFilterEventStatus
 gtk_gesture_drag_filter_event (GtkEventController *controller,
                                GdkEvent           *event)
 {
@@ -72,9 +72,9 @@ gtk_gesture_drag_filter_event (GtkEventController *controller,
       n_fingers = gdk_touchpad_event_get_n_fingers (event);
 
       if (n_fingers == n_points)
-        return FALSE;
+        return GTK_EVENT_HANDLE;
       else
-        return TRUE;
+        return GTK_EVENT_SKIP;
     }
 
   return GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_drag_parent_class)->filter_event (controller, event);
diff --git a/gtk/gtkgesturerotate.c b/gtk/gtkgesturerotate.c
index df174bf646..32a7d04378 100644
--- a/gtk/gtkgesturerotate.c
+++ b/gtk/gtkgesturerotate.c
@@ -168,7 +168,7 @@ gtk_gesture_rotate_update (GtkGesture       *gesture,
   _gtk_gesture_rotate_check_emit (GTK_GESTURE_ROTATE (gesture));
 }
 
-static gboolean
+static GtkFilterEventStatus
 gtk_gesture_rotate_filter_event (GtkEventController *controller,
                                  GdkEvent           *event)
 {
@@ -181,9 +181,9 @@ gtk_gesture_rotate_filter_event (GtkEventController *controller,
       n_fingers = gdk_touchpad_event_get_n_fingers (event);
 
       if (n_fingers == 2)
-        return FALSE;
+        return GTK_EVENT_HANDLE;
       else
-        return TRUE;
+        return GTK_EVENT_SKIP;
     }
 
   return GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_rotate_parent_class)->filter_event (controller, event);
diff --git a/gtk/gtkgestureswipe.c b/gtk/gtkgestureswipe.c
index e168aa84a3..86f160da91 100644
--- a/gtk/gtkgestureswipe.c
+++ b/gtk/gtkgestureswipe.c
@@ -80,7 +80,7 @@ gtk_gesture_swipe_finalize (GObject *object)
   G_OBJECT_CLASS (gtk_gesture_swipe_parent_class)->finalize (object);
 }
 
-static gboolean
+static GtkFilterEventStatus
 gtk_gesture_swipe_filter_event (GtkEventController *controller,
                                 GdkEvent           *event)
 {
@@ -96,9 +96,9 @@ gtk_gesture_swipe_filter_event (GtkEventController *controller,
       n_fingers = gdk_touchpad_event_get_n_fingers (event);
 
       if (n_fingers == n_points)
-        return FALSE;
+        return GTK_EVENT_HANDLE;
       else
-        return TRUE;
+        return GTK_EVENT_SKIP;
     }
 
   return GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_swipe_parent_class)->filter_event (controller, event);
diff --git a/gtk/gtkgesturezoom.c b/gtk/gtkgesturezoom.c
index 9d6116bce1..a3b87f96b7 100644
--- a/gtk/gtkgesturezoom.c
+++ b/gtk/gtkgesturezoom.c
@@ -145,7 +145,7 @@ _gtk_gesture_zoom_check_emit (GtkGestureZoom *gesture)
   return TRUE;
 }
 
-static gboolean
+static GtkFilterEventStatus
 gtk_gesture_zoom_filter_event (GtkEventController *controller,
                                GdkEvent           *event)
 {
@@ -158,9 +158,9 @@ gtk_gesture_zoom_filter_event (GtkEventController *controller,
       n_fingers = gdk_touchpad_event_get_n_fingers (event);
 
       if (n_fingers == 2)
-        return FALSE;
+        return GTK_EVENT_HANDLE;
       else
-        return TRUE;
+        return GTK_EVENT_SKIP;
     }
 
   return GTK_EVENT_CONTROLLER_CLASS (gtk_gesture_zoom_parent_class)->filter_event (controller, event);
diff --git a/gtk/gtkpadcontroller.c b/gtk/gtkpadcontroller.c
index d49dc00e10..67415cd82c 100644
--- a/gtk/gtkpadcontroller.c
+++ b/gtk/gtkpadcontroller.c
@@ -198,7 +198,7 @@ gtk_pad_controller_handle_mode_switch (GtkPadController *controller,
 #endif
 }
 
-static gboolean
+static GtkFilterEventStatus
 gtk_pad_controller_filter_event (GtkEventController *controller,
                                  GdkEvent           *event)
 {
@@ -210,13 +210,13 @@ gtk_pad_controller_filter_event (GtkEventController *controller,
       event_type != GDK_PAD_RING &&
       event_type != GDK_PAD_STRIP &&
       event_type != GDK_PAD_GROUP_MODE)
-    return TRUE;
+    return GTK_EVENT_SKIP;
 
   if (pad_controller->pad &&
       gdk_event_get_device (event) != pad_controller->pad)
-    return TRUE;
+    return GTK_EVENT_SKIP;
 
-  return FALSE;
+  return GTK_EVENT_HANDLE;
 }
 
 static gboolean
diff --git a/gtk/gtkshortcutcontroller.c b/gtk/gtkshortcutcontroller.c
index 5eb0187022..01f718c0f7 100644
--- a/gtk/gtkshortcutcontroller.c
+++ b/gtk/gtkshortcutcontroller.c
@@ -422,6 +422,18 @@ gtk_shortcut_controller_run_controllers (GtkEventController *controller,
   return retval;
 }
 
+static GtkFilterEventStatus
+gtk_shortcut_controller_filter_event (GtkEventController *controller,
+                                      GdkEvent           *event)
+{
+  GdkEventType event_type = gdk_event_get_event_type (event);
+
+  if (event_type == GDK_KEY_PRESS || event_type == GDK_KEY_RELEASE)
+    return GTK_EVENT_HANDLE;
+
+  return GTK_EVENT_SKIP;
+}
+
 static gboolean
 gtk_shortcut_controller_handle_event (GtkEventController *controller,
                                       GdkEvent           *event,
@@ -435,9 +447,6 @@ gtk_shortcut_controller_handle_event (GtkEventController *controller,
   if (self->scope != GTK_SHORTCUT_SCOPE_LOCAL)
     return FALSE;
 
-  if (event_type != GDK_KEY_PRESS && event_type != GDK_KEY_RELEASE)
-    return FALSE;
-
   if (event_type == GDK_KEY_PRESS)
     {
       GdkModifierType modifiers, consumed_modifiers;
@@ -558,6 +567,7 @@ gtk_shortcut_controller_class_init (GtkShortcutControllerClass *klass)
   object_class->set_property = gtk_shortcut_controller_set_property;
   object_class->get_property = gtk_shortcut_controller_get_property;
 
+  controller_class->filter_event = gtk_shortcut_controller_filter_event;
   controller_class->handle_event = gtk_shortcut_controller_handle_event;
   controller_class->set_widget = gtk_shortcut_controller_set_widget;
   controller_class->unset_widget = gtk_shortcut_controller_unset_widget;