GesturePan.hs


{- |
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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> 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