XMonad.Layout.BinarySpacePartition

Layout where new windows will split the focused window in half, based off of BSPWM

Usage

You can use this module with the following in your ~/.xmonad/xmonad.hs:

import XMonad.Layout.BinarySpacePartition

Then add the layout, using the default BSP (BinarySpacePartition)

myLayout = emptyBSP ||| etc ..

It may be a good idea to use XMonad.Actions.Navigation2D to move between the windows.

This layout responds to SetGeometry and is compatible with e.g. XMonad.Actions.MouseResize or XMonad.Layout.BorderResize. You should probably try both to decide which is better for you, if you want to be able to resize the splits with the mouse.

If you don't want to use the mouse, add the following key bindings to resize the splits with the keyboard:

, ((modm .|. altMask,               xK_l     ), sendMessage $ ExpandTowards R)
, ((modm .|. altMask,               xK_h     ), sendMessage $ ExpandTowards L)
, ((modm .|. altMask,               xK_j     ), sendMessage $ ExpandTowards D)
, ((modm .|. altMask,               xK_k     ), sendMessage $ ExpandTowards U)
, ((modm .|. altMask .|. ctrlMask , xK_l     ), sendMessage $ ShrinkFrom R)
, ((modm .|. altMask .|. ctrlMask , xK_h     ), sendMessage $ ShrinkFrom L)
, ((modm .|. altMask .|. ctrlMask , xK_j     ), sendMessage $ ShrinkFrom D)
, ((modm .|. altMask .|. ctrlMask , xK_k     ), sendMessage $ ShrinkFrom U)
, ((modm,                           xK_r     ), sendMessage Rotate)
, ((modm,                           xK_s     ), sendMessage Swap)
, ((modm,                           xK_n     ), sendMessage FocusParent)
, ((modm .|. ctrlMask,              xK_n     ), sendMessage SelectNode)
, ((modm .|. shiftMask,             xK_n     ), sendMessage MoveNode)

Here's an alternative key mapping, this time using additionalKeysP, arrow keys, and slightly different behavior when resizing windows

, ("M-M1-<Left>",    sendMessage $ ExpandTowards L)
, ("M-M1-<Right>",   sendMessage $ ShrinkFrom L)
, ("M-M1-<Up>",      sendMessage $ ExpandTowards U)
, ("M-M1-<Down>",    sendMessage $ ShrinkFrom U)
, ("M-M1-C-<Left>",  sendMessage $ ShrinkFrom R)
, ("M-M1-C-<Right>", sendMessage $ ExpandTowards R)
, ("M-M1-C-<Up>",    sendMessage $ ShrinkFrom D)
, ("M-M1-C-<Down>",  sendMessage $ ExpandTowards D)
, ("M-s",            sendMessage $ BSP.Swap)
, ("M-M1-s",         sendMessage $ Rotate) ]

If you have many windows open and the layout begins to look too hard to manage, you can Balance the layout, so that the current splittings are discarded and windows are tiled freshly in a way that the split depth is minimized. You can combine this with Equalize, which does not change your tree, but tunes the split ratios in a way that each window gets the same amount of space:

, ((myModMask,               xK_a),     sendMessage Balance)
, ((myModMask .|. shiftMask, xK_a),     sendMessage Equalize)

emptyBSP :: BinarySpacePartition a

an empty BinarySpacePartition to use as a default for adding windows to.

data BinarySpacePartition a

Instances

LayoutClass BinarySpacePartition Window

Defined in XMonad.Layout.BinarySpacePartition

Methods

runLayout :: Workspace WorkspaceId (BinarySpacePartition Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (BinarySpacePartition Window))

doLayout :: BinarySpacePartition Window -> Rectangle -> Stack Window -> X ([(Window, Rectangle)], Maybe (BinarySpacePartition Window))

pureLayout :: BinarySpacePartition Window -> Rectangle -> Stack Window -> [(Window, Rectangle)]

emptyLayout :: BinarySpacePartition Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (BinarySpacePartition Window))

handleMessage :: BinarySpacePartition Window -> SomeMessage -> X (Maybe (BinarySpacePartition Window))

pureMessage :: BinarySpacePartition Window -> SomeMessage -> Maybe (BinarySpacePartition Window)

description :: BinarySpacePartition Window -> String

Eq (BinarySpacePartition a)

Defined in XMonad.Layout.BinarySpacePartition

Methods

(==) :: BinarySpacePartition a -> BinarySpacePartition a -> Bool

(/=) :: BinarySpacePartition a -> BinarySpacePartition a -> Bool

Read (BinarySpacePartition a)

Defined in XMonad.Layout.BinarySpacePartition

Methods

readsPrec :: Int -> ReadS (BinarySpacePartition a)

readList :: ReadS [BinarySpacePartition a]

readPrec :: ReadPrec (BinarySpacePartition a)

readListPrec :: ReadPrec [BinarySpacePartition a]

Show (BinarySpacePartition a)

Defined in XMonad.Layout.BinarySpacePartition

Methods

showsPrec :: Int -> BinarySpacePartition a -> ShowS

show :: BinarySpacePartition a -> String

showList :: [BinarySpacePartition a] -> ShowS

data Rotate

Message for rotating a split (horizontal/vertical) in the BSP

Constructors

Rotate

Instances

Message Rotate

Defined in XMonad.Layout.BinarySpacePartition

data Swap

Message for swapping the left child of a split with the right child of split

Constructors

Swap

Instances

Message Swap

Defined in XMonad.Layout.BinarySpacePartition

data ResizeDirectional

Message for resizing one of the cells in the BSP

Constructors

ExpandTowards Direction2D

ShrinkFrom Direction2D

MoveSplit Direction2D

Instances

Message ResizeDirectional

Defined in XMonad.Layout.BinarySpacePartition

data TreeRotate

Message for rotating the binary tree around the parent node of the window to the left or right

Constructors

RotateL

RotateR

Instances

Message TreeRotate

Defined in XMonad.Layout.BinarySpacePartition

data TreeBalance

Message to balance the tree in some way (Balance retiles the windows, Equalize changes ratios)

Constructors

Balance

Equalize

Instances

Message TreeBalance

Defined in XMonad.Layout.BinarySpacePartition

data FocusParent

Message to cyclically select the parent node instead of the leaf

Constructors

FocusParent

Instances

Message FocusParent

Defined in XMonad.Layout.BinarySpacePartition

data SelectMoveNode

Message to move nodes inside the tree

Constructors

SelectNode

MoveNode

Instances

Message SelectMoveNode

Defined in XMonad.Layout.BinarySpacePartition

data Direction2D

Two-dimensional directions:

Constructors

U

Up

D

Down

R

Right

L

Left

Instances

Bounded Direction2D

Defined in XMonad.Util.Types

Methods

minBound :: Direction2D

maxBound :: Direction2D

Enum Direction2D

Defined in XMonad.Util.Types

Methods

succ :: Direction2D -> Direction2D

pred :: Direction2D -> Direction2D

toEnum :: Int -> Direction2D

fromEnum :: Direction2D -> Int

enumFrom :: Direction2D -> [Direction2D]

enumFromThen :: Direction2D -> Direction2D -> [Direction2D]

enumFromTo :: Direction2D -> Direction2D -> [Direction2D]

enumFromThenTo :: Direction2D -> Direction2D -> Direction2D -> [Direction2D]

Eq Direction2D

Defined in XMonad.Util.Types

Methods

(==) :: Direction2D -> Direction2D -> Bool

(/=) :: Direction2D -> Direction2D -> Bool

Ord Direction2D

Defined in XMonad.Util.Types

Methods

compare :: Direction2D -> Direction2D -> Ordering

(<) :: Direction2D -> Direction2D -> Bool

(<=) :: Direction2D -> Direction2D -> Bool

(>) :: Direction2D -> Direction2D -> Bool

(>=) :: Direction2D -> Direction2D -> Bool

max :: Direction2D -> Direction2D -> Direction2D

min :: Direction2D -> Direction2D -> Direction2D

Read Direction2D

Defined in XMonad.Util.Types

Methods

readsPrec :: Int -> ReadS Direction2D

readList :: ReadS [Direction2D]

readPrec :: ReadPrec Direction2D

readListPrec :: ReadPrec [Direction2D]

Show Direction2D

Defined in XMonad.Util.Types

Methods

showsPrec :: Int -> Direction2D -> ShowS

show :: Direction2D -> String

showList :: [Direction2D] -> ShowS