Merge pull request #275 from LSLeary/point14

0.14

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,24 @@
+### Problem Description
+
+Describe the problem you are having, what you expect to happen
+instead, and how to reproduce the problem.
+
+### Configuration File
+
+Please include the smallest configuration file that reproduces the
+problem you are experiencing:
+
+```haskell
+module Main (main) where
+
+import XMonad
+
+main :: IO ()
+main = xmonad def
+```
+
+### Checklist
+
+  - [ ] I've read [CONTRIBUTING.md](https://github.com/xmonad/xmonad/blob/master/CONTRIBUTING.md)
+
+  - [ ] I tested my configuration with [xmonad-testing](https://github.com/xmonad/xmonad-testing)

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,12 @@
+### Description
+
+Include a description for your changes, including the motivation
+behind them.
+
+### Checklist
+
+  - [ ] I've read [CONTRIBUTING.md](https://github.com/xmonad/xmonad/blob/master/CONTRIBUTING.md)
+
+  - [ ] I tested my changes with [xmonad-testing](https://github.com/xmonad/xmonad-testing)
+
+  - [ ] I updated the `CHANGES.md` file

.gitignore

@@ -0,0 +1,26 @@
+.cabal-sandbox/
+cabal.sandbox.config
+.hpc/
+*.hi
+*.o
+*.p_hi
+*.prof
+*.tix
+cabal.config
+dist
+dist-*
+
+# editor temp files
+
+*#
+.#*
+*~
+.*.swp
+
+# TAGS files
+TAGS
+tags
+
+# stack artifacts
+/.stack-work/
+/cabal.project.local

.mailmap

@@ -0,0 +1,102 @@
+Alejandro Serrano Mena <trupill@gmail.com>
+Alexandre Buisse <buisse@cs.chalmers.se>
+Anders Engstrom <ankaan@gmail.com>
+Antoine R. Dumont <eniotna.t@gmail.com>
+Anton Pirogov <anton.pirogov@gmail.com>
+Anton Pirogov <anton.pirogov@gmail.com> anton.pirogov at gmail . com <unknown>
+Arjun Comar <nrujac@gmail.com>
+Audun Skaugen <audun@skaugen.name> <audunskaugen@gmail.com>
+Bas van Dijk <v.dijk.bas@gmail.com>
+Ben Boeckel <mathstuf@gmail.com>
+Ben Weitzman <benweitzman@gmail.com>
+Bogdan Sinitsyn <bogdan.sinitsyn@gmail.com>
+Brandon S Allbery KF8NH <allbery.b@gmail.com>
+Brandon S Allbery KF8NH <allbery.b@gmail.com> <allbery@ece.cmu.edu>
+Brent Yorgey <byorgey@gmail.com> <byorgey@cis.upenn.edu>
+Carlos Lopez-Camey <c.lopez@kmels.net>
+Carsten Otto <xmonad@c-otto.de>
+Christian Dietrich <stettberger@dokucode.de>
+Christian Wills <cwills.dev@gmail.com>
+Daniel Neri <daniel.neri@sigicom.com> <daniel.neri@sigicom.se>
+Daniel Schoepe <daniel.schoepe@googlemail.com> <asgaroth_@gmx.de>
+Daniel Schoepe <daniel.schoepe@googlemail.com> <daniel.schoepe@gmail.com>
+Daniel Wagner <me@dmwit.com> <daniel@wagner-home.com>
+Dave Harrison <dave@nullcube.com>
+David Glasser <glasser@mit.edu>
+David McLean <gopsychonauts@gmail.com>
+Devin Mullins <devin.mullins@gmail.com> <me@twifkak.com>
+Dominik Bruhn <dominik@dbruhn.de>
+Don Stewart <dons00@gmail.com> <dons@cse.unsw.edu.au>
+Don Stewart <dons00@gmail.com> <dons@galois.com>
+Edward Z. Yang <ezyang@cs.stanford.edu>
+Gwern Branwen <gwern@gwern.net>
+Gwern Branwen <gwern@gwern.net> <gwern0@gmail.com>
+Henrique Abreu <hgabreu@gmail.com>
+Ilya Portnov <portnov84@rambler.ru>
+intrigeri <intrigeri@boum.org>
+Ivan Miljenovic <Ivan.Miljenovic@gmail.com>
+Jan-David Quesel <quesel@informatik.uni-oldenburg.de>
+Jens Petersen <juhp@community.haskell.org> <petersen@haskell.org>
+Jeremy Apthorp <nornagon@gmail.com>
+Joachim Breitner <mail@joachim-breitner.de>
+Joachim Fasting <joachim.fasting@gmail.com>
+Joel Suovaniemi <joel.suovaniemi@iki.fi>
+Joe Thornber <joe.thornber@gmail.com>
+Johann Giwer <johanngiwer@web.de>
+Jussi Maki <joamaki@gmail.com>
+Konstantin Sobolev <konstantin.sobolev@gmail.com>
+Lanny Ripple <lan3ny@gmail.com>
+Lei Chen <linxray@gmail.com>
+Leonardo Serra <leoserra@minaslivre.org>
+Luis Cabellos <zhen.sydow@gmail.com>
+Lukas Mai <l.mai@web.de>
+Mario Pastorelli <pastorelli.mario@gmail.com>
+Mathias Stearn <redbeard0531@gmail.com>
+Matt Brown <deadguysfrom@gmail.com>
+Matthew Hague <matthewhague@zoho.com>
+Nathaniel Filardo <nwfilardo@gmail.com>
+Nelson Elhage <nelhage@mit.edu>
+Nicolas Dudebout <nicolas.dudebout@gatech.edu>
+Nicolas Pouillard <nicolas.pouillard@gmail.com>
+Nils Schweinsberg <mail@n-sch.de>
+Norbert Zeh <nzeh@cs.dal.ca>
+Peter Olson <polson2@hawk.iit.edu>
+Quentin Moser <moserq@gmail.com>
+Quentin Moser <quentin.moser@unifr.ch>
+Rickard Gustafsson <acura@allyourbase.se>
+Robert Marlow <bobstopper@bobturf.org>
+Robert Marlow <bobstopper@bobturf.org> <robreim@bobturf.org>
+Rohan Jain <crodjer@gmail.com>
+Sibi Prabakaran <sibi@psibi.in> <psibi2000@gmail.com>
+Sean Escriva <sean.escriva@gmail.com>
+Sean McEligot <seanmce33@gmail.com>
+Spencer Janssen <spencerjanssen@gmail.com> <sjanssen@cse.unl.edu>
+Tomohiro Matsuyama <matsuyama3@ariel-networks.com>
+Tom Rauchenwald <its.sec@gmx.net>
+Tony Morris <haskell@tmorris.net>
+Valery V. Vorotyntsev <valery.vv@gmail.com>
+Will Farrington <wcfarrington@gmail.com>
+Wirt Wolff <wirtwolff@gmail.com>
+Yaakov Nemoy <loupgaroublond@gmail.com>
+
+brian <brian@lorf.org>
+cardboard42 <cardboard42@gmail.com>
+daedalusinfinity <daedalusinfinity@gmail.com>
+hexago.nl <xmonad-contrib@hexago.nl>
+intrigeri <intrigeri@boum.org>
+jakob <jakob@pipefour.org>
+kedals0 <kedals0@gmail.com>
+lithis <xmonad@selg.hethrael.org>
+lithis <xmonad@selg.hethrael.org> <xmonad@s001.hethrael.com>
+longpoke <longpoke@gmail.com>
+md143rbh7f <md143rbh7f@gmail.com>
+perlkat <perlkat@katspace.org>
+rupa <rupa@lrrr.us> <rupa@lrrr.us>
+timthelion <tim.thelion@gmail.com>
+
+# for core only
+Neil Mitchell <http://www.cs.york.ac.uk/~ndm/>, Neil Mitchell
+Nick Burlett <nickburlett@mac.com>
+Sam Hughes   <hughes@rpi.edu>
+Shae Erisson <shae@ScannedInAvian.com>
+Conrad Irwin <conrad.irwin@gmail.com>

.travis.yml

@@ -0,0 +1,104 @@
+# This file has been generated -- see https://github.com/hvr/multi-ghc-travis
+language: c
+sudo: false
+
+cache:
+  directories:
+    - $HOME/.cabsnap
+    - $HOME/.cabal/packages
+
+before_cache:
+  - rm -fv $HOME/.cabal/packages/hackage.haskell.org/build-reports.log
+  - rm -fv $HOME/.cabal/packages/hackage.haskell.org/00-index.tar
+
+matrix:
+  include:
+    - env: GHCVER=8.4.3  CABALVER=2.2
+      compiler: ": #GHC 8.4.3"
+      addons: { apt: { packages: [cabal-install-2.2,  ghc-8.4.3,  libxrandr-dev]
+                     , sources:  [hvr-ghc]
+                     } }
+    - env: GHCVER=8.2.2  CABALVER=2.0
+      compiler: ": #GHC 8.2.2"
+      addons: { apt: { packages: [cabal-install-2.0,  ghc-8.2.2,  libxrandr-dev]
+                     , sources:  [hvr-ghc]
+                     } }
+    - env: GHCVER=8.0.1  CABALVER=1.24
+      compiler: ": #GHC 8.0.1"
+      addons: { apt: { packages: [cabal-install-1.24, ghc-8.0.1,  libxrandr-dev]
+                     , sources:  [hvr-ghc]
+                     } }
+    - env: GHCVER=7.10.3 CABALVER=1.22
+      compiler: ": #GHC 7.10.3"
+      addons: { apt: { packages: [cabal-install-1.22, ghc-7.10.3, libxrandr-dev]
+                     , sources:  [hvr-ghc]
+                     } }
+    - env: GHCVER=7.8.4  CABALVER=1.18
+      compiler: ": #GHC 7.8.4"
+      addons: { apt: { packages: [cabal-install-1.18, ghc-7.8.4,  libxrandr-dev]
+                     , sources:  [hvr-ghc]
+                     } }
+
+before_install:
+ - unset CC
+ - export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH
+
+install:
+ - cabal --version
+ - echo "$(ghc --version) [$(ghc --print-project-git-commit-id 2> /dev/null || echo '?')]"
+ - if [ -f $HOME/.cabal/packages/hackage.haskell.org/00-index.tar.gz ];
+   then
+     zcat $HOME/.cabal/packages/hackage.haskell.org/00-index.tar.gz >
+          $HOME/.cabal/packages/hackage.haskell.org/00-index.tar;
+   fi
+ - travis_retry cabal update -v
+
+ # build xmonad from HEAD
+ - git clone https://github.com/xmonad/xmonad.git
+ - cabal install xmonad/
+
+ - sed -i 's/^jobs:/-- jobs:/' ${HOME}/.cabal/config
+ - cabal install --only-dependencies --enable-tests --enable-benchmarks --dry -v > installplan.txt
+ - sed -i -e '1,/^Resolving /d' installplan.txt; cat installplan.txt
+
+# check whether current requested install-plan matches cached package-db snapshot
+ - if diff -u $HOME/.cabsnap/installplan.txt installplan.txt;
+   then
+     echo "cabal build-cache HIT";
+     rm -rfv .ghc;
+     cp -a $HOME/.cabsnap/ghc $HOME/.ghc;
+     cp -a $HOME/.cabsnap/lib $HOME/.cabsnap/share $HOME/.cabsnap/bin $HOME/.cabal/;
+   else
+     echo "cabal build-cache MISS";
+     rm -rf $HOME/.cabsnap;
+     mkdir -p $HOME/.ghc $HOME/.cabal/lib $HOME/.cabal/share $HOME/.cabal/bin;
+   fi
+ - cabal install --only-dependencies --enable-tests --enable-benchmarks;
+
+# snapshot package-db on cache miss
+ - if [ ! -d $HOME/.cabsnap ];
+   then
+      echo "snapshotting package-db to build-cache";
+      mkdir $HOME/.cabsnap;
+      cp -a $HOME/.ghc $HOME/.cabsnap/ghc;
+      cp -a $HOME/.cabal/lib $HOME/.cabal/share $HOME/.cabal/bin installplan.txt $HOME/.cabsnap/;
+   fi
+
+# Here starts the actual work to be performed for the package under test;
+# any command which exits with a non-zero exit code causes the build to fail.
+script:
+ - if [ -f configure.ac ]; then autoreconf -i; fi
+ - cabal configure --enable-tests --enable-benchmarks -v2  # -v2 provides useful information for debugging
+ - cabal build   # this builds all libraries and executables (including tests/benchmarks)
+ - cabal test
+# - cabal check   # complains about -Werror even though it is
+                  # hidden behind a manual flag with default false
+ - cabal sdist   # tests that a source-distribution can be generated
+
+# Check that the resulting source distribution can be built & installed.
+# If there are no other `.tar.gz` files in `dist`, this can be even simpler:
+# `cabal install --force-reinstalls dist/*-*.tar.gz`
+ - SRC_TGZ=$(cabal info . | awk '{print $2;exit}').tar.gz &&
+   (cd dist && cabal install --force-reinstalls "$SRC_TGZ")
+
+# EOF

CHANGES.md

@@ -0,0 +1,651 @@
+# Change Log / Release Notes
+
+## 0.14
+
+### Breaking Changes
+
+  * `XMonad.Layout.Spacing`
+
+    Rewrite `XMonad.Layout.Spacing`. Borders are no longer uniform but composed
+    of four sides each with its own border width. The screen and window borders
+    are now separate and can be independently toggled on/off. The screen border
+    examines the window/rectangle list resulting from 'runLayout' rather than
+    the stack, which makes it compatible with layouts such as the builtin
+    `Full`. The child layout will always be called with the screen border. If
+    only a single window is displayed (and `smartBorder` enabled), it will be
+    expanded into the original layout rectangle. Windows that are displayed but
+    not part of the stack, such as those created by 'XMonad.Layout.Decoration',
+    will be shifted out of the way, but not scaled (not possible for windows
+    created by XMonad). This isn't perfect, so you might want to disable
+    `Spacing` on such layouts.
+
+  * `XMonad.Util.SpawnOnce`
+
+    - Added `spawnOnOnce`, `spawnNOnOnce` and `spawnAndDoOnce`. These are useful in startup hooks
+      to shift spawned windows to a specific workspace.
+
+  * Adding handling of modifySpacing message in smartSpacing and smartSpacingWithEdge layout modifier
+
+  * `XMonad.Actions.GridSelect`
+
+    - Added field `gs_bordercolor` to `GSConfig` to specify border color.
+
+  * `XMonad.Layout.Minimize`
+
+     Though the interface it offers is quite similar, this module has been
+     almost completely rewritten. The new `XMonad.Actions.Minimize` contains
+     several functions that allow interaction with minimization window state.
+     If you are using this module, you must upgrade your configuration to import
+     `X.A.Minimize` and use `maximizeWindow` and `withLastMinimized` instead of
+     sending messages to `Minimized` layout. `XMonad.Hooks.RestoreMinimized` has
+     been completely deprecated, and its functions have no effect.
+
+  * `XMonad.Prompt.Unicode`
+
+    - `unicodePrompt :: String -> XPConfig -> X ()` now additionally takes a
+      filepath to the `UnicodeData.txt` file containing unicode data.
+
+  * `XMonad.Actions.PhysicalScreens`
+
+    `getScreen`, `viewScreen`, `sendToScreen`, `onNextNeighbour`, `onPrevNeighbour` now need a extra parameter
+    of type `ScreenComparator`. This allow the user to specify how he want his screen to be ordered default
+    value are:
+
+     - `def`(same as verticalScreenOrderer) will keep previous behavior
+     - `verticalScreenOrderer`
+     - `horizontalScreenOrderer`
+
+    One can build his custom ScreenOrderer using:
+     - `screenComparatorById` (allow to order by Xinerama id)
+     - `screenComparatorByRectangle` (allow to order by screen coordonate)
+     - `ScreenComparator` (allow to mix ordering by screen coordonate and xinerama id)
+
+  * `XMonad.Util.WorkspaceCompare`
+
+    `getXineramaPhysicalWsCompare` now need a extra argument of type `ScreenComparator` defined in
+    `XMonad.Actions.PhysicalScreens` (see changelog of this module for more information)
+
+  * `XMonad.Hooks.EwmhDesktops`
+
+    - Simplify ewmhDesktopsLogHookCustom, and remove the gnome-panel specific
+      remapping of all visible windows to the active workspace (#216).
+    - Handle workspace renames that might be occuring in the custom function
+      that is provided to ewmhDesktopsLogHookCustom.
+
+  * `XMonad.Hooks.DynamicLog`
+
+    - Support xmobar's \<action> and \<raw> tags; see `xmobarAction` and
+      `xmobarRaw`.
+
+  * `XMonad.Layout.NoBorders`
+
+    The layout now maintains a list of windows that never have borders, and a
+    list of windows that always have borders. Use `BorderMessage` to manage
+    these lists and the accompanying event hook (`borderEventHook`) to remove
+    destroyed windows from them. Also provides the `hasBorder` manage hook.
+
+    Two new conditions have been added to `Ambiguity`: `OnlyLayoutFloat` and
+    `OnlyLayoutFloatBelow`; `OnlyFloat` was renamed to `OnlyScreenFloat`.  See
+    the documentation for more information.
+
+    The type signature of `hiddens` was changed to accept a new `Rectangle`
+    parameter representing the bounds of the parent layout, placed after the
+    `WindowSet` parameter. Anyone defining a new instance of `SetsAmbiguous`
+    will need to update their configuration. For example, replace "`hiddens amb
+    wset mst wrs =`" either with "`hiddens amb wset _ mst wrs =`" or to make
+    use of the new parameter with "`hiddens amb wset lr mst wrs =`".
+
+  * `XMonad.Actions.MessageFeedback`
+
+    - Follow the naming conventions of `XMonad.Operations`. Functions returning
+      `X ()` are named regularly (previously these ended in underscore) while
+      those returning `X Bool` are suffixed with an uppercase 'B'.
+    - Provide all `X Bool` and `SomeMessage` variations for `sendMessage` and
+      `sendMessageWithNoRefresh`, not just `sendMessageWithNoRefreshToCurrent`
+      (renamed from `send`).
+    - The new `tryInOrderB` and `tryMessageB` functions accept a parameter of
+      type `SomeMessage -> X Bool`, which means you are no longer constrained
+      to the behavior of the `sendMessageWithNoRefreshToCurrent` dispatcher.
+    - The `send*Messages*` family of funtions allows for sequencing arbitrary
+      sets of messages with minimal refresh. It makes little sense for these
+      functions to support custom message dispatchers.
+    - Remain backwards compatible. Maintain deprecated aliases of all renamed
+      functions:
+      - `send`          -> `sendMessageWithNoRefreshToCurrentB`
+      - `sendSM`        -> `sendSomeMessageWithNoRefreshToCurrentB`
+      - `sendSM_`       -> `sendSomeMessageWithNoRefreshToCurrent`
+      - `tryInOrder`    -> `tryInOrderWithNoRefreshToCurrentB`
+      - `tryInOrder_`   -> `tryInOrderWithNoRefreshToCurrent`
+      - `tryMessage`    -> `tryMessageWithNoRefreshToCurrentB`
+      - `tryMessage_`   -> `tryMessageWithNoRefreshToCurrent`
+
+### New Modules
+
+  * `XMonad.Layout.MultiToggle.TabBarDecoration`
+
+    Provides a simple transformer for use with `XMonad.Layout.MultiToggle` to
+    dynamically toggle `XMonad.Layout.TabBarDecoration`.
+
+  * `XMonad.Layout.StateFull`
+
+    Provides `StateFull`: a stateful form of `Full` that does not misbehave when
+    floats are focused, and the `FocusTracking` layout transformer by means of
+    which `StateFull` is implemented. `FocusTracking` simply holds onto the last
+    true focus it was given and continues to use it as the focus for the
+    transformed layout until it sees another. It can be used to improve the
+    behaviour of a child layout that has not been given the focused window.
+
+  * `XMonad.Actions.SwapPromote`
+
+    Module for tracking master window history per workspace, and associated
+    functions for manipulating the stack using such history.
+
+  * `XMonad.Actions.CycleWorkspaceByScreen`
+
+    A new module that allows cycling through previously viewed workspaces in the
+    order they were viewed most recently on the screen where cycling is taking
+    place.
+
+    Also provides the `repeatableAction` helper function which can be used to
+    build actions that can be repeated while a modifier key is held down.
+
+  * `XMonad.Prompt.FuzzyMatch`
+
+    Provides a predicate `fuzzyMatch` that is much more lenient in matching
+    completions in `XMonad.Prompt` than the default prefix match.  Also provides
+    a function `fuzzySort` that allows sorting the fuzzy matches by "how well"
+    they match.
+
+  * `XMonad.Utils.SessionStart`
+
+    A new module that allows to query if this is the first time xmonad is
+    started of the session, or a xmonad restart.
+
+    Currently needs manual setting of the session start flag. This could be
+    automated when this moves to the core repository.
+
+  * `XMonad.Layout.MultiDishes`
+
+    A new layout based on Dishes, however it accepts additional configuration
+    to allow multiple windows within a single stack.
+
+  * `XMonad.Util.Rectangle`
+
+    A new module for handling pixel rectangles.
+
+  * `XMonad.Layout.BinaryColumn`
+
+    A new module which provides a simple grid layout, halving the window
+    sizes of each window after master.
+
+    This is similar to Column, but splits the window in a way
+    that maintains window sizes upon adding & removing windows as well as the
+    option to specify a minimum window size.
+
+### Bug Fixes and Minor Changes
+
+  * `XMonad.Layout.Grid`
+
+    Fix as per issue #223; Grid will no longer calculate more columns than there
+    are windows.
+
+  * `XMonad.Hooks.FadeWindows`
+
+    Added support for GHC version 8.4.x by adding a Semigroup instance for
+    Monoids
+
+  * `XMonad.Hooks.WallpaperSetter`
+
+    Added support for GHC version 8.4.x by adding a Semigroup instance for
+    Monoids
+
+  * `XMonad.Hooks.Mosaic`
+
+    Added support for GHC version 8.4.x by adding a Semigroup instance for
+    Monoids
+
+  * `XMonad.Actions.Navigation2D`
+
+    Added `sideNavigation` and a parameterised variant, providing a navigation
+    strategy with fewer quirks for tiled layouts using X.L.Spacing.
+
+  * `XMonad.Layout.Fullscreen`
+
+    The fullscreen layouts will now not render any window that is totally
+    obscured by fullscreen windows.
+
+  * `XMonad.Layout.Gaps`
+
+    Extended the sendMessage interface with `ModifyGaps` to allow arbitrary
+    modifications to the `GapSpec`.
+
+  * `XMonad.Layout.Groups`
+
+    Added a new `ModifyX` message type that allows the modifying
+    function to return values in the `X` monad.
+
+  * `XMonad.Actions.Navigation2D`
+
+    Generalised (and hence deprecated) hybridNavigation to hybridOf.
+
+  * `XMonad.Layout.LayoutHints`
+
+    Preserve the window order of the modified layout, except for the focused
+    window that is placed on top. This fixes an issue where the border of the
+    focused window in certain situations could be rendered below borders of
+    unfocused windows. It also has a lower risk of interfering with the
+    modified layout.
+
+  * `XMonad.Layout.MultiColumns`
+
+    The focused window is placed above the other windows if they would be made to
+    overlap due to a layout modifier. (As long as it preserves the window order.)
+
+  * `XMonad.Actions.GridSelect`
+
+    - The vertical centring of text in each cell has been improved.
+
+  * `XMonad.Actions.SpawnOn`
+
+    - Bind windows spawns by child processes of the original window to the same
+      workspace as the original window.
+
+  * `XMonad.Util.WindowProperties`
+
+    - Added the ability to test if a window has a tag from
+      `XMonad.Actions.TagWindows`
+
+  * `XMonad.Layout.Magnifier`
+
+    - Handle `IncMasterN` messages.
+
+  * `XMonad.Util.EZConfig`
+
+    - Can now parse Latin1 keys, to better accommodate users with
+      non-US keyboards.
+
+  * `XMonad.Actions.Submap`
+
+    Establish pointer grab to avoid freezing X, when button press occurs after
+    submap key press.  And terminate submap at button press in the same way,
+    as we do for wrong key press.
+
+  * `XMonad.Hooks.SetWMName`
+
+    Add function `getWMName`.
+
+  * `XMonad.Hooks.ManageHelpers`
+
+    Make type of ManageHook combinators more general.
+
+  * `XMonad.Prompt`
+
+    Export `insertString`.
+
+  * `XMonad.Prompt.Window`
+
+    - New function: `windowMultiPrompt` for using `mkXPromptWithModes`
+      with window prompts.
+
+  * `XMonad.Hooks.WorkspaceHistory`
+
+    - Now supports per screen history.
+
+  * `XMonad.Layout.ComboP`
+
+    - New `PartitionWins` message to re-partition all windows into the
+      configured sub-layouts.  Useful when window properties have
+      changed and you want to re-sort windows into the appropriate
+      sub-layout.
+
+  * `XMonad.Actions.Minimize`
+
+    - Now has `withFirstMinimized` and `withFirstMinimized'` so you can perform
+      actions with both the last and first minimized windows easily.
+
+  * `XMonad.Config.Gnome`
+
+    - Update logout key combination (modm+shift+Q) to work with modern
+
+  * `XMonad.Prompt.Pass`
+
+    - New function `passTypePrompt` which uses `xdotool` to type in a password
+      from the store, bypassing the clipboard.
+    - Now handles password labels with spaces and special characters inside
+      them.
+
+  * `XMonad.Prompt.Unicode`
+
+    - Persist unicode data cache across XMonad instances due to
+      `ExtensibleState` now used instead of `unsafePerformIO`.
+    - `typeUnicodePrompt :: String -> XPConfig -> X ()` provided to insert the
+      Unicode character via `xdotool` instead of copying it to the paste buffer.
+    - `mkUnicodePrompt :: String -> [String] -> String -> XPConfig -> X ()`
+      acts as a generic function to pass the selected Unicode character to any
+      program.
+
+  * `XMonad.Prompt.AppendFile`
+
+    - New function `appendFilePrompt'` which allows for transformation of the
+      string passed by a user before writing to a file.
+
+  * `XMonad.Hooks.DynamicLog`
+
+    - Added a new function `dzenWithFlags` which allows specifying the arguments
+    passed to `dzen2` invocation. The behaviour of current `dzen` function is
+    unchanged.
+
+  * `XMonad.Util.Dzen`
+
+    - Now provides functions `fgColor` and `bgColor` to specify foreground and
+    background color, `align` and `slaveAlign` to set text alignment, and
+    `lineCount` to enable a second (slave) window that displays lines beyond
+    the initial (title) one.
+
+  * `XMonad.Hooks.DynamicLog`
+
+    - Added optional `ppVisibleNoWindows` to differentiate between empty
+      and non-empty visible workspaces in pretty printing.
+
+  * `XMonad.Actions.DynamicWorkspaceOrder`
+
+    - Added `updateName` and `removeName` to better control ordering when
+      workspace names are changed or workspaces are removed.
+
+  * `XMonad.Config.Azerty`
+
+    * Added `belgianConfig` and `belgianKeys` to support Belgian AZERTY
+      keyboards, which are slightly different from the French ones in the top
+      row.
+
+## 0.13 (February 10, 2017)
+
+### Breaking Changes
+
+  * The type of `completionKey` (of `XPConfig` record) has been
+    changed from `KeySym` to `(KeyMask, KeySym)`. The default value
+    for this is still bound to the `Tab` key.
+
+  * New constructor `CenteredAt Rational Rational` added for
+    `XMonad.Prompt.XPPosition`.
+
+  * `XMonad.Prompt` now stores its history file in the XMonad cache
+    directory in a file named `prompt-history`.
+
+### New Modules
+
+  * `XMonad.Layout.SortedLayout`
+
+    A new LayoutModifier that sorts a given layout by a list of
+    properties. The order of properties in the list determines
+    the order of windows in the final layout. Any unmatched windows
+    go to the end of the order.
+
+  * `XMonad.Prompt.Unicode`
+
+    A prompt to search a unicode character by its name, and put it into the
+    clipboard.
+
+  * `XMonad.Util.Ungrab`
+
+    Release xmonad's keyboard and pointer grabs immediately, so
+    screen grabbers and lock utilities, etc. will work. Replaces
+    the short sleep hackaround.
+
+  * `XMonad.Util.Loggers.NamedScratchpad`
+
+    A collection of Loggers (see `XMonad.Util.Loggers`) for NamedScratchpads
+    (see `XMonad.Util.NamedScratchpad`).
+
+  * `XMonad.Util.NoTaskbar`
+
+    Utility function and `ManageHook` to mark a window to be ignored by
+    EWMH taskbars and pagers. Useful for `NamedScratchpad` windows, since
+    you will usually be taken to the `NSP` workspace by them.
+
+### Bug Fixes and Minor Changes
+
+  * `XMonad.Hooks.ManageDocks`,
+
+    - Fix a very annoying bug where taskbars/docs would be
+      covered by windows.
+
+    - Also fix a bug that caused certain Gtk and Qt application to
+      have issues displaying menus and popups.
+
+  * `XMonad.Layout.LayoutBuilder`
+
+    Merge all functionality from `XMonad.Layout.LayoutBuilderP` into
+    `XMonad.Layout.LayoutBuilder`.
+
+  * `XMonad.Actions.WindowGo`
+
+    - Fix `raiseNextMaybe` cycling between 2 workspaces only.
+
+  * `XMonad.Actions.UpdatePointer`
+
+    - Fix bug when cursor gets stuck in one of the corners.
+
+  * `XMonad.Actions.DynamicProjects`
+
+    - Switching away from a dynamic project that contains no windows
+      automatically deletes that project's workspace.
+
+      The project itself was already being deleted, this just deletes
+      the workspace created for it as well.
+
+    - Added function to change the working directory (`changeProjectDirPrompt`)
+
+    - All of the prompts are now multiple mode prompts.  Try using the
+      `changeModeKey` in a prompt and see what happens!
+
+## 0.12 (December 14, 2015)
+
+### Breaking Changes
+
+  * `XMonad.Actions.UpdatePointer.updatePointer` arguments were
+    changed. This allows including aspects of both of the
+    `TowardsCentre` and `Relative` methods. To keep the same behavior,
+    replace the entry in the left column with the entry on the right:
+
+    | < 0.12                              |   >= 0.12                        |
+    |-------------------------------------|----------------------------------|
+    | `updatePointer Nearest`             | `updatePointer (0.5, 0.5) (1,1)` |
+    | `updatePointer (Relative x y)`      | `updatePointer (x,y) (0,0)`      |
+    | `updatePointer (TowardsCentre x y)` | `updatePointer (0.5,0.5) (x,y)`  |
+
+### New Modules
+
+  * `XMonad.Actions.AfterDrag`
+
+    Perform an action after the current mouse drag is completed.
+
+  * `XMonad.Actions.DynamicProjects`
+
+    Imbues workspaces with additional features so they can be treated
+    as individual project areas.
+
+  * `XMonad.Actions.LinkWorkspaces`
+
+    Provides bindings to add and delete links between workspaces. It
+    is aimed at providing useful links between workspaces in a
+    multihead setup. Linked workspaces are viewed at the same time.
+
+  * `XMonad.Config.Bepo`
+
+    This module fixes some of the keybindings for the francophone
+    among you who use a BEPO keyboard layout. Based on
+    `XMonad.Config.Azerty`
+
+  * `XMonad.Config.Dmwit`
+
+    Daniel Wagner's configuration.
+
+  * `XMonad.Config.Mate`
+
+    This module provides a config suitable for use with the MATE
+    desktop environment.
+
+  * `XMonad.Config.Prime`
+
+    A draft of a brand new config syntax for xmonad.
+
+  * `XMonad.Hooks.DynamicProperty`
+
+    Module to apply a `ManageHook` to an already-mapped window when a
+    property changes. This would commonly be used to match browser
+    windows by title, since the final title will only be set after (a)
+    the window is mapped, (b) its document has been loaded, (c) all
+    load-time scripts have run.
+
+  * `XMonad.Hooks.ManageDebug`
+
+    A `manageHook` and associated `logHook` for debugging `ManageHook`s.
+    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.
+
+  * `XMonad.Hooks.WallpaperSetter`
+
+    Log hook which changes the wallpapers depending on visible
+    workspaces.
+
+  * `XMonad.Hooks.WorkspaceHistory`
+
+    Keeps track of workspace viewing order.
+
+  * `XMonad.Layout.AvoidFloats`
+
+    Find a maximum empty rectangle around floating windows and use
+    that area to display non-floating windows.
+
+  * `XMonad.Layout.BinarySpacePartition`
+
+    Layout where new windows will split the focused window in half,
+    based off of BSPWM.
+
+  * `XMonad.Layout.Dwindle`
+
+    Three layouts: The first, `Spiral`, is a reimplementation of
+    `XMonad.Layout.Spiral.spiral` with, at least to me, more intuitive
+    semantics.  The second, `Dwindle`, is inspired by a similar layout
+    in awesome and produces the same sequence of decreasing window
+    sizes as Spiral but pushes the smallest windows into a screen
+    corner rather than the centre.  The third, `Squeeze` arranges all
+    windows in one row or in one column, with geometrically decreasing
+    sizes.
+
+  * `XMonad.Layout.Hidden`
+
+    Similar to `XMonad.Layout.Minimize` but completely removes windows
+    from the window set so `XMonad.Layout.BoringWindows` isn't
+    necessary.  Perfect companion to `XMonad.Layout.BinarySpacePartition`
+    since it can be used to move windows to another part of the BSP tree.
+
+  * `XMonad.Layout.IfMax`
+
+    Provides `IfMax` layout, which will run one layout if there are
+    maximum `N` windows on workspace, and another layout, when number
+    of windows is greater than `N`.
+
+  * `XMonad.Layout.PerScreen`
+
+    Configure layouts based on the width of your screen; use your
+    favorite multi-column layout for wide screens and a full-screen
+    layout for small ones.
+
+  * `XMonad.Layout.Stoppable`
+
+    This module implements a special kind of layout modifier, which when
+    applied to a layout, causes xmonad to stop all non-visible processes.
+    In a way, this is a sledge-hammer for applications that drain power.
+    For example, given a web browser on a stoppable workspace, once the
+    workspace is hidden the web browser will be stopped.
+
+  * `XMonad.Prompt.ConfirmPrompt`
+
+    A module for setting up simple confirmation prompts for
+    keybindings.
+
+  * `XMonad.Prompt.Pass`
+
+    This module provides 3 `XMonad.Prompt`s to ease passwords
+    manipulation (generate, read, remove) via [pass][].
+
+  * `XMonad.Util.RemoteWindows`
+
+    This module implements a proper way of finding out whether the
+    window is remote or local.
+
+  * `XMonad.Util.SpawnNamedPipe`
+
+    A module for spawning a pipe whose `Handle` lives in the xmonad state.
+
+  * `XMonad.Util.WindowState`
+
+    Functions for saving per-window data.
+
+### Miscellaneous Changes
+
+  * Fix issue #9: `XMonad.Prompt.Shell` `searchPredicate` is ignored,
+    defaults to `isPrefixOf`
+
+  * Fix moveHistory when alwaysHighlight is enabled
+
+  * `XMonad.Actions.DynamicWorkspaceGroups` now exports `addRawWSGroup`
+
+  * Side tabs were added to the tabbed layout
+
+  * `XMonad/Layout/IndependentScreens` now exports `marshallSort`
+
+  * `XMonad/Hooks/UrgencyHook` now exports `clearUrgency`
+
+  * Exceptions are now caught when finding commands on `PATH` in `Prompt.Shell`
+
+  * Switched to `Data.Default` wherever possible
+
+  * `XMonad.Layout.IndependentScreens` now exports `whenCurrentOn`
+
+  * `XMonad.Util.NamedActions` now exports `addDescrKeys'`
+
+  * EWMH `DEMANDS_ATTENTION` support added to `UrgencyHook`
+
+  * New `useTransientFor` modifier in `XMonad.Layout.TrackFloating`
+
+  * Added the ability to remove arbitrary workspaces
+
+## 0.9 (October 26, 2009)
+
+### Updates that Require Changes in `xmonad.hs`
+
+  * `XMonad.Hooks.EwmhDesktops` no longer uses `layoutHook`, the
+    `ewmhDesktopsLayout` modifier has been removed from
+    xmonad-contrib. It uses `logHook`, `handleEventHook`, and
+    `startupHook` instead and provides a convenient function `ewmh` to
+    add EWMH support to a `defaultConfig`.
+
+  * Most `DynamicLog` users can continue with configs unchanged, but
+    users of the quickbar functions `xmobar` or `dzen` will need to
+    change `xmonad.hs`: their types have changed to allow easier
+    composition with other `XConfig` modifiers. The `dynamicLogDzen`
+    and `dynamicLogXmobar` functions have been removed.
+
+  * `WindowGo` or `safeSpawn` users may need to change command lines
+    due to `safeSpawn` changes.
+
+  * People explicitly referencing the "SP" scratchpad workspace should
+    change it to "NSP" which is also used by the new
+    `Util.NamedScratchpad` module.
+
+  * (Optional) People who explicitly use `swapMaster` in key or mouse
+    bindings should change it to `shiftMaster`. It's the current
+    default used where `swapMaster` had been used previously. It works
+    better than `swapMaster` when using floating and tiled windows
+    together on the same workspace.
+
+## See Also
+
+<https://wiki.haskell.org/Xmonad/Notable_changes_since_0.8>
+
+[pass]: http://www.passwordstore.org/

README

@@ -1,82 +0,0 @@
-  xmonad-contrib : third party extensions to the xmonad window manager
-
-                           http://xmonad.org
-
-    You need the ghc compiler and xmonad window manager installed in
-    order to use these extensions.
-
-    For installation and configuration instructions, please see the
-    xmonad website, the documents included with the xmonad source
-    distribution, and online haddock documentation:
-
-    http://www.xmonad.org/xmonad-docs
-
-------------------------------------------------------------------------
-
-Changelogs
-
-    For a list of changes since the 0.8.x releases, see:
-
-http://www.haskell.org/haskellwiki/Xmonad/Notable_changes_since_0.8
-
-------------------------------------------------------------------------
-
-Updates to XMonadContrib-0.9 that may Require Changes to ~/.xmonad/xmonad.hs
-
-    Please see the Changelogs and xmonad-contrib haddock documentation
-    links for further details regarding the following changes.
-
-    * XMonad.Hooks.EwmhDesktops no longer uses layoutHook, the
-    ewmhDesktopsLayout modifier has been removed from xmonad-contrib. It
-    uses logHook, handleEventHook, and startupHook instead and provides
-    a convenient function 'ewmh' to add EWMH support to a defaultConfig.
-
-    * Most DynamicLog users can continue with configs unchanged, but users
-    of the quickbar functions 'xmobar' or 'dzen' will need to change
-    xmonad.hs: their types have changed to allow easier composition with
-    other XConfig modifiers. The 'dynamicLogDzen' and 'dynamicLogXmobar'
-    functions have been removed.
-
-    * WindowGo or safeSpawn users may need to change command lines due to
-    safeSpawn changes.
-
-    * People explicitly referencing the "SP" scratchpad workspace should
-    change it to "NSP" which is also used by the new Util.NamedScratchpad.
-
-    * (Optional) People who explicitly use swapMaster in key or mouse
-    bindings should change it to shiftMaster. It's the current default
-    used where swapMaster had been used previously. It works better than
-    swapMaster when using floating and tiled windows together on the
-    same workspace.
-
-------------------------------------------------------------------------
-
-Getting or updating XMonadContrib
-
-    latest release: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/xmonad-contrib
-
-    darcs version:  darcs get http://code.haskell.org/XMonadContrib
-
-    (To use darcs xmonad-contrib you must also use the darcs version
-    of xmonad.)
-
-------------------------------------------------------------------------
-
-Contributing
-
-    Haskell code contributed to this repo should live under the
-    appropriate subdivision of the 'XMonad.' namespace (currently
-    includes Actions, Config, Hooks, Layout, Prompt, and Util). For
-    example, to use the Grid layout, one would import:
-
-        XMonad.Layout.Grid
-
-    For further details, see the documentation for the
-    XMonad.Doc.Developing module and http://xmonad.org website.
-
-------------------------------------------------------------------------
-
-Code submitted to the contrib repo is licensed under the same license as
-xmonad itself, with copyright held by the authors.
-
-------------------------------------------------------------------------

README.md

@@ -0,0 +1,43 @@
+# xmonad-contrib: Third Party Extensions to the xmonad Window Manager
+
+[![Build Status](https://travis-ci.org/xmonad/xmonad-contrib.svg?branch=master)](https://travis-ci.org/xmonad/xmonad-contrib)
+[![Open Source Helpers](https://www.codetriage.com/xmonad/xmonad-contrib/badges/users.svg)](https://www.codetriage.com/xmonad/xmonad-contrib)
+
+You need the ghc compiler and xmonad window manager installed in
+order to use these extensions.
+
+For installation and configuration instructions, please see the
+[xmonad website][xmonad], the documents included with the
+[xmonad source distribution][xmonad-git], and the
+[online haddock documentation][xmonad-docs].
+
+## Getting or Updating XMonadContrib
+
+  * Latest release: <https://hackage.haskell.org/package/xmonad-contrib>
+
+  * Git version: <https://github.com/xmonad/xmonad-contrib>
+
+(To use git xmonad-contrib you must also use the
+[git version of xmonad][xmonad-git].)
+
+## Contributing
+
+Haskell code contributed to this repo should live under the
+appropriate subdivision of the `XMonad` namespace (currently includes
+`Actions`, `Config`, `Hooks`, `Layout`, `Prompt`, and `Util`). For
+example, to use the Grid layout, one would import:
+
+    XMonad.Layout.Grid
+
+For further details, see the [documentation][developing] for the
+`XMonad.Doc.Developing` module, XMonad's [CONTRIBUTING.md](https://github.com/xmonad/xmonad/blob/master/CONTRIBUTING.md)  and the [xmonad website][xmonad].
+
+## License
+
+Code submitted to the contrib repo is licensed under the same license as
+xmonad itself, with copyright held by the authors.
+ 
+[xmonad]: http://xmonad.org
+[xmonad-git]: https://github.com/xmonad/xmonad
+[xmonad-docs]: http://hackage.haskell.org/package/xmonad
+[developing]: http://hackage.haskell.org/package/xmonad-contrib/docs/XMonad-Doc-Developing.html

XMonad/Actions/AfterDrag.hs

@@ -0,0 +1,71 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  XMonad.Actions.AfterDrag
+-- Copyright   :  (c) 2014 Anders Engstrom <ankaan@gmail.com>
+-- License     :  BSD3-style (see LICENSE)
+--
+-- Maintainer  :  Anders Engstrom <ankaan@gmail.com>
+-- Stability   :  unstable
+-- Portability :  unportable
+--
+-- Perform an action after the current mouse drag is completed.
+-----------------------------------------------------------------------------
+
+module XMonad.Actions.AfterDrag (
+                -- * Usage
+                -- $usage
+                afterDrag,
+                ifClick,
+                ifClick') where
+
+import XMonad
+import System.Time
+
+-- $usage
+-- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:
+--
+-- >    import XMonad.Actions.AfterDrag
+--
+-- Then add appropriate mouse bindings, for example:
+--
+-- >        , ((modm, button3), (\w -> focus w >> mouseResizeWindow w >> ifClick (windows $ W.float w $ W.RationalRect 0 0 1 1)))
+--
+-- This will allow you to resize windows as usual, but if you instead of
+-- draging click the mouse button the window will be automatically resized to
+-- fill the whole screen.
+--
+-- For detailed instructions on editing your mouse bindings, see
+-- "XMonad.Doc.Extending#Editing_mouse_bindings".
+--
+-- More practical examples are available in "XMonad.Actions.FloatSnap".
+
+-- | Schedule a task to take place after the current dragging is completed.
+afterDrag
+    :: X () -- ^ The task to schedule.
+    -> X ()
+afterDrag task = do drag <- gets dragging
+                    case drag of
+                        Nothing -> return () -- Not dragging
+                        Just (motion, cleanup) -> modify $ \s -> s { dragging = Just(motion, cleanup >> task) }
+
+-- | Take an action if the current dragging can be considered a click,
+--   supposing the drag just started before this function is called.
+--   A drag is considered a click if it is completed within 300 ms.
+ifClick
+  :: X ()   -- ^ The action to take if the dragging turned out to be a click.
+  -> X () 
+ifClick action = ifClick' 300 action (return ())
+
+-- | Take an action if the current dragging is completed within a certain time (in milliseconds.)
+ifClick'
+  :: Int    -- ^ Maximum time of dragging for it to be considered a click (in milliseconds.)
+  -> X ()   -- ^ The action to take if the dragging turned out to be a click.
+  -> X ()   -- ^ The action to take if the dragging turned out to not be a click.
+  -> X () 
+ifClick' ms click drag = do
+  start <- io $ getClockTime
+  afterDrag $ do 
+    stop <- io $ getClockTime
+    if diffClockTimes stop start <= noTimeDiff { tdPicosec = fromIntegral ms * 10^(9 :: Integer) }
+      then click
+      else drag

XMonad/Actions/BluetileCommands.hs

@@ -36,7 +36,7 @@ import System.Exit
 --
 -- Then edit your @handleEventHook@:
 --
--- > main = xmonad defaultConfig { handleEventHook = serverModeEventHook' bluetileCommands }
+-- > main = xmonad def { handleEventHook = serverModeEventHook' bluetileCommands }
 --
 -- See the documentation of "XMonad.Hooks.ServerMode" for details on
 -- how to actually invoke the commands from external programs.

XMonad/Actions/Commands.hs

@@ -19,6 +19,7 @@ module XMonad.Actions.Commands (
                              -- $usage
                              commandMap,
                              runCommand,
+                             runCommandConfig,
                              runCommand',
                              workspaceCommands,
                              screenCommands,
@@ -103,11 +104,18 @@ defaultCommands = do
         ]
 
 -- | Given a list of command\/action pairs, prompt the user to choose a
---   command and return the corresponding action.
+--   command using dmenu and return the corresponding action.
 runCommand :: [(String, X ())] -> X ()
-runCommand cl = do
+runCommand = runCommandConfig dmenu
+
+
+-- | Given a list of command\/action pairs, prompt the user to choose a
+--   command using dmenu-compatible launcher and return the corresponding action.
+--   See X.U.Dmenu for compatible launchers.
+runCommandConfig :: ([String] -> X String) -> [(String, X ())] -> X()
+runCommandConfig f cl = do
   let m = commandMap cl
-  choice <- dmenu (M.keys m)
+  choice <- f (M.keys m)
   fromMaybe (return ()) (M.lookup choice m)
 
 -- | Given the name of a command from 'defaultCommands', return the

XMonad/Actions/CopyWindow.hs

@@ -87,7 +87,7 @@ import qualified XMonad.StackSet as W
 -- >
 -- > main = do
 -- >    h <- spawnPipe "xmobar"
--- >    xmonad defaultConfig { logHook = sampleLogHook h }
+-- >    xmonad def { logHook = sampleLogHook h }
 
 -- | Copy the focused window to a workspace.
 copy :: (Eq s, Eq i, Eq a) => i -> W.StackSet i l a s sd -> W.StackSet i l a s sd

XMonad/Actions/CycleWS.hs

@@ -78,11 +78,11 @@ module XMonad.Actions.CycleWS (
 
                              ) where
 
-import Control.Monad ( unless )
-import Data.List ( findIndex )
+import Data.List ( find, findIndex )
 import Data.Maybe ( isNothing, isJust )
 
 import XMonad hiding (workspaces)
+import qualified XMonad.Hooks.WorkspaceHistory as WH
 import XMonad.StackSet hiding (filter)
 import XMonad.Util.Types
 import XMonad.Util.WorkspaceCompare
@@ -119,6 +119,10 @@ import XMonad.Util.WorkspaceCompare
 --
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings".
+--
+-- When using the toggle functions, in order to ensure that the workspace
+-- to which you switch is the previously viewed workspace, use the
+-- 'logHook' in "XMonad.Hooks.WorkspaceHistory".
 
 {- $moving
 
@@ -158,9 +162,7 @@ toggleWS = toggleWS' []
 -- > -- Ignore the scratchpad workspace while toggling:
 -- > ("M-b", toggleWS' ["NSP"])
 toggleWS' :: [WorkspaceId] -> X ()
-toggleWS' skips = do
-    hs' <- cleanHiddens skips
-    unless (null hs') (windows . view . tag $ head hs')
+toggleWS' skips = lastViewedHiddenExcept skips >>= flip whenJust (windows . view)
 
 -- | 'XMonad.StackSet.greedyView' a workspace, or if already there, view
 -- the previously displayed workspace ala weechat. Change @greedyView@ to
@@ -184,10 +186,9 @@ toggleOrView = toggleOrDoSkip [] greedyView
 toggleOrDoSkip :: [WorkspaceId] -> (WorkspaceId -> WindowSet -> WindowSet)
                                   -> WorkspaceId -> X ()
 toggleOrDoSkip skips f toWS = do
-    hs' <- cleanHiddens skips
     cur <- gets (currentTag . windowset)
     if toWS == cur
-        then unless (null hs') (windows . f . tag $ head hs')
+        then lastViewedHiddenExcept skips >>= flip whenJust (windows . f)
         else windows (f toWS)
 
 -- | List difference ('\\') for workspaces and tags. Removes workspaces
@@ -195,8 +196,16 @@ toggleOrDoSkip skips f toWS = do
 skipTags :: (Eq i) => [Workspace i l a] -> [i] -> [Workspace i l a]
 skipTags wss ids = filter ((`notElem` ids) . tag) wss
 
-cleanHiddens :: [WorkspaceId] -> X [WindowSpace]
-cleanHiddens skips =  gets $ (flip skipTags) skips . hidden . windowset
+-- | Ignoring the skips, find the best candidate for the last viewed hidden
+-- workspace.
+lastViewedHiddenExcept :: [WorkspaceId] -> X (Maybe WorkspaceId)
+lastViewedHiddenExcept skips = do
+    hs <- gets $ map tag . flip skipTags skips . hidden . windowset
+    vs <- WH.workspaceHistory
+    return $ choose hs (find (`elem` hs) vs)
+    where choose []    _           = Nothing
+          choose (h:_) Nothing     = Just h
+          choose _     vh@(Just _) = vh
 
 switchWorkspace :: Int -> X ()
 switchWorkspace d = wsBy d >>= windows . greedyView
@@ -230,6 +239,7 @@ data WSType = EmptyWS     -- ^ cycle through empty workspaces
             | NonEmptyWS  -- ^ cycle through non-empty workspaces
             | HiddenWS    -- ^ cycle through non-visible workspaces
             | HiddenNonEmptyWS  -- ^ cycle through non-empty non-visible workspaces
+            | HiddenEmptyWS  -- ^ cycle through empty non-visible workspaces
             | AnyWS       -- ^ cycle through all workspaces
             | WSTagGroup Char
                           -- ^ cycle through workspaces in the same group, the
@@ -248,6 +258,9 @@ wsTypeToPred HiddenWS   = do hs <- gets (map tag . hidden . windowset)
 wsTypeToPred HiddenNonEmptyWS  = do ne <- wsTypeToPred NonEmptyWS
                                     hi <- wsTypeToPred HiddenWS
                                     return (\w -> hi w && ne w)
+wsTypeToPred HiddenEmptyWS  = do ne <- wsTypeToPred EmptyWS
+                                 hi <- wsTypeToPred HiddenWS
+                                 return (\w -> hi w && ne w)
 wsTypeToPred AnyWS      = return (const True)
 wsTypeToPred (WSTagGroup sep) = do cur <- (groupName.workspace.current) `fmap` gets windowset
                                    return $ (cur ==).groupName

XMonad/Actions/CycleWorkspaceByScreen.hs

@@ -0,0 +1,102 @@
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  XMonad.Actions.CycleWorkspaceByScreen
+-- Copyright   :  (c) 2017 Ivan Malison
+-- License     :  BSD3-style (see LICENSE)
+--
+-- Maintainer  :  IvanMalison@gmail.com
+-- Stability   :  unstable
+-- Portability :  unportable
+--
+-- Cycle through previously viewed workspaces in the order they were viewed most
+-- recently on the screen where cycling is taking place.
+--
+-----------------------------------------------------------------------------
+
+module XMonad.Actions.CycleWorkspaceByScreen (
+    -- * Usage
+    -- $usage
+    cycleWorkspaceOnScreen
+  , cycleWorkspaceOnCurrentScreen
+  , handleKeyEvent
+  , repeatableAction
+  ) where
+
+import           Control.Monad
+import           Data.IORef
+import           Data.List
+import           Data.Maybe
+
+import           Graphics.X11.Xlib.Extras
+
+import           XMonad
+import           XMonad.Hooks.WorkspaceHistory
+import qualified XMonad.StackSet as W
+
+-- $usage
+-- This module must be used in conjuction with XMonad.Hooks.WorkspaceHistory
+--
+-- To use, add something like the following to your keybindings
+-- , ((mod4Mask,  xK_slash), cycleWorkspaceOnCurrentScreen [xK_Super_L] xK_slash xK_p)
+
+repeatableAction :: [KeySym] -> (EventType -> KeySym -> X ()) -> X ()
+repeatableAction mods pressHandler = do
+  XConf {theRoot = root, display = d} <- ask
+  let getNextEvent = io $ allocaXEvent $ \p ->
+                 do
+                   maskEvent d (keyPressMask .|. keyReleaseMask) p
+                   KeyEvent {ev_event_type = t, ev_keycode = c} <- getEvent p
+                   s <- io $ keycodeToKeysym d c 0
+                   return (t, s)
+      handleEvent (t, s)
+        | t == keyRelease && s `elem` mods = return ()
+        | otherwise = (pressHandler t s) >> getNextEvent >>= handleEvent
+
+  io $ grabKeyboard d root False grabModeAsync grabModeAsync currentTime
+  getNextEvent >>= handleEvent
+  io $ ungrabKeyboard d currentTime
+
+handleKeyEvent :: EventType
+               -> KeySym
+               -> X ()
+               -> EventType
+               -> KeySym
+               -> Maybe (X ())
+handleKeyEvent eventType key action = helper
+  where
+  helper et k
+    | et == eventType && k == key = Just action
+    | otherwise = Nothing
+
+
+runFirst :: [EventType -> KeySym -> Maybe (X ())] -> EventType -> KeySym -> X ()
+runFirst matchers eventType key =
+  fromMaybe (return ()) $ join $ find isJust $ map (\fn -> fn eventType key) matchers
+
+cycleWorkspaceOnScreen :: ScreenId -> [KeySym] -> KeySym -> KeySym -> X ()
+cycleWorkspaceOnScreen screenId mods nextKey prevKey = workspaceHistoryTransaction $ do
+  startingHistory <- workspaceHistoryByScreen
+  currentWSIndex <- io $ newIORef 1
+  let cycleWorkspaces = fromMaybe [] $ lookup screenId startingHistory
+      getAndIncrementWS increment = do
+        current <- readIORef currentWSIndex
+        modifyIORef
+          currentWSIndex
+          ((`mod` (length cycleWorkspaces)) . (+ increment))
+        return $ cycleWorkspaces !! current
+      focusIncrement i = (io $ getAndIncrementWS i) >>= (windows . W.greedyView)
+
+  focusIncrement 1 -- Do the first workspace cycle
+  repeatableAction mods $
+    runFirst
+      [ handleKeyEvent keyPress nextKey $ focusIncrement 1
+      , handleKeyEvent keyPress prevKey $ focusIncrement (-1)
+      ]
+  return ()
+
+cycleWorkspaceOnCurrentScreen
+  :: [KeySym] -> KeySym -> KeySym -> X ()
+cycleWorkspaceOnCurrentScreen mods n p =
+  withWindowSet $ \ws ->
+    cycleWorkspaceOnScreen (W.screen $ W.current ws) mods n p

XMonad/Actions/DynamicProjects.hs

@@ -0,0 +1,363 @@
+{-# LANGUAGE DeriveDataTypeable #-}
+
+--------------------------------------------------------------------------------
+-- |
+-- Module      :  XMonad.Actions.DynamicProjects
+-- Copyright   :  (c) Peter J. Jones
+-- License     :  BSD3-style (see LICENSE)
+--
+-- Maintainer  :  Peter Jones <pjones@devalot.com>
+-- Stability   :  unstable
+-- Portability :  not portable
+--
+-- Imbues workspaces with additional features so they can be treated
+-- as individual project areas.
+--------------------------------------------------------------------------------
+module XMonad.Actions.DynamicProjects
+       ( -- * Overview
+         -- $overview
+
+         -- * Usage
+         -- $usage
+
+         -- * Types
+         Project (..)
+       , ProjectName
+
+         -- * Hooks
+       , dynamicProjects
+
+         -- * Bindings
+       , switchProjectPrompt
+       , shiftToProjectPrompt
+       , renameProjectPrompt
+       , changeProjectDirPrompt
+
+         -- * Helper Functions
+       , switchProject
+       , shiftToProject
+       , lookupProject
+       , currentProject
+       , activateProject
+       ) where
+
+--------------------------------------------------------------------------------
+import Control.Applicative ((<|>))
+import Control.Monad (when, unless)
+import Data.Char (isSpace)
+import Data.List (sort, union, stripPrefix)
+import Data.Map.Strict (Map)
+import qualified Data.Map.Strict as Map
+import Data.Maybe (fromMaybe, isNothing)
+import Data.Monoid ((<>))
+import System.Directory (setCurrentDirectory, getHomeDirectory)
+import XMonad
+import XMonad.Actions.DynamicWorkspaces
+import XMonad.Prompt
+import XMonad.Prompt.Directory
+import qualified XMonad.StackSet as W
+import qualified XMonad.Util.ExtensibleState as XS
+
+--------------------------------------------------------------------------------
+-- $overview
+-- Inspired by @TopicSpace@, @DynamicWorkspaces@, and @WorkspaceDir@,
+-- @DynamicProjects@ treats workspaces as projects while maintaining
+-- compatibility with all existing workspace-related functionality in
+-- XMonad.
+--
+-- Instead of using generic workspace names such as @3@ or @work@,
+-- @DynamicProjects@ allows you to dedicate workspaces to specific
+-- projects and then switch between projects easily.
+--
+-- A project is made up of a name, working directory, and a start-up
+-- hook.  When you switch to a workspace, @DynamicProjects@ changes
+-- the working directory to the one configured for the matching
+-- project.  If the workspace doesn't have any windows, the project's
+-- start-up hook is executed.  This allows you to launch applications
+-- or further configure the workspace/project.
+--
+-- When using the @switchProjectPrompt@ function, workspaces are
+-- created as needed.  This means you can create new project spaces
+-- (and therefore workspaces) on the fly.  (These dynamic projects are
+-- not preserved across restarts.)
+--
+-- Additionally, frequently used projects can be configured statically
+-- in your XMonad configuration.  Doing so allows you to configure the
+-- per-project start-up hook.
+
+--------------------------------------------------------------------------------
+-- $usage
+-- To use @DynamicProjects@ you need to add it to your XMonad
+-- configuration and then configure some optional key bindings.
+--
+-- > import XMonad.Actions.DynamicProjects
+--
+-- Start by defining some projects:
+--
+-- > projects :: [Project]
+-- > projects =
+-- >   [ Project { projectName      = "scratch"
+-- >             , projectDirectory = "~/"
+-- >             , projectStartHook = Nothing
+-- >             }
+-- >
+-- >   , Project { projectName      = "browser"
+-- >             , projectDirectory = "~/download"
+-- >             , projectStartHook = Just $ do spawn "conkeror"
+-- >                                            spawn "chromium"
+-- >             }
+-- >   ]
+--
+-- Then inject @DynamicProjects@ into your XMonad configuration:
+--
+-- > main = xmonad $ dynamicProjects projects def
+--
+-- And finally, configure some optional key bindings:
+--
+-- >  , ((modm, xK_space), switchProjectPrompt)
+-- >  , ((modm, xK_slash), shiftToProjectPrompt)
+--
+-- For detailed instructions on editing your key bindings, see
+-- "XMonad.Doc.Extending#Editing_key_bindings".
+
+--------------------------------------------------------------------------------
+type ProjectName  = String
+type ProjectTable = Map ProjectName Project
+
+--------------------------------------------------------------------------------
+-- | Details about a workspace that represents a project.
+data Project = Project
+  { projectName      :: !ProjectName    -- ^ Workspace name.
+  , projectDirectory :: !FilePath       -- ^ Working directory.
+  , projectStartHook :: !(Maybe (X ())) -- ^ Optional start-up hook.
+  } deriving Typeable
+
+--------------------------------------------------------------------------------
+-- | Internal project state.
+data ProjectState = ProjectState
+  { projects        :: !ProjectTable
+  , previousProject :: !(Maybe WorkspaceId)
+  } deriving Typeable
+
+--------------------------------------------------------------------------------
+instance ExtensionClass ProjectState where
+  initialValue = ProjectState Map.empty Nothing
+
+--------------------------------------------------------------------------------
+-- Internal types for working with XPrompt.
+data ProjectPrompt = ProjectPrompt ProjectMode [ProjectName]
+data ProjectMode = SwitchMode | ShiftMode | RenameMode | DirMode
+
+instance XPrompt ProjectPrompt where
+  showXPrompt (ProjectPrompt submode _) =
+    case submode of
+      SwitchMode -> "Switch or Create Project: "
+      ShiftMode  -> "Send Window to Project: "
+      RenameMode -> "New Project Name: "
+      DirMode    -> "Change Project Directory: "
+
+  completionFunction (ProjectPrompt RenameMode _) = return . (:[])
+  completionFunction (ProjectPrompt DirMode _) =
+    let xpt = directoryMultipleModes "" (const $ return ())
+    in completionFunction xpt
+  completionFunction (ProjectPrompt _ ns) = mkComplFunFromList' ns
+
+  modeAction (ProjectPrompt SwitchMode _) buf auto = do
+    let name = if null auto then buf else auto
+    ps <- XS.gets projects
+
+    case Map.lookup name ps of
+      Just p              -> switchProject p
+      Nothing | null name -> return ()
+              | otherwise -> switchProject (defProject name)
+
+  modeAction (ProjectPrompt ShiftMode _) buf auto = do
+    let name = if null auto then buf else auto
+    ps <- XS.gets projects
+    shiftToProject . fromMaybe (defProject name) $ Map.lookup name ps
+
+  modeAction (ProjectPrompt RenameMode _) name _ =
+    when (not (null name) && not (all isSpace name)) $ do
+      renameWorkspaceByName name
+      modifyProject (\p -> p { projectName = name })
+
+  modeAction (ProjectPrompt DirMode _) buf auto = do
+    let dir = if null auto then buf else auto
+    modifyProject (\p -> p { projectDirectory = dir })
+
+--------------------------------------------------------------------------------
+-- | Add dynamic projects support to the given config.
+dynamicProjects :: [Project] -> XConfig a -> XConfig a
+dynamicProjects ps c =
+  c { startupHook     = dynamicProjectsStartupHook ps <> startupHook c
+    , logHook         = dynamicProjectsLogHook        <> logHook c
+    }
+
+--------------------------------------------------------------------------------
+-- | Log hook for tracking workspace changes.
+dynamicProjectsLogHook :: X ()
+dynamicProjectsLogHook = do
+  name   <- gets (W.tag . W.workspace . W.current . windowset)
+  xstate <- XS.get
+
+  unless (Just name == previousProject xstate) $ do
+    XS.put (xstate {previousProject = Just name})
+    activateProject . fromMaybe (defProject name) $
+      Map.lookup name (projects xstate)
+
+--------------------------------------------------------------------------------
+-- | Start-up hook for recording configured projects.
+dynamicProjectsStartupHook :: [Project] -> X ()
+dynamicProjectsStartupHook ps = XS.modify go
+  where
+    go :: ProjectState -> ProjectState
+    go s = s {projects = update $ projects s}
+
+    update :: ProjectTable -> ProjectTable
+    update = Map.union (Map.fromList $ map entry ps)
+
+    entry :: Project -> (ProjectName, Project)
+    entry p = (projectName p, addDefaultHook p)
+
+    -- Force the hook to be a @Just@ so that it doesn't automatically
+    -- get deleted when switching away from a workspace with no
+    -- windows.
+    addDefaultHook :: Project -> Project
+    addDefaultHook p = p { projectStartHook = projectStartHook p <|>
+                                              Just (return ())
+                         }
+
+--------------------------------------------------------------------------------
+-- | Find a project based on its name.
+lookupProject :: ProjectName -> X (Maybe Project)
+lookupProject name = Map.lookup name `fmap` XS.gets projects
+
+--------------------------------------------------------------------------------
+-- | Fetch the current project (the one being used for the currently
+-- active workspace).
+currentProject :: X Project
+currentProject = do
+  name <- gets (W.tag . W.workspace . W.current . windowset)
+  proj <- lookupProject name
+  return $ fromMaybe (defProject name) proj
+
+--------------------------------------------------------------------------------
+-- | Modify the current project using a pure function.
+modifyProject :: (Project -> Project) -> X ()
+modifyProject f = do
+  p  <- currentProject
+  ps <- XS.gets projects
+
+  -- If a project is renamed to match another project, the old project
+  -- will be removed and replaced with this one.
+  let new = f p
+      ps' = Map.insert (projectName new) new $ Map.delete (projectName p) ps
+
+  XS.modify $ \s -> s {projects = ps'}
+  activateProject new
+
+--------------------------------------------------------------------------------
+-- | Switch to the given project.
+switchProject :: Project -> X ()
+switchProject p = do
+  oldws <- gets (W.workspace . W.current . windowset)
+  oldp <- currentProject
+
+  let name = W.tag oldws
+      ws   = W.integrate' (W.stack oldws)
+
+  -- If the project we are switching away from has no windows, and
+  -- it's a dynamic project, remove it from the configuration.
+  when (null ws && isNothing (projectStartHook oldp)) $ do
+    removeWorkspaceByTag name -- also remove the old workspace
+    XS.modify (\s -> s {projects = Map.delete name $ projects s})
+
+  appendWorkspace (projectName p)
+
+--------------------------------------------------------------------------------
+-- | Prompt for a project name and then switch to it.  Automatically
+-- creates a project if a new name is returned from the prompt.
+switchProjectPrompt :: XPConfig -> X ()
+switchProjectPrompt = projectPrompt [ SwitchMode
+                                    , ShiftMode
+                                    , RenameMode
+                                    , DirMode
+                                    ]
+
+--------------------------------------------------------------------------------
+-- | Shift the currently focused window to the given project.
+shiftToProject :: Project -> X ()
+shiftToProject p = do
+  addHiddenWorkspace (projectName p)
+  windows (W.shift $ projectName p)
+
+--------------------------------------------------------------------------------
+-- | Prompts for a project name and then shifts the currently focused
+-- window to that project.
+shiftToProjectPrompt :: XPConfig -> X ()
+shiftToProjectPrompt = projectPrompt [ ShiftMode
+                                     , RenameMode
+                                     , SwitchMode
+                                     , DirMode
+                                     ]
+
+--------------------------------------------------------------------------------
+-- | Rename the current project.
+renameProjectPrompt :: XPConfig -> X ()
+renameProjectPrompt = projectPrompt [ RenameMode
+                                    , DirMode
+                                    , SwitchMode
+                                    , ShiftMode
+                                    ]
+
+--------------------------------------------------------------------------------
+-- | Change the working directory used for the current project.
+--
+-- NOTE: This will only affect new processed started in this project.
+-- Existing processes will maintain the previous working directory.
+changeProjectDirPrompt :: XPConfig -> X ()
+changeProjectDirPrompt = projectPrompt [ DirMode
+                                       , SwitchMode
+                                       , ShiftMode
+                                       , RenameMode
+                                       ]
+
+--------------------------------------------------------------------------------
+-- | Prompt for a project name.
+projectPrompt :: [ProjectMode] -> XPConfig -> X ()
+projectPrompt submodes c = do
+  ws <- map W.tag `fmap` gets (W.workspaces . windowset)
+  ps <- XS.gets projects
+
+  let names = sort (Map.keys ps `union` ws)
+      modes = map (\m -> XPT $ ProjectPrompt m names) submodes
+
+  mkXPromptWithModes modes c
+
+--------------------------------------------------------------------------------
+-- | Activate a project by updating the working directory and
+-- possibly running its start-up hook.  This function is automatically
+-- invoked when the workspace changes.
+activateProject :: Project -> X ()
+activateProject p = do
+    ws   <- gets (W.integrate' . W.stack . W.workspace . W.current . windowset)
+    home <- io getHomeDirectory
+
+    -- Change to the project's directory.
+    catchIO (setCurrentDirectory $ expandHome home $ projectDirectory p)
+
+    -- Possibly run the project's startup hook.
+    when (null ws) $ fromMaybe (return ()) (projectStartHook p)
+
+  where
+
+    -- Replace an initial @~@ character with the home directory.
+    expandHome :: FilePath -> FilePath -> FilePath
+    expandHome home dir = case stripPrefix "~" dir of
+      Nothing -> dir
+      Just xs -> home ++ xs
+
+--------------------------------------------------------------------------------
+-- | Default project.
+defProject :: ProjectName -> Project
+defProject name = Project name "~/" Nothing

XMonad/Actions/DynamicWorkspaceGroups.hs

@@ -23,6 +23,7 @@ module XMonad.Actions.DynamicWorkspaceGroups
 
       WSGroupId
 
+    , addRawWSGroup
     , addWSGroup
     , addCurrentWSGroup
     , forgetWSGroup
@@ -72,20 +73,27 @@ instance ExtensionClass WSGroupStorage where
   initialValue = WSG $ M.empty
   extensionType = PersistentExtension
 
+-- | Add a new workspace group of the given name, mapping to an
+--   explicitly specified association between screen IDs and workspace
+--   names.  This function could be useful for, say, creating some
+--   standard workspace groups in your startup hook.
+addRawWSGroup :: WSGroupId -> [(ScreenId, WorkspaceId)] -> X ()
+addRawWSGroup name = XS.modify . withWSG . M.insert name
+
 -- | Add a new workspace group with the given name.
 addWSGroup :: WSGroupId -> [WorkspaceId] -> X ()
 addWSGroup name wids = withWindowSet $ \w -> do
   let wss  = map ((W.tag . W.workspace) &&& W.screen) $ W.screens w
       wmap = mapM (strength . (flip lookup wss &&& id)) wids
   case wmap of
-    Just ps -> XS.modify . withWSG . M.insert name $ ps
+    Just ps -> addRawWSGroup name ps
     Nothing -> return ()
  where strength (ma, b) = ma >>= \a -> return (a,b)
 
 -- | Give a name to the current workspace group.
 addCurrentWSGroup :: WSGroupId -> X ()
 addCurrentWSGroup name = withWindowSet $ \w ->
-  addWSGroup name $ map (W.tag . W.workspace) (W.current w : W.visible w)
+  addWSGroup name $ map (W.tag . W.workspace) (reverse $ W.current w : W.visible w)
 
 -- | Delete the named workspace group from the list of workspace
 --   groups.  Note that this has no effect on the workspaces involved;

XMonad/Actions/DynamicWorkspaceOrder.hs

@@ -23,6 +23,8 @@ module XMonad.Actions.DynamicWorkspaceOrder
       getWsCompareByOrder
     , getSortByOrder
     , swapWith
+    , updateName
+    , removeName
 
     , moveTo
     , moveToGreedy
@@ -152,6 +154,21 @@ swapOrder w1 w2 = do
   XS.modify (withWSO (M.insert w1 i2 . M.insert w2 i1))
   windows id  -- force a status bar update
 
+-- | Update the name of a workspace in the stored order.
+updateName :: WorkspaceId -> WorkspaceId -> X ()
+updateName oldId newId = XS.modify . withWSO $ changeKey oldId newId
+
+-- | Remove a workspace from the stored order.
+removeName :: WorkspaceId -> X ()
+removeName = XS.modify . withWSO . M.delete
+
+-- | Update a key in a Map.
+changeKey :: Ord k => k -> k -> M.Map k a -> M.Map k a
+changeKey oldKey newKey oldMap =
+  case M.updateLookupWithKey (\_ _ -> Nothing) oldKey oldMap of
+    (Nothing, _) -> oldMap
+    (Just val, newMap) -> M.insert newKey val newMap
+
 -- | View the next workspace of the given type in the given direction,
 -- where \"next\" is determined using the dynamic workspace order.
 moveTo :: Direction1D -> WSType -> X ()
@@ -175,4 +192,4 @@ withNthWorkspace job wnum = do
   ws <- gets (map W.tag . sort . W.workspaces . windowset)
   case drop wnum ws of
     (w:_) -> windows $ job w
-    []    -> return ()
+    []    -> return ()

XMonad/Actions/DynamicWorkspaces.hs

@@ -1,3 +1,5 @@
+{-# LANGUAGE DeriveDataTypeable #-}
+
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  XMonad.Actions.DynamicWorkspaces
@@ -16,15 +18,21 @@ module XMonad.Actions.DynamicWorkspaces (
                                          -- * Usage
                                          -- $usage
                                          addWorkspace, addWorkspacePrompt,
+                                         appendWorkspace, appendWorkspacePrompt,
+                                         addWorkspaceAt,
                                          removeWorkspace,
+                                         removeWorkspaceByTag,
                                          removeEmptyWorkspace,
+                                         removeEmptyWorkspaceByTag,
                                          removeEmptyWorkspaceAfter,
                                          removeEmptyWorkspaceAfterExcept,
-                                         addHiddenWorkspace,
+                                         addHiddenWorkspace, addHiddenWorkspaceAt,
                                          withWorkspace,
                                          selectWorkspace, renameWorkspace,
                                          renameWorkspaceByName,
-                                         toNthWorkspace, withNthWorkspace
+                                         toNthWorkspace, withNthWorkspace,
+                                         setWorkspaceIndex, withWorkspaceIndex,
+                                         WorkspaceIndex
                                        ) where
 
 import XMonad hiding (workspaces)
@@ -35,6 +43,8 @@ import XMonad.Util.WorkspaceCompare ( getSortByIndex )
 import Data.List (find)
 import Data.Maybe (isNothing)
 import Control.Monad (when)
+import qualified Data.Map.Strict as Map
+import qualified XMonad.Util.ExtensibleState as XS
 
 -- $usage
 -- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@ file:
@@ -45,21 +55,60 @@ import Control.Monad (when)
 -- Then add keybindings like the following:
 --
 -- >   , ((modm .|. shiftMask, xK_BackSpace), removeWorkspace)
--- >   , ((modm .|. shiftMask, xK_v      ), selectWorkspace defaultXPConfig)
--- >   , ((modm, xK_m                    ), withWorkspace defaultXPConfig (windows . W.shift))
--- >   , ((modm .|. shiftMask, xK_m      ), withWorkspace defaultXPConfig (windows . copy))
--- >   , ((modm .|. shiftMask, xK_r      ), renameWorkspace defaultXPConfig)
+-- >   , ((modm .|. shiftMask, xK_v      ), selectWorkspace def)
+-- >   , ((modm, xK_m                    ), withWorkspace def (windows . W.shift))
+-- >   , ((modm .|. shiftMask, xK_m      ), withWorkspace def (windows . copy))
+-- >   , ((modm .|. shiftMask, xK_r      ), renameWorkspace def)
 --
--- > -- mod-[1..9]       %! Switch to workspace N
--- > -- mod-shift-[1..9] %! Move client to workspace N
+-- > -- mod-[1..9]       %! Switch to workspace N in the list of workspaces
+-- > -- mod-shift-[1..9] %! Move client to workspace N in the list of workspaces
 -- >    ++
 -- >    zip (zip (repeat (modm)) [xK_1..xK_9]) (map (withNthWorkspace W.greedyView) [0..])
 -- >    ++
 -- >    zip (zip (repeat (modm .|. shiftMask)) [xK_1..xK_9]) (map (withNthWorkspace W.shift) [0..])
 --
+-- Alternatively, you can associate indexes (which don't depend of the
+-- workspace list order) to workspaces by using following keybindings:
+--
+-- > -- mod-[1..9]         %! Switch to workspace of index N
+-- > -- mod-control-[1..9] %! Set index N to the current workspace
+-- >    ++
+-- >    zip (zip (repeat (modm)) [xK_1..xK_9]) (map (withWorkspaceIndex W.greedyView) [1..])
+-- >    ++
+-- >    zip (zip (repeat (modm .|. controlMask)) [xK_1..xK_9]) (map (setWorkspaceIndex) [1..])
+--
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings". See also the documentation for
--- "XMonad.Actions.CopyWindow", 'windows', 'shift', and 'defaultXPConfig'.
+-- "XMonad.Actions.CopyWindow", 'windows', 'shift', and 'XPConfig'.
+
+type WorkspaceTag = String
+-- | The workspace index is mapped to a workspace tag by the user and
+-- can be updated.
+type WorkspaceIndex  = Int
+
+-- | Internal dynamic project state that stores a mapping between
+--   workspace indexes and workspace tags.
+data DynamicWorkspaceState = DynamicWorkspaceState {workspaceIndexMap :: Map.Map WorkspaceIndex WorkspaceTag}
+  deriving (Typeable, Read, Show)
+
+instance ExtensionClass DynamicWorkspaceState where
+  initialValue = DynamicWorkspaceState Map.empty
+  extensionType = PersistentExtension
+
+-- | Set the index of the current workspace.
+setWorkspaceIndex :: WorkspaceIndex -> X ()
+setWorkspaceIndex widx = do
+  wtag  <- gets (currentTag . windowset)
+  wmap <- XS.gets workspaceIndexMap
+  XS.modify $ \s -> s {workspaceIndexMap = Map.insert widx wtag wmap}
+
+withWorkspaceIndex :: (String -> WindowSet -> WindowSet) -> WorkspaceIndex -> X ()
+withWorkspaceIndex job widx = do
+  wtag <- ilookup widx
+  maybe (return ()) (windows . job) wtag
+    where
+      ilookup :: WorkspaceIndex -> X (Maybe WorkspaceTag)
+      ilookup idx = Map.lookup idx `fmap` XS.gets workspaceIndexMap
 
 
 mkCompl :: [String] -> String -> IO [String]
@@ -77,10 +126,15 @@ renameWorkspace :: XPConfig -> X ()
 renameWorkspace conf = workspacePrompt conf renameWorkspaceByName
 
 renameWorkspaceByName :: String -> X ()
-renameWorkspaceByName w = windows $ \s -> let sett wk = wk { tag = w }
-                                              setscr scr = scr { workspace = sett $ workspace scr }
-                                              sets q = q { current = setscr $ current q }
-                                          in sets $ removeWorkspace' w s
+renameWorkspaceByName w = do old  <- gets (currentTag . windowset)
+			     windows $ \s -> let sett wk = wk { tag = w }
+						 setscr scr = scr { workspace = sett $ workspace scr }
+						 sets q = q { current = setscr $ current q }
+                                             in sets $ removeWorkspace' w s
+			     updateIndexMap old w
+  where updateIndexMap old new = do
+          wmap <- XS.gets workspaceIndexMap
+          XS.modify $ \s -> s {workspaceIndexMap = Map.map (\t -> if t == old then new else t) wmap}
 
 toNthWorkspace :: (String -> X ()) -> Int -> X ()
 toNthWorkspace job wnum = do sort <- getSortByIndex
@@ -107,20 +161,41 @@ selectWorkspace conf = workspacePrompt conf $ \w ->
 --   workspace with the given name already exists; then switch to the
 --   newly created workspace.
 addWorkspace :: String -> X ()
-addWorkspace newtag = addHiddenWorkspace newtag >> windows (greedyView newtag)
+addWorkspace = addWorkspaceAt (:)
+
+-- | Same as addWorkspace, but adds the workspace to the end of the list of workspaces
+appendWorkspace :: String -> X()
+appendWorkspace = addWorkspaceAt (flip (++) . return)
+
+-- | Adds a new workspace with the given name to the current list of workspaces.
+--   This function allows the user to pass a function that inserts an element
+--   into a list at an arbitrary spot.
+addWorkspaceAt :: (WindowSpace -> [WindowSpace] -> [WindowSpace]) -> String -> X ()
+addWorkspaceAt add newtag = addHiddenWorkspaceAt add newtag >> windows (greedyView newtag)
 
 -- | Prompt for the name of a new workspace, add it if it does not
 --   already exist, and switch to it.
 addWorkspacePrompt :: XPConfig -> X ()
 addWorkspacePrompt conf = mkXPrompt (Wor "New workspace name: ") conf (const (return [])) addWorkspace
 
+-- | Prompt for the name of a new workspace, appending it to the end of the list of workspaces
+--   if it does not already exist, and switch to it.
+appendWorkspacePrompt :: XPConfig -> X ()
+appendWorkspacePrompt conf = mkXPrompt (Wor "New workspace name: ") conf (const (return [])) appendWorkspace
+
+-- | Add a new hidden workspace with the given name, or do nothing if
+--   a workspace with the given name already exists. Takes a function to insert
+--   the workspace at an arbitrary spot in the list.
+addHiddenWorkspaceAt :: (WindowSpace -> [WindowSpace] -> [WindowSpace]) -> String -> X ()
+addHiddenWorkspaceAt add newtag =
+  whenX (gets (not . tagMember newtag . windowset)) $ do
+    l <- asks (layoutHook . config)
+    windows (addHiddenWorkspace' add newtag l)
+
 -- | Add a new hidden workspace with the given name, or do nothing if
 --   a workspace with the given name already exists.
 addHiddenWorkspace :: String -> X ()
-addHiddenWorkspace newtag =
-  whenX (gets (not . tagMember newtag . windowset)) $ do
-    l <- asks (layoutHook . config)
-    windows (addHiddenWorkspace' newtag l)
+addHiddenWorkspace = addHiddenWorkspaceAt (:)
 
 -- | Remove the current workspace if it contains no windows.
 removeEmptyWorkspace :: X ()
@@ -130,12 +205,11 @@ removeEmptyWorkspace = gets (currentTag . windowset) >>= removeEmptyWorkspaceByT
 removeWorkspace :: X ()
 removeWorkspace = gets (currentTag . windowset) >>= removeWorkspaceByTag
 
--- | Remove workspace with specific tag if it contains no windows. Only works
---   on the current or the last workspace.
+-- | Remove workspace with specific tag if it contains no windows.
 removeEmptyWorkspaceByTag :: String -> X ()
 removeEmptyWorkspaceByTag t = whenX (isEmpty t) $ removeWorkspaceByTag t
 
--- | Remove workspace with specific tag. Only works on the current or the last workspace.
+-- | Remove workspace with specific tag.
 removeWorkspaceByTag :: String -> X ()
 removeWorkspaceByTag torem = do
     s <- gets windowset
@@ -166,16 +240,21 @@ isEmpty t = do wsl <- gets $ workspaces . windowset
                let mws = find (\ws -> tag ws == t) wsl
                return $ maybe True (isNothing . stack) mws
 
-addHiddenWorkspace' :: i -> l -> StackSet i l a sid sd -> StackSet i l a sid sd
-addHiddenWorkspace' newtag l s@(StackSet { hidden = ws }) = s { hidden = Workspace newtag l Nothing:ws }
+addHiddenWorkspace' :: (Workspace i l a -> [Workspace i l a] -> [Workspace i l a]) -> i -> l -> StackSet i l a sid sd -> StackSet i l a sid sd
+addHiddenWorkspace' add newtag l s@(StackSet { hidden = ws }) = s { hidden = add (Workspace newtag l Nothing) ws }
 
+-- | Remove the hidden workspace with the given tag from the StackSet, if
+--   it exists. All the windows in that workspace are moved to the current
+--   workspace.
 removeWorkspace' :: (Eq i) => i -> StackSet i l a sid sd -> StackSet i l a sid sd
 removeWorkspace' torem s@(StackSet { current = scr@(Screen { workspace = wc })
-                                   , hidden = (w:ws) })
-    | tag w == torem = s { current = scr { workspace = wc { stack = meld (stack w) (stack wc) } }
-                         , hidden = ws }
+                                   , hidden = hs })
+    = let (xs, ys) = break ((== torem) . tag) hs
+      in removeWorkspace'' xs ys
    where meld Nothing Nothing = Nothing
          meld x Nothing = x
          meld Nothing x = x
          meld (Just x) (Just y) = differentiate (integrate x ++ integrate y)
-removeWorkspace' _ s = s
+         removeWorkspace'' xs (y:ys) = s { current = scr { workspace = wc { stack = meld (stack y) (stack wc) } }
+                                         , hidden = xs ++ ys }
+         removeWorkspace'' _  _      = s

XMonad/Actions/FloatSnap.hs

@@ -21,18 +21,21 @@ module XMonad.Actions.FloatSnap (
                 snapShrink,
                 snapMagicMove,
                 snapMagicResize,
-                snapMagicMouseResize) where
+                snapMagicMouseResize,
+                afterDrag,
+                ifClick,
+                ifClick') where
 
 import XMonad
 import Control.Applicative((<$>))
 import Data.List (sort)
 import Data.Maybe (listToMaybe,fromJust,isNothing)
 import qualified XMonad.StackSet as W
+import qualified Data.Set as S
 
 import XMonad.Hooks.ManageDocks (calcGap)
 import XMonad.Util.Types (Direction2D(..))
-
-import qualified Data.Set as S
+import XMonad.Actions.AfterDrag
 
 -- $usage
 -- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:
@@ -53,17 +56,24 @@ import qualified Data.Set as S
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings".
 --
--- And possibly add an appropriate mouse binding, for example:
+-- And possibly add appropriate mouse bindings, for example:
 --
--- >        , ((modm,               button1), (\w -> focus w >> mouseMoveWindow w >> snapMagicMove (Just 50) (Just 50) w))
--- >        , ((modm .|. shiftMask, button1), (\w -> focus w >> mouseMoveWindow w >> snapMagicResize [L,R,U,D] (Just 50) (Just 50) w))
--- >        , ((modm,               button3), (\w -> focus w >> mouseResizeWindow w >> snapMagicResize [R,D] (Just 50) (Just 50) w))
+-- >        , ((modm,               button1), (\w -> focus w >> mouseMoveWindow w >> ifClick (snapMagicMove (Just 50) (Just 50) w)))
+-- >        , ((modm .|. shiftMask, button1), (\w -> focus w >> mouseMoveWindow w >> ifClick (snapMagicResize [L,R,U,D] (Just 50) (Just 50) w)))
+-- >        , ((modm,               button3), (\w -> focus w >> mouseResizeWindow w >> ifClick (snapMagicResize [R,D] (Just 50) (Just 50) w)))
 --
 -- For detailed instructions on editing your mouse bindings, see
 -- "XMonad.Doc.Extending#Editing_mouse_bindings".
 --
 -- Using these mouse bindings, it will not snap while moving, but allow you to click the window once after it has been moved or resized to snap it into place.
--- Note that the order in which the commands are applied in the mouse bindings are important.
+-- Note that the order in which the commands are applied in the mouse bindings are important. Snapping can also be used together with other window resizing
+-- functions, such as those from "XMonad.Actions.FlexibleResize"
+--
+-- An alternative set of mouse bindings that will always snap after the drag is:
+--
+-- >        , ((modm,               button1), (\w -> focus w >> mouseMoveWindow w >> afterDrag (snapMagicMove (Just 50) (Just 50) w)))
+-- >        , ((modm .|. shiftMask, button1), (\w -> focus w >> mouseMoveWindow w >> afterDrag (snapMagicResize [L,R,U,D] (Just 50) (Just 50) w)))
+-- >        , ((modm,               button3), (\w -> focus w >> mouseResizeWindow w >> afterDrag (snapMagicResize [R,D] (Just 50) (Just 50) w)))
 --
 -- Interesting values for the distance to look for window in the orthogonal axis are Nothing (to snap against every window), Just 0 (to only snap
 -- against windows that we should collide with geometrically while moving) and Just 1 (to also snap against windows we brush against).

XMonad/Actions/FocusNth.hs

@@ -14,7 +14,8 @@
 module XMonad.Actions.FocusNth (
                  -- * Usage
                  -- $usage
-                 focusNth,focusNth') where
+                 focusNth,focusNth',
+                 swapNth,swapNth') where
 
 import XMonad.StackSet
 import XMonad
@@ -41,6 +42,17 @@ focusNth' :: Int -> Stack a -> Stack a
 focusNth' n s@(Stack _ ls rs) | (n < 0) || (n > length(ls) + length(rs)) = s
                               | otherwise = listToStack n (integrate s)
 
+-- | Swap current window with nth. Focus stays in the same position
+swapNth :: Int -> X ()
+swapNth = windows . modify' . swapNth'
+
+swapNth' :: Int -> Stack a -> Stack a
+swapNth' n s@(Stack c l r)
+  | (n < 0) || (n > length l + length r) || (n == length l) = s
+  | n < length l = let (nl, nc:nr) = splitAt (length l - n - 1) l in Stack nc (nl ++ c : nr) r
+  | otherwise    = let (nl, nc:nr) = splitAt (n - length l - 1) r in Stack nc l (nl ++ c : nr)
+                                                                          
+
 listToStack :: Int -> [a] -> Stack a
 listToStack n l = Stack t ls rs
  where

XMonad/Actions/GridSelect.hs

@@ -27,6 +27,7 @@ module XMonad.Actions.GridSelect (
 
     -- * Configuration
     GSConfig(..),
+    def,
     defaultGSConfig,
     TwoDPosition,
     buildDefaultGSConfig,
@@ -38,6 +39,7 @@ module XMonad.Actions.GridSelect (
     bringSelected,
     goToSelected,
     gridselectWorkspace,
+    gridselectWorkspace',
     spawnSelected,
     runSelectedAction,
 
@@ -65,6 +67,12 @@ module XMonad.Actions.GridSelect (
     cancel,
     transformSearchString,
 
+    -- * Rearrangers
+    -- $rearrangers
+    Rearranger,
+    noRearranger,
+    searchStringRearrangerGenerator,
+
     -- * Screenshots
     -- $screenshots
 
@@ -167,7 +175,7 @@ import Data.Word (Word8)
 --
 -- You can then define @gsconfig3@ which may be used in exactly the same manner as @gsconfig1@:
 --
--- > gsconfig3 = defaultGSConfig
+-- > gsconfig3 = def
 -- >    { gs_cellheight = 30
 -- >    , gs_cellwidth = 100
 -- >    , gs_navigate = myNavigation
@@ -183,6 +191,11 @@ import Data.Word (Word8)
 --
 -- <<http://haskell.org/wikiupload/3/35/Xmonad-gridselect-window-aavogt.png>>
 
+-- | The 'Default' instance gives a basic configuration for 'gridselect', with
+-- the colorizer chosen based on the type.
+--
+-- If you want to replace the 'gs_colorizer' field, use 'buildDefaultGSConfig'
+-- instead of 'def' to avoid ambiguous type variables.
 data GSConfig a = GSConfig {
       gs_cellheight :: Integer,
       gs_cellwidth :: Integer,
@@ -190,8 +203,10 @@ data GSConfig a = GSConfig {
       gs_colorizer :: a -> Bool -> X (String, String),
       gs_font :: String,
       gs_navigate :: TwoD a (Maybe a),
+      gs_rearranger :: Rearranger a,
       gs_originFractX :: Double,
-      gs_originFractY :: Double
+      gs_originFractY :: Double,
+      gs_bordercolor :: String
 }
 
 -- | That is 'fromClassName' if you are selecting a 'Window', or
@@ -212,12 +227,12 @@ instance HasColorizer a where
         let getColor = if isFg then focusedBorderColor else normalBorderColor
         in asks $ flip (,) "black" . getColor . config
 
--- | A basic configuration for 'gridselect', with the colorizer chosen based on the type.
---
--- If you want to replace the 'gs_colorizer' field, use 'buildDefaultGSConfig'
--- instead, to avoid ambiguous type variables.
+instance HasColorizer a => Default (GSConfig a) where
+    def = buildDefaultGSConfig defaultColorizer
+
+{-# DEPRECATED defaultGSConfig "Use def (from Data.Default, and re-exported from XMonad.Actions.GridSelect) instead." #-}
 defaultGSConfig :: HasColorizer a => GSConfig a
-defaultGSConfig = buildDefaultGSConfig defaultColorizer
+defaultGSConfig = def
 
 type TwoDPosition = (Integer, Integer)
 
@@ -232,13 +247,18 @@ data TwoDState a = TwoDState { td_curpos :: TwoDPosition
                              , td_paneY :: Integer
                              , td_drawingWin :: Window
                              , td_searchString :: String
+                             , td_elementmap :: TwoDElementMap a
                              }
 
-td_elementmap :: TwoDState a -> [(TwoDPosition,(String,a))]
-td_elementmap s = zipWith (,) positions sortedElements
+generateElementmap :: TwoDState a -> X (TwoDElementMap a)
+generateElementmap s = do
+    rearrangedElements <- rearranger searchString sortedElements
+    return $ zip positions rearrangedElements
   where
     TwoDState {td_availSlots = positions,
+               td_gsconfig = gsconfig,
                td_searchString = searchString} = s
+    GSConfig {gs_rearranger = rearranger} = gsconfig
     -- Filter out any elements that don't contain the searchString (case insensitive)
     filteredElements = L.filter ((searchString `isInfixOfI`) . fst) (td_elements s)
     -- Sorts the elementmap
@@ -303,15 +323,15 @@ diamondRestrict x y originX originY =
 findInElementMap :: (Eq a) => a -> [(a, b)] -> Maybe (a, b)
 findInElementMap pos = find ((== pos) . fst)
 
-drawWinBox :: Window -> XMonadFont -> (String, String) -> Integer -> Integer -> String -> Integer -> Integer -> Integer -> X ()
-drawWinBox win font (fg,bg) ch cw text x y cp =
+drawWinBox :: Window -> XMonadFont -> (String, String) -> String -> Integer -> Integer -> String -> Integer -> Integer -> Integer -> X ()
+drawWinBox win font (fg,bg) bc ch cw text x y cp =
   withDisplay $ \dpy -> do
   gc <- liftIO $ createGC dpy win
   bordergc <- liftIO $ createGC dpy win
   liftIO $ do
     Just fgcolor <- initColor dpy fg
     Just bgcolor <- initColor dpy bg
-    Just bordercolor <- initColor dpy borderColor
+    Just bordercolor <- initColor dpy bc
     setForeground dpy gc fgcolor
     setBackground dpy gc bgcolor
     setForeground dpy bordergc bordercolor
@@ -321,7 +341,10 @@ drawWinBox win font (fg,bg) ch cw text x y cp =
            (\n -> do size <- liftIO $ textWidthXMF dpy font n
                      return $ size > (fromInteger (cw-(2*cp))))
            text
-  printStringXMF dpy win font gc bg fg (fromInteger (x+cp)) (fromInteger (y+(div ch 2))) stext
+  -- calculate the offset to vertically centre the text based on the ascender and descender
+  (asc,desc) <- liftIO $ textExtentsXMF font stext
+  let offset = ((ch - fromIntegral (asc + desc)) `div` 2) + fromIntegral asc
+  printStringXMF dpy win font gc bg fg (fromInteger (x+cp)) (fromInteger (y+offset)) stext
   liftIO $ freeGC dpy gc
   liftIO $ freeGC dpy bordergc
 
@@ -331,11 +354,11 @@ updateAllElements =
       s <- get
       updateElements (td_elementmap s)
 
-grayoutAllElements :: TwoD a ()
-grayoutAllElements =
+grayoutElements :: Int -> TwoD a ()
+grayoutElements skip =
     do
       s <- get
-      updateElementsWithColorizer grayOnly (td_elementmap s)
+      updateElementsWithColorizer grayOnly $ drop skip (td_elementmap s)
     where grayOnly _ _ = return ("#808080", "#808080")
 
 updateElements :: TwoDElementMap a -> TwoD a ()
@@ -359,6 +382,7 @@ updateElementsWithColorizer colorizer elementmap = do
             colors <- colorizer element (pos == curpos)
             drawWinBox win font
                        colors
+                       (gs_bordercolor gsconfig)
                        cellheight
                        cellwidth
                        text
@@ -371,7 +395,7 @@ stdHandle :: Event -> TwoD a (Maybe a) -> TwoD a (Maybe a)
 stdHandle (ButtonEvent { ev_event_type = t, ev_x = x, ev_y = y }) contEventloop
     | t == buttonRelease = do
         s @  TwoDState { td_paneX = px, td_paneY = py,
-                         td_gsconfig = (GSConfig ch cw _ _ _ _ _ _) } <- get
+                         td_gsconfig = (GSConfig ch cw _ _ _ _ _ _ _ _) } <- get
         let gridX = (fi x - (px - cw) `div` 2) `div` cw
             gridY = (fi y - (py - ch) `div` 2) `div` ch
         case lookup (gridX,gridY) (td_elementmap s) of
@@ -467,11 +491,17 @@ transformSearchString f = do
           let oldSearchString = td_searchString s
               newSearchString = f oldSearchString
           when (newSearchString /= oldSearchString) $ do
-            -- FIXME: grayoutAllElements + updateAllElements paint some fields twice causing flickering
-            --        we would need a much smarter update strategy to fix that
-            when (length newSearchString > length oldSearchString) grayoutAllElements
             -- FIXME curpos might end up outside new bounds
-            put s { td_searchString = newSearchString }
+            let s' = s { td_searchString = newSearchString }
+            m <- liftX $ generateElementmap s'
+            let s'' = s' { td_elementmap = m }
+                oldLen = length $ td_elementmap s
+                newLen = length $ td_elementmap s''
+            -- All the elements in the previous element map should be
+            -- grayed out, except for those which will be covered by
+            -- elements in the new element map.
+            when (newLen < oldLen) $ grayoutElements newLen
+            put s''
             updateAllElements
 
 -- | By default gridselect used the defaultNavigation action, which
@@ -622,16 +652,16 @@ gridselect _ [] = return Nothing
 gridselect gsconfig elements =
  withDisplay $ \dpy -> do
     rootw <- asks theRoot
-    s <- gets $ screenRect . W.screenDetail . W.current . windowset
+    scr <- gets $ screenRect . W.screenDetail . W.current . windowset
     win <- liftIO $ mkUnmanagedWindow dpy (defaultScreenOfDisplay dpy) rootw
-                    (rect_x s) (rect_y s) (rect_width s) (rect_height s)
+                    (rect_x scr) (rect_y scr) (rect_width scr) (rect_height scr)
     liftIO $ mapWindow dpy win
     liftIO $ selectInput dpy win (exposureMask .|. keyPressMask .|. buttonReleaseMask)
     status <- io $ grabKeyboard dpy win True grabModeAsync grabModeAsync currentTime
-    io $ grabButton dpy button1 anyModifier win True buttonReleaseMask grabModeAsync grabModeAsync none none
+    io $ grabPointer dpy win True buttonReleaseMask grabModeAsync grabModeAsync none none currentTime
     font <- initXMF (gs_font gsconfig)
-    let screenWidth = toInteger $ rect_width s;
-        screenHeight = toInteger $ rect_height s;
+    let screenWidth = toInteger $ rect_width scr
+        screenHeight = toInteger $ rect_height scr
     selectedElement <- if (status == grabSuccess) then do
                             let restriction ss cs = (fromInteger ss/fromInteger (cs gsconfig)-1)/2 :: Double
                                 restrictX = floor $ restriction screenWidth gs_cellwidth
@@ -639,21 +669,25 @@ gridselect gsconfig elements =
                                 originPosX = floor $ ((gs_originFractX gsconfig) - (1/2)) * 2 * fromIntegral restrictX
                                 originPosY = floor $ ((gs_originFractY gsconfig) - (1/2)) * 2 * fromIntegral restrictY
                                 coords = diamondRestrict restrictX restrictY originPosX originPosY
-
-                            evalTwoD (updateAllElements >> (gs_navigate gsconfig)) TwoDState { td_curpos = (head coords),
-                                                                                  td_availSlots = coords,
-                                                                                  td_elements = elements,
-                                                                                  td_gsconfig = gsconfig,
-                                                                                  td_font = font,
-                                                                                  td_paneX = screenWidth,
-                                                                                  td_paneY = screenHeight,
-                                                                                  td_drawingWin = win,
-                                                                                  td_searchString = "" }
+                                s = TwoDState { td_curpos = (head coords),
+                                                td_availSlots = coords,
+                                                td_elements = elements,
+                                                td_gsconfig = gsconfig,
+                                                td_font = font,
+                                                td_paneX = screenWidth,
+                                                td_paneY = screenHeight,
+                                                td_drawingWin = win,
+                                                td_searchString = "",
+                                                td_elementmap = [] }
+                            m <- generateElementmap s
+                            evalTwoD (updateAllElements >> (gs_navigate gsconfig))
+                                     (s { td_elementmap = m })
                       else
                           return Nothing
     liftIO $ do
       unmapWindow dpy win
       destroyWindow dpy win
+      ungrabPointer dpy currentTime
       sync dpy False
     releaseXMF font
     return selectedElement
@@ -685,10 +719,7 @@ decorateName' w = do
 
 -- | Builds a default gs config from a colorizer function.
 buildDefaultGSConfig :: (a -> Bool -> X (String,String)) -> GSConfig a
-buildDefaultGSConfig col = GSConfig 50 130 10 col "xft:Sans-8" defaultNavigation (1/2) (1/2)
-
-borderColor :: String
-borderColor = "white"
+buildDefaultGSConfig col = GSConfig 50 130 10 col "xft:Sans-8" defaultNavigation noRearranger (1/2) (1/2) "white"
 
 -- | Brings selected window to the current workspace.
 bringSelected :: GSConfig Window -> X ()
@@ -721,6 +752,44 @@ runSelectedAction conf actions = do
 -- > gridselectWorkspace (\ws -> W.greedyView ws . W.shift ws)
 gridselectWorkspace :: GSConfig WorkspaceId ->
                           (WorkspaceId -> WindowSet -> WindowSet) -> X ()
-gridselectWorkspace conf viewFunc = withWindowSet $ \ws -> do
+gridselectWorkspace conf viewFunc = gridselectWorkspace' conf (windows . viewFunc)
+
+-- | Select a workspace and run an arbitrary action on it.
+gridselectWorkspace' :: GSConfig WorkspaceId -> (WorkspaceId -> X ()) -> X ()
+gridselectWorkspace' conf func = withWindowSet $ \ws -> do
     let wss = map W.tag $ W.hidden ws ++ map W.workspace (W.current ws : W.visible ws)
-    gridselect conf (zip wss wss) >>= flip whenJust (windows . viewFunc)
+    gridselect conf (zip wss wss) >>= flip whenJust func
+
+-- $rearrangers
+--
+-- Rearrangers allow for arbitrary post-filter rearranging of the grid
+-- elements.
+--
+-- For example, to be able to switch to a new dynamic workspace by typing
+-- in its name, you can use the following keybinding action:
+--
+-- > import XMonad.Actions.DynamicWorkspaces (addWorkspace)
+-- >
+-- > gridselectWorkspace' defaultGSConfig
+-- >                          { gs_navigate   = navNSearch
+-- >                          , gs_rearranger = searchStringRearrangerGenerator id
+-- >                          }
+-- >                      addWorkspace
+
+-- | A function taking the search string and a list of elements, and
+-- returning a potentially rearranged list of elements.
+type Rearranger a = String -> [(String, a)] -> X [(String, a)]
+
+-- | A rearranger that leaves the elements unmodified.
+noRearranger :: Rearranger a
+noRearranger _ = return
+
+-- | A generator for rearrangers that append a single element based on the
+-- search string, if doing so would not be redundant (empty string or value
+-- already present).
+searchStringRearrangerGenerator :: (String -> a) -> Rearranger a
+searchStringRearrangerGenerator f =
+    let r "" xs                       = return $ xs
+        r s  xs | s `elem` map fst xs = return $ xs
+                | otherwise           = return $ xs ++ [(s, f s)]
+    in r

XMonad/Actions/GroupNavigation.hs

@@ -73,7 +73,7 @@ Finally, you can define keybindings to jump to the most recent window
 matching a certain Boolean query.  To do this, you need to add
 'historyHook' to your logHook:
 
-> main = xmonad $ defaultConfig { logHook = historyHook }
+> main = xmonad $ def { logHook = historyHook }
 
 Then the following keybindings, for example, allow you to return to
 the most recent xterm or emacs window or to simply to the most recent

XMonad/Actions/Launcher.hs

@@ -34,10 +34,10 @@ import           XMonad.Util.Run
 
     To test it, modify your local .xmonad:
 
-    > import XMonad.Prompt(defaultXPConfig)
+    > import XMonad.Prompt(def)
     > import XMonad.Actions.Launcher
 
-    > ((modm .|. controlMask, xK_l), launcherPrompt defaultXPConfig $ defaultLauncherModes launcherConfig)
+    > ((modm .|. controlMask, xK_l), launcherPrompt def $ defaultLauncherModes launcherConfig)
 
     A LauncherConfig contains settings for the default modes, modify them accordingly.
 
@@ -45,7 +45,7 @@ import           XMonad.Util.Run
 
 Restart xmonad. Press Ctrl + Your_Modkey + L and the first prompt should pop up.
 
- If you used 'defaultXPConfig', you can change mode with 'xK_grave'. If you are using your own 'XPConfig', define the value for 'changeModeKey'.
+ If you used the default 'XPConfig', you can change mode with 'xK_grave'. If you are using your own 'XPConfig', define the value for 'changeModeKey'.
  -}
 
 data HoogleMode = HMode FilePath String --path to hoogle and browser

XMonad/Actions/LinkWorkspaces.hs

@@ -0,0 +1,169 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  XMonad.Actions.LinkWorkspaces
+-- Copyright   :  (c) Jan-David Quesel <quesel@gmail.org>
+-- License     :  BSD3-style (see LICENSE)
+--
+-- Maintainer  :  none
+-- Stability   :  unstable
+-- Portability :  unportable
+--
+-- Provides bindings to add and delete links between workspaces. It is aimed
+-- at providing useful links between workspaces in a multihead setup. Linked
+-- workspaces are view at the same time.
+--
+-----------------------------------------------------------------------------
+
+{-# LANGUAGE DeriveDataTypeable  #-}
+module XMonad.Actions.LinkWorkspaces (
+                                         -- * Usage
+                                         -- $usage
+                                        switchWS,
+                                        removeAllMatchings,
+                                        unMatch,
+                                        toggleLinkWorkspaces,
+                                        defaultMessageConf,
+                                        MessageConfig(..)
+                                       ) where
+
+import XMonad
+import qualified XMonad.StackSet as W
+import XMonad.Layout.IndependentScreens(countScreens)
+import qualified XMonad.Util.ExtensibleState as XS (get, put)
+import XMonad.Actions.OnScreen(Focus(FocusCurrent), onScreen')
+import qualified Data.Map as M
+    ( insert, delete, Map, lookup, empty, filter )
+
+-- $usage
+-- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@ file:
+--
+-- > import XMonad.Actions.LinkWorkspaces
+--
+-- and add a function to print messages like
+--
+-- > message_command (S screen) = " dzen2 -p 1 -w 300 -xs " ++ show (screen + 1)
+-- > message_color_func c1 c2 msg = dzenColor c1 c2 msg
+-- > message screen c1 c2 msg = spawn $ "echo '" ++ (message_color_func c1 c2 msg) ++ "' | " ++ message_command screen
+--
+-- alternatively you can use the noMessages function as the argument
+--
+-- Then add keybindings like the following:
+--
+-- > ,((modm, xK_p), toggleLinkWorkspaces message)
+-- > ,((modm .|. shiftMask, xK_p), removeAllMatchings message)
+--
+-- >   [ ((modm .|. m, k), a i)
+-- >       | (a, m) <- [(switchWS (\y -> windows $ view y) message, 0),(switchWS (\x -> windows $ shift x . view x) message, shiftMask)]
+-- >       , (i, k) <- zip (XMonad.workspaces conf) [xK_1 .. xK_9]]
+--
+-- For detailed instructions on editing your key bindings, see
+-- "XMonad.Doc.Extending#Editing_key_bindings".
+
+data MessageConfig = MessageConfig {  messageFunction :: (ScreenId -> [Char] -> [Char] -> [Char] -> X())
+                    , foreground :: [Char]
+                    , alertedForeground :: [Char]
+                    , background :: [Char]
+                   }
+
+defaultMessageConf :: MessageConfig
+defaultMessageConf = MessageConfig { messageFunction = noMessageFn
+                     , background = "#000000"
+                     , alertedForeground = "#ff7701"
+                     , foreground = "#00ff00" }
+
+noMessageFn :: ScreenId -> [Char] -> [Char] -> [Char] -> X()
+noMessageFn _ _ _ _ = return () :: X ()
+
+-- | Stuff for linking workspaces
+data WorkspaceMap = WorkspaceMap (M.Map WorkspaceId WorkspaceId) deriving (Read, Show, Typeable)
+instance ExtensionClass WorkspaceMap 
+    where initialValue = WorkspaceMap M.empty
+          extensionType = PersistentExtension
+
+switchWS :: (WorkspaceId -> X ()) -> MessageConfig -> WorkspaceId -> X ()
+switchWS f m ws = switchWS' f m ws Nothing
+
+-- | Switch to the given workspace in a non greedy way, stop if we reached the first screen
+-- | we already did switching on
+switchWS' :: (WorkspaceId -> X ()) -> MessageConfig  -> WorkspaceId -> (Maybe ScreenId) -> X ()
+switchWS' switchFn message workspace stopAtScreen = do
+  ws <- gets windowset
+  nScreens <- countScreens
+  let now = W.screen (W.current ws)
+  let next = ((now + 1) `mod` nScreens)
+  switchFn workspace
+  case stopAtScreen of
+    Nothing -> sTM now next (Just now)
+    Just sId -> if sId == next then return () else sTM now next (Just sId)
+  where sTM = switchToMatching (switchWS' switchFn message) message workspace
+
+-- | Switch to the workspace that matches the current one, executing switches for that workspace as well.
+-- | The function switchWorkspaceNonGreedy' will take of stopping if we reached the first workspace again.
+switchToMatching :: (WorkspaceId -> (Maybe ScreenId) -> X ()) -> MessageConfig -> WorkspaceId -> ScreenId 
+    -> ScreenId -> (Maybe ScreenId) -> X ()
+switchToMatching f message t now next stopAtScreen = do
+    WorkspaceMap matchings <- XS.get :: X WorkspaceMap
+    case (M.lookup t matchings) of
+        Nothing -> return () :: X()
+        Just newWorkspace -> do
+            onScreen' (f newWorkspace stopAtScreen) FocusCurrent next 
+            messageFunction message now (foreground message) (background message) ("Switching to: " ++ (t ++ " and " ++ newWorkspace))
+
+-- | Insert a mapping between t1 and t2 or remove it was already present
+toggleMatching :: MessageConfig -> WorkspaceId -> WorkspaceId -> X ()
+toggleMatching message t1 t2 = do
+    WorkspaceMap matchings <- XS.get :: X WorkspaceMap
+    case (M.lookup t1 matchings) of
+        Nothing -> setMatching message t1 t2 matchings
+        Just t -> if t == t2 then removeMatching' message t1 t2 matchings else setMatching message t1 t2 matchings
+    return ()
+
+-- | Insert a mapping between t1 and t2 and display a message
+setMatching :: MessageConfig -> WorkspaceId -> WorkspaceId -> M.Map WorkspaceId WorkspaceId -> X ()
+setMatching message t1 t2 matchings = do
+   ws <- gets windowset
+   let now = W.screen (W.current ws)
+   XS.put $ WorkspaceMap $ M.insert t1 t2 matchings
+   messageFunction message now (foreground message) (background message) ("Linked: " ++ (t1 ++ " " ++ t2))
+
+-- currently this function is called manually this means that if workspaces
+-- were deleted, some links stay in the RAM even though they are not used
+-- anymore... because of the small amount of memory used for those there is no
+-- special cleanup so far
+removeMatching' :: MessageConfig -> WorkspaceId -> WorkspaceId -> M.Map WorkspaceId WorkspaceId -> X ()
+removeMatching' message t1 t2 matchings = do
+   ws <- gets windowset
+   let now = W.screen (W.current ws)
+   XS.put $ WorkspaceMap $ M.delete t1 matchings
+   messageFunction message now (alertedForeground message) (background message) ("Unlinked: " ++ t1 ++ " " ++ t2)
+
+-- | Remove all maps between workspaces
+removeAllMatchings :: MessageConfig -> X ()
+removeAllMatchings message = do
+   ws <- gets windowset
+   let now = W.screen (W.current ws)
+   XS.put $ WorkspaceMap $ M.empty
+   messageFunction message now (alertedForeground message) (background message) "All links removed!"
+
+-- | remove all matching regarding a given workspace
+unMatch :: WorkspaceId -> X ()
+unMatch workspace = do
+    WorkspaceMap matchings <- XS.get :: X WorkspaceMap
+    XS.put $ WorkspaceMap $ M.delete workspace (M.filter (/= workspace) matchings)
+
+-- | Toggle the currently displayed workspaces as matching. Starting from the one with focus
+-- | a linked list of workspaces is created that will later be iterated by switchToMatching.
+toggleLinkWorkspaces :: MessageConfig -> X ()
+toggleLinkWorkspaces message = withWindowSet $ \ws -> toggleLinkWorkspaces' (W.screen (W.current ws)) message
+
+toggleLinkWorkspaces' :: ScreenId -> MessageConfig -> X ()
+toggleLinkWorkspaces' first message = do
+    ws <- gets windowset
+    nScreens <- countScreens
+    let now = W.screen (W.current ws)
+    let next = (now + 1) `mod` nScreens
+    if next == first then return () else do -- this is also the case if there is only one screen
+        case (W.lookupWorkspace next ws) of
+            Nothing -> return ()
+            Just name -> toggleMatching message (W.currentTag ws) (name)
+        onScreen' (toggleLinkWorkspaces' first message) FocusCurrent next

XMonad/Actions/MessageFeedback.hs

@@ -1,7 +1,8 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module       : XMonad.Actions.MessageFeedback
--- Copyright    : (c) Quentin Moser <moserq@gmail.com>
+-- Copyright    : (c) --   Quentin Moser <moserq@gmail.com>
+--                    2018 Yclept Nemo
 -- License      : BSD3
 --
 -- Maintainer   : orphaned
@@ -13,87 +14,263 @@
 -- this facility.
 -----------------------------------------------------------------------------
 
-module XMonad.Actions.MessageFeedback (
-                                      -- * Usage
-                                      -- $usage
+module XMonad.Actions.MessageFeedback
+    ( -- * Usage
+      -- $usage
 
-                                        send
-                                      , tryMessage
-                                      , tryMessage_
-                                      , tryInOrder
-                                      , tryInOrder_
-                                      , sm
-                                      , sendSM
-                                      , sendSM_
-                                      ) where
+      -- * Messaging variants
 
-import XMonad.Core ( X (), Message, SomeMessage(..), LayoutClass(..), windowset, catchX )
-import XMonad.StackSet ( current, workspace, layout, tag )
-import XMonad.Operations ( updateLayout )
+      -- ** 'SomeMessage'
+      sendSomeMessageB, sendSomeMessage
+    , sendSomeMessageWithNoRefreshB, sendSomeMessageWithNoRefresh
+    , sendSomeMessageWithNoRefreshToCurrentB, sendSomeMessageWithNoRefreshToCurrent
 
-import Control.Monad.State ( gets )
-import Data.Maybe ( isJust )
-import Control.Applicative ((<$>))
+      -- ** 'Message'
+    , sendMessageB
+    , sendMessageWithNoRefreshB
+    , sendMessageWithNoRefreshToCurrentB, sendMessageWithNoRefreshToCurrent
+
+      -- * Utility Functions
+
+      -- ** Send All
+    , sendSomeMessagesB, sendSomeMessages, sendMessagesB, sendMessages
+
+      -- ** Send Until
+    , tryInOrderB, tryInOrderWithNoRefreshToCurrentB, tryInOrderWithNoRefreshToCurrent
+    , tryMessageB, tryMessageWithNoRefreshToCurrentB, tryMessageWithNoRefreshToCurrent
+
+      -- ** Aliases
+    , sm
+
+      -- * Backwards Compatibility
+      -- $backwardsCompatibility
+    , send, sendSM, sendSM_
+    , tryInOrder, tryInOrder_
+    , tryMessage, tryMessage_
+    ) where
+
+import XMonad               ( Window )
+import XMonad.Core          ( X(), Message, SomeMessage(..), LayoutClass(..), windowset, catchX, WorkspaceId, Layout, whenJust )
+import XMonad.StackSet      ( Workspace, current, workspace, layout, tag )
+import XMonad.Operations    ( updateLayout, refresh, windows )
+
+import Data.Maybe           ( isJust )
+import Control.Monad        ( when, void )
+import Control.Monad.State  ( gets )
+import Control.Applicative  ( (<$>), liftA2 )
 
 -- $usage
 -- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:
 --
 -- > import XMonad.Actions.MessageFeedback
 --
--- You can then use this module's functions wherever an action is expected.
+-- You can then use this module's functions wherever an action is expected. All
+-- feedback variants are supported:
+--
+-- * message to any workspace with no refresh
+-- * message to current workspace with no refresh
+-- * message to current workspace with refresh
+--
+-- Except "message to any workspace with refresh" which makes little sense.
 --
 -- Note that most functions in this module have a return type of @X Bool@
--- whereas configuration options will expect a @X ()@ action.
--- For example, the key binding
+-- whereas configuration options will expect a @X ()@ action. For example, the
+-- key binding:
 --
 -- > -- Shrink the master area of a tiled layout, or move the focused window
 -- > -- to the left in a WindowArranger-based layout
--- > ((modKey, xK_Left), tryMessage Shrink (MoveLeft 50))
+-- > ((modKey, xK_Left), tryMessageWithNoRefreshToCurrentB Shrink (MoveLeft 50))
 --
--- is mis-typed. For this reason, this module provides alternatives (ending with
--- an underscore, e.g. tryMessage_) that discard their result and return an @X ()@.
--- For example, to correct the previous example:
+-- is mis-typed. For this reason, this module provides alternatives (not ending
+-- with an uppercase \"B\", e.g. 'XMonad.Operations.sendMessage' rather than
+-- 'sendMessageB') that discard their boolean result and return an @X ()@. For
+-- example, to correct the previous example:
 --
--- > ((modKey, xK_Left), tryMessage_ Shrink (MoveLeft 50))
+-- > ((modKey, xK_Left), tryMessageWithNoRefreshToCurrent Shrink (MoveLeft 50))
 --
+-- This module also provides 'SomeMessage' variants of each 'Message' function
+-- for when the messages are of differing types (but still instances of
+-- 'Message'). First box each message using 'SomeMessage' or the convenience
+-- alias 'sm'. Then, for example, to send each message:
+--
+-- > sendSomeMessages [sm messageOfTypeA, sm messageOfTypeB]
+--
+-- This is /not/ equivalent to the following example, which will not refresh
+-- the workspace unless the last message is handled:
+--
+-- > sendMessageWithNoRefreshToCurrent messageOfTypeA >> sendMessage messageOfTypeB
 
 
--- | Behaves like 'XMonad.Operations.sendMessage', but returns True of the
--- message was handled by the layout, False otherwise.
-send :: Message a => a -> X Bool
-send = sendSM . sm
+-- | Variant of 'XMonad.Operations.sendMessage'. Accepts 'SomeMessage'; to use
+-- 'Message' see 'sendMessageB'. Returns @True@ if the message was handled,
+-- @False@ otherwise. Instead of using 'sendSomeMessageWithNoRefreshToCurrentB'
+-- for efficiency this is pretty much an exact copy of the
+-- 'XMonad.Operations.sendMessage' code - foregoes the O(n) 'updateLayout'.
+sendSomeMessageB :: SomeMessage -> X Bool
+sendSomeMessageB m = do
+    w  <- workspace . current <$> gets windowset
+    ml <- handleMessage (layout w) m `catchX` return Nothing
+    whenJust ml $ \l ->
+        windows $ \ws -> ws { current = (current ws)
+                                { workspace = (workspace $ current ws)
+                                    { layout = l }}}
+    return $ isJust ml
 
--- | Sends the first message, and if it was not handled, sends the second.
--- Returns True if either message was handled, False otherwise.
-tryMessage :: (Message a, Message b) => a -> b -> X Bool
-tryMessage m1 m2 = do b <- send m1
-                      if b then return True else send m2
+-- | Variant of 'sendSomeMessageB' that discards the result.
+sendSomeMessage :: SomeMessage -> X ()
+sendSomeMessage = void . sendSomeMessageB
 
-tryMessage_ :: (Message a, Message b) => a -> b -> X ()
-tryMessage_ m1 m2 = tryMessage m1 m2 >> return ()
+-- | Variant of 'XMonad.Operations.sendMessageWithNoRefresh'. Accepts
+-- 'SomeMessage'; to use 'Message' see 'sendMessageWithNoRefreshB'. Returns
+-- @True@ if the message was handled, @False@ otherwise.
+sendSomeMessageWithNoRefreshB :: SomeMessage -> Workspace WorkspaceId (Layout Window) Window -> X Bool
+sendSomeMessageWithNoRefreshB m w
+    =   handleMessage (layout w) m `catchX` return Nothing
+    >>= liftA2 (>>) (updateLayout $ tag w) (return . isJust)
 
--- | Tries sending every message of the list in order until one of them
--- is handled. Returns True if one of the messages was handled, False otherwise.
-tryInOrder :: [SomeMessage] -> X Bool
-tryInOrder [] = return False
-tryInOrder (m:ms) = do b <- sendSM m
-                       if b then return True else tryInOrder ms
+-- | Variant of 'sendSomeMessageWithNoRefreshB' that discards the result.
+sendSomeMessageWithNoRefresh :: SomeMessage -> Workspace WorkspaceId (Layout Window) Window -> X ()
+sendSomeMessageWithNoRefresh m = void . sendSomeMessageWithNoRefreshB m
 
-tryInOrder_ :: [SomeMessage] -> X ()
-tryInOrder_ ms = tryInOrder ms >> return ()
+-- | Variant of 'XMonad.Operations.sendMessageWithNoRefresh' that sends the
+-- message to the current layout. Accepts 'SomeMessage'; to use 'Message' see
+-- 'sendMessageWithNoRefreshToCurrentB'. Returns @True@ if the message was
+-- handled, @False@ otherwise. This function is somewhat of a cross between
+-- 'XMonad.Operations.sendMessage' (sends to the current layout) and
+-- 'XMonad.Operations.sendMessageWithNoRefresh' (does not refresh).
+sendSomeMessageWithNoRefreshToCurrentB :: SomeMessage -> X Bool
+sendSomeMessageWithNoRefreshToCurrentB m
+    =   (gets $ workspace . current . windowset)
+    >>= sendSomeMessageWithNoRefreshB m
+
+-- | Variant of 'sendSomeMessageWithNoRefreshToCurrentB' that discards the
+-- result.
+sendSomeMessageWithNoRefreshToCurrent :: SomeMessage -> X ()
+sendSomeMessageWithNoRefreshToCurrent = void . sendSomeMessageWithNoRefreshToCurrentB
 
 
--- | Convenience shorthand for 'XMonad.Core.SomeMessage'.
+-- | Variant of 'sendSomeMessageB' which like 'XMonad.Operations.sendMessage'
+-- accepts 'Message' rather than 'SomeMessage'. Returns @True@ if the message
+-- was handled, @False@ otherwise.
+sendMessageB :: Message a => a -> X Bool
+sendMessageB = sendSomeMessageB . SomeMessage
+
+-- | Variant of 'sendSomeMessageWithNoRefreshB' which like
+-- 'XMonad.Operations.sendMessageWithNoRefresh' accepts 'Message' rather than
+-- 'SomeMessage'. Returns @True@ if the message was handled, @False@ otherwise.
+sendMessageWithNoRefreshB :: Message a => a -> Workspace WorkspaceId (Layout Window) Window -> X Bool
+sendMessageWithNoRefreshB = sendSomeMessageWithNoRefreshB . SomeMessage
+
+-- | Variant of 'sendSomeMessageWithNoRefreshToCurrentB' which accepts
+-- 'Message' rather than 'SomeMessage'. Returns @True@ if the message was
+-- handled, @False@ otherwise.
+sendMessageWithNoRefreshToCurrentB :: Message a => a -> X Bool
+sendMessageWithNoRefreshToCurrentB = sendSomeMessageWithNoRefreshToCurrentB . SomeMessage
+
+-- | Variant of 'sendMessageWithNoRefreshToCurrentB' that discards the result.
+sendMessageWithNoRefreshToCurrent :: Message a => a -> X ()
+sendMessageWithNoRefreshToCurrent = void . sendMessageWithNoRefreshToCurrentB
+
+
+-- | Send each 'SomeMessage' to the current layout without refresh (using
+-- 'sendSomeMessageWithNoRefreshToCurrentB') and collect the results. If any
+-- message was handled, refresh. If you want to sequence a series of messages
+-- that would have otherwise used 'XMonad.Operations.sendMessage' while
+-- minimizing refreshes, use this.
+sendSomeMessagesB :: [SomeMessage] -> X [Bool]
+sendSomeMessagesB m
+    =   mapM sendSomeMessageWithNoRefreshToCurrentB m
+    >>= liftA2 (>>) (flip when refresh . or) return
+
+-- | Variant of 'sendSomeMessagesB' that discards the results.
+sendSomeMessages :: [SomeMessage] -> X ()
+sendSomeMessages = void . sendSomeMessagesB
+
+-- | Variant of 'sendSomeMessagesB' which accepts 'Message' rather than
+-- 'SomeMessage'. Use this if all the messages are of the same type.
+sendMessagesB :: Message a => [a] -> X [Bool]
+sendMessagesB = sendSomeMessagesB . map SomeMessage
+
+-- | Variant of 'sendMessagesB' that discards the results.
+sendMessages :: Message a => [a] -> X ()
+sendMessages = void . sendMessagesB
+
+
+-- | Apply the dispatch function in order to each message of the list until one
+-- is handled. Returns @True@ if so, @False@ otherwise.
+tryInOrderB :: (SomeMessage -> X Bool) -> [SomeMessage] -> X Bool
+tryInOrderB _ []     = return False
+tryInOrderB f (m:ms) = do b <- f m
+                          if b then return True else tryInOrderB f ms
+
+-- | Variant of 'tryInOrderB' that sends messages to the current layout without
+-- refresh using 'sendSomeMessageWithNoRefreshToCurrentB'.
+tryInOrderWithNoRefreshToCurrentB :: [SomeMessage] -> X Bool
+tryInOrderWithNoRefreshToCurrentB = tryInOrderB sendSomeMessageWithNoRefreshToCurrentB
+
+-- | Variant of 'tryInOrderWithNoRefreshToCurrent' that discards the results.
+tryInOrderWithNoRefreshToCurrent :: [SomeMessage] -> X ()
+tryInOrderWithNoRefreshToCurrent = void . tryInOrderWithNoRefreshToCurrentB
+
+-- | Apply the dispatch function to the first message, and if it was not
+-- handled, apply it to the second. Returns @True@ if either message was
+-- handled, @False@ otherwise.
+tryMessageB :: (Message a, Message b) => (SomeMessage -> X Bool) -> a -> b -> X Bool
+tryMessageB f m1 m2 = tryInOrderB f [sm m1,sm m2]
+
+-- | Variant of 'tryMessageB' that sends messages to the current layout without
+-- refresh using 'sendMessageWithNoRefreshToCurrentB'.
+tryMessageWithNoRefreshToCurrentB :: (Message a, Message b) => a -> b -> X Bool
+tryMessageWithNoRefreshToCurrentB = tryMessageB sendSomeMessageWithNoRefreshToCurrentB
+
+-- | Variant of 'tryMessage' that discards the results.
+tryMessageWithNoRefreshToCurrent :: (Message a, Message b) => a -> b -> X ()
+tryMessageWithNoRefreshToCurrent m = void . tryMessageWithNoRefreshToCurrentB m
+
+
+-- | Convenience shorthand for 'SomeMessage'.
 sm :: Message a => a -> SomeMessage
 sm = SomeMessage
 
+--------------------------------------------------------------------------------
+-- Backwards Compatibility:
+--------------------------------------------------------------------------------
+{-# DEPRECATED send "Use sendMessageB instead." #-}
+{-# DEPRECATED sendSM "Use sendSomeMessageB instead." #-}
+{-# DEPRECATED sendSM_ "Use sendSomeMessage instead." #-}
+{-# DEPRECATED tryInOrder "Use tryInOrderWithNoRefreshToCurrentB instead." #-}
+{-# DEPRECATED tryInOrder_ "Use tryInOrderWithNoRefreshToCurrent instead." #-}
+{-# DEPRECATED tryMessage "Use tryMessageWithNoRefreshToCurrentB instead." #-}
+{-# DEPRECATED tryMessage_ "Use tryMessageWithNoRefreshToCurrent instead." #-}
 
+-- $backwardsCompatibility
+-- The following functions exist solely for compatibility with pre-0.14
+-- releases.
+
+-- | See 'sendMessageWithNoRefreshToCurrentB'.
+send :: Message a => a -> X Bool
+send = sendMessageWithNoRefreshToCurrentB
+
+-- | See 'sendSomeMessageWithNoRefreshToCurrentB'.
 sendSM :: SomeMessage -> X Bool
-sendSM m = do w <- workspace . current <$> gets windowset
-              ml' <- handleMessage (layout w) m `catchX` return Nothing
-              updateLayout (tag w) ml'
-              return $ isJust ml'
-
+sendSM = sendSomeMessageWithNoRefreshToCurrentB
 
+-- | See 'sendSomeMessageWithNoRefreshToCurrent'.
 sendSM_ :: SomeMessage -> X ()
-sendSM_ m = sendSM m >> return ()
+sendSM_ = sendSomeMessageWithNoRefreshToCurrent
+
+-- | See 'tryInOrderWithNoRefreshToCurrentB'.
+tryInOrder :: [SomeMessage] -> X Bool
+tryInOrder = tryInOrderWithNoRefreshToCurrentB
+
+-- | See 'tryInOrderWithNoRefreshToCurrent'.
+tryInOrder_ :: [SomeMessage] -> X ()
+tryInOrder_ = tryInOrderWithNoRefreshToCurrent
+
+-- | See 'tryMessageWithNoRefreshToCurrentB'.
+tryMessage :: (Message a, Message b) => a -> b -> X Bool
+tryMessage = tryMessageWithNoRefreshToCurrentB
+
+-- | See 'tryMessageWithNoRefreshToCurrent'.
+tryMessage_ :: (Message a, Message b) => a -> b -> X ()
+tryMessage_ = tryMessageWithNoRefreshToCurrent

XMonad/Actions/Minimize.hs

@@ -0,0 +1,144 @@
+----------------------------------------------------------------------------
+-- |
+-- Module      :  XMonad.Actions.Minimize
+-- Copyright   :  (c) Bogdan Sinitsyn (2016)
+-- License     :  BSD3-style (see LICENSE)
+--
+-- Maintainer  :  Bogdan Sinitsyn <bogdan.sinitsyn@gmail.com>
+-- Stability   :  unstable
+-- Portability :  not portable
+--
+-- Adds actions for minimizing and maximizing windows
+--
+-- This module should be used with "XMonad.Layout.Minimize". Add 'minimize' to your
+-- layout modifiers as described in "XMonad.Layout.Minimized" and use actions from
+-- this module
+--
+-- Possible keybindings:
+--
+-- >        , ((modm,               xK_m     ), withFocused minimizeWindow)
+-- >        , ((modm .|. shiftMask, xK_m     ), withLastMinimized maximizeWindowAndFocus)
+--
+-----------------------------------------------------------------------------
+
+module XMonad.Actions.Minimize
+  ( -- * Usage
+    -- $usage
+    minimizeWindow
+  , maximizeWindow
+  , maximizeWindowAndFocus
+  , withLastMinimized
+  , withLastMinimized'
+  , withFirstMinimized
+  , withFirstMinimized'
+  , withMinimized
+  ) where
+
+import XMonad
+import qualified XMonad.StackSet as W
+
+import qualified XMonad.Layout.BoringWindows as BW
+import qualified XMonad.Util.ExtensibleState as XS
+import XMonad.Util.Minimize
+import XMonad.Util.WindowProperties (getProp32)
+
+import Foreign.C.Types (CLong)
+import Control.Applicative((<$>))
+import Control.Monad (join)
+import Data.Maybe (fromMaybe, listToMaybe)
+import qualified Data.List as L
+import qualified Data.Map as M
+
+-- $usage
+-- Import this module with "XMonad.Layout.Minimize" and "XMonad.Layout.BoringWindows":
+-- > import XMonad.Actions.Minimize
+-- > import XMonad.Layout.Minimize
+-- > import qualified XMonad.Layout.BoringWindows as BW
+--
+-- Then apply 'minimize' and 'boringWindows' to your layout hook and use some
+-- actions from this module:
+-- > main = xmonad def { layoutHook = minimize . BW.boringWindows $ whatever }
+-- Example keybindings:
+-- >        , ((modm,               xK_m     ), withFocused minimizeWindow      )
+-- >        , ((modm .|. shiftMask, xK_m     ), withLastMinimized maximizeWindow)
+
+setMinimizedState :: Window -> Int -> (CLong -> [CLong] -> [CLong]) -> X ()
+setMinimizedState win st f = do
+    setWMState win st
+    withDisplay $ \dpy -> do
+        wm_state <- getAtom "_NET_WM_STATE"
+        hidden <- fromIntegral <$> getAtom "_NET_WM_STATE_HIDDEN"
+        wstate <- fromMaybe [] <$> getProp32 wm_state win
+        io $ changeProperty32 dpy win wm_state aTOM propModeReplace (f hidden wstate)
+
+setMinimized :: Window -> X ()
+setMinimized win = setMinimizedState win iconicState (:)
+
+setNotMinimized :: Window -> X ()
+setNotMinimized win = setMinimizedState win normalState L.delete
+
+-- It does not just set minimizedStack to newWindows because it should save
+-- order in which elements were added (newer first)
+modified :: (RectMap -> RectMap) -> X Bool
+modified f = XS.modified $
+    \Minimized { rectMap = oldRectMap, minimizedStack = oldStack } ->
+      let newRectMap = f oldRectMap
+          newWindows = M.keys newRectMap
+       in Minimized { rectMap = newRectMap
+                    , minimizedStack = (newWindows L.\\ oldStack)
+                                       ++
+                                       (oldStack `L.intersect` newWindows)
+                    }
+
+
+-- | Minimize a window
+minimizeWindow :: Window -> X ()
+minimizeWindow w = withWindowSet $ \ws ->
+  whenX (modified $ M.insert w (M.lookup w $ W.floating ws)) $ do
+    setMinimized w
+    windows $ W.sink w
+    BW.focusDown
+
+
+-- | Maximize window and apply a function to maximized window and 'WindowSet'
+maximizeWindowAndChangeWSet :: (Window -> WindowSet -> WindowSet) -> Window -> X ()
+maximizeWindowAndChangeWSet f w = do
+  mrect <- XS.gets (join . M.lookup w . rectMap)
+  whenX (modified $ M.delete w) $ do
+    setNotMinimized w
+    broadcastMessage BW.UpdateBoring
+    windows $ f w . maybe id (W.float w) mrect
+
+-- | Just maximize a window without focusing
+maximizeWindow :: Window -> X ()
+maximizeWindow = maximizeWindowAndChangeWSet $ const id
+
+-- | Maximize a window and then focus it
+maximizeWindowAndFocus :: Window -> X ()
+maximizeWindowAndFocus = maximizeWindowAndChangeWSet W.focusWindow
+
+-- | Perform an action with first minimized window on current workspace
+--   or do nothing if there is no minimized windows on current workspace
+withFirstMinimized :: (Window -> X ()) -> X ()
+withFirstMinimized action = withFirstMinimized' (flip whenJust action)
+
+-- | Like withFirstMinimized but the provided action is always invoked with a
+--   'Maybe Window', that will be nothing if there is no first minimized window.
+withFirstMinimized' :: (Maybe Window -> X ()) -> X ()
+withFirstMinimized' action = withMinimized (action . listToMaybe . reverse)
+
+-- | Perform an action with last minimized window on current workspace
+--   or do nothing if there is no minimized windows on current workspace
+withLastMinimized :: (Window -> X ()) -> X ()
+withLastMinimized action = withLastMinimized' (flip whenJust action)
+
+-- | Like withLastMinimized but the provided action is always invoked with a
+--   'Maybe Window', that will be nothing if there is no last minimized window.
+withLastMinimized' :: (Maybe Window -> X ()) -> X ()
+withLastMinimized' action = withMinimized (action . listToMaybe)
+
+withMinimized :: ([Window] -> X a) -> X a
+withMinimized action = do
+  minimized <- XS.gets minimizedStack
+  currentStack <- withWindowSet $ return . W.index
+  action $ minimized `L.intersect` currentStack

XMonad/Actions/MouseResize.hs

@@ -43,11 +43,11 @@ import XMonad.Util.XUtils
 --
 -- Then edit your @layoutHook@ by modifying a given layout:
 --
--- > myLayout = mouseResize $ windowArrange $ layoutHook defaultConfig
+-- > myLayout = mouseResize $ windowArrange $ layoutHook def
 --
 -- and then:
 --
--- > main = xmonad defaultConfig { layoutHook = myLayout }
+-- > main = xmonad def { layoutHook = myLayout }
 --
 -- For more detailed instructions on editing the layoutHook see:
 --

XMonad/Actions/Navigation2D.hs

@@ -32,12 +32,21 @@ module XMonad.Actions.Navigation2D ( -- * Usage
                                      -- * Exported functions and types
                                      -- #Exports#
 
-                                     withNavigation2DConfig
+                                     navigation2D
+                                   , navigation2DP
+                                   , additionalNav2DKeys
+                                   , additionalNav2DKeysP
+                                   , withNavigation2DConfig
                                    , Navigation2DConfig(..)
+                                   , def
                                    , defaultNavigation2DConfig
                                    , Navigation2D
                                    , lineNavigation
                                    , centerNavigation
+                                   , sideNavigation
+                                   , sideNavigationWithBias
+                                   , hybridOf
+                                   , hybridNavigation
                                    , fullScreenRect
                                    , singleWindowRect
                                    , switchLayer
@@ -53,9 +62,11 @@ import Control.Applicative
 import qualified Data.List as L
 import qualified Data.Map as M
 import Data.Maybe
+import Data.Ord (comparing)
 import XMonad hiding (Screen)
 import qualified XMonad.StackSet as W
 import qualified XMonad.Util.ExtensibleState as XS
+import XMonad.Util.EZConfig (additionalKeys, additionalKeysP)
 import XMonad.Util.Types
 
 -- $usage
@@ -63,24 +74,62 @@ import XMonad.Util.Types
 -- Navigation2D provides directional navigation (go left, right, up, down) for
 -- windows and screens.  It treats floating and tiled windows as two separate
 -- layers and provides mechanisms to navigate within each layer and to switch
--- between layers.  Navigation2D provides two different navigation strategies
--- (see <#Technical_Discussion> for details): /Line navigation/ feels rather
--- natural but may make it impossible to navigate to a given window from the
--- current window, particularly in the floating layer.  /Center navigation/
--- feels less natural in certain situations but ensures that all windows can be
--- reached without the need to involve the mouse.  Navigation2D allows different
--- navigation strategies to be used in the two layers and allows customization
--- of the navigation strategy for the tiled layer based on the layout currently
--- in effect.
+-- between layers.  Navigation2D provides three different navigation strategies
+-- (see <#Technical_Discussion> for details): /Line navigation/ and
+-- /Side navigation/ feel rather natural but may make it impossible to navigate
+-- to a given window from the current window, particularly in the floating
+-- layer. /Center navigation/ feels less natural in certain situations but
+-- ensures that all windows can be reached without the need to involve the
+-- mouse. Another option is to use a /Hybrid/ of the three strategies,
+-- automatically choosing whichever first provides a suitable target window.
+-- Navigation2D allows different navigation strategies to be used in the two
+-- layers and allows customization of the navigation strategy for the tiled
+-- layer based on the layout currently in effect.
 --
 -- You can use this module with (a subset of) the following in your @~\/.xmonad\/xmonad.hs@:
 --
 -- > import XMonad.Actions.Navigation2D
 --
--- Then edit your keybindings:
+-- Then add the configuration of the module to your main function:
+--
+-- > main = xmonad $ navigation2D def
+-- >                              (xK_Up, xK_Left, xK_Down, xK_Right)
+-- >                              [(mod4Mask,               windowGo  ),
+-- >                               (mod4Mask .|. shiftMask, windowSwap)]
+-- >                              False
+-- >               $ def
+--
+-- Alternatively, you can use navigation2DP:
+--
+-- > main = xmonad $ navigation2DP def
+-- >                               ("<Up>", "<Left>", "<Down>", "<Right>")
+-- >                               [("M-",   windowGo  ),
+-- >                                ("M-S-", windowSwap)]
+-- >                               False
+-- >               $ def
+--
+-- That's it. If instead you'd like more control, you can combine
+-- withNavigation2DConfig and additionalNav2DKeys or additionalNav2DKeysP:
+--
+-- > main = xmonad $ withNavigation2DConfig def
+-- >               $ additionalNav2DKeys (xK_Up, xK_Left, xK_Down, xK_Right)
+-- >                                     [(mod4Mask,               windowGo  ),
+-- >                                      (mod4Mask .|. shiftMask, windowSwap)]
+-- >                                     False
+-- >               $ additionalNav2DKeys (xK_u, xK_l, xK_d, xK_r)
+-- >                                     [(mod4Mask,               screenGo  ),
+-- >                                      (mod4Mask .|. shiftMask, screenSwap)]
+-- >                                     False
+-- >               $ def
+--
+-- Or you can add the configuration of the module to your main function:
+--
+-- > main = xmonad $ withNavigation2DConfig def $ def
+--
+-- And specify your keybindings normally:
 --
 -- >    -- Switch between layers
--- >    , ((modm,                 xK_space), switchLayers)
+-- >    , ((modm,                 xK_space), switchLayer)
 -- >
 -- >    -- Directional navigation of windows
 -- >    , ((modm,                 xK_Right), windowGo R False)
@@ -112,11 +161,6 @@ import XMonad.Util.Types
 -- >    , ((modm .|. mod1Mask,    xK_u    ), windowToScreen U False)
 -- >    , ((modm .|. mod1Mask,    xK_d    ), windowToScreen D False)
 --
--- and add the configuration of the module to your main function:
---
--- > main = xmonad $ withNavigation2DConfig defaultNavigation2DConfig
--- >               $ defaultConfig
---
 -- For detailed instruction on editing the key binding see:
 --
 -- "XMonad.Doc.Extending#Editing_key_bindings".
@@ -147,10 +191,10 @@ import XMonad.Util.Types
 -- example, for the Full layout, is to switch to center navigation for the Full
 -- layout:
 --
--- > myNavigation2DConfig = defaultNavigation2DConfig { layoutNavigation = [("Full", centerNavigation)] }
+-- > myNavigation2DConfig = def { layoutNavigation = [("Full", centerNavigation)] }
 -- >
 -- > main = xmonad $ withNavigation2DConfig myNavigation2DConfig
--- >               $ defaultConfig
+-- >               $ def
 --
 -- The navigation between windows is based on their screen rectangles, which are
 -- available /and meaningful/ only for mapped windows.  Thus, as already said,
@@ -164,12 +208,12 @@ import XMonad.Util.Types
 -- on top of each other so that only the frontmost one is visible.  This can be
 -- done as follows:
 --
--- > myNavigation2DConfig = defaultNavigation2DConfig { layoutNavigation   = [("Full", centerNavigation)]
--- >                                                  , unmappedWindowRect = [("Full", singleWindowRect)]
--- >                                                  }
+-- > myNavigation2DConfig = def { layoutNavigation   = [("Full", centerNavigation)]
+-- >                            , unmappedWindowRect = [("Full", singleWindowRect)]
+-- >                            }
 -- >
 -- > main = xmonad $ withNavigation2DConfig myNavigation2DConfig
--- >               $ defaultConfig
+-- >               $ def
 --
 -- With this setup, Left/Up navigation behaves like standard
 -- 'XMonad.StackSet.focusUp' and Right/Down navigation behaves like
@@ -279,7 +323,51 @@ lineNavigation = N 1 doLineNavigation
 centerNavigation :: Navigation2D
 centerNavigation = N 2 doCenterNavigation
 
--- | Stores the configuration of directional navigation
+-- | Side navigation. Consider navigating to the right this time. The strategy
+-- is to take the line segment forming the right boundary of the current window,
+-- and push it to the right until it intersects with at least one other window.
+-- Of those windows, one with a point that is the closest to the centre of the
+-- line (+1) is selected. This is probably the most intuitive strategy for the
+-- tiled layer when using XMonad.Layout.Spacing.
+sideNavigation :: Navigation2D
+sideNavigation = N 1 (doSideNavigationWithBias 1)
+
+-- | Side navigation with bias. Consider a case where the screen is divided
+-- up into three vertical panes; the side panes occupied by one window each and
+-- the central pane split across the middle by two windows. By the criteria
+-- of side navigation, the two central windows are equally good choices when
+-- navigating inwards from one of the side panes. Hence in order to be
+-- equitable, symmetric and pleasant to use, different windows are chosen when
+-- navigating from different sides. In particular, the lower is chosen when
+-- going left and the higher when going right, causing L, L, R, R, L, L, etc to
+-- cycle through the four windows clockwise. This is implemented by using a bias
+-- of 1. /Bias/ is how many pixels off centre the vertical split can be before
+-- this behaviour is lost and the same window chosen every time. A negative bias
+-- swaps the preferred window for each direction. A bias of zero disables the
+-- behaviour.
+sideNavigationWithBias :: Int -> Navigation2D
+sideNavigationWithBias b = N 1 (doSideNavigationWithBias b)
+
+-- | Hybrid of two modes of navigation, preferring the motions of the first.
+-- Use this if you want to fall back on a second strategy whenever the first
+-- does not find a candidate window. E.g.
+-- @hybridOf lineNavigation centerNavigation@ is a good strategy for the
+-- floating layer, and @hybridOf sideNavigation centerNavigation@ will enable
+-- you to take advantage of some of the latter strategy's more interesting
+-- motions in the tiled layer.
+hybridOf :: Navigation2D -> Navigation2D -> Navigation2D
+hybridOf (N g1 s1) (N g2 s2) = N (max g1 g2) $ applyToBoth s1 s2
+  where
+    applyToBoth f g a b c = f a b c <|> g a b c
+
+{-# DEPRECATED hybridNavigation "Use hybridOf with lineNavigation and centerNavigation as arguments." #-}
+hybridNavigation :: Navigation2D
+hybridNavigation = hybridOf lineNavigation centerNavigation
+
+-- | Stores the configuration of directional navigation. The 'Default' instance
+-- uses line navigation for the tiled layer and for navigation between screens,
+-- and center navigation for the float layer.  No custom navigation strategies
+-- or rectangles for unmapped windows are defined for individual layouts.
 data Navigation2DConfig = Navigation2DConfig
   { defaultTiledNavigation :: Navigation2D             -- ^ default navigation strategy for the tiled layer
   , floatNavigation        :: Navigation2D             -- ^ navigation strategy for the float layer
@@ -303,9 +391,59 @@ data Navigation2DConfig = Navigation2DConfig
 -- | Shorthand for the tedious screen type
 type Screen = W.Screen WorkspaceId (Layout Window) Window ScreenId ScreenDetail
 
+-- | Convenience function for enabling Navigation2D with typical keybindings.
+-- Takes a Navigation2DConfig, an (up, left, down, right) tuple, a mapping from
+-- modifier key to action, and a bool to indicate if wrapping should occur, and
+-- returns a function from XConfig to XConfig.
+-- Example:
+--
+-- >  navigation2D def (xK_w, xK_a, xK_s, xK_d) [(mod4Mask, windowGo), (mod4Mask .|. shiftMask, windowSwap)] False myConfig
+navigation2D :: Navigation2DConfig -> (KeySym, KeySym, KeySym, KeySym) -> [(ButtonMask, Direction2D -> Bool -> X ())] ->
+                Bool -> XConfig l -> XConfig l
+navigation2D navConfig (u, l, d, r) modifiers wrap xconfig =
+  additionalNav2DKeys (u, l, d, r) modifiers wrap $
+  withNavigation2DConfig navConfig xconfig
+
+-- | Convenience function for enabling Navigation2D with typical keybindings,
+-- using the syntax defined in 'XMonad.Util.EZConfig.mkKeymap'. Takes a
+-- Navigation2DConfig, an (up, left, down, right) tuple, a mapping from key
+-- prefix to action, and a bool to indicate if wrapping should occur, and
+-- returns a function from XConfig to XConfig. Example:
+--
+-- >  navigation2DP def ("w", "a", "s", "d") [("M-", windowGo), ("M-S-", windowSwap)] False myConfig
+navigation2DP :: Navigation2DConfig -> (String, String, String, String) -> [(String, Direction2D -> Bool -> X ())] ->
+                 Bool -> XConfig l -> XConfig l
+navigation2DP navConfig (u, l, d, r) modifiers wrap xconfig =
+  additionalNav2DKeysP (u, l, d, r) modifiers wrap $
+  withNavigation2DConfig navConfig xconfig
+
+-- | Convenience function for adding keybindings. Takes an (up, left, down,
+-- right) tuple, a mapping from key prefix to action, and a bool to indicate if
+-- wrapping should occur, and returns a function from XConfig to XConfig.
+-- Example:
+--
+-- >  additionalNav2DKeys (xK_w, xK_a, xK_s, xK_d) [(mod4Mask, windowGo), (mod4Mask .|. shiftMask, windowSwap)] False myConfig
+additionalNav2DKeys :: (KeySym, KeySym, KeySym, KeySym) -> [(ButtonMask, Direction2D -> Bool -> X ())] ->
+                       Bool -> XConfig l -> XConfig l
+additionalNav2DKeys (u, l, d, r) modifiers wrap =
+  flip additionalKeys [((modif, k), func dir wrap) | (modif, func) <- modifiers, (k, dir) <- dirKeys]
+  where dirKeys = [(u, U), (l, L), (d, D), (r, R)]
+
+-- | Convenience function for adding keybindings, using the syntax defined in
+-- 'XMonad.Util.EZConfig.mkKeymap'. Takes an (up, left, down, right) tuple, a
+-- mapping from key prefix to action, and a bool to indicate if wrapping should
+-- occur, and returns a function from XConfig to XConfig. Example:
+--
+-- >  additionalNav2DKeysP def ("w", "a", "s", "d") [("M-", windowGo), ("M-S-", windowSwap)] False myConfig
+additionalNav2DKeysP :: (String, String, String, String) -> [(String, Direction2D -> Bool -> X ())] ->
+                        Bool -> XConfig l -> XConfig l
+additionalNav2DKeysP (u, l, d, r) modifiers wrap =
+  flip additionalKeysP [(modif ++ k, func dir wrap) | (modif, func) <- modifiers, (k, dir) <- dirKeys]
+  where dirKeys = [(u, U), (l, L), (d, D), (r, R)]
+
 -- So we can store the configuration in extensible state
 instance ExtensionClass Navigation2DConfig where
-  initialValue = defaultNavigation2DConfig
+  initialValue = def
 
 -- | Modifies the xmonad configuration to store the Navigation2D configuration
 withNavigation2DConfig :: Navigation2DConfig -> XConfig a -> XConfig a
@@ -313,12 +451,12 @@ withNavigation2DConfig conf2d xconf = xconf { startupHook  = startupHook xconf
                                                           >> XS.put conf2d
                                             }
 
--- | Default navigation configuration.  It uses line navigation for the tiled
--- layer and for navigation between screens, and center navigation for the float
--- layer.  No custom navigation strategies or rectangles for unmapped windows are
--- defined for individual layouts.
+{-# DEPRECATED defaultNavigation2DConfig "Use def (from Data.Default, and re-exported from XMonad.Actions.Navigation2D) instead." #-}
 defaultNavigation2DConfig :: Navigation2DConfig
-defaultNavigation2DConfig = Navigation2DConfig { defaultTiledNavigation = lineNavigation
+defaultNavigation2DConfig = def
+
+instance Default Navigation2DConfig where
+    def                   = Navigation2DConfig { defaultTiledNavigation = lineNavigation
                                                , floatNavigation        = centerNavigation
                                                , screenNavigation       = lineNavigation
                                                , layoutNavigation       = []
@@ -668,6 +806,55 @@ doCenterNavigation dir (cur, rect) winrects
                                              -- or it has the same distance but comes later
                                              -- in the window stack
 
+-- x -y w h format is a pain. Let's use side coordinates. We assume x1 <= x2 and
+-- y1 <= y2, and make the assumption valid by initialising SideRects with the
+-- property and carefully preserving it over any individual transformation.
+data SideRect = SideRect { x1 :: Int, x2 :: Int, y1 :: Int, y2 :: Int }
+  deriving Show
+
+-- Conversion from Rectangle format to SideRect.
+toSR :: Rectangle -> SideRect
+toSR (Rectangle x y w h) = SideRect (fi x) (fi x + fi w) (-fi y - fi h) (-fi y)
+
+-- Implements side navigation with bias.
+doSideNavigationWithBias ::
+  Eq a => Int -> Direction2D -> Rect a -> [Rect a] -> Maybe a
+doSideNavigationWithBias bias dir (cur, rect)
+  = fmap fst . listToMaybe
+  . L.sortBy (comparing dist) . foldr acClosest []
+  . filter (`toRightOf` (cur, transform rect))
+  . map (fmap transform)
+  where
+    -- Getting the center of the current window so we can make it the new origin.
+    cOf r = ((x1 r + x2 r) `div` 2, (y1 r + y2 r) `div` 2)
+    (x0, y0) = cOf . toSR $ rect
+
+    -- Translate the given SideRect by (-x0, -y0).
+    translate r = SideRect (x1 r - x0) (x2 r - x0) (y1 r - y0) (y2 r - y0)
+
+    -- Rotate the given SideRect 90 degrees counter-clockwise about the origin.
+    rHalfPiCC r = SideRect (-y2 r) (-y1 r) (x1 r) (x2 r)
+
+    -- Apply the above function until d becomes synonymous with R (wolog).
+    rotateToR d = let (_, _:l) = break (d ==) [U, L, D, R]
+                  in  foldr (const $ (.) rHalfPiCC) id l
+
+    transform = rotateToR dir . translate . toSR
+
+    -- (_, r) `toRightOf` (_, c) iff r has points to the right of c that aren't
+    -- below or above c, i.e. iff:
+    -- [x1 r, x2 r] x [y1 r, y2 r] intersects (x2 c, infinity) x (y1 c, y2 c)
+    toRightOf (_, r) (_, c) = (x2 r > x2 c) && (y2 r > y1 c) && (y1 r < y2 c)
+
+    -- Greedily accumulate the windows tied for the leftmost left side.
+    acClosest (w, r) l@((_, r'):_) | x1 r == x1 r' = (w, r) : l
+                                   | x1 r >  x1 r' =          l
+    acClosest (w, r) _                             = (w, r) : []
+
+    -- Given a (_, SideRect), calculate how far it is from the y=bias line.
+    dist (_, r) | (y1 r <= bias) && (bias <= y2 r) = 0
+                | otherwise = min (abs $ y1 r - bias) (abs $ y2 r - bias)
+
 -- | Swaps the current window with the window given as argument
 swap :: Window -> WindowSet -> WindowSet
 swap win winset = W.focusWindow cur

XMonad/Actions/PhysicalScreens.hs

@@ -21,6 +21,12 @@ module XMonad.Actions.PhysicalScreens (
                                       , sendToScreen
                                       , onNextNeighbour
                                       , onPrevNeighbour
+                                      , horizontalScreenOrderer
+                                      , verticalScreenOrderer
+                                      , ScreenComparator(ScreenComparator)
+                                      , getScreenIdAndRectangle
+                                      , screenComparatorById
+                                      , screenComparatorByRectangle
                                       ) where
 
 import XMonad
@@ -36,17 +42,20 @@ physical location relative to each other (as reported by Xinerama),
 rather than their @ScreenID@ s, which are arbitrarily determined by
 your X server and graphics hardware.
 
-Screens are ordered by the upper-left-most corner, from top-to-bottom
+You can specify how to order the screen by giving a ScreenComparator.
+To create a screen comparator you can use screenComparatorByRectangle or screenComparatorByScreenId.
+The default ScreenComparator orders screens by the upper-left-most corner, from top-to-bottom
 and then left-to-right.
 
 Example usage in your @~\/.xmonad\/xmonad.hs@ file:
 
 > import XMonad.Actions.PhysicalScreens
+> import Data.Default
 
-> , ((modMask, xK_a), onPrevNeighbour W.view)
-> , ((modMask, xK_o), onNextNeighbour W.view)
-> , ((modMask .|. shiftMask, xK_a), onPrevNeighbour W.shift)
-> , ((modMask .|. shiftMask, xK_o), onNextNeighbour W.shift)
+> , ((modMask, xK_a), onPrevNeighbour def W.view)
+> , ((modMask, xK_o), onNextNeighbour def W.view)
+> , ((modMask .|. shiftMask, xK_a), onPrevNeighbour def W.shift)
+> , ((modMask .|. shiftMask, xK_o), onNextNeighbour def W.shift)
 
 > --
 > -- mod-{w,e,r}, Switch to physical/Xinerama screens 1, 2, or 3
@@ -54,7 +63,7 @@ Example usage in your @~\/.xmonad\/xmonad.hs@ file:
 > --
 > [((modm .|. mask, key), f sc)
 >     | (key, sc) <- zip [xK_w, xK_e, xK_r] [0..]
->     , (f, mask) <- [(viewScreen, 0), (sendToScreen, shiftMask)]]
+>     , (f, mask) <- [(viewScreen, 0), (sendToScreen def, shiftMask)]]
 
 For detailed instructions on editing your key bindings, see
 "XMonad.Doc.Extending#Editing_key_bindings".
@@ -63,52 +72,78 @@ For detailed instructions on editing your key bindings, see
 -- | The type of the index of a screen by location
 newtype PhysicalScreen = P Int deriving (Eq,Ord,Show,Read,Enum,Num,Integral,Real)
 
+getScreenIdAndRectangle :: (W.Screen i l a ScreenId ScreenDetail) -> (ScreenId, Rectangle)
+getScreenIdAndRectangle screen = (W.screen screen, rect) where
+  rect = screenRect $ W.screenDetail screen
+
 -- | Translate a physical screen index to a "ScreenId"
-getScreen :: PhysicalScreen -> X (Maybe ScreenId)
-getScreen (P i) = do w <- gets windowset
-                     let screens = W.current w : W.visible w
-                     if i<0 || i >= length screens
-                      then return Nothing
-                      else let ss = sortBy (cmpScreen `on` (screenRect . W.screenDetail)) screens
-                           in return $ Just $ W.screen $ ss !! i
+getScreen:: ScreenComparator -> PhysicalScreen -> X (Maybe ScreenId)
+getScreen (ScreenComparator cmpScreen) (P i) = do w <- gets windowset
+                                                  let screens = W.current w : W.visible w
+                                                  if i<0 || i >= length screens
+                                                    then return Nothing
+                                                    else let ss = sortBy (cmpScreen `on` getScreenIdAndRectangle) screens
+                                                    in return $ Just $ W.screen $ ss !! i
 
 -- | Switch to a given physical screen
-viewScreen :: PhysicalScreen -> X ()
-viewScreen p = do i <- getScreen p
-                  whenJust i $ \s -> do
-                  w <- screenWorkspace s
-                  whenJust w $ windows . W.view
+viewScreen :: ScreenComparator -> PhysicalScreen -> X ()
+viewScreen sc p = do i <- getScreen sc p
+                     whenJust i $ \s -> do
+                     w <- screenWorkspace s
+                     whenJust w $ windows . W.view
 
 -- | Send the active window to a given physical screen
-sendToScreen :: PhysicalScreen -> X ()
-sendToScreen p = do i <- getScreen p
-                    whenJust i $ \s -> do
-                      w <- screenWorkspace s
-                      whenJust w $ windows . W.shift
+sendToScreen :: ScreenComparator -> PhysicalScreen -> X ()
+sendToScreen sc p = do i <- getScreen sc p
+                       whenJust i $ \s -> do
+                         w <- screenWorkspace s
+                         whenJust w $ windows . W.shift
 
--- | Compare two screens by their top-left corners, ordering
--- | top-to-bottom and then left-to-right.
-cmpScreen :: Rectangle -> Rectangle -> Ordering
-cmpScreen (Rectangle x1 y1 _ _) (Rectangle x2 y2 _ _) = compare (y1,x1) (y2,x2)
+-- | A ScreenComparator allow to compare two screen based on their coordonate and Xinerama Id
+newtype ScreenComparator = ScreenComparator ((ScreenId, Rectangle) -> (ScreenId, Rectangle) -> Ordering)
 
+-- | The default ScreenComparator orders screens by the upper-left-most corner, from top-to-bottom
+instance Default ScreenComparator where
+  def= verticalScreenOrderer
+
+-- | Compare screen only by their coordonate
+screenComparatorByRectangle :: (Rectangle -> Rectangle -> Ordering) -> ScreenComparator
+screenComparatorByRectangle rectComparator = ScreenComparator comparator where
+  comparator (_, rec1) (_, rec2) = rectComparator rec1 rec2
+
+-- | Compare screen only by their Xinerama id
+screenComparatorById :: (ScreenId -> ScreenId -> Ordering) -> ScreenComparator
+screenComparatorById idComparator = ScreenComparator comparator where
+  comparator (id1, _) (id2, _) = idComparator id1 id2
+
+-- | orders screens by the upper-left-most corner, from top-to-bottom
+verticalScreenOrderer :: ScreenComparator
+verticalScreenOrderer = screenComparatorByRectangle comparator where
+    comparator (Rectangle x1 y1 _ _) (Rectangle x2 y2 _ _) = compare (y1, x1) (y2, x2)
+
+-- | orders screens by the upper-left-most corner, from left-to-right
+horizontalScreenOrderer :: ScreenComparator
+horizontalScreenOrderer = screenComparatorByRectangle comparator where
+    comparator (Rectangle x1 y1 _ _) (Rectangle x2 y2 _ _) = compare (x1, y1) (x2, y2)
 
 -- | Get ScreenId for neighbours of the current screen based on position offset.
-getNeighbour :: Int -> X ScreenId
-getNeighbour d = do w <- gets windowset
-                    let ss = map W.screen $ sortBy (cmpScreen `on` (screenRect . W.screenDetail)) $ W.current w : W.visible w
-                        curPos = maybe 0 id $ findIndex (== W.screen (W.current w)) ss
-                        pos = (curPos + d) `mod` length ss
-                    return $ ss !! pos
+getNeighbour :: ScreenComparator -> Int -> X ScreenId
+getNeighbour (ScreenComparator cmpScreen) d =
+  do w <- gets windowset
+     let ss = map W.screen $ sortBy (cmpScreen `on` getScreenIdAndRectangle) $ W.current w : W.visible w
+         curPos = maybe 0 id $ findIndex (== W.screen (W.current w)) ss
+         pos = (curPos + d) `mod` length ss
+     return $ ss !! pos
 
-neighbourWindows :: Int -> (WorkspaceId -> WindowSet -> WindowSet) -> X ()
-neighbourWindows d f = do s <- getNeighbour d
-                          w <- screenWorkspace s
-                          whenJust w $ windows . f
+neighbourWindows :: ScreenComparator -> Int -> (WorkspaceId -> WindowSet -> WindowSet) -> X ()
+neighbourWindows sc d f = do s <- getNeighbour sc d
+                             w <- screenWorkspace s
+                             whenJust w $ windows . f
 
 -- | Apply operation on a WindowSet with the WorkspaceId of the next screen in the physical order as parameter.
-onNextNeighbour :: (WorkspaceId -> WindowSet -> WindowSet) -> X ()
-onNextNeighbour = neighbourWindows 1
+onNextNeighbour :: ScreenComparator -> (WorkspaceId -> WindowSet -> WindowSet) -> X ()
+onNextNeighbour sc = neighbourWindows sc 1
 
 -- | Apply operation on a WindowSet with the WorkspaceId of the previous screen in the physical order as parameter.
-onPrevNeighbour :: (WorkspaceId -> WindowSet -> WindowSet) -> X ()
-onPrevNeighbour = neighbourWindows (-1)
+onPrevNeighbour :: ScreenComparator -> (WorkspaceId -> WindowSet -> WindowSet) -> X ()
+onPrevNeighbour sc = neighbourWindows sc (-1)

XMonad/Actions/Plane.hs

@@ -51,12 +51,13 @@ import XMonad.Util.Run
 -- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@ file:
 --
 -- > import XMonad.Actions.Plane
+-- > import Data.Map (union)
 -- >
--- > main = xmonad defaultConfig {keys = myKeys}
+-- > main = xmonad def {keys = myKeys}
 -- >
--- > myKeys conf = union (keys defaultConfig conf) $ myNewKeys conf
+-- > myKeys conf = union (keys def conf) $ myNewKeys conf
 -- >
--- > myNewkeys (XConfig {modMask = modm}) = planeKeys modm (Lines 3) Finite
+-- > myNewKeys (XConfig {modMask = modm}) = planeKeys modm (Lines 3) Finite
 --
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings".
@@ -226,4 +227,4 @@ gconftool :: String
 gconftool = "gconftool-2"
 
 parameters :: [String]
-parameters = ["--get", "/apps/panel/applets/workspace_switcher_screen0/prefs/num_rows"]
+parameters = ["--get", "/apps/panel/applets/workspace_switcher_screen0/prefs/num_rows"]

XMonad/Actions/Search.hs

@@ -46,11 +46,14 @@ module XMonad.Actions.Search (   -- * Usage
                                  mathworld,
                                  openstreetmap,
                                  scholar,
+                                 stackage,
                                  thesaurus,
                                  wayback,
                                  wikipedia,
                                  wiktionary,
                                  youtube,
+                                 vocabulary,
+                                 duckduckgo,
                                  multi,
                                   -- * Use case: searching with a submap
                                   -- $tip
@@ -59,15 +62,17 @@ module XMonad.Actions.Search (   -- * Usage
                                  Browser, Site, Query, Name, Search
                           ) where
 
-import Codec.Binary.UTF8.String (encode)
-import Data.Char (isAlphaNum, isAscii)
-import Data.List (isPrefixOf)
-import Text.Printf
-import XMonad (X(), MonadIO, liftIO)
-import XMonad.Prompt (XPrompt(showXPrompt, nextCompletion, commandToComplete), mkXPrompt, XPConfig(), historyCompletionP, getNextCompletion)
-import XMonad.Prompt.Shell (getBrowser)
-import XMonad.Util.Run (safeSpawn)
-import XMonad.Util.XSelection (getSelection)
+import           Codec.Binary.UTF8.String (encode)
+import           Data.Char                (isAlphaNum, isAscii)
+import           Data.List                (isPrefixOf)
+import           Text.Printf
+import           XMonad                   (X (), liftIO)
+import           XMonad.Prompt            (XPConfig (), XPrompt (showXPrompt, nextCompletion, commandToComplete),
+                                           getNextCompletion,
+                                           historyCompletionP, mkXPrompt)
+import           XMonad.Prompt.Shell      (getBrowser)
+import           XMonad.Util.Run          (safeSpawn)
+import           XMonad.Util.XSelection   (getSelection)
 
 
 {- $usage
@@ -114,6 +119,8 @@ import XMonad.Util.XSelection (getSelection)
 
 * 'hoogle' -- Hoogle, the Haskell libraries API search engine.
 
+* 'stackage' -- Stackage, An alternative Haskell libraries API search engine.
+
 * 'images' -- Google images.
 
 * 'imdb'   -- the Internet Movie Database.
@@ -138,6 +145,10 @@ import XMonad.Util.XSelection (getSelection)
 
 * 'youtube' -- Youtube video search.
 
+* 'vocabulary' -- Dictionary search
+
+* 'duckduckgo' -- DuckDuckGo search engine.
+
 * 'multi' -- Search based on the prefix. \"amazon:Potter\" will use amazon, etc. With no prefix searches google.
 
 Feel free to add more! -}
@@ -157,7 +168,7 @@ Then add the following to your key bindings:
 
 > ...
 > -- Search commands
-> , ((modm, xK_s), SM.submap $ searchEngineMap $ S.promptSearch P.defaultXPConfig)
+> , ((modm, xK_s), SM.submap $ searchEngineMap $ S.promptSearch P.def)
 > , ((modm .|. shiftMask, xK_s), SM.submap $ searchEngineMap $ S.selectSearch)
 >
 > ...
@@ -173,7 +184,7 @@ Or in combination with XMonad.Util.EZConfig:
 > ...
 > ] -- end of regular keybindings
 > -- Search commands
-> ++ [("M-s " ++ k, S.promptSearch P.defaultXPConfig f) | (k,f) <- searchList ]
+> ++ [("M-s " ++ k, S.promptSearch P.def f) | (k,f) <- searchList ]
 > ++ [("M-S-s " ++ k, S.selectSearch f) | (k,f) <- searchList ]
 >
 > ...
@@ -271,9 +282,9 @@ searchEngineF = SearchEngine
 
 -- The engines.
 amazon, alpha, codesearch, deb, debbts, debpts, dictionary, google, hackage, hoogle,
-  images, imdb, isohunt, lucky, maps, mathworld, openstreetmap, scholar, thesaurus, wayback, wikipedia, wiktionary,
-  youtube :: SearchEngine
-amazon        = searchEngine "amazon"        "http://www.amazon.com/exec/obidos/external-search?index=all&keyword="
+  images, imdb, isohunt, lucky, maps, mathworld, openstreetmap, scholar, stackage, thesaurus, vocabulary, wayback, wikipedia, wiktionary,
+  youtube, duckduckgo :: SearchEngine
+amazon        = searchEngine "amazon"        "http://www.amazon.com/s/ref=nb_sb_noss_2?url=search-alias%3Daps&field-keywords="
 alpha         = searchEngine "alpha"         "http://www.wolframalpha.com/input/?i="
 codesearch    = searchEngine "codesearch"    "http://www.google.com/codesearch?q="
 deb           = searchEngine "deb"           "http://packages.debian.org/"
@@ -291,14 +302,17 @@ maps          = searchEngine "maps"          "http://maps.google.com/maps?q="
 mathworld     = searchEngine "mathworld"     "http://mathworld.wolfram.com/search/?query="
 openstreetmap = searchEngine "openstreetmap" "http://gazetteer.openstreetmap.org/namefinder/?find="
 scholar       = searchEngine "scholar"       "http://scholar.google.com/scholar?q="
+stackage      = searchEngine "stackage"      "www.stackage.org/lts/hoogle?q="
 thesaurus     = searchEngine "thesaurus"     "http://thesaurus.reference.com/search?q="
 wikipedia     = searchEngine "wiki"          "http://en.wikipedia.org/wiki/Special:Search?go=Go&search="
 wiktionary    = searchEngine "wikt"          "http://en.wiktionary.org/wiki/Special:Search?go=Go&search="
 youtube       = searchEngine "youtube"       "http://www.youtube.com/results?search_type=search_videos&search_query="
 wayback       = searchEngineF "wayback"      ("http://web.archive.org/web/*/"++)
+vocabulary    = searchEngine "vocabulary"    "http://www.vocabulary.com/search?q="
+duckduckgo    = searchEngine "duckduckgo"    "https://duckduckgo.com/?t=lm&q="
 
 multi :: SearchEngine
-multi = namedEngine "multi" $ foldr1 (!>) [amazon, alpha, codesearch, deb, debbts, debpts, dictionary, google, hackage, hoogle, images, imdb, isohunt, lucky, maps, mathworld, openstreetmap, scholar, thesaurus, wayback, wikipedia, wiktionary, (prefixAware google)]
+multi = namedEngine "multi" $ foldr1 (!>) [amazon, alpha, codesearch, deb, debbts, debpts, dictionary, google, hackage, hoogle, images, imdb, isohunt, lucky, maps, mathworld, openstreetmap, scholar, thesaurus, wayback, wikipedia, wiktionary, duckduckgo, (prefixAware google)]
 
 {- | This function wraps up a search engine and creates a new one, which works
    like the argument, but goes directly to a URL if one is given rather than

XMonad/Actions/ShowText.hs

@@ -16,7 +16,8 @@
 module XMonad.Actions.ShowText
     ( -- * Usage
       -- $usage
-      defaultSTConfig
+      def
+    , defaultSTConfig
     , handleTimerEvent
     , flashText
     , ShowTextConfig(..)
@@ -52,7 +53,7 @@ import qualified XMonad.Util.ExtensibleState as ES
 --
 -- You can then use flashText in your keybindings:
 --
--- > ((modMask, xK_Right), flashText defaultSTConfig 1 "->" >> nextWS)
+-- > ((modMask, xK_Right), flashText def 1 "->" >> nextWS)
 --
 
 -- | ShowText contains the map with timers as keys and created windows as values
@@ -72,13 +73,17 @@ data ShowTextConfig =
         , st_fg   :: String -- ^ Foreground color
     }
 
-defaultSTConfig :: ShowTextConfig
-defaultSTConfig =
+instance Default ShowTextConfig where
+  def =
     STC { st_font = "-misc-fixed-*-*-*-*-20-*-*-*-*-*-*-*"
         , st_bg   = "black"
         , st_fg   = "white"
     }
 
+{-# DEPRECATED defaultSTConfig "Use def (from Data.Default, and re-exported by XMonad.Actions.ShowText) instead." #-}
+defaultSTConfig :: ShowTextConfig
+defaultSTConfig = def
+
 -- | Handles timer events that notify when a window should be removed
 handleTimerEvent :: Event -> X All
 handleTimerEvent (ClientMessageEvent _ _ _ dis _ mtyp d) = do

XMonad/Actions/SpawnOn.hs

@@ -20,6 +20,7 @@ module XMonad.Actions.SpawnOn (
     -- $usage
     Spawner,
     manageSpawn,
+    manageSpawnWithGC,
     spawnHere,
     spawnOn,
     spawnAndDo,
@@ -27,8 +28,14 @@ module XMonad.Actions.SpawnOn (
     shellPromptOn
 ) where
 
+import Control.Exception (tryJust)
+import Control.Monad (guard)
 import Data.List (isInfixOf)
+import Data.Maybe (isJust)
+import System.IO.Error (isDoesNotExistError)
+import System.IO.Unsafe (unsafePerformIO)
 import System.Posix.Types (ProcessID)
+import Text.Printf (printf)
 
 import XMonad
 import qualified XMonad.StackSet as W
@@ -44,16 +51,16 @@ import qualified XMonad.Util.ExtensibleState as XS
 -- >    import XMonad.Actions.SpawnOn
 --
 -- >    main = do
--- >      xmonad defaultConfig {
+-- >      xmonad def {
 -- >         ...
--- >         manageHook = manageSpawn <+> manageHook defaultConfig
+-- >         manageHook = manageSpawn <+> manageHook def
 -- >         ...
 -- >      }
 --
 -- To ensure that application appears on a workspace it was launched at, add keybindings like:
 --
 -- >  , ((mod1Mask,xK_o), spawnHere "urxvt")
--- >  , ((mod1Mask,xK_s), shellPromptHere defaultXPConfig)
+-- >  , ((mod1Mask,xK_s), shellPromptHere def)
 --
 -- The module can also be used to apply other manage hooks to the window of
 -- the spawned application(e.g. float or resize it).
@@ -66,8 +73,25 @@ newtype Spawner = Spawner {pidsRef :: [(ProcessID, ManageHook)]} deriving Typeab
 instance ExtensionClass Spawner where
     initialValue = Spawner []
 
-maxPids :: Int
-maxPids = 5
+
+getPPIDOf :: ProcessID -> Maybe ProcessID
+getPPIDOf pid =
+    case unsafePerformIO . tryJust (guard . isDoesNotExistError) . readFile . printf "/proc/%d/stat" $ toInteger pid of
+      Left _         -> Nothing
+      Right contents -> case lines contents of
+                          []        -> Nothing
+                          first : _ -> case words first of
+                                         _ : _ : _ : ppid : _ -> Just $ fromIntegral (read ppid :: Int)
+                                         _                    -> Nothing
+
+getPPIDChain :: ProcessID -> [ProcessID]
+getPPIDChain pid' = ppid_chain pid' []
+    where ppid_chain pid acc =
+              if pid == 0
+              then acc
+              else case getPPIDOf pid of
+                     Nothing   -> acc
+                     Just ppid -> ppid_chain ppid (ppid : acc)
 
 -- | Get the current Spawner or create one if it doesn't exist.
 modifySpawner :: ([(ProcessID, ManageHook)] -> [(ProcessID, ManageHook)]) -> X ()
@@ -76,20 +100,34 @@ modifySpawner f = XS.modify (Spawner . f . pidsRef)
 -- | Provides a manage hook to react on process spawned with
 -- 'spawnOn', 'spawnHere' etc.
 manageSpawn :: ManageHook
-manageSpawn = do
+manageSpawn = manageSpawnWithGC (return . take 20)
+
+manageSpawnWithGC :: ([(ProcessID, ManageHook)] -> X [(ProcessID, ManageHook)])
+        -- ^ function to stop accumulation of entries for windows that never set @_NET_WM_PID@
+       -> ManageHook
+manageSpawnWithGC garbageCollect = do
     Spawner pids <- liftX XS.get
     mp <- pid
-    case flip lookup pids =<< mp of
-        Nothing -> idHook
-        Just mh  -> do
-            whenJust mp $ \p ->
-                liftX . modifySpawner $ filter ((/= p) . fst)
+    let ppid_chain = case mp of
+                       Just winpid -> winpid : getPPIDChain winpid
+                       Nothing     -> []
+        known_window_handlers = [ mh
+                                | ppid <- ppid_chain
+                                , let mpid = lookup ppid pids
+                                , isJust mpid
+                                , let (Just mh) = mpid ]
+    case known_window_handlers of
+        [] -> idHook
+        (mh:_)  -> do
+            whenJust mp $ \p -> liftX $ do
+                ps <- XS.gets pidsRef
+                XS.put . Spawner =<< garbageCollect (filter ((/= p) . fst) ps)
             mh
 
 mkPrompt :: (String -> X ()) -> XPConfig -> X ()
 mkPrompt cb c = do
     cmds <- io $ getCommands
-    mkXPrompt Shell c (getShellCompl cmds) cb
+    mkXPrompt Shell c (getShellCompl cmds $ searchPredicate c) cb
 
 -- | Replacement for Shell prompt ("XMonad.Prompt.Shell") which launches
 -- application on current workspace.
@@ -115,7 +153,7 @@ spawnOn ws cmd = spawnAndDo (doShift ws) cmd
 spawnAndDo :: ManageHook -> String -> X ()
 spawnAndDo mh cmd = do
     p <- spawnPID $ mangle cmd
-    modifySpawner $ (take maxPids . ((p,mh) :))
+    modifySpawner $ ((p,mh) :)
  where
     -- TODO this is silly, search for a better solution
     mangle xs | any (`elem` metaChars) xs || "exec" `isInfixOf` xs = xs

XMonad/Actions/Submap.hs

@@ -16,9 +16,11 @@ module XMonad.Actions.Submap (
                              -- * Usage
                              -- $usage
                              submap,
-                             submapDefault
+                             submapDefault,
+                             submapDefaultWithKey
                             ) where
 import Data.Bits
+import Data.Maybe (fromMaybe)
 import XMonad hiding (keys)
 import qualified Data.Map as M
 import Control.Monad.Fix (fix)
@@ -58,25 +60,38 @@ For detailed instructions on editing your key bindings, see
 --   corresponding action, or does nothing if the key is not found in
 --   the map.
 submap :: M.Map (KeyMask, KeySym) (X ()) -> X ()
-submap keys = submapDefault (return ()) keys
+submap = submapDefault (return ())
 
 -- | Like 'submap', but executes a default action if the key did not match.
 submapDefault :: X () -> M.Map (KeyMask, KeySym) (X ()) -> X ()
-submapDefault def keys = do
+submapDefault = submapDefaultWithKey . const
+
+-- | Like 'submapDefault', but sends the unmatched key to the default
+-- action as argument.
+submapDefaultWithKey :: ((KeyMask, KeySym) -> X ())
+                     -> M.Map (KeyMask, KeySym) (X ())
+                     -> X ()
+submapDefaultWithKey defAction keys = do
     XConf { theRoot = root, display = d } <- ask
 
     io $ grabKeyboard d root False grabModeAsync grabModeAsync currentTime
+    io $ grabPointer d root False buttonPressMask grabModeAsync grabModeAsync
+                     none none currentTime
 
     (m, s) <- io $ allocaXEvent $ \p -> fix $ \nextkey -> do
-        maskEvent d keyPressMask p
-        KeyEvent { ev_keycode = code, ev_state = m } <- getEvent p
-        keysym <- keycodeToKeysym d code 0
-        if isModifierKey keysym
-            then nextkey
-            else return (m, keysym)
+        maskEvent d (keyPressMask .|. buttonPressMask) p
+        ev <- getEvent p
+        case ev of
+          KeyEvent { ev_keycode = code, ev_state = m } -> do
+            keysym <- keycodeToKeysym d code 0
+            if isModifierKey keysym
+                then nextkey
+                else return (m, keysym)
+          _ -> return (0, 0)
     -- Remove num lock mask and Xkb group state bits
     m' <- cleanMask $ m .&. ((1 `shiftL` 12) - 1)
 
+    io $ ungrabPointer d currentTime
     io $ ungrabKeyboard d currentTime
 
-    maybe def id (M.lookup (m', s) keys)
+    fromMaybe (defAction (m', s)) (M.lookup (m', s) keys)

XMonad/Actions/SwapPromote.hs

@@ -0,0 +1,407 @@
+{-# LANGUAGE DeriveDataTypeable #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  XMonad.Actions.SwapPromote
+-- Copyright   :  (c) 2018 Yclept Nemo
+-- License     :  BSD-style (see LICENSE)
+--
+-- Maintainer  :
+-- Stability   :  unstable
+-- Portability :  unportable
+--
+-- Module for tracking master window history per workspace, and associated
+-- functions for manipulating the stack using such history.
+--
+-----------------------------------------------------------------------------
+
+
+module XMonad.Actions.SwapPromote
+    ( -- * Usage
+      -- $usage
+      MasterHistory (..)
+      -- * State Accessors
+    , getMasterHistoryMap
+    , getMasterHistoryFromTag
+    , getMasterHistoryCurrent
+    , getMasterHistoryFromWindow
+    , modifyMasterHistoryFromTag
+    , modifyMasterHistoryCurrent
+      -- * Log Hook
+    , masterHistoryHook
+      -- * Log Hook Building Blocks
+    , masterHistoryHook'
+    , updateMasterHistory
+      -- * Actions
+    , swapPromote
+    , swapPromote'
+    , swapIn
+    , swapIn'
+    , swapHybrid
+    , swapHybrid'
+      -- * Action Building Blocks
+    , swapApply
+    , swapPromoteStack
+    , swapInStack
+    , swapHybridStack
+      -- * List Utilities
+    , cycleN
+    , split
+    , split'
+    , merge
+    , merge'
+      -- * Stack Utilities
+    , stackSplit
+    , stackMerge
+    ) where
+
+
+import           XMonad
+import qualified XMonad.StackSet                as W
+import qualified XMonad.Util.ExtensibleState    as XS
+
+import qualified Data.Map                       as M
+import qualified Data.Set                       as S
+import           Data.List
+import           Data.Maybe
+import           Control.Arrow
+import           Control.Applicative ((<$>),(<*>))
+import           Control.Monad
+
+
+-- $usage
+-- Given your configuration file, import this module:
+--
+-- > import XMonad.Actions.SwapPromote
+--
+-- First add 'masterHistoryHook' to your 'logHook' to track master windows per
+-- workspace:
+--
+-- > myLogHook = otherHook >> masterHistoryHook
+--
+-- Then replace xmonad's default promote keybinding with 'swapPromote'':
+--
+-- > , ((mod1Mask, xK_Return), swapPromote' False)
+--
+-- Depending on your xmonad configuration or window actions the master history
+-- may be empty. If this is the case you can still chain another promotion
+-- function:
+--
+-- > import XMonad.Actions.DwmPromote
+-- > , ((mod1Mask, xK_Return), whenX (swapPromote False) dwmpromote)
+--
+-- To be clear, this is only called when the lack of master history hindered
+-- the swap and not other conditions, such as having a only a single window.
+--
+-- While 'swapPromote' preserves window focus, 'swapIn' preserves the focus
+-- position - effectively "swapping" new windows into focus without moving the
+-- zipper. A mix of both, 'swapHybrid' promotes focused non-master windows
+-- while swapping windows into the focused master. This works well on layouts
+-- with large masters. Both come with chainable variants, see 'swapIn'' and
+-- 'swapHybrid''.
+--
+-- So far floating windows have been treated no differently than tiled windows
+-- even though their positions are independent of the stack. Often, yanking
+-- floating windows in and out of the workspace will obliterate the stack
+-- history - particularly frustrating with 'XMonad.Util.Scratchpad' since it is
+-- toggled so frequenty and always replaces the master window. That's why the
+-- swap functions accept a boolean argument; when @True@ non-focused floating
+-- windows will be ignored.
+--
+-- All together:
+--
+-- > , ((mod1Mask, xK_Return), whenX (swapHybrid True) dwmpromote)
+
+
+-- | Mapping from workspace tag to master history list. The current master is
+-- the head of the list, the previous master the second element, and so on.
+-- Without history, the list is empty.
+newtype MasterHistory = MasterHistory
+    { getMasterHistory :: M.Map WorkspaceId [Window]
+    } deriving (Read,Show,Typeable)
+
+instance ExtensionClass MasterHistory where
+    initialValue = MasterHistory M.empty
+
+-- | Return the master history map from the state.
+getMasterHistoryMap :: X (M.Map WorkspaceId [Window])
+getMasterHistoryMap = XS.gets getMasterHistory
+
+-- | Return the master history list of a given tag. The master history list may
+-- be empty. An invalid tag will also result in an empty list.
+getMasterHistoryFromTag :: WorkspaceId -> X [Window]
+getMasterHistoryFromTag t = M.findWithDefault [] t <$> getMasterHistoryMap
+
+-- | Return the master history list of the current workspace.
+getMasterHistoryCurrent :: X [Window]
+getMasterHistoryCurrent =   gets (W.currentTag . windowset)
+                        >>= getMasterHistoryFromTag
+
+-- | Return the master history list of the workspace containing the given
+-- window. Return an empty list if the window is not in the stackset.
+getMasterHistoryFromWindow :: Window -> X [Window]
+getMasterHistoryFromWindow w =   gets (W.findTag w . windowset)
+                             >>= maybe (return []) getMasterHistoryFromTag
+
+-- | Modify the master history list of a given workspace, or the empty list of
+-- no such workspace is mapped. The result is then re-inserted into the master
+-- history map.
+modifyMasterHistoryFromTag :: WorkspaceId -> ([Window] -> [Window]) -> X ()
+modifyMasterHistoryFromTag t f = XS.modify $ \(MasterHistory m) ->
+    let l = M.findWithDefault [] t m
+    in  MasterHistory $ M.insert t (f l) m
+
+-- | Modify the master history list of the current workspace. While the current
+-- workspace is guaranteed to exist; its master history may not. For more
+-- information see 'modifyMasterHistoryFromTag'.
+modifyMasterHistoryCurrent :: ([Window] -> [Window]) -> X ()
+modifyMasterHistoryCurrent f =   gets (W.currentTag . windowset)
+                             >>= flip modifyMasterHistoryFromTag f
+
+-- | A 'logHook' to update the master history mapping. Non-existent workspaces
+-- are removed, and the master history list for the current workspaces is
+-- updated. See 'masterHistoryHook''.
+masterHistoryHook :: X ()
+masterHistoryHook = masterHistoryHook' True updateMasterHistory
+
+-- | Backend for 'masterHistoryHook'.
+masterHistoryHook' :: Bool
+                        -- ^ If @True@, remove non-existent workspaces.
+                   -> ([Window] -> [Window] -> [Window])
+                        -- ^ Function used to update the master history list of
+                        -- the current workspace. First argument is the master
+                        -- history, second is the integrated stack.  See
+                        -- 'updateMasterHistory' for more details.
+                   -> X ()
+masterHistoryHook' removeWorkspaces historyModifier = do
+    wset <- gets windowset
+    let W.Workspace wid _ mst = W.workspace . W.current $ wset
+        tags = map W.tag $ W.workspaces wset
+        st = W.integrate' mst
+    XS.modify $ \(MasterHistory mm) ->
+        let mm' = if removeWorkspaces
+                  then restrictKeys mm $ S.fromList tags
+                  else mm
+            ms  = M.findWithDefault [] wid mm'
+            ms' = historyModifier ms st
+        in  MasterHistory $ M.insert wid ms' mm'
+
+-- | Less efficient version of 'M.restrictKeys'. Given broader eventual
+-- adoption, replace this with 'M.restrictKeys'.
+restrictKeys :: Ord k => M.Map k a -> S.Set k -> M.Map k a
+restrictKeys m s = M.filterWithKey (\k _ -> k `S.member` s) m
+
+-- | Given the current master history list and an integrated stack, return the
+-- new master history list. The current master is either moved (if it exists
+-- within the history) or added to the head of the list, and all missing (i.e.
+-- closed) windows are removed.
+updateMasterHistory :: [Window] -- ^ The master history list.
+                    -> [Window] -- ^ The integrated stack.
+                    -> [Window]
+updateMasterHistory _  []       = []
+updateMasterHistory ms ws@(w:_) = (w : delete w ms) `intersect` ws
+
+-- | Wrap 'swapPromoteStack'; see also 'swapApply'.
+swapPromote :: Bool -> X Bool
+swapPromote = flip swapApply swapPromoteStack
+
+-- | Like 'swapPromote'' but discard the result.
+swapPromote' :: Bool -> X ()
+swapPromote' = void . swapPromote
+
+-- | Wrap 'swapInStack'; see also 'swapApply'.
+swapIn :: Bool -> X Bool
+swapIn = flip swapApply swapInStack
+
+-- | Like 'swapIn'' but discard the result.
+swapIn' :: Bool -> X ()
+swapIn' = void . swapIn
+
+-- | Wrap 'swapHybridStack'; see also 'swapApply'.
+swapHybrid :: Bool -> X Bool
+swapHybrid = flip swapApply swapHybridStack
+
+-- | Like 'swapHybrid'' but discard the result.
+swapHybrid' :: Bool -> X ()
+swapHybrid' = void . swapHybrid
+
+-- | Apply the given master history stack modifier to the current stack. If
+-- given @True@, all non-focused floating windows will be ignored. Return
+-- @True@ if insufficient history; if so use 'whenX' to sequence a backup
+-- promotion function.
+swapApply :: Bool
+          -> (Maybe Window -> W.Stack Window -> (Bool,W.Stack Window))
+          -> X Bool
+swapApply ignoreFloats swapFunction = do
+    fl <- gets $ W.floating . windowset
+    st <- gets $ W.stack . W.workspace . W.current . windowset
+    ch <- getMasterHistoryCurrent
+    let swapApply' s1 =
+            let fl' = if ignoreFloats then M.keysSet fl else S.empty
+                ff = (||) <$> (`S.notMember` fl') <*> (== W.focus s1)
+                fh = filter ff ch
+                pm = listToMaybe . drop 1 $ fh
+                (r,s2) = stackSplit s1 fl' :: ([(Int,Window)],W.Stack Window)
+                (b,s3) = swapFunction pm s2
+                s4 = stackMerge s3 r
+                mh = let w = head . W.integrate $ s3
+                     in  const $ w : delete w ch
+            in (b,Just s4,mh)
+        (x,y,z) = maybe (False,Nothing,id) swapApply' st
+    -- Any floating master windows will be added to the history when 'windows'
+    -- calls the log hook.
+    modifyMasterHistoryCurrent z
+    windows $ W.modify Nothing . const $ y
+    return x
+
+-- | If the focused window is the master window and there is no previous
+-- master, do nothing. Otherwise swap the master with the previous master. If
+-- the focused window is not the master window, swap it with the master window.
+-- In either case focus follows the original window, i.e. the focused window
+-- does not change, only its position.
+--
+-- The first argument is the previous master (which may not exist), the second
+-- a window stack. Return @True@ if the master history hindered the swap; the
+-- history is either empty or out-of-sync. Though the latter shouldn't happen
+-- this function never changes the stack under such circumstances.
+swapPromoteStack :: Maybe Window -> W.Stack Window -> (Bool,W.Stack Window)
+swapPromoteStack _         st@(W.Stack _x [] []) = (False,st)
+swapPromoteStack Nothing   st@(W.Stack _x [] _r) = (True,st)
+swapPromoteStack (Just pm)    (W.Stack  x []  r) =
+    let (r',l') = (reverse *** cycleN 1) $ span (/= pm) $ reverse r
+        st'     = W.Stack x l' r'
+        b       = null l'
+    in  (b,st')
+swapPromoteStack _            (W.Stack  x l   r) =
+    let r'  = (++ r) . cycleN 1 . reverse $ l
+        st' = W.Stack x [] r'
+    in  (False,st')
+
+-- | Perform the same swap as 'swapPromoteStack'. However the new window
+-- receives the focus; it appears to "swap into" the position of the original
+-- window. Under this model focus follows stack position and the zipper does
+-- not move.
+--
+-- See 'swapPromoteStack' for more details regarding the parameters.
+swapInStack :: Maybe Window -> W.Stack Window -> (Bool,W.Stack Window)
+swapInStack _         st@(W.Stack _x [] []) = (False,st)
+swapInStack Nothing   st@(W.Stack _x [] _r) = (True,st)
+swapInStack (Just pm)    (W.Stack  x []  r) =
+    let (x',r') = case span (/= pm) r of
+            (__,[]) -> (x,r)
+            (sl,sr) -> (pm,sl ++ x : drop 1 sr)
+        st'     = W.Stack x' [] r'
+        b       = x' == x
+    in  (b,st')
+swapInStack _            (W.Stack  x l   r) =
+    let l'  = init l ++ [x]
+        x'  = last l
+        st' = W.Stack x' l' r
+    in  (False,st')
+
+-- | If the focused window is the master window, use 'swapInStack'. Otherwise use
+-- 'swapPromoteStack'.
+--
+-- See 'swapPromoteStack' for more details regarding the parameters.
+swapHybridStack :: Maybe Window -> W.Stack Window -> (Bool,W.Stack Window)
+swapHybridStack m st@(W.Stack _ [] _) = swapInStack m st
+swapHybridStack m st                  = swapPromoteStack m st
+
+-- | Cycle a list by the given count. If positive, cycle to the left. If
+-- negative, cycle to the right:
+--
+-- >>> cycleN 2 [1,2,3,4,5]
+-- [3,4,5,1,2]
+-- >>> cycleN (-2) [1,2,3,4,5]
+-- [4,5,1,2,3]
+cycleN :: Int -> [a] -> [a]
+cycleN n ls =
+    let l = length ls
+    in  take l $ drop (n `mod` l) $ cycle ls
+
+-- | Wrap 'split'' with an initial index of @0@, discarding the list's length.
+split :: (Num a, Enum a) => (b -> Bool) -> [b] -> ([(a,b)],[b])
+split p l =
+    let (_,ys,ns) = split' p 0 l
+    in  (ys,ns)
+
+-- | Given a predicate, an initial index and a list, return a tuple containing:
+--
+--  * List length.
+--  * Indexed list of elements which satisfy the predicate. An indexed element
+--    is a tuple containing the element index (offset by the initial index) and
+--    the element.
+--  * List of elements which do not satisfy the predicate.
+--
+-- The initial index and length of the list simplify chaining calls to this
+-- function, such as for zippers of lists.
+split' :: (Num a, Enum a) => (b -> Bool) -> a -> [b] -> (a,[(a,b)],[b])
+split' p i l =
+    let accumulate e (c,ys,ns) = if p (snd e)
+            then (c+1,e:ys,ns)
+            else (c+1,ys,e:ns)
+        (c',ys',ns') = foldr accumulate (0,[],[]) $ zip [i..] l
+    in  (c',ys',snd . unzip $ ns')
+
+-- | Wrap 'merge'' with an initial virtual index of @0@. Return only the
+-- unindexed list with elements from the leftover indexed list appended.
+merge :: (Ord a, Num a) => [(a,b)] -> [b] -> [b]
+merge il ul =
+    let (_,il',ul') = merge' 0 il ul
+    in  ul' ++ map snd il'
+
+-- | Inverse of 'split'. Merge an indexed list with an unindexed list (see
+-- 'split''). Given a virtual index, an indexed list and an unindexed list,
+-- return a tuple containing:
+--
+--  * Virtual index /after/ the unindexed list
+--  * Remainder of the indexed list
+--  * Merged unindexed list
+--
+-- If the indexed list is empty, this functions consumes the entire unindexed
+-- list. If the unindexed list is empty, this function consumes only adjacent
+-- indexed elements. For example, @[(10,"ten"),(12,"twelve")]@ implies missing
+-- unindexed elements and so once @(10,"ten")@ is consumed this function
+-- concludes.
+--
+-- The indexed list is assumed to have been created by 'split'' and not checked
+-- for correctness. Indices are assumed to be ascending, i.e.
+-- > [(1,"one"),(2,"two"),(4,"four")]
+--
+-- The initial and final virtual indices simplify chaining calls to the this
+-- function, as as for zippers of lists. Positive values shift the unindexed
+-- list towards the tail, as if preceded by that many elements.
+merge' :: (Ord a, Num a) => a -> [(a,b)] -> [b] -> (a,[(a,b)],[b])
+merge' i il@((j,a):ps) ul@(b:bs) = if j <= i
+    then let (x,y,z) = merge' (i+1) ps ul
+         in  (x,y,a:z)
+    else let (x,y,z) = merge' (i+1) il bs
+         in  (x,y,b:z)
+merge' i [] (b:bs) =
+         let (x,y,z) = merge' (i+1) [] bs
+         in  (x,y,b:z)
+merge' i il@((j,a):ps) [] = if j <= i
+    then let (x,y,z) = merge' (i+1) ps []
+         in  (x,y,a:z)
+    else (i,il,[])
+merge' i [] [] =
+         (i,[],[])
+
+-- | Remove all elements of the set from the stack. Skip the currently focused
+-- member. Return an indexed list of excluded elements and the modified stack.
+-- Use 'stackMerge' to re-insert the elements using this list.
+stackSplit :: (Num a, Enum a, Ord b) => W.Stack b -> S.Set b -> ([(a,b)],W.Stack b)
+stackSplit (W.Stack x l r) s =
+    let (c,fl,tl) = split' (`S.member` s) 0 (reverse l)
+        (_,fr,tr) = split' (`S.member` s) (c+1) r
+    in  (fl++fr,W.Stack x (reverse tl) tr)
+
+-- | Inverse of 'stackSplit'. Given a list of elements and their original
+-- indices, re-insert the elements into these same positions within the stack.
+-- Skip the currently focused member. Works best if the stack's length hasn't
+-- changed, though if shorter any leftover elements will be tacked on.
+stackMerge :: (Ord a, Num a) => W.Stack b -> [(a,b)] -> W.Stack b
+stackMerge (W.Stack x l r) il =
+    let (i,il1,l') = merge' 0 il (reverse l)
+        (_,il2,r') = merge' (i+1) il1 r
+    in  W.Stack x (reverse l') (r' ++ map snd il2)

XMonad/Actions/TagWindows.hs

@@ -53,12 +53,12 @@ econst = const . return
 -- >   , ((modm,                 xK_d  ), withTaggedP "abc" (W.shiftWin "2"))
 -- >   , ((modm .|. shiftMask,   xK_d  ), withTaggedGlobalP "abc" shiftHere)
 -- >   , ((modm .|. controlMask, xK_d  ), focusUpTaggedGlobal "abc")
--- >   , ((modm,                 xK_g  ), tagPrompt defaultXPConfig (\s -> withFocused (addTag s)))
--- >   , ((modm .|. controlMask, xK_g  ), tagDelPrompt defaultXPConfig)
--- >   , ((modm .|. shiftMask,   xK_g  ), tagPrompt defaultXPConfig (\s -> withTaggedGlobal s float))
--- >   , ((modWinMask,                xK_g  ), tagPrompt defaultXPConfig (\s -> withTaggedP s (W.shiftWin "2")))
--- >   , ((modWinMask .|. shiftMask,  xK_g  ), tagPrompt defaultXPConfig (\s -> withTaggedGlobalP s shiftHere))
--- >   , ((modWinMask .|. controlMask, xK_g ), tagPrompt defaultXPConfig (\s -> focusUpTaggedGlobal s))
+-- >   , ((modm,                 xK_g  ), tagPrompt def (\s -> withFocused (addTag s)))
+-- >   , ((modm .|. controlMask, xK_g  ), tagDelPrompt def)
+-- >   , ((modm .|. shiftMask,   xK_g  ), tagPrompt def (\s -> withTaggedGlobal s float))
+-- >   , ((modWinMask,                xK_g  ), tagPrompt def (\s -> withTaggedP s (W.shiftWin "2")))
+-- >   , ((modWinMask .|. shiftMask,  xK_g  ), tagPrompt def (\s -> withTaggedGlobalP s shiftHere))
+-- >   , ((modWinMask .|. controlMask, xK_g ), tagPrompt def (\s -> focusUpTaggedGlobal s))
 --
 -- NOTE: Tags are saved as space separated strings and split with
 --       'unwords'. Thus if you add a tag \"a b\" the window will have

XMonad/Actions/TopicSpace.hs

@@ -22,6 +22,7 @@ module XMonad.Actions.TopicSpace
    Topic
   , Dir
   , TopicConfig(..)
+  , def
   , defaultTopicConfig
   , getLastFocusedTopics
   , setLastFocusedTopic
@@ -89,7 +90,7 @@ import qualified XMonad.Util.ExtensibleState as XS
 -- >   ]
 -- >
 -- > myTopicConfig :: TopicConfig
--- > myTopicConfig = defaultTopicConfig
+-- > myTopicConfig = def
 -- >   { topicDirs = M.fromList $
 -- >       [ ("conf", "w/conf")
 -- >       , ("dashboard", "Desktop")
@@ -161,7 +162,7 @@ import qualified XMonad.Util.ExtensibleState as XS
 -- > myConfig = do
 -- >     checkTopicConfig myTopics myTopicConfig
 -- >     myLogHook <- makeMyLogHook
--- >     return $ defaultConfig
+-- >     return $ def
 -- >          { borderWidth = 1 -- Width of the window border in pixels.
 -- >          , workspaces = myTopics
 -- >          , layoutHook = myModifiers myLayout
@@ -206,14 +207,18 @@ data TopicConfig = TopicConfig { topicDirs          :: M.Map Topic Dir
                                  -- numeric keypad.
                                }
 
-defaultTopicConfig :: TopicConfig
-defaultTopicConfig = TopicConfig { topicDirs = M.empty
+instance Default TopicConfig where
+    def            = TopicConfig { topicDirs = M.empty
                                  , topicActions = M.empty
                                  , defaultTopicAction = const (ask >>= spawn . terminal . config)
                                  , defaultTopic = "1"
                                  , maxTopicHistory = 10
                                  }
 
+{-# DEPRECATED defaultTopicConfig "Use def (from Data.Default, and re-exported by XMonad.Actions.TopicSpace) instead." #-}
+defaultTopicConfig :: TopicConfig
+defaultTopicConfig = def
+
 newtype PrevTopics = PrevTopics { getPrevTopics :: [String] } deriving (Read,Show,Typeable)
 instance ExtensionClass PrevTopics where
     initialValue = PrevTopics []

XMonad/Actions/TreeSelect.hs

@@ -0,0 +1,657 @@
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE RecordWildCards #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  XMonad.Actions.TreeSelect
+-- Copyright   :  (c) Tom Smeets <tom.tsmeets@gmail.com>
+-- License     :  BSD3-style (see LICENSE)
+--
+-- Maintainer  :  Tom Smeets <tom.tsmeets@gmail.com>
+-- Stability   :  unstable
+-- Portability :  unportable
+--
+--
+-- TreeSelect displays your workspaces or actions in a Tree-like format.
+-- You can select the desired workspace/action with the cursor or hjkl keys.
+--
+-- This module is fully configurable and very useful if you like to have a
+-- lot of workspaces.
+--
+-- Only the nodes up to the currently selected are displayed.
+-- This will be configurable in the near future by changing 'ts_hidechildren' to @False@, this is not yet implemented.
+--
+-- <<https://wiki.haskell.org/wikiupload/thumb/0/0b/Treeselect-Workspace.png/800px-Treeselect-Workspace.png>>
+--
+-----------------------------------------------------------------------------
+module XMonad.Actions.TreeSelect
+    (
+      -- * Usage
+      -- $usage
+      treeselectWorkspace
+    , toWorkspaces
+    , treeselectAction
+
+      -- * Configuring
+      -- $config
+    , Pixel
+      -- $pixel
+
+    , TSConfig(..)
+    , tsDefaultConfig
+
+      -- * Navigation
+      -- $navigation
+    , defaultNavigation
+    , select
+    , cancel
+    , moveParent
+    , moveChild
+    , moveNext
+    , movePrev
+    , moveHistBack
+    , moveHistForward
+    , moveTo
+
+      -- * Advanced usage
+      -- $advusage
+    , TSNode(..)
+    , treeselect
+    , treeselectAt
+    ) where
+
+import Control.Applicative
+import Control.Monad.Reader
+import Control.Monad.State
+import Data.List (find)
+import Data.Maybe
+import Data.Tree
+import Foreign
+import System.IO
+import System.Posix.Process (forkProcess, executeFile)
+import XMonad hiding (liftX)
+import XMonad.StackSet as W
+import XMonad.Util.Font
+import XMonad.Util.NamedWindows
+import XMonad.Util.TreeZipper
+import XMonad.Hooks.WorkspaceHistory
+import qualified Data.Map as M
+
+#ifdef XFT
+import Graphics.X11.Xft
+import Graphics.X11.Xrender
+#endif
+
+-- $usage
+--
+-- These imports are used in the following example
+--
+-- > import Data.Tree
+-- > import XMonad.Actions.TreeSelect
+-- > import XMonad.Hooks.WorkspaceHistory
+-- > import qualified XMonad.StackSet as W
+--
+-- For selecting Workspaces, you need to define them in a tree structure using 'Data.Tree.Node' instead of just a standard list
+--
+-- Here is an example workspace-tree
+--
+-- > myWorkspaces :: Forest String
+-- > myWorkspaces = [ Node "Browser" [] -- a workspace for your browser
+-- >                , Node "Home"       -- for everyday activity's
+-- >                    [ Node "1" []   --  with 4 extra sub-workspaces, for even more activity's
+-- >                    , Node "2" []
+-- >                    , Node "3" []
+-- >                    , Node "4" []
+-- >                    ]
+-- >                , Node "Programming" -- for all your programming needs
+-- >                    [ Node "Haskell" []
+-- >                    , Node "Docs"    [] -- documentation
+-- >                    ]
+-- >                ]
+--
+-- Then add it to your 'XMonad.Core.workspaces' using the 'toWorkspaces' function.
+--
+-- Optionally, if you add 'workspaceHistoryHook' to your 'logHook' you can use the \'o\' and \'i\' keys to select from previously-visited workspaces
+--
+-- > xmonad $ defaultConfig { ...
+-- >                        , workspaces = toWorkspaces myWorkspaces
+-- >                        , logHook = workspaceHistoryHook
+-- >                        }
+--
+-- After that you still need to bind buttons to 'treeselectWorkspace' to start selecting a workspaces and moving windows
+--
+-- you could bind @Mod-f@ to switch workspace
+--
+-- >  , ((modMask, xK_f), treeselectWorkspace myTreeConf myWorkspaces W.greedyView)
+--
+-- and bind @Mod-Shift-f@ to moving the focused windows to a workspace
+--
+-- >  , ((modMask .|. shiftMask, xK_f), treeselectWorkspace myTreeConf myWorkspaces W.shift)
+
+-- $config
+-- The selection menu is very configurable, you can change the font, all colors and the sizes of the boxes.
+--
+-- The default config defined as 'tsDefaultConfig'
+--
+-- > tsDefaultConfig = TSConfig { ts_hidechildren = True
+-- >                            , ts_background   = 0xc0c0c0c0
+-- >                            , ts_font         = "xft:Sans-16"
+-- >                            , ts_node         = (0xff000000, 0xff50d0db)
+-- >                            , ts_nodealt      = (0xff000000, 0xff10b8d6)
+-- >                            , ts_highlight    = (0xffffffff, 0xffff0000)
+-- >                            , ts_extra        = 0xff000000
+-- >                            , ts_node_width   = 200
+-- >                            , ts_node_height  = 30
+-- >                            , ts_originX      = 0
+-- >                            , ts_originY      = 0
+-- >                            , ts_indent       = 80
+-- >                            , ts_navigate     = defaultNavigation
+-- >                            }
+
+-- $pixel
+--
+-- The 'Pixel' Color format is in the form of @0xaarrggbb@
+--
+-- Note that transparency is only supported if you have a window compositor running like <https://github.com/chjj/compton compton>
+--
+-- Some Examples:
+--
+-- @
+-- white       = 0xffffffff
+-- black       = 0xff000000
+-- red         = 0xffff0000
+-- blue        = 0xff00ff00
+-- green       = 0xff0000ff
+-- transparent = 0x00000000
+-- @
+
+-- $navigation
+--
+-- Keybindings for navigations can also be modified
+--
+-- This is the definition of 'defaultNavigation'
+--
+-- > defaultNavigation :: M.Map (KeyMask, KeySym) (TreeSelect a (Maybe a))
+-- > defaultNavigation = M.fromList
+-- >     [ ((0, xK_Escape), cancel)
+-- >     , ((0, xK_Return), select)
+-- >     , ((0, xK_space),  select)
+-- >     , ((0, xK_Up),     movePrev)
+-- >     , ((0, xK_Down),   moveNext)
+-- >     , ((0, xK_Left),   moveParent)
+-- >     , ((0, xK_Right),  moveChild)
+-- >     , ((0, xK_k),      movePrev)
+-- >     , ((0, xK_j),      moveNext)
+-- >     , ((0, xK_h),      moveParent)
+-- >     , ((0, xK_l),      moveChild)
+-- >     , ((0, xK_o),      moveHistBack)
+-- >     , ((0, xK_i),      moveHistForward)
+-- >     ]
+
+-- $advusage
+-- This module can also be used to select any other action
+
+-- | Extensive configuration for displaying the tree.
+--
+-- This class also has a 'Default' instance
+data TSConfig a = TSConfig { ts_hidechildren :: Bool -- ^ when enabled, only the parents (and their first children) of the current node will be shown (This feature is not yet implemented!)
+                           , ts_background :: Pixel -- ^ background color filling the entire screen.
+
+                           , ts_font :: String -- ^ XMF font for drawing the node name extra text
+
+                           , ts_node      :: (Pixel, Pixel) -- ^ node foreground (text) and background color when not selected
+                           , ts_nodealt   :: (Pixel, Pixel) -- ^ every other node will use this color instead of 'ts_node'
+                           , ts_highlight :: (Pixel, Pixel) -- ^ node foreground (text) and background color when selected
+
+                           , ts_extra :: Pixel -- ^ extra text color
+
+                           , ts_node_width   :: Int -- ^ node width in pixels
+                           , ts_node_height  :: Int -- ^ node height in pixels
+                           , ts_originX :: Int -- ^ tree X position on the screen in pixels
+                           , ts_originY :: Int -- ^ tree Y position on the screen in pixels
+
+                           , ts_indent :: Int -- ^ indentation amount for each level in pixels
+
+                           , ts_navigate :: M.Map (KeyMask, KeySym) (TreeSelect a (Maybe a)) -- ^ key bindings for navigating the tree
+                           }
+
+instance Default (TSConfig a) where
+    def = TSConfig { ts_hidechildren = True
+                   , ts_background   = 0xc0c0c0c0
+                   , ts_font         = "xft:Sans-16"
+                   , ts_node         = (0xff000000, 0xff50d0db)
+                   , ts_nodealt      = (0xff000000, 0xff10b8d6)
+                   , ts_highlight    = (0xffffffff, 0xffff0000)
+                   , ts_extra        = 0xff000000
+                   , ts_node_width   = 200
+                   , ts_node_height  = 30
+                   , ts_originX      = 0
+                   , ts_originY      = 0
+                   , ts_indent       = 80
+                   , ts_navigate     = defaultNavigation
+                   }
+
+-- | Default navigation
+--
+-- * navigation using either arrow key or vi style hjkl
+-- * Return or Space to confirm
+-- * Escape or Backspace to cancel to
+defaultNavigation :: M.Map (KeyMask, KeySym) (TreeSelect a (Maybe a))
+defaultNavigation = M.fromList
+    [ ((0, xK_Escape), cancel)
+    , ((0, xK_Return), select)
+    , ((0, xK_space),  select)
+    , ((0, xK_Up),     movePrev)
+    , ((0, xK_Down),   moveNext)
+    , ((0, xK_Left),   moveParent)
+    , ((0, xK_Right),  moveChild)
+    , ((0, xK_k),      movePrev)
+    , ((0, xK_j),      moveNext)
+    , ((0, xK_h),      moveParent)
+    , ((0, xK_l),      moveChild)
+    , ((0, xK_o),      moveHistBack)
+    , ((0, xK_i),      moveHistForward)
+    ]
+
+-- | Default configuration.
+--
+-- Using nice alternating blue nodes
+tsDefaultConfig :: TSConfig a
+tsDefaultConfig = def
+
+-- | Tree Node With a name and extra text
+data TSNode a = TSNode { tsn_name  :: String
+                       , tsn_extra :: String -- ^ extra text, displayed next to the node name
+                       , tsn_value :: a      -- ^ value to return when this node is selected
+                       }
+
+-- | State used by TreeSelect.
+--
+-- Contains all needed information such as the window, font and a zipper over the tree.
+data TSState a = TSState { tss_tree     :: TreeZipper (TSNode a)
+                         , tss_window   :: Window
+                         , tss_display  :: Display
+                         , tss_size     :: (Int, Int) -- ^ size of 'tz_window'
+                         , tss_xfont    :: XMonadFont
+                         , tss_gc       :: GC
+                         , tss_visual   :: Visual
+                         , tss_colormap :: Colormap
+                         , tss_history  :: ([[String]], [[String]]) -- ^ history zipper, navigated with 'moveHistBack' and 'moveHistForward'
+                         }
+
+-- | State monad transformer using 'TSState'
+newtype TreeSelect a b = TreeSelect { runTreeSelect :: ReaderT (TSConfig a) (StateT (TSState a) X) b }
+    deriving (Monad, Applicative, Functor, MonadState (TSState a),  MonadReader (TSConfig a), MonadIO)
+
+-- | Lift the 'X' action into the 'XMonad.Actions.TreeSelect.TreeSelect' monad
+liftX :: X a -> TreeSelect b a
+liftX = TreeSelect . lift . lift
+
+-- | Run Treeselect with a given config and tree.
+-- This can be used for selectiong anything
+--
+-- * for switching workspaces and moving windows use 'treeselectWorkspace'
+-- * for selecting actions use 'treeselectAction'
+treeselect :: TSConfig a         -- ^ config file
+           -> Forest (TSNode a)  -- ^ a list of 'Data.Tree.Tree's to select from.
+           -> X (Maybe a)
+treeselect c t = treeselectAt c (fromForest t) []
+
+-- | Same as 'treeselect' but ad a specific starting position
+treeselectAt :: TSConfig a         -- ^ config file
+             -> TreeZipper (TSNode a)  -- ^ tree structure with a cursor position (starting node)
+             -> [[String]] -- ^ list of paths that can be navigated with 'moveHistBack' and 'moveHistForward' (bound to the 'o' and 'i' keys)
+             -> X (Maybe a)
+treeselectAt conf@TSConfig{..} zipper hist = withDisplay $ \display -> do
+    -- create a window on the currently focused screen
+    rootw <- asks theRoot
+    Rectangle{..} <- gets $ screenRect . W.screenDetail . W.current . windowset
+
+    Just vinfo <- liftIO $ matchVisualInfo display (defaultScreen display) 32 4
+
+    colormap <- liftIO $ createColormap display rootw (visualInfo_visual vinfo) allocNone
+
+    win <- liftIO $ allocaSetWindowAttributes $ \attributes -> do
+        set_override_redirect attributes True
+        set_colormap attributes colormap
+        set_background_pixel attributes ts_background
+        set_border_pixel attributes 0
+        createWindow display rootw rect_x rect_y rect_width rect_height 0 (visualInfo_depth vinfo) inputOutput (visualInfo_visual vinfo) (cWColormap .|. cWBorderPixel .|. cWBackPixel) attributes
+
+    liftIO $ do
+        -- TODO: move below?
+        -- make the window visible
+        mapWindow display win
+
+        -- listen to key and mouse button events
+        selectInput display win (exposureMask .|. keyPressMask .|. buttonReleaseMask)
+
+        -- TODO: enable mouse select?
+        -- and mouse button 1
+        grabButton display button1 anyModifier win True buttonReleaseMask grabModeAsync grabModeAsync none none
+
+    -- grab the keyboard
+    status <- liftIO $ grabKeyboard display win True grabModeAsync grabModeAsync currentTime
+
+    r <- if status == grabSuccess
+        then do
+            -- load the XMF font
+            gc <- liftIO $ createGC display win
+            xfont <- initXMF ts_font
+
+            -- run the treeselect Monad
+            ret <- evalStateT (runReaderT (runTreeSelect (redraw >> navigate)) conf)
+                TSState{ tss_tree     = zipper
+                       , tss_window   = win
+                       , tss_display  = display
+                       , tss_xfont    = xfont
+                       , tss_size     = (fromIntegral rect_width, fromIntegral rect_height)
+                       , tss_gc       = gc
+                       , tss_visual   = visualInfo_visual vinfo
+                       , tss_colormap = colormap
+                       , tss_history = ([], hist)
+                       }
+
+            -- release the XMF font
+            releaseXMF xfont
+            liftIO $ freeGC display gc
+            return ret
+
+        else return Nothing
+
+    -- destroy the window
+    liftIO $ do
+        unmapWindow display win
+        destroyWindow display win
+        freeColormap display colormap
+        -- Flush the output buffer and wait for all the events to be processed
+        -- TODO: is this needed?
+        sync display False
+    return r
+
+-- | Select a workspace and execute a \"view\" function from "XMonad.StackSet" on it.
+treeselectWorkspace :: TSConfig WorkspaceId
+                    -> Forest String -- ^ your tree of workspace-names
+                    -> (WorkspaceId -> WindowSet -> WindowSet) -- ^ the \"view\" function.
+                                                               -- Instances can be 'W.greedyView' for switching to a workspace
+                                                               -- and/or 'W.shift' for moving the focused window to a selected workspace.
+                                                               --
+                                                               -- These actions can also be combined by doing
+                                                               --
+                                                               -- > \i -> W.greedyView i . W.shift i
+                    -> X ()
+treeselectWorkspace c xs f = do
+    -- get all defined workspaces
+    -- They have to be set with 'toWorkspaces'!
+    ws <- gets (W.workspaces . windowset)
+
+    -- check the 'XConfig.workspaces'
+    if all (`elem` map tag ws) (toWorkspaces xs)
+      then do
+        -- convert the 'Forest WorkspaceId' to 'Forest (TSNode WorkspaceId)'
+        wsf <- forMForest (mkPaths xs) $ \(n, i) -> maybe (return (TSNode n "Does not exist!" "")) (mkNode n) (find (\w -> i == tag w) ws)
+
+        -- get the current workspace path
+        me <- gets (W.tag . W.workspace . W.current . windowset)
+        hist <- workspaceHistory
+        treeselectAt c (fromJust $ followPath tsn_name (splitPath me) $ fromForest wsf) (map splitPath hist) >>= maybe (return ()) (windows . f)
+
+      else liftIO $ do
+        -- error!
+        let msg = unlines $ [ "Please add:"
+                            , "    workspaces = toWorkspaces myWorkspaces"
+                            , "to your XMonad config!"
+                            , ""
+                            , "XConfig.workspaces: "
+                            ] ++ map tag ws
+        hPutStrLn stderr msg
+        _ <- forkProcess $ executeFile "xmessage" True [msg] Nothing
+        return ()
+  where
+    mkNode n w = do
+        -- find the focused window's name on this workspace
+        name <- maybe (return "") (fmap show . getName . W.focus) $ stack w
+        return $ TSNode n name (tag w)
+
+-- | Convert the workspace-tree to a flat list of paths such that XMonad can use them
+--
+-- The Nodes will be separated by a dot (\'.\') character
+toWorkspaces :: Forest String -> [WorkspaceId]
+toWorkspaces = map snd . concatMap flatten . mkPaths
+
+mkPaths :: Forest String -> Forest (String, WorkspaceId)
+mkPaths = map (\(Node n ns) -> Node (n, n) (map (f n) ns))
+  where
+    f pth (Node x xs) = let pth' = pth ++ '.' : x
+                         in Node (x, pth') (map (f pth') xs)
+
+splitPath :: WorkspaceId -> [String]
+splitPath i = case break (== '.') i of
+    (x,   []) -> [x]
+    (x, _:xs) -> x : splitPath xs
+
+-- | Select from a Tree of 'X' actions
+--
+-- <<https://wiki.haskell.org/wikiupload/thumb/9/9b/Treeselect-Action.png/800px-Treeselect-Action.png>>
+--
+-- Each of these actions have to be specified inside a 'TSNode'
+--
+-- Example
+--
+-- > treeselectAction myTreeConf
+-- >    [ Node (TSNode "Hello"    "displays hello"      (spawn "xmessage hello!")) []
+-- >    , Node (TSNode "Shutdown" "Poweroff the system" (spawn "shutdown")) []
+-- >    , Node (TSNode "Brightness" "Sets screen brightness using xbacklight" (return ()))
+-- >        [ Node (TSNode "Bright" "FULL POWER!!"            (spawn "xbacklight -set 100")) []
+-- >        , Node (TSNode "Normal" "Normal Brightness (50%)" (spawn "xbacklight -set 50"))  []
+-- >        , Node (TSNode "Dim"    "Quite dark"              (spawn "xbacklight -set 10"))  []
+-- >        ]
+-- >    ]
+treeselectAction :: TSConfig (X a) -> Forest (TSNode (X a)) -> X ()
+treeselectAction c xs = treeselect c xs >>= \x -> case x of
+    Just a  -> a >> return ()
+    Nothing -> return ()
+
+forMForest :: (Functor m, Applicative m, Monad m) => [Tree a] -> (a -> m b) -> m [Tree b]
+forMForest x g = mapM (mapMTree g) x
+
+mapMTree :: (Functor m, Applicative m, Monad m) => (a -> m b) -> Tree a -> m (Tree b)
+mapMTree f (Node x xs) = Node <$> f x <*>  mapM (mapMTree f) xs
+
+
+-- | Quit returning the currently selected node
+select :: TreeSelect a (Maybe a)
+select = Just <$> gets (tsn_value . cursor . tss_tree)
+
+-- | Quit without returning anything
+cancel :: TreeSelect a (Maybe a)
+cancel = return Nothing
+
+-- TODO: redraw only what is necessary.
+-- Examples: redrawAboveCursor, redrawBelowCursor and redrawCursor
+
+-- | Move the cursor to its parent node
+moveParent :: TreeSelect a (Maybe a)
+moveParent = moveWith parent >> redraw >> navigate
+
+-- | Move the cursor one level down, highlighting its first child-node
+moveChild :: TreeSelect a (Maybe a)
+moveChild = moveWith children >> redraw >> navigate
+
+-- | Move the cursor to the next child-node
+moveNext :: TreeSelect a (Maybe a)
+moveNext = moveWith nextChild >> redraw >> navigate
+
+-- | Move the cursor to the previous child-node
+movePrev :: TreeSelect a (Maybe a)
+movePrev = moveWith previousChild >> redraw >> navigate
+
+-- | Move backwards in history
+moveHistBack :: TreeSelect a (Maybe a)
+moveHistBack = do
+    s <- get
+    case tss_history s of
+        (xs, a:y:ys) -> do
+            put s{tss_history = (a:xs, y:ys)}
+            moveTo y
+        _ -> navigate
+
+-- | Move forward in history
+moveHistForward :: TreeSelect a (Maybe a)
+moveHistForward = do
+    s <- get
+    case tss_history s of
+        (x:xs, ys) -> do
+            put s{tss_history = (xs, x:ys)}
+            moveTo x
+        _ -> navigate
+
+-- | Move to a specific node
+moveTo :: [String] -- ^ path, always starting from the top
+       -> TreeSelect a (Maybe a)
+moveTo i = moveWith (followPath tsn_name i . rootNode) >> redraw >> navigate
+
+-- | Apply a transformation on the internal 'XMonad.Util.TreeZipper.TreeZipper'.
+moveWith :: (TreeZipper (TSNode a) -> Maybe (TreeZipper (TSNode a))) -> TreeSelect a ()
+moveWith f = do
+    s <- get
+    case f (tss_tree s) of
+        -- TODO: redraw cursor only?
+        Just t -> put s{ tss_tree = t }
+        Nothing -> return ()
+
+-- | wait for keys and run navigation
+navigate :: TreeSelect a (Maybe a)
+navigate = gets tss_display >>= \d -> join . liftIO . allocaXEvent $ \e -> do
+    maskEvent d (exposureMask .|. keyPressMask .|. buttonReleaseMask) e
+
+    ev <- getEvent e
+
+    if ev_event_type ev == keyPress
+      then do
+        (ks, _) <- lookupString $ asKeyEvent e
+        return $ do
+            mask <- liftX $ cleanMask (ev_state ev)
+            f <- asks ts_navigate
+            fromMaybe navigate $ M.lookup (mask, fromMaybe xK_VoidSymbol ks) f
+      else return navigate
+
+-- | Request a full redraw
+redraw :: TreeSelect a ()
+redraw = do
+    win <- gets tss_window
+    dpy <- gets tss_display
+
+    -- clear window
+    -- TODO: not always needed!
+    liftIO $ clearWindow dpy win
+
+    t <- gets tss_tree
+    _ <- drawLayers 0 0 (reverse $ (tz_before t, cursor t, tz_after t) : tz_parents t)
+    return ()
+
+drawLayers :: Int -- ^ indentation level
+           -> Int -- ^ height
+           -> [(Forest (TSNode a), TSNode a, Forest (TSNode a))] -- ^ node layers (from top to bottom!)
+           -> TreeSelect a Int
+drawLayers _ yl [] = return yl
+drawLayers xl yl ((bs, c, as):xs) = do
+    TSConfig{..} <- ask
+
+    let nodeColor y = if odd y then ts_node else ts_nodealt
+
+    -- draw nodes above
+    forM_ (zip [yl ..] (reverse bs)) $ \(y, Node n _) ->
+        drawNode xl y n (nodeColor y)
+        -- drawLayers (xl + 1) (y + 1) ns
+        -- TODO: draw rest? if not ts_hidechildren
+        -- drawLayers (xl + 1) (y + 1) ns
+
+    -- draw the current / parent node
+    -- if this is the last (currently focused) we use the 'ts_highlight' color
+    let current_level = yl + length bs
+    drawNode xl current_level c $
+        if null xs then ts_highlight
+                   else nodeColor current_level
+
+    l2 <- drawLayers (xl + 1) (current_level + 1) xs
+
+    -- draw nodes below
+    forM_ (zip [l2 ..] as) $ \(y, Node n _) ->
+        drawNode xl y n (nodeColor y)
+        -- TODO: draw rest? if not ts_hidechildren
+        -- drawLayers (xl + 1) (y + 1) ns
+    return (l2 + length as)
+
+
+-- | Draw a node at a given indentation and height level
+drawNode :: Int -- ^ indentation level (not in pixels)
+         -> Int -- ^ height level (not in pixels)
+         -> TSNode a -- ^ node to draw
+         -> (Pixel, Pixel) -- ^ node foreground (font) and background color
+         -> TreeSelect a ()
+drawNode ix iy TSNode{..} col = do
+    TSConfig{..} <- ask
+    window       <- gets tss_window
+    display      <- gets tss_display
+    font         <- gets tss_xfont
+    gc           <- gets tss_gc
+    colormap <- gets tss_colormap
+    visual   <- gets tss_visual
+    liftIO $ drawWinBox window display visual colormap gc font col tsn_name ts_extra tsn_extra
+        (ix * ts_indent) (iy * ts_node_height)
+        ts_node_width ts_node_height
+
+    -- TODO: draw extra text (transparent background? or ts_background)
+    -- drawWinBox window fnt col2 nodeH (scW-x) (mes) (x+nodeW) y 8
+
+-- | Draw a simple box with text
+drawWinBox :: Window -> Display -> Visual -> Colormap -> GC -> XMonadFont -> (Pixel, Pixel) -> String -> Pixel -> String -> Int -> Int -> Int -> Int -> IO ()
+drawWinBox win display visual colormap gc font (fg, bg) text fg2 text2 x y w h = do
+    -- draw box
+    setForeground display gc bg
+    fillRectangle display win gc (fromIntegral x) (fromIntegral y) (fromIntegral w) (fromIntegral h)
+
+    -- dreaw text
+    drawStringXMF display win visual colormap gc font fg
+        (fromIntegral $ x + 8)
+        (fromIntegral $ y + h - 8)
+        text
+
+    -- dreaw extra text
+    drawStringXMF display win visual colormap gc font fg2
+        (fromIntegral $ x + w + 8)
+        (fromIntegral $ y + h - 8)
+        text2
+
+-- | Modified version of 'XMonad.Util.Font.printStringXMF' that uses 'Pixel' as color format
+drawStringXMF :: Display -> Drawable -> Visual -> Colormap -> GC
+              -> XMonadFont -- ^ XMF Font
+              -> Pixel -- ^ font color
+              -> Position   -- ^ x-position
+              -> Position   -- ^ y-position
+              -> String -- ^ string text
+              -> IO ()
+drawStringXMF display window visual colormap gc font col x y text = case font of
+    Core fnt -> do
+        setForeground display gc col
+        setFont display gc $ fontFromFontStruct fnt
+        drawImageString display window gc x y text
+    Utf8 fnt -> do
+        setForeground display gc col
+        wcDrawImageString display window fnt gc x y text
+#ifdef XFT
+    Xft fnt -> do
+        withXftDraw display window visual colormap $
+            \ft_draw -> withXftColorValue display visual colormap (fromARGB col) $
+            \ft_color -> xftDrawString ft_draw ft_color fnt x y text
+
+-- | Convert 'Pixel' to 'XRenderColor'
+--
+-- Note that it uses short to represent its components
+fromARGB :: Pixel -> XRenderColor
+fromARGB x = XRenderColor (fromIntegral $ 0xff00 .&. shiftR x 8)  -- red
+                          (fromIntegral $ 0xff00 .&. x)           -- green
+                          (fromIntegral $ 0xff00 .&. shiftL x 8)  -- blue
+                          (fromIntegral $ 0xff00 .&. shiftR x 16) -- alpha
+#endif

XMonad/Actions/UpdateFocus.hs

@@ -29,7 +29,7 @@ import Data.Monoid
 -- following to your @~\/.xmonad\/xmonad.hs@:
 --
 -- > import XMonad.Actions.UpdateFocus
--- > xmonad $ defaultConfig {
+-- > xmonad $ def {
 -- >   ..
 -- >   startupHook = adjustEventInput
 -- >   handleEventHook = focusOnMouseMove
@@ -57,4 +57,4 @@ adjustEventInput = withDisplay $ \dpy -> do
   rootw <- asks theRoot
   io $ selectInput dpy rootw $  substructureRedirectMask .|. substructureNotifyMask
                                 .|. enterWindowMask .|. leaveWindowMask .|. structureNotifyMask
-                                .|. buttonPressMask .|. pointerMotionMask
+                                .|. buttonPressMask .|. pointerMotionMask

XMonad/Actions/UpdatePointer.hs

@@ -1,7 +1,8 @@
+{-# LANGUAGE ScopedTypeVariables #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  XMonadContrib.UpdatePointer
--- Copyright   :  (c) Robert Marlow <robreim@bobturf.org>
+-- Copyright   :  (c) Robert Marlow <robreim@bobturf.org>, 2015 Evgeny Kurnevsky
 -- License     :  BSD3-style (see LICENSE)
 --
 -- Maintainer  :  Robert Marlow <robreim@bobturf.org>
@@ -19,15 +20,16 @@ module XMonad.Actions.UpdatePointer
      -- * Usage
      -- $usage
      updatePointer
-     , PointerPosition (..)
     )
     where
 
 import XMonad
 import XMonad.Util.XUtils (fi)
+import Control.Arrow
 import Control.Monad
 import XMonad.StackSet (member, peek, screenDetail, current)
 import Data.Maybe
+import Control.Exception
 
 -- $usage
 -- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:
@@ -35,71 +37,74 @@ import Data.Maybe
 -- > import XMonad
 -- > import XMonad.Actions.UpdatePointer
 --
--- Enable it by including it in your logHook definition. Eg:
+-- Enable it by including it in your logHook definition, e.g.:
 --
--- > logHook = updatePointer Nearest
+-- > logHook = updatePointer (0.5, 0.5) (1, 1)
 --
--- which will move the pointer to the nearest point of a newly focused window, or
+-- which will move the pointer to the nearest point of a newly focused
+-- window. The first argument establishes a reference point within the
+-- newly-focused window, while the second argument linearly interpolates
+-- between said reference point and the edges of the newly-focused window to
+-- obtain a bounding box for the pointer.
 --
--- > logHook = updatePointer (Relative 0.5 0.5)
---
--- which will move the pointer to the center of a newly focused window.
+-- > logHook = updatePointer (0.5, 0.5) (0, 0) -- exact centre of window
+-- > logHook = updatePointer (0.25, 0.25) (0.25, 0.25) -- near the top-left
+-- > logHook = updatePointer (0.5, 0.5) (1.1, 1.1) -- within 110% of the edge
 --
 -- To use this with an existing logHook, use >> :
 --
 -- > logHook = dynamicLog
--- >           >> updatePointer (Relative 1 1)
+-- >           >> updatePointer (1, 1) (0, 0)
 --
 -- which moves the pointer to the bottom-right corner of the focused window.
 
-data PointerPosition = Nearest | Relative Rational Rational | TowardsCentre Rational Rational
-    deriving (Read,Show)
-
 -- | Update the pointer's location to the currently focused
 -- window or empty screen unless it's already there, or unless the user was changing
 -- focus with the mouse
-updatePointer :: PointerPosition -> X ()
-updatePointer p = do
+updatePointer :: (Rational, Rational) -> (Rational, Rational) -> X ()
+updatePointer refPos ratio = do
   ws <- gets windowset
   dpy <- asks display
+  let defaultRect = screenRect $ screenDetail $ current ws
   rect <- case peek ws of
-        Nothing -> return $ (screenRect . screenDetail .current) ws
-        Just w  -> windowAttributesToRectangle `fmap` io (getWindowAttributes dpy w)
+        Nothing -> return defaultRect
+        Just w  -> do tryAttributes <- io $ try $ getWindowAttributes dpy w
+                      return $ case tryAttributes of
+                        Left (_ :: SomeException) -> defaultRect
+                        Right attributes          -> windowAttributesToRectangle attributes
   root <- asks theRoot
   mouseIsMoving <- asks mouseFocused
-  (_sameRoot,_,currentWindow,rootx,rooty,_,_,_) <- io $ queryPointer dpy root
+  (_sameRoot,_,currentWindow,rootX,rootY,_,_,_) <- io $ queryPointer dpy root
   drag <- gets dragging
-  unless (pointWithin (fi rootx) (fi rooty) rect
+  unless (pointWithin (fi rootX) (fi rootY) rect
           || mouseIsMoving
           || isJust drag
-          || not (currentWindow `member` ws || currentWindow == none)) $
-    case p of
-    Nearest -> do
-      let x = moveWithin (fi rootx) (rect_x rect) (fi (rect_x rect) + fi (rect_width  rect))
-          y = moveWithin (fi rooty) (rect_y rect) (fi (rect_y rect) + fi (rect_height rect))
-      io $ warpPointer dpy none root 0 0 0 0 x y
-    TowardsCentre xfrc yfrc -> do
-      let cx = fi (rect_width rect) / 2 + fi (rect_x rect)
-          cy = fi (rect_height rect) / 2 + fi (rect_y rect)
-          x,y,cx,cy :: Rational
-          x = moveWithin (fi rootx) (fi $ rect_x rect) (fi (rect_x rect) + fi (rect_width  rect))
-          y = moveWithin (fi rooty) (fi $ rect_y rect) (fi (rect_y rect) + fi (rect_height rect))
-      io $ warpPointer dpy none root 0 0 0 0 (round $ x + xfrc*(cx-x)) (round $ y + yfrc*(cy-y))
-    Relative h v ->
-      io $ warpPointer dpy none root 0 0 0 0
-           (rect_x rect + fraction h (rect_width rect))
-           (rect_y rect + fraction v (rect_height rect))
-        where fraction x y = floor (x * fromIntegral y)
+          || not (currentWindow `member` ws || currentWindow == none)) $ let
+    -- focused rectangle
+    (rectX, rectY) = (rect_x &&& rect_y) rect
+    (rectW, rectH) = (fi . rect_width &&& fi . rect_height) rect
+    -- reference position, with (0,0) and (1,1) being top-left and bottom-right
+    refX = lerp (fst refPos) rectX (rectX + rectW)
+    refY = lerp (snd refPos) rectY (rectY + rectH)
+    -- final pointer bounds, lerped *outwards* from reference position
+    boundsX = join (***) (lerp (fst ratio) refX) (rectX, rectX + rectW)
+    boundsY = join (***) (lerp (snd ratio) refY) (rectY, rectY + rectH)
+    -- ideally we ought to move the pointer in a straight line towards the
+    -- reference point until it is within the above bounds, but…
+    in io $ warpPointer dpy none root 0 0 0 0
+        (round . clip boundsX $ fi rootX)
+        (round . clip boundsY $ fi rootY)
 
 windowAttributesToRectangle :: WindowAttributes -> Rectangle
 windowAttributesToRectangle wa = Rectangle (fi (wa_x wa))
                                            (fi (wa_y wa))
                                            (fi (wa_width wa + 2 * wa_border_width wa))
                                            (fi (wa_height wa + 2 * wa_border_width wa))
-moveWithin :: Ord a => a -> a -> a -> a
-moveWithin now lower upper =
-    if now < lower
-    then lower
-    else if now > upper
-         then upper
-         else now
+
+lerp :: (RealFrac r, Real a, Real b) => r -> a -> b -> r
+lerp r a b = (1 - r) * realToFrac a + r * realToFrac b
+
+clip :: Ord a => (a, a) -> a -> a
+clip (lower, upper) x = if x < lower then lower
+    else if x > upper then upper else x
+

XMonad/Actions/WindowBringer.hs

@@ -1,3 +1,4 @@
+{-# LANGUAGE TupleSections #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  XMonad.Actions.WindowBringer
@@ -17,13 +18,13 @@
 module XMonad.Actions.WindowBringer (
                     -- * Usage
                     -- $usage
-                    gotoMenu, gotoMenu', gotoMenuArgs, gotoMenuArgs',
-                    bringMenu, bringMenu', bringMenuArgs, bringMenuArgs',
-                    windowMap,
-                    bringWindow
+                    WindowBringerConfig(..),
+                    gotoMenu, gotoMenuConfig, gotoMenu', gotoMenuArgs, gotoMenuArgs',
+                    bringMenu, bringMenuConfig, bringMenu', bringMenuArgs, bringMenuArgs',
+                    windowMap, windowMap', bringWindow, actionMenu
                    ) where
 
-import Data.Char (toLower)
+import Control.Applicative((<$>))
 import qualified Data.Map as M
 
 import qualified XMonad.StackSet as W
@@ -46,54 +47,74 @@ import XMonad.Util.NamedWindows (getName)
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings".
 
--- | Default menu command
-defaultCmd :: String
-defaultCmd = "dmenu"
+data WindowBringerConfig = WindowBringerConfig
+    { menuCommand :: String -- ^ The shell command that will handle window selection
+    , menuArgs :: [String] -- ^ Arguments to be passed to menuCommand
+    , windowTitler :: X.WindowSpace -> Window -> X String -- ^ A function that produces window titles given a workspace and a window
+    }
+
+instance Default WindowBringerConfig where
+    def = WindowBringerConfig{ menuCommand = "dmenu"
+                             , menuArgs = ["-i"]
+                             , windowTitler = decorateName
+                             }
 
 -- | Pops open a dmenu with window titles. Choose one, and you will be
 --   taken to the corresponding workspace.
 gotoMenu :: X ()
-gotoMenu = gotoMenuArgs []
+gotoMenu = gotoMenuConfig def
+
+-- | Pops open a dmenu with window titles. Choose one, and you will be
+--   taken to the corresponding workspace. This version accepts a configuration
+--   object.
+gotoMenuConfig :: WindowBringerConfig -> X ()
+gotoMenuConfig wbConfig = actionMenu wbConfig W.focusWindow
 
 -- | Pops open a dmenu with window titles. Choose one, and you will be
 --   taken to the corresponding workspace. This version takes a list of
 --   arguments to pass to dmenu.
 gotoMenuArgs :: [String] -> X ()
-gotoMenuArgs menuArgs = gotoMenuArgs' defaultCmd menuArgs
+gotoMenuArgs args = gotoMenuConfig def { menuArgs = args }
 
 -- | Pops open an application with window titles given over stdin. Choose one,
 --   and you will be taken to the corresponding workspace.
 gotoMenu' :: String -> X ()
-gotoMenu' menuCmd = gotoMenuArgs' menuCmd []
+gotoMenu' cmd = gotoMenuConfig def { menuArgs = [], menuCommand = cmd }
 
 -- | Pops open an application with window titles given over stdin. Choose one,
 --   and you will be taken to the corresponding workspace. This version takes a
 --   list of arguments to pass to dmenu.
 gotoMenuArgs' :: String -> [String] -> X ()
-gotoMenuArgs' menuCmd menuArgs = actionMenu menuCmd menuArgs W.focusWindow
+gotoMenuArgs' cmd args = gotoMenuConfig def { menuCommand = cmd, menuArgs = args }
 
 -- | Pops open a dmenu with window titles. Choose one, and it will be
 --   dragged, kicking and screaming, into your current workspace.
 bringMenu :: X ()
-bringMenu = bringMenuArgs []
+bringMenu = bringMenuArgs def
+
+-- | Pops open a dmenu with window titles. Choose one, and it will be
+--   dragged, kicking and screaming, into your current workspace. This version
+--   accepts a configuration object.
+bringMenuConfig :: WindowBringerConfig -> X ()
+bringMenuConfig wbConfig = actionMenu wbConfig bringWindow
 
 -- | Pops open a dmenu with window titles. Choose one, and it will be
 --   dragged, kicking and screaming, into your current workspace. This version
 --   takes a list of arguments to pass to dmenu.
 bringMenuArgs :: [String] -> X ()
-bringMenuArgs menuArgs = bringMenuArgs' defaultCmd menuArgs
+bringMenuArgs args = bringMenuConfig def { menuArgs = args }
 
 -- | Pops open an application with window titles given over stdin. Choose one,
 --   and it will be dragged, kicking and screaming, into your current
 --   workspace.
 bringMenu' :: String -> X ()
-bringMenu' menuCmd = bringMenuArgs' menuCmd []
+bringMenu' cmd = bringMenuConfig def { menuArgs = [], menuCommand = cmd }
 
 -- | Pops open an application with window titles given over stdin. Choose one,
 --   and it will be dragged, kicking and screaming, into your current
 --   workspace. This version allows arguments to the chooser to be specified.
 bringMenuArgs' :: String -> [String] -> X ()
-bringMenuArgs' menuCmd menuArgs = actionMenu menuCmd menuArgs bringWindow
+bringMenuArgs' cmd args = bringMenuConfig def { menuArgs = args, menuCommand = cmd }
 
 -- | Brings the specified window into the current workspace.
 bringWindow :: Window -> X.WindowSet -> X.WindowSet
@@ -101,25 +122,33 @@ bringWindow w ws = W.shiftWin (W.currentTag ws) w ws
 
 -- | Calls dmenuMap to grab the appropriate Window, and hands it off to action
 --   if found.
-actionMenu :: String -> [String] -> (Window -> X.WindowSet -> X.WindowSet) -> X ()
-actionMenu menuCmd menuArgs action = windowMap >>= menuMapFunction >>= flip X.whenJust (windows . action)
+actionMenu :: WindowBringerConfig -> (Window -> X.WindowSet -> X.WindowSet) -> X ()
+actionMenu WindowBringerConfig{ menuCommand = cmd
+                              , menuArgs = args
+                              , windowTitler = titler
+                              } action
+    = windowMap' titler >>= menuMapFunction >>= flip X.whenJust (windows . action)
     where
       menuMapFunction :: M.Map String a -> X (Maybe a)
-      menuMapFunction selectionMap = menuMapArgs menuCmd menuArgs selectionMap
+      menuMapFunction = menuMapArgs cmd args
+
 
 -- | A map from window names to Windows.
 windowMap :: X (M.Map String Window)
-windowMap = do
+windowMap = windowMap' decorateName
+
+-- | A map from window names to Windows, given a windowTitler function.
+windowMap' :: (X.WindowSpace -> Window -> X String) -> X (M.Map String Window)
+windowMap' titler = do
   ws <- gets X.windowset
-  M.fromList `fmap` concat `fmap` mapM keyValuePairs (W.workspaces ws)
+  M.fromList . concat <$> mapM keyValuePairs (W.workspaces ws)
  where keyValuePairs ws = mapM (keyValuePair ws) $ W.integrate' (W.stack ws)
-       keyValuePair ws w = flip (,) w `fmap` decorateName ws w
+       keyValuePair ws w = flip (,) w <$> titler ws w
 
 -- | Returns the window name as will be listed in dmenu.
---   Lowercased, for your convenience (since dmenu is case-sensitive).
 --   Tagged with the workspace ID, to guarantee uniqueness, and to let the user
 --   know where he's going.
 decorateName :: X.WindowSpace -> Window -> X String
 decorateName ws w = do
-  name <- fmap (map toLower . show) $ getName w
+  name <- show <$> getName w
   return $ name ++ " [" ++ W.tag ws ++ "]"

XMonad/Actions/WindowGo.hs

@@ -21,6 +21,7 @@ module XMonad.Actions.WindowGo (
                  runOrRaiseNext,
                  raiseMaybe,
                  raiseNextMaybe,
+                 raiseNextMaybeCustomFocus,
 
                  raiseBrowser,
                  raiseEditor,
@@ -37,13 +38,14 @@ module XMonad.Actions.WindowGo (
 
 import Control.Monad
 import Data.Char (toLower)
+import qualified Data.List as L (nub,sortBy)
 import Data.Monoid
-import XMonad (Query(), X(), ManageHook, withWindowSet, runQuery, liftIO, ask)
+import XMonad (Query(), X(), ManageHook, WindowSet, withWindowSet, runQuery, liftIO, ask)
 import Graphics.X11 (Window)
 import XMonad.ManageHook
 import XMonad.Operations (windows)
 import XMonad.Prompt.Shell (getBrowser, getEditor)
-import qualified XMonad.StackSet as W (allWindows, peek, swapMaster, focusWindow)
+import qualified XMonad.StackSet as W (peek, swapMaster, focusWindow, workspaces, StackSet, Workspace, integrate', tag, stack)
 import XMonad.Util.Run (safeSpawnProg)
 {- $usage
 
@@ -65,12 +67,20 @@ appropriate one, or cover your bases by using instead something like:
 For detailed instructions on editing your key bindings, see
 "XMonad.Doc.Extending#Editing_key_bindings". -}
 
+-- | Get the list of workspaces sorted by their tag
+workspacesSorted :: Ord i => W.StackSet i l a s sd -> [W.Workspace i l a]
+workspacesSorted s = L.sortBy (\u t -> W.tag u `compare` W.tag t) $ W.workspaces s
+
+-- | Get a list of all windows in the 'StackSet' with an absolute ordering of workspaces
+allWindowsSorted :: Ord i => Eq a => W.StackSet i l a s sd -> [a]
+allWindowsSorted = L.nub . concatMap (W.integrate' . W.stack) . workspacesSorted
+
 -- | If windows that satisfy the query exist, apply the supplied
 -- function to them, otherwise run the action given as
 -- second parameter.
 ifWindows :: Query Bool -> ([Window] -> X ()) -> X () -> X ()
 ifWindows qry f el = withWindowSet $ \wins -> do
-  matches <- filterM (runQuery qry) $ W.allWindows wins
+  matches <- filterM (runQuery qry) $ allWindowsSorted wins
   case matches of
     [] -> el
     ws -> f ws
@@ -137,16 +147,21 @@ raiseNext = raiseNextMaybe $ return ()
      'raiseNextMaybe' is an alternative version that allows cycling
      through the matching windows. If the focused window matches the
      query the next matching window is raised. If no matches are found
-     the function f is executed.
--}
-
+     the function f is executed. -}
 raiseNextMaybe :: X () -> Query Bool -> X ()
-raiseNextMaybe f qry = flip (ifWindows qry) f $ \ws -> do
+raiseNextMaybe = raiseNextMaybeCustomFocus W.focusWindow
+
+{- | See 'raiseMaybe' and 'raiseNextMaybe'.
+     In addition to all of the options offered by 'raiseNextMaybe'
+     'raiseNextMaybeCustomFocus' allows the user to supply the function that
+     should be used to shift the focus to any window that is found. -}
+raiseNextMaybeCustomFocus :: (Window -> WindowSet -> WindowSet) -> X() -> Query Bool -> X()
+raiseNextMaybeCustomFocus focusFn f qry = flip (ifWindows qry) f $ \ws -> do
   foc <- withWindowSet $ return . W.peek
   case foc of
     Just w | w `elem` ws -> let (_:y:_) = dropWhile (/=w) $ cycle ws -- cannot fail to match
-                            in windows $ W.focusWindow y
-    _ -> windows . W.focusWindow . head $ ws
+                            in windows $ focusFn y
+    _ -> windows . focusFn . head $ ws
 
 -- | Given a function which gets us a String, we try to raise a window with that classname,
 --   or we then interpret that String as a executable name.
@@ -167,7 +182,8 @@ raiseAndDo :: X () -> Query Bool -> (Window -> X ()) -> X ()
 raiseAndDo f qry after = ifWindow qry (afterRaise `mappend` raiseHook) f
     where afterRaise = ask >>= (>> idHook) . liftX . after
 
-{- | If a window matching the second argument is found, the window is focused and the third argument is called;
+{- | If a window matching the second argument is found, the window is focused and
+     the third argument is called;
      otherwise, the first argument is called. -}
 runOrRaiseAndDo :: String -> Query Bool -> (Window -> X ()) -> X ()
 runOrRaiseAndDo = raiseAndDo . safeSpawnProg
@@ -182,7 +198,6 @@ raiseMaster raisef thatUserQuery = raiseAndDo raisef thatUserQuery (\_ -> window
 {- |  If the window is found the window is focused and set to master
       otherwise, action is run.
 
-      > runOrRaiseMaster "firefox" (className =? "Firefox"))
-  -}
+      > runOrRaiseMaster "firefox" (className =? "Firefox")) -}
 runOrRaiseMaster :: String -> Query Bool -> X ()
 runOrRaiseMaster run query = runOrRaiseAndDo run query (\_ -> windows W.swapMaster)

XMonad/Actions/WindowMenu.hs

@@ -28,7 +28,7 @@ import XMonad
 import qualified XMonad.StackSet as W
 import XMonad.Actions.GridSelect
 import XMonad.Layout.Maximize
-import XMonad.Layout.Minimize
+import XMonad.Actions.Minimize
 import XMonad.Util.XUtils (fi)
 
 -- $usage

XMonad/Actions/WindowNavigation.hs

@@ -62,7 +62,7 @@ import qualified Data.Set as S
 --
 -- > main = do
 -- >     config <- withWindowNavigation (xK_w, xK_a, xK_s, xK_d)
--- >             $ defaultConfig { ... }
+-- >             $ def { ... }
 -- >     xmonad config
 --
 -- Here, we pass in the keys for navigation in counter-clockwise order from up.

XMonad/Actions/Workscreen.hs

@@ -31,6 +31,7 @@ module XMonad.Actions.Workscreen (
   ,shiftToWorkscreen
   ,fromWorkspace
   ,expandWorkspace
+  ,WorkscreenId
   ) where
 
 import XMonad hiding (workspaces)

XMonad/Actions/WorkspaceCursors.hs

@@ -69,8 +69,8 @@ import Data.Traversable(sequenceA)
 -- >     x <- xmobar conf
 -- >     xmonad x
 -- >
--- > conf = additionalKeysP defaultConfig
--- >        { layoutHook = workspaceCursors myCursors $ layoutHook defaultConfig
+-- > conf = additionalKeysP def
+-- >        { layoutHook = workspaceCursors myCursors $ layoutHook def
 -- >        , workspaces = toList myCursors } $
 -- >        [("M-"++shift++control++[k], f direction depth)
 -- >          | (f,shift) <- zip [modifyLayer,shiftModifyLayer] ["","S-"]

XMonad/Actions/WorkspaceNames.hs

@@ -24,7 +24,10 @@ module XMonad.Actions.WorkspaceNames (
     -- * Workspace naming
     renameWorkspace,
     workspaceNamesPP,
+    getWorkspaceNames',
     getWorkspaceNames,
+    getWorkspaceName,
+    getCurrentWorkspaceName,
     setWorkspaceName,
     setCurrentWorkspaceName,
 
@@ -32,6 +35,9 @@ module XMonad.Actions.WorkspaceNames (
     swapTo,
     swapTo',
     swapWithCurrent,
+
+    -- * Workspace prompt
+    workspaceNamePrompt
     ) where
 
 import XMonad
@@ -47,6 +53,7 @@ import XMonad.Util.WorkspaceCompare (getSortByIndex)
 
 import qualified Data.Map as M
 import Data.Maybe (fromMaybe)
+import Data.List (isInfixOf)
 
 -- $usage
 -- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@ file:
@@ -55,7 +62,7 @@ import Data.Maybe (fromMaybe)
 --
 -- Then add keybindings like the following:
 --
--- >   , ((modm .|. shiftMask, xK_r      ), renameWorkspace defaultXPConfig)
+-- >   , ((modm .|. shiftMask, xK_r      ), renameWorkspace def)
 --
 -- and apply workspaceNamesPP to your DynamicLog pretty-printer:
 --
@@ -84,14 +91,27 @@ instance ExtensionClass WorkspaceNames where
     initialValue = WorkspaceNames M.empty
     extensionType = PersistentExtension
 
+-- | Returns a lookup function that maps workspace tags to workspace names.
+getWorkspaceNames' :: X (WorkspaceId -> Maybe String)
+getWorkspaceNames' = do
+    WorkspaceNames m <- XS.get
+    return (`M.lookup` m)
+
 -- | Returns a function that maps workspace tag @\"t\"@ to @\"t:name\"@ for
 -- workspaces with a name, and to @\"t\"@ otherwise.
 getWorkspaceNames :: X (WorkspaceId -> String)
 getWorkspaceNames = do
-    WorkspaceNames m <- XS.get
-    return $ \wks -> case M.lookup wks m of
-        Nothing -> wks
-        Just s  -> wks ++ ":" ++ s
+    lookup <- getWorkspaceNames'
+    return $ \wks -> wks ++ maybe "" (':' :) (lookup wks)
+
+-- | Gets the name of a workspace, if set, otherwise returns nothing.
+getWorkspaceName :: WorkspaceId -> X (Maybe String)
+getWorkspaceName w = ($ w) `fmap` getWorkspaceNames'
+
+-- | Gets the name of the current workspace. See 'getWorkspaceName'
+getCurrentWorkspaceName :: X (Maybe String)
+getCurrentWorkspaceName = do
+    getWorkspaceName =<< gets (W.currentTag . windowset)
 
 -- | Sets the name of a workspace. Empty string makes the workspace unnamed
 -- again.
@@ -150,3 +170,18 @@ swapNames w1 w2 = do
     let getname w = fromMaybe "" $ M.lookup w m
         set w name m' = if null name then M.delete w m' else M.insert w name m'
     XS.put $ WorkspaceNames $ set w1 (getname w2) $ set w2 (getname w1) $ m
+
+-- | Same behavior than 'XMonad.Prompt.Workspace.workspacePrompt' excepted it acts on the workspace name provided by this module.
+workspaceNamePrompt :: XPConfig -> (String -> X ()) -> X ()
+workspaceNamePrompt conf job = do
+    myWorkspaces <- gets $ map W.tag . W.workspaces . windowset
+    myWorkspacesName <- getWorkspaceNames >>= \f -> return $ map f myWorkspaces
+    let pairs = zip myWorkspacesName myWorkspaces
+    mkXPrompt (Wor "Select workspace: ") conf
+              (contains myWorkspacesName)
+              (job . toWsId pairs)
+  where toWsId pairs name = case lookup name pairs of
+                                Nothing -> ""
+                                Just i -> i
+        contains completions input =
+          return $ filter (Data.List.isInfixOf input) completions

XMonad/Config/Arossato.hs

@@ -36,7 +36,6 @@ import XMonad.Layout.NoBorders
 import XMonad.Layout.SimpleFloat
 import XMonad.Layout.Tabbed
 import XMonad.Layout.WindowArranger
-import XMonad.Prompt
 import XMonad.Prompt.Shell
 import XMonad.Prompt.Ssh
 import XMonad.Prompt.Theme
@@ -86,7 +85,7 @@ import XMonad.Util.Themes
 
 arossatoConfig = do
     xmobar <- spawnPipe "xmobar" -- REMOVE this line if you do not have xmobar installed!
-    return $ defaultConfig
+    return $ def
          { workspaces         = ["home","var","dev","mail","web","doc"] ++
                                 map show [7 .. 9 :: Int]
          , logHook            = myDynLog xmobar -- REMOVE this line if you do not have xmobar installed!
@@ -120,7 +119,7 @@ arossatoConfig = do
       newManageHook = myManageHook
 
       -- xmobar
-      myDynLog    h = dynamicLogWithPP defaultPP
+      myDynLog    h = dynamicLogWithPP def
                       { ppCurrent = xmobarColor "yellow" "" . wrap "[" "]"
                       , ppTitle   = xmobarColor "green"  "" . shorten 40
                       , ppVisible = wrap "(" ")"
@@ -128,7 +127,7 @@ arossatoConfig = do
                       }
 
       -- key bindings stuff
-      defKeys    = keys defaultConfig
+      defKeys    = keys def
       delKeys x  = foldr M.delete           (defKeys x) (toRemove x)
       newKeys x  = foldr (uncurry M.insert) (delKeys x) (toAdd    x)
       -- remove some of the default key bindings
@@ -144,12 +143,12 @@ arossatoConfig = do
           [(shiftMask .|. modMask x, k) | k <- [xK_1 .. xK_9]]
       -- These are my personal key bindings
       toAdd x   =
-          [ ((modMask x              , xK_F12   ), xmonadPrompt      defaultXPConfig     )
-          , ((modMask x              , xK_F3    ), shellPrompt       defaultXPConfig     )
-          , ((modMask x              , xK_F4    ), sshPrompt         defaultXPConfig     )
-          , ((modMask x              , xK_F5    ), themePrompt       defaultXPConfig     )
-          , ((modMask x              , xK_F6    ), windowPromptGoto  defaultXPConfig     )
-          , ((modMask x              , xK_F7    ), windowPromptBring defaultXPConfig     )
+          [ ((modMask x              , xK_F12   ), xmonadPrompt      def                 )
+          , ((modMask x              , xK_F3    ), shellPrompt       def                 )
+          , ((modMask x              , xK_F4    ), sshPrompt         def                 )
+          , ((modMask x              , xK_F5    ), themePrompt       def                 )
+          , ((modMask x              , xK_F6    ), windowPromptGoto  def                 )
+          , ((modMask x              , xK_F7    ), windowPromptBring def                 )
           , ((modMask x              , xK_comma ), prevWS                                )
           , ((modMask x              , xK_period), nextWS                                )
           , ((modMask x              , xK_Right ), windows W.focusDown                   )

XMonad/Config/Azerty.hs

@@ -17,7 +17,7 @@
 module XMonad.Config.Azerty (
     -- * Usage
     -- $usage
-    azertyConfig, azertyKeys
+    azertyConfig, azertyKeys, belgianConfig, belgianKeys
     ) where
 
 import XMonad
@@ -36,13 +36,25 @@ import qualified Data.Map as M
 -- If you prefer, an azertyKeys function is provided which you can use as so:
 --
 -- > import qualified Data.Map as M
--- > main = xmonad someConfig { keys = \c -> azertyKeys c `M.union` keys someConfig c }
+-- > main = xmonad someConfig { keys = \c -> azertyKeys c <+> keys someConfig c }
 
-azertyConfig = defaultConfig { keys = azertyKeys <+> keys defaultConfig }
+azertyConfig = def { keys = azertyKeys <+> keys def }
 
-azertyKeys conf@(XConfig {modMask = modm}) = M.fromList $
+belgianConfig = def { keys = belgianKeys <+> keys def }
+
+azertyKeys = azertyKeysTop [0x26,0xe9,0x22,0x27,0x28,0x2d,0xe8,0x5f,0xe7,0xe0]
+
+belgianKeys = azertyKeysTop [0x26,0xe9,0x22,0x27,0x28,0xa7,0xe8,0x21,0xe7,0xe0]
+
+azertyKeysTop topRow conf@(XConfig {modMask = modm}) = M.fromList $
     [((modm, xK_semicolon), sendMessage (IncMasterN (-1)))]
     ++
     [((m .|. modm, k), windows $ f i)
-        | (i, k) <- zip (workspaces conf) [0x26,0xe9,0x22,0x27,0x28,0x2d,0xe8,0x5f,0xe7,0xe0],
+        | (i, k) <- zip (workspaces conf) topRow,
           (f, m) <- [(W.greedyView, 0), (W.shift, shiftMask)]]
+    ++
+    -- mod-{z,e,r} %! Switch to physical/Xinerama screens 1, 2, or 3
+    -- mod-shift-{z,e,r} %! Move client to screen 1, 2, or 3
+    [((m .|. modm, key), screenWorkspace sc >>= flip whenJust (windows . f))
+        | (key, sc) <- zip [xK_z, xK_e, xK_r] [0..],
+          (f, m) <- [(W.view, 0), (W.shift, shiftMask)]]

XMonad/Config/Bepo.hs

@@ -0,0 +1,47 @@
+{-# OPTIONS_GHC -fno-warn-missing-signatures #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module       : XMonad.Config.Bepo
+-- Copyright    : (c) Yorick Laupa <yo.eight@gmail.com>
+-- License      : BSD
+--
+-- Maintainer   : Yorick Laupa <yo.eight@gmail.com>
+-- Stability    : stable
+-- Portability  : unportable
+--
+-- This module fixes some of the keybindings for the francophone among you who
+-- use a BEPO keyboard layout. Based on XMonad.Config.Azerty
+
+module XMonad.Config.Bepo (
+    -- * Usage
+    -- $usage
+    bepoConfig, bepoKeys
+    ) where
+
+import XMonad
+import qualified XMonad.StackSet as W
+
+import qualified Data.Map as M
+
+-- $usage
+-- To use this module, start with the following @~\/.xmonad\/xmonad.hs@:
+--
+-- > import XMonad
+-- > import XMonad.Config.Bepo
+-- >
+-- > main = xmonad bepoConfig
+--
+-- If you prefer, an bepoKeys function is provided which you can use as so:
+--
+-- > import qualified Data.Map as M
+-- > main = xmonad someConfig { keys = \c -> bepoKeys c `M.union` keys someConfig c }
+
+bepoConfig = def { keys = bepoKeys <+> keys def }
+
+bepoKeys conf@(XConfig { modMask = modm }) = M.fromList $
+    [((modm, xK_semicolon), sendMessage (IncMasterN (-1)))]
+    ++
+    [((m .|. modm, k), windows $ f i)
+        | (i, k) <- zip (workspaces conf) [0x22,0xab,0xbb,0x28,0x29,0x40,0x2b,0x2d,0x2f,0x2a],
+          (f, m) <- [(W.greedyView, 0), (W.shift, shiftMask)]]

XMonad/Config/Bluetile.hs

@@ -1,3 +1,4 @@
+{-# LANGUAGE FlexibleContexts #-}
 {-# OPTIONS -fno-warn-missing-signatures #-}
 ----------------------------------------------------------------------------
 -- |
@@ -43,6 +44,7 @@ import XMonad.Layout.WindowSwitcherDecoration
 
 import XMonad.Actions.BluetileCommands
 import XMonad.Actions.CycleWS
+import XMonad.Actions.Minimize
 import XMonad.Actions.WindowMenu
 
 import XMonad.Hooks.CurrentWorkspaceOnTop
@@ -142,7 +144,7 @@ bluetileKeys conf@(XConfig {XMonad.modMask = modMask'}) = M.fromList $
 
     -- Minimizing
     , ((modMask',               xK_m     ), withFocused minimizeWindow)
-    , ((modMask' .|. shiftMask, xK_m     ), sendMessage RestoreNextMinimizedWin)
+    , ((modMask' .|. shiftMask, xK_m     ), withLastMinimized maximizeWindow)
     ]
     ++
     -- mod-[1..9] ++ [0] %! Switch to workspace N
@@ -179,8 +181,7 @@ bluetileManageHook :: ManageHook
 bluetileManageHook = composeAll
                [ workspaceByPos, positionStoreManageHook (Just defaultThemeWithButtons)
                 , className =? "MPlayer" --> doFloat
-                , isFullscreen --> doFullFloat
-                , manageDocks]
+                , isFullscreen --> doFullFloat]
 
 bluetileLayoutHook = avoidStruts $ minimize $ boringWindows $ (
                         named "Floating" floating |||
@@ -198,7 +199,8 @@ bluetileLayoutHook = avoidStruts $ minimize $ boringWindows $ (
             floatingDeco l = buttonDeco shrinkText defaultThemeWithButtons l
 
 bluetileConfig =
-    defaultConfig
+    docks $
+    def
         { modMask = mod4Mask,   -- logo key
           manageHook = bluetileManageHook,
           layoutHook = bluetileLayoutHook,

XMonad/Config/Desktop.hs

@@ -22,7 +22,8 @@ module XMonad.Config.Desktop (
     -- the DE via a subset of the Extended Window Manager Hints (EWMH)
     -- specification. Extra xmonad settings unique to specific DE's are
     -- added by overriding or modifying @desktopConfig@ fields in the
-    -- same way that @defaultConfig@ is customized in @~\/.xmonad/xmonad.hs@.
+    -- same way that the default configuration is customized in
+    -- @~\/.xmonad/xmonad.hs@.
     --
     -- For more information about EWMH see:
     --
@@ -69,7 +70,7 @@ import qualified Data.Map as M
 -- <http://haskell.org/haskellwiki/Xmonad>
 --
 -- To configure xmonad for use with a DE or with DE tools like panels
--- and pagers, in place of @defaultConfig@ in your @~\/.xmonad/xmonad.hs@,
+-- and pagers, in place of @def@ in your @~\/.xmonad/xmonad.hs@,
 -- use @desktopConfig@ or one of the other desktop configs from the
 -- @XMonad.Config@ namespace. The following setup and customization examples
 -- work the same way for the other desktop configs as for @desktopConfig@.
@@ -88,7 +89,7 @@ import qualified Data.Map as M
 
 -- $customizing
 -- To customize a desktop config, modify its fields as is illustrated with
--- @defaultConfig@ in "XMonad.Doc.Extending#Extending xmonad".
+-- the default configuration @def@ in "XMonad.Doc.Extending#Extending xmonad".
 
 -- $layouts
 -- See also "XMonad.Util.EZConfig" for more options for modifying key bindings.
@@ -163,11 +164,10 @@ import qualified Data.Map as M
 -- >        adjustEventInput
 --
 
-desktopConfig = ewmh defaultConfig
-    { startupHook     = setDefaultCursor xC_left_ptr
-    , layoutHook      = desktopLayoutModifiers $ layoutHook defaultConfig
-    , manageHook      = manageHook defaultConfig <+> manageDocks
-    , keys            = desktopKeys <+> keys defaultConfig }
+desktopConfig = docks $ ewmh def
+    { startupHook     = setDefaultCursor xC_left_ptr <+> startupHook def
+    , layoutHook      = desktopLayoutModifiers $ layoutHook def
+    , keys            = desktopKeys <+> keys def }
 
 desktopKeys (XConfig {modMask = modm}) = M.fromList $
     [ ((modm, xK_b), sendMessage ToggleStruts) ]

XMonad/Config/Dmwit.hs

@@ -0,0 +1,322 @@
+-- boilerplate {{{
+{-# LANGUAGE ExistentialQuantification, NoMonomorphismRestriction, TypeSynonymInstances #-}
+{-# OPTIONS_GHC -fno-warn-missing-signatures -fno-warn-type-defaults #-}
+module XMonad.Config.Dmwit where
+
+-- system imports
+import Control.Applicative
+import Control.Monad
+import Control.Monad.Trans
+import Data.Char
+import Data.List
+import Data.Map (Map, fromList)
+import Data.Ratio
+import Data.Word
+import GHC.Real
+import System.Environment
+import System.Exit
+import System.IO
+import System.Process
+
+-- xmonad core
+import XMonad
+import XMonad.StackSet hiding (workspaces)
+
+-- xmonad contrib
+import XMonad.Actions.SpawnOn
+import XMonad.Actions.Warp
+import XMonad.Hooks.DynamicLog
+import XMonad.Hooks.ManageDocks
+import XMonad.Hooks.ManageHelpers
+import XMonad.Layout.Grid
+import XMonad.Layout.IndependentScreens
+import XMonad.Layout.Magnifier
+import XMonad.Layout.NoBorders
+import XMonad.Util.Dzen hiding (x, y)
+import XMonad.Util.SpawnOnce
+-- }}}
+-- volume {{{
+outputOf :: String -> IO String
+outputOf s = do
+    uninstallSignalHandlers
+    (hIn, hOut, hErr, p) <- runInteractiveCommand s
+    mapM_ hClose [hIn, hErr]
+    hGetContents hOut <* waitForProcess p <* installSignalHandlers
+
+geomMean :: Floating a => [a] -> a
+geomMean xs = product xs ** (recip . fromIntegral . length $ xs)
+
+arithMean :: Floating a => [a] -> a
+arithMean xs = sum xs / fromIntegral (length xs)
+
+namedNumbers n s = do
+    l <- lines s
+    guard (sentinel `isPrefixOf` l)
+    return (drop (length sentinel) l)
+    where sentinel = n ++ " #"
+
+-- Data.List.Split.splitOn ":", but without involving an extra dependency
+splitColon xs = case break (==':') xs of
+    (a, ':':b) -> a : splitColon b
+    (a, _)     -> [a]
+
+parse s = arithMean $ do
+    l <- lines s
+    guard ("\tVolume: " `isPrefixOf` l)
+    part <- splitColon l
+    (n,'%':_) <- reads part
+    return n
+
+modVolume :: String -> Integer -> IO Double
+modVolume kind n = do
+    is <- namedNumbers parseKind <$> outputOf listCommand
+    forM_ is (outputOf . setCommand)
+    parse <$> outputOf listCommand
+    where
+    sign | n > 0 = "+" | otherwise = "-"
+    ctlKind      = map (\c -> if c == ' ' then '-' else c) kind
+    parseKind    = unwords . map (\(c:cs) -> toUpper c : cs) . words $ kind
+    setCommand i = "pactl set-" ++ ctlKind ++ "-volume " ++ i ++ " -- " ++ sign ++ show (abs n) ++ "%"
+    listCommand  = "pactl list " ++ ctlKind ++ "s"
+-- }}}
+-- convenient actions {{{
+centerMouse = warpToWindow (1/2) (1/2)
+statusBarMouse = warpToScreen 0 (5/1600) (5/1200)
+withScreen s f = screenWorkspace s >>= flip whenJust (windows . f)
+
+makeLauncher yargs run exec close = concat
+    ["exe=`yeganesh ", yargs, "` && ", run, " ", exec, "$exe", close]
+launcher     = makeLauncher "" "eval" "\"exec " "\""
+termLauncher = makeLauncher "-p withterm" "exec urxvt -e" "" ""
+viewShift  i = view i . shift i
+floatAll     = composeAll . map (\s -> className =? s --> doFloat)
+sinkFocus    = peek >>= maybe id sink
+showMod  k n = liftIO (modVolume k n) >>= volumeDzen . show . round
+volumeDzen   = dzenConfig $ onCurr (center 170 66) >=> font "-*-helvetica-*-r-*-*-64-*-*-*-*-*-*-*,-*-terminus-*-*-*-*-64-*-*-*-*-*-*-*"
+-- }}}
+altMask = mod1Mask
+bright  = "#80c0ff"
+dark    = "#13294e"
+-- manage hooks for mplayer {{{
+fullscreen43on169 = expand $ RationalRect 0 (-1/6) 1 (4/3) where
+    expand (RationalRect x y w h) = RationalRect (x - bwx) (y - bwy) (w + 2 * bwx) (h + 2 * bwy)
+    bwx = 2 / 1920 -- borderwidth
+    bwy = 2 / 1080
+
+fullscreenMPlayer = className =? "MPlayer" --> do
+    dpy   <- liftX $ asks display
+    win   <- ask
+    hints <- liftIO $ getWMNormalHints dpy win
+    case fmap (approx . fst) (sh_aspect hints) of
+        Just ( 4 :% 3)  -> viewFullOn 0 "5" win
+        Just (16 :% 9)  -> viewFullOn 1 "5" win
+        _               -> doFloat
+    where
+    fi               = fromIntegral :: Dimension -> Double
+    approx (n, d)    = approxRational (fi n / fi d) (1/100)
+
+operationOn f s n w = do
+    let ws = marshall s n
+    currws <- liftX $ screenWorkspace s
+    doF $ view ws . maybe id view currws . shiftWin ws w . f w
+
+viewFullOn = operationOn sink
+centerWineOn = operationOn (`XMonad.StackSet.float` RationalRect (79/960) (-1/540) (401/480) (271/270))
+-- }}}
+-- debugging {{{
+class Show a => PPrint a where
+    pprint :: Int -> a -> String
+    pprint _ = show
+
+data PPrintable = forall a. PPrint a => P a
+instance Show   PPrintable where show     (P x) = show x
+instance PPrint PPrintable where pprint n (P x) = pprint n x
+
+record :: String -> Int -> [(String, PPrintable)] -> String
+record s n xs = preamble ++ intercalate newline fields ++ postlude where
+    indentation = '\n' : replicate n '\t'
+    preamble    = s ++ " {" ++ indentation
+    postlude    = indentation ++ "}"
+    newline     = ',' : indentation
+    fields      = map (\(name, value) -> name ++ " = " ++ pprint (n+1) value) xs
+
+instance PPrint a => PPrint (Maybe a) where
+    pprint n (Just x) = "Just (" ++ pprint n x ++ ")"
+    pprint _ x        = show x
+
+instance PPrint a => PPrint [a] where
+    pprint _ [] = "[]"
+    pprint n xs = preamble ++ intercalate newline allLines ++ postlude where
+        indentation = '\n' : replicate n '\t'
+        preamble    = "[" ++ indentation
+        allLines    = map (pprint (n+1)) xs
+        newline     = ',' : indentation
+        postlude    = indentation ++ "]"
+
+instance PPrint Rectangle where
+    pprint n x = record "Rectangle" n [
+        ("rect_x", P (rect_x x)),
+        ("rect_y", P (rect_y x)),
+        ("rect_width", P (rect_width x)),
+        ("rect_height", P (rect_height x))
+        ]
+
+instance PPrint a => PPrint (Stack a) where
+    pprint n x = record "Stack" n [
+        ("focus", P (XMonad.StackSet.focus x)),
+        ("up", P (up x)),
+        ("down", P (down x))
+        ]
+
+instance (PPrint i, PPrint l, PPrint a) => PPrint (Workspace i l a) where
+    pprint n x = record "Workspace" n [
+        ("tag", P (tag x)),
+        ("layout", P (layout x)),
+        ("stack", P (stack x))
+        ]
+
+instance PPrint ScreenDetail where
+    pprint n x = record "SD" n [("screenRect", P (screenRect x))]
+
+instance (PPrint i, PPrint l, PPrint a, PPrint sid, PPrint sd) => PPrint (XMonad.StackSet.Screen i l a sid sd) where
+    pprint n x = record "Screen" n [
+        ("workspace", P (workspace x)),
+        ("screen", P (screen x)),
+        ("screenDetail", P (screenDetail x))
+        ]
+
+instance (PPrint i, PPrint l, PPrint a, PPrint sid, PPrint sd) => PPrint (StackSet i l a sid sd) where
+    pprint n x = record "StackSet" n [
+        ("current", P (current x)),
+        ("visible", P (visible x)),
+        ("hidden", P (hidden x)),
+        ("floating", P (floating x))
+        ]
+
+instance PPrint (Layout a)
+instance PPrint Int
+instance PPrint XMonad.Screen
+instance PPrint Integer
+instance PPrint Position
+instance PPrint Dimension
+instance PPrint Char
+instance PPrint Word64
+instance PPrint ScreenId
+instance (Show a, Show b) => PPrint (Map a b)
+-- }}}
+-- main {{{
+dmwitConfig nScreens = docks $ def {
+    borderWidth             = 2,
+    workspaces              = withScreens nScreens (map show [1..5]),
+    terminal                = "urxvt",
+    normalBorderColor       = dark,
+    focusedBorderColor      = bright,
+    modMask                 = mod4Mask,
+    keys                    = keyBindings,
+    layoutHook              = magnifierOff $ avoidStruts (GridRatio 0.9) ||| noBorders Full,
+    manageHook              =     (title =? "CGoban: Main Window" --> doF sinkFocus)
+                              <+> (className =? "Wine" <&&> (appName =? "hl2.exe" <||> appName =? "portal2.exe") --> ask >>= viewFullOn {-centerWineOn-} 1 "5")
+                              <+> (className =? "VirtualBox" --> ask >>= viewFullOn 1 "5")
+                              <+> (isFullscreen --> doFullFloat) -- TF2 matches the "isFullscreen" criteria, so its manage hook should appear after (e.g., to the left of a <+> compared to) this one
+                              <+> (appName =? "huludesktop" --> doRectFloat fullscreen43on169)
+                              <+> fullscreenMPlayer
+                              <+> floatAll ["Gimp", "Wine"]
+                              <+> manageSpawn,
+    logHook                 = allPPs nScreens,
+    startupHook             = refresh
+                           >> mapM_ (spawnOnce . xmobarCommand) [0 .. nScreens-1]
+    }
+
+main = countScreens >>= xmonad . dmwitConfig
+-- }}}
+-- keybindings {{{
+keyBindings conf = let m = modMask conf in fromList . anyMask $ [
+    ((m                , xK_BackSpace  ), spawnHere "urxvt"),
+    ((m                , xK_p          ), spawnHere launcher),
+    ((m .|. shiftMask  , xK_p          ), spawnHere termLauncher),
+    ((m .|. shiftMask  , xK_c          ), kill),
+    ((m                , xK_q          ), restart "xmonad" True),
+    ((m .|. shiftMask  , xK_q          ), io (exitWith ExitSuccess)),
+    ((m                , xK_grave      ), sendMessage NextLayout),
+    ((m .|. shiftMask  , xK_grave      ), setLayout $ layoutHook conf),
+    ((m                , xK_o          ), sendMessage Toggle),
+    ((m                , xK_x          ), withFocused (windows . sink)),
+    ((m                , xK_Home       ), windows focusUp),
+    ((m .|. shiftMask  , xK_Home       ), windows swapUp),
+    ((m                , xK_End        ), windows focusDown),
+    ((m .|. shiftMask  , xK_End        ), windows swapDown),
+    ((m                , xK_a          ), windows focusMaster),
+    ((m .|. shiftMask  , xK_a          ), windows swapMaster),
+    ((m                , xK_Control_L  ), withScreen 0 view),
+    ((m .|. shiftMask  , xK_Control_L  ), withScreen 0 viewShift),
+    ((m                , xK_Alt_L      ), withScreen 1 view),
+    ((m .|. shiftMask  , xK_Alt_L      ), withScreen 1 viewShift),
+    ((m                , xK_u          ), centerMouse),
+    ((m .|. shiftMask  , xK_u          ), statusBarMouse),
+    ((m                , xK_s          ), spawnHere "chromium --password-store=gnome"),
+    ((m                , xK_n          ), spawnHere "gvim todo"),
+    ((m                , xK_t          ), spawnHere "mpc toggle"),
+    ((m                , xK_h          ), spawnHere "urxvt -e alsamixer"),
+    ((m                , xK_d          ), spawnHere "wyvern"),
+    ((m                , xK_l          ), spawnHere "urxvt -e sup"),
+    ((m                , xK_r          ), spawnHere "urxvt -e ncmpcpp"),
+    ((m                , xK_c          ), spawnHere "urxvt -e ghci"),
+    ((m                , xK_g          ), spawnHere "slock" >> spawnHere "xscreensaver-command -lock"),
+    ((m                , xK_f          ), spawnHere "gvim ~/.xmonad/xmonad.hs"),
+    ((      noModMask  , xK_F8         ), showMod "sink input" (-4)),
+    ((      noModMask  , xK_F9         ), showMod "sink input"   4 ),
+    ((      shiftMask  , xK_F8         ), showMod "sink"       (-4)),
+    ((      shiftMask  , xK_F9         ), showMod "sink"         4 ),
+    ((      noModMask  , xK_Super_L    ), return ()) -- make VirtualBox ignore stray hits of the Windows key
+    ] ++ [
+    ((m .|. e          , key           ), windows (onCurrentScreen f ws))
+    | (key, ws) <- zip [xK_1..xK_9] (workspaces' conf)
+    , (e, f)    <- [(0, view), (shiftMask, viewShift)]
+    ]
+
+atSchool school home = do
+    host <- liftIO (getEnv "HOST")
+    return $ case host of
+        "sorghum"   -> home
+        "buckwheat" -> home
+        _           -> school
+
+anyMask xs = do
+    ((mask, key), action) <- xs
+    extraMask             <- [0, controlMask, altMask, controlMask .|. altMask]
+    return ((mask .|. extraMask, key), action)
+-- }}}
+-- logHook {{{
+pipeName n s = "/home/dmwit/.xmonad/pipe-" ++ n ++ "-" ++ show s
+
+xmobarCommand (S s) = unwords ["xmobar",
+    "-x", show s,
+    "-t", template s,
+    "-C", pipeReader
+    ]
+    where
+    template 0 = "}%focus%{%workspaces%"
+    template _ = "%date%}%focus%{%workspaces%"
+    pipeReader = "'[\
+        \Run PipeReader \"" ++ pipeName "focus"      s ++ "\" \"focus\",\
+        \Run PipeReader \"" ++ pipeName "workspaces" s ++ "\" \"workspaces\"\
+        \]'"
+
+allPPs nScreens = sequence_ [dynamicLogWithPP (pp s) | s <- [0..nScreens-1], pp <- [ppFocus, ppWorkspaces]]
+color c = xmobarColor c ""
+
+ppFocus s@(S s_) = whenCurrentOn s def {
+    ppOrder  = \(_:_:windowTitle:_) -> [windowTitle],
+    ppOutput = appendFile (pipeName "focus" s_) . (++ "\n")
+    }
+
+ppWorkspaces s@(S s_) = marshallPP s def {
+    ppCurrent           = color "white",
+    ppVisible           = color "white",
+    ppHiddenNoWindows   = color dark,
+    ppUrgent            = color "red",
+    ppSep               = "",
+    ppOrder             = \(wss:_layout:_title:_) -> [wss],
+    ppOutput            = appendFile (pipeName "workspaces" s_) . (++"\n")
+    }
+-- }}}

XMonad/Config/Droundy.hs

@@ -16,7 +16,7 @@ import qualified XMonad.StackSet as W
 import qualified Data.Map as M
 import System.Exit ( exitWith, ExitCode(ExitSuccess) )
 
-import XMonad.Layout.Tabbed ( tabbed, defaultTheme,
+import XMonad.Layout.Tabbed ( tabbed,
                               shrinkText, Shrinker, shrinkIt, CustomShrink(CustomShrink) )
 import XMonad.Layout.Combo ( combineTwo )
 import XMonad.Layout.Named ( named )
@@ -32,7 +32,7 @@ import XMonad.Layout.ToggleLayouts ( toggleLayouts, ToggleLayout(ToggleLayout) )
 import XMonad.Layout.ShowWName ( showWName )
 import XMonad.Layout.Magnifier ( maximizeVertical, MagnifyMsg(Toggle) )
 
-import XMonad.Prompt ( defaultXPConfig, font, height, XPConfig )
+import XMonad.Prompt ( font, height, XPConfig )
 import XMonad.Prompt.Layout ( layoutPrompt )
 import XMonad.Prompt.Shell ( shellPrompt )
 
@@ -42,12 +42,12 @@ import XMonad.Actions.DynamicWorkspaces ( withNthWorkspace, withWorkspace,
 import XMonad.Actions.CycleWS ( moveTo, WSType( HiddenNonEmptyWS ),
                                 Direction1D( Prev, Next) )
 
-import XMonad.Hooks.ManageDocks ( avoidStruts, manageDocks )
+import XMonad.Hooks.ManageDocks ( avoidStruts, docks )
 import XMonad.Hooks.EwmhDesktops ( ewmh )
 
 myXPConfig :: XPConfig
-myXPConfig = defaultXPConfig {font="-*-lucida-medium-r-*-*-14-*-*-*-*-*-*-*"
-                             ,height=22}
+myXPConfig = def {font="-*-lucida-medium-r-*-*-14-*-*-*-*-*-*-*"
+                 ,height=22}
 
 
 ------------------------------------------------------------------------
@@ -117,7 +117,7 @@ keys x = M.fromList $
     ++
     zip (zip (repeat (modMask x .|. shiftMask)) [xK_F1..xK_F12]) (map (withNthWorkspace copy) [0..])
 
-config = ewmh defaultConfig
+config = docks $ ewmh def
          { borderWidth = 1 -- Width of the window border in pixels.
          , XMonad.workspaces = ["mutt","iceweasel"]
          , layoutHook = showWName $ workspaceDir "~" $
@@ -129,7 +129,6 @@ config = ewmh defaultConfig
                         named "widescreen" ((mytab *||* mytab)
                                                 ****//* combineTwo Square mytab mytab) --   |||
                         --mosaic 0.25 0.5
-         , manageHook = manageHook defaultConfig <+> manageDocks -- add panel-handling
          , terminal = "xterm" -- The preferred terminal program.
          , normalBorderColor = "#222222" -- Border color for unfocused windows.
          , focusedBorderColor = "#00ff00" -- Border color for focused windows.
@@ -137,7 +136,7 @@ config = ewmh defaultConfig
          , XMonad.keys = keys
          }
 
-mytab = tabbed CustomShrink defaultTheme
+mytab = tabbed CustomShrink def
 
 instance Shrinker CustomShrink where
     shrinkIt shr s | Just s' <- dropFromHead " " s = shrinkIt shr s'

XMonad/Config/Example.hs

@@ -0,0 +1,78 @@
+--------------------------------------------------------------------------------
+-- | Example.hs
+--
+-- Example configuration file for xmonad using the latest recommended
+-- features (e.g., 'desktopConfig').
+module Main (main) where
+
+--------------------------------------------------------------------------------
+import System.Exit
+import XMonad
+import XMonad.Config.Desktop
+import XMonad.Hooks.DynamicLog
+import XMonad.Hooks.ManageHelpers
+import XMonad.Layout.BinarySpacePartition (emptyBSP)
+import XMonad.Layout.NoBorders (noBorders)
+import XMonad.Layout.ResizableTile (ResizableTall(..))
+import XMonad.Layout.ToggleLayouts (ToggleLayout(..), toggleLayouts)
+import XMonad.Prompt
+import XMonad.Prompt.ConfirmPrompt
+import XMonad.Prompt.Shell
+import XMonad.Util.EZConfig
+
+--------------------------------------------------------------------------------
+main = do
+  spawn "xmobar" -- Start a task bar such as xmobar.
+
+  -- Start xmonad using the main desktop configuration with a few
+  -- simple overrides:
+  xmonad $ desktopConfig
+    { modMask    = mod4Mask -- Use the "Win" key for the mod key
+    , manageHook = myManageHook <+> manageHook desktopConfig
+    , layoutHook = desktopLayoutModifiers $ myLayouts
+    , logHook    = dynamicLogString def >>= xmonadPropLog
+    }
+
+    `additionalKeysP` -- Add some extra key bindings:
+      [ ("M-S-q",   confirmPrompt myXPConfig "exit" (io exitSuccess))
+      , ("M-p",     shellPrompt myXPConfig)
+      , ("M-<Esc>", sendMessage (Toggle "Full"))
+      ]
+
+--------------------------------------------------------------------------------
+-- | Customize layouts.
+--
+-- This layout configuration uses two primary layouts, 'ResizableTall'
+-- and 'BinarySpacePartition'.  You can also use the 'M-<Esc>' key
+-- binding defined above to toggle between the current layout and a
+-- full screen layout.
+myLayouts = toggleLayouts (noBorders Full) others
+  where
+    others = ResizableTall 1 (1.5/100) (3/5) [] ||| emptyBSP
+
+--------------------------------------------------------------------------------
+-- | Customize the way 'XMonad.Prompt' looks and behaves.  It's a
+-- great replacement for dzen.
+myXPConfig = def
+  { position          = Top
+  , alwaysHighlight   = True
+  , promptBorderWidth = 0
+  , font              = "xft:monospace:size=9"
+  }
+
+--------------------------------------------------------------------------------
+-- | Manipulate windows as they are created.  The list given to
+-- @composeOne@ is processed from top to bottom.  The first matching
+-- rule wins.
+--
+-- Use the `xprop' tool to get the info you need for these matches.
+-- For className, use the second value that xprop gives you.
+myManageHook = composeOne
+  [ className =? "Pidgin" -?> doFloat
+  , className =? "XCalc"  -?> doFloat
+  , className =? "mpv"    -?> doFloat
+  , isDialog              -?> doCenterFloat
+
+    -- Move transient windows to their parent:
+  , transience
+  ]

XMonad/Config/Gnome.hs

@@ -18,7 +18,8 @@ module XMonad.Config.Gnome (
     -- $usage
     gnomeConfig,
     gnomeRun,
-    gnomeRegister
+    gnomeRegister,
+    desktopLayoutModifiers
     ) where
 
 import XMonad
@@ -46,7 +47,7 @@ gnomeConfig = desktopConfig
 
 gnomeKeys (XConfig {modMask = modm}) = M.fromList $
     [ ((modm, xK_p), gnomeRun)
-    , ((modm .|. shiftMask, xK_q), spawn "gnome-session-save --kill") ]
+    , ((modm .|. shiftMask, xK_q), spawn "gnome-session-quit --logout") ]
 
 -- | Launch the "Run Application" dialog.  gnome-panel must be running for this
 -- to work.
@@ -74,7 +75,7 @@ gnomeRegister = io $ do
     x <- lookup "DESKTOP_AUTOSTART_ID" `fmap` getEnvironment
     whenJust x $ \sessionId -> safeSpawn "dbus-send"
             ["--session"
-            ,"--print-reply=string"
+            ,"--print-reply=literal"
             ,"--dest=org.gnome.SessionManager"
             ,"/org/gnome/SessionManager"
             ,"org.gnome.SessionManager.RegisterClient"

XMonad/Config/Kde.hs

@@ -17,7 +17,8 @@ module XMonad.Config.Kde (
     -- * Usage
     -- $usage
     kdeConfig,
-    kde4Config
+    kde4Config,
+    desktopLayoutModifiers
     ) where
 
 import XMonad

XMonad/Config/Mate.hs

@@ -0,0 +1,88 @@
+{-# OPTIONS_GHC -fno-warn-missing-signatures #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module       : XMonad.Config.Mate
+-- Copyright    : (c) Brandon S Allbery KF8NH, 2014
+-- License      : BSD
+--
+-- Maintainer   : allbery.b@gmail.com
+-- Stability    :  unstable
+-- Portability  :  unportable
+--
+-- This module provides a config suitable for use with the MATE desktop
+-- environment.
+--
+-----------------------------------------------------------------------------
+
+module XMonad.Config.Mate (
+    -- * Usage
+    -- $usage
+    mateConfig,
+    mateRun,
+    mateRegister,
+    desktopLayoutModifiers
+    ) where
+
+import XMonad
+import XMonad.Config.Desktop
+import XMonad.Util.Run (safeSpawn)
+
+import qualified Data.Map as M
+
+import System.Environment (getEnvironment)
+
+-- $usage
+-- To use this module, start with the following @~\/.xmonad\/xmonad.hs@:
+--
+-- > import XMonad
+-- > import XMonad.Config.Mate
+-- >
+-- > main = xmonad mateConfig
+--
+-- For examples of how to further customize @mateConfig@ see "XMonad.Config.Desktop".
+
+mateConfig = desktopConfig
+    { terminal = "mate-terminal"
+    , keys     = mateKeys <+> keys desktopConfig
+    , startupHook = mateRegister >> startupHook desktopConfig }
+
+mateKeys (XConfig {modMask = modm}) = M.fromList $
+    [ ((modm, xK_p), mateRun)
+    , ((modm .|. shiftMask, xK_q), spawn "mate-session-save --logout-dialog") ]
+
+-- | Launch the "Run Application" dialog.  mate-panel must be running for this
+-- to work.
+mateRun :: X ()
+mateRun = withDisplay $ \dpy -> do
+    rw <- asks theRoot
+    mate_panel <- getAtom "_MATE_PANEL_ACTION"
+    panel_run  <- getAtom "_MATE_PANEL_ACTION_RUN_DIALOG"
+
+    io $ allocaXEvent $ \e -> do
+        setEventType e clientMessage
+        setClientMessageEvent e rw mate_panel 32 panel_run 0
+        sendEvent dpy rw False structureNotifyMask e
+        sync dpy False
+
+-- | Register xmonad with mate. 'dbus-send' must be in the $PATH with which
+-- xmonad is started.
+--
+-- This action reduces a delay on startup only if you have configured
+-- mate-session to start xmonad with a command such as (check local
+-- documentation):
+--
+-- > dconf write /org/mate/desktop/session/required_components/windowmanager "'xmonad'"
+--
+-- (the extra quotes are required by dconf)
+mateRegister :: MonadIO m => m ()
+mateRegister = io $ do
+    x <- lookup "DESKTOP_AUTOSTART_ID" `fmap` getEnvironment
+    whenJust x $ \sessionId -> safeSpawn "dbus-send"
+            ["--session"
+            ,"--print-reply=literal"
+            ,"--dest=org.mate.SessionManager"
+            ,"/org/mate/SessionManager"
+            ,"org.mate.SessionManager.RegisterClient"
+            ,"string:xmonad"
+            ,"string:"++sessionId]

XMonad/Config/Prime.hs

@@ -0,0 +1,689 @@
+{-# LANGUAGE FlexibleContexts, FlexibleInstances, FunctionalDependencies, KindSignatures, MultiParamTypeClasses, UndecidableInstances #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  XMonad.Config.Prime
+-- Copyright   :  Devin Mullins <devin.mullins@gmail.com>
+-- License     :  BSD-style (see LICENSE)
+--
+-- Maintainer  :  Devin Mullins <devin.mullins@gmail.com>
+-- Stability   :  unstable
+-- Portability :  unportable
+--
+-- This is a draft of a brand new config syntax for xmonad. It aims to be:
+--
+--  * easier to copy/paste snippets from the docs
+--
+--  * easier to get the gist for what's going on, for you imperative programmers
+--
+-- It's brand new, so it's pretty much guaranteed to break or change syntax.
+-- But what's the worst that could happen? Xmonad crashes and logs you out?
+-- It probably won't do that. Give it a try.
+--
+-----------------------------------------------------------------------------
+
+module XMonad.Config.Prime (
+-- Note: The identifiers here are listed in the order that makes the most sense
+-- for a user, while the definitions below are listed in the order that makes
+-- the most sense for a developer.
+
+-- * Start here
+-- $start_here
+xmonad,
+nothing,
+-- * Attributes you can set
+-- $settables
+normalBorderColor,
+focusedBorderColor,
+terminal,
+modMask,
+borderWidth,
+focusFollowsMouse,
+clickJustFocuses,
+SettableClass(..),
+UpdateableClass(..),
+
+-- * Attributes you can add to
+-- $summables
+manageHook,
+handleEventHook,
+workspaces,
+logHook,
+startupHook,
+clientMask,
+rootMask,
+SummableClass(..),
+
+-- * Attributes you can add to or remove from
+-- $removables
+keys,
+mouseBindings,
+RemovableClass(..),
+
+-- * Modifying the list of workspaces
+-- $workspaces
+withWorkspaces,
+wsNames,
+wsKeys,
+wsActions,
+wsSetName,
+
+-- * Modifying the screen keybindings
+-- $screens
+withScreens,
+sKeys,
+sActions,
+onScreens,
+
+-- * Modifying the layoutHook
+-- $layout
+addLayout,
+resetLayout,
+modifyLayout,
+
+-- * Updating the XConfig en masse
+-- $update
+startWith,
+apply,
+applyIO,
+
+-- * The rest of the world
+-- | Everything you know and love from the core "XMonad" module is available
+-- for use in your config file, too.
+module XMonad,
+-- | (Almost) everything you know and love from the Haskell "Prelude" is
+-- available for use in your config file. Note that '>>' has been overriden, so
+-- if you want to create do-blocks for normal monads, you'll need some let
+-- statements or a separate module. (See the Troubleshooting section.)
+module Prelude,
+
+-- * Core
+-- | These are the building blocks on which the config language is built.
+-- Regular people shouldn't need to know about these.
+Prime,
+Arr,
+(>>),
+ifThenElse,
+
+-- * Example config
+-- $example
+
+-- * Troubleshooting
+-- $troubleshooting
+) where
+
+import Prelude hiding ((>>), mod)
+import qualified Prelude as P ((>>=), (>>))
+
+import Data.Monoid (All)
+
+import XMonad hiding (xmonad, XConfig(..))
+import XMonad (XConfig(XConfig))
+import qualified XMonad.StackSet as W
+import qualified XMonad as X (xmonad, XConfig(..))
+
+import XMonad.Util.EZConfig (additionalKeysP, additionalMouseBindings, checkKeymap, removeKeysP, removeMouseBindings)
+
+-- $start_here
+-- To start with, create a @~\/.xmonad\/xmonad.hs@ that looks like this:
+--
+-- > {-# LANGUAGE RebindableSyntax #-}
+-- > import XMonad.Config.Prime
+-- >
+-- > -- Imports go here.
+-- >
+-- > main = xmonad $ do
+-- >   nothing
+-- >   -- Configs go here.
+--
+-- This will give you a default xmonad install, with room to grow. The lines
+-- starting with double dashes are comments. You may delete them. Note that
+-- Haskell is a bit precise about indentation. Make sure all the statements in
+-- your do-block start at the same column, and make sure that any multi-line
+-- statements are formatted with a hanging indent. (For an example, see the
+-- 'keys =+' statement in the /Example config/ section, below.)
+--
+-- After changing your config file, restart xmonad with mod-q (where, by
+-- default, "mod" == "alt").
+
+--
+-- The Prime "Monad"
+--
+
+-- | A Prime is a function that transforms an XConfig. It's not a monad, but we
+-- turn on RebindableSyntax so we can abuse the pretty do notation.
+type Prime l l' = Arr (XConfig l) (XConfig l')
+
+-- | An Arr is a generalization of Prime. Don't reference the type, if you can
+-- avoid it. It might go away in the future.
+type Arr x y = x -> IO y
+
+-- | Composes two Arrs using 'Prelude.>>=' from "Prelude".
+(>>) :: Arr x y -> Arr y z -> Arr x z
+(>>) x y c = (P.>>=) (x c) y
+
+-- | Because of RebindableSyntax, this is necessary to enable you to use
+-- if-then-else expressions. No need to call it directly.
+ifThenElse :: Bool -> a -> a -> a
+ifThenElse True  a _ = a
+ifThenElse False _ b = b
+
+-- | This is the xmonad main function. It passes 'XMonad.Config.def' (the
+-- default 'XConfig') into your do-block, takes the modified config out of your
+-- do-block, and then runs xmonad.
+--
+-- The do-block is a 'Prime'. Advanced readers can skip right to that
+-- definition.
+
+xmonad :: (Default a, Read (l Window), LayoutClass l Window) =>
+          (a -> IO (XConfig l)) -> IO ()
+xmonad prime = (P.>>=) (prime def) X.xmonad
+
+-- | This doesn't modify the config in any way. It's just here for your initial
+-- config because Haskell doesn't allow empty do-blocks. Feel free to delete it
+-- once you've added other stuff.
+nothing :: Prime l l
+nothing = return
+
+-- $settables
+-- These are a bunch of attributes that you can set. Syntax looks like this:
+--
+-- >   terminal =: "urxvt"
+--
+-- Strings are double quoted, Dimensions are unquoted integers, booleans are
+-- 'True' or 'False' (case-sensitive), and 'modMask' is usually 'mod1Mask' or
+-- 'mod4Mask'.
+
+class UpdateableClass s x y | s -> x y where
+  -- | This lets you apply a function to an attribute (i.e. read, modify, write).
+  (=.) :: s c -> (x -> y) -> Arr c c
+
+class SettableClass s x y | s -> x y where
+  -- | This lets you modify an attribute.
+  (=:) :: s c -> y -> Arr c c
+
+-- Undecideable instance. But it's nice to leave open the possibility to write
+-- fields you can't read (e.g. `wmName =: ...`).
+instance UpdateableClass s x y => SettableClass s x y where
+  s =: y = s =. const y
+
+data Settable x c = Settable (c -> x)      -- getter
+                             (x -> c -> c) -- setter
+
+instance UpdateableClass (Settable x) x x where
+  (Settable g s =. f) c = return $ s (f $ g c) c
+
+-- | Non-focused windows border color. Default: @\"#dddddd\"@
+normalBorderColor :: Settable String (XConfig l)
+normalBorderColor = Settable X.normalBorderColor (\x c -> c { X.normalBorderColor = x })
+
+-- | Focused windows border color. Default: @\"#ff0000\"@
+focusedBorderColor :: Settable String (XConfig l)
+focusedBorderColor = Settable X.focusedBorderColor (\x c -> c { X.focusedBorderColor = x })
+
+-- | The preferred terminal application. Default: @\"xterm\"@
+terminal :: Settable String (XConfig l)
+terminal = Settable X.terminal (\x c -> c { X.terminal = x })
+
+-- | The mod modifier, as used by key bindings. Default: @mod1Mask@ (which is
+-- probably alt on your computer).
+modMask :: Settable KeyMask (XConfig l)
+modMask = Settable X.modMask (\x c -> c { X.modMask = x })
+
+-- | The border width (in pixels). Default: @1@
+borderWidth :: Settable Dimension (XConfig l)
+borderWidth = Settable X.borderWidth (\x c -> c { X.borderWidth = x })
+
+-- | Whether window focus follows the mouse cursor on move, or requires a mouse
+-- click. (Mouse? What's that?) Default: @True@
+focusFollowsMouse :: Settable Bool (XConfig l)
+focusFollowsMouse = Settable X.focusFollowsMouse (\x c -> c { X.focusFollowsMouse = x })
+
+-- | If True, a mouse click on an inactive window focuses it, but the click is
+-- not passed to the window. If False, the click is also passed to the window.
+-- Default @True@
+clickJustFocuses :: Settable Bool (XConfig l)
+clickJustFocuses = Settable X.clickJustFocuses (\x c -> c { X.clickJustFocuses = x })
+
+-- $summables
+-- In addition to being able to set these attributes, they have a special
+-- syntax for being able to add to them. The operator is @=+@ (the plus comes
+-- /after/ the equals), but each attribute has a different syntax for what
+-- comes after the operator.
+
+class SummableClass s y | s -> y where
+  -- | This lets you add to an attribute.
+  (=+) :: s c -> y -> Arr c c
+  infix 0 =+
+
+data Summable x y c = Summable (c -> x)      -- getter
+                               (x -> c -> c) -- setter
+                               (x -> y -> x) -- accumulator
+
+instance UpdateableClass (Summable x y) x x where
+  (Summable g s _ =. f) c = return $ s (f $ g c) c
+
+instance SummableClass (Summable x y) y where
+  (Summable g s a =+ y) c = return $ s (g c `a` y) c
+
+-- | 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.
+manageHook :: Summable ManageHook ManageHook (XConfig l)
+manageHook = Summable X.manageHook (\x c -> c { X.manageHook = x }) (<+>)
+
+-- | Custom X event handler. Return @All True@ if the default handler should
+-- also be run afterwards. Default does nothing. To add an event handler:
+--
+-- > import XMonad.Hooks.ServerMode
+-- > ...
+-- >   handleEventHook =+ serverModeEventHook
+handleEventHook :: Summable (Event -> X All) (Event -> X All) (XConfig l)
+handleEventHook = Summable X.handleEventHook (\x c -> c { X.handleEventHook = x }) (<+>)
+
+-- | List of workspaces' names. Default: @map show [1 .. 9 :: Int]@. Adding
+-- appends to the end:
+--
+-- >   workspaces =+ ["0"]
+--
+-- This is useless unless you also create keybindings for this.
+workspaces :: Summable [String] [String] (XConfig l)
+workspaces = Summable X.workspaces (\x c -> c { X.workspaces = x }) (++)
+
+-- | The action to perform when the windows set is changed. This happens
+-- whenever focus change, a window is moved, etc. @logHook =+@ takes an @X ()@
+-- and appends it via '(>>)'. For instance:
+--
+-- > import XMonad.Hooks.ICCCMFocus
+-- > ...
+-- >   logHook =+ takeTopFocus
+--
+-- Note that if your expression is parametrically typed (e.g. of type
+-- @MonadIO m => m ()@), you'll need to explicitly annotate it, like so:
+--
+-- >   logHook =+ (io $ putStrLn "Hello, world!" :: X ())
+logHook :: Summable (X ()) (X ()) (XConfig l)
+logHook = Summable X.logHook (\x c -> c { X.logHook = x }) (P.>>)
+
+-- | The action to perform on startup. @startupHook =+@ takes an @X ()@ and
+-- appends it via '(>>)'. For instance:
+--
+-- > import XMonad.Hooks.SetWMName
+-- > ...
+-- >   startupHook =+ setWMName "LG3D"
+--
+-- Note that if your expression is parametrically typed (e.g. of type
+-- @MonadIO m => m ()@), you'll need to explicitly annotate it, as documented
+-- in 'logHook'.
+startupHook :: Summable (X ()) (X ()) (XConfig l)
+startupHook = Summable X.startupHook (\x c -> c { X.startupHook = x }) (P.>>)
+
+-- | The client events that xmonad is interested in. This is useful in
+-- combination with handleEventHook. Default: @structureNotifyMask .|.
+-- enterWindowMask .|. propertyChangeMask@
+--
+-- >   clientMask =+ keyPressMask .|. keyReleaseMask
+clientMask :: Summable EventMask EventMask (XConfig l)
+clientMask = Summable X.clientMask (\x c -> c { X.clientMask = x }) (.|.)
+
+-- | The root events that xmonad is interested in. This is useful in
+-- combination with handleEventHook. Default: @substructureRedirectMask .|.
+-- substructureNotifyMask .|. enterWindowMask .|. leaveWindowMask .|.
+-- structureNotifyMask .|. buttonPressMask@
+rootMask :: Summable EventMask EventMask (XConfig l)
+rootMask = Summable X.rootMask (\x c -> c { X.rootMask = x }) (.|.)
+
+-- $removables
+-- The following support the the @=+@ for adding items and the @=-@ operator
+-- for removing items.
+
+class RemovableClass r y | r -> y where
+  -- | This lets you remove from an attribute.
+  (=-) :: r c -> y -> Arr c c
+  infix 0 =-
+
+data Keys c = Keys { kAdd :: [(String, X ())] -> c -> c,
+                     kRemove :: [String] -> c -> c }
+
+instance SummableClass Keys [(String, X ())] where
+  Keys { kAdd = a } =+ newKeys = return . a newKeys
+
+instance RemovableClass Keys [String] where
+  Keys { kRemove = r } =- sadKeys = return . r sadKeys
+
+-- | Key bindings to 'X' actions. Default: see @`man xmonad`@. 'keys'
+-- takes a list of keybindings specified emacs-style, as documented in
+-- 'XMonad.Util.EZConfig.mkKeyMap'. For example, to change the "kill window"
+-- key:
+--
+-- >   keys =- ["M-S-c"]
+-- >   keys =+ [("M-M1-x", kill)]
+keys :: Keys (XConfig l)
+keys = Keys {
+  -- Note that since checkKeymap happens on newKeys, it doesn't check for
+  -- duplicates between repeated applications. Probably OK. (Especially since
+  -- overriding defaults is a common behavior.) Also note that there's no
+  -- reference cycle here. Yay!
+  kAdd = \newKeys c -> (c `additionalKeysP` newKeys) { X.startupHook = (P.>>) (X.startupHook c) (checkKeymap c newKeys) },
+  kRemove = flip removeKeysP
+}
+
+data MouseBindings c = MouseBindings { mAdd :: [((ButtonMask, Button), Window -> X ())] -> c -> c,
+                                       mRemove :: [(ButtonMask, Button)] -> c -> c }
+
+instance SummableClass MouseBindings [((ButtonMask, Button), Window -> X ())] where
+  MouseBindings { mAdd = a } =+ newBindings = return . a newBindings
+
+instance RemovableClass MouseBindings [(ButtonMask, Button)] where
+  MouseBindings { mRemove = r } =- sadBindings = return . r sadBindings
+
+-- | Mouse button bindings to an 'X' actions on a window. Default: see @`man
+-- xmonad`@. To make mod-<scrollwheel> switch workspaces:
+--
+-- > import XMonad.Actions.CycleWS (nextWS, prevWS)
+-- > ...
+-- >   mouseBindings =+ [((mod4Mask, button4), const prevWS),
+-- >                     ((mod4Mask, button5), const nextWS)]
+--
+-- Note that you need to specify the numbered mod-mask e.g. 'mod4Mask' instead
+-- of just 'modMask'.
+mouseBindings :: MouseBindings (XConfig l)
+mouseBindings = MouseBindings {
+  mAdd = flip additionalMouseBindings,
+  mRemove = flip removeMouseBindings
+}
+
+-- $workspaces
+-- Workspaces can be configured through 'workspaces', but then the 'keys' need
+-- to be set, and this can be a bit laborious. 'withWorkspaces' provides a
+-- convenient mechanism for common workspace updates.
+
+-- | Configure workspaces through a Prime-like interface. Example:
+--
+-- >   withWorkspaces $ do
+-- >     wsKeys =+ ["0"]
+-- >     wsActions =+ [("M-M1-", windows . swapWithCurrent)]
+-- >     wsSetName 1 "mail"
+--
+-- This will set 'workspaces' and add the necessary keybindings to 'keys'. Note
+-- that it won't remove old keybindings; it's just not that clever.
+withWorkspaces :: Arr WorkspaceConfig WorkspaceConfig -> Prime l l
+withWorkspaces wsarr xconf = (P.>>=) (wsarr def) $ \wsconf -> wsprime wsconf xconf
+  where wsprime :: WorkspaceConfig -> Prime l l
+        wsprime wsconf =
+          (workspaces =: allNames) >>
+          (keys =+ [(mod ++ key, action name) | (name, key) <- zip allNames (wsKeys_ wsconf),
+                                                (mod, action) <- wsActions_ wsconf])
+          where allNames = zipWith chooseName (wsNames_ wsconf) (wsKeys_ wsconf)
+                chooseName name keyspec = if not (null name) then name else keyspec
+
+data WorkspaceConfig = WorkspaceConfig {
+  wsNames_ :: [String],
+  wsKeys_ :: [String],
+  wsActions_ :: [(String, String -> X ())]
+}
+
+instance Default WorkspaceConfig where
+  def = WorkspaceConfig {
+    wsNames_ = repeat "",
+    wsKeys_ = map (:[]) ['1'..'9'], -- The hungry monkey eats dots and turns them into numbers.
+    wsActions_ = [("M-", windows . W.greedyView),
+                  ("M-S-", windows . W.shift)]
+  }
+
+-- | The list of workspace names, like 'workspaces' but with two differences:
+--
+--   1. If any entry is the empty string, it'll be replaced with the
+--      corresponding entry in 'wsKeys'.
+--   2. The list is truncated to the size of 'wsKeys'.
+--
+-- The default value is @'repeat' ""@.
+--
+-- If you'd like to create workspaces without associated keyspecs, you can do
+-- that afterwards, outside the 'withWorkspaces' block, with @'workspaces' =+@.
+wsNames :: Settable [String] WorkspaceConfig
+wsNames = Settable wsNames_ (\x c -> c { wsNames_ = x })
+
+-- | The list of workspace keys. These are combined with the modifiers in
+-- 'wsActions' to form the keybindings for navigating to workspaces. Default:
+-- @["1","2",...,"9"]@.
+wsKeys :: Summable [String] [String] WorkspaceConfig
+wsKeys = Summable wsKeys_ (\x c -> c { wsKeys_ = x }) (++)
+
+-- | Mapping from key prefix to command. Its type is @[(String, String ->
+-- X())]@. The key prefix may be a modifier such as @\"M-\"@, or a submap
+-- prefix such as @\"M-a \"@, or both, as in @\"M-a M-\"@. The command is a
+-- function that takes a workspace name and returns an @X ()@. 'withWorkspaces'
+-- creates keybindings for the cartesian product of 'wsKeys' and 'wsActions'.
+--
+-- Default:
+--
+-- > [("M-", windows . W.greedyView),
+-- >  ("M-S-", windows . W.shift)]
+wsActions :: Summable [(String, String -> X ())] [(String, String -> X ())] WorkspaceConfig
+wsActions = Summable wsActions_ (\x c -> c { wsActions_ = x }) (++)
+
+-- | A convenience for just modifying one entry in 'wsNames', in case you only
+-- want a few named workspaces. Example:
+--
+-- >     wsSetName 1 "mail"
+-- >     wsSetName 2 "web"
+wsSetName :: Int -> String -> Arr WorkspaceConfig WorkspaceConfig
+wsSetName index newName = wsNames =. (map maybeSet . zip [0..])
+  where maybeSet (i, oldName) | i == (index - 1) = newName
+                              | otherwise = oldName
+
+-- $screens
+-- 'withScreens' provides a convenient mechanism to set keybindings for moving
+-- between screens, much like 'withWorkspaces'.
+
+-- | Configure screen keys through a Prime-like interface:
+--
+-- >   withScreens $ do
+-- >     sKeys =: ["e", "r"]
+--
+-- This will add the necessary keybindings to 'keys'. Note that it won't remove
+-- old keybindings; it's just not that clever.
+withScreens :: Arr ScreenConfig ScreenConfig -> Prime l l
+withScreens sarr xconf = (P.>>=) (sarr def) $ \sconf -> sprime sconf xconf
+  where sprime :: ScreenConfig -> Prime l l
+        sprime sconf =
+          (keys =+ [(mod ++ key, action sid) | (sid, key) <- zip [0..] (sKeys_ sconf),
+                                               (mod, action) <- sActions_ sconf])
+
+data ScreenConfig = ScreenConfig {
+  sKeys_ :: [String],
+  sActions_ :: [(String, ScreenId -> X ())]
+}
+
+instance Default ScreenConfig where
+  def = ScreenConfig {
+    sKeys_ = ["w", "e", "r"],
+    sActions_ = [("M-", windows . onScreens W.view),
+                 ("M-S-", windows . onScreens W.shift)]
+  }
+
+
+-- | The list of screen keys. These are combined with the modifiers in
+-- 'sActions' to form the keybindings for navigating to workspaces. Default:
+-- @["w","e","r"]@.
+sKeys :: Summable [String] [String] ScreenConfig
+sKeys = Summable sKeys_ (\x c -> c { sKeys_ = x }) (++)
+
+-- | Mapping from key prefix to command. Its type is @[(String, ScreenId ->
+-- X())]@. Works the same as 'wsActions' except for a different function type.
+--
+-- Default:
+--
+-- > [("M-", windows . onScreens W.view),
+-- >  ("M-S-", windows . onScreens W.shift)]
+sActions :: Summable [(String, ScreenId -> X ())] [(String, ScreenId -> X ())] ScreenConfig
+sActions = Summable sActions_ (\x c -> c { sActions_ = x }) (++)
+
+-- | Converts a stackset transformer parameterized on the workspace type into one
+-- parameterized on the screen type. For example, you can use @onScreens W.view
+-- 0@ to navigate to the workspace on the 0th screen. If the screen id is not
+-- recognized, the returned transformer acts as an identity function.
+onScreens :: Eq s => (i -> W.StackSet i l a s sd -> W.StackSet i l a s sd) ->
+                     s -> W.StackSet i l a s sd -> W.StackSet i l a s sd
+onScreens f sc ws = maybe id f (W.lookupWorkspace sc ws) ws
+
+-- $layout
+-- Layouts are special. You can't modify them using the @=:@ or @=.@ operator.
+-- You need to use the following functions.
+
+-- | Add a layout to the list of layouts choosable with mod-space. For instance:
+--
+-- > import XMonad.Layout.Tabbed
+-- > ...
+-- >   addLayout simpleTabbed
+addLayout :: (LayoutClass l Window, LayoutClass r Window) => r Window -> Prime l (Choose l r)
+addLayout r c = return c { X.layoutHook = X.layoutHook c ||| r }
+
+-- | Reset the layoutHook from scratch. For instance, to get rid of the wide
+-- layout:
+--
+-- >   resetLayout $ Tall 1 (3/100) (1/2) ||| Full
+--
+-- (The dollar is like an auto-closing parenthesis, so all the stuff to the
+-- right of it is treated like an argument to resetLayout.)
+resetLayout :: (LayoutClass r Window) => r Window -> Prime l r
+resetLayout r c = return c { X.layoutHook = r }
+
+-- | Modify your 'layoutHook' with some wrapper function. You probably want to call
+-- this after you're done calling 'addLayout'. Example:
+--
+-- > import XMonad.Layout.NoBorders
+-- > ...
+-- >   modifyLayout smartBorders
+modifyLayout :: (LayoutClass r Window) => (l Window -> r Window) -> Prime l r
+modifyLayout f c = return c { X.layoutHook = f $ X.layoutHook c }
+
+-- $update
+-- Finally, there are a few contrib modules that bundle multiple attribute
+-- updates together. There are three types: 1) wholesale replacements for the
+-- default config, 2) pure functions on the config, and 3) IO actions on the
+-- config. The syntax for each is different. Examples:
+--
+-- 1) To start with a 'XMonad.Config.Gnome.gnomeConfig' instead of the default,
+-- we use 'startWith':
+--
+-- > import XMonad.Config.Gnome
+-- > ...
+-- >   startWith gnomeConfig
+--
+-- 2) 'XMonad.Hooks.UrgencyHook.withUrgencyHook' is a pure function, so we need
+-- to use 'apply':
+--
+-- > import XMonad.Hooks.UrgencyHook
+-- > ...
+-- >   apply $ withUrgencyHook dzenUrgencyHook
+--
+-- 3) 'XMonad.Hooks.DynamicLog.xmobar' returns an @IO (XConfig l)@, so we need
+-- to use 'applyIO':
+--
+-- > import XMonad.Hooks.DynamicLog
+-- > ...
+-- >   applyIO xmobar
+
+-- | Replace the current 'XConfig' with the given one. If you use this, you
+-- probably want it to be the first line of your config.
+startWith :: XConfig l' -> Prime l l'
+startWith = const . return
+
+-- | Turns a pure function on 'XConfig' into a 'Prime'.
+apply :: (XConfig l -> XConfig l') -> Prime l l'
+apply f = return . f
+
+-- | Turns an IO function on 'XConfig' into a 'Prime'.
+applyIO :: (XConfig l -> IO (XConfig l')) -> Prime l l'
+applyIO = id  -- This is here in case we want to change the Prime type later.
+
+-- $example
+-- As an example, I've included below a subset of my current config. Note that
+-- my import statements specify individual identifiers in parentheticals.
+-- That's optional. The default is to import the entire module. I just find it
+-- helpful to remind me where things came from.
+--
+-- > {-# LANGUAGE RebindableSyntax #-}
+-- > import XMonad.Config.Prime
+-- >
+-- > import XMonad.Actions.CycleWS (prevWS, nextWS)
+-- > import XMonad.Actions.SwapWorkspaces (swapWithCurrent)
+-- > import XMonad.Actions.WindowNavigation (withWindowNavigation)
+-- > import XMonad.Layout.Fullscreen (fullscreenSupport)
+-- > import XMonad.Layout.NoBorders (smartBorders)
+-- > import XMonad.Layout.Tabbed (simpleTabbed)
+-- >
+-- > main = xmonad $ do
+-- >   modMask =: mod4Mask
+-- >   normalBorderColor =: "#222222"
+-- >   terminal =: "urxvt"
+-- >   focusFollowsMouse =: False
+-- >   resetLayout $ Tall 1 (3/100) (1/2) ||| simpleTabbed
+-- >   modifyLayout smartBorders
+-- >   apply fullscreenSupport
+-- >   applyIO $ withWindowNavigation (xK_w, xK_a, xK_s, xK_d)
+-- >   withWorkspaces $ do
+-- >     wsKeys =+ ["0"]
+-- >     wsActions =+ [("M-M1-", windows . swapWithCurrent)]
+-- >   keys =+ [
+-- >       ("M-,",                      sendMessage $ IncMasterN (-1)),
+-- >       ("M-.",                      sendMessage $ IncMasterN 1),
+-- >       ("M-M1-d",                   spawn "date | dzen2 -fg '#eeeeee' -p 2"),
+-- >       ("C-S-q",                    return ()),
+-- >       ("<XF86AudioLowerVolume>",   spawn "amixer set Master 5%-"),
+-- >       ("<XF86AudioRaiseVolume>",   spawn "amixer set Master 5%+"),
+-- >       ("M-M1-x",                   kill),
+-- >       ("M-i",                      prevWS),
+-- >       ("M-o",                      nextWS)
+-- >     ]
+
+-- $troubleshooting
+-- === Only the last line of my config seems to take effect. What gives?
+-- You're missing the @{-\# LANGUAGE RebindableSyntax \#-}@ line at the top.
+--
+-- === How do I do use normal monads like 'X' or 'IO'?
+-- Here are a couple of ways:
+--
+-- > import qualified Prelude as P
+-- > ...
+-- > test1, test2 :: X ()
+-- > test1 = spawn "echo Hi" P.>> spawn "echo Bye"
+-- > test2 = do spawn "echo Hi"
+-- >            spawn "echo Bye"
+-- >   where (>>) = (P.>>)
+--
+-- === How do I use the old keyboard syntax?
+-- You can use 'apply' and supply your own Haskell function. For instance:
+--
+-- > apply $ flip additionalKeys $ [((mod1Mask, xK_z), spawn "date | dzen2 -fg '#eeeeee' -p 2")]
+--
+-- === How do I run a command before xmonad starts (like 'spawnPipe')?
+-- If you're using it for a status bar, see if 'XMonad.Hooks.DynamicLog.dzen'
+-- or 'XMonad.Hooks.DynamicLog.xmobar' does what you want. If so, you can apply
+-- it with 'applyIO'.
+--
+-- If not, you can write your own @XConfig l -> IO (XConfig l)@ and apply it
+-- with 'applyIO'. When writing this function, see the above tip about using
+-- normal monads.
+--
+-- Alternatively, you could do something like this this:
+--
+-- > import qualified Prelude as P (>>)
+-- >
+-- > main =
+-- >   openFile ".xmonad.log" AppendMode >>= \log ->
+-- >   hSetBuffering log LineBuffering P.>>
+-- >   (xmonad $ do
+-- >      nothing -- Prime config here.
+-- >   )

XMonad/Config/Saegesser.hs

@@ -0,0 +1,79 @@
+{-# OPTIONS_GHC -fno-warn-missing-signatures -fno-warn-orphans #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+---------------------------------------------------------------------
+-- |
+-- A mostly striped down configuration that demonstrates spawnOnOnce
+--
+---------------------------------------------------------------------
+import System.IO
+
+import XMonad
+
+import XMonad.Hooks.DynamicLog
+import XMonad.Hooks.ManageDocks
+import XMonad.Hooks.ManageHelpers
+import XMonad.Hooks.UrgencyHook
+import XMonad.Hooks.FadeInactive
+
+import XMonad.Layout.NoBorders
+import XMonad.Layout.ResizableTile
+import XMonad.Layout.Mosaic
+
+import XMonad.Util.Run
+import XMonad.Util.Cursor
+import XMonad.Util.NamedScratchpad
+import XMonad.Util.Scratchpad
+import XMonad.Util.SpawnOnce
+
+import XMonad.Actions.CopyWindow
+import XMonad.Actions.SpawnOn
+
+import qualified XMonad.StackSet as W
+
+main = do
+  myStatusBarPipe <- spawnPipe "xmobar"
+  xmonad $ docks $ withUrgencyHook NoUrgencyHook $ def
+    { terminal          = "xterm"
+    , workspaces        = myWorkspaces
+    , layoutHook        = myLayoutHook
+    , manageHook        = myManageHook <+> manageSpawn
+    , startupHook       = myStartupHook
+    , logHook           = myLogHook myStatusBarPipe
+    , focusFollowsMouse = False
+    }
+
+myManageHook = composeOne
+  [ isDialog                     -?> doFloat
+  , className =? "trayer"        -?> doIgnore
+  , className =? "Skype"         -?> doShift "chat"
+  , appName   =? "libreoffice"   -?> doShift "office"
+  , return True                  -?> doF W.swapDown
+  ]
+
+myWorkspaces = [ "web", "emacs", "chat", "vm", "office", "media", "xterms", "8", "9", "0"]
+
+myStartupHook = do
+  setDefaultCursor xC_left_ptr
+  spawnOnOnce "emacs" "emacs"
+  spawnNOnOnce 4 "xterms" "xterm"
+
+myLayoutHook = smartBorders $ avoidStruts $ standardLayouts
+  where standardLayouts = tiled ||| mosaic 2 [3,2]  ||| Mirror tiled ||| Full
+        tiled = ResizableTall nmaster delta ratio []
+        nmaster = 1
+        delta = 0.03
+        ratio = 0.6
+
+myLogHook p =  do
+  copies <- wsContainingCopies
+  let check ws | ws == "NSP" = ""                               -- Hide the scratchpad workspace
+               | ws `elem` copies = xmobarColor "red" "black" $ ws  -- Workspaces with copied windows are red on black
+               | otherwise = ws
+  dynamicLogWithPP $ xmobarPP { ppHidden = check
+                              , ppOutput = hPutStrLn p
+                              , ppUrgent = xmobarColor "white" "red"
+                              , ppTitle  = xmobarColor "green" "" . shorten 180
+                              }
+  fadeInactiveLogHook 0.6
+

XMonad/Config/Sjanssen.hs

@@ -21,21 +21,21 @@ import XMonad.Layout.TwoPane
 import qualified Data.Map as M
 
 sjanssenConfig =
-    ewmh $ defaultConfig
+    docks $ ewmh $ def
         { terminal = "exec urxvt"
         , workspaces = ["irc", "web"] ++ map show [3 .. 9 :: Int]
         , mouseBindings = \(XConfig {modMask = modm}) -> M.fromList $
                 [ ((modm, button1), (\w -> focus w >> mouseMoveWindow w))
                 , ((modm, button2), (\w -> focus w >> windows W.swapMaster))
                 , ((modm.|. shiftMask, button1), (\w -> focus w >> mouseResizeWindow w)) ]
-        , keys = \c -> mykeys c `M.union` keys defaultConfig c
+        , keys = \c -> mykeys c `M.union` keys def c
         , logHook = dynamicLogString sjanssenPP >>= xmonadPropLog
         , layoutHook  = modifiers layouts
         , manageHook  = composeAll [className =? x --> doShift w
                                     | (x, w) <- [ ("Firefox", "web")
                                                 , ("Ktorrent", "7")
                                                 , ("Amarokapp", "7")]]
-                        <+> manageHook defaultConfig <+> manageDocks <+> manageSpawn
+                        <+> manageHook def <+> manageSpawn
                         <+> (isFullscreen --> doFullFloat)
         , startupHook = mapM_ spawnOnce spawns
         }
@@ -62,8 +62,8 @@ sjanssenConfig =
         ]
 
     myFont = "xft:Bitstream Vera Sans Mono:pixelsize=10"
-    myTheme = defaultTheme { fontName = myFont }
-    myPromptConfig = defaultXPConfig
+    myTheme = def { fontName = myFont }
+    myPromptConfig = def
                         { position = Top
                         , font = myFont
                         , showCompletionOnTab = True

XMonad/Config/Xfce.hs

@@ -16,7 +16,8 @@
 module XMonad.Config.Xfce (
     -- * Usage
     -- $usage
-    xfceConfig
+    xfceConfig,
+    desktopLayoutModifiers
     ) where
 
 import XMonad

XMonad/Config/dmwit.xmobarrc

@@ -0,0 +1,10 @@
+Config {
+    font         = "xft:Monospace:pixelsize=14,-*-*-*-r-*-*-16-*-*-*-*-*-*-*",
+    bgColor      = "#000040",
+    fgColor      = "#80c0ff",
+    position     = TopSize C 100 26,
+    lowerOnStart = True,
+    commands     = [ Run Com "date" ["+%H:%M"] "" 30 ],
+    sepChar      = "%",
+    alignSep     = "}{"
+}

XMonad/Doc.hs

@@ -49,9 +49,9 @@ import XMonad.Doc.Developing ()
 xmonad is a tiling window manager for X. The xmonad-contrib library
 collects third party tiling algorithms, hooks, configurations,
 scripts, and other extensions to xmonad.  The source for this library
-is available from <http://code.haskell.org/XMonadContrib> via darcs:
+is available from <https://github.com/xmonad/xmonad-contrib> via git:
 
-> darcs get http://code.haskell.org/XMonadContrib
+> git clone https://github.com/xmonad/xmonad-contrib.git
 
 Each stable release of xmonad is accompanied by a stable release of
 the contrib library, which you should use if (and only if) you're

XMonad/Doc/Configuring.hs

@@ -84,7 +84,7 @@ some colours:
 >
 >    import XMonad
 >
->    main = xmonad $ defaultConfig
+>    main = xmonad $ def
 >        { borderWidth        = 2
 >        , terminal           = "urxvt"
 >        , normalBorderColor  = "#cccccc"

XMonad/Doc/Extending.hs

@@ -102,7 +102,7 @@ For more information about any particular module, just click on its
 name to view its Haddock documentation; each module should come with
 extensive documentation.  If you find a module that could be better
 documented, or has incorrect documentation, please report it as a bug
-(<http://code.google.com/p/xmonad/issues/list>)!
+(<https://github.com/xmonad/xmonad/issues>)!
 
 -}
 
@@ -116,6 +116,13 @@ beyond the standard keybindings provided by xmonad.
 See "XMonad.Doc.Extending#Editing_key_bindings" for instructions on how to
 edit your key bindings.
 
+* "XMonad.Actions.AfterDrag":
+    Allows you to add actions dependent on the current mouse drag.
+
+* "XMonad.Actions.BluetileCommands":
+    External commands for interfacing the [Bluetile](https://hackage.haskell.org/package/bluetile)
+    tiling window manager with Xmonad.
+
 * "XMonad.Actions.Commands":
     Allows you to run internal xmonad commands (X () actions) using
     a dmenu menu in addition to key bindings.  Requires dmenu and
@@ -159,6 +166,20 @@ edit your key bindings.
     master, swap it with the next window in the stack. Focus stays in the
     master.
 
+* "XMonad.Actions.DynamicProjects":
+    Imbues workspaces with additional features so they can be treated as
+    individual project areas.
+
+* "XMonad.Actions.DynamicWorkspaceGroups":
+    Dynamically manage "workspace groups", sets of workspaces being used
+    together for some common task or purpose, to allow switching between
+    workspace groups in a single action. Note that this only makes sense for
+    multi-head setups.
+
+* "XMonad.Actions.DynamicWorkspaceOrder":
+    Remember a dynamically updateable ordering on workspaces, together with
+    tools for using this ordering with "XMonad.Actions.CycleWS" and "XMonad.Hooks.DynamicLog".
+
 * "XMonad.Actions.DynamicWorkspaces":
     Provides bindings to add and delete workspaces.  Note that you may only
     delete a workspace that is already empty.
@@ -186,6 +207,24 @@ edit your key bindings.
     GridSelect displays items(e.g. the opened windows) in a 2D grid and lets
     the user select from it with the cursor/hjkl keys or the mouse.
 
+* "XMonad.Actions.GroupNavigation":
+    Provides methods for cycling through groups of windows across workspaces,
+    ignoring windows that do not belong to this group. A group consists of all
+    windows matching a user-provided boolean query. Also provides a method for
+    jumping back to the most recently used window in any given group.
+
+* "XMonad.Actions.KeyRemap":
+    Remap Keybinding on the fly, e.g having Dvorak char,
+    but everything with Control/Shift is left US Layout.
+
+* "XMonad.Actions.Launcher":
+    A set of prompts for XMonad.
+
+* "XMonad.Actions.LinkWorkspaces":
+    Provides bindings to add and delete links between workspaces. It is aimed at
+    providing useful links between workspaces in a multihead setup.
+    Linked workspaces are view at the same time.
+
 * "XMonad.Actions.MessageFeedback":
     Alternative to 'XMonad.Operations.sendMessage' that provides knowledge
     of whether the message was handled, and utility functions based on
@@ -198,6 +237,10 @@ edit your key bindings.
     A layout modifier to resize windows with the mouse by grabbing the
     window's lower right corner.
 
+* "XMonad.Actions.Navigation2D":
+    Navigation2D is an xmonad extension that allows easy directional navigation
+    of windows and screens (in a multi-monitor setup).
+
 * "XMonad.Actions.NoBorders":
     This module provides helper functions for dealing with window borders.
 
@@ -228,6 +271,10 @@ edit your key bindings.
     A module for easily running Internet searches on web sites through xmonad.
     Modeled after the handy Surfraw CLI search tools at <https://secure.wikimedia.org/wikipedia/en/wiki/Surfraw>.
 
+* "XMonad.Actions.ShowText":
+    ShowText displays text for sometime on the screen similar to
+    "XMonad.Util.Dzen" which offers more features (currently).
+
 * "XMonad.Actions.SimpleDate":
     An example external contrib module for XMonad.
     Provides a simple binding to dzen2 to print the date as a popup menu.
@@ -254,6 +301,12 @@ edit your key bindings.
 * "XMonad.Actions.TopicSpace":
     Turns your workspaces into a more topic oriented system.
 
+* "XMonad.Actions.TreeSelect":
+    TreeSelect displays your workspaces or actions in a Tree-like format.
+    You can select the desired workspace/action with the cursor or hjkl keys.
+    This module is fully configurable and very useful if you like to have a
+    lot of workspaces.
+
 * "XMonad.Actions.UpdateFocus":
     Updates the focus on mouse move in unfocused windows.
 
@@ -283,9 +336,23 @@ edit your key bindings.
     Provides functions for performing a given action on all windows of
     the current workspace.
 
+* "XMonad.Actions.Workscreen":
+    A workscreen permits to display a set of workspaces on several screens. In
+    xinerama mode, when a workscreen is viewed, workspaces associated to all
+    screens are visible. The first workspace of a workscreen is displayed on
+    first screen, second on second screen, etc. Workspace position can be easily
+    changed. If the current workscreen is called again, workspaces are shifted.
+    This also permits to see all workspaces of a workscreen even if just one screen
+    is present, and to move windows from workspace to workscreen.
+
 * "XMonad.Actions.WorkspaceCursors":
     Like "XMonad.Actions.Plane" for an arbitrary number of dimensions.
 
+* "XMonad.Actions.WorkspaceNames":
+    Provides bindings to rename workspaces, show these names in DynamicLog and
+    swap workspaces along with their names. These names survive restart. Together
+    with "XMonad.Layout.WorkspaceDir" this provides for a fully dynamic topic
+    space workflow.
 -}
 
 {- $configs
@@ -297,25 +364,56 @@ configuration; you can also simply import them and use them as your
 own configuration, possibly with some modifications.
 
 
-* "XMonad.Config.Arossato"
+* "XMonad.Config.Arossato":
     This module specifies my xmonad defaults.
 
-* "XMonad.Config.Azerty"
+* "XMonad.Config.Azerty":
     Fixes some keybindings for users of French keyboard layouts.
 
-* "XMonad.Config.Desktop"
+* "XMonad.Config.Bepo":
+    This module fixes some of the keybindings for the francophone among you who
+    use a BEPO keyboard layout. Based on "XMonad.Config.Azerty".
+
+* "XMonad.Config.Bluetile":
+    This is the default configuration of [Bluetile](http://projects.haskell.org/bluetile/).
+    If you are migrating from Bluetile to xmonad or want to create a similar setup,
+    then this will give you pretty much the same thing, except for Bluetile's
+    helper applications such as the dock.
+
+* "XMonad.Config.Desktop":
     This module provides core desktop environment settings used
     in the Gnome, Kde, and Xfce config configs. It is also useful
     for people using other environments such as lxde, or using
     tray or panel applications without full desktop environments.
 
-* "XMonad.Config.Gnome"
+* "XMonad.Config.Dmwit":
+    [dmwit](https://github.com/dmwit)'s xmonad configs and helpers.
 
-* "XMonad.Config.Kde"
+* "XMonad.Config.Droundy":
+    Droundy's xmonad config.
 
-* "XMonad.Config.Sjanssen"
+* "XMonad.Config.Gnome":
+    This module provides a config suitable for use with the GNOME desktop environment.
 
-* "XMonad.Config.Xfce"
+* "XMonad.Config.Kde":
+    This module provides a config suitable for use with the KDE desktop environment.
+
+* "XMonad.Config.Mate":
+    This module provides a config suitable for use with the MATE desktop environment.
+
+* "XMonad.Config.Prime":
+    This is a draft of a brand new config syntax for xmonad. It aims to be
+    1) easier to copy/paste snippets from the docs 2) easier to get the gist
+    for what's going on, for you imperative programmers. It's brand new, so it's
+    pretty much guaranteed to break or change syntax. But what's the worst that
+    could happen? Xmonad crashes and logs you out? It probably won't do that.
+    Give it a try.
+
+* "XMonad.Config.Sjanssen":
+    [spencerjanssen](https://github.com/spencerjanssen)'s xmonad configs.
+
+* "XMonad.Config.Xfce":
+    This module provides a config suitable for use with the Xfce desktop environment.
 
 -}
 
@@ -349,6 +447,29 @@ occur. The two most important hooks are:
 
 Here is a list of the modules found in @XMonad.Hooks@:
 
+* "XMonad.Hooks.CurrentWorkspaceOnTop":
+    Ensures that the windows of the current workspace are always in front of
+    windows that are located on other visible screens. This becomes important if
+    you use decoration and drag windows from one screen to another.
+    Using this module, the dragged window will always be in front of other windows.
+
+* "XMonad.Hooks.DebugEvents":
+    Module to dump diagnostic information about X11 events received by xmonad.
+    This is incomplete due to "Event" being incomplete and not providing
+    information about a number of events, and enforcing artificial constraints
+    on others (for example ClientMessage); the X11 package will require a number
+    of changes to fix these problems.
+
+* "XMonad.Hooks.DebugKeyEvents":
+    A debugging module to track key events, useful when you can't tell whether
+    xmonad is processing some or all key events.
+
+* "XMonad.Hooks.DebugStack":
+    Dump the state of the StackSet. A logHook and handleEventHook are also provided.
+
+* "Xmonad.Hooks.DynamicBars":
+    Manage per-screen status bars.
+
 * "XMonad.Hooks.DynamicHooks":
     One-shot and permanent ManageHooks that can be updated at runtime.
 
@@ -367,14 +488,28 @@ Here is a list of the modules found in @XMonad.Hooks@:
     which causes those windows to become slightly translucent if something
     like xcompmgr is running
 
+* "XMonad.Hooks.FadeWindows":
+    A more flexible and general compositing interface than FadeInactive. Windows
+    can be selected and opacity specified by means of FadeHooks, which are very
+    similar to ManageHooks and use the same machinery.
+
 * "XMonad.Hooks.FloatNext":
     Hook and keybindings for automatically sending the next
     spawned window(s) to the floating layer.
 
+* "XMonad.Hooks.ICCCMFocus":
+    Deprecated.
+
 * "XMonad.Hooks.InsertPosition":
     Configure where new windows should be added and which window should be
     focused.
 
+* "XMonad.Hooks.ManageDebug":
+    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 "EZConfig" syntax. Or use the individual hooks in whatever way you see fit.
+
 * "XMonad.Hooks.ManageDocks":
     This module provides tools to automatically manage 'dock' type programs,
     such as gnome-panel, kicker, dzen, and xmobar.
@@ -389,35 +524,54 @@ Here is a list of the modules found in @XMonad.Hooks@:
 * "XMonad.Hooks.Place":
     Automatic placement of floating windows.
 
+* "XMonad.Hooks.PositionStoreHooks":
+    This module contains two hooks for the PositionStore (see XMonad.Util.PositionStore) -
+    a ManageHook and an EventHook. The ManageHook can be used to fill the
+    PositionStore with position and size information about new windows. The advantage
+    of using this hook is, that the information is recorded independent of the
+    currently active layout. So the floating shape of the window can later be restored
+    even if it was opened in a tiled layout initially. The EventHook makes sure
+    that windows are deleted from the PositionStore when they are closed.
+
 * "XMonad.Hooks.RestoreMinimized":
     (Deprecated: Use XMonad.Hooks.Minimize) Lets you restore minimized
     windows (see "XMonad.Layout.Minimize") by selecting them on a
     taskbar (listens for _NET_ACTIVE_WINDOW and WM_CHANGE_STATE).
 
+* "XMonad.Hooks.ScreenCorners":
+    Run X () actions by touching the edge of your screen with your mouse.
+
 * "XMonad.Hooks.Script":
     Provides a simple interface for running a ~\/.xmonad\/hooks script with the
     name of a hook.
 
-* "XMonad.Hooks.ServerMode": Allows sending commands to a running xmonad process.
-
-* "XMonad.Hooks.SetCursor":
-    Set a default mouse cursor on startup.
+* "XMonad.Hooks.ServerMode":
+    Allows sending commands to a running xmonad process.
 
 * "XMonad.Hooks.SetWMName":
     Sets the WM name to a given string, so that it could be detected using
     _NET_SUPPORTING_WM_CHECK protocol.  May be useful for making Java GUI
     programs work.
 
+* "XMonad.Hooks.ToggleHook":
+    Hook and keybindings for toggling hook behavior.
+
 * "XMonad.Hooks.UrgencyHook":
     UrgencyHook lets you configure an action to occur when a window demands
     your attention. (In traditional WMs, this takes the form of \"flashing\"
     on your \"taskbar.\" Blech.)
 
+* "XMonad.Hooks.WallpaperSetter":
+    Log hook which changes the wallpapers depending on visible workspaces.
+
 * "XMonad.Hooks.WorkspaceByPos":
     Useful in a dual-head setup: Looks at the requested geometry of
     new windows and moves them to the workspace of the non-focused
     screen if necessary.
 
+* "XMonad.Hooks.WorkspaceHistory":
+    Keeps track of workspace viewing order.
+
 * "XMonad.Hooks.XPropManage":
     A ManageHook matching on XProperties.
 
@@ -450,6 +604,13 @@ For more information on using those modules for customizing your
     master and slave. Size of slave area automatically changes depending on
     number of slave windows.
 
+* "XMonad.Layout.AvoidFloats":
+    Find a maximum empty rectangle around floating windows and use that area to
+    display non-floating windows.
+
+* "XMonad.Layout.BinarySpacePartition":
+    Layout where new windows will split the focused window in half, based off of BSPWM.
+
 * "XMonad.Layout.BorderResize":
     This layout modifier will allow to resize windows by dragging their
     borders with the mouse. However, it only works in layouts or modified
@@ -460,6 +621,11 @@ For more information on using those modules for customizing your
 * "XMonad.Layout.BoringWindows":
     BoringWindows is an extension to allow windows to be marked boring
 
+* "XMonad.Layout.ButtonDecoration":
+    A decoration that includes small buttons on both ends which invoke various
+    actions when clicked on: Show a window menu (see "XMonad.Actions.WindowMenu"),
+    minimize, maximize or close the window.
+
 * "XMonad.Layout.CenteredMaster":
     Two layout modifiers. centerMaster places master window at center,
     on top of all other windows, which are managed by base layout.
@@ -488,6 +654,11 @@ For more information on using those modules for customizing your
     A layout modifier and a class for easily creating decorated
     layouts.
 
+* "XMonad.Layout.DecorationAddons":
+    Various stuff that can be added to the decoration. Most of it is intended to
+    be used by other modules. See "XMonad.Layout.ButtonDecoration" for a module
+    that makes use of this.
+
 * "XMonad.Layout.DecorationMadness":
     A collection of decorated layouts: some of them may be nice, some
     usable, others just funny.
@@ -502,6 +673,24 @@ For more information on using those modules for customizing your
     the other is either the currently focused window or the second window in
     layout order. See also "XMonad.Layout.MouseResizableTall"
 
+* "XMonad.Layout.DraggingVisualizer":
+    A helper module to visualize the process of dragging a window by making it
+    follow the mouse cursor. See "XMonad.Layout.WindowSwitcherDecoration" for a
+    module that makes use of this.
+
+* "XMonad.Layout.Drawer":
+    A layout modifier that puts some windows in a "drawer" which retracts and
+    expands depending on whether any window in it has focus. Useful for music
+    players, tool palettes, etc.
+
+* "XMonad.Layout.Dwindle":
+    Three layouts: The first, Spiral, is a reimplementation of spiral with, at
+    least to me, more intuitive semantics. The second, Dwindle, is inspired by
+    a similar layout in awesome and produces the same sequence of decreasing
+    window sizes as Spiral but pushes the smallest windows into a screen corner
+    rather than the centre. The third, Squeeze arranges all windows in one row
+    or in one column, with geometrically decreasing sizes.
+
 * "XMonad.Layout.DwmStyle":
     A layout modifier for decorating windows in a dwm like style.
 
@@ -511,6 +700,10 @@ For more information on using those modules for customizing your
     split. This is useful when you usually leave a text editor or
     terminal in the master pane and like it to be 80 columns wide.
 
+* "XMonad.Layout.Fullscreen":
+    Hooks for sending messages about fullscreen windows to layouts, and a few
+    example layout modifier that implement fullscreen windows.
+
 * "XMonad.Layout.Gaps":
     Create manually-sized gaps along edges of the screen which will not
     be used for tiling, along with support for toggling gaps on and
@@ -526,6 +719,25 @@ For more information on using those modules for customizing your
     master area and uses an aspect-ratio-specified layout for the
     slaves.
 
+* "XMonad.Layout.Groups":
+    Two-level layout with windows split in individual layout groups, themselves
+    managed by a user-provided layout.
+
+*   * "XMonad.Layout.Groups.Examples":
+        Example layouts for "XMonad.Layout.Groups".
+
+*   * "XMonad.Layout.Groups.Helpers":
+        Utility functions for "XMonad.Layout.Groups".
+
+*   * "XMonad.Layout.Groups.Wmii":
+        A wmii-like layout algorithm.
+
+* "XMonad.Layout.Hidden":
+    Similar to XMonad.Layout.Minimize but completely removes windows from the
+    window set so XMonad.Layout.BoringWindows isn't necessary. Perfect companion
+    to XMonad.Layout.BinarySpacePartition since it can be used to move windows
+    to another part of the BSP tree.
+
 * "XMonad.Layout.HintedGrid":
     A not so simple layout that attempts to put all windows in a square grid
     while obeying their size hints.
@@ -538,6 +750,16 @@ For more information on using those modules for customizing your
     Layout modfier suitable for workspace with multi-windowed instant messenger
     (like Psi or Tkabber).
 
+* "XMonad.Layout.IfMax":
+    Provides IfMax layout, which will run one layout if there are maximum N
+    windows on workspace, and another layout, when number of windows is greater
+    than N.
+
+* "XMonad.Layout.ImageButtonDecoration":
+    A decoration that includes small image buttons on both ends which invoke
+    various actions when clicked on: Show a window menu (see "XMonad.Actions.WindowMenu"),
+    minimize, maximize or close the window.
+
 * "XMonad.Layout.IndependentScreens":
     Utility functions for simulating independent sets of workspaces on
     each screen (like dwm's workspace model), using internal tags to
@@ -613,12 +835,19 @@ For more information on using those modules for customizing your
     A layout in the spirit of "XMonad.Layout.ResizableTile", but with the option
     to use the mouse to adjust the layout.
 
+* "XMonad.Layout.MultiColumns":
+    This layout tiles windows in a growing number of columns. The number of
+    windows in each column can be controlled by messages.
+
 * "XMonad.Layout.MultiToggle":
     Dynamically apply and unapply transformers to your window layout. This can
     be used to rotate your window layout by 90 degrees, or to make the
     currently focused window occupy the whole screen (\"zoom in\") then undo
     the transformation (\"zoom out\").
 
+*   * "XMonad.Layout.MultiToggle.Instances":
+        Some convenient common instances of the Transformer class, for use with "XMonad.Layout.MultiToggle".
+
 * "XMonad.Layout.Named":
     A module for assigning a name to a given layout.
 
@@ -634,17 +863,38 @@ For more information on using those modules for customizing your
     result in title bars that span the entire window instead of being only the
     length of the window title.
 
+* "XMonad.Layout.OnHost":
+    Configure layouts on a per-host basis: use layouts and apply layout modifiers
+    selectively, depending on the host. Heavily based on "XMonad.Layout.PerWorkspace"
+    by Brent Yorgey.
+
 * "XMonad.Layout.OneBig":
     Places one (master) window at top left corner of screen, and other (slave)
     windows at the top.
 
+* "XMonad.Layout.PerScreen":
+    Configure layouts based on the width of your screen; use your favorite
+    multi-column layout for wide screens and a full-screen layout for small ones.
+
 * "XMonad.Layout.PerWorkspace":
     Configure layouts on a per-workspace basis: use layouts and apply
     layout modifiers selectively, depending on the workspace.
 
+* "XMonad.Layout.PositionStoreFloat":
+    A floating layout which has been designed with a dual-head setup in mind.
+    It makes use of "XMonad.Util.PositionStore" as well as "XMonad.Hooks.PositionStoreHooks".
+    Since there is currently no way to move or resize windows with the keyboard
+    alone in this layout, it is adviced to use it in combination with a decoration
+    such as "XMonad.Layout.NoFrillsDecoration" (to move windows) and the layout
+    modifier "XMonad.Layout.BorderResize" (to resize windows).
+
 * "XMonad.Layout.Reflect":
     Reflect a layout horizontally or vertically.
 
+* "XMonad.Layout.Renamed":
+    Layout modifier that can modify the description of its underlying layout on
+    a (hopefully) flexible way.
+
 * "XMonad.Layout.ResizableTile":
     More useful tiled layout that allows you to change a width\/height of window.
     See also "XMonad.Layout.MouseResizableTile".
@@ -676,6 +926,12 @@ For more information on using those modules for customizing your
 * "XMonad.Layout.SimplestFloat":
     A basic floating layout like SimpleFloat but without the decoration.
 
+* "XMonad.Layout.SortedLayout":
+    A new LayoutModifier that sorts a given layout by a list of
+    properties. The order of properties in the list determines
+    the order of windows in the final layout. Any unmatched windows
+    go to the end of the order.
+
 * "XMonad.Layout.Spacing":
     Add a configurable amount of space around windows.
 
@@ -694,6 +950,13 @@ For more information on using those modules for customizing your
     A stacking layout, like dishes but with the ability to resize master pane.
     Mostly useful on small screens.
 
+* "XMonad.Layout.Stoppable":
+    This module implements a special kind of layout modifier, which when applied
+    to a layout, causes xmonad to stop all non-visible processes. In a way,
+    this is a sledge-hammer for applications that drain power. For example, given
+    a web browser on a stoppable workspace, once the workspace is hidden the web
+    browser will be stopped.
+
 * "XMonad.Layout.SubLayouts":
     A layout combinator that allows layouts to be nested.
 
@@ -724,6 +987,10 @@ For more information on using those modules for customizing your
     WindowNavigation is an extension to allow easy navigation of a workspace.
     See also "XMonad.Actions.WindowNavigation".
 
+* "XMonad.Layout.WindowSwitcherDecoration":
+    A decoration that allows to switch the position of windows by dragging them
+    onto each other.
+
 * "XMonad.Layout.WorkspaceDir":
     WorkspaceDir is an extension to set the current directory in a workspace.
     Actually, it sets the current directory in a layout, since there's no way I
@@ -757,6 +1024,9 @@ These are the available prompts:
     you're doing.
     Who knows, it might be useful for other purposes as well!
 
+* "XMonad.Prompt.ConfirmPrompt":
+    A module for setting up simple confirmation prompts for keybindings.
+
 * "XMonad.Prompt.DirExec":
     A directory file executables prompt for XMonad. This might be useful if you
     don't want to have scripts in your PATH environment variable (same
@@ -786,6 +1056,13 @@ These are the available prompts:
     * narrow completions by section number, if the one is specified
     (like @\/etc\/bash_completion@ does)
 
+* "XMonad.Prompt.Pass":
+    This module provides 3 combinators for ease passwords manipulation (generate, read, remove):
+    1) one to lookup passwords in the password-storage.
+    2) one to generate a password for a given password label that the user inputs.
+    3) one to delete a stored password for a given password label that the user inputs.
+
+
 * "XMonad.Prompt.RunOrRaise":
     A prompt for XMonad which will run a program, open a file,
     or raise an already running program, depending on context.
@@ -830,6 +1107,10 @@ A non complete list with a brief description:
 * "XMonad.Util.CustomKeys": configure key bindings (see
   "XMonad.Doc.Extending#Editing_key_bindings").
 
+* "XMonad.Util.DebugWindow":
+    Module to dump window information for diagnostic/debugging purposes. See
+    "XMonad.Hooks.DebugEvents" and "XMonad.Hooks.DebugStack" for practical uses.
+
 * "XMonad.Util.Dmenu":
     A convenient binding to dmenu.
     Requires the process-1.0 package
@@ -837,11 +1118,19 @@ A non complete list with a brief description:
 * "XMonad.Util.Dzen":
     Handy wrapper for dzen. Requires dzen >= 0.2.4.
 
-* "XMonad.Util.EZConfig": configure key bindings easily, including a
-  parser for writing key bindings in "M-C-x" style.
+* "XMonad.Util.EZConfig":
+    Configure key bindings easily, including a
+    parser for writing key bindings in "M-C-x" style.
 
-* "XMonad.Util.Font": A module for abstracting a font facility over
-  Core fonts and Xft
+* "XMonad.Util.ExtensibleState":
+    Module for storing custom mutable state in xmonad.
+
+* "XMonad.Util.Font":
+    A module for abstracting a font facility over
+    Core fonts and Xft.
+
+* "XMonad.Util.Image":
+    Utilities for manipulating [[Bool]] as images.
 
 * "XMonad.Util.Invisible":
     A data type to store the layout state
@@ -852,6 +1141,10 @@ A non complete list with a brief description:
     a pretty-printing status logger format. See "XMonad.Hooks.DynamicLog"
     for more information.
 
+*   * "XMonad.Util.Loggers.NamedScratchpad":
+        A collection of Loggers (see "XMonad.Util.Loggers") for NamedScratchpads
+        (see "XMonad.Util.NamedScratchpad").
+
 * "XMonad.Util.NamedActions":
     A wrapper for keybinding configuration that can list the available
     keybindings.
@@ -864,10 +1157,22 @@ A non complete list with a brief description:
     This module allows you to associate the X titles of windows with
     them.
 
+* "XMonad.Util.NoTaskbar":
+    Utility function and 'ManageHook` to mark a window to be ignored by
+    EWMH taskbars and pagers. Useful for `NamedScratchpad` windows, since
+    you will usually be taken to the `NSP` workspace by them.
+
 * "XMonad.Util.Paste":
     A module for sending key presses to windows. This modules provides generalized
     and specialized functions for this task.
 
+* "XMonad.Util.PositionStore":
+    A utility module to store information about position and size of a window.
+    See "XMonad.Layout.PositionStoreFloat" for a layout that makes use of this.
+
+* "XMonad.Util.RemoteWindows":
+    This module implements a proper way of finding out whether the window is remote or local.
+
 * "XMonad.Util.Replace":
     Implements a @--replace@ flag outside of core.
 
@@ -880,6 +1185,16 @@ A non complete list with a brief description:
 * "XMonad.Util.Scratchpad":
     Very handy hotkey-launched toggleable floating terminal window.
 
+* "XMonad.Util.SpawnNamedPipe":
+    A module for spawning a pipe whose Handle lives in the Xmonad state.
+
+* "XMonad.Util.SpawnOnce":
+    A module for spawning a command once, and only once. Useful to start status
+    bars and make session settings inside startupHook.
+
+* "XMonad.Util.Stack":
+    Utility functions for manipulating Maybe Stacks.
+
 * "XMonad.Util.StringProp":
     Internal utility functions for storing Strings with the root window.
     Used for global state like IORefs with string keys, but more latency,
@@ -894,10 +1209,21 @@ A non complete list with a brief description:
 * "XMonad.Util.Types":
     Miscellaneous commonly used types.
 
+* "XMonad.Util.Ungrab":
+    Release xmonad's keyboard and pointer grabs immediately, so
+    screen grabbers and lock utilities, etc. will work. Replaces
+    the short sleep hackaround.
+
 * "XMonad.Util.WindowProperties":
     EDSL for specifying window properties; various utilities related to window
     properties.
 
+* "XMonad.Util.WindowState":
+    Functions for saving per-window data.
+
+* "XMonad.Util.WorkspaceCompare":
+    Functions for examining, comparing, and sorting workspaces.
+
 * "XMonad.Util.XSelection":
     A module for accessing and manipulating X Window's mouse selection (the buffer used in copy and pasting).
     'getSelection' and 'putSelection' are adaptations of Hxsel.hs and Hxput.hs from the XMonad-utils
@@ -932,13 +1258,13 @@ example, you could write:
 
 >    import XMonad
 >
->    main = xmonad $ defaultConfig { keys = myKeys }
+>    main = xmonad $ def { keys = myKeys }
 
 and provide an appropriate definition of @myKeys@, such as:
 
 > myKeys conf@(XConfig {XMonad.modMask = modm}) = M.fromList
->             [ ((modm, xK_F12), xmonadPrompt defaultXPConfig)
->             , ((modm, xK_F3 ), shellPrompt  defaultXPConfig)
+>             [ ((modm, xK_F12), xmonadPrompt def)
+>             , ((modm, xK_F3 ), shellPrompt  def)
 >             ]
 
 This particular definition also requires importing "XMonad.Prompt",
@@ -984,25 +1310,25 @@ For instance, if you have defined some additional key bindings like
 these:
 
 >    myKeys conf@(XConfig {XMonad.modMask = modm}) = M.fromList
->             [ ((modm, xK_F12), xmonadPrompt defaultXPConfig)
->             , ((modm, xK_F3 ), shellPrompt  defaultXPConfig)
+>             [ ((modm, xK_F12), xmonadPrompt def)
+>             , ((modm, xK_F3 ), shellPrompt  def)
 >             ]
 
 then you can create a new key bindings map by joining the default one
 with yours:
 
->    newKeys x  = myKeys x `M.union` keys defaultConfig x
+>    newKeys x  = myKeys x `M.union` keys def x
 
 Finally, you can use @newKeys@ in the 'XMonad.Core.XConfig.keys' field
 of the configuration:
 
->    main = xmonad $ defaultConfig { keys = newKeys }
+>    main = xmonad $ def { keys = newKeys }
 
 Alternatively, the '<+>' operator can be used which in this usage does exactly
 the same as the explicit usage of 'M.union' and propagation of the config
 argument, thanks to appropriate instances in "Data.Monoid".
 
->    main = xmonad $ defaultConfig { keys = myKeys <+> keys defaultConfig }
+>    main = xmonad $ def { keys = myKeys <+> keys def }
 
 All together, your @~\/.xmonad\/xmonad.hs@ would now look like this:
 
@@ -1018,11 +1344,11 @@ All together, your @~\/.xmonad\/xmonad.hs@ would now look like this:
 >    import XMonad.Prompt.XMonad
 >
 >    main :: IO ()
->    main = xmonad $ defaultConfig { keys = myKeys <+> keys defaultConfig }
+>    main = xmonad $ def { keys = myKeys <+> keys def }
 >
 >    myKeys conf@(XConfig {XMonad.modMask = modm}) = M.fromList
->             [ ((modm, xK_F12), xmonadPrompt defaultXPConfig)
->             , ((modm, xK_F3 ), shellPrompt  defaultXPConfig)
+>             [ ((modm, xK_F12), xmonadPrompt def)
+>             , ((modm, xK_F3 ), shellPrompt  def)
 >             ]
 
 There are much simpler ways to accomplish this, however, if you are
@@ -1044,7 +1370,7 @@ For example, suppose you want to get rid of @mod-q@ and @mod-shift-q@
 to define @newKeys@ as a 'Data.Map.difference' between the default
 map and the map of the key bindings you want to remove.  Like so:
 
->    newKeys x = keys defaultConfig x `M.difference` keysToRemove x
+>    newKeys x = keys def x `M.difference` keysToRemove x
 >
 >    keysToRemove :: XConfig Layout ->    M.Map (KeyMask, KeySym) (X ())
 >    keysToRemove x = M.fromList
@@ -1060,7 +1386,7 @@ It is also possible to simply define a list of keys we want to unbind
 and then use 'Data.Map.delete' to remove them. In that case we would
 write something like:
 
->    newKeys x = foldr M.delete (keys defaultConfig x) (keysToRemove x)
+>    newKeys x = foldr M.delete (keys def x) (keysToRemove x)
 >
 >    keysToRemove :: XConfig Layout -> [(KeyMask, KeySym)]
 >    keysToRemove x =
@@ -1081,7 +1407,7 @@ Adding and removing key bindings requires simply combining the steps
 for removing and adding.  Here is an example from
 "XMonad.Config.Arossato":
 
->    defKeys    = keys defaultConfig
+>    defKeys    = keys def
 >    delKeys x  = foldr M.delete           (defKeys x) (toRemove x)
 >    newKeys x  = foldr (uncurry M.insert) (delKeys x) (toAdd    x)
 >    -- remove some of the default key bindings
@@ -1097,8 +1423,8 @@ for removing and adding.  Here is an example from
 >        [(shiftMask .|. modm, k) | k <- [xK_1 .. xK_9]]
 >    -- These are my personal key bindings
 >    toAdd XConfig{modMask = modm} =
->        [ ((modm              , xK_F12   ), xmonadPrompt defaultXPConfig )
->        , ((modm              , xK_F3    ), shellPrompt  defaultXPConfig )
+>        [ ((modm              , xK_F12   ), xmonadPrompt def )
+>        , ((modm              , xK_F3    ), shellPrompt  def )
 >        ] ++
 >        -- Use modm .|. shiftMask .|. controlMask 1-9 instead
 >        [( (m .|. modm, k), windows $ f i)
@@ -1125,9 +1451,9 @@ the window you click on like so:
 >
 >    myMouse x  = [ (0, button4), (\w -> focus w >> kill) ]
 >
->    newMouse x = M.union (mouseBindings defaultConfig x) (M.fromList (myMouse x))
+>    newMouse x = M.union (mouseBindings def x) (M.fromList (myMouse x))
 >
->    main = xmonad $ defaultConfig { ..., mouseBindings = newMouse, ... }
+>    main = xmonad $ def { ..., mouseBindings = newMouse, ... }
 
 Overriding or deleting mouse bindings works similarly.  You can also
 configure mouse bindings much more easily using the
@@ -1174,13 +1500,13 @@ Suppose we want a list with the 'XMonad.Layout.Full',
 
 Then we create the combination of layouts we need:
 
->    mylayoutHook = Full ||| tabbed shrinkText defaultTheme ||| Accordion
+>    mylayoutHook = Full ||| tabbed shrinkText def ||| Accordion
 
 
 Now, all we need to do is change the 'XMonad.Core.layoutHook'
 field of the 'XMonad.Core.XConfig' record, like so:
 
->    main = xmonad $ defaultConfig { layoutHook = mylayoutHook }
+>    main = xmonad $ def { layoutHook = mylayoutHook }
 
 Thanks to the new combinator, we can apply a layout modifier to a
 whole combination of layouts, instead of applying it to each one. For
@@ -1188,11 +1514,11 @@ example, suppose we want to use the
 'XMonad.Layout.NoBorders.noBorders' layout modifier, from the
 "XMonad.Layout.NoBorders" module (which must be imported):
 
->    mylayoutHook = noBorders (Full ||| tabbed shrinkText defaultTheme ||| Accordion)
+>    mylayoutHook = noBorders (Full ||| tabbed shrinkText def ||| Accordion)
 
 If we want only the tabbed layout without borders, then we may write:
 
->    mylayoutHook = Full ||| noBorders (tabbed shrinkText defaultTheme) ||| Accordion
+>    mylayoutHook = Full ||| noBorders (tabbed shrinkText def) ||| Accordion
 
 Our @~\/.xmonad\/xmonad.hs@ will now look like this:
 
@@ -1202,9 +1528,9 @@ Our @~\/.xmonad\/xmonad.hs@ will now look like this:
 >    import XMonad.Layout.Accordion
 >    import XMonad.Layout.NoBorders
 >
->    mylayoutHook = Full ||| noBorders (tabbed shrinkText defaultTheme) ||| Accordion
+>    mylayoutHook = Full ||| noBorders (tabbed shrinkText def) ||| Accordion
 >
->    main = xmonad $ defaultConfig { layoutHook = mylayoutHook }
+>    main = xmonad $ def { layoutHook = mylayoutHook }
 
 That's it!
 
@@ -1256,7 +1582,7 @@ This is another example of 'XMonad.Config.manageHook', taken from
 >                               , resource =? "win"          --> doF (W.shift "doc") -- xpdf
 >                               , resource =? "firefox-bin"  --> doF (W.shift "web")
 >                               ]
->    newManageHook = myManageHook <+> manageHook defaultConfig
+>    newManageHook = myManageHook <+> manageHook def
 
 
 Again we use 'XMonad.ManageHook.composeAll' to compose a list of
@@ -1318,14 +1644,14 @@ Then we create our own 'XMonad.Config.manageHook':
 We can now use the 'XMonad.ManageHook.<+>' combinator to add our
 'XMonad.Config.manageHook' to the default one:
 
->    newManageHook = myManageHook <+> manageHook defaultConfig
+>    newManageHook = myManageHook <+> manageHook def
 
 (Of course, if we wanted to completely replace the default
 'XMonad.Config.manageHook', this step would not be necessary.) Now,
 all we need to do is change the 'XMonad.Core.manageHook' field of the
 'XMonad.Core.XConfig' record, like so:
 
->    main = xmonad defaultConfig { ..., manageHook = newManageHook, ... }
+>    main = xmonad def { ..., manageHook = newManageHook, ... }
 
 And we are done.
 
@@ -1387,7 +1713,7 @@ Then you just need to update the 'XMonad.Core.logHook' field of the
 'XMonad.Core.XConfig' record with one of the provided functions. For
 example:
 
->    main = xmonad defaultConfig { logHook = dynamicLog }
+>    main = xmonad def { logHook = dynamicLog }
 
 More interesting configurations are also possible; see the
 "XMonad.Hooks.DynamicLog" module for more possibilities.

XMonad/Hooks/CurrentWorkspaceOnTop.hs

@@ -33,7 +33,7 @@ import qualified Data.Map as M
 --
 -- > import XMonad.Hooks.CurrentWorkspaceOnTop
 -- >
--- > main = xmonad $ defaultConfig {
+-- > main = xmonad $ def {
 -- >    ...
 -- >    logHook = currentWorkspaceOnTop
 -- >    ...

XMonad/Hooks/DebugEvents.hs

@@ -42,26 +42,12 @@ import           Codec.Binary.UTF8.String
 import           Data.Maybe                                  (fromMaybe)
 import           Data.Monoid
 import           Foreign
-import           Foreign.C.String
 import           Foreign.C.Types
 import           Numeric                                     (showHex)
 import           System.Exit
 import           System.IO
 import           System.Process
-
--- this should move into X11
-foreign import ccall unsafe "XGetAtomName"
-  xGetAtomName :: Display -> Atom -> IO CString
-
-getAtomName     :: Display -> Atom -> IO (Maybe String)
-getAtomName d a =  do
-  n <- xGetAtomName d a
-  if n == nullPtr
-    then return Nothing
-    else do
-      n' <- peekCString n
-      xFree n
-      return $ Just n'
+import           Control.Applicative
 
 -- | Event hook to dump all received events.  You should probably not use this
 --   unconditionally; it will produce massive amounts of output.
@@ -239,6 +225,12 @@ clientMessages =  [("_NET_ACTIVE_WINDOW",("_NET_ACTIVE_WINDOW",32,1))
                   ,("WM_SAVE_YOURSELF"  ,("STRING"            , 8,0))
                   ]
 
+#if __GLASGOW_HASKELL__ < 707
+finiteBitSize :: Bits a => a -> Int
+finiteBitSize x = bitSize x
+#endif
+
+
 -- | Convert a modifier mask into a useful string
 vmask                 :: KeyMask -> KeyMask -> String
 vmask numLockMask msk =  unwords $
@@ -246,7 +238,7 @@ vmask numLockMask msk =  unwords $
                          fst     $
                          foldr vmask' ([],msk) masks
     where
-      masks = map (\m -> (m,show m)) [0..toEnum (bitSize msk - 1)] ++
+      masks = map (\m -> (m,show m)) [0..toEnum (finiteBitSize msk - 1)] ++
               [(numLockMask,"num"  )
               ,(   lockMask,"lock" )
               ,(controlMask,"ctrl" )
@@ -285,6 +277,7 @@ data DecodeState = DecS {value :: Raw           -- unconsumed raw property value
 newtype Decoder a = Decoder (ReaderT Decode (StateT DecodeState X) a)
 #ifndef __HADDOCK__
     deriving (Functor
+             ,Applicative
              ,Monad
              ,MonadIO
              ,MonadState  DecodeState

XMonad/Hooks/DebugKeyEvents.hs

@@ -1,3 +1,4 @@
+{-# LANGUAGE CPP #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module       : XMonad.Hooks.DebugKeyEvents
@@ -91,7 +92,11 @@ vmask numLockMask msk =  intercalate " " $
                          fst $
                          foldr vmask' ([],msk) masks
     where
-      masks = map (\m -> (m,show m)) [0..toEnum (bitSize msk - 1)] ++
+
+#if __GLASGOW_HASKELL__ < 707
+      finiteBitSize x = bitSize x
+#endif
+      masks = map (\m -> (m,show m)) [0..toEnum (finiteBitSize msk - 1)] ++
               [(numLockMask,"num"  )
               ,(   lockMask,"lock" )
               ,(controlMask,"ctrl" )

XMonad/Hooks/DebugStack.hs

@@ -1,26 +1,30 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  XMonad.Hooks.DebugStack
--- Copyright   :  (c) Brandon S Allbery KF8NH, 2012
+-- Copyright   :  (c) Brandon S Allbery KF8NH, 2014
 -- License     :  BSD3-style (see LICENSE)
 --
 -- Maintainer  :  allbery.b@gmail.com
 -- Stability   :  unstable
 -- Portability :  not portable
 --
--- Dump the state of the 'StackSet'.  A @logHook@ and @handleEventHook@ are
+-- Dump the state of the 'StackSet'. A @logHook@ and @handleEventHook@ are
 -- also provided.
 --
 -----------------------------------------------------------------------------
 
 module XMonad.Hooks.DebugStack (debugStack
+                               ,debugStackFull
                                ,debugStackString
+                               ,debugStackFullString
                                ,debugStackLogHook
+                               ,debugStackFullLogHook
                                ,debugStackEventHook
+                               ,debugStackFullEventHook
                                ) where
 
 import           XMonad.Core
-import qualified XMonad.StackSet         as W
+import qualified XMonad.StackSet                                       as W
 
 import           XMonad.Util.DebugWindow
 
@@ -28,66 +32,79 @@ import           Graphics.X11.Types                  (Window)
 import           Graphics.X11.Xlib.Extras            (Event)
 
 import           Control.Monad                       (foldM)
-import           Data.Map                            (toList)
+import           Data.Map                            (member)
 import           Data.Monoid                         (All(..))
+import           Data.List                           (intercalate)
 
--- | Print the state of the current window stack to @stderr@, which for most
---   installations goes to @~/.xsession-errors@.  "XMonad.Util.DebugWindow"
---   is used to display the individual windows.
+-- | Print the state of the current window stack for the current workspace to
+--   @stderr@, which for most installations goes to @~/.xsession-errors@.
+--   "XMonad.Util.DebugWindow" is used to display the individual windows.
 debugStack :: X ()
 debugStack =  debugStackString >>= trace
 
--- | The above packaged as a 'logHook'.  (Currently this is identical.)
+-- | Print the state of the current window stack for all workspaces to
+--   @stderr@, which for most installations goes to @~/.xsession-errors@.
+--   "XMonad.Util.DebugWindow" is used to display the individual windows.
+debugStackFull :: X ()
+debugStackFull =  debugStackFullString >>= trace
+
+-- | 'debugStack' packaged as a 'logHook'. (Currently this is identical.)
 debugStackLogHook :: X ()
 debugStackLogHook =  debugStack
 
--- | The above packaged as a 'handleEventHook'.  You almost certainly do not
+-- | 'debugStackFull packaged as a 'logHook'. (Currently this is identical.)
+debugStackFullLogHook :: X ()
+debugStackFullLogHook =  debugStackFull
+
+-- | 'debugStack' packaged as a 'handleEventHook'. You almost certainly do not
 --   want to use this unconditionally, as it will cause massive amounts of
 --   output and possibly slow @xmonad@ down severely.
 
 debugStackEventHook   :: Event -> X All
 debugStackEventHook _ =  debugStack >> return (All True)
 
--- | Dump the state of the current 'StackSet' as a multiline 'String'.
---   @
---   stack [    mm
---         ,(*) ww
---         ,    ww
---         ]
---   float {    ww
---         ,    ww
---         }
---   @
---
--- One thing I'm not sure of is where the zipper is when focus is on a
--- floating window.
-debugStackString :: X String
-debugStackString =  withWindowSet $ \ws -> do
-                      s <- emit "stack" ("[","]") (W.peek ws)                    $ W.index    ws
-                      f <- emit "float" ("{","}") (W.peek ws) $ map fst $ toList $ W.floating ws
-                      return $ s ++ f
-  where
-    emit :: String -> (String,String) -> Maybe Window -> [Window] -> X String
-    emit title (lb,rb) _       [] = return $ title ++ " " ++ lb ++ rb ++ "]\n"
-    emit title (lb,rb) focused ws = do
-      (_,_,_,_,ss) <- foldM emit' (title,lb,rb,focused,"") ws
-      return $ ss                               ++
-               replicate (length title + 1) ' ' ++
-               rb                               ++
-               "\n"
+-- | 'debugStackFull' packaged as a 'handleEventHook'. You almost certainly do
+--   not want to use this unconditionally, as it will cause massive amounts of
+--   output and possibly slow @xmonad@ down severely.
 
-    emit' :: (String,String,String,Maybe Window,String)
+debugStackFullEventHook   :: Event -> X All
+debugStackFullEventHook _ =  debugStackFull >> return (All True)
+
+-- | Dump the state of the current workspace in the 'StackSet' as a multiline 'String'.
+debugStackString :: X String
+debugStackString =  withWindowSet $ debugStackWs . W.workspace . W.current
+
+-- | Dump the state of all workspaces in the 'StackSet' as a multiline 'String'.
+-- @@@ this is in stackset order, which is roughly lru-ish
+debugStackFullString :: X String
+debugStackFullString =  withWindowSet $ fmap (intercalate "\n") . mapM debugStackWs . W.workspaces
+
+-- | Dump the state of a workspace in the current 'StackSet' as a multiline 'String'.
+--   @
+--   Workspace "foo::
+--     mm
+--   * ww
+--    ^ww
+--   @
+--   * indicates the focused window, ^ indicates a floating window
+debugStackWs   :: W.Workspace String (Layout Window) Window -> X String
+debugStackWs w =  withWindowSet $ \ws -> do
+  let cur = if wt == W.currentTag ws then " (current)" else ""
+      wt  = W.tag w
+  s <- emit ws $ W.integrate' . W.stack $ w
+  return $ intercalate "\n" $ ("Workspace " ++ show wt ++ cur):s
+  where
+    emit       :: WindowSet -> [Window] -> X [String]
+    emit _  [] =  return ["    -empty workspace-"]
+    emit ww ws = do
+      (_,ss) <- foldM emit' (ww,[]) ws
+      return ss
+
+    emit' :: (WindowSet,[String])
           -> Window
-          -> X (String,String,String,Maybe Window,String)
-    emit' (t,l,r,f,a) w = do
-      w' <- emit'' f w
-      return (replicate (length t) ' '
-             ,',' : replicate (length l - 1) ' '
-             ,r
-             ,f
-             ,a ++ t ++ " " ++ l ++ w' ++ "\n"
-             )
-    emit'' :: Maybe Window -> Window -> X String
-    emit'' focus win =
-      let fi f = if win == f then "(*) " else "    "
-       in (maybe "    " fi focus ++) `fmap` debugWindow win
+          -> X (WindowSet,[String])
+    emit' (ws,a) w' = do
+      let focus = if Just w' == W.peek ws then '*' else ' '
+          float = if w' `member` W.floating ws then '^' else ' '
+      s <- debugWindow w'
+      return (ws,(focus:float:s):a)

XMonad/Hooks/DynamicBars.hs

@@ -1,3 +1,4 @@
+{-# LANGUAGE DeriveDataTypeable #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  XMonad.Hooks.DynamicBars
@@ -17,21 +18,25 @@ module XMonad.Hooks.DynamicBars (
   -- $usage
     DynamicStatusBar
   , DynamicStatusBarCleanup
+  , DynamicStatusBarPartialCleanup
   , dynStatusBarStartup
+  , dynStatusBarStartup'
   , dynStatusBarEventHook
+  , dynStatusBarEventHook'
   , multiPP
+  , multiPPFormat
   ) where
 
 import Prelude
 
-import Control.Concurrent.MVar
 import Control.Monad
 import Control.Monad.Trans (lift)
 import Control.Monad.Writer (WriterT, execWriterT, tell)
 
+import Data.List
 import Data.Maybe
 import Data.Monoid
-import Data.Traversable (traverse)
+import Data.Foldable (traverse_)
 
 import Graphics.X11.Xinerama
 import Graphics.X11.Xlib
@@ -39,24 +44,39 @@ import Graphics.X11.Xlib.Extras
 import Graphics.X11.Xrandr
 
 import System.IO
-import System.IO.Unsafe
 
 import XMonad
 import qualified XMonad.StackSet as W
 import XMonad.Hooks.DynamicLog
+import qualified XMonad.Util.ExtensibleState as XS
 
 -- $usage
 -- Provides a few helper functions to manage per-screen status bars while
 -- dynamically responding to screen changes. A startup action, event hook, and
 -- a way to separate PP styles based on the screen's focus are provided:
 --
--- * The 'dynStatusBarStartup' hook which initializes the status bars.
+-- * The 'dynStatusBarStartup' hook which initializes the status bars. The
+-- first argument is an `ScreenId -> IO Handle` which spawns a status bar on the
+-- given screen and returns the pipe which the string should be written to.
+-- The second argument is a `IO ()` to shut down all status bars. This should
+-- be placed in your `startupHook`.
 --
 -- * The 'dynStatusBarEventHook' hook which respawns status bars when the
--- number of screens changes.
+-- number of screens changes. The arguments are the same as for the
+-- `dynStatusBarStartup` function. This should be placed in your
+-- `handleEventHook`.
+--
+-- * Each of the above functions have an alternate form
+-- (`dynStatusBarStartup'` and `dynStatusBarEventHook'`) which use a cleanup
+-- function which takes an additional `ScreenId` argument which allows for
+-- more fine-grained control for shutting down a specific screen's status bar.
 --
 -- * The 'multiPP' function which allows for different output based on whether
--- the screen for the status bar has focus.
+-- the screen for the status bar has focus (the first argument) or not (the
+-- second argument). This is for use in your `logHook`.
+--
+-- * The 'multiPPFormat' function is the same as the 'multiPP' function, but it
+-- also takes in a function that can customize the output to status bars.
 --
 -- The hooks take a 'DynamicStatusBar' function which is given the id of the
 -- screen to start up and returns the 'Handle' to the pipe to write to. The
@@ -65,39 +85,67 @@ import XMonad.Hooks.DynamicLog
 --
 
 data DynStatusBarInfo = DynStatusBarInfo
-  { dsbInfoScreens :: [ScreenId]
-  , dsbInfoHandles :: [Handle]
-  }
+  { dsbInfo :: [(ScreenId, Handle)]
+  } deriving (Typeable)
+
+instance ExtensionClass DynStatusBarInfo where
+  initialValue = DynStatusBarInfo []
 
 type DynamicStatusBar = ScreenId -> IO Handle
 type DynamicStatusBarCleanup = IO ()
+type DynamicStatusBarPartialCleanup = ScreenId -> IO ()
 
--- Global state
-statusBarInfo :: MVar DynStatusBarInfo
-statusBarInfo = unsafePerformIO $ newMVar (DynStatusBarInfo [] [])
+dynStatusBarSetup :: X ()
+dynStatusBarSetup = do
+  dpy <- asks display
+  root <- asks theRoot
+  io $ xrrSelectInput dpy root rrScreenChangeNotifyMask
 
 dynStatusBarStartup :: DynamicStatusBar -> DynamicStatusBarCleanup -> X ()
-dynStatusBarStartup sb cleanup = liftIO $ do
-  dpy <- openDisplay ""
-  xrrSelectInput dpy (defaultRootWindow dpy) rrScreenChangeNotifyMask
-  closeDisplay dpy
+dynStatusBarStartup sb cleanup = do
+  dynStatusBarSetup
   updateStatusBars sb cleanup
 
-dynStatusBarEventHook :: DynamicStatusBar -> DynamicStatusBarCleanup -> Event -> X All
-dynStatusBarEventHook sb cleanup (RRScreenChangeNotifyEvent {}) = liftIO (updateStatusBars sb cleanup) >> return (All True)
-dynStatusBarEventHook _  _       _                              = return (All True)
+dynStatusBarStartup' :: DynamicStatusBar -> DynamicStatusBarPartialCleanup -> X ()
+dynStatusBarStartup' sb cleanup = do
+  dynStatusBarSetup
+  updateStatusBars' sb cleanup
 
-updateStatusBars :: DynamicStatusBar -> DynamicStatusBarCleanup -> IO ()
-updateStatusBars sb cleanup = liftIO $ do
-  dsbInfo <- takeMVar statusBarInfo
+dynStatusBarEventHook :: DynamicStatusBar -> DynamicStatusBarCleanup -> Event -> X All
+dynStatusBarEventHook sb cleanup = dynStatusBarRun (updateStatusBars sb cleanup)
+
+dynStatusBarEventHook' :: DynamicStatusBar -> DynamicStatusBarPartialCleanup -> Event -> X All
+dynStatusBarEventHook' sb cleanup = dynStatusBarRun (updateStatusBars' sb cleanup)
+
+dynStatusBarRun :: X () -> Event -> X All
+dynStatusBarRun action (RRScreenChangeNotifyEvent {}) = action >> return (All True)
+dynStatusBarRun _      _                              = return (All True)
+
+updateStatusBars :: DynamicStatusBar -> DynamicStatusBarCleanup -> X ()
+updateStatusBars sb cleanup = do
+  (dsbInfoScreens, dsbInfoHandles) <- XS.get >>= return . unzip . dsbInfo
   screens <- getScreens
-  if (screens /= (dsbInfoScreens dsbInfo))
-    then do
-      mapM hClose (dsbInfoHandles dsbInfo)
-      cleanup
-      newHandles <- mapM sb screens
-      putMVar statusBarInfo (DynStatusBarInfo screens newHandles)
-    else putMVar statusBarInfo dsbInfo
+  when (screens /= dsbInfoScreens) $ do
+      newHandles <- liftIO $ do
+          hClose `mapM_` dsbInfoHandles
+          cleanup
+          mapM sb screens
+      XS.put $ DynStatusBarInfo (zip screens newHandles)
+
+updateStatusBars' :: DynamicStatusBar -> DynamicStatusBarPartialCleanup -> X ()
+updateStatusBars' sb cleanup = do
+  (dsbInfoScreens, dsbInfoHandles) <- XS.get >>= return . unzip . dsbInfo
+  screens <- getScreens
+  when (screens /= dsbInfoScreens) $ do
+      let oldInfo = zip dsbInfoScreens dsbInfoHandles
+      let (infoToKeep, infoToClose) = partition (flip elem screens . fst) oldInfo
+      newInfo <- liftIO $ do
+          mapM_ hClose $ map snd infoToClose
+          mapM_ cleanup $ map fst infoToClose
+          let newScreens = screens \\ dsbInfoScreens
+          newHandles <- mapM sb newScreens
+          return $ zip newScreens newHandles
+      XS.put . DynStatusBarInfo $ infoToKeep ++ newInfo
 
 -----------------------------------------------------------------------------
 -- The following code is from adamvo's xmonad.hs file.
@@ -106,9 +154,12 @@ updateStatusBars sb cleanup = liftIO $ do
 multiPP :: PP -- ^ The PP to use if the screen is focused
         -> PP -- ^ The PP to use otherwise
         -> X ()
-multiPP focusPP unfocusPP = do
-  dsbInfo <- liftIO $ readMVar statusBarInfo
-  multiPP' dynamicLogString focusPP unfocusPP (dsbInfoHandles dsbInfo)
+multiPP = multiPPFormat dynamicLogString
+
+multiPPFormat :: (PP -> X String) -> PP -> PP -> X ()
+multiPPFormat dynlStr focusPP unfocusPP = do
+  (_, dsbInfoHandles) <- XS.get >>= return . unzip . dsbInfo
+  multiPP' dynlStr focusPP unfocusPP dsbInfoHandles
 
 multiPP' :: (PP -> X String) -> PP -> PP -> [Handle] -> X ()
 multiPP' dynlStr focusPP unfocusPP handles = do
@@ -120,13 +171,12 @@ multiPP' dynlStr focusPP unfocusPP handles = do
         out <- lift $ dynlStr $ if isFoc then focusPP else unfocusPP
         when isFoc $ get >>= tell . Last . Just
         return out
-  traverse put . getLast
+  traverse_ put . getLast
     =<< execWriterT . (io . zipWithM_ hPutStrLn handles <=< mapM pickPP) . catMaybes
     =<< mapM screenWorkspace (zipWith const [0 .. ] handles)
-  return ()
 
-getScreens :: IO [ScreenId]
-getScreens = do
+getScreens :: MonadIO m => m [ScreenId]
+getScreens = liftIO $ do
   screens <- do
     dpy <- openDisplay ""
     rects <- getScreenInfo dpy

XMonad/Hooks/DynamicLog.hs

@@ -1,4 +1,4 @@
-{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleContexts, PatternGuards #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -24,6 +24,7 @@ module XMonad.Hooks.DynamicLog (
 
     -- * Drop-in loggers
     dzen,
+    dzenWithFlags,
     xmobar,
     statusBar,
     dynamicLog,
@@ -35,14 +36,15 @@ module XMonad.Hooks.DynamicLog (
     -- * Build your own formatter
     dynamicLogWithPP,
     dynamicLogString,
-    PP(..), defaultPP,
+    PP(..), defaultPP, def,
 
     -- * Example formatters
     dzenPP, xmobarPP, sjanssenPP, byorgeyPP,
 
     -- * Formatting utilities
     wrap, pad, trim, shorten,
-    xmobarColor, xmobarStrip,
+    xmobarColor, xmobarAction, xmobarRaw,
+    xmobarStrip, xmobarStripTags,
     dzenColor, dzenEscape, dzenStrip,
 
     -- * Internal formatting functions
@@ -57,10 +59,10 @@ module XMonad.Hooks.DynamicLog (
 -- Useful imports
 
 import Codec.Binary.UTF8.String (encodeString)
-import Control.Monad (liftM2)
+import Control.Monad (liftM2, msum)
 import Data.Char ( isSpace, ord )
-import Data.List (intersperse, isPrefixOf, sortBy)
-import Data.Maybe ( isJust, catMaybes )
+import Data.List (intersperse, stripPrefix, isPrefixOf, sortBy)
+import Data.Maybe ( isJust, catMaybes, mapMaybe, fromMaybe )
 import Data.Ord ( comparing )
 import qualified Data.Map as M
 import qualified XMonad.StackSet as S
@@ -88,7 +90,7 @@ import XMonad.Hooks.ManageDocks
 --
 -- > main = xmonad =<< xmobar myConfig
 -- >
--- > myConfig = defaultConfig { ... }
+-- > myConfig = def { ... }
 --
 -- There is also 'statusBar' if you'd like to use another status bar, or would
 -- like to use different formatting options.  The 'xmobar', 'dzen', and
@@ -99,7 +101,7 @@ import XMonad.Hooks.ManageDocks
 -- ('dynamicLog' or 'dynamicLogXinerama') by simply setting your logHook to the
 -- appropriate function, for instance:
 --
--- > main = xmonad $ defaultConfig {
+-- > main = xmonad $ def {
 -- >    ...
 -- >    logHook = dynamicLog
 -- >    ...
@@ -124,9 +126,9 @@ import XMonad.Hooks.ManageDocks
 -- >
 -- > main = do
 -- >     h <- spawnPipe "xmobar -options -foo -bar"
--- >     xmonad $ defaultConfig {
+-- >     xmonad $ def {
 -- >       ...
--- >       logHook = dynamicLogWithPP $ defaultPP { ppOutput = hPutStrLn h }
+-- >       logHook = dynamicLogWithPP $ def { ppOutput = hPutStrLn h }
 --
 -- If you use @spawnPipe@, be sure to redefine the 'ppOutput' field of
 -- your pretty-printer as in the example above; by default the status
@@ -149,14 +151,17 @@ import XMonad.Hooks.ManageDocks
 
 ------------------------------------------------------------------------
 
--- | Run xmonad with a dzen status bar set to some nice defaults.
+-- | Run xmonad with a dzen status bar with specified dzen
+--   command line arguments.
 --
--- > main = xmonad =<< dzen myConfig
+-- > main = xmonad =<< dzenWithFlags flags myConfig
 -- >
--- > myConfig = defaultConfig { ... }
+-- > myConfig = def { ... }
+-- >
+-- > flags = "-e onstart lower -w 800 -h 24 -ta l -fg #a8a3f7 -bg #3f3c6d"
 --
--- The intent is that the above config file should provide a nice
--- status bar with minimal effort.
+-- This function can be used to customize the arguments passed to dzen2.
+-- e.g changing the default width and height of dzen2.
 --
 -- If you wish to customize the status bar format at all, you'll have to
 -- use the 'statusBar' function instead.
@@ -165,9 +170,30 @@ import XMonad.Hooks.ManageDocks
 -- handle screen placement for dzen, and enables 'mod-b' for toggling
 -- the menu bar.
 --
+-- You should use this function only when the default 'dzen' function does not
+-- serve your purpose.
+--
+dzenWithFlags :: LayoutClass l Window
+    => String -> XConfig l -> IO (XConfig (ModifiedLayout AvoidStruts l))
+dzenWithFlags flags conf = statusBar ("dzen2 " ++ flags) dzenPP toggleStrutsKey conf
+
+-- | Run xmonad with a dzen status bar set to some nice defaults.
+--
+-- > main = xmonad =<< dzen myConfig
+-- >
+-- > myConfig = def { ... }
+--
+-- The intent is that the above config file should provide a nice
+-- status bar with minimal effort.
+--
+-- The binding uses the XMonad.Hooks.ManageDocks module to automatically
+-- handle screen placement for dzen, and enables 'mod-b' for toggling
+-- the menu bar. Please refer to 'dzenWithFlags' function for further
+-- documentation.
+--
 dzen :: LayoutClass l Window
      => XConfig l -> IO (XConfig (ModifiedLayout AvoidStruts l))
-dzen conf = statusBar ("dzen2 " ++ flags) dzenPP toggleStrutsKey conf
+dzen conf = dzenWithFlags flags conf
  where
     fg      = "'#a8a3f7'" -- n.b quoting
     bg      = "'#3f3c6d'"
@@ -178,7 +204,7 @@ dzen conf = statusBar ("dzen2 " ++ flags) dzenPP toggleStrutsKey conf
 --
 -- > main = xmonad =<< xmobar myConfig
 -- >
--- > myConfig = defaultConfig { ... }
+-- > myConfig = def { ... }
 --
 -- This works pretty much the same as 'dzen' function above.
 --
@@ -198,12 +224,11 @@ statusBar :: LayoutClass l Window
           -> IO (XConfig (ModifiedLayout AvoidStruts l))
 statusBar cmd pp k conf = do
     h <- spawnPipe cmd
-    return $ conf
+    return $ docks $ conf
         { layoutHook = avoidStruts (layoutHook conf)
         , logHook = do
                         logHook conf
                         dynamicLogWithPP pp { ppOutput = hPutStrLn h }
-        , manageHook = manageHook conf <+> manageDocks
         , keys       = liftM2 M.union keys' (keys conf)
         }
  where
@@ -246,7 +271,7 @@ toggleStrutsKey XConfig{modMask = modm} = (modm, xK_b )
 -- To customize the output format, see 'dynamicLogWithPP'.
 --
 dynamicLog :: X ()
-dynamicLog = dynamicLogWithPP defaultPP
+dynamicLog = dynamicLogWithPP def
 
 -- | Format the current status using the supplied pretty-printing format,
 --   and write it to stdout.
@@ -279,7 +304,7 @@ dynamicLogString pp = do
     return $ encodeString . sepBy (ppSep pp) . ppOrder pp $
                         [ ws
                         , ppLayout pp ld
-                        , ppTitle  pp wt
+                        , ppTitle  pp $ ppTitleSanitize pp wt
                         ]
                         ++ catMaybes extras
 
@@ -295,7 +320,8 @@ pprWindowSet sort' urgents pp s = sepBy (ppWsSep pp) . map fmt . sort' $
          fmt w = printer pp (S.tag w)
           where printer | any (\x -> maybe False (== S.tag w) (S.findTag x s)) urgents  = ppUrgent
                         | S.tag w == this                                               = ppCurrent
-                        | S.tag w `elem` visibles                                       = ppVisible
+                        | S.tag w `elem` visibles && isJust (S.stack w)                 = ppVisible
+                        | S.tag w `elem` visibles                                       = liftM2 fromMaybe ppVisible ppVisibleNoWindows
                         | isJust (S.stack w)                                            = ppHidden
                         | otherwise                                                     = ppHiddenNoWindows
 
@@ -312,10 +338,10 @@ pprWindowSet sort' urgents pp s = sepBy (ppWsSep pp) . map fmt . sort' $
 -- using 'dynamicLogWithPP' by setting 'ppSort' to /getSortByXineramaRule/ from
 -- "XMonad.Util.WorkspaceCompare".  For example,
 --
--- > defaultPP { ppCurrent = dzenColor "red" "#efebe7"
--- >           , ppVisible = wrap "[" "]"
--- >           , ppSort    = getSortByXineramaRule
--- >           }
+-- > def { ppCurrent = dzenColor "red" "#efebe7"
+-- >     , ppVisible = wrap "[" "]"
+-- >     , ppSort    = getSortByXineramaRule
+-- >     }
 dynamicLogXinerama :: X ()
 dynamicLogXinerama = withWindowSet $ io . putStrLn . pprWindowSetXinerama
 
@@ -392,18 +418,60 @@ xmobarColor :: String  -- ^ foreground color: a color name, or #rrggbb format
 xmobarColor fg bg = wrap t "</fc>"
  where t = concat ["<fc=", fg, if null bg then "" else "," ++ bg, ">"]
 
+-- | Encapsulate text with an action. The text will be displayed, and the
+-- action executed when the displayed text is clicked. Illegal input is not
+-- filtered, allowing xmobar to display any parse errors. Uses xmobar's new
+-- syntax wherein the command is surrounded by backticks.
+xmobarAction :: String
+                -- ^ Command. Use of backticks (`) will cause a parse error.
+             -> String
+                -- ^ Buttons 1-5, such as "145". Other characters will cause a
+                -- parse error.
+             -> String
+                -- ^ Displayed/wrapped text.
+             -> String
+xmobarAction command button = wrap l r
+    where
+        l = "<action=`" ++ command ++ "` button=" ++ button ++ ">"
+        r = "</action>"
+
+-- | Encapsulate arbitrary text for display only, i.e. untrusted content if
+-- wrapped (perhaps from window titles) will be displayed only, with all tags
+-- ignored. Introduced in xmobar 0.21; see their documentation. Be careful not
+-- to shorten the result.
+xmobarRaw :: String -> String
+xmobarRaw "" = ""
+xmobarRaw s  = concat ["<raw=", show $ length s, ":", s, "/>"]
+
 -- ??? add an xmobarEscape function?
 
--- | Strip xmobar markup.
+-- | Strip xmobar markup, specifically the <fc>, <icon> and <action> tags and
+-- the matching tags like </fc>.
 xmobarStrip :: String -> String
-xmobarStrip = strip [] where
+xmobarStrip = converge (xmobarStripTags ["fc","icon","action"]) where
+
+converge :: (Eq a) => (a -> a) -> a -> a
+converge f a = let xs = iterate f a
+    in fst $ head $ dropWhile (uncurry (/=)) $ zip xs $ tail xs
+
+xmobarStripTags :: [String] -- ^ tags
+        -> String -> String -- ^ with all <tag>...</tag> removed
+xmobarStripTags tags = strip [] where
+    strip keep [] = keep
     strip keep x
-      | null x                 = keep
-      | "<fc="  `isPrefixOf` x = strip keep (drop 1 . dropWhile (/= '>') $ x)
-      | "</fc>" `isPrefixOf` x = strip keep (drop 5  x)
-      | '<' == head x          = strip (keep ++ "<") (tail x)
-      | otherwise              = let (good,x') = span (/= '<') x
-                                 in strip (keep ++ good) x'
+        | rest: _ <- mapMaybe dropTag tags = strip keep rest
+
+
+        | '<':xs <- x = strip (keep ++ "<") xs
+        | (good,x') <- span (/= '<') x = strip (keep ++ good) x' -- this is n^2 bad... but titles have few tags
+      where dropTag :: String -> Maybe String
+            dropTag tag = msum [fmap dropTilClose (openTag tag `stripPrefix` x),
+                                                   closeTag tag `stripPrefix` x]
+
+    dropTilClose, openTag, closeTag :: String -> String
+    dropTilClose = drop 1 . dropWhile (/= '>')
+    openTag str = "<" ++ str ++ "="
+    closeTag str = "</" ++ str ++ ">"
 
 -- | The 'PP' type allows the user to customize the formatting of
 --   status information.
@@ -418,6 +486,8 @@ data PP = PP { ppCurrent :: WorkspaceId -> String
                -- contain windows
              , ppHiddenNoWindows :: WorkspaceId -> String
                -- ^ how to print tags of empty hidden workspaces
+             , ppVisibleNoWindows :: Maybe (WorkspaceId -> String)
+               -- ^ how to print tags of empty visible workspaces
              , ppUrgent :: WorkspaceId -> String
                -- ^ format to be applied to tags of urgent workspaces.
              , ppSep :: String
@@ -427,6 +497,8 @@ data PP = PP { ppCurrent :: WorkspaceId -> String
                -- ^ separator to use between workspace tags
              , ppTitle :: String -> String
                -- ^ window title format
+             , ppTitleSanitize :: String -> String
+              -- ^  escape / sanitizes input to 'ppTitle'
              , ppLayout :: String -> String
                -- ^ layout name format
              , ppOrder :: [String] -> [String]
@@ -459,15 +531,21 @@ data PP = PP { ppCurrent :: WorkspaceId -> String
              }
 
 -- | The default pretty printing options, as seen in 'dynamicLog'.
+{-# DEPRECATED defaultPP "Use def (from Data.Default, and re-exported by XMonad.Hooks.DynamicLog) instead." #-}
 defaultPP :: PP
-defaultPP = PP { ppCurrent         = wrap "[" "]"
+defaultPP = def
+
+instance Default PP where
+    def   = PP { ppCurrent         = wrap "[" "]"
                , ppVisible         = wrap "<" ">"
                , ppHidden          = id
                , ppHiddenNoWindows = const ""
+               , ppVisibleNoWindows= Nothing
                , ppUrgent          = id
                , ppSep             = " : "
                , ppWsSep           = " "
                , ppTitle           = shorten 80
+               , ppTitleSanitize   = xmobarStrip . dzenEscape
                , ppLayout          = id
                , ppOrder           = id
                , ppOutput          = putStrLn
@@ -477,7 +555,7 @@ defaultPP = PP { ppCurrent         = wrap "[" "]"
 
 -- | Settings to emulate dwm's statusbar, dzen only.
 dzenPP :: PP
-dzenPP = defaultPP { ppCurrent  = dzenColor "white" "#2b4f98" . pad
+dzenPP = def { ppCurrent  = dzenColor "white" "#2b4f98" . pad
                    , ppVisible  = dzenColor "black" "#999999" . pad
                    , ppHidden   = dzenColor "black" "#cccccc" . pad
                    , ppHiddenNoWindows = const ""
@@ -496,7 +574,7 @@ dzenPP = defaultPP { ppCurrent  = dzenColor "white" "#2b4f98" . pad
 
 -- | Some nice xmobar defaults.
 xmobarPP :: PP
-xmobarPP = defaultPP { ppCurrent = xmobarColor "yellow" "" . wrap "[" "]"
+xmobarPP = def { ppCurrent = xmobarColor "yellow" "" . wrap "[" "]"
                      , ppTitle   = xmobarColor "green"  "" . shorten 40
                      , ppVisible = wrap "(" ")"
                      , ppUrgent  = xmobarColor "red" "yellow"
@@ -504,23 +582,23 @@ xmobarPP = defaultPP { ppCurrent = xmobarColor "yellow" "" . wrap "[" "]"
 
 -- | The options that sjanssen likes to use with xmobar, as an
 -- example.  Note the use of 'xmobarColor' and the record update on
--- 'defaultPP'.
+-- 'def'.
 sjanssenPP :: PP
-sjanssenPP = defaultPP { ppCurrent = xmobarColor "white" "black"
-                       , ppTitle = xmobarColor "#00ee00" "" . shorten 120
-                       }
+sjanssenPP = def { ppCurrent = xmobarColor "white" "black"
+                 , ppTitle = xmobarColor "#00ee00" "" . shorten 120
+                 }
 
 -- | The options that byorgey likes to use with dzen, as another example.
 byorgeyPP :: PP
-byorgeyPP = defaultPP { ppHiddenNoWindows = showNamedWorkspaces
-                      , ppHidden  = dzenColor "black"  "#a8a3f7" . pad
-                      , ppCurrent = dzenColor "yellow" "#a8a3f7" . pad
-                      , ppUrgent  = dzenColor "red"    "yellow"  . pad
-                      , ppSep     = " | "
-                      , ppWsSep   = ""
-                      , ppTitle   = shorten 70
-                      , ppOrder   = reverse
-                      }
+byorgeyPP = def { ppHiddenNoWindows = showNamedWorkspaces
+                , ppHidden  = dzenColor "black"  "#a8a3f7" . pad
+                , ppCurrent = dzenColor "yellow" "#a8a3f7" . pad
+                , ppUrgent  = dzenColor "red"    "yellow"  . pad
+                , ppSep     = " | "
+                , ppWsSep   = ""
+                , ppTitle   = shorten 70
+                , ppOrder   = reverse
+                }
   where showNamedWorkspaces wsId = if any (`elem` wsId) ['a'..'z']
                                        then pad wsId
                                        else ""

XMonad/Hooks/DynamicProperty.hs

@@ -0,0 +1,71 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  XMonad.Hooks.DynamicProperty
+-- Copyright   :  (c) Brandon S Allbery, 2015
+-- License     :  BSD3-style (see LICENSE)
+--
+-- Maintainer  :  allbery.b@gmail.com
+-- Stability   :  unstable
+-- Portability :  not portable
+--
+-- Module to apply a ManageHook to an already-mapped window when a property
+-- changes. This would commonly be used to match browser windows by title,
+-- since the final title will only be set after (a) the window is mapped,
+-- (b) its document has been loaded, (c) all load-time scripts have run.
+-- (Don't blame browsers for this; it's inherent in HTML and the DOM. And
+-- changing title dynamically is explicitly permitted by ICCCM and EWMH;
+-- you don't really want to have your editor window umapped/remapped to
+-- show the current document and modified state in the titlebar, do you?)
+--
+-- This is a handleEventHook that triggers on a PropertyChange event. It
+-- currently ignores properties being removed, in part because you can't
+-- do anything useful in a ManageHook involving nonexistence of a property.
+--
+-----------------------------------------------------------------------------
+
+module XMonad.Hooks.DynamicProperty where
+
+import XMonad
+import Data.Monoid
+import Control.Applicative
+import Control.Monad (when)
+
+-- |
+-- Run a 'ManageHook' when a specific property is changed on a window. Note
+-- that this will run on any window which changes the property, so you should
+-- be very specific in your 'MansgeHook' matching (lots of windows change
+-- their titles on the fly!):
+--
+-- dynamicPropertyChange "WM_NAME" (className =? "Iceweasel" <&&> title =? "whatever" --> doShift "2")
+-- 
+-- Note that the fixity of (-->) won't allow it to be mixed with ($), so you
+-- can't use the obvious $ shorthand.
+--
+-- > dynamicPropertyChange "WM_NAME" $ title =? "Foo" --> doFloat -- won't work!
+--
+-- Consider instead phrasing it like any
+-- other 'ManageHook':
+--
+-- >      , handleEventHook = dynamicPropertyChange "WM_NAME" myDynHook <+> handleEventHook baseConfig
+-- > 
+-- >    {- ... -}
+-- > 
+-- >    myDynHook = composeAll [...]
+--
+dynamicPropertyChange :: String -> ManageHook -> Event -> X All
+dynamicPropertyChange prop hook PropertyEvent { ev_window = w, ev_atom = a, ev_propstate = ps } = do
+  pa <- getAtom prop
+  when (ps == propertyNewValue && a == pa) $ do
+    g <- appEndo <$> userCodeDef (Endo id) (runQuery hook w)
+    windows g
+  return mempty -- so anything else also processes it
+dynamicPropertyChange _ _ _ = return mempty
+
+-- | A shorthand for the most common case, dynamic titles
+dynamicTitle :: ManageHook -> Event -> X All
+-- strictly, this should also check _NET_WM_NAME. practically, both will
+-- change and each gets its own PropertyEvent, so we'd need to record that
+-- we saw the event for that window and ignore the second one. Instead, just
+-- trust that nobody sets only _NET_WM_NAME. (I'm sure this will prove false,
+-- since there's always someone who can't bother being compliant.)
+dynamicTitle = dynamicPropertyChange "WM_NAME"

XMonad/Hooks/EwmhDesktops.hs

@@ -25,6 +25,7 @@ module XMonad.Hooks.EwmhDesktops (
     ) where
 
 import Codec.Binary.UTF8.String (encode)
+import Control.Applicative((<$>))
 import Data.List
 import Data.Maybe
 import Data.Monoid
@@ -44,10 +45,10 @@ import XMonad.Util.WindowProperties (getProp32)
 -- > import XMonad
 -- > import XMonad.Hooks.EwmhDesktops
 -- >
--- > main = xmonad $ ewmh defaultConfig{ handleEventHook =
--- >            handleEventHook defaultConfig <+> fullscreenEventHook }
+-- > main = xmonad $ ewmh def{ handleEventHook =
+-- >            handleEventHook def <+> fullscreenEventHook }
 --
--- You may also be interested in 'avoidStruts' from "XMonad.Hooks.ManageDocks".
+-- You may also be interested in 'docks' from "XMonad.Hooks.ManageDocks".
 
 
 -- | Add EWMH functionality to the given config.  See above for an example.
@@ -55,7 +56,8 @@ ewmh :: XConfig a -> XConfig a
 ewmh c = c { startupHook     = startupHook c +++ ewmhDesktopsStartup
            , handleEventHook = handleEventHook c +++ ewmhDesktopsEventHook
            , logHook         = logHook c +++ ewmhDesktopsLogHook }
- where x +++ y = mappend x y
+ -- @@@ will fix this correctly later with the rewrite
+ where x +++ y = mappend y x
 
 -- |
 -- Initializes EwmhDesktops and advertises EWMH support to the X
@@ -86,29 +88,19 @@ ewmhDesktopsLogHookCustom f = withWindowSet $ \s -> do
     let wins =  nub . concatMap (maybe [] (\(W.Stack x l r)-> reverse l ++ r ++ [x]) . W.stack) $ ws
     setClientList wins
 
-    -- Current desktop
-    case (elemIndex (W.currentTag s) $ map W.tag ws) of
-      Nothing -> return ()
-      Just curr -> do
-        setCurrentDesktop curr
+    -- Remap the current workspace to handle any renames that f might be doing.
+    let maybeCurrent' = W.tag <$> listToMaybe (f [W.workspace $ W.current s])
+        maybeCurrent  = join (flip elemIndex (map W.tag ws) <$> maybeCurrent')
 
-        -- Per window Desktop
-        -- To make gnome-panel accept our xinerama stuff, we display
-        -- all visible windows on the current desktop.
-        forM_ (W.current s : W.visible s) $ \x ->
-            forM_ (W.integrate' (W.stack (W.workspace x))) $ \win -> do
-                setWindowDesktop win curr
+    fromMaybe (return ()) $ setCurrentDesktop <$> maybeCurrent
 
-    forM_ (W.hidden s) $ \w ->
-        case elemIndex (W.tag w) (map W.tag ws) of
-          Nothing -> return ()
-          Just wn -> forM_ (W.integrate' (W.stack w)) $ \win -> do
-                         setWindowDesktop win wn
+    sequence_ $ zipWith setWorkspaceWindowDesktops [0..] ws
 
     setActiveWindow
 
     return ()
 
+
 -- |
 -- Intercepts messages from pagers and similar applications and reacts on them.
 -- Currently supports:
@@ -229,6 +221,10 @@ setClientList wins = withDisplay $ \dpy -> do
     a' <- getAtom "_NET_CLIENT_LIST_STACKING"
     io $ changeProperty32 dpy r a' c propModeReplace (fmap fromIntegral wins)
 
+setWorkspaceWindowDesktops :: (Integral a) => a -> WindowSpace -> X()
+setWorkspaceWindowDesktops index workspace =
+  mapM_ (flip setWindowDesktop index) (W.integrate' $ W.stack workspace)
+
 setWindowDesktop :: (Integral a) => Window -> a -> X ()
 setWindowDesktop win i = withDisplay $ \dpy -> do
     a <- getAtom "_NET_WM_DESKTOP"

XMonad/Hooks/FadeInactive.hs

@@ -40,7 +40,7 @@ import Control.Monad
 -- > myLogHook = fadeInactiveLogHook fadeAmount
 -- >     where fadeAmount = 0.8
 -- >
--- > main = xmonad defaultConfig { logHook = myLogHook }
+-- > main = xmonad def { logHook = myLogHook }
 --
 -- fadeAmount can be any rational between 0 and 1.
 -- you will need to have xcompmgr <http://freedesktop.org/wiki/Software/xapps>

XMonad/Hooks/FadeWindows.hs

@@ -61,7 +61,8 @@ import           Control.Monad.Reader                    (ask
                                                          ,asks)
 import           Control.Monad.State                     (gets)
 import qualified Data.Map                    as M
-import           Data.Monoid
+import           Data.Monoid                      hiding ((<>))
+import           Data.Semigroup
 
 import           Graphics.X11.Xlib.Extras                (Event(..))
 
@@ -115,7 +116,7 @@ import           Graphics.X11.Xlib.Extras                (Event(..))
 -- a tight loop trying to fade the popup in).  I find it useful to
 -- have a key binding to restart the compositing manager; for example,
 --
--- main = xmonad $ defaultConfig {
+-- main = xmonad $ def {
 --                   {- ... -}
 --                 }
 --                 `additionalKeysP`
@@ -134,6 +135,9 @@ instance Monoid Opacity where
   r      `mappend` OEmpty = r
   _      `mappend` r      = r
 
+instance Semigroup Opacity where
+  (<>) = mappend
+
 -- | A FadeHook is similar to a ManageHook, but records window opacity.
 type FadeHook = Query Opacity
 

XMonad/Hooks/FloatNext.hs

@@ -53,7 +53,7 @@ hookName = "__float"
 --
 -- and adding 'floatNextHook' to your 'ManageHook':
 --
--- > myManageHook = floatNextHook <+> manageHook defaultConfig
+-- > myManageHook = floatNextHook <+> manageHook def
 --
 -- The 'floatNext' and 'toggleFloatNext' functions can be used in key
 -- bindings to float the next spawned window:

XMonad/Hooks/InsertPosition.hs

@@ -31,7 +31,7 @@ import Data.Monoid(Endo(Endo))
 -- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:
 --
 -- > import XMonad.Hooks.InsertPosition
--- > xmonad defaultConfig { manageHook = insertPosition Master Newer <+> myManageHook }
+-- > xmonad def { manageHook = insertPosition Master Newer <+> myManageHook }
 --
 -- You should you put the manageHooks that use 'doShift' to take effect
 -- /before/ 'insertPosition', so that the window order will be consistent.

XMonad/Hooks/ManageDebug.hs

@@ -0,0 +1,100 @@
+{-# LANGUAGE DeriveDataTypeable #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  XMonad.Hooks.ManageDebug
+-- Copyright   :  (c) Brandon S Allbery KF8NH, 2014
+-- License     :  BSD3-style (see LICENSE)
+--
+-- Maintainer  :  allbery.b@gmail.com
+-- Stability   :  unstable
+-- Portability :  not portable
+--
+-- A @manageHook@ and associated @logHook@ for debugging 'ManageHook's.
+-- 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.
+--
+-----------------------------------------------------------------------------
+--
+--
+
+module XMonad.Hooks.ManageDebug (debugManageHook
+                                ,debugManageHookOn
+                                ,manageDebug
+                                ,maybeManageDebug
+                                ,manageDebugLogHook
+                                ,debugNextManagedWindow
+                                ) where
+
+import           XMonad
+import           XMonad.Hooks.DebugStack
+import           XMonad.Util.DebugWindow
+import           XMonad.Util.EZConfig
+import qualified XMonad.Util.ExtensibleState                                                 as XS
+import           Control.Monad                            (when)
+
+-- persistent state for manageHook debugging to trigger logHook debugging
+data ManageStackDebug = MSD (Bool,Bool) deriving Typeable
+instance ExtensionClass ManageStackDebug where
+  initialValue = MSD (False,False)
+
+-- | A combinator to add full 'ManageHook' debugging in a single operation.
+debugManageHook :: XConfig l -> XConfig l
+debugManageHook cf = cf {logHook    = manageDebugLogHook <+> logHook    cf
+                        ,manageHook = manageDebug        <+> manageHook cf
+                        }
+
+-- | A combinator to add triggerable 'ManageHook' debugging in a single operation.
+--   Specify a key sequence as a string in 'XMonad.Util.EZConfig' syntax; press
+--   this key before opening the window to get just that logged.
+debugManageHookOn :: String -> XConfig l -> XConfig l
+debugManageHookOn key cf = cf {logHook    = manageDebugLogHook <+> logHook    cf
+                              ,manageHook = maybeManageDebug   <+> manageHook cf
+                              }
+                           `additionalKeysP`
+                           [(key,debugNextManagedWindow)]
+
+-- | 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',
+manageDebug :: ManageHook
+manageDebug = do
+  w <- ask
+  liftX $ do
+    trace "== manageHook; current stack =="
+    debugStackString >>= trace
+    ws <- debugWindow w
+    trace $ "new:\n  " ++ ws
+    XS.modify $ \(MSD (_,key)) -> MSD (True,key)
+  idHook
+
+-- | @manageDebug@ only if the user requested it with @debugNextManagedWindow@.
+maybeManageDebug :: ManageHook
+maybeManageDebug = do
+  go <- liftX $ do
+    MSD (log_,go') <- XS.get
+    XS.put $ MSD (log_,False)
+    return go'
+  if go then manageDebug else idHook
+
+-- | If @manageDebug@ has set the debug-stack flag, show the stack.
+manageDebugLogHook :: X ()
+manageDebugLogHook = do
+                       MSD (go,key) <- XS.get
+                       when go $ do
+                         trace "== manageHook; final stack =="
+                         debugStackFullString >>= trace
+                         XS.put $ MSD (False,key)
+                       idHook
+
+-- | Request that the next window to be managed be @manageDebug@-ed. This can
+--   be used anywhere an X action can, such as key bindings, mouse bindings
+--   (presumably with 'const'), 'startupHook', etc.
+debugNextManagedWindow :: X ()
+debugNextManagedWindow = XS.modify $ \(MSD (log_,_)) -> MSD (log_,True)

XMonad/Hooks/ManageDocks.hs

@@ -1,5 +1,4 @@
 {-# LANGUAGE DeriveDataTypeable, PatternGuards, FlexibleInstances, MultiParamTypeClasses, CPP #-}
--- deriving Typeable for ghc-6.6 compatibility, which is retained in the core
 -----------------------------------------------------------------------------
 -- |
 -- Module       : XMonad.Hooks.ManageDocks
@@ -16,8 +15,8 @@
 module XMonad.Hooks.ManageDocks (
     -- * Usage
     -- $usage
-    manageDocks, checkDock, AvoidStruts, avoidStruts, avoidStrutsOn,
-    docksEventHook,
+    docks, manageDocks, checkDock, AvoidStruts, avoidStruts, avoidStrutsOn,
+    docksEventHook, docksStartupHook,
     ToggleStruts(..),
     SetStruts(..),
     module XMonad.Util.Types,
@@ -40,34 +39,29 @@ import XMonad.Layout.LayoutModifier
 import XMonad.Util.Types
 import XMonad.Util.WindowProperties (getProp32s)
 import XMonad.Util.XUtils (fi)
-import Data.Monoid (All(..))
+import qualified XMonad.Util.ExtensibleState as XS
+import Data.Monoid (All(..), mempty)
+import Data.Functor((<$>))
 
 import qualified Data.Set as S
+import qualified Data.Map as M
+import Control.Monad (when, forM_, filterM)
 
 -- $usage
 -- To use this module, add the following import to @~\/.xmonad\/xmonad.hs@:
 --
 -- > import XMonad.Hooks.ManageDocks
 --
--- The first component is a 'ManageHook' which recognizes these
--- windows and de-manages them, so that xmonad does not try to tile
--- them.  To enable it:
+-- Wrap your xmonad config with a call to 'docks', like so:
 --
--- > manageHook = ... <+> manageDocks
+-- > main = xmonad $ docks def
 --
--- The second component is a layout modifier that prevents windows
--- from overlapping these dock windows.  It is intended to replace
--- xmonad's so-called \"gap\" support.  First, you must add it to your
--- list of layouts:
+-- Then add 'avoidStruts' or 'avoidStrutsOn' layout modifier to your layout
+-- to prevent windows from overlapping these windows.
 --
 -- > layoutHook = avoidStruts (tall ||| mirror tall ||| ...)
 -- >                   where  tall = Tall 1 (3/100) (1/2)
 --
--- The third component is an event hook that causes new docks to appear
--- immediately, instead of waiting for the next focus change.
---
--- > handleEventHook = ... <+> docksEventHook
---
 -- 'AvoidStruts' also supports toggling the dock gaps; add a keybinding
 -- similar to:
 --
@@ -87,22 +81,44 @@ import qualified Data.Set as S
 --
 -- > layoutHook = avoidStrutsOn [U,L] (tall ||| mirror tall ||| ...)
 --
--- /Important note/: if you are switching from manual gaps
--- (defaultGaps in your config) to avoidStruts (recommended, since
--- manual gaps will probably be phased out soon), be sure to switch
--- off all your gaps (with mod-b) /before/ reloading your config with
--- avoidStruts!  Toggling struts with a 'ToggleStruts' message will
--- not work unless your gaps are set to zero.
---
 -- For detailed instructions on editing your key bindings, see
 -- "XMonad.Doc.Extending#Editing_key_bindings".
 --
 
+-- | Add docks functionality to the given config.  See above for an example.
+docks :: XConfig a -> XConfig a
+docks c = c { startupHook     = docksStartupHook <+> startupHook c
+            , handleEventHook = docksEventHook <+> handleEventHook c
+            , manageHook      = manageDocks <+> manageHook c }
+
+newtype StrutCache = StrutCache { fromStrutCache :: M.Map Window [Strut] }
+    deriving (Eq, Typeable)
+
+data UpdateDocks = UpdateDocks deriving Typeable
+instance Message UpdateDocks
+
+refreshDocks :: X ()
+refreshDocks = sendMessage UpdateDocks
+
+instance ExtensionClass StrutCache where
+  initialValue = StrutCache M.empty
+
+updateStrutCache :: Window -> [Strut] -> X Bool
+updateStrutCache w strut = do
+  XS.modified $ StrutCache . M.insert w strut . fromStrutCache
+
+deleteFromStructCache :: Window -> X Bool
+deleteFromStructCache w = do
+  XS.modified $ StrutCache . M.delete w . fromStrutCache
+
 -- | Detects if the given window is of type DOCK and if so, reveals
---   it, but does not manage it. If the window has the STRUT property
---   set, adjust the gap accordingly.
+--   it, but does not manage it.
 manageDocks :: ManageHook
-manageDocks = checkDock --> doIgnore
+manageDocks = checkDock --> (doIgnore <+> setDocksMask)
+    where setDocksMask = do
+            ask >>= \win -> liftX $ withDisplay $ \dpy -> do
+                io $ selectInput dpy win (propertyChangeMask .|. structureNotifyMask)
+            mempty
 
 -- | Checks if a window is a DOCK or DESKTOP window
 checkDock :: Query Bool
@@ -117,11 +133,34 @@ checkDock = ask >>= \w -> liftX $ do
 -- | Whenever a new dock appears, refresh the layout immediately to avoid the
 -- new dock.
 docksEventHook :: Event -> X All
-docksEventHook (MapNotifyEvent {ev_window = w}) = do
-    whenX ((not `fmap` (isClient w)) <&&> runQuery checkDock w) refresh
+docksEventHook (MapNotifyEvent { ev_window = w }) = do
+    whenX (runQuery checkDock w <&&> (not <$> isClient w)) $ do
+        strut <- getStrut w
+        whenX (updateStrutCache w strut) refreshDocks
+    return (All True)
+docksEventHook (PropertyEvent { ev_window = w
+                              , ev_atom = a }) = do
+    nws <- getAtom "_NET_WM_STRUT"
+    nwsp <- getAtom "_NET_WM_STRUT_PARTIAL"
+    when (a == nws || a == nwsp) $ do
+        strut <- getStrut w
+        whenX (updateStrutCache w strut) refreshDocks
+    return (All True)
+docksEventHook (DestroyWindowEvent {ev_window = w}) = do
+    whenX (deleteFromStructCache w) refreshDocks
     return (All True)
 docksEventHook _ = return (All True)
 
+docksStartupHook :: X ()
+docksStartupHook = withDisplay $ \dpy -> do
+    rootw <- asks theRoot
+    (_,_,wins) <- io $ queryTree dpy rootw
+    docks <- filterM (runQuery checkDock) wins
+    forM_ docks $ \win -> do
+        strut <- getStrut win
+        updateStrutCache win strut
+    refreshDocks
+
 -- | Gets the STRUT config, if present, in xmonad gap order
 getStrut :: Window -> X [Strut]
 getStrut w = do
@@ -143,9 +182,7 @@ getStrut w = do
 calcGap :: S.Set Direction2D -> X (Rectangle -> Rectangle)
 calcGap ss = withDisplay $ \dpy -> do
     rootw <- asks theRoot
-    -- We don't keep track of dock like windows, so we find all of them here
-    (_,_,wins) <- io $ queryTree dpy rootw
-    struts <- (filter careAbout . concat) `fmap` mapM getStrut wins
+    struts <- (filter careAbout . concat) `fmap` XS.gets (M.elems . fromStrutCache)
 
     -- we grab the window attributes of the root window rather than checking
     -- the width of the screen because xlib caches this info and it tends to
@@ -167,7 +204,7 @@ avoidStrutsOn :: LayoutClass l a =>
                  [Direction2D]
               -> l a
               -> ModifiedLayout AvoidStruts l a
-avoidStrutsOn ss = ModifiedLayout $ AvoidStruts $ S.fromList ss
+avoidStrutsOn ss = ModifiedLayout $ AvoidStruts (S.fromList ss)
 
 data AvoidStruts a = AvoidStruts (S.Set Direction2D) deriving ( Read, Show )
 
@@ -207,21 +244,30 @@ instance Message SetStruts
 
 instance LayoutModifier AvoidStruts a where
     modifyLayout (AvoidStruts ss) w r = do
-        nr <- fmap ($ r) (calcGap ss)
-        runLayout w nr
+        srect <- fmap ($ r) (calcGap ss)
+        -- Ensure _NET_WORKAREA is not set.
+        -- See: https://github.com/xmonad/xmonad-contrib/pull/79
+        rmWorkarea
+        runLayout w srect
 
-    pureMess (AvoidStruts ss) m
+    pureMess as@(AvoidStruts ss) m
         | Just ToggleStruts    <- fromMessage m = Just $ AvoidStruts (toggleAll ss)
         | Just (ToggleStrut s) <- fromMessage m = Just $ AvoidStruts (toggleOne s ss)
         | Just (SetStruts n k) <- fromMessage m
         , let newSS = S.fromList n `S.union` (ss S.\\ S.fromList k)
         , newSS /= ss = Just $ AvoidStruts newSS
+        | Just UpdateDocks <- fromMessage m = Just as
         | otherwise = Nothing
       where toggleAll x | S.null x = S.fromList [minBound .. maxBound]
                         | otherwise = S.empty
             toggleOne x xs | x `S.member` xs = S.delete x xs
                            | otherwise   = x `S.insert` xs
 
+rmWorkarea :: X ()
+rmWorkarea = withDisplay $ \dpy -> do
+    a <- getAtom "_NET_WORKAREA"
+    r <- asks theRoot
+    io (deleteProperty dpy r a)
 
 -- | (Direction, height\/width, initial pixel, final pixel).
 

XMonad/Hooks/ManageHelpers.hs

@@ -13,7 +13,7 @@
 --
 -- > import XMonad.Hooks.ManageHelpers
 -- > main =
--- >     xmonad defaultConfig{
+-- >     xmonad def{
 -- >         ...
 -- >         manageHook = composeOne [
 -- >             isKDETrayWindow -?> doIgnore,

XMonad/Hooks/Minimize.hs

@@ -9,7 +9,7 @@
 -- Portability :  not portable
 --
 -- Handles window manager hints to minimize and restore windows. Use
--- this with XMonad.Layout.Minimize.
+-- this with "XMonad.Layout.Minimize".
 --
 -----------------------------------------------------------------------------
 
@@ -23,7 +23,7 @@ import Data.Monoid
 import Control.Monad(when)
 
 import XMonad
-import XMonad.Layout.Minimize
+import XMonad.Actions.Minimize
 
 -- $usage
 -- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:
@@ -33,8 +33,8 @@ import XMonad.Layout.Minimize
 -- >
 -- > myHandleEventHook = minimizeEventHook
 -- > myLayout = minimize (Tall 1 (3/100) (1/2)) ||| Full ||| etc..
--- > main = xmonad defaultConfig { layoutHook = myLayout
--- >                             , handleEventHook = myHandleEventHook }
+-- > main = xmonad def { layoutHook = myLayout
+-- >                   , handleEventHook = myHandleEventHook }
 
 minimizeEventHook :: Event -> X All
 minimizeEventHook (ClientMessageEvent {ev_window = w,
@@ -43,10 +43,10 @@ minimizeEventHook (ClientMessageEvent {ev_window = w,
     a_aw <- getAtom "_NET_ACTIVE_WINDOW"
     a_cs <- getAtom "WM_CHANGE_STATE"
 
-    when (mt == a_aw) $ sendMessage (RestoreMinimizedWin w)
+    when (mt == a_aw) $ maximizeWindow w
     when (mt == a_cs) $ do
       let message = fromIntegral . head $ dt
-      when (message == normalState) $ sendMessage (RestoreMinimizedWin w)
+      when (message == normalState) $ maximizeWindow w
       when (message == iconicState) $ minimizeWindow w
 
     return (All True)

XMonad/Hooks/Place.hs

@@ -59,8 +59,8 @@ import Control.Monad.Trans (lift)
 --
 -- and adding 'placeHook' to your 'manageHook', for example:
 --
--- > main = xmonad $ defaultConfig { manageHook = placeHook simpleSmart
--- >                                              <+> manageHook defaultConfig }
+-- > main = xmonad $ def { manageHook = placeHook simpleSmart
+-- >                                    <+> manageHook def }
 --
 -- Note that 'placeHook' should be applied after most other hooks, especially hooks
 -- such as 'doFloat' and 'doShift'. Since hooks combined with '<+>' are applied from

XMonad/Hooks/PositionStoreHooks.hs

@@ -55,15 +55,15 @@ import qualified Data.Set as S
 -- as 'positionStoreEventHook' to your event hooks. To be accurate
 -- about window sizes, the module needs to know if any decoration is in effect.
 -- This is specified with the first argument: Supply 'Nothing' for no decoration,
--- otherwise use 'Just defaultTheme' or similar to inform the module about the
+-- otherwise use 'Just def' or similar to inform the module about the
 -- decoration theme used.
 --
--- > myManageHook = positionStoreManageHook Nothing <+> manageHook defaultConfig
+-- > myManageHook = positionStoreManageHook Nothing <+> manageHook def
 -- > myHandleEventHook = positionStoreEventHook
 -- >
--- > main = xmonad defaultConfig { manageHook = myManageHook
--- >                             , handleEventHook = myHandleEventHook
--- >                             }
+-- > main = xmonad def { manageHook = myManageHook
+-- >                   , handleEventHook = myHandleEventHook
+-- >                   }
 --
 
 positionStoreManageHook :: Maybe Theme -> ManageHook
@@ -88,9 +88,9 @@ positionStoreInit mDecoTheme w  = withDisplay $ \d -> do
             else do
                 sc <- fromMaybe (W.current ws) <$> pointScreen (fi $ wa_x wa) (fi $ wa_y wa)
                 let sr = screenRect . W.screenDetail $ sc
-                sr' <- fmap ($ sr) (calcGap $ S.fromList [minBound .. maxBound])    -- take docks into account, accepting
-                                                                                    -- a somewhat unfortunate inter-dependency
-                                                                                    -- with 'XMonad.Hooks.ManageDocks'
+                sr' <- fmap ($ sr) (calcGap $ S.fromList [minBound .. maxBound]) -- take docks into account, accepting
+                                                                                       -- a somewhat unfortunate inter-dependency
+                                                                                       -- with 'XMonad.Hooks.ManageDocks'
                 modifyPosStore (\ps -> posStoreInsert ps w
                                         (Rectangle (fi $ wa_x wa) (fi (wa_y wa) - fi decoH)
                                             (fi $ wa_width wa) (decoH + fi (wa_height wa))) sr' )

XMonad/Hooks/RestoreMinimized.hs

@@ -1,4 +1,4 @@
-----------------------------------------------------------------------------
+-----------------------------------------------------------------------------
 -- |
 -- Module      :  XMonad.Hooks.RestoreMinimized
 -- Copyright   :  (c) Jan Vornberger 2009
@@ -15,6 +15,7 @@
 -----------------------------------------------------------------------------
 
 module XMonad.Hooks.RestoreMinimized
+    {-# DEPRECATED "Use XMonad.Hooks.Minimize instead, this module has no effect" #-}
     ( -- * Usage
       -- $usage
       RestoreMinimized (..)
@@ -22,10 +23,8 @@ module XMonad.Hooks.RestoreMinimized
     ) where
 
 import Data.Monoid
-import Control.Monad(when)
 
 import XMonad
-import XMonad.Layout.Minimize
 
 -- $usage
 -- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:
@@ -34,16 +33,9 @@ import XMonad.Layout.Minimize
 -- >
 -- > myHandleEventHook = restoreMinimizedEventHook
 -- >
--- > main = xmonad defaultConfig { handleEventHook = myHandleEventHook }
+-- > main = xmonad def { handleEventHook = myHandleEventHook }
 
 data RestoreMinimized = RestoreMinimized deriving ( Show, Read )
 
 restoreMinimizedEventHook :: Event -> X All
-restoreMinimizedEventHook (ClientMessageEvent {ev_window = w,
-                                                ev_message_type = mt}) = do
-    a_aw <- getAtom "_NET_ACTIVE_WINDOW"
-    a_cs <- getAtom "WM_CHANGE_STATE"
-    when (mt == a_aw || mt == a_cs) $ do
-        sendMessage (RestoreMinimizedWin w)
-    return (All True)
 restoreMinimizedEventHook _ = return (All True)

XMonad/Hooks/ScreenCorners.hs

@@ -1,8 +1,8 @@
-{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  XMonad.Hooks.ScreenCorners
--- Copyright   :  (c) 2009 Nils Schweinsberg
+-- Copyright   :  (c) 2009 Nils Schweinsberg, 2015 Evgeny Kurnevsky
 -- License     :  BSD3-style (see LICENSE)
 --
 -- Maintainer  :  Nils Schweinsberg <mail@n-sch.de>
@@ -25,12 +25,16 @@ module XMonad.Hooks.ScreenCorners
 
     -- * Event hook
     , screenCornerEventHook
+
+    -- * Layout hook
+    , screenCornerLayoutHook
     ) where
 
 import Data.Monoid
 import Data.List (find)
 import XMonad
 import XMonad.Util.XUtils (fi)
+import XMonad.Layout.LayoutModifier
 
 import qualified Data.Map as M
 import qualified XMonad.Util.ExtensibleState as XS
@@ -142,6 +146,23 @@ screenCornerEventHook CrossingEvent { ev_window = win } = do
 screenCornerEventHook _ = return (All True)
 
 
+--------------------------------------------------------------------------------
+-- Layout hook
+--------------------------------------------------------------------------------
+
+data ScreenCornerLayout a = ScreenCornerLayout
+    deriving ( Read, Show )
+
+instance LayoutModifier ScreenCornerLayout a where
+    hook ScreenCornerLayout = withDisplay $ \dpy -> do
+        ScreenCornerState m <- XS.get
+        io $ mapM_ (raiseWindow dpy) $ M.keys m
+    unhook = hook
+
+screenCornerLayoutHook :: l a -> ModifiedLayout ScreenCornerLayout l a
+screenCornerLayoutHook = ModifiedLayout ScreenCornerLayout
+
+
 --------------------------------------------------------------------------------
 -- $usage
 --
@@ -163,6 +184,14 @@ screenCornerEventHook _ = return (All True)
 -- >                      , (SCLowerLeft,  prevWS)
 -- >                      ]
 --
+-- Then add layout hook:
+--
+-- > myLayout = screenCornerLayoutHook $ tiled ||| Mirror tiled ||| Full where
+-- >     tiled   = Tall nmaster delta ratio
+-- >     nmaster = 1
+-- >     ratio   = 1 / 2
+-- >     delta   = 3 / 100
+--
 -- And finally wait for screen corner events in your event hook:
 --
 -- > myEventHook e = do

XMonad/Hooks/Script.hs

@@ -34,7 +34,7 @@ import XMonad
 -- For example, if you wanted to run the hook "startup" in your script every
 -- time your startup hook ran, you could modify your xmonad config as such:
 --
--- > main = xmonad $ defaultConfig {
+-- > main = xmonad $ def {
 -- >   ...
 -- >   startupHook = execScriptHook "startup"
 -- >   ...

XMonad/Hooks/ServerMode.hs

@@ -1,69 +1,104 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  XMonad.Hooks.ServerMode
--- Copyright   :  (c) Andrea Rossato and David Roundy 2007
+-- Copyright   :  (c) Peter Olson 2013 and Andrea Rossato and David Roundy 2007
 -- License     :  BSD-style (see xmonad/LICENSE)
 --
--- Maintainer  :  andrea.rossato@unibz.it
+-- Maintainer  :  polson2@hawk.iit.edu
 -- Stability   :  unstable
 -- Portability :  unportable
 --
 -- This is an 'EventHook' that will receive commands from an external
--- client.
+-- client. Also consider "XMonad.Hooks.EwmhDesktops" together with
+-- @wmctrl@.
 --
 -- This is the example of a client:
 --
 -- > import Graphics.X11.Xlib
 -- > import Graphics.X11.Xlib.Extras
 -- > import System.Environment
+-- > import System.IO
 -- > import Data.Char
--- >
--- > usage :: String -> String
--- > usage n = "Usage: " ++ n ++ " command number\nSend a command number to a running instance of XMonad"
--- >
+-- > 
 -- > main :: IO ()
--- > main = do
--- >   args <- getArgs
--- >   pn <- getProgName
--- >   let com = case args of
--- >               [] -> error $ usage pn
--- >               w -> (w !! 0)
--- >   sendCommand com
--- >
--- > sendCommand :: String -> IO ()
--- > sendCommand s = do
+-- > main = parse True "XMONAD_COMMAND" =<< getArgs
+-- > 
+-- > parse :: Bool -> String -> [String] -> IO ()
+-- > parse input addr args = case args of
+-- >         ["--"] | input -> repl addr
+-- >                | otherwise -> return ()
+-- >         ("--":xs) -> sendAll addr xs
+-- >         ("-a":a:xs) -> parse input a xs
+-- >         ("-h":_) -> showHelp
+-- >         ("--help":_) -> showHelp
+-- >         ("-?":_) -> showHelp
+-- >         (a@('-':_):_) -> hPutStrLn stderr ("Unknown option " ++ a)
+-- > 
+-- >         (x:xs) -> sendCommand addr x >> parse False addr xs
+-- >         [] | input -> repl addr
+-- >            | otherwise -> return ()
+-- > 
+-- > 
+-- > repl :: String -> IO ()
+-- > repl addr = do e <- isEOF
+-- >                case e of
+-- >                 True -> return ()
+-- >                 False -> do l <- getLine
+-- >                             sendCommand addr l
+-- >                             repl addr
+-- > 
+-- > sendAll :: String -> [String] -> IO ()
+-- > sendAll addr ss = foldr (\a b -> sendCommand addr a >> b) (return ()) ss
+-- > 
+-- > sendCommand :: String -> String -> IO ()
+-- > sendCommand addr s = do
 -- >   d   <- openDisplay ""
 -- >   rw  <- rootWindow d $ defaultScreen d
--- >   a <- internAtom d "XMONAD_COMMAND" False
+-- >   a <- internAtom d addr False
+-- >   m <- internAtom d s False
 -- >   allocaXEvent $ \e -> do
 -- >                   setEventType e clientMessage
--- >                   setClientMessageEvent e rw a 32 (fromIntegral (read s)) currentTime
+-- >                   setClientMessageEvent e rw a 32 m currentTime
 -- >                   sendEvent d rw False structureNotifyMask e
 -- >                   sync d False
+-- > 
+-- > showHelp :: IO ()
+-- > showHelp = do pn <- getProgName
+-- >               putStrLn ("Send commands to a running instance of xmonad. xmonad.hs must be configured with XMonad.Hooks.ServerMode to work.\n-a atomname can be used at any point in the command line arguments to change which atom it is sending on.\nIf sent with no arguments or only -a atom arguments, it will read commands from stdin.\nEx:\n" ++ pn ++ " cmd1 cmd2\n" ++ pn ++ " -a XMONAD_COMMAND cmd1 cmd2 cmd3 -a XMONAD_PRINT hello world\n" ++ pn ++ " -a XMONAD_PRINT # will read data from stdin.\nThe atom defaults to XMONAD_COMMAND.")
 --
--- compile with: @ghc --make sendCommand.hs@
+--
+-- compile with: @ghc --make xmonadctl.hs@
 --
 -- run with
 --
--- > sendCommand command number
+-- > xmonadctl command
 --
--- For instance:
+-- or with
 --
--- > sendCommand 0
+-- > $ xmonadctl
+-- > command1
+-- > command2
+-- > .
+-- > .
+-- > .
+-- > ^D
+--
+-- Usage will change depending on which event hook(s) you use. More examples are shown below.
 --
---  will ask to xmonad to print the list of command numbers in
--- stderr (so you can read it in @~\/.xsession-errors@).
 -----------------------------------------------------------------------------
 
 module XMonad.Hooks.ServerMode
     ( -- * Usage
       -- $usage
-      ServerMode (..)
-    , serverModeEventHook
+      serverModeEventHook
     , serverModeEventHook'
+    , serverModeEventHookCmd
+    , serverModeEventHookCmd'
+    , serverModeEventHookF
     ) where
 
 import Control.Monad (when)
+import Data.Maybe
 import Data.Monoid
 import System.IO
 
@@ -75,31 +110,64 @@ import XMonad.Actions.Commands
 -- @~\/.xmonad\/xmonad.hs@:
 --
 -- > import XMonad.Hooks.ServerMode
--- > import XMonad.Actions.Commands
 --
--- Then edit your @handleEventHook@ by adding the 'serverModeEventHook':
---
--- > main = xmonad defaultConfig { handleEventHook = serverModeEventHook }
---
-
-data ServerMode = ServerMode deriving ( Show, Read )
+-- Then edit your @handleEventHook@ by adding the appropriate event hook from below
 
 -- | Executes a command of the list when receiving its index via a special ClientMessageEvent
--- (indexing starts at 1)
+-- (indexing starts at 1). Sending index 0 will ask xmonad to print the list of command numbers
+-- in stderr (so that you can read it in @~\/.xsession-errors@). Uses "XMonad.Actions.Commands#defaultCommands" as the default.
+--
+-- > main = xmonad def { handleEventHook = serverModeEventHook }
+-- 
+-- > xmonadctl 0 # tells xmonad to output command list
+-- > xmonadctl 1 # tells xmonad to switch to workspace 1
+--
 serverModeEventHook :: Event -> X All
 serverModeEventHook = serverModeEventHook' defaultCommands
 
 -- | serverModeEventHook' additionally takes an action to generate the list of
 -- commands.
 serverModeEventHook' :: X [(String,X ())] -> Event -> X All
-serverModeEventHook' cmdAction (ClientMessageEvent {ev_message_type = mt, ev_data = dt}) = do
+serverModeEventHook' cmdAction ev = serverModeEventHookF "XMONAD_COMMAND" (sequence_ . map helper . words) ev
+        where helper cmd = do cl <- cmdAction
+                              case lookup cmd (zip (map show [1 :: Integer ..]) cl) of
+                                Just (_,action) -> action
+                                Nothing         -> mapM_ (io . hPutStrLn stderr) . listOfCommands $ cl
+              listOfCommands cl = map (uncurry (++)) $ zip (map show ([1..] :: [Int])) $ map ((++) " - " . fst) cl
+
+
+-- | Executes a command of the list when receiving its name via a special ClientMessageEvent.
+-- Uses "XMonad.Actions.Commands#defaultCommands" as the default.
+--
+-- > main = xmonad def { handleEventHook = serverModeEventHookCmd }
+--
+-- > xmonadctl run # Tells xmonad to generate a run prompt
+--
+serverModeEventHookCmd :: Event -> X All
+serverModeEventHookCmd = serverModeEventHookCmd' defaultCommands
+
+-- | Additionally takes an action to generate the list of commands
+serverModeEventHookCmd' :: X [(String,X ())] -> Event -> X All
+serverModeEventHookCmd' cmdAction ev = serverModeEventHookF "XMONAD_COMMAND" (sequence_ . map helper . words) ev
+        where helper cmd = do cl <- cmdAction
+                              fromMaybe (io $ hPutStrLn stderr ("Couldn't find command " ++ cmd)) (lookup cmd cl)
+
+-- | Listens for an atom, then executes a callback function whenever it hears it.
+-- A trivial example that prints everything supplied to it on xmonad's standard out:
+--
+-- > main = xmonad def { handleEventHook = serverModeEventHookF "XMONAD_PRINT" (io . putStrLn) }
+--
+-- > xmonadctl -a XMONAD_PRINT "hello world"
+--
+serverModeEventHookF :: String -> (String -> X ()) -> Event -> X All
+serverModeEventHookF key func (ClientMessageEvent {ev_message_type = mt, ev_data = dt}) = do
         d <- asks display
-        a <- io $ internAtom d "XMONAD_COMMAND" False
-        when (mt == a && dt /= []) $ do
-             cl <- cmdAction
-             let listOfCommands = map (uncurry (++)) . zip (map show ([1..] :: [Int])) . map ((++) " - " . fst)
-             case lookup (fromIntegral (head dt) :: Int) (zip [1..] cl) of
-                  Just (_,action) -> action
-                  Nothing         -> mapM_ (io . hPutStrLn stderr) . listOfCommands $ cl
+        atm <- io $ internAtom d key False
+        when (mt == atm && dt /= []) $ do
+         let atom = fromIntegral $ toInteger $ foldr1 (\a b -> a + (b*2^(32::Int))) dt
+         cmd <- io $ getAtomName d atom
+         case cmd of
+              Just command -> func command
+              Nothing -> io $ hPutStrLn stderr ("Couldn't retrieve atom " ++ (show atom))
         return (All True)
-serverModeEventHook' _ _ = return (All True)
+serverModeEventHookF _ _ _ = return (All True)

XMonad/Hooks/ToggleHook.hs

@@ -85,12 +85,12 @@ modify' n f = XS.modify (HookState . setter . hooks)
 -- and adding 'toggleHook name hook' to your 'ManageHook' where @name@ is the
 -- name of the hook and @hook@ is the hook to execute based on the state.
 --
--- > myManageHook = toggleHook "float" doFloat <+> manageHook defaultConfig
+-- > myManageHook = toggleHook "float" doFloat <+> manageHook def
 --
 -- Additionally, toggleHook' is provided to toggle between two hooks (rather
 -- than on/off).
 --
--- > myManageHook = toggleHook' "oldfocus" (const id) W.focusWindow <+> manageHook defaultConfig
+-- > myManageHook = toggleHook' "oldfocus" (const id) W.focusWindow <+> manageHook def
 --
 -- The 'hookNext' and 'toggleHookNext' functions can be used in key
 -- bindings to set whether the hook is applied or not.

XMonad/Hooks/UrgencyHook.hs

@@ -61,6 +61,7 @@ module XMonad.Hooks.UrgencyHook (
                                  NoUrgencyHook(..),
                                  BorderUrgencyHook(..),
                                  FocusHook(..),
+                                 filterUrgencyHook,
                                  minutes, seconds,
                                  -- * Stuff for developers:
                                  readUrgents, withUrgents,
@@ -78,14 +79,16 @@ import XMonad.Util.Dzen (dzenWithArgs, seconds)
 import qualified XMonad.Util.ExtensibleState as XS
 import XMonad.Util.NamedWindows (getName)
 import XMonad.Util.Timer (TimerId, startTimer, handleTimer)
+import XMonad.Util.WindowProperties (getProp32)
 
 import Control.Applicative ((<$>))
 import Control.Monad (when)
 import Data.Bits (testBit)
 import Data.List (delete, (\\))
-import Data.Maybe (listToMaybe, maybeToList)
+import Data.Maybe (listToMaybe, maybeToList, fromMaybe)
 import qualified Data.Set as S
 import System.IO (hPutStrLn, stderr)
+import Foreign.C.Types (CLong)
 
 -- $usage
 --
@@ -104,7 +107,7 @@ import System.IO (hPutStrLn, stderr)
 -- 'withUrgencyHook'. For example:
 --
 -- > main = xmonad $ withUrgencyHook dzenUrgencyHook { args = ["-bg", "darkgreen", "-xs", "1"] }
--- >               $ defaultConfig
+-- >               $ def
 --
 -- This will pop up a dzen bar for five seconds telling you you've got an
 -- urgent window.
@@ -116,7 +119,7 @@ import System.IO (hPutStrLn, stderr)
 -- extra popup, install NoUrgencyHook, as so:
 --
 -- > main = xmonad $ withUrgencyHook NoUrgencyHook
--- >               $ defaultConfig
+-- >               $ def
 --
 -- Now, your "XMonad.Hooks.DynamicLog" must be set up to display the urgent
 -- windows. If you're using the 'dzen' or 'dzenPP' functions from that module,
@@ -257,7 +260,7 @@ minutes secs = secs * 60
 
 -- | The default 'UrgencyConfig'. suppressWhen = Visible, remindWhen = Dont.
 -- Use a variation of this in your config just as you use a variation of
--- defaultConfig for your xmonad definition.
+-- 'def' for your xmonad definition.
 urgencyConfig :: UrgencyConfig
 urgencyConfig = UrgencyConfig { suppressWhen = Visible, remindWhen = Dont }
 
@@ -310,12 +313,34 @@ readReminders = XS.get
 adjustReminders :: ([Reminder] -> [Reminder]) -> X ()
 adjustReminders = XS.modify
 
-clearUrgency :: Window -> X ()
-clearUrgency w = adjustUrgents (delete w) >> adjustReminders (filter $ (w /=) . window)
 
 data WithUrgencyHook h = WithUrgencyHook h UrgencyConfig
     deriving (Read, Show)
 
+-- | Change the _NET_WM_STATE property by applying a function to the list of atoms.
+changeNetWMState :: Display -> Window -> ([CLong] -> [CLong]) -> X ()
+changeNetWMState dpy w f = do
+   wmstate <- getAtom "_NET_WM_STATE"
+   wstate  <- fromMaybe [] `fmap` getProp32 wmstate w
+   let ptype = 4 -- atom property type for changeProperty
+   io $ changeProperty32 dpy w wmstate ptype propModeReplace (f wstate)
+   return ()
+
+-- | Add an atom to the _NET_WM_STATE property.
+addNetWMState :: Display -> Window -> Atom -> X ()
+addNetWMState dpy w atom = changeNetWMState dpy w $ ((fromIntegral atom):)
+
+-- | Remove an atom from the _NET_WM_STATE property.
+removeNetWMState :: Display -> Window -> Atom -> X ()
+removeNetWMState dpy w atom = changeNetWMState dpy w $ delete (fromIntegral atom)
+
+-- | Get the _NET_WM_STATE propertly as a [CLong]
+getNetWMState :: Window -> X [CLong]
+getNetWMState w = do
+    a_wmstate <- getAtom "_NET_WM_STATE"
+    fromMaybe [] `fmap` getProp32 a_wmstate w
+
+
 -- The Non-ICCCM Manifesto:
 -- Note: Some non-standard choices have been made in this implementation to
 -- account for the fact that things are different in a tiling window manager:
@@ -331,20 +356,40 @@ data WithUrgencyHook h = WithUrgencyHook h UrgencyConfig
 handleEvent :: UrgencyHook h => WithUrgencyHook h -> Event -> X ()
 handleEvent wuh event =
     case event of
+     -- WM_HINTS urgency flag
       PropertyEvent { ev_event_type = t, ev_atom = a, ev_window = w } -> do
           when (t == propertyNotify && a == wM_HINTS) $ withDisplay $ \dpy -> do
               WMHints { wmh_flags = flags } <- io $ getWMHints dpy w
-              if (testBit flags urgencyHintBit) then do
-                  adjustUrgents (\ws -> if elem w ws then ws else w : ws)
-                  callUrgencyHook wuh w
-                else
-                  clearUrgency w
-              userCodeDef () =<< asks (logHook . config)
+              if (testBit flags urgencyHintBit) then markUrgent w else markNotUrgent w
+      -- Window destroyed
       DestroyWindowEvent {ev_window = w} ->
-          clearUrgency w
+          markNotUrgent w
+      -- _NET_WM_STATE_DEMANDS_ATTENTION requested by client
+      ClientMessageEvent {ev_event_display = dpy, ev_window = w, ev_message_type = t, ev_data = action:atoms} -> do
+          a_wmstate <- getAtom "_NET_WM_STATE"
+          a_da      <- getAtom "_NET_WM_STATE_DEMANDS_ATTENTION"
+          wstate    <- getNetWMState w
+          let demandsAttention = fromIntegral a_da `elem` wstate
+              remove = 0
+              add    = 1
+              toggle = 2
+          when (t == a_wmstate && fromIntegral a_da `elem` atoms) $ do
+            when (action == add || (action == toggle && not demandsAttention)) $ do
+              markUrgent w
+              addNetWMState dpy w a_da
+            when (action == remove || (action == toggle && demandsAttention)) $ do
+              markNotUrgent w
+              removeNetWMState dpy w a_da
       _ ->
           mapM_ handleReminder =<< readReminders
       where handleReminder reminder = handleTimer (timer reminder) event $ reminderHook wuh reminder
+            markUrgent w = do
+                adjustUrgents (\ws -> if elem w ws then ws else w : ws)
+                callUrgencyHook wuh w
+                userCodeDef () =<< asks (logHook . config)
+            markNotUrgent w = do
+                adjustUrgents (delete w) >> adjustReminders (filter $ (w /=) . window)
+                userCodeDef () =<< asks (logHook . config)
 
 callUrgencyHook :: UrgencyHook h => WithUrgencyHook h -> Window -> X ()
 callUrgencyHook (WithUrgencyHook hook UrgencyConfig { suppressWhen = sw, remindWhen = rw }) w =
@@ -378,6 +423,9 @@ shouldSuppress sw w = elem w <$> suppressibleWindows sw
 cleanupUrgents :: SuppressWhen -> X ()
 cleanupUrgents sw = do
     sw' <- suppressibleWindows sw
+    a_da <- getAtom "_NET_WM_STATE_DEMANDS_ATTENTION"
+    dpy <- withDisplay (\dpy -> return dpy)
+    mapM_ (\w -> removeNetWMState dpy w a_da) sw'
     adjustUrgents (\\ sw') >> adjustReminders (filter $ ((`notElem` sw') . window))
 
 suppressibleWindows :: SuppressWhen -> X [Window]
@@ -449,14 +497,14 @@ data BorderUrgencyHook = BorderUrgencyHook { urgencyBorderColor :: !String }
 
 instance UrgencyHook BorderUrgencyHook where
   urgencyHook BorderUrgencyHook { urgencyBorderColor = cs } w =
-    withDisplay $ \dpy -> io $ do
-      c' <- initColor dpy cs
+    withDisplay $ \dpy -> do
+      c' <- io (initColor dpy cs)
       case c' of
-        Just c -> setWindowBorder dpy w c
-        _      -> hPutStrLn stderr $ concat ["Warning: bad urgentBorderColor "
-                                            ,show cs
-                                            ," in BorderUrgencyHook"
-                                            ]
+        Just c -> setWindowBorderWithFallback dpy w cs c
+        _      -> io $ hPutStrLn stderr $ concat ["Warning: bad urgentBorderColor "
+                                                 ,show cs
+                                                 ," in BorderUrgencyHook"
+                                                 ]
 
 -- | Flashes when a window requests your attention and you can't see it.
 -- Defaults to a duration of five seconds, and no extra args to dzen.
@@ -481,3 +529,17 @@ data StdoutUrgencyHook = StdoutUrgencyHook deriving (Read, Show)
 
 instance UrgencyHook StdoutUrgencyHook where
     urgencyHook    _ w = io $ putStrLn $ "Urgent: " ++ show w
+
+-- | urgencyhook such that windows on certain workspaces
+-- never get urgency set.
+--
+-- Useful for scratchpad workspaces perhaps:
+--
+-- > main = xmonad (withUrgencyHook (filterUrgencyHook ["NSP", "SP"]) defaultConfig)
+filterUrgencyHook :: [WorkspaceId] -> Window -> X ()
+filterUrgencyHook skips w = do
+    ws <- gets windowset
+    case W.findTag w ws of
+        Just tag -> when (tag `elem` skips)
+                        $ adjustUrgents (delete w)
+        _ -> return ()

XMonad/Hooks/WallpaperSetter.hs

@@ -0,0 +1,227 @@
+{-# LANGUAGE DeriveDataTypeable #-}
+-----------------------------------
+-- |
+-- Module      : XMonad.Hooks.WallpaperSetter
+-- Copyright   : (c) Anton Pirogov, 2014
+-- License     : BSD3
+--
+-- Maintainer  : Anton Pirogov <anton.pirogov@gmail.com>
+-- Stability   : unstable
+-- Portability : unportable
+--
+-- Log hook which changes the wallpapers depending on visible workspaces.
+-----------------------------------
+module XMonad.Hooks.WallpaperSetter (
+  -- * Usage
+  -- $usage
+  wallpaperSetter
+, WallpaperConf(..)
+, Wallpaper(..)
+, WallpaperList(..)
+, defWallpaperConf
+, defWPNames
+  -- *TODO
+  -- $todo
+) where
+import XMonad
+import qualified XMonad.StackSet as S
+import qualified XMonad.Util.ExtensibleState as XS
+
+import System.IO
+import System.Process
+import System.Directory (getHomeDirectory, doesFileExist, doesDirectoryExist, getDirectoryContents)
+import System.FilePath ((</>))
+import System.Random (randomRIO)
+
+import qualified Data.Map as M
+import Data.List (intersperse, sortBy)
+import Data.Char (isAlphaNum)
+import Data.Ord (comparing)
+
+import Control.Monad
+import Control.Applicative
+import Data.Maybe
+import Data.Monoid hiding ((<>))
+import Data.Semigroup
+
+-- $usage
+-- This module requires imagemagick and feh to be installed, as these are utilized
+-- for the required image transformations and the actual setting of the wallpaper.
+--
+-- This was especially tested with multi-head setups - if you have two monitors and swap
+-- the workspaces, the wallpapers will be swapped too, scaled accordingly and rotated if necessary
+-- (e.g. if you are using your monitor rotated but only have wide wallpapers).
+--
+-- Add a log hook like this:
+--
+-- > myWorkspaces = ["1:main","2:misc","3","4"]
+-- > ...
+-- > main = xmonad $ defaultConfig {
+-- >   logHook = wallpaperSetter defWallpaperConf {
+-- >                                wallpapers = defWPNames myWorkspaces
+-- >                                          <> WallpaperList [("1:main",WallpaperDir "1")]
+-- >                             }
+-- >   }
+-- > ...
+
+-- $todo
+-- * implement a kind of image cache like in wallpaperd to remove or at least reduce the lag
+--
+-- * find out how to merge multiple images from stdin to one (-> for caching all pictures in memory)
+
+-- | internal. to use XMonad state for memory in-between log-hook calls and remember PID of old external call
+data WCState = WCState (Maybe [WorkspaceId]) (Maybe ProcessHandle) deriving Typeable
+instance ExtensionClass WCState where
+  initialValue = WCState Nothing Nothing
+
+-- | Represents a wallpaper
+data Wallpaper = WallpaperFix FilePath -- ^ Single, fixed wallpaper
+               | WallpaperDir FilePath -- ^ Random wallpaper from this subdirectory
+               deriving (Eq, Show, Read)
+
+newtype WallpaperList = WallpaperList [(WorkspaceId, Wallpaper)]
+  deriving (Show,Read)
+
+instance Monoid WallpaperList where
+  mempty = WallpaperList []
+  mappend (WallpaperList w1) (WallpaperList w2) =
+    WallpaperList $ M.toList $ (M.fromList w2) `M.union` (M.fromList w1)
+
+instance Semigroup WallpaperList where
+  (<>) = mappend
+
+-- | Complete wallpaper configuration passed to the hook
+data WallpaperConf = WallpaperConf {
+    wallpaperBaseDir :: FilePath  -- ^ Where the wallpapers reside (if empty, will look in \~\/.wallpapers/)
+  , wallpapers :: WallpaperList   -- ^ List of the wallpaper associations for workspaces
+  } deriving (Show, Read)
+
+-- | default configuration. looks in \~\/.wallpapers/ for WORKSPACEID.jpg
+defWallpaperConf :: WallpaperConf
+defWallpaperConf = WallpaperConf "" $ WallpaperList []
+
+instance Default WallpaperConf where
+    def = defWallpaperConf
+
+-- |returns the default association list (maps name to name.jpg, non-alphanumeric characters are omitted)
+defWPNames :: [WorkspaceId] -> WallpaperList
+defWPNames xs = WallpaperList $ map (\x -> (x,WallpaperFix (filter isAlphaNum x++".jpg"))) xs
+
+-- | Add this to your log hook with the workspace configuration as argument.
+wallpaperSetter :: WallpaperConf -> X ()
+wallpaperSetter wpconf = do
+  WCState oldws h <- XS.get
+  visws <- getVisibleWorkspaces
+  when (Just visws /= oldws) $ do
+
+    wpconf' <- completeWPConf wpconf
+    wspicpaths <- getPicPathsAndWSRects wpconf'
+
+    -- terminate old call if any to prevent unnecessary CPU overload when switching WS too fast
+    case h of
+      Nothing -> return ()
+      Just pid -> liftIO $ terminateProcess pid
+
+    handle <- applyWallpaper wspicpaths
+    XS.put $ WCState (Just visws) $ Just handle
+
+-- Helper functions
+-------------------
+
+-- | Picks a random element from a list
+pickFrom :: [a] -> IO a
+pickFrom list = do
+  i <- randomRIO (0,length list - 1)
+  return $ list !! i
+
+-- | get absolute picture path of the given wallpaper picture
+-- or select a random one if it is a directory
+getPicPath :: WallpaperConf -> Wallpaper -> IO (Maybe FilePath)
+getPicPath conf (WallpaperDir dir) = do
+  direxists <- doesDirectoryExist $ wallpaperBaseDir conf </> dir
+  if direxists
+    then do files <- getDirectoryContents $ wallpaperBaseDir conf </> dir
+            let files' = filter ((/='.').head) files
+            file <- pickFrom files'
+            return $ Just $ wallpaperBaseDir conf </> dir </> file
+    else return Nothing
+getPicPath conf (WallpaperFix file) = do
+  exist <- doesFileExist path
+  return $ if exist then Just path else Nothing
+  where path = wallpaperBaseDir conf </> file
+
+-- | Take a path to a picture, return (width, height) if the path is a valid picture
+-- (requires imagemagick tool identify to be installed)
+getPicRes :: FilePath -> IO (Maybe (Int,Int))
+getPicRes picpath = do
+  (_, Just outh,_,_pid) <- createProcess $ (proc "identify" ["-format", "%w %h", picpath]) { std_out = CreatePipe }
+  output <- hGetContents outh
+  return $ case map reads (words output) of
+    -- mapM Text.Read.readMaybe is better but only in ghc>=7.6
+    [[(w,"")],[(h,"")]] -> Just (w,h)
+    _ -> Nothing
+
+
+-- |complete unset fields to default values (wallpaper directory = ~/.wallpapers,
+--  expects a file "NAME.jpg" for each workspace named NAME)
+completeWPConf :: WallpaperConf -> X WallpaperConf
+completeWPConf (WallpaperConf dir (WallpaperList ws)) = do
+  home <- liftIO getHomeDirectory
+  winset <- gets windowset
+  let tags = map S.tag $ S.workspaces winset
+      dir' = if null dir then home </> ".wallpapers" else dir
+      ws'  = if null ws then defWPNames tags else WallpaperList ws
+  return (WallpaperConf dir' ws')
+
+getVisibleWorkspaces :: X [WorkspaceId]
+getVisibleWorkspaces = do
+  winset <- gets windowset
+  return $ map (S.tag . S.workspace) . sortBy (comparing S.screen) $ S.current winset : S.visible winset
+
+getPicPathsAndWSRects :: WallpaperConf -> X [(Rectangle, FilePath)]
+getPicPathsAndWSRects wpconf = do
+  winset <- gets windowset
+  paths <- liftIO getPicPaths
+  visws <- getVisibleWorkspaces
+  let visscr = S.current winset : S.visible winset
+      visrects = M.fromList $ map (\x -> ((S.tag . S.workspace) x, S.screenDetail x)) visscr
+      hasPicAndIsVisible (n, mp) = n `elem` visws && (isJust mp)
+      getRect tag = screenRect $ fromJust $ M.lookup tag visrects
+      foundpaths = map (\(n,Just p)->(getRect n,p)) $ filter hasPicAndIsVisible paths
+  return foundpaths
+  where getPicPaths = mapM (\(x,y) -> getPicPath wpconf y
+                             >>= \p -> return (x,p)) wl
+        WallpaperList wl   = wallpapers wpconf
+
+-- | Gets a list of geometry rectangles and filenames, builds and sets wallpaper
+applyWallpaper :: [(Rectangle, FilePath)] -> X ProcessHandle
+applyWallpaper parts = do
+  winset <- gets windowset
+  let (vx,vy) = getVScreenDim winset
+  layers <- liftIO $ mapM layerCommand parts
+  let basepart ="convert -size "++show vx++"x"++show vy++" xc:black "
+      endpart =" jpg:- | feh --no-xinerama --bg-tile --no-fehbg -"
+      cmd = basepart ++ (concat $ intersperse " " layers) ++ endpart
+  liftIO $ runCommand cmd
+
+
+getVScreenDim :: S.StackSet i l a sid ScreenDetail -> (Integer, Integer)
+getVScreenDim = foldr maxXY (0,0) . map (screenRect . S.screenDetail) . S.screens
+  where maxXY (Rectangle x y w h) (mx,my) = ( fromIntegral ((fromIntegral x)+w) `max` mx
+                                            , fromIntegral ((fromIntegral y)+h) `max` my )
+
+needsRotation :: Rectangle -> (Int,Int) -> Bool
+needsRotation rect (px,py) = let wratio, pratio :: Double
+                                 wratio = (fromIntegral $ rect_width rect) / (fromIntegral $ rect_height rect)
+                                 pratio = fromIntegral px / fromIntegral py
+                             in wratio > 1 && pratio < 1 || wratio < 1 && pratio > 1
+
+layerCommand :: (Rectangle, FilePath) -> IO String
+layerCommand (rect, path) = do
+  res <- getPicRes path
+  return $ case needsRotation rect <$> res of
+    Nothing -> ""
+    Just rotate ->
+                     " \\( '"++path++"' "++(if rotate then "-rotate 90 " else "")
+                      ++ " -scale "++(show$rect_width rect)++"x"++(show$rect_height rect)++"! \\)"
+                      ++ " -geometry +"++(show$rect_x rect)++"+"++(show$rect_y rect)++" -composite "

XMonad/Hooks/WorkspaceByPos.hs

@@ -33,9 +33,9 @@ import Control.Monad.Error ((<=<),guard,lift,runErrorT,throwError)
 --
 -- > import XMonad.Hooks.WorkspaceByPos
 -- >
--- > myManageHook = workspaceByPos <+> manageHook defaultConfig
+-- > myManageHook = workspaceByPos <+> manageHook def
 -- >
--- > main = xmonad defaultConfig { manageHook = myManageHook }
+-- > main = xmonad def { manageHook = myManageHook }
 
 workspaceByPos :: ManageHook
 workspaceByPos = (maybe idHook doShift <=< liftX . needsMoving) =<< ask

XMonad/Hooks/WorkspaceHistory.hs

@@ -0,0 +1,103 @@
+{-# LANGUAGE DeriveDataTypeable #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  XMonad.Hooks.WorkspaceHistory
+-- Copyright   :  (c) 2013 Dmitri Iouchtchenko
+-- License     :  BSD3-style (see LICENSE)
+--
+-- Maintainer  :  Dmitri Iouchtchenko <johnnyspoon@gmail.com>
+-- Stability   :  unstable
+-- Portability :  unportable
+--
+-- Keeps track of workspace viewing order.
+--
+-----------------------------------------------------------------------------
+
+module XMonad.Hooks.WorkspaceHistory (
+      -- * Usage
+      -- $usage
+      -- * Hooking
+    workspaceHistoryHook
+      -- * Querying
+  , workspaceHistory
+  , workspaceHistoryByScreen
+  , workspaceHistoryWithScreen
+    -- * Handling edits
+  , workspaceHistoryTransaction
+  ) where
+
+import           Control.Applicative
+import           Prelude
+
+import XMonad
+import XMonad.StackSet hiding (filter, delete)
+import Data.List
+import qualified XMonad.Util.ExtensibleState as XS
+
+-- $usage
+-- To record the order in which you view workspaces, you can use this
+-- module with the following in your @~\/.xmonad\/xmonad.hs@:
+--
+-- > import XMonad.Hooks.WorkspaceHistory (workspaceHistoryHook)
+--
+-- Then add the hook to your 'logHook':
+--
+-- >  main = xmonad $ def
+-- >      { ...
+-- >      , logHook = ... >> workspaceHistoryHook >> ...
+-- >      , ...
+-- >      }
+--
+-- To make use of the collected data, a query function is provided.
+
+data WorkspaceHistory = WorkspaceHistory
+  { history :: [(ScreenId, WorkspaceId)] -- ^ Workspace Screens in
+                                         -- reverse-chronological order.
+  } deriving (Typeable, Read, Show)
+
+instance ExtensionClass WorkspaceHistory where
+    initialValue = WorkspaceHistory []
+    extensionType = PersistentExtension
+
+-- | A 'logHook' that keeps track of the order in which workspaces have
+-- been viewed.
+workspaceHistoryHook :: X ()
+workspaceHistoryHook = gets windowset >>= (XS.modify . updateLastActiveOnEachScreen)
+
+workspaceHistoryWithScreen :: X [(ScreenId, WorkspaceId)]
+workspaceHistoryWithScreen = XS.gets history
+
+workspaceHistoryByScreen :: X [(ScreenId, [WorkspaceId])]
+workspaceHistoryByScreen =
+  map (\wss -> (fst $ head wss, map snd wss)) .
+  groupBy (\a b -> fst a == fst b) .
+  sortBy (\a b -> compare (fst a) $ fst b)<$>
+  workspaceHistoryWithScreen
+
+-- | A list of workspace tags in the order they have been viewed, with the
+-- most recent first. No duplicates are present, but not all workspaces are
+-- guaranteed to appear, and there may be workspaces that no longer exist.
+workspaceHistory :: X [WorkspaceId]
+workspaceHistory = nub . map snd <$> XS.gets history
+
+workspaceHistoryTransaction :: X () -> X ()
+workspaceHistoryTransaction action = do
+  startingHistory <- XS.gets history
+  action
+  new <- (flip updateLastActiveOnEachScreen $ WorkspaceHistory startingHistory) <$> gets windowset
+  XS.put new
+
+-- | Update the last visible workspace on each monitor if needed
+-- already there, or move it to the front if it is.
+updateLastActiveOnEachScreen :: WindowSet -> WorkspaceHistory -> WorkspaceHistory
+updateLastActiveOnEachScreen StackSet {current = cur, visible = vis} wh =
+  WorkspaceHistory { history = doUpdate cur $ foldl updateLastForScreen (history wh) $ vis ++ [cur] }
+  where
+    firstOnScreen sid = find ((== sid) . fst)
+    doUpdate Screen {workspace = Workspace { tag = wid }, screen = sid} curr =
+      let newEntry = (sid, wid) in newEntry:delete newEntry curr
+    updateLastForScreen curr Screen {workspace = Workspace { tag = wid }, screen = sid} =
+      let newEntry = (sid, wid)
+          alreadyCurrent = maybe False (== newEntry) $ firstOnScreen sid curr
+      in if alreadyCurrent then curr else newEntry:delete newEntry curr

XMonad/Layout/Accordion.hs

@@ -31,7 +31,7 @@ import Data.Ratio
 -- Then edit your @layoutHook@ by adding the Accordion layout:
 --
 -- > myLayout = Accordion ||| Full ||| etc..
--- > main = xmonad defaultConfig { layoutHook = myLayout }
+-- > main = xmonad def { layoutHook = myLayout }
 --
 -- For more detailed instructions on editing the layoutHook see:
 --

XMonad/Layout/AvoidFloats.hs

@@ -0,0 +1,239 @@
+{-# LANGUAGE PatternGuards, FlexibleContexts, FlexibleInstances, MultiParamTypeClasses, TypeSynonymInstances, ParallelListComp, DeriveDataTypeable #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  XMonad.Layout.AvoidFloats
+-- Copyright   :  (c) 2014 Anders Engstrom <ankaan@gmail.com>
+-- License     :  BSD3-style (see LICENSE)
+--
+-- Maintainer  :  (c) Anders Engstrom <ankaan@gmail.com>
+-- Stability   :  unstable
+-- Portability :  unportable
+--
+-- Find a maximum empty rectangle around floating windows and use that area
+-- to display non-floating windows.
+--
+-----------------------------------------------------------------------------
+
+module XMonad.Layout.AvoidFloats (
+                                   -- * Usage
+                                   -- $usage
+                                   avoidFloats,
+                                   avoidFloats',
+                                   AvoidFloatMsg(..),
+                                   AvoidFloatItemMsg(..),
+                                 ) where
+
+import XMonad
+import XMonad.Layout.LayoutModifier
+import qualified XMonad.StackSet as W
+
+import Data.List
+import Data.Ord
+import Data.Maybe
+import qualified Data.Map as M
+import qualified Data.Set as S
+
+-- $usage
+-- You can use this module with the following in your ~\/.xmonad\/xmonad.hs file:
+--
+-- > import XMonad.Layout.AvoidFloats
+--
+-- and modify the layouts to call avoidFloats on the layouts where you want the
+-- non-floating windows to not be behind floating windows.
+--
+-- > layoutHook = ... ||| avoidFloats Full ||| ...
+--
+-- For more detailed instructions on editing the layoutHook see:
+-- "XMonad.Doc.Extending#Editing_the_layout_hook"
+--
+-- Then add appropriate key bindings, for example:
+--
+-- > ,((modm .|. shiftMask, xK_b), sendMessage AvoidFloatToggle)
+-- > ,((modm .|. controlMask, xK_b), withFocused $ sendMessage . AvoidFloatToggleItem)
+-- > ,((modm .|. shiftMask .|. controlMask, xK_b), sendMessage (AvoidFloatSet False) >> sendMessage AvoidFloatClearItems)
+--
+-- For detailed instructions on editing your key bindings, see
+-- "XMonad.Doc.Extending#Editing_key_bindings".
+--
+-- Note that this module is incompatible with an old way of configuring
+-- "XMonad.Actions.FloatSnap". If you are having problems, please update your
+-- configuration.
+
+-- | Avoid floating windows unless the resulting area for windows would be too small.
+--   In that case, use the whole screen as if this layout modifier wasn't there.
+--   No windows are avoided by default, they need to be added using signals.
+avoidFloats
+    :: l a  -- ^ Layout to modify.
+    -> ModifiedLayout AvoidFloats l a
+avoidFloats = avoidFloats' 100 100 False
+
+-- | Avoid floating windows unless the resulting area for windows would be too small.
+--   In that case, use the whole screen as if this layout modifier wasn't there.
+avoidFloats'
+    :: Int  -- ^ Minimum width of the area used for non-floating windows.
+    -> Int  -- ^ Minimum height of the area used for non-floating windows.
+    -> Bool -- ^ If floating windows should be avoided by default.
+    -> l a  -- ^ Layout to modify.
+    -> ModifiedLayout AvoidFloats l a
+avoidFloats' w h act = ModifiedLayout (AvoidFloats Nothing S.empty w h act)
+
+data AvoidFloats a = AvoidFloats
+    { cache :: Maybe ((M.Map a W.RationalRect, Rectangle), Rectangle)
+    , chosen :: S.Set a
+    , minw :: Int
+    , minh :: Int
+    , avoidAll :: Bool
+    } deriving (Read, Show)
+
+-- | Change the state of the whole avoid float layout modifier.
+data AvoidFloatMsg
+    = AvoidFloatToggle        -- ^ Toggle between avoiding all or only selected.
+    | AvoidFloatSet Bool      -- ^ Set if all all floating windows should be avoided.
+    | AvoidFloatClearItems    -- ^ Clear the set of windows to specifically avoid.
+    deriving (Typeable)
+
+
+-- | Change the state of the avoid float layout modifier conserning a specific window.
+data AvoidFloatItemMsg a
+    = AvoidFloatAddItem a     -- ^ Add a window to always avoid.
+    | AvoidFloatRemoveItem a  -- ^ Stop always avoiding selected window.
+    | AvoidFloatToggleItem a  -- ^ Toggle between always avoiding selected window.
+    deriving (Typeable)
+
+instance Message AvoidFloatMsg
+instance Typeable a => Message (AvoidFloatItemMsg a)
+
+instance LayoutModifier AvoidFloats Window where
+    modifyLayoutWithUpdate lm w r = withDisplay $ \d -> do
+        floating <- gets $ W.floating . windowset
+        case cache lm of
+            Just (key, mer) | key == (floating,r) -> flip (,) Nothing `fmap` runLayout w mer
+            _ -> do rs <- io $ map toRect `fmap` mapM (getWindowAttributes d) (filter shouldAvoid $ M.keys floating)
+                    let mer = maximumBy (comparing area) $ filter bigEnough $ maxEmptyRectangles r rs
+                    flip (,) (Just $ pruneWindows $ lm { cache = Just ((floating,r),mer) }) `fmap` runLayout w mer
+        where
+            toRect :: WindowAttributes -> Rectangle
+            toRect wa = let b = fi $ wa_border_width wa
+                        in Rectangle (fi $ wa_x wa) (fi $ wa_y wa) (fi $ wa_width wa + 2*b) (fi $ wa_height wa + 2*b)
+            
+            bigEnough :: Rectangle -> Bool
+            bigEnough rect = rect_width rect >= fi (minw lm) && rect_height rect >= fi (minh lm)
+
+            shouldAvoid a = avoidAll lm || a `S.member` chosen lm
+
+    pureMess lm m
+        | Just (AvoidFloatToggle) <- fromMessage m =                               Just $ lm { avoidAll = not (avoidAll lm), cache = Nothing }
+        | Just (AvoidFloatSet s) <- fromMessage m, s /= avoidAll lm =              Just $ lm { avoidAll = s, cache = Nothing }
+        | Just (AvoidFloatClearItems) <- fromMessage m =                           Just $ lm { chosen = S.empty, cache = Nothing }
+        | Just (AvoidFloatAddItem a) <- fromMessage m, a `S.notMember` chosen lm = Just $ lm { chosen = S.insert a (chosen lm), cache = Nothing }
+        | Just (AvoidFloatRemoveItem a) <- fromMessage m, a `S.member` chosen lm = Just $ lm { chosen = S.delete a (chosen lm), cache = Nothing }
+        | Just (AvoidFloatToggleItem a) <- fromMessage m =                         let op = if a `S.member` chosen lm then S.delete else S.insert
+                                                                                   in Just $ lm { chosen = op a (chosen lm), cache = Nothing }
+        | otherwise =                                                              Nothing
+
+pruneWindows :: AvoidFloats Window -> AvoidFloats Window
+pruneWindows lm = case cache lm of
+    Nothing -> lm
+    Just ((floating,_),_) -> lm { chosen = S.filter (flip M.member floating) (chosen lm) }
+
+-- | Find all maximum empty rectangles (MERs) that are axis aligned. This is
+--   done in O(n^2) time using a modified version of the algoprithm MERAlg 1
+--   described in \"On the maximum empty rectangle problem\" by A. Naamad, D.T.
+--   Lee and W.-L HSU. Published in Discrete Applied Mathematics 8 (1984.)
+maxEmptyRectangles :: Rectangle -> [Rectangle] -> [Rectangle]
+maxEmptyRectangles br rectangles = filter (\a -> area a > 0) $ upAndDownEdge ++ noneOrUpEdge ++ downEdge
+    where
+        upAndDownEdge = findGaps br rectangles
+        noneOrUpEdge = concat $ map (everyLower br bottoms) bottoms
+        downEdge = concat $ map maybeToList $ map (bottomEdge br bottoms) bottoms
+        bottoms = sortBy (comparing bottom) $ splitContainers rectangles
+
+everyLower :: Rectangle -> [Rectangle] -> Rectangle -> [Rectangle]
+everyLower br bottoms r = let (rs, boundLeft, boundRight, boundRects) = foldr (everyUpper r) ([], left br, right br, reverse bottoms) bottoms
+                              (boundLeft', boundRight', _) = shrinkBounds boundLeft boundRight boundRects r (top br)
+                          in mkRect boundLeft' boundRight' (top br) (top r) ?: rs
+
+everyUpper
+    :: Rectangle                         -- ^ The current rectangle where the top edge is used.
+    -> Rectangle                         -- ^ The current rectangle where the bottom edge is used.
+    -> ([Rectangle],Int,Int,[Rectangle]) -- ^ List of MERs found so far, left bound, right bound and list of rectangles used for bounds.
+    -> ([Rectangle],Int,Int,[Rectangle])
+everyUpper lower upper (rs, boundLeft, boundRight, boundRects) = (r?:rs, boundLeft', boundRight', boundRects')
+    where
+        r = mkRect boundLeft' boundRight' (bottom upper) (top lower)
+        (boundLeft', boundRight', boundRects') = shrinkBounds boundLeft boundRight boundRects lower (bottom upper)
+
+shrinkBounds :: Int -> Int -> [Rectangle] -> Rectangle -> Int -> (Int, Int, [Rectangle])
+shrinkBounds boundLeft boundRight boundRects lower upperLimit = (boundLeft', boundRight', boundRects')
+    where
+        (shrinkers, boundRects') = span (\a -> bottom a > upperLimit) boundRects
+        (boundLeft', boundRight') = foldr (shrinkBounds' lower) (boundLeft, boundRight) $ filter (\a -> top a < top lower) shrinkers
+
+shrinkBounds' :: Rectangle -> Rectangle -> (Int, Int) -> (Int, Int)
+shrinkBounds' mr r (boundLeft, boundRight)
+    | right r < right mr = (max boundLeft $ right r, boundRight)
+    | left r > left mr = (boundLeft, min boundRight $ left r)
+    | otherwise = (right r, left r) -- r is horizontally covering all of mr; make sure the area of this rectangle will always be 0.
+
+bottomEdge :: Rectangle -> [Rectangle] -> Rectangle -> Maybe Rectangle
+bottomEdge br bottoms r = let rs = filter (\a -> bottom r < bottom a && top a < bottom br) bottoms
+                              boundLeft = maximum $ left br : (filter (< right r) $ map right rs)
+                              boundRight = minimum $ right br : (filter (> left r) $ map left rs)
+                          in if any (\a -> left a <= left r && right r <= right a) rs
+                             then Nothing
+                             else mkRect boundLeft boundRight (bottom r) (bottom br)
+
+-- | Split rectangles that horizontally fully contains another rectangle
+--   without sharing either the left or right side.
+splitContainers :: [Rectangle] -> [Rectangle]
+splitContainers rects = splitContainers' [] $ sortBy (comparing rect_width) rects
+    where
+        splitContainers' :: [Rectangle] -> [Rectangle] -> [Rectangle]
+        splitContainers' res [] = res
+        splitContainers' res (r:rs) = splitContainers' (r:res) $ concat $ map (doSplit r) rs
+
+        doSplit :: Rectangle -> Rectangle -> [Rectangle]
+        doSplit guide r
+            | left guide <= left r || right r <= right guide = [r]
+            | otherwise = let w0 = fi (rect_x guide - rect_x r) + (rect_width guide `div` 2)
+                              w1 = rect_width r - w0
+                          in  [ Rectangle (rect_x r)          (rect_y r) w0 (rect_height r)
+                              , Rectangle (rect_x r + fi w0)  (rect_y r) w1 (rect_height r)
+                              ]
+
+-- | Find all horizontal gaps that are left empty from top to bottom of screen.
+findGaps
+    :: Rectangle    -- ^ Bounding rectangle.
+    -> [Rectangle]  -- ^ List of all rectangles that can cover areas in the bounding rectangle.
+    -> [Rectangle]
+findGaps br rs = let (gaps,end) = foldr findGaps' ([], left br) $ sortBy (flip $ comparing left) $ filter inBounds rs
+                     lastgap = mkRect end (right br) (top br) (bottom br)
+                 in lastgap?:gaps
+    where
+        findGaps' :: Rectangle -> ([Rectangle], Int) -> ([Rectangle], Int)
+        findGaps' r (gaps, end) = let gap = mkRect end (left r) (top br) (bottom br)
+                                  in (gap?:gaps, max end (right r))
+
+        inBounds :: Rectangle -> Bool
+        inBounds r = left r < right br && left br < right r
+
+fi :: (Integral a, Num b) => a -> b
+fi x = fromIntegral x
+
+(?:) :: Maybe a -> [a] -> [a]
+Just x ?: xs = x:xs
+_ ?: xs = xs
+
+left, right, top, bottom, area :: Rectangle -> Int
+left r = fi (rect_x r)
+right r = fi (rect_x r) + fi (rect_width r)
+top r = fi (rect_y r)
+bottom r = fi (rect_y r) + fi (rect_height r)
+area r = fi (rect_width r * rect_height r)
+
+mkRect :: Int -> Int -> Int -> Int -> Maybe Rectangle
+mkRect l r t b = let rect = Rectangle (fi l) (fi t) (fi $ max 0 $ r-l) (fi $ max 0 $ b-t)
+                 in if area rect > 0
+                    then Just rect
+                    else Nothing

XMonad/Layout/BinaryColumn.hs

@@ -0,0 +1,139 @@
+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, TypeSynonymInstances #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  XMonad.Layout.BinaryColumn
+-- Copyright   :  (c) 2009 Ilya Portnov, (c) 2018 Campbell Barton
+-- License     :  BSD3-style (see LICENSE)
+--
+-- Maintainer  :  Campbell Barton <ideasman42@gmail.com>
+-- Stability   :  unstable
+-- Portability :  unportable
+--
+-- Provides Column layout that places all windows in one column.
+-- Each window is half the height of the previous,
+-- except for the last pair of windows.
+--
+-- Note: Originally based on 'XMonad.Layout.Column' with changes:
+--
+-- * Adding/removing windows doesn't resize all other windows.
+-- (last window pair exception).
+-- * Minimum window height option.
+--
+-----------------------------------------------------------------------------
+
+module XMonad.Layout.BinaryColumn (
+                             -- * Usage
+                             -- $usage
+                             BinaryColumn (..)
+                            ) where
+import XMonad
+import qualified XMonad.StackSet
+import qualified Data.List
+
+-- $usage
+-- This module defines layout named BinaryColumn.
+-- It places all windows in one column.
+-- Windows heights are calculated to prevent window resizing whenever
+-- a window is added or removed.
+-- This is done by keeping the last two windows in the stack the same height.
+--
+-- You can use this module by adding following in your @xmonad.hs@:
+--
+-- > import XMonad.Layout.BinaryColumn
+--
+-- Then add layouts to your layoutHook:
+--
+-- > myLayoutHook = BinaryColumn 1.0 32 ||| ...
+--
+-- The first value causes the master window to take exactly half of the screen,
+-- the second ensures that windows are no less than 32 pixels tall.
+--
+-- Shrink/Expand can be used to adjust the first value by increments of 0.1.
+--
+-- * 2.0 uses all space for the master window
+-- (minus the space for windows which get their fixed height).
+-- * 0.0 gives an evenly spaced grid.
+-- Negative values reverse the sizes so the last
+-- window in the stack becomes larger.
+--
+
+data BinaryColumn a = BinaryColumn Float Int
+  deriving (Read, Show)
+
+instance XMonad.LayoutClass BinaryColumn a where
+  pureLayout = columnLayout
+  pureMessage = columnMessage
+
+columnMessage :: BinaryColumn a -> SomeMessage -> Maybe (BinaryColumn a)
+columnMessage (BinaryColumn q min_size) m = fmap resize (fromMessage m)
+  where
+    resize Shrink = BinaryColumn (max (-2.0) (q - 0.1)) min_size
+    resize Expand = BinaryColumn (min   2.0  (q + 0.1)) min_size
+
+columnLayout :: BinaryColumn a
+  -> XMonad.Rectangle
+  -> XMonad.StackSet.Stack a
+  -> [(a, XMonad.Rectangle)]
+columnLayout (BinaryColumn scale min_size) rect stack = zip ws rects
+  where
+    ws = XMonad.StackSet.integrate stack
+    n = length ws
+    scale_abs = abs scale
+    heights_noflip =
+      let
+        -- Regular case: check for min size.
+        f n size div False = let
+          n_fl = (fromIntegral n)
+          n_prev_fl = (fromIntegral (n + 1))
+          div_test = min (div) (n_prev_fl)
+          value_test = (toInteger (round ((fromIntegral size) / div_test)))
+          value_max = size - (toInteger (min_size * n))
+          (value, divide_next, no_room) =
+            if value_test < value_max then
+              (value_test, div, False)
+            else
+              (value_max, n_fl, True)
+          size_next = size - value
+          n_next = n - 1
+          in value
+          : f n_next size_next divide_next no_room
+        -- Fallback case: when windows have reached min size
+        -- simply create an even grid with the remaining space.
+        f n size div True = let
+          n_fl = (fromIntegral n)
+          value_even = ((fromIntegral size) / div)
+          value = (toInteger (round value_even))
+
+          n_next = n - 1
+          size_next = size - value
+          divide_next = n_fl
+          in value
+          : f n_next size_next n_fl True
+        -- Last item: included twice.
+        f 0 size div no_room_prev =
+          [size];
+      in f
+         n_init size_init divide_init False
+      where
+        n_init = n - 1
+        size_init = (toInteger (rect_height rect))
+        divide_init =
+          if scale_abs == 0.0 then
+            (fromIntegral n)
+          else
+            (1.0 / (0.5 * scale_abs))
+
+    heights =
+      if (scale < 0.0) then
+        Data.List.reverse (take n heights_noflip)
+      else
+        heights_noflip
+
+    ys = [fromIntegral $ sum $ take k heights | k <- [0..n - 1]]
+    rects = map (mkRect rect) $ zip heights ys
+
+mkRect :: XMonad.Rectangle
+  -> (Integer,XMonad.Position)
+  -> XMonad.Rectangle
+mkRect (XMonad.Rectangle xs ys ws _) (h, y) =
+  XMonad.Rectangle xs (ys + fromIntegral y) ws (fromInteger h)

XMonad/Layout/BinarySpacePartition.hs

@@ -0,0 +1,795 @@
+{-# LANGUAGE PatternGuards #-}
+{-# LANGUAGE DoAndIfThenElse #-}
+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, DeriveDataTypeable #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  XMonad.Layout.BinarySpacePartition
+-- Copyright   :  (c) 2013 Ben Weitzman    <benweitzman@gmail.com>
+--                    2015 Anton Pirogov   <anton.pirogov@gmail.com>
+-- License     :  BSD3-style (see LICENSE)
+--
+-- Maintainer  :  Ben Weitzman <benweitzman@gmail.com>
+-- Stability   :  unstable
+-- Portability :  unportable
+--
+-- Layout where new windows will split the focused window in half, based off of BSPWM
+--
+-----------------------------------------------------------------------------
+
+module XMonad.Layout.BinarySpacePartition (
+  -- * Usage
+  -- $usage
+    emptyBSP
+  , BinarySpacePartition
+  , Rotate(..)
+  , Swap(..)
+  , ResizeDirectional(..)
+  , TreeRotate(..)
+  , TreeBalance(..)
+  , FocusParent(..)
+  , SelectMoveNode(..)
+  , Direction2D(..)
+  ) where
+
+import XMonad
+import qualified XMonad.StackSet as W
+import XMonad.Util.Stack hiding (Zipper)
+import XMonad.Util.Types
+
+-- for mouse resizing
+import XMonad.Layout.WindowArranger (WindowArrangerMsg(SetGeometry))
+-- for "focus parent" node border
+import XMonad.Util.XUtils
+
+import qualified Data.Map as M
+import qualified Data.Set as S
+import Data.List ((\\), elemIndex, foldl')
+import Data.Maybe (fromMaybe, isNothing, isJust, mapMaybe, catMaybes)
+import Control.Applicative
+import Control.Monad
+import Data.Ratio ((%))
+
+-- $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)
+--
+
+-- |Message for rotating the binary tree around the parent node of the window to the left or right
+data TreeRotate = RotateL | RotateR deriving Typeable
+instance Message TreeRotate
+
+-- |Message to balance the tree in some way (Balance retiles the windows, Equalize changes ratios)
+data TreeBalance = Balance | Equalize deriving Typeable
+instance Message TreeBalance
+
+-- |Message for resizing one of the cells in the BSP
+data ResizeDirectional = ExpandTowards Direction2D | ShrinkFrom Direction2D | MoveSplit Direction2D deriving Typeable
+instance Message ResizeDirectional
+
+-- |Message for rotating a split (horizontal/vertical) in the BSP
+data Rotate = Rotate deriving Typeable
+instance Message Rotate
+
+-- |Message for swapping the left child of a split with the right child of split
+data Swap = Swap deriving Typeable
+instance Message Swap
+
+-- |Message to cyclically select the parent node instead of the leaf
+data FocusParent = FocusParent deriving Typeable
+instance Message FocusParent
+
+-- |Message to move nodes inside the tree
+data SelectMoveNode = SelectNode | MoveNode deriving Typeable
+instance Message SelectMoveNode
+
+data Axis = Horizontal | Vertical deriving (Show, Read, Eq)
+
+oppositeDirection :: Direction2D -> Direction2D
+oppositeDirection U = D
+oppositeDirection D = U
+oppositeDirection L = R
+oppositeDirection R = L
+
+oppositeAxis :: Axis -> Axis
+oppositeAxis Vertical = Horizontal
+oppositeAxis Horizontal = Vertical
+
+toAxis :: Direction2D -> Axis
+toAxis U = Horizontal
+toAxis D = Horizontal
+toAxis L = Vertical
+toAxis R = Vertical
+
+split :: Axis -> Rational -> Rectangle -> (Rectangle, Rectangle)
+split Horizontal r (Rectangle sx sy sw sh) = (r1, r2) where
+    r1 = Rectangle sx sy sw sh'
+    r2 = Rectangle sx (sy + fromIntegral sh') sw (sh - sh')
+    sh' = floor $ fromIntegral sh * r
+split Vertical r (Rectangle sx sy sw sh) = (r1, r2) where
+    r1 = Rectangle sx sy sw' sh
+    r2 = Rectangle (sx + fromIntegral sw') sy (sw - sw') sh
+    sw' = floor $ fromIntegral sw * r
+
+data Split = Split { axis :: Axis
+                   , ratio :: Rational
+                   } deriving (Show, Read, Eq)
+
+oppositeSplit :: Split -> Split
+oppositeSplit (Split d r) = Split (oppositeAxis d) r
+
+increaseRatio :: Split -> Rational -> Split
+increaseRatio (Split d r) delta = Split d (min 0.9 (max 0.1 (r + delta)))
+
+resizeDiff :: Rational
+resizeDiff = 0.05
+
+
+data Tree a = Leaf Int | Node { value :: a
+                          , left :: Tree a
+                          , right :: Tree a
+                          } deriving (Show, Read, Eq)
+
+numLeaves :: Tree a -> Int
+numLeaves (Leaf _) = 1
+numLeaves (Node _ l r) = numLeaves l + numLeaves r
+
+-- right or left rotation of a (sub)tree, no effect if rotation not possible
+rotTree :: Direction2D -> Tree a -> Tree a
+rotTree _ (Leaf n) = Leaf n
+rotTree R n@(Node _ (Leaf _) _) = n
+rotTree L n@(Node _ _ (Leaf _)) = n
+rotTree R (Node sp (Node sp2 l2 r2) r) = Node sp2 l2 (Node sp r2 r)
+rotTree L (Node sp l (Node sp2 l2 r2)) = Node sp2 (Node sp l l2) r2
+rotTree _ t = t
+
+
+data Crumb a = LeftCrumb a (Tree a) | RightCrumb a (Tree a) deriving (Show, Read, Eq)
+
+swapCrumb :: Crumb a -> Crumb a
+swapCrumb (LeftCrumb s t) = RightCrumb s t
+swapCrumb (RightCrumb s t) = LeftCrumb s t
+
+parentVal :: Crumb a -> a
+parentVal (LeftCrumb s _) = s
+parentVal (RightCrumb s _) = s
+
+modifyParentVal :: (a -> a) -> Crumb a -> Crumb a
+modifyParentVal f (LeftCrumb s t) = LeftCrumb (f s) t
+modifyParentVal f (RightCrumb s t) = RightCrumb (f s) t
+
+type Zipper a = (Tree a, [Crumb a])
+
+toZipper :: Tree a -> Zipper a
+toZipper t = (t, [])
+
+goLeft :: Zipper a -> Maybe (Zipper a)
+goLeft (Leaf _, _) = Nothing
+goLeft (Node x l r, bs) = Just (l, LeftCrumb x r:bs)
+
+goRight :: Zipper a -> Maybe (Zipper a)
+goRight (Leaf _, _) = Nothing
+goRight (Node x l r, bs) = Just (r, RightCrumb x l:bs)
+
+goUp :: Zipper a -> Maybe (Zipper a)
+goUp (_, []) = Nothing
+goUp (t, LeftCrumb x r:cs) = Just (Node x t r, cs)
+goUp (t, RightCrumb x l:cs) = Just (Node x l t, cs)
+
+goSibling :: Zipper a -> Maybe (Zipper a)
+goSibling (_, []) = Nothing
+goSibling z@(_, LeftCrumb _ _:_) = Just z >>= goUp >>= goRight
+goSibling z@(_, RightCrumb _ _:_) = Just z >>= goUp >>= goLeft
+
+top :: Zipper a -> Zipper a
+top z = case goUp z of
+          Nothing -> z
+          Just z' -> top z'
+
+toTree :: Zipper a -> Tree a
+toTree = fst . top
+
+goToNthLeaf :: Int -> Zipper a -> Maybe (Zipper a)
+goToNthLeaf _ z@(Leaf _, _) = Just z
+goToNthLeaf n z@(t, _) =
+  if numLeaves (left t) > n
+  then do z' <- goLeft z
+          goToNthLeaf n z'
+  else do z' <- goRight z
+          goToNthLeaf (n - (numLeaves . left $ t)) z'
+
+toggleSplits :: Tree Split -> Tree Split
+toggleSplits (Leaf l) = Leaf l
+toggleSplits (Node s l r) = Node (oppositeSplit s) (toggleSplits l) (toggleSplits r)
+
+splitCurrent :: Zipper Split -> Maybe (Zipper Split)
+splitCurrent (Leaf _, []) = Just (Node (Split Vertical 0.5) (Leaf 0) (Leaf 0), [])
+splitCurrent (Leaf _, crumb:cs) = Just (Node (Split (oppositeAxis . axis . parentVal $ crumb) 0.5) (Leaf 0) (Leaf 0), crumb:cs)
+splitCurrent (n, []) = Just (Node (Split Vertical 0.5) (Leaf 0) (toggleSplits n), [])
+splitCurrent (n, crumb:cs) = Just (Node (Split (oppositeAxis . axis . parentVal $ crumb) 0.5) (Leaf 0) (toggleSplits n), crumb:cs)
+
+removeCurrent :: Zipper a -> Maybe (Zipper a)
+removeCurrent (Leaf _, LeftCrumb _ r:cs) = Just (r, cs)
+removeCurrent (Leaf _, RightCrumb _ l:cs) = Just (l, cs)
+removeCurrent (Leaf _, []) = Nothing
+removeCurrent (Node _ (Leaf _) r@(Node _ _ _), cs) = Just (r, cs)
+removeCurrent (Node _ l@(Node _ _ _) (Leaf _), cs) = Just (l, cs)
+removeCurrent (Node _ (Leaf _) (Leaf _), cs) = Just (Leaf 0, cs)
+removeCurrent z@(Node _ _ _, _) = goLeft z >>= removeCurrent
+
+rotateCurrent :: Zipper Split -> Maybe (Zipper Split)
+rotateCurrent l@(_, []) = Just l
+rotateCurrent (n, c:cs) = Just (n, modifyParentVal oppositeSplit c:cs)
+
+swapCurrent :: Zipper a -> Maybe (Zipper a)
+swapCurrent l@(_, []) = Just l
+swapCurrent (n, c:cs) = Just (n, swapCrumb c:cs)
+
+isAllTheWay :: Direction2D -> Zipper Split -> Bool
+isAllTheWay _ (_, []) = True
+isAllTheWay R (_, LeftCrumb s _:_)
+  | axis s == Vertical = False
+isAllTheWay L (_, RightCrumb s _:_)
+  | axis s == Vertical = False
+isAllTheWay D (_, LeftCrumb s _:_)
+  | axis s == Horizontal = False
+isAllTheWay U (_, RightCrumb s _:_)
+  | axis s == Horizontal = False
+isAllTheWay dir z = fromMaybe False $ goUp z >>= Just . isAllTheWay dir
+
+expandTreeTowards :: Direction2D -> Zipper Split -> Maybe (Zipper Split)
+expandTreeTowards _ z@(_, []) = Just z
+expandTreeTowards dir z
+  | isAllTheWay dir z = shrinkTreeFrom (oppositeDirection dir) z
+expandTreeTowards R (t, LeftCrumb s r:cs)
+  | axis s == Vertical = Just (t, LeftCrumb (increaseRatio s resizeDiff) r:cs)
+expandTreeTowards L (t, RightCrumb s l:cs)
+  | axis s == Vertical = Just (t, RightCrumb (increaseRatio s (-resizeDiff)) l:cs)
+expandTreeTowards D (t, LeftCrumb s r:cs)
+  | axis s == Horizontal = Just (t, LeftCrumb (increaseRatio s resizeDiff) r:cs)
+expandTreeTowards U (t, RightCrumb s l:cs)
+  | axis s == Horizontal = Just (t, RightCrumb (increaseRatio s (-resizeDiff)) l:cs)
+expandTreeTowards dir z = goUp z >>= expandTreeTowards dir
+
+shrinkTreeFrom :: Direction2D -> Zipper Split -> Maybe (Zipper Split)
+shrinkTreeFrom _ z@(_, []) = Just z
+shrinkTreeFrom R z@(_, LeftCrumb s _:_)
+  | axis s == Vertical = Just z >>= goSibling >>= expandTreeTowards L
+shrinkTreeFrom L z@(_, RightCrumb s _:_)
+  | axis s == Vertical = Just z >>= goSibling >>= expandTreeTowards R
+shrinkTreeFrom D z@(_, LeftCrumb s _:_)
+  | axis s == Horizontal = Just z >>= goSibling >>= expandTreeTowards U
+shrinkTreeFrom U z@(_, RightCrumb s _:_)
+  | axis s == Horizontal = Just z >>= goSibling >>= expandTreeTowards D
+shrinkTreeFrom dir z = goUp z >>= shrinkTreeFrom dir
+
+-- Direction2D refers to which direction the divider should move.
+autoSizeTree :: Direction2D -> Zipper Split -> Maybe (Zipper Split)
+autoSizeTree _ z@(_, []) = Just z
+autoSizeTree d z =
+    Just z >>= getSplit (toAxis d) >>= resizeTree d
+
+-- resizing once found the correct split. YOU MUST FIND THE RIGHT SPLIT FIRST.
+resizeTree :: Direction2D -> Zipper Split -> Maybe (Zipper Split)
+resizeTree _ z@(_, []) = Just z
+resizeTree R z@(_, LeftCrumb _ _:_) =
+  Just z >>= expandTreeTowards R
+resizeTree L z@(_, LeftCrumb _ _:_) =
+  Just z >>= shrinkTreeFrom    R
+resizeTree U z@(_, LeftCrumb _ _:_) =
+  Just z >>= shrinkTreeFrom    D
+resizeTree D z@(_, LeftCrumb _ _:_) =
+  Just z >>= expandTreeTowards D
+resizeTree R z@(_, RightCrumb _ _:_) =
+  Just z >>= shrinkTreeFrom    L
+resizeTree L z@(_, RightCrumb _ _:_) =
+  Just z >>= expandTreeTowards L
+resizeTree U z@(_, RightCrumb _ _:_) =
+  Just z >>= expandTreeTowards U
+resizeTree D z@(_, RightCrumb _ _:_) =
+  Just z >>= shrinkTreeFrom    U
+
+getSplit :: Axis -> Zipper Split -> Maybe (Zipper Split)
+getSplit _ (_, []) = Nothing
+getSplit d z =
+ do let fs = findSplit d z
+    if isNothing fs
+      then findClosest d z
+      else fs
+
+findClosest :: Axis -> Zipper Split -> Maybe (Zipper Split)
+findClosest _ z@(_, []) = Just z
+findClosest d z@(_, LeftCrumb s _:_)
+  | axis s == d = Just z
+findClosest d z@(_, RightCrumb s _:_)
+  | axis s == d = Just z
+findClosest d z = goUp z >>= findClosest d
+
+findSplit :: Axis -> Zipper Split -> Maybe (Zipper Split)
+findSplit _ (_, []) = Nothing
+findSplit d z@(_, LeftCrumb s _:_)
+  | axis s == d = Just z
+findSplit d z = goUp z >>= findSplit d
+
+resizeSplit :: Direction2D -> (Rational,Rational) -> Zipper Split -> Maybe (Zipper Split)
+resizeSplit _ _ z@(_, []) = Just z
+resizeSplit dir (xsc,ysc) z = case goToBorder dir z of
+  Nothing -> Just z
+  Just (t, crumb) -> Just $ case dir of
+    R -> (t{value=sp{ratio=scaleRatio (ratio sp) xsc}}, crumb)
+    D -> (t{value=sp{ratio=scaleRatio (ratio sp) ysc}}, crumb)
+    L -> (t{value=sp{ratio=1-scaleRatio (1-ratio sp) xsc}}, crumb)
+    U -> (t{value=sp{ratio=1-scaleRatio (1-ratio sp) ysc}}, crumb)
+    where sp = value t
+          scaleRatio r fac = min 0.9 $ max 0.1 $ r*fac
+
+-- starting from a leaf, go to node representing a border of the according window
+goToBorder :: Direction2D -> Zipper Split -> Maybe (Zipper Split)
+goToBorder L z@(_, RightCrumb (Split Vertical _) _:_) = goUp z
+goToBorder L z = goUp z >>= goToBorder L
+goToBorder R z@(_, LeftCrumb  (Split Vertical _) _:_) = goUp z
+goToBorder R z = goUp z >>= goToBorder R
+goToBorder U z@(_, RightCrumb (Split Horizontal _) _:_) = goUp z
+goToBorder U z = goUp z >>= goToBorder U
+goToBorder D z@(_, LeftCrumb  (Split Horizontal _) _:_) = goUp z
+goToBorder D z = goUp z >>= goToBorder D
+
+-- takes a list of indices and numerates the leaves of a given tree
+numerate :: [Int] -> Tree a -> Tree a
+numerate ns t = snd $ num ns t
+  where num (n:nns) (Leaf _) = (nns, Leaf n)
+        num [] (Leaf _) = ([], Leaf 0)
+        num n (Node s l r) = (n'', Node s nl nr)
+          where (n', nl)  = num n l
+                (n'', nr) = num n' r
+
+-- return values of leaves from left to right as list
+flatten :: Tree a -> [Int]
+flatten (Leaf n) = [n]
+flatten (Node _ l r) = flatten l++flatten r
+
+-- adjust ratios to make window areas equal
+equalize :: Zipper Split -> Maybe (Zipper Split)
+equalize (t, cs) = Just (eql t, cs)
+  where eql (Leaf n) = Leaf n
+        eql n@(Node s l r) = Node s{ratio=fromIntegral (numLeaves l) % fromIntegral (numLeaves n)}
+                                  (eql l) (eql r)
+
+-- generate a symmetrical balanced tree for n leaves from given tree, preserving leaf labels
+balancedTree :: Zipper Split -> Maybe (Zipper Split)
+balancedTree (t, cs) =  Just (numerate (flatten t) $ balanced (numLeaves t), cs)
+  where balanced 1 = Leaf 0
+        balanced 2 = Node (Split Horizontal 0.5) (Leaf 0) (Leaf 0)
+        balanced m = Node (Split Horizontal 0.5) (balanced (m`div`2)) (balanced (m-m`div`2))
+
+-- attempt to rotate splits optimally in order choose more quad-like rects
+optimizeOrientation :: Rectangle -> Zipper Split -> Maybe (Zipper Split)
+optimizeOrientation rct (t, cs) = Just (opt t rct, cs)
+  where opt (Leaf v) _ = Leaf v
+        opt (Node sp l r) rect = Node sp' (opt l lrect) (opt r rrect)
+         where (Rectangle _ _ w1 h1,Rectangle _ _ w2 h2) = split (axis sp) (ratio sp) rect
+               (Rectangle _ _ w3 h3,Rectangle _ _ w4 h4) = split (axis $ oppositeSplit sp) (ratio sp) rect
+               f w h = if w > h then w'/h' else h'/w' where (w',h') = (fromIntegral w :: Double, fromIntegral h :: Double)
+               wratio = min (f w1 h1) (f w2 h2)
+               wratio' = min (f w3 h3) (f w4 h4)
+               sp' = if wratio<wratio' then sp else oppositeSplit sp
+               (lrect, rrect) = split (axis sp') (ratio sp') rect
+
+
+-- initially focused leaf, path from root to selected node, window ids of borders highlighting the selection
+data NodeRef = NodeRef { refLeaf :: Int, refPath :: [Direction2D], refWins :: [Window] } deriving (Show,Read,Eq)
+noRef :: NodeRef
+noRef = NodeRef (-1) [] []
+
+goToNode :: NodeRef -> Zipper a -> Maybe (Zipper a)
+goToNode (NodeRef _ dirs _) z = foldM gofun z dirs
+  where gofun z' L = goLeft z'
+        gofun z' R = goRight z'
+        gofun _ _ = Nothing
+
+toNodeRef :: Int -> Maybe (Zipper Split) -> NodeRef
+toNodeRef _ Nothing = noRef
+toNodeRef l (Just (_, cs)) = NodeRef l (reverse $ map crumbToDir cs) []
+  where crumbToDir (LeftCrumb _ _) = L
+        crumbToDir (RightCrumb _ _) = R
+
+-- returns the leaf a noderef is leading to, if any
+nodeRefToLeaf :: NodeRef -> Maybe (Zipper a) -> Maybe Int
+nodeRefToLeaf n (Just z) = case goToNode n z of
+  Just (Leaf l, _) -> Just l
+  Just (Node _ _ _, _) -> Nothing
+  Nothing -> Nothing
+nodeRefToLeaf _ Nothing = Nothing
+
+leafToNodeRef :: Int -> BinarySpacePartition a -> NodeRef
+leafToNodeRef l b = toNodeRef l (makeZipper b >>= goToNthLeaf l)
+
+data BinarySpacePartition a = BinarySpacePartition { getOldRects :: [(Window,Rectangle)]
+                                                   , getFocusedNode :: NodeRef
+                                                   , getSelectedNode :: NodeRef
+                                                   , getTree :: Maybe (Tree Split) } deriving (Show, Read,Eq)
+
+-- | an empty BinarySpacePartition to use as a default for adding windows to.
+emptyBSP :: BinarySpacePartition a
+emptyBSP = BinarySpacePartition [] noRef noRef Nothing
+
+makeBSP :: Tree Split -> BinarySpacePartition a
+makeBSP = BinarySpacePartition [] noRef noRef . Just
+
+makeZipper :: BinarySpacePartition a -> Maybe (Zipper Split)
+makeZipper (BinarySpacePartition _ _ _ Nothing) = Nothing
+makeZipper (BinarySpacePartition _ _ _ (Just t)) = Just . toZipper $ t
+
+size :: BinarySpacePartition a -> Int
+size = maybe 0 numLeaves . getTree
+
+zipperToBinarySpacePartition :: Maybe (Zipper Split) -> BinarySpacePartition b
+zipperToBinarySpacePartition Nothing = emptyBSP
+zipperToBinarySpacePartition (Just z) = BinarySpacePartition [] noRef noRef . Just . toTree . top $ z
+
+rectangles :: BinarySpacePartition a -> Rectangle -> [Rectangle]
+rectangles (BinarySpacePartition _ _ _ Nothing) _ = []
+rectangles (BinarySpacePartition _ _ _ (Just (Leaf _))) rootRect = [rootRect]
+rectangles (BinarySpacePartition _ _ _ (Just node)) rootRect =
+    rectangles (makeBSP . left $ node) leftBox ++
+    rectangles (makeBSP . right $ node) rightBox
+    where (leftBox, rightBox) = split (axis info) (ratio info) rootRect
+          info = value node
+
+getNodeRect :: BinarySpacePartition a -> Rectangle -> NodeRef -> Rectangle
+getNodeRect b r n = fromMaybe (Rectangle 0 0 1 1) (makeZipper b >>= goToNode n >>= getRect [])
+  where getRect ls (_, []) = Just $ foldl (\r' (s,f) -> f $ split' s r') r ls
+        getRect ls z@(_, LeftCrumb s _:_) = goUp z >>= getRect ((s,fst):ls)
+        getRect ls z@(_, RightCrumb s _:_) = goUp z >>= getRect ((s,snd):ls)
+        split' s = split (axis s) (ratio s)
+
+doToNth :: (Zipper Split -> Maybe (Zipper Split)) -> BinarySpacePartition a -> BinarySpacePartition a
+doToNth f b = b{getTree=getTree $ zipperToBinarySpacePartition $ makeZipper b >>= goToNode (getFocusedNode b) >>= f}
+
+splitNth :: BinarySpacePartition a -> BinarySpacePartition a
+splitNth (BinarySpacePartition _ _ _ Nothing) = makeBSP (Leaf 0)
+splitNth b = doToNth splitCurrent b
+
+removeNth :: BinarySpacePartition a -> BinarySpacePartition a
+removeNth (BinarySpacePartition _ _ _ Nothing) = emptyBSP
+removeNth (BinarySpacePartition _ _ _ (Just (Leaf _))) = emptyBSP
+removeNth b = doToNth removeCurrent b
+
+rotateNth :: BinarySpacePartition a -> BinarySpacePartition a
+rotateNth (BinarySpacePartition _ _ _ Nothing) = emptyBSP
+rotateNth b@(BinarySpacePartition _ _ _ (Just (Leaf _))) = b
+rotateNth b = doToNth rotateCurrent b
+
+swapNth :: BinarySpacePartition a -> BinarySpacePartition a
+swapNth (BinarySpacePartition _ _ _ Nothing) = emptyBSP
+swapNth b@(BinarySpacePartition _ _ _ (Just (Leaf _))) = b
+swapNth b = doToNth swapCurrent b
+
+growNthTowards :: Direction2D -> BinarySpacePartition a -> BinarySpacePartition a
+growNthTowards _ (BinarySpacePartition _ _ _ Nothing) = emptyBSP
+growNthTowards _ b@(BinarySpacePartition _ _ _ (Just (Leaf _))) = b
+growNthTowards dir b = doToNth (expandTreeTowards dir) b
+
+shrinkNthFrom :: Direction2D -> BinarySpacePartition a -> BinarySpacePartition a
+shrinkNthFrom _ (BinarySpacePartition _ _ _ Nothing)= emptyBSP
+shrinkNthFrom _ b@(BinarySpacePartition _ _ _ (Just (Leaf _))) = b
+shrinkNthFrom dir b = doToNth (shrinkTreeFrom dir) b
+
+autoSizeNth :: Direction2D -> BinarySpacePartition a -> BinarySpacePartition a
+autoSizeNth _ (BinarySpacePartition _ _ _ Nothing) = emptyBSP
+autoSizeNth _ b@(BinarySpacePartition _ _ _ (Just (Leaf _))) = b
+autoSizeNth dir b = doToNth (autoSizeTree dir) b
+
+resizeSplitNth :: Direction2D -> (Rational,Rational) -> BinarySpacePartition a -> BinarySpacePartition a
+resizeSplitNth _ _ (BinarySpacePartition _ _ _ Nothing) = emptyBSP
+resizeSplitNth _ _ b@(BinarySpacePartition _ _ _ (Just (Leaf _))) = b
+resizeSplitNth dir sc b = doToNth (resizeSplit dir sc) b
+
+-- rotate tree left or right around parent of nth leaf
+rotateTreeNth :: Direction2D -> BinarySpacePartition a -> BinarySpacePartition a
+rotateTreeNth _ (BinarySpacePartition _ _ _ Nothing) = emptyBSP
+rotateTreeNth U b = b
+rotateTreeNth D b = b
+rotateTreeNth dir b@(BinarySpacePartition _ _ _ (Just _)) =
+  doToNth (\t -> case goUp t of
+                Nothing     -> Just t
+                Just (t', c) -> Just (rotTree dir t', c)) b
+
+equalizeNth :: BinarySpacePartition a -> BinarySpacePartition a
+equalizeNth (BinarySpacePartition _ _ _ Nothing) = emptyBSP
+equalizeNth b@(BinarySpacePartition _ _ _ (Just (Leaf _))) = b
+equalizeNth b = doToNth equalize b
+
+rebalanceNth :: BinarySpacePartition a -> Rectangle -> BinarySpacePartition a
+rebalanceNth (BinarySpacePartition _ _ _ Nothing) _ = emptyBSP
+rebalanceNth b@(BinarySpacePartition _ _ _ (Just (Leaf _))) _ = b
+rebalanceNth b r = doToNth (balancedTree >=> optimizeOrientation r) b
+
+flattenLeaves :: BinarySpacePartition a -> [Int]
+flattenLeaves (BinarySpacePartition _ _ _ Nothing) = []
+flattenLeaves (BinarySpacePartition _ _ _ (Just t)) = flatten t
+
+-- we do this before an action to look afterwards which leaves moved where
+numerateLeaves :: BinarySpacePartition a -> BinarySpacePartition a
+numerateLeaves b@(BinarySpacePartition _ _ _ Nothing) = b
+numerateLeaves b@(BinarySpacePartition _ _ _ (Just t)) = b{getTree=Just $ numerate ns t}
+  where ns = [0..(numLeaves t-1)]
+
+-- if there is a selected and focused node and the focused is not a part of selected,
+-- move selected node to be a child of focused node
+moveNode :: BinarySpacePartition a -> BinarySpacePartition a
+moveNode b@(BinarySpacePartition _ (NodeRef (-1) _ _) _ _) = b
+moveNode b@(BinarySpacePartition _ _ (NodeRef (-1) _ _) _) = b
+moveNode b@(BinarySpacePartition _ _ _ Nothing) = b
+moveNode b@(BinarySpacePartition _ f s (Just ot)) =
+  case makeZipper b >>= goToNode s of
+    Just (n, LeftCrumb _ t:cs)  -> b{getTree=Just $ insert n $ top (t, cs)}
+    Just (n, RightCrumb _ t:cs) -> b{getTree=Just $ insert n $ top (t, cs)}
+    _ -> b
+  where insert t z = case goToNode f z of
+          Nothing -> ot --return original tree (abort)
+          Just (n, c:cs) -> toTree (Node (Split (oppositeAxis . axis . parentVal $ c) 0.5) t n, c:cs)
+          Just (n, []) -> toTree (Node (Split Vertical 0.5) t n, [])
+
+------------------------------------------
+
+-- returns index of focused window or 0 for empty stack
+index :: W.Stack a -> Int
+index s = case toIndex (Just s) of
+            (_, Nothing) -> 0
+            (_, Just int) -> int
+
+--move windows to new positions according to tree transformations, keeping focus on originally focused window
+--CAREFUL here! introduce a bug here and have fun debugging as your windows start to disappear or explode
+adjustStack :: Maybe (W.Stack Window)  --original stack
+            -> Maybe (W.Stack Window)  --stack without floating windows
+            -> [Window]                --just floating windows of this WS
+            -> Maybe (BinarySpacePartition Window) -- Tree with numbered leaves telling what to move where
+            -> Maybe (W.Stack Window)  --resulting stack
+adjustStack orig Nothing _ _ = orig    --no new stack -> no changes
+adjustStack orig _ _ Nothing = orig    --empty tree   -> no changes
+adjustStack orig s fw (Just b) =
+ if length ls<length ws then orig      --less leaves than non-floating windows -> tree incomplete, no changes
+ else fromIndex ws' fid'
+ where ws' = mapMaybe (`M.lookup` wsmap) ls ++ fw
+       fid' = fromMaybe 0 $ elemIndex focused ws'
+       wsmap = M.fromList $ zip [0..] ws -- map: old index in list -> window
+       ls = flattenLeaves b              -- get new index ordering from tree
+       (ws,fid) = toIndex s
+       focused = ws !! fromMaybe 0 fid
+
+--replace the window stack of the managed workspace with our modified stack
+replaceStack :: Maybe (W.Stack Window) -> X ()
+replaceStack s = do
+  st <- get
+  let wset = windowset st
+      cur  = W.current wset
+      wsp  = W.workspace cur
+  put st{windowset=wset{W.current=cur{W.workspace=wsp{W.stack=s}}}}
+
+replaceFloating :: M.Map Window W.RationalRect -> X ()
+replaceFloating wsm = do
+  st <- get
+  let wset = windowset st
+  put st{windowset=wset{W.floating=wsm}}
+
+-- some helpers to filter windows
+--
+getFloating :: X [Window]
+getFloating = (M.keys . W.floating) <$> gets windowset -- all floating windows
+
+getStackSet :: X (Maybe (W.Stack Window))
+getStackSet = (W.stack . W.workspace . W.current) <$> gets windowset -- windows on this WS (with floating)
+
+getScreenRect :: X Rectangle
+getScreenRect = (screenRect . W.screenDetail . W.current) <$> gets windowset
+
+withoutFloating :: [Window] -> Maybe (W.Stack Window) -> Maybe (W.Stack Window)
+withoutFloating fs = maybe Nothing (unfloat fs)
+
+-- ignore messages if current focus is on floating window, otherwise return stack without floating
+unfloat :: [Window] -> W.Stack Window -> Maybe (W.Stack Window)
+unfloat fs s = if W.focus s `elem` fs
+      then Nothing
+      else Just $ s{W.up = W.up s \\ fs, W.down = W.down s \\ fs}
+
+instance LayoutClass BinarySpacePartition Window where
+  doLayout b r s = do
+    let b' = layout b
+    b'' <- updateNodeRef b' (size b/=size b') r
+    let rs = rectangles b'' r
+        wrs = zip ws rs
+    return (wrs, Just b''{getOldRects=wrs})
+    where
+      ws = W.integrate s
+      l = length ws
+      layout bsp
+        | l == sz = bsp
+        | l > sz = layout $ splitNth bsp
+        | otherwise = layout $ removeNth bsp
+        where sz = size bsp
+
+  handleMessage b_orig m
+   | Just msg@(SetGeometry _) <- fromMessage m = handleResize b msg
+   | Just FocusParent <- fromMessage m = do
+       let n = getFocusedNode b
+       let n' = toNodeRef (refLeaf n) (makeZipper b >>= goToNode n >>= goUp)
+       return $ Just b{getFocusedNode=n'{refWins=refWins n}}
+   | Just SelectNode <- fromMessage m = do
+       let n = getFocusedNode b
+       let s = getSelectedNode b
+       removeBorder $ refWins s
+       let s' = if refLeaf n == refLeaf s && refPath n == refPath s
+                then noRef else n{refWins=[]}
+       return $ Just b{getSelectedNode=s'}
+   | otherwise = do
+       ws <- getStackSet
+       fs <- getFloating
+       r <- getScreenRect
+       -- removeBorder $ refWins $ getSelectedNode b
+       let lws = withoutFloating fs ws                                    -- tiled windows on WS
+           lfs = maybe [] W.integrate ws \\ maybe [] W.integrate lws      -- untiled windows on WS
+           b'  = handleMesg r                -- transform tree (concerns only tiled windows)
+           ws' = adjustStack ws lws lfs b'   -- apply transformation to window stack, reintegrate floating wins
+       replaceStack ws'
+       return b'
+    where handleMesg r = msum [ fmap resize        (fromMessage m)
+                              , fmap rotate        (fromMessage m)
+                              , fmap swap          (fromMessage m)
+                              , fmap rotateTr      (fromMessage m)
+                              , fmap (balanceTr r) (fromMessage m)
+                              , fmap move          (fromMessage m)
+                              ]
+          resize (ExpandTowards dir) = growNthTowards dir b
+          resize (ShrinkFrom dir) = shrinkNthFrom dir b
+          resize (MoveSplit dir) = autoSizeNth dir b
+          rotate Rotate = resetFoc $ rotateNth b
+          swap Swap = resetFoc $ swapNth b
+          rotateTr RotateL = resetFoc $ rotateTreeNth L b
+          rotateTr RotateR = resetFoc $ rotateTreeNth R b
+          balanceTr _ Equalize = resetFoc $ equalizeNth b
+          balanceTr r Balance  = resetFoc $ rebalanceNth b r
+          move MoveNode = resetFoc $ moveNode b
+          move SelectNode = b --should not happen here, is done above, as we need X monad
+
+          b = numerateLeaves b_orig
+          resetFoc bsp = bsp{getFocusedNode=(getFocusedNode bsp){refLeaf=(-1)}
+                            ,getSelectedNode=(getSelectedNode bsp){refLeaf=(-1)}}
+
+  description _  = "BSP"
+
+-- React to SetGeometry message to work with BorderResize/MouseResize
+handleResize :: BinarySpacePartition Window -> WindowArrangerMsg -> X (Maybe (BinarySpacePartition Window))
+handleResize b (SetGeometry newrect@(Rectangle _ _ w h)) = do
+  ws <- getStackSet
+  fs <- getFloating
+  case W.focus <$> ws of
+    Nothing -> return Nothing
+    Just win -> do
+      (_,_,_,_,_,mx,my,_) <- withDisplay (\d -> io $ queryPointer d win)
+      let oldrect@(Rectangle _ _ ow oh) = fromMaybe (Rectangle 0 0 0 0) $ lookup win $ getOldRects b
+      let (xsc,ysc)   = (fi w % fi ow, fi h % fi oh)
+          (xsc',ysc') = (rough xsc, rough ysc)
+          dirs = changedDirs oldrect newrect (fi mx,fi my)
+          n = elemIndex win $ maybe [] W.integrate $ withoutFloating fs ws
+      -- unless (isNothing dir) $ debug $
+      --       show (fi x-fi ox,fi y-fi oy) ++ show (fi w-fi ow,fi h-fi oh)
+      --       ++ show dir ++ " " ++ show win ++ " " ++ show (mx,my)
+      return $ case n of
+                Just _ -> Just $ foldl' (\b' d -> resizeSplitNth d (xsc',ysc') b') b dirs
+                Nothing -> Nothing --focused window is floating -> ignore
+  where rough v = min 1.5 $ max 0.75 v -- extreme scale factors are forbidden
+handleResize _ _ = return Nothing
+
+-- find out which borders have been pulled. We need the old and new rects and the mouse coordinates
+changedDirs :: Rectangle -> Rectangle -> (Int,Int) -> [Direction2D]
+changedDirs (Rectangle _ _ ow oh) (Rectangle _ _ w h) (mx,my) = catMaybes [lr, ud]
+ where lr = if ow==w then Nothing
+            else Just (if (fi mx :: Double) >  (fi ow :: Double)/2 then R else L)
+       ud = if oh==h then Nothing
+            else Just (if (fi my :: Double) > (fi oh :: Double)/2 then D else U)
+
+-- node focus border helpers
+----------------------------
+updateNodeRef :: BinarySpacePartition Window -> Bool -> Rectangle -> X (BinarySpacePartition Window)
+updateNodeRef b force r = do
+    let n = getFocusedNode b
+    let s = getSelectedNode b
+    removeBorder (refWins n++refWins s)
+    l <- getCurrFocused
+    b' <- if refLeaf n /= l || refLeaf n == (-1) || force
+            then return b{getFocusedNode=leafToNodeRef l b}
+            else return b
+    b'' <- if force then return b'{getSelectedNode=noRef} else return b'
+    renderBorders r b''
+  where getCurrFocused = maybe 0 index <$> (withoutFloating <$> getFloating <*> getStackSet)
+
+-- create border around focused node if necessary
+renderBorders :: Rectangle -> BinarySpacePartition a -> X (BinarySpacePartition a)
+renderBorders r b = do
+  let l = nodeRefToLeaf (getFocusedNode b) $ makeZipper b
+  wssel <- if refLeaf (getSelectedNode b)/=(-1)
+           then createBorder (getNodeRect b r (getSelectedNode b)) $ Just "#00ff00"
+           else return []
+  let b' = b{getSelectedNode=(getSelectedNode b){refWins=wssel}}
+  if refLeaf (getFocusedNode b')==(-1) || isJust l || size b'<2 then return b'
+    else do
+      ws' <- createBorder (getNodeRect b' r (getFocusedNode b')) Nothing
+      return b'{getFocusedNode=(getFocusedNode b'){refWins=ws'}}
+
+-- create a window for each border line, show, add into stack and set floating
+createBorder :: Rectangle -> Maybe String -> X [Window]
+createBorder (Rectangle wx wy ww wh) c = do
+  bw <- asks (borderWidth.config)
+  bc <- case c of
+         Nothing -> asks (focusedBorderColor.config)
+         Just s -> return s
+  let rects = [ Rectangle wx wy ww (fi bw)
+              , Rectangle wx wy (fi bw) wh
+              , Rectangle wx (wy+fi wh-fi bw) ww (fi bw)
+              , Rectangle (wx+fi ww-fi bw) wy (fi bw) wh
+              ]
+  ws <- mapM (\r -> createNewWindow r Nothing bc False) rects
+  showWindows ws
+  maybe Nothing (\s -> Just s{W.down=W.down s ++ ws}) <$> getStackSet >>= replaceStack
+  M.union (M.fromList $ zip ws $ map toRR rects) . W.floating . windowset <$> get >>= replaceFloating
+  modify (\s -> s{mapped=mapped s `S.union` S.fromList ws})
+  -- show <$> mapM isClient ws >>= debug
+  return ws
+  where toRR (Rectangle x y w h) = W.RationalRect (fi x) (fi y) (fi w) (fi h)
+
+-- remove border line windows from stack + floating, kill
+removeBorder :: [Window] -> X ()
+removeBorder ws = do
+  modify (\s -> s{mapped = mapped s `S.difference` S.fromList ws})
+  flip (foldl (flip M.delete)) ws . W.floating . windowset <$> get >>= replaceFloating
+  maybe Nothing (\s -> Just s{W.down=W.down s \\ ws}) <$> getStackSet >>= replaceStack
+  deleteWindows ws

XMonad/Layout/BorderResize.hs

@@ -40,7 +40,7 @@ import qualified Data.Map as M
 --
 -- > import XMonad.Layout.BorderResize
 -- > myLayout = borderResize (... layout setup that reacts to SetGeometry ...)
--- > main = xmonad defaultConfig { layoutHook = myLayout }
+-- > main = xmonad def { layoutHook = myLayout }
 --
 
 type BorderBlueprint = (Rectangle, Glyph, BorderType)

XMonad/Layout/BoringWindows.hs

@@ -49,7 +49,7 @@ import qualified XMonad.StackSet as W
 -- Then edit your @layoutHook@ by adding the layout modifier:
 --
 -- > myLayout = boringWindows (Full ||| etc..)
--- > main = xmonad defaultConfig { layoutHook = myLayout }
+-- > main = xmonad def { layoutHook = myLayout }
 --
 -- Then to your keybindings, add:
 --

XMonad/Layout/ButtonDecoration.hs

@@ -40,8 +40,8 @@ import XMonad.Layout.DecorationAddons
 -- Then edit your @layoutHook@ by adding the ButtonDecoration to
 -- your layout:
 --
--- > myL = buttonDeco shrinkText defaultThemeWithButtons (layoutHook defaultConfig)
--- > main = xmonad defaultConfig { layoutHook = myL }
+-- > myL = buttonDeco shrinkText defaultThemeWithButtons (layoutHook def)
+-- > main = xmonad def { layoutHook = myL }
 --
 
 buttonDeco :: (Eq a, Shrinker s) => s -> Theme