Remove -fhpc from ghc-options (annoying hackage workaround)

This patch:
- moves broadcastMessage and restart from Core to Operations (to avoid
  circular imports);
- in Operations introduces sendMessageWithNoRefresh and move
 updateLayout outside windows.
- broadcastMessage now uses sendMessageWithNoRefresh to obey to this
  rules:
  1. if handleMessage returns Nothing no action is taken;
  2. if handleMessage returns a Just ml *only* the layout field of the
     workspace record will be updated.

LICENSE

@@ -1,27 +1,31 @@
-Copyright (c) Spencer Janssen
+Copyright (c) 2007,2008 Spencer Janssen
+Copyright (c) 2007,2008 Don Stewart
 
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
 are met:
+
 1. Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
+
 2. Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.
+
 3. Neither the name of the author nor the names of his contributors
    may be used to endorse or promote products derived from this software
    without specific prior written permission.
 
-THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND
+THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
+DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-SUCH DAMAGE.
+POSSIBILITY OF SUCH DAMAGE.

Main.hs

@@ -1,6 +1,6 @@
 ----------------------------------------------------------------------------
 -- |
--- Module      :  Main.hs
+-- Module      :  Main
 -- Copyright   :  (c) Spencer Janssen 2007
 -- License     :  BSD3-style (see LICENSE)
 --
@@ -14,21 +14,50 @@
 
 module Main (main) where
 
-import XMonad.Main
+import XMonad
-import XMonad.Config
-import XMonad.Core (getXMonadDir, recompile)
 
-import Control.Exception (handle)
 import System.IO
+import System.Info
 import System.Environment
 import System.Posix.Process (executeFile)
 
+import Paths_xmonad (version)
+import Data.Version (showVersion)
+
+#ifdef TESTING
+import qualified Properties
+#endif
+
 -- | The entry point into xmonad. Attempts to compile any custom main
 -- for xmonad, and if it doesn't find one, just launches the default.
 main :: IO ()
 main = do
-    handle (hPrint stderr) buildLaunch
+    args <- getArgs
-    xmonad defaultConfig -- if buildLaunch returns, execute the trusted core
+    let launch = catchIO buildLaunch >> xmonad defaultConfig
+    case args of
+        []                    -> launch
+        ["--resume", _]       -> launch
+        ["--help"]            -> usage
+        ["--recompile"]       -> recompile True >> return ()
+        ["--version"]         -> putStrLn ("xmonad " ++ showVersion version)
+#ifdef TESTING
+        ("--run-tests":_)     -> Properties.main
+#endif
+        _                     -> fail "unrecognized flags"
+
+usage :: IO ()
+usage = do
+    self <- getProgName
+    putStr . unlines $
+        concat ["Usage: ", self, " [OPTION]"] :
+        "Options:" :
+        "  --help                       Print this message" :
+        "  --version                    Print the version number" :
+        "  --recompile                  Recompile your ~/.xmonad/xmonad.hs" :
+#ifdef TESTING
+        "  --run-tests                  Run the test suite" :
+#endif
+        []
 
 -- | Build "~/.xmonad/xmonad.hs" with ghc, then execute it.  If there are no
 -- errors, this function does not return.  An exception is raised in any of
@@ -45,5 +74,5 @@ buildLaunch = do
     recompile False
     dir  <- getXMonadDir
     args <- getArgs
-    executeFile (dir ++ "/xmonad") False args Nothing
+    executeFile (dir ++ "/xmonad-"++arch++"-"++os) False args Nothing
     return ()

README

@@ -12,6 +12,16 @@
     workspace. Xinerama is fully supported, allowing windows to be tiled
     on several physical screens.
 
+Quick start:
+
+Obtain the dependent libraries, then build with:
+
+        runhaskell Setup.lhs configure --user --prefix=$HOME
+        runhaskell Setup.lhs build
+        runhaskell Setup.lhs install --user
+
+For the full story, read on.
+
 Building:
 
  Building is quite straightforward, and requries a basic Haskell toolchain.
@@ -72,7 +82,7 @@ Building:
 
     mtl   http://hackage.haskell.org/cgi-bin/hackage-scripts/package/mtl-1.0
     unix  http://hackage.haskell.org/cgi-bin/hackage-scripts/package/unix-2.0 
-    X11   http://hackage.haskell.org/cgi-bin/hackage-scripts/package/X11-1.3.0
+    X11   http://hackage.haskell.org/cgi-bin/hackage-scripts/package/X11-1.4.1
 
  * Build xmonad: 
 
@@ -123,7 +133,7 @@ XMonadContrib
     prompt/program launcher, and various other useful modules.
     XMonadContrib is available at:
 
-        0.5 release:   http://hackage.haskell.org/cgi-bin/hackage-scripts/package/xmonad-contrib-0.5
+        latest release: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/xmonad-contrib
 
         darcs version:  darcs get http://code.haskell.org/XMonadContrib
 

TODO

@@ -18,3 +18,4 @@
 * upload X11 and xmonad to hackage
 * check examples/text in user-facing Config.hs
 * check tour.html and intro.html are up to date, and mention all core bindings
+* confirm template config is type correct

XMonad/Config.hs

@@ -10,8 +10,12 @@
 -- Portability :  portable
 --
 -- This module specifies the default configuration values for xmonad.
--- Users should not modify this file. Rather, they should provide their
+--
--- own @~\/.xmonad\/xmonad.hs@ that overrides specific fields in defaultConfig.
+-- DO NOT MODIFY THIS FILE!  It won't work.  You may configure xmonad
+-- by providing your own @~\/.xmonad\/xmonad.hs@ that overrides
+-- specific fields in 'defaultConfig'.  For a starting point, you can
+-- copy the @xmonad.hs@ found in the @man@ directory, or look at
+-- examples on the xmonad wiki.
 --
 ------------------------------------------------------------------------
 
@@ -21,11 +25,13 @@ module XMonad.Config (defaultConfig) where
 -- Useful imports
 --
 import XMonad.Core as XMonad hiding
-    (workspaces,manageHook,numlockMask,keys,logHook,borderWidth,mouseBindings
+    (workspaces,manageHook,numlockMask,keys,logHook,startupHook,borderWidth,mouseBindings
-    ,defaultGaps,layoutHook,modMask,terminal,normalBorderColor,focusedBorderColor)
+    ,defaultGaps,layoutHook,modMask,terminal,normalBorderColor,focusedBorderColor
+    ,focusFollowsMouse)
 import qualified XMonad.Core as XMonad
-    (workspaces,manageHook,numlockMask,keys,logHook,borderWidth,mouseBindings
+    (workspaces,manageHook,numlockMask,keys,logHook,startupHook,borderWidth,mouseBindings
-    ,defaultGaps,layoutHook,modMask,terminal,normalBorderColor,focusedBorderColor)
+    ,defaultGaps,layoutHook,modMask,terminal,normalBorderColor,focusedBorderColor
+    ,focusFollowsMouse)
 
 import XMonad.Layout
 import XMonad.Operations
@@ -113,9 +119,7 @@ defaultGaps = [(0,0,0,0)] -- 15 for default dzen font
 manageHook :: ManageHook
 manageHook = composeAll
                 [ className =? "MPlayer"        --> doFloat
-                , className =? "Gimp"           --> doFloat
+                , className =? "Gimp"           --> doFloat ]
-                , resource  =? "desktop_window" --> doIgnore
-                , resource  =? "kdesktop"       --> doIgnore ]
 
 ------------------------------------------------------------------------
 -- Logging
@@ -130,6 +134,10 @@ manageHook = composeAll
 logHook :: X ()
 logHook = return ()
 
+-- | Perform an arbitrary action at xmonad startup.
+startupHook :: X ()
+startupHook = return ()
+
 ------------------------------------------------------------------------
 -- Extensible layouts
 --
@@ -163,6 +171,10 @@ layout = tiled ||| Mirror tiled ||| Full
 terminal :: String
 terminal = "xterm"
 
+-- | Whether focus follows the mouse pointer.
+focusFollowsMouse :: Bool
+focusFollowsMouse = True
+
 -- | The xmonad key bindings. Add, modify or remove key bindings here.
 --
 -- (The comment formatting character is used when generating the manpage)
@@ -182,6 +194,7 @@ keys conf@(XConfig {XMonad.modMask = modMask}) = M.fromList $
 
     -- move focus up or down the window stack
     , ((modMask,               xK_Tab   ), windows W.focusDown) -- %! Move focus to the next window
+    , ((modMask .|. shiftMask, xK_Tab   ), windows W.focusUp  ) -- %! Move focus to the previous window
     , ((modMask,               xK_j     ), windows W.focusDown) -- %! Move focus to the next window
     , ((modMask,               xK_k     ), windows W.focusUp  ) -- %! Move focus to the previous window
     , ((modMask,               xK_m     ), windows W.focusMaster  ) -- %! Move focus to the master window
@@ -207,7 +220,7 @@ keys conf@(XConfig {XMonad.modMask = modMask}) = M.fromList $
 
     -- quit, or restart
     , ((modMask .|. shiftMask, xK_q     ), io (exitWith ExitSuccess)) -- %! Quit xmonad
-    , ((modMask              , xK_q     ), broadcastMessage ReleaseResources >> restart (Just "xmonad") True) -- %! Restart xmonad
+    , ((modMask              , xK_q     ), restart "xmonad" True) -- %! Restart xmonad
     ]
     ++
     -- mod-[1..9] %! Switch to workspace N
@@ -248,5 +261,7 @@ defaultConfig = XConfig
     , XMonad.modMask            = defaultModMask
     , XMonad.keys               = keys
     , XMonad.logHook            = logHook
+    , XMonad.startupHook        = startupHook
     , XMonad.mouseBindings      = mouseBindings
-    , XMonad.manageHook         = manageHook }
+    , XMonad.manageHook         = manageHook
+    , XMonad.focusFollowsMouse  = focusFollowsMouse }

XMonad/Core.hs

@@ -1,11 +1,11 @@
 {-# LANGUAGE ExistentialQuantification, FlexibleInstances, GeneralizedNewtypeDeriving,
-             MultiParamTypeClasses, TypeSynonymInstances #-}
+             MultiParamTypeClasses, TypeSynonymInstances, CPP #-}
 -- required for deriving Typeable
 {-# OPTIONS_GHC -fglasgow-exts #-}
 
 -----------------------------------------------------------------------------
 -- |
--- Module      :  XMonad/Core.hs
+-- Module      :  XMonad.Core
 -- Copyright   :  (c) Spencer Janssen 2007
 -- License     :  BSD3-style (see LICENSE)
 --
@@ -23,14 +23,14 @@ module XMonad.Core (
     ScreenId(..), ScreenDetail(..), XState(..),
     XConf(..), XConfig(..), LayoutClass(..),
     Layout(..), readsLayout, Typeable, Message,
-    SomeMessage(..), fromMessage, runLayout, LayoutMessages(..),
+    SomeMessage(..), fromMessage, LayoutMessages(..),
-    runX, catchX, userCode, io, catchIO,
+    runX, catchX, userCode, io, catchIO, doubleFork,
-    withDisplay, withWindowSet, isRoot,
+    withDisplay, withWindowSet, isRoot, runOnWorkspaces,
-    getAtom, spawn, restart, getXMonadDir, recompile, trace, whenJust, whenX,
+    getAtom, spawn, getXMonadDir, recompile, trace, whenJust, whenX,
-    atom_WM_STATE, atom_WM_PROTOCOLS, atom_WM_DELETE_WINDOW, ManageHook, Query(..), runManageHook
+    atom_WM_STATE, atom_WM_PROTOCOLS, atom_WM_DELETE_WINDOW, ManageHook, Query(..), runQuery
   ) where
 
-import XMonad.StackSet
+import XMonad.StackSet hiding (modify)
 
 import Prelude hiding ( catch )
 import Control.Exception (catch, bracket, throw, Exception(ExitException))
@@ -38,11 +38,11 @@ import Control.Applicative
 import Control.Monad.State
 import Control.Monad.Reader
 import System.IO
+import System.Info
 import System.Posix.Process (executeFile, forkProcess, getProcessStatus, createSession)
 import System.Process
 import System.Directory
 import System.Exit
-import System.Environment
 import Graphics.X11.Xlib
 import Graphics.X11.Xlib.Extras (Event)
 import Data.Typeable
@@ -51,14 +51,14 @@ import Data.Monoid
 import qualified Data.Map as M
 import qualified Data.Set as S
 
--- | XState, the window manager state.
+-- | XState, the (mutable) window manager state.
--- Just the display, width, height and a window list
 data XState = XState
     { windowset    :: !WindowSet           -- ^ workspace list
     , mapped       :: !(S.Set Window)      -- ^ the Set of mapped windows
     , waitingUnmap :: !(M.Map Window Int)  -- ^ the number of expected UnmapEvents
     , dragging     :: !(Maybe (Position -> Position -> X (), X ())) }
 
+-- | XConf, the (read-only) window manager configuration.
 data XConf = XConf
     { display       :: Display        -- ^ the X11 display
     , config        :: !(XConfig Layout)       -- ^ initial user configuration
@@ -76,40 +76,42 @@ data XConfig l = XConfig
     { normalBorderColor  :: !String              -- ^ Non focused windows border color. Default: \"#dddddd\"
     , focusedBorderColor :: !String              -- ^ Focused windows border color. Default: \"#ff0000\"
     , terminal           :: !String              -- ^ The preferred terminal application. Default: \"xterm\"
-    , layoutHook         :: !(l Window)         -- ^ The avaiable layouts
+    , layoutHook         :: !(l Window)          -- ^ The available layouts
-    , manageHook         :: !ManageHook
+    , manageHook         :: !ManageHook          -- ^ The action to run when a new window is opened
-                                                -- ^ The action to run when a new window is opened
+    , workspaces         :: ![String]            -- ^ The list of workspaces' names
-    , workspaces         :: [String]            -- ^ The list of workspaces' names
+    , defaultGaps        :: ![(Int,Int,Int,Int)] -- ^ The list of gaps, per screen
-    , defaultGaps        :: [(Int,Int,Int,Int)] -- ^ The list of gaps, per screen
     , numlockMask        :: !KeyMask             -- ^ The numlock modifier
     , modMask            :: !KeyMask             -- ^ the mod modifier
-    , keys               :: XConfig Layout -> M.Map (ButtonMask,KeySym) (X ())
+    , keys               :: !(XConfig Layout -> M.Map (ButtonMask,KeySym) (X ()))
                                                  -- ^ The key binding: a map from key presses and actions
-    , mouseBindings      :: XConfig Layout -> M.Map (ButtonMask, Button) (Window -> X ())
+    , mouseBindings      :: !(XConfig Layout -> M.Map (ButtonMask, Button) (Window -> X ()))
                                                  -- ^ The mouse bindings
     , borderWidth        :: !Dimension           -- ^ The border width
-    , logHook            :: X ()                -- ^ The action to perform when the windows set is changed
+    , logHook            :: !(X ())              -- ^ The action to perform when the windows set is changed
+    , startupHook        :: !(X ())              -- ^ The action to perform on startup
+    , focusFollowsMouse  :: !Bool                -- ^ Whether window entry events can change focus
     }
 
 
 type WindowSet   = StackSet  WorkspaceId (Layout Window) Window ScreenId ScreenDetail
 type WindowSpace = Workspace WorkspaceId (Layout Window) Window
 
--- | Virtual workspace indicies
+-- | Virtual workspace indices
 type WorkspaceId = String
 
--- | Physical screen indicies
+-- | Physical screen indices
 newtype ScreenId    = S Int deriving (Eq,Ord,Show,Read,Enum,Num,Integral,Real)
 
 -- | The 'Rectangle' with screen dimensions and the list of gaps
 data ScreenDetail   = SD { screenRect :: !Rectangle
-                         , statusGap  :: !(Int,Int,Int,Int) -- ^ width of status bar on the screen
+                         , statusGap  :: !(Int,Int,Int,Int) -- ^ gaps on the sides of the screen that shouldn't be tiled, usually for status bars
                          } deriving (Eq,Show, Read)
 
 ------------------------------------------------------------------------
 
--- | The X monad, a StateT transformer over IO encapsulating the window
+-- | The X monad, ReaderT and StateT transformers over IO
--- manager state
+-- encapsulating the window manager configuration and state,
+-- respectively.
 --
 -- Dynamic components may be retrieved with 'get', static components
 -- with 'ask'. With newtype deriving we get readers and state monads
@@ -120,6 +122,10 @@ newtype X a = X (ReaderT XConf (StateT XState IO) a)
     deriving (Functor, Monad, MonadIO, MonadState XState, MonadReader XConf)
 #endif
 
+instance Applicative X where
+  pure = return
+  (<*>) = ap
+
 instance (Monoid a) => Monoid (X a) where
     mempty  = return mempty
     mappend = liftM2 mappend
@@ -130,8 +136,8 @@ newtype Query a = Query (ReaderT Window X a)
     deriving (Functor, Monad, MonadReader Window, MonadIO)
 #endif
 
-runManageHook :: ManageHook -> Window -> X (WindowSet -> WindowSet)
+runQuery :: Query a -> Window -> X a
-runManageHook (Query m) w = appEndo <$> runReaderT m w
+runQuery (Query m) w = runReaderT m w
 
 instance Monoid a => Monoid (Query a) where
     mempty  = return mempty
@@ -185,91 +191,135 @@ atom_WM_DELETE_WINDOW   = getAtom "WM_DELETE_WINDOW"
 atom_WM_STATE           = getAtom "WM_STATE"
 
 ------------------------------------------------------------------------
--- | LayoutClass handling. See particular instances in Operations.hs
+-- LayoutClass handling. See particular instances in Operations.hs
 
--- | An existential type that can hold any object that is in Read and LayoutClass.
+-- | An existential type that can hold any object that is in 'Read'
+--   and 'LayoutClass'.
 data Layout a = forall l. (LayoutClass l a, Read (l a)) => Layout (l a)
 
 -- | Using the 'Layout' as a witness, parse existentially wrapped windows
--- from a 'String'
+-- from a 'String'.
 readsLayout :: Layout a -> String -> [(Layout a, String)]
 readsLayout (Layout l) s = [(Layout (asTypeOf x l), rs) | (x, rs) <- reads s]
 
--- | The different layout modes
+-- | Every layout must be an instance of 'LayoutClass', which defines
+-- the basic layout operations along with a sensible default for each.
 --
--- 'doLayout': given a Rectangle and a Stack, layout the stack elements
+-- Minimal complete definition:
--- inside the given Rectangle.  If an element is not given a Rectangle
--- by 'doLayout', then it is not shown on screen.  Windows are restacked
--- according to the order they are returned by 'doLayout'.
 --
+-- * 'runLayout' || (('doLayout' || 'pureLayout') && 'emptyLayout'), and
+--
+-- * 'handleMessage' || 'pureMessage'
+--
+-- You should also strongly consider implementing 'description',
+-- although it is not required.
+--
+-- Note that any code which /uses/ 'LayoutClass' methods should only
+-- ever call 'runLayout', 'handleMessage', and 'description'!  In
+-- other words, the only calls to 'doLayout', 'pureMessage', and other
+-- such methods should be from the default implementations of
+-- 'runLayout', 'handleMessage', and so on.  This ensures that the
+-- proper methods will be used, regardless of the particular methods
+-- that any 'LayoutClass' instance chooses to define.
 class Show (layout a) => LayoutClass layout a where
 
-    -- | Given a Rectangle in which to place the windows, and a Stack of
+    -- | By default, 'runLayout' calls 'doLayout' if there are any
-    -- windows, return a list of windows and their corresponding Rectangles.
+    --   windows to be laid out, and 'emptyLayout' otherwise.  Most
-    -- The order of windows in this list should be the desired stacking order.
+    --   instances of 'LayoutClass' probably do not need to implement
-    -- Also return a modified layout, if this layout needs to be modified
+    --   'runLayout'; it is only useful for layouts which wish to make
-    -- (e.g. if we keep track of the windows we have displayed).
+    --   use of more of the 'Workspace' information (for example,
-    doLayout    :: layout a -> Rectangle -> Stack a -> X ([(a, Rectangle)], Maybe (layout a))
+    --   "XMonad.Layout.PerWorkspace").
+    runLayout :: Workspace WorkspaceId (layout a) a
+              -> Rectangle
+              -> X ([(a, Rectangle)], Maybe (layout a))
+    runLayout (Workspace _ l ms) r = maybe (emptyLayout l r) (doLayout l r) ms
+
+    -- | Given a 'Rectangle' in which to place the windows, and a 'Stack'
+    -- of windows, return a list of windows and their corresponding
+    -- Rectangles.  If an element is not given a Rectangle by
+    -- 'doLayout', then it is not shown on screen.  The order of
+    -- windows in this list should be the desired stacking order.
+    --
+    -- Also possibly return a modified layout (by returning @Just
+    -- newLayout@), if this layout needs to be modified (e.g. if it
+    -- keeps track of some sort of state).  Return @Nothing@ if the
+    -- layout does not need to be modified.
+    --
+    -- Layouts which do not need access to the 'X' monad ('IO', window
+    -- manager state, or configuration) and do not keep track of their
+    -- own state should implement 'pureLayout' instead of 'doLayout'.
+    doLayout    :: layout a -> Rectangle -> Stack a
+                -> X ([(a, Rectangle)], Maybe (layout a))
     doLayout l r s   = return (pureLayout l r s, Nothing)
 
-    -- | This is a pure version of doLayout, for cases where we don't need
+    -- | This is a pure version of 'doLayout', for cases where we
-    -- access to the X monad to determine how to layout the windows, and
+    -- don't need access to the 'X' monad to determine how to lay out
-    -- we don't need to modify our layout itself.
+    -- the windows, and we don't need to modify the layout itself.
     pureLayout  :: layout a -> Rectangle -> Stack a -> [(a, Rectangle)]
     pureLayout _ r s = [(focus s, r)]
 
-    -- | 'handleMessage' performs message handling for that layout.  If
+    -- | 'emptyLayout' is called when there are no windows.
-    -- 'handleMessage' returns Nothing, then the layout did not respond to
+    emptyLayout :: layout a -> Rectangle -> X ([(a, Rectangle)], Maybe (layout a))
-    -- that message and the screen is not refreshed.  Otherwise, 'handleMessage'
+    emptyLayout _ _ = return ([], Nothing)
-    -- returns an updated 'Layout' and the screen is refreshed.
+
+    -- | 'handleMessage' performs message handling.  If
+    -- 'handleMessage' returns @Nothing@, then the layout did not
+    -- respond to the message and the screen is not refreshed.
+    -- Otherwise, 'handleMessage' returns an updated layout and the
+    -- screen is refreshed.
     --
+    -- Layouts which do not need access to the 'X' monad to decide how
+    -- to handle messages should implement 'pureMessage' instead of
+    -- 'handleMessage' (this restricts the risk of error, and makes
+    -- testing much easier).
     handleMessage :: layout a -> SomeMessage -> X (Maybe (layout a))
     handleMessage l  = return . pureMessage l
 
-    -- | Respond to a message by (possibly) changing our layout, but taking
+    -- | Respond to a message by (possibly) changing our layout, but
-    -- no other action.  If the layout changes, the screen will be refreshed.
+    -- taking no other action.  If the layout changes, the screen will
+    -- be refreshed.
     pureMessage :: layout a -> SomeMessage -> Maybe (layout a)
     pureMessage _ _  = Nothing
 
-    -- | This should be a human-readable string that is used when selecting
+    -- | This should be a human-readable string that is used when
-    -- layouts by name.
+    -- selecting layouts by name.  The default implementation is
+    -- 'show', which is in some cases a poor default.
     description :: layout a -> String
     description      = show
 
 instance LayoutClass Layout Window where
+    runLayout (Workspace i (Layout l) ms) r = fmap (fmap Layout) `fmap` runLayout (Workspace i l ms) r
     doLayout (Layout l) r s  = fmap (fmap Layout) `fmap` doLayout l r s
+    emptyLayout (Layout l) r = fmap (fmap Layout) `fmap` emptyLayout l r
     handleMessage (Layout l) = fmap (fmap Layout) . handleMessage l
     description (Layout l)   = description l
 
 instance Show (Layout a) where show (Layout l) = show l
 
--- | This calls doLayout if there are any windows to be laid out.
+-- | Based on ideas in /An Extensible Dynamically-Typed Hierarchy of
-runLayout :: LayoutClass l a => l a -> Rectangle -> Maybe (Stack a) -> X ([(a, Rectangle)], Maybe (l a))
+-- Exceptions/, Simon Marlow, 2006. Use extensible messages to the
-runLayout l r = maybe (return ([], Nothing)) (doLayout l r)
+-- 'handleMessage' handler.
-
--- | Based on ideas in /An Extensible Dynamically-Typed Hierarchy of Exceptions/,
--- Simon Marlow, 2006. Use extensible messages to the handleMessage handler.
 --
 -- User-extensible messages must be a member of this class.
 --
 class Typeable a => Message a
 
 -- |
--- A wrapped value of some type in the Message class.
+-- A wrapped value of some type in the 'Message' class.
 --
 data SomeMessage = forall a. Message a => SomeMessage a
 
 -- |
--- And now, unwrap a given, unknown Message type, performing a (dynamic)
+-- And now, unwrap a given, unknown 'Message' type, performing a (dynamic)
 -- type check on the result.
 --
 fromMessage :: Message m => SomeMessage -> Maybe m
 fromMessage (SomeMessage m) = cast m
 
--- | X Events are valid Messages
+-- X Events are valid Messages.
 instance Message Event
 
--- | LayoutMessages are core messages that all layouts (especially stateful
+-- | 'LayoutMessages' are core messages that all layouts (especially stateful
 -- layouts) should consider handling.
 data LayoutMessages = Hide              -- ^ sent when a layout becomes non-visible
                     | ReleaseResources  -- ^ sent when xmonad is exiting or restarting
@@ -286,7 +336,7 @@ io = liftIO
 
 -- | Lift an IO action into the X monad.  If the action results in an IO
 -- exception, log the exception to stderr and continue normal execution.
-catchIO :: IO () -> X ()
+catchIO :: MonadIO m => IO () -> m ()
 catchIO f = io (f `catch` \e -> hPrint stderr e >> hFlush stderr)
 
 -- | spawn. Launch an external application
@@ -303,26 +353,21 @@ doubleFork m = io $ do
     getProcessStatus True False pid
     return ()
 
--- | Restart xmonad via exec().
+-- | This is basically a map function, running a function in the X monad on
---
+-- each workspace with the output of that function being the modified workspace.
--- If the first parameter is 'Just name', restart will attempt to execute the
+runOnWorkspaces :: (WindowSpace -> X WindowSpace) -> X ()
--- program corresponding to 'name'.  Otherwise, xmonad will attempt to execute
+runOnWorkspaces job = do
--- the name of the current program.
+    ws <- gets windowset
---
+    h <- mapM job $ hidden ws
--- When the second parameter is 'True', xmonad will attempt to resume with the
+    c:v <- mapM (\s -> (\w -> s { workspace = w}) <$> job (workspace s))
--- current window state.
+             $ current ws : visible ws
-restart :: Maybe String -> Bool -> X ()
+    modify $ \s -> s { windowset = ws { current = c, visible = v, hidden = h } }
-restart mprog resume = do
-    prog <- maybe (io getProgName) return mprog
-    args <- if resume then gets (("--resume":) . return . showWs . windowset) else return []
-    catchIO (executeFile prog True args Nothing)
- where showWs = show . mapLayout show
 
 -- | Return the path to @~\/.xmonad@.
 getXMonadDir :: MonadIO m => m String
 getXMonadDir = io $ getAppUserDataDirectory "xmonad"
 
--- | 'recompile force', recompile ~\/.xmonad\/xmonad.hs when any of the
+-- | 'recompile force', recompile @~\/.xmonad\/xmonad.hs@ when any of the
 -- following apply:
 --      * force is True
 --      * the xmonad executable does not exist
@@ -331,20 +376,25 @@ getXMonadDir = io $ getAppUserDataDirectory "xmonad"
 -- The -i flag is used to restrict recompilation to the xmonad.hs file only.
 --
 -- Compilation errors (if any) are logged to ~\/.xmonad\/xmonad.errors.  If
--- GHC indicates failure with a non-zero exit code, an xmessage containing
+-- GHC indicates failure with a non-zero exit code, an xmessage displaying
--- GHC's is spawned.
+-- that file is spawned.
 --
-recompile :: MonadIO m => Bool -> m ()
+-- False is returned if there are compilation errors.
+--
+recompile :: MonadIO m => Bool -> m Bool
 recompile force = io $ do
     dir <- getXMonadDir
-    let bin = dir ++ "/" ++ "xmonad"
+    let binn = "xmonad-"++arch++"-"++os
-        err = bin ++ ".errors"
+        bin  = dir ++ "/" ++ binn
-        src = bin ++ ".hs"
+        base = dir ++ "/" ++ "xmonad"
+        err  = base ++ ".errors"
+        src  = base ++ ".hs"
     srcT <- getModTime src
     binT <- getModTime bin
-    when (force || srcT > binT) $ do
+    if (force || srcT > binT)
+      then do
         status <- bracket (openFile err WriteMode) hClose $ \h -> do
-            waitForProcess =<< runProcess "ghc" ["--make", "xmonad.hs", "-i", "-no-recomp", "-v0"] (Just dir)
+            waitForProcess =<< runProcess "ghc" ["--make", "xmonad.hs", "-i", "-no-recomp", "-v0", "-o",binn] (Just dir)
                                     Nothing Nothing Nothing (Just h)
 
         -- now, if it fails, run xmessage to let the user know:
@@ -353,10 +403,15 @@ recompile force = io $ do
             let msg = unlines $
                     ["Error detected while loading xmonad configuration file: " ++ src]
                     ++ lines ghcErr ++ ["","Please check the file for errors."]
-            doubleFork $ executeFile "xmessage" True [msg] Nothing
+            -- nb, the ordering of printing, then forking, is crucial due to
+            -- lazy evaluation
+            hPutStrLn stderr msg
+            doubleFork $ executeFile "xmessage" True ["-default", "okay", msg] Nothing
+        return (status == ExitSuccess)
+      else return True
  where getModTime f = catch (Just <$> getModificationTime f) (const $ return Nothing)
 
--- | Run a side effecting action with the current workspace. Like 'when' but
+-- | Conditionally run an action, using a @Maybe a@ to decide.
 whenJust :: Monad m => Maybe a -> (a -> m ()) -> m ()
 whenJust mg f = maybe (return ()) f mg
 

XMonad/Layout.hs

@@ -3,7 +3,7 @@
 
 -- --------------------------------------------------------------------------
 -- |
--- Module      :  Layouts.hs
+-- Module      :  XMonad.Layout
 -- Copyright   :  (c) Spencer Janssen 2007
 -- License     :  BSD3-style (see LICENSE)
 --
@@ -15,9 +15,14 @@
 --
 -----------------------------------------------------------------------------
 
-module XMonad.Layout (ChangeLayout(..), Choose, (|||), Resize(..), IncMasterN(..),
+module XMonad.Layout (
+    ChangeLayout(..), Choose, (|||), Resize(..), IncMasterN(..),
     Full(..), Tall(..), Mirror(..), mirrorRect, splitVertically,
-                splitHorizontally, splitHorizontallyBy, splitVerticallyBy) where
+    splitHorizontally, splitHorizontallyBy, splitVerticallyBy,
+
+    tile
+
+  ) where
 
 import XMonad.Core
 
@@ -27,64 +32,8 @@ import Control.Arrow ((***), second)
 import Control.Monad
 import Data.Maybe (fromMaybe)
 
-
 ------------------------------------------------------------------------
--- LayoutClass selection manager
+-- | Builtin basic layout algorithms:
-
--- | A layout that allows users to switch between various layout options.
-
--- | Messages to change the current layout.
-data ChangeLayout = FirstLayout | NextLayout deriving (Eq, Show, Typeable)
-
-instance Message ChangeLayout
-
--- | The layout choice combinator
-(|||) :: (LayoutClass l a, LayoutClass r a) => l a -> r a -> Choose l r a
-(|||) = flip SLeft
-infixr 5 |||
-
-data Choose l r a = SLeft  (r a) (l a)
-                  | SRight (l a) (r a) deriving (Read, Show)
-
-data NextNoWrap = NextNoWrap deriving (Eq, Show, Typeable)
-instance Message NextNoWrap
-
--- This has lots of pseudo duplicated code, we must find a better way
-instance (LayoutClass l a, LayoutClass r a) => LayoutClass (Choose l r) a where
-    doLayout (SLeft  r l) = (fmap (second . fmap $ SLeft r) .) . doLayout l
-    doLayout (SRight l r) = (fmap (second . fmap $ SRight l) .) . doLayout r
-
-    description (SLeft _ l)  = description l
-    description (SRight _ r) = description r
-
-    handleMessage lr m | Just FirstLayout <- fromMessage m = case lr of
-        SLeft {}   -> return Nothing
-        SRight l r -> fmap (Just . flip SLeft l . fromMaybe r)
-                        $ handleMessage r (SomeMessage Hide)
-
-    handleMessage lr m | Just NextLayout <- fromMessage m = do
-        mlr <- handleMessage lr $ SomeMessage NextNoWrap
-        maybe (handleMessage lr $ SomeMessage FirstLayout) (return . Just) mlr
-
-    handleMessage (SLeft r l) m | Just NextNoWrap <- fromMessage m = do
-        handleMessage l (SomeMessage Hide)
-        mr <- handleMessage r (SomeMessage FirstLayout)
-        return . Just . SRight l $ fromMaybe r mr
-
-    handleMessage lr m | Just ReleaseResources <- fromMessage m =
-        liftM2 ((Just .) . cons)
-                    (fmap (fromMaybe l) $ handleMessage l m)
-                    (fmap (fromMaybe r) $ handleMessage r m)
-     where (cons, l, r) = case lr of
-                            (SLeft  r' l') -> (flip SLeft, l', r')
-                            (SRight l' r') -> (SRight, l', r')
-
-    -- The default cases for left and right:
-    handleMessage (SLeft  r l) m = fmap (fmap $ SLeft  r) $ handleMessage l m
-    handleMessage (SRight l r) m = fmap (fmap $ SRight l) $ handleMessage r m
-
---
--- | Builtin layout algorithms:
 --
 -- > fullscreen mode
 -- > tall mode
@@ -97,7 +46,7 @@ instance (LayoutClass l a, LayoutClass r a) => LayoutClass (Choose l r) a where
 data Resize     = Shrink | Expand   deriving Typeable
 
 -- | You can also increase the number of clients in the master pane
-data IncMasterN = IncMasterN Int    deriving Typeable
+data IncMasterN = IncMasterN !Int    deriving Typeable
 
 instance Message Resize
 instance Message IncMasterN
@@ -107,34 +56,26 @@ data Full a = Full deriving (Show, Read)
 
 instance LayoutClass Full a
 
--- | The inbuilt tiling mode of xmonad, and its operations.
+-- | The builtin tiling mode of xmonad, and its operations.
-data Tall a = Tall Int Rational Rational deriving (Show, Read)
+data Tall a = Tall !Int !Rational !Rational deriving (Show, Read)
+                        -- TODO should be capped [0..1] ..
 
+-- a nice pure layout, lots of properties for the layout, and its messages, in Properties.hs
 instance LayoutClass Tall a where
     pureLayout (Tall nmaster _ frac) r s = zip ws rs
       where ws = W.integrate s
             rs = tile frac r nmaster (length ws)
 
-    pureMessage (Tall nmaster delta frac) m = msum [fmap resize (fromMessage m)
+    pureMessage (Tall nmaster delta frac) m =
+            msum [fmap resize     (fromMessage m)
                  ,fmap incmastern (fromMessage m)]
+
       where resize Shrink             = Tall nmaster delta (max 0 $ frac-delta)
             resize Expand             = Tall nmaster delta (min 1 $ frac+delta)
             incmastern (IncMasterN d) = Tall (max 0 (nmaster+d)) delta frac
+
     description _ = "Tall"
 
--- | Mirror a rectangle
-mirrorRect :: Rectangle -> Rectangle
-mirrorRect (Rectangle rx ry rw rh) = (Rectangle ry rx rh rw)
-
--- | Mirror a layout, compute its 90 degree rotated form.
-data Mirror l a = Mirror (l a) deriving (Show, Read)
-
-instance LayoutClass l a => LayoutClass (Mirror l) a where
-    doLayout (Mirror l) r s = (map (second mirrorRect) *** fmap Mirror)
-                                `fmap` doLayout l (mirrorRect r) s
-    handleMessage (Mirror l) = fmap (fmap Mirror) . handleMessage l
-    description (Mirror l) = "Mirror "++ description l
-
 -- | tile.  Compute the positions for windows using the default 2 pane tiling algorithm.
 --
 -- The screen is divided (currently) into two panes. all clients are
@@ -163,6 +104,7 @@ splitVertically n (Rectangle sx sy sw sh) = Rectangle sx sy sw smallh :
     splitVertically (n-1) (Rectangle sx (sy+fromIntegral smallh) sw (sh-smallh))
   where smallh = sh `div` fromIntegral n --hmm, this is a fold or map.
 
+-- Not used in the core, but exported
 splitHorizontally n = map mirrorRect . splitVertically n . mirrorRect
 
 -- Divide the screen into two rectangles, using a rational to specify the ratio
@@ -172,4 +114,79 @@ splitHorizontallyBy f (Rectangle sx sy sw sh) =
     , Rectangle (sx + fromIntegral leftw) sy (sw-fromIntegral leftw) sh)
   where leftw = floor $ fromIntegral sw * f
 
+-- Not used in the core, but exported
 splitVerticallyBy f = (mirrorRect *** mirrorRect) . splitHorizontallyBy f . mirrorRect
+
+------------------------------------------------------------------------
+-- | Mirror a layout, compute its 90 degree rotated form.
+
+-- | Mirror a layout, compute its 90 degree rotated form.
+data Mirror l a = Mirror (l a) deriving (Show, Read)
+
+instance LayoutClass l a => LayoutClass (Mirror l) a where
+    runLayout (W.Workspace i (Mirror l) ms) r = (map (second mirrorRect) *** fmap Mirror)
+                                                `fmap` runLayout (W.Workspace i l ms) (mirrorRect r)
+    handleMessage (Mirror l) = fmap (fmap Mirror) . handleMessage l
+    description (Mirror l) = "Mirror "++ description l
+
+-- | Mirror a rectangle
+mirrorRect :: Rectangle -> Rectangle
+mirrorRect (Rectangle rx ry rw rh) = (Rectangle ry rx rh rw)
+
+------------------------------------------------------------------------
+-- LayoutClass selection manager
+-- Layouts that transition between other layouts
+
+-- | A layout that allows users to switch between various layout options.
+
+-- | Messages to change the current layout.
+data ChangeLayout = FirstLayout | NextLayout deriving (Eq, Show, Typeable)
+
+instance Message ChangeLayout
+
+-- | The layout choice combinator
+(|||) :: (LayoutClass l a, LayoutClass r a) => l a -> r a -> Choose l r a
+(|||) = flip SLeft
+infixr 5 |||
+
+data Choose l r a = SLeft  (r a) (l a)
+                  | SRight (l a) (r a) deriving (Read, Show)
+
+data NextNoWrap = NextNoWrap deriving (Eq, Show, Typeable)
+instance Message NextNoWrap
+
+-- This has lots of pseudo duplicated code, we must find a better way
+instance (LayoutClass l a, LayoutClass r a) => LayoutClass (Choose l r) a where
+    runLayout (W.Workspace i (SLeft  r l) ms) =
+        fmap (second . fmap $ SLeft  r) . runLayout (W.Workspace i l ms)
+    runLayout (W.Workspace i (SRight l r) ms) =
+        fmap (second . fmap $ SRight l) . runLayout (W.Workspace i r ms)
+
+    description (SLeft _ l)  = description l
+    description (SRight _ r) = description r
+
+    handleMessage lr m | Just FirstLayout <- fromMessage m = case lr of
+        SLeft {}   -> return Nothing
+        SRight l r -> fmap (Just . flip SLeft l . fromMaybe r)
+                        $ handleMessage r (SomeMessage Hide)
+
+    handleMessage lr m | Just NextLayout <- fromMessage m = do
+        mlr <- handleMessage lr $ SomeMessage NextNoWrap
+        maybe (handleMessage lr $ SomeMessage FirstLayout) (return . Just) mlr
+
+    handleMessage (SLeft r l) m | Just NextNoWrap <- fromMessage m = do
+        handleMessage l (SomeMessage Hide)
+        mr <- handleMessage r (SomeMessage FirstLayout)
+        return . Just . SRight l $ fromMaybe r mr
+
+    handleMessage lr m | Just ReleaseResources <- fromMessage m =
+        liftM2 ((Just .) . cons)
+                    (fmap (fromMaybe l) $ handleMessage l m)
+                    (fmap (fromMaybe r) $ handleMessage r m)
+     where (cons, l, r) = case lr of
+                            (SLeft  r' l') -> (flip SLeft, l', r')
+                            (SRight l' r') -> (SRight, l', r')
+
+    -- The default cases for left and right:
+    handleMessage (SLeft  r l) m = fmap (fmap $ SLeft  r) $ handleMessage l m
+    handleMessage (SRight l r) m = fmap (fmap $ SRight l) $ handleMessage r m

XMonad/Main.hs

@@ -1,7 +1,7 @@
 {-# LANGUAGE MultiParamTypeClasses, FlexibleContexts #-}
 ----------------------------------------------------------------------------
 -- |
--- Module      :  Core.hs
+-- Module      :  XMonad.Main
 -- Copyright   :  (c) Spencer Janssen 2007
 -- License     :  BSD3-style (see LICENSE)
 --
@@ -16,6 +16,7 @@
 module XMonad.Main (xmonad) where
 
 import Data.Bits
+import Data.List ((\\))
 import qualified Data.Map as M
 import qualified Data.Set as S
 import Control.Monad.Reader
@@ -23,12 +24,13 @@ import Control.Monad.State
 import Data.Maybe (fromMaybe)
 
 import System.Environment (getArgs)
+import System.Posix.Signals
 
 import Graphics.X11.Xlib hiding (refreshKeyboardMapping)
 import Graphics.X11.Xlib.Extras
-import Graphics.X11.Xinerama    (getScreenInfo)
 
 import XMonad.Core
+import qualified XMonad.Config as Default
 import XMonad.StackSet (new, floating, member)
 import qualified XMonad.StackSet as W
 import XMonad.Operations
@@ -40,15 +42,23 @@ import System.IO
 --
 xmonad :: (LayoutClass l Window, Read (l Window)) => XConfig l -> IO ()
 xmonad initxmc = do
+    -- ignore SIGPIPE
+    installHandler openEndedPipe Ignore Nothing
     -- First, wrap the layout in an existential, to keep things pretty:
     let xmc = initxmc { layoutHook = Layout $ layoutHook initxmc }
     dpy   <- openDisplay ""
     let dflt = defaultScreen dpy
 
     rootw  <- rootWindow dpy dflt
-    xinesc <- getScreenInfo dpy
+    xinesc <- getCleanedScreenInfo dpy
-    nbc    <- initColor dpy $ normalBorderColor xmc
+    nbc    <- do v            <- initColor dpy $ normalBorderColor  xmc
-    fbc    <- initColor dpy $ focusedBorderColor xmc
+                 ~(Just nbc_) <- initColor dpy $ normalBorderColor Default.defaultConfig
+                 return (fromMaybe nbc_ v)
+
+    fbc    <- do v <- initColor dpy $ focusedBorderColor xmc
+                 ~(Just fbc_)  <- initColor dpy $ focusedBorderColor Default.defaultConfig
+                 return (fromMaybe fbc_ v)
+
     hSetBuffering stdout NoBuffering
     args <- getArgs
 
@@ -97,15 +107,19 @@ xmonad initxmc = do
 
             io $ sync dpy False
 
+            ws <- io $ scan dpy rootw
+
             -- bootstrap the windowset, Operations.windows will identify all
             -- the windows in winset as new and set initial properties for
-            -- those windows
+            -- those windows.  Remove all windows that are no longer top-level
-            windows (const winset)
+            -- children of the root, they may have disappeared since
+            -- restarting.
+            windows . const . foldr W.delete winset $ W.allWindows winset \\ ws
 
-            -- scan for all top-level windows, add the unmanaged ones to the
+            -- manage the as-yet-unmanaged windows
-            -- windowset
+            mapM_ manage (ws \\ W.allWindows winset)
-            ws <- io $ scan dpy rootw
+
-            mapM_ manage ws
+            userCode $ startupHook initxmc
 
             -- main loop, for all you HOF/recursion fans out there.
             forever_ $ handle =<< io (nextEvent dpy e >> getEvent e)
@@ -143,7 +157,10 @@ handle (MapRequestEvent    {ev_window = w}) = withDisplay $ \dpy -> do
 
 -- window destroyed, unmanage it
 -- window gone,      unmanage it
-handle (DestroyWindowEvent {ev_window = w}) = whenX (isClient w) $ unmanage w
+handle (DestroyWindowEvent {ev_window = w}) = whenX (isClient w) $ do
+    unmanage w
+    modify (\s -> s { mapped       = S.delete w (mapped s)
+                    , waitingUnmap = M.delete w (waitingUnmap s)})
 
 -- We track expected unmap events in waitingUnmap.  We ignore this event unless
 -- it is synthetic or we are not expecting an unmap notification from a window.
@@ -151,7 +168,9 @@ handle (UnmapEvent {ev_window = w, ev_send_event = synthetic}) = whenX (isClient
     e <- gets (fromMaybe 0 . M.lookup w . waitingUnmap)
     if (synthetic || e == 0)
         then unmanage w
-        else modify (\s -> s { waitingUnmap = M.adjust pred w (waitingUnmap s) })
+        else modify (\s -> s { waitingUnmap = M.update mpred w (waitingUnmap s) })
+ where mpred 1 = Nothing
+       mpred n = Just $ pred n
 
 -- set keyboard mapping
 handle e@(MappingNotifyEvent {}) = do
@@ -184,12 +203,14 @@ handle e@(ButtonEvent {ev_window = w,ev_event_type = t,ev_button = b })
     ba <- asks buttonActions
     if isr then userCode $ whenJust (M.lookup (m, b) ba) ($ ev_subwindow e)
            else focus w
-    sendMessage e -- Always send button events.
+    broadcastMessage e -- Always send button events.
 
--- entered a normal window, makes this focused.
+-- entered a normal window: focus it if focusFollowsMouse is set to
+-- True in the user's config.
 handle e@(CrossingEvent {ev_window = w, ev_event_type = t})
     | t == enterNotify && ev_mode   e == notifyNormal
-                       && ev_detail e /= notifyInferior = focus w
+                       && ev_detail e /= notifyInferior
+    = whenX (asks $ focusFollowsMouse . config) (focus w)
 
 -- left a window, check if we need to focus root
 handle e@(CrossingEvent {ev_event_type = t})

XMonad/ManageHook.hs

@@ -2,7 +2,7 @@
 
 -----------------------------------------------------------------------------
 -- |
--- Module      :  XMonad/ManageHook.hs
+-- Module      :  XMonad.ManageHook
 -- Copyright   :  (c) Spencer Janssen 2007
 -- License     :  BSD3-style (see LICENSE)
 --
@@ -20,6 +20,7 @@ module XMonad.ManageHook where
 
 import XMonad.Core
 import Graphics.X11.Xlib.Extras
+import Graphics.X11.Xlib (Display,Window)
 import Control.Monad.Reader
 import Data.Maybe
 import Data.Monoid
@@ -65,6 +66,17 @@ title     = ask >>= (\w -> liftX $ withDisplay $ \d -> fmap (fromMaybe "") $ io
 resource  = ask >>= (\w -> liftX $ withDisplay $ \d -> fmap resName        $ io $ getClassHint d w)
 className = ask >>= (\w -> liftX $ withDisplay $ \d -> fmap resClass       $ io $ getClassHint d w)
 
+-- | A query that can return an arbitrary X property of type String,
+--   identified by name.
+stringProperty :: String -> Query String
+stringProperty p = ask >>= (\w -> liftX $ withDisplay $ \d -> fmap (fromMaybe "") $ getStringProperty d w p)
+
+getStringProperty :: Display -> Window -> String -> X (Maybe String)
+getStringProperty d w p = do
+  a  <- getAtom p
+  md <- io $ getWindowProperty8 d a w
+  return $ fmap (map (toEnum . fromIntegral)) md
+
 -- | Modify the 'WindowSet' with a pure function.
 doF :: (WindowSet -> WindowSet) -> ManageHook
 doF = return . Endo

XMonad/Operations.hs

@@ -4,7 +4,7 @@
 
 -- --------------------------------------------------------------------------
 -- |
--- Module      :  Operations.hs
+-- Module      :  XMonad.Operations
 -- Copyright   :  (c) Spencer Janssen 2007
 -- License     :  BSD3-style (see LICENSE)
 --
@@ -23,6 +23,7 @@ import XMonad.Layout (Full(..))
 import qualified XMonad.StackSet as W
 
 import Data.Maybe
+import Data.Monoid          (appEndo)
 import Data.List            (nub, (\\), find)
 import Data.Bits            ((.|.), (.&.), complement)
 import Data.Ratio
@@ -30,10 +31,12 @@ import qualified Data.Map as M
 import qualified Data.Set as S
 
 import Control.Applicative
-import Control.Monad.State
 import Control.Monad.Reader
+import Control.Monad.State
+import qualified Control.Exception as C
 
 import System.IO
+import System.Posix.Process (executeFile)
 import Graphics.X11.Xlib
 import Graphics.X11.Xinerama (getScreenInfo)
 import Graphics.X11.Xlib.Extras
@@ -65,19 +68,14 @@ manage w = whenX (not <$> isClient w) $ withDisplay $ \d -> do
             where i = fromMaybe (W.tag . W.workspace . W.current $ ws) $ W.lookupWorkspace sc ws
 
     mh <- asks (manageHook . config)
-    g <- runManageHook mh w `catchX` return id
+    g <- fmap appEndo (runQuery mh w) `catchX` return id
     windows (g . f)
 
 -- | unmanage. A window no longer exists, remove it from the window
 -- list, on whatever workspace it is.
 --
--- should also unmap?
---
 unmanage :: Window -> X ()
-unmanage w = do
+unmanage = windows . W.delete
-    windows (W.delete w)
-    setWMState w withdrawnState
-    modify (\s -> s {mapped = S.delete w (mapped s), waitingUnmap = M.delete w (waitingUnmap s)})
 
 -- | Modify the size of the status gap at the top of the current screen
 -- Taking a function giving the current screen, and current geometry.
@@ -116,22 +114,24 @@ windows f = do
     let oldvisible = concatMap (W.integrate' . W.stack . W.workspace) $ W.current old : W.visible old
         ws = f old
     XConf { display = d , normalBorder = nbc, focusedBorder = fbc } <- ask
+
     mapM_ setInitialProperties (W.allWindows ws \\ W.allWindows old)
+
     whenJust (W.peek old) $ \otherw -> io $ setWindowBorder d otherw nbc
     modify (\s -> s { windowset = ws })
 
     -- notify non visibility
     let tags_oldvisible = map (W.tag . W.workspace) $ W.current old : W.visible old
-        gottenhidden    = filter (`elem` tags_oldvisible) $ map W.tag $ W.hidden ws
+        gottenhidden    = filter (flip elem tags_oldvisible . W.tag) $ W.hidden ws
-    sendMessageToWorkspaces Hide gottenhidden
+    mapM_ (sendMessageWithNoRefresh Hide) gottenhidden
 
     -- for each workspace, layout the currently visible workspaces
     let allscreens     = W.screens ws
         summed_visible = scanl (++) [] $ map (W.integrate' . W.stack . W.workspace) allscreens
     visible <- fmap concat $ forM (zip allscreens summed_visible) $ \ (w, vis) -> do
-        let n      = W.tag (W.workspace w)
+        let wsp   = W.workspace w
             this  = W.view n ws
-            l = W.layout (W.workspace w)
+            n     = W.tag wsp
             flt   = filter (flip M.member (W.floating ws)) (W.index this)
             tiled = (W.stack . W.workspace . W.current $ this)
                     >>= W.filter (`M.notMember` W.floating ws)
@@ -143,11 +143,10 @@ windows f = do
 
         -- just the tiled windows:
         -- now tile the windows on this workspace, modified by the gap
-        (rs, ml') <- runLayout l viewrect tiled `catchX` runLayout (Layout Full) viewrect tiled
+        (rs, ml') <- runLayout wsp { W.stack = tiled } viewrect `catchX`
+                     runLayout wsp { W.stack = tiled, W.layout = Layout Full } viewrect
         mapM_ (uncurry tileWindow) rs
-        whenJust ml' $ \l' -> runOnWorkspaces (\ww -> if W.tag ww == n
+        updateLayout n ml'
-                                                      then return $ ww { W.layout = l'}
-                                                      else return ww)
 
         -- now the floating windows:
         -- move/resize the floating windows, if there are any
@@ -165,12 +164,16 @@ windows f = do
     whenJust (W.peek ws) $ \w -> io $ setWindowBorder d w fbc
     setTopFocus
     asks (logHook . config) >>= userCode
-    -- io performGC -- really helps, but seems to trigger GC bugs?
 
     -- hide every window that was potentially visible before, but is not
     -- given a position by a layout now.
     mapM_ hide (nub oldvisible \\ visible)
 
+    -- all windows that are no longer in the windowset are marked as
+    -- withdrawn, it is important to do this after the above, otherwise 'hide'
+    -- will overwrite withdrawnState with iconicState
+    mapM_ (flip setWMState withdrawnState) (W.allWindows old \\ W.allWindows ws)
+
     clearEvents enterWindowMask
 
 -- | setWMState.  set the WM_STATE property
@@ -245,11 +248,31 @@ tileWindow w r = withDisplay $ \d -> do
 
 -- ---------------------------------------------------------------------
 
+-- | Returns True if the first rectangle is contained within, but not equal
+-- to the second.
+containedIn :: Rectangle -> Rectangle -> Bool
+containedIn r1@(Rectangle x1 y1 w1 h1) r2@(Rectangle x2 y2 w2 h2)
+ = and [ r1 /= r2
+       , x1 >= x2
+       , y1 >= y2
+       , fromIntegral x1 + w1 <= fromIntegral x2 + w2
+       , fromIntegral y1 + h1 <= fromIntegral y2 + h2 ]
+
+-- | Given a list of screens, remove all duplicated screens and screens that
+-- are entirely contained within another.
+nubScreens :: [Rectangle] -> [Rectangle]
+nubScreens xs = nub . filter (\x -> not $ any (x `containedIn`) xs) $ xs
+
+-- | Cleans the list of screens according to the rules documented for
+-- nubScreens.
+getCleanedScreenInfo :: MonadIO m => Display -> m [Rectangle]
+getCleanedScreenInfo = io .  fmap nubScreens . getScreenInfo
+
 -- | rescreen.  The screen configuration may have changed (due to
 -- xrandr), update the state and refresh the screen, and reset the gap.
 rescreen :: X ()
 rescreen = do
-    xinesc <- withDisplay (io . getScreenInfo)
+    xinesc <- withDisplay getCleanedScreenInfo
 
     windows $ \ws@(W.StackSet { W.current = v, W.visible = vs, W.hidden = hs }) ->
         let (xs, ys) = splitAt (length xinesc) $ map W.workspace (v:vs) ++ hs
@@ -315,30 +338,24 @@ sendMessage a = do
                                 { W.workspace = (W.workspace $ W.current ws)
                                   { W.layout = l' }}}
 
--- | Send a message to a list of workspaces' layouts, without necessarily refreshing.
+-- | Send a message to all layouts, without refreshing.
-sendMessageToWorkspaces :: Message a => a -> [WorkspaceId] -> X ()
-sendMessageToWorkspaces a l = runOnWorkspaces $ \w ->
-   if W.tag w `elem` l
-      then do ml' <- handleMessage (W.layout w) (SomeMessage a) `catchX` return Nothing
-              return $ w { W.layout = maybe (W.layout w) id ml' }
-      else return w
-
--- | Send a message to all visible layouts, without necessarily refreshing.
--- This is how we implement the hooks, such as UnDoLayout.
 broadcastMessage :: Message a => a -> X ()
-broadcastMessage a = runOnWorkspaces $ \w -> do
+broadcastMessage a = withWindowSet $ \ws -> do
-    ml' <- handleMessage (W.layout w) (SomeMessage a) `catchX` return Nothing
+   let c = W.workspace . W.current $ ws
-    return $ w { W.layout = maybe (W.layout w) id ml' }
+       v = map W.workspace . W.visible $ ws
+       h = W.hidden ws
+   mapM_ (sendMessageWithNoRefresh a) (c : v ++ h)
 
--- | This is basically a map function, running a function in the X monad on
+-- | Send a message to a layout, without refreshing.
--- each workspace with the output of that function being the modified workspace.
+sendMessageWithNoRefresh :: Message a => a -> W.Workspace WorkspaceId (Layout Window) Window -> X ()
-runOnWorkspaces :: (WindowSpace -> X WindowSpace) -> X ()
+sendMessageWithNoRefresh a w =
-runOnWorkspaces job =do
+    handleMessage (W.layout w) (SomeMessage a) `catchX` return Nothing >>=
-    ws <- gets windowset
+    updateLayout  (W.tag w)
-    h <- mapM job $ W.hidden ws
+
-    c:v <- mapM (\s -> (\w -> s { W.workspace = w}) <$> job (W.workspace s))
+-- | Update the layout field of a workspace
-             $ W.current ws : W.visible ws
+updateLayout :: WorkspaceId -> Maybe (Layout Window) -> X ()
-    modify $ \s -> s { windowset = ws { W.current = c, W.visible = v, W.hidden = h } }
+updateLayout i ml = whenJust ml $ \l ->
+    runOnWorkspaces $ \ww -> return $ if W.tag ww == i then ww { W.layout = l} else ww
 
 -- | Set the layout of the currently viewed workspace
 setLayout :: Layout Window -> X ()
@@ -376,10 +393,24 @@ cleanMask km = do
     return (complement (nlm .|. lockMask) .&. km)
 
 -- | Get the Pixel value for a named color
-initColor :: Display -> String -> IO Pixel
+initColor :: Display -> String -> IO (Maybe Pixel)
-initColor dpy c = (color_pixel . fst) <$> allocNamedColor dpy colormap c
+initColor dpy c = C.handle (\_ -> return Nothing) $
+    (Just . color_pixel . fst) <$> allocNamedColor dpy colormap c
     where colormap = defaultColormap dpy (defaultScreen dpy)
 
+------------------------------------------------------------------------
+
+-- | @restart name resume@. Attempt to restart xmonad by executing the program
+-- @name@.  If @resume@ is 'True', restart with the current window state.
+-- When executing another window manager, @resume@ should be 'False'.
+restart :: String -> Bool -> X ()
+restart prog resume = do
+    broadcastMessage ReleaseResources
+    io . flush =<< asks display
+    args <- if resume then gets (("--resume":) . return . showWs . windowset) else return []
+    catchIO (executeFile prog True args Nothing)
+ where showWs = show . W.mapLayout show
+
 ------------------------------------------------------------------------
 -- | Floating layer support
 

XMonad/StackSet.hs

@@ -2,7 +2,7 @@
 
 -----------------------------------------------------------------------------
 -- |
--- Module      :  StackSet
+-- Module      :  XMonad.StackSet
 -- Copyright   :  (c) Don Stewart 2007
 -- License     :  BSD3-style (see LICENSE)
 --
@@ -122,38 +122,6 @@ import qualified Data.Map  as M (Map,insert,delete,empty)
 -- 'delete'.
 --
 
--- |
--- API changes from xmonad 0.1:
--- StackSet constructor arguments changed. StackSet workspace window screen
---
--- * new,                    -- was: empty
---
--- * view,
---
--- * index,
---
--- * peek,                   -- was: peek\/peekStack
---
--- * focusUp, focusDown,     -- was: rotate
---
--- * swapUp, swapDown
---
--- * focus                   -- was: raiseFocus
---
--- * insertUp,               -- was: insert\/push
---
--- * delete,
---
--- * swapMaster,             -- was: promote\/swap
---
--- * member,
---
--- * shift,
---
--- * lookupWorkspace,        -- was: workspace
---
--- * visibleWorkspaces       -- gone.
---
 ------------------------------------------------------------------------
 -- |
 -- A cursor into a non-empty list of workspaces.
@@ -177,7 +145,7 @@ data Screen i l a sid sd = Screen { workspace :: !(Workspace i l a)
     deriving (Show, Read, Eq)
 
 -- |
--- A workspace is just a tag - its index - and a stack
+-- A workspace is just a tag, a layout, and a stack.
 --
 data Workspace i l a = Workspace  { tag :: !i, layout :: l, stack :: Maybe (Stack a) }
     deriving (Show, Read, Eq)
@@ -242,8 +210,7 @@ new _ _ _ = abort "non-positive argument to StackSet.new"
 
 view :: (Eq s, Eq i) => i -> StackSet i l a s sd -> StackSet i l a s sd
 view i s
-    | not (i `tagMember` s)
+    | i == tag (workspace (current s)) = s  -- current
-      || i == tag (workspace (current s)) = s  -- out of bounds or current
 
     | Just x <- L.find ((i==).tag.workspace) (visible s)
     -- if it is visible, it is just raised
@@ -254,7 +221,7 @@ view i s
     = s { current = (current s) { workspace = x }
         , hidden = workspace (current s) : L.deleteBy (equating tag) x (hidden s) }
 
-    | otherwise = s -- can't happen: all workspaces are either invalid, current, visible, or hidden
+    | otherwise = s -- not a member of the stackset
 
   where equating f = \x y -> f x == f y
 
@@ -446,7 +413,7 @@ mapLayout f (StackSet v vs hs m) = StackSet (fScreen v) (map fScreen vs) (map fW
     fScreen (Screen ws s sd) = Screen (fWorkspace ws) s sd
     fWorkspace (Workspace t l s) = Workspace t (f l) s
 
--- | /O(n)/. Is a window in the StackSet.
+-- | /O(n)/. Is a window in the StackSet?
 member :: Eq a => a -> StackSet i l a s sd -> Bool
 member a s = isJust (findTag a s)
 

man/xmonad.1.in

@@ -9,32 +9,23 @@ xmonad \- a tiling window manager
 .PP
 By default, \fBxmonad\fR provides three layout algorithms: tall, wide and fullscreen. In tall or wide mode, windows are tiled and arranged to prevent overlap and maximise screen use. Sets of windows are grouped together on virtual screens, and each screen retains its own layout, which may be reconfigured dynamically. Multiple physical monitors are supported via Xinerama, allowing simultaneous display of a number of screens.
 .PP
-By utilising the expressivity of a modern functional language with a rich static type system, \fBxmonad\fR provides a complete, featureful window manager in less than 500 lines of code, with an emphasis on correctness and robustness. Internal properties of the window manager are checked using a combination of static guarantees provided by the type system, and type-based automated testing. A benefit of this is that the code is simple to understand, and easy to modify.
+By utilising the expressivity of a modern functional language with a rich static type system, \fBxmonad\fR provides a complete, featureful window manager in less than 1200 lines of code, with an emphasis on correctness and robustness. Internal properties of the window manager are checked using a combination of static guarantees provided by the type system, and type-based automated testing. A benefit of this is that the code is simple to understand, and easy to modify.
 .SH USAGE
 .PP
 \fBxmonad\fR places each window into a "workspace". Each workspace can have any number of windows, which you can cycle though with mod-j and mod-k. Windows are either displayed full screen, tiled horizontally, or tiled vertically. You can toggle the layout mode with mod-space, which will cycle through the available modes.
 .PP
 You can switch to workspace N with mod-N. For example, to switch to workspace 5, you would press mod-5. Similarly, you can move the current window to another workspace with mod-shift-N.
 .PP
-When running with multiple monitors (Xinerama), each screen has exactly 1 workspace visible. When \fBxmonad\fR starts, workspace 1 is on screen 1, workspace 2 is on screen 2, etc. If you switch to a workspace which is currently visible on another screen, \fBxmonad\fR simply switches focus to that screen. If you switch to a workspace which is *not* visible, \fBxmonad\fR replaces the workspace on the *current* screen with the workspace you selected.
+When running with multiple monitors (Xinerama), each screen has exactly 1 workspace visible. mod-{w,e,r} switch the focus between screens, while shift-mod-{w,e,r} move the current window to that screen. When \fBxmonad\fR starts, workspace 1 is on screen 1, workspace 2 is on screen 2, etc. When switching workspaces to one that is already visible, the current and visible workspaces are swapped.
 .PP
-For example, if you have the following configuration:
+.SS Flags
-.RS
+\fBxmonad\fR has several flags which you may pass to the executable. These flags are:
-.PP
+.TP
-Screen 1: Workspace 2
+\fB--recompile
-.PP
+Recompiles your configuration in ~/.xmonad/xmonad.hs
-Screen 2: Workspace 5 (current workspace)
+.TP
-.RE
+\fB--version
-.PP
+Display version of \fBxmonad\fR.
-and you wanted to view workspace 7 on screen 1, you would press:
-.RS
-.PP
-mod-2 (to select workspace 2, and make screen 1 the current screen)
-.PP
-mod-7 (to select workspace 7)
-.RE
-.PP
-Since switching to the workspace currently visible on a given screen is such a common operation, shortcuts are provided: mod-{w,e,r} switch to the workspace currently visible on screens 1, 2, and 3 respectively. Likewise, shift-mod-{w,e,r} moves the current window to the workspace on that screen. Using these keys, the above example would become mod-w mod-7.
 .SS Default keyboard bindings
 ___KEYBINDINGS___
 .SH EXAMPLES
@@ -44,6 +35,6 @@ xmonad
 .RE
 to your \fI~/.xinitrc\fR file
 .SH CUSTOMIZATION
-\fBxmonad\fR is customized by creating a custom Config.hs and (re)compiling the source code. After recompiling, 'restart' is used to fork the new version, with changes reflected immediately.
+\fBxmonad\fR is customized in ~/.xmonad/xmonad.hs, and then restarting with mod-q.
 .SH BUGS
 Probably. If you find any, please report them: http://code.google.com/p/xmonad/issues/list

man/xmonad.hs

@@ -145,8 +145,7 @@ myKeys conf@(XConfig {XMonad.modMask = modMask}) = M.fromList $
     , ((modMask .|. shiftMask, xK_q     ), io (exitWith ExitSuccess))
 
     -- Restart xmonad
-    , ((modMask              , xK_q     ),
+    , ((modMask              , xK_q     ), restart "xmonad" True)
-          broadcastMessage ReleaseResources >> restart (Just "xmonad") True)
     ]
     ++
 
@@ -222,12 +221,19 @@ myLayout = tiled ||| Mirror tiled ||| Full
 -- > xprop | grep WM_CLASS
 -- and click on the client you're interested in.
 --
+-- To match on the WM_NAME, you can use 'title' in the same way that
+-- 'className' and 'resource' are used below.
+--
 myManageHook = composeAll
     [ className =? "MPlayer"        --> doFloat
     , className =? "Gimp"           --> doFloat
     , resource  =? "desktop_window" --> doIgnore
     , resource  =? "kdesktop"       --> doIgnore ]
 
+-- Whether focus follows the mouse pointer.
+myFocusFollowsMouse :: Bool
+myFocusFollowsMouse = True
+
 
 ------------------------------------------------------------------------
 -- Status bars and logging
@@ -241,6 +247,16 @@ myManageHook = composeAll
 --
 myLogHook = return ()
 
+------------------------------------------------------------------------
+-- Startup hook
+
+-- Perform an arbitrary action each time xmonad starts or is restarted
+-- with mod-q.  Used by, e.g., XMonad.Layout.PerWorkspace to initialize
+-- per-workspace layout choices.
+--
+-- By default, do nothing.
+myStartupHook = return ()
+
 ------------------------------------------------------------------------
 -- Now run xmonad with all the defaults we set up.
 
@@ -257,6 +273,7 @@ main = xmonad defaults
 defaults = defaultConfig {
       -- simple stuff
         terminal           = myTerminal,
+        focusFollowsMouse  = myFocusFollowsMouse,
         borderWidth        = myBorderWidth,
         modMask            = myModMask,
         numlockMask        = myNumlockMask,
@@ -272,5 +289,6 @@ defaults = defaultConfig {
       -- hooks, layouts
         layoutHook         = myLayout,
         manageHook         = myManageHook,
-        logHook            = myLogHook
+        logHook            = myLogHook,
+        startupHook        = myStartupHook
     }

tests/Main.hs

@@ -1,8 +0,0 @@
-module Main where
-
-import qualified Properties
-
--- This will run all of the QC files for xmonad core. Currently, that's just
--- Properties. If any more get added, sequence the main actions together.
-main = do
-  Properties.main

tests/Properties.hs

@@ -1,7 +1,10 @@
-{-# OPTIONS -fglasgow-exts #-}
+{-# OPTIONS -fglasgow-exts -w #-}
 module Properties where
 
 import XMonad.StackSet hiding (filter)
+import XMonad.Layout
+import XMonad.Core hiding (workspaces,trace)
+import XMonad.Operations  ( applyResizeIncHint, applyMaxSizeHint )
 import qualified XMonad.StackSet as S (filter)
 
 import Debug.Trace
@@ -52,7 +55,6 @@ instance (Integral i, Integral s, Eq a, Arbitrary a, Arbitrary l, Arbitrary sd)
                        | s <- ls ]
 
         return $ fromList (fromIntegral n, sds,fs,ls,lay)
-    coarbitrary = error "no coarbitrary for StackSet"
 
 
 -- | fromList. Build a new StackSet from a list of list of elements,
@@ -137,10 +139,10 @@ prop_empty_I  (n :: Positive Int) l = forAll (choose (1,fromIntegral n)) $  \m -
         invariant $ new l [0..fromIntegral n-1] ms
 
 prop_view_I (n :: NonNegative Int) (x :: T) =
-    n `tagMember` x ==> invariant $ view (fromIntegral n) x
+    invariant $ view (fromIntegral n) x
 
 prop_greedyView_I (n :: NonNegative Int) (x :: T) =
-    n `tagMember` x ==> invariant $ view (fromIntegral n) x
+    invariant $ greedyView (fromIntegral n) x
 
 prop_focusUp_I (n :: NonNegative Int) (x :: T) =
     invariant $ foldr (const focusUp) x [1..n]
@@ -237,6 +239,13 @@ prop_greedyView_current (x :: T) (n :: NonNegative Int) = i `tagMember` x ==>
   where
     i = fromIntegral n
 
+-- greedyView leaves things unchanged for invalid workspaces
+prop_greedyView_current_id (x :: T) (n :: NonNegative Int) = not (i `tagMember` x) ==>
+    tag (workspace $ current (greedyView i x)) == j
+  where
+    i = fromIntegral n
+    j = tag (workspace (current x))
+
 -- greedyView *only* sets the current workspace, and touches Xinerama.
 -- no workspace contents will be changed.
 prop_greedyView_local  (x :: T) (n :: NonNegative Int) = i `tagMember` x ==>
@@ -349,6 +358,10 @@ prop_focusWindow_local (n :: NonNegative Int) (x::T ) =
                        i = fromIntegral n `mod` length s
                    in hidden_spaces (focusWindow (s !! i) x) == hidden_spaces x
 
+-- On an invalid window, the stackset is unmodified
+prop_focusWindow_identity (n :: Char) (x::T ) =
+    not (n `member` x) ==> focusWindow n x == x
+
 -- ---------------------------------------------------------------------
 -- member/findTag
 
@@ -541,13 +554,19 @@ prop_float_reversible n (x :: T) =
         where
             geom = RationalRect 100 100 100 100
 
--- check rectanges were set
+prop_float_geometry n (x :: T) =
-{-
+    n `member` x ==> let s = float n geom x
-prop_float_sets_geometry n (x :: T) =
+                     in M.lookup n (floating s) == Just geom
-    n `member` x ==> let y = float n geom x in M.lookup y (floating x) == Just geom
         where
             geom = RationalRect 100 100 100 100
--}
+
+prop_float_delete n (x :: T) =
+    n `member` x ==> let s = float n geom x
+                         t = delete n s
+                     in not (n `member` t)
+        where
+            geom = RationalRect 100 100 100 100
+
 
 ------------------------------------------------------------------------
 
@@ -606,9 +625,26 @@ prop_rename1 (x::T) o n = o `tagMember` x && not (n `tagMember` x) ==>
     let y = renameTag o n x
             in n `tagMember` y
 
+-- | 
+-- Ensure that a given set of workspace tags is present by renaming
+-- existing workspaces and\/or creating new hidden workspaces as
+-- necessary.
+--
 prop_ensure (x :: T) l xs = let y = ensureTags l xs x
                                 in and [ n `tagMember` y | n <- xs ]
 
+-- adding a tag should create a new hidden workspace
+prop_ensure_append (x :: T) l n =
+    not (n  `tagMember` x)
+      ==>
+   (hidden y /= hidden x        -- doesn't append, renames
+   &&
+   and [ isNothing (stack z) && layout z == l | z <- hidden y, tag z == n ]
+   )
+  where
+    y  = ensureTags l (n:ts) x
+    ts = [ tag z | z <- workspaces x ]
+
 prop_mapWorkspaceId (x::T) = x == mapWorkspace id x
 
 prop_mapWorkspaceInverse (x::T) = x == mapWorkspace predTag (mapWorkspace succTag x)
@@ -620,17 +656,145 @@ prop_mapLayoutId (x::T) = x == mapLayout id x
 prop_mapLayoutInverse (x::T) = x == mapLayout pred (mapLayout succ x)
 
 ------------------------------------------------------------------------
--- some properties for layouts:
+-- The Tall layout
 
 -- 1 window should always be tiled fullscreen
-{-
 prop_tile_fullscreen rect = tile pct rect 1 1 == [rect]
+    where pct = 1/2
 
 -- multiple windows
 prop_tile_non_overlap rect windows nmaster = noOverlaps (tile pct rect nmaster windows)
   where _ = rect :: Rectangle
+        pct = 3 % 100
 
-pct = 3 % 100
+-- splitting horizontally yields sensible results
+prop_split_hoziontal (NonNegative n) x =
+{-
+    trace (show (rect_x x
+                ,rect_width x
+                ,rect_x x + fromIntegral (rect_width x)
+                ,map rect_x xs))
+          $
+-}
+
+        sum (map rect_width xs) == rect_width x
+     &&
+        all (== rect_height x) (map rect_height xs)
+     &&
+        (map rect_x xs) == (sort $ map rect_x xs)
+
+    where
+        xs = splitHorizontally n x
+
+-- splitting horizontally yields sensible results
+prop_splitVertically (r :: Rational) x =
+
+        rect_x x == rect_x a && rect_x x == rect_x b
+      &&
+        rect_width x == rect_width a && rect_width x == rect_width b
+
+{-
+    trace (show (rect_x x
+                ,rect_width x
+                ,rect_x x + fromIntegral (rect_width x)
+                ,map rect_x xs))
+          $
+-}
+
+    where
+        (a,b) = splitVerticallyBy r x
+
+
+-- pureLayout works.
+prop_purelayout_tall n r1 r2 rect (t :: T) =
+    isJust (peek t) ==>
+        length ts == length (index t)
+      &&
+        noOverlaps (map snd ts)
+      &&
+        description layoot == "Tall"
+    where layoot = Tall n r1 r2
+          st = fromJust . stack . workspace . current $ t
+          ts = pureLayout layoot rect st
+
+-- Test message handling of Tall
+
+-- what happens when we send a Shrink message to Tall
+prop_shrink_tall (NonNegative n) (NonZero (NonNegative delta)) (NonNegative frac) =
+        n == n' && delta == delta' -- these state components are unchanged
+    && frac' <= frac  && (if frac' < frac then frac' == 0 || frac' == frac - delta
+                                          else frac == 0 )
+        -- remaining fraction should shrink
+    where
+         l1                   = Tall n delta frac
+         Just l2@(Tall n' delta' frac') = l1 `pureMessage` (SomeMessage Shrink)
+        --  pureMessage :: layout a -> SomeMessage -> Maybe (layout a)
+
+
+-- what happens when we send a Shrink message to Tall
+prop_expand_tall (NonNegative n)
+                 (NonZero (NonNegative delta))
+                 (NonNegative n1)
+                 (NonZero (NonNegative d1)) =
+
+       n == n'
+    && delta == delta' -- these state components are unchanged
+    && frac' >= frac
+    && (if frac' > frac
+           then frac' == 1 || frac' == frac + delta
+           else frac == 1 )
+
+        -- remaining fraction should shrink
+    where
+         frac                 = min 1 (n1 % d1)
+         l1                   = Tall n delta frac
+         Just l2@(Tall n' delta' frac') = l1 `pureMessage` (SomeMessage Expand)
+        --  pureMessage :: layout a -> SomeMessage -> Maybe (layout a)
+
+-- what happens when we send an IncMaster message to Tall
+prop_incmaster_tall (NonNegative n) (NonZero (NonNegative delta)) (NonNegative frac)
+                    (NonNegative k) =
+       delta == delta'  && frac == frac' && n' == n + k
+    where
+         l1                   = Tall n delta frac
+         Just l2@(Tall n' delta' frac') = l1 `pureMessage` (SomeMessage (IncMasterN k))
+        --  pureMessage :: layout a -> SomeMessage -> Maybe (layout a)
+
+
+
+     --   toMessage LT = SomeMessage Shrink
+     --   toMessage EQ = SomeMessage Expand
+     --   toMessage GT = SomeMessage (IncMasterN 1)
+
+
+------------------------------------------------------------------------
+-- Full layout
+
+-- pureLayout works for Full
+prop_purelayout_full rect (t :: T) =
+    isJust (peek t) ==>
+        length ts == 1        -- only one window to view
+      &&
+        snd (head ts) == rect -- and sets fullscreen
+      &&
+        fst (head ts) == fromJust (peek t) -- and the focused window is shown
+
+    where layoot = Full
+          st = fromJust . stack . workspace . current $ t
+          ts = pureLayout layoot rect st
+
+-- what happens when we send an IncMaster message to Full --- Nothing
+prop_sendmsg_full (NonNegative k) =
+         isNothing (Full `pureMessage` (SomeMessage (IncMasterN k)))
+
+prop_desc_full = description Full == show Full
+
+------------------------------------------------------------------------
+
+prop_desc_mirror n r1 r2 = description (Mirror $! t) == "Mirror Tall"
+    where t = Tall n r1 r2
+
+------------------------------------------------------------------------
 
 noOverlaps []  = True
 noOverlaps [_] = True
@@ -646,15 +810,36 @@ noOverlaps xs  = and [ verts a `notOverlap` verts b
         =  (top1 < bottom2 || top2 < bottom1)
         || (right1 < left2 || right2 < left1)
 
--}
+------------------------------------------------------------------------
+-- Aspect ratios
+
+prop_resize_inc (NonZero (NonNegative inc_w),NonZero (NonNegative inc_h))  b@(w,h) =
+    w' `mod` inc_w == 0 && h' `mod` inc_h == 0
+   where (w',h') = applyResizeIncHint a b
+         a = (inc_w,inc_h)
+
+prop_resize_inc_extra ((NonNegative inc_w))  b@(w,h) =
+     (w,h) == (w',h')
+   where (w',h') = applyResizeIncHint a b
+         a = (-inc_w,0::Dimension)-- inc_h)
+
+prop_resize_max (NonZero (NonNegative inc_w),NonZero (NonNegative inc_h))  b@(w,h) =
+    w' <= inc_w && h' <= inc_h
+   where (w',h') = applyMaxSizeHint a b
+         a = (inc_w,inc_h)
+
+prop_resize_max_extra ((NonNegative inc_w))  b@(w,h) =
+     (w,h) == (w',h')
+   where (w',h') = applyMaxSizeHint a b
+         a = (-inc_w,0::Dimension)-- inc_h)
 
 ------------------------------------------------------------------------
 
 main :: IO ()
 main = do
-    args <- getArgs
+    args <- fmap (drop 1) getArgs
     let n = if null args then 100 else read (head args)
-    (results, passed) <- liftM unzip $ mapM (\(s,a) -> printf "%-25s: " s >> a n) tests
+    (results, passed) <- liftM unzip $ mapM (\(s,a) -> printf "%-40s: " s >> a n) tests
     printf "Passed %d tests!\n" (sum passed)
     when (not . and $ results) $ fail "Not all tests passed!"
  where
@@ -676,6 +861,7 @@ main = do
 
         ,("greedyView : invariant"    , mytest prop_greedyView_I)
         ,("greedyView sets current"   , mytest prop_greedyView_current)
+        ,("greedyView is safe "   ,   mytest prop_greedyView_current_id)
         ,("greedyView idempotent"     , mytest prop_greedyView_idem)
         ,("greedyView reversible"     , mytest prop_greedyView_reversible)
         ,("greedyView is local"       , mytest prop_greedyView_local)
@@ -705,6 +891,7 @@ main = do
 
         ,("focusWindow is local", mytest prop_focusWindow_local)
         ,("focusWindow works"   , mytest prop_focusWindow_works)
+        ,("focusWindow identity", mytest prop_focusWindow_identity)
 
         ,("findTag"           , mytest prop_findIndex)
         ,("allWindows/member"   , mytest prop_allWindowsMember)
@@ -749,13 +936,17 @@ main = do
         ,("shiftWin fix current" , mytest prop_shift_win_fix_current)
 
         ,("floating is reversible" , mytest prop_float_reversible)
+        ,("floating sets geometry" , mytest prop_float_geometry)
+        ,("floats can be deleted", mytest prop_float_delete)
         ,("screens includes current", mytest prop_screens)
+
         ,("differentiate works", mytest prop_differentiate)
         ,("lookupTagOnScreen", mytest prop_lookup_current)
         ,("lookupTagOnVisbleScreen", mytest prop_lookup_visible)
         ,("screens works",      mytest prop_screens_works)
         ,("renaming works",     mytest prop_rename1)
         ,("ensure works",     mytest prop_ensure)
+        ,("ensure hidden semantics",     mytest prop_ensure_append)
 
         ,("mapWorkspace id", mytest prop_mapWorkspaceId)
         ,("mapWorkspace inverse", mytest prop_mapWorkspaceInverse)
@@ -767,12 +958,31 @@ main = do
         ,("new fails with abort",   mytest prop_new_abort)
         ,("shiftWin identity",      mytest prop_shift_win_indentity)
 
-        -- renaming
+        -- tall layout
 
-{-
         ,("tile 1 window fullsize", mytest prop_tile_fullscreen)
         ,("tiles never overlap",    mytest prop_tile_non_overlap)
--}
+        ,("split hozizontally",     mytest prop_split_hoziontal)
+        ,("split verticalBy",       mytest prop_splitVertically)
+
+        ,("pure layout tall",       mytest prop_purelayout_tall)
+        ,("send shrink    tall",    mytest prop_shrink_tall)
+        ,("send expand    tall",    mytest prop_expand_tall)
+        ,("send incmaster tall",    mytest prop_incmaster_tall)
+
+        -- full layout
+
+        ,("pure layout full",       mytest prop_purelayout_full)
+        ,("send message full",      mytest prop_sendmsg_full)
+        ,("describe full",          mytest prop_desc_full)
+
+        ,("describe mirror",        mytest prop_desc_mirror)
+
+        -- resize hints
+        ,("window hints: inc",      mytest prop_resize_inc)
+        ,("window hints: inc all",  mytest prop_resize_inc_extra)
+        ,("window hints: max",      mytest prop_resize_max)
+        ,("window hints: max all ", mytest prop_resize_max_extra)
 
         ]
 
@@ -941,6 +1151,7 @@ instance Arbitrary EmptyStackSet where
         l <- arbitrary
         -- there cannot be more screens than workspaces:
         return . EmptyStackSet . new l ns $ take (min (length ns) (length sds)) sds
+    coarbitrary = error "coarbitrary EmptyStackSet"
 
 -- | Generates a value that satisfies a predicate.
 suchThat :: Gen a -> (a -> Bool) -> Gen a

tests/coverage.hs

@@ -0,0 +1,10 @@
+#!/usr/bin/env runhaskell
+
+import System.Cmd
+
+-- generate appropriate .hpc files
+main = do
+    system $ "rm -rf *.tix"
+    system $ "dist/build/xmonad/xmonad --run-tests"
+    system $ "hpc markup xmonad --exclude=Main --exclude=Properties --exclude=XMonad --exclude=Paths_xmonad"
+    system $ "hpc report xmonad --exclude=Main --exclude=Properties --exclude=XMonad --exclude=Paths_xmonad"

xmonad.cabal

@@ -1,5 +1,5 @@
 name:               xmonad
-version:            0.5
+version:            0.7
 homepage:           http://xmonad.org
 synopsis:           A tiling window manager
 description:
@@ -21,10 +21,15 @@ extra-source-files: README TODO CONFIG STYLE tests/loc.hs tests/Properties.hs
                     man/xmonad.1.in man/xmonad.1 man/xmonad.html man/xmonad.hs
                     util/GenerateManpage.hs
 cabal-version:      >= 1.2
+build-type:         Simple
 
 flag small_base
     description: Choose the new smaller, split-up base package.
 
+flag testing
+    description: Testing mode, only build minimal components
+    default: False
+
 library
     exposed-modules:    XMonad
                         XMonad.Main
@@ -39,17 +44,34 @@ library
         build-depends: base >= 3, containers, directory, process
     else
         build-depends: base < 3
-    build-depends: X11>=1.4.0, mtl, unix
+    build-depends: X11>=1.4.1, mtl, unix
 
-    ghc-options:        -funbox-strict-fields -Wall -Werror -optl-Wl,-s
+    ghc-options:        -funbox-strict-fields -Wall -optl-Wl,-s
     ghc-prof-options:   -prof -auto-all
     extensions:         CPP
 
+    if flag(testing)
+        buildable: False
+
 executable xmonad
     main-is:            Main.hs
-    other-modules:      XMonad.Core XMonad.Main XMonad.Layout
+    other-modules:      XMonad
-                        XMonad.Operations XMonad.StackSet XMonad
+                        XMonad.Main
+                        XMonad.Core
+                        XMonad.Config
+                        XMonad.Layout
+                        XMonad.ManageHook
+                        XMonad.Operations
+                        XMonad.StackSet
 
-    ghc-options:        -funbox-strict-fields -Wall -Werror -optl-Wl,-s
+    ghc-options:        -funbox-strict-fields -Wall -optl-Wl,-s
     ghc-prof-options:   -prof -auto-all
     extensions:         CPP
+
+    if flag(testing)
+        cpp-options:    -DTESTING
+        hs-source-dirs: . tests/
+        build-depends:  QuickCheck < 2
+        ghc-options:    -Werror
+    if flag(testing) && flag(small_base)
+        build-depends:  random