    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- The t'GI.Gdk.Objects.Seat.Seat' object represents a collection of input devices
    -- that belong to a user.

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Gdk.Objects.Seat
        (

    -- * Exported types
        Seat(..)                                ,
        IsSeat                                  ,
        toSeat                                  ,

     -- * Methods
    -- ** Overloaded methods #method:Overloaded methods#

    #if defined(ENABLE_OVERLOADING)
        ResolveSeatMethod                       ,
    #endif

    -- ** getCapabilities #method:getCapabilities#

    #if defined(ENABLE_OVERLOADING)
        SeatGetCapabilitiesMethodInfo           ,
    #endif
        seatGetCapabilities                     ,

    -- ** getDisplay #method:getDisplay#

    #if defined(ENABLE_OVERLOADING)
        SeatGetDisplayMethodInfo                ,
    #endif
        seatGetDisplay                          ,

    -- ** getKeyboard #method:getKeyboard#

    #if defined(ENABLE_OVERLOADING)
        SeatGetKeyboardMethodInfo               ,
    #endif
        seatGetKeyboard                         ,

    -- ** getPointer #method:getPointer#

    #if defined(ENABLE_OVERLOADING)
        SeatGetPointerMethodInfo                ,
    #endif
        seatGetPointer                          ,

    -- ** getSlaves #method:getSlaves#

    #if defined(ENABLE_OVERLOADING)
        SeatGetSlavesMethodInfo                 ,
    #endif
        seatGetSlaves                           ,

    -- ** grab #method:grab#

    #if defined(ENABLE_OVERLOADING)
        SeatGrabMethodInfo                      ,
    #endif
        seatGrab                                ,

    -- ** ungrab #method:ungrab#

    #if defined(ENABLE_OVERLOADING)
        SeatUngrabMethodInfo                    ,
    #endif
        seatUngrab                              ,

     -- * Properties
    -- ** display #attr:display#
    -- | t'GI.Gdk.Objects.Display.Display' of this seat.
    --
    -- /Since: 3.20/

    #if defined(ENABLE_OVERLOADING)
        SeatDisplayPropertyInfo                 ,
    #endif
        constructSeatDisplay                    ,
        getSeatDisplay                          ,
    #if defined(ENABLE_OVERLOADING)
        seatDisplay                             ,
    #endif

     -- * Signals
    -- ** deviceAdded #signal:deviceAdded#

        C_SeatDeviceAddedCallback               ,
        SeatDeviceAddedCallback                 ,
    #if defined(ENABLE_OVERLOADING)
        SeatDeviceAddedSignalInfo               ,
    #endif
        afterSeatDeviceAdded                    ,
        genClosure_SeatDeviceAdded              ,
        mk_SeatDeviceAddedCallback              ,
        noSeatDeviceAddedCallback               ,
        onSeatDeviceAdded                       ,
        wrap_SeatDeviceAddedCallback            ,

    -- ** deviceRemoved #signal:deviceRemoved#

        C_SeatDeviceRemovedCallback             ,
        SeatDeviceRemovedCallback               ,
    #if defined(ENABLE_OVERLOADING)
        SeatDeviceRemovedSignalInfo             ,
    #endif
        afterSeatDeviceRemoved                  ,
        genClosure_SeatDeviceRemoved            ,
        mk_SeatDeviceRemovedCallback            ,
        noSeatDeviceRemovedCallback             ,
        onSeatDeviceRemoved                     ,
        wrap_SeatDeviceRemovedCallback          ,

    -- ** toolAdded #signal:toolAdded#

        C_SeatToolAddedCallback                 ,
        SeatToolAddedCallback                   ,
    #if defined(ENABLE_OVERLOADING)
        SeatToolAddedSignalInfo                 ,
    #endif
        afterSeatToolAdded                      ,
        genClosure_SeatToolAdded                ,
        mk_SeatToolAddedCallback                ,
        noSeatToolAddedCallback                 ,
        onSeatToolAdded                         ,
        wrap_SeatToolAddedCallback              ,

    -- ** toolRemoved #signal:toolRemoved#

        C_SeatToolRemovedCallback               ,
        SeatToolRemovedCallback                 ,
    #if defined(ENABLE_OVERLOADING)
        SeatToolRemovedSignalInfo               ,
    #endif
        afterSeatToolRemoved                    ,
        genClosure_SeatToolRemoved              ,
        mk_SeatToolRemovedCallback              ,
        noSeatToolRemovedCallback               ,
        onSeatToolRemoved                       ,
        wrap_SeatToolRemovedCallback            ,

        ) 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.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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL

    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gdk.Callbacks as Gdk.Callbacks
    import {-# SOURCE #-} qualified GI.Gdk.Enums as Gdk.Enums
    import {-# SOURCE #-} qualified GI.Gdk.Flags as Gdk.Flags
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Cursor as Gdk.Cursor
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Device as Gdk.Device
    import {-# SOURCE #-} qualified GI.Gdk.Objects.DeviceTool as Gdk.DeviceTool
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Display as Gdk.Display
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Window as Gdk.Window
    import {-# SOURCE #-} qualified GI.Gdk.Unions.Event as Gdk.Event

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

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

    foreign import ccall "gdk_seat_get_type"
        c_gdk_seat_get_type :: IO B.Types.GType

    instance B.Types.TypedObject Seat where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_seat_get_type

    instance B.Types.GObject Seat

    -- | Convert 'Seat' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue Seat where
        toGValue :: Seat -> IO GValue
    toGValue o :: Seat
    o = do
            GType
    gtype <- IO GType
    c_gdk_seat_get_type
            Seat -> (Ptr Seat -> IO GValue) -> IO GValue
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr Seat
    o (GType -> (GValue -> Ptr Seat -> IO ()) -> Ptr Seat -> IO GValue
    forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
    B.GValue.buildGValue GType
    gtype GValue -> Ptr Seat -> IO ()
    forall a. GObject a => GValue -> Ptr a -> IO ()
    B.GValue.set_object)

        fromGValue :: GValue -> IO Seat
    fromGValue gv :: GValue
    gv = do
            Ptr Seat
    ptr <- GValue -> IO (Ptr Seat)
    forall b. GObject b => GValue -> IO (Ptr b)
    B.GValue.get_object GValue
    gv :: IO (Ptr Seat)
            (ManagedPtr Seat -> Seat) -> Ptr Seat -> IO Seat
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    B.ManagedPtr.newObject ManagedPtr Seat -> Seat
    Seat Ptr Seat
    ptr

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

    instance O.HasParentTypes Seat
    type instance O.ParentTypes Seat = '[GObject.Object.Object]

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

    #if defined(ENABLE_OVERLOADING)
    type family ResolveSeatMethod (t :: Symbol) (o :: *) :: * where
        ResolveSeatMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveSeatMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveSeatMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveSeatMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveSeatMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveSeatMethod "grab" o = SeatGrabMethodInfo
        ResolveSeatMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveSeatMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveSeatMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveSeatMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveSeatMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveSeatMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveSeatMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveSeatMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveSeatMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveSeatMethod "ungrab" o = SeatUngrabMethodInfo
        ResolveSeatMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveSeatMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveSeatMethod "getCapabilities" o = SeatGetCapabilitiesMethodInfo
        ResolveSeatMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveSeatMethod "getDisplay" o = SeatGetDisplayMethodInfo
        ResolveSeatMethod "getKeyboard" o = SeatGetKeyboardMethodInfo
        ResolveSeatMethod "getPointer" o = SeatGetPointerMethodInfo
        ResolveSeatMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveSeatMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveSeatMethod "getSlaves" o = SeatGetSlavesMethodInfo
        ResolveSeatMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveSeatMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveSeatMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveSeatMethod l o = O.MethodResolutionFailed l o

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

    #endif

    -- signal Seat::device-added
    -- | The [deviceAdded](#g:signal:deviceAdded) signal is emitted when a new input
    -- device is related to this seat.
    --
    -- /Since: 3.20/
    type SeatDeviceAddedCallback =
        Gdk.Device.Device
        -- ^ /@device@/: the newly added t'GI.Gdk.Objects.Device.Device'.
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `SeatDeviceAddedCallback`@.
    noSeatDeviceAddedCallback :: Maybe SeatDeviceAddedCallback
    noSeatDeviceAddedCallback :: Maybe SeatDeviceAddedCallback
    noSeatDeviceAddedCallback = Maybe SeatDeviceAddedCallback
    forall a. Maybe a
    Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_SeatDeviceAddedCallback =
        Ptr () ->                               -- object
        Ptr Gdk.Device.Device ->
        Ptr () ->                               -- user_data
        IO ()

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_SeatDeviceAdded :: MonadIO m => SeatDeviceAddedCallback -> m (GClosure C_SeatDeviceAddedCallback)
    genClosure_SeatDeviceAdded :: SeatDeviceAddedCallback -> m (GClosure C_SeatDeviceAddedCallback)
    genClosure_SeatDeviceAdded cb :: SeatDeviceAddedCallback
    cb = IO (GClosure C_SeatDeviceAddedCallback)
    -> m (GClosure C_SeatDeviceAddedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_SeatDeviceAddedCallback)
     -> m (GClosure C_SeatDeviceAddedCallback))
    -> IO (GClosure C_SeatDeviceAddedCallback)
    -> m (GClosure C_SeatDeviceAddedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_SeatDeviceAddedCallback
    cb' = SeatDeviceAddedCallback -> C_SeatDeviceAddedCallback
    wrap_SeatDeviceAddedCallback SeatDeviceAddedCallback
    cb
        C_SeatDeviceAddedCallback -> IO (FunPtr C_SeatDeviceAddedCallback)
    mk_SeatDeviceAddedCallback C_SeatDeviceAddedCallback
    cb' IO (FunPtr C_SeatDeviceAddedCallback)
    -> (FunPtr C_SeatDeviceAddedCallback
        -> IO (GClosure C_SeatDeviceAddedCallback))
    -> IO (GClosure C_SeatDeviceAddedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_SeatDeviceAddedCallback
    -> IO (GClosure C_SeatDeviceAddedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `SeatDeviceAddedCallback` into a `C_SeatDeviceAddedCallback`.
    wrap_SeatDeviceAddedCallback ::
        SeatDeviceAddedCallback ->
        C_SeatDeviceAddedCallback
    wrap_SeatDeviceAddedCallback :: SeatDeviceAddedCallback -> C_SeatDeviceAddedCallback
    wrap_SeatDeviceAddedCallback _cb :: SeatDeviceAddedCallback
    _cb _ device :: Ptr Device
    device _ = do
        Device
    device' <- ((ManagedPtr Device -> Device) -> Ptr Device -> IO Device
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Device -> Device
    Gdk.Device.Device) Ptr Device
    device
        SeatDeviceAddedCallback
    _cb  Device
    device'

    -- | Connect a signal handler for the [deviceAdded](#signal:deviceAdded) 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' seat #deviceAdded callback
    -- @
    --
    --
    onSeatDeviceAdded :: (IsSeat a, MonadIO m) => a -> SeatDeviceAddedCallback -> m SignalHandlerId
    onSeatDeviceAdded :: a -> SeatDeviceAddedCallback -> m SignalHandlerId
    onSeatDeviceAdded obj :: a
    obj cb :: SeatDeviceAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_SeatDeviceAddedCallback
    cb' = SeatDeviceAddedCallback -> C_SeatDeviceAddedCallback
    wrap_SeatDeviceAddedCallback SeatDeviceAddedCallback
    cb
        FunPtr C_SeatDeviceAddedCallback
    cb'' <- C_SeatDeviceAddedCallback -> IO (FunPtr C_SeatDeviceAddedCallback)
    mk_SeatDeviceAddedCallback C_SeatDeviceAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_SeatDeviceAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "device-added" FunPtr C_SeatDeviceAddedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [deviceAdded](#signal:deviceAdded) 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' seat #deviceAdded callback
    -- @
    --
    --
    afterSeatDeviceAdded :: (IsSeat a, MonadIO m) => a -> SeatDeviceAddedCallback -> m SignalHandlerId
    afterSeatDeviceAdded :: a -> SeatDeviceAddedCallback -> m SignalHandlerId
    afterSeatDeviceAdded obj :: a
    obj cb :: SeatDeviceAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_SeatDeviceAddedCallback
    cb' = SeatDeviceAddedCallback -> C_SeatDeviceAddedCallback
    wrap_SeatDeviceAddedCallback SeatDeviceAddedCallback
    cb
        FunPtr C_SeatDeviceAddedCallback
    cb'' <- C_SeatDeviceAddedCallback -> IO (FunPtr C_SeatDeviceAddedCallback)
    mk_SeatDeviceAddedCallback C_SeatDeviceAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_SeatDeviceAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "device-added" FunPtr C_SeatDeviceAddedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data SeatDeviceAddedSignalInfo
    instance SignalInfo SeatDeviceAddedSignalInfo where
        type HaskellCallbackType SeatDeviceAddedSignalInfo = SeatDeviceAddedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_SeatDeviceAddedCallback cb
            cb'' <- mk_SeatDeviceAddedCallback cb'
            connectSignalFunPtr obj "device-added" cb'' connectMode detail

    #endif

    -- signal Seat::device-removed
    -- | The [deviceRemoved](#g:signal:deviceRemoved) signal is emitted when an
    -- input device is removed (e.g. unplugged).
    --
    -- /Since: 3.20/
    type SeatDeviceRemovedCallback =
        Gdk.Device.Device
        -- ^ /@device@/: the just removed t'GI.Gdk.Objects.Device.Device'.
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `SeatDeviceRemovedCallback`@.
    noSeatDeviceRemovedCallback :: Maybe SeatDeviceRemovedCallback
    noSeatDeviceRemovedCallback :: Maybe SeatDeviceAddedCallback
    noSeatDeviceRemovedCallback = Maybe SeatDeviceAddedCallback
    forall a. Maybe a
    Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_SeatDeviceRemovedCallback =
        Ptr () ->                               -- object
        Ptr Gdk.Device.Device ->
        Ptr () ->                               -- user_data
        IO ()

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_SeatDeviceRemoved :: MonadIO m => SeatDeviceRemovedCallback -> m (GClosure C_SeatDeviceRemovedCallback)
    genClosure_SeatDeviceRemoved :: SeatDeviceAddedCallback -> m (GClosure C_SeatDeviceAddedCallback)
    genClosure_SeatDeviceRemoved cb :: SeatDeviceAddedCallback
    cb = IO (GClosure C_SeatDeviceAddedCallback)
    -> m (GClosure C_SeatDeviceAddedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_SeatDeviceAddedCallback)
     -> m (GClosure C_SeatDeviceAddedCallback))
    -> IO (GClosure C_SeatDeviceAddedCallback)
    -> m (GClosure C_SeatDeviceAddedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_SeatDeviceAddedCallback
    cb' = SeatDeviceAddedCallback -> C_SeatDeviceAddedCallback
    wrap_SeatDeviceRemovedCallback SeatDeviceAddedCallback
    cb
        C_SeatDeviceAddedCallback -> IO (FunPtr C_SeatDeviceAddedCallback)
    mk_SeatDeviceRemovedCallback C_SeatDeviceAddedCallback
    cb' IO (FunPtr C_SeatDeviceAddedCallback)
    -> (FunPtr C_SeatDeviceAddedCallback
        -> IO (GClosure C_SeatDeviceAddedCallback))
    -> IO (GClosure C_SeatDeviceAddedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_SeatDeviceAddedCallback
    -> IO (GClosure C_SeatDeviceAddedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `SeatDeviceRemovedCallback` into a `C_SeatDeviceRemovedCallback`.
    wrap_SeatDeviceRemovedCallback ::
        SeatDeviceRemovedCallback ->
        C_SeatDeviceRemovedCallback
    wrap_SeatDeviceRemovedCallback :: SeatDeviceAddedCallback -> C_SeatDeviceAddedCallback
    wrap_SeatDeviceRemovedCallback _cb :: SeatDeviceAddedCallback
    _cb _ device :: Ptr Device
    device _ = do
        Device
    device' <- ((ManagedPtr Device -> Device) -> Ptr Device -> IO Device
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Device -> Device
    Gdk.Device.Device) Ptr Device
    device
        SeatDeviceAddedCallback
    _cb  Device
    device'

    -- | Connect a signal handler for the [deviceRemoved](#signal:deviceRemoved) 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' seat #deviceRemoved callback
    -- @
    --
    --
    onSeatDeviceRemoved :: (IsSeat a, MonadIO m) => a -> SeatDeviceRemovedCallback -> m SignalHandlerId
    onSeatDeviceRemoved :: a -> SeatDeviceAddedCallback -> m SignalHandlerId
    onSeatDeviceRemoved obj :: a
    obj cb :: SeatDeviceAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_SeatDeviceAddedCallback
    cb' = SeatDeviceAddedCallback -> C_SeatDeviceAddedCallback
    wrap_SeatDeviceRemovedCallback SeatDeviceAddedCallback
    cb
        FunPtr C_SeatDeviceAddedCallback
    cb'' <- C_SeatDeviceAddedCallback -> IO (FunPtr C_SeatDeviceAddedCallback)
    mk_SeatDeviceRemovedCallback C_SeatDeviceAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_SeatDeviceAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "device-removed" FunPtr C_SeatDeviceAddedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [deviceRemoved](#signal:deviceRemoved) 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' seat #deviceRemoved callback
    -- @
    --
    --
    afterSeatDeviceRemoved :: (IsSeat a, MonadIO m) => a -> SeatDeviceRemovedCallback -> m SignalHandlerId
    afterSeatDeviceRemoved :: a -> SeatDeviceAddedCallback -> m SignalHandlerId
    afterSeatDeviceRemoved obj :: a
    obj cb :: SeatDeviceAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_SeatDeviceAddedCallback
    cb' = SeatDeviceAddedCallback -> C_SeatDeviceAddedCallback
    wrap_SeatDeviceRemovedCallback SeatDeviceAddedCallback
    cb
        FunPtr C_SeatDeviceAddedCallback
    cb'' <- C_SeatDeviceAddedCallback -> IO (FunPtr C_SeatDeviceAddedCallback)
    mk_SeatDeviceRemovedCallback C_SeatDeviceAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_SeatDeviceAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "device-removed" FunPtr C_SeatDeviceAddedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data SeatDeviceRemovedSignalInfo
    instance SignalInfo SeatDeviceRemovedSignalInfo where
        type HaskellCallbackType SeatDeviceRemovedSignalInfo = SeatDeviceRemovedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_SeatDeviceRemovedCallback cb
            cb'' <- mk_SeatDeviceRemovedCallback cb'
            connectSignalFunPtr obj "device-removed" cb'' connectMode detail

    #endif

    -- signal Seat::tool-added
    -- | The [toolAdded](#g:signal:toolAdded) signal is emitted whenever a new tool
    -- is made known to the seat. The tool may later be assigned
    -- to a device (i.e. on proximity with a tablet). The device
    -- will emit the [toolChanged]("GI.Gdk.Objects.Device#g:signal:toolChanged") signal accordingly.
    --
    -- A same tool may be used by several devices.
    --
    -- /Since: 3.22/
    type SeatToolAddedCallback =
        Gdk.DeviceTool.DeviceTool
        -- ^ /@tool@/: the new t'GI.Gdk.Objects.DeviceTool.DeviceTool' known to the seat
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `SeatToolAddedCallback`@.
    noSeatToolAddedCallback :: Maybe SeatToolAddedCallback
    noSeatToolAddedCallback :: Maybe SeatToolAddedCallback
    noSeatToolAddedCallback = Maybe SeatToolAddedCallback
    forall a. Maybe a
    Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_SeatToolAddedCallback =
        Ptr () ->                               -- object
        Ptr Gdk.DeviceTool.DeviceTool ->
        Ptr () ->                               -- user_data
        IO ()

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_SeatToolAdded :: MonadIO m => SeatToolAddedCallback -> m (GClosure C_SeatToolAddedCallback)
    genClosure_SeatToolAdded :: SeatToolAddedCallback -> m (GClosure C_SeatToolAddedCallback)
    genClosure_SeatToolAdded cb :: SeatToolAddedCallback
    cb = IO (GClosure C_SeatToolAddedCallback)
    -> m (GClosure C_SeatToolAddedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_SeatToolAddedCallback)
     -> m (GClosure C_SeatToolAddedCallback))
    -> IO (GClosure C_SeatToolAddedCallback)
    -> m (GClosure C_SeatToolAddedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_SeatToolAddedCallback
    cb' = SeatToolAddedCallback -> C_SeatToolAddedCallback
    wrap_SeatToolAddedCallback SeatToolAddedCallback
    cb
        C_SeatToolAddedCallback -> IO (FunPtr C_SeatToolAddedCallback)
    mk_SeatToolAddedCallback C_SeatToolAddedCallback
    cb' IO (FunPtr C_SeatToolAddedCallback)
    -> (FunPtr C_SeatToolAddedCallback
        -> IO (GClosure C_SeatToolAddedCallback))
    -> IO (GClosure C_SeatToolAddedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_SeatToolAddedCallback
    -> IO (GClosure C_SeatToolAddedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `SeatToolAddedCallback` into a `C_SeatToolAddedCallback`.
    wrap_SeatToolAddedCallback ::
        SeatToolAddedCallback ->
        C_SeatToolAddedCallback
    wrap_SeatToolAddedCallback :: SeatToolAddedCallback -> C_SeatToolAddedCallback
    wrap_SeatToolAddedCallback _cb :: SeatToolAddedCallback
    _cb _ tool :: Ptr DeviceTool
    tool _ = do
        DeviceTool
    tool' <- ((ManagedPtr DeviceTool -> DeviceTool)
    -> Ptr DeviceTool -> IO DeviceTool
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr DeviceTool -> DeviceTool
    Gdk.DeviceTool.DeviceTool) Ptr DeviceTool
    tool
        SeatToolAddedCallback
    _cb  DeviceTool
    tool'

    -- | Connect a signal handler for the [toolAdded](#signal:toolAdded) 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' seat #toolAdded callback
    -- @
    --
    --
    onSeatToolAdded :: (IsSeat a, MonadIO m) => a -> SeatToolAddedCallback -> m SignalHandlerId
    onSeatToolAdded :: a -> SeatToolAddedCallback -> m SignalHandlerId
    onSeatToolAdded obj :: a
    obj cb :: SeatToolAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_SeatToolAddedCallback
    cb' = SeatToolAddedCallback -> C_SeatToolAddedCallback
    wrap_SeatToolAddedCallback SeatToolAddedCallback
    cb
        FunPtr C_SeatToolAddedCallback
    cb'' <- C_SeatToolAddedCallback -> IO (FunPtr C_SeatToolAddedCallback)
    mk_SeatToolAddedCallback C_SeatToolAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_SeatToolAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "tool-added" FunPtr C_SeatToolAddedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [toolAdded](#signal:toolAdded) 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' seat #toolAdded callback
    -- @
    --
    --
    afterSeatToolAdded :: (IsSeat a, MonadIO m) => a -> SeatToolAddedCallback -> m SignalHandlerId
    afterSeatToolAdded :: a -> SeatToolAddedCallback -> m SignalHandlerId
    afterSeatToolAdded obj :: a
    obj cb :: SeatToolAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_SeatToolAddedCallback
    cb' = SeatToolAddedCallback -> C_SeatToolAddedCallback
    wrap_SeatToolAddedCallback SeatToolAddedCallback
    cb
        FunPtr C_SeatToolAddedCallback
    cb'' <- C_SeatToolAddedCallback -> IO (FunPtr C_SeatToolAddedCallback)
    mk_SeatToolAddedCallback C_SeatToolAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_SeatToolAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "tool-added" FunPtr C_SeatToolAddedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data SeatToolAddedSignalInfo
    instance SignalInfo SeatToolAddedSignalInfo where
        type HaskellCallbackType SeatToolAddedSignalInfo = SeatToolAddedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_SeatToolAddedCallback cb
            cb'' <- mk_SeatToolAddedCallback cb'
            connectSignalFunPtr obj "tool-added" cb'' connectMode detail

    #endif

    -- signal Seat::tool-removed
    -- | This signal is emitted whenever a tool is no longer known
    -- to this /@seat@/.
    --
    -- /Since: 3.22/
    type SeatToolRemovedCallback =
        Gdk.DeviceTool.DeviceTool
        -- ^ /@tool@/: the just removed t'GI.Gdk.Objects.DeviceTool.DeviceTool'
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `SeatToolRemovedCallback`@.
    noSeatToolRemovedCallback :: Maybe SeatToolRemovedCallback
    noSeatToolRemovedCallback :: Maybe SeatToolAddedCallback
    noSeatToolRemovedCallback = Maybe SeatToolAddedCallback
    forall a. Maybe a
    Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_SeatToolRemovedCallback =
        Ptr () ->                               -- object
        Ptr Gdk.DeviceTool.DeviceTool ->
        Ptr () ->                               -- user_data
        IO ()

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_SeatToolRemoved :: MonadIO m => SeatToolRemovedCallback -> m (GClosure C_SeatToolRemovedCallback)
    genClosure_SeatToolRemoved :: SeatToolAddedCallback -> m (GClosure C_SeatToolAddedCallback)
    genClosure_SeatToolRemoved cb :: SeatToolAddedCallback
    cb = IO (GClosure C_SeatToolAddedCallback)
    -> m (GClosure C_SeatToolAddedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_SeatToolAddedCallback)
     -> m (GClosure C_SeatToolAddedCallback))
    -> IO (GClosure C_SeatToolAddedCallback)
    -> m (GClosure C_SeatToolAddedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_SeatToolAddedCallback
    cb' = SeatToolAddedCallback -> C_SeatToolAddedCallback
    wrap_SeatToolRemovedCallback SeatToolAddedCallback
    cb
        C_SeatToolAddedCallback -> IO (FunPtr C_SeatToolAddedCallback)
    mk_SeatToolRemovedCallback C_SeatToolAddedCallback
    cb' IO (FunPtr C_SeatToolAddedCallback)
    -> (FunPtr C_SeatToolAddedCallback
        -> IO (GClosure C_SeatToolAddedCallback))
    -> IO (GClosure C_SeatToolAddedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_SeatToolAddedCallback
    -> IO (GClosure C_SeatToolAddedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `SeatToolRemovedCallback` into a `C_SeatToolRemovedCallback`.
    wrap_SeatToolRemovedCallback ::
        SeatToolRemovedCallback ->
        C_SeatToolRemovedCallback
    wrap_SeatToolRemovedCallback :: SeatToolAddedCallback -> C_SeatToolAddedCallback
    wrap_SeatToolRemovedCallback _cb :: SeatToolAddedCallback
    _cb _ tool :: Ptr DeviceTool
    tool _ = do
        DeviceTool
    tool' <- ((ManagedPtr DeviceTool -> DeviceTool)
    -> Ptr DeviceTool -> IO DeviceTool
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr DeviceTool -> DeviceTool
    Gdk.DeviceTool.DeviceTool) Ptr DeviceTool
    tool
        SeatToolAddedCallback
    _cb  DeviceTool
    tool'

    -- | Connect a signal handler for the [toolRemoved](#signal:toolRemoved) 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' seat #toolRemoved callback
    -- @
    --
    --
    onSeatToolRemoved :: (IsSeat a, MonadIO m) => a -> SeatToolRemovedCallback -> m SignalHandlerId
    onSeatToolRemoved :: a -> SeatToolAddedCallback -> m SignalHandlerId
    onSeatToolRemoved obj :: a
    obj cb :: SeatToolAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_SeatToolAddedCallback
    cb' = SeatToolAddedCallback -> C_SeatToolAddedCallback
    wrap_SeatToolRemovedCallback SeatToolAddedCallback
    cb
        FunPtr C_SeatToolAddedCallback
    cb'' <- C_SeatToolAddedCallback -> IO (FunPtr C_SeatToolAddedCallback)
    mk_SeatToolRemovedCallback C_SeatToolAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_SeatToolAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "tool-removed" FunPtr C_SeatToolAddedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [toolRemoved](#signal:toolRemoved) 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' seat #toolRemoved callback
    -- @
    --
    --
    afterSeatToolRemoved :: (IsSeat a, MonadIO m) => a -> SeatToolRemovedCallback -> m SignalHandlerId
    afterSeatToolRemoved :: a -> SeatToolAddedCallback -> m SignalHandlerId
    afterSeatToolRemoved obj :: a
    obj cb :: SeatToolAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    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 cb' :: C_SeatToolAddedCallback
    cb' = SeatToolAddedCallback -> C_SeatToolAddedCallback
    wrap_SeatToolRemovedCallback SeatToolAddedCallback
    cb
        FunPtr C_SeatToolAddedCallback
    cb'' <- C_SeatToolAddedCallback -> IO (FunPtr C_SeatToolAddedCallback)
    mk_SeatToolRemovedCallback C_SeatToolAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_SeatToolAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "tool-removed" FunPtr C_SeatToolAddedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data SeatToolRemovedSignalInfo
    instance SignalInfo SeatToolRemovedSignalInfo where
        type HaskellCallbackType SeatToolRemovedSignalInfo = SeatToolRemovedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_SeatToolRemovedCallback cb
            cb'' <- mk_SeatToolRemovedCallback cb'
            connectSignalFunPtr obj "tool-removed" cb'' connectMode detail

    #endif

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data SeatDisplayPropertyInfo
    instance AttrInfo SeatDisplayPropertyInfo where
        type AttrAllowedOps SeatDisplayPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint SeatDisplayPropertyInfo = IsSeat
        type AttrSetTypeConstraint SeatDisplayPropertyInfo = Gdk.Display.IsDisplay
        type AttrTransferTypeConstraint SeatDisplayPropertyInfo = Gdk.Display.IsDisplay
        type AttrTransferType SeatDisplayPropertyInfo = Gdk.Display.Display
        type AttrGetType SeatDisplayPropertyInfo = Gdk.Display.Display
        type AttrLabel SeatDisplayPropertyInfo = "display"
        type AttrOrigin SeatDisplayPropertyInfo = Seat
        attrGet = getSeatDisplay
        attrSet = undefined
        attrTransfer _ v = do
            unsafeCastTo Gdk.Display.Display v
        attrConstruct = constructSeatDisplay
        attrClear = undefined
    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList Seat
    type instance O.AttributeList Seat = SeatAttributeList
    type SeatAttributeList = ('[ '("display", SeatDisplayPropertyInfo)] :: [(Symbol, *)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    seatDisplay :: AttrLabelProxy "display"
    seatDisplay = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList Seat = SeatSignalList
    type SeatSignalList = ('[ '("deviceAdded", SeatDeviceAddedSignalInfo), '("deviceRemoved", SeatDeviceRemovedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("toolAdded", SeatToolAddedSignalInfo), '("toolRemoved", SeatToolRemovedSignalInfo)] :: [(Symbol, *)])

    #endif

    -- method Seat::get_capabilities
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "seat"
    --           , argType = TInterface Name { namespace = "Gdk" , name = "Seat" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkSeat" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Gdk" , name = "SeatCapabilities" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_seat_get_capabilities" gdk_seat_get_capabilities ::
        Ptr Seat ->                             -- seat : TInterface (Name {namespace = "Gdk", name = "Seat"})
        IO CUInt

    -- | Returns the capabilities this t'GI.Gdk.Objects.Seat.Seat' currently has.
    --
    -- /Since: 3.20/
    seatGetCapabilities ::
        (B.CallStack.HasCallStack, MonadIO m, IsSeat a) =>
        a
        -- ^ /@seat@/: a t'GI.Gdk.Objects.Seat.Seat'
        -> m [Gdk.Flags.SeatCapabilities]
        -- ^ __Returns:__ the seat capabilities
    seatGetCapabilities :: a -> m [SeatCapabilities]
    seatGetCapabilities seat :: a
    seat = IO [SeatCapabilities] -> m [SeatCapabilities]
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [SeatCapabilities] -> m [SeatCapabilities])
    -> IO [SeatCapabilities] -> m [SeatCapabilities]
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Seat
    seat' <- a -> IO (Ptr Seat)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    seat
        CUInt
    result <- Ptr Seat -> IO CUInt
    gdk_seat_get_capabilities Ptr Seat
    seat'
        let result' :: [SeatCapabilities]
    result' = CUInt -> [SeatCapabilities]
    forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
    wordToGFlags CUInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    seat
        [SeatCapabilities] -> IO [SeatCapabilities]
    forall (m :: * -> *) a. Monad m => a -> m a
    return [SeatCapabilities]
    result'

    #if defined(ENABLE_OVERLOADING)
    data SeatGetCapabilitiesMethodInfo
    instance (signature ~ (m [Gdk.Flags.SeatCapabilities]), MonadIO m, IsSeat a) => O.MethodInfo SeatGetCapabilitiesMethodInfo a signature where
        overloadedMethod = seatGetCapabilities

    #endif

    -- method Seat::get_display
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "seat"
    --           , argType = TInterface Name { namespace = "Gdk" , name = "Seat" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkSeat" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gdk" , name = "Display" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_seat_get_display" gdk_seat_get_display ::
        Ptr Seat ->                             -- seat : TInterface (Name {namespace = "Gdk", name = "Seat"})
        IO (Ptr Gdk.Display.Display)

    -- | Returns the t'GI.Gdk.Objects.Display.Display' this seat belongs to.
    seatGetDisplay ::
        (B.CallStack.HasCallStack, MonadIO m, IsSeat a) =>
        a
        -- ^ /@seat@/: a t'GI.Gdk.Objects.Seat.Seat'
        -> m Gdk.Display.Display
        -- ^ __Returns:__ a t'GI.Gdk.Objects.Display.Display'. This object is owned by GTK+
        --          and must not be freed.
    seatGetDisplay :: a -> m Display
    seatGetDisplay seat :: a
    seat = IO Display -> m Display
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Display -> m Display) -> IO Display -> m Display
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Seat
    seat' <- a -> IO (Ptr Seat)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    seat
        Ptr Display
    result <- Ptr Seat -> IO (Ptr Display)
    gdk_seat_get_display Ptr Seat
    seat'
        Text -> Ptr Display -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "seatGetDisplay" Ptr Display
    result
        Display
    result' <- ((ManagedPtr Display -> Display) -> Ptr Display -> IO Display
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Display -> Display
    Gdk.Display.Display) Ptr Display
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    seat
        Display -> IO Display
    forall (m :: * -> *) a. Monad m => a -> m a
    return Display
    result'

    #if defined(ENABLE_OVERLOADING)
    data SeatGetDisplayMethodInfo
    instance (signature ~ (m Gdk.Display.Display), MonadIO m, IsSeat a) => O.MethodInfo SeatGetDisplayMethodInfo a signature where
        overloadedMethod = seatGetDisplay

    #endif

    -- method Seat::get_keyboard
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "seat"
    --           , argType = TInterface Name { namespace = "Gdk" , name = "Seat" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkSeat" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gdk" , name = "Device" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_seat_get_keyboard" gdk_seat_get_keyboard ::
        Ptr Seat ->                             -- seat : TInterface (Name {namespace = "Gdk", name = "Seat"})
        IO (Ptr Gdk.Device.Device)

    -- | Returns the master device that routes keyboard events.
    --
    -- /Since: 3.20/
    seatGetKeyboard ::
        (B.CallStack.HasCallStack, MonadIO m, IsSeat a) =>
        a
        -- ^ /@seat@/: a t'GI.Gdk.Objects.Seat.Seat'
        -> m (Maybe Gdk.Device.Device)
        -- ^ __Returns:__ a master t'GI.Gdk.Objects.Device.Device' with keyboard
        --          capabilities. This object is owned by GTK+ and must not be freed.
    seatGetKeyboard :: a -> m (Maybe Device)
    seatGetKeyboard seat :: a
    seat = IO (Maybe Device) -> m (Maybe Device)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Device) -> m (Maybe Device))
    -> IO (Maybe Device) -> m (Maybe Device)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Seat
    seat' <- a -> IO (Ptr Seat)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    seat
        Ptr Device
    result <- Ptr Seat -> IO (Ptr Device)
    gdk_seat_get_keyboard Ptr Seat
    seat'
        Maybe Device
    maybeResult <- Ptr Device -> (Ptr Device -> IO Device) -> IO (Maybe Device)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr Device
    result ((Ptr Device -> IO Device) -> IO (Maybe Device))
    -> (Ptr Device -> IO Device) -> IO (Maybe Device)
    forall a b. (a -> b) -> a -> b
    $ \result' :: Ptr Device
    result' -> do
            Device
    result'' <- ((ManagedPtr Device -> Device) -> Ptr Device -> IO Device
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Device -> Device
    Gdk.Device.Device) Ptr Device
    result'
            Device -> IO Device
    forall (m :: * -> *) a. Monad m => a -> m a
    return Device
    result''
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    seat
        Maybe Device -> IO (Maybe Device)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Device
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data SeatGetKeyboardMethodInfo
    instance (signature ~ (m (Maybe Gdk.Device.Device)), MonadIO m, IsSeat a) => O.MethodInfo SeatGetKeyboardMethodInfo a signature where
        overloadedMethod = seatGetKeyboard

    #endif

    -- method Seat::get_pointer
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "seat"
    --           , argType = TInterface Name { namespace = "Gdk" , name = "Seat" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkSeat" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gdk" , name = "Device" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_seat_get_pointer" gdk_seat_get_pointer ::
        Ptr Seat ->                             -- seat : TInterface (Name {namespace = "Gdk", name = "Seat"})
        IO (Ptr Gdk.Device.Device)

    -- | Returns the master device that routes pointer events.
    --
    -- /Since: 3.20/
    seatGetPointer ::
        (B.CallStack.HasCallStack, MonadIO m, IsSeat a) =>
        a
        -- ^ /@seat@/: a t'GI.Gdk.Objects.Seat.Seat'
        -> m (Maybe Gdk.Device.Device)
        -- ^ __Returns:__ a master t'GI.Gdk.Objects.Device.Device' with pointer
        --          capabilities. This object is owned by GTK+ and must not be freed.
    seatGetPointer :: a -> m (Maybe Device)
    seatGetPointer seat :: a
    seat = IO (Maybe Device) -> m (Maybe Device)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Device) -> m (Maybe Device))
    -> IO (Maybe Device) -> m (Maybe Device)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Seat
    seat' <- a -> IO (Ptr Seat)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    seat
        Ptr Device
    result <- Ptr Seat -> IO (Ptr Device)
    gdk_seat_get_pointer Ptr Seat
    seat'
        Maybe Device
    maybeResult <- Ptr Device -> (Ptr Device -> IO Device) -> IO (Maybe Device)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr Device
    result ((Ptr Device -> IO Device) -> IO (Maybe Device))
    -> (Ptr Device -> IO Device) -> IO (Maybe Device)
    forall a b. (a -> b) -> a -> b
    $ \result' :: Ptr Device
    result' -> do
            Device
    result'' <- ((ManagedPtr Device -> Device) -> Ptr Device -> IO Device
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Device -> Device
    Gdk.Device.Device) Ptr Device
    result'
            Device -> IO Device
    forall (m :: * -> *) a. Monad m => a -> m a
    return Device
    result''
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    seat
        Maybe Device -> IO (Maybe Device)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Device
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data SeatGetPointerMethodInfo
    instance (signature ~ (m (Maybe Gdk.Device.Device)), MonadIO m, IsSeat a) => O.MethodInfo SeatGetPointerMethodInfo a signature where
        overloadedMethod = seatGetPointer

    #endif

    -- method Seat::get_slaves
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "seat"
    --           , argType = TInterface Name { namespace = "Gdk" , name = "Seat" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkSeat" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "capabilities"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "SeatCapabilities" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "capabilities to get devices for"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TGList (TInterface Name { namespace = "Gdk" , name = "Device" }))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_seat_get_slaves" gdk_seat_get_slaves ::
        Ptr Seat ->                             -- seat : TInterface (Name {namespace = "Gdk", name = "Seat"})
        CUInt ->                                -- capabilities : TInterface (Name {namespace = "Gdk", name = "SeatCapabilities"})
        IO (Ptr (GList (Ptr Gdk.Device.Device)))

    -- | Returns the slave devices that match the given capabilities.
    --
    -- /Since: 3.20/
    seatGetSlaves ::
        (B.CallStack.HasCallStack, MonadIO m, IsSeat a) =>
        a
        -- ^ /@seat@/: a t'GI.Gdk.Objects.Seat.Seat'
        -> [Gdk.Flags.SeatCapabilities]
        -- ^ /@capabilities@/: capabilities to get devices for
        -> m [Gdk.Device.Device]
        -- ^ __Returns:__ A list of @/GdkDevices/@.
        --          The list must be freed with @/g_list_free()/@, the elements are owned
        --          by GDK and must not be freed.
    seatGetSlaves :: a -> [SeatCapabilities] -> m [Device]
    seatGetSlaves seat :: a
    seat capabilities :: [SeatCapabilities]
    capabilities = IO [Device] -> m [Device]
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [Device] -> m [Device]) -> IO [Device] -> m [Device]
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Seat
    seat' <- a -> IO (Ptr Seat)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    seat
        let capabilities' :: CUInt
    capabilities' = [SeatCapabilities] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [SeatCapabilities]
    capabilities
        Ptr (GList (Ptr Device))
    result <- Ptr Seat -> CUInt -> IO (Ptr (GList (Ptr Device)))
    gdk_seat_get_slaves Ptr Seat
    seat' CUInt
    capabilities'
        [Ptr Device]
    result' <- Ptr (GList (Ptr Device)) -> IO [Ptr Device]
    forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
    unpackGList Ptr (GList (Ptr Device))
    result
        [Device]
    result'' <- (Ptr Device -> IO Device) -> [Ptr Device] -> IO [Device]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM ((ManagedPtr Device -> Device) -> Ptr Device -> IO Device
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Device -> Device
    Gdk.Device.Device) [Ptr Device]
    result'
        Ptr (GList (Ptr Device)) -> IO ()
    forall a. Ptr (GList a) -> IO ()
    g_list_free Ptr (GList (Ptr Device))
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    seat
        [Device] -> IO [Device]
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Device]
    result''

    #if defined(ENABLE_OVERLOADING)
    data SeatGetSlavesMethodInfo
    instance (signature ~ ([Gdk.Flags.SeatCapabilities] -> m [Gdk.Device.Device]), MonadIO m, IsSeat a) => O.MethodInfo SeatGetSlavesMethodInfo a signature where
        overloadedMethod = seatGetSlaves

    #endif

    -- method Seat::grab
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "seat"
    --           , argType = TInterface Name { namespace = "Gdk" , name = "Seat" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkSeat" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "window"
    --           , argType = TInterface Name { namespace = "Gdk" , name = "Window" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #GdkWindow which will own the grab"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "capabilities"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "SeatCapabilities" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "capabilities that will be grabbed"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "owner_events"
    --           , argType = TBasicType TBoolean
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "if %FALSE then all device events are reported with respect to\n               @window and are only reported if selected by @event_mask. If\n               %TRUE then pointer events for this application are reported\n               as normal, but pointer events outside this application are\n               reported with respect to @window and only if selected by\n               @event_mask. In either mode, unreported events are discarded."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cursor"
    --           , argType = TInterface Name { namespace = "Gdk" , name = "Cursor" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the cursor to display while the grab is active. If\n         this is %NULL then the normal cursors are used for\n         @window and its descendants, and the cursor for @window is used\n         elsewhere."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "event"
    --           , argType = TInterface Name { namespace = "Gdk" , name = "Event" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the event that is triggering the grab, or %NULL if none\n        is available."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "prepare_func"
    --           , argType =
    --               TInterface
    --                 Name { namespace = "Gdk" , name = "SeatGrabPrepareFunc" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "function to\n               prepare the window to be grabbed, it can be %NULL if @window is\n               visible before this call."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeCall
    --           , argClosure = 7
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "prepare_func_data"
    --           , argType = TBasicType TPtr
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "user data to pass to @prepare_func"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gdk" , name = "GrabStatus" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_seat_grab" gdk_seat_grab ::
        Ptr Seat ->                             -- seat : TInterface (Name {namespace = "Gdk", name = "Seat"})
        Ptr Gdk.Window.Window ->                -- window : TInterface (Name {namespace = "Gdk", name = "Window"})
        CUInt ->                                -- capabilities : TInterface (Name {namespace = "Gdk", name = "SeatCapabilities"})
        CInt ->                                 -- owner_events : TBasicType TBoolean
        Ptr Gdk.Cursor.Cursor ->                -- cursor : TInterface (Name {namespace = "Gdk", name = "Cursor"})
        Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})
        FunPtr Gdk.Callbacks.C_SeatGrabPrepareFunc -> -- prepare_func : TInterface (Name {namespace = "Gdk", name = "SeatGrabPrepareFunc"})
        Ptr () ->                               -- prepare_func_data : TBasicType TPtr
        IO CUInt

    -- | Grabs the seat so that all events corresponding to the given /@capabilities@/
    -- are passed to this application until the seat is ungrabbed with 'GI.Gdk.Objects.Seat.seatUngrab',
    -- or the window becomes hidden. This overrides any previous grab on the
    -- seat by this client.
    --
    -- As a rule of thumb, if a grab is desired over 'GI.Gdk.Flags.SeatCapabilitiesPointer',
    -- all other \"pointing\" capabilities (eg. 'GI.Gdk.Flags.SeatCapabilitiesTouch') should
    -- be grabbed too, so the user is able to interact with all of those while
    -- the grab holds, you should thus use 'GI.Gdk.Flags.SeatCapabilitiesAllPointing' most
    -- commonly.
    --
    -- Grabs are used for operations which need complete control over the
    -- events corresponding to the given capabilities. For example in GTK+ this
    -- is used for Drag and Drop operations, popup menus and such.
    --
    -- Note that if the event mask of a t'GI.Gdk.Objects.Window.Window' has selected both button press
    -- and button release events, or touch begin and touch end, then a press event
    -- will cause an automatic grab until the button is released, equivalent to a
    -- grab on the window with /@ownerEvents@/ set to 'P.True'. This is done because most
    -- applications expect to receive paired press and release events.
    --
    -- If you set up anything at the time you take the grab that needs to be
    -- cleaned up when the grab ends, you should handle the t'GI.Gdk.Structs.EventGrabBroken.EventGrabBroken'
    -- events that are emitted when the grab ends unvoluntarily.
    --
    -- /Since: 3.20/
    seatGrab ::
        (B.CallStack.HasCallStack, MonadIO m, IsSeat a, Gdk.Window.IsWindow b, Gdk.Cursor.IsCursor c) =>
        a
        -- ^ /@seat@/: a t'GI.Gdk.Objects.Seat.Seat'
        -> b
        -- ^ /@window@/: the t'GI.Gdk.Objects.Window.Window' which will own the grab
        -> [Gdk.Flags.SeatCapabilities]
        -- ^ /@capabilities@/: capabilities that will be grabbed
        -> Bool
        -- ^ /@ownerEvents@/: if 'P.False' then all device events are reported with respect to
        --                /@window@/ and are only reported if selected by /@eventMask@/. If
        --                'P.True' then pointer events for this application are reported
        --                as normal, but pointer events outside this application are
        --                reported with respect to /@window@/ and only if selected by
        --                /@eventMask@/. In either mode, unreported events are discarded.
        -> Maybe (c)
        -- ^ /@cursor@/: the cursor to display while the grab is active. If
        --          this is 'P.Nothing' then the normal cursors are used for
        --          /@window@/ and its descendants, and the cursor for /@window@/ is used
        --          elsewhere.
        -> Maybe (Gdk.Event.Event)
        -- ^ /@event@/: the event that is triggering the grab, or 'P.Nothing' if none
        --         is available.
        -> Maybe (Gdk.Callbacks.SeatGrabPrepareFunc)
        -- ^ /@prepareFunc@/: function to
        --                prepare the window to be grabbed, it can be 'P.Nothing' if /@window@/ is
        --                visible before this call.
        -> m Gdk.Enums.GrabStatus
        -- ^ __Returns:__ 'GI.Gdk.Enums.GrabStatusSuccess' if the grab was successful.
    seatGrab :: a
    -> b
    -> [SeatCapabilities]
    -> Bool
    -> Maybe c
    -> Maybe Event
    -> Maybe SeatGrabPrepareFunc
    -> m GrabStatus
    seatGrab seat :: a
    seat window :: b
    window capabilities :: [SeatCapabilities]
    capabilities ownerEvents :: Bool
    ownerEvents cursor :: Maybe c
    cursor event :: Maybe Event
    event prepareFunc :: Maybe SeatGrabPrepareFunc
    prepareFunc = IO GrabStatus -> m GrabStatus
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GrabStatus -> m GrabStatus) -> IO GrabStatus -> m GrabStatus
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Seat
    seat' <- a -> IO (Ptr Seat)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    seat
        Ptr Window
    window' <- b -> IO (Ptr Window)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    window
        let capabilities' :: CUInt
    capabilities' = [SeatCapabilities] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [SeatCapabilities]
    capabilities
        let ownerEvents' :: CInt
    ownerEvents' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    fromEnum) Bool
    ownerEvents
        Ptr Cursor
    maybeCursor <- case Maybe c
    cursor of
            Nothing -> Ptr Cursor -> IO (Ptr Cursor)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cursor
    forall a. Ptr a
    nullPtr
            Just jCursor :: c
    jCursor -> do
                Ptr Cursor
    jCursor' <- c -> IO (Ptr Cursor)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr c
    jCursor
                Ptr Cursor -> IO (Ptr Cursor)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cursor
    jCursor'
        Ptr Event
    maybeEvent <- case Maybe Event
    event of
            Nothing -> Ptr Event -> IO (Ptr Event)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Event
    forall a. Ptr a
    nullPtr
            Just jEvent :: Event
    jEvent -> do
                Ptr Event
    jEvent' <- Event -> IO (Ptr Event)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Event
    jEvent
                Ptr Event -> IO (Ptr Event)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Event
    jEvent'
        FunPtr C_SeatGrabPrepareFunc
    maybePrepareFunc <- case Maybe SeatGrabPrepareFunc
    prepareFunc of
            Nothing -> FunPtr C_SeatGrabPrepareFunc -> IO (FunPtr C_SeatGrabPrepareFunc)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Ptr Any -> FunPtr C_SeatGrabPrepareFunc
    forall a b. Ptr a -> FunPtr b
    castPtrToFunPtr Ptr Any
    forall a. Ptr a
    nullPtr)
            Just jPrepareFunc :: SeatGrabPrepareFunc
    jPrepareFunc -> do
                FunPtr C_SeatGrabPrepareFunc
    jPrepareFunc' <- C_SeatGrabPrepareFunc -> IO (FunPtr C_SeatGrabPrepareFunc)
    Gdk.Callbacks.mk_SeatGrabPrepareFunc (Maybe (Ptr (FunPtr C_SeatGrabPrepareFunc))
    -> SeatGrabPrepareFunc_WithClosures -> C_SeatGrabPrepareFunc
    Gdk.Callbacks.wrap_SeatGrabPrepareFunc Maybe (Ptr (FunPtr C_SeatGrabPrepareFunc))
    forall a. Maybe a
    Nothing (SeatGrabPrepareFunc -> SeatGrabPrepareFunc_WithClosures
    Gdk.Callbacks.drop_closures_SeatGrabPrepareFunc SeatGrabPrepareFunc
    jPrepareFunc))
                FunPtr C_SeatGrabPrepareFunc -> IO (FunPtr C_SeatGrabPrepareFunc)
    forall (m :: * -> *) a. Monad m => a -> m a
    return FunPtr C_SeatGrabPrepareFunc
    jPrepareFunc'
        let prepareFuncData :: Ptr a
    prepareFuncData = Ptr a
    forall a. Ptr a
    nullPtr
        CUInt
    result <- Ptr Seat
    -> Ptr Window
    -> CUInt
    -> CInt
    -> Ptr Cursor
    -> Ptr Event
    -> FunPtr C_SeatGrabPrepareFunc
    -> Ptr ()
    -> IO CUInt
    gdk_seat_grab Ptr Seat
    seat' Ptr Window
    window' CUInt
    capabilities' CInt
    ownerEvents' Ptr Cursor
    maybeCursor Ptr Event
    maybeEvent FunPtr C_SeatGrabPrepareFunc
    maybePrepareFunc Ptr ()
    forall a. Ptr a
    prepareFuncData
        let result' :: GrabStatus
    result' = (Int -> GrabStatus
    forall a. Enum a => Int -> a
    toEnum (Int -> GrabStatus) -> (CUInt -> Int) -> CUInt -> GrabStatus
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    result
        Ptr Any -> IO ()
    forall a. Ptr a -> IO ()
    safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr C_SeatGrabPrepareFunc -> Ptr Any
    forall a b. FunPtr a -> Ptr b
    castFunPtrToPtr FunPtr C_SeatGrabPrepareFunc
    maybePrepareFunc
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    seat
        b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    window
        Maybe c -> (c -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe c
    cursor c -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        Maybe Event -> (Event -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe Event
    event Event -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        GrabStatus -> IO GrabStatus
    forall (m :: * -> *) a. Monad m => a -> m a
    return GrabStatus
    result'

    #if defined(ENABLE_OVERLOADING)
    data SeatGrabMethodInfo
    instance (signature ~ (b -> [Gdk.Flags.SeatCapabilities] -> Bool -> Maybe (c) -> Maybe (Gdk.Event.Event) -> Maybe (Gdk.Callbacks.SeatGrabPrepareFunc) -> m Gdk.Enums.GrabStatus), MonadIO m, IsSeat a, Gdk.Window.IsWindow b, Gdk.Cursor.IsCursor c) => O.MethodInfo SeatGrabMethodInfo a signature where
        overloadedMethod = seatGrab

    #endif

    -- method Seat::ungrab
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "seat"
    --           , argType = TInterface Name { namespace = "Gdk" , name = "Seat" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GdkSeat" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_seat_ungrab" gdk_seat_ungrab ::
        Ptr Seat ->                             -- seat : TInterface (Name {namespace = "Gdk", name = "Seat"})
        IO ()

    -- | Releases a grab added through 'GI.Gdk.Objects.Seat.seatGrab'.
    --
    -- /Since: 3.20/
    seatUngrab ::
        (B.CallStack.HasCallStack, MonadIO m, IsSeat a) =>
        a
        -- ^ /@seat@/: a t'GI.Gdk.Objects.Seat.Seat'
        -> m ()
    seatUngrab :: a -> m ()
    seatUngrab seat :: a
    seat = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Seat
    seat' <- a -> IO (Ptr Seat)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    seat
        Ptr Seat -> IO ()
    gdk_seat_ungrab Ptr Seat
    seat'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    seat
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data SeatUngrabMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsSeat a) => O.MethodInfo SeatUngrabMethodInfo a signature where
        overloadedMethod = seatUngrab

    #endif