Copyright | Will Thompson and Iñaki García Etxebarria |
---|---|
License | LGPL-2.1 |
Maintainer | Iñaki García Etxebarria |
Safe Haskell | Safe-Inferred |
Language | Haskell2010 |
- Exported types
- Methods
- calcWorkspaceLayout
- changeWorkspaceCount
- forceUpdate
- freeWorkspaceLayout
- get
- getActiveWindow
- getActiveWorkspace
- getBackgroundPixmap
- getDefault
- getForRoot
- getHeight
- getNumber
- getPreviouslyActiveWindow
- getShowingDesktop
- getWidth
- getWindowManagerName
- getWindows
- getWindowsStacked
- getWorkspace
- getWorkspaceCount
- getWorkspaces
- moveViewport
- netWmSupports
- releaseWorkspaceLayout
- toggleShowingDesktop
- trySetWorkspaceLayout
- Signals
The Screen
struct contains only private fields and should not be
directly accessed.
Synopsis
- newtype Screen = Screen (ManagedPtr Screen)
- class (GObject o, IsDescendantOf Screen o) => IsScreen o
- toScreen :: (MonadIO m, IsScreen o) => o -> m Screen
- screenCalcWorkspaceLayout :: (HasCallStack, MonadIO m, IsScreen a) => a -> Int32 -> Int32 -> WorkspaceLayout -> m ()
- screenChangeWorkspaceCount :: (HasCallStack, MonadIO m, IsScreen a) => a -> Int32 -> m ()
- screenForceUpdate :: (HasCallStack, MonadIO m, IsScreen a) => a -> m ()
- screenFreeWorkspaceLayout :: (HasCallStack, MonadIO m) => WorkspaceLayout -> m ()
- screenGet :: (HasCallStack, MonadIO m) => Int32 -> m Screen
- screenGetActiveWindow :: (HasCallStack, MonadIO m, IsScreen a) => a -> m (Maybe Window)
- screenGetActiveWorkspace :: (HasCallStack, MonadIO m, IsScreen a) => a -> m (Maybe Workspace)
- screenGetBackgroundPixmap :: (HasCallStack, MonadIO m, IsScreen a) => a -> m CULong
- screenGetDefault :: (HasCallStack, MonadIO m) => m (Maybe Screen)
- screenGetForRoot :: (HasCallStack, MonadIO m) => CULong -> m Screen
- screenGetHeight :: (HasCallStack, MonadIO m, IsScreen a) => a -> m Int32
- screenGetNumber :: (HasCallStack, MonadIO m, IsScreen a) => a -> m Int32
- screenGetPreviouslyActiveWindow :: (HasCallStack, MonadIO m, IsScreen a) => a -> m Window
- screenGetShowingDesktop :: (HasCallStack, MonadIO m, IsScreen a) => a -> m Bool
- screenGetWidth :: (HasCallStack, MonadIO m, IsScreen a) => a -> m Int32
- screenGetWindowManagerName :: (HasCallStack, MonadIO m, IsScreen a) => a -> m Text
- screenGetWindows :: (HasCallStack, MonadIO m, IsScreen a) => a -> m [Window]
- screenGetWindowsStacked :: (HasCallStack, MonadIO m, IsScreen a) => a -> m [Window]
- screenGetWorkspace :: (HasCallStack, MonadIO m, IsScreen a) => a -> Int32 -> m Workspace
- screenGetWorkspaceCount :: (HasCallStack, MonadIO m, IsScreen a) => a -> m Int32
- screenGetWorkspaces :: (HasCallStack, MonadIO m, IsScreen a) => a -> m [Workspace]
- screenMoveViewport :: (HasCallStack, MonadIO m, IsScreen a) => a -> Int32 -> Int32 -> m ()
- screenNetWmSupports :: (HasCallStack, MonadIO m, IsScreen a) => a -> Text -> m Bool
- screenReleaseWorkspaceLayout :: (HasCallStack, MonadIO m, IsScreen a) => a -> Int32 -> m ()
- screenToggleShowingDesktop :: (HasCallStack, MonadIO m, IsScreen a) => a -> Bool -> m ()
- screenTrySetWorkspaceLayout :: (HasCallStack, MonadIO m, IsScreen a) => a -> Int32 -> Int32 -> Int32 -> m Int32
- type ScreenActiveWindowChangedCallback = Window -> IO ()
- afterScreenActiveWindowChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenActiveWindowChangedCallback) -> m SignalHandlerId
- onScreenActiveWindowChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenActiveWindowChangedCallback) -> m SignalHandlerId
- type ScreenActiveWorkspaceChangedCallback = Workspace -> IO ()
- afterScreenActiveWorkspaceChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenActiveWorkspaceChangedCallback) -> m SignalHandlerId
- onScreenActiveWorkspaceChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenActiveWorkspaceChangedCallback) -> m SignalHandlerId
- type ScreenApplicationClosedCallback = Application -> IO ()
- afterScreenApplicationClosed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenApplicationClosedCallback) -> m SignalHandlerId
- onScreenApplicationClosed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenApplicationClosedCallback) -> m SignalHandlerId
- type ScreenApplicationOpenedCallback = Application -> IO ()
- afterScreenApplicationOpened :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenApplicationOpenedCallback) -> m SignalHandlerId
- onScreenApplicationOpened :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenApplicationOpenedCallback) -> m SignalHandlerId
- type ScreenBackgroundChangedCallback = IO ()
- afterScreenBackgroundChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenBackgroundChangedCallback) -> m SignalHandlerId
- onScreenBackgroundChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenBackgroundChangedCallback) -> m SignalHandlerId
- type ScreenClassGroupClosedCallback = ClassGroup -> IO ()
- afterScreenClassGroupClosed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenClassGroupClosedCallback) -> m SignalHandlerId
- onScreenClassGroupClosed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenClassGroupClosedCallback) -> m SignalHandlerId
- type ScreenClassGroupOpenedCallback = ClassGroup -> IO ()
- afterScreenClassGroupOpened :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenClassGroupOpenedCallback) -> m SignalHandlerId
- onScreenClassGroupOpened :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenClassGroupOpenedCallback) -> m SignalHandlerId
- type ScreenShowingDesktopChangedCallback = IO ()
- afterScreenShowingDesktopChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenShowingDesktopChangedCallback) -> m SignalHandlerId
- onScreenShowingDesktopChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenShowingDesktopChangedCallback) -> m SignalHandlerId
- type ScreenViewportsChangedCallback = IO ()
- afterScreenViewportsChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenViewportsChangedCallback) -> m SignalHandlerId
- onScreenViewportsChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenViewportsChangedCallback) -> m SignalHandlerId
- type ScreenWindowClosedCallback = Window -> IO ()
- afterScreenWindowClosed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowClosedCallback) -> m SignalHandlerId
- onScreenWindowClosed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowClosedCallback) -> m SignalHandlerId
- type ScreenWindowManagerChangedCallback = IO ()
- afterScreenWindowManagerChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowManagerChangedCallback) -> m SignalHandlerId
- onScreenWindowManagerChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowManagerChangedCallback) -> m SignalHandlerId
- type ScreenWindowOpenedCallback = Window -> IO ()
- afterScreenWindowOpened :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowOpenedCallback) -> m SignalHandlerId
- onScreenWindowOpened :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowOpenedCallback) -> m SignalHandlerId
- type ScreenWindowStackingChangedCallback = IO ()
- afterScreenWindowStackingChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowStackingChangedCallback) -> m SignalHandlerId
- onScreenWindowStackingChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowStackingChangedCallback) -> m SignalHandlerId
- type ScreenWorkspaceCreatedCallback = Workspace -> IO ()
- afterScreenWorkspaceCreated :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWorkspaceCreatedCallback) -> m SignalHandlerId
- onScreenWorkspaceCreated :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWorkspaceCreatedCallback) -> m SignalHandlerId
- type ScreenWorkspaceDestroyedCallback = Workspace -> IO ()
- afterScreenWorkspaceDestroyed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWorkspaceDestroyedCallback) -> m SignalHandlerId
- onScreenWorkspaceDestroyed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWorkspaceDestroyedCallback) -> m SignalHandlerId
Exported types
Memory-managed wrapper type.
Instances
Eq Screen Source # | |
GObject Screen Source # | |
Defined in GI.Wnck.Objects.Screen | |
ManagedPtrNewtype Screen Source # | |
Defined in GI.Wnck.Objects.Screen toManagedPtr :: Screen -> ManagedPtr Screen # | |
TypedObject Screen Source # | |
Defined in GI.Wnck.Objects.Screen | |
HasParentTypes Screen Source # | |
Defined in GI.Wnck.Objects.Screen | |
IsGValue (Maybe Screen) Source # | Convert |
Defined in GI.Wnck.Objects.Screen | |
type ParentTypes Screen Source # | |
Defined in GI.Wnck.Objects.Screen |
class (GObject o, IsDescendantOf Screen o) => IsScreen o Source #
Instances
(GObject o, IsDescendantOf Screen o) => IsScreen o Source # | |
Defined in GI.Wnck.Objects.Screen |
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, getHeight, getNumber, getPreviouslyActiveWindow, getProperty, getQdata, getShowingDesktop, getWidth, getWindowManagerName, getWindows, getWindowsStacked, getWorkspace, getWorkspaceCount, getWorkspaces.
Setters
calcWorkspaceLayout
screenCalcWorkspaceLayout Source #
:: (HasCallStack, MonadIO m, IsScreen a) | |
=> a |
|
-> Int32 |
|
-> Int32 |
|
-> WorkspaceLayout |
|
-> m () |
changeWorkspaceCount
screenChangeWorkspaceCount Source #
:: (HasCallStack, MonadIO m, IsScreen a) | |
=> a |
|
-> Int32 |
|
-> m () |
Asks the window manager to change the number of Workspace
on screen
.
Since: 2.2
forceUpdate
:: (HasCallStack, MonadIO m, IsScreen a) | |
=> a |
|
-> 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 #
:: (HasCallStack, MonadIO m) | |
=> 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
:: (HasCallStack, MonadIO m) | |
=> Int32 |
|
-> m Screen | Returns: the |
Gets the Screen
for a given screen on the default display.
getActiveWindow
getActiveWorkspace
getBackgroundPixmap
screenGetBackgroundPixmap Source #
:: (HasCallStack, MonadIO m, IsScreen a) | |
=> a |
|
-> m CULong | Returns: the X window ID of the background pixmap of |
Gets the X window ID of the background pixmap of screen
.
getDefault
:: (HasCallStack, MonadIO m) | |
=> m (Maybe Screen) | Returns: the default |
Gets the default Screen
on the default display.
getForRoot
getHeight
:: (HasCallStack, MonadIO m, IsScreen a) | |
=> a |
|
-> m Int32 | Returns: the height of |
Gets the height of screen
.
getNumber
:: (HasCallStack, MonadIO m, IsScreen a) | |
=> a |
|
-> m Int32 | Returns: the index of |
Gets the index of screen
on the display to which it belongs. The first
Screen
has an index of 0.
Since: 2.20
getPreviouslyActiveWindow
getShowingDesktop
screenGetShowingDesktop Source #
:: (HasCallStack, MonadIO m, IsScreen a) | |
=> a |
|
-> m Bool |
Gets whether screen
is in the "showing the desktop" mode. This mode is
changed when a showingDesktopChanged signal gets emitted.
Since: 2.2
getWidth
:: (HasCallStack, MonadIO m, IsScreen a) | |
=> a |
|
-> m Int32 | Returns: the width of |
Gets the width of screen
.
getWindowManagerName
screenGetWindowManagerName Source #
:: (HasCallStack, MonadIO m, IsScreen a) | |
=> a |
|
-> m Text | Returns: the name of the window manager, or |
Gets the name of the window manager.
Since: 2.20
getWindows
:: (HasCallStack, MonadIO m, IsScreen a) | |
=> a |
|
-> m [Window] | Returns: the list of
|
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 #
:: (HasCallStack, MonadIO m, IsScreen a) | |
=> a |
|
-> m [Window] | Returns: the list of
|
Gets the list of Window
on screen
in bottom-to-top order.
getWorkspace
:: (HasCallStack, MonadIO m, IsScreen a) | |
=> a |
|
-> Int32 |
|
-> m Workspace | Returns: the |
Gets the Workspace
numbered workspace
on screen
.
getWorkspaceCount
screenGetWorkspaceCount Source #
:: (HasCallStack, MonadIO m, IsScreen a) | |
=> a |
|
-> m Int32 | Returns: the number of |
Gets the number of Workspace
on screen
.
getWorkspaces
moveViewport
:: (HasCallStack, MonadIO m, IsScreen a) | |
=> a |
|
-> Int32 |
|
-> Int32 |
|
-> m () |
Asks the window manager to move the viewport of the current Workspace
on screen
.
Since: 2.4
netWmSupports
:: (HasCallStack, MonadIO m, IsScreen a) | |
=> a |
|
-> Text |
|
-> m Bool | Returns: |
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 #
:: (HasCallStack, MonadIO m, IsScreen a) | |
=> a |
|
-> Int32 |
|
-> 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 #
:: (HasCallStack, MonadIO m, IsScreen a) | |
=> a |
|
-> Bool |
|
-> m () |
Asks the window manager to set the "showing the desktop" mode on screen
according to show
.
Since: 2.2
trySetWorkspaceLayout
screenTrySetWorkspaceLayout Source #
:: (HasCallStack, MonadIO m, IsScreen a) | |
=> a |
|
-> Int32 |
|
-> Int32 |
|
-> Int32 |
|
-> m Int32 | Returns: a token to use for future calls to
|
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 Source #
Emitted when the active window on screen
has changed.
afterScreenActiveWindowChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenActiveWindowChangedCallback) -> m SignalHandlerId Source #
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 Source #
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 Source #
Emitted when the active workspace on screen
has changed.
afterScreenActiveWorkspaceChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenActiveWorkspaceChangedCallback) -> m SignalHandlerId Source #
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 Source #
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 Source #
= Application |
|
-> IO () |
Emitted when a Application
is closed on screen
.
afterScreenApplicationClosed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenApplicationClosedCallback) -> m SignalHandlerId Source #
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 Source #
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 Source #
= Application |
|
-> IO () |
Emitted when a new Application
is opened on screen
.
afterScreenApplicationOpened :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenApplicationOpenedCallback) -> m SignalHandlerId Source #
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 Source #
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 () Source #
Emitted when the background on the root window of screen
has changed.
afterScreenBackgroundChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenBackgroundChangedCallback) -> m SignalHandlerId Source #
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 Source #
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 Source #
= ClassGroup |
|
-> IO () |
Emitted when a ClassGroup
is closed on screen
.
Since: 2.20
afterScreenClassGroupClosed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenClassGroupClosedCallback) -> m SignalHandlerId Source #
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 Source #
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 Source #
= 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 Source #
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 Source #
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 () Source #
Emitted when "showing the desktop" mode of screen
is toggled.
Since: 2.20
afterScreenShowingDesktopChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenShowingDesktopChangedCallback) -> m SignalHandlerId Source #
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 Source #
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 () Source #
afterScreenViewportsChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenViewportsChangedCallback) -> m SignalHandlerId Source #
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 Source #
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 Source #
Emitted when a Window
is closed on screen
.
afterScreenWindowClosed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowClosedCallback) -> m SignalHandlerId Source #
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 Source #
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 () Source #
Emitted when the window manager on screen
has changed.
Since: 2.20
afterScreenWindowManagerChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowManagerChangedCallback) -> m SignalHandlerId Source #
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 Source #
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 Source #
Emitted when a new Window
is opened on screen
.
afterScreenWindowOpened :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowOpenedCallback) -> m SignalHandlerId Source #
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 Source #
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 () Source #
Emitted when the stacking order of Window
on screen
has changed.
afterScreenWindowStackingChanged :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWindowStackingChangedCallback) -> m SignalHandlerId Source #
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 Source #
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 Source #
Emitted when a Workspace
is created on screen
.
afterScreenWorkspaceCreated :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWorkspaceCreatedCallback) -> m SignalHandlerId Source #
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 Source #
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 Source #
Emitted when a Workspace
is destroyed on screen
.
afterScreenWorkspaceDestroyed :: (IsScreen a, MonadIO m) => a -> ((?self :: a) => ScreenWorkspaceDestroyedCallback) -> m SignalHandlerId Source #
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 Source #
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