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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A swipe tracker used in [class/@carousel@/], [class/@navigationView@/] and
-- [class/@overlaySplitView@/].
-- 
-- The @AdwSwipeTracker@ object can be used for implementing widgets with swipe
-- gestures. It supports touch-based swipes, pointer dragging, and touchpad
-- scrolling.
-- 
-- The widgets will probably want to expose the [property/@swipeTracker@/:enabled]
-- property. If they expect to use horizontal orientation,
-- [property/@swipeTracker@/:reversed] can be used for supporting RTL text
-- direction.

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

module GI.Adw.Objects.SwipeTracker
    ( 

-- * Exported types
    SwipeTracker(..)                        ,
    IsSwipeTracker                          ,
    toSwipeTracker                          ,


 -- * 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"), [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"), [shiftPosition]("GI.Adw.Objects.SwipeTracker#g:method:shiftPosition"), [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
-- [getAllowLongSwipes]("GI.Adw.Objects.SwipeTracker#g:method:getAllowLongSwipes"), [getAllowMouseDrag]("GI.Adw.Objects.SwipeTracker#g:method:getAllowMouseDrag"), [getAllowWindowHandle]("GI.Adw.Objects.SwipeTracker#g:method:getAllowWindowHandle"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getEnabled]("GI.Adw.Objects.SwipeTracker#g:method:getEnabled"), [getLowerOvershoot]("GI.Adw.Objects.SwipeTracker#g:method:getLowerOvershoot"), [getOrientation]("GI.Gtk.Interfaces.Orientable#g:method:getOrientation"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getReversed]("GI.Adw.Objects.SwipeTracker#g:method:getReversed"), [getSwipeable]("GI.Adw.Objects.SwipeTracker#g:method:getSwipeable"), [getUpperOvershoot]("GI.Adw.Objects.SwipeTracker#g:method:getUpperOvershoot").
-- 
-- ==== Setters
-- [setAllowLongSwipes]("GI.Adw.Objects.SwipeTracker#g:method:setAllowLongSwipes"), [setAllowMouseDrag]("GI.Adw.Objects.SwipeTracker#g:method:setAllowMouseDrag"), [setAllowWindowHandle]("GI.Adw.Objects.SwipeTracker#g:method:setAllowWindowHandle"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setEnabled]("GI.Adw.Objects.SwipeTracker#g:method:setEnabled"), [setLowerOvershoot]("GI.Adw.Objects.SwipeTracker#g:method:setLowerOvershoot"), [setOrientation]("GI.Gtk.Interfaces.Orientable#g:method:setOrientation"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReversed]("GI.Adw.Objects.SwipeTracker#g:method:setReversed"), [setUpperOvershoot]("GI.Adw.Objects.SwipeTracker#g:method:setUpperOvershoot").

#if defined(ENABLE_OVERLOADING)
    ResolveSwipeTrackerMethod               ,
#endif

-- ** getAllowLongSwipes #method:getAllowLongSwipes#

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerGetAllowLongSwipesMethodInfo,
#endif
    swipeTrackerGetAllowLongSwipes          ,


-- ** getAllowMouseDrag #method:getAllowMouseDrag#

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerGetAllowMouseDragMethodInfo ,
#endif
    swipeTrackerGetAllowMouseDrag           ,


-- ** getAllowWindowHandle #method:getAllowWindowHandle#

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerGetAllowWindowHandleMethodInfo,
#endif
    swipeTrackerGetAllowWindowHandle        ,


-- ** getEnabled #method:getEnabled#

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerGetEnabledMethodInfo        ,
#endif
    swipeTrackerGetEnabled                  ,


-- ** getLowerOvershoot #method:getLowerOvershoot#

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerGetLowerOvershootMethodInfo ,
#endif
    swipeTrackerGetLowerOvershoot           ,


-- ** getReversed #method:getReversed#

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerGetReversedMethodInfo       ,
#endif
    swipeTrackerGetReversed                 ,


-- ** getSwipeable #method:getSwipeable#

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerGetSwipeableMethodInfo      ,
#endif
    swipeTrackerGetSwipeable                ,


-- ** getUpperOvershoot #method:getUpperOvershoot#

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerGetUpperOvershootMethodInfo ,
#endif
    swipeTrackerGetUpperOvershoot           ,


-- ** new #method:new#

    swipeTrackerNew                         ,


-- ** setAllowLongSwipes #method:setAllowLongSwipes#

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerSetAllowLongSwipesMethodInfo,
#endif
    swipeTrackerSetAllowLongSwipes          ,


-- ** setAllowMouseDrag #method:setAllowMouseDrag#

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerSetAllowMouseDragMethodInfo ,
#endif
    swipeTrackerSetAllowMouseDrag           ,


-- ** setAllowWindowHandle #method:setAllowWindowHandle#

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerSetAllowWindowHandleMethodInfo,
#endif
    swipeTrackerSetAllowWindowHandle        ,


-- ** setEnabled #method:setEnabled#

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerSetEnabledMethodInfo        ,
#endif
    swipeTrackerSetEnabled                  ,


-- ** setLowerOvershoot #method:setLowerOvershoot#

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerSetLowerOvershootMethodInfo ,
#endif
    swipeTrackerSetLowerOvershoot           ,


-- ** setReversed #method:setReversed#

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerSetReversedMethodInfo       ,
#endif
    swipeTrackerSetReversed                 ,


-- ** setUpperOvershoot #method:setUpperOvershoot#

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerSetUpperOvershootMethodInfo ,
#endif
    swipeTrackerSetUpperOvershoot           ,


-- ** shiftPosition #method:shiftPosition#

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerShiftPositionMethodInfo     ,
#endif
    swipeTrackerShiftPosition               ,




 -- * Properties


-- ** allowLongSwipes #attr:allowLongSwipes#
-- | Whether to allow swiping for more than one snap point at a time.
-- 
-- If the value is @FALSE@, each swipe can only move to the adjacent snap
-- points.

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerAllowLongSwipesPropertyInfo ,
#endif
    constructSwipeTrackerAllowLongSwipes    ,
    getSwipeTrackerAllowLongSwipes          ,
    setSwipeTrackerAllowLongSwipes          ,
#if defined(ENABLE_OVERLOADING)
    swipeTrackerAllowLongSwipes             ,
#endif


-- ** allowMouseDrag #attr:allowMouseDrag#
-- | Whether to allow dragging with mouse pointer.

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerAllowMouseDragPropertyInfo  ,
#endif
    constructSwipeTrackerAllowMouseDrag     ,
    getSwipeTrackerAllowMouseDrag           ,
    setSwipeTrackerAllowMouseDrag           ,
#if defined(ENABLE_OVERLOADING)
    swipeTrackerAllowMouseDrag              ,
#endif


-- ** allowWindowHandle #attr:allowWindowHandle#
-- | Whether to allow touchscreen swiping from @GtkWindowHandle@.
-- 
-- This will make dragging the window impossible.
-- 
-- /Since: 1.5/

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerAllowWindowHandlePropertyInfo,
#endif
    constructSwipeTrackerAllowWindowHandle  ,
    getSwipeTrackerAllowWindowHandle        ,
    setSwipeTrackerAllowWindowHandle        ,
#if defined(ENABLE_OVERLOADING)
    swipeTrackerAllowWindowHandle           ,
#endif


-- ** enabled #attr:enabled#
-- | Whether the swipe tracker is enabled.
-- 
-- When it\'s not enabled, no events will be processed. Usually widgets will
-- want to expose this via a property.

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerEnabledPropertyInfo         ,
#endif
    constructSwipeTrackerEnabled            ,
    getSwipeTrackerEnabled                  ,
    setSwipeTrackerEnabled                  ,
#if defined(ENABLE_OVERLOADING)
    swipeTrackerEnabled                     ,
#endif


-- ** lowerOvershoot #attr:lowerOvershoot#
-- | Whether to allow swiping past the first available snap point.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerLowerOvershootPropertyInfo  ,
#endif
    constructSwipeTrackerLowerOvershoot     ,
    getSwipeTrackerLowerOvershoot           ,
    setSwipeTrackerLowerOvershoot           ,
#if defined(ENABLE_OVERLOADING)
    swipeTrackerLowerOvershoot              ,
#endif


-- ** reversed #attr:reversed#
-- | Whether to reverse the swipe direction.
-- 
-- If the swipe tracker is horizontal, it can be used for supporting RTL text
-- direction.

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerReversedPropertyInfo        ,
#endif
    constructSwipeTrackerReversed           ,
    getSwipeTrackerReversed                 ,
    setSwipeTrackerReversed                 ,
#if defined(ENABLE_OVERLOADING)
    swipeTrackerReversed                    ,
#endif


-- ** swipeable #attr:swipeable#
-- | The widget the swipe tracker is attached to.

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerSwipeablePropertyInfo       ,
#endif
    constructSwipeTrackerSwipeable          ,
    getSwipeTrackerSwipeable                ,
#if defined(ENABLE_OVERLOADING)
    swipeTrackerSwipeable                   ,
#endif


-- ** upperOvershoot #attr:upperOvershoot#
-- | Whether to allow swiping past the last available snap point.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    SwipeTrackerUpperOvershootPropertyInfo  ,
#endif
    constructSwipeTrackerUpperOvershoot     ,
    getSwipeTrackerUpperOvershoot           ,
    setSwipeTrackerUpperOvershoot           ,
#if defined(ENABLE_OVERLOADING)
    swipeTrackerUpperOvershoot              ,
#endif




 -- * Signals


-- ** beginSwipe #signal:beginSwipe#

    SwipeTrackerBeginSwipeCallback          ,
#if defined(ENABLE_OVERLOADING)
    SwipeTrackerBeginSwipeSignalInfo        ,
#endif
    afterSwipeTrackerBeginSwipe             ,
    onSwipeTrackerBeginSwipe                ,


-- ** endSwipe #signal:endSwipe#

    SwipeTrackerEndSwipeCallback            ,
#if defined(ENABLE_OVERLOADING)
    SwipeTrackerEndSwipeSignalInfo          ,
#endif
    afterSwipeTrackerEndSwipe               ,
    onSwipeTrackerEndSwipe                  ,


-- ** prepare #signal:prepare#

    SwipeTrackerPrepareCallback             ,
#if defined(ENABLE_OVERLOADING)
    SwipeTrackerPrepareSignalInfo           ,
#endif
    afterSwipeTrackerPrepare                ,
    onSwipeTrackerPrepare                   ,


-- ** updateSwipe #signal:updateSwipe#

    SwipeTrackerUpdateSwipeCallback         ,
#if defined(ENABLE_OVERLOADING)
    SwipeTrackerUpdateSwipeSignalInfo       ,
#endif
    afterSwipeTrackerUpdateSwipe            ,
    onSwipeTrackerUpdateSwipe               ,




    ) 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.Kind as DK
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 qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import {-# SOURCE #-} qualified GI.Adw.Enums as Adw.Enums
import {-# SOURCE #-} qualified GI.Adw.Interfaces.Swipeable as Adw.Swipeable
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
import qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.Orientable as Gtk.Orientable
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

#else
import {-# SOURCE #-} qualified GI.Adw.Enums as Adw.Enums
import {-# SOURCE #-} qualified GI.Adw.Interfaces.Swipeable as Adw.Swipeable
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Interfaces.Orientable as Gtk.Orientable

#endif

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

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

foreign import ccall "adw_swipe_tracker_get_type"
    c_adw_swipe_tracker_get_type :: IO B.Types.GType

instance B.Types.TypedObject SwipeTracker where
    glibType :: IO GType
glibType = IO GType
c_adw_swipe_tracker_get_type

instance B.Types.GObject SwipeTracker

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

instance O.HasParentTypes SwipeTracker
type instance O.ParentTypes SwipeTracker = '[GObject.Object.Object, Gtk.Orientable.Orientable]

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

-- | Convert 'SwipeTracker' 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 SwipeTracker) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_adw_swipe_tracker_get_type
    gvalueSet_ :: Ptr GValue -> Maybe SwipeTracker -> IO ()
gvalueSet_ Ptr GValue
gv Maybe SwipeTracker
P.Nothing = Ptr GValue -> Ptr SwipeTracker -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr SwipeTracker
forall a. Ptr a
FP.nullPtr :: FP.Ptr SwipeTracker)
    gvalueSet_ Ptr GValue
gv (P.Just SwipeTracker
obj) = SwipeTracker -> (Ptr SwipeTracker -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr SwipeTracker
obj (Ptr GValue -> Ptr SwipeTracker -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe SwipeTracker)
gvalueGet_ Ptr GValue
gv = do
        Ptr SwipeTracker
ptr <- Ptr GValue -> IO (Ptr SwipeTracker)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr SwipeTracker)
        if Ptr SwipeTracker
ptr Ptr SwipeTracker -> Ptr SwipeTracker -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr SwipeTracker
forall a. Ptr a
FP.nullPtr
        then SwipeTracker -> Maybe SwipeTracker
forall a. a -> Maybe a
P.Just (SwipeTracker -> Maybe SwipeTracker)
-> IO SwipeTracker -> IO (Maybe SwipeTracker)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr SwipeTracker -> SwipeTracker)
-> Ptr SwipeTracker -> IO SwipeTracker
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr SwipeTracker -> SwipeTracker
SwipeTracker Ptr SwipeTracker
ptr
        else Maybe SwipeTracker -> IO (Maybe SwipeTracker)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SwipeTracker
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveSwipeTrackerMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveSwipeTrackerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveSwipeTrackerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveSwipeTrackerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveSwipeTrackerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveSwipeTrackerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveSwipeTrackerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveSwipeTrackerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveSwipeTrackerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveSwipeTrackerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveSwipeTrackerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveSwipeTrackerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveSwipeTrackerMethod "shiftPosition" o = SwipeTrackerShiftPositionMethodInfo
    ResolveSwipeTrackerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveSwipeTrackerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveSwipeTrackerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveSwipeTrackerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveSwipeTrackerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveSwipeTrackerMethod "getAllowLongSwipes" o = SwipeTrackerGetAllowLongSwipesMethodInfo
    ResolveSwipeTrackerMethod "getAllowMouseDrag" o = SwipeTrackerGetAllowMouseDragMethodInfo
    ResolveSwipeTrackerMethod "getAllowWindowHandle" o = SwipeTrackerGetAllowWindowHandleMethodInfo
    ResolveSwipeTrackerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveSwipeTrackerMethod "getEnabled" o = SwipeTrackerGetEnabledMethodInfo
    ResolveSwipeTrackerMethod "getLowerOvershoot" o = SwipeTrackerGetLowerOvershootMethodInfo
    ResolveSwipeTrackerMethod "getOrientation" o = Gtk.Orientable.OrientableGetOrientationMethodInfo
    ResolveSwipeTrackerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveSwipeTrackerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveSwipeTrackerMethod "getReversed" o = SwipeTrackerGetReversedMethodInfo
    ResolveSwipeTrackerMethod "getSwipeable" o = SwipeTrackerGetSwipeableMethodInfo
    ResolveSwipeTrackerMethod "getUpperOvershoot" o = SwipeTrackerGetUpperOvershootMethodInfo
    ResolveSwipeTrackerMethod "setAllowLongSwipes" o = SwipeTrackerSetAllowLongSwipesMethodInfo
    ResolveSwipeTrackerMethod "setAllowMouseDrag" o = SwipeTrackerSetAllowMouseDragMethodInfo
    ResolveSwipeTrackerMethod "setAllowWindowHandle" o = SwipeTrackerSetAllowWindowHandleMethodInfo
    ResolveSwipeTrackerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveSwipeTrackerMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveSwipeTrackerMethod "setEnabled" o = SwipeTrackerSetEnabledMethodInfo
    ResolveSwipeTrackerMethod "setLowerOvershoot" o = SwipeTrackerSetLowerOvershootMethodInfo
    ResolveSwipeTrackerMethod "setOrientation" o = Gtk.Orientable.OrientableSetOrientationMethodInfo
    ResolveSwipeTrackerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveSwipeTrackerMethod "setReversed" o = SwipeTrackerSetReversedMethodInfo
    ResolveSwipeTrackerMethod "setUpperOvershoot" o = SwipeTrackerSetUpperOvershootMethodInfo
    ResolveSwipeTrackerMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveSwipeTrackerMethod t SwipeTracker, O.OverloadedMethod info SwipeTracker p) => OL.IsLabel t (SwipeTracker -> 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 ~ ResolveSwipeTrackerMethod t SwipeTracker, O.OverloadedMethod info SwipeTracker p, R.HasField t SwipeTracker p) => R.HasField t SwipeTracker p where
    getField = O.overloadedMethod @info

#endif

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

#endif

-- signal SwipeTracker::begin-swipe
-- | This signal is emitted right before a swipe will be started, after the
-- drag threshold has been passed.
type SwipeTrackerBeginSwipeCallback =
    IO ()

type C_SwipeTrackerBeginSwipeCallback =
    Ptr SwipeTracker ->                     -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_SwipeTrackerBeginSwipeCallback :: 
    GObject a => (a -> SwipeTrackerBeginSwipeCallback) ->
    C_SwipeTrackerBeginSwipeCallback
wrap_SwipeTrackerBeginSwipeCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_SwipeTrackerBeginSwipeCallback
wrap_SwipeTrackerBeginSwipeCallback a -> IO ()
gi'cb Ptr SwipeTracker
gi'selfPtr Ptr ()
_ = do
    Ptr SwipeTracker -> (SwipeTracker -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr SwipeTracker
gi'selfPtr ((SwipeTracker -> IO ()) -> IO ())
-> (SwipeTracker -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SwipeTracker
gi'self -> a -> IO ()
gi'cb (SwipeTracker -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SwipeTracker
gi'self) 


-- | Connect a signal handler for the [beginSwipe](#signal:beginSwipe) 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' swipeTracker #beginSwipe callback
-- @
-- 
-- 
onSwipeTrackerBeginSwipe :: (IsSwipeTracker a, MonadIO m) => a -> ((?self :: a) => SwipeTrackerBeginSwipeCallback) -> m SignalHandlerId
onSwipeTrackerBeginSwipe :: forall a (m :: * -> *).
(IsSwipeTracker a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onSwipeTrackerBeginSwipe a
obj (?self::a) => IO ()
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 -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_SwipeTrackerBeginSwipeCallback
wrapped' = (a -> IO ()) -> C_SwipeTrackerBeginSwipeCallback
forall a.
GObject a =>
(a -> IO ()) -> C_SwipeTrackerBeginSwipeCallback
wrap_SwipeTrackerBeginSwipeCallback a -> IO ()
wrapped
    FunPtr C_SwipeTrackerBeginSwipeCallback
wrapped'' <- C_SwipeTrackerBeginSwipeCallback
-> IO (FunPtr C_SwipeTrackerBeginSwipeCallback)
mk_SwipeTrackerBeginSwipeCallback C_SwipeTrackerBeginSwipeCallback
wrapped'
    a
-> Text
-> FunPtr C_SwipeTrackerBeginSwipeCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"begin-swipe" FunPtr C_SwipeTrackerBeginSwipeCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [beginSwipe](#signal:beginSwipe) 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' swipeTracker #beginSwipe 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.
-- 
afterSwipeTrackerBeginSwipe :: (IsSwipeTracker a, MonadIO m) => a -> ((?self :: a) => SwipeTrackerBeginSwipeCallback) -> m SignalHandlerId
afterSwipeTrackerBeginSwipe :: forall a (m :: * -> *).
(IsSwipeTracker a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterSwipeTrackerBeginSwipe a
obj (?self::a) => IO ()
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 -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_SwipeTrackerBeginSwipeCallback
wrapped' = (a -> IO ()) -> C_SwipeTrackerBeginSwipeCallback
forall a.
GObject a =>
(a -> IO ()) -> C_SwipeTrackerBeginSwipeCallback
wrap_SwipeTrackerBeginSwipeCallback a -> IO ()
wrapped
    FunPtr C_SwipeTrackerBeginSwipeCallback
wrapped'' <- C_SwipeTrackerBeginSwipeCallback
-> IO (FunPtr C_SwipeTrackerBeginSwipeCallback)
mk_SwipeTrackerBeginSwipeCallback C_SwipeTrackerBeginSwipeCallback
wrapped'
    a
-> Text
-> FunPtr C_SwipeTrackerBeginSwipeCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"begin-swipe" FunPtr C_SwipeTrackerBeginSwipeCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data SwipeTrackerBeginSwipeSignalInfo
instance SignalInfo SwipeTrackerBeginSwipeSignalInfo where
    type HaskellCallbackType SwipeTrackerBeginSwipeSignalInfo = SwipeTrackerBeginSwipeCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_SwipeTrackerBeginSwipeCallback cb
        cb'' <- mk_SwipeTrackerBeginSwipeCallback cb'
        connectSignalFunPtr obj "begin-swipe" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker::begin-swipe"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#g:signal:beginSwipe"})

#endif

-- signal SwipeTracker::end-swipe
-- | This signal is emitted as soon as the gesture has stopped.
-- 
-- The user is expected to animate the deceleration from the current progress
-- value to /@to@/ with an animation using /@velocity@/ as the initial velocity,
-- provided in pixels per second. [class/@springAnimation@/] is usually a good
-- fit for this.
type SwipeTrackerEndSwipeCallback =
    Double
    -- ^ /@velocity@/: the velocity of the swipe
    -> Double
    -- ^ /@to@/: the progress value to animate to
    -> IO ()

type C_SwipeTrackerEndSwipeCallback =
    Ptr SwipeTracker ->                     -- object
    CDouble ->
    CDouble ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_SwipeTrackerEndSwipeCallback :: 
    GObject a => (a -> SwipeTrackerEndSwipeCallback) ->
    C_SwipeTrackerEndSwipeCallback
wrap_SwipeTrackerEndSwipeCallback :: forall a.
GObject a =>
(a -> SwipeTrackerEndSwipeCallback)
-> C_SwipeTrackerEndSwipeCallback
wrap_SwipeTrackerEndSwipeCallback a -> SwipeTrackerEndSwipeCallback
gi'cb Ptr SwipeTracker
gi'selfPtr CDouble
velocity CDouble
to Ptr ()
_ = do
    let velocity' :: Double
velocity' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
velocity
    let to' :: Double
to' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
to
    Ptr SwipeTracker -> (SwipeTracker -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr SwipeTracker
gi'selfPtr ((SwipeTracker -> IO ()) -> IO ())
-> (SwipeTracker -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SwipeTracker
gi'self -> a -> SwipeTrackerEndSwipeCallback
gi'cb (SwipeTracker -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SwipeTracker
gi'self)  Double
velocity' Double
to'


-- | Connect a signal handler for the [endSwipe](#signal:endSwipe) 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' swipeTracker #endSwipe callback
-- @
-- 
-- 
onSwipeTrackerEndSwipe :: (IsSwipeTracker a, MonadIO m) => a -> ((?self :: a) => SwipeTrackerEndSwipeCallback) -> m SignalHandlerId
onSwipeTrackerEndSwipe :: forall a (m :: * -> *).
(IsSwipeTracker a, MonadIO m) =>
a
-> ((?self::a) => SwipeTrackerEndSwipeCallback)
-> m SignalHandlerId
onSwipeTrackerEndSwipe a
obj (?self::a) => SwipeTrackerEndSwipeCallback
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 -> SwipeTrackerEndSwipeCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SwipeTrackerEndSwipeCallback
SwipeTrackerEndSwipeCallback
cb
    let wrapped' :: C_SwipeTrackerEndSwipeCallback
wrapped' = (a -> SwipeTrackerEndSwipeCallback)
-> C_SwipeTrackerEndSwipeCallback
forall a.
GObject a =>
(a -> SwipeTrackerEndSwipeCallback)
-> C_SwipeTrackerEndSwipeCallback
wrap_SwipeTrackerEndSwipeCallback a -> SwipeTrackerEndSwipeCallback
wrapped
    FunPtr C_SwipeTrackerEndSwipeCallback
wrapped'' <- C_SwipeTrackerEndSwipeCallback
-> IO (FunPtr C_SwipeTrackerEndSwipeCallback)
mk_SwipeTrackerEndSwipeCallback C_SwipeTrackerEndSwipeCallback
wrapped'
    a
-> Text
-> FunPtr C_SwipeTrackerEndSwipeCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"end-swipe" FunPtr C_SwipeTrackerEndSwipeCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [endSwipe](#signal:endSwipe) 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' swipeTracker #endSwipe 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.
-- 
afterSwipeTrackerEndSwipe :: (IsSwipeTracker a, MonadIO m) => a -> ((?self :: a) => SwipeTrackerEndSwipeCallback) -> m SignalHandlerId
afterSwipeTrackerEndSwipe :: forall a (m :: * -> *).
(IsSwipeTracker a, MonadIO m) =>
a
-> ((?self::a) => SwipeTrackerEndSwipeCallback)
-> m SignalHandlerId
afterSwipeTrackerEndSwipe a
obj (?self::a) => SwipeTrackerEndSwipeCallback
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 -> SwipeTrackerEndSwipeCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SwipeTrackerEndSwipeCallback
SwipeTrackerEndSwipeCallback
cb
    let wrapped' :: C_SwipeTrackerEndSwipeCallback
wrapped' = (a -> SwipeTrackerEndSwipeCallback)
-> C_SwipeTrackerEndSwipeCallback
forall a.
GObject a =>
(a -> SwipeTrackerEndSwipeCallback)
-> C_SwipeTrackerEndSwipeCallback
wrap_SwipeTrackerEndSwipeCallback a -> SwipeTrackerEndSwipeCallback
wrapped
    FunPtr C_SwipeTrackerEndSwipeCallback
wrapped'' <- C_SwipeTrackerEndSwipeCallback
-> IO (FunPtr C_SwipeTrackerEndSwipeCallback)
mk_SwipeTrackerEndSwipeCallback C_SwipeTrackerEndSwipeCallback
wrapped'
    a
-> Text
-> FunPtr C_SwipeTrackerEndSwipeCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"end-swipe" FunPtr C_SwipeTrackerEndSwipeCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data SwipeTrackerEndSwipeSignalInfo
instance SignalInfo SwipeTrackerEndSwipeSignalInfo where
    type HaskellCallbackType SwipeTrackerEndSwipeSignalInfo = SwipeTrackerEndSwipeCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_SwipeTrackerEndSwipeCallback cb
        cb'' <- mk_SwipeTrackerEndSwipeCallback cb'
        connectSignalFunPtr obj "end-swipe" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker::end-swipe"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#g:signal:endSwipe"})

#endif

-- signal SwipeTracker::prepare
-- | This signal is emitted when a possible swipe is detected.
-- 
-- The /@direction@/ value can be used to restrict the swipe to a certain
-- direction.
type SwipeTrackerPrepareCallback =
    Adw.Enums.NavigationDirection
    -- ^ /@direction@/: the direction of the swipe
    -> IO ()

type C_SwipeTrackerPrepareCallback =
    Ptr SwipeTracker ->                     -- object
    CUInt ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_SwipeTrackerPrepareCallback :: 
    GObject a => (a -> SwipeTrackerPrepareCallback) ->
    C_SwipeTrackerPrepareCallback
wrap_SwipeTrackerPrepareCallback :: forall a.
GObject a =>
(a -> SwipeTrackerPrepareCallback) -> C_SwipeTrackerPrepareCallback
wrap_SwipeTrackerPrepareCallback a -> SwipeTrackerPrepareCallback
gi'cb Ptr SwipeTracker
gi'selfPtr CUInt
direction Ptr ()
_ = do
    let direction' :: NavigationDirection
direction' = (Int -> NavigationDirection
forall a. Enum a => Int -> a
toEnum (Int -> NavigationDirection)
-> (CUInt -> Int) -> CUInt -> NavigationDirection
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
direction
    Ptr SwipeTracker -> (SwipeTracker -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr SwipeTracker
gi'selfPtr ((SwipeTracker -> IO ()) -> IO ())
-> (SwipeTracker -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SwipeTracker
gi'self -> a -> SwipeTrackerPrepareCallback
gi'cb (SwipeTracker -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SwipeTracker
gi'self)  NavigationDirection
direction'


-- | Connect a signal handler for the [prepare](#signal:prepare) 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' swipeTracker #prepare callback
-- @
-- 
-- 
onSwipeTrackerPrepare :: (IsSwipeTracker a, MonadIO m) => a -> ((?self :: a) => SwipeTrackerPrepareCallback) -> m SignalHandlerId
onSwipeTrackerPrepare :: forall a (m :: * -> *).
(IsSwipeTracker a, MonadIO m) =>
a
-> ((?self::a) => SwipeTrackerPrepareCallback) -> m SignalHandlerId
onSwipeTrackerPrepare a
obj (?self::a) => SwipeTrackerPrepareCallback
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 -> SwipeTrackerPrepareCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SwipeTrackerPrepareCallback
SwipeTrackerPrepareCallback
cb
    let wrapped' :: C_SwipeTrackerPrepareCallback
wrapped' = (a -> SwipeTrackerPrepareCallback) -> C_SwipeTrackerPrepareCallback
forall a.
GObject a =>
(a -> SwipeTrackerPrepareCallback) -> C_SwipeTrackerPrepareCallback
wrap_SwipeTrackerPrepareCallback a -> SwipeTrackerPrepareCallback
wrapped
    FunPtr C_SwipeTrackerPrepareCallback
wrapped'' <- C_SwipeTrackerPrepareCallback
-> IO (FunPtr C_SwipeTrackerPrepareCallback)
mk_SwipeTrackerPrepareCallback C_SwipeTrackerPrepareCallback
wrapped'
    a
-> Text
-> FunPtr C_SwipeTrackerPrepareCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"prepare" FunPtr C_SwipeTrackerPrepareCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [prepare](#signal:prepare) 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' swipeTracker #prepare 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.
-- 
afterSwipeTrackerPrepare :: (IsSwipeTracker a, MonadIO m) => a -> ((?self :: a) => SwipeTrackerPrepareCallback) -> m SignalHandlerId
afterSwipeTrackerPrepare :: forall a (m :: * -> *).
(IsSwipeTracker a, MonadIO m) =>
a
-> ((?self::a) => SwipeTrackerPrepareCallback) -> m SignalHandlerId
afterSwipeTrackerPrepare a
obj (?self::a) => SwipeTrackerPrepareCallback
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 -> SwipeTrackerPrepareCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SwipeTrackerPrepareCallback
SwipeTrackerPrepareCallback
cb
    let wrapped' :: C_SwipeTrackerPrepareCallback
wrapped' = (a -> SwipeTrackerPrepareCallback) -> C_SwipeTrackerPrepareCallback
forall a.
GObject a =>
(a -> SwipeTrackerPrepareCallback) -> C_SwipeTrackerPrepareCallback
wrap_SwipeTrackerPrepareCallback a -> SwipeTrackerPrepareCallback
wrapped
    FunPtr C_SwipeTrackerPrepareCallback
wrapped'' <- C_SwipeTrackerPrepareCallback
-> IO (FunPtr C_SwipeTrackerPrepareCallback)
mk_SwipeTrackerPrepareCallback C_SwipeTrackerPrepareCallback
wrapped'
    a
-> Text
-> FunPtr C_SwipeTrackerPrepareCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"prepare" FunPtr C_SwipeTrackerPrepareCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data SwipeTrackerPrepareSignalInfo
instance SignalInfo SwipeTrackerPrepareSignalInfo where
    type HaskellCallbackType SwipeTrackerPrepareSignalInfo = SwipeTrackerPrepareCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_SwipeTrackerPrepareCallback cb
        cb'' <- mk_SwipeTrackerPrepareCallback cb'
        connectSignalFunPtr obj "prepare" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker::prepare"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#g:signal:prepare"})

#endif

-- signal SwipeTracker::update-swipe
-- | This signal is emitted every time the progress value changes.
type SwipeTrackerUpdateSwipeCallback =
    Double
    -- ^ /@progress@/: the current animation progress value
    -> IO ()

type C_SwipeTrackerUpdateSwipeCallback =
    Ptr SwipeTracker ->                     -- object
    CDouble ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_SwipeTrackerUpdateSwipeCallback :: 
    GObject a => (a -> SwipeTrackerUpdateSwipeCallback) ->
    C_SwipeTrackerUpdateSwipeCallback
wrap_SwipeTrackerUpdateSwipeCallback :: forall a.
GObject a =>
(a -> SwipeTrackerUpdateSwipeCallback)
-> C_SwipeTrackerUpdateSwipeCallback
wrap_SwipeTrackerUpdateSwipeCallback a -> SwipeTrackerUpdateSwipeCallback
gi'cb Ptr SwipeTracker
gi'selfPtr CDouble
progress Ptr ()
_ = do
    let progress' :: Double
progress' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
progress
    Ptr SwipeTracker -> (SwipeTracker -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr SwipeTracker
gi'selfPtr ((SwipeTracker -> IO ()) -> IO ())
-> (SwipeTracker -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SwipeTracker
gi'self -> a -> SwipeTrackerUpdateSwipeCallback
gi'cb (SwipeTracker -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SwipeTracker
gi'self)  Double
progress'


-- | Connect a signal handler for the [updateSwipe](#signal:updateSwipe) 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' swipeTracker #updateSwipe callback
-- @
-- 
-- 
onSwipeTrackerUpdateSwipe :: (IsSwipeTracker a, MonadIO m) => a -> ((?self :: a) => SwipeTrackerUpdateSwipeCallback) -> m SignalHandlerId
onSwipeTrackerUpdateSwipe :: forall a (m :: * -> *).
(IsSwipeTracker a, MonadIO m) =>
a
-> ((?self::a) => SwipeTrackerUpdateSwipeCallback)
-> m SignalHandlerId
onSwipeTrackerUpdateSwipe a
obj (?self::a) => SwipeTrackerUpdateSwipeCallback
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 -> SwipeTrackerUpdateSwipeCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SwipeTrackerUpdateSwipeCallback
SwipeTrackerUpdateSwipeCallback
cb
    let wrapped' :: C_SwipeTrackerUpdateSwipeCallback
wrapped' = (a -> SwipeTrackerUpdateSwipeCallback)
-> C_SwipeTrackerUpdateSwipeCallback
forall a.
GObject a =>
(a -> SwipeTrackerUpdateSwipeCallback)
-> C_SwipeTrackerUpdateSwipeCallback
wrap_SwipeTrackerUpdateSwipeCallback a -> SwipeTrackerUpdateSwipeCallback
wrapped
    FunPtr C_SwipeTrackerUpdateSwipeCallback
wrapped'' <- C_SwipeTrackerUpdateSwipeCallback
-> IO (FunPtr C_SwipeTrackerUpdateSwipeCallback)
mk_SwipeTrackerUpdateSwipeCallback C_SwipeTrackerUpdateSwipeCallback
wrapped'
    a
-> Text
-> FunPtr C_SwipeTrackerUpdateSwipeCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"update-swipe" FunPtr C_SwipeTrackerUpdateSwipeCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [updateSwipe](#signal:updateSwipe) 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' swipeTracker #updateSwipe 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.
-- 
afterSwipeTrackerUpdateSwipe :: (IsSwipeTracker a, MonadIO m) => a -> ((?self :: a) => SwipeTrackerUpdateSwipeCallback) -> m SignalHandlerId
afterSwipeTrackerUpdateSwipe :: forall a (m :: * -> *).
(IsSwipeTracker a, MonadIO m) =>
a
-> ((?self::a) => SwipeTrackerUpdateSwipeCallback)
-> m SignalHandlerId
afterSwipeTrackerUpdateSwipe a
obj (?self::a) => SwipeTrackerUpdateSwipeCallback
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 -> SwipeTrackerUpdateSwipeCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SwipeTrackerUpdateSwipeCallback
SwipeTrackerUpdateSwipeCallback
cb
    let wrapped' :: C_SwipeTrackerUpdateSwipeCallback
wrapped' = (a -> SwipeTrackerUpdateSwipeCallback)
-> C_SwipeTrackerUpdateSwipeCallback
forall a.
GObject a =>
(a -> SwipeTrackerUpdateSwipeCallback)
-> C_SwipeTrackerUpdateSwipeCallback
wrap_SwipeTrackerUpdateSwipeCallback a -> SwipeTrackerUpdateSwipeCallback
wrapped
    FunPtr C_SwipeTrackerUpdateSwipeCallback
wrapped'' <- C_SwipeTrackerUpdateSwipeCallback
-> IO (FunPtr C_SwipeTrackerUpdateSwipeCallback)
mk_SwipeTrackerUpdateSwipeCallback C_SwipeTrackerUpdateSwipeCallback
wrapped'
    a
-> Text
-> FunPtr C_SwipeTrackerUpdateSwipeCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"update-swipe" FunPtr C_SwipeTrackerUpdateSwipeCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data SwipeTrackerUpdateSwipeSignalInfo
instance SignalInfo SwipeTrackerUpdateSwipeSignalInfo where
    type HaskellCallbackType SwipeTrackerUpdateSwipeSignalInfo = SwipeTrackerUpdateSwipeCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_SwipeTrackerUpdateSwipeCallback cb
        cb'' <- mk_SwipeTrackerUpdateSwipeCallback cb'
        connectSignalFunPtr obj "update-swipe" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker::update-swipe"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#g:signal:updateSwipe"})

#endif

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

-- | Get the value of the “@allow-long-swipes@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' swipeTracker #allowLongSwipes
-- @
getSwipeTrackerAllowLongSwipes :: (MonadIO m, IsSwipeTracker o) => o -> m Bool
getSwipeTrackerAllowLongSwipes :: forall (m :: * -> *) o.
(MonadIO m, IsSwipeTracker o) =>
o -> m Bool
getSwipeTrackerAllowLongSwipes 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
"allow-long-swipes"

-- | Set the value of the “@allow-long-swipes@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' swipeTracker [ #allowLongSwipes 'Data.GI.Base.Attributes.:=' value ]
-- @
setSwipeTrackerAllowLongSwipes :: (MonadIO m, IsSwipeTracker o) => o -> Bool -> m ()
setSwipeTrackerAllowLongSwipes :: forall (m :: * -> *) o.
(MonadIO m, IsSwipeTracker o) =>
o -> Bool -> m ()
setSwipeTrackerAllowLongSwipes 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
"allow-long-swipes" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@allow-long-swipes@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSwipeTrackerAllowLongSwipes :: (IsSwipeTracker o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSwipeTrackerAllowLongSwipes :: forall o (m :: * -> *).
(IsSwipeTracker o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSwipeTrackerAllowLongSwipes 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
"allow-long-swipes" Bool
val

#if defined(ENABLE_OVERLOADING)
data SwipeTrackerAllowLongSwipesPropertyInfo
instance AttrInfo SwipeTrackerAllowLongSwipesPropertyInfo where
    type AttrAllowedOps SwipeTrackerAllowLongSwipesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SwipeTrackerAllowLongSwipesPropertyInfo = IsSwipeTracker
    type AttrSetTypeConstraint SwipeTrackerAllowLongSwipesPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SwipeTrackerAllowLongSwipesPropertyInfo = (~) Bool
    type AttrTransferType SwipeTrackerAllowLongSwipesPropertyInfo = Bool
    type AttrGetType SwipeTrackerAllowLongSwipesPropertyInfo = Bool
    type AttrLabel SwipeTrackerAllowLongSwipesPropertyInfo = "allow-long-swipes"
    type AttrOrigin SwipeTrackerAllowLongSwipesPropertyInfo = SwipeTracker
    attrGet = getSwipeTrackerAllowLongSwipes
    attrSet = setSwipeTrackerAllowLongSwipes
    attrTransfer _ v = do
        return v
    attrConstruct = constructSwipeTrackerAllowLongSwipes
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.allowLongSwipes"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#g:attr:allowLongSwipes"
        })
#endif

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

-- | Get the value of the “@allow-mouse-drag@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' swipeTracker #allowMouseDrag
-- @
getSwipeTrackerAllowMouseDrag :: (MonadIO m, IsSwipeTracker o) => o -> m Bool
getSwipeTrackerAllowMouseDrag :: forall (m :: * -> *) o.
(MonadIO m, IsSwipeTracker o) =>
o -> m Bool
getSwipeTrackerAllowMouseDrag 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
"allow-mouse-drag"

-- | Set the value of the “@allow-mouse-drag@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' swipeTracker [ #allowMouseDrag 'Data.GI.Base.Attributes.:=' value ]
-- @
setSwipeTrackerAllowMouseDrag :: (MonadIO m, IsSwipeTracker o) => o -> Bool -> m ()
setSwipeTrackerAllowMouseDrag :: forall (m :: * -> *) o.
(MonadIO m, IsSwipeTracker o) =>
o -> Bool -> m ()
setSwipeTrackerAllowMouseDrag 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
"allow-mouse-drag" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@allow-mouse-drag@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSwipeTrackerAllowMouseDrag :: (IsSwipeTracker o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSwipeTrackerAllowMouseDrag :: forall o (m :: * -> *).
(IsSwipeTracker o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSwipeTrackerAllowMouseDrag 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
"allow-mouse-drag" Bool
val

#if defined(ENABLE_OVERLOADING)
data SwipeTrackerAllowMouseDragPropertyInfo
instance AttrInfo SwipeTrackerAllowMouseDragPropertyInfo where
    type AttrAllowedOps SwipeTrackerAllowMouseDragPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SwipeTrackerAllowMouseDragPropertyInfo = IsSwipeTracker
    type AttrSetTypeConstraint SwipeTrackerAllowMouseDragPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SwipeTrackerAllowMouseDragPropertyInfo = (~) Bool
    type AttrTransferType SwipeTrackerAllowMouseDragPropertyInfo = Bool
    type AttrGetType SwipeTrackerAllowMouseDragPropertyInfo = Bool
    type AttrLabel SwipeTrackerAllowMouseDragPropertyInfo = "allow-mouse-drag"
    type AttrOrigin SwipeTrackerAllowMouseDragPropertyInfo = SwipeTracker
    attrGet = getSwipeTrackerAllowMouseDrag
    attrSet = setSwipeTrackerAllowMouseDrag
    attrTransfer _ v = do
        return v
    attrConstruct = constructSwipeTrackerAllowMouseDrag
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.allowMouseDrag"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#g:attr:allowMouseDrag"
        })
#endif

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

-- | Get the value of the “@allow-window-handle@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' swipeTracker #allowWindowHandle
-- @
getSwipeTrackerAllowWindowHandle :: (MonadIO m, IsSwipeTracker o) => o -> m Bool
getSwipeTrackerAllowWindowHandle :: forall (m :: * -> *) o.
(MonadIO m, IsSwipeTracker o) =>
o -> m Bool
getSwipeTrackerAllowWindowHandle 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
"allow-window-handle"

-- | Set the value of the “@allow-window-handle@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' swipeTracker [ #allowWindowHandle 'Data.GI.Base.Attributes.:=' value ]
-- @
setSwipeTrackerAllowWindowHandle :: (MonadIO m, IsSwipeTracker o) => o -> Bool -> m ()
setSwipeTrackerAllowWindowHandle :: forall (m :: * -> *) o.
(MonadIO m, IsSwipeTracker o) =>
o -> Bool -> m ()
setSwipeTrackerAllowWindowHandle 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
"allow-window-handle" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@allow-window-handle@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSwipeTrackerAllowWindowHandle :: (IsSwipeTracker o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSwipeTrackerAllowWindowHandle :: forall o (m :: * -> *).
(IsSwipeTracker o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSwipeTrackerAllowWindowHandle 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
"allow-window-handle" Bool
val

#if defined(ENABLE_OVERLOADING)
data SwipeTrackerAllowWindowHandlePropertyInfo
instance AttrInfo SwipeTrackerAllowWindowHandlePropertyInfo where
    type AttrAllowedOps SwipeTrackerAllowWindowHandlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SwipeTrackerAllowWindowHandlePropertyInfo = IsSwipeTracker
    type AttrSetTypeConstraint SwipeTrackerAllowWindowHandlePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SwipeTrackerAllowWindowHandlePropertyInfo = (~) Bool
    type AttrTransferType SwipeTrackerAllowWindowHandlePropertyInfo = Bool
    type AttrGetType SwipeTrackerAllowWindowHandlePropertyInfo = Bool
    type AttrLabel SwipeTrackerAllowWindowHandlePropertyInfo = "allow-window-handle"
    type AttrOrigin SwipeTrackerAllowWindowHandlePropertyInfo = SwipeTracker
    attrGet = getSwipeTrackerAllowWindowHandle
    attrSet = setSwipeTrackerAllowWindowHandle
    attrTransfer _ v = do
        return v
    attrConstruct = constructSwipeTrackerAllowWindowHandle
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.allowWindowHandle"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#g:attr:allowWindowHandle"
        })
#endif

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

-- | Get the value of the “@enabled@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' swipeTracker #enabled
-- @
getSwipeTrackerEnabled :: (MonadIO m, IsSwipeTracker o) => o -> m Bool
getSwipeTrackerEnabled :: forall (m :: * -> *) o.
(MonadIO m, IsSwipeTracker o) =>
o -> m Bool
getSwipeTrackerEnabled 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
"enabled"

-- | Set the value of the “@enabled@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' swipeTracker [ #enabled 'Data.GI.Base.Attributes.:=' value ]
-- @
setSwipeTrackerEnabled :: (MonadIO m, IsSwipeTracker o) => o -> Bool -> m ()
setSwipeTrackerEnabled :: forall (m :: * -> *) o.
(MonadIO m, IsSwipeTracker o) =>
o -> Bool -> m ()
setSwipeTrackerEnabled 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
"enabled" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@enabled@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSwipeTrackerEnabled :: (IsSwipeTracker o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSwipeTrackerEnabled :: forall o (m :: * -> *).
(IsSwipeTracker o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSwipeTrackerEnabled 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
"enabled" Bool
val

#if defined(ENABLE_OVERLOADING)
data SwipeTrackerEnabledPropertyInfo
instance AttrInfo SwipeTrackerEnabledPropertyInfo where
    type AttrAllowedOps SwipeTrackerEnabledPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SwipeTrackerEnabledPropertyInfo = IsSwipeTracker
    type AttrSetTypeConstraint SwipeTrackerEnabledPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SwipeTrackerEnabledPropertyInfo = (~) Bool
    type AttrTransferType SwipeTrackerEnabledPropertyInfo = Bool
    type AttrGetType SwipeTrackerEnabledPropertyInfo = Bool
    type AttrLabel SwipeTrackerEnabledPropertyInfo = "enabled"
    type AttrOrigin SwipeTrackerEnabledPropertyInfo = SwipeTracker
    attrGet = getSwipeTrackerEnabled
    attrSet = setSwipeTrackerEnabled
    attrTransfer _ v = do
        return v
    attrConstruct = constructSwipeTrackerEnabled
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.enabled"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#g:attr:enabled"
        })
#endif

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

-- | Get the value of the “@lower-overshoot@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' swipeTracker #lowerOvershoot
-- @
getSwipeTrackerLowerOvershoot :: (MonadIO m, IsSwipeTracker o) => o -> m Bool
getSwipeTrackerLowerOvershoot :: forall (m :: * -> *) o.
(MonadIO m, IsSwipeTracker o) =>
o -> m Bool
getSwipeTrackerLowerOvershoot 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
"lower-overshoot"

-- | Set the value of the “@lower-overshoot@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' swipeTracker [ #lowerOvershoot 'Data.GI.Base.Attributes.:=' value ]
-- @
setSwipeTrackerLowerOvershoot :: (MonadIO m, IsSwipeTracker o) => o -> Bool -> m ()
setSwipeTrackerLowerOvershoot :: forall (m :: * -> *) o.
(MonadIO m, IsSwipeTracker o) =>
o -> Bool -> m ()
setSwipeTrackerLowerOvershoot 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
"lower-overshoot" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@lower-overshoot@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSwipeTrackerLowerOvershoot :: (IsSwipeTracker o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSwipeTrackerLowerOvershoot :: forall o (m :: * -> *).
(IsSwipeTracker o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSwipeTrackerLowerOvershoot 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
"lower-overshoot" Bool
val

#if defined(ENABLE_OVERLOADING)
data SwipeTrackerLowerOvershootPropertyInfo
instance AttrInfo SwipeTrackerLowerOvershootPropertyInfo where
    type AttrAllowedOps SwipeTrackerLowerOvershootPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SwipeTrackerLowerOvershootPropertyInfo = IsSwipeTracker
    type AttrSetTypeConstraint SwipeTrackerLowerOvershootPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SwipeTrackerLowerOvershootPropertyInfo = (~) Bool
    type AttrTransferType SwipeTrackerLowerOvershootPropertyInfo = Bool
    type AttrGetType SwipeTrackerLowerOvershootPropertyInfo = Bool
    type AttrLabel SwipeTrackerLowerOvershootPropertyInfo = "lower-overshoot"
    type AttrOrigin SwipeTrackerLowerOvershootPropertyInfo = SwipeTracker
    attrGet = getSwipeTrackerLowerOvershoot
    attrSet = setSwipeTrackerLowerOvershoot
    attrTransfer _ v = do
        return v
    attrConstruct = constructSwipeTrackerLowerOvershoot
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.lowerOvershoot"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#g:attr:lowerOvershoot"
        })
#endif

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

-- | Get the value of the “@reversed@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' swipeTracker #reversed
-- @
getSwipeTrackerReversed :: (MonadIO m, IsSwipeTracker o) => o -> m Bool
getSwipeTrackerReversed :: forall (m :: * -> *) o.
(MonadIO m, IsSwipeTracker o) =>
o -> m Bool
getSwipeTrackerReversed 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
"reversed"

-- | Set the value of the “@reversed@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' swipeTracker [ #reversed 'Data.GI.Base.Attributes.:=' value ]
-- @
setSwipeTrackerReversed :: (MonadIO m, IsSwipeTracker o) => o -> Bool -> m ()
setSwipeTrackerReversed :: forall (m :: * -> *) o.
(MonadIO m, IsSwipeTracker o) =>
o -> Bool -> m ()
setSwipeTrackerReversed 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
"reversed" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@reversed@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSwipeTrackerReversed :: (IsSwipeTracker o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSwipeTrackerReversed :: forall o (m :: * -> *).
(IsSwipeTracker o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSwipeTrackerReversed 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
"reversed" Bool
val

#if defined(ENABLE_OVERLOADING)
data SwipeTrackerReversedPropertyInfo
instance AttrInfo SwipeTrackerReversedPropertyInfo where
    type AttrAllowedOps SwipeTrackerReversedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SwipeTrackerReversedPropertyInfo = IsSwipeTracker
    type AttrSetTypeConstraint SwipeTrackerReversedPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SwipeTrackerReversedPropertyInfo = (~) Bool
    type AttrTransferType SwipeTrackerReversedPropertyInfo = Bool
    type AttrGetType SwipeTrackerReversedPropertyInfo = Bool
    type AttrLabel SwipeTrackerReversedPropertyInfo = "reversed"
    type AttrOrigin SwipeTrackerReversedPropertyInfo = SwipeTracker
    attrGet = getSwipeTrackerReversed
    attrSet = setSwipeTrackerReversed
    attrTransfer _ v = do
        return v
    attrConstruct = constructSwipeTrackerReversed
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.reversed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#g:attr:reversed"
        })
#endif

-- VVV Prop "swipeable"
   -- Type: TInterface (Name {namespace = "Adw", name = "Swipeable"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@swipeable@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' swipeTracker #swipeable
-- @
getSwipeTrackerSwipeable :: (MonadIO m, IsSwipeTracker o) => o -> m Adw.Swipeable.Swipeable
getSwipeTrackerSwipeable :: forall (m :: * -> *) o.
(MonadIO m, IsSwipeTracker o) =>
o -> m Swipeable
getSwipeTrackerSwipeable o
obj = IO Swipeable -> m Swipeable
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Swipeable -> m Swipeable) -> IO Swipeable -> m Swipeable
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Swipeable) -> IO Swipeable
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getSwipeTrackerSwipeable" (IO (Maybe Swipeable) -> IO Swipeable)
-> IO (Maybe Swipeable) -> IO Swipeable
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr Swipeable -> Swipeable)
-> IO (Maybe Swipeable)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"swipeable" ManagedPtr Swipeable -> Swipeable
Adw.Swipeable.Swipeable

-- | Construct a `GValueConstruct` with valid value for the “@swipeable@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSwipeTrackerSwipeable :: (IsSwipeTracker o, MIO.MonadIO m, Adw.Swipeable.IsSwipeable a) => a -> m (GValueConstruct o)
constructSwipeTrackerSwipeable :: forall o (m :: * -> *) a.
(IsSwipeTracker o, MonadIO m, IsSwipeable a) =>
a -> m (GValueConstruct o)
constructSwipeTrackerSwipeable a
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 -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"swipeable" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

#if defined(ENABLE_OVERLOADING)
data SwipeTrackerSwipeablePropertyInfo
instance AttrInfo SwipeTrackerSwipeablePropertyInfo where
    type AttrAllowedOps SwipeTrackerSwipeablePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SwipeTrackerSwipeablePropertyInfo = IsSwipeTracker
    type AttrSetTypeConstraint SwipeTrackerSwipeablePropertyInfo = Adw.Swipeable.IsSwipeable
    type AttrTransferTypeConstraint SwipeTrackerSwipeablePropertyInfo = Adw.Swipeable.IsSwipeable
    type AttrTransferType SwipeTrackerSwipeablePropertyInfo = Adw.Swipeable.Swipeable
    type AttrGetType SwipeTrackerSwipeablePropertyInfo = Adw.Swipeable.Swipeable
    type AttrLabel SwipeTrackerSwipeablePropertyInfo = "swipeable"
    type AttrOrigin SwipeTrackerSwipeablePropertyInfo = SwipeTracker
    attrGet = getSwipeTrackerSwipeable
    attrSet = undefined
    attrTransfer _ v = do
        unsafeCastTo Adw.Swipeable.Swipeable v
    attrConstruct = constructSwipeTrackerSwipeable
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.swipeable"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#g:attr:swipeable"
        })
#endif

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

-- | Get the value of the “@upper-overshoot@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' swipeTracker #upperOvershoot
-- @
getSwipeTrackerUpperOvershoot :: (MonadIO m, IsSwipeTracker o) => o -> m Bool
getSwipeTrackerUpperOvershoot :: forall (m :: * -> *) o.
(MonadIO m, IsSwipeTracker o) =>
o -> m Bool
getSwipeTrackerUpperOvershoot 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
"upper-overshoot"

-- | Set the value of the “@upper-overshoot@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' swipeTracker [ #upperOvershoot 'Data.GI.Base.Attributes.:=' value ]
-- @
setSwipeTrackerUpperOvershoot :: (MonadIO m, IsSwipeTracker o) => o -> Bool -> m ()
setSwipeTrackerUpperOvershoot :: forall (m :: * -> *) o.
(MonadIO m, IsSwipeTracker o) =>
o -> Bool -> m ()
setSwipeTrackerUpperOvershoot 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
"upper-overshoot" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@upper-overshoot@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSwipeTrackerUpperOvershoot :: (IsSwipeTracker o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructSwipeTrackerUpperOvershoot :: forall o (m :: * -> *).
(IsSwipeTracker o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructSwipeTrackerUpperOvershoot 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
"upper-overshoot" Bool
val

#if defined(ENABLE_OVERLOADING)
data SwipeTrackerUpperOvershootPropertyInfo
instance AttrInfo SwipeTrackerUpperOvershootPropertyInfo where
    type AttrAllowedOps SwipeTrackerUpperOvershootPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SwipeTrackerUpperOvershootPropertyInfo = IsSwipeTracker
    type AttrSetTypeConstraint SwipeTrackerUpperOvershootPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SwipeTrackerUpperOvershootPropertyInfo = (~) Bool
    type AttrTransferType SwipeTrackerUpperOvershootPropertyInfo = Bool
    type AttrGetType SwipeTrackerUpperOvershootPropertyInfo = Bool
    type AttrLabel SwipeTrackerUpperOvershootPropertyInfo = "upper-overshoot"
    type AttrOrigin SwipeTrackerUpperOvershootPropertyInfo = SwipeTracker
    attrGet = getSwipeTrackerUpperOvershoot
    attrSet = setSwipeTrackerUpperOvershoot
    attrTransfer _ v = do
        return v
    attrConstruct = constructSwipeTrackerUpperOvershoot
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.upperOvershoot"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#g:attr:upperOvershoot"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList SwipeTracker
type instance O.AttributeList SwipeTracker = SwipeTrackerAttributeList
type SwipeTrackerAttributeList = ('[ '("allowLongSwipes", SwipeTrackerAllowLongSwipesPropertyInfo), '("allowMouseDrag", SwipeTrackerAllowMouseDragPropertyInfo), '("allowWindowHandle", SwipeTrackerAllowWindowHandlePropertyInfo), '("enabled", SwipeTrackerEnabledPropertyInfo), '("lowerOvershoot", SwipeTrackerLowerOvershootPropertyInfo), '("orientation", Gtk.Orientable.OrientableOrientationPropertyInfo), '("reversed", SwipeTrackerReversedPropertyInfo), '("swipeable", SwipeTrackerSwipeablePropertyInfo), '("upperOvershoot", SwipeTrackerUpperOvershootPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
swipeTrackerAllowLongSwipes :: AttrLabelProxy "allowLongSwipes"
swipeTrackerAllowLongSwipes = AttrLabelProxy

swipeTrackerAllowMouseDrag :: AttrLabelProxy "allowMouseDrag"
swipeTrackerAllowMouseDrag = AttrLabelProxy

swipeTrackerAllowWindowHandle :: AttrLabelProxy "allowWindowHandle"
swipeTrackerAllowWindowHandle = AttrLabelProxy

swipeTrackerEnabled :: AttrLabelProxy "enabled"
swipeTrackerEnabled = AttrLabelProxy

swipeTrackerLowerOvershoot :: AttrLabelProxy "lowerOvershoot"
swipeTrackerLowerOvershoot = AttrLabelProxy

swipeTrackerReversed :: AttrLabelProxy "reversed"
swipeTrackerReversed = AttrLabelProxy

swipeTrackerSwipeable :: AttrLabelProxy "swipeable"
swipeTrackerSwipeable = AttrLabelProxy

swipeTrackerUpperOvershoot :: AttrLabelProxy "upperOvershoot"
swipeTrackerUpperOvershoot = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList SwipeTracker = SwipeTrackerSignalList
type SwipeTrackerSignalList = ('[ '("beginSwipe", SwipeTrackerBeginSwipeSignalInfo), '("endSwipe", SwipeTrackerEndSwipeSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("prepare", SwipeTrackerPrepareSignalInfo), '("updateSwipe", SwipeTrackerUpdateSwipeSignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method SwipeTracker::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "swipeable"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Swipeable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget to add the tracker on"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Adw" , name = "SwipeTracker" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_swipe_tracker_new" adw_swipe_tracker_new :: 
    Ptr Adw.Swipeable.Swipeable ->          -- swipeable : TInterface (Name {namespace = "Adw", name = "Swipeable"})
    IO (Ptr SwipeTracker)

-- | Creates a new @AdwSwipeTracker@ for /@widget@/.
swipeTrackerNew ::
    (B.CallStack.HasCallStack, MonadIO m, Adw.Swipeable.IsSwipeable a) =>
    a
    -- ^ /@swipeable@/: a widget to add the tracker on
    -> m SwipeTracker
    -- ^ __Returns:__ the newly created @AdwSwipeTracker@
swipeTrackerNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSwipeable a) =>
a -> m SwipeTracker
swipeTrackerNew a
swipeable = IO SwipeTracker -> m SwipeTracker
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SwipeTracker -> m SwipeTracker)
-> IO SwipeTracker -> m SwipeTracker
forall a b. (a -> b) -> a -> b
$ do
    Ptr Swipeable
swipeable' <- a -> IO (Ptr Swipeable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
swipeable
    Ptr SwipeTracker
result <- Ptr Swipeable -> IO (Ptr SwipeTracker)
adw_swipe_tracker_new Ptr Swipeable
swipeable'
    Text -> Ptr SwipeTracker -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"swipeTrackerNew" Ptr SwipeTracker
result
    SwipeTracker
result' <- ((ManagedPtr SwipeTracker -> SwipeTracker)
-> Ptr SwipeTracker -> IO SwipeTracker
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr SwipeTracker -> SwipeTracker
SwipeTracker) Ptr SwipeTracker
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
swipeable
    SwipeTracker -> IO SwipeTracker
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SwipeTracker
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "adw_swipe_tracker_get_allow_long_swipes" adw_swipe_tracker_get_allow_long_swipes :: 
    Ptr SwipeTracker ->                     -- self : TInterface (Name {namespace = "Adw", name = "SwipeTracker"})
    IO CInt

-- | Gets whether to allow swiping for more than one snap point at a time.
swipeTrackerGetAllowLongSwipes ::
    (B.CallStack.HasCallStack, MonadIO m, IsSwipeTracker a) =>
    a
    -- ^ /@self@/: a swipe tracker
    -> m Bool
    -- ^ __Returns:__ whether long swipes are allowed
swipeTrackerGetAllowLongSwipes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSwipeTracker a) =>
a -> m Bool
swipeTrackerGetAllowLongSwipes 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 SwipeTracker
self' <- a -> IO (Ptr SwipeTracker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr SwipeTracker -> IO CInt
adw_swipe_tracker_get_allow_long_swipes Ptr SwipeTracker
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 SwipeTrackerGetAllowLongSwipesMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSwipeTracker a) => O.OverloadedMethod SwipeTrackerGetAllowLongSwipesMethodInfo a signature where
    overloadedMethod = swipeTrackerGetAllowLongSwipes

instance O.OverloadedMethodInfo SwipeTrackerGetAllowLongSwipesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.swipeTrackerGetAllowLongSwipes",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#v:swipeTrackerGetAllowLongSwipes"
        })


#endif

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

foreign import ccall "adw_swipe_tracker_get_allow_mouse_drag" adw_swipe_tracker_get_allow_mouse_drag :: 
    Ptr SwipeTracker ->                     -- self : TInterface (Name {namespace = "Adw", name = "SwipeTracker"})
    IO CInt

-- | Gets whether /@self@/ can be dragged with mouse pointer.
swipeTrackerGetAllowMouseDrag ::
    (B.CallStack.HasCallStack, MonadIO m, IsSwipeTracker a) =>
    a
    -- ^ /@self@/: a swipe tracker
    -> m Bool
    -- ^ __Returns:__ whether mouse dragging is allowed
swipeTrackerGetAllowMouseDrag :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSwipeTracker a) =>
a -> m Bool
swipeTrackerGetAllowMouseDrag 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 SwipeTracker
self' <- a -> IO (Ptr SwipeTracker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr SwipeTracker -> IO CInt
adw_swipe_tracker_get_allow_mouse_drag Ptr SwipeTracker
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 SwipeTrackerGetAllowMouseDragMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSwipeTracker a) => O.OverloadedMethod SwipeTrackerGetAllowMouseDragMethodInfo a signature where
    overloadedMethod = swipeTrackerGetAllowMouseDrag

instance O.OverloadedMethodInfo SwipeTrackerGetAllowMouseDragMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.swipeTrackerGetAllowMouseDrag",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#v:swipeTrackerGetAllowMouseDrag"
        })


#endif

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

foreign import ccall "adw_swipe_tracker_get_allow_window_handle" adw_swipe_tracker_get_allow_window_handle :: 
    Ptr SwipeTracker ->                     -- self : TInterface (Name {namespace = "Adw", name = "SwipeTracker"})
    IO CInt

-- | Gets whether to allow touchscreen swiping from @GtkWindowHandle@.
-- 
-- /Since: 1.5/
swipeTrackerGetAllowWindowHandle ::
    (B.CallStack.HasCallStack, MonadIO m, IsSwipeTracker a) =>
    a
    -- ^ /@self@/: a swipe tracker
    -> m Bool
    -- ^ __Returns:__ whether swiping from window handles is allowed
swipeTrackerGetAllowWindowHandle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSwipeTracker a) =>
a -> m Bool
swipeTrackerGetAllowWindowHandle 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 SwipeTracker
self' <- a -> IO (Ptr SwipeTracker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr SwipeTracker -> IO CInt
adw_swipe_tracker_get_allow_window_handle Ptr SwipeTracker
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 SwipeTrackerGetAllowWindowHandleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSwipeTracker a) => O.OverloadedMethod SwipeTrackerGetAllowWindowHandleMethodInfo a signature where
    overloadedMethod = swipeTrackerGetAllowWindowHandle

instance O.OverloadedMethodInfo SwipeTrackerGetAllowWindowHandleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.swipeTrackerGetAllowWindowHandle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#v:swipeTrackerGetAllowWindowHandle"
        })


#endif

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

foreign import ccall "adw_swipe_tracker_get_enabled" adw_swipe_tracker_get_enabled :: 
    Ptr SwipeTracker ->                     -- self : TInterface (Name {namespace = "Adw", name = "SwipeTracker"})
    IO CInt

-- | Gets whether /@self@/ is enabled.
swipeTrackerGetEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsSwipeTracker a) =>
    a
    -- ^ /@self@/: a swipe tracker
    -> m Bool
    -- ^ __Returns:__ whether /@self@/ is enabled
swipeTrackerGetEnabled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSwipeTracker a) =>
a -> m Bool
swipeTrackerGetEnabled 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 SwipeTracker
self' <- a -> IO (Ptr SwipeTracker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr SwipeTracker -> IO CInt
adw_swipe_tracker_get_enabled Ptr SwipeTracker
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 SwipeTrackerGetEnabledMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSwipeTracker a) => O.OverloadedMethod SwipeTrackerGetEnabledMethodInfo a signature where
    overloadedMethod = swipeTrackerGetEnabled

instance O.OverloadedMethodInfo SwipeTrackerGetEnabledMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.swipeTrackerGetEnabled",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#v:swipeTrackerGetEnabled"
        })


#endif

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

foreign import ccall "adw_swipe_tracker_get_lower_overshoot" adw_swipe_tracker_get_lower_overshoot :: 
    Ptr SwipeTracker ->                     -- self : TInterface (Name {namespace = "Adw", name = "SwipeTracker"})
    IO CInt

-- | Gets whether to allow swiping past the first available snap point.
-- 
-- /Since: 1.4/
swipeTrackerGetLowerOvershoot ::
    (B.CallStack.HasCallStack, MonadIO m, IsSwipeTracker a) =>
    a
    -- ^ /@self@/: a swipe tracker
    -> m Bool
    -- ^ __Returns:__ whether to allow swiping past the first available snap point
swipeTrackerGetLowerOvershoot :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSwipeTracker a) =>
a -> m Bool
swipeTrackerGetLowerOvershoot 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 SwipeTracker
self' <- a -> IO (Ptr SwipeTracker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr SwipeTracker -> IO CInt
adw_swipe_tracker_get_lower_overshoot Ptr SwipeTracker
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 SwipeTrackerGetLowerOvershootMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSwipeTracker a) => O.OverloadedMethod SwipeTrackerGetLowerOvershootMethodInfo a signature where
    overloadedMethod = swipeTrackerGetLowerOvershoot

instance O.OverloadedMethodInfo SwipeTrackerGetLowerOvershootMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.swipeTrackerGetLowerOvershoot",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#v:swipeTrackerGetLowerOvershoot"
        })


#endif

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

foreign import ccall "adw_swipe_tracker_get_reversed" adw_swipe_tracker_get_reversed :: 
    Ptr SwipeTracker ->                     -- self : TInterface (Name {namespace = "Adw", name = "SwipeTracker"})
    IO CInt

-- | Gets whether /@self@/ is reversing the swipe direction.
swipeTrackerGetReversed ::
    (B.CallStack.HasCallStack, MonadIO m, IsSwipeTracker a) =>
    a
    -- ^ /@self@/: a swipe tracker
    -> m Bool
    -- ^ __Returns:__ whether the direction is reversed
swipeTrackerGetReversed :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSwipeTracker a) =>
a -> m Bool
swipeTrackerGetReversed 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 SwipeTracker
self' <- a -> IO (Ptr SwipeTracker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr SwipeTracker -> IO CInt
adw_swipe_tracker_get_reversed Ptr SwipeTracker
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 SwipeTrackerGetReversedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSwipeTracker a) => O.OverloadedMethod SwipeTrackerGetReversedMethodInfo a signature where
    overloadedMethod = swipeTrackerGetReversed

instance O.OverloadedMethodInfo SwipeTrackerGetReversedMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.swipeTrackerGetReversed",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#v:swipeTrackerGetReversed"
        })


#endif

-- method SwipeTracker::get_swipeable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SwipeTracker" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a swipe tracker" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Adw" , name = "Swipeable" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_swipe_tracker_get_swipeable" adw_swipe_tracker_get_swipeable :: 
    Ptr SwipeTracker ->                     -- self : TInterface (Name {namespace = "Adw", name = "SwipeTracker"})
    IO (Ptr Adw.Swipeable.Swipeable)

-- | Get the widget /@self@/ is attached to.
swipeTrackerGetSwipeable ::
    (B.CallStack.HasCallStack, MonadIO m, IsSwipeTracker a) =>
    a
    -- ^ /@self@/: a swipe tracker
    -> m Adw.Swipeable.Swipeable
    -- ^ __Returns:__ the swipeable widget
swipeTrackerGetSwipeable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSwipeTracker a) =>
a -> m Swipeable
swipeTrackerGetSwipeable a
self = IO Swipeable -> m Swipeable
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Swipeable -> m Swipeable) -> IO Swipeable -> m Swipeable
forall a b. (a -> b) -> a -> b
$ do
    Ptr SwipeTracker
self' <- a -> IO (Ptr SwipeTracker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Swipeable
result <- Ptr SwipeTracker -> IO (Ptr Swipeable)
adw_swipe_tracker_get_swipeable Ptr SwipeTracker
self'
    Text -> Ptr Swipeable -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"swipeTrackerGetSwipeable" Ptr Swipeable
result
    Swipeable
result' <- ((ManagedPtr Swipeable -> Swipeable)
-> Ptr Swipeable -> IO Swipeable
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Swipeable -> Swipeable
Adw.Swipeable.Swipeable) Ptr Swipeable
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Swipeable -> IO Swipeable
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Swipeable
result'

#if defined(ENABLE_OVERLOADING)
data SwipeTrackerGetSwipeableMethodInfo
instance (signature ~ (m Adw.Swipeable.Swipeable), MonadIO m, IsSwipeTracker a) => O.OverloadedMethod SwipeTrackerGetSwipeableMethodInfo a signature where
    overloadedMethod = swipeTrackerGetSwipeable

instance O.OverloadedMethodInfo SwipeTrackerGetSwipeableMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.swipeTrackerGetSwipeable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#v:swipeTrackerGetSwipeable"
        })


#endif

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

foreign import ccall "adw_swipe_tracker_get_upper_overshoot" adw_swipe_tracker_get_upper_overshoot :: 
    Ptr SwipeTracker ->                     -- self : TInterface (Name {namespace = "Adw", name = "SwipeTracker"})
    IO CInt

-- | Gets whether to allow swiping past the last available snap point.
-- 
-- /Since: 1.4/
swipeTrackerGetUpperOvershoot ::
    (B.CallStack.HasCallStack, MonadIO m, IsSwipeTracker a) =>
    a
    -- ^ /@self@/: a swipe tracker
    -> m Bool
    -- ^ __Returns:__ whether to allow swiping past the last available snap point
swipeTrackerGetUpperOvershoot :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSwipeTracker a) =>
a -> m Bool
swipeTrackerGetUpperOvershoot 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 SwipeTracker
self' <- a -> IO (Ptr SwipeTracker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr SwipeTracker -> IO CInt
adw_swipe_tracker_get_upper_overshoot Ptr SwipeTracker
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 SwipeTrackerGetUpperOvershootMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSwipeTracker a) => O.OverloadedMethod SwipeTrackerGetUpperOvershootMethodInfo a signature where
    overloadedMethod = swipeTrackerGetUpperOvershoot

instance O.OverloadedMethodInfo SwipeTrackerGetUpperOvershootMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.swipeTrackerGetUpperOvershoot",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#v:swipeTrackerGetUpperOvershoot"
        })


#endif

-- method SwipeTracker::set_allow_long_swipes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SwipeTracker" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a swipe tracker" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "allow_long_swipes"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to allow long swipes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_swipe_tracker_set_allow_long_swipes" adw_swipe_tracker_set_allow_long_swipes :: 
    Ptr SwipeTracker ->                     -- self : TInterface (Name {namespace = "Adw", name = "SwipeTracker"})
    CInt ->                                 -- allow_long_swipes : TBasicType TBoolean
    IO ()

-- | Sets whether to allow swiping for more than one snap point at a time.
-- 
-- If the value is @FALSE@, each swipe can only move to the adjacent snap
-- points.
swipeTrackerSetAllowLongSwipes ::
    (B.CallStack.HasCallStack, MonadIO m, IsSwipeTracker a) =>
    a
    -- ^ /@self@/: a swipe tracker
    -> Bool
    -- ^ /@allowLongSwipes@/: whether to allow long swipes
    -> m ()
swipeTrackerSetAllowLongSwipes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSwipeTracker a) =>
a -> Bool -> m ()
swipeTrackerSetAllowLongSwipes a
self Bool
allowLongSwipes = 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 SwipeTracker
self' <- a -> IO (Ptr SwipeTracker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let allowLongSwipes' :: CInt
allowLongSwipes' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
allowLongSwipes
    Ptr SwipeTracker -> CInt -> IO ()
adw_swipe_tracker_set_allow_long_swipes Ptr SwipeTracker
self' CInt
allowLongSwipes'
    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 SwipeTrackerSetAllowLongSwipesMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSwipeTracker a) => O.OverloadedMethod SwipeTrackerSetAllowLongSwipesMethodInfo a signature where
    overloadedMethod = swipeTrackerSetAllowLongSwipes

instance O.OverloadedMethodInfo SwipeTrackerSetAllowLongSwipesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.swipeTrackerSetAllowLongSwipes",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#v:swipeTrackerSetAllowLongSwipes"
        })


#endif

-- method SwipeTracker::set_allow_mouse_drag
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SwipeTracker" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a swipe tracker" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "allow_mouse_drag"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to allow mouse dragging"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_swipe_tracker_set_allow_mouse_drag" adw_swipe_tracker_set_allow_mouse_drag :: 
    Ptr SwipeTracker ->                     -- self : TInterface (Name {namespace = "Adw", name = "SwipeTracker"})
    CInt ->                                 -- allow_mouse_drag : TBasicType TBoolean
    IO ()

-- | Sets whether /@self@/ can be dragged with mouse pointer.
swipeTrackerSetAllowMouseDrag ::
    (B.CallStack.HasCallStack, MonadIO m, IsSwipeTracker a) =>
    a
    -- ^ /@self@/: a swipe tracker
    -> Bool
    -- ^ /@allowMouseDrag@/: whether to allow mouse dragging
    -> m ()
swipeTrackerSetAllowMouseDrag :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSwipeTracker a) =>
a -> Bool -> m ()
swipeTrackerSetAllowMouseDrag a
self Bool
allowMouseDrag = 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 SwipeTracker
self' <- a -> IO (Ptr SwipeTracker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let allowMouseDrag' :: CInt
allowMouseDrag' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
allowMouseDrag
    Ptr SwipeTracker -> CInt -> IO ()
adw_swipe_tracker_set_allow_mouse_drag Ptr SwipeTracker
self' CInt
allowMouseDrag'
    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 SwipeTrackerSetAllowMouseDragMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSwipeTracker a) => O.OverloadedMethod SwipeTrackerSetAllowMouseDragMethodInfo a signature where
    overloadedMethod = swipeTrackerSetAllowMouseDrag

instance O.OverloadedMethodInfo SwipeTrackerSetAllowMouseDragMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.swipeTrackerSetAllowMouseDrag",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#v:swipeTrackerSetAllowMouseDrag"
        })


#endif

-- method SwipeTracker::set_allow_window_handle
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SwipeTracker" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a swipe tracker" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "allow_window_handle"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to allow swiping from window handles"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_swipe_tracker_set_allow_window_handle" adw_swipe_tracker_set_allow_window_handle :: 
    Ptr SwipeTracker ->                     -- self : TInterface (Name {namespace = "Adw", name = "SwipeTracker"})
    CInt ->                                 -- allow_window_handle : TBasicType TBoolean
    IO ()

-- | Sets whether to allow touchscreen swiping from @GtkWindowHandle@.
-- 
-- Setting it to @TRUE@ will make dragging the window impossible.
-- 
-- /Since: 1.5/
swipeTrackerSetAllowWindowHandle ::
    (B.CallStack.HasCallStack, MonadIO m, IsSwipeTracker a) =>
    a
    -- ^ /@self@/: a swipe tracker
    -> Bool
    -- ^ /@allowWindowHandle@/: whether to allow swiping from window handles
    -> m ()
swipeTrackerSetAllowWindowHandle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSwipeTracker a) =>
a -> Bool -> m ()
swipeTrackerSetAllowWindowHandle a
self Bool
allowWindowHandle = 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 SwipeTracker
self' <- a -> IO (Ptr SwipeTracker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let allowWindowHandle' :: CInt
allowWindowHandle' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
allowWindowHandle
    Ptr SwipeTracker -> CInt -> IO ()
adw_swipe_tracker_set_allow_window_handle Ptr SwipeTracker
self' CInt
allowWindowHandle'
    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 SwipeTrackerSetAllowWindowHandleMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSwipeTracker a) => O.OverloadedMethod SwipeTrackerSetAllowWindowHandleMethodInfo a signature where
    overloadedMethod = swipeTrackerSetAllowWindowHandle

instance O.OverloadedMethodInfo SwipeTrackerSetAllowWindowHandleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.swipeTrackerSetAllowWindowHandle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#v:swipeTrackerSetAllowWindowHandle"
        })


#endif

-- method SwipeTracker::set_enabled
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SwipeTracker" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a swipe tracker" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enabled"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether @self is enabled"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_swipe_tracker_set_enabled" adw_swipe_tracker_set_enabled :: 
    Ptr SwipeTracker ->                     -- self : TInterface (Name {namespace = "Adw", name = "SwipeTracker"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

-- | Sets whether /@self@/ is enabled.
-- 
-- When it\'s not enabled, no events will be processed. Usually widgets will want
-- to expose this via a property.
swipeTrackerSetEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsSwipeTracker a) =>
    a
    -- ^ /@self@/: a swipe tracker
    -> Bool
    -- ^ /@enabled@/: whether /@self@/ is enabled
    -> m ()
swipeTrackerSetEnabled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSwipeTracker a) =>
a -> Bool -> m ()
swipeTrackerSetEnabled a
self Bool
enabled = 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 SwipeTracker
self' <- a -> IO (Ptr SwipeTracker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let enabled' :: CInt
enabled' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
enabled
    Ptr SwipeTracker -> CInt -> IO ()
adw_swipe_tracker_set_enabled Ptr SwipeTracker
self' CInt
enabled'
    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 SwipeTrackerSetEnabledMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSwipeTracker a) => O.OverloadedMethod SwipeTrackerSetEnabledMethodInfo a signature where
    overloadedMethod = swipeTrackerSetEnabled

instance O.OverloadedMethodInfo SwipeTrackerSetEnabledMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.swipeTrackerSetEnabled",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#v:swipeTrackerSetEnabled"
        })


#endif

-- method SwipeTracker::set_lower_overshoot
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SwipeTracker" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a swipe tracker" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "overshoot"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether to allow swiping past the first available snap point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_swipe_tracker_set_lower_overshoot" adw_swipe_tracker_set_lower_overshoot :: 
    Ptr SwipeTracker ->                     -- self : TInterface (Name {namespace = "Adw", name = "SwipeTracker"})
    CInt ->                                 -- overshoot : TBasicType TBoolean
    IO ()

-- | Sets whether to allow swiping past the first available snap point.
-- 
-- /Since: 1.4/
swipeTrackerSetLowerOvershoot ::
    (B.CallStack.HasCallStack, MonadIO m, IsSwipeTracker a) =>
    a
    -- ^ /@self@/: a swipe tracker
    -> Bool
    -- ^ /@overshoot@/: whether to allow swiping past the first available snap point
    -> m ()
swipeTrackerSetLowerOvershoot :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSwipeTracker a) =>
a -> Bool -> m ()
swipeTrackerSetLowerOvershoot a
self Bool
overshoot = 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 SwipeTracker
self' <- a -> IO (Ptr SwipeTracker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let overshoot' :: CInt
overshoot' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
overshoot
    Ptr SwipeTracker -> CInt -> IO ()
adw_swipe_tracker_set_lower_overshoot Ptr SwipeTracker
self' CInt
overshoot'
    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 SwipeTrackerSetLowerOvershootMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSwipeTracker a) => O.OverloadedMethod SwipeTrackerSetLowerOvershootMethodInfo a signature where
    overloadedMethod = swipeTrackerSetLowerOvershoot

instance O.OverloadedMethodInfo SwipeTrackerSetLowerOvershootMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.swipeTrackerSetLowerOvershoot",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#v:swipeTrackerSetLowerOvershoot"
        })


#endif

-- method SwipeTracker::set_reversed
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SwipeTracker" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a swipe tracker" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "reversed"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to reverse the swipe direction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_swipe_tracker_set_reversed" adw_swipe_tracker_set_reversed :: 
    Ptr SwipeTracker ->                     -- self : TInterface (Name {namespace = "Adw", name = "SwipeTracker"})
    CInt ->                                 -- reversed : TBasicType TBoolean
    IO ()

-- | Sets whether to reverse the swipe direction.
-- 
-- If the swipe tracker is horizontal, it can be used for supporting RTL text
-- direction.
swipeTrackerSetReversed ::
    (B.CallStack.HasCallStack, MonadIO m, IsSwipeTracker a) =>
    a
    -- ^ /@self@/: a swipe tracker
    -> Bool
    -- ^ /@reversed@/: whether to reverse the swipe direction
    -> m ()
swipeTrackerSetReversed :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSwipeTracker a) =>
a -> Bool -> m ()
swipeTrackerSetReversed a
self Bool
reversed = 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 SwipeTracker
self' <- a -> IO (Ptr SwipeTracker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let reversed' :: CInt
reversed' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
reversed
    Ptr SwipeTracker -> CInt -> IO ()
adw_swipe_tracker_set_reversed Ptr SwipeTracker
self' CInt
reversed'
    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 SwipeTrackerSetReversedMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSwipeTracker a) => O.OverloadedMethod SwipeTrackerSetReversedMethodInfo a signature where
    overloadedMethod = swipeTrackerSetReversed

instance O.OverloadedMethodInfo SwipeTrackerSetReversedMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.swipeTrackerSetReversed",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#v:swipeTrackerSetReversed"
        })


#endif

-- method SwipeTracker::set_upper_overshoot
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SwipeTracker" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a swipe tracker" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "overshoot"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether to allow swiping past the last available snap point"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_swipe_tracker_set_upper_overshoot" adw_swipe_tracker_set_upper_overshoot :: 
    Ptr SwipeTracker ->                     -- self : TInterface (Name {namespace = "Adw", name = "SwipeTracker"})
    CInt ->                                 -- overshoot : TBasicType TBoolean
    IO ()

-- | Sets whether to allow swiping past the last available snap point.
-- 
-- /Since: 1.4/
swipeTrackerSetUpperOvershoot ::
    (B.CallStack.HasCallStack, MonadIO m, IsSwipeTracker a) =>
    a
    -- ^ /@self@/: a swipe tracker
    -> Bool
    -- ^ /@overshoot@/: whether to allow swiping past the last available snap point
    -> m ()
swipeTrackerSetUpperOvershoot :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSwipeTracker a) =>
a -> Bool -> m ()
swipeTrackerSetUpperOvershoot a
self Bool
overshoot = 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 SwipeTracker
self' <- a -> IO (Ptr SwipeTracker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let overshoot' :: CInt
overshoot' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
overshoot
    Ptr SwipeTracker -> CInt -> IO ()
adw_swipe_tracker_set_upper_overshoot Ptr SwipeTracker
self' CInt
overshoot'
    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 SwipeTrackerSetUpperOvershootMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSwipeTracker a) => O.OverloadedMethod SwipeTrackerSetUpperOvershootMethodInfo a signature where
    overloadedMethod = swipeTrackerSetUpperOvershoot

instance O.OverloadedMethodInfo SwipeTrackerSetUpperOvershootMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.swipeTrackerSetUpperOvershoot",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#v:swipeTrackerSetUpperOvershoot"
        })


#endif

-- method SwipeTracker::shift_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SwipeTracker" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a swipe tracker" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "delta"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the position delta" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_swipe_tracker_shift_position" adw_swipe_tracker_shift_position :: 
    Ptr SwipeTracker ->                     -- self : TInterface (Name {namespace = "Adw", name = "SwipeTracker"})
    CDouble ->                              -- delta : TBasicType TDouble
    IO ()

-- | Moves the current progress value by /@delta@/.
-- 
-- This can be used to adjust the current position if snap points move during
-- the gesture.
swipeTrackerShiftPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsSwipeTracker a) =>
    a
    -- ^ /@self@/: a swipe tracker
    -> Double
    -- ^ /@delta@/: the position delta
    -> m ()
swipeTrackerShiftPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSwipeTracker a) =>
a -> Double -> m ()
swipeTrackerShiftPosition a
self Double
delta = 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 SwipeTracker
self' <- a -> IO (Ptr SwipeTracker)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let delta' :: CDouble
delta' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
delta
    Ptr SwipeTracker -> CDouble -> IO ()
adw_swipe_tracker_shift_position Ptr SwipeTracker
self' CDouble
delta'
    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 SwipeTrackerShiftPositionMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsSwipeTracker a) => O.OverloadedMethod SwipeTrackerShiftPositionMethodInfo a signature where
    overloadedMethod = swipeTrackerShiftPosition

instance O.OverloadedMethodInfo SwipeTrackerShiftPositionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SwipeTracker.swipeTrackerShiftPosition",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SwipeTracker.html#v:swipeTrackerShiftPosition"
        })


#endif