GI.Wnck.Objects.Window

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

Exported types

newtype Window

Memory-managed wrapper type.

Constructors

Window (ManagedPtr Window)

Instances

GObject Window

Defined in GI.Wnck.Objects.Window

Methods

gobjectType :: Window -> IO GType

IsObject Window

Defined in GI.Wnck.Objects.Window

IsWindow Window

Defined in GI.Wnck.Objects.Window

class GObject o => IsWindow o

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

Instances

(GObject a, (UnknownAncestorError Window a :: Constraint)) => IsWindow a

Defined in GI.Wnck.Objects.Window

IsWindow Window

Defined in GI.Wnck.Objects.Window

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

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

noWindow :: Maybe Window

A convenience alias for Nothing :: Maybe Window.

Methods

activate

windowActivate

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> Word32

timestamp: the X server timestamp of the user interaction event that caused this call to occur.

-> m ()

Asks the window manager to make window the active window. The window manager may choose to raise window along with focusing it, and may decide to refuse the request (to not steal the focus if there is a more recent user activity, for example).

This function existed before 2.10, but the timestamp argument was missing in earlier versions.

Since: 2.10

activateTransient

windowActivateTransient

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> Word32

timestamp: the X server timestamp of the user interaction event that caused this call to occur.

-> m ()

If window has transients, activates the most likely transient instead of the window itself. Otherwise activates window.

FIXME the ideal behavior of this function is probably to activate the most recently active window among window and its transients. This is probably best implemented on the window manager side.

This function existed before 2.10, but the timestamp argument was missing in earlier versions.

Since: 2.10

close

windowClose

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> Word32

timestamp: the X server timestamp of the user interaction event that caused this call to occur.

-> m ()

Closes window.

This function existed before 2.6, but the timestamp argument was missing in earlier versions.

Since: 2.6

get

windowGet

Arguments

:: (HasCallStack, MonadIO m)

=> CULong

xwindow: an X window ID.

-> m Window

Returns: the Window for xwindow. The returned Window is owned by libwnck and must not be referenced or unreferenced.

Gets a preexisting Window for the X window xwindow. This will not create a Window if none exists. The function is robust against bogus window IDs.

getActions

windowGetActions

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m [WindowActions]

Returns: bitmask of actions that can be done for window.

Gets the actions that can be done for window.

getApplication

windowGetApplication

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Application

Returns: the Application to which window belongs. The returned Application is owned by libwnck and must not be referenced or unreferenced.

Gets the Application to which window belongs.

getClassGroup

windowGetClassGroup

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ClassGroup

Returns: the ClassGroup to which window belongs. The returned ClassGroup is owned by libwnck and must not be referenced or unreferenced.

Gets the ClassGroup to which window belongs.

Since: 2.2

getClassGroupName

windowGetClassGroupName

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Text

Returns: the class group name for window, or Nothing if window belongs to no class group.

Gets the class group name from the <ulink url="http://tronche.com/gui/x/icccm/sec-4.html&num;WM_CLASS">WM_CLASS Property</ulink> for window.

The class group name is also the identifier name of the ClassGroup to which window belongs.

getClassInstanceName

windowGetClassInstanceName

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Text

Returns: the class instance name for window, or Nothing if window has no class instance.

Gets the class instance name from the <ulink url="http://tronche.com/gui/x/icccm/sec-4.html&num;WM_CLASS">WM_CLASS Property</ulink> for window.

The class instance name allows to differentiate windows belonging to the same class group, so that they can use different resources.

getClientWindowGeometry

windowGetClientWindowGeometry

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m (Int32, Int32, Int32, Int32)

Gets the size and position of window, as last received in a ConfigureNotify event (i.e. this call does not round-trip to the server, just gets the last size we were notified of). The X and Y coordinates are relative to the root window.

The window manager usually adds a frame around windows. If you need to know the size of window with the frame, use windowGetGeometry.

Since: 2.20

getGeometry

windowGetGeometry

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m (Int32, Int32, Int32, Int32)

Gets the size and position of window, including decorations. This function uses the information last received in a ConfigureNotify event and adjusts it according to the size of the frame that is added by the window manager (this call does not round-trip to the server, it just gets the last sizes that were notified). The X and Y coordinates are relative to the root window.

If you need to know the actual size of window ignoring the frame added by the window manager, use windowGetClientWindowGeometry.

getGroupLeader

windowGetGroupLeader

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m CULong

Returns: the group leader of the group of windows to which window belongs, or the X window ID of window if window does not belong to any group.

Gets the group leader of the group of windows to which window belongs.

getIcon

windowGetIcon

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Pixbuf

Returns: the icon for window. The caller should reference the returned <classname>GdkPixbuf</classname> if it needs to keep the icon around.

Gets the icon to be used for window. If no icon was found, a fallback icon is used. windowGetIconIsFallback can be used to tell if the icon is the fallback icon.

getIconIsFallback

windowGetIconIsFallback

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Bool

Returns: True if the icon for window is a fallback, False otherwise.

Gets whether a default fallback icon is used for window (because none was set on window).

getIconName

windowGetIconName

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window

-> m Text

Returns: the icon name of window, or a fallback icon name if no icon name is available.

Gets the icon name of window, as it should be displayed for an icon (minimized state). Always returns some value, even if window has no icon name set; use windowHasIconName if you need to know whether the returned icon name is "real" or not.

Contrast with windowGetName, which returns window<!-- -->'s title, not its icon title.

getMiniIcon

windowGetMiniIcon

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Pixbuf

Returns: the mini-icon for window. The caller should reference the returned <classname>GdkPixbuf</classname> if it needs to keep the icon around.

Gets the mini-icon to be used for window. If no mini-icon was found, a fallback mini-icon is used. windowGetIconIsFallback can be used to tell if the mini-icon is the fallback mini-icon.

getName

windowGetName

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Text

Returns: the name of window, or a fallback name if no name is available.

Gets the name of window, as it should be displayed in a pager or tasklist. Always returns some value, even if window has no name set; use windowHasName if you need to know whether the returned name is "real" or not.

For icons titles, use windowGetIconName instead.

getPid

windowGetPid

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Int32

Returns: the process ID of window, or 0 if none is available.

Gets the process ID of window.

getRole

windowGetRole

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Text

Returns: role for window, or Nothing if window has no role.

Gets the role for window. The role uniquely identifies a window among all windows that have the same client leader window.

getScreen

windowGetScreen

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Screen

Returns: the Screen window is on. The returned Screen is owned by libwnck and must not be referenced or unreferenced.

Gets the Screen window is on.

getSessionId

windowGetSessionId

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Text

Returns: the session ID for window in Latin-1, or Nothing if window has no session ID.

Gets the session ID for window in Latin-1 encoding. NOTE: this is invalid UTF-8. You can't display this string in a GTK+ widget without converting to UTF-8. See windowGetSessionIdUtf8.

getSessionIdUtf8

windowGetSessionIdUtf8

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Text

Returns: the session ID for window in UTF-8, or Nothing if window has no session ID.

Gets the session ID for window in UTF-8 encoding. The session ID should be in Latin-1 encoding, so the conversion should work, but a broken client could set a session ID that might not be convertable to UTF-8.

getSortOrder

windowGetSortOrder

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Int32

Returns: the sort order of window, or G_MAXINT if none is available.

Gets the sort order of window, used for ordering of window in Selector and Tasklist. The sort order is an internal state in libwnck. The initial value is defined when the window is created.

Since: 2.10

getState

windowGetState

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m [WindowState]

Returns: bitmask of active states for window.

Gets the state of window.

getTransient

windowGetTransient

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Window

Returns: the Window for which window is transient, or Nothing if window is not transient for any Window. The returned Window is owned by libwnck and must not be referenced or unreferenced.

Gets the Window for which window is transient.

Since: 2.12

getWindowType

windowGetWindowType

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m WindowType

Returns: the semantic type of window.

Gets the semantic type of window.

getWorkspace

windowGetWorkspace

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Workspace

Returns: the single current workspace window is on, or Nothing. The returned Workspace is owned by libwnck and must not be referenced or unreferenced.

Gets the current workspace window is on. If the window is pinned (on all workspaces), or not on any workspaces, Nothing may be returned.

getXid

windowGetXid

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m CULong

Returns: the X window ID of window.

Gets the X window ID of window.

hasIconName

windowHasIconName

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window

-> m Bool

Returns: True if windowGetIconName returns window<!-- -->'s icon name, False if it returns a fallback name.

Checks whether or not window has an icon name. windowGetIconName will always return some value, even if window has no icon name set; windowHasIconName can be used to tell if that icon name is real or not.

(Note that if windowHasIconName returns False, but windowHasName returns True, then the name returned by windowGetIconName is window<!-- -->'s name. Only when both methods return False does windowGetIconName return a generic fallback name.)

Since: 2.16

hasName

windowHasName

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Bool

Returns: True if windowGetName returns window<!-- -->'s name, False if it returns a fallback name.

Checks whether or not window has a name. windowGetName will always return some value, even if window has no name set; windowHasName can be used to tell if that name is real or not.

For icons titles, use windowHasIconName instead.

Since: 2.16

isAbove

windowIsAbove

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Bool

Returns: True if window is above other windows, False otherwise.

Gets whether window is above other windows. This state may change anytime a Window::state-changed signal gets emitted.

See windowMakeAbove for more details on this state.

Since: 2.14

isActive

windowIsActive

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Bool

Returns: True if window is the active window on its Screen, False otherwise.

Gets whether window is the active window on its Screen.

isBelow

windowIsBelow

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Bool

Returns: True if window is below other windows, False otherwise.

Gets whether window is below other windows. This state may change anytime a Window::state-changed signal gets emitted.

See windowMakeBelow for more details on this state.

Since: 2.20

isFullscreen

windowIsFullscreen

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Bool

Returns: True if window is fullscreen, False otherwise.

Gets whether window is fullscreen. Fullscreen state may change anytime a Window::state-changed signal gets emitted.

Since: 2.8

isInViewport

windowIsInViewport

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsWorkspace b)

=> a

window: a Window.

-> b

workspace: a Workspace.

-> m Bool

Returns: True if window appears in current viewport of workspace, False otherwise.

Gets True if window appears in the current viewport of workspace.

Since: 2.4

isMaximized

windowIsMaximized

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Bool

Returns: True if window is maximized in both directions, False otherwise.

Gets whether window is maximized. Maximization state may change anytime a Window::state-changed signal gets emitted.

As for GDK, "maximized" means both vertically and horizontally. If window is maximized in only one direction, then window is not considered maximized.

isMaximizedHorizontally

windowIsMaximizedHorizontally

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Bool

Returns: True if window is maximized horizontally, False otherwise.

Gets whether window is maximized horizontally. Horizontal maximization state may change anytime a Window::state-changed signal gets emitted.

isMaximizedVertically

windowIsMaximizedVertically

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Bool

Returns: True if window is maximized vertically, False otherwise.

Gets whether window is maximized vertically. vertiVal maximization state may change anytime a Window::state-changed signal gets emitted.

isMinimized

windowIsMinimized

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Bool

Returns: True if window is minimized, False otherwise.

Gets whether window is minimized. Minimization state may change anytime a Window::state-changed signal gets emitted.

isMostRecentlyActivated

windowIsMostRecentlyActivated

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Bool

Returns: True if window was the most recently activated window on its Screen, False otherwise.

Gets whether window is the most recently activated window on its Screen.

The most recently activated window is identical to the active window for click and sloppy focus methods (since a window is always active in those cases) but differs slightly for mouse focus since there often is no active window.

Since: 2.8

isOnWorkspace

windowIsOnWorkspace

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsWorkspace b)

=> a

window: a Window.

-> b

workspace: a Workspace.

-> m Bool

Returns: True if window appears on workspace, False otherwise.

Gets whether window appears on workspace.

isPinned

windowIsPinned

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Bool

Returns: True if window is on all workspaces, False otherwise.

Gets whether window is on all workspace. Pinned state may change anytime a Window::workspace-changed signal gets emitted, but not when a Window::state-changed gets emitted.

isShaded

windowIsShaded

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Bool

Returns: True if window is shaded, False otherwise.

Gets whether window is shaded. Shade state may change anytime a Window::state-changed signal gets emitted.

isSkipPager

windowIsSkipPager

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Bool

Returns: True if window is included on pagers, False otherwise.

Gets whether window is included on pagers. This state may change anytime a Window::state-changed signal gets emitted.

isSkipTasklist

windowIsSkipTasklist

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Bool

Returns: True if window is included on tasklists, False otherwise.

Gets whether window is included on tasklists. This state may change anytime a Window::state-changed signal gets emitted.

isSticky

windowIsSticky

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Bool

Returns: True if window is "stuck to the glass", False otherwise.

Gets whether window is sticky. Sticky state may change anytime a Window::state-changed signal gets emitted.

Sticky here means "stuck to the glass", i.e. does not scroll with the viewport. In GDK/GTK+ (e.g. 'GI.Gdk.Objects.Window.windowStick'\/'GI.Gtk.Objects.Window.windowStick'), sticky means "stuck to the glass" and <emphasis>also</emphasis> that the window is on all workspaces. But here it only means the viewport aspect of it.

isVisibleOnWorkspace

windowIsVisibleOnWorkspace

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsWorkspace b)

=> a

window: a Window.

-> b

workspace: a Workspace.

-> m Bool

Returns: True if window appears on workspace in normal state, False otherwise.

Like windowIsOnWorkspace, but also checks that the window is in a visible state (i.e. not minimized or shaded).

keyboardMove

windowKeyboardMove

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ()

Asks the window manager to start moving window via the keyboard.

keyboardSize

windowKeyboardSize

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ()

Asks the window manager to start resizing window via the keyboard.

makeAbove

windowMakeAbove

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ()

Asks the window manager to put window on top of most windows (window will not be on top of focused fullscreen windows, of other windows with this setting and of dock windows).

Since: 2.14

makeBelow

windowMakeBelow

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ()

Asks the window manager to put window below most windows.

Since: 2.20

maximize

windowMaximize

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ()

Asks the window manager to maximize window.

maximizeHorizontally

windowMaximizeHorizontally

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ()

Asks the window manager to maximize horizontally window.

maximizeVertically

windowMaximizeVertically

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ()

Asks the window manager to maximize vertically window.

minimize

windowMinimize

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ()

Minimizes window.

moveToWorkspace

windowMoveToWorkspace

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsWorkspace b)

=> a

window: a Window.

-> b

space: a Workspace.

-> m ()

Asks the window manager to move window to space. If window was pinned, it will also result in window being visible only on space.

needsAttention

windowNeedsAttention

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Bool

Returns: True if window needs attention, False otherwise.

Gets whether window needs attention. This state may change anytime a Window::state-changed signal gets emitted.

This state depends on flags such as the demands_attention and is_urgent hints.

Since: 2.12

orTransientNeedsAttention

windowOrTransientNeedsAttention

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Bool

Returns: True if window or one of its transients needs attention, False otherwise.

Gets whether window or one of its transients needs attention. This state may change anytime a Window::state-changed signal gets emitted.

Since: 2.12

pin

windowPin

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ()

Asks the window manager to put window on all workspaces.

setFullscreen

windowSetFullscreen

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> Bool

fullscreen: whether to make window fullscreen.

-> m ()

Asks the window manager to set the fullscreen state of window according to fullscreen.

Since: 2.8

setGeometry

windowSetGeometry

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> WindowGravity

gravity: the gravity point to use as a reference for the new position.

-> [WindowMoveResizeMask]

geometryMask: a bitmask containing flags for what should be set.

-> Int32

x: new X coordinate in pixels of window.

-> Int32

y: new Y coordinate in pixels of window.

-> Int32

width: new width in pixels of window.

-> Int32

height: new height in pixels of window.

-> m ()

Sets the size and position of window. The X and Y coordinates should be relative to the root window.

Note that the new size and position apply to window with its frame added by the window manager. Therefore, using windowSetGeometry with the values returned by windowGetGeometry should be a no-op, while using windowSetGeometry with the values returned by windowGetClientWindowGeometry should reduce the size of window and move it.

Since: 2.16

setIconGeometry

windowSetIconGeometry

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> Int32

x: X coordinate in pixels.

-> Int32

y: Y coordinate in pixels.

-> Int32

width: width in pixels.

-> Int32

height: height in pixels.

-> m ()

Sets the icon geometry for window. A typical use case for this is the destination of the minimization animation of window.

setSkipPager

windowSetSkipPager

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> Bool

skip: whether window should be included on pagers.

-> m ()

Asks the window manager to make window included or not included on pagers.

setSkipTasklist

windowSetSkipTasklist

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> Bool

skip: whether window should be included on tasklists.

-> m ()

Asks the window manager to make window included or not included on tasklists.

setSortOrder

windowSetSortOrder

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> Int32

order: new sort order for window.

-> m ()

Sets the sort order of window. The sort order is used for ordering of window in Selector and Tasklist.

Since: 2.20

setWindowType

windowSetWindowType

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> WindowType

wintype: a semantic type.

-> m ()

Sets the semantic type of window to wintype.

Since: 2.12

shade

windowShade

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ()

Asks the window manager to shade window.

stick

windowStick

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ()

Asks the window manager to keep the window<!-- -->'s position fixed on the screen, even when the workspace or viewport scrolls.

transientIsMostRecentlyActivated

windowTransientIsMostRecentlyActivated

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m Bool

Returns: True if one of the transients of window is the most recently activated window, False otherwise.

Gets whether one of the transients of window is the most recently activated window. See windowIsMostRecentlyActivated for a more complete description of what is meant by most recently activated. This function is needed because clicking on a Tasklist once will activate a transient instead of window itself (wnck_window_activate_transient), and clicking again should minimize window and its transients. (Not doing this can be especially annoying in the case of modal dialogs that don't appear in the Tasklist).

Since: 2.12

unmakeAbove

windowUnmakeAbove

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ()

Asks the window manager to not put window on top of most windows, and to put it again in the stack with other windows.

Since: 2.14

unmakeBelow

windowUnmakeBelow

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ()

Asks the window manager to not put window below most windows, and to put it again in the stack with other windows.

Since: 2.20

unmaximize

windowUnmaximize

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ()

Asks the window manager to unmaximize window.

unmaximizeHorizontally

windowUnmaximizeHorizontally

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ()

Asks the window manager to unmaximize horizontally window.

unmaximizeVertically

windowUnmaximizeVertically

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ()

Asks the window manager to unmaximize vertically window.

unminimize

windowUnminimize

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> Word32

timestamp: the X server timestamp of the user interaction event that caused this call to occur.

-> m ()

Unminimizes window by activating it or one of its transients. See windowActivateTransient for details on how the activation is done.

unpin

windowUnpin

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ()

Asks the window manager to put window only in the currently active workspace, if window was previously pinned. If window was not pinned, does not change window<!-- -->'s workspace. If the active workspace is not known for some reason (it should not happen much), sets window<!-- -->'s workspace to the first workspace.

unshade

windowUnshade

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ()

Asks the window manager to unshade window.

unstick

windowUnstick

Arguments

:: (HasCallStack, MonadIO m, IsWindow a)

=> a

window: a Window.

-> m ()

Asks the window manager to not have window<!-- -->'s position fixed on the screen when the workspace or viewport scrolls.

Signals

actionsChanged

type C_WindowActionsChangedCallback = Ptr () -> CUInt -> CUInt -> Ptr () -> IO ()

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

type WindowActionsChangedCallback

Arguments

 = [WindowActions]

changedMask: the bitmask containing bits set for all actions availabilities for window that have changed.

-> [WindowActions]

newState: the new actions availabilities for window.

-> IO ()

Emitted when the actions availabilities for window change.

afterWindowActionsChanged :: (IsWindow a, MonadIO m) => a -> WindowActionsChangedCallback -> m SignalHandlerId

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

after window #actionsChanged callback

genClosure_WindowActionsChanged :: WindowActionsChangedCallback -> IO Closure

Wrap the callback into a Closure.

mk_WindowActionsChangedCallback :: C_WindowActionsChangedCallback -> IO (FunPtr C_WindowActionsChangedCallback)

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

noWindowActionsChangedCallback :: Maybe WindowActionsChangedCallback

A convenience synonym for Nothing :: Maybe WindowActionsChangedCallback.

onWindowActionsChanged :: (IsWindow a, MonadIO m) => a -> WindowActionsChangedCallback -> m SignalHandlerId

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

on window #actionsChanged callback

wrap_WindowActionsChangedCallback :: WindowActionsChangedCallback -> C_WindowActionsChangedCallback

Wrap a WindowActionsChangedCallback into a C_WindowActionsChangedCallback.

classChanged

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

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

type WindowClassChangedCallback = IO ()

Emitted when the class name or instance name of window changes.

afterWindowClassChanged :: (IsWindow a, MonadIO m) => a -> WindowClassChangedCallback -> m SignalHandlerId

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

after window #classChanged callback

genClosure_WindowClassChanged :: WindowClassChangedCallback -> IO Closure

Wrap the callback into a Closure.

mk_WindowClassChangedCallback :: C_WindowClassChangedCallback -> IO (FunPtr C_WindowClassChangedCallback)

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

noWindowClassChangedCallback :: Maybe WindowClassChangedCallback

A convenience synonym for Nothing :: Maybe WindowClassChangedCallback.

onWindowClassChanged :: (IsWindow a, MonadIO m) => a -> WindowClassChangedCallback -> m SignalHandlerId

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

on window #classChanged callback

wrap_WindowClassChangedCallback :: WindowClassChangedCallback -> C_WindowClassChangedCallback

Wrap a WindowClassChangedCallback into a C_WindowClassChangedCallback.

geometryChanged

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

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

type WindowGeometryChangedCallback = IO ()

Emitted when the geometry of window changes.

afterWindowGeometryChanged :: (IsWindow a, MonadIO m) => a -> WindowGeometryChangedCallback -> m SignalHandlerId

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

after window #geometryChanged callback

genClosure_WindowGeometryChanged :: WindowGeometryChangedCallback -> IO Closure

Wrap the callback into a Closure.

mk_WindowGeometryChangedCallback :: C_WindowGeometryChangedCallback -> IO (FunPtr C_WindowGeometryChangedCallback)

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

noWindowGeometryChangedCallback :: Maybe WindowGeometryChangedCallback

A convenience synonym for Nothing :: Maybe WindowGeometryChangedCallback.

onWindowGeometryChanged :: (IsWindow a, MonadIO m) => a -> WindowGeometryChangedCallback -> m SignalHandlerId

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

on window #geometryChanged callback

wrap_WindowGeometryChangedCallback :: WindowGeometryChangedCallback -> C_WindowGeometryChangedCallback

Wrap a WindowGeometryChangedCallback into a C_WindowGeometryChangedCallback.

iconChanged

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

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

type WindowIconChangedCallback = IO ()

Emitted when the icon of window changes.

afterWindowIconChanged :: (IsWindow a, MonadIO m) => a -> WindowIconChangedCallback -> m SignalHandlerId

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

after window #iconChanged callback

genClosure_WindowIconChanged :: WindowIconChangedCallback -> IO Closure

Wrap the callback into a Closure.

mk_WindowIconChangedCallback :: C_WindowIconChangedCallback -> IO (FunPtr C_WindowIconChangedCallback)

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

noWindowIconChangedCallback :: Maybe WindowIconChangedCallback

A convenience synonym for Nothing :: Maybe WindowIconChangedCallback.

onWindowIconChanged :: (IsWindow a, MonadIO m) => a -> WindowIconChangedCallback -> m SignalHandlerId

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

on window #iconChanged callback

wrap_WindowIconChangedCallback :: WindowIconChangedCallback -> C_WindowIconChangedCallback

Wrap a WindowIconChangedCallback into a C_WindowIconChangedCallback.

nameChanged

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

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

type WindowNameChangedCallback = IO ()

Emitted when the name of window changes.

afterWindowNameChanged :: (IsWindow a, MonadIO m) => a -> WindowNameChangedCallback -> m SignalHandlerId

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

after window #nameChanged callback

genClosure_WindowNameChanged :: WindowNameChangedCallback -> IO Closure

Wrap the callback into a Closure.

mk_WindowNameChangedCallback :: C_WindowNameChangedCallback -> IO (FunPtr C_WindowNameChangedCallback)

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

noWindowNameChangedCallback :: Maybe WindowNameChangedCallback

A convenience synonym for Nothing :: Maybe WindowNameChangedCallback.

onWindowNameChanged :: (IsWindow a, MonadIO m) => a -> WindowNameChangedCallback -> m SignalHandlerId

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

on window #nameChanged callback

wrap_WindowNameChangedCallback :: WindowNameChangedCallback -> C_WindowNameChangedCallback

Wrap a WindowNameChangedCallback into a C_WindowNameChangedCallback.

roleChanged

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

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

type WindowRoleChangedCallback = IO ()

Emitted when the role of window changes.

afterWindowRoleChanged :: (IsWindow a, MonadIO m) => a -> WindowRoleChangedCallback -> m SignalHandlerId

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

after window #roleChanged callback

genClosure_WindowRoleChanged :: WindowRoleChangedCallback -> IO Closure

Wrap the callback into a Closure.

mk_WindowRoleChangedCallback :: C_WindowRoleChangedCallback -> IO (FunPtr C_WindowRoleChangedCallback)

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

noWindowRoleChangedCallback :: Maybe WindowRoleChangedCallback

A convenience synonym for Nothing :: Maybe WindowRoleChangedCallback.

onWindowRoleChanged :: (IsWindow a, MonadIO m) => a -> WindowRoleChangedCallback -> m SignalHandlerId

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

on window #roleChanged callback

wrap_WindowRoleChangedCallback :: WindowRoleChangedCallback -> C_WindowRoleChangedCallback

Wrap a WindowRoleChangedCallback into a C_WindowRoleChangedCallback.

stateChanged

type C_WindowStateChangedCallback = Ptr () -> CUInt -> CUInt -> Ptr () -> IO ()

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

type WindowStateChangedCallback

Arguments

 = [WindowState]

changedMask: the bitmask containing bits set for all states of window that have changed.

-> [WindowState]

newState: the new state of window.

-> IO ()

Emitted when the state of window changes. This can happen when window is (un)minimized, (un)maximized, (un)sticked, (un)shaded, (un)made above, (un)made below, (un)set fullscreen, when it needs attention, etc. See WindowState for the complete list of states that might have changed.

afterWindowStateChanged :: (IsWindow a, MonadIO m) => a -> WindowStateChangedCallback -> m SignalHandlerId

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

after window #stateChanged callback

genClosure_WindowStateChanged :: WindowStateChangedCallback -> IO Closure

Wrap the callback into a Closure.

mk_WindowStateChangedCallback :: C_WindowStateChangedCallback -> IO (FunPtr C_WindowStateChangedCallback)

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

noWindowStateChangedCallback :: Maybe WindowStateChangedCallback

A convenience synonym for Nothing :: Maybe WindowStateChangedCallback.

onWindowStateChanged :: (IsWindow a, MonadIO m) => a -> WindowStateChangedCallback -> m SignalHandlerId

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

on window #stateChanged callback

wrap_WindowStateChangedCallback :: WindowStateChangedCallback -> C_WindowStateChangedCallback

Wrap a WindowStateChangedCallback into a C_WindowStateChangedCallback.

typeChanged

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

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

type WindowTypeChangedCallback = IO ()

Emitted when the EWMH type hint of the window changes.

Since: 3.20

afterWindowTypeChanged :: (IsWindow a, MonadIO m) => a -> WindowTypeChangedCallback -> m SignalHandlerId

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

after window #typeChanged callback

genClosure_WindowTypeChanged :: WindowTypeChangedCallback -> IO Closure

Wrap the callback into a Closure.

mk_WindowTypeChangedCallback :: C_WindowTypeChangedCallback -> IO (FunPtr C_WindowTypeChangedCallback)

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

noWindowTypeChangedCallback :: Maybe WindowTypeChangedCallback

A convenience synonym for Nothing :: Maybe WindowTypeChangedCallback.

onWindowTypeChanged :: (IsWindow a, MonadIO m) => a -> WindowTypeChangedCallback -> m SignalHandlerId

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

on window #typeChanged callback

wrap_WindowTypeChangedCallback :: WindowTypeChangedCallback -> C_WindowTypeChangedCallback

Wrap a WindowTypeChangedCallback into a C_WindowTypeChangedCallback.

workspaceChanged

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

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

type WindowWorkspaceChangedCallback = IO ()

Emitted when the current workspace of window changes, or if window has been pinned or unpinned.

afterWindowWorkspaceChanged :: (IsWindow a, MonadIO m) => a -> WindowWorkspaceChangedCallback -> m SignalHandlerId

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

after window #workspaceChanged callback

genClosure_WindowWorkspaceChanged :: WindowWorkspaceChangedCallback -> IO Closure

Wrap the callback into a Closure.

mk_WindowWorkspaceChangedCallback :: C_WindowWorkspaceChangedCallback -> IO (FunPtr C_WindowWorkspaceChangedCallback)

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

noWindowWorkspaceChangedCallback :: Maybe WindowWorkspaceChangedCallback

A convenience synonym for Nothing :: Maybe WindowWorkspaceChangedCallback.

onWindowWorkspaceChanged :: (IsWindow a, MonadIO m) => a -> WindowWorkspaceChangedCallback -> m SignalHandlerId

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

on window #workspaceChanged callback

wrap_WindowWorkspaceChangedCallback :: WindowWorkspaceChangedCallback -> C_WindowWorkspaceChangedCallback

Wrap a WindowWorkspaceChangedCallback into a C_WindowWorkspaceChangedCallback.