{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.Atk.Interfaces.Window.Window' should be implemented by the UI elements that represent
-- a top-level window, such as the main window of an application or
-- dialog.

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

module GI.Atk.Interfaces.Window
    ( 

-- * Exported types
    Window(..)                              ,
    IsWindow                                ,
    toWindow                                ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveWindowMethod                     ,
#endif




 -- * Signals
-- ** activate #signal:activate#

    C_WindowActivateCallback                ,
    WindowActivateCallback                  ,
#if defined(ENABLE_OVERLOADING)
    WindowActivateSignalInfo                ,
#endif
    afterWindowActivate                     ,
    genClosure_WindowActivate               ,
    mk_WindowActivateCallback               ,
    noWindowActivateCallback                ,
    onWindowActivate                        ,
    wrap_WindowActivateCallback             ,


-- ** create #signal:create#

    C_WindowCreateCallback                  ,
    WindowCreateCallback                    ,
#if defined(ENABLE_OVERLOADING)
    WindowCreateSignalInfo                  ,
#endif
    afterWindowCreate                       ,
    genClosure_WindowCreate                 ,
    mk_WindowCreateCallback                 ,
    noWindowCreateCallback                  ,
    onWindowCreate                          ,
    wrap_WindowCreateCallback               ,


-- ** deactivate #signal:deactivate#

    C_WindowDeactivateCallback              ,
    WindowDeactivateCallback                ,
#if defined(ENABLE_OVERLOADING)
    WindowDeactivateSignalInfo              ,
#endif
    afterWindowDeactivate                   ,
    genClosure_WindowDeactivate             ,
    mk_WindowDeactivateCallback             ,
    noWindowDeactivateCallback              ,
    onWindowDeactivate                      ,
    wrap_WindowDeactivateCallback           ,


-- ** destroy #signal:destroy#

    C_WindowDestroyCallback                 ,
    WindowDestroyCallback                   ,
#if defined(ENABLE_OVERLOADING)
    WindowDestroySignalInfo                 ,
#endif
    afterWindowDestroy                      ,
    genClosure_WindowDestroy                ,
    mk_WindowDestroyCallback                ,
    noWindowDestroyCallback                 ,
    onWindowDestroy                         ,
    wrap_WindowDestroyCallback              ,


-- ** maximize #signal:maximize#

    C_WindowMaximizeCallback                ,
    WindowMaximizeCallback                  ,
#if defined(ENABLE_OVERLOADING)
    WindowMaximizeSignalInfo                ,
#endif
    afterWindowMaximize                     ,
    genClosure_WindowMaximize               ,
    mk_WindowMaximizeCallback               ,
    noWindowMaximizeCallback                ,
    onWindowMaximize                        ,
    wrap_WindowMaximizeCallback             ,


-- ** minimize #signal:minimize#

    C_WindowMinimizeCallback                ,
    WindowMinimizeCallback                  ,
#if defined(ENABLE_OVERLOADING)
    WindowMinimizeSignalInfo                ,
#endif
    afterWindowMinimize                     ,
    genClosure_WindowMinimize               ,
    mk_WindowMinimizeCallback               ,
    noWindowMinimizeCallback                ,
    onWindowMinimize                        ,
    wrap_WindowMinimizeCallback             ,


-- ** move #signal:move#

    C_WindowMoveCallback                    ,
    WindowMoveCallback                      ,
#if defined(ENABLE_OVERLOADING)
    WindowMoveSignalInfo                    ,
#endif
    afterWindowMove                         ,
    genClosure_WindowMove                   ,
    mk_WindowMoveCallback                   ,
    noWindowMoveCallback                    ,
    onWindowMove                            ,
    wrap_WindowMoveCallback                 ,


-- ** resize #signal:resize#

    C_WindowResizeCallback                  ,
    WindowResizeCallback                    ,
#if defined(ENABLE_OVERLOADING)
    WindowResizeSignalInfo                  ,
#endif
    afterWindowResize                       ,
    genClosure_WindowResize                 ,
    mk_WindowResizeCallback                 ,
    noWindowResizeCallback                  ,
    onWindowResize                          ,
    wrap_WindowResizeCallback               ,


-- ** restore #signal:restore#

    C_WindowRestoreCallback                 ,
    WindowRestoreCallback                   ,
#if defined(ENABLE_OVERLOADING)
    WindowRestoreSignalInfo                 ,
#endif
    afterWindowRestore                      ,
    genClosure_WindowRestore                ,
    mk_WindowRestoreCallback                ,
    noWindowRestoreCallback                 ,
    onWindowRestore                         ,
    wrap_WindowRestoreCallback              ,




    ) 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.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 {-# SOURCE #-} qualified GI.Atk.Objects.Object as Atk.Object
import qualified GI.GObject.Objects.Object as GObject.Object

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

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

foreign import ccall "atk_window_get_type"
    c_atk_window_get_type :: IO B.Types.GType

instance B.Types.TypedObject Window where
    glibType :: IO GType
glibType = IO GType
c_atk_window_get_type

instance B.Types.GObject Window

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

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

instance O.HasParentTypes Window
type instance O.ParentTypes Window = '[GObject.Object.Object, Atk.Object.Object]

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

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Window
type instance O.AttributeList Window = WindowAttributeList
type WindowAttributeList = ('[ '("accessibleComponentLayer", Atk.Object.ObjectAccessibleComponentLayerPropertyInfo), '("accessibleComponentMdiZorder", Atk.Object.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessibleDescription", Atk.Object.ObjectAccessibleDescriptionPropertyInfo), '("accessibleHypertextNlinks", Atk.Object.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessibleName", Atk.Object.ObjectAccessibleNamePropertyInfo), '("accessibleParent", Atk.Object.ObjectAccessibleParentPropertyInfo), '("accessibleRole", Atk.Object.ObjectAccessibleRolePropertyInfo), '("accessibleTableCaption", Atk.Object.ObjectAccessibleTableCaptionPropertyInfo), '("accessibleTableCaptionObject", Atk.Object.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessibleTableColumnDescription", Atk.Object.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessibleTableColumnHeader", Atk.Object.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessibleTableRowDescription", Atk.Object.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessibleTableRowHeader", Atk.Object.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessibleTableSummary", Atk.Object.ObjectAccessibleTableSummaryPropertyInfo), '("accessibleValue", Atk.Object.ObjectAccessibleValuePropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveWindowMethod (t :: Symbol) (o :: *) :: * where
    ResolveWindowMethod "addRelationship" o = Atk.Object.ObjectAddRelationshipMethodInfo
    ResolveWindowMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveWindowMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveWindowMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveWindowMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveWindowMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveWindowMethod "initialize" o = Atk.Object.ObjectInitializeMethodInfo
    ResolveWindowMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveWindowMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveWindowMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveWindowMethod "notifyStateChange" o = Atk.Object.ObjectNotifyStateChangeMethodInfo
    ResolveWindowMethod "peekParent" o = Atk.Object.ObjectPeekParentMethodInfo
    ResolveWindowMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveWindowMethod "refAccessibleChild" o = Atk.Object.ObjectRefAccessibleChildMethodInfo
    ResolveWindowMethod "refRelationSet" o = Atk.Object.ObjectRefRelationSetMethodInfo
    ResolveWindowMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveWindowMethod "refStateSet" o = Atk.Object.ObjectRefStateSetMethodInfo
    ResolveWindowMethod "removePropertyChangeHandler" o = Atk.Object.ObjectRemovePropertyChangeHandlerMethodInfo
    ResolveWindowMethod "removeRelationship" o = Atk.Object.ObjectRemoveRelationshipMethodInfo
    ResolveWindowMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveWindowMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveWindowMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveWindowMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveWindowMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveWindowMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveWindowMethod "getAccessibleId" o = Atk.Object.ObjectGetAccessibleIdMethodInfo
    ResolveWindowMethod "getAttributes" o = Atk.Object.ObjectGetAttributesMethodInfo
    ResolveWindowMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveWindowMethod "getDescription" o = Atk.Object.ObjectGetDescriptionMethodInfo
    ResolveWindowMethod "getIndexInParent" o = Atk.Object.ObjectGetIndexInParentMethodInfo
    ResolveWindowMethod "getLayer" o = Atk.Object.ObjectGetLayerMethodInfo
    ResolveWindowMethod "getMdiZorder" o = Atk.Object.ObjectGetMdiZorderMethodInfo
    ResolveWindowMethod "getNAccessibleChildren" o = Atk.Object.ObjectGetNAccessibleChildrenMethodInfo
    ResolveWindowMethod "getName" o = Atk.Object.ObjectGetNameMethodInfo
    ResolveWindowMethod "getObjectLocale" o = Atk.Object.ObjectGetObjectLocaleMethodInfo
    ResolveWindowMethod "getParent" o = Atk.Object.ObjectGetParentMethodInfo
    ResolveWindowMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveWindowMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveWindowMethod "getRole" o = Atk.Object.ObjectGetRoleMethodInfo
    ResolveWindowMethod "setAccessibleId" o = Atk.Object.ObjectSetAccessibleIdMethodInfo
    ResolveWindowMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveWindowMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveWindowMethod "setDescription" o = Atk.Object.ObjectSetDescriptionMethodInfo
    ResolveWindowMethod "setName" o = Atk.Object.ObjectSetNameMethodInfo
    ResolveWindowMethod "setParent" o = Atk.Object.ObjectSetParentMethodInfo
    ResolveWindowMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveWindowMethod "setRole" o = Atk.Object.ObjectSetRoleMethodInfo
    ResolveWindowMethod l o = O.MethodResolutionFailed l o

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

#endif

-- signal Window::activate
-- | The signal [activate]("GI.Atk.Interfaces.Window#g:signal:activate") is emitted when a window
-- becomes the active window of the application or session.
-- 
-- /Since: 2.2/
type WindowActivateCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowActivateCallback`@.
noWindowActivateCallback :: Maybe WindowActivateCallback
noWindowActivateCallback :: Maybe (IO ())
noWindowActivateCallback = Maybe (IO ())
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WindowActivate :: MonadIO m => WindowActivateCallback -> m (GClosure C_WindowActivateCallback)
genClosure_WindowActivate :: IO () -> m (GClosure C_WindowActivateCallback)
genClosure_WindowActivate IO ()
cb = IO (GClosure C_WindowActivateCallback)
-> m (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WindowActivateCallback)
 -> m (GClosure C_WindowActivateCallback))
-> IO (GClosure C_WindowActivateCallback)
-> m (GClosure C_WindowActivateCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowActivateCallback IO ()
cb
    C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowActivateCallback C_WindowActivateCallback
cb' IO (FunPtr C_WindowActivateCallback)
-> (FunPtr C_WindowActivateCallback
    -> IO (GClosure C_WindowActivateCallback))
-> IO (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WindowActivateCallback
-> IO (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WindowActivateCallback` into a `C_WindowActivateCallback`.
wrap_WindowActivateCallback ::
    WindowActivateCallback ->
    C_WindowActivateCallback
wrap_WindowActivateCallback :: IO () -> C_WindowActivateCallback
wrap_WindowActivateCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [activate](#signal:activate) 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' window #activate callback
-- @
-- 
-- 
onWindowActivate :: (IsWindow a, MonadIO m) => a -> WindowActivateCallback -> m SignalHandlerId
onWindowActivate :: a -> IO () -> m SignalHandlerId
onWindowActivate a
obj IO ()
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_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowActivateCallback IO ()
cb
    FunPtr C_WindowActivateCallback
cb'' <- C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowActivateCallback C_WindowActivateCallback
cb'
    a
-> Text
-> FunPtr C_WindowActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate" FunPtr C_WindowActivateCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [activate](#signal:activate) 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' window #activate callback
-- @
-- 
-- 
afterWindowActivate :: (IsWindow a, MonadIO m) => a -> WindowActivateCallback -> m SignalHandlerId
afterWindowActivate :: a -> IO () -> m SignalHandlerId
afterWindowActivate a
obj IO ()
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_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowActivateCallback IO ()
cb
    FunPtr C_WindowActivateCallback
cb'' <- C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowActivateCallback C_WindowActivateCallback
cb'
    a
-> Text
-> FunPtr C_WindowActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate" FunPtr C_WindowActivateCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WindowActivateSignalInfo
instance SignalInfo WindowActivateSignalInfo where
    type HaskellCallbackType WindowActivateSignalInfo = WindowActivateCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WindowActivateCallback cb
        cb'' <- mk_WindowActivateCallback cb'
        connectSignalFunPtr obj "activate" cb'' connectMode detail

#endif

-- signal Window::create
-- | The signal [create]("GI.Atk.Interfaces.Window#g:signal:create") is emitted when a new window
-- is created.
-- 
-- /Since: 2.2/
type WindowCreateCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowCreateCallback`@.
noWindowCreateCallback :: Maybe WindowCreateCallback
noWindowCreateCallback :: Maybe (IO ())
noWindowCreateCallback = Maybe (IO ())
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WindowCreate :: MonadIO m => WindowCreateCallback -> m (GClosure C_WindowCreateCallback)
genClosure_WindowCreate :: IO () -> m (GClosure C_WindowActivateCallback)
genClosure_WindowCreate IO ()
cb = IO (GClosure C_WindowActivateCallback)
-> m (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WindowActivateCallback)
 -> m (GClosure C_WindowActivateCallback))
-> IO (GClosure C_WindowActivateCallback)
-> m (GClosure C_WindowActivateCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowCreateCallback IO ()
cb
    C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowCreateCallback C_WindowActivateCallback
cb' IO (FunPtr C_WindowActivateCallback)
-> (FunPtr C_WindowActivateCallback
    -> IO (GClosure C_WindowActivateCallback))
-> IO (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WindowActivateCallback
-> IO (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WindowCreateCallback` into a `C_WindowCreateCallback`.
wrap_WindowCreateCallback ::
    WindowCreateCallback ->
    C_WindowCreateCallback
wrap_WindowCreateCallback :: IO () -> C_WindowActivateCallback
wrap_WindowCreateCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [create](#signal:create) 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' window #create callback
-- @
-- 
-- 
onWindowCreate :: (IsWindow a, MonadIO m) => a -> WindowCreateCallback -> m SignalHandlerId
onWindowCreate :: a -> IO () -> m SignalHandlerId
onWindowCreate a
obj IO ()
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_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowCreateCallback IO ()
cb
    FunPtr C_WindowActivateCallback
cb'' <- C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowCreateCallback C_WindowActivateCallback
cb'
    a
-> Text
-> FunPtr C_WindowActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"create" FunPtr C_WindowActivateCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [create](#signal:create) 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' window #create callback
-- @
-- 
-- 
afterWindowCreate :: (IsWindow a, MonadIO m) => a -> WindowCreateCallback -> m SignalHandlerId
afterWindowCreate :: a -> IO () -> m SignalHandlerId
afterWindowCreate a
obj IO ()
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_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowCreateCallback IO ()
cb
    FunPtr C_WindowActivateCallback
cb'' <- C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowCreateCallback C_WindowActivateCallback
cb'
    a
-> Text
-> FunPtr C_WindowActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"create" FunPtr C_WindowActivateCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WindowCreateSignalInfo
instance SignalInfo WindowCreateSignalInfo where
    type HaskellCallbackType WindowCreateSignalInfo = WindowCreateCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WindowCreateCallback cb
        cb'' <- mk_WindowCreateCallback cb'
        connectSignalFunPtr obj "create" cb'' connectMode detail

#endif

-- signal Window::deactivate
-- | The signal [deactivate]("GI.Atk.Interfaces.Window#g:signal:deactivate") is emitted when a window is
-- no longer the active window of the application or session.
-- 
-- /Since: 2.2/
type WindowDeactivateCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowDeactivateCallback`@.
noWindowDeactivateCallback :: Maybe WindowDeactivateCallback
noWindowDeactivateCallback :: Maybe (IO ())
noWindowDeactivateCallback = Maybe (IO ())
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WindowDeactivate :: MonadIO m => WindowDeactivateCallback -> m (GClosure C_WindowDeactivateCallback)
genClosure_WindowDeactivate :: IO () -> m (GClosure C_WindowActivateCallback)
genClosure_WindowDeactivate IO ()
cb = IO (GClosure C_WindowActivateCallback)
-> m (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WindowActivateCallback)
 -> m (GClosure C_WindowActivateCallback))
-> IO (GClosure C_WindowActivateCallback)
-> m (GClosure C_WindowActivateCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowDeactivateCallback IO ()
cb
    C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowDeactivateCallback C_WindowActivateCallback
cb' IO (FunPtr C_WindowActivateCallback)
-> (FunPtr C_WindowActivateCallback
    -> IO (GClosure C_WindowActivateCallback))
-> IO (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WindowActivateCallback
-> IO (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WindowDeactivateCallback` into a `C_WindowDeactivateCallback`.
wrap_WindowDeactivateCallback ::
    WindowDeactivateCallback ->
    C_WindowDeactivateCallback
wrap_WindowDeactivateCallback :: IO () -> C_WindowActivateCallback
wrap_WindowDeactivateCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [deactivate](#signal:deactivate) 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' window #deactivate callback
-- @
-- 
-- 
onWindowDeactivate :: (IsWindow a, MonadIO m) => a -> WindowDeactivateCallback -> m SignalHandlerId
onWindowDeactivate :: a -> IO () -> m SignalHandlerId
onWindowDeactivate a
obj IO ()
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_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowDeactivateCallback IO ()
cb
    FunPtr C_WindowActivateCallback
cb'' <- C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowDeactivateCallback C_WindowActivateCallback
cb'
    a
-> Text
-> FunPtr C_WindowActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"deactivate" FunPtr C_WindowActivateCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [deactivate](#signal:deactivate) 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' window #deactivate callback
-- @
-- 
-- 
afterWindowDeactivate :: (IsWindow a, MonadIO m) => a -> WindowDeactivateCallback -> m SignalHandlerId
afterWindowDeactivate :: a -> IO () -> m SignalHandlerId
afterWindowDeactivate a
obj IO ()
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_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowDeactivateCallback IO ()
cb
    FunPtr C_WindowActivateCallback
cb'' <- C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowDeactivateCallback C_WindowActivateCallback
cb'
    a
-> Text
-> FunPtr C_WindowActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"deactivate" FunPtr C_WindowActivateCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WindowDeactivateSignalInfo
instance SignalInfo WindowDeactivateSignalInfo where
    type HaskellCallbackType WindowDeactivateSignalInfo = WindowDeactivateCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WindowDeactivateCallback cb
        cb'' <- mk_WindowDeactivateCallback cb'
        connectSignalFunPtr obj "deactivate" cb'' connectMode detail

#endif

-- signal Window::destroy
-- | The signal [destroy]("GI.Atk.Interfaces.Window#g:signal:destroy") is emitted when a window is
-- destroyed.
-- 
-- /Since: 2.2/
type WindowDestroyCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowDestroyCallback`@.
noWindowDestroyCallback :: Maybe WindowDestroyCallback
noWindowDestroyCallback :: Maybe (IO ())
noWindowDestroyCallback = Maybe (IO ())
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WindowDestroy :: MonadIO m => WindowDestroyCallback -> m (GClosure C_WindowDestroyCallback)
genClosure_WindowDestroy :: IO () -> m (GClosure C_WindowActivateCallback)
genClosure_WindowDestroy IO ()
cb = IO (GClosure C_WindowActivateCallback)
-> m (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WindowActivateCallback)
 -> m (GClosure C_WindowActivateCallback))
-> IO (GClosure C_WindowActivateCallback)
-> m (GClosure C_WindowActivateCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowDestroyCallback IO ()
cb
    C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowDestroyCallback C_WindowActivateCallback
cb' IO (FunPtr C_WindowActivateCallback)
-> (FunPtr C_WindowActivateCallback
    -> IO (GClosure C_WindowActivateCallback))
-> IO (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WindowActivateCallback
-> IO (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WindowDestroyCallback` into a `C_WindowDestroyCallback`.
wrap_WindowDestroyCallback ::
    WindowDestroyCallback ->
    C_WindowDestroyCallback
wrap_WindowDestroyCallback :: IO () -> C_WindowActivateCallback
wrap_WindowDestroyCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [destroy](#signal:destroy) 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' window #destroy callback
-- @
-- 
-- 
onWindowDestroy :: (IsWindow a, MonadIO m) => a -> WindowDestroyCallback -> m SignalHandlerId
onWindowDestroy :: a -> IO () -> m SignalHandlerId
onWindowDestroy a
obj IO ()
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_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowDestroyCallback IO ()
cb
    FunPtr C_WindowActivateCallback
cb'' <- C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowDestroyCallback C_WindowActivateCallback
cb'
    a
-> Text
-> FunPtr C_WindowActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"destroy" FunPtr C_WindowActivateCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [destroy](#signal:destroy) 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' window #destroy callback
-- @
-- 
-- 
afterWindowDestroy :: (IsWindow a, MonadIO m) => a -> WindowDestroyCallback -> m SignalHandlerId
afterWindowDestroy :: a -> IO () -> m SignalHandlerId
afterWindowDestroy a
obj IO ()
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_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowDestroyCallback IO ()
cb
    FunPtr C_WindowActivateCallback
cb'' <- C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowDestroyCallback C_WindowActivateCallback
cb'
    a
-> Text
-> FunPtr C_WindowActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"destroy" FunPtr C_WindowActivateCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WindowDestroySignalInfo
instance SignalInfo WindowDestroySignalInfo where
    type HaskellCallbackType WindowDestroySignalInfo = WindowDestroyCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WindowDestroyCallback cb
        cb'' <- mk_WindowDestroyCallback cb'
        connectSignalFunPtr obj "destroy" cb'' connectMode detail

#endif

-- signal Window::maximize
-- | The signal [maximize]("GI.Atk.Interfaces.Window#g:signal:maximize") is emitted when a window
-- is maximized.
-- 
-- /Since: 2.2/
type WindowMaximizeCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowMaximizeCallback`@.
noWindowMaximizeCallback :: Maybe WindowMaximizeCallback
noWindowMaximizeCallback :: Maybe (IO ())
noWindowMaximizeCallback = Maybe (IO ())
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WindowMaximize :: MonadIO m => WindowMaximizeCallback -> m (GClosure C_WindowMaximizeCallback)
genClosure_WindowMaximize :: IO () -> m (GClosure C_WindowActivateCallback)
genClosure_WindowMaximize IO ()
cb = IO (GClosure C_WindowActivateCallback)
-> m (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WindowActivateCallback)
 -> m (GClosure C_WindowActivateCallback))
-> IO (GClosure C_WindowActivateCallback)
-> m (GClosure C_WindowActivateCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowMaximizeCallback IO ()
cb
    C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowMaximizeCallback C_WindowActivateCallback
cb' IO (FunPtr C_WindowActivateCallback)
-> (FunPtr C_WindowActivateCallback
    -> IO (GClosure C_WindowActivateCallback))
-> IO (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WindowActivateCallback
-> IO (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WindowMaximizeCallback` into a `C_WindowMaximizeCallback`.
wrap_WindowMaximizeCallback ::
    WindowMaximizeCallback ->
    C_WindowMaximizeCallback
wrap_WindowMaximizeCallback :: IO () -> C_WindowActivateCallback
wrap_WindowMaximizeCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [maximize](#signal:maximize) 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' window #maximize callback
-- @
-- 
-- 
onWindowMaximize :: (IsWindow a, MonadIO m) => a -> WindowMaximizeCallback -> m SignalHandlerId
onWindowMaximize :: a -> IO () -> m SignalHandlerId
onWindowMaximize a
obj IO ()
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_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowMaximizeCallback IO ()
cb
    FunPtr C_WindowActivateCallback
cb'' <- C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowMaximizeCallback C_WindowActivateCallback
cb'
    a
-> Text
-> FunPtr C_WindowActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"maximize" FunPtr C_WindowActivateCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [maximize](#signal:maximize) 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' window #maximize callback
-- @
-- 
-- 
afterWindowMaximize :: (IsWindow a, MonadIO m) => a -> WindowMaximizeCallback -> m SignalHandlerId
afterWindowMaximize :: a -> IO () -> m SignalHandlerId
afterWindowMaximize a
obj IO ()
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_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowMaximizeCallback IO ()
cb
    FunPtr C_WindowActivateCallback
cb'' <- C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowMaximizeCallback C_WindowActivateCallback
cb'
    a
-> Text
-> FunPtr C_WindowActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"maximize" FunPtr C_WindowActivateCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WindowMaximizeSignalInfo
instance SignalInfo WindowMaximizeSignalInfo where
    type HaskellCallbackType WindowMaximizeSignalInfo = WindowMaximizeCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WindowMaximizeCallback cb
        cb'' <- mk_WindowMaximizeCallback cb'
        connectSignalFunPtr obj "maximize" cb'' connectMode detail

#endif

-- signal Window::minimize
-- | The signal [minimize]("GI.Atk.Interfaces.Window#g:signal:minimize") is emitted when a window
-- is minimized.
-- 
-- /Since: 2.2/
type WindowMinimizeCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowMinimizeCallback`@.
noWindowMinimizeCallback :: Maybe WindowMinimizeCallback
noWindowMinimizeCallback :: Maybe (IO ())
noWindowMinimizeCallback = Maybe (IO ())
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WindowMinimize :: MonadIO m => WindowMinimizeCallback -> m (GClosure C_WindowMinimizeCallback)
genClosure_WindowMinimize :: IO () -> m (GClosure C_WindowActivateCallback)
genClosure_WindowMinimize IO ()
cb = IO (GClosure C_WindowActivateCallback)
-> m (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WindowActivateCallback)
 -> m (GClosure C_WindowActivateCallback))
-> IO (GClosure C_WindowActivateCallback)
-> m (GClosure C_WindowActivateCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowMinimizeCallback IO ()
cb
    C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowMinimizeCallback C_WindowActivateCallback
cb' IO (FunPtr C_WindowActivateCallback)
-> (FunPtr C_WindowActivateCallback
    -> IO (GClosure C_WindowActivateCallback))
-> IO (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WindowActivateCallback
-> IO (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WindowMinimizeCallback` into a `C_WindowMinimizeCallback`.
wrap_WindowMinimizeCallback ::
    WindowMinimizeCallback ->
    C_WindowMinimizeCallback
wrap_WindowMinimizeCallback :: IO () -> C_WindowActivateCallback
wrap_WindowMinimizeCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [minimize](#signal:minimize) 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' window #minimize callback
-- @
-- 
-- 
onWindowMinimize :: (IsWindow a, MonadIO m) => a -> WindowMinimizeCallback -> m SignalHandlerId
onWindowMinimize :: a -> IO () -> m SignalHandlerId
onWindowMinimize a
obj IO ()
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_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowMinimizeCallback IO ()
cb
    FunPtr C_WindowActivateCallback
cb'' <- C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowMinimizeCallback C_WindowActivateCallback
cb'
    a
-> Text
-> FunPtr C_WindowActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"minimize" FunPtr C_WindowActivateCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [minimize](#signal:minimize) 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' window #minimize callback
-- @
-- 
-- 
afterWindowMinimize :: (IsWindow a, MonadIO m) => a -> WindowMinimizeCallback -> m SignalHandlerId
afterWindowMinimize :: a -> IO () -> m SignalHandlerId
afterWindowMinimize a
obj IO ()
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_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowMinimizeCallback IO ()
cb
    FunPtr C_WindowActivateCallback
cb'' <- C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowMinimizeCallback C_WindowActivateCallback
cb'
    a
-> Text
-> FunPtr C_WindowActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"minimize" FunPtr C_WindowActivateCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WindowMinimizeSignalInfo
instance SignalInfo WindowMinimizeSignalInfo where
    type HaskellCallbackType WindowMinimizeSignalInfo = WindowMinimizeCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WindowMinimizeCallback cb
        cb'' <- mk_WindowMinimizeCallback cb'
        connectSignalFunPtr obj "minimize" cb'' connectMode detail

#endif

-- signal Window::move
-- | The signal [move]("GI.Atk.Interfaces.Window#g:signal:move") is emitted when a window
-- is moved.
-- 
-- /Since: 2.2/
type WindowMoveCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowMoveCallback`@.
noWindowMoveCallback :: Maybe WindowMoveCallback
noWindowMoveCallback :: Maybe (IO ())
noWindowMoveCallback = Maybe (IO ())
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WindowMove :: MonadIO m => WindowMoveCallback -> m (GClosure C_WindowMoveCallback)
genClosure_WindowMove :: IO () -> m (GClosure C_WindowActivateCallback)
genClosure_WindowMove IO ()
cb = IO (GClosure C_WindowActivateCallback)
-> m (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WindowActivateCallback)
 -> m (GClosure C_WindowActivateCallback))
-> IO (GClosure C_WindowActivateCallback)
-> m (GClosure C_WindowActivateCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowMoveCallback IO ()
cb
    C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowMoveCallback C_WindowActivateCallback
cb' IO (FunPtr C_WindowActivateCallback)
-> (FunPtr C_WindowActivateCallback
    -> IO (GClosure C_WindowActivateCallback))
-> IO (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WindowActivateCallback
-> IO (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WindowMoveCallback` into a `C_WindowMoveCallback`.
wrap_WindowMoveCallback ::
    WindowMoveCallback ->
    C_WindowMoveCallback
wrap_WindowMoveCallback :: IO () -> C_WindowActivateCallback
wrap_WindowMoveCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [move](#signal:move) 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' window #move callback
-- @
-- 
-- 
onWindowMove :: (IsWindow a, MonadIO m) => a -> WindowMoveCallback -> m SignalHandlerId
onWindowMove :: a -> IO () -> m SignalHandlerId
onWindowMove a
obj IO ()
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_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowMoveCallback IO ()
cb
    FunPtr C_WindowActivateCallback
cb'' <- C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowMoveCallback C_WindowActivateCallback
cb'
    a
-> Text
-> FunPtr C_WindowActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"move" FunPtr C_WindowActivateCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [move](#signal:move) 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' window #move callback
-- @
-- 
-- 
afterWindowMove :: (IsWindow a, MonadIO m) => a -> WindowMoveCallback -> m SignalHandlerId
afterWindowMove :: a -> IO () -> m SignalHandlerId
afterWindowMove a
obj IO ()
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_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowMoveCallback IO ()
cb
    FunPtr C_WindowActivateCallback
cb'' <- C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowMoveCallback C_WindowActivateCallback
cb'
    a
-> Text
-> FunPtr C_WindowActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"move" FunPtr C_WindowActivateCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WindowMoveSignalInfo
instance SignalInfo WindowMoveSignalInfo where
    type HaskellCallbackType WindowMoveSignalInfo = WindowMoveCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WindowMoveCallback cb
        cb'' <- mk_WindowMoveCallback cb'
        connectSignalFunPtr obj "move" cb'' connectMode detail

#endif

-- signal Window::resize
-- | The signal [resize]("GI.Atk.Interfaces.Window#g:signal:resize") is emitted when a window
-- is resized.
-- 
-- /Since: 2.2/
type WindowResizeCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowResizeCallback`@.
noWindowResizeCallback :: Maybe WindowResizeCallback
noWindowResizeCallback :: Maybe (IO ())
noWindowResizeCallback = Maybe (IO ())
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WindowResize :: MonadIO m => WindowResizeCallback -> m (GClosure C_WindowResizeCallback)
genClosure_WindowResize :: IO () -> m (GClosure C_WindowActivateCallback)
genClosure_WindowResize IO ()
cb = IO (GClosure C_WindowActivateCallback)
-> m (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WindowActivateCallback)
 -> m (GClosure C_WindowActivateCallback))
-> IO (GClosure C_WindowActivateCallback)
-> m (GClosure C_WindowActivateCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowResizeCallback IO ()
cb
    C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowResizeCallback C_WindowActivateCallback
cb' IO (FunPtr C_WindowActivateCallback)
-> (FunPtr C_WindowActivateCallback
    -> IO (GClosure C_WindowActivateCallback))
-> IO (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WindowActivateCallback
-> IO (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WindowResizeCallback` into a `C_WindowResizeCallback`.
wrap_WindowResizeCallback ::
    WindowResizeCallback ->
    C_WindowResizeCallback
wrap_WindowResizeCallback :: IO () -> C_WindowActivateCallback
wrap_WindowResizeCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [resize](#signal:resize) 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' window #resize callback
-- @
-- 
-- 
onWindowResize :: (IsWindow a, MonadIO m) => a -> WindowResizeCallback -> m SignalHandlerId
onWindowResize :: a -> IO () -> m SignalHandlerId
onWindowResize a
obj IO ()
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_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowResizeCallback IO ()
cb
    FunPtr C_WindowActivateCallback
cb'' <- C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowResizeCallback C_WindowActivateCallback
cb'
    a
-> Text
-> FunPtr C_WindowActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"resize" FunPtr C_WindowActivateCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [resize](#signal:resize) 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' window #resize callback
-- @
-- 
-- 
afterWindowResize :: (IsWindow a, MonadIO m) => a -> WindowResizeCallback -> m SignalHandlerId
afterWindowResize :: a -> IO () -> m SignalHandlerId
afterWindowResize a
obj IO ()
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_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowResizeCallback IO ()
cb
    FunPtr C_WindowActivateCallback
cb'' <- C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowResizeCallback C_WindowActivateCallback
cb'
    a
-> Text
-> FunPtr C_WindowActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"resize" FunPtr C_WindowActivateCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WindowResizeSignalInfo
instance SignalInfo WindowResizeSignalInfo where
    type HaskellCallbackType WindowResizeSignalInfo = WindowResizeCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WindowResizeCallback cb
        cb'' <- mk_WindowResizeCallback cb'
        connectSignalFunPtr obj "resize" cb'' connectMode detail

#endif

-- signal Window::restore
-- | The signal [restore]("GI.Atk.Interfaces.Window#g:signal:restore") is emitted when a window
-- is restored.
-- 
-- /Since: 2.2/
type WindowRestoreCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowRestoreCallback`@.
noWindowRestoreCallback :: Maybe WindowRestoreCallback
noWindowRestoreCallback :: Maybe (IO ())
noWindowRestoreCallback = Maybe (IO ())
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_WindowRestore :: MonadIO m => WindowRestoreCallback -> m (GClosure C_WindowRestoreCallback)
genClosure_WindowRestore :: IO () -> m (GClosure C_WindowActivateCallback)
genClosure_WindowRestore IO ()
cb = IO (GClosure C_WindowActivateCallback)
-> m (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_WindowActivateCallback)
 -> m (GClosure C_WindowActivateCallback))
-> IO (GClosure C_WindowActivateCallback)
-> m (GClosure C_WindowActivateCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowRestoreCallback IO ()
cb
    C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowRestoreCallback C_WindowActivateCallback
cb' IO (FunPtr C_WindowActivateCallback)
-> (FunPtr C_WindowActivateCallback
    -> IO (GClosure C_WindowActivateCallback))
-> IO (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_WindowActivateCallback
-> IO (GClosure C_WindowActivateCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `WindowRestoreCallback` into a `C_WindowRestoreCallback`.
wrap_WindowRestoreCallback ::
    WindowRestoreCallback ->
    C_WindowRestoreCallback
wrap_WindowRestoreCallback :: IO () -> C_WindowActivateCallback
wrap_WindowRestoreCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [restore](#signal:restore) 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' window #restore callback
-- @
-- 
-- 
onWindowRestore :: (IsWindow a, MonadIO m) => a -> WindowRestoreCallback -> m SignalHandlerId
onWindowRestore :: a -> IO () -> m SignalHandlerId
onWindowRestore a
obj IO ()
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_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowRestoreCallback IO ()
cb
    FunPtr C_WindowActivateCallback
cb'' <- C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowRestoreCallback C_WindowActivateCallback
cb'
    a
-> Text
-> FunPtr C_WindowActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"restore" FunPtr C_WindowActivateCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [restore](#signal:restore) 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' window #restore callback
-- @
-- 
-- 
afterWindowRestore :: (IsWindow a, MonadIO m) => a -> WindowRestoreCallback -> m SignalHandlerId
afterWindowRestore :: a -> IO () -> m SignalHandlerId
afterWindowRestore a
obj IO ()
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_WindowActivateCallback
cb' = IO () -> C_WindowActivateCallback
wrap_WindowRestoreCallback IO ()
cb
    FunPtr C_WindowActivateCallback
cb'' <- C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)
mk_WindowRestoreCallback C_WindowActivateCallback
cb'
    a
-> Text
-> FunPtr C_WindowActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"restore" FunPtr C_WindowActivateCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data WindowRestoreSignalInfo
instance SignalInfo WindowRestoreSignalInfo where
    type HaskellCallbackType WindowRestoreSignalInfo = WindowRestoreCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_WindowRestoreCallback cb
        cb'' <- mk_WindowRestoreCallback cb'
        connectSignalFunPtr obj "restore" cb'' connectMode detail

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Window = WindowSignalList
type WindowSignalList = ('[ '("activate", WindowActivateSignalInfo), '("activeDescendantChanged", Atk.Object.ObjectActiveDescendantChangedSignalInfo), '("childrenChanged", Atk.Object.ObjectChildrenChangedSignalInfo), '("create", WindowCreateSignalInfo), '("deactivate", WindowDeactivateSignalInfo), '("destroy", WindowDestroySignalInfo), '("focusEvent", Atk.Object.ObjectFocusEventSignalInfo), '("maximize", WindowMaximizeSignalInfo), '("minimize", WindowMinimizeSignalInfo), '("move", WindowMoveSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("propertyChange", Atk.Object.ObjectPropertyChangeSignalInfo), '("resize", WindowResizeSignalInfo), '("restore", WindowRestoreSignalInfo), '("stateChange", Atk.Object.ObjectStateChangeSignalInfo), '("visibleDataChanged", Atk.Object.ObjectVisibleDataChangedSignalInfo)] :: [(Symbol, *)])

#endif