    {-# 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 !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.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL

    import {-# 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 p :: 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 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 -> 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 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 (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 cb :: 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 _cb :: IO ()
    _cb _ _ = 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 obj :: a
    obj cb :: 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 "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 obj :: a
    obj cb :: 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 "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 cb :: 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 _cb :: IO ()
    _cb _ _ = 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 obj :: a
    obj cb :: 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 "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 obj :: a
    obj cb :: 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 "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 cb :: 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 _cb :: IO ()
    _cb _ _ = 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 obj :: a
    obj cb :: 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 "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 obj :: a
    obj cb :: 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 "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 cb :: 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 _cb :: IO ()
    _cb _ _ = 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 obj :: a
    obj cb :: 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 "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 obj :: a
    obj cb :: 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 "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 cb :: 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 _cb :: IO ()
    _cb _ _ = 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 obj :: a
    obj cb :: 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 "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 obj :: a
    obj cb :: 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 "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 cb :: 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 _cb :: IO ()
    _cb _ _ = 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 obj :: a
    obj cb :: 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 "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 obj :: a
    obj cb :: 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 "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 cb :: 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 _cb :: IO ()
    _cb _ _ = 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 obj :: a
    obj cb :: 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 "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 obj :: a
    obj cb :: 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 "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 cb :: 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 _cb :: IO ()
    _cb _ _ = 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 obj :: a
    obj cb :: 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 "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 obj :: a
    obj cb :: 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 "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 cb :: 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 _cb :: IO ()
    _cb _ _ = 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 obj :: a
    obj cb :: 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 "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 obj :: a
    obj cb :: 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 "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