XMonad.Core

Dynamic components may be retrieved with get, static components with ask. With newtype deriving we get readers and state monads instantiated on XConf and XState automatically.

Instances

Monad X

Monoid a => Monoid (X a)

type WindowSet = StackSet WorkspaceId (Layout Window) Window ScreenId ScreenDetail

Source

type WindowSpace = Workspace WorkspaceId (Layout Window) Window

Source

type WorkspaceId = String

Source

Virtual workspace indicies

newtype ScreenId

Source

Physical screen indicies

Constructors

S Int

Instances

data ScreenDetail

Source

The Rectangle with screen dimensions and the list of gaps

Constructors

screenRect :: !Rectangle
statusGap :: !(Int, Int, Int, Int)	width of status bar on the screen

Instances

data XState

XState, the window manager state. Just the display, width, height and a window list

Constructors

XState

windowset :: !WindowSet	workspace list
mapped :: !(Set Window)	the Set of mapped windows
waitingUnmap :: !(Map Window Int)	the number of expected UnmapEvents
dragging :: !(Maybe (Position -> Position -> X (), X ()))

Instances

MonadState XState X

data XConf

Source

Constructors

XConf

display :: Display	the X11 display
config :: !(XConfig Layout)	initial user configuration
theRoot :: !Window	the root window
normalBorder :: !Pixel	border color of unfocused windows
focusedBorder :: !Pixel	border color of the focused window
keyActions :: !(Map (KeyMask, KeySym) (X ()))	a mapping of key presses to actions
buttonActions :: !(Map (KeyMask, Button) (Window -> X ()))	a mapping of button presses to actions

Instances

MonadReader XConf X

data XConfig l

Source

Constructors

XConfig

normalBorderColor :: !String	Non focused windows border color. Default: "#dddddd"
focusedBorderColor :: !String	Focused windows border color. Default: "#ff0000"
terminal :: !String	The preferred terminal application. Default: "xterm"
layoutHook :: !(l Window)	The available layouts
manageHook :: !ManageHook	The action to run when a new window is opened
workspaces :: ![String]	The list of workspaces' names
defaultGaps :: ![(Int, Int, Int, Int)]	The list of gaps, per screen
numlockMask :: !KeyMask	The numlock modifier
modMask :: !KeyMask	the mod modifier
keys :: !(XConfig Layout -> Map (ButtonMask, KeySym) (X ()))	The key binding: a map from key presses and actions
mouseBindings :: !(XConfig Layout -> Map (ButtonMask, Button) (Window -> X ()))	The mouse bindings
borderWidth :: !Dimension	The border width
logHook :: !(X ())	The action to perform when the windows set is changed
focusFollowsMouse :: !Bool	Whether window entry events can change focus

class Show (layout a) => LayoutClass layout a where

Source

The different layout modes

doLayout: given a Rectangle and a Stack, layout the stack elements inside the given Rectangle. If an element is not given a Rectangle by doLayout, then it is not shown on screen. Windows are restacked according to the order they are returned by doLayout.

Methods

doLayout :: layout a -> Rectangle -> Stack a -> X ([(a, Rectangle)], Maybe (layout a))

Source

Given a Rectangle in which to place the windows, and a Stack of windows, return a list of windows and their corresponding Rectangles. The order of windows in this list should be the desired stacking order. Also return a modified layout, if this layout needs to be modified (e.g. if we keep track of the windows we have displayed).

pureLayout :: layout a -> Rectangle -> Stack a -> [(a, Rectangle)]

Source

This is a pure version of doLayout, for cases where we don't need access to the X monad to determine how to layout the windows, and we don't need to modify our layout itself.

handleMessage :: layout a -> SomeMessage -> X (Maybe (layout a))

Source

handleMessage performs message handling for that layout. If handleMessage returns Nothing, then the layout did not respond to that message and the screen is not refreshed. Otherwise, handleMessage returns an updated Layout and the screen is refreshed.

pureMessage :: layout a -> SomeMessage -> Maybe (layout a)

Source

Respond to a message by (possibly) changing our layout, but taking no other action. If the layout changes, the screen will be refreshed.

description :: layout a -> String

Source

This should be a human-readable string that is used when selecting layouts by name.

Instances

LayoutClass Layout Window

LayoutClass Tall a

LayoutClass Full a

LayoutClass l a => LayoutClass (Mirror l) a

(LayoutClass l a, LayoutClass r a) => LayoutClass (Choose l r) a

data Layout a

Source

LayoutClass handling. See particular instances in Operations.hs

An existential type that can hold any object that is in Read and LayoutClass.

Constructors

forall l . (LayoutClass l a, Read (l a)) => Layout (l a)

Instances

LayoutClass Layout Window

Show (Layout a)

readsLayout :: Layout a -> String -> [(Layout a, String)]

Source

Using the Layout as a witness, parse existentially wrapped windows from a String

Typeable (typeOf)

class Typeable a => Message a

Source

Based on ideas in An Extensible Dynamically-Typed Hierarchy of Exceptions, Simon Marlow, 2006. Use extensible messages to the handleMessage handler.

User-extensible messages must be a member of this class.

Instances

Message Event

Message LayoutMessages

Message NextNoWrap

data SomeMessage

A wrapped value of some type in the Message class.

Constructors

forall a . Message a => SomeMessage a

fromMessage :: Message m => SomeMessage -> Maybe m

Source

And now, unwrap a given, unknown Message type, performing a (dynamic) type check on the result.

runLayout :: LayoutClass l a => l a -> Rectangle -> Maybe (Stack a) -> X ([(a, Rectangle)], Maybe (l a))

Source

This calls doLayout if there are any windows to be laid out.

data LayoutMessages

Source

LayoutMessages are core messages that all layouts (especially stateful layouts) should consider handling.

Constructors

Hide	sent when a layout becomes non-visible
ReleaseResources	sent when xmonad is exiting or restarting

Instances

Eq LayoutMessages

Typeable LayoutMessages

Message LayoutMessages

runX :: XConf -> XState -> X a -> IO (a, XState)

Source

Run the X monad, given a chunk of X monad code, and an initial state Return the result, and final state

catchX :: X a -> X a -> X a

Source

Run in the X monad, and in case of exception, and catch it and log it to stderr, and run the error case.

userCode :: X () -> X ()

Source

Execute the argument, catching all exceptions. Either this function or catchX should be used at all callsites of user customized code.

io :: MonadIO m => IO a -> m a

Source

General utilities

Lift an IO action into the X monad

catchIO :: IO () -> X ()

Source

Lift an IO action into the X monad. If the action results in an IO exception, log the exception to stderr and continue normal execution.

doubleFork :: MonadIO m => IO () -> m ()

Source

Double fork and execute an IO action (usually one of the exec family of functions)

withDisplay :: (Display -> X a) -> X a

Source

Run a monad action with the current display settings

withWindowSet :: (WindowSet -> X a) -> X a

Source

Run a monadic action with the current stack set

isRoot :: Window -> X Bool

Source

True if the given window is the root window

runOnWorkspaces :: (WindowSpace -> X WindowSpace) -> X ()

Source

This is basically a map function, running a function in the X monad on each workspace with the output of that function being the modified workspace.

broadcastMessage :: Message a => a -> X ()

Source

Send a message to all visible layouts, without necessarily refreshing. This is how we implement the hooks, such as UnDoLayout.

getAtom :: String -> X Atom

Source

Wrapper for the common case of atom internment

spawn :: MonadIO m => String -> m ()

Source

spawn. Launch an external application

restart :: String -> Bool -> X ()

Source

restart name resume. Attempt to restart xmonad by executing the program name. If resume is True, restart with the current window state. When executing another window manager, resume should be False.

getXMonadDir :: MonadIO m => m String

Source

Return the path to ~/.xmonad.

recompile :: MonadIO m => Bool -> m Bool

Source

'recompile force', recompile ~/.xmonad/xmonad.hs when any of the following apply: * force is True * the xmonad executable does not exist * the xmonad executable is older than xmonad.hs

The -i flag is used to restrict recompilation to the xmonad.hs file only.

Compilation errors (if any) are logged to ~/.xmonad/xmonad.errors. If GHC indicates failure with a non-zero exit code, an xmessage displaying that file is spawned.

False is returned if there is compilation errors.

trace :: MonadIO m => String -> m ()

Source

A trace for the X monad. Logs a string to stderr. The result may be found in your .xsession-errors file

whenJust :: Monad m => Maybe a -> (a -> m ()) -> m ()

Source

Run a side effecting action with the current workspace. Like when but

whenX :: X Bool -> X () -> X ()

Source

Conditionally run an action, using a X event to decide

atom_WM_STATE :: X Atom

Source