17 files changed, 138 insertions, 69 deletions

diff --git a/gtk/gtkdragsource.c b/gtk/gtkdragsource.c
index b3df700065..1070298442 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 5b91bbb103..c7ec7a1aa8 100644
--- a/gtk/gtkdroptarget.c
+++ b/gtk/gtkdroptarget.c
@@ -387,7 +387,7 @@ gtk_drop_target_drop (GtkDropTarget  *self,
   return FALSE;
 }
 
-static gboolean
+static GtkFilterEventStatus
 gtk_drop_target_filter_event (GtkEventController *controller,
                               GdkEvent           *event)
 {
@@ -397,12 +397,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 6892562901..058625e25e 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 bf5f8f5dcb..6dc4924d9f 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 b246bb22db..b12e840f6d 100644
--- a/gtk/gtkeventcontrollerscroll.c
+++ b/gtk/gtkeventcontrollerscroll.c
@@ -235,6 +235,18 @@ gtk_event_controller_scroll_get_property (GObject    *object,
     }
 }
 
+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)
+    return GTK_EVENT_HANDLE;
+
+  return GTK_EVENT_SKIP;
+}
+
 static gboolean
 gtk_event_controller_scroll_handle_event (GtkEventController *controller,
                                           GdkEvent           *event,
@@ -246,9 +258,6 @@ gtk_event_controller_scroll_handle_event (GtkEventController *controller,
   double dx = 0, dy = 0;
   gboolean handled = GDK_EVENT_PROPAGATE;
 
-  if (gdk_event_get_event_type (event) != GDK_SCROLL)
-    return FALSE;
-
   if ((scroll->flags & (GTK_EVENT_CONTROLLER_SCROLL_VERTICAL |
                         GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL)) == 0)
     return FALSE;
@@ -360,6 +369,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 71a0300ea1..7bdc538559 100644
--- a/gtk/gtkgesture.c
+++ b/gtk/gtkgesture.c
@@ -584,19 +584,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 5ecf7490b1..2da7ab41b7 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)
 {
@@ -180,9 +180,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 ac52638298..9540fa6df3 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)
 {
@@ -95,9 +95,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 0baf55fb7c..93bb5f570d 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)
 {
@@ -157,9 +157,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 49e7ae512e..9c81640444 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;