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.

Exported types

newtype Window

Memory-managed wrapper type.

Constructors

Window (ManagedPtr Window)

Instances

GObject Window

Defined in GI.Atk.Interfaces.Window

Methods

gobjectType :: IO GType

HasParentTypes Window

Defined in GI.Atk.Interfaces.Window

type ParentTypes Window

Defined in GI.Atk.Interfaces.Window

type ParentTypes Window = Object ': (Object ': ([] :: [Type]))

noWindow :: Maybe Window

A convenience alias for Nothing :: Maybe Window.

class (GObject o, IsDescendantOf Window o) => IsWindow o

Type class for types which can be safely cast to Window, for instance with toWindow.

Instances

(GObject o, IsDescendantOf Window o) => IsWindow o

Defined in GI.Atk.Interfaces.Window

toWindow :: (MonadIO m, IsWindow o) => o -> m Window

Cast to Window, for types for which this is known to be safe. For general casts, use castTo.

Signals

activate

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

Type for the callback on the (unwrapped) C side.

type WindowActivateCallback = IO ()

The signal Window::activate is emitted when a window becomes the active window of the application or session.

Since: 2.2

afterWindowActivate :: (IsWindow a, MonadIO m) => a -> WindowActivateCallback -> m SignalHandlerId

Connect a signal handler for the “activate” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after window #activate callback

genClosure_WindowActivate :: MonadIO m => WindowActivateCallback -> m (GClosure C_WindowActivateCallback)

Wrap the callback into a GClosure.

mk_WindowActivateCallback :: C_WindowActivateCallback -> IO (FunPtr C_WindowActivateCallback)

Generate a function pointer callable from C code, from a C_WindowActivateCallback.

noWindowActivateCallback :: Maybe WindowActivateCallback

A convenience synonym for Nothing :: Maybe WindowActivateCallback.

onWindowActivate :: (IsWindow a, MonadIO m) => a -> WindowActivateCallback -> m SignalHandlerId

Connect a signal handler for the “activate” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on window #activate callback

wrap_WindowActivateCallback :: WindowActivateCallback -> C_WindowActivateCallback

Wrap a WindowActivateCallback into a C_WindowActivateCallback.

create

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

Type for the callback on the (unwrapped) C side.

type WindowCreateCallback = IO ()

The signal Window::create is emitted when a new window is created.

Since: 2.2

afterWindowCreate :: (IsWindow a, MonadIO m) => a -> WindowCreateCallback -> m SignalHandlerId

Connect a signal handler for the “create” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after window #create callback

genClosure_WindowCreate :: MonadIO m => WindowCreateCallback -> m (GClosure C_WindowCreateCallback)

Wrap the callback into a GClosure.

mk_WindowCreateCallback :: C_WindowCreateCallback -> IO (FunPtr C_WindowCreateCallback)

Generate a function pointer callable from C code, from a C_WindowCreateCallback.

noWindowCreateCallback :: Maybe WindowCreateCallback

A convenience synonym for Nothing :: Maybe WindowCreateCallback.

onWindowCreate :: (IsWindow a, MonadIO m) => a -> WindowCreateCallback -> m SignalHandlerId

Connect a signal handler for the “create” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on window #create callback

wrap_WindowCreateCallback :: WindowCreateCallback -> C_WindowCreateCallback

Wrap a WindowCreateCallback into a C_WindowCreateCallback.

deactivate

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

Type for the callback on the (unwrapped) C side.

type WindowDeactivateCallback = IO ()

The signal Window::deactivate is emitted when a window is no longer the active window of the application or session.

Since: 2.2

afterWindowDeactivate :: (IsWindow a, MonadIO m) => a -> WindowDeactivateCallback -> m SignalHandlerId

Connect a signal handler for the “deactivate” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after window #deactivate callback

genClosure_WindowDeactivate :: MonadIO m => WindowDeactivateCallback -> m (GClosure C_WindowDeactivateCallback)

Wrap the callback into a GClosure.

mk_WindowDeactivateCallback :: C_WindowDeactivateCallback -> IO (FunPtr C_WindowDeactivateCallback)

Generate a function pointer callable from C code, from a C_WindowDeactivateCallback.

noWindowDeactivateCallback :: Maybe WindowDeactivateCallback

A convenience synonym for Nothing :: Maybe WindowDeactivateCallback.

onWindowDeactivate :: (IsWindow a, MonadIO m) => a -> WindowDeactivateCallback -> m SignalHandlerId

Connect a signal handler for the “deactivate” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on window #deactivate callback

wrap_WindowDeactivateCallback :: WindowDeactivateCallback -> C_WindowDeactivateCallback

Wrap a WindowDeactivateCallback into a C_WindowDeactivateCallback.

destroy

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

Type for the callback on the (unwrapped) C side.

type WindowDestroyCallback = IO ()

The signal Window::destroy is emitted when a window is destroyed.

Since: 2.2

afterWindowDestroy :: (IsWindow a, MonadIO m) => a -> WindowDestroyCallback -> m SignalHandlerId

Connect a signal handler for the “destroy” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after window #destroy callback

genClosure_WindowDestroy :: MonadIO m => WindowDestroyCallback -> m (GClosure C_WindowDestroyCallback)

Wrap the callback into a GClosure.

mk_WindowDestroyCallback :: C_WindowDestroyCallback -> IO (FunPtr C_WindowDestroyCallback)

Generate a function pointer callable from C code, from a C_WindowDestroyCallback.

noWindowDestroyCallback :: Maybe WindowDestroyCallback

A convenience synonym for Nothing :: Maybe WindowDestroyCallback.

onWindowDestroy :: (IsWindow a, MonadIO m) => a -> WindowDestroyCallback -> m SignalHandlerId

Connect a signal handler for the “destroy” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on window #destroy callback

wrap_WindowDestroyCallback :: WindowDestroyCallback -> C_WindowDestroyCallback

Wrap a WindowDestroyCallback into a C_WindowDestroyCallback.

maximize

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

Type for the callback on the (unwrapped) C side.

type WindowMaximizeCallback = IO ()

The signal Window::maximize is emitted when a window is maximized.

Since: 2.2

afterWindowMaximize :: (IsWindow a, MonadIO m) => a -> WindowMaximizeCallback -> m SignalHandlerId

Connect a signal handler for the “maximize” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after window #maximize callback

genClosure_WindowMaximize :: MonadIO m => WindowMaximizeCallback -> m (GClosure C_WindowMaximizeCallback)

Wrap the callback into a GClosure.

mk_WindowMaximizeCallback :: C_WindowMaximizeCallback -> IO (FunPtr C_WindowMaximizeCallback)

Generate a function pointer callable from C code, from a C_WindowMaximizeCallback.

noWindowMaximizeCallback :: Maybe WindowMaximizeCallback

A convenience synonym for Nothing :: Maybe WindowMaximizeCallback.

onWindowMaximize :: (IsWindow a, MonadIO m) => a -> WindowMaximizeCallback -> m SignalHandlerId

Connect a signal handler for the “maximize” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on window #maximize callback

wrap_WindowMaximizeCallback :: WindowMaximizeCallback -> C_WindowMaximizeCallback

Wrap a WindowMaximizeCallback into a C_WindowMaximizeCallback.

minimize

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

Type for the callback on the (unwrapped) C side.

type WindowMinimizeCallback = IO ()

The signal Window::minimize is emitted when a window is minimized.

Since: 2.2

afterWindowMinimize :: (IsWindow a, MonadIO m) => a -> WindowMinimizeCallback -> m SignalHandlerId

Connect a signal handler for the “minimize” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after window #minimize callback

genClosure_WindowMinimize :: MonadIO m => WindowMinimizeCallback -> m (GClosure C_WindowMinimizeCallback)

Wrap the callback into a GClosure.

mk_WindowMinimizeCallback :: C_WindowMinimizeCallback -> IO (FunPtr C_WindowMinimizeCallback)

Generate a function pointer callable from C code, from a C_WindowMinimizeCallback.

noWindowMinimizeCallback :: Maybe WindowMinimizeCallback

A convenience synonym for Nothing :: Maybe WindowMinimizeCallback.

onWindowMinimize :: (IsWindow a, MonadIO m) => a -> WindowMinimizeCallback -> m SignalHandlerId

Connect a signal handler for the “minimize” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on window #minimize callback

wrap_WindowMinimizeCallback :: WindowMinimizeCallback -> C_WindowMinimizeCallback

Wrap a WindowMinimizeCallback into a C_WindowMinimizeCallback.

move

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

Type for the callback on the (unwrapped) C side.

type WindowMoveCallback = IO ()

The signal Window::move is emitted when a window is moved.

Since: 2.2

afterWindowMove :: (IsWindow a, MonadIO m) => a -> WindowMoveCallback -> m SignalHandlerId

Connect a signal handler for the “move” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after window #move callback

genClosure_WindowMove :: MonadIO m => WindowMoveCallback -> m (GClosure C_WindowMoveCallback)

Wrap the callback into a GClosure.

mk_WindowMoveCallback :: C_WindowMoveCallback -> IO (FunPtr C_WindowMoveCallback)

Generate a function pointer callable from C code, from a C_WindowMoveCallback.

noWindowMoveCallback :: Maybe WindowMoveCallback

A convenience synonym for Nothing :: Maybe WindowMoveCallback.

onWindowMove :: (IsWindow a, MonadIO m) => a -> WindowMoveCallback -> m SignalHandlerId

Connect a signal handler for the “move” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on window #move callback

wrap_WindowMoveCallback :: WindowMoveCallback -> C_WindowMoveCallback

Wrap a WindowMoveCallback into a C_WindowMoveCallback.

resize

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

Type for the callback on the (unwrapped) C side.

type WindowResizeCallback = IO ()

The signal Window::resize is emitted when a window is resized.

Since: 2.2

afterWindowResize :: (IsWindow a, MonadIO m) => a -> WindowResizeCallback -> m SignalHandlerId

Connect a signal handler for the “resize” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after window #resize callback

genClosure_WindowResize :: MonadIO m => WindowResizeCallback -> m (GClosure C_WindowResizeCallback)

Wrap the callback into a GClosure.

mk_WindowResizeCallback :: C_WindowResizeCallback -> IO (FunPtr C_WindowResizeCallback)

Generate a function pointer callable from C code, from a C_WindowResizeCallback.

noWindowResizeCallback :: Maybe WindowResizeCallback

A convenience synonym for Nothing :: Maybe WindowResizeCallback.

onWindowResize :: (IsWindow a, MonadIO m) => a -> WindowResizeCallback -> m SignalHandlerId

Connect a signal handler for the “resize” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on window #resize callback

wrap_WindowResizeCallback :: WindowResizeCallback -> C_WindowResizeCallback

Wrap a WindowResizeCallback into a C_WindowResizeCallback.

restore

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

Type for the callback on the (unwrapped) C side.

type WindowRestoreCallback = IO ()

The signal Window::restore is emitted when a window is restored.

Since: 2.2

afterWindowRestore :: (IsWindow a, MonadIO m) => a -> WindowRestoreCallback -> m SignalHandlerId

Connect a signal handler for the “restore” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after window #restore callback

genClosure_WindowRestore :: MonadIO m => WindowRestoreCallback -> m (GClosure C_WindowRestoreCallback)

Wrap the callback into a GClosure.

mk_WindowRestoreCallback :: C_WindowRestoreCallback -> IO (FunPtr C_WindowRestoreCallback)

Generate a function pointer callable from C code, from a C_WindowRestoreCallback.

noWindowRestoreCallback :: Maybe WindowRestoreCallback

A convenience synonym for Nothing :: Maybe WindowRestoreCallback.

onWindowRestore :: (IsWindow a, MonadIO m) => a -> WindowRestoreCallback -> m SignalHandlerId

Connect a signal handler for the “restore” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on window #restore callback

wrap_WindowRestoreCallback :: WindowRestoreCallback -> C_WindowRestoreCallback

Wrap a WindowRestoreCallback into a C_WindowRestoreCallback.