{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The t'GI.Clutter.Objects.PanAction.PanAction' structure contains
-- only private data and should be accessed using the provided API
-- 
-- /Since: 1.12/

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Clutter.Objects.PanAction
    ( 

-- * Exported types
    PanAction(..)                           ,
    IsPanAction                             ,
    toPanAction                             ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [cancel]("GI.Clutter.Objects.GestureAction#g:method:cancel"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccelerationFactor]("GI.Clutter.Objects.PanAction#g:method:getAccelerationFactor"), [getActor]("GI.Clutter.Objects.ActorMeta#g:method:getActor"), [getConstrainedMotionDelta]("GI.Clutter.Objects.PanAction#g:method:getConstrainedMotionDelta"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDeceleration]("GI.Clutter.Objects.PanAction#g:method:getDeceleration"), [getDevice]("GI.Clutter.Objects.GestureAction#g:method:getDevice"), [getEnabled]("GI.Clutter.Objects.ActorMeta#g:method:getEnabled"), [getInterpolate]("GI.Clutter.Objects.PanAction#g:method:getInterpolate"), [getInterpolatedCoords]("GI.Clutter.Objects.PanAction#g:method:getInterpolatedCoords"), [getInterpolatedDelta]("GI.Clutter.Objects.PanAction#g:method:getInterpolatedDelta"), [getLastEvent]("GI.Clutter.Objects.GestureAction#g:method:getLastEvent"), [getMotionCoords]("GI.Clutter.Objects.PanAction#g:method:getMotionCoords"), [getMotionDelta]("GI.Clutter.Objects.PanAction#g:method:getMotionDelta"), [getNCurrentPoints]("GI.Clutter.Objects.GestureAction#g:method:getNCurrentPoints"), [getNTouchPoints]("GI.Clutter.Objects.GestureAction#g:method:getNTouchPoints"), [getName]("GI.Clutter.Objects.ActorMeta#g:method:getName"), [getPanAxis]("GI.Clutter.Objects.PanAction#g:method:getPanAxis"), [getPressCoords]("GI.Clutter.Objects.GestureAction#g:method:getPressCoords"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getReleaseCoords]("GI.Clutter.Objects.GestureAction#g:method:getReleaseCoords"), [getSequence]("GI.Clutter.Objects.GestureAction#g:method:getSequence"), [getThresholdTriggerDistance]("GI.Clutter.Objects.GestureAction#g:method:getThresholdTriggerDistance"), [getThresholdTriggerEdge]("GI.Clutter.Objects.GestureAction#g:method:getThresholdTriggerEdge"), [getThresholdTriggerEgde]("GI.Clutter.Objects.GestureAction#g:method:getThresholdTriggerEgde"), [getVelocity]("GI.Clutter.Objects.GestureAction#g:method:getVelocity").
-- 
-- ==== Setters
-- [setAccelerationFactor]("GI.Clutter.Objects.PanAction#g:method:setAccelerationFactor"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDeceleration]("GI.Clutter.Objects.PanAction#g:method:setDeceleration"), [setEnabled]("GI.Clutter.Objects.ActorMeta#g:method:setEnabled"), [setInterpolate]("GI.Clutter.Objects.PanAction#g:method:setInterpolate"), [setNTouchPoints]("GI.Clutter.Objects.GestureAction#g:method:setNTouchPoints"), [setName]("GI.Clutter.Objects.ActorMeta#g:method:setName"), [setPanAxis]("GI.Clutter.Objects.PanAction#g:method:setPanAxis"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setThresholdTriggerDistance]("GI.Clutter.Objects.GestureAction#g:method:setThresholdTriggerDistance"), [setThresholdTriggerEdge]("GI.Clutter.Objects.GestureAction#g:method:setThresholdTriggerEdge").

#if defined(ENABLE_OVERLOADING)
    ResolvePanActionMethod                  ,
#endif

-- ** getAccelerationFactor #method:getAccelerationFactor#

#if defined(ENABLE_OVERLOADING)
    PanActionGetAccelerationFactorMethodInfo,
#endif
    panActionGetAccelerationFactor          ,


-- ** getConstrainedMotionDelta #method:getConstrainedMotionDelta#

#if defined(ENABLE_OVERLOADING)
    PanActionGetConstrainedMotionDeltaMethodInfo,
#endif
    panActionGetConstrainedMotionDelta      ,


-- ** getDeceleration #method:getDeceleration#

#if defined(ENABLE_OVERLOADING)
    PanActionGetDecelerationMethodInfo      ,
#endif
    panActionGetDeceleration                ,


-- ** getInterpolate #method:getInterpolate#

#if defined(ENABLE_OVERLOADING)
    PanActionGetInterpolateMethodInfo       ,
#endif
    panActionGetInterpolate                 ,


-- ** getInterpolatedCoords #method:getInterpolatedCoords#

#if defined(ENABLE_OVERLOADING)
    PanActionGetInterpolatedCoordsMethodInfo,
#endif
    panActionGetInterpolatedCoords          ,


-- ** getInterpolatedDelta #method:getInterpolatedDelta#

#if defined(ENABLE_OVERLOADING)
    PanActionGetInterpolatedDeltaMethodInfo ,
#endif
    panActionGetInterpolatedDelta           ,


-- ** getMotionCoords #method:getMotionCoords#

#if defined(ENABLE_OVERLOADING)
    PanActionGetMotionCoordsMethodInfo      ,
#endif
    panActionGetMotionCoords                ,


-- ** getMotionDelta #method:getMotionDelta#

#if defined(ENABLE_OVERLOADING)
    PanActionGetMotionDeltaMethodInfo       ,
#endif
    panActionGetMotionDelta                 ,


-- ** getPanAxis #method:getPanAxis#

#if defined(ENABLE_OVERLOADING)
    PanActionGetPanAxisMethodInfo           ,
#endif
    panActionGetPanAxis                     ,


-- ** new #method:new#

    panActionNew                            ,


-- ** setAccelerationFactor #method:setAccelerationFactor#

#if defined(ENABLE_OVERLOADING)
    PanActionSetAccelerationFactorMethodInfo,
#endif
    panActionSetAccelerationFactor          ,


-- ** setDeceleration #method:setDeceleration#

#if defined(ENABLE_OVERLOADING)
    PanActionSetDecelerationMethodInfo      ,
#endif
    panActionSetDeceleration                ,


-- ** setInterpolate #method:setInterpolate#

#if defined(ENABLE_OVERLOADING)
    PanActionSetInterpolateMethodInfo       ,
#endif
    panActionSetInterpolate                 ,


-- ** setPanAxis #method:setPanAxis#

#if defined(ENABLE_OVERLOADING)
    PanActionSetPanAxisMethodInfo           ,
#endif
    panActionSetPanAxis                     ,




 -- * Properties


-- ** accelerationFactor #attr:accelerationFactor#
-- | The initial acceleration factor
-- 
-- The kinetic momentum measured at the time of releasing the pointer will
-- be multiplied by the factor specified by this property before being used
-- to generate interpolated [pan](#g:signal:pan) events.
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    PanActionAccelerationFactorPropertyInfo ,
#endif
    constructPanActionAccelerationFactor    ,
    getPanActionAccelerationFactor          ,
#if defined(ENABLE_OVERLOADING)
    panActionAccelerationFactor             ,
#endif
    setPanActionAccelerationFactor          ,


-- ** deceleration #attr:deceleration#
-- | The rate at which the interpolated panning will decelerate in
-- 
-- t'GI.Clutter.Objects.PanAction.PanAction' will emit interpolated [pan](#g:signal:pan) events with decreasing
-- scroll deltas, using the rate specified by this property.
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    PanActionDecelerationPropertyInfo       ,
#endif
    constructPanActionDeceleration          ,
    getPanActionDeceleration                ,
#if defined(ENABLE_OVERLOADING)
    panActionDeceleration                   ,
#endif
    setPanActionDeceleration                ,


-- ** interpolate #attr:interpolate#
-- | Whether interpolated events emission is enabled.
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    PanActionInterpolatePropertyInfo        ,
#endif
    constructPanActionInterpolate           ,
    getPanActionInterpolate                 ,
#if defined(ENABLE_OVERLOADING)
    panActionInterpolate                    ,
#endif
    setPanActionInterpolate                 ,


-- ** panAxis #attr:panAxis#
-- | Constraints the panning action to the specified axis
-- 
-- /Since: 1.12/

#if defined(ENABLE_OVERLOADING)
    PanActionPanAxisPropertyInfo            ,
#endif
    constructPanActionPanAxis               ,
    getPanActionPanAxis                     ,
#if defined(ENABLE_OVERLOADING)
    panActionPanAxis                        ,
#endif
    setPanActionPanAxis                     ,




 -- * Signals


-- ** pan #signal:pan#

    PanActionPanCallback                    ,
#if defined(ENABLE_OVERLOADING)
    PanActionPanSignalInfo                  ,
#endif
    afterPanActionPan                       ,
    onPanActionPan                          ,


-- ** panStopped #signal:panStopped#

    PanActionPanStoppedCallback             ,
#if defined(ENABLE_OVERLOADING)
    PanActionPanStoppedSignalInfo           ,
#endif
    afterPanActionPanStopped                ,
    onPanActionPanStopped                   ,




    ) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
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 GHC.Records as R

import {-# SOURCE #-} qualified GI.Clutter.Enums as Clutter.Enums
import {-# SOURCE #-} qualified GI.Clutter.Objects.Action as Clutter.Action
import {-# SOURCE #-} qualified GI.Clutter.Objects.Actor as Clutter.Actor
import {-# SOURCE #-} qualified GI.Clutter.Objects.ActorMeta as Clutter.ActorMeta
import {-# SOURCE #-} qualified GI.Clutter.Objects.GestureAction as Clutter.GestureAction
import qualified GI.GObject.Objects.Object as GObject.Object

-- | Memory-managed wrapper type.
newtype PanAction = PanAction (SP.ManagedPtr PanAction)
    deriving (PanAction -> PanAction -> Bool
(PanAction -> PanAction -> Bool)
-> (PanAction -> PanAction -> Bool) -> Eq PanAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PanAction -> PanAction -> Bool
== :: PanAction -> PanAction -> Bool
$c/= :: PanAction -> PanAction -> Bool
/= :: PanAction -> PanAction -> Bool
Eq)

instance SP.ManagedPtrNewtype PanAction where
    toManagedPtr :: PanAction -> ManagedPtr PanAction
toManagedPtr (PanAction ManagedPtr PanAction
p) = ManagedPtr PanAction
p

foreign import ccall "clutter_pan_action_get_type"
    c_clutter_pan_action_get_type :: IO B.Types.GType

instance B.Types.TypedObject PanAction where
    glibType :: IO GType
glibType = IO GType
c_clutter_pan_action_get_type

instance B.Types.GObject PanAction

-- | Type class for types which can be safely cast to `PanAction`, for instance with `toPanAction`.
class (SP.GObject o, O.IsDescendantOf PanAction o) => IsPanAction o
instance (SP.GObject o, O.IsDescendantOf PanAction o) => IsPanAction o

instance O.HasParentTypes PanAction
type instance O.ParentTypes PanAction = '[Clutter.GestureAction.GestureAction, Clutter.Action.Action, Clutter.ActorMeta.ActorMeta, GObject.Object.Object]

-- | Cast to `PanAction`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toPanAction :: (MIO.MonadIO m, IsPanAction o) => o -> m PanAction
toPanAction :: forall (m :: * -> *) o.
(MonadIO m, IsPanAction o) =>
o -> m PanAction
toPanAction = IO PanAction -> m PanAction
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO PanAction -> m PanAction)
-> (o -> IO PanAction) -> o -> m PanAction
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr PanAction -> PanAction) -> o -> IO PanAction
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr PanAction -> PanAction
PanAction

-- | Convert 'PanAction' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe PanAction) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_pan_action_get_type
    gvalueSet_ :: Ptr GValue -> Maybe PanAction -> IO ()
gvalueSet_ Ptr GValue
gv Maybe PanAction
P.Nothing = Ptr GValue -> Ptr PanAction -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr PanAction
forall a. Ptr a
FP.nullPtr :: FP.Ptr PanAction)
    gvalueSet_ Ptr GValue
gv (P.Just PanAction
obj) = PanAction -> (Ptr PanAction -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr PanAction
obj (Ptr GValue -> Ptr PanAction -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe PanAction)
gvalueGet_ Ptr GValue
gv = do
        Ptr PanAction
ptr <- Ptr GValue -> IO (Ptr PanAction)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr PanAction)
        if Ptr PanAction
ptr Ptr PanAction -> Ptr PanAction -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr PanAction
forall a. Ptr a
FP.nullPtr
        then PanAction -> Maybe PanAction
forall a. a -> Maybe a
P.Just (PanAction -> Maybe PanAction)
-> IO PanAction -> IO (Maybe PanAction)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr PanAction -> PanAction)
-> Ptr PanAction -> IO PanAction
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr PanAction -> PanAction
PanAction Ptr PanAction
ptr
        else Maybe PanAction -> IO (Maybe PanAction)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PanAction
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolvePanActionMethod (t :: Symbol) (o :: *) :: * where
    ResolvePanActionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolvePanActionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolvePanActionMethod "cancel" o = Clutter.GestureAction.GestureActionCancelMethodInfo
    ResolvePanActionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolvePanActionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolvePanActionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolvePanActionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolvePanActionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolvePanActionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolvePanActionMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolvePanActionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolvePanActionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolvePanActionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolvePanActionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolvePanActionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolvePanActionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolvePanActionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolvePanActionMethod "getAccelerationFactor" o = PanActionGetAccelerationFactorMethodInfo
    ResolvePanActionMethod "getActor" o = Clutter.ActorMeta.ActorMetaGetActorMethodInfo
    ResolvePanActionMethod "getConstrainedMotionDelta" o = PanActionGetConstrainedMotionDeltaMethodInfo
    ResolvePanActionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolvePanActionMethod "getDeceleration" o = PanActionGetDecelerationMethodInfo
    ResolvePanActionMethod "getDevice" o = Clutter.GestureAction.GestureActionGetDeviceMethodInfo
    ResolvePanActionMethod "getEnabled" o = Clutter.ActorMeta.ActorMetaGetEnabledMethodInfo
    ResolvePanActionMethod "getInterpolate" o = PanActionGetInterpolateMethodInfo
    ResolvePanActionMethod "getInterpolatedCoords" o = PanActionGetInterpolatedCoordsMethodInfo
    ResolvePanActionMethod "getInterpolatedDelta" o = PanActionGetInterpolatedDeltaMethodInfo
    ResolvePanActionMethod "getLastEvent" o = Clutter.GestureAction.GestureActionGetLastEventMethodInfo
    ResolvePanActionMethod "getMotionCoords" o = PanActionGetMotionCoordsMethodInfo
    ResolvePanActionMethod "getMotionDelta" o = PanActionGetMotionDeltaMethodInfo
    ResolvePanActionMethod "getNCurrentPoints" o = Clutter.GestureAction.GestureActionGetNCurrentPointsMethodInfo
    ResolvePanActionMethod "getNTouchPoints" o = Clutter.GestureAction.GestureActionGetNTouchPointsMethodInfo
    ResolvePanActionMethod "getName" o = Clutter.ActorMeta.ActorMetaGetNameMethodInfo
    ResolvePanActionMethod "getPanAxis" o = PanActionGetPanAxisMethodInfo
    ResolvePanActionMethod "getPressCoords" o = Clutter.GestureAction.GestureActionGetPressCoordsMethodInfo
    ResolvePanActionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolvePanActionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolvePanActionMethod "getReleaseCoords" o = Clutter.GestureAction.GestureActionGetReleaseCoordsMethodInfo
    ResolvePanActionMethod "getSequence" o = Clutter.GestureAction.GestureActionGetSequenceMethodInfo
    ResolvePanActionMethod "getThresholdTriggerDistance" o = Clutter.GestureAction.GestureActionGetThresholdTriggerDistanceMethodInfo
    ResolvePanActionMethod "getThresholdTriggerEdge" o = Clutter.GestureAction.GestureActionGetThresholdTriggerEdgeMethodInfo
    ResolvePanActionMethod "getThresholdTriggerEgde" o = Clutter.GestureAction.GestureActionGetThresholdTriggerEgdeMethodInfo
    ResolvePanActionMethod "getVelocity" o = Clutter.GestureAction.GestureActionGetVelocityMethodInfo
    ResolvePanActionMethod "setAccelerationFactor" o = PanActionSetAccelerationFactorMethodInfo
    ResolvePanActionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolvePanActionMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolvePanActionMethod "setDeceleration" o = PanActionSetDecelerationMethodInfo
    ResolvePanActionMethod "setEnabled" o = Clutter.ActorMeta.ActorMetaSetEnabledMethodInfo
    ResolvePanActionMethod "setInterpolate" o = PanActionSetInterpolateMethodInfo
    ResolvePanActionMethod "setNTouchPoints" o = Clutter.GestureAction.GestureActionSetNTouchPointsMethodInfo
    ResolvePanActionMethod "setName" o = Clutter.ActorMeta.ActorMetaSetNameMethodInfo
    ResolvePanActionMethod "setPanAxis" o = PanActionSetPanAxisMethodInfo
    ResolvePanActionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolvePanActionMethod "setThresholdTriggerDistance" o = Clutter.GestureAction.GestureActionSetThresholdTriggerDistanceMethodInfo
    ResolvePanActionMethod "setThresholdTriggerEdge" o = Clutter.GestureAction.GestureActionSetThresholdTriggerEdgeMethodInfo
    ResolvePanActionMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolvePanActionMethod t PanAction, O.OverloadedMethod info PanAction p) => OL.IsLabel t (PanAction -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolvePanActionMethod t PanAction, O.OverloadedMethod info PanAction p, R.HasField t PanAction p) => R.HasField t PanAction p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolvePanActionMethod t PanAction, O.OverloadedMethodInfo info PanAction) => OL.IsLabel t (O.MethodProxy info PanAction) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- signal PanAction::pan
-- | The [pan](#g:signal:pan) signal is emitted to keep track of the motion during
-- a pan gesture. /@isInterpolated@/ is set to 'P.True' during the
-- interpolation phase of the pan, after the drag has ended and
-- the :interpolate property was set to 'P.True'.
-- 
-- /Since: 1.12/
type PanActionPanCallback =
    Clutter.Actor.Actor
    -- ^ /@actor@/: the t'GI.Clutter.Objects.Actor.Actor' attached to the /@action@/
    -> Bool
    -- ^ /@isInterpolated@/: if the event is the result of interpolating
    --                   the motion velocity at the end of the drag
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if the pan should continue, and 'P.False' if
    --   the pan should be cancelled.

type C_PanActionPanCallback =
    Ptr PanAction ->                        -- object
    Ptr Clutter.Actor.Actor ->
    CInt ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_PanActionPanCallback`.
foreign import ccall "wrapper"
    mk_PanActionPanCallback :: C_PanActionPanCallback -> IO (FunPtr C_PanActionPanCallback)

wrap_PanActionPanCallback :: 
    GObject a => (a -> PanActionPanCallback) ->
    C_PanActionPanCallback
wrap_PanActionPanCallback :: forall a.
GObject a =>
(a -> PanActionPanCallback) -> C_PanActionPanCallback
wrap_PanActionPanCallback a -> PanActionPanCallback
gi'cb Ptr PanAction
gi'selfPtr Ptr Actor
actor CInt
isInterpolated Ptr ()
_ = do
    Actor
actor' <- ((ManagedPtr Actor -> Actor) -> Ptr Actor -> IO Actor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Actor -> Actor
Clutter.Actor.Actor) Ptr Actor
actor
    let isInterpolated' :: Bool
isInterpolated' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
isInterpolated
    Bool
result <- Ptr PanAction -> (PanAction -> IO Bool) -> IO Bool
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr PanAction
gi'selfPtr ((PanAction -> IO Bool) -> IO Bool)
-> (PanAction -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \PanAction
gi'self -> a -> PanActionPanCallback
gi'cb (PanAction -> a
forall a b. Coercible a b => a -> b
Coerce.coerce PanAction
gi'self)  Actor
actor' Bool
isInterpolated'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [pan](#signal: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' panAction #pan callback
-- @
-- 
-- 
onPanActionPan :: (IsPanAction a, MonadIO m) => a -> ((?self :: a) => PanActionPanCallback) -> m SignalHandlerId
onPanActionPan :: forall a (m :: * -> *).
(IsPanAction a, MonadIO m) =>
a -> ((?self::a) => PanActionPanCallback) -> m SignalHandlerId
onPanActionPan a
obj (?self::a) => PanActionPanCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> PanActionPanCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => PanActionPanCallback
PanActionPanCallback
cb
    let wrapped' :: C_PanActionPanCallback
wrapped' = (a -> PanActionPanCallback) -> C_PanActionPanCallback
forall a.
GObject a =>
(a -> PanActionPanCallback) -> C_PanActionPanCallback
wrap_PanActionPanCallback a -> PanActionPanCallback
wrapped
    FunPtr C_PanActionPanCallback
wrapped'' <- C_PanActionPanCallback -> IO (FunPtr C_PanActionPanCallback)
mk_PanActionPanCallback C_PanActionPanCallback
wrapped'
    a
-> Text
-> FunPtr C_PanActionPanCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"pan" FunPtr C_PanActionPanCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [pan](#signal: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' panAction #pan callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterPanActionPan :: (IsPanAction a, MonadIO m) => a -> ((?self :: a) => PanActionPanCallback) -> m SignalHandlerId
afterPanActionPan :: forall a (m :: * -> *).
(IsPanAction a, MonadIO m) =>
a -> ((?self::a) => PanActionPanCallback) -> m SignalHandlerId
afterPanActionPan a
obj (?self::a) => PanActionPanCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> PanActionPanCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => PanActionPanCallback
PanActionPanCallback
cb
    let wrapped' :: C_PanActionPanCallback
wrapped' = (a -> PanActionPanCallback) -> C_PanActionPanCallback
forall a.
GObject a =>
(a -> PanActionPanCallback) -> C_PanActionPanCallback
wrap_PanActionPanCallback a -> PanActionPanCallback
wrapped
    FunPtr C_PanActionPanCallback
wrapped'' <- C_PanActionPanCallback -> IO (FunPtr C_PanActionPanCallback)
mk_PanActionPanCallback C_PanActionPanCallback
wrapped'
    a
-> Text
-> FunPtr C_PanActionPanCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"pan" FunPtr C_PanActionPanCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data PanActionPanSignalInfo
instance SignalInfo PanActionPanSignalInfo where
    type HaskellCallbackType PanActionPanSignalInfo = PanActionPanCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanActionPanCallback cb
        cb'' <- mk_PanActionPanCallback cb'
        connectSignalFunPtr obj "pan" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PanAction::pan"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PanAction.html#g:signal:pan"})

#endif

-- signal PanAction::pan-stopped
-- | The [panStopped](#g:signal:panStopped) signal is emitted at the end of the interpolation
-- phase of the pan action, only when :interpolate is set to 'P.True'.
-- 
-- /Since: 1.12/
type PanActionPanStoppedCallback =
    Clutter.Actor.Actor
    -- ^ /@actor@/: the t'GI.Clutter.Objects.Actor.Actor' attached to the /@action@/
    -> IO ()

type C_PanActionPanStoppedCallback =
    Ptr PanAction ->                        -- object
    Ptr Clutter.Actor.Actor ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_PanActionPanStoppedCallback`.
foreign import ccall "wrapper"
    mk_PanActionPanStoppedCallback :: C_PanActionPanStoppedCallback -> IO (FunPtr C_PanActionPanStoppedCallback)

wrap_PanActionPanStoppedCallback :: 
    GObject a => (a -> PanActionPanStoppedCallback) ->
    C_PanActionPanStoppedCallback
wrap_PanActionPanStoppedCallback :: forall a.
GObject a =>
(a -> PanActionPanStoppedCallback) -> C_PanActionPanStoppedCallback
wrap_PanActionPanStoppedCallback a -> PanActionPanStoppedCallback
gi'cb Ptr PanAction
gi'selfPtr Ptr Actor
actor Ptr ()
_ = do
    Actor
actor' <- ((ManagedPtr Actor -> Actor) -> Ptr Actor -> IO Actor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Actor -> Actor
Clutter.Actor.Actor) Ptr Actor
actor
    Ptr PanAction -> (PanAction -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr PanAction
gi'selfPtr ((PanAction -> IO ()) -> IO ()) -> (PanAction -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \PanAction
gi'self -> a -> PanActionPanStoppedCallback
gi'cb (PanAction -> a
forall a b. Coercible a b => a -> b
Coerce.coerce PanAction
gi'self)  Actor
actor'


-- | Connect a signal handler for the [panStopped](#signal:panStopped) 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' panAction #panStopped callback
-- @
-- 
-- 
onPanActionPanStopped :: (IsPanAction a, MonadIO m) => a -> ((?self :: a) => PanActionPanStoppedCallback) -> m SignalHandlerId
onPanActionPanStopped :: forall a (m :: * -> *).
(IsPanAction a, MonadIO m) =>
a
-> ((?self::a) => PanActionPanStoppedCallback) -> m SignalHandlerId
onPanActionPanStopped a
obj (?self::a) => PanActionPanStoppedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> PanActionPanStoppedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => PanActionPanStoppedCallback
PanActionPanStoppedCallback
cb
    let wrapped' :: C_PanActionPanStoppedCallback
wrapped' = (a -> PanActionPanStoppedCallback) -> C_PanActionPanStoppedCallback
forall a.
GObject a =>
(a -> PanActionPanStoppedCallback) -> C_PanActionPanStoppedCallback
wrap_PanActionPanStoppedCallback a -> PanActionPanStoppedCallback
wrapped
    FunPtr C_PanActionPanStoppedCallback
wrapped'' <- C_PanActionPanStoppedCallback
-> IO (FunPtr C_PanActionPanStoppedCallback)
mk_PanActionPanStoppedCallback C_PanActionPanStoppedCallback
wrapped'
    a
-> Text
-> FunPtr C_PanActionPanStoppedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"pan-stopped" FunPtr C_PanActionPanStoppedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [panStopped](#signal:panStopped) 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' panAction #panStopped callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterPanActionPanStopped :: (IsPanAction a, MonadIO m) => a -> ((?self :: a) => PanActionPanStoppedCallback) -> m SignalHandlerId
afterPanActionPanStopped :: forall a (m :: * -> *).
(IsPanAction a, MonadIO m) =>
a
-> ((?self::a) => PanActionPanStoppedCallback) -> m SignalHandlerId
afterPanActionPanStopped a
obj (?self::a) => PanActionPanStoppedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> PanActionPanStoppedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => PanActionPanStoppedCallback
PanActionPanStoppedCallback
cb
    let wrapped' :: C_PanActionPanStoppedCallback
wrapped' = (a -> PanActionPanStoppedCallback) -> C_PanActionPanStoppedCallback
forall a.
GObject a =>
(a -> PanActionPanStoppedCallback) -> C_PanActionPanStoppedCallback
wrap_PanActionPanStoppedCallback a -> PanActionPanStoppedCallback
wrapped
    FunPtr C_PanActionPanStoppedCallback
wrapped'' <- C_PanActionPanStoppedCallback
-> IO (FunPtr C_PanActionPanStoppedCallback)
mk_PanActionPanStoppedCallback C_PanActionPanStoppedCallback
wrapped'
    a
-> Text
-> FunPtr C_PanActionPanStoppedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"pan-stopped" FunPtr C_PanActionPanStoppedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data PanActionPanStoppedSignalInfo
instance SignalInfo PanActionPanStoppedSignalInfo where
    type HaskellCallbackType PanActionPanStoppedSignalInfo = PanActionPanStoppedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanActionPanStoppedCallback cb
        cb'' <- mk_PanActionPanStoppedCallback cb'
        connectSignalFunPtr obj "pan-stopped" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PanAction::pan-stopped"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PanAction.html#g:signal:panStopped"})

#endif

-- VVV Prop "acceleration-factor"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@acceleration-factor@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' panAction #accelerationFactor
-- @
getPanActionAccelerationFactor :: (MonadIO m, IsPanAction o) => o -> m Double
getPanActionAccelerationFactor :: forall (m :: * -> *) o. (MonadIO m, IsPanAction o) => o -> m Double
getPanActionAccelerationFactor o
obj = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj String
"acceleration-factor"

-- | Set the value of the “@acceleration-factor@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' panAction [ #accelerationFactor 'Data.GI.Base.Attributes.:=' value ]
-- @
setPanActionAccelerationFactor :: (MonadIO m, IsPanAction o) => o -> Double -> m ()
setPanActionAccelerationFactor :: forall (m :: * -> *) o.
(MonadIO m, IsPanAction o) =>
o -> Double -> m ()
setPanActionAccelerationFactor o
obj Double
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"acceleration-factor" Double
val

-- | Construct a `GValueConstruct` with valid value for the “@acceleration-factor@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPanActionAccelerationFactor :: (IsPanAction o, MIO.MonadIO m) => Double -> m (GValueConstruct o)
constructPanActionAccelerationFactor :: forall o (m :: * -> *).
(IsPanAction o, MonadIO m) =>
Double -> m (GValueConstruct o)
constructPanActionAccelerationFactor Double
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Double -> IO (GValueConstruct o)
forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble String
"acceleration-factor" Double
val

#if defined(ENABLE_OVERLOADING)
data PanActionAccelerationFactorPropertyInfo
instance AttrInfo PanActionAccelerationFactorPropertyInfo where
    type AttrAllowedOps PanActionAccelerationFactorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint PanActionAccelerationFactorPropertyInfo = IsPanAction
    type AttrSetTypeConstraint PanActionAccelerationFactorPropertyInfo = (~) Double
    type AttrTransferTypeConstraint PanActionAccelerationFactorPropertyInfo = (~) Double
    type AttrTransferType PanActionAccelerationFactorPropertyInfo = Double
    type AttrGetType PanActionAccelerationFactorPropertyInfo = Double
    type AttrLabel PanActionAccelerationFactorPropertyInfo = "acceleration-factor"
    type AttrOrigin PanActionAccelerationFactorPropertyInfo = PanAction
    attrGet = getPanActionAccelerationFactor
    attrSet = setPanActionAccelerationFactor
    attrTransfer _ v = do
        return v
    attrConstruct = constructPanActionAccelerationFactor
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PanAction.accelerationFactor"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PanAction.html#g:attr:accelerationFactor"
        })
#endif

-- VVV Prop "deceleration"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@deceleration@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' panAction #deceleration
-- @
getPanActionDeceleration :: (MonadIO m, IsPanAction o) => o -> m Double
getPanActionDeceleration :: forall (m :: * -> *) o. (MonadIO m, IsPanAction o) => o -> m Double
getPanActionDeceleration o
obj = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj String
"deceleration"

-- | Set the value of the “@deceleration@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' panAction [ #deceleration 'Data.GI.Base.Attributes.:=' value ]
-- @
setPanActionDeceleration :: (MonadIO m, IsPanAction o) => o -> Double -> m ()
setPanActionDeceleration :: forall (m :: * -> *) o.
(MonadIO m, IsPanAction o) =>
o -> Double -> m ()
setPanActionDeceleration o
obj Double
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"deceleration" Double
val

-- | Construct a `GValueConstruct` with valid value for the “@deceleration@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPanActionDeceleration :: (IsPanAction o, MIO.MonadIO m) => Double -> m (GValueConstruct o)
constructPanActionDeceleration :: forall o (m :: * -> *).
(IsPanAction o, MonadIO m) =>
Double -> m (GValueConstruct o)
constructPanActionDeceleration Double
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Double -> IO (GValueConstruct o)
forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble String
"deceleration" Double
val

#if defined(ENABLE_OVERLOADING)
data PanActionDecelerationPropertyInfo
instance AttrInfo PanActionDecelerationPropertyInfo where
    type AttrAllowedOps PanActionDecelerationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint PanActionDecelerationPropertyInfo = IsPanAction
    type AttrSetTypeConstraint PanActionDecelerationPropertyInfo = (~) Double
    type AttrTransferTypeConstraint PanActionDecelerationPropertyInfo = (~) Double
    type AttrTransferType PanActionDecelerationPropertyInfo = Double
    type AttrGetType PanActionDecelerationPropertyInfo = Double
    type AttrLabel PanActionDecelerationPropertyInfo = "deceleration"
    type AttrOrigin PanActionDecelerationPropertyInfo = PanAction
    attrGet = getPanActionDeceleration
    attrSet = setPanActionDeceleration
    attrTransfer _ v = do
        return v
    attrConstruct = constructPanActionDeceleration
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PanAction.deceleration"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PanAction.html#g:attr:deceleration"
        })
#endif

-- VVV Prop "interpolate"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@interpolate@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' panAction #interpolate
-- @
getPanActionInterpolate :: (MonadIO m, IsPanAction o) => o -> m Bool
getPanActionInterpolate :: forall (m :: * -> *) o. (MonadIO m, IsPanAction o) => o -> m Bool
getPanActionInterpolate o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"interpolate"

-- | Set the value of the “@interpolate@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' panAction [ #interpolate 'Data.GI.Base.Attributes.:=' value ]
-- @
setPanActionInterpolate :: (MonadIO m, IsPanAction o) => o -> Bool -> m ()
setPanActionInterpolate :: forall (m :: * -> *) o.
(MonadIO m, IsPanAction o) =>
o -> Bool -> m ()
setPanActionInterpolate o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"interpolate" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@interpolate@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPanActionInterpolate :: (IsPanAction o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructPanActionInterpolate :: forall o (m :: * -> *).
(IsPanAction o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructPanActionInterpolate Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"interpolate" Bool
val

#if defined(ENABLE_OVERLOADING)
data PanActionInterpolatePropertyInfo
instance AttrInfo PanActionInterpolatePropertyInfo where
    type AttrAllowedOps PanActionInterpolatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint PanActionInterpolatePropertyInfo = IsPanAction
    type AttrSetTypeConstraint PanActionInterpolatePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint PanActionInterpolatePropertyInfo = (~) Bool
    type AttrTransferType PanActionInterpolatePropertyInfo = Bool
    type AttrGetType PanActionInterpolatePropertyInfo = Bool
    type AttrLabel PanActionInterpolatePropertyInfo = "interpolate"
    type AttrOrigin PanActionInterpolatePropertyInfo = PanAction
    attrGet = getPanActionInterpolate
    attrSet = setPanActionInterpolate
    attrTransfer _ v = do
        return v
    attrConstruct = constructPanActionInterpolate
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PanAction.interpolate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PanAction.html#g:attr:interpolate"
        })
#endif

-- VVV Prop "pan-axis"
   -- Type: TInterface (Name {namespace = "Clutter", name = "PanAxis"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@pan-axis@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' panAction #panAxis
-- @
getPanActionPanAxis :: (MonadIO m, IsPanAction o) => o -> m Clutter.Enums.PanAxis
getPanActionPanAxis :: forall (m :: * -> *) o.
(MonadIO m, IsPanAction o) =>
o -> m PanAxis
getPanActionPanAxis o
obj = IO PanAxis -> m PanAxis
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO PanAxis -> m PanAxis) -> IO PanAxis -> m PanAxis
forall a b. (a -> b) -> a -> b
$ o -> String -> IO PanAxis
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"pan-axis"

-- | Set the value of the “@pan-axis@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' panAction [ #panAxis 'Data.GI.Base.Attributes.:=' value ]
-- @
setPanActionPanAxis :: (MonadIO m, IsPanAction o) => o -> Clutter.Enums.PanAxis -> m ()
setPanActionPanAxis :: forall (m :: * -> *) o.
(MonadIO m, IsPanAction o) =>
o -> PanAxis -> m ()
setPanActionPanAxis o
obj PanAxis
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> PanAxis -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"pan-axis" PanAxis
val

-- | Construct a `GValueConstruct` with valid value for the “@pan-axis@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPanActionPanAxis :: (IsPanAction o, MIO.MonadIO m) => Clutter.Enums.PanAxis -> m (GValueConstruct o)
constructPanActionPanAxis :: forall o (m :: * -> *).
(IsPanAction o, MonadIO m) =>
PanAxis -> m (GValueConstruct o)
constructPanActionPanAxis PanAxis
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> PanAxis -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"pan-axis" PanAxis
val

#if defined(ENABLE_OVERLOADING)
data PanActionPanAxisPropertyInfo
instance AttrInfo PanActionPanAxisPropertyInfo where
    type AttrAllowedOps PanActionPanAxisPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint PanActionPanAxisPropertyInfo = IsPanAction
    type AttrSetTypeConstraint PanActionPanAxisPropertyInfo = (~) Clutter.Enums.PanAxis
    type AttrTransferTypeConstraint PanActionPanAxisPropertyInfo = (~) Clutter.Enums.PanAxis
    type AttrTransferType PanActionPanAxisPropertyInfo = Clutter.Enums.PanAxis
    type AttrGetType PanActionPanAxisPropertyInfo = Clutter.Enums.PanAxis
    type AttrLabel PanActionPanAxisPropertyInfo = "pan-axis"
    type AttrOrigin PanActionPanAxisPropertyInfo = PanAction
    attrGet = getPanActionPanAxis
    attrSet = setPanActionPanAxis
    attrTransfer _ v = do
        return v
    attrConstruct = constructPanActionPanAxis
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PanAction.panAxis"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PanAction.html#g:attr:panAxis"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList PanAction
type instance O.AttributeList PanAction = PanActionAttributeList
type PanActionAttributeList = ('[ '("accelerationFactor", PanActionAccelerationFactorPropertyInfo), '("actor", Clutter.ActorMeta.ActorMetaActorPropertyInfo), '("deceleration", PanActionDecelerationPropertyInfo), '("enabled", Clutter.ActorMeta.ActorMetaEnabledPropertyInfo), '("interpolate", PanActionInterpolatePropertyInfo), '("nTouchPoints", Clutter.GestureAction.GestureActionNTouchPointsPropertyInfo), '("name", Clutter.ActorMeta.ActorMetaNamePropertyInfo), '("panAxis", PanActionPanAxisPropertyInfo), '("thresholdTriggerDistanceX", Clutter.GestureAction.GestureActionThresholdTriggerDistanceXPropertyInfo), '("thresholdTriggerDistanceY", Clutter.GestureAction.GestureActionThresholdTriggerDistanceYPropertyInfo), '("thresholdTriggerEdge", Clutter.GestureAction.GestureActionThresholdTriggerEdgePropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
panActionAccelerationFactor :: AttrLabelProxy "accelerationFactor"
panActionAccelerationFactor = AttrLabelProxy

panActionDeceleration :: AttrLabelProxy "deceleration"
panActionDeceleration = AttrLabelProxy

panActionInterpolate :: AttrLabelProxy "interpolate"
panActionInterpolate = AttrLabelProxy

panActionPanAxis :: AttrLabelProxy "panAxis"
panActionPanAxis = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList PanAction = PanActionSignalList
type PanActionSignalList = ('[ '("gestureBegin", Clutter.GestureAction.GestureActionGestureBeginSignalInfo), '("gestureCancel", Clutter.GestureAction.GestureActionGestureCancelSignalInfo), '("gestureEnd", Clutter.GestureAction.GestureActionGestureEndSignalInfo), '("gestureProgress", Clutter.GestureAction.GestureActionGestureProgressSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pan", PanActionPanSignalInfo), '("panStopped", PanActionPanStoppedSignalInfo)] :: [(Symbol, *)])

#endif

-- method PanAction::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "PanAction" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_pan_action_new" clutter_pan_action_new :: 
    IO (Ptr PanAction)

-- | Creates a new t'GI.Clutter.Objects.PanAction.PanAction' instance
-- 
-- /Since: 1.12/
panActionNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m PanAction
    -- ^ __Returns:__ the newly created t'GI.Clutter.Objects.PanAction.PanAction'
panActionNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m PanAction
panActionNew  = IO PanAction -> m PanAction
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PanAction -> m PanAction) -> IO PanAction -> m PanAction
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanAction
result <- IO (Ptr PanAction)
clutter_pan_action_new
    Text -> Ptr PanAction -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"panActionNew" Ptr PanAction
result
    PanAction
result' <- ((ManagedPtr PanAction -> PanAction)
-> Ptr PanAction -> IO PanAction
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr PanAction -> PanAction
PanAction) Ptr PanAction
result
    PanAction -> IO PanAction
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return PanAction
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method PanAction::get_acceleration_factor
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "PanAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterPanAction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_pan_action_get_acceleration_factor" clutter_pan_action_get_acceleration_factor :: 
    Ptr PanAction ->                        -- self : TInterface (Name {namespace = "Clutter", name = "PanAction"})
    IO CDouble

-- | Retrieves the initial acceleration factor for interpolated [pan](#g:signal:pan) events.
-- 
-- /Since: 1.12/
panActionGetAccelerationFactor ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanAction a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.PanAction.PanAction'
    -> m Double
    -- ^ __Returns:__ The initial acceleration factor for interpolated events.
panActionGetAccelerationFactor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanAction a) =>
a -> m Double
panActionGetAccelerationFactor a
self = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanAction
self' <- a -> IO (Ptr PanAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CDouble
result <- Ptr PanAction -> IO CDouble
clutter_pan_action_get_acceleration_factor Ptr PanAction
self'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data PanActionGetAccelerationFactorMethodInfo
instance (signature ~ (m Double), MonadIO m, IsPanAction a) => O.OverloadedMethod PanActionGetAccelerationFactorMethodInfo a signature where
    overloadedMethod = panActionGetAccelerationFactor

instance O.OverloadedMethodInfo PanActionGetAccelerationFactorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PanAction.panActionGetAccelerationFactor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PanAction.html#v:panActionGetAccelerationFactor"
        })


#endif

-- method PanAction::get_constrained_motion_delta
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "PanAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterPanAction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "point"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the touch point index, with 0 being the first touch\n  point received by the action"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "delta_x"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the X delta"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "delta_y"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the Y delta"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_pan_action_get_constrained_motion_delta" clutter_pan_action_get_constrained_motion_delta :: 
    Ptr PanAction ->                        -- self : TInterface (Name {namespace = "Clutter", name = "PanAction"})
    Word32 ->                               -- point : TBasicType TUInt
    Ptr CFloat ->                           -- delta_x : TBasicType TFloat
    Ptr CFloat ->                           -- delta_y : TBasicType TFloat
    IO CFloat

-- | Retrieves the delta, in stage space, dependent on the current state
-- of the t'GI.Clutter.Objects.PanAction.PanAction', and respecting the constraint specified by the
-- [PanAction:panAxis]("GI.Clutter.Objects.PanAction#g:attr:panAxis") property.
-- 
-- /Since: 1.24/
panActionGetConstrainedMotionDelta ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanAction a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.PanAction.PanAction'
    -> Word32
    -- ^ /@point@/: the touch point index, with 0 being the first touch
    --   point received by the action
    -> m ((Float, Float, Float))
    -- ^ __Returns:__ the distance since last motion event
panActionGetConstrainedMotionDelta :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanAction a) =>
a -> Word32 -> m (Float, Float, Float)
panActionGetConstrainedMotionDelta a
self Word32
point = IO (Float, Float, Float) -> m (Float, Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float, Float) -> m (Float, Float, Float))
-> IO (Float, Float, Float) -> m (Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanAction
self' <- a -> IO (Ptr PanAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CFloat
deltaX <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
deltaY <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    CFloat
result <- Ptr PanAction -> Word32 -> Ptr CFloat -> Ptr CFloat -> IO CFloat
clutter_pan_action_get_constrained_motion_delta Ptr PanAction
self' Word32
point Ptr CFloat
deltaX Ptr CFloat
deltaY
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    CFloat
deltaX' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
deltaX
    let deltaX'' :: Float
deltaX'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
deltaX'
    CFloat
deltaY' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
deltaY
    let deltaY'' :: Float
deltaY'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
deltaY'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
deltaX
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
deltaY
    (Float, Float, Float) -> IO (Float, Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
result', Float
deltaX'', Float
deltaY'')

#if defined(ENABLE_OVERLOADING)
data PanActionGetConstrainedMotionDeltaMethodInfo
instance (signature ~ (Word32 -> m ((Float, Float, Float))), MonadIO m, IsPanAction a) => O.OverloadedMethod PanActionGetConstrainedMotionDeltaMethodInfo a signature where
    overloadedMethod = panActionGetConstrainedMotionDelta

instance O.OverloadedMethodInfo PanActionGetConstrainedMotionDeltaMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PanAction.panActionGetConstrainedMotionDelta",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PanAction.html#v:panActionGetConstrainedMotionDelta"
        })


#endif

-- method PanAction::get_deceleration
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "PanAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterPanAction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_pan_action_get_deceleration" clutter_pan_action_get_deceleration :: 
    Ptr PanAction ->                        -- self : TInterface (Name {namespace = "Clutter", name = "PanAction"})
    IO CDouble

-- | Retrieves the deceleration rate of interpolated [pan](#g:signal:pan) events.
-- 
-- /Since: 1.12/
panActionGetDeceleration ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanAction a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.PanAction.PanAction'
    -> m Double
    -- ^ __Returns:__ The deceleration rate of the interpolated events.
panActionGetDeceleration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanAction a) =>
a -> m Double
panActionGetDeceleration a
self = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanAction
self' <- a -> IO (Ptr PanAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CDouble
result <- Ptr PanAction -> IO CDouble
clutter_pan_action_get_deceleration Ptr PanAction
self'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data PanActionGetDecelerationMethodInfo
instance (signature ~ (m Double), MonadIO m, IsPanAction a) => O.OverloadedMethod PanActionGetDecelerationMethodInfo a signature where
    overloadedMethod = panActionGetDeceleration

instance O.OverloadedMethodInfo PanActionGetDecelerationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PanAction.panActionGetDeceleration",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PanAction.html#v:panActionGetDeceleration"
        })


#endif

-- method PanAction::get_interpolate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "PanAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterPanAction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_pan_action_get_interpolate" clutter_pan_action_get_interpolate :: 
    Ptr PanAction ->                        -- self : TInterface (Name {namespace = "Clutter", name = "PanAction"})
    IO CInt

-- | Checks if the action should emit [pan](#g:signal:pan) events even after releasing
-- the pointer during a panning gesture, to emulate some kind of
-- kinetic inertia.
-- 
-- /Since: 1.12/
panActionGetInterpolate ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanAction a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.PanAction.PanAction'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if interpolated events emission is active.
panActionGetInterpolate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanAction a) =>
a -> m Bool
panActionGetInterpolate a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanAction
self' <- a -> IO (Ptr PanAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr PanAction -> IO CInt
clutter_pan_action_get_interpolate Ptr PanAction
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data PanActionGetInterpolateMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPanAction a) => O.OverloadedMethod PanActionGetInterpolateMethodInfo a signature where
    overloadedMethod = panActionGetInterpolate

instance O.OverloadedMethodInfo PanActionGetInterpolateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PanAction.panActionGetInterpolate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PanAction.html#v:panActionGetInterpolate"
        })


#endif

-- method PanAction::get_interpolated_coords
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "PanAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterPanAction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "interpolated_x"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the latest\n  interpolated event's X coordinate"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "interpolated_y"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the latest\n  interpolated event's Y coordinate"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_pan_action_get_interpolated_coords" clutter_pan_action_get_interpolated_coords :: 
    Ptr PanAction ->                        -- self : TInterface (Name {namespace = "Clutter", name = "PanAction"})
    Ptr CFloat ->                           -- interpolated_x : TBasicType TFloat
    Ptr CFloat ->                           -- interpolated_y : TBasicType TFloat
    IO ()

-- | Retrieves the coordinates, in stage space, of the latest interpolated
-- event, analogous to 'GI.Clutter.Objects.GestureAction.gestureActionGetMotionCoords'.
-- 
-- /Since: 1.12/
panActionGetInterpolatedCoords ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanAction a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.PanAction.PanAction'
    -> m ((Float, Float))
panActionGetInterpolatedCoords :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanAction a) =>
a -> m (Float, Float)
panActionGetInterpolatedCoords a
self = IO (Float, Float) -> m (Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float) -> m (Float, Float))
-> IO (Float, Float) -> m (Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanAction
self' <- a -> IO (Ptr PanAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CFloat
interpolatedX <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
interpolatedY <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr PanAction -> Ptr CFloat -> Ptr CFloat -> IO ()
clutter_pan_action_get_interpolated_coords Ptr PanAction
self' Ptr CFloat
interpolatedX Ptr CFloat
interpolatedY
    CFloat
interpolatedX' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
interpolatedX
    let interpolatedX'' :: Float
interpolatedX'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
interpolatedX'
    CFloat
interpolatedY' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
interpolatedY
    let interpolatedY'' :: Float
interpolatedY'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
interpolatedY'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
interpolatedX
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
interpolatedY
    (Float, Float) -> IO (Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
interpolatedX'', Float
interpolatedY'')

#if defined(ENABLE_OVERLOADING)
data PanActionGetInterpolatedCoordsMethodInfo
instance (signature ~ (m ((Float, Float))), MonadIO m, IsPanAction a) => O.OverloadedMethod PanActionGetInterpolatedCoordsMethodInfo a signature where
    overloadedMethod = panActionGetInterpolatedCoords

instance O.OverloadedMethodInfo PanActionGetInterpolatedCoordsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PanAction.panActionGetInterpolatedCoords",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PanAction.html#v:panActionGetInterpolatedCoords"
        })


#endif

-- method PanAction::get_interpolated_delta
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "PanAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterPanAction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "delta_x"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the X delta since\n  the latest interpolated event"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "delta_y"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the Y delta since\n  the latest interpolated event"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_pan_action_get_interpolated_delta" clutter_pan_action_get_interpolated_delta :: 
    Ptr PanAction ->                        -- self : TInterface (Name {namespace = "Clutter", name = "PanAction"})
    Ptr CFloat ->                           -- delta_x : TBasicType TFloat
    Ptr CFloat ->                           -- delta_y : TBasicType TFloat
    IO CFloat

-- | Retrieves the delta, in stage space, since the latest interpolated
-- event, analogous to 'GI.Clutter.Objects.GestureAction.gestureActionGetMotionDelta'.
-- 
-- /Since: 1.12/
panActionGetInterpolatedDelta ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanAction a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.PanAction.PanAction'
    -> m ((Float, Float, Float))
    -- ^ __Returns:__ the distance since the latest interpolated event
panActionGetInterpolatedDelta :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanAction a) =>
a -> m (Float, Float, Float)
panActionGetInterpolatedDelta a
self = IO (Float, Float, Float) -> m (Float, Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float, Float) -> m (Float, Float, Float))
-> IO (Float, Float, Float) -> m (Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanAction
self' <- a -> IO (Ptr PanAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CFloat
deltaX <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
deltaY <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    CFloat
result <- Ptr PanAction -> Ptr CFloat -> Ptr CFloat -> IO CFloat
clutter_pan_action_get_interpolated_delta Ptr PanAction
self' Ptr CFloat
deltaX Ptr CFloat
deltaY
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    CFloat
deltaX' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
deltaX
    let deltaX'' :: Float
deltaX'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
deltaX'
    CFloat
deltaY' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
deltaY
    let deltaY'' :: Float
deltaY'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
deltaY'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
deltaX
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
deltaY
    (Float, Float, Float) -> IO (Float, Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
result', Float
deltaX'', Float
deltaY'')

#if defined(ENABLE_OVERLOADING)
data PanActionGetInterpolatedDeltaMethodInfo
instance (signature ~ (m ((Float, Float, Float))), MonadIO m, IsPanAction a) => O.OverloadedMethod PanActionGetInterpolatedDeltaMethodInfo a signature where
    overloadedMethod = panActionGetInterpolatedDelta

instance O.OverloadedMethodInfo PanActionGetInterpolatedDeltaMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PanAction.panActionGetInterpolatedDelta",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PanAction.html#v:panActionGetInterpolatedDelta"
        })


#endif

-- method PanAction::get_motion_coords
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "PanAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterPanAction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "point"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the touch point index, with 0 being the first touch\n  point received by the action"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "motion_x"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the X coordinate"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "motion_y"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the Y coordinate"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_pan_action_get_motion_coords" clutter_pan_action_get_motion_coords :: 
    Ptr PanAction ->                        -- self : TInterface (Name {namespace = "Clutter", name = "PanAction"})
    Word32 ->                               -- point : TBasicType TUInt
    Ptr CFloat ->                           -- motion_x : TBasicType TFloat
    Ptr CFloat ->                           -- motion_y : TBasicType TFloat
    IO ()

-- | Retrieves the coordinates, in stage space, dependent on the current state
-- of the t'GI.Clutter.Objects.PanAction.PanAction'. If it is inactive, both fields will be
-- set to 0. If it is panning by user action, the values will be equivalent
-- to those returned by 'GI.Clutter.Objects.GestureAction.gestureActionGetMotionCoords'.
-- If it is interpolating with some form of kinetic scrolling, the values
-- will be equivalent to those returned by
-- 'GI.Clutter.Objects.PanAction.panActionGetInterpolatedCoords'. This is a convenience
-- method designed to be used in replacement \"pan\" signal handlers.
-- 
-- /Since: 1.14/
panActionGetMotionCoords ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanAction a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.PanAction.PanAction'
    -> Word32
    -- ^ /@point@/: the touch point index, with 0 being the first touch
    --   point received by the action
    -> m ((Float, Float))
panActionGetMotionCoords :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanAction a) =>
a -> Word32 -> m (Float, Float)
panActionGetMotionCoords a
self Word32
point = IO (Float, Float) -> m (Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float) -> m (Float, Float))
-> IO (Float, Float) -> m (Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanAction
self' <- a -> IO (Ptr PanAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CFloat
motionX <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
motionY <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr PanAction -> Word32 -> Ptr CFloat -> Ptr CFloat -> IO ()
clutter_pan_action_get_motion_coords Ptr PanAction
self' Word32
point Ptr CFloat
motionX Ptr CFloat
motionY
    CFloat
motionX' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
motionX
    let motionX'' :: Float
motionX'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
motionX'
    CFloat
motionY' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
motionY
    let motionY'' :: Float
motionY'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
motionY'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
motionX
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
motionY
    (Float, Float) -> IO (Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
motionX'', Float
motionY'')

#if defined(ENABLE_OVERLOADING)
data PanActionGetMotionCoordsMethodInfo
instance (signature ~ (Word32 -> m ((Float, Float))), MonadIO m, IsPanAction a) => O.OverloadedMethod PanActionGetMotionCoordsMethodInfo a signature where
    overloadedMethod = panActionGetMotionCoords

instance O.OverloadedMethodInfo PanActionGetMotionCoordsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PanAction.panActionGetMotionCoords",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PanAction.html#v:panActionGetMotionCoords"
        })


#endif

-- method PanAction::get_motion_delta
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "PanAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterPanAction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "point"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the touch point index, with 0 being the first touch\n  point received by the action"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "delta_x"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the X delta"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "delta_y"
--           , argType = TBasicType TFloat
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the Y delta"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "clutter_pan_action_get_motion_delta" clutter_pan_action_get_motion_delta :: 
    Ptr PanAction ->                        -- self : TInterface (Name {namespace = "Clutter", name = "PanAction"})
    Word32 ->                               -- point : TBasicType TUInt
    Ptr CFloat ->                           -- delta_x : TBasicType TFloat
    Ptr CFloat ->                           -- delta_y : TBasicType TFloat
    IO CFloat

-- | Retrieves the delta, in stage space, dependent on the current state
-- of the t'GI.Clutter.Objects.PanAction.PanAction'. If it is inactive, both fields will be
-- set to 0. If it is panning by user action, the values will be equivalent
-- to those returned by 'GI.Clutter.Objects.GestureAction.gestureActionGetMotionDelta'.
-- If it is interpolating with some form of kinetic scrolling, the values
-- will be equivalent to those returned by
-- 'GI.Clutter.Objects.PanAction.panActionGetInterpolatedDelta'. This is a convenience
-- method designed to be used in replacement \"pan\" signal handlers.
-- 
-- /Since: 1.14/
panActionGetMotionDelta ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanAction a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.PanAction.PanAction'
    -> Word32
    -- ^ /@point@/: the touch point index, with 0 being the first touch
    --   point received by the action
    -> m ((Float, Float, Float))
panActionGetMotionDelta :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanAction a) =>
a -> Word32 -> m (Float, Float, Float)
panActionGetMotionDelta a
self Word32
point = IO (Float, Float, Float) -> m (Float, Float, Float)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float, Float) -> m (Float, Float, Float))
-> IO (Float, Float, Float) -> m (Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanAction
self' <- a -> IO (Ptr PanAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CFloat
deltaX <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    Ptr CFloat
deltaY <- IO (Ptr CFloat)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CFloat)
    CFloat
result <- Ptr PanAction -> Word32 -> Ptr CFloat -> Ptr CFloat -> IO CFloat
clutter_pan_action_get_motion_delta Ptr PanAction
self' Word32
point Ptr CFloat
deltaX Ptr CFloat
deltaY
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    CFloat
deltaX' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
deltaX
    let deltaX'' :: Float
deltaX'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
deltaX'
    CFloat
deltaY' <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek Ptr CFloat
deltaY
    let deltaY'' :: Float
deltaY'' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
deltaY'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
deltaX
    Ptr CFloat -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CFloat
deltaY
    (Float, Float, Float) -> IO (Float, Float, Float)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Float
result', Float
deltaX'', Float
deltaY'')

#if defined(ENABLE_OVERLOADING)
data PanActionGetMotionDeltaMethodInfo
instance (signature ~ (Word32 -> m ((Float, Float, Float))), MonadIO m, IsPanAction a) => O.OverloadedMethod PanActionGetMotionDeltaMethodInfo a signature where
    overloadedMethod = panActionGetMotionDelta

instance O.OverloadedMethodInfo PanActionGetMotionDeltaMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PanAction.panActionGetMotionDelta",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PanAction.html#v:panActionGetMotionDelta"
        })


#endif

-- method PanAction::get_pan_axis
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "PanAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterPanAction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Clutter" , name = "PanAxis" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_pan_action_get_pan_axis" clutter_pan_action_get_pan_axis :: 
    Ptr PanAction ->                        -- self : TInterface (Name {namespace = "Clutter", name = "PanAction"})
    IO CUInt

-- | Retrieves the axis constraint set by 'GI.Clutter.Objects.PanAction.panActionSetPanAxis'
-- 
-- /Since: 1.12/
panActionGetPanAxis ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanAction a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.PanAction.PanAction'
    -> m Clutter.Enums.PanAxis
    -- ^ __Returns:__ the axis constraint
panActionGetPanAxis :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanAction a) =>
a -> m PanAxis
panActionGetPanAxis a
self = IO PanAxis -> m PanAxis
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PanAxis -> m PanAxis) -> IO PanAxis -> m PanAxis
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanAction
self' <- a -> IO (Ptr PanAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr PanAction -> IO CUInt
clutter_pan_action_get_pan_axis Ptr PanAction
self'
    let result' :: PanAxis
result' = (Int -> PanAxis
forall a. Enum a => Int -> a
toEnum (Int -> PanAxis) -> (CUInt -> Int) -> CUInt -> PanAxis
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    PanAxis -> IO PanAxis
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return PanAxis
result'

#if defined(ENABLE_OVERLOADING)
data PanActionGetPanAxisMethodInfo
instance (signature ~ (m Clutter.Enums.PanAxis), MonadIO m, IsPanAction a) => O.OverloadedMethod PanActionGetPanAxisMethodInfo a signature where
    overloadedMethod = panActionGetPanAxis

instance O.OverloadedMethodInfo PanActionGetPanAxisMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PanAction.panActionGetPanAxis",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PanAction.html#v:panActionGetPanAxis"
        })


#endif

-- method PanAction::set_acceleration_factor
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "PanAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterPanAction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "factor"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The acceleration factor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_pan_action_set_acceleration_factor" clutter_pan_action_set_acceleration_factor :: 
    Ptr PanAction ->                        -- self : TInterface (Name {namespace = "Clutter", name = "PanAction"})
    CDouble ->                              -- factor : TBasicType TDouble
    IO ()

-- | Factor applied to the momentum velocity at the time of releasing the
-- pointer when generating interpolated [pan](#g:signal:pan) events.
-- 
-- /Since: 1.12/
panActionSetAccelerationFactor ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanAction a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.PanAction.PanAction'
    -> Double
    -- ^ /@factor@/: The acceleration factor
    -> m ()
panActionSetAccelerationFactor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanAction a) =>
a -> Double -> m ()
panActionSetAccelerationFactor a
self Double
factor = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanAction
self' <- a -> IO (Ptr PanAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let factor' :: CDouble
factor' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
factor
    Ptr PanAction -> CDouble -> IO ()
clutter_pan_action_set_acceleration_factor Ptr PanAction
self' CDouble
factor'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PanActionSetAccelerationFactorMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsPanAction a) => O.OverloadedMethod PanActionSetAccelerationFactorMethodInfo a signature where
    overloadedMethod = panActionSetAccelerationFactor

instance O.OverloadedMethodInfo PanActionSetAccelerationFactorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PanAction.panActionSetAccelerationFactor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PanAction.html#v:panActionSetAccelerationFactor"
        })


#endif

-- method PanAction::set_deceleration
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "PanAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #ClutterPanAction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rate"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The deceleration rate"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_pan_action_set_deceleration" clutter_pan_action_set_deceleration :: 
    Ptr PanAction ->                        -- self : TInterface (Name {namespace = "Clutter", name = "PanAction"})
    CDouble ->                              -- rate : TBasicType TDouble
    IO ()

-- | Sets the deceleration rate of the interpolated [pan](#g:signal:pan) events generated
-- after a pan gesture. This is approximately the value that the momentum
-- at the time of releasing the pointer is divided by every 60th of a second.
-- 
-- /Since: 1.12/
panActionSetDeceleration ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanAction a) =>
    a
    -- ^ /@self@/: A t'GI.Clutter.Objects.PanAction.PanAction'
    -> Double
    -- ^ /@rate@/: The deceleration rate
    -> m ()
panActionSetDeceleration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanAction a) =>
a -> Double -> m ()
panActionSetDeceleration a
self Double
rate = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanAction
self' <- a -> IO (Ptr PanAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let rate' :: CDouble
rate' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
rate
    Ptr PanAction -> CDouble -> IO ()
clutter_pan_action_set_deceleration Ptr PanAction
self' CDouble
rate'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PanActionSetDecelerationMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsPanAction a) => O.OverloadedMethod PanActionSetDecelerationMethodInfo a signature where
    overloadedMethod = panActionSetDeceleration

instance O.OverloadedMethodInfo PanActionSetDecelerationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PanAction.panActionSetDeceleration",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PanAction.html#v:panActionSetDeceleration"
        })


#endif

-- method PanAction::set_interpolate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "PanAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterPanAction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "should_interpolate"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to enable interpolated pan events"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_pan_action_set_interpolate" clutter_pan_action_set_interpolate :: 
    Ptr PanAction ->                        -- self : TInterface (Name {namespace = "Clutter", name = "PanAction"})
    CInt ->                                 -- should_interpolate : TBasicType TBoolean
    IO ()

-- | Sets whether the action should emit interpolated [pan](#g:signal:pan) events
-- after the drag has ended, to emulate the gesture kinetic inertia.
-- 
-- /Since: 1.12/
panActionSetInterpolate ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanAction a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.PanAction.PanAction'
    -> Bool
    -- ^ /@shouldInterpolate@/: whether to enable interpolated pan events
    -> m ()
panActionSetInterpolate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanAction a) =>
a -> Bool -> m ()
panActionSetInterpolate a
self Bool
shouldInterpolate = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanAction
self' <- a -> IO (Ptr PanAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let shouldInterpolate' :: CInt
shouldInterpolate' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
shouldInterpolate
    Ptr PanAction -> CInt -> IO ()
clutter_pan_action_set_interpolate Ptr PanAction
self' CInt
shouldInterpolate'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PanActionSetInterpolateMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsPanAction a) => O.OverloadedMethod PanActionSetInterpolateMethodInfo a signature where
    overloadedMethod = panActionSetInterpolate

instance O.OverloadedMethodInfo PanActionSetInterpolateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PanAction.panActionSetInterpolate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PanAction.html#v:panActionSetInterpolate"
        })


#endif

-- method PanAction::set_pan_axis
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "PanAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #ClutterPanAction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "axis"
--           , argType =
--               TInterface Name { namespace = "Clutter" , name = "PanAxis" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the axis to constraint the panning to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "clutter_pan_action_set_pan_axis" clutter_pan_action_set_pan_axis :: 
    Ptr PanAction ->                        -- self : TInterface (Name {namespace = "Clutter", name = "PanAction"})
    CUInt ->                                -- axis : TInterface (Name {namespace = "Clutter", name = "PanAxis"})
    IO ()

-- | Restricts the panning action to a specific axis
-- 
-- /Since: 1.12/
panActionSetPanAxis ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanAction a) =>
    a
    -- ^ /@self@/: a t'GI.Clutter.Objects.PanAction.PanAction'
    -> Clutter.Enums.PanAxis
    -- ^ /@axis@/: the axis to constraint the panning to
    -> m ()
panActionSetPanAxis :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanAction a) =>
a -> PanAxis -> m ()
panActionSetPanAxis a
self PanAxis
axis = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanAction
self' <- a -> IO (Ptr PanAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let axis' :: CUInt
axis' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PanAxis -> Int) -> PanAxis -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PanAxis -> Int
forall a. Enum a => a -> Int
fromEnum) PanAxis
axis
    Ptr PanAction -> CUInt -> IO ()
clutter_pan_action_set_pan_axis Ptr PanAction
self' CUInt
axis'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PanActionSetPanAxisMethodInfo
instance (signature ~ (Clutter.Enums.PanAxis -> m ()), MonadIO m, IsPanAction a) => O.OverloadedMethod PanActionSetPanAxisMethodInfo a signature where
    overloadedMethod = panActionSetPanAxis

instance O.OverloadedMethodInfo PanActionSetPanAxisMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Objects.PanAction.panActionSetPanAxis",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Objects-PanAction.html#v:panActionSetPanAxis"
        })


#endif