GI.Gtk.Objects.Gesture

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 Nothing EventSequence value for these).

The number of touches that a Gesture need to be recognized is controlled by the Gesture: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 Gesture::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:

• Gesture::begin when the gesture is recognized.
• A number of Gesture::update, whenever an input event is processed.
• Gesture::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 eventControllerSetPropagationPhase, or feed those manually through eventControllerHandleEvent.

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 Widget::button-press-event, Widget::button-release-event, Widget::touch-event, etc signals. Gestures with the PropagationPhaseTarget phase are fed events from the default Widget::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.

# {touch-sequence-states}

Whenever input interaction happens, a single event may trigger a cascade of GtkGestures, 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 GdkEventSequences triggering those.

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

By default, all sequences start out in the GTK_EVENT_SEQUENCE_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 GTK_EVENT_SEQUENCE_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 GTK_EVENT_SEQUENCE_CLAIMED state, the gesture group will grab all interaction on the sequence, by:

• Setting the same sequence to GTK_EVENT_SEQUENCE_DENIED on every other gesture group within the widget, and every gesture on parent widgets in the propagation chain.
• calling Gesture::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 GTK_EVENT_SEQUENCE_CLAIMED on GDK_TOUCH_BEGIN/GDK_BUTTON_PRESS (so those events are captured before reaching the event widget, this implies GTK_PHASE_CAPTURE), one similar event will emulated if the sequence changes to GTK_EVENT_SEQUENCE_DENIED. This way event coherence is preserved before event propagation is unstopped again.

Sequence states can't be changed freely, see gestureSetSequenceState 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 EventMaskTouchpadGestureMask on their GdkWindows
• If the gesture has PropagationPhaseNone, ensuring events of type EventTypeTouchpadSwipe and EventTypeTouchpadPinch are handled by the Gesture

Exported types

newtype Gesture

Constructors

Gesture (ManagedPtr Gesture)

Instances

GObject Gesture

Methods

gobjectType :: Gesture -> IO GType

IsObject Gesture

IsGesture Gesture

IsEventController Gesture

((~) * info (ResolveGestureMethod t Gesture), MethodInfo * info Gesture p) => IsLabel t (Gesture -> p)

Methods

fromLabel :: Proxy# Symbol t -> Gesture -> p

((~) * info (ResolveGestureMethod t Gesture), MethodInfo * info Gesture p) => IsLabelProxy t (Gesture -> p)

Methods

fromLabelProxy :: Proxy Symbol t -> Gesture -> p

HasAttributeList * Gesture

type AttributeList Gesture

type AttributeList Gesture

type SignalList Gesture

type SignalList Gesture

class GObject o => IsGesture o

Instances

(GObject a, UnknownAncestorError Constraint Gesture a) => IsGesture a

IsGesture GestureSingle

IsGesture GestureDrag

IsGesture Gesture

IsGesture GestureLongPress

IsGesture GestureMultiPress

IsGesture GestureRotate

IsGesture GestureSwipe

IsGesture GestureZoom

IsGesture GesturePan

toGesture :: IsGesture o => o -> IO Gesture

noGesture :: Maybe Gesture

Methods

getBoundingBox

data GestureGetBoundingBoxMethodInfo

Instances

((~) * signature (m (Bool, Rectangle)), MonadIO m, IsGesture a) => MethodInfo * GestureGetBoundingBoxMethodInfo a signature

Methods

overloadedMethod :: MethodProxy GestureGetBoundingBoxMethodInfo a -> signature -> s

gestureGetBoundingBox

Arguments

:: (HasCallStack, MonadIO m, IsGesture a)

=> a

gesture: a Gesture

-> m (Bool, Rectangle)

Returns: True if there are active touches, False otherwise

If there are touch sequences being currently handled by gesture, this function returns True and fills in rect with the bounding box containing all active touches. Otherwise, False will be returned.

Note: This function will yield unexpected results on touchpad gestures. Since there is no correlation between physical and pixel distances, these will look as if constrained in an infinitely small area, rect width and height will thus be 0 regardless of the number of touchpoints.

Since: 3.14

getBoundingBoxCenter

data GestureGetBoundingBoxCenterMethodInfo

Instances

((~) * signature (m (Bool, Double, Double)), MonadIO m, IsGesture a) => MethodInfo * GestureGetBoundingBoxCenterMethodInfo a signature

Methods

overloadedMethod :: MethodProxy GestureGetBoundingBoxCenterMethodInfo a -> signature -> s

gestureGetBoundingBoxCenter

Arguments

:: (HasCallStack, MonadIO m, IsGesture a)

=> a

gesture: a Gesture

-> m (Bool, Double, Double)

Returns: False if no active touches are present, True otherwise

If there are touch sequences being currently handled by gesture, this function returns True and fills in x and y with the center of the bounding box containing all active touches. Otherwise, False will be returned.

Since: 3.14

getDevice

data GestureGetDeviceMethodInfo

Instances

((~) * signature (m (Maybe Device)), MonadIO m, IsGesture a) => MethodInfo * GestureGetDeviceMethodInfo a signature

Methods

overloadedMethod :: MethodProxy GestureGetDeviceMethodInfo a -> signature -> s

gestureGetDevice

Arguments

:: (HasCallStack, MonadIO m, IsGesture a)

=> a

gesture: a Gesture

-> m (Maybe Device)

Returns: a Device, or Nothing

Returns the master Device that is currently operating on gesture, or Nothing if the gesture is not being interacted.

Since: 3.14

getGroup

data GestureGetGroupMethodInfo

Instances

((~) * signature (m [Gesture]), MonadIO m, IsGesture a) => MethodInfo * GestureGetGroupMethodInfo a signature

Methods

overloadedMethod :: MethodProxy GestureGetGroupMethodInfo a -> signature -> s

gestureGetGroup

Arguments

:: (HasCallStack, MonadIO m, IsGesture a)

=> a

gesture: a Gesture

-> m [Gesture]

Returns: The list of GtkGestures, free with g_list_free()

Returns all gestures in the group of gesture

Since: 3.14

getLastEvent

data GestureGetLastEventMethodInfo

Instances

((~) * signature (EventSequence -> m (Maybe Event)), MonadIO m, IsGesture a) => MethodInfo * GestureGetLastEventMethodInfo a signature

Methods

overloadedMethod :: MethodProxy GestureGetLastEventMethodInfo a -> signature -> s

gestureGetLastEvent

Arguments

:: (HasCallStack, MonadIO m, IsGesture a)

=> a

gesture: a Gesture

-> EventSequence

sequence: a EventSequence

-> m (Maybe Event)

Returns: The last event from sequence

Returns the last event that was processed for sequence.

Note that the returned pointer is only valid as long as the sequence is still interpreted by the gesture. If in doubt, you should make a copy of the event.

getLastUpdatedSequence

data GestureGetLastUpdatedSequenceMethodInfo

Instances

((~) * signature (m (Maybe EventSequence)), MonadIO m, IsGesture a) => MethodInfo * GestureGetLastUpdatedSequenceMethodInfo a signature

Methods

overloadedMethod :: MethodProxy GestureGetLastUpdatedSequenceMethodInfo a -> signature -> s

gestureGetLastUpdatedSequence

Arguments

:: (HasCallStack, MonadIO m, IsGesture a)

=> a

gesture: a Gesture

-> m (Maybe EventSequence)

Returns: The last updated sequence

Returns the EventSequence that was last updated on gesture.

Since: 3.14

getPoint

data GestureGetPointMethodInfo

Instances

((~) * signature (Maybe EventSequence -> m (Bool, Double, Double)), MonadIO m, IsGesture a) => MethodInfo * GestureGetPointMethodInfo a signature

Methods

overloadedMethod :: MethodProxy GestureGetPointMethodInfo a -> signature -> s

gestureGetPoint

Arguments

:: (HasCallStack, MonadIO m, IsGesture a)

=> a

gesture: a Gesture

-> Maybe EventSequence

sequence: a EventSequence, or Nothing for pointer events

-> m (Bool, Double, Double)

Returns: True if sequence is currently interpreted

If sequence is currently being interpreted by gesture, this function returns True and fills in x and y with the last coordinates stored for that event sequence. The coordinates are always relative to the widget allocation.

Since: 3.14

getSequenceState

data GestureGetSequenceStateMethodInfo

Instances

((~) * signature (EventSequence -> m EventSequenceState), MonadIO m, IsGesture a) => MethodInfo * GestureGetSequenceStateMethodInfo a signature

Methods

overloadedMethod :: MethodProxy GestureGetSequenceStateMethodInfo a -> signature -> s

gestureGetSequenceState

Arguments

:: (HasCallStack, MonadIO m, IsGesture a)

=> a

gesture: a Gesture

-> EventSequence

sequence: a EventSequence

-> m EventSequenceState

Returns: The sequence state in gesture

Returns the sequence state, as seen by gesture.

Since: 3.14

getSequences

data GestureGetSequencesMethodInfo

Instances

((~) * signature (m [EventSequence]), MonadIO m, IsGesture a) => MethodInfo * GestureGetSequencesMethodInfo a signature

Methods

overloadedMethod :: MethodProxy GestureGetSequencesMethodInfo a -> signature -> s

gestureGetSequences

Arguments

:: (HasCallStack, MonadIO m, IsGesture a)

=> a

gesture: a Gesture

-> m [EventSequence]

Returns: A list of GdkEventSequences, the list elements are owned by GTK+ and must not be freed or modified, the list itself must be deleted through g_list_free()

Returns the list of GdkEventSequences currently being interpreted by gesture.

Since: 3.14

getWindow

data GestureGetWindowMethodInfo

Instances

((~) * signature (m (Maybe Window)), MonadIO m, IsGesture a) => MethodInfo * GestureGetWindowMethodInfo a signature

Methods

overloadedMethod :: MethodProxy GestureGetWindowMethodInfo a -> signature -> s

gestureGetWindow

Arguments

:: (HasCallStack, MonadIO m, IsGesture a)

=> a

gesture: a Gesture

-> m (Maybe Window)

Returns: the user defined window, or Nothing if none

Returns the user-defined window that receives the events handled by gesture. See gestureSetWindow for more information.

Since: 3.14

group

data GestureGroupMethodInfo

Instances

((~) * signature (b -> m ()), MonadIO m, IsGesture a, IsGesture b) => MethodInfo * GestureGroupMethodInfo a signature

Methods

overloadedMethod :: MethodProxy GestureGroupMethodInfo a -> signature -> s

gestureGroup

Arguments

:: (HasCallStack, MonadIO m, IsGesture a, IsGesture b)

=> a

groupGesture: Gesture to group gesture with

-> b

gesture: a Gesture

-> m ()

Adds gesture to the same group than groupGesture. Gestures are by default isolated in their own groups.

When gestures are grouped, the state of GdkEventSequences is kept in sync for all of those, so calling gestureSetSequenceState, on one will transfer the same value to the others.

Groups also perform an "implicit grabbing" of sequences, if a EventSequence state is set to GTK_EVENT_SEQUENCE_CLAIMED on one group, every other gesture group attached to the same Widget will switch the state for that sequence to GTK_EVENT_SEQUENCE_DENIED.

Since: 3.14

handlesSequence

data GestureHandlesSequenceMethodInfo

Instances

((~) * signature (EventSequence -> m Bool), MonadIO m, IsGesture a) => MethodInfo * GestureHandlesSequenceMethodInfo a signature

Methods

overloadedMethod :: MethodProxy GestureHandlesSequenceMethodInfo a -> signature -> s

gestureHandlesSequence

Arguments

:: (HasCallStack, MonadIO m, IsGesture a)

=> a

gesture: a Gesture

-> EventSequence

sequence: a EventSequence

-> m Bool

Returns: True if gesture is handling sequence

Returns True if gesture is currently handling events corresponding to sequence.

Since: 3.14

isActive

data GestureIsActiveMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsGesture a) => MethodInfo * GestureIsActiveMethodInfo a signature

Methods

overloadedMethod :: MethodProxy GestureIsActiveMethodInfo a -> signature -> s

gestureIsActive

Arguments

:: (HasCallStack, MonadIO m, IsGesture a)

=> a

gesture: a Gesture

-> m Bool

Returns: True if gesture is active

Returns True if the gesture is currently active. A gesture is active meanwhile there are touch sequences interacting with it.

Since: 3.14

isGroupedWith

data GestureIsGroupedWithMethodInfo

Instances

((~) * signature (b -> m Bool), MonadIO m, IsGesture a, IsGesture b) => MethodInfo * GestureIsGroupedWithMethodInfo a signature

Methods

overloadedMethod :: MethodProxy GestureIsGroupedWithMethodInfo a -> signature -> s

gestureIsGroupedWith

Arguments

:: (HasCallStack, MonadIO m, IsGesture a, IsGesture b)

=> a

gesture: a Gesture

-> b

other: another Gesture

-> m Bool

Returns: whether the gestures are grouped

Returns True if both gestures pertain to the same group.

Since: 3.14

isRecognized

data GestureIsRecognizedMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, IsGesture a) => MethodInfo * GestureIsRecognizedMethodInfo a signature

Methods

overloadedMethod :: MethodProxy GestureIsRecognizedMethodInfo a -> signature -> s

gestureIsRecognized

Arguments

:: (HasCallStack, MonadIO m, IsGesture a)

=> a

gesture: a Gesture

-> m Bool

Returns: True if gesture is recognized

Returns True if the gesture is currently recognized. A gesture is recognized if there are as many interacting touch sequences as required by gesture, and Gesture::check returned True for the sequences being currently interpreted.

Since: 3.14

setSequenceState

data GestureSetSequenceStateMethodInfo

Instances

((~) * signature (EventSequence -> EventSequenceState -> m Bool), MonadIO m, IsGesture a) => MethodInfo * GestureSetSequenceStateMethodInfo a signature

Methods

overloadedMethod :: MethodProxy GestureSetSequenceStateMethodInfo a -> signature -> s

gestureSetSequenceState

Arguments

:: (HasCallStack, MonadIO m, IsGesture a)

=> a

gesture: a Gesture

-> EventSequence

sequence: a EventSequence

-> EventSequenceState

state: the sequence state

-> m Bool

Returns: True if sequence is handled by gesture, and the state is changed successfully

Sets the state of sequence in gesture. Sequences start in state GTK_EVENT_SEQUENCE_NONE, and whenever they change state, they can never go back to that state. Likewise, sequences in state GTK_EVENT_SEQUENCE_DENIED cannot turn back to a not denied state. With these rules, the lifetime of an event sequence is constrained to the next four:

• None
• None → Denied
• None → Claimed
• None → Claimed → Denied

Note: Due to event handling ordering, it may be unsafe to set the state on another gesture within a Gesture::begin signal handler, as the callback might be executed before the other gesture knows about the sequence. A safe way to perform this could be:

static void
first_gesture_begin_cb (GtkGesture       *first_gesture,
                        GdkEventSequence *sequence,
                        gpointer          user_data)
{
  gtk_gesture_set_sequence_state (first_gesture, sequence, GTK_EVENT_SEQUENCE_ACCEPTED);
  gtk_gesture_set_sequence_state (second_gesture, sequence, GTK_EVENT_SEQUENCE_DENIED);
}

static void
second_gesture_begin_cb (GtkGesture       *second_gesture,
                         GdkEventSequence *sequence,
                         gpointer          user_data)
{
  if (gtk_gesture_get_sequence_state (first_gesture, sequence) == GTK_EVENT_SEQUENCE_ACCEPTED)
    gtk_gesture_set_sequence_state (second_gesture, sequence, GTK_EVENT_SEQUENCE_DENIED);
}

If both gestures are in the same group, just set the state on the gesture emitting the event, the sequence will be already be initialized to the group's global state when the second gesture processes the event.

Since: 3.14

setState

data GestureSetStateMethodInfo

Instances

((~) * signature (EventSequenceState -> m Bool), MonadIO m, IsGesture a) => MethodInfo * GestureSetStateMethodInfo a signature

Methods

overloadedMethod :: MethodProxy GestureSetStateMethodInfo a -> signature -> s

gestureSetState

Arguments

:: (HasCallStack, MonadIO m, IsGesture a)

=> a

gesture: a Gesture

-> EventSequenceState

state: the sequence state

-> m Bool

Returns: True if the state of at least one sequence was changed successfully

Sets the state of all sequences that gesture is currently interacting with. See gestureSetSequenceState for more details on sequence states.

Since: 3.14

setWindow

data GestureSetWindowMethodInfo

Instances

((~) * signature (Maybe b -> m ()), MonadIO m, IsGesture a, IsWindow b) => MethodInfo * GestureSetWindowMethodInfo a signature

Methods

overloadedMethod :: MethodProxy GestureSetWindowMethodInfo a -> signature -> s

gestureSetWindow

Arguments

:: (HasCallStack, MonadIO m, IsGesture a, IsWindow b)

=> a

gesture: a Gesture

-> Maybe b

window: a Window, or Nothing

-> m ()

Sets a specific window to receive events about, so gesture will effectively handle only events targeting window, or a child of it. window must pertain to eventControllerGetWidget.

Since: 3.14

ungroup

data GestureUngroupMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsGesture a) => MethodInfo * GestureUngroupMethodInfo a signature

Methods

overloadedMethod :: MethodProxy GestureUngroupMethodInfo a -> signature -> s

gestureUngroup

Arguments

:: (HasCallStack, MonadIO m, IsGesture a)

=> a

gesture: a Gesture

-> m ()

Separates gesture into an isolated group.

Since: 3.14

Properties

nPoints

data GestureNPointsPropertyInfo

Instances

AttrInfo GestureNPointsPropertyInfo

Associated Types

type AttrAllowedOps GestureNPointsPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint GestureNPointsPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint GestureNPointsPropertyInfo :: * -> Constraint

type AttrGetType GestureNPointsPropertyInfo :: *

type AttrLabel GestureNPointsPropertyInfo :: Symbol

type AttrOrigin GestureNPointsPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint GestureNPointsPropertyInfo o => Proxy * GestureNPointsPropertyInfo -> o -> IO (AttrGetType GestureNPointsPropertyInfo)

attrSet :: (AttrBaseTypeConstraint GestureNPointsPropertyInfo o, AttrSetTypeConstraint GestureNPointsPropertyInfo b) => Proxy * GestureNPointsPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint GestureNPointsPropertyInfo o => Proxy * GestureNPointsPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint GestureNPointsPropertyInfo o, AttrSetTypeConstraint GestureNPointsPropertyInfo b) => Proxy * GestureNPointsPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin GestureNPointsPropertyInfo

type AttrOrigin GestureNPointsPropertyInfo = Gesture

type AttrLabel GestureNPointsPropertyInfo

type AttrLabel GestureNPointsPropertyInfo = "n-points"

type AttrGetType GestureNPointsPropertyInfo

type AttrGetType GestureNPointsPropertyInfo = Word32

type AttrBaseTypeConstraint GestureNPointsPropertyInfo

type AttrBaseTypeConstraint GestureNPointsPropertyInfo = IsGesture

type AttrSetTypeConstraint GestureNPointsPropertyInfo

type AttrSetTypeConstraint GestureNPointsPropertyInfo = * ~ Word32

type AttrAllowedOps GestureNPointsPropertyInfo

type AttrAllowedOps GestureNPointsPropertyInfo = (:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag))

constructGestureNPoints :: IsGesture o => Word32 -> IO (GValueConstruct o)

gestureNPoints :: AttrLabelProxy "nPoints"

getGestureNPoints :: (MonadIO m, IsGesture o) => o -> m Word32

window

data GestureWindowPropertyInfo

Instances

AttrInfo GestureWindowPropertyInfo

Associated Types

type AttrAllowedOps GestureWindowPropertyInfo :: [AttrOpTag]

type AttrSetTypeConstraint GestureWindowPropertyInfo :: * -> Constraint

type AttrBaseTypeConstraint GestureWindowPropertyInfo :: * -> Constraint

type AttrGetType GestureWindowPropertyInfo :: *

type AttrLabel GestureWindowPropertyInfo :: Symbol

type AttrOrigin GestureWindowPropertyInfo :: *

Methods

attrGet :: AttrBaseTypeConstraint GestureWindowPropertyInfo o => Proxy * GestureWindowPropertyInfo -> o -> IO (AttrGetType GestureWindowPropertyInfo)

attrSet :: (AttrBaseTypeConstraint GestureWindowPropertyInfo o, AttrSetTypeConstraint GestureWindowPropertyInfo b) => Proxy * GestureWindowPropertyInfo -> o -> b -> IO ()

attrClear :: AttrBaseTypeConstraint GestureWindowPropertyInfo o => Proxy * GestureWindowPropertyInfo -> o -> IO ()

attrConstruct :: (AttrBaseTypeConstraint GestureWindowPropertyInfo o, AttrSetTypeConstraint GestureWindowPropertyInfo b) => Proxy * GestureWindowPropertyInfo -> b -> IO (GValueConstruct o)

type AttrOrigin GestureWindowPropertyInfo

type AttrOrigin GestureWindowPropertyInfo = Gesture

type AttrLabel GestureWindowPropertyInfo

type AttrLabel GestureWindowPropertyInfo = "window"

type AttrGetType GestureWindowPropertyInfo

type AttrGetType GestureWindowPropertyInfo = Maybe Window

type AttrBaseTypeConstraint GestureWindowPropertyInfo

type AttrBaseTypeConstraint GestureWindowPropertyInfo = IsGesture

type AttrSetTypeConstraint GestureWindowPropertyInfo

type AttrSetTypeConstraint GestureWindowPropertyInfo = IsWindow

type AttrAllowedOps GestureWindowPropertyInfo

type AttrAllowedOps GestureWindowPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))))

clearGestureWindow :: (MonadIO m, IsGesture o) => o -> m ()

constructGestureWindow :: (IsGesture o, IsWindow a) => a -> IO (GValueConstruct o)

gestureWindow :: AttrLabelProxy "window"

getGestureWindow :: (MonadIO m, IsGesture o) => o -> m (Maybe Window)

setGestureWindow :: (MonadIO m, IsGesture o, IsWindow a) => o -> a -> m ()

Signals

begin

type C_GestureBeginCallback = Ptr () -> Ptr EventSequence -> Ptr () -> IO ()

type GestureBeginCallback = EventSequence -> IO ()

data GestureBeginSignalInfo

Instances

SignalInfo GestureBeginSignalInfo

Associated Types

type HaskellCallbackType GestureBeginSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o GestureBeginSignalInfo -> o -> HaskellCallbackType GestureBeginSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType GestureBeginSignalInfo

type HaskellCallbackType GestureBeginSignalInfo = GestureBeginCallback

afterGestureBegin :: (GObject a, MonadIO m) => a -> GestureBeginCallback -> m SignalHandlerId

genClosure_GestureBegin :: GestureBeginCallback -> IO Closure

mk_GestureBeginCallback :: C_GestureBeginCallback -> IO (FunPtr C_GestureBeginCallback)

noGestureBeginCallback :: Maybe GestureBeginCallback

onGestureBegin :: (GObject a, MonadIO m) => a -> GestureBeginCallback -> m SignalHandlerId

wrap_GestureBeginCallback :: GestureBeginCallback -> Ptr () -> Ptr EventSequence -> Ptr () -> IO ()

cancel

type C_GestureCancelCallback = Ptr () -> Ptr EventSequence -> Ptr () -> IO ()

type GestureCancelCallback = EventSequence -> IO ()

data GestureCancelSignalInfo

Instances

SignalInfo GestureCancelSignalInfo

Associated Types

type HaskellCallbackType GestureCancelSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o GestureCancelSignalInfo -> o -> HaskellCallbackType GestureCancelSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType GestureCancelSignalInfo

type HaskellCallbackType GestureCancelSignalInfo = GestureCancelCallback

afterGestureCancel :: (GObject a, MonadIO m) => a -> GestureCancelCallback -> m SignalHandlerId

genClosure_GestureCancel :: GestureCancelCallback -> IO Closure

mk_GestureCancelCallback :: C_GestureCancelCallback -> IO (FunPtr C_GestureCancelCallback)

noGestureCancelCallback :: Maybe GestureCancelCallback

onGestureCancel :: (GObject a, MonadIO m) => a -> GestureCancelCallback -> m SignalHandlerId

wrap_GestureCancelCallback :: GestureCancelCallback -> Ptr () -> Ptr EventSequence -> Ptr () -> IO ()

end

type C_GestureEndCallback = Ptr () -> Ptr EventSequence -> Ptr () -> IO ()

type GestureEndCallback = EventSequence -> IO ()

data GestureEndSignalInfo

Instances

SignalInfo GestureEndSignalInfo

Associated Types

type HaskellCallbackType GestureEndSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o GestureEndSignalInfo -> o -> HaskellCallbackType GestureEndSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType GestureEndSignalInfo

type HaskellCallbackType GestureEndSignalInfo = GestureEndCallback

afterGestureEnd :: (GObject a, MonadIO m) => a -> GestureEndCallback -> m SignalHandlerId

genClosure_GestureEnd :: GestureEndCallback -> IO Closure

mk_GestureEndCallback :: C_GestureEndCallback -> IO (FunPtr C_GestureEndCallback)

noGestureEndCallback :: Maybe GestureEndCallback

onGestureEnd :: (GObject a, MonadIO m) => a -> GestureEndCallback -> m SignalHandlerId

wrap_GestureEndCallback :: GestureEndCallback -> Ptr () -> Ptr EventSequence -> Ptr () -> IO ()

sequenceStateChanged

type C_GestureSequenceStateChangedCallback = Ptr () -> Ptr EventSequence -> CUInt -> Ptr () -> IO ()

type GestureSequenceStateChangedCallback = EventSequence -> EventSequenceState -> IO ()

data GestureSequenceStateChangedSignalInfo

Instances

SignalInfo GestureSequenceStateChangedSignalInfo

Associated Types

type HaskellCallbackType GestureSequenceStateChangedSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o GestureSequenceStateChangedSignalInfo -> o -> HaskellCallbackType GestureSequenceStateChangedSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType GestureSequenceStateChangedSignalInfo

type HaskellCallbackType GestureSequenceStateChangedSignalInfo = GestureSequenceStateChangedCallback

afterGestureSequenceStateChanged :: (GObject a, MonadIO m) => a -> GestureSequenceStateChangedCallback -> m SignalHandlerId

genClosure_GestureSequenceStateChanged :: GestureSequenceStateChangedCallback -> IO Closure

mk_GestureSequenceStateChangedCallback :: C_GestureSequenceStateChangedCallback -> IO (FunPtr C_GestureSequenceStateChangedCallback)

noGestureSequenceStateChangedCallback :: Maybe GestureSequenceStateChangedCallback

onGestureSequenceStateChanged :: (GObject a, MonadIO m) => a -> GestureSequenceStateChangedCallback -> m SignalHandlerId

wrap_GestureSequenceStateChangedCallback :: GestureSequenceStateChangedCallback -> Ptr () -> Ptr EventSequence -> CUInt -> Ptr () -> IO ()

update

type C_GestureUpdateCallback = Ptr () -> Ptr EventSequence -> Ptr () -> IO ()

type GestureUpdateCallback = EventSequence -> IO ()

data GestureUpdateSignalInfo

Instances

SignalInfo GestureUpdateSignalInfo

Associated Types

type HaskellCallbackType GestureUpdateSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o GestureUpdateSignalInfo -> o -> HaskellCallbackType GestureUpdateSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType GestureUpdateSignalInfo

type HaskellCallbackType GestureUpdateSignalInfo = GestureUpdateCallback

afterGestureUpdate :: (GObject a, MonadIO m) => a -> GestureUpdateCallback -> m SignalHandlerId

genClosure_GestureUpdate :: GestureUpdateCallback -> IO Closure

mk_GestureUpdateCallback :: C_GestureUpdateCallback -> IO (FunPtr C_GestureUpdateCallback)

noGestureUpdateCallback :: Maybe GestureUpdateCallback

onGestureUpdate :: (GObject a, MonadIO m) => a -> GestureUpdateCallback -> m SignalHandlerId

wrap_GestureUpdateCallback :: GestureUpdateCallback -> Ptr () -> Ptr EventSequence -> Ptr () -> IO ()