{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

'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.
-}

module GI.Atk.Interfaces.Window
    ( 

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


 -- * Signals
-- ** activate #signal:activate#
    C_WindowActivateCallback                ,
    WindowActivateCallback                  ,
    WindowActivateSignalInfo                ,
    afterWindowActivate                     ,
    genClosure_WindowActivate               ,
    mk_WindowActivateCallback               ,
    noWindowActivateCallback                ,
    onWindowActivate                        ,
    wrap_WindowActivateCallback             ,


-- ** create #signal:create#
    C_WindowCreateCallback                  ,
    WindowCreateCallback                    ,
    WindowCreateSignalInfo                  ,
    afterWindowCreate                       ,
    genClosure_WindowCreate                 ,
    mk_WindowCreateCallback                 ,
    noWindowCreateCallback                  ,
    onWindowCreate                          ,
    wrap_WindowCreateCallback               ,


-- ** deactivate #signal:deactivate#
    C_WindowDeactivateCallback              ,
    WindowDeactivateCallback                ,
    WindowDeactivateSignalInfo              ,
    afterWindowDeactivate                   ,
    genClosure_WindowDeactivate             ,
    mk_WindowDeactivateCallback             ,
    noWindowDeactivateCallback              ,
    onWindowDeactivate                      ,
    wrap_WindowDeactivateCallback           ,


-- ** destroy #signal:destroy#
    C_WindowDestroyCallback                 ,
    WindowDestroyCallback                   ,
    WindowDestroySignalInfo                 ,
    afterWindowDestroy                      ,
    genClosure_WindowDestroy                ,
    mk_WindowDestroyCallback                ,
    noWindowDestroyCallback                 ,
    onWindowDestroy                         ,
    wrap_WindowDestroyCallback              ,


-- ** maximize #signal:maximize#
    C_WindowMaximizeCallback                ,
    WindowMaximizeCallback                  ,
    WindowMaximizeSignalInfo                ,
    afterWindowMaximize                     ,
    genClosure_WindowMaximize               ,
    mk_WindowMaximizeCallback               ,
    noWindowMaximizeCallback                ,
    onWindowMaximize                        ,
    wrap_WindowMaximizeCallback             ,


-- ** minimize #signal:minimize#
    C_WindowMinimizeCallback                ,
    WindowMinimizeCallback                  ,
    WindowMinimizeSignalInfo                ,
    afterWindowMinimize                     ,
    genClosure_WindowMinimize               ,
    mk_WindowMinimizeCallback               ,
    noWindowMinimizeCallback                ,
    onWindowMinimize                        ,
    wrap_WindowMinimizeCallback             ,


-- ** move #signal:move#
    C_WindowMoveCallback                    ,
    WindowMoveCallback                      ,
    WindowMoveSignalInfo                    ,
    afterWindowMove                         ,
    genClosure_WindowMove                   ,
    mk_WindowMoveCallback                   ,
    noWindowMoveCallback                    ,
    onWindowMove                            ,
    wrap_WindowMoveCallback                 ,


-- ** resize #signal:resize#
    C_WindowResizeCallback                  ,
    WindowResizeCallback                    ,
    WindowResizeSignalInfo                  ,
    afterWindowResize                       ,
    genClosure_WindowResize                 ,
    mk_WindowResizeCallback                 ,
    noWindowResizeCallback                  ,
    onWindowResize                          ,
    wrap_WindowResizeCallback               ,


-- ** restore #signal:restore#
    C_WindowRestoreCallback                 ,
    WindowRestoreCallback                   ,
    WindowRestoreSignalInfo                 ,
    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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 {-# SOURCE #-} qualified GI.Atk.Objects.Object as Atk.Object
import qualified GI.GObject.Objects.Object as GObject.Object

-- interface Window 
newtype Window = Window (ManagedPtr Window)
noWindow :: Maybe Window
noWindow = Nothing

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 "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 "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveWindowMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    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 "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) => O.IsLabelProxy t (Window -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveWindowMethod t Window, O.MethodInfo info Window p) => O.IsLabel t (Window -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

-- signal Window::activate
type WindowActivateCallback =
    IO ()

noWindowActivateCallback :: Maybe WindowActivateCallback
noWindowActivateCallback = Nothing

type C_WindowActivateCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WindowActivateCallback :: C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)

genClosure_WindowActivate :: WindowActivateCallback -> IO Closure
genClosure_WindowActivate cb = do
    let cb' = wrap_WindowActivateCallback cb
    mk_WindowActivateCallback cb' >>= newCClosure


wrap_WindowActivateCallback ::
    WindowActivateCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WindowActivateCallback _cb _ _ = do
    _cb 


onWindowActivate :: (GObject a, MonadIO m) => a -> WindowActivateCallback -> m SignalHandlerId
onWindowActivate obj cb = liftIO $ connectWindowActivate obj cb SignalConnectBefore
afterWindowActivate :: (GObject a, MonadIO m) => a -> WindowActivateCallback -> m SignalHandlerId
afterWindowActivate obj cb = connectWindowActivate obj cb SignalConnectAfter

connectWindowActivate :: (GObject a, MonadIO m) =>
                         a -> WindowActivateCallback -> SignalConnectMode -> m SignalHandlerId
connectWindowActivate obj cb after = liftIO $ do
    let cb' = wrap_WindowActivateCallback cb
    cb'' <- mk_WindowActivateCallback cb'
    connectSignalFunPtr obj "activate" cb'' after

-- signal Window::create
type WindowCreateCallback =
    IO ()

noWindowCreateCallback :: Maybe WindowCreateCallback
noWindowCreateCallback = Nothing

type C_WindowCreateCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WindowCreateCallback :: C_WindowCreateCallback -> IO (FunPtr C_WindowCreateCallback)

genClosure_WindowCreate :: WindowCreateCallback -> IO Closure
genClosure_WindowCreate cb = do
    let cb' = wrap_WindowCreateCallback cb
    mk_WindowCreateCallback cb' >>= newCClosure


wrap_WindowCreateCallback ::
    WindowCreateCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WindowCreateCallback _cb _ _ = do
    _cb 


onWindowCreate :: (GObject a, MonadIO m) => a -> WindowCreateCallback -> m SignalHandlerId
onWindowCreate obj cb = liftIO $ connectWindowCreate obj cb SignalConnectBefore
afterWindowCreate :: (GObject a, MonadIO m) => a -> WindowCreateCallback -> m SignalHandlerId
afterWindowCreate obj cb = connectWindowCreate obj cb SignalConnectAfter

connectWindowCreate :: (GObject a, MonadIO m) =>
                       a -> WindowCreateCallback -> SignalConnectMode -> m SignalHandlerId
connectWindowCreate obj cb after = liftIO $ do
    let cb' = wrap_WindowCreateCallback cb
    cb'' <- mk_WindowCreateCallback cb'
    connectSignalFunPtr obj "create" cb'' after

-- signal Window::deactivate
type WindowDeactivateCallback =
    IO ()

noWindowDeactivateCallback :: Maybe WindowDeactivateCallback
noWindowDeactivateCallback = Nothing

type C_WindowDeactivateCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WindowDeactivateCallback :: C_WindowDeactivateCallback -> IO (FunPtr C_WindowDeactivateCallback)

genClosure_WindowDeactivate :: WindowDeactivateCallback -> IO Closure
genClosure_WindowDeactivate cb = do
    let cb' = wrap_WindowDeactivateCallback cb
    mk_WindowDeactivateCallback cb' >>= newCClosure


wrap_WindowDeactivateCallback ::
    WindowDeactivateCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WindowDeactivateCallback _cb _ _ = do
    _cb 


onWindowDeactivate :: (GObject a, MonadIO m) => a -> WindowDeactivateCallback -> m SignalHandlerId
onWindowDeactivate obj cb = liftIO $ connectWindowDeactivate obj cb SignalConnectBefore
afterWindowDeactivate :: (GObject a, MonadIO m) => a -> WindowDeactivateCallback -> m SignalHandlerId
afterWindowDeactivate obj cb = connectWindowDeactivate obj cb SignalConnectAfter

connectWindowDeactivate :: (GObject a, MonadIO m) =>
                           a -> WindowDeactivateCallback -> SignalConnectMode -> m SignalHandlerId
connectWindowDeactivate obj cb after = liftIO $ do
    let cb' = wrap_WindowDeactivateCallback cb
    cb'' <- mk_WindowDeactivateCallback cb'
    connectSignalFunPtr obj "deactivate" cb'' after

-- signal Window::destroy
type WindowDestroyCallback =
    IO ()

noWindowDestroyCallback :: Maybe WindowDestroyCallback
noWindowDestroyCallback = Nothing

type C_WindowDestroyCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WindowDestroyCallback :: C_WindowDestroyCallback -> IO (FunPtr C_WindowDestroyCallback)

genClosure_WindowDestroy :: WindowDestroyCallback -> IO Closure
genClosure_WindowDestroy cb = do
    let cb' = wrap_WindowDestroyCallback cb
    mk_WindowDestroyCallback cb' >>= newCClosure


wrap_WindowDestroyCallback ::
    WindowDestroyCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WindowDestroyCallback _cb _ _ = do
    _cb 


onWindowDestroy :: (GObject a, MonadIO m) => a -> WindowDestroyCallback -> m SignalHandlerId
onWindowDestroy obj cb = liftIO $ connectWindowDestroy obj cb SignalConnectBefore
afterWindowDestroy :: (GObject a, MonadIO m) => a -> WindowDestroyCallback -> m SignalHandlerId
afterWindowDestroy obj cb = connectWindowDestroy obj cb SignalConnectAfter

connectWindowDestroy :: (GObject a, MonadIO m) =>
                        a -> WindowDestroyCallback -> SignalConnectMode -> m SignalHandlerId
connectWindowDestroy obj cb after = liftIO $ do
    let cb' = wrap_WindowDestroyCallback cb
    cb'' <- mk_WindowDestroyCallback cb'
    connectSignalFunPtr obj "destroy" cb'' after

-- signal Window::maximize
type WindowMaximizeCallback =
    IO ()

noWindowMaximizeCallback :: Maybe WindowMaximizeCallback
noWindowMaximizeCallback = Nothing

type C_WindowMaximizeCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WindowMaximizeCallback :: C_WindowMaximizeCallback -> IO (FunPtr C_WindowMaximizeCallback)

genClosure_WindowMaximize :: WindowMaximizeCallback -> IO Closure
genClosure_WindowMaximize cb = do
    let cb' = wrap_WindowMaximizeCallback cb
    mk_WindowMaximizeCallback cb' >>= newCClosure


wrap_WindowMaximizeCallback ::
    WindowMaximizeCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WindowMaximizeCallback _cb _ _ = do
    _cb 


onWindowMaximize :: (GObject a, MonadIO m) => a -> WindowMaximizeCallback -> m SignalHandlerId
onWindowMaximize obj cb = liftIO $ connectWindowMaximize obj cb SignalConnectBefore
afterWindowMaximize :: (GObject a, MonadIO m) => a -> WindowMaximizeCallback -> m SignalHandlerId
afterWindowMaximize obj cb = connectWindowMaximize obj cb SignalConnectAfter

connectWindowMaximize :: (GObject a, MonadIO m) =>
                         a -> WindowMaximizeCallback -> SignalConnectMode -> m SignalHandlerId
connectWindowMaximize obj cb after = liftIO $ do
    let cb' = wrap_WindowMaximizeCallback cb
    cb'' <- mk_WindowMaximizeCallback cb'
    connectSignalFunPtr obj "maximize" cb'' after

-- signal Window::minimize
type WindowMinimizeCallback =
    IO ()

noWindowMinimizeCallback :: Maybe WindowMinimizeCallback
noWindowMinimizeCallback = Nothing

type C_WindowMinimizeCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WindowMinimizeCallback :: C_WindowMinimizeCallback -> IO (FunPtr C_WindowMinimizeCallback)

genClosure_WindowMinimize :: WindowMinimizeCallback -> IO Closure
genClosure_WindowMinimize cb = do
    let cb' = wrap_WindowMinimizeCallback cb
    mk_WindowMinimizeCallback cb' >>= newCClosure


wrap_WindowMinimizeCallback ::
    WindowMinimizeCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WindowMinimizeCallback _cb _ _ = do
    _cb 


onWindowMinimize :: (GObject a, MonadIO m) => a -> WindowMinimizeCallback -> m SignalHandlerId
onWindowMinimize obj cb = liftIO $ connectWindowMinimize obj cb SignalConnectBefore
afterWindowMinimize :: (GObject a, MonadIO m) => a -> WindowMinimizeCallback -> m SignalHandlerId
afterWindowMinimize obj cb = connectWindowMinimize obj cb SignalConnectAfter

connectWindowMinimize :: (GObject a, MonadIO m) =>
                         a -> WindowMinimizeCallback -> SignalConnectMode -> m SignalHandlerId
connectWindowMinimize obj cb after = liftIO $ do
    let cb' = wrap_WindowMinimizeCallback cb
    cb'' <- mk_WindowMinimizeCallback cb'
    connectSignalFunPtr obj "minimize" cb'' after

-- signal Window::move
type WindowMoveCallback =
    IO ()

noWindowMoveCallback :: Maybe WindowMoveCallback
noWindowMoveCallback = Nothing

type C_WindowMoveCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WindowMoveCallback :: C_WindowMoveCallback -> IO (FunPtr C_WindowMoveCallback)

genClosure_WindowMove :: WindowMoveCallback -> IO Closure
genClosure_WindowMove cb = do
    let cb' = wrap_WindowMoveCallback cb
    mk_WindowMoveCallback cb' >>= newCClosure


wrap_WindowMoveCallback ::
    WindowMoveCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WindowMoveCallback _cb _ _ = do
    _cb 


onWindowMove :: (GObject a, MonadIO m) => a -> WindowMoveCallback -> m SignalHandlerId
onWindowMove obj cb = liftIO $ connectWindowMove obj cb SignalConnectBefore
afterWindowMove :: (GObject a, MonadIO m) => a -> WindowMoveCallback -> m SignalHandlerId
afterWindowMove obj cb = connectWindowMove obj cb SignalConnectAfter

connectWindowMove :: (GObject a, MonadIO m) =>
                     a -> WindowMoveCallback -> SignalConnectMode -> m SignalHandlerId
connectWindowMove obj cb after = liftIO $ do
    let cb' = wrap_WindowMoveCallback cb
    cb'' <- mk_WindowMoveCallback cb'
    connectSignalFunPtr obj "move" cb'' after

-- signal Window::resize
type WindowResizeCallback =
    IO ()

noWindowResizeCallback :: Maybe WindowResizeCallback
noWindowResizeCallback = Nothing

type C_WindowResizeCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WindowResizeCallback :: C_WindowResizeCallback -> IO (FunPtr C_WindowResizeCallback)

genClosure_WindowResize :: WindowResizeCallback -> IO Closure
genClosure_WindowResize cb = do
    let cb' = wrap_WindowResizeCallback cb
    mk_WindowResizeCallback cb' >>= newCClosure


wrap_WindowResizeCallback ::
    WindowResizeCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WindowResizeCallback _cb _ _ = do
    _cb 


onWindowResize :: (GObject a, MonadIO m) => a -> WindowResizeCallback -> m SignalHandlerId
onWindowResize obj cb = liftIO $ connectWindowResize obj cb SignalConnectBefore
afterWindowResize :: (GObject a, MonadIO m) => a -> WindowResizeCallback -> m SignalHandlerId
afterWindowResize obj cb = connectWindowResize obj cb SignalConnectAfter

connectWindowResize :: (GObject a, MonadIO m) =>
                       a -> WindowResizeCallback -> SignalConnectMode -> m SignalHandlerId
connectWindowResize obj cb after = liftIO $ do
    let cb' = wrap_WindowResizeCallback cb
    cb'' <- mk_WindowResizeCallback cb'
    connectSignalFunPtr obj "resize" cb'' after

-- signal Window::restore
type WindowRestoreCallback =
    IO ()

noWindowRestoreCallback :: Maybe WindowRestoreCallback
noWindowRestoreCallback = Nothing

type C_WindowRestoreCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WindowRestoreCallback :: C_WindowRestoreCallback -> IO (FunPtr C_WindowRestoreCallback)

genClosure_WindowRestore :: WindowRestoreCallback -> IO Closure
genClosure_WindowRestore cb = do
    let cb' = wrap_WindowRestoreCallback cb
    mk_WindowRestoreCallback cb' >>= newCClosure


wrap_WindowRestoreCallback ::
    WindowRestoreCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WindowRestoreCallback _cb _ _ = do
    _cb 


onWindowRestore :: (GObject a, MonadIO m) => a -> WindowRestoreCallback -> m SignalHandlerId
onWindowRestore obj cb = liftIO $ connectWindowRestore obj cb SignalConnectBefore
afterWindowRestore :: (GObject a, MonadIO m) => a -> WindowRestoreCallback -> m SignalHandlerId
afterWindowRestore obj cb = connectWindowRestore obj cb SignalConnectAfter

connectWindowRestore :: (GObject a, MonadIO m) =>
                        a -> WindowRestoreCallback -> SignalConnectMode -> m SignalHandlerId
connectWindowRestore obj cb after = liftIO $ do
    let cb' = wrap_WindowRestoreCallback cb
    cb'' <- mk_WindowRestoreCallback cb'
    connectSignalFunPtr obj "restore" cb'' after

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, *)])

data WindowActivateSignalInfo
instance SignalInfo WindowActivateSignalInfo where
    type HaskellCallbackType WindowActivateSignalInfo = WindowActivateCallback
    connectSignal _ = connectWindowActivate

data WindowCreateSignalInfo
instance SignalInfo WindowCreateSignalInfo where
    type HaskellCallbackType WindowCreateSignalInfo = WindowCreateCallback
    connectSignal _ = connectWindowCreate

data WindowDeactivateSignalInfo
instance SignalInfo WindowDeactivateSignalInfo where
    type HaskellCallbackType WindowDeactivateSignalInfo = WindowDeactivateCallback
    connectSignal _ = connectWindowDeactivate

data WindowDestroySignalInfo
instance SignalInfo WindowDestroySignalInfo where
    type HaskellCallbackType WindowDestroySignalInfo = WindowDestroyCallback
    connectSignal _ = connectWindowDestroy

data WindowMaximizeSignalInfo
instance SignalInfo WindowMaximizeSignalInfo where
    type HaskellCallbackType WindowMaximizeSignalInfo = WindowMaximizeCallback
    connectSignal _ = connectWindowMaximize

data WindowMinimizeSignalInfo
instance SignalInfo WindowMinimizeSignalInfo where
    type HaskellCallbackType WindowMinimizeSignalInfo = WindowMinimizeCallback
    connectSignal _ = connectWindowMinimize

data WindowMoveSignalInfo
instance SignalInfo WindowMoveSignalInfo where
    type HaskellCallbackType WindowMoveSignalInfo = WindowMoveCallback
    connectSignal _ = connectWindowMove

data WindowResizeSignalInfo
instance SignalInfo WindowResizeSignalInfo where
    type HaskellCallbackType WindowResizeSignalInfo = WindowResizeCallback
    connectSignal _ = connectWindowResize

data WindowRestoreSignalInfo
instance SignalInfo WindowRestoreSignalInfo where
    type HaskellCallbackType WindowRestoreSignalInfo = WindowRestoreCallback
    connectSignal _ = connectWindowRestore

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, *)])

foreign import ccall "atk_window_get_type"
    c_atk_window_get_type :: IO GType

instance GObject Window where
    gobjectType _ = c_atk_window_get_type
    

class GObject o => IsWindow o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Window a) =>
    IsWindow a
#endif
instance IsWindow Window
instance Atk.Object.IsObject Window
instance GObject.Object.IsObject Window

toWindow :: IsWindow o => o -> IO Window
toWindow = unsafeCastTo Window