treeview: Make the multipress gesture listen only to bin_window

This gesture is meant to handle row-activated signaling, so make the gesture ignore events from any other window.
button: Claim the sequence on multipress::pressed
2014-05-27 17:37:07 +02:00 · 2014-05-27 17:35:36 +02:00 · 2014-05-27 17:33:31 +02:00 · 2014-05-27 12:41:30 +02:00 · 2014-05-27 12:38:49 +02:00 · 2014-05-27 12:14:52 +02:00
31 changed files with 288 additions and 344 deletions
@@ -93,11 +93,11 @@ drawing_area_draw (GtkWidget *widget,

      cairo_save (cr);

-      if (gtk_gesture_rotate_get_angle_delta (GTK_GESTURE_ROTATE (rotate), &angle))
-        cairo_matrix_rotate (&matrix, angle);
+      angle = gtk_gesture_rotate_get_angle_delta (GTK_GESTURE_ROTATE (rotate));
+      cairo_matrix_rotate (&matrix, angle);

-      if (gtk_gesture_zoom_get_scale_delta (GTK_GESTURE_ZOOM (zoom), &scale))
-        cairo_matrix_scale (&matrix, scale, scale);
+      scale = gtk_gesture_zoom_get_scale_delta (GTK_GESTURE_ZOOM (zoom));
+      cairo_matrix_scale (&matrix, scale, scale);

      cairo_set_matrix (cr, &matrix);
      cairo_rectangle (cr, -100, -100, 200, 200);
@@ -156,8 +156,9 @@ do_gestures (GtkWidget *do_widget)
      gesture = gtk_gesture_swipe_new (drawing_area);
      g_signal_connect (gesture, "swipe",
                        G_CALLBACK (swipe_gesture_swept), drawing_area);
-      gtk_gesture_attach (gesture, GTK_PHASE_BUBBLE);
-      g_object_unref (gesture);
+      gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
+                                                  GTK_PHASE_BUBBLE);
+      g_object_weak_ref (G_OBJECT (drawing_area), (GWeakNotify) g_object_unref, gesture);

      /* Long press */
      gesture = gtk_gesture_long_press_new (drawing_area);
@@ -165,22 +166,25 @@ do_gestures (GtkWidget *do_widget)
                        G_CALLBACK (long_press_gesture_pressed), drawing_area);
      g_signal_connect (gesture, "end",
                        G_CALLBACK (long_press_gesture_end), drawing_area);
-      gtk_gesture_attach (gesture, GTK_PHASE_BUBBLE);
-      g_object_unref (gesture);
+      gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
+                                                  GTK_PHASE_BUBBLE);
+      g_object_weak_ref (G_OBJECT (drawing_area), (GWeakNotify) g_object_unref, gesture);

      /* Rotate */
      rotate = gesture = gtk_gesture_rotate_new (drawing_area);
      g_signal_connect (gesture, "angle-changed",
                        G_CALLBACK (rotation_angle_changed), drawing_area);
-      gtk_gesture_attach (gesture, GTK_PHASE_BUBBLE);
-      g_object_unref (gesture);
+      gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
+                                                  GTK_PHASE_BUBBLE);
+      g_object_weak_ref (G_OBJECT (drawing_area), (GWeakNotify) g_object_unref, gesture);

      /* Zoom */
      zoom = gesture = gtk_gesture_zoom_new (drawing_area);
      g_signal_connect (gesture, "scale-changed",
                        G_CALLBACK (zoom_scale_changed), drawing_area);
-      gtk_gesture_attach (gesture, GTK_PHASE_BUBBLE);
-      g_object_unref (gesture);
+      gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
+                                                  GTK_PHASE_BUBBLE);
+      g_object_weak_ref (G_OBJECT (drawing_area), (GWeakNotify) g_object_unref, gesture);
    }

  if (!gtk_widget_get_visible (window))
@@ -7898,9 +7898,10 @@ gtk_popover_get_modal
 <FILE>gtkeventcontroller</FILE>
 <TITLE>GtkEventController</TITLE>
 GtkEventController
+GtkPropagationPhase
+gtk_event_controller_get_propagation_phase
+gtk_event_controller_set_propagation_phase
 gtk_event_controller_handle_event
-gtk_event_controller_get_event_mask
-gtk_event_controller_set_event_mask
 gtk_event_controller_get_widget
 gtk_event_controller_reset

@@ -7931,9 +7932,6 @@ gtk_gesture_set_sequence_state
 gtk_gesture_set_state
 gtk_gesture_get_sequences
 gtk_gesture_handles_sequence
-GtkPropagationPhase
-gtk_gesture_attach
-gtk_gesture_detach

 <SUBSECTION>
 gtk_gesture_get_last_updated_sequence
@@ -598,6 +598,7 @@ multipress_pressed_cb (GtkGestureMultiPress *gesture,
    gtk_widget_grab_focus (widget);

  g_signal_emit (button, button_signals[PRESSED], 0);
+  gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
 }

 static void
@@ -653,7 +654,7 @@ gtk_button_init (GtkButton *button)
  gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (priv->gesture), GDK_BUTTON_PRIMARY);
  g_signal_connect (priv->gesture, "pressed", G_CALLBACK (multipress_pressed_cb), button);
  g_signal_connect (priv->gesture, "released", G_CALLBACK (multipress_released_cb), button);
-  gtk_gesture_attach (priv->gesture, GTK_PHASE_TARGET);
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->gesture), GTK_PHASE_BUBBLE);
 }

 static void
@@ -668,12 +669,7 @@ gtk_button_destroy (GtkWidget *widget)
      priv->label_text = NULL;
    }

-  if (priv->gesture)
-    {
-      gtk_gesture_detach (priv->gesture);
-      g_object_unref (priv->gesture);
-      priv->gesture = NULL;
-    }
+  g_clear_object (&priv->gesture);

  GTK_WIDGET_CLASS (gtk_button_parent_class)->destroy (widget);
 }
@@ -409,14 +409,16 @@ gtk_color_plane_init (GtkColorPlane *plane)
 		    G_CALLBACK (plane_drag_gesture_update), plane);
  g_signal_connect (plane->priv->drag_gesture, "drag-end",
 		    G_CALLBACK (plane_drag_gesture_end), plane);
-  gtk_gesture_attach (plane->priv->drag_gesture, GTK_PHASE_TARGET);
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (plane->priv->drag_gesture),
+                                              GTK_PHASE_BUBBLE);
  gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (plane->priv->drag_gesture),
                                     FALSE);

  plane->priv->long_press_gesture = gtk_gesture_long_press_new (GTK_WIDGET (plane));
  g_signal_connect (plane->priv->long_press_gesture, "pressed",
                    G_CALLBACK (hold_action), plane);
-  gtk_gesture_attach (plane->priv->long_press_gesture, GTK_PHASE_TARGET);
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (plane->priv->long_press_gesture),
+                                              GTK_PHASE_BUBBLE);
 }

 static void
@@ -431,10 +433,7 @@ plane_finalize (GObject *object)
  g_clear_object (&plane->priv->s_adj);
  g_clear_object (&plane->priv->v_adj);

-  gtk_gesture_detach (plane->priv->drag_gesture);
  g_clear_object (&plane->priv->drag_gesture);
-
-  gtk_gesture_detach (plane->priv->long_press_gesture);
  g_clear_object (&plane->priv->long_press_gesture);

  G_OBJECT_CLASS (gtk_color_plane_parent_class)->finalize (object);
@@ -258,7 +258,8 @@ gtk_color_scale_init (GtkColorScale *scale)
  scale->priv->long_press_gesture = gtk_gesture_long_press_new (GTK_WIDGET (scale));
  g_signal_connect (scale->priv->long_press_gesture, "pressed",
                    G_CALLBACK (hold_action), scale);
-  gtk_gesture_attach (scale->priv->long_press_gesture, GTK_PHASE_BUBBLE);
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (scale->priv->long_press_gesture),
+                                              GTK_PHASE_TARGET);
 }

 static void
@@ -269,7 +270,6 @@ scale_finalize (GObject *object)
  if (scale->priv->surface)
    cairo_surface_destroy (scale->priv->surface);

-  gtk_gesture_detach (scale->priv->long_press_gesture);
  g_clear_object (&scale->priv->long_press_gesture);

  G_OBJECT_CLASS (gtk_color_scale_parent_class)->finalize (object);
@@ -90,13 +90,15 @@ gtk_color_swatch_init (GtkColorSwatch *swatch)
  swatch->priv->long_press_gesture = gtk_gesture_long_press_new (GTK_WIDGET (swatch));
  g_signal_connect (swatch->priv->long_press_gesture, "pressed",
                    G_CALLBACK (hold_action), swatch);
-  gtk_gesture_attach (swatch->priv->long_press_gesture, GTK_PHASE_TARGET);
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (swatch->priv->long_press_gesture),
+                                              GTK_PHASE_BUBBLE);

  swatch->priv->multipress_gesture = gtk_gesture_multi_press_new (GTK_WIDGET (swatch));
  gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (swatch->priv->multipress_gesture), FALSE);
  g_signal_connect (swatch->priv->multipress_gesture, "pressed",
                    G_CALLBACK (tap_action), swatch);
-  gtk_gesture_attach (swatch->priv->multipress_gesture, GTK_PHASE_TARGET);
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (swatch->priv->multipress_gesture),
+                                              GTK_PHASE_BUBBLE);
 }

 #define INTENSITY(r, g, b) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11)
@@ -694,10 +696,7 @@ swatch_finalize (GObject *object)

  g_free (swatch->priv->icon);

-  gtk_gesture_detach (swatch->priv->long_press_gesture);
  g_object_unref (swatch->priv->long_press_gesture);
-
-  gtk_gesture_detach (swatch->priv->multipress_gesture);
  g_object_unref (swatch->priv->multipress_gesture);

  G_OBJECT_CLASS (gtk_color_swatch_parent_class)->finalize (object);
@@ -2801,7 +2801,6 @@ gtk_drag_source_set (GtkWidget            *widget,
      site->drag_gesture = gtk_gesture_drag_new (widget);
      gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (site->drag_gesture),
                                         FALSE);
-      gtk_gesture_attach (site->drag_gesture, GTK_PHASE_NONE);

      g_signal_connect (widget, "button-press-event",
 			G_CALLBACK (gtk_drag_source_event_cb),
@@ -2844,7 +2843,6 @@ gtk_drag_source_unset (GtkWidget *widget)
      g_signal_handlers_disconnect_by_func (widget,
                                            gtk_drag_source_event_cb,
                                            site);
-      gtk_gesture_detach (site->drag_gesture);
      g_object_set_data (G_OBJECT (widget), I_("gtk-site-data"), NULL);
    }
 }
@@ -2701,14 +2701,16 @@ gtk_entry_init (GtkEntry *entry)
                    G_CALLBACK (gtk_entry_drag_gesture_end), entry);
  gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (priv->drag_gesture), FALSE);
  gtk_gesture_single_set_exclusive (GTK_GESTURE_SINGLE (priv->drag_gesture), TRUE);
-  gtk_gesture_attach (priv->drag_gesture, GTK_PHASE_TARGET);
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->drag_gesture),
+                                              GTK_PHASE_BUBBLE);

  priv->multipress_gesture = gtk_gesture_multi_press_new (GTK_WIDGET (entry));
  g_signal_connect (priv->multipress_gesture, "pressed",
                    G_CALLBACK (gtk_entry_multipress_gesture_pressed), entry);
  gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (priv->multipress_gesture), FALSE);
  gtk_gesture_single_set_exclusive (GTK_GESTURE_SINGLE (priv->multipress_gesture), TRUE);
-  gtk_gesture_attach (priv->multipress_gesture, GTK_PHASE_TARGET);
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->multipress_gesture),
+                                              GTK_PHASE_BUBBLE);
 }

 static void
@@ -2988,6 +2990,9 @@ gtk_entry_finalize (GObject *object)
  g_free (priv->placeholder_text);
  g_free (priv->im_module);

+  g_clear_object (&priv->drag_gesture);
+  g_clear_object (&priv->multipress_gesture);
+
  if (priv->tabs)
    pango_tab_array_free (priv->tabs);

@@ -331,11 +331,12 @@ typedef enum

 /**
 * GtkOrientation:
- * @GTK_ORIENTATION_HORIZONTAL: The widget is in horizontal orientation.
- * @GTK_ORIENTATION_VERTICAL: The widget is in vertical orientation.
+ * @GTK_ORIENTATION_HORIZONTAL: The element is in horizontal orientation.
+ * @GTK_ORIENTATION_VERTICAL: The element is in vertical orientation.
 *
- * Represents the orientation of widgets which can be switched between horizontal
- * and vertical orientation on the fly, like #GtkToolbar.
+ * Represents the orientation of widgets and other objects which can be switched
+ * between horizontal and vertical orientation on the fly, like #GtkToolbar or
+ * #GtkGesturePan.
 */
 typedef enum
 {
@@ -1114,19 +1115,4 @@ typedef enum
  GTK_PAN_DIRECTION_DOWN
 } GtkPanDirection;

-/**
- * GtkPanOrientation:
- * @GTK_PAN_ORIENTATION_VERTICAL: vertical panning allowed
- * @GTK_PAN_ORIENTATION_HORIZONTAL: horizontal panning allowed
- *
- * Describes the panning axis of a #GtkGesturePan
- *
- * Since: 3.14
- */
-typedef enum
-{
-  GTK_PAN_ORIENTATION_VERTICAL,
-  GTK_PAN_ORIENTATION_HORIZONTAL
-} GtkPanOrientation;
-
 #endif /* __GTK_ENUMS_H__ */
@@ -32,6 +32,7 @@
 #include "config.h"
 #include "gtkeventcontroller.h"
 #include "gtkeventcontrollerprivate.h"
+#include "gtkwidgetprivate.h"
 #include "gtktypebuiltins.h"
 #include "gtkmarshalers.h"
 #include "gtkprivate.h"
@@ -41,23 +42,16 @@ typedef struct _GtkEventControllerPrivate GtkEventControllerPrivate;

 enum {
  PROP_WIDGET = 1,
-  PROP_EVENT_MASK
-};
-
-enum {
-  HANDLE_EVENT,
-  RESET,
-  N_SIGNALS
+  PROP_PROPAGATION_PHASE
 };

 struct _GtkEventControllerPrivate
 {
  GtkWidget *widget;
  guint evmask;
+  GtkPropagationPhase phase;
 };

-guint signals[N_SIGNALS] = { 0 };
-
 G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GtkEventController, gtk_event_controller, G_TYPE_OBJECT)

 static gboolean
@@ -82,8 +76,9 @@ gtk_event_controller_set_property (GObject      *object,
    case PROP_WIDGET:
      priv->widget = g_value_get_object (value);
      break;
-    case PROP_EVENT_MASK:
-      priv->evmask = g_value_get_flags (value);
+    case PROP_PROPAGATION_PHASE:
+      gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (object),
+                                                  g_value_get_enum (value));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -105,14 +100,34 @@ gtk_event_controller_get_property (GObject    *object,
    case PROP_WIDGET:
      g_value_set_object (value, priv->widget);
      break;
-    case PROP_EVENT_MASK:
-      g_value_set_flags (value, priv->evmask);
+    case PROP_PROPAGATION_PHASE:
+      g_value_set_enum (value, priv->phase);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
 }

+static void
+gtk_event_controller_constructed (GObject *object)
+{
+  GtkEventController *controller = GTK_EVENT_CONTROLLER (object);
+  GtkEventControllerPrivate *priv;
+
+  priv = gtk_event_controller_get_instance_private (controller);
+  g_assert (priv->widget != NULL);
+  _gtk_widget_add_controller (priv->widget, controller);
+}
+
+static void
+gtk_event_controller_dispose (GObject *object)
+{
+  GtkEventController *controller = GTK_EVENT_CONTROLLER (object);
+  GtkEventControllerPrivate *priv;
+
+  priv = gtk_event_controller_get_instance_private (controller);
+  _gtk_widget_remove_controller (priv->widget, controller);
+}

 static void
 gtk_event_controller_class_init (GtkEventControllerClass *klass)
@@ -123,6 +138,8 @@ gtk_event_controller_class_init (GtkEventControllerClass *klass)

  object_class->set_property = gtk_event_controller_set_property;
  object_class->get_property = gtk_event_controller_get_property;
+  object_class->constructed = gtk_event_controller_constructed;
+  object_class->dispose = gtk_event_controller_dispose;

  /**
   * GtkEventController:widget:
@@ -140,55 +157,20 @@ gtk_event_controller_class_init (GtkEventControllerClass *klass)
                                                        GTK_PARAM_READWRITE |
                                                        G_PARAM_CONSTRUCT_ONLY));
  /**
-   * GtkEventController:event-mask:
+   * GtkEventController:propagation-phase:
   *
-   * Set of events that the controller handles.
+   * The propagation phase at which this controller will handle events.
   *
   * Since: 3.14
   */
  g_object_class_install_property (object_class,
-                                   PROP_EVENT_MASK,
-                                   g_param_spec_flags ("event-mask",
-                                                       P_("Event mask"),
-                                                       P_("Event mask the controller handles"),
-                                                       GDK_TYPE_EVENT_MASK, 0,
-                                                       GTK_PARAM_READWRITE));
-  /**
-   * GtkEventController::handle-event:
-   * @controller: the object which receives the signal
-   * @event: the event to handle
-   *
-   * This signal is emitted on @controller whenever an event is to be handled.
-   *
-   * Return value: %TRUE to propagate further emission if the event was handled,
-   *   %FALSE otherwise
-   *
-   * Since: 3.14
-   */
-  signals[HANDLE_EVENT] =
-    g_signal_new ("handle-event",
-                  G_TYPE_FROM_CLASS (klass),
-                  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
-                  G_STRUCT_OFFSET (GtkEventControllerClass, handle_event),
-                  g_signal_accumulator_true_handled, NULL, NULL,
-                  G_TYPE_BOOLEAN, 1,
-                  GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
-  /**
-   * GtkEventController::reset:
-   * @controller: the object which receives the signal
-   *
-   * This signal is emitted on @controller whenever it needs to be reset. When
-   * this happens controllers must forget any recorded state.
-   *
-   * Since: 3.14
-   */
-  signals[RESET] =
-    g_signal_new ("reset",
-                  G_TYPE_FROM_CLASS (klass),
-                  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
-                  G_STRUCT_OFFSET (GtkEventControllerClass, reset),
-                  NULL, NULL, NULL,
-                  G_TYPE_NONE, 0);
+                                   PROP_PROPAGATION_PHASE,
+                                   g_param_spec_enum ("propagation-phase",
+                                                      P_("Propagation phase"),
+                                                      P_("Propagation phase at which this controller is run"),
+                                                      GTK_TYPE_PROPAGATION_PHASE,
+                                                      GTK_PHASE_NONE,
+                                                      GTK_PARAM_READWRITE));
 }

 static void
@@ -213,27 +195,20 @@ gboolean
 gtk_event_controller_handle_event (GtkEventController *controller,
                                   const GdkEvent     *event)
 {
+  GtkEventControllerClass *controller_class;
  gboolean retval = FALSE;

  g_return_val_if_fail (GTK_IS_EVENT_CONTROLLER (controller), FALSE);
  g_return_val_if_fail (event != NULL, FALSE);

-  g_signal_emit (controller, signals[HANDLE_EVENT], 0, event, &retval);
+  controller_class = GTK_EVENT_CONTROLLER_GET_CLASS (controller);
+
+  if (controller_class->handle_event)
+    retval = controller_class->handle_event (controller, event);

  return retval;
 }

-/**
- * gtk_event_controller_set_event_mask:
- * @controller: a #GtkEventController
- * @event_mask: mask for the events the controller handles
- *
- * Sets the event mask that the controller handles. This is only
- * meant for #GtkEventController implementations and should not be
- * called in applications.
- *
- * Since: 3.14
- **/
 void
 gtk_event_controller_set_event_mask (GtkEventController *controller,
                                     GdkEventMask        event_mask)
@@ -248,19 +223,8 @@ gtk_event_controller_set_event_mask (GtkEventController *controller,
    return;

  priv->evmask = event_mask;
-  g_object_notify (G_OBJECT (controller), "event-mask");
 }

-/**
- * gtk_event_controller_get_event_mask:
- * @controller: a #GtkEventController
- *
- * Returns the event mask necessary for the events handled by @controller.
- *
- * Returns: the controller event mask
- *
- * Since: 3.14
- **/
 GdkEventMask
 gtk_event_controller_get_event_mask (GtkEventController *controller)
 {
@@ -308,7 +272,69 @@ gtk_event_controller_get_widget (GtkEventController *controller)
 void
 gtk_event_controller_reset (GtkEventController *controller)
 {
+  GtkEventControllerClass *controller_class;
+
  g_return_if_fail (GTK_IS_EVENT_CONTROLLER (controller));

-  g_signal_emit (controller, signals[RESET], 0);
+  controller_class = GTK_EVENT_CONTROLLER_GET_CLASS (controller);
+
+  if (controller_class->reset)
+    controller_class->reset (controller);
+}
+
+/**
+ * gtk_event_controller_get_propagation_phase:
+ * @controller: a #GtkEventController
+ *
+ * Gets the propagation phase at which @controller handles events.
+ *
+ * Returns: the propagation phase
+ *
+ * Since: 3.14
+ **/
+GtkPropagationPhase
+gtk_event_controller_get_propagation_phase (GtkEventController *controller)
+{
+  GtkEventControllerPrivate *priv;
+
+  g_return_val_if_fail (GTK_IS_EVENT_CONTROLLER (controller), GTK_PHASE_NONE);
+
+  priv = gtk_event_controller_get_instance_private (controller);
+
+  return priv->phase;
+}
+
+/**
+ * gtk_event_controller_set_propagation_phase:
+ * @controller: a #GtkEventController
+ * @phase: a propagation phase
+ *
+ * Sets the propagation phase at which a controller handles events.
+ *
+ * If @phase is %GTK_PHASE_NONE, no automatic event handling will be
+ * performed, but other additional gesture maintenance will. In that phase,
+ * the events can be managed by calling gtk_event_controller_handle_event().
+ *
+ * Since: 3.14
+ **/
+void
+gtk_event_controller_set_propagation_phase (GtkEventController  *controller,
+                                            GtkPropagationPhase  phase)
+{
+  GtkEventControllerPrivate *priv;
+
+  g_return_if_fail (GTK_IS_EVENT_CONTROLLER (controller));
+  g_return_if_fail (phase >= GTK_PHASE_NONE && phase <= GTK_PHASE_TARGET);
+
+  priv = gtk_event_controller_get_instance_private (controller);
+
+  if (priv->phase == phase)
+    return;
+
+  priv->phase = phase;
+
+  if (phase == GTK_PHASE_NONE)
+    gtk_event_controller_reset (controller);
+
+  g_object_notify (G_OBJECT (controller), "propagation-phase");
 }
@@ -47,18 +47,19 @@ GType        gtk_event_controller_get_type       (void) G_GNUC_CONST;
 GDK_AVAILABLE_IN_3_14
 GtkWidget  * gtk_event_controller_get_widget     (GtkEventController *controller);

-GDK_AVAILABLE_IN_3_14
-void         gtk_event_controller_set_event_mask (GtkEventController *controller,
-                                                  GdkEventMask        event_mask);
-GDK_AVAILABLE_IN_3_14
-GdkEventMask gtk_event_controller_get_event_mask (GtkEventController *controller);
-
 GDK_AVAILABLE_IN_3_14
 gboolean     gtk_event_controller_handle_event   (GtkEventController *controller,
                                                  const GdkEvent     *event);
 GDK_AVAILABLE_IN_3_14
 void         gtk_event_controller_reset          (GtkEventController *controller);

+GDK_AVAILABLE_IN_3_14
+GtkPropagationPhase gtk_event_controller_get_propagation_phase (GtkEventController *controller);
+
+GDK_AVAILABLE_IN_3_14
+void                gtk_event_controller_set_propagation_phase (GtkEventController  *controller,
+                                                                GtkPropagationPhase  phase);
+
 G_END_DECLS

 #endif /* __GTK_EVENT_CONTROLLER_H__ */
@@ -39,4 +39,8 @@ struct _GtkEventControllerClass
  gpointer padding[10];
 };

+void         gtk_event_controller_set_event_mask (GtkEventController *controller,
+						  GdkEventMask        event_mask);
+GdkEventMask gtk_event_controller_get_event_mask (GtkEventController *controller);
+
 #endif /* __GTK_EVENT_CONTROLLER_PRIVATE_H__ */
@@ -46,9 +46,9 @@
 *
 * ## Event propagation
 *
- * To receive events, a gesture needs to first be attached to its widget with
- * gtk_gesture_attach(). The phase passed to this call determines at which
- * point in the event processing a gesture operates.
+ * In order to receive events, a gesture needs to either set a propagation phase
+ * through gtk_event_controller_set_propagation_phase(), or feed those manually
+ * through gtk_event_controller_handle_event().
 *
 * In the capture phase, events are propagated from the toplevel down to the
 * target widget, and gestures that are attached to containers above the widget
@@ -56,17 +56,13 @@
 *
 * After the capture phase, GTK+ emits the traditional #GtkWidget::button-press,
 * #GtkWidget::button-release, #GtkWidget::touch-event, etc signals. Gestures 
- * with the target phase are fed events from the default #GtkWidget::event
+ * with the %GTK_PHASE_TARGET phase are fed events from the default #GtkWidget::event
 * handlers.
 *
 * In the bubble phase, events are propagated up from the target widget to the
 * toplevel, and gestures that are attached to containers above the widget get
 * a chance to interact with events that have not been handled yet.
 *
- * Gestures attached with the phase 'none' are not receiving any events
- * automatically, but events can be passed to them with
- * gtk_event_controller_handle_event().
- *
 * ## States of a sequence # {#touch-sequence-states}
 *
 * Whenever input interaction happens, a single event may trigger a cascade of
@@ -113,6 +109,7 @@
 #include "config.h"
 #include "gtkgesture.h"
 #include "gtkwidgetprivate.h"
+#include "gtkeventcontrollerprivate.h"
 #include "gtkgestureprivate.h"
 #include "gtktypebuiltins.h"
 #include "gtkprivate.h"
@@ -1344,7 +1341,7 @@ gtk_gesture_set_window (GtkGesture *gesture,
      GtkWidget *window_widget;

      gdk_window_get_user_data (window, (gpointer*) &window_widget);
-      g_return_if_fail (window_widget !=
+      g_return_if_fail (window_widget ==
                        gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture)));
    }

@@ -1546,51 +1543,3 @@ _gtk_gesture_get_pointer_emulating_sequence (GtkGesture        *gesture,

  return FALSE;
 }
-
-/**
- * gtk_gesture_attach:
- * @gesture: a #GtkGesture
- * @phase: phase at which events are handled
- *
- * Attaches @gesture to its widget, so @gesture is able to receive
- * and manage the events that are emitted on the #GtkWidget. This call
- * will also make sure that the gesture state is maintained properly
- * whenever input is grabbed elsewhere.
- *
- * If @phase is %GTK_PHASE_NONE, no automatical event handling will be
- * performed, but other additional gesture maintenance will. The events
- * can be managed by calling gtk_event_controller_handle_event().
- *
- * Since: 3.14
- **/
-void
-gtk_gesture_attach (GtkGesture          *gesture,
-                    GtkPropagationPhase  phase)
-{
-  GtkWidget *widget;
-
-  g_return_if_fail (GTK_IS_GESTURE (gesture));
-  g_return_if_fail (phase >= GTK_PHASE_NONE && phase <= GTK_PHASE_TARGET);
-
-  widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
-  _gtk_widget_add_controller (widget, GTK_EVENT_CONTROLLER (gesture), phase);
-}
-
-/**
- * gtk_gesture_detach:
- * @gesture: a #GtkGesture
- *
- * Detaches @gesture from its widget.
- *
- * Since: 3.14
- **/
-void
-gtk_gesture_detach (GtkGesture *gesture)
-{
-  GtkWidget *widget;
-
-  g_return_if_fail (GTK_IS_GESTURE (gesture));
-
-  widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
-  _gtk_widget_remove_controller (widget, GTK_EVENT_CONTROLLER (gesture));
-}
@@ -109,12 +109,6 @@ GDK_AVAILABLE_IN_3_14
 gboolean    gtk_gesture_is_grouped_with      (GtkGesture       *gesture,
                                              GtkGesture       *other);

-GDK_AVAILABLE_IN_3_14
-void        gtk_gesture_attach               (GtkGesture          *gesture,
-                                              GtkPropagationPhase  phase);
-GDK_AVAILABLE_IN_3_14
-void        gtk_gesture_detach               (GtkGesture          *gesture);
-
 G_END_DECLS

 #endif /* __GTK_GESTURE_H__ */
@@ -104,19 +104,19 @@ gtk_gesture_pan_set_property (GObject      *object,
 }

 static void
-direction_from_offset (gdouble            offset_x,
-                       gdouble            offset_y,
-                       GtkPanOrientation  orientation,
-                       GtkPanDirection   *direction)
+direction_from_offset (gdouble          offset_x,
+                       gdouble          offset_y,
+                       GtkOrientation   orientation,
+                       GtkPanDirection *direction)
 {
-  if (orientation == GTK_PAN_ORIENTATION_HORIZONTAL)
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
    {
      if (offset_x > 0)
        *direction = GTK_PAN_DIRECTION_RIGHT;
      else
        *direction = GTK_PAN_DIRECTION_LEFT;
    }
-  else if (orientation == GTK_PAN_ORIENTATION_VERTICAL)
+  else if (orientation == GTK_ORIENTATION_VERTICAL)
    {
      if (offset_y > 0)
        *direction = GTK_PAN_DIRECTION_DOWN;
@@ -141,10 +141,10 @@ guess_direction (GtkGesturePan   *gesture,
 #define FACTOR 2
  if (abs_x > abs_y * FACTOR)
    direction_from_offset (offset_x, offset_y,
-                           GTK_PAN_ORIENTATION_HORIZONTAL, direction);
+                           GTK_ORIENTATION_HORIZONTAL, direction);
  else if (abs_y > abs_x * FACTOR)
    direction_from_offset (offset_x, offset_y,
-                           GTK_PAN_ORIENTATION_VERTICAL, direction);
+                           GTK_ORIENTATION_VERTICAL, direction);
  else
    return FALSE;

@@ -160,10 +160,10 @@ check_orientation_matches (GtkGesturePan   *gesture,

  return (((direction == GTK_PAN_DIRECTION_LEFT ||
            direction == GTK_PAN_DIRECTION_RIGHT) &&
-           priv->orientation == GTK_PAN_ORIENTATION_HORIZONTAL) ||
+           priv->orientation == GTK_ORIENTATION_HORIZONTAL) ||
          ((direction == GTK_PAN_DIRECTION_UP ||
            direction == GTK_PAN_DIRECTION_DOWN) &&
-           priv->orientation == GTK_PAN_ORIENTATION_VERTICAL));
+           priv->orientation == GTK_ORIENTATION_VERTICAL));
 }

 static void
@@ -196,7 +196,7 @@ gtk_gesture_pan_drag_update (GtkGestureDrag *gesture,
  else
    direction_from_offset (offset_x, offset_y, priv->orientation, &direction);

-  offset = (priv->orientation == GTK_PAN_ORIENTATION_VERTICAL) ?
+  offset = (priv->orientation == GTK_ORIENTATION_VERTICAL) ?
    ABS (offset_y) : ABS (offset_x);
  g_signal_emit (gesture, signals[PAN], 0, direction, offset);
 }
@@ -236,8 +236,8 @@ gtk_gesture_pan_class_init (GtkGesturePanClass *klass)
                                   g_param_spec_enum ("orientation",
                                                      P_("Orientation"),
                                                      P_("Allowed orientations"),
-                                                      GTK_TYPE_PAN_ORIENTATION,
-                                                      GTK_PAN_ORIENTATION_HORIZONTAL,
+                                                      GTK_TYPE_ORIENTATION,
+                                                      GTK_ORIENTATION_HORIZONTAL,
                                                      GTK_PARAM_READWRITE));
  /**
   * GtkGesturePan::pan:
@@ -266,7 +266,7 @@ gtk_gesture_pan_init (GtkGesturePan *gesture)
  GtkGesturePanPrivate *priv;

  priv = gtk_gesture_pan_get_instance_private (gesture);
-  priv->orientation = GTK_PAN_ORIENTATION_HORIZONTAL;
+  priv->orientation = GTK_ORIENTATION_HORIZONTAL;
 }

 /**
@@ -281,8 +281,8 @@ gtk_gesture_pan_init (GtkGesturePan *gesture)
 * Since: 3.14
 **/
 GtkGesture *
-gtk_gesture_pan_new (GtkWidget         *widget,
-                     GtkPanOrientation  orientation)
+gtk_gesture_pan_new (GtkWidget      *widget,
+                     GtkOrientation  orientation)
 {
  g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);

@@ -302,7 +302,7 @@ gtk_gesture_pan_new (GtkWidget         *widget,
 *
 * Since: 3.14
 */
-GtkPanOrientation
+GtkOrientation
 gtk_gesture_pan_get_orientation (GtkGesturePan *gesture)
 {
  GtkGesturePanPrivate *priv;
@@ -324,14 +324,14 @@ gtk_gesture_pan_get_orientation (GtkGesturePan *gesture)
 * Since: 3.14
 */
 void
-gtk_gesture_pan_set_orientation (GtkGesturePan     *gesture,
-                                 GtkPanOrientation  orientation)
+gtk_gesture_pan_set_orientation (GtkGesturePan  *gesture,
+                                 GtkOrientation  orientation)
 {
  GtkGesturePanPrivate *priv;

  g_return_if_fail (GTK_IS_GESTURE_PAN (gesture));
-  g_return_if_fail (orientation == GTK_PAN_ORIENTATION_HORIZONTAL ||
-                    orientation == GTK_PAN_ORIENTATION_VERTICAL);
+  g_return_if_fail (orientation == GTK_ORIENTATION_HORIZONTAL ||
+                    orientation == GTK_ORIENTATION_VERTICAL);

  priv = gtk_gesture_pan_get_instance_private (gesture);

@@ -42,15 +42,15 @@ GDK_AVAILABLE_IN_3_14
 GType             gtk_gesture_pan_get_type        (void) G_GNUC_CONST;

 GDK_AVAILABLE_IN_3_14
-GtkGesture *      gtk_gesture_pan_new             (GtkWidget         *widget,
-                                                   GtkPanOrientation  orientation);
+GtkGesture *      gtk_gesture_pan_new             (GtkWidget      *widget,
+                                                   GtkOrientation  orientation);

 GDK_AVAILABLE_IN_3_14
-GtkPanOrientation gtk_gesture_pan_get_orientation (GtkGesturePan     *gesture);
+GtkOrientation    gtk_gesture_pan_get_orientation (GtkGesturePan  *gesture);

 GDK_AVAILABLE_IN_3_14
-void              gtk_gesture_pan_set_orientation (GtkGesturePan     *gesture,
-                                                   GtkPanOrientation  orientation);
+void              gtk_gesture_pan_set_orientation (GtkGesturePan  *gesture,
+                                                   GtkOrientation  orientation);


 G_END_DECLS
@@ -196,19 +196,16 @@ gtk_gesture_rotate_new (GtkWidget *widget)
 /**
 * gtk_gesture_rotate_get_angle_delta:
 * @gesture: a #GtkGestureRotate
- * @delta: (out) (transfer none): angle delta
 *
- * If @gesture is active, this function returns %TRUE and fills
- * in @delta with the angle difference in radians since the
- * gesture was first recognized.
+ * If @gesture is active, this function returns the angle difference
+ * in radians since the gesture was first recognized.
 *
- * Returns: %TRUE if @controller is recognizing a rotate gesture
+ * Returns: the angle delta in radians
 *
 * Since: 3.14
 **/
-gboolean
-gtk_gesture_rotate_get_angle_delta (GtkGestureRotate *gesture,
-                                    gdouble          *delta)
+gdouble
+gtk_gesture_rotate_get_angle_delta (GtkGestureRotate *gesture)
 {
  GtkGestureRotatePrivate *priv;
  gdouble angle;
@@ -216,12 +213,9 @@ gtk_gesture_rotate_get_angle_delta (GtkGestureRotate *gesture,
  g_return_val_if_fail (GTK_IS_GESTURE_ROTATE (gesture), FALSE);

  if (!_gtk_gesture_rotate_get_angle (gesture, &angle))
-    return FALSE;
+    return 0;

  priv = gtk_gesture_rotate_get_instance_private (gesture);

-  if (delta)
-    *delta = angle - priv->initial_angle;
-
-  return TRUE;
+  return angle - priv->initial_angle;
 }
@@ -46,8 +46,7 @@ GDK_AVAILABLE_IN_3_14
 GtkGesture * gtk_gesture_rotate_new             (GtkWidget        *widget);

 GDK_AVAILABLE_IN_3_14
-gboolean     gtk_gesture_rotate_get_angle_delta (GtkGestureRotate *gesture,
-                                                 gdouble          *delta);
+gdouble      gtk_gesture_rotate_get_angle_delta (GtkGestureRotate *gesture);

 G_END_DECLS

@@ -191,17 +191,16 @@ gtk_gesture_zoom_new (GtkWidget *widget)
 * @gesture: a #GtkGestureZoom
 * @scale: (out) (transfer none): zoom delta
 *
- * If @controller is active, this function returns %TRUE and fills
- * in @scale with the zooming difference since the gesture was
- * recognized (hence the starting point is considered 1:1).
+ * If @gesture is active, this function returns the zooming difference
+ * since the gesture was recognized (hence the starting point is
+ * considered 1:1). If @gesture is not active, 1 is returned.
 *
 * Returns: %TRUE if @controller is recognizing a zoom gesture
 *
 * Since: 3.14
 **/
-gboolean
-gtk_gesture_zoom_get_scale_delta (GtkGestureZoom *gesture,
-                                  gdouble        *scale)
+gdouble
+gtk_gesture_zoom_get_scale_delta (GtkGestureZoom *gesture)
 {
  GtkGestureZoomPrivate *priv;
  gdouble distance;
@@ -209,12 +208,9 @@ gtk_gesture_zoom_get_scale_delta (GtkGestureZoom *gesture,
  g_return_val_if_fail (GTK_IS_GESTURE_ZOOM (gesture), FALSE);

  if (!_gtk_gesture_zoom_get_distance (gesture, &distance))
-    return FALSE;
+    return 1;

  priv = gtk_gesture_zoom_get_instance_private (gesture);

-  if (scale)
-    *scale = distance / priv->initial_distance;
-
-  return TRUE;
+  return distance / priv->initial_distance;
 }
@@ -46,8 +46,7 @@ GDK_AVAILABLE_IN_3_14
 GtkGesture * gtk_gesture_zoom_new             (GtkWidget      *widget);

 GDK_AVAILABLE_IN_3_14
-gboolean     gtk_gesture_zoom_get_scale_delta (GtkGestureZoom *gesture,
-                                               gdouble        *scale);
+gdouble      gtk_gesture_zoom_get_scale_delta (GtkGestureZoom *gesture);

 G_END_DECLS

@@ -793,7 +793,7 @@ gtk_paned_init (GtkPaned *paned)
  priv->handle_pos.y = -1;

  gesture = gtk_gesture_pan_new (GTK_WIDGET (paned),
-                                 GTK_PAN_ORIENTATION_HORIZONTAL);
+                                 GTK_ORIENTATION_HORIZONTAL);
  gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (gesture), FALSE);
  g_signal_connect (gesture, "drag-begin",
                    G_CALLBACK (pan_gesture_drag_begin_cb), paned);
@@ -801,7 +801,8 @@ gtk_paned_init (GtkPaned *paned)
                    G_CALLBACK (pan_gesture_pan_cb), paned);
  g_signal_connect (gesture, "drag-end",
                    G_CALLBACK (pan_gesture_drag_end_cb), paned);
-  gtk_gesture_attach (gesture, GTK_PHASE_CAPTURE);
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
+                                              GTK_PHASE_CAPTURE);
  priv->pan_gesture = gesture;
 }

@@ -824,13 +825,13 @@ gtk_paned_set_property (GObject        *object,
        {
          priv->cursor_type = GDK_SB_H_DOUBLE_ARROW;
          gtk_gesture_pan_set_orientation (GTK_GESTURE_PAN (priv->pan_gesture),
-                                           GTK_PAN_ORIENTATION_HORIZONTAL);
+                                           GTK_ORIENTATION_HORIZONTAL);
        }
      else
        {
          priv->cursor_type = GDK_SB_V_DOUBLE_ARROW;
          gtk_gesture_pan_set_orientation (GTK_GESTURE_PAN (priv->pan_gesture),
-                                           GTK_PAN_ORIENTATION_VERTICAL);
+                                           GTK_ORIENTATION_VERTICAL);
        }

      /* state_flags_changed updates the cursor */
@@ -971,7 +972,6 @@ gtk_paned_finalize (GObject *object)
  gtk_paned_set_saved_focus (paned, NULL);
  gtk_paned_set_first_paned (paned, NULL);

-  gtk_gesture_detach (paned->priv->pan_gesture);
  g_clear_object (&paned->priv->pan_gesture);

  G_OBJECT_CLASS (gtk_paned_parent_class)->finalize (object);
@@ -1505,11 +1505,7 @@ gtk_range_destroy (GtkWidget *widget)

  gtk_range_remove_step_timer (range);

-  if (priv->long_press_gesture)
-    {
-      gtk_gesture_detach (priv->long_press_gesture);
-      g_clear_object (&priv->long_press_gesture);
-    }
+  g_clear_object (&priv->long_press_gesture);

  if (priv->adjustment)
    {
@@ -2368,10 +2364,7 @@ update_zoom_set (GtkRange *range,
                 gboolean  zoom_set)
 {
  if (zoom_set)
-    {
-      gtk_gesture_detach (range->priv->long_press_gesture);
-      g_clear_object (&range->priv->long_press_gesture);
-    }
+    g_clear_object (&range->priv->long_press_gesture);

  range->priv->zoom_set = zoom_set;
 }
@@ -2711,7 +2704,6 @@ gtk_range_button_press (GtkWidget      *widget,
                  gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (priv->long_press_gesture),
                                                     FALSE);
                  gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (priv->long_press_gesture), 1);
-                  gtk_gesture_attach (priv->long_press_gesture, GTK_PHASE_NONE);

                  g_signal_connect (priv->long_press_gesture, "pressed",
                                    G_CALLBACK (hold_action), range);
@@ -724,25 +724,26 @@ scrolled_window_long_press_cancelled_cb (GtkScrolledWindow *scrolled_window,
 static void
 gtk_scrolled_window_check_attach_pan_gesture (GtkScrolledWindow *sw)
 {
+  GtkPropagationPhase phase = GTK_PHASE_NONE;
  GtkScrolledWindowPrivate *priv = sw->priv;

  if (priv->kinetic_scrolling &&
      ((priv->hscrollbar_visible && !priv->vscrollbar_visible) ||
       (!priv->hscrollbar_visible && priv->vscrollbar_visible)))
    {
-      GtkPanOrientation orientation;
+      GtkOrientation orientation;

      if (priv->hscrollbar_visible)
-        orientation = GTK_PAN_ORIENTATION_HORIZONTAL;
+        orientation = GTK_ORIENTATION_HORIZONTAL;
      else
-        orientation = GTK_PAN_ORIENTATION_VERTICAL;
+        orientation = GTK_ORIENTATION_VERTICAL;

      gtk_gesture_pan_set_orientation (GTK_GESTURE_PAN (priv->pan_gesture),
                                       orientation);
-      gtk_gesture_attach (priv->pan_gesture, GTK_PHASE_CAPTURE);
+      phase = GTK_PHASE_CAPTURE;
    }
-  else
-    gtk_gesture_detach (priv->pan_gesture);
+
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->pan_gesture), phase);
 }

 static void
@@ -783,7 +784,7 @@ gtk_scrolled_window_init (GtkScrolledWindow *scrolled_window)
                            G_CALLBACK (scrolled_window_drag_end_cb),
                            scrolled_window);

-  priv->pan_gesture = gtk_gesture_pan_new (widget, GTK_PAN_ORIENTATION_VERTICAL);
+  priv->pan_gesture = gtk_gesture_pan_new (widget, GTK_ORIENTATION_VERTICAL);
  gtk_gesture_group (priv->pan_gesture, priv->drag_gesture);
  gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (priv->pan_gesture), 1);

@@ -1267,6 +1268,7 @@ void
 gtk_scrolled_window_set_kinetic_scrolling (GtkScrolledWindow *scrolled_window,
                                           gboolean           kinetic_scrolling)
 {
+  GtkPropagationPhase phase = GTK_PHASE_NONE;
  GtkScrolledWindowPrivate *priv;

  g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
@@ -1279,19 +1281,15 @@ gtk_scrolled_window_set_kinetic_scrolling (GtkScrolledWindow *scrolled_window,
  gtk_scrolled_window_check_attach_pan_gesture (scrolled_window);

  if (priv->kinetic_scrolling)
-    {
-      gtk_gesture_attach (priv->drag_gesture, GTK_PHASE_CAPTURE);
-      gtk_gesture_attach (priv->swipe_gesture, GTK_PHASE_CAPTURE);
-      gtk_gesture_attach (priv->long_press_gesture, GTK_PHASE_CAPTURE);
-    }
+    phase = GTK_PHASE_CAPTURE;
  else
-    {
-      gtk_gesture_detach (priv->drag_gesture);
-      gtk_gesture_detach (priv->swipe_gesture);
-      gtk_gesture_detach (priv->long_press_gesture);
+    gtk_scrolled_window_cancel_deceleration (scrolled_window);
+
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->drag_gesture), phase);
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->swipe_gesture), phase);
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->long_press_gesture), phase);
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->pan_gesture), phase);

-      gtk_scrolled_window_cancel_deceleration (scrolled_window);
-    }
  g_object_notify (G_OBJECT (scrolled_window), "kinetic-scrolling");
 }

@@ -710,7 +710,8 @@ gtk_spin_button_init (GtkSpinButton *spin_button)
  gtk_widget_add_events (GTK_WIDGET (spin_button), GDK_SCROLL_MASK);

  priv->swipe_gesture = gtk_gesture_swipe_new (GTK_WIDGET (spin_button));
-  gtk_gesture_attach (priv->swipe_gesture, GTK_PHASE_CAPTURE);
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->swipe_gesture),
+                                              GTK_PHASE_CAPTURE);
  g_signal_connect (priv->swipe_gesture, "begin",
                    G_CALLBACK (swipe_gesture_begin), spin_button);
  g_signal_connect (priv->swipe_gesture, "update",
@@ -731,7 +732,6 @@ gtk_spin_button_finalize (GObject *object)
  if (priv->up_panel_context)
    g_object_unref (priv->up_panel_context);

-  gtk_gesture_detach (priv->swipe_gesture);
  g_object_unref (priv->swipe_gesture);

  G_OBJECT_CLASS (gtk_spin_button_parent_class)->finalize (object);
@@ -749,6 +749,9 @@ gtk_switch_dispose (GObject *object)
      priv->action = NULL;
    }

+  g_clear_object (&priv->pan_gesture);
+  g_clear_object (&priv->multipress_gesture);
+
  G_OBJECT_CLASS (gtk_switch_parent_class)->dispose (object);
 }

@@ -924,18 +927,20 @@ gtk_switch_init (GtkSwitch *self)
                    G_CALLBACK (gtk_switch_multipress_gesture_pressed), self);
  g_signal_connect (gesture, "released",
                    G_CALLBACK (gtk_switch_multipress_gesture_released), self);
-  gtk_gesture_attach (gesture, GTK_PHASE_TARGET);
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
+                                              GTK_PHASE_BUBBLE);
  self->priv->multipress_gesture = gesture;

  gesture = gtk_gesture_pan_new (GTK_WIDGET (self),
-                                 GTK_PAN_ORIENTATION_HORIZONTAL);
+                                 GTK_ORIENTATION_HORIZONTAL);
  gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (gesture), FALSE);
  gtk_gesture_single_set_exclusive (GTK_GESTURE_SINGLE (gesture), TRUE);
  g_signal_connect (gesture, "pan",
                    G_CALLBACK (gtk_switch_pan_gesture_pan), self);
  g_signal_connect (gesture, "drag-end",
                    G_CALLBACK (gtk_switch_pan_gesture_drag_end), self);
-  gtk_gesture_attach (gesture, GTK_PHASE_TARGET);
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
+                                              GTK_PHASE_BUBBLE);
  self->priv->pan_gesture = gesture;
 }

@@ -1555,7 +1555,8 @@ gtk_text_view_init (GtkTextView *text_view)
  priv->multipress_gesture = gtk_gesture_multi_press_new (widget);
  gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (priv->multipress_gesture),
                                     FALSE);
-  gtk_gesture_attach (priv->multipress_gesture, GTK_PHASE_TARGET);
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->multipress_gesture),
+                                              GTK_PHASE_BUBBLE);
  g_signal_connect (priv->multipress_gesture, "pressed",
                    G_CALLBACK (gtk_text_view_multipress_gesture_pressed),
                    widget);
@@ -1563,7 +1564,8 @@ gtk_text_view_init (GtkTextView *text_view)
  priv->drag_gesture = gtk_gesture_drag_new (widget);
  gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (priv->drag_gesture),
                                     FALSE);
-  gtk_gesture_attach (priv->drag_gesture, GTK_PHASE_TARGET);
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (priv->drag_gesture),
+                                              GTK_PHASE_BUBBLE);
  g_signal_connect (priv->drag_gesture, "drag-update",
                    G_CALLBACK (gtk_text_view_drag_gesture_update),
                    widget);
@@ -3258,10 +3260,7 @@ gtk_text_view_finalize (GObject *object)
  
  cancel_pending_scroll (text_view);

-  gtk_gesture_detach (priv->multipress_gesture);
  g_object_unref (priv->multipress_gesture);
-
-  gtk_gesture_detach (priv->drag_gesture);
  g_object_unref (priv->drag_gesture);

  if (priv->tabs)
@@ -1841,7 +1841,8 @@ gtk_tree_view_init (GtkTreeView *tree_view)
  gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (tree_view->priv->multipress_gesture), FALSE);
  g_signal_connect (tree_view->priv->multipress_gesture, "pressed",
                    G_CALLBACK (_tree_view_multipress_pressed), tree_view);
-  gtk_gesture_attach (tree_view->priv->multipress_gesture, GTK_PHASE_BUBBLE);
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (tree_view->priv->multipress_gesture),
+                                              GTK_PHASE_TARGET);
 }


@@ -2206,11 +2207,7 @@ gtk_tree_view_destroy (GtkWidget *widget)
    _gtk_pixel_cache_free (tree_view->priv->pixel_cache);
  tree_view->priv->pixel_cache = NULL;

-  if (tree_view->priv->multipress_gesture)
-    {
-      gtk_gesture_detach (tree_view->priv->multipress_gesture);
-      g_clear_object (&tree_view->priv->multipress_gesture);
-    }
+  g_clear_object (&tree_view->priv->multipress_gesture);

  GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->destroy (widget);
 }
@@ -2445,6 +2442,9 @@ gtk_tree_view_realize (GtkWidget *widget)
  gtk_tree_view_set_enable_tree_lines (tree_view, tree_view->priv->tree_lines_enabled);

  install_presize_handler (tree_view); 
+
+  gtk_gesture_set_window (tree_view->priv->multipress_gesture,
+                          tree_view->priv->bin_window);
 }

 static void
@@ -2521,6 +2521,8 @@ gtk_tree_view_unrealize (GtkWidget *widget)
      priv->drag_highlight_window = NULL;
    }

+  gtk_gesture_set_window (tree_view->priv->multipress_gesture, NULL);
+
  GTK_WIDGET_CLASS (gtk_tree_view_parent_class)->unrealize (widget);
 }

@@ -400,7 +400,6 @@ typedef struct {

 typedef struct {
  GtkEventController *controller;
-  GtkPropagationPhase phase;
  guint evmask_notify_id;
  guint grab_notify_id;
  guint sequence_state_changed_id;
@@ -4206,11 +4205,13 @@ gtk_widget_needs_press_emulation (GtkWidget        *widget,
  for (l = priv->event_controllers; l; l = l->next)
    {
      EventControllerData *data;
+      GtkPropagationPhase phase;
      GtkGesture *gesture;

      data = l->data;
+      phase = gtk_event_controller_get_propagation_phase (data->controller);

-      if (data->phase != GTK_PHASE_CAPTURE)
+      if (phase != GTK_PHASE_CAPTURE)
        continue;
      if (!GTK_IS_GESTURE (data->controller))
        continue;
@@ -7129,7 +7130,7 @@ gtk_widget_real_button_event (GtkWidget      *widget,
                              GdkEventButton *event)
 {
  return _gtk_widget_run_controllers (widget, (GdkEvent *) event,
-                                      GTK_PHASE_TARGET);
+                                      GTK_PHASE_BUBBLE);
 }

 static gboolean
@@ -7137,7 +7138,7 @@ gtk_widget_real_motion_event (GtkWidget      *widget,
                              GdkEventMotion *event)
 {
  return _gtk_widget_run_controllers (widget, (GdkEvent *) event,
-                                      GTK_PHASE_TARGET);
+                                      GTK_PHASE_BUBBLE);
 }

 static gboolean
@@ -7182,7 +7183,7 @@ gtk_widget_real_touch_event (GtkWidget     *widget,

  if (!event->emulating_pointer)
    return _gtk_widget_run_controllers (widget, (GdkEvent*) event,
-                                        GTK_PHASE_TARGET);
+                                        GTK_PHASE_BUBBLE);

  if (event->type == GDK_TOUCH_BEGIN ||
      event->type == GDK_TOUCH_END)
@@ -7247,7 +7248,7 @@ gtk_widget_real_grab_broken_event (GtkWidget          *widget,
                                   GdkEventGrabBroken *event)
 {
  return _gtk_widget_run_controllers (widget, (GdkEvent*) event,
-                                      GTK_PHASE_TARGET);
+                                      GTK_PHASE_BUBBLE);
 }

 #define WIDGET_REALIZED_FOR_EVENT(widget, event) \
@@ -7332,6 +7333,7 @@ _gtk_widget_run_controllers (GtkWidget           *widget,
  while (l != NULL)
    {
      GList *next = l->next;
+
      data = l->data;

      if (data->controller == NULL)
@@ -7339,8 +7341,15 @@ _gtk_widget_run_controllers (GtkWidget           *widget,
          priv->event_controllers = g_list_delete_link (priv->event_controllers, l);
          g_free (data);
        }
-      else if (data->phase == phase)
-        handled |= gtk_event_controller_handle_event (data->controller, event);
+      else
+        {
+          GtkPropagationPhase controller_phase;
+
+          controller_phase = gtk_event_controller_get_propagation_phase (data->controller);
+
+          if (controller_phase == phase)
+            handled |= gtk_event_controller_handle_event (data->controller, event);
+        }

      l = next;
    }
@@ -7577,6 +7586,9 @@ gtk_widget_event_internal (GtkWidget *widget,

  g_object_ref (widget);

+  if (widget == gtk_get_event_widget (event))
+    return_val |= _gtk_widget_run_controllers (widget, event, GTK_PHASE_TARGET);
+
  g_signal_emit (widget, widget_signals[EVENT], 0, event, &handled);
  return_val |= handled | !WIDGET_REALIZED_FOR_EVENT (widget, event);
  if (!return_val)
@@ -7690,8 +7702,6 @@ gtk_widget_event_internal (GtkWidget *widget,
  else
    return_val = TRUE;

-  return_val |= _gtk_widget_run_controllers (widget, event, GTK_PHASE_BUBBLE);
-
  g_object_unref (widget);

  return return_val;
@@ -16874,10 +16884,12 @@ event_controller_grab_notify (GtkWidget           *widget,
                              EventControllerData *data)
 {
  GtkWidget *grab_widget, *toplevel;
+  GtkPropagationPhase phase;
  GtkWindowGroup *group;
  GdkDevice *device;

  device = gtk_gesture_get_device (GTK_GESTURE (data->controller));
+  phase = gtk_event_controller_get_propagation_phase (data->controller);

  if (!device)
    return;
@@ -16897,9 +16909,9 @@ event_controller_grab_notify (GtkWidget           *widget,
  if (!grab_widget || grab_widget == widget)
    return;

-  if ((data->phase != GTK_PHASE_CAPTURE &&
+  if ((phase != GTK_PHASE_CAPTURE &&
       !gtk_widget_is_ancestor (widget, grab_widget)) ||
-      (data->phase == GTK_PHASE_CAPTURE &&
+      (phase == GTK_PHASE_CAPTURE &&
       !gtk_widget_is_ancestor (widget, grab_widget) &&
       !gtk_widget_is_ancestor (grab_widget, widget)))
    {
@@ -16988,8 +17000,7 @@ _gtk_widget_has_controller (GtkWidget          *widget,

 void
 _gtk_widget_add_controller (GtkWidget           *widget,
-                            GtkEventController  *controller,
-                            GtkPropagationPhase  phase)
+                            GtkEventController  *controller)
 {
  EventControllerData *data;
  GtkWidgetPrivate *priv;
@@ -16997,20 +17008,15 @@ _gtk_widget_add_controller (GtkWidget           *widget,
  g_return_if_fail (GTK_IS_WIDGET (widget));
  g_return_if_fail (GTK_IS_EVENT_CONTROLLER (controller));
  g_return_if_fail (widget == gtk_event_controller_get_widget (controller));
-  g_return_if_fail (phase >= GTK_PHASE_NONE && phase <= GTK_PHASE_TARGET);

  priv = widget->priv;
  data = _gtk_widget_has_controller (widget, controller);

  if (data)
-    {
-      data->phase = phase;
-      return;
-    }
+    return;

  data = g_new0 (EventControllerData, 1);
-  data->controller = g_object_ref (controller);
-  data->phase = phase;
+  data->controller = controller;
  data->evmask_notify_id =
    g_signal_connect (controller, "notify::event-mask",
                      G_CALLBACK (event_controller_notify_event_mask), widget);
@@ -17049,8 +17055,6 @@ _gtk_widget_remove_controller (GtkWidget          *widget,

  g_signal_handler_disconnect (data->controller, data->evmask_notify_id);
  g_signal_handler_disconnect (data->controller, data->sequence_state_changed_id);
-  gtk_event_controller_reset (GTK_EVENT_CONTROLLER (data->controller));
-  g_object_unref (data->controller);
  data->controller = NULL;
 }

@@ -17069,7 +17073,9 @@ _gtk_widget_list_controllers (GtkWidget           *widget,
  for (l = priv->event_controllers; l; l = l->next)
    {
      data = l->data;
-      if (data->phase == phase && data->controller != NULL)
+
+      if (data->controller != NULL &&
+          phase == gtk_event_controller_get_propagation_phase (data->controller))
        retval = g_list_prepend (retval, data->controller);
    }

@@ -156,8 +156,7 @@ GActionGroup *    _gtk_widget_get_action_group             (GtkWidget    *widget
                                                            const gchar  *prefix);

 void              _gtk_widget_add_controller               (GtkWidget           *widget,
-                                                            GtkEventController  *controller,
-                                                            GtkPropagationPhase  phase);
+                                                            GtkEventController  *controller);
 void              _gtk_widget_remove_controller            (GtkWidget           *widget,
                                                            GtkEventController  *controller);
 GList *           _gtk_widget_list_controllers             (GtkWidget           *widget,
@@ -1595,7 +1595,6 @@ gtk_window_constructor (GType                  type,
                        G_CALLBACK (multipress_gesture_pressed_cb), object);
      g_signal_connect (priv->multipress_gesture, "stopped",
                        G_CALLBACK (multipress_gesture_stopped_cb), object);
-      gtk_gesture_attach (priv->multipress_gesture, GTK_PHASE_CAPTURE);
    }

  return object;
@@ -5482,10 +5481,7 @@ gtk_window_finalize (GObject *object)
    }

  if (priv->multipress_gesture)
-    {
-      gtk_gesture_detach (priv->multipress_gesture);
-      g_object_unref (priv->multipress_gesture);
-    }
+    g_object_unref (priv->multipress_gesture);

  G_OBJECT_CLASS (gtk_window_parent_class)->finalize (object);
 }
@@ -74,7 +74,7 @@ phase_changed_cb (GtkComboBox *combo, GtkInspectorGestures *sl)
  phase = gtk_combo_box_get_active (combo);
  row = gtk_widget_get_ancestor (GTK_WIDGET (combo), GTK_TYPE_LIST_BOX_ROW);
  gesture = GTK_GESTURE (g_object_get_data (G_OBJECT (row), "gesture"));
-  gtk_gesture_attach (gesture, phase);
+  gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture), phase);
 }

 static void
Author	SHA1	Message	Date
Carlos Garnacho	a35c581710	treeview: Make the multipress gesture listen only to bin_window This gesture is meant to handle row-activated signaling, so make the gesture ignore events from any other window.	2014-05-27 17:37:07 +02:00
Carlos Garnacho	ba6b7633aa	button: Claim the sequence on multipress::pressed In order to avoid the event from bubbling, as it used to (not) do.	2014-05-27 17:35:36 +02:00
Carlos Garnacho	a2fe2ab4e6	gesture: Fix wrong assert in gtk_gesture_set_window The window must be part of the event controller widget, so fix the inverted logic.	2014-05-27 17:33:31 +02:00
Carlos Garnacho	f4ed7e23da	eventcontroller: Hide more details Signals are left hidden, so the only entry point to handle_event/reset is API.	2014-05-27 12:41:30 +02:00
Carlos Garnacho	d46ed462ca	gtk: Update GtkGesture users to the GtkPropagationPhase semantics change Mainly doing s/TARGET/BUBBLE/ on the fully ported widgets, but GtkTreeView where the double click handler has moved to GTK_PHASE_TARGET so it runs parallelly to the still existing event handlers.	2014-05-27 12:38:49 +02:00
Carlos Garnacho	ff88366dd2	widget: Change GtkCapturePhase behavior in event controllers' handling Previously, there would be globally just a capture and a bubble phase, with the event just going down the hierarchy once, and the up once. GTK_PHASE_TARGET actually meaning "run within event handlers", so in a hierarchy of 3 widgets, emission would be: Capture(C) Capture(B) Capture(A) Target(A) (if event handlers allow) Bubble(A) Target(B) (if event handlers allow) Bubble(B) Target(C) (if event handlers allow) Bubble(C) This commit changes this behavior and uses GTK_PHASE_TARGET in a less misleading way, running only on the widget that was meant to receive the event. And GTK_PHASE_BUBBLE has taken over the execution place of GTK_PHASE_TARGET, so the emission remains: Capture(C) Capture(B) Capture(A) Target(A) Bubble(A) (if event handlers allow) Bubble(B) (...) Bubble(C) (...) As it was, GTK_PHASE_BUBBLE was useful for running event controllers paralelly to event handlers, without modifying a single line in those. For those mixed scenarios, Any of the other phases will have to be used at discretion, or the event handlers eventually changed to chain up and let the default event handlers in GtkWidget to be run.	2014-05-27 12:14:52 +02:00
Carlos Garnacho	3a86218983	window: Avoid double event processing in the multipress event controller The events to those are fed outside the regular event propagation scheme, through _gtk_window_check_handle_wm_event(), so set the controller to GTK_PHASE_NONE so events aren't processed first manually, and then automatically.	2014-05-27 12:14:17 +02:00
Carlos Garnacho	361812066a	gesturezoom: Just return a double in get_scale_delta() Checking whether the gesture is active is a responsibility of the caller.	2014-05-26 14:38:56 +02:00
Carlos Garnacho	83bb9d10a3	gesturerotate: Just return a double in get_angle_delta() Whether the gesture is active or recognized should be checked before in callers, or just not used naively.	2014-05-26 14:38:56 +02:00
Carlos Garnacho	f563a64460	gesture: Replace gtk_gesture_attach/detach with event controller API Event controllers now auto-attach, and the GtkCapturePhase only determines when are events dispatched, but all controllers are managed by the widget wrt grabs. All callers have been updated.	2014-05-26 14:38:56 +02:00
Carlos Garnacho	68dd8e817b	gtk: Update callers of GtkGesturePan orientation	2014-05-26 14:34:24 +02:00
Carlos Garnacho	fb34e6ad36	eventcontroller: Make the event-mask property and methods private. This will rarely have any use if no subclassing is allowed, so just make it private for our own.	2014-05-26 14:34:24 +02:00
Carlos Garnacho	c0d74d3ea7	gtk: Replace GtkPanOrientation with GtkOrientation And document GtkOrientation to be more generic. There's little added value in a separate enum for this.	2014-05-26 14:34:24 +02:00