Memory-managed wrapper type.

Type class for types which can be safely cast to Screen, for instance with toScreen.

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

A convenience alias for Nothing :: Maybe Screen.

Calculates the layout of Workspace, with additional information like the row and column of the Workspace with index spaceIndex.

Since: 2.12

Asks the window manager to change the number of Workspace on screen.

Since: 2.2

Synchronously and immediately updates the list of Window on screen. This bypasses the standard update mechanism, where the list of Window is updated in the idle loop.

This is usually a bad idea for both performance and correctness reasons (to get things right, you need to write model-view code that tracks changes, not get a static list of open windows). However, this function can be useful for small applications that just do something and then exit.

Frees the content of layout. This does not free layout itself, so you might want to free layout yourself after calling this.

Since: 2.12

Gets the Screen for a given screen on the default display.

Gets the active Window on screen. May return Nothing sometimes, since not all window managers guarantee that a window is always active.

Gets the active Workspace on screen. May return Nothing sometimes, if libwnck is in a weird state due to the asynchronous nature of the interaction with the window manager.

Gets the X window ID of the background pixmap of screen.

Gets the default Screen on the default display.

Gets the Screen for the root window at rootWindowId, or Nothing if no Screen exists for this root window.

This function does not work if screenGet was not called for the sought Screen before, and returns Nothing.

Gets the height of screen.

Gets the index of screen on the display to which it belongs. The first Screen has an index of 0.

Since: 2.20

Gets the previously active Window on screen. May return Nothing sometimes, since not all window managers guarantee that a window is always active.

Since: 2.8

Gets whether screen is in the "showing the desktop" mode. This mode is changed when a Screen::showing-desktop-changed signal gets emitted.

Since: 2.2

Gets the width of screen.

Gets the name of the window manager.

Since: 2.20

Gets the list of Window on screen. The list is not in a defined order, but should be "stable" (windows should not be reordered in it). However, the stability of the list is established by the window manager, so don't blame libwnck if it breaks down.

Gets the list of Window on screen in bottom-to-top order.

Gets the Workspace numbered workspace on screen.

Gets the number of Workspace on screen.

Gets the list of Workspace on screen. The list is ordered: the first element in the list is the first Workspace, etc..

Since: 2.20

Asks the window manager to move the viewport of the current Workspace on screen.

Since: 2.4

Gets whether the window manager for screen supports a certain hint from the <ulink url="http://standards.freedesktop.org/wm-spec/wm-spec-latest.html">Extended Window Manager Hints specification</ulink> (EWMH).

When using this function, keep in mind that the window manager can change over time; so you should not use this function in a way that impacts persistent application state. A common bug is that your application can start up before the window manager does when the user logs in, and before the window manager starts screenNetWmSupports will return False for every property.

See also gdk_x11_screen_supports_net_wm_hint() in GDK.

Releases the ownership of the layout of Workspace on screen. currentToken is used to verify that the caller is the owner of the layout. If the verification fails, nothing happens.

Asks the window manager to set the "showing the desktop" mode on screen according to show.

Since: 2.2

Tries to modify the layout of Workspace on screen. To do this, tries to acquire ownership of the layout. If the current process is the owner of the layout, currentToken is used to determine if the caller is the owner (there might be more than one part of the same process trying to set the layout). Since no more than one application should set this property of screen at a time, setting the layout is not guaranteed to work.

If rows is 0, the actual number of rows will be determined based on columns and the number of Workspace. If columns is 0, the actual number of columns will be determined based on rows and the number of Workspace. rows and columns must not be 0 at the same time.

You have to release the ownership of the layout with screenReleaseWorkspaceLayout when you do not need it anymore.

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

Emitted when the active window on screen has changed.

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

after screen #activeWindowChanged callback

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ScreenActiveWindowChangedCallback.

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

on screen #activeWindowChanged callback

Wrap a ScreenActiveWindowChangedCallback into a C_ScreenActiveWindowChangedCallback.

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

Emitted when the active workspace on screen has changed.

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

after screen #activeWorkspaceChanged callback

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ScreenActiveWorkspaceChangedCallback.

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

on screen #activeWorkspaceChanged callback

Wrap a ScreenActiveWorkspaceChangedCallback into a C_ScreenActiveWorkspaceChangedCallback.

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

Emitted when a Application is closed on screen.

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

after screen #applicationClosed callback

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ScreenApplicationClosedCallback.

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

on screen #applicationClosed callback

Wrap a ScreenApplicationClosedCallback into a C_ScreenApplicationClosedCallback.

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

Emitted when a new Application is opened on screen.

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

after screen #applicationOpened callback

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ScreenApplicationOpenedCallback.

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

on screen #applicationOpened callback

Wrap a ScreenApplicationOpenedCallback into a C_ScreenApplicationOpenedCallback.

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

Emitted when the background on the root window of screen has changed.

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

after screen #backgroundChanged callback

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ScreenBackgroundChangedCallback.

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

on screen #backgroundChanged callback

Wrap a ScreenBackgroundChangedCallback into a C_ScreenBackgroundChangedCallback.

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

Emitted when a ClassGroup is closed on screen.

Since: 2.20

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

after screen #classGroupClosed callback

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ScreenClassGroupClosedCallback.

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

on screen #classGroupClosed callback

Wrap a ScreenClassGroupClosedCallback into a C_ScreenClassGroupClosedCallback.

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

Emitted when a new ClassGroup is opened on screen.

Since: 2.20

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

after screen #classGroupOpened callback

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ScreenClassGroupOpenedCallback.

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

on screen #classGroupOpened callback

Wrap a ScreenClassGroupOpenedCallback into a C_ScreenClassGroupOpenedCallback.

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

Emitted when "showing the desktop" mode of screen is toggled.

Since: 2.20

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

after screen #showingDesktopChanged callback

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ScreenShowingDesktopChangedCallback.

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

on screen #showingDesktopChanged callback

Wrap a ScreenShowingDesktopChangedCallback into a C_ScreenShowingDesktopChangedCallback.

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

Emitted when a viewport position has changed in a Workspace of screen or when a Workspace of screen gets or loses its viewport.

Since: 2.20

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

after screen #viewportsChanged callback

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ScreenViewportsChangedCallback.

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

on screen #viewportsChanged callback

Wrap a ScreenViewportsChangedCallback into a C_ScreenViewportsChangedCallback.

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

Emitted when a Window is closed on screen.

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

after screen #windowClosed callback

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ScreenWindowClosedCallback.

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

on screen #windowClosed callback

Wrap a ScreenWindowClosedCallback into a C_ScreenWindowClosedCallback.

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

Emitted when the window manager on screen has changed.

Since: 2.20

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

after screen #windowManagerChanged callback

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ScreenWindowManagerChangedCallback.

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

on screen #windowManagerChanged callback

Wrap a ScreenWindowManagerChangedCallback into a C_ScreenWindowManagerChangedCallback.

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

Emitted when a new Window is opened on screen.

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

after screen #windowOpened callback

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ScreenWindowOpenedCallback.

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

on screen #windowOpened callback

Wrap a ScreenWindowOpenedCallback into a C_ScreenWindowOpenedCallback.

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

Emitted when the stacking order of Window on screen has changed.

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

after screen #windowStackingChanged callback

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ScreenWindowStackingChangedCallback.

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

on screen #windowStackingChanged callback

Wrap a ScreenWindowStackingChangedCallback into a C_ScreenWindowStackingChangedCallback.

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

Emitted when a Workspace is created on screen.

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

after screen #workspaceCreated callback

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ScreenWorkspaceCreatedCallback.

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

on screen #workspaceCreated callback

Wrap a ScreenWorkspaceCreatedCallback into a C_ScreenWorkspaceCreatedCallback.

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

Emitted when a Workspace is destroyed on screen.

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

after screen #workspaceDestroyed callback

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ScreenWorkspaceDestroyedCallback.

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

on screen #workspaceDestroyed callback

Wrap a ScreenWorkspaceDestroyedCallback into a C_ScreenWorkspaceDestroyedCallback.