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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.Dazzle.Objects.DockManager
    ( 

-- * Exported types
    DockManager(..)                         ,
    IsDockManager                           ,
    toDockManager                           ,


 -- * 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"), [pauseGrabs]("GI.Dazzle.Objects.DockManager#g:method:pauseGrabs"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [registerDock]("GI.Dazzle.Objects.DockManager#g:method:registerDock"), [releaseTransientGrab]("GI.Dazzle.Objects.DockManager#g:method:releaseTransientGrab"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unpauseGrabs]("GI.Dazzle.Objects.DockManager#g:method:unpauseGrabs"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unregisterDock]("GI.Dazzle.Objects.DockManager#g:method:unregisterDock"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveDockManagerMethod                ,
#endif

-- ** new #method:new#

    dockManagerNew                          ,


-- ** pauseGrabs #method:pauseGrabs#

#if defined(ENABLE_OVERLOADING)
    DockManagerPauseGrabsMethodInfo         ,
#endif
    dockManagerPauseGrabs                   ,


-- ** registerDock #method:registerDock#

#if defined(ENABLE_OVERLOADING)
    DockManagerRegisterDockMethodInfo       ,
#endif
    dockManagerRegisterDock                 ,


-- ** releaseTransientGrab #method:releaseTransientGrab#

#if defined(ENABLE_OVERLOADING)
    DockManagerReleaseTransientGrabMethodInfo,
#endif
    dockManagerReleaseTransientGrab         ,


-- ** unpauseGrabs #method:unpauseGrabs#

#if defined(ENABLE_OVERLOADING)
    DockManagerUnpauseGrabsMethodInfo       ,
#endif
    dockManagerUnpauseGrabs                 ,


-- ** unregisterDock #method:unregisterDock#

#if defined(ENABLE_OVERLOADING)
    DockManagerUnregisterDockMethodInfo     ,
#endif
    dockManagerUnregisterDock               ,




 -- * Signals


-- ** registerDock #signal:registerDock#

    DockManagerRegisterDockCallback         ,
#if defined(ENABLE_OVERLOADING)
    DockManagerRegisterDockSignalInfo       ,
#endif
    afterDockManagerRegisterDock            ,
    onDockManagerRegisterDock               ,


-- ** unregisterDock #signal:unregisterDock#

    DockManagerUnregisterDockCallback       ,
#if defined(ENABLE_OVERLOADING)
    DockManagerUnregisterDockSignalInfo     ,
#endif
    afterDockManagerUnregisterDock          ,
    onDockManagerUnregisterDock             ,




    ) 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.Dazzle.Interfaces.Dock as Dazzle.Dock
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Objects.Container as Gtk.Container
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

#else
import {-# SOURCE #-} qualified GI.Dazzle.Interfaces.Dock as Dazzle.Dock
import qualified GI.GObject.Objects.Object as GObject.Object

#endif

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

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

foreign import ccall "dzl_dock_manager_get_type"
    c_dzl_dock_manager_get_type :: IO B.Types.GType

instance B.Types.TypedObject DockManager where
    glibType :: IO GType
glibType = IO GType
c_dzl_dock_manager_get_type

instance B.Types.GObject DockManager

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

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

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveDockManagerMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveDockManagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDockManagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDockManagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDockManagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDockManagerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveDockManagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDockManagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDockManagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDockManagerMethod "pauseGrabs" o = DockManagerPauseGrabsMethodInfo
    ResolveDockManagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDockManagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDockManagerMethod "registerDock" o = DockManagerRegisterDockMethodInfo
    ResolveDockManagerMethod "releaseTransientGrab" o = DockManagerReleaseTransientGrabMethodInfo
    ResolveDockManagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDockManagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDockManagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDockManagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDockManagerMethod "unpauseGrabs" o = DockManagerUnpauseGrabsMethodInfo
    ResolveDockManagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDockManagerMethod "unregisterDock" o = DockManagerUnregisterDockMethodInfo
    ResolveDockManagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDockManagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDockManagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDockManagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDockManagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDockManagerMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveDockManagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDockManagerMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- signal DockManager::register-dock
-- | /No description available in the introspection data./
type DockManagerRegisterDockCallback =
    Dazzle.Dock.Dock
    -> IO ()

type C_DockManagerRegisterDockCallback =
    Ptr DockManager ->                      -- object
    Ptr Dazzle.Dock.Dock ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_DockManagerRegisterDockCallback :: 
    GObject a => (a -> DockManagerRegisterDockCallback) ->
    C_DockManagerRegisterDockCallback
wrap_DockManagerRegisterDockCallback :: forall a.
GObject a =>
(a -> DockManagerRegisterDockCallback)
-> C_DockManagerRegisterDockCallback
wrap_DockManagerRegisterDockCallback a -> DockManagerRegisterDockCallback
gi'cb Ptr DockManager
gi'selfPtr Ptr Dock
object Ptr ()
_ = do
    Dock
object' <- ((ManagedPtr Dock -> Dock) -> Ptr Dock -> IO Dock
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Dock -> Dock
Dazzle.Dock.Dock) Ptr Dock
object
    Ptr DockManager -> (DockManager -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr DockManager
gi'selfPtr ((DockManager -> IO ()) -> IO ())
-> (DockManager -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \DockManager
gi'self -> a -> DockManagerRegisterDockCallback
gi'cb (DockManager -> a
forall a b. Coercible a b => a -> b
Coerce.coerce DockManager
gi'self)  Dock
object'


-- | Connect a signal handler for the [registerDock](#signal:registerDock) 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' dockManager #registerDock callback
-- @
-- 
-- 
onDockManagerRegisterDock :: (IsDockManager a, MonadIO m) => a -> ((?self :: a) => DockManagerRegisterDockCallback) -> m SignalHandlerId
onDockManagerRegisterDock :: forall a (m :: * -> *).
(IsDockManager a, MonadIO m) =>
a
-> ((?self::a) => DockManagerRegisterDockCallback)
-> m SignalHandlerId
onDockManagerRegisterDock a
obj (?self::a) => DockManagerRegisterDockCallback
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 -> DockManagerRegisterDockCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DockManagerRegisterDockCallback
DockManagerRegisterDockCallback
cb
    let wrapped' :: C_DockManagerRegisterDockCallback
wrapped' = (a -> DockManagerRegisterDockCallback)
-> C_DockManagerRegisterDockCallback
forall a.
GObject a =>
(a -> DockManagerRegisterDockCallback)
-> C_DockManagerRegisterDockCallback
wrap_DockManagerRegisterDockCallback a -> DockManagerRegisterDockCallback
wrapped
    FunPtr C_DockManagerRegisterDockCallback
wrapped'' <- C_DockManagerRegisterDockCallback
-> IO (FunPtr C_DockManagerRegisterDockCallback)
mk_DockManagerRegisterDockCallback C_DockManagerRegisterDockCallback
wrapped'
    a
-> Text
-> FunPtr C_DockManagerRegisterDockCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"register-dock" FunPtr C_DockManagerRegisterDockCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [registerDock](#signal:registerDock) 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' dockManager #registerDock 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.
-- 
afterDockManagerRegisterDock :: (IsDockManager a, MonadIO m) => a -> ((?self :: a) => DockManagerRegisterDockCallback) -> m SignalHandlerId
afterDockManagerRegisterDock :: forall a (m :: * -> *).
(IsDockManager a, MonadIO m) =>
a
-> ((?self::a) => DockManagerRegisterDockCallback)
-> m SignalHandlerId
afterDockManagerRegisterDock a
obj (?self::a) => DockManagerRegisterDockCallback
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 -> DockManagerRegisterDockCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DockManagerRegisterDockCallback
DockManagerRegisterDockCallback
cb
    let wrapped' :: C_DockManagerRegisterDockCallback
wrapped' = (a -> DockManagerRegisterDockCallback)
-> C_DockManagerRegisterDockCallback
forall a.
GObject a =>
(a -> DockManagerRegisterDockCallback)
-> C_DockManagerRegisterDockCallback
wrap_DockManagerRegisterDockCallback a -> DockManagerRegisterDockCallback
wrapped
    FunPtr C_DockManagerRegisterDockCallback
wrapped'' <- C_DockManagerRegisterDockCallback
-> IO (FunPtr C_DockManagerRegisterDockCallback)
mk_DockManagerRegisterDockCallback C_DockManagerRegisterDockCallback
wrapped'
    a
-> Text
-> FunPtr C_DockManagerRegisterDockCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"register-dock" FunPtr C_DockManagerRegisterDockCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data DockManagerRegisterDockSignalInfo
instance SignalInfo DockManagerRegisterDockSignalInfo where
    type HaskellCallbackType DockManagerRegisterDockSignalInfo = DockManagerRegisterDockCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_DockManagerRegisterDockCallback cb
        cb'' <- mk_DockManagerRegisterDockCallback cb'
        connectSignalFunPtr obj "register-dock" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.DockManager::register-dock"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-DockManager.html#g:signal:registerDock"})

#endif

-- signal DockManager::unregister-dock
-- | /No description available in the introspection data./
type DockManagerUnregisterDockCallback =
    Dazzle.Dock.Dock
    -> IO ()

type C_DockManagerUnregisterDockCallback =
    Ptr DockManager ->                      -- object
    Ptr Dazzle.Dock.Dock ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_DockManagerUnregisterDockCallback :: 
    GObject a => (a -> DockManagerUnregisterDockCallback) ->
    C_DockManagerUnregisterDockCallback
wrap_DockManagerUnregisterDockCallback :: forall a.
GObject a =>
(a -> DockManagerRegisterDockCallback)
-> C_DockManagerRegisterDockCallback
wrap_DockManagerUnregisterDockCallback a -> DockManagerRegisterDockCallback
gi'cb Ptr DockManager
gi'selfPtr Ptr Dock
object Ptr ()
_ = do
    Dock
object' <- ((ManagedPtr Dock -> Dock) -> Ptr Dock -> IO Dock
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Dock -> Dock
Dazzle.Dock.Dock) Ptr Dock
object
    Ptr DockManager -> (DockManager -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr DockManager
gi'selfPtr ((DockManager -> IO ()) -> IO ())
-> (DockManager -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \DockManager
gi'self -> a -> DockManagerRegisterDockCallback
gi'cb (DockManager -> a
forall a b. Coercible a b => a -> b
Coerce.coerce DockManager
gi'self)  Dock
object'


-- | Connect a signal handler for the [unregisterDock](#signal:unregisterDock) 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' dockManager #unregisterDock callback
-- @
-- 
-- 
onDockManagerUnregisterDock :: (IsDockManager a, MonadIO m) => a -> ((?self :: a) => DockManagerUnregisterDockCallback) -> m SignalHandlerId
onDockManagerUnregisterDock :: forall a (m :: * -> *).
(IsDockManager a, MonadIO m) =>
a
-> ((?self::a) => DockManagerRegisterDockCallback)
-> m SignalHandlerId
onDockManagerUnregisterDock a
obj (?self::a) => DockManagerRegisterDockCallback
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 -> DockManagerRegisterDockCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DockManagerRegisterDockCallback
DockManagerRegisterDockCallback
cb
    let wrapped' :: C_DockManagerRegisterDockCallback
wrapped' = (a -> DockManagerRegisterDockCallback)
-> C_DockManagerRegisterDockCallback
forall a.
GObject a =>
(a -> DockManagerRegisterDockCallback)
-> C_DockManagerRegisterDockCallback
wrap_DockManagerUnregisterDockCallback a -> DockManagerRegisterDockCallback
wrapped
    FunPtr C_DockManagerRegisterDockCallback
wrapped'' <- C_DockManagerRegisterDockCallback
-> IO (FunPtr C_DockManagerRegisterDockCallback)
mk_DockManagerUnregisterDockCallback C_DockManagerRegisterDockCallback
wrapped'
    a
-> Text
-> FunPtr C_DockManagerRegisterDockCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"unregister-dock" FunPtr C_DockManagerRegisterDockCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [unregisterDock](#signal:unregisterDock) 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' dockManager #unregisterDock 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.
-- 
afterDockManagerUnregisterDock :: (IsDockManager a, MonadIO m) => a -> ((?self :: a) => DockManagerUnregisterDockCallback) -> m SignalHandlerId
afterDockManagerUnregisterDock :: forall a (m :: * -> *).
(IsDockManager a, MonadIO m) =>
a
-> ((?self::a) => DockManagerRegisterDockCallback)
-> m SignalHandlerId
afterDockManagerUnregisterDock a
obj (?self::a) => DockManagerRegisterDockCallback
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 -> DockManagerRegisterDockCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DockManagerRegisterDockCallback
DockManagerRegisterDockCallback
cb
    let wrapped' :: C_DockManagerRegisterDockCallback
wrapped' = (a -> DockManagerRegisterDockCallback)
-> C_DockManagerRegisterDockCallback
forall a.
GObject a =>
(a -> DockManagerRegisterDockCallback)
-> C_DockManagerRegisterDockCallback
wrap_DockManagerUnregisterDockCallback a -> DockManagerRegisterDockCallback
wrapped
    FunPtr C_DockManagerRegisterDockCallback
wrapped'' <- C_DockManagerRegisterDockCallback
-> IO (FunPtr C_DockManagerRegisterDockCallback)
mk_DockManagerUnregisterDockCallback C_DockManagerRegisterDockCallback
wrapped'
    a
-> Text
-> FunPtr C_DockManagerRegisterDockCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"unregister-dock" FunPtr C_DockManagerRegisterDockCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data DockManagerUnregisterDockSignalInfo
instance SignalInfo DockManagerUnregisterDockSignalInfo where
    type HaskellCallbackType DockManagerUnregisterDockSignalInfo = DockManagerUnregisterDockCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_DockManagerUnregisterDockCallback cb
        cb'' <- mk_DockManagerUnregisterDockCallback cb'
        connectSignalFunPtr obj "unregister-dock" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.DockManager::unregister-dock"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-DockManager.html#g:signal:unregisterDock"})

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DockManager
type instance O.AttributeList DockManager = DockManagerAttributeList
type DockManagerAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList DockManager = DockManagerSignalList
type DockManagerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo), '("registerDock", DockManagerRegisterDockSignalInfo), '("unregisterDock", DockManagerUnregisterDockSignalInfo)] :: [(Symbol, DK.Type)])

#endif

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

foreign import ccall "dzl_dock_manager_new" dzl_dock_manager_new :: 
    IO (Ptr DockManager)

-- | /No description available in the introspection data./
dockManagerNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m DockManager
dockManagerNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m DockManager
dockManagerNew  = IO DockManager -> m DockManager
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DockManager -> m DockManager)
-> IO DockManager -> m DockManager
forall a b. (a -> b) -> a -> b
$ do
    Ptr DockManager
result <- IO (Ptr DockManager)
dzl_dock_manager_new
    Text -> Ptr DockManager -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dockManagerNew" Ptr DockManager
result
    DockManager
result' <- ((ManagedPtr DockManager -> DockManager)
-> Ptr DockManager -> IO DockManager
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DockManager -> DockManager
DockManager) Ptr DockManager
result
    DockManager -> IO DockManager
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DockManager
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method DockManager::pause_grabs
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #DzlDockManager" , 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 "dzl_dock_manager_pause_grabs" dzl_dock_manager_pause_grabs :: 
    Ptr DockManager ->                      -- self : TInterface (Name {namespace = "Dazzle", name = "DockManager"})
    IO ()

-- | Requests that the transient grab monitoring stop until
-- 'GI.Dazzle.Objects.DockManager.dockManagerUnpauseGrabs' is called.
-- 
-- This might be useful while setting up UI so that you don\'t focus
-- something unexpectedly.
-- 
-- This function may be called multiple times and after an equivalent
-- number of calls to 'GI.Dazzle.Objects.DockManager.dockManagerUnpauseGrabs', transient
-- grab monitoring will continue.
-- 
-- /Since: 3.26/
dockManagerPauseGrabs ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockManager a) =>
    a
    -- ^ /@self@/: a t'GI.Dazzle.Objects.DockManager.DockManager'
    -> m ()
dockManagerPauseGrabs :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDockManager a) =>
a -> m ()
dockManagerPauseGrabs a
self = 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 DockManager
self' <- a -> IO (Ptr DockManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DockManager -> IO ()
dzl_dock_manager_pause_grabs Ptr DockManager
self'
    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 DockManagerPauseGrabsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDockManager a) => O.OverloadedMethod DockManagerPauseGrabsMethodInfo a signature where
    overloadedMethod = dockManagerPauseGrabs

instance O.OverloadedMethodInfo DockManagerPauseGrabsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.DockManager.dockManagerPauseGrabs",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-DockManager.html#v:dockManagerPauseGrabs"
        })


#endif

-- method DockManager::register_dock
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dock"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "Dock" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , 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 "dzl_dock_manager_register_dock" dzl_dock_manager_register_dock :: 
    Ptr DockManager ->                      -- self : TInterface (Name {namespace = "Dazzle", name = "DockManager"})
    Ptr Dazzle.Dock.Dock ->                 -- dock : TInterface (Name {namespace = "Dazzle", name = "Dock"})
    IO ()

-- | /No description available in the introspection data./
dockManagerRegisterDock ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockManager a, Dazzle.Dock.IsDock b) =>
    a
    -> b
    -> m ()
dockManagerRegisterDock :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDockManager a, IsDock b) =>
a -> b -> m ()
dockManagerRegisterDock a
self b
dock = 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 DockManager
self' <- a -> IO (Ptr DockManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Dock
dock' <- b -> IO (Ptr Dock)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
dock
    Ptr DockManager -> Ptr Dock -> IO ()
dzl_dock_manager_register_dock Ptr DockManager
self' Ptr Dock
dock'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
dock
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DockManagerRegisterDockMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDockManager a, Dazzle.Dock.IsDock b) => O.OverloadedMethod DockManagerRegisterDockMethodInfo a signature where
    overloadedMethod = dockManagerRegisterDock

instance O.OverloadedMethodInfo DockManagerRegisterDockMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.DockManager.dockManagerRegisterDock",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-DockManager.html#v:dockManagerRegisterDock"
        })


#endif

-- method DockManager::release_transient_grab
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , 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 "dzl_dock_manager_release_transient_grab" dzl_dock_manager_release_transient_grab :: 
    Ptr DockManager ->                      -- self : TInterface (Name {namespace = "Dazzle", name = "DockManager"})
    IO ()

-- | /No description available in the introspection data./
dockManagerReleaseTransientGrab ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockManager a) =>
    a
    -> m ()
dockManagerReleaseTransientGrab :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDockManager a) =>
a -> m ()
dockManagerReleaseTransientGrab a
self = 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 DockManager
self' <- a -> IO (Ptr DockManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DockManager -> IO ()
dzl_dock_manager_release_transient_grab Ptr DockManager
self'
    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 DockManagerReleaseTransientGrabMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDockManager a) => O.OverloadedMethod DockManagerReleaseTransientGrabMethodInfo a signature where
    overloadedMethod = dockManagerReleaseTransientGrab

instance O.OverloadedMethodInfo DockManagerReleaseTransientGrabMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.DockManager.dockManagerReleaseTransientGrab",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-DockManager.html#v:dockManagerReleaseTransientGrab"
        })


#endif

-- method DockManager::unpause_grabs
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #DzlDockManager" , 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 "dzl_dock_manager_unpause_grabs" dzl_dock_manager_unpause_grabs :: 
    Ptr DockManager ->                      -- self : TInterface (Name {namespace = "Dazzle", name = "DockManager"})
    IO ()

-- | Unpauses a previous call to 'GI.Dazzle.Objects.DockManager.dockManagerPauseGrabs'.
-- 
-- Once the pause count returns to zero, transient grab monitoring
-- will be restored.
-- 
-- /Since: 3.26/
dockManagerUnpauseGrabs ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockManager a) =>
    a
    -- ^ /@self@/: a t'GI.Dazzle.Objects.DockManager.DockManager'
    -> m ()
dockManagerUnpauseGrabs :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDockManager a) =>
a -> m ()
dockManagerUnpauseGrabs a
self = 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 DockManager
self' <- a -> IO (Ptr DockManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DockManager -> IO ()
dzl_dock_manager_unpause_grabs Ptr DockManager
self'
    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 DockManagerUnpauseGrabsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDockManager a) => O.OverloadedMethod DockManagerUnpauseGrabsMethodInfo a signature where
    overloadedMethod = dockManagerUnpauseGrabs

instance O.OverloadedMethodInfo DockManagerUnpauseGrabsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.DockManager.dockManagerUnpauseGrabs",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-DockManager.html#v:dockManagerUnpauseGrabs"
        })


#endif

-- method DockManager::unregister_dock
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "DockManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dock"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "Dock" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , 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 "dzl_dock_manager_unregister_dock" dzl_dock_manager_unregister_dock :: 
    Ptr DockManager ->                      -- self : TInterface (Name {namespace = "Dazzle", name = "DockManager"})
    Ptr Dazzle.Dock.Dock ->                 -- dock : TInterface (Name {namespace = "Dazzle", name = "Dock"})
    IO ()

-- | /No description available in the introspection data./
dockManagerUnregisterDock ::
    (B.CallStack.HasCallStack, MonadIO m, IsDockManager a, Dazzle.Dock.IsDock b) =>
    a
    -> b
    -> m ()
dockManagerUnregisterDock :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDockManager a, IsDock b) =>
a -> b -> m ()
dockManagerUnregisterDock a
self b
dock = 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 DockManager
self' <- a -> IO (Ptr DockManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Dock
dock' <- b -> IO (Ptr Dock)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
dock
    Ptr DockManager -> Ptr Dock -> IO ()
dzl_dock_manager_unregister_dock Ptr DockManager
self' Ptr Dock
dock'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
dock
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DockManagerUnregisterDockMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDockManager a, Dazzle.Dock.IsDock b) => O.OverloadedMethod DockManagerUnregisterDockMethodInfo a signature where
    overloadedMethod = dockManagerUnregisterDock

instance O.OverloadedMethodInfo DockManagerUnregisterDockMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.DockManager.dockManagerUnregisterDock",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-DockManager.html#v:dockManagerUnregisterDock"
        })


#endif