{-# 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(..)                              ,
    noWindow                                ,
    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.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 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 (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)
-- | A convenience alias for `Nothing` :: `Maybe` `Window`.
noWindow :: Maybe Window
noWindow :: Maybe Window
noWindow = Maybe Window
forall a. Maybe a
Nothing

-- signal Window::activate
-- | The signal [activate]("GI.Atk.Interfaces.Window#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 WindowActivateCallback
noWindowActivateCallback = Maybe WindowActivateCallback
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 :: WindowActivateCallback -> m (GClosure C_WindowActivateCallback)
genClosure_WindowActivate cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowActivateCallback WindowActivateCallback
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 :: WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowActivateCallback _cb :: WindowActivateCallback
_cb _ _ = do
    WindowActivateCallback
_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 -> WindowActivateCallback -> m SignalHandlerId
onWindowActivate obj :: a
obj cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowActivateCallback WindowActivateCallback
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 "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 -> WindowActivateCallback -> m SignalHandlerId
afterWindowActivate obj :: a
obj cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowActivateCallback WindowActivateCallback
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 "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#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 WindowActivateCallback
noWindowCreateCallback = Maybe WindowActivateCallback
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 :: WindowActivateCallback -> m (GClosure C_WindowActivateCallback)
genClosure_WindowCreate cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowCreateCallback WindowActivateCallback
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 :: WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowCreateCallback _cb :: WindowActivateCallback
_cb _ _ = do
    WindowActivateCallback
_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 -> WindowActivateCallback -> m SignalHandlerId
onWindowCreate obj :: a
obj cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowCreateCallback WindowActivateCallback
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 "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 -> WindowActivateCallback -> m SignalHandlerId
afterWindowCreate obj :: a
obj cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowCreateCallback WindowActivateCallback
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 "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#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 WindowActivateCallback
noWindowDeactivateCallback = Maybe WindowActivateCallback
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 :: WindowActivateCallback -> m (GClosure C_WindowActivateCallback)
genClosure_WindowDeactivate cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowDeactivateCallback WindowActivateCallback
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 :: WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowDeactivateCallback _cb :: WindowActivateCallback
_cb _ _ = do
    WindowActivateCallback
_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 -> WindowActivateCallback -> m SignalHandlerId
onWindowDeactivate obj :: a
obj cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowDeactivateCallback WindowActivateCallback
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 "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 -> WindowActivateCallback -> m SignalHandlerId
afterWindowDeactivate obj :: a
obj cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowDeactivateCallback WindowActivateCallback
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 "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#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 WindowActivateCallback
noWindowDestroyCallback = Maybe WindowActivateCallback
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 :: WindowActivateCallback -> m (GClosure C_WindowActivateCallback)
genClosure_WindowDestroy cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowDestroyCallback WindowActivateCallback
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 :: WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowDestroyCallback _cb :: WindowActivateCallback
_cb _ _ = do
    WindowActivateCallback
_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 -> WindowActivateCallback -> m SignalHandlerId
onWindowDestroy obj :: a
obj cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowDestroyCallback WindowActivateCallback
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 "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 -> WindowActivateCallback -> m SignalHandlerId
afterWindowDestroy obj :: a
obj cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowDestroyCallback WindowActivateCallback
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 "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#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 WindowActivateCallback
noWindowMaximizeCallback = Maybe WindowActivateCallback
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 :: WindowActivateCallback -> m (GClosure C_WindowActivateCallback)
genClosure_WindowMaximize cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowMaximizeCallback WindowActivateCallback
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 :: WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowMaximizeCallback _cb :: WindowActivateCallback
_cb _ _ = do
    WindowActivateCallback
_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 -> WindowActivateCallback -> m SignalHandlerId
onWindowMaximize obj :: a
obj cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowMaximizeCallback WindowActivateCallback
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 "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 -> WindowActivateCallback -> m SignalHandlerId
afterWindowMaximize obj :: a
obj cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowMaximizeCallback WindowActivateCallback
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 "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#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 WindowActivateCallback
noWindowMinimizeCallback = Maybe WindowActivateCallback
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 :: WindowActivateCallback -> m (GClosure C_WindowActivateCallback)
genClosure_WindowMinimize cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowMinimizeCallback WindowActivateCallback
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 :: WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowMinimizeCallback _cb :: WindowActivateCallback
_cb _ _ = do
    WindowActivateCallback
_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 -> WindowActivateCallback -> m SignalHandlerId
onWindowMinimize obj :: a
obj cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowMinimizeCallback WindowActivateCallback
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 "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 -> WindowActivateCallback -> m SignalHandlerId
afterWindowMinimize obj :: a
obj cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowMinimizeCallback WindowActivateCallback
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 "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#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 WindowActivateCallback
noWindowMoveCallback = Maybe WindowActivateCallback
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 :: WindowActivateCallback -> m (GClosure C_WindowActivateCallback)
genClosure_WindowMove cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowMoveCallback WindowActivateCallback
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 :: WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowMoveCallback _cb :: WindowActivateCallback
_cb _ _ = do
    WindowActivateCallback
_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 -> WindowActivateCallback -> m SignalHandlerId
onWindowMove obj :: a
obj cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowMoveCallback WindowActivateCallback
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 "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 -> WindowActivateCallback -> m SignalHandlerId
afterWindowMove obj :: a
obj cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowMoveCallback WindowActivateCallback
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 "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#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 WindowActivateCallback
noWindowResizeCallback = Maybe WindowActivateCallback
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 :: WindowActivateCallback -> m (GClosure C_WindowActivateCallback)
genClosure_WindowResize cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowResizeCallback WindowActivateCallback
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 :: WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowResizeCallback _cb :: WindowActivateCallback
_cb _ _ = do
    WindowActivateCallback
_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 -> WindowActivateCallback -> m SignalHandlerId
onWindowResize obj :: a
obj cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowResizeCallback WindowActivateCallback
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 "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 -> WindowActivateCallback -> m SignalHandlerId
afterWindowResize obj :: a
obj cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowResizeCallback WindowActivateCallback
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 "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#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 WindowActivateCallback
noWindowRestoreCallback = Maybe WindowActivateCallback
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 :: WindowActivateCallback -> m (GClosure C_WindowActivateCallback)
genClosure_WindowRestore cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowRestoreCallback WindowActivateCallback
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 :: WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowRestoreCallback _cb :: WindowActivateCallback
_cb _ _ = do
    WindowActivateCallback
_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 -> WindowActivateCallback -> m SignalHandlerId
onWindowRestore obj :: a
obj cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowRestoreCallback WindowActivateCallback
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 "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 -> WindowActivateCallback -> m SignalHandlerId
afterWindowRestore obj :: a
obj cb :: WindowActivateCallback
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' = WindowActivateCallback -> C_WindowActivateCallback
wrap_WindowRestoreCallback WindowActivateCallback
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 "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

foreign import ccall "atk_window_get_type"
    c_atk_window_get_type :: IO GType

instance GObject Window where
    gobjectType :: IO GType
gobjectType = IO GType
c_atk_window_get_type
    

-- | 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 o :: 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 -> WindowActivateCallback)
-> Ptr Window
-> IO GValue
forall a.
GType -> (GValue -> a -> WindowActivateCallback) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Window -> WindowActivateCallback
forall a. GObject a => GValue -> Ptr a -> WindowActivateCallback
B.GValue.set_object)
        
    fromGValue :: GValue -> IO Window
fromGValue gv :: 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 (GObject o, O.IsDescendantOf Window o) => IsWindow o
instance (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, GObject o, GObject 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 "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 "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