man package:xmonad-contrib

A manual page prompt for XMonad window manager. TODO

• narrow completions by section number, if the one is specified (like /etc/bash_completion does)

Provides a manage hook to react on process spawned with spawnOn, spawnHere etc.

Add a new window to be managed in the current workspace. Bring it into focus. Whether the window is already managed, or not, it is mapped, has its border set, and its event mask set.

The action to run when a new window is opened. Default:

manageHook =: composeAll [className =? "MPlayer" --> doFloat, className =? "Gimp" --> doFloat]

To add more rules to this list, you can say, for instance:

import XMonad.StackSet
...
manageHook =+ (className =? "Emacs" --> doF kill)
manageHook =+ (className =? "Vim" --> doF shiftMaster)

Note that operator precedence mandates the parentheses here.

I don't know at which workspace new window will appear until (Endo WindowSet) function from windows in XMonad.Operations actually run, but in (Endo WindowSet) function i can't already execute monadic actions, because it's pure. So, i compute result for every workspace here and just use it later in (Endo WindowSet) function. Note, though, that this will execute monadic actions many times, and therefore assume, that result of FocusHook does not depend on the number of times it was executed.

Place this at the start of a ManageHook, or possibly other places for a more limited view. It will show the current StackSet state and the new window, and set a flag so that manageDebugLogHook will display the final StackSet state. Note that the initial state shows only the current workspace; the final one shows all workspaces, since your manageHook might use e.g. doShift,

If manageDebug has set the debug-stack flag, show the stack.

Detects if the given window is of type DOCK and if so, reveals it, but does not manage it.

ManageHook which demanages monitor window and applies opacity settings.

Query for manual page to be displayed.

Parse one or more occurrences of the given parser.

manyTill p end parses zero or more occurrences of p, until end succeeds. Returns a list of values returned by p.

Use this hook to let XMonad properly track remote/local windows. For example, manageHook = manageRemote =<< io getHostName.

Use this hook if you want to manage XMONAD_REMOTE properties, but don't want to use an external getHostName in your config. That way you are retreating to environment variables.

A manageHook and associated logHook for debugging ManageHooks. Simplest usage: wrap your xmonad config in the debugManageHook combinator. Or use debugManageHookOn for a triggerable version, specifying the triggering key sequence in XMonad.Util.EZConfig syntax. Or use the individual hooks in whatever way you see fit.

This module provides tools to automatically manage dock type programs, such as gnome-panel, kicker, dzen, and xmobar.

This module provides helper functions to be used in manageHook. Here's how you might use this:

import XMonad.Hooks.ManageHelpers
main =
xmonad def{
...
manageHook = composeOne [
isKDETrayWindow -?> doIgnore,
transience,
isFullscreen -?> doFullFloat,
resource =? "stalonetray" -?> doIgnore
],
...
}

Here's how you can define more helpers like the ones from this module:

-- some function you want to transform into an infix operator
f :: a -> b -> Bool

-- a new helper
q ***? x = fmap (\a -> f a x) q   -- or: (\b -> f x b)
-- or
q ***? x = fmap (`f` x) q         -- or: (x `f`)

Any existing operator can be "lifted" in the same way:

q ++? x = fmap (++ x) q

This is a list of selected commands that can be made available using XMonad.Hooks.ServerMode to allow external programs to control the window manager. Bluetile (http://projects.haskell.org/bluetile/) uses this to enable its dock application to do things like changing workspaces and layouts.

Allows you to run internal xmonad commands (X () actions) using a dmenu menu in addition to key bindings. Requires dmenu and the Dmenu XMonad.Actions module.

Create a Map from Strings to xmonad actions from a list of pairs.