xmonad-contrib-0.17.1: Community-maintained extensions for xmonad

Copyright | (c) David Roundy <droundy@darcs.net>
License | BSD
Maintainer | none
Stability | unstable
Portability | portable
Safe Haskell | Safe-Inferred
Language | Haskell2010

XMonad.Layout.LayoutModifier

Contents

- Usage
- The `LayoutModifier` class

Description

A module for writing easy layout modifiers, which do not define a layout in and of themselves, but modify the behavior of or add new functionality to other layouts. If you ever find yourself writing a layout which takes another layout as a parameter, chances are you should be writing a LayoutModifier instead!

In case it is not clear, this module is not intended to help you configure xmonad, it is to help you write other extension modules. So get hacking!

Synopsis

- class (Show (m a), Read (m a)) => LayoutModifier m a where
  - modifyLayout :: LayoutClass l a => m a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a))
  - modifyLayoutWithUpdate :: LayoutClass l a => m a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (m a))
  - handleMess :: m a -> SomeMessage -> X (Maybe (m a))
  - handleMessOrMaybeModifyIt :: m a -> SomeMessage -> X (Maybe (Either (m a) SomeMessage))
  - pureMess :: m a -> SomeMessage -> Maybe (m a)
  - redoLayout :: m a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (m a))
  - pureModifier :: m a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (m a))
  - hook :: m a -> X ()
  - unhook :: m a -> X ()
  - modifierDescription :: m a -> String
  - modifyDescription :: LayoutClass l a => m a -> l a -> String
- data ModifiedLayout m l a = ModifiedLayout (m a) (l a)

# Usage

The `LayoutModifier` class is provided to help extension developers write easy layout modifiers. End users won't find much of interest here. =)

To write a layout modifier using the `LayoutModifier` class, define a data type to represent the layout modification (storing any necessary state), define an instance of `LayoutModifier`, and export an appropriate function for applying the modifier. For example:

    data MyModifier a = MyModifier MyState
      deriving (Show, Read)

    instance LayoutModifier MyModifier a where
      -- override whatever methods from LayoutModifier you like

    modify :: l a -> ModifiedLayout MyModifier l a
    modify = ModifiedLayout (MyModifier initialState)

When defining an instance of `LayoutModifier`, you are free to override as many or as few of the methods as you see fit. See the documentation below for specific information about the effect of overriding each method. Every method has a default implementation; an instance of `LayoutModifier` which did not provide a non-default implementation of any of the methods would simply act as the identity on any layouts to which it is applied.

For more specific usage examples, see

- XMonad.Layout.WorkspaceDir
- XMonad.Layout.Magnifier
- XMonad.Layout.NoBorders
- XMonad.Layout.Reflect
- XMonad.Layout.Named
- XMonad.Layout.WindowNavigation

and several others. You probably want to start by looking at some of the above examples; the documentation below is detailed but possibly confusing, and in many cases the creation of a `LayoutModifier` is actually quite simple.

Important note: because of the way the `LayoutModifier` class is intended to be used, by overriding any of its methods and keeping default implementations for all the others, `LayoutModifier` methods should never be called explicitly. It is likely that such explicit calls will not have the intended effect. Rather, the `LayoutModifier` methods should only be called indirectly through the `LayoutClass` instance for `ModifiedLayout`, since it is this instance that defines the semantics of overriding the various `LayoutModifier` methods.

# The `LayoutModifier` class

class (Show (m a), Read (m a)) => LayoutModifier m a where #

Minimal complete definition

Nothing

Methods

modifyLayout #

Arguments

:: LayoutClass l a |
=> m a | the layout modifier
-> Workspace WorkspaceId (l a) a | current workspace
-> Rectangle | screen rectangle
-> X ([(a, Rectangle)], Maybe (l a)) |

`modifyLayout` allows you to intercept a call to `runLayout` before it is called on the underlying layout, in order to perform some effect in the X monad, and/or modify some of the parameters before passing them on to the `runLayout` method of the underlying layout.

The default implementation of `modifyLayout` simply calls `runLayout` on the underlying layout.

modifyLayoutWithUpdate :: LayoutClass l a => m a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (m a)) #

Similar to `modifyLayout`, but this function also allows you update the state of your layout modifier(the second value in the outer tuple).

If both `modifyLayoutWithUpdate` and `redoLayout` return a modified state of the layout modifier, `redoLayout` takes precedence. If this function returns a modified state, this state will internally be used in the subsequent call to `redoLayout` as well.

handleMess :: m a -> SomeMessage -> X (Maybe (m a)) #

`handleMess` allows you to spy on messages to the underlying layout, in order to have an effect in the X monad, or alter the layout modifier state in some way (by returning `Just nm`, where `nm` is a new modifier). In all cases, the underlying layout will also receive the message as usual, after the message has been processed by `handleMess`.

If you wish to possibly modify a message before it reaches the underlying layout, you should use `handleMessOrMaybeModifyIt` instead. If you do not need to modify messages or have access to the X monad, you should use `pureMess` instead.

The default implementation of `handleMess` calls `unhook` when receiving a `Hide` or `ReleaseResources` method (after which it returns `Nothing`), and otherwise passes the message on to `pureMess`.

handleMessOrMaybeModifyIt :: m a -> SomeMessage -> X (Maybe (Either (m a) SomeMessage)) #

`handleMessOrMaybeModifyIt` allows you to intercept messages sent to the underlying layout, in order to have an effect in the X monad, alter the layout modifier state, or produce a modified message to be passed on to the underlying layout.

The default implementation of `handleMessOrMaybeModifyIt` simply passes on the message to `handleMess`.

pureMess :: m a -> SomeMessage -> Maybe (m a) #

`pureMess` allows you to spy on messages sent to the underlying layout, in order to possibly change the layout modifier state.

The default implementation of `pureMess` ignores messages sent to it, and returns `Nothing` (causing the layout modifier to remain unchanged).

redoLayout #

Arguments

:: m a | the layout modifier
-> Rectangle | screen rectangle
-> Maybe (Stack a) | current window stack
-> [(a, Rectangle)] | (window,rectangle) pairs returned by the underlying layout
-> X ([(a, Rectangle)], Maybe (m a)) |

`redoLayout` allows you to intercept a call to `runLayout` on workspaces with at least one window, after it is called on the underlying layout, in order to perform some effect in the X monad, possibly return a new layout modifier, and/or modify the results of `runLayout` before returning them.

If you don't need access to the X monad, use `pureModifier` instead. Also, if the behavior you need can be cleanly separated into an effect in the X monad, followed by a pure transformation of the results of `runLayout`, you should consider implementing `hook` and `pureModifier` instead of `redoLayout`.

On empty workspaces, the Stack is Nothing.

The default implementation of `redoLayout` calls `hook` and then `pureModifier`.

pureModifier #

Arguments

:: m a | the layout modifier
-> Rectangle | screen rectangle
-> Maybe (Stack a) | current window stack
-> [(a, Rectangle)] | (window, rectangle) pairs returned by the underlying layout
-> ([(a, Rectangle)], Maybe (m a)) |

`pureModifier` allows you to intercept a call to `runLayout` after it is called on the underlying layout, in order to modify the list of window/rectangle pairings it has returned, and/or return a new layout modifier.

The default implementation of `pureModifier` returns the window rectangles unmodified.

hook :: m a -> X () #

`hook` is called by the default implementation of `redoLayout`, and as such represents an X action which is to be run each time `runLayout` is called on the underlying layout, after `runLayout` has completed. Of course, if you override `redoLayout`, then `hook` will not be called unless you explicitly call it.

The default implementation of `hook` is `return ()` (i.e., it has no effect).

unhook :: m a -> X () #

`unhook` is called by the default implementation of `handleMess` upon receiving a `Hide` or a `ReleaseResources` message.

The default implementation, of course, does nothing.

modifierDescription :: m a -> String #

`modifierDescription` is used to give a String description to this layout modifier. It is the empty string by default; you should only override this if it is important that the presence of the layout modifier be displayed in text representations of the layout (for example, in the status bar of a XMonad.Hooks.StatusBar user).

modifyDescription :: LayoutClass l a => m a -> l a -> String #

`modifyDescription` gives a String description for the entire layout (modifier + underlying layout). By default, it is derived from the concatenation of the `modifierDescription` with the `description` of the underlying layout, with a "smart space" in between (the space is not included if the `modifierDescription` is empty).

#### Instances

Instances details

LayoutModifier MouseResize Window # |

Instance details

Defined in XMonad.Actions.MouseResize

Methods

modifyLayout :: LayoutClass l Window => MouseResize Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => MouseResize Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (MouseResize Window)) #

handleMess :: MouseResize Window -> SomeMessage -> X (Maybe (MouseResize Window)) #

handleMessOrMaybeModifyIt :: MouseResize Window -> SomeMessage -> X (Maybe (Either (MouseResize Window) SomeMessage)) #

pureMess :: MouseResize Window -> SomeMessage -> Maybe (MouseResize Window) #

redoLayout :: MouseResize Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (MouseResize Window)) #

pureModifier :: MouseResize Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (MouseResize Window)) #

hook :: MouseResize Window -> X () #

unhook :: MouseResize Window -> X () #

modifierDescription :: MouseResize Window -> String #

modifyDescription :: LayoutClass l Window => MouseResize Window -> l Window -> String #

LayoutModifier WorkspaceCursors a # |

Instance details

Defined in XMonad.Actions.WorkspaceCursors

Methods

modifyLayout :: LayoutClass l a => WorkspaceCursors a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) #

modifyLayoutWithUpdate :: LayoutClass l a => WorkspaceCursors a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (WorkspaceCursors a)) #

handleMess :: WorkspaceCursors a -> SomeMessage -> X (Maybe (WorkspaceCursors a)) #

handleMessOrMaybeModifyIt :: WorkspaceCursors a -> SomeMessage -> X (Maybe (Either (WorkspaceCursors a) SomeMessage)) #

pureMess :: WorkspaceCursors a -> SomeMessage -> Maybe (WorkspaceCursors a) #

redoLayout :: WorkspaceCursors a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (WorkspaceCursors a)) #

pureModifier :: WorkspaceCursors a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (WorkspaceCursors a)) #

hook :: WorkspaceCursors a -> X () #

unhook :: WorkspaceCursors a -> X () #

modifierDescription :: WorkspaceCursors a -> String #

modifyDescription :: LayoutClass l a => WorkspaceCursors a -> l a -> String #

LayoutModifier AvoidStruts a # |

Instance details

Defined in XMonad.Hooks.ManageDocks

Methods

modifyLayout :: LayoutClass l a => AvoidStruts a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) #

modifyLayoutWithUpdate :: LayoutClass l a => AvoidStruts a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (AvoidStruts a)) #

handleMess :: AvoidStruts a -> SomeMessage -> X (Maybe (AvoidStruts a)) #

handleMessOrMaybeModifyIt :: AvoidStruts a -> SomeMessage -> X (Maybe (Either (AvoidStruts a) SomeMessage)) #

pureMess :: AvoidStruts a -> SomeMessage -> Maybe (AvoidStruts a) #

redoLayout :: AvoidStruts a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (AvoidStruts a)) #

pureModifier :: AvoidStruts a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (AvoidStruts a)) #

hook :: AvoidStruts a -> X () #

unhook :: AvoidStruts a -> X () #

modifierDescription :: AvoidStruts a -> String #

modifyDescription :: LayoutClass l a => AvoidStruts a -> l a -> String #

LayoutModifier RefocusLastLayoutHook a # |

Instance details

Defined in XMonad.Hooks.RefocusLast

Methods

modifyLayout :: LayoutClass l a => RefocusLastLayoutHook a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) #

modifyLayoutWithUpdate :: LayoutClass l a => RefocusLastLayoutHook a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (RefocusLastLayoutHook a)) #

handleMess :: RefocusLastLayoutHook a -> SomeMessage -> X (Maybe (RefocusLastLayoutHook a)) #

handleMessOrMaybeModifyIt :: RefocusLastLayoutHook a -> SomeMessage -> X (Maybe (Either (RefocusLastLayoutHook a) SomeMessage)) #

pureMess :: RefocusLastLayoutHook a -> SomeMessage -> Maybe (RefocusLastLayoutHook a) #

redoLayout :: RefocusLastLayoutHook a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (RefocusLastLayoutHook a)) #

pureModifier :: RefocusLastLayoutHook a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (RefocusLastLayoutHook a)) #

hook :: RefocusLastLayoutHook a -> X () #

unhook :: RefocusLastLayoutHook a -> X () #

modifierDescription :: RefocusLastLayoutHook a -> String #

modifyDescription :: LayoutClass l a => RefocusLastLayoutHook a -> l a -> String #

Eq w => LayoutModifier AutoMaster w # |

Instance details

Defined in XMonad.Layout.AutoMaster

Methods

modifyLayout :: LayoutClass l w => AutoMaster w -> Workspace WorkspaceId (l w) w -> Rectangle -> X ([(w, Rectangle)], Maybe (l w)) #

modifyLayoutWithUpdate :: LayoutClass l w => AutoMaster w -> Workspace WorkspaceId (l w) w -> Rectangle -> X (([(w, Rectangle)], Maybe (l w)), Maybe (AutoMaster w)) #

handleMess :: AutoMaster w -> SomeMessage -> X (Maybe (AutoMaster w)) #

handleMessOrMaybeModifyIt :: AutoMaster w -> SomeMessage -> X (Maybe (Either (AutoMaster w) SomeMessage)) #

pureMess :: AutoMaster w -> SomeMessage -> Maybe (AutoMaster w) #

redoLayout :: AutoMaster w -> Rectangle -> Maybe (Stack w) -> [(w, Rectangle)] -> X ([(w, Rectangle)], Maybe (AutoMaster w)) #

pureModifier :: AutoMaster w -> Rectangle -> Maybe (Stack w) -> [(w, Rectangle)] -> ([(w, Rectangle)], Maybe (AutoMaster w)) #

hook :: AutoMaster w -> X () #

unhook :: AutoMaster w -> X () #

modifierDescription :: AutoMaster w -> String #

modifyDescription :: LayoutClass l w => AutoMaster w -> l w -> String #

LayoutModifier BorderResize Window # |

Instance details

Defined in XMonad.Layout.BorderResize

Methods

modifyLayout :: LayoutClass l Window => BorderResize Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => BorderResize Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (BorderResize Window)) #

handleMess :: BorderResize Window -> SomeMessage -> X (Maybe (BorderResize Window)) #

handleMessOrMaybeModifyIt :: BorderResize Window -> SomeMessage -> X (Maybe (Either (BorderResize Window) SomeMessage)) #

pureMess :: BorderResize Window -> SomeMessage -> Maybe (BorderResize Window) #

redoLayout :: BorderResize Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (BorderResize Window)) #

pureModifier :: BorderResize Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (BorderResize Window)) #

hook :: BorderResize Window -> X () #

unhook :: BorderResize Window -> X () #

modifierDescription :: BorderResize Window -> String #

modifyDescription :: LayoutClass l Window => BorderResize Window -> l Window -> String #

LayoutModifier BoringWindows Window # |

Instance details

Defined in XMonad.Layout.BoringWindows

Methods

modifyLayout :: LayoutClass l Window => BoringWindows Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => BoringWindows Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (BoringWindows Window)) #

handleMess :: BoringWindows Window -> SomeMessage -> X (Maybe (BoringWindows Window)) #

handleMessOrMaybeModifyIt :: BoringWindows Window -> SomeMessage -> X (Maybe (Either (BoringWindows Window) SomeMessage)) #

pureMess :: BoringWindows Window -> SomeMessage -> Maybe (BoringWindows Window) #

redoLayout :: BoringWindows Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (BoringWindows Window)) #

pureModifier :: BoringWindows Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (BoringWindows Window)) #

hook :: BoringWindows Window -> X () #

unhook :: BoringWindows Window -> X () #

modifierDescription :: BoringWindows Window -> String #

modifyDescription :: LayoutClass l Window => BoringWindows Window -> l Window -> String #

LayoutModifier CenteredIfSingle Window # |

Instance details

Defined in XMonad.Layout.CenteredIfSingle

Methods

modifyLayout :: LayoutClass l Window => CenteredIfSingle Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => CenteredIfSingle Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (CenteredIfSingle Window)) #

handleMess :: CenteredIfSingle Window -> SomeMessage -> X (Maybe (CenteredIfSingle Window)) #

handleMessOrMaybeModifyIt :: CenteredIfSingle Window -> SomeMessage -> X (Maybe (Either (CenteredIfSingle Window) SomeMessage)) #

pureMess :: CenteredIfSingle Window -> SomeMessage -> Maybe (CenteredIfSingle Window) #

redoLayout :: CenteredIfSingle Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (CenteredIfSingle Window)) #

pureModifier :: CenteredIfSingle Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (CenteredIfSingle Window)) #

hook :: CenteredIfSingle Window -> X () #

unhook :: CenteredIfSingle Window -> X () #

modifierDescription :: CenteredIfSingle Window -> String #

modifyDescription :: LayoutClass l Window => CenteredIfSingle Window -> l Window -> String #

LayoutModifier CenteredMaster Window # |

Instance details

Defined in XMonad.Layout.CenteredMaster

Methods

modifyLayout :: LayoutClass l Window => CenteredMaster Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => CenteredMaster Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (CenteredMaster Window)) #

handleMess :: CenteredMaster Window -> SomeMessage -> X (Maybe (CenteredMaster Window)) #

handleMessOrMaybeModifyIt :: CenteredMaster Window -> SomeMessage -> X (Maybe (Either (CenteredMaster Window) SomeMessage)) #

pureMess :: CenteredMaster Window -> SomeMessage -> Maybe (CenteredMaster Window) #

redoLayout :: CenteredMaster Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (CenteredMaster Window)) #

pureModifier :: CenteredMaster Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (CenteredMaster Window)) #

hook :: CenteredMaster Window -> X () #

unhook :: CenteredMaster Window -> X () #

modifierDescription :: CenteredMaster Window -> String #

modifyDescription :: LayoutClass l Window => CenteredMaster Window -> l Window -> String #

LayoutModifier TopRightMaster Window # |

Instance details

Defined in XMonad.Layout.CenteredMaster

Methods

modifyLayout :: LayoutClass l Window => TopRightMaster Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => TopRightMaster Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (TopRightMaster Window)) #

handleMess :: TopRightMaster Window -> SomeMessage -> X (Maybe (TopRightMaster Window)) #

handleMessOrMaybeModifyIt :: TopRightMaster Window -> SomeMessage -> X (Maybe (Either (TopRightMaster Window) SomeMessage)) #

pureMess :: TopRightMaster Window -> SomeMessage -> Maybe (TopRightMaster Window) #

redoLayout :: TopRightMaster Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (TopRightMaster Window)) #

pureModifier :: TopRightMaster Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (TopRightMaster Window)) #

hook :: TopRightMaster Window -> X () #

unhook :: TopRightMaster Window -> X () #

modifierDescription :: TopRightMaster Window -> String #

modifyDescription :: LayoutClass l Window => TopRightMaster Window -> l Window -> String #

LayoutModifier DraggingVisualizer Window # |

Instance details

Defined in XMonad.Layout.DraggingVisualizer

Methods

modifyLayout :: LayoutClass l Window => DraggingVisualizer Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => DraggingVisualizer Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (DraggingVisualizer Window)) #

handleMess :: DraggingVisualizer Window -> SomeMessage -> X (Maybe (DraggingVisualizer Window)) #

handleMessOrMaybeModifyIt :: DraggingVisualizer Window -> SomeMessage -> X (Maybe (Either (DraggingVisualizer Window) SomeMessage)) #

pureMess :: DraggingVisualizer Window -> SomeMessage -> Maybe (DraggingVisualizer Window) #

redoLayout :: DraggingVisualizer Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (DraggingVisualizer Window)) #

pureModifier :: DraggingVisualizer Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (DraggingVisualizer Window)) #

hook :: DraggingVisualizer Window -> X () #

unhook :: DraggingVisualizer Window -> X () #

modifierDescription :: DraggingVisualizer Window -> String #

modifyDescription :: LayoutClass l Window => DraggingVisualizer Window -> l Window -> String #

LayoutModifier FixedAspectRatio Window # |

Instance details

Defined in XMonad.Layout.FixedAspectRatio

Methods

modifyLayout :: LayoutClass l Window => FixedAspectRatio Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => FixedAspectRatio Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (FixedAspectRatio Window)) #

handleMess :: FixedAspectRatio Window -> SomeMessage -> X (Maybe (FixedAspectRatio Window)) #

handleMessOrMaybeModifyIt :: FixedAspectRatio Window -> SomeMessage -> X (Maybe (Either (FixedAspectRatio Window) SomeMessage)) #

pureMess :: FixedAspectRatio Window -> SomeMessage -> Maybe (FixedAspectRatio Window) #

redoLayout :: FixedAspectRatio Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (FixedAspectRatio Window)) #

pureModifier :: FixedAspectRatio Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (FixedAspectRatio Window)) #

hook :: FixedAspectRatio Window -> X () #

unhook :: FixedAspectRatio Window -> X () #

modifierDescription :: FixedAspectRatio Window -> String #

modifyDescription :: LayoutClass l Window => FixedAspectRatio Window -> l Window -> String #

LayoutModifier FullscreenFloat Window # |

Instance details

Defined in XMonad.Layout.Fullscreen

Methods

modifyLayout :: LayoutClass l Window => FullscreenFloat Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => FullscreenFloat Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (FullscreenFloat Window)) #

handleMess :: FullscreenFloat Window -> SomeMessage -> X (Maybe (FullscreenFloat Window)) #

handleMessOrMaybeModifyIt :: FullscreenFloat Window -> SomeMessage -> X (Maybe (Either (FullscreenFloat Window) SomeMessage)) #

pureMess :: FullscreenFloat Window -> SomeMessage -> Maybe (FullscreenFloat Window) #

redoLayout :: FullscreenFloat Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (FullscreenFloat Window)) #

pureModifier :: FullscreenFloat Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (FullscreenFloat Window)) #

hook :: FullscreenFloat Window -> X () #

unhook :: FullscreenFloat Window -> X () #

modifierDescription :: FullscreenFloat Window -> String #

modifyDescription :: LayoutClass l Window => FullscreenFloat Window -> l Window -> String #

LayoutModifier FullscreenFocus Window # |

Instance details

Defined in XMonad.Layout.Fullscreen

Methods

modifyLayout :: LayoutClass l Window => FullscreenFocus Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => FullscreenFocus Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (FullscreenFocus Window)) #

handleMess :: FullscreenFocus Window -> SomeMessage -> X (Maybe (FullscreenFocus Window)) #

handleMessOrMaybeModifyIt :: FullscreenFocus Window -> SomeMessage -> X (Maybe (Either (FullscreenFocus Window) SomeMessage)) #

pureMess :: FullscreenFocus Window -> SomeMessage -> Maybe (FullscreenFocus Window) #

redoLayout :: FullscreenFocus Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (FullscreenFocus Window)) #

pureModifier :: FullscreenFocus Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (FullscreenFocus Window)) #

hook :: FullscreenFocus Window -> X () #

unhook :: FullscreenFocus Window -> X () #

modifierDescription :: FullscreenFocus Window -> String #

modifyDescription :: LayoutClass l Window => FullscreenFocus Window -> l Window -> String #

LayoutModifier FullscreenFull Window # |

Instance details

Defined in XMonad.Layout.Fullscreen

Methods

modifyLayout :: LayoutClass l Window => FullscreenFull Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => FullscreenFull Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (FullscreenFull Window)) #

handleMess :: FullscreenFull Window -> SomeMessage -> X (Maybe (FullscreenFull Window)) #

handleMessOrMaybeModifyIt :: FullscreenFull Window -> SomeMessage -> X (Maybe (Either (FullscreenFull Window) SomeMessage)) #

pureMess :: FullscreenFull Window -> SomeMessage -> Maybe (FullscreenFull Window) #

redoLayout :: FullscreenFull Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (FullscreenFull Window)) #

pureModifier :: FullscreenFull Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (FullscreenFull Window)) #

hook :: FullscreenFull Window -> X () #

unhook :: FullscreenFull Window -> X () #

modifierDescription :: FullscreenFull Window -> String #

modifyDescription :: LayoutClass l Window => FullscreenFull Window -> l Window -> String #

LayoutModifier Gaps a # |

Instance details

Defined in XMonad.Layout.Gaps

Methods

modifyLayout :: LayoutClass l a => Gaps a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) #

modifyLayoutWithUpdate :: LayoutClass l a => Gaps a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (Gaps a)) #

handleMess :: Gaps a -> SomeMessage -> X (Maybe (Gaps a)) #

handleMessOrMaybeModifyIt :: Gaps a -> SomeMessage -> X (Maybe (Either (Gaps a) SomeMessage)) #

pureMess :: Gaps a -> SomeMessage -> Maybe (Gaps a) #

redoLayout :: Gaps a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (Gaps a)) #

pureModifier :: Gaps a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (Gaps a)) #

hook :: Gaps a -> X () #

unhook :: Gaps a -> X () #

modifierDescription :: Gaps a -> String #

modifyDescription :: LayoutClass l a => Gaps a -> l a -> String #

LayoutModifier HiddenWindows Window # |

Instance details

Defined in XMonad.Layout.Hidden

Methods

modifyLayout :: LayoutClass l Window => HiddenWindows Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => HiddenWindows Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (HiddenWindows Window)) #

handleMess :: HiddenWindows Window -> SomeMessage -> X (Maybe (HiddenWindows Window)) #

handleMessOrMaybeModifyIt :: HiddenWindows Window -> SomeMessage -> X (Maybe (Either (HiddenWindows Window) SomeMessage)) #

pureMess :: HiddenWindows Window -> SomeMessage -> Maybe (HiddenWindows Window) #

redoLayout :: HiddenWindows Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (HiddenWindows Window)) #

pureModifier :: HiddenWindows Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (HiddenWindows Window)) #

hook :: HiddenWindows Window -> X () #

unhook :: HiddenWindows Window -> X () #

modifierDescription :: HiddenWindows Window -> String #

modifyDescription :: LayoutClass l Window => HiddenWindows Window -> l Window -> String #

LayoutModifier AddRoster Window # |

Instance details

Defined in XMonad.Layout.IM

Methods

modifyLayout :: LayoutClass l Window => AddRoster Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => AddRoster Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (AddRoster Window)) #

handleMess :: AddRoster Window -> SomeMessage -> X (Maybe (AddRoster Window)) #

handleMessOrMaybeModifyIt :: AddRoster Window -> SomeMessage -> X (Maybe (Either (AddRoster Window) SomeMessage)) #

pureMess :: AddRoster Window -> SomeMessage -> Maybe (AddRoster Window) #

redoLayout :: AddRoster Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (AddRoster Window)) #

pureModifier :: AddRoster Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (AddRoster Window)) #

hook :: AddRoster Window -> X () #

unhook :: AddRoster Window -> X () #

modifierDescription :: AddRoster Window -> String #

modifyDescription :: LayoutClass l Window => AddRoster Window -> l Window -> String #

LayoutModifier LayoutHints Window # |

Instance details

Defined in XMonad.Layout.LayoutHints

Methods

modifyLayout :: LayoutClass l Window => LayoutHints Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => LayoutHints Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (LayoutHints Window)) #

handleMess :: LayoutHints Window -> SomeMessage -> X (Maybe (LayoutHints Window)) #

handleMessOrMaybeModifyIt :: LayoutHints Window -> SomeMessage -> X (Maybe (Either (LayoutHints Window) SomeMessage)) #

pureMess :: LayoutHints Window -> SomeMessage -> Maybe (LayoutHints Window) #

redoLayout :: LayoutHints Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (LayoutHints Window)) #

pureModifier :: LayoutHints Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (LayoutHints Window)) #

hook :: LayoutHints Window -> X () #

unhook :: LayoutHints Window -> X () #

modifierDescription :: LayoutHints Window -> String #

modifyDescription :: LayoutClass l Window => LayoutHints Window -> l Window -> String #

LayoutModifier LayoutHintsToCenter Window # |

Instance details

Defined in XMonad.Layout.LayoutHints

Methods

modifyLayout :: LayoutClass l Window => LayoutHintsToCenter Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => LayoutHintsToCenter Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (LayoutHintsToCenter Window)) #

handleMess :: LayoutHintsToCenter Window -> SomeMessage -> X (Maybe (LayoutHintsToCenter Window)) #

handleMessOrMaybeModifyIt :: LayoutHintsToCenter Window -> SomeMessage -> X (Maybe (Either (LayoutHintsToCenter Window) SomeMessage)) #

pureMess :: LayoutHintsToCenter Window -> SomeMessage -> Maybe (LayoutHintsToCenter Window) #

redoLayout :: LayoutHintsToCenter Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (LayoutHintsToCenter Window)) #

pureModifier :: LayoutHintsToCenter Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (LayoutHintsToCenter Window)) #

hook :: LayoutHintsToCenter Window -> X () #

unhook :: LayoutHintsToCenter Window -> X () #

modifierDescription :: LayoutHintsToCenter Window -> String #

modifyDescription :: LayoutClass l Window => LayoutHintsToCenter Window -> l Window -> String #

LayoutModifier LimitWindows a # |

Instance details

Defined in XMonad.Layout.LimitWindows

Methods

modifyLayout :: LayoutClass l a => LimitWindows a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) #

modifyLayoutWithUpdate :: LayoutClass l a => LimitWindows a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (LimitWindows a)) #

handleMess :: LimitWindows a -> SomeMessage -> X (Maybe (LimitWindows a)) #

handleMessOrMaybeModifyIt :: LimitWindows a -> SomeMessage -> X (Maybe (Either (LimitWindows a) SomeMessage)) #

pureMess :: LimitWindows a -> SomeMessage -> Maybe (LimitWindows a) #

redoLayout :: LimitWindows a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (LimitWindows a)) #

pureModifier :: LimitWindows a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (LimitWindows a)) #

hook :: LimitWindows a -> X () #

unhook :: LimitWindows a -> X () #

modifierDescription :: LimitWindows a -> String #

modifyDescription :: LayoutClass l a => LimitWindows a -> l a -> String #

LayoutModifier Selection a # |

Instance details

Defined in XMonad.Layout.LimitWindows

Methods

modifyLayout :: LayoutClass l a => Selection a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) #

modifyLayoutWithUpdate :: LayoutClass l a => Selection a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (Selection a)) #

handleMess :: Selection a -> SomeMessage -> X (Maybe (Selection a)) #

handleMessOrMaybeModifyIt :: Selection a -> SomeMessage -> X (Maybe (Either (Selection a) SomeMessage)) #

pureMess :: Selection a -> SomeMessage -> Maybe (Selection a) #

redoLayout :: Selection a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (Selection a)) #

pureModifier :: Selection a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (Selection a)) #

hook :: Selection a -> X () #

unhook :: Selection a -> X () #

modifierDescription :: Selection a -> String #

modifyDescription :: LayoutClass l a => Selection a -> l a -> String #

LayoutModifier MagicFocus Window # |

Instance details

Defined in XMonad.Layout.MagicFocus

Methods

modifyLayout :: LayoutClass l Window => MagicFocus Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => MagicFocus Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (MagicFocus Window)) #

handleMess :: MagicFocus Window -> SomeMessage -> X (Maybe (MagicFocus Window)) #

handleMessOrMaybeModifyIt :: MagicFocus Window -> SomeMessage -> X (Maybe (Either (MagicFocus Window) SomeMessage)) #

pureMess :: MagicFocus Window -> SomeMessage -> Maybe (MagicFocus Window) #

redoLayout :: MagicFocus Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (MagicFocus Window)) #

pureModifier :: MagicFocus Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (MagicFocus Window)) #

hook :: MagicFocus Window -> X () #

unhook :: MagicFocus Window -> X () #

modifierDescription :: MagicFocus Window -> String #

modifyDescription :: LayoutClass l Window => MagicFocus Window -> l Window -> String #

LayoutModifier Magnifier Window # |

Instance details

Defined in XMonad.Layout.Magnifier

Methods

modifyLayout :: LayoutClass l Window => Magnifier Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => Magnifier Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (Magnifier Window)) #

handleMess :: Magnifier Window -> SomeMessage -> X (Maybe (Magnifier Window)) #

handleMessOrMaybeModifyIt :: Magnifier Window -> SomeMessage -> X (Maybe (Either (Magnifier Window) SomeMessage)) #

pureMess :: Magnifier Window -> SomeMessage -> Maybe (Magnifier Window) #

redoLayout :: Magnifier Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (Magnifier Window)) #

pureModifier :: Magnifier Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (Magnifier Window)) #

hook :: Magnifier Window -> X () #

unhook :: Magnifier Window -> X () #

modifierDescription :: Magnifier Window -> String #

modifyDescription :: LayoutClass l Window => Magnifier Window -> l Window -> String #

LayoutModifier AddMaster Window # |

Instance details

Defined in XMonad.Layout.Master

Methods

modifyLayout :: LayoutClass l Window => AddMaster Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => AddMaster Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (AddMaster Window)) #

handleMess :: AddMaster Window -> SomeMessage -> X (Maybe (AddMaster Window)) #

handleMessOrMaybeModifyIt :: AddMaster Window -> SomeMessage -> X (Maybe (Either (AddMaster Window) SomeMessage)) #

pureMess :: AddMaster Window -> SomeMessage -> Maybe (AddMaster Window) #

redoLayout :: AddMaster Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (AddMaster Window)) #

pureModifier :: AddMaster Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (AddMaster Window)) #

hook :: AddMaster Window -> X () #

unhook :: AddMaster Window -> X () #

modifierDescription :: AddMaster Window -> String #

modifyDescription :: LayoutClass l Window => AddMaster Window -> l Window -> String #

LayoutModifier Maximize Window # |

Instance details

Defined in XMonad.Layout.Maximize

Methods

modifyLayout :: LayoutClass l Window => Maximize Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => Maximize Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (Maximize Window)) #

handleMess :: Maximize Window -> SomeMessage -> X (Maybe (Maximize Window)) #

handleMessOrMaybeModifyIt :: Maximize Window -> SomeMessage -> X (Maybe (Either (Maximize Window) SomeMessage)) #

pureMess :: Maximize Window -> SomeMessage -> Maybe (Maximize Window) #

redoLayout :: Maximize Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (Maximize Window)) #

pureModifier :: Maximize Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (Maximize Window)) #

hook :: Maximize Window -> X () #

unhook :: Maximize Window -> X () #

modifierDescription :: Maximize Window -> String #

modifyDescription :: LayoutClass l Window => Maximize Window -> l Window -> String #

LayoutModifier UnEscape a # |

Instance details

Defined in XMonad.Layout.MessageControl

Methods

modifyLayout :: LayoutClass l a => UnEscape a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) #

modifyLayoutWithUpdate :: LayoutClass l a => UnEscape a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (UnEscape a)) #

handleMess :: UnEscape a -> SomeMessage -> X (Maybe (UnEscape a)) #

handleMessOrMaybeModifyIt :: UnEscape a -> SomeMessage -> X (Maybe (Either (UnEscape a) SomeMessage)) #

pureMess :: UnEscape a -> SomeMessage -> Maybe (UnEscape a) #

redoLayout :: UnEscape a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (UnEscape a)) #

pureModifier :: UnEscape a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (UnEscape a)) #

hook :: UnEscape a -> X () #

unhook :: UnEscape a -> X () #

modifierDescription :: UnEscape a -> String #

modifyDescription :: LayoutClass l a => UnEscape a -> l a -> String #

LayoutModifier Minimize Window # |

Instance details

Defined in XMonad.Layout.Minimize

Methods

modifyLayout :: LayoutClass l Window => Minimize Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => Minimize Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (Minimize Window)) #

handleMess :: Minimize Window -> SomeMessage -> X (Maybe (Minimize Window)) #

handleMessOrMaybeModifyIt :: Minimize Window -> SomeMessage -> X (Maybe (Either (Minimize Window) SomeMessage)) #

pureMess :: Minimize Window -> SomeMessage -> Maybe (Minimize Window) #

redoLayout :: Minimize Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (Minimize Window)) #

pureModifier :: Minimize Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (Minimize Window)) #

hook :: Minimize Window -> X () #

unhook :: Minimize Window -> X () #

modifierDescription :: Minimize Window -> String #

modifyDescription :: LayoutClass l Window => Minimize Window -> l Window -> String #

LayoutModifier Monitor Window # |

Instance details

Defined in XMonad.Layout.Monitor

Methods

modifyLayout :: LayoutClass l Window => Monitor Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => Monitor Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (Monitor Window)) #

handleMess :: Monitor Window -> SomeMessage -> X (Maybe (Monitor Window)) #

handleMessOrMaybeModifyIt :: Monitor Window -> SomeMessage -> X (Maybe (Either (Monitor Window) SomeMessage)) #

pureMess :: Monitor Window -> SomeMessage -> Maybe (Monitor Window) #

redoLayout :: Monitor Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (Monitor Window)) #

pureModifier :: Monitor Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (Monitor Window)) #

hook :: Monitor Window -> X () #

unhook :: Monitor Window -> X () #

modifierDescription :: Monitor Window -> String #

modifyDescription :: LayoutClass l Window => Monitor Window -> l Window -> String #

LayoutModifier WithBorder Window # |

Instance details

Defined in XMonad.Layout.NoBorders

Methods

modifyLayout :: LayoutClass l Window => WithBorder Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => WithBorder Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (WithBorder Window)) #

handleMess :: WithBorder Window -> SomeMessage -> X (Maybe (WithBorder Window)) #

handleMessOrMaybeModifyIt :: WithBorder Window -> SomeMessage -> X (Maybe (Either (WithBorder Window) SomeMessage)) #

pureMess :: WithBorder Window -> SomeMessage -> Maybe (WithBorder Window) #

redoLayout :: WithBorder Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (WithBorder Window)) #

pureModifier :: WithBorder Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (WithBorder Window)) #

hook :: WithBorder Window -> X () #

unhook :: WithBorder Window -> X () #

modifierDescription :: WithBorder Window -> String #

modifyDescription :: LayoutClass l Window => WithBorder Window -> l Window -> String #

LayoutModifier Reflect a # |

Instance details

Defined in XMonad.Layout.Reflect

Methods

modifyLayout :: LayoutClass l a => Reflect a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) #

modifyLayoutWithUpdate :: LayoutClass l a => Reflect a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (Reflect a)) #

handleMess :: Reflect a -> SomeMessage -> X (Maybe (Reflect a)) #

handleMessOrMaybeModifyIt :: Reflect a -> SomeMessage -> X (Maybe (Either (Reflect a) SomeMessage)) #

pureMess :: Reflect a -> SomeMessage -> Maybe (Reflect a) #

redoLayout :: Reflect a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (Reflect a)) #

pureModifier :: Reflect a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (Reflect a)) #

hook :: Reflect a -> X () #

unhook :: Reflect a -> X () #

modifierDescription :: Reflect a -> String #

modifyDescription :: LayoutClass l a => Reflect a -> l a -> String #

LayoutModifier Rename a # |

Instance details

Defined in XMonad.Layout.Renamed

Methods

modifyLayout :: LayoutClass l a => Rename a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) #

modifyLayoutWithUpdate :: LayoutClass l a => Rename a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (Rename a)) #

handleMess :: Rename a -> SomeMessage -> X (Maybe (Rename a)) #

handleMessOrMaybeModifyIt :: Rename a -> SomeMessage -> X (Maybe (Either (Rename a) SomeMessage)) #

pureMess :: Rename a -> SomeMessage -> Maybe (Rename a) #

redoLayout :: Rename a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (Rename a)) #

pureModifier :: Rename a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (Rename a)) #

hook :: Rename a -> X () #

unhook :: Rename a -> X () #

modifierDescription :: Rename a -> String #

modifyDescription :: LayoutClass l a => Rename a -> l a -> String #

LayoutModifier ResizeScreen a # |

Instance details

Defined in XMonad.Layout.ResizeScreen

Methods

modifyLayout :: LayoutClass l a => ResizeScreen a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) #

modifyLayoutWithUpdate :: LayoutClass l a => ResizeScreen a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (ResizeScreen a)) #

handleMess :: ResizeScreen a -> SomeMessage -> X (Maybe (ResizeScreen a)) #

handleMessOrMaybeModifyIt :: ResizeScreen a -> SomeMessage -> X (Maybe (Either (ResizeScreen a) SomeMessage)) #

pureMess :: ResizeScreen a -> SomeMessage -> Maybe (ResizeScreen a) #

redoLayout :: ResizeScreen a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (ResizeScreen a)) #

pureModifier :: ResizeScreen a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (ResizeScreen a)) #

hook :: ResizeScreen a -> X () #

unhook :: ResizeScreen a -> X () #

modifierDescription :: ResizeScreen a -> String #

modifyDescription :: LayoutClass l a => ResizeScreen a -> l a -> String #

LayoutModifier ShowWName a # |

Instance details

Defined in XMonad.Layout.ShowWName

Methods

modifyLayout :: LayoutClass l a => ShowWName a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) #

modifyLayoutWithUpdate :: LayoutClass l a => ShowWName a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (ShowWName a)) #

handleMess :: ShowWName a -> SomeMessage -> X (Maybe (ShowWName a)) #

handleMessOrMaybeModifyIt :: ShowWName a -> SomeMessage -> X (Maybe (Either (ShowWName a) SomeMessage)) #

pureMess :: ShowWName a -> SomeMessage -> Maybe (ShowWName a) #

redoLayout :: ShowWName a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (ShowWName a)) #

pureModifier :: ShowWName a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (ShowWName a)) #

hook :: ShowWName a -> X () #

unhook :: ShowWName a -> X () #

modifierDescription :: ShowWName a -> String #

modifyDescription :: LayoutClass l a => ShowWName a -> l a -> String #

Eq a => LayoutModifier Spacing a # |

Instance details

Defined in XMonad.Layout.Spacing

Methods

modifyLayout :: LayoutClass l a => Spacing a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) #

modifyLayoutWithUpdate :: LayoutClass l a => Spacing a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (Spacing a)) #

handleMess :: Spacing a -> SomeMessage -> X (Maybe (Spacing a)) #

handleMessOrMaybeModifyIt :: Spacing a -> SomeMessage -> X (Maybe (Either (Spacing a) SomeMessage)) #

pureMess :: Spacing a -> SomeMessage -> Maybe (Spacing a) #

redoLayout :: Spacing a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (Spacing a)) #

pureModifier :: Spacing a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (Spacing a)) #

hook :: Spacing a -> X () #

unhook :: Spacing a -> X () #

modifierDescription :: Spacing a -> String #

modifyDescription :: LayoutClass l a => Spacing a -> l a -> String #

LayoutModifier Stoppable Window # |

Instance details

Defined in XMonad.Layout.Stoppable

Methods

modifyLayout :: LayoutClass l Window => Stoppable Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => Stoppable Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (Stoppable Window)) #

handleMess :: Stoppable Window -> SomeMessage -> X (Maybe (Stoppable Window)) #

handleMessOrMaybeModifyIt :: Stoppable Window -> SomeMessage -> X (Maybe (Either (Stoppable Window) SomeMessage)) #

pureMess :: Stoppable Window -> SomeMessage -> Maybe (Stoppable Window) #

redoLayout :: Stoppable Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (Stoppable Window)) #

pureModifier :: Stoppable Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (Stoppable Window)) #

hook :: Stoppable Window -> X () #

unhook :: Stoppable Window -> X () #

modifierDescription :: Stoppable Window -> String #

modifyDescription :: LayoutClass l Window => Stoppable Window -> l Window -> String #

LayoutModifier TrackFloating Window # |

Instance details

Defined in XMonad.Layout.TrackFloating

Methods

modifyLayout :: LayoutClass l Window => TrackFloating Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => TrackFloating Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (TrackFloating Window)) #

handleMess :: TrackFloating Window -> SomeMessage -> X (Maybe (TrackFloating Window)) #

handleMessOrMaybeModifyIt :: TrackFloating Window -> SomeMessage -> X (Maybe (Either (TrackFloating Window) SomeMessage)) #

pureMess :: TrackFloating Window -> SomeMessage -> Maybe (TrackFloating Window) #

redoLayout :: TrackFloating Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (TrackFloating Window)) #

pureModifier :: TrackFloating Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (TrackFloating Window)) #

hook :: TrackFloating Window -> X () #

unhook :: TrackFloating Window -> X () #

modifierDescription :: TrackFloating Window -> String #

modifyDescription :: LayoutClass l Window => TrackFloating Window -> l Window -> String #

LayoutModifier UseTransientFor Window # |

Instance details

Defined in XMonad.Layout.TrackFloating

Methods

modifyLayout :: LayoutClass l Window => UseTransientFor Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => UseTransientFor Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (UseTransientFor Window)) #

handleMess :: UseTransientFor Window -> SomeMessage -> X (Maybe (UseTransientFor Window)) #

handleMessOrMaybeModifyIt :: UseTransientFor Window -> SomeMessage -> X (Maybe (Either (UseTransientFor Window) SomeMessage)) #

pureMess :: UseTransientFor Window -> SomeMessage -> Maybe (UseTransientFor Window) #

redoLayout :: UseTransientFor Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (UseTransientFor Window)) #

pureModifier :: UseTransientFor Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (UseTransientFor Window)) #

hook :: UseTransientFor Window -> X () #

unhook :: UseTransientFor Window -> X () #

modifierDescription :: UseTransientFor Window -> String #

modifyDescription :: LayoutClass l Window => UseTransientFor Window -> l Window -> String #

(Show a, Read a, Eq a) => LayoutModifier WindowArranger a # |

Instance details

Defined in XMonad.Layout.WindowArranger

Methods

modifyLayout :: LayoutClass l a => WindowArranger a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) #

modifyLayoutWithUpdate :: LayoutClass l a => WindowArranger a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (WindowArranger a)) #

handleMess :: WindowArranger a -> SomeMessage -> X (Maybe (WindowArranger a)) #

handleMessOrMaybeModifyIt :: WindowArranger a -> SomeMessage -> X (Maybe (Either (WindowArranger a) SomeMessage)) #

pureMess :: WindowArranger a -> SomeMessage -> Maybe (WindowArranger a) #

redoLayout :: WindowArranger a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (WindowArranger a)) #

pureModifier :: WindowArranger a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (WindowArranger a)) #

hook :: WindowArranger a -> X () #

unhook :: WindowArranger a -> X () #

modifierDescription :: WindowArranger a -> String #

modifyDescription :: LayoutClass l a => WindowArranger a -> l a -> String #

LayoutModifier WindowNavigation Window # |

Instance details

Defined in XMonad.Layout.WindowNavigation

Methods

modifyLayout :: LayoutClass l Window => WindowNavigation Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => WindowNavigation Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (WindowNavigation Window)) #

handleMess :: WindowNavigation Window -> SomeMessage -> X (Maybe (WindowNavigation Window)) #

handleMessOrMaybeModifyIt :: WindowNavigation Window -> SomeMessage -> X (Maybe (Either (WindowNavigation Window) SomeMessage)) #

pureMess :: WindowNavigation Window -> SomeMessage -> Maybe (WindowNavigation Window) #

redoLayout :: WindowNavigation Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (WindowNavigation Window)) #

pureModifier :: WindowNavigation Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (WindowNavigation Window)) #

hook :: WindowNavigation Window -> X () #

unhook :: WindowNavigation Window -> X () #

modifierDescription :: WindowNavigation Window -> String #

modifyDescription :: LayoutClass l Window => WindowNavigation Window -> l Window -> String #

LayoutModifier WorkspaceDir Window # |

Instance details

Defined in XMonad.Layout.WorkspaceDir

Methods

modifyLayout :: LayoutClass l Window => WorkspaceDir Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => WorkspaceDir Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (WorkspaceDir Window)) #

handleMess :: WorkspaceDir Window -> SomeMessage -> X (Maybe (WorkspaceDir Window)) #

handleMessOrMaybeModifyIt :: WorkspaceDir Window -> SomeMessage -> X (Maybe (Either (WorkspaceDir Window) SomeMessage)) #

pureMess :: WorkspaceDir Window -> SomeMessage -> Maybe (WorkspaceDir Window) #

redoLayout :: WorkspaceDir Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (WorkspaceDir Window)) #

pureModifier :: WorkspaceDir Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (WorkspaceDir Window)) #

hook :: WorkspaceDir Window -> X () #

unhook :: WorkspaceDir Window -> X () #

modifierDescription :: WorkspaceDir Window -> String #

modifyDescription :: LayoutClass l Window => WorkspaceDir Window -> l Window -> String #

(LayoutClass l Window, Read (l Window)) => LayoutModifier (Drawer l) Window # |

Instance details

Defined in XMonad.Layout.Drawer

Methods

modifyLayout :: LayoutClass l0 Window => Drawer l Window -> Workspace WorkspaceId (l0 Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l0 Window)) #

modifyLayoutWithUpdate :: LayoutClass l0 Window => Drawer l Window -> Workspace WorkspaceId (l0 Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l0 Window)), Maybe (Drawer l Window)) #

handleMess :: Drawer l Window -> SomeMessage -> X (Maybe (Drawer l Window)) #

handleMessOrMaybeModifyIt :: Drawer l Window -> SomeMessage -> X (Maybe (Either (Drawer l Window) SomeMessage)) #

pureMess :: Drawer l Window -> SomeMessage -> Maybe (Drawer l Window) #

redoLayout :: Drawer l Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (Drawer l Window)) #

pureModifier :: Drawer l Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (Drawer l Window)) #

hook :: Drawer l Window -> X () #

unhook :: Drawer l Window -> X () #

modifierDescription :: Drawer l Window -> String #

modifyDescription :: LayoutClass l0 Window => Drawer l Window -> l0 Window -> String #

(Read p, Show p, SetsAmbiguous p) => LayoutModifier (ConfigurableBorder p) Window # |

Instance details

Defined in XMonad.Layout.NoBorders

Methods

modifyLayout :: LayoutClass l Window => ConfigurableBorder p Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => ConfigurableBorder p Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (ConfigurableBorder p Window)) #

handleMess :: ConfigurableBorder p Window -> SomeMessage -> X (Maybe (ConfigurableBorder p Window)) #

handleMessOrMaybeModifyIt :: ConfigurableBorder p Window -> SomeMessage -> X (Maybe (Either (ConfigurableBorder p Window) SomeMessage)) #

pureMess :: ConfigurableBorder p Window -> SomeMessage -> Maybe (ConfigurableBorder p Window) #

redoLayout :: ConfigurableBorder p Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (ConfigurableBorder p Window)) #

pureModifier :: ConfigurableBorder p Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (ConfigurableBorder p Window)) #

hook :: ConfigurableBorder p Window -> X () #

unhook :: ConfigurableBorder p Window -> X () #

modifierDescription :: ConfigurableBorder p Window -> String #

modifyDescription :: LayoutClass l Window => ConfigurableBorder p Window -> l Window -> String #

(Read (l Window), Show (l Window), LayoutClass l Window) => LayoutModifier (Sublayout l) Window # |

Instance details

Defined in XMonad.Layout.SubLayouts

Methods

modifyLayout :: LayoutClass l0 Window => Sublayout l Window -> Workspace WorkspaceId (l0 Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l0 Window)) #

modifyLayoutWithUpdate :: LayoutClass l0 Window => Sublayout l Window -> Workspace WorkspaceId (l0 Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l0 Window)), Maybe (Sublayout l Window)) #

handleMess :: Sublayout l Window -> SomeMessage -> X (Maybe (Sublayout l Window)) #

handleMessOrMaybeModifyIt :: Sublayout l Window -> SomeMessage -> X (Maybe (Either (Sublayout l Window) SomeMessage)) #

pureMess :: Sublayout l Window -> SomeMessage -> Maybe (Sublayout l Window) #

redoLayout :: Sublayout l Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (Sublayout l Window)) #

pureModifier :: Sublayout l Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (Sublayout l Window)) #

hook :: Sublayout l Window -> X () #

unhook :: Sublayout l Window -> X () #

modifierDescription :: Sublayout l Window -> String #

modifyDescription :: LayoutClass l0 Window => Sublayout l Window -> l0 Window -> String #

(DecorationStyle ds Window, Shrinker s) => LayoutModifier (Decoration ds s) Window #

The long `LayoutModifier` instance for the `Decoration` type.

In `redoLayout` we check the state: if there is no state we initialize it.

The state is `diff`ed against the list of windows produced by the underlying layout: removed windows get deleted and new ones decorated by `createDecos`, which will call `decorate` to decide if a window must be given a `Rectangle`, in which case a decoration window will be created.

After that we resync the updated state with the windows' list and then we process the resynced stated (as we do with a new state).

First we map the decoration windows, we update each decoration to reflect any decorated window's change, and we insert, in the list of windows and rectangles returned by the underlying layout, the decoration for each window. This way xmonad will restack the decorations and their windows accordingly. At the end we remove invisible/stacked windows.

Message handling is quite simple: when needed we release the state component of the `Decoration` `LayoutModifier`. Otherwise we call `handleEvent`, which will call the appropriate `DecorationStyle` methods to perform its tasks.

Instance details

Defined in XMonad.Layout.Decoration

Methods

modifyLayout :: LayoutClass l Window => Decoration ds s Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) #

modifyLayoutWithUpdate :: LayoutClass l Window => Decoration ds s Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (Decoration ds s Window)) #

handleMess :: Decoration ds s Window -> SomeMessage -> X (Maybe (Decoration ds s Window)) #

handleMessOrMaybeModifyIt :: Decoration ds s Window -> SomeMessage -> X (Maybe (Either (Decoration ds s Window) SomeMessage)) #

pureMess :: Decoration ds s Window -> SomeMessage -> Maybe (Decoration ds s Window) #

redoLayout :: Decoration ds s Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (Decoration ds s Window)) #

pureModifier :: Decoration ds s Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (Decoration ds s Window)) #

hook :: Decoration ds s Window -> X () #

unhook :: Decoration ds s Window -> X () #

modifierDescription :: Decoration ds s Window -> String #

modifyDescription :: LayoutClass l Window => Decoration ds s Window -> l Window -> String #

data ModifiedLayout m l a #

A `ModifiedLayout` is simply a container for a layout modifier combined with an underlying layout. It is, of course, itself a layout (i.e. an instance of `LayoutClass`).

Constructors

ModifiedLayout (m a) (l a) |

#### Instances

Instances details

(LayoutModifier m a, LayoutClass l a, Typeable m) => LayoutClass (ModifiedLayout m l) a # | The `LayoutClass` instance for a `ModifiedLayout` defines the semantics of a `LayoutModifier` applied to an underlying layout.

Instance details

Defined in XMonad.Layout.LayoutModifier

Methods

runLayout :: Workspace WorkspaceId (ModifiedLayout m l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (ModifiedLayout m l a)) #

doLayout :: ModifiedLayout m l a -> Rectangle -> Stack a -> X ([(a, Rectangle)], Maybe (ModifiedLayout m l a)) #

pureLayout :: ModifiedLayout m l a -> Rectangle -> Stack a -> [(a, Rectangle)] #

emptyLayout :: ModifiedLayout m l a -> Rectangle -> X ([(a, Rectangle)], Maybe (ModifiedLayout m l a)) #

handleMessage :: ModifiedLayout m l a -> SomeMessage -> X (Maybe (ModifiedLayout m l a)) #

pureMessage :: ModifiedLayout m l a -> SomeMessage -> Maybe (ModifiedLayout m l a) #

description :: ModifiedLayout m l a -> String #

(Read (m a), Read (l a)) => Read (ModifiedLayout m l a) # |
Instance details Defined in XMonad.Layout.LayoutModifier Methods readsPrec :: Int -> ReadS (ModifiedLayout m l a) # readList :: ReadS [ModifiedLayout m l a] # readPrec :: ReadPrec (ModifiedLayout m l a) readListPrec :: ReadPrec [ModifiedLayout m l a]
(Show (m a), Show (l a)) => Show (ModifiedLayout m l a) # |
Instance details Defined in XMonad.Layout.LayoutModifier Methods showsPrec :: Int -> ModifiedLayout m l a -> ShowS # show :: ModifiedLayout m l a -> String # showList :: [ModifiedLayout m l a] -> ShowS #