gi-wnck-3.0.4: Wnck bindings

CopyrightWill Thompson Iñaki García Etxebarria and Jonas Platte
LicenseLGPL-2.1
MaintainerIñaki García Etxebarria (inaki@blueleaf.cc)
Safe HaskellNone
LanguageHaskell2010

GI.Wnck.Objects.Screen

Contents

Description

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

Synopsis

Exported types

newtype Screen Source #

Memory-managed wrapper type.

Constructors

Screen (ManagedPtr Screen) 
Instances
GObject Screen Source # 
Instance details

Defined in GI.Wnck.Objects.Screen

Methods

gobjectType :: IO GType

HasParentTypes Screen Source # 
Instance details

Defined in GI.Wnck.Objects.Screen

type ParentTypes Screen Source # 
Instance details

Defined in GI.Wnck.Objects.Screen

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

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

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

Instances
(GObject o, IsDescendantOf Screen o) => IsScreen o Source # 
Instance details

Defined in GI.Wnck.Objects.Screen

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

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

noScreen :: Maybe Screen Source #

A convenience alias for Nothing :: Maybe Screen.

Methods

calcWorkspaceLayout

screenCalcWorkspaceLayout Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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.

getHeight

screenGetHeight Source #

Arguments

:: (HasCallStack, MonadIO m, IsScreen a) 
=> a

screen: a Screen.

-> m Int32

Returns: the height of screen.

Gets the height of screen.

getNumber

screenGetNumber Source #

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 Source #

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 Source #

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::showing-desktop-changed signal gets emitted.

Since: 2.2

getWidth

screenGetWidth Source #

Arguments

:: (HasCallStack, MonadIO m, IsScreen a) 
=> a

screen: a Screen.

-> m Int32

Returns: the width of screen.

Gets the width of screen.

getWindowManagerName

screenGetWindowManagerName Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 C_ScreenActiveWindowChangedCallback = Ptr () -> Ptr Window -> Ptr () -> IO () Source #

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

type ScreenActiveWindowChangedCallback Source #

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 -> ScreenActiveWindowChangedCallback -> m SignalHandlerId Source #

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

onScreenActiveWindowChanged :: (IsScreen a, MonadIO m) => a -> ScreenActiveWindowChangedCallback -> m SignalHandlerId Source #

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

activeWorkspaceChanged

type C_ScreenActiveWorkspaceChangedCallback = Ptr () -> Ptr Workspace -> Ptr () -> IO () Source #

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

type ScreenActiveWorkspaceChangedCallback Source #

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 -> ScreenActiveWorkspaceChangedCallback -> m SignalHandlerId Source #

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

onScreenActiveWorkspaceChanged :: (IsScreen a, MonadIO m) => a -> ScreenActiveWorkspaceChangedCallback -> m SignalHandlerId Source #

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

applicationClosed

type C_ScreenApplicationClosedCallback = Ptr () -> Ptr Application -> Ptr () -> IO () Source #

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

type ScreenApplicationClosedCallback Source #

Arguments

 = Application

app: the closed Application.

-> IO () 

Emitted when a Application is closed on screen.

afterScreenApplicationClosed :: (IsScreen a, MonadIO m) => a -> ScreenApplicationClosedCallback -> m SignalHandlerId Source #

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

onScreenApplicationClosed :: (IsScreen a, MonadIO m) => a -> ScreenApplicationClosedCallback -> m SignalHandlerId Source #

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

applicationOpened

type C_ScreenApplicationOpenedCallback = Ptr () -> Ptr Application -> Ptr () -> IO () Source #

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

type ScreenApplicationOpenedCallback Source #

Arguments

 = Application

app: the opened Application.

-> IO () 

Emitted when a new Application is opened on screen.

afterScreenApplicationOpened :: (IsScreen a, MonadIO m) => a -> ScreenApplicationOpenedCallback -> m SignalHandlerId Source #

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

onScreenApplicationOpened :: (IsScreen a, MonadIO m) => a -> ScreenApplicationOpenedCallback -> m SignalHandlerId Source #

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

backgroundChanged

type C_ScreenBackgroundChangedCallback = Ptr () -> Ptr () -> IO () Source #

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

type ScreenBackgroundChangedCallback = IO () Source #

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

afterScreenBackgroundChanged :: (IsScreen a, MonadIO m) => a -> ScreenBackgroundChangedCallback -> m SignalHandlerId Source #

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

onScreenBackgroundChanged :: (IsScreen a, MonadIO m) => a -> ScreenBackgroundChangedCallback -> m SignalHandlerId Source #

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

classGroupClosed

type C_ScreenClassGroupClosedCallback = Ptr () -> Ptr ClassGroup -> Ptr () -> IO () Source #

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

type ScreenClassGroupClosedCallback Source #

Arguments

 = ClassGroup

classGroup: the closed ClassGroup.

-> IO () 

Emitted when a ClassGroup is closed on screen.

Since: 2.20

afterScreenClassGroupClosed :: (IsScreen a, MonadIO m) => a -> ScreenClassGroupClosedCallback -> m SignalHandlerId Source #

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

onScreenClassGroupClosed :: (IsScreen a, MonadIO m) => a -> ScreenClassGroupClosedCallback -> m SignalHandlerId Source #

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

classGroupOpened

type C_ScreenClassGroupOpenedCallback = Ptr () -> Ptr ClassGroup -> Ptr () -> IO () Source #

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

type ScreenClassGroupOpenedCallback Source #

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 -> ScreenClassGroupOpenedCallback -> m SignalHandlerId Source #

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

onScreenClassGroupOpened :: (IsScreen a, MonadIO m) => a -> ScreenClassGroupOpenedCallback -> m SignalHandlerId Source #

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

showingDesktopChanged

type C_ScreenShowingDesktopChangedCallback = Ptr () -> Ptr () -> IO () Source #

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

type ScreenShowingDesktopChangedCallback = IO () Source #

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

Since: 2.20

afterScreenShowingDesktopChanged :: (IsScreen a, MonadIO m) => a -> ScreenShowingDesktopChangedCallback -> m SignalHandlerId Source #

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

onScreenShowingDesktopChanged :: (IsScreen a, MonadIO m) => a -> ScreenShowingDesktopChangedCallback -> m SignalHandlerId Source #

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

viewportsChanged

type C_ScreenViewportsChangedCallback = Ptr () -> Ptr () -> IO () Source #

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

type ScreenViewportsChangedCallback = IO () Source #

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 -> ScreenViewportsChangedCallback -> m SignalHandlerId Source #

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

onScreenViewportsChanged :: (IsScreen a, MonadIO m) => a -> ScreenViewportsChangedCallback -> m SignalHandlerId Source #

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

windowClosed

type C_ScreenWindowClosedCallback = Ptr () -> Ptr Window -> Ptr () -> IO () Source #

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

type ScreenWindowClosedCallback Source #

Arguments

 = Window

window: the closed Window.

-> IO () 

Emitted when a Window is closed on screen.

afterScreenWindowClosed :: (IsScreen a, MonadIO m) => a -> ScreenWindowClosedCallback -> m SignalHandlerId Source #

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

onScreenWindowClosed :: (IsScreen a, MonadIO m) => a -> ScreenWindowClosedCallback -> m SignalHandlerId Source #

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

windowManagerChanged

type C_ScreenWindowManagerChangedCallback = Ptr () -> Ptr () -> IO () Source #

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

type ScreenWindowManagerChangedCallback = IO () Source #

Emitted when the window manager on screen has changed.

Since: 2.20

afterScreenWindowManagerChanged :: (IsScreen a, MonadIO m) => a -> ScreenWindowManagerChangedCallback -> m SignalHandlerId Source #

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

onScreenWindowManagerChanged :: (IsScreen a, MonadIO m) => a -> ScreenWindowManagerChangedCallback -> m SignalHandlerId Source #

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

windowOpened

type C_ScreenWindowOpenedCallback = Ptr () -> Ptr Window -> Ptr () -> IO () Source #

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

type ScreenWindowOpenedCallback Source #

Arguments

 = Window

window: the opened Window.

-> IO () 

Emitted when a new Window is opened on screen.

afterScreenWindowOpened :: (IsScreen a, MonadIO m) => a -> ScreenWindowOpenedCallback -> m SignalHandlerId Source #

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

onScreenWindowOpened :: (IsScreen a, MonadIO m) => a -> ScreenWindowOpenedCallback -> m SignalHandlerId Source #

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

windowStackingChanged

type C_ScreenWindowStackingChangedCallback = Ptr () -> Ptr () -> IO () Source #

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

type ScreenWindowStackingChangedCallback = IO () Source #

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

afterScreenWindowStackingChanged :: (IsScreen a, MonadIO m) => a -> ScreenWindowStackingChangedCallback -> m SignalHandlerId Source #

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

onScreenWindowStackingChanged :: (IsScreen a, MonadIO m) => a -> ScreenWindowStackingChangedCallback -> m SignalHandlerId Source #

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

workspaceCreated

type C_ScreenWorkspaceCreatedCallback = Ptr () -> Ptr Workspace -> Ptr () -> IO () Source #

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

type ScreenWorkspaceCreatedCallback Source #

Arguments

 = Workspace

space: the workspace that has been created.

-> IO () 

Emitted when a Workspace is created on screen.

afterScreenWorkspaceCreated :: (IsScreen a, MonadIO m) => a -> ScreenWorkspaceCreatedCallback -> m SignalHandlerId Source #

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

onScreenWorkspaceCreated :: (IsScreen a, MonadIO m) => a -> ScreenWorkspaceCreatedCallback -> m SignalHandlerId Source #

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

workspaceDestroyed

type C_ScreenWorkspaceDestroyedCallback = Ptr () -> Ptr Workspace -> Ptr () -> IO () Source #

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

type ScreenWorkspaceDestroyedCallback Source #

Arguments

 = Workspace

space: the workspace that has been destroyed.

-> IO () 

Emitted when a Workspace is destroyed on screen.

afterScreenWorkspaceDestroyed :: (IsScreen a, MonadIO m) => a -> ScreenWorkspaceDestroyedCallback -> m SignalHandlerId Source #

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

onScreenWorkspaceDestroyed :: (IsScreen a, MonadIO m) => a -> ScreenWorkspaceDestroyedCallback -> m SignalHandlerId Source #

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