Gesture


Object Hierarchy:

Object hierarchy for Gesture

Description:

public abstract class Gesture : EventController

Gesture is the base object for gesture recognition, although this object is quite generalized to serve as a base for multi-touch gestures, it is suitable to implement single-touch and pointer-based gestures (using the special null EventSequence value for these).

The number of touches that a Gesture need to be recognized is controlled by the n_points property, if a gesture is keeping track of less or more than that number of sequences, it won't check wether the gesture is recognized.

As soon as the gesture has the expected number of touches, the gesture will run the GtkGesture::check signal regularly on input events until the gesture is recognized, the criteria to consider a gesture as "recognized" is left to Gesture subclasses.

A recognized gesture will then emit the following signals: - begin when the gesture is recognized. - A number of update, whenever an input event is processed. - end when the gesture is no longer recognized.

Event propagation

In order to receive events, a gesture needs to either set a propagation phase through set_propagation_phase, or feed those manually through 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 get a chance to interact with the event before it reaches the target.

After the capture phase, GTK+ emits the traditional button_press_event , button_release_event, touch_event, etc signals. Gestures with the gtk_phase_target phase are fed events from the default 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.

States of a sequence # {touch-sequence-states}

Whenever input interaction happens, a single event may trigger a cascade of Gestures, both across the parents of the widget receiving the event and in parallel within an individual widget. It is a responsibility of the widgets using those gestures to set the state of touch sequences accordingly in order to enable cooperation of gestures around the EventSequences triggering those.

Within a widget, gestures can be grouped through group, grouped gestures synchronize the state of sequences, so calling set_sequence_state on one will effectively propagate the state throughout the group.

By default, all sequences start out in the NONE state, sequences in this state trigger the gesture event handler, but event propagation will continue unstopped by gestures.

If a sequence enters into the DENIED state, the gesture group will effectively ignore the sequence, letting events go unstopped through the gesture, but the "slot" will still remain occupied while the touch is active.

If a sequence enters in the CLAIMED state, the gesture group will grab all interaction on the sequence, by: - Setting the same sequence to DENIED on every other gesture group within the widget, and every gesture on parent widgets in the propagation chain. - calling cancel on every gesture in widgets underneath in the propagation chain. - Stopping event propagation after the gesture group handles the event.

Note: if a sequence is set early to CLAIMED on TOUCH_BEGIN/ BUTTON_PRESS (so those events are captured before reaching the event widget, this implies CAPTURE), one similar event will emulated if the sequence changes to DENIED. This way event coherence is preserved before event propagation is unstopped again.

Sequence states can't be changed freely, see set_sequence_state to know about the possible lifetimes of a EventSequence.

Touchpad gestures

On the platforms that support it, Gesture will handle transparently touchpad gesture events. The only precautions users of Gesture should do to enable this support are: - Enabling gdk_touchpad_gesture_mask on their Windows - If the gesture has gtk_phase_none, ensuring events of type gdk_touchpad_swipe and gdk_touchpad_pinch are handled by the Gesture


Namespace: Gtk
Package: gtk+-3.0

Content:

Properties:

Creation methods:

Methods:

Signals:

Inherited Members:

All known members inherited from class Gtk.EventController