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

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

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

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

Methods

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

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

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

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

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

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 :: m a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (m a)) Source #

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 :: m a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (m a)) Source #

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

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

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

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.DynamicLog user).

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

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

Window)), May4.9.0.2 href="XMonad-Layout-LayoutModifier.html#t:La:LayoutHintsToCentef="file:///usr/share/doc/libghc-xmonad-doc/html/XMonad-Core.html#t:X">Xout-LayoutModifier.html#line-145" class="link">Source #Window, Maybe e/doctml/XMonad-StackSet.html#t:Stack">Stack Window)), May4.>.0."#v:pureMess">pureMess ::

#String X () #String May4.>.0."#v:pureMess">pureMess :: #

Source

#

pureMess :: #

#

pef="="link">Source

Window) href="file:///usr/share/doc/html#t:Gaps">Gaps a -> X () X#

#

hef="="link">Source

RectangleWorkspaceId (l Source

X () XWindow) href="file:///usr/share/doc/html#t:Gaps">Gaps a -> RectangleWorkspaceId (l Source

X () XWindow) href="file:///usr/share/doc/html#t:Gaps">Gaps a -> X (S.html#t:WorkspaceId">WorkspaceId (l a) a -> #

pureMess :: Window -> WorkspaceId (l a) a -> RectangleWorkspaceId (l Source

X () XWindow) href="file:///">#

modifierDescription.html#handibghyoutModifier.html#handleMess" class="link">Source

Window, Rectangle)]share/doc/libghc-x11-doc/html/Graphics-X11-Types.html#t:Window">Window)), May4.9.0.0/Daries/base-4.9.0.0/Data-Maybe.htm><.1n">modifierDescription.html#handibghyoutModifier.html#handleMess" class="link">Source

Window, Rectangle)]share/doc/libghc-x11-doc/html/Grap-doc/htmref="file:///usr/share/doc/libghc-x11-doc/html/Graphics-X11-Xl class="link">Source<11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle class="link">Source< 1href="file:///usr/shshare/ics-X11-Types.html#t:Window">Window, Rectangle)]share/doc/libghc-x11-doc/html/Graphics-X11-Types.html#t:Window">Window)), May4.9.0.0/Daries/base-4.9.0h0/Data-Maybe.htm><.1n">modifierDescription.html#handibghyoutModifier.html#handleMess" class="link">Source

Window, Rectangle)]share/doc/libghc-x11-doc/html/Grap-doc/htmref="file:///usr/share/doc/libghc-x11-doc/html/Graphics-X11-Xl class="link">Source<11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle class="link">Source< 1href="file:///usr/shshare/ics-X11-Types.html#t:Window">Window, Rectangle)]share/doc/liypes.html#t:Window">Window Source<11-doc/htad-Layout-Gaps.html#t:Gaps">Gaps a)) Source Rectangle)]share/doc/liypes.html#t:Window">Window Source<11-doc/htad-Layout-Gaps.html#t:Gaps">Gaps a)) Source Rectangle)]shodifierDescription">modifierDescription :: Snn11-Types.hut-LayoutModifice #

Source<11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle cla///usr/share/doc/libghc-xmonad-doc/html/XMonad-Core.html#t:X">X () XWindow) href="file:///">#

modifierDescription :: Maybe (Either (<modifierDescription :: Workspas.h/share/doc/ef="src/XMonad-Layout-LayoutModifier.html#unhook" class="link">Source<11-doc/html/Gr="self="file:///usr/share/doc/libghc-x11-doc/html/Graphics-X11-Xl class="link">S-doc/html/Graphics-X11-Types.html#t:Window">Window, WindowNavigationXout-LayoutpaceId">Workspas.h/share/doc/ef="src/XMonad-Layout-LayoutModifier.html#unhook" class="linption">modifierDescription :: Source<11-doc/html/Gr="self="file:///usr/share/doc/libghc-x11-dlass="link">S-doc/html/Graphics-X11-Types.html#t:Window">Window,

pureMess :: #

#

pef="="link">Source

W.html#t:Rectangle">Rectangle -> Source#pureMes href="XMonad-Layout-Magnifie#

W.html#t:Rectangle">Rectangle -> String May4.>.0."#v:pureMess">pureMess :: #

X ([(a, Source #pureMes href="XMonad-Layoutdoc/libghc-x11-doc/html/Graphics-X11-Types.hcs-e/doc/ghc-doc/html/libraries/base-4.9.0.0/Data-Maybe.html#t:Maybec"/libghhtml 1Window">W.html#t:Rectangle">Rectangle -> String pureMess :: LayoutClass l1 a, LayoutClass l2 a) => l1 a -> u2 a -> CombineTwo (DragPane ()) l1 l2 a infixr 6

#String Rectangle)], String Rectangle)], String R> :: Rectangle)], String handleMess :: LayoutHintsToCenter Window -> pureMess :: LayoutHintsToCenter WindowSource#pureMes href="XMonad-Layout-Magnifie#

W.html#t:Rectangle">Rectangle -> Window) #

pureMes href="XMonad-Layout-Magnifie#

String #Window)), Rectangle)], unhook :: Sou/usr/shaMes hrindow"/html/Graphics-X11-Types.hcs-e/doc/ghc-doc/html/libraries/base-4.9.0.0/Data-Maybout-Magnifie #

X (

String#Window)), Rectib-Types.html#t:Rectangle">Rectangle)], String Gaps a -> XayoutModifier.html#m

Rectangle -> SourceString StringRectangle)]share/doc/libghc-x11-doc/html/Graphics-X11-Types.html#t:Window">Window)), May4.9.0.0/Da/Graphics-X11-Xlib-Types.html#t:Rectangle">Rectangle)]share/doc/libghc-x11-doc/html/Graphics-X11-Types.html#t:Window">Window)), May4.9t-LayoutHc/libga> :: Source< 1href="file:///usr/shshare/ics-X11-Types.html#t:Window">Window, Gaps () Set.html#:Workspace">Workspace #difier.html#t:ModifiedLayout">ModifiedLayout May4.9.0.2 href="XMonad-Layout-LayoutModifier.htmhc-xmonad-doc/html/XMonad-Core.html#t:X">X () Maybe (GapsGaps () Set.html#:Workspace">Workspace nad-Layout-LayoutModifier.html#line-145" class="link">Source #

LayoutModifier WithBorder Window Source #
Methods modifyLayout :: LayoutClass l Window => WithBorder Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => WithBorder Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (WithBorder Window)) Source # handleMess :: WithBorder Window -> SomeMessage -> X (Maybe (WithBorder Window)) Source # handleMessOrMaybeModifyIt :: WithBorder Window -> SomeMessage -> X (Maybe (Either (WithBorder Window) SomeMessage)) Source # pureMess :: WithBorder Window -> SomeMessage -> Maybe (WithBorder Window) Source # redoLayout :: WithBorder Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (WithBorder Window)) Source # pureModifier :: WithBorder Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (WithBorder Window)) Source # hook :: WithBorder Window -> X () Source # unhook :: WithBorder Window -> X () Source # modifierDescription :: WithBorder Window -> String Source # modifyDescription :: LayoutClass l Window => WithBorder Window -> l Window -> String Source #
LayoutModifier BoringWindows Window Source #
Methods modifyLayout :: LayoutClass l Window => BoringWindows Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => BoringWindows Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (BoringWindows Window)) Source # handleMess :: BoringWindows Window -> SomeMessage -> X (Maybe (BoringWindows Window)) Source # handleMessOrMaybeModifyIt :: BoringWindows Window -> SomeMessage -> X (Maybe (Either (BoringWindows Window) SomeMessage)) Source # pureMess :: BoringWindows Window -> SomeMessage -> Maybe (BoringWindows Window) Source # redoLayout :: BoringWindows Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (BoringWindows Window)) Source # pureModifier :: BoringWindows Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (BoringWindows Window)) Source # hook :: BoringWindows Window -> X () Source # unhook :: BoringWindows Window -> X () Source # modifierDescription :: BoringWindows Window -> String Source # modifyDescription :: LayoutClass l Window => BoringWindows Window -> l Window -> String Source #
LayoutModifier DraggingVisualizer Window Source #
Methods modifyLayout :: LayoutClass l Window => DraggingVisualizer Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => DraggingVisualizer Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (DraggingVisualizer Window)) Source # handleMess :: DraggingVisualizer Window -> SomeMessage -> X (Maybe (DraggingVisualizer Window)) Source # handleMessOrMaybeModifyIt :: DraggingVisualizer Window -> SomeMessage -> X (Maybe (Either (DraggingVisualizer Window) SomeMessage)) Source # pureMess :: DraggingVisualizer Window -> SomeMessage -> Maybe (DraggingVisualizer Window) Source # redoLayout :: DraggingVisualizer Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (DraggingVisualizer Window)) Source # pureModifier :: DraggingVisualizer Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (DraggingVisualizer Window)) Source # hook :: DraggingVisualizer Window -> X () Source # unhook :: DraggingVisualizer Window -> X () Source # modifierDescription :: DraggingVisualizer Window -> String Source # modifyDescription :: LayoutClass l Window => DraggingVisualizer Window -> l Window -> String Source #
Eq w => LayoutModifier AutoMaster w Source #
Methods modifyLayout :: LayoutClass l w => AutoMaster w -> Workspace WorkspaceId (l w) w -> Rectangle -> X ([(w, Rectangle)], Maybe (l w)) Source # modifyLayoutWithUpdate :: LayoutClass l w => AutoMaster w -> Workspace WorkspaceId (l w) w -> Rectangle -> X (([(w, Rectangle)], Maybe (l w)), Maybe (AutoMaster w)) Source # handleMess :: AutoMaster w -> SomeMessage -> X (Maybe (AutoMaster w)) Source # handleMessOrMaybeModifyIt :: AutoMaster w -> SomeMessage -> X (Maybe (Either (AutoMaster w) SomeMessage)) Source # pureMess :: AutoMaster w -> SomeMessage -> Maybe (AutoMaster w) Source # redoLayout :: AutoMaster w -> Rectangle -> Maybe (Stack w) -> [(w, Rectangle)] -> X ([(w, Rectangle)], Maybe (AutoMaster w)) Source # pureModifier :: AutoMaster w -> Rectangle -> Maybe (Stack w) -> [(w, Rectangle)] -> ([(w, Rectangle)], Maybe (AutoMaster w)) Source # hook :: AutoMaster w -> X () Source # unhook :: AutoMaster w -> X () Source # modifierDescription :: AutoMaster w -> String Source # modifyDescription :: LayoutClass l w => AutoMaster w -> l w -> String Source #
LayoutModifier TopRightMaster Window Source #
Methods modifyLayout :: LayoutClass l Window => TopRightMaster Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => TopRightMaster Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (TopRightMaster Window)) Source # handleMess :: TopRightMaster Window -> SomeMessage -> X (Maybe (TopRightMaster Window)) Source # handleMessOrMaybeModifyIt :: TopRightMaster Window -> SomeMessage -> X (Maybe (Either (TopRightMaster Window) SomeMessage)) Source # pureMess :: TopRightMaster Window -> SomeMessage -> Maybe (TopRightMaster Window) Source # redoLayout :: TopRightMaster Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (TopRightMaster Window)) Source # pureModifier :: TopRightMaster Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (TopRightMaster Window)) Source # hook :: TopRightMaster Window -> X () Source # unhook :: TopRightMaster Window -> X () Source # modifierDescription :: TopRightMaster Window -> String Source # modifyDescription :: LayoutClass l Window => TopRightMaster Window -> l Window -> String Source #
LayoutModifier CenteredMaster Window Source #
Methods modifyLayout :: LayoutClass l Window => CenteredMaster Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => CenteredMaster Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (CenteredMaster Window)) Source # handleMess :: CenteredMaster Window -> SomeMessage -> X (Maybe (CenteredMaster Window)) Source # handleMessOrMaybeModifyIt :: CenteredMaster Window -> SomeMessage -> X (Maybe (Either (CenteredMaster Window) SomeMessage)) Source # pureMess :: CenteredMaster Window -> SomeMessage -> Maybe (CenteredMaster Window) Source # redoLayout :: CenteredMaster Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (CenteredMaster Window)) Source # pureModifier :: CenteredMaster Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (CenteredMaster Window)) Source # hook :: CenteredMaster Window -> X () Source # unhook :: CenteredMaster Window -> X () Source # modifierDescription :: CenteredMaster Window -> String Source # modifyDescription :: LayoutClass l Window => CenteredMaster Window -> l Window -> String Source #
LayoutModifier Rename a Source #
Methods modifyLayout :: LayoutClass l a => Rename a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) Source # modifyLayoutWithUpdate :: LayoutClass l a => Rename a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (Rename a)) Source # handleMess :: Rename a -> SomeMessage -> X (Maybe (Rename a)) Source # handleMessOrMaybeModifyIt :: Rename a -> SomeMessage -> X (Maybe (Either (Rename a) SomeMessage)) Source # pureMess :: Rename a -> SomeMessage -> Maybe (Rename a) Source # redoLayout :: Rename a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (Rename a)) Source # pureModifier :: Rename a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (Rename a)) Source # hook :: Rename a -> X () Source # unhook :: Rename a -> X () Source # modifierDescription :: Rename a -> String Source # modifyDescription :: LayoutClass l a => Rename a -> l a -> String Source #
LayoutModifier UnEscape a Source #
Methods modifyLayout :: LayoutClass l a => UnEscape a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) Source # modifyLayoutWithUpdate :: LayoutClass l a => UnEscape a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (UnEscape a)) Source # handleMess :: UnEscape a -> SomeMessage -> X (Maybe (UnEscape a)) Source # handleMessOrMaybeModifyIt :: UnEscape a -> SomeMessage -> X (Maybe (Either (UnEscape a) SomeMessage)) Source # pureMess :: UnEscape a -> SomeMessage -> Maybe (UnEscape a) Source # redoLayout :: UnEscape a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (UnEscape a)) Source # pureModifier :: UnEscape a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (UnEscape a)) Source # hook :: UnEscape a -> X () Source # unhook :: UnEscape a -> X () Source # modifierDescription :: UnEscape a -> String Source # modifyDescription :: LayoutClass l a => UnEscape a -> l a -> String Source #
LayoutModifier AddRoster Window Source #
Methods modifyLayout :: LayoutClass l Window => AddRoster Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => AddRoster Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (AddRoster Window)) Source # handleMess :: AddRoster Window -> SomeMessage -> X (Maybe (AddRoster Window)) Source # handleMessOrMaybeModifyIt :: AddRoster Window -> SomeMessage -> X (Maybe (Either (AddRoster Window) SomeMessage)) Source # pureMess :: AddRoster Window -> SomeMessage -> Maybe (AddRoster Window) Source # redoLayout :: AddRoster Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (AddRoster Window)) Source # pureModifier :: AddRoster Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (AddRoster Window)) Source # hook :: AddRoster Window -> X () Source # unhook :: AddRoster Window -> X () Source # modifierDescription :: AddRoster Window -> String Source # modifyDescription :: LayoutClass l Window => AddRoster Window -> l Window -> String Source #
LayoutModifier Selection a Source #
Methods modifyLayout :: LayoutClass l a => Selection a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) Source # modifyLayoutWithUpdate :: LayoutClass l a => Selection a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (Selection a)) Source # handleMess :: Selection a -> SomeMessage -> X (Maybe (Selection a)) Source # handleMessOrMaybeModifyIt :: Selection a -> SomeMessage -> X (Maybe (Either (Selection a) SomeMessage)) Source # pureMess :: Selection a -> SomeMessage -> Maybe (Selection a) Source # redoLayout :: Selection a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (Selection a)) Source # pureModifier :: Selection a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (Selection a)) Source # hook :: Selection a -> X () Source # unhook :: Selection a -> X () Source # modifierDescription :: Selection a -> String Source # modifyDescription :: LayoutClass l a => Selection a -> l a -> String Source #
LayoutModifier LimitWindows a Source #
Methods modifyLayout :: LayoutClass l a => LimitWindows a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) Source # modifyLayoutWithUpdate :: LayoutClass l a => LimitWindows a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (LimitWindows a)) Source # handleMess :: LimitWindows a -> SomeMessage -> X (Maybe (LimitWindows a)) Source # handleMessOrMaybeModifyIt :: LimitWindows a -> SomeMessage -> X (Maybe (Either (LimitWindows a) SomeMessage)) Source # pureMess :: LimitWindows a -> SomeMessage -> Maybe (LimitWindows a) Source # redoLayout :: LimitWindows a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (LimitWindows a)) Source # pureModifier :: LimitWindows a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (LimitWindows a)) Source # hook :: LimitWindows a -> X () Source # unhook :: LimitWindows a -> X () Source # modifierDescription :: LimitWindows a -> String Source # modifyDescription :: LayoutClass l a => LimitWindows a -> l a -> String Source #
LayoutModifier AddMaster Window Source #
Methods modifyLayout :: LayoutClass l Window => AddMaster Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => AddMaster Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (AddMaster Window)) Source # handleMess :: AddMaster Window -> SomeMessage -> X (Maybe (AddMaster Window)) Source # handleMessOrMaybeModifyIt :: AddMaster Window -> SomeMessage -> X (Maybe (Either (AddMaster Window) SomeMessage)) Source # pureMess :: AddMaster Window -> SomeMessage -> Maybe (AddMaster Window) Source # redoLayout :: AddMaster Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (AddMaster Window)) Source # pureModifier :: AddMaster Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (AddMaster Window)) Source # hook :: AddMaster Window -> X () Source # unhook :: AddMaster Window -> X () Source # modifierDescription :: AddMaster Window -> String Source # modifyDescription :: LayoutClass l Window => AddMaster Window -> l Window -> String Source #
LayoutModifier UseTransientFor Window Source #
Methods modifyLayout :: LayoutClass l Window => UseTransientFor Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => UseTransientFor Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (UseTransientFor Window)) Source # handleMess :: UseTransientFor Window -> SomeMessage -> X (Maybe (UseTransientFor Window)) Source # handleMessOrMaybeModifyIt :: UseTransientFor Window -> SomeMessage -> X (Maybe (Either (UseTransientFor Window) SomeMessage)) Source # pureMess :: UseTransientFor Window -> SomeMessage -> Maybe (UseTransientFor Window) Source # redoLayout :: UseTransientFor Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (UseTransientFor Window)) Source # pureModifier :: UseTransientFor Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (UseTransientFor Window)) Source # hook :: UseTransientFor Window -> X () Source # unhook :: UseTransientFor Window -> X () Source # modifierDescription :: UseTransientFor Window -> String Source # modifyDescription :: LayoutClass l Window => UseTransientFor Window -> l Window -> String Source #
LayoutModifier TrackFloating Window Source #
Methods modifyLayout :: LayoutClass l Window => TrackFloating Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => TrackFloating Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (TrackFloating Window)) Source # handleMess :: TrackFloating Window -> SomeMessage -> X (Maybe (TrackFloating Window)) Source # handleMessOrMaybeModifyIt :: TrackFloating Window -> SomeMessage -> X (Maybe (Either (TrackFloating Window) SomeMessage)) Source # pureMess :: TrackFloating Window -> SomeMessage -> Maybe (TrackFloating Window) Source # redoLayout :: TrackFloating Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (TrackFloating Window)) Source # pureModifier :: TrackFloating Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (TrackFloating Window)) Source # hook :: TrackFloating Window -> X () Source # unhook :: TrackFloating Window -> X () Source # modifierDescription :: TrackFloating Window -> String Source # modifyDescription :: LayoutClass l Window => TrackFloating Window -> l Window -> String Source #
LayoutModifier Minimize Window Source #
Methods modifyLayout :: LayoutClass l Window => Minimize Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => Minimize Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (Minimize Window)) Source # handleMess :: Minimize Window -> SomeMessage -> X (Maybe (Minimize Window)) Source # handleMessOrMaybeModifyIt :: Minimize Window -> SomeMessage -> X (Maybe (Either (Minimize Window) SomeMessage)) Source # pureMess :: Minimize Window -> SomeMessage -> Maybe (Minimize Window) Source # redoLayout :: Minimize Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (Minimize Window)) Source # pureModifier :: Minimize Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (Minimize Window)) Source # hook :: Minimize Window -> X () Source # unhook :: Minimize Window -> X () Source # modifierDescription :: Minimize Window -> String Source # modifyDescription :: LayoutClass l Window => Minimize Window -> l Window -> String Source #
LayoutModifier Maximize Window Source #
Methods modifyLayout :: LayoutClass l Window => Maximize Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => Maximize Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (Maximize Window)) Source # handleMess :: Maximize Window -> SomeMessage -> X (Maybe (Maximize Window)) Source # handleMessOrMaybeModifyIt :: Maximize Window -> SomeMessage -> X (Maybe (Either (Maximize Window) SomeMessage)) Source # pureMess :: Maximize Window -> SomeMessage -> Maybe (Maximize Window) Source # redoLayout :: Maximize Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (Maximize Window)) Source # pureModifier :: Maximize Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (Maximize Window)) Source # hook :: Maximize Window -> X () Source # unhook :: Maximize Window -> X () Source # modifierDescription :: Maximize Window -> String Source # modifyDescription :: LayoutClass l Window => Maximize Window -> l Window -> String Source #
LayoutModifier FullscreenFloat Window Source #
Methods modifyLayout :: LayoutClass l Window => FullscreenFloat Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => FullscreenFloat Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (FullscreenFloat Window)) Source # handleMess :: FullscreenFloat Window -> SomeMessage -> X (Maybe (FullscreenFloat Window)) Source # handleMessOrMaybeModifyIt :: FullscreenFloat Window -> SomeMessage -> X (Maybe (Either (FullscreenFloat Window) SomeMessage)) Source # pureMess :: FullscreenFloat Window -> SomeMessage -> Maybe (FullscreenFloat Window) Source # redoLayout :: FullscreenFloat Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (FullscreenFloat Window)) Source # pureModifier :: FullscreenFloat Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (FullscreenFloat Window)) Source # hook :: FullscreenFloat Window -> X () Source # unhook :: FullscreenFloat Window -> X () Source # modifierDescription :: FullscreenFloat Window -> String Source # modifyDescription :: LayoutClass l Window => FullscreenFloat Window -> l Window -> String Source #
LayoutModifier FullscreenFocus Window Source #
Methods modifyLayout :: LayoutClass l Window => FullscreenFocus Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => FullscreenFocus Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (FullscreenFocus Window)) Source # handleMess :: FullscreenFocus Window -> SomeMessage -> X (Maybe (FullscreenFocus Window)) Source # handleMessOrMaybeModifyIt :: FullscreenFocus Window -> SomeMessage -> X (Maybe (Either (FullscreenFocus Window) SomeMessage)) Source # pureMess :: FullscreenFocus Window -> SomeMessage -> Maybe (FullscreenFocus Window) Source # redoLayout :: FullscreenFocus Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (FullscreenFocus Window)) Source # pureModifier :: FullscreenFocus Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (FullscreenFocus Window)) Source # hook :: FullscreenFocus Window -> X () Source # unhook :: FullscreenFocus Window -> X () Source # modifierDescription :: FullscreenFocus Window -> String Source # modifyDescription :: LayoutClass l Window => FullscreenFocus Window -> l Window -> String Source #
LayoutModifier FullscreenFull Window Source #
Methods modifyLayout :: LayoutClass l Window => FullscreenFull Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => FullscreenFull Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (FullscreenFull Window)) Source # handleMess :: FullscreenFull Window -> SomeMessage -> X (Maybe (FullscreenFull Window)) Source # handleMessOrMaybeModifyIt :: FullscreenFull Window -> SomeMessage -> X (Maybe (Either (FullscreenFull Window) SomeMessage)) Source # pureMess :: FullscreenFull Window -> SomeMessage -> Maybe (FullscreenFull Window) Source # redoLayout :: FullscreenFull Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (FullscreenFull Window)) Source # pureModifier :: FullscreenFull Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (FullscreenFull Window)) Source # hook :: FullscreenFull Window -> X () Source # unhook :: FullscreenFull Window -> X () Source # modifierDescription :: FullscreenFull Window -> String Source # modifyDescription :: LayoutClass l Window => FullscreenFull Window -> l Window -> String Source #
LayoutModifier Monitor Window Source #
Methods modifyLayout :: LayoutClass l Window => Monitor Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => Monitor Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (Monitor Window)) Source # handleMess :: Monitor Window -> SomeMessage -> X (Maybe (Monitor Window)) Source # handleMessOrMaybeModifyIt :: Monitor Window -> SomeMessage -> X (Maybe (Either (Monitor Window) SomeMessage)) Source # pureMess :: Monitor Window -> SomeMessage -> Maybe (Monitor Window) Source # redoLayout :: Monitor Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (Monitor Window)) Source # pureModifier :: Monitor Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (Monitor Window)) Source # hook :: Monitor Window -> X () Source # unhook :: Monitor Window -> X () Source # modifierDescription :: Monitor Window -> String Source # modifyDescription :: LayoutClass l Window => Monitor Window -> l Window -> String Source #
LayoutModifier Stoppable Window Source #
Methods modifyLayout :: LayoutClass l Window => Stoppable Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => Stoppable Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (Stoppable Window)) Source # handleMess :: Stoppable Window -> SomeMessage -> X (Maybe (Stoppable Window)) Source # handleMessOrMaybeModifyIt :: Stoppable Window -> SomeMessage -> X (Maybe (Either (Stoppable Window) SomeMessage)) Source # pureMess :: Stoppable Window -> SomeMessage -> Maybe (Stoppable Window) Source # redoLayout :: Stoppable Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (Stoppable Window)) Source # pureModifier :: Stoppable Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (Stoppable Window)) Source # hook :: Stoppable Window -> X () Source # unhook :: Stoppable Window -> X () Source # modifierDescription :: Stoppable Window -> String Source # modifyDescription :: LayoutClass l Window => Stoppable Window -> l Window -> String Source #
LayoutModifier SmartSpacingWithEdge a Source #
Methods modifyLayout :: LayoutClass l a => SmartSpacingWithEdge a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) Source # modifyLayoutWithUpdate :: LayoutClass l a => SmartSpacingWithEdge a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (SmartSpacingWithEdge a)) Source # handleMess :: SmartSpacingWithEdge a -> SomeMessage -> X (Maybe (SmartSpacingWithEdge a)) Source # handleMessOrMaybeModifyIt :: SmartSpacingWithEdge a -> SomeMessage -> X (Maybe (Either (SmartSpacingWithEdge a) SomeMessage)) Source # pureMess :: SmartSpacingWithEdge a -> SomeMessage -> Maybe (SmartSpacingWithEdge a) Source # redoLayout :: SmartSpacingWithEdge a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (SmartSpacingWithEdge a)) Source # pureModifier :: SmartSpacingWithEdge a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (SmartSpacingWithEdge a)) Source # hook :: SmartSpacingWithEdge a -> X () Source # unhook :: SmartSpacingWithEdge a -> X () Source # modifierDescription :: SmartSpacingWithEdge a -> String Source # modifyDescription :: LayoutClass l a => SmartSpacingWithEdge a -> l a -> String Source #
LayoutModifier SmartSpacing a Source #
Methods modifyLayout :: LayoutClass l a => SmartSpacing a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) Source # modifyLayoutWithUpdate :: LayoutClass l a => SmartSpacing a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (SmartSpacing a)) Source # handleMess :: SmartSpacing a -> SomeMessage -> X (Maybe (SmartSpacing a)) Source # handleMessOrMaybeModifyIt :: SmartSpacing a -> SomeMessage -> X (Maybe (Either (SmartSpacing a) SomeMessage)) Source # pureMess :: SmartSpacing a -> SomeMessage -> Maybe (SmartSpacing a) Source # redoLayout :: SmartSpacing a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (SmartSpacing a)) Source # pureModifier :: SmartSpacing a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (SmartSpacing a)) Source # hook :: SmartSpacing a -> X () Source # unhook :: SmartSpacing a -> X () Source # modifierDescription :: SmartSpacing a -> String Source # modifyDescription :: LayoutClass l a => SmartSpacing a -> l a -> String Source #
LayoutModifier SpacingWithEdge a Source #
Methods modifyLayout :: LayoutClass l a => SpacingWithEdge a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) Source # modifyLayoutWithUpdate :: LayoutClass l a => SpacingWithEdge a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (SpacingWithEdge a)) Source # handleMess :: SpacingWithEdge a -> SomeMessage -> X (Maybe (SpacingWithEdge a)) Source # handleMessOrMaybeModifyIt :: SpacingWithEdge a -> SomeMessage -> X (Maybe (Either (SpacingWithEdge a) SomeMessage)) Source # pureMess :: SpacingWithEdge a -> SomeMessage -> Maybe (SpacingWithEdge a) Source # redoLayout :: SpacingWithEdge a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (SpacingWithEdge a)) Source # pureModifier :: SpacingWithEdge a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (SpacingWithEdge a)) Source # hook :: SpacingWithEdge a -> X () Source # unhook :: SpacingWithEdge a -> X () Source # modifierDescription :: SpacingWithEdge a -> String Source # modifyDescription :: LayoutClass l a => SpacingWithEdge a -> l a -> String Source #
LayoutModifier Spacing a Source #
Methods modifyLayout :: LayoutClass l a => Spacing a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) Source # modifyLayoutWithUpdate :: LayoutClass l a => Spacing a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (Spacing a)) Source # handleMess :: Spacing a -> SomeMessage -> X (Maybe (Spacing a)) Source # handleMessOrMaybeModifyIt :: Spacing a -> SomeMessage -> X (Maybe (Either (Spacing a) SomeMessage)) Source # pureMess :: Spacing a -> SomeMessage -> Maybe (Spacing a) Source # redoLayout :: Spacing a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (Spacing a)) Source # pureModifier :: Spacing a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (Spacing a)) Source # hook :: Spacing a -> X () Source # unhook :: Spacing a -> X () Source # modifierDescription :: Spacing a -> String Source # modifyDescription :: LayoutClass l a => Spacing a -> l a -> String Source #
LayoutModifier WorkspaceCursors a Source #
Methods modifyLayout :: LayoutClass l a => WorkspaceCursors a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) Source # modifyLayoutWithUpdate :: LayoutClass l a => WorkspaceCursors a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (WorkspaceCursors a)) Source # handleMess :: WorkspaceCursors a -> SomeMessage -> X (Maybe (WorkspaceCursors a)) Source # handleMessOrMaybeModifyIt :: WorkspaceCursors a -> SomeMessage -> X (Maybe (Either (WorkspaceCursors a) SomeMessage)) Source # pureMess :: WorkspaceCursors a -> SomeMessage -> Maybe (WorkspaceCursors a) Source # redoLayout :: WorkspaceCursors a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (WorkspaceCursors a)) Source # pureModifier :: WorkspaceCursors a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (WorkspaceCursors a)) Source # hook :: WorkspaceCursors a -> X () Source # unhook :: WorkspaceCursors a -> X () Source # modifierDescription :: WorkspaceCursors a -> String Source # modifyDescription :: LayoutClass l a => WorkspaceCursors a -> l a -> String Source #
(Show a, Read a, Eq a) => LayoutModifier WindowArranger a Source #
Methods modifyLayout :: LayoutClass l a => WindowArranger a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) Source # modifyLayoutWithUpdate :: LayoutClass l a => WindowArranger a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (WindowArranger a)) Source # handleMess :: WindowArranger a -> SomeMessage -> X (Maybe (WindowArranger a)) Source # handleMessOrMaybeModifyIt :: WindowArranger a -> SomeMessage -> X (Maybe (Either (WindowArranger a) SomeMessage)) Source # pureMess :: WindowArranger a -> SomeMessage -> Maybe (WindowArranger a) Source # redoLayout :: WindowArranger a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (WindowArranger a)) Source # pureModifier :: WindowArranger a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (WindowArranger a)) Source # hook :: WindowArranger a -> X () Source # unhook :: WindowArranger a -> X () Source # modifierDescription :: WindowArranger a -> String Source # modifyDescription :: LayoutClass l a => WindowArranger a -> l a -> String Source #
LayoutModifier MagicFocus Window Source #
Methods modifyLayout :: LayoutClass l Window => MagicFocus Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => MagicFocus Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (MagicFocus Window)) Source # handleMess :: MagicFocus Window -> SomeMessage -> X (Maybe (MagicFocus Window)) Source # handleMessOrMaybeModifyIt :: MagicFocus Window -> SomeMessage -> X (Maybe (Either (MagicFocus Window) SomeMessage)) Source # pureMess :: MagicFocus Window -> SomeMessage -> Maybe (MagicFocus Window) Source # redoLayout :: MagicFocus Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (MagicFocus Window)) Source # pureModifier :: MagicFocus Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (MagicFocus Window)) Source # hook :: MagicFocus Window -> X () Source # unhook :: MagicFocus Window -> X () Source # modifierDescription :: MagicFocus Window -> String Source # modifyDescription :: LayoutClass l Window => MagicFocus Window -> l Window -> String Source #
LayoutModifier Magnifier Window Source #
Methods modifyLayout :: LayoutClass l Window => Magnifier Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => Magnifier Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (Magnifier Window)) Source # handleMess :: Magnifier Window -> SomeMessage -> X (Maybe (Magnifier Window)) Source # handleMessOrMaybeModifyIt :: Magnifier Window -> SomeMessage -> X (Maybe (Either (Magnifier Window) SomeMessage)) Source # pureMess :: Magnifier Window -> SomeMessage -> Maybe (Magnifier Window) Source # redoLayout :: Magnifier Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (Magnifier Window)) Source # pureModifier :: Magnifier Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (Magnifier Window)) Source # hook :: Magnifier Window -> X () Source # unhook :: Magnifier Window -> X () Source # modifierDescription :: Magnifier Window -> String Source # modifyDescription :: LayoutClass l Window => Magnifier Window -> l Window -> String Source #
LayoutModifier ShowWName a Source #
Methods modifyLayout :: LayoutClass l a => ShowWName a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) Source # modifyLayoutWithUpdate :: LayoutClass l a => ShowWName a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (ShowWName a)) Source # handleMess :: ShowWName a -> SomeMessage -> X (Maybe (ShowWName a)) Source # handleMessOrMaybeModifyIt :: ShowWName a -> SomeMessage -> X (Maybe (Either (ShowWName a) SomeMessage)) Source # pureMess :: ShowWName a -> SomeMessage -> Maybe (ShowWName a) Source # redoLayout :: ShowWName a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (ShowWName a)) Source # pureModifier :: ShowWName a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (ShowWName a)) Source # hook :: ShowWName a -> X () Source # unhook :: ShowWName a -> X () Source # modifierDescription :: ShowWName a -> String Source # modifyDescription :: LayoutClass l a => ShowWName a -> l a -> String Source #
LayoutModifier Reflect a Source #
Methods modifyLayout :: LayoutClass l a => Reflect a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) Source # modifyLayoutWithUpdate :: LayoutClass l a => Reflect a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (Reflect a)) Source # handleMess :: Reflect a -> SomeMessage -> X (Maybe (Reflect a)) Source # handleMessOrMaybeModifyIt :: Reflect a -> SomeMessage -> X (Maybe (Either (Reflect a) SomeMessage)) Source # pureMess :: Reflect a -> SomeMessage -> Maybe (Reflect a) Source # redoLayout :: Reflect a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (Reflect a)) Source # pureModifier :: Reflect a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (Reflect a)) Source # hook :: Reflect a -> X () Source # unhook :: Reflect a -> X () Source # modifierDescription :: Reflect a -> String Source # modifyDescription :: LayoutClass l a => Reflect a -> l a -> String Source #
LayoutModifier MouseResize Window Source #
Methods modifyLayout :: LayoutClass l Window => MouseResize Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => MouseResize Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (MouseResize Window)) Source # handleMess :: MouseResize Window -> SomeMessage -> X (Maybe (MouseResize Window)) Source # handleMessOrMaybeModifyIt :: MouseResize Window -> SomeMessage -> X (Maybe (Either (MouseResize Window) SomeMessage)) Source # pureMess :: MouseResize Window -> SomeMessage -> Maybe (MouseResize Window) Source # redoLayout :: MouseResize Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (MouseResize Window)) Source # pureModifier :: MouseResize Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (MouseResize Window)) Source # hook :: MouseResize Window -> X () Source # unhook :: MouseResize Window -> X () Source # modifierDescription :: MouseResize Window -> String Source # modifyDescription :: LayoutClass l Window => MouseResize Window -> l Window -> String Source #
LayoutModifier BorderResize Window Source #
Methods modifyLayout :: LayoutClass l Window => BorderResize Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => BorderResize Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (BorderResize Window)) Source # handleMess :: BorderResize Window -> SomeMessage -> X (Maybe (BorderResize Window)) Source # handleMessOrMaybeModifyIt :: BorderResize Window -> SomeMessage -> X (Maybe (Either (BorderResize Window) SomeMessage)) Source # pureMess :: BorderResize Window -> SomeMessage -> Maybe (BorderResize Window) Source # redoLayout :: BorderResize Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (BorderResize Window)) Source # pureModifier :: BorderResize Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (BorderResize Window)) Source # hook :: BorderResize Window -> X () Source # unhook :: BorderResize Window -> X () Source # modifierDescription :: BorderResize Window -> String Source # modifyDescription :: LayoutClass l Window => BorderResize Window -> l Window -> String Source #
LayoutModifier ResizeScreen a Source #
Methods modifyLayout :: LayoutClass l a => ResizeScreen a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) Source # modifyLayoutWithUpdate :: LayoutClass l a => ResizeScreen a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (ResizeScreen a)) Source # handleMess :: ResizeScreen a -> SomeMessage -> X (Maybe (ResizeScreen a)) Source # handleMessOrMaybeModifyIt :: ResizeScreen a -> SomeMessage -> X (Maybe (Either (ResizeScreen a) SomeMessage)) Source # pureMess :: ResizeScreen a -> SomeMessage -> Maybe (ResizeScreen a) Source # redoLayout :: ResizeScreen a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (ResizeScreen a)) Source # pureModifier :: ResizeScreen a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (ResizeScreen a)) Source # hook :: ResizeScreen a -> X () Source # unhook :: ResizeScreen a -> X () Source # modifierDescription :: ResizeScreen a -> String Source # modifyDescription :: LayoutClass l a => ResizeScreen a -> l a -> String Source #
LayoutModifier WorkspaceDir Window Source #
Methods modifyLayout :: LayoutClass l Window => WorkspaceDir Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => WorkspaceDir Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (WorkspaceDir Window)) Source # handleMess :: WorkspaceDir Window -> SomeMessage -> X (Maybe (WorkspaceDir Window)) Source # handleMessOrMaybeModifyIt :: WorkspaceDir Window -> SomeMessage -> X (Maybe (Either (WorkspaceDir Window) SomeMessage)) Source # pureMess :: WorkspaceDir Window -> SomeMessage -> Maybe (WorkspaceDir Window) Source # redoLayout :: WorkspaceDir Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (WorkspaceDir Window)) Source # pureModifier :: WorkspaceDir Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (WorkspaceDir Window)) Source # hook :: WorkspaceDir Window -> X () Source # unhook :: WorkspaceDir Window -> X () Source # modifierDescription :: WorkspaceDir Window -> String Source # modifyDescription :: LayoutClass l Window => WorkspaceDir Window -> l Window -> String Source #
LayoutModifier AvoidStruts a Source #
Methods modifyLayout :: LayoutClass l a => AvoidStruts a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) Source # modifyLayoutWithUpdate :: LayoutClass l a => AvoidStruts a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (AvoidStruts a)) Source # handleMess :: AvoidStruts a -> SomeMessage -> X (Maybe (AvoidStruts a)) Source # handleMessOrMaybeModifyIt :: AvoidStruts a -> SomeMessage -> X (Maybe (Either (AvoidStruts a) SomeMessage)) Source # pureMess :: AvoidStruts a -> SomeMessage -> Maybe (AvoidStruts a) Source # redoLayout :: AvoidStruts a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (AvoidStruts a)) Source # pureModifier :: AvoidStruts a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (AvoidStruts a)) Source # hook :: AvoidStruts a -> X () Source # unhook :: AvoidStruts a -> X () Source # modifierDescription :: AvoidStruts a -> String Source # modifyDescription :: LayoutClass l a => AvoidStruts a -> l a -> String Source #
LayoutModifier WindowNavigation Window Source #
Methods modifyLayout :: LayoutClass l Window => WindowNavigation Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => WindowNavigation Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (WindowNavigation Window)) Source # handleMess :: WindowNavigation Window -> SomeMessage -> X (Maybe (WindowNavigation Window)) Source # handleMessOrMaybeModifyIt :: WindowNavigation Window -> SomeMessage -> X (Maybe (Either (WindowNavigation Window) SomeMessage)) Source # pureMess :: WindowNavigation Window -> SomeMessage -> Maybe (WindowNavigation Window) Source # redoLayout :: WindowNavigation Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> X ([(Window, Rectangle)], Maybe (WindowNavigation Window)) Source # pureModifier :: WindowNavigation Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)] -> ([(Window, Rectangle)], Maybe (WindowNavigation Window)) Source # hook :: WindowNavigation Window -> X () Source # unhook :: WindowNavigation Window -> X () Source # modifierDescription :: WindowNavigation Window -> String Source # modifyDescription :: LayoutClass l Window => WindowNavigation Window -> l Window -> String Source #
LayoutModifier Gaps a Source #
Methods modifyLayout :: LayoutClass l a => Gaps a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) Source # modifyLayoutWithUpdate :: LayoutClass l a => Gaps a -> Workspace WorkspaceId (l a) a -> Rectangle -> X (([(a, Rectangle)], Maybe (l a)), Maybe (Gaps a)) Source # handleMess :: Gaps a -> SomeMessage -> X (Maybe (Gaps a)) Source # handleMessOrMaybeModifyIt :: Gaps a -> SomeMessage -> X (Maybe (Either (Gaps a) SomeMessage)) Source # pureMess :: Gaps a -> SomeMessage -> Maybe (Gaps a) Source # redoLayout :: Gaps a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> X ([(a, Rectangle)], Maybe (Gaps a)) Source # pureModifier :: Gaps a -> Rectangle -> Maybe (Stack a) -> [(a, Rectangle)] -> ([(a, Rectangle)], Maybe (Gaps a)) Source # hook :: Gaps a -> X () Source # unhook :: Gaps a -> X () Source # modifierDescription :: Gaps a -> String Source # modifyDescription :: LayoutClass l a => Gaps a -> l a -> String Source #
LayoutModifier LayoutHintsToCenter Window Source #
Methods modifyLayout :: LayoutClass l Window => LayoutHintsToCenter Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (l Window)) Source # modifyLayoutWithUpdate :: LayoutClass l Window => LayoutHintsToCenter Window -> Workspace WorkspaceId (l Window) Window -> Rectangle -> X (([(Window, Rectangle)], Maybe (l Window)), Maybe (LayoutHintsToCenter Window)) Source # handleMess :: LayoutHintsToCenter Window -> SomeMessage -> X (Maybe (LayoutHintsToCenter Window)) Source # handleMessOrMaybeModifyIt :: LayoutHintsToCenter Window -> SomeMessage -> X (Maybe (Either (LayoutHintsToCenter Window) SomeMessage)) Source # pureMess :: LayoutHintsToCenter Window -> SomeMessage -> Maybe (LayoutHintsToCenter Window) Source # redoLayout :: LayoutHintsToCenter Window -> Rectangle -> Maybe (Stack Window) -> [(Window, Rectangle)], Maybe (WindowNavigation Rectangle)], Maybe (l a)) X (Maybe (LayoutHintsToCenter Maybe (LayoutHintsToCenter Maybe e/doc/libghc-x11-doc/html/Graphics-X11-Types.html#t:Window">Window, WindowNavigation Rectangle)], Rectangle)], Maybe (Gaps a)) String Source # unhook :: Gaps a -> X () Source # modifierDescription :: LayoutHintsToCenter Maybe e/doc/libghc-x11-doc/html/Graphics-X11-Types.html#t:Window">Window, Maybe e/doc/libghc-x11-doc/html/Graphics-X11-Types.html#t:Window">Window, Maybe e/doc/libghc-x11-doc/html/Graphics-X11-Types.html#t:Window">Window, Maybe e/doctml/XMonad-StackSet.html#t:Stack">Stack Maybe (Gaps a -> X () Maybe (Gaps a -> BorderResize Gaps a -> X () SourceSomeMessage -> Maybe (Maybe (Gaps a -> X () X (([(Window, RectangleWorkspaceId (l Window) Window -> WorkspaceId (l a) a -> Rectangle Window, #
X () SourceSomeMessa/a> Gaps a -> Window) SomeMessage)) Source # pureMess :: Window -> SomeMhref="#v:handleMessOrMaybeModifyIt" class="selflink"># pureMess :: # pureMess :: # pureMess :: Maybe (pureMess :: # LayoutHintsToCenterMaybe (LayoutHintsToCenter # # pureMess :: Stack Maybe (Gaps a -> Source # pureMess :: # pureMess :: LayoutHintsToCenter Window -> # pureMess :: # pureMess :: redoLayout :: LayoutHintsToCenter Window (Gaps a)) Source # X (Source # #	WindowNavigation Window -> LayoutHintsToCenter Gaps a -> Workspace WorkspaceId (l a) a -> Rectangle -> X ([(a, Rectangle)], oc/libghc-xmonad-doc/html/XMonad-StackSet.html#t:Workspace">Workspaw">Window)) LayoutHintsToCenter Gaps a -> Workspace #	Source # Window -> LayoutHintsToCenter Gaps a -> Gaps a)) Source # Lay/p> redoLayout :: WindowNavigation Gaps a)) Source # Lay/p> :: Gaps a -> Workspace Workspas.html#t:Rectangle">Rectangle)], Rectangle)], unhook :: Gaps a -> XayoutModifier.html#modifyLayoutWithUpdate" class="link">Source # Lay/p> -> String X () Source # modare/doc/libghc-xmonad-doc/html/XMonad-Core.hter (BorderResize Maybe e/doc/libghc-x11-doc/html/Graphics-X11-Types.html#t:Window">Window, Maybe e/doc/libghc-x11-doc/html/Graphics-X11-Types.html#t:Window">Window, Maybe e/doc/libghc-x11-doc/html/Gt:String">String Source X () Source<11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">Rectangle -> Source<11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">Rectangle-doc/html/XMonad-Stacka href="file:///us.9.0.0/Data-Maybe.html#t:Maybe">Maybe e/doc/libghc-x11-doc/html/Graphics-X11-Types.html#t:Window">Window, Maybe e/doc/libghc-xad-Core.html#t:X">X () Source<11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">Rectangle -> SourceSomeMessage -> MaybeRectangle -> Source be.html#t:Maybe">Maybe (MaybeRectangle ->-> WorkspaceId (l a) a -> Rectangle Window, #
Stack Maybe (Gaps a -> Window, RectangleWorkspaceId (l Source # handleMessOrMaybeModifyIt :: LayoutHintsToCenter (l Source # handleMessOrMaybeMef="#v:handleMess" class="selflink"># Window) href="file:///usr/share/doc/libghc-x11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">RectangleWorkspaceId (l Source Window) href="file:///usr/share/doc/libghc-x11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">Reouss="selflink"># pureMess :: Source<11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">Rectangle -> SourceMaybe (pureMess :: Workspace WorkspaceId (l a) a -> # pureMess :: Source<11-doc/html/Graphicsr/share/doc/libghc-x11-doc/html/Graphics-X11-Types.html#tc:LayoutMooutHints/doc/ghc-doc/html/libraries/base-4.9.0.0/Data-Maybe.html#t:Maybe">MaybeRectangle ->-> LayoutHintsToCenter Rectangle ->> # pureMess :: Stack Maybe (Gaps a -> X (Source LayoutHintsToCenter X (S.html#t:WorkspaceId">WorkspaceId (l a) a -> # pureMess :: Window -> WorkspaceId (l a) a -> X (Source LayoutHintsToCenter Stack Maybe (LayoutHintsToCenter Window)) Source # Lay/p> Gaps a -> Workspace nk"># pureMess :: # Lay/p> -> Maybe (X ([(a, Rectangle)], oc/libghc-xmonad-doc/html/XMonad-StackSet.htmlsr/share/doc/libghc-x11-doc/html/Graphics-X11-Types">Gaps a -> Workspace a -> Workspace nk"># pureMess :: X ([(a, Workspace nk">#< file:///usr/share/doc/libghc-xmonad-doc/html/XMonad-Core.html#t:X">X () Set.html#:Workspace">Workspace a -> Workspace nk"># pureMess :: X ([(a, Workspace nk"># pureMess :: X ([(a, Workspace nk"># pureMess :: a -> Source # modifierDescription :: Set.html#:Workspace">Workspace a -> a -> Workspace Source<11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">Rectangle -> WorkspaceId (l Window) Window -> R> :: WindowNavigation Source # modifierDescription :hare/doc/libghc-xmonad-doc/htmlre/do:Gaps a -> Gaps a -> X () Maybe (Gaps a -> BorderResize Gapsc/ghc-doc/html/libraries/base-4.9.0.0/Data-May>X () Source be.html#t:Maybe">Maybe (MaybeRectangle ->-> WorkspaceId (l a) a -> Rectangle Window, #
Stack LayoutHintsToCenterMaybe (LayoutHintsToCenter # modifierDescription :: Avsoile:///usr/share/doc/libghc-x11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">Rectangle -> Maybe (Stack SomeMessage -> X (Maybe (Either (Gaps a) Maybe (Gaps a -> # Stack a -> Maybe (Either (Gaps a) pureMess :: Window, Rectangle)]share/doc/libghc-x11-doc/html/Graphics-X11-Types.html#t:Window">Window)), May4.9.0.0/Daries/base-4.9.0.0/Data-Maybe.htm> pureMess :: # pureMess :: Stack Window, # pureMess :: Stack <"file://Siy/usr/share/ics-X11-Types.html#t:Window">Window, Rc">pureMess :: Stack Window href="/usr/share/doc/libghc-x11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">RectangleWorkspaceId (l Source Window) href="file:///usr/share/doc/libghc-x11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">Reouss="selflink"># Window, Rectangle)], Maybe (l Window)), href="/usr/share/doc/libghc-x11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">RectangleWorkspaceId (l RectangleWorkspaceId (l Source WorkspaceId (l a) a -> RectangleWorkspaceId (l Source # Source nk"># pureMess :: # pef="="link">Source Window) href="file:///usr/share/doc/libghc-x11-doc/htmref="file:///usr/share/doc/libghc-x11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">RectangleWorkspaceId (l Source Source<11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">Rectangle -> SourceMaybe (pureMess :: # pef="="link">Source Window) href="file:///usr/share/doc/libghc-x11-doc/htmref="file:///usr/share/doc/libghc-x11-doc/html/Graphics-X11-Xl class="link">Source<11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle class="link">Source Window) href="file:///usr/share/doc/libghc-x11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">Reous>Maybe (l a)) X (Source # modifierDescription.html#handleMess" class="link">Source Source<11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">Rectangle -> Rectangle)], # pef="="link">Source Window) href="file:///usr/share/doc/libghc-x11-doc/htmref="file:///usr/share/doc/libghc-x11-doc/html/Graphics-X11-Xl class="link">Snn11-Types.hut-LayoutModifier.html#handleMessOrMaybeModifyIt" class="link">Source # pureMess :: Rectangle)], Window) href="file:///usr/share/doc/libghc-x11-doc/htmref="file://le:-Core.html#t:X">X () Source<11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">Rectangle -> ///usr.0/Data-Maybe.html#t:Maybe">Maybe (LayoutHintsToCenter Source<11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">Rectangle -a href="file:///usr/share/doc/libghf="file:///usr/share/doc/libghc-x11-doc/html/Graphics-X11-Types.html#tc:LayoutModifier:Layouss="selflink"># Snn11-Types.hut-LayoutModifier.html#handleMessOrMaybeModifyIt" class="link">Source # Snn11-Types.hut-LayoutModifice # modifierDescription.html#handleMess" class="link">Source Source<11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectan2>odifyIt" class="selflink"># pureMess :: Rectangle)], Window) href="file:///usr/share/doc/libghc-x11-doc/htmref="file://le:-Core.html#t:X">X () Source<11-doc/html/Gr="self="file:///usr/share/doc/libghc-x11-doc/html/Graphics-X11-Xl class="link">Snn11-Types.hut-LayoutModifier.html#handleMessOrMaybeModifyIt" class="link">Source # Rectangle)]share/doc/libghc-x11-doc/html/Graphics-X11-Types.html#t:Window">Window)), May4.9.0.2 href="XMonad-Layout-LayoutModifier.html#t:LayoutModifier">LayoutModifier LayoutHintsToCenter Window Source #	Window)), May4.9.0.2 href="XMonad-Layout-LayoutModifier.html#t:La:LayoutHintsToCentef="file:///usr/share/doc/libghc-xmonad-doc/html/XMonad-Core.html#t:X">X ([(a, Source #	Window)), May4.9.0.2 href="XMonad-Layout-LayoutModifier.html#t:La:LayoutHintsToCentef="file:///usr/share/doc/libghc-xmonad-doc/html/XMonad-Core.html#t:X">X ([(a, Source #
#
LayoutHintsToCenter Window Source #	X () XWindow) href="file:///usr/share/doc/html#t:Gaps">Gaps a -> Source Rectangle)]share/doc/liypes.html#t:Window">Window May4.9.0.0/Daries/base-4.9.0.0/Data-Maybe.htm><.1n">modifierDescription.html#handibghyoutModifier.html#handleMess" class="link">Sourre/doc/libghc-x11-doc/html/Graphics-X11-Xl class="li>
Source<11-doc/html/Graphics-share/doc/libghc-x11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">Rectangle)]share/doc/libghc-x11-doc/html/Graphics-X11-Types.html#t:Window">WindowMay4.9.0.0/Daries/base-4.9.0h0/Data-Maybe.htm><.1n">modifierDescription.html#handibghyoutModifier.html#handleMess" class="link">Source Window, Window, Rectangle)]share/doc/libghc-x11 href="fil/doc/lut-MagnifieStack WindowMay4.9.0.0/Daries/base-4.9.0h0/Data-Maybe.htm><.1n">modifierDescription.html#hande-4.9.0.0/Data-Maybe.html#t:Maybe">May4.9.0.0/Daries/base-4.9.0.0/Data-Maybe.htm><.1n">modifierDescription.html#handibghyoutModifier.html#handleMess" class="link">Source Window, Rectangle)]share/doc/ml/Graphics-e/doc/ghc-doc/html/libraries/bandow">WindowRectangleWorkspaceId (l Source Source<11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">Rectangle -> SourceMaybe (pureMess :: SomeMessage -> X (Source Source<11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">Rectangle -> SourceMaybe (pureMess :: SomeMessage -> Source<11-doc/html/Gr="self="file:///usr/share/doc/libghc-x.html#t:Maybe">Maybe (LayoutHintsToCenter Window, pureMess :: Maybe (Maybe (LayoutHintsToCent a -> SomeMessage -> Source<11-doc/html/Gr="self="file:///usr/share/doc/libghc-x.html#t:Maybe">Maybe (LayoutHintsToCenter Set.html#:Workspace">Workspace LayoutHintsToCent a -> Window, Maybe e/doc/libghc-xad-Core.html#t:X">X () es.hile:///usr/showN> pureMess :: Source<11-doc/html/Gr="self="file:///usr/share/doc/libghc-x.html#t:Maybe">Maybe (LayoutHintsToCent a -> Window, Maybe e/doc/libghc-xad-Core.html#t:X">X () CombineTwo (Workspace Window, Source<11-doc/html/Gr="self="file:///usr/share/doc/libghc-x11-dlass="link">S-doc/html/Graphics-X11-Types.html#t:Window">Window, unhook :: Gaps a -&a1a href"1ayout-LayoutCombinators.html#%2A%2A%R> :: Rectangle)], DragPane ()) l1 l2 a infixr 6 #String Rectangle)], String # Lay/p>Rectangle)], String # Lay/p>Rectangle)], unhook :: Gaps a -> XayoutModifier.html#modifyLayoutWithUpdate" class="link">Source RectangleWorkspaceId (l Source Rectangle)]share/doc/libghc-x11-doc/html/Grap-doc/htmref="file:///usr/share/doc/libghc-x11-doc/html/Graphics-X11-Xl class="link">Source<11-doc/html/Graphics-X11-Xlib-Types.hts.html#t:Gaps">Gaps a -> XayoutModifier.html#modifyLayoutWithUpdate" class="link">Source Rectangle)], unhook :: Source< 1href="file:///usr/shshare/ics-X11-Types.html#t:Window">Window, ass="link">Source<11-doc/html/Graphics-X11-Xlib-Types.hts.html#t:Gaps">Gaps a -> XayoutM hrec/libghc-x11-doc/html/Graphics-X11-Types.html#t:Window">Window) href="file:///usr/share/doc/html#t:Gaps">Gaps a -> X () XWindowSourceRectangle<-Types.htes.html#ttml/Graphics-e/doc/ghc-doc/htource # pureMess :: Gap"file:///usr/share/doc/libghc-x11-doc/html/Graphics-X11-Types.html#t:Window">Window) Windoghc-x1html/XMoreModiass="src"/libghc-">#Window)), Source a -> Window)), Source a -> Window)), May4.9.0.2 href="XMonad-Layout-LayoutModifier.html#t:La:LayoutHintsToCentef="file:///usr/share/doc/libghc-xmonad-doc/html/XMonad-Core.html#t:<11-doc/htad-Layout-Gaps.html#t:Gaps">Gaps a)) Source Rectangle)]share/doc/liypes.htmlpes.htmlare/difierDescription :: Set.html#:Workspace">Workspace W.html#t:Rectangle">Rectangle -> Window/Graphihics-X11-Xlib-Types.html#t:Rectangle">Rectangle)]share/doc/libghc-x11-doc/html/.9.0.0ies/baMaybe">Msr/share/0/Data-Maybe.htm><.1n">modifierDescription.html#hande-4.9.0.0/Data-Maybe.htData-MN> pureMess :: Gaps a)) Window) href="file:///usr/share/doc/libghc-x11-doc/htmref="file:///usr/share/doc/libghc-x11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">RectangleWorkspaceId (l Source Source<11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">Rectangle -> SourceMaybe (Gaps a)) Source Rectangle)]share/doc/lt:Rectangle">Rectoc/lut-MagnifieGaps a)) Window) href="file:///usr/share/doc/libghc-x11-doc/htmref="file:///usr/share/doc/libghc-x11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">RectangleWorkspaceId (l LayoutModifier LayoutHintsToCenter Window Source Source<11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">Rectangle -> Workspace Source Either (Gaps a) pushare/do:"src/XMo.9.0.0/Dhref="doc/ghc-doc/html/libraries/base-es/base-4.0 8>May4.>.0."#v:pureMess">pureMess :: Snn11-Types.hut-LayoutModifier.html#handleMessOrMaybeModifyIt" class="link">Soad-Lay)), Source Rectangle)]share/doc/liypes.html#t:Window">Window a -(1>tml/libraries/base-es/base-4.0 8>May4.>.0."#v:pureMess">pureMessSomeMessage -> Source<11-doc/html/Gr="self="file:///usr/share/doc/libghc-x.html#t:Maybe">Maybe (LayoutHintsTo1-Xl class /html/libref="Xsr/share/doc/libghc-x11-doc/html/Graphics-e/doc/ghgle)]share/doc/liypes.html#t:Window">Window May4.9.0.0/Daries/base-4.9.ef="figunhook" class="link">Source<11-doc/html/Gr="self="file:///usr/share/doc/libghc-x.html#t:Maybe">Maybe (LayoutHintsTo1-Xl classLayouts a -(1>tml/libraries/base-es/base-4.0 8>May4.>.0."#v:pureMess">pureMessSomeMessage -> Source<11-doc/html/Gr="self="file:///usr/share/dlf="file:///usr/share/doc/libghc-x.html#t:Maybe">Maybe (LayoutHintsTo1-Xl class /html/libref="Xsr/share/doc/libghc-x11-doc/htl#t:Layouc/libghc-x11-doc/html/Grap-doc/htmref="file:///usr/share/doc/libghc-x11-doc/html/Graphics-X11-Xl class="link">Source<11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle class="link">So, r/shaa-Maybe.s/base-4.9.0h0/Data-Maybe.htm><.1n">modifierDescription.html#handibghyoutModifier.html#handleMess" class="link">Source Window, Maybe (LMagn ut-> (l a) a -> Rectangle # Lay/p>Rectangle)], #	X () ///usr/share/doc/libghc-x11-doc/html/Graphics-X11-Xlib-Types.html#t:Rectangle">RectangleWorkspaceId (l Source< 1href="file:///usr/shshare/ics-X11-Types.html#t:html/Gml#t:Recta)escriptimonad-doc/html/XM-doc/html/XMonad-Core.html#t:SomeMessage">SomeMessage -> X (String RectangleWorkspaceId (l WindowNavigation Source

Usage

The LayoutModifier class

The `LayoutModifier` class