GI.Wnck.Objects.Screen

The Screen struct contains only private fields and should not be directly accessed.

Exported types

newtype Screen

Memory-managed wrapper type.

Constructors

Screen (ManagedPtr Screen)

Instances

Eq Screen

Defined in GI.Wnck.Objects.Screen

Methods

(==) :: Screen -> Screen -> Bool

(/=) :: Screen -> Screen -> Bool

GObject Screen

Defined in GI.Wnck.Objects.Screen

ManagedPtrNewtype Screen

Defined in GI.Wnck.Objects.Screen

Methods

toManagedPtr :: Screen -> ManagedPtr Screen

TypedObject Screen

Defined in GI.Wnck.Objects.Screen

Methods

glibType :: IO GType

HasParentTypes Screen

Defined in GI.Wnck.Objects.Screen

IsGValue (Maybe Screen)

Convert Screen to and from GValue. See toGValue and fromGValue.

Defined in GI.Wnck.Objects.Screen

Methods

gvalueGType_ :: IO GType

gvalueSet_ :: Ptr GValue -> Maybe Screen -> IO ()

gvalueGet_ :: Ptr GValue -> IO (Maybe Screen)

type ParentTypes Screen

Defined in GI.Wnck.Objects.Screen

type ParentTypes Screen = '[Object]

class (GObject o, IsDescendantOf Screen o) => IsScreen o

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

Instances

(GObject o, IsDescendantOf Screen o) => IsScreen o

Defined in GI.Wnck.Objects.Screen

toScreen :: (MonadIO m, IsScreen o) => o -> m Screen

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

Methods

Click to display all available methods, including inherited ones

Methods

bindProperty, bindPropertyFull, calcWorkspaceLayout, changeWorkspaceCount, forceFloating, forceUpdate, freezeNotify, getv, isFloating, moveViewport, netWmSupports, notify, notifyByPspec, ref, refSink, releaseWorkspaceLayout, runDispose, stealData, stealQdata, thawNotify, toggleShowingDesktop, trySetWorkspaceLayout, unref, watchClosure.

Getters

getActiveWindow, getActiveWorkspace, getBackgroundPixmap, getData, getHandle, getHeight, getNumber, getPreviouslyActiveWindow, getProperty, getQdata, getShowingDesktop, getWidth, getWindowManagerName, getWindows, getWindowsStacked, getWorkspace, getWorkspaceCount, getWorkspaces.

Setters

setData, setDataFull, setProperty.

calcWorkspaceLayout

screenCalcWorkspaceLayout

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> Int32

numWorkspaces: the number of Workspace on screen, or -1 to let screenCalcWorkspaceLayout find this number.

-> Int32

spaceIndex: the index of a Workspace.

-> WorkspaceLayout

layout: return location for the layout of Workspace with additional information.

-> m ()

Deprecated: (Since version 2.20)

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

Since: 2.12

changeWorkspaceCount

screenChangeWorkspaceCount

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> Int32

count: the number of Workspace to request.

-> m ()

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

Since: 2.2

forceUpdate

screenForceUpdate

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> m ()

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.

freeWorkspaceLayout

screenFreeWorkspaceLayout

Arguments

:: (HasCallStack, MonadIO m)

=> WorkspaceLayout

layout: a WorkspaceLayout.

-> m ()

Deprecated: (Since version 2.20)

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

get

screenGet

Arguments

:: (HasCallStack, MonadIO m)

=> Int32

index: screen number, starting from 0.

-> m Screen

Returns: the Screen for screen index, or Nothing if no such screen exists. The returned Screen is owned by libwnck and must not be referenced or unreferenced.

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

getActiveWindow

screenGetActiveWindow

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> m (Maybe Window)

Returns: the active Window on screen, or Nothing. The returned Window is owned by libwnck and must not be referenced or unreferenced.

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

getActiveWorkspace

screenGetActiveWorkspace

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> m (Maybe Workspace)

Returns: the active Workspace on screen, or Nothing. The returned Workspace is owned by libwnck and must not be referenced or unreferenced.

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.

getBackgroundPixmap

screenGetBackgroundPixmap

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> m CULong

Returns: the X window ID of the background pixmap of screen.

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

getDefault

screenGetDefault

Arguments

:: (HasCallStack, MonadIO m)

=> m (Maybe Screen)

Returns: the default Screen. The returned Screen is owned by libwnck and must not be referenced or unreferenced. This can return Nothing if not on X11.

Gets the default Screen on the default display.

getForRoot

screenGetForRoot

Arguments

:: (HasCallStack, MonadIO m)

=> CULong

rootWindowId: an X window ID.

-> m Screen

Returns: the Screen for the root window at rootWindowId, or Nothing. The returned Screen is owned by libwnck and must not be referenced or unreferenced.

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.

getHandle

screenGetHandle

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> m Handle

Returns: a Handle, or Nothing.

Gets the handle.

getHeight

screenGetHeight

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> m Int32

Returns: the height of screen.

Gets the height of screen.

getNumber

screenGetNumber

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> m Int32

Returns: the index of space on screen, or -1 on errors.

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

Since: 2.20

getPreviouslyActiveWindow

screenGetPreviouslyActiveWindow

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> m Window

Returns: the previously active Window on screen, or Nothing. The returned Window is owned by libwnck and must not be referenced or unreferenced.

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

getShowingDesktop

screenGetShowingDesktop

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> m Bool

Returns: True if window is fullscreen, False otherwise.

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

Since: 2.2

getWidth

screenGetWidth

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> m Int32

Returns: the width of screen.

Gets the width of screen.

getWindowManagerName

screenGetWindowManagerName

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> m Text

Returns: the name of the window manager, or Nothing if the window manager does not comply with the <ulink url="http://standards.freedesktop.org/wm-spec/wm-spec-latest.html">EWMH</ulink> specification.

Gets the name of the window manager.

Since: 2.20

getWindows

screenGetWindows

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> m [Window]

Returns: the list of Window on screen, or Nothing if there is no window on screen. The list should not be modified nor freed, as it is owned by screen.

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.

getWindowsStacked

screenGetWindowsStacked

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> m [Window]

Returns: the list of Window in stacking order on screen, or Nothing if there is no window on screen. The list should not be modified nor freed, as it is owned by screen.

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

getWorkspace

screenGetWorkspace

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> Int32

workspace: a workspace index, starting from 0.

-> m Workspace

Returns: the Workspace numbered workspace on screen, or Nothing if no such workspace exists. The returned Workspace is owned by libwnck and must not be referenced or unreferenced.

Gets the Workspace numbered workspace on screen.

getWorkspaceCount

screenGetWorkspaceCount

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> m Int32

Returns: the number of Workspace on screen.

Gets the number of Workspace on screen.

getWorkspaces

screenGetWorkspaces

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> m [Workspace]

Returns: the list of Workspace on screen. The list should not be modified nor freed, as it is owned by 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

moveViewport

screenMoveViewport

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> Int32

x: X offset in pixels of viewport.

-> Int32

y: Y offset in pixels of viewport.

-> m ()

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

Since: 2.4

netWmSupports

screenNetWmSupports

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> Text

atom: a property atom.

-> m Bool

Returns: True if the window manager for screen supports the atom hint, False otherwise.

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.

releaseWorkspaceLayout

screenReleaseWorkspaceLayout

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> Int32

currentToken: the token obtained through screenTrySetWorkspaceLayout.

-> m ()

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.

toggleShowingDesktop

screenToggleShowingDesktop

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> Bool

show: whether to activate the "showing the desktop" mode on screen.

-> m ()

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

Since: 2.2

trySetWorkspaceLayout

screenTrySetWorkspaceLayout

Arguments

:: (HasCallStack, MonadIO m, IsScreen a)

=> a

screen: a Screen.

-> Int32

currentToken: a token. Use 0 if you do not called screenTrySetWorkspaceLayout before, or if you did not keep the old token.

-> Int32

rows: the number of rows to use for the Workspace layout.

-> Int32

columns: the number of columns to use for the Workspace layout.

-> m Int32

Returns: a token to use for future calls to screenTrySetWorkspaceLayout and to screenReleaseWorkspaceLayout, or 0 if the layout could not be set.

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.

Signals

activeWindowChanged

type ScreenActiveWindowChangedCallback

Arguments

 = Window

previouslyActiveWindow: the previously active Window before this change.

-> IO ()

Emitted when the active window on screen has changed.

afterScreenActiveWindowChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenActiveWindowChangedCallback) -> m SignalHandlerId

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

after screen #activeWindowChanged callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onScreenActiveWindowChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenActiveWindowChangedCallback) -> m SignalHandlerId

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

on screen #activeWindowChanged callback

activeWorkspaceChanged

type ScreenActiveWorkspaceChangedCallback

Arguments

 = Workspace

previouslyActiveSpace: the previously active Workspace before this change.

-> IO ()

Emitted when the active workspace on screen has changed.

afterScreenActiveWorkspaceChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenActiveWorkspaceChangedCallback) -> m SignalHandlerId

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

after screen #activeWorkspaceChanged callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onScreenActiveWorkspaceChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenActiveWorkspaceChangedCallback) -> m SignalHandlerId

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

on screen #activeWorkspaceChanged callback

applicationClosed

type ScreenApplicationClosedCallback

Arguments

 = Application

app: the closed Application.

-> IO ()

Emitted when a Application is closed on screen.

afterScreenApplicationClosed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenApplicationClosedCallback) -> m SignalHandlerId

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

after screen #applicationClosed callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onScreenApplicationClosed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenApplicationClosedCallback) -> m SignalHandlerId

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

on screen #applicationClosed callback

applicationOpened

type ScreenApplicationOpenedCallback

Arguments

 = Application

app: the opened Application.

-> IO ()

Emitted when a new Application is opened on screen.

afterScreenApplicationOpened :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenApplicationOpenedCallback) -> m SignalHandlerId

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

after screen #applicationOpened callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onScreenApplicationOpened :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenApplicationOpenedCallback) -> m SignalHandlerId

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

on screen #applicationOpened callback

backgroundChanged

type ScreenBackgroundChangedCallback = IO ()

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

afterScreenBackgroundChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenBackgroundChangedCallback) -> m SignalHandlerId

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

after screen #backgroundChanged callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onScreenBackgroundChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenBackgroundChangedCallback) -> m SignalHandlerId

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

on screen #backgroundChanged callback

classGroupClosed

type ScreenClassGroupClosedCallback

Arguments

 = ClassGroup

classGroup: the closed ClassGroup.

-> IO ()

Emitted when a ClassGroup is closed on screen.

Since: 2.20

afterScreenClassGroupClosed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenClassGroupClosedCallback) -> m SignalHandlerId

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

after screen #classGroupClosed callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onScreenClassGroupClosed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenClassGroupClosedCallback) -> m SignalHandlerId

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

on screen #classGroupClosed callback

classGroupOpened

type ScreenClassGroupOpenedCallback

Arguments

 = ClassGroup

classGroup: the opened ClassGroup.

-> IO ()

Emitted when a new ClassGroup is opened on screen.

Since: 2.20

afterScreenClassGroupOpened :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenClassGroupOpenedCallback) -> m SignalHandlerId

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

after screen #classGroupOpened callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onScreenClassGroupOpened :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenClassGroupOpenedCallback) -> m SignalHandlerId

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

on screen #classGroupOpened callback

showingDesktopChanged

type ScreenShowingDesktopChangedCallback = IO ()

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

Since: 2.20

afterScreenShowingDesktopChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenShowingDesktopChangedCallback) -> m SignalHandlerId

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

after screen #showingDesktopChanged callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onScreenShowingDesktopChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenShowingDesktopChangedCallback) -> m SignalHandlerId

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

on screen #showingDesktopChanged callback

viewportsChanged

type ScreenViewportsChangedCallback = IO ()

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

afterScreenViewportsChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenViewportsChangedCallback) -> m SignalHandlerId

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

after screen #viewportsChanged callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onScreenViewportsChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenViewportsChangedCallback) -> m SignalHandlerId

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

on screen #viewportsChanged callback

windowClosed

type ScreenWindowClosedCallback

Arguments

 = Window

window: the closed Window.

-> IO ()

Emitted when a Window is closed on screen.

afterScreenWindowClosed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowClosedCallback) -> m SignalHandlerId

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

after screen #windowClosed callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onScreenWindowClosed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowClosedCallback) -> m SignalHandlerId

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

on screen #windowClosed callback

windowManagerChanged

type ScreenWindowManagerChangedCallback = IO ()

Emitted when the window manager on screen has changed.

Since: 2.20

afterScreenWindowManagerChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowManagerChangedCallback) -> m SignalHandlerId

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

after screen #windowManagerChanged callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onScreenWindowManagerChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowManagerChangedCallback) -> m SignalHandlerId

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

on screen #windowManagerChanged callback

windowOpened

type ScreenWindowOpenedCallback

Arguments

 = Window

window: the opened Window.

-> IO ()

Emitted when a new Window is opened on screen.

afterScreenWindowOpened :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowOpenedCallback) -> m SignalHandlerId

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

after screen #windowOpened callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onScreenWindowOpened :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowOpenedCallback) -> m SignalHandlerId

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

on screen #windowOpened callback

windowStackingChanged

type ScreenWindowStackingChangedCallback = IO ()

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

afterScreenWindowStackingChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowStackingChangedCallback) -> m SignalHandlerId

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

after screen #windowStackingChanged callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onScreenWindowStackingChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowStackingChangedCallback) -> m SignalHandlerId

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

on screen #windowStackingChanged callback

workspaceCreated

type ScreenWorkspaceCreatedCallback

Arguments

 = Workspace

space: the workspace that has been created.

-> IO ()

Emitted when a Workspace is created on screen.

afterScreenWorkspaceCreated :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWorkspaceCreatedCallback) -> m SignalHandlerId

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

after screen #workspaceCreated callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onScreenWorkspaceCreated :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWorkspaceCreatedCallback) -> m SignalHandlerId

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

on screen #workspaceCreated callback

workspaceDestroyed

type ScreenWorkspaceDestroyedCallback

Arguments

 = Workspace

space: the workspace that has been destroyed.

-> IO ()

Emitted when a Workspace is destroyed on screen.

afterScreenWorkspaceDestroyed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWorkspaceDestroyedCallback) -> m SignalHandlerId

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

after screen #workspaceDestroyed callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onScreenWorkspaceDestroyed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWorkspaceDestroyedCallback) -> m SignalHandlerId

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

on screen #workspaceDestroyed callback