{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) 'GI.Gtk.Objects.GesturePan.GesturePan' is a 'GI.Gtk.Objects.Gesture.Gesture' implementation able to recognize pan gestures, those are drags that are locked to happen along one axis. The axis that a 'GI.Gtk.Objects.GesturePan.GesturePan' handles is defined at construct time, and can be changed through 'GI.Gtk.Objects.GesturePan.gesturePanSetOrientation'. When the gesture starts to be recognized, 'GI.Gtk.Objects.GesturePan.GesturePan' will attempt to determine as early as possible whether the sequence is moving in the expected direction, and denying the sequence if this does not happen. Once a panning gesture along the expected axis is recognized, the 'GI.Gtk.Objects.GesturePan.GesturePan'::@/pan/@ signal will be emitted as input events are received, containing the offset in the given axis. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gtk.Objects.GesturePan ( -- * Exported types GesturePan(..) , IsGesturePan , toGesturePan , noGesturePan , -- * Methods -- ** getOrientation #method:getOrientation# #if ENABLE_OVERLOADING GesturePanGetOrientationMethodInfo , #endif gesturePanGetOrientation , -- ** new #method:new# gesturePanNew , -- ** setOrientation #method:setOrientation# #if ENABLE_OVERLOADING GesturePanSetOrientationMethodInfo , #endif gesturePanSetOrientation , -- * Properties -- ** orientation #attr:orientation# {- | The expected orientation of pan gestures. /Since: 3.14/ -} #if ENABLE_OVERLOADING GesturePanOrientationPropertyInfo , #endif constructGesturePanOrientation , #if ENABLE_OVERLOADING gesturePanOrientation , #endif getGesturePanOrientation , setGesturePanOrientation , -- * Signals -- ** pan #signal:pan# C_GesturePanPanCallback , GesturePanPanCallback , #if ENABLE_OVERLOADING GesturePanPanSignalInfo , #endif afterGesturePanPan , genClosure_GesturePanPan , mk_GesturePanPanCallback , noGesturePanPanCallback , onGesturePanPan , wrap_GesturePanPanCallback , ) where import Data.GI.Base.ShortPrelude import qualified Data.GI.Base.ShortPrelude as SP import qualified Data.GI.Base.Overloading as O import qualified Prelude as P import qualified Data.GI.Base.Attributes as GI.Attributes import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr import qualified Data.GI.Base.GClosure as B.GClosure import qualified Data.GI.Base.GError as B.GError import qualified Data.GI.Base.GVariant as B.GVariant import qualified Data.GI.Base.GValue as B.GValue import qualified Data.GI.Base.GParamSpec as B.GParamSpec import qualified Data.GI.Base.CallStack as B.CallStack import qualified Data.GI.Base.Properties as B.Properties import qualified Data.Text as T import qualified Data.ByteString.Char8 as B import qualified Data.Map as Map import qualified Foreign.Ptr as FP import qualified GHC.OverloadedLabels as OL import qualified GI.GObject.Objects.Object as GObject.Object import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums import {-# SOURCE #-} qualified GI.Gtk.Objects.EventController as Gtk.EventController import {-# SOURCE #-} qualified GI.Gtk.Objects.Gesture as Gtk.Gesture import {-# SOURCE #-} qualified GI.Gtk.Objects.GestureDrag as Gtk.GestureDrag import {-# SOURCE #-} qualified GI.Gtk.Objects.GestureSingle as Gtk.GestureSingle import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget -- | Memory-managed wrapper type. newtype GesturePan = GesturePan (ManagedPtr GesturePan) foreign import ccall "gtk_gesture_pan_get_type" c_gtk_gesture_pan_get_type :: IO GType instance GObject GesturePan where gobjectType = c_gtk_gesture_pan_get_type -- | Type class for types which can be safely cast to `GesturePan`, for instance with `toGesturePan`. class (GObject o, O.IsDescendantOf GesturePan o) => IsGesturePan o instance (GObject o, O.IsDescendantOf GesturePan o) => IsGesturePan o instance O.HasParentTypes GesturePan type instance O.ParentTypes GesturePan = '[Gtk.GestureDrag.GestureDrag, Gtk.GestureSingle.GestureSingle, Gtk.Gesture.Gesture, Gtk.EventController.EventController, GObject.Object.Object] -- | Cast to `GesturePan`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toGesturePan :: (MonadIO m, IsGesturePan o) => o -> m GesturePan toGesturePan = liftIO . unsafeCastTo GesturePan -- | A convenience alias for `Nothing` :: `Maybe` `GesturePan`. noGesturePan :: Maybe GesturePan noGesturePan = Nothing #if ENABLE_OVERLOADING type family ResolveGesturePanMethod (t :: Symbol) (o :: *) :: * where ResolveGesturePanMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveGesturePanMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveGesturePanMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveGesturePanMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveGesturePanMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveGesturePanMethod "group" o = Gtk.Gesture.GestureGroupMethodInfo ResolveGesturePanMethod "handleEvent" o = Gtk.EventController.EventControllerHandleEventMethodInfo ResolveGesturePanMethod "handlesSequence" o = Gtk.Gesture.GestureHandlesSequenceMethodInfo ResolveGesturePanMethod "isActive" o = Gtk.Gesture.GestureIsActiveMethodInfo ResolveGesturePanMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveGesturePanMethod "isGroupedWith" o = Gtk.Gesture.GestureIsGroupedWithMethodInfo ResolveGesturePanMethod "isRecognized" o = Gtk.Gesture.GestureIsRecognizedMethodInfo ResolveGesturePanMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveGesturePanMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveGesturePanMethod "ref" o = GObject.Object.ObjectRefMethodInfo ResolveGesturePanMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveGesturePanMethod "reset" o = Gtk.EventController.EventControllerResetMethodInfo ResolveGesturePanMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveGesturePanMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveGesturePanMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveGesturePanMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveGesturePanMethod "ungroup" o = Gtk.Gesture.GestureUngroupMethodInfo ResolveGesturePanMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo ResolveGesturePanMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveGesturePanMethod "getBoundingBox" o = Gtk.Gesture.GestureGetBoundingBoxMethodInfo ResolveGesturePanMethod "getBoundingBoxCenter" o = Gtk.Gesture.GestureGetBoundingBoxCenterMethodInfo ResolveGesturePanMethod "getButton" o = Gtk.GestureSingle.GestureSingleGetButtonMethodInfo ResolveGesturePanMethod "getCurrentButton" o = Gtk.GestureSingle.GestureSingleGetCurrentButtonMethodInfo ResolveGesturePanMethod "getCurrentSequence" o = Gtk.GestureSingle.GestureSingleGetCurrentSequenceMethodInfo ResolveGesturePanMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveGesturePanMethod "getDevice" o = Gtk.Gesture.GestureGetDeviceMethodInfo ResolveGesturePanMethod "getExclusive" o = Gtk.GestureSingle.GestureSingleGetExclusiveMethodInfo ResolveGesturePanMethod "getGroup" o = Gtk.Gesture.GestureGetGroupMethodInfo ResolveGesturePanMethod "getLastEvent" o = Gtk.Gesture.GestureGetLastEventMethodInfo ResolveGesturePanMethod "getLastUpdatedSequence" o = Gtk.Gesture.GestureGetLastUpdatedSequenceMethodInfo ResolveGesturePanMethod "getOffset" o = Gtk.GestureDrag.GestureDragGetOffsetMethodInfo ResolveGesturePanMethod "getOrientation" o = GesturePanGetOrientationMethodInfo ResolveGesturePanMethod "getPoint" o = Gtk.Gesture.GestureGetPointMethodInfo ResolveGesturePanMethod "getPropagationPhase" o = Gtk.EventController.EventControllerGetPropagationPhaseMethodInfo ResolveGesturePanMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveGesturePanMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveGesturePanMethod "getSequenceState" o = Gtk.Gesture.GestureGetSequenceStateMethodInfo ResolveGesturePanMethod "getSequences" o = Gtk.Gesture.GestureGetSequencesMethodInfo ResolveGesturePanMethod "getStartPoint" o = Gtk.GestureDrag.GestureDragGetStartPointMethodInfo ResolveGesturePanMethod "getTouchOnly" o = Gtk.GestureSingle.GestureSingleGetTouchOnlyMethodInfo ResolveGesturePanMethod "getWidget" o = Gtk.EventController.EventControllerGetWidgetMethodInfo ResolveGesturePanMethod "getWindow" o = Gtk.Gesture.GestureGetWindowMethodInfo ResolveGesturePanMethod "setButton" o = Gtk.GestureSingle.GestureSingleSetButtonMethodInfo ResolveGesturePanMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveGesturePanMethod "setExclusive" o = Gtk.GestureSingle.GestureSingleSetExclusiveMethodInfo ResolveGesturePanMethod "setOrientation" o = GesturePanSetOrientationMethodInfo ResolveGesturePanMethod "setPropagationPhase" o = Gtk.EventController.EventControllerSetPropagationPhaseMethodInfo ResolveGesturePanMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveGesturePanMethod "setSequenceState" o = Gtk.Gesture.GestureSetSequenceStateMethodInfo ResolveGesturePanMethod "setState" o = Gtk.Gesture.GestureSetStateMethodInfo ResolveGesturePanMethod "setTouchOnly" o = Gtk.GestureSingle.GestureSingleSetTouchOnlyMethodInfo ResolveGesturePanMethod "setWindow" o = Gtk.Gesture.GestureSetWindowMethodInfo ResolveGesturePanMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveGesturePanMethod t GesturePan, O.MethodInfo info GesturePan p) => OL.IsLabel t (GesturePan -> p) where #if MIN_VERSION_base(4,10,0) fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif -- signal GesturePan::pan {- | This signal is emitted once a panning gesture along the expected axis is detected. /Since: 3.14/ -} type GesturePanPanCallback = Gtk.Enums.PanDirection {- ^ /@direction@/: current direction of the pan gesture -} -> Double {- ^ /@offset@/: Offset along the gesture orientation -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `GesturePanPanCallback`@. noGesturePanPanCallback :: Maybe GesturePanPanCallback noGesturePanPanCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_GesturePanPanCallback = Ptr () -> -- object CUInt -> CDouble -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_GesturePanPanCallback`. foreign import ccall "wrapper" mk_GesturePanPanCallback :: C_GesturePanPanCallback -> IO (FunPtr C_GesturePanPanCallback) -- | Wrap the callback into a `GClosure`. genClosure_GesturePanPan :: MonadIO m => GesturePanPanCallback -> m (GClosure C_GesturePanPanCallback) genClosure_GesturePanPan cb = liftIO $ do let cb' = wrap_GesturePanPanCallback cb mk_GesturePanPanCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `GesturePanPanCallback` into a `C_GesturePanPanCallback`. wrap_GesturePanPanCallback :: GesturePanPanCallback -> C_GesturePanPanCallback wrap_GesturePanPanCallback _cb _ direction offset _ = do let direction' = (toEnum . fromIntegral) direction let offset' = realToFrac offset _cb direction' offset' {- | Connect a signal handler for the “@pan@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' gesturePan #pan callback @ -} onGesturePanPan :: (IsGesturePan a, MonadIO m) => a -> GesturePanPanCallback -> m SignalHandlerId onGesturePanPan obj cb = liftIO $ do let cb' = wrap_GesturePanPanCallback cb cb'' <- mk_GesturePanPanCallback cb' connectSignalFunPtr obj "pan" cb'' SignalConnectBefore {- | Connect a signal handler for the “@pan@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' gesturePan #pan callback @ -} afterGesturePanPan :: (IsGesturePan a, MonadIO m) => a -> GesturePanPanCallback -> m SignalHandlerId afterGesturePanPan obj cb = liftIO $ do let cb' = wrap_GesturePanPanCallback cb cb'' <- mk_GesturePanPanCallback cb' connectSignalFunPtr obj "pan" cb'' SignalConnectAfter -- VVV Prop "orientation" -- Type: TInterface (Name {namespace = "Gtk", name = "Orientation"}) -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Just False,Just False) {- | Get the value of the “@orientation@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' gesturePan #orientation @ -} getGesturePanOrientation :: (MonadIO m, IsGesturePan o) => o -> m Gtk.Enums.Orientation getGesturePanOrientation obj = liftIO $ B.Properties.getObjectPropertyEnum obj "orientation" {- | Set the value of the “@orientation@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' gesturePan [ #orientation 'Data.GI.Base.Attributes.:=' value ] @ -} setGesturePanOrientation :: (MonadIO m, IsGesturePan o) => o -> Gtk.Enums.Orientation -> m () setGesturePanOrientation obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "orientation" val {- | Construct a `GValueConstruct` with valid value for the “@orientation@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructGesturePanOrientation :: (IsGesturePan o) => Gtk.Enums.Orientation -> IO (GValueConstruct o) constructGesturePanOrientation val = B.Properties.constructObjectPropertyEnum "orientation" val #if ENABLE_OVERLOADING data GesturePanOrientationPropertyInfo instance AttrInfo GesturePanOrientationPropertyInfo where type AttrAllowedOps GesturePanOrientationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint GesturePanOrientationPropertyInfo = (~) Gtk.Enums.Orientation type AttrBaseTypeConstraint GesturePanOrientationPropertyInfo = IsGesturePan type AttrGetType GesturePanOrientationPropertyInfo = Gtk.Enums.Orientation type AttrLabel GesturePanOrientationPropertyInfo = "orientation" type AttrOrigin GesturePanOrientationPropertyInfo = GesturePan attrGet _ = getGesturePanOrientation attrSet _ = setGesturePanOrientation attrConstruct _ = constructGesturePanOrientation attrClear _ = undefined #endif #if ENABLE_OVERLOADING instance O.HasAttributeList GesturePan type instance O.AttributeList GesturePan = GesturePanAttributeList type GesturePanAttributeList = ('[ '("button", Gtk.GestureSingle.GestureSingleButtonPropertyInfo), '("exclusive", Gtk.GestureSingle.GestureSingleExclusivePropertyInfo), '("nPoints", Gtk.Gesture.GestureNPointsPropertyInfo), '("orientation", GesturePanOrientationPropertyInfo), '("propagationPhase", Gtk.EventController.EventControllerPropagationPhasePropertyInfo), '("touchOnly", Gtk.GestureSingle.GestureSingleTouchOnlyPropertyInfo), '("widget", Gtk.EventController.EventControllerWidgetPropertyInfo), '("window", Gtk.Gesture.GestureWindowPropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING gesturePanOrientation :: AttrLabelProxy "orientation" gesturePanOrientation = AttrLabelProxy #endif #if ENABLE_OVERLOADING data GesturePanPanSignalInfo instance SignalInfo GesturePanPanSignalInfo where type HaskellCallbackType GesturePanPanSignalInfo = GesturePanPanCallback connectSignal _ obj cb connectMode = do let cb' = wrap_GesturePanPanCallback cb cb'' <- mk_GesturePanPanCallback cb' connectSignalFunPtr obj "pan" cb'' connectMode type instance O.SignalList GesturePan = GesturePanSignalList type GesturePanSignalList = ('[ '("begin", Gtk.Gesture.GestureBeginSignalInfo), '("cancel", Gtk.Gesture.GestureCancelSignalInfo), '("dragBegin", Gtk.GestureDrag.GestureDragDragBeginSignalInfo), '("dragEnd", Gtk.GestureDrag.GestureDragDragEndSignalInfo), '("dragUpdate", Gtk.GestureDrag.GestureDragDragUpdateSignalInfo), '("end", Gtk.Gesture.GestureEndSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pan", GesturePanPanSignalInfo), '("sequenceStateChanged", Gtk.Gesture.GestureSequenceStateChangedSignalInfo), '("update", Gtk.Gesture.GestureUpdateSignalInfo)] :: [(Symbol, *)]) #endif -- method GesturePan::new -- method type : Constructor -- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "orientation", argType = TInterface (Name {namespace = "Gtk", name = "Orientation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "expected orientation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gtk", name = "GesturePan"})) -- throws : False -- Skip return : False foreign import ccall "gtk_gesture_pan_new" gtk_gesture_pan_new :: Ptr Gtk.Widget.Widget -> -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"}) CUInt -> -- orientation : TInterface (Name {namespace = "Gtk", name = "Orientation"}) IO (Ptr GesturePan) {- | Returns a newly created 'GI.Gtk.Objects.Gesture.Gesture' that recognizes pan gestures. /Since: 3.14/ -} gesturePanNew :: (B.CallStack.HasCallStack, MonadIO m, Gtk.Widget.IsWidget a) => a {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -} -> Gtk.Enums.Orientation {- ^ /@orientation@/: expected orientation -} -> m GesturePan {- ^ __Returns:__ a newly created 'GI.Gtk.Objects.GesturePan.GesturePan' -} gesturePanNew widget orientation = liftIO $ do widget' <- unsafeManagedPtrCastPtr widget let orientation' = (fromIntegral . fromEnum) orientation result <- gtk_gesture_pan_new widget' orientation' checkUnexpectedReturnNULL "gesturePanNew" result result' <- (wrapObject GesturePan) result touchManagedPtr widget return result' #if ENABLE_OVERLOADING #endif -- method GesturePan::get_orientation -- method type : OrdinaryMethod -- Args : [Arg {argCName = "gesture", argType = TInterface (Name {namespace = "Gtk", name = "GesturePan"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkGesturePan", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Orientation"})) -- throws : False -- Skip return : False foreign import ccall "gtk_gesture_pan_get_orientation" gtk_gesture_pan_get_orientation :: Ptr GesturePan -> -- gesture : TInterface (Name {namespace = "Gtk", name = "GesturePan"}) IO CUInt {- | Returns the orientation of the pan gestures that this /@gesture@/ expects. /Since: 3.14/ -} gesturePanGetOrientation :: (B.CallStack.HasCallStack, MonadIO m, IsGesturePan a) => a {- ^ /@gesture@/: A 'GI.Gtk.Objects.GesturePan.GesturePan' -} -> m Gtk.Enums.Orientation {- ^ __Returns:__ the expected orientation for pan gestures -} gesturePanGetOrientation gesture = liftIO $ do gesture' <- unsafeManagedPtrCastPtr gesture result <- gtk_gesture_pan_get_orientation gesture' let result' = (toEnum . fromIntegral) result touchManagedPtr gesture return result' #if ENABLE_OVERLOADING data GesturePanGetOrientationMethodInfo instance (signature ~ (m Gtk.Enums.Orientation), MonadIO m, IsGesturePan a) => O.MethodInfo GesturePanGetOrientationMethodInfo a signature where overloadedMethod _ = gesturePanGetOrientation #endif -- method GesturePan::set_orientation -- method type : OrdinaryMethod -- Args : [Arg {argCName = "gesture", argType = TInterface (Name {namespace = "Gtk", name = "GesturePan"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkGesturePan", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "orientation", argType = TInterface (Name {namespace = "Gtk", name = "Orientation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "expected orientation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gtk_gesture_pan_set_orientation" gtk_gesture_pan_set_orientation :: Ptr GesturePan -> -- gesture : TInterface (Name {namespace = "Gtk", name = "GesturePan"}) CUInt -> -- orientation : TInterface (Name {namespace = "Gtk", name = "Orientation"}) IO () {- | Sets the orientation to be expected on pan gestures. /Since: 3.14/ -} gesturePanSetOrientation :: (B.CallStack.HasCallStack, MonadIO m, IsGesturePan a) => a {- ^ /@gesture@/: A 'GI.Gtk.Objects.GesturePan.GesturePan' -} -> Gtk.Enums.Orientation {- ^ /@orientation@/: expected orientation -} -> m () gesturePanSetOrientation gesture orientation = liftIO $ do gesture' <- unsafeManagedPtrCastPtr gesture let orientation' = (fromIntegral . fromEnum) orientation gtk_gesture_pan_set_orientation gesture' orientation' touchManagedPtr gesture return () #if ENABLE_OVERLOADING data GesturePanSetOrientationMethodInfo instance (signature ~ (Gtk.Enums.Orientation -> m ()), MonadIO m, IsGesturePan a) => O.MethodInfo GesturePanSetOrientationMethodInfo a signature where overloadedMethod _ = gesturePanSetOrientation #endif