xmonad-contrib 0.8.1 → 0.9

raw patch · 171 files changed

+11401/−2514 lines, 171 filesdep ~X11dep ~xmonadPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: X11, xmonad

API changes (from Hackage documentation)

Files

• README +69/−15
• XMonad/Actions/Commands.hs +8/−9
• XMonad/Actions/ConstrainedResize.hs +3/−3
• XMonad/Actions/CopyWindow.hs +86/−38
• XMonad/Actions/CycleRecentWS.hs +1/−1
• XMonad/Actions/CycleSelectedLayouts.hs +2/−2
• XMonad/Actions/CycleWS.hs +73/−26
• XMonad/Actions/CycleWindows.hs +233/−0
• XMonad/Actions/DeManage.hs +4/−3
• XMonad/Actions/DwmPromote.hs +2/−2
• XMonad/Actions/DynamicWorkspaces.hs +7/−7
• XMonad/Actions/FindEmptyWorkspace.hs +3/−3
• XMonad/Actions/FlexibleManipulate.hs +2/−2
• XMonad/Actions/FlexibleResize.hs +36/−22
• XMonad/Actions/FloatKeys.hs +6/−6
• XMonad/Actions/FloatSnap.hs +328/−0
• XMonad/Actions/FocusNth.hs +3/−3
• XMonad/Actions/GridSelect.hs +525/−0
• XMonad/Actions/MessageFeedback.hs +99/−0
• XMonad/Actions/MouseGestures.hs +9/−9
• XMonad/Actions/MouseResize.hs +4/−3
• XMonad/Actions/NoBorders.hs +2/−2
• XMonad/Actions/OnScreen.hs +115/−0
• XMonad/Actions/PerWorkspaceKeys.hs +1/−1
• XMonad/Actions/PhysicalScreens.hs +88/−0
• XMonad/Actions/Plane.hs +26/−32
• XMonad/Actions/Promote.hs +1/−1
• XMonad/Actions/RandomBackground.hs +72/−0
• XMonad/Actions/RotSlaves.hs +2/−2
• XMonad/Actions/Search.hs +172/−39
• XMonad/Actions/SimpleDate.hs +1/−1
• XMonad/Actions/SinkAll.hs +8/−14
• XMonad/Actions/SpawnOn.hs +122/−0
• XMonad/Actions/Submap.hs +12/−7
• XMonad/Actions/SwapWorkspaces.hs +5/−4
• XMonad/Actions/TagWindows.hs +13/−14
• XMonad/Actions/TopicSpace.hs +317/−0
• XMonad/Actions/UpdateFocus.hs +61/−0
• XMonad/Actions/UpdatePointer.hs +40/−27
• XMonad/Actions/Warp.hs +20/−4
• XMonad/Actions/WindowBringer.hs +20/−11
• XMonad/Actions/WindowGo.hs +78/−30
• XMonad/Actions/WindowMenu.hs +71/−0
• XMonad/Actions/WindowNavigation.hs +24/−22
• XMonad/Actions/WithAll.hs +54/−0
• XMonad/Actions/WorkspaceCursors.hs +219/−0
• XMonad/Config/Arossato.hs +2/−2
• XMonad/Config/Azerty.hs +48/−0
• XMonad/Config/Desktop.hs +150/−8
• XMonad/Config/Droundy.hs +14/−16
• XMonad/Config/Gnome.hs +31/−4
• XMonad/Config/Kde.hs +19/−3
• XMonad/Config/PlainConfig.hs +0/−528
• XMonad/Config/Sjanssen.hs +30/−18
• XMonad/Config/Xfce.hs +6/−3
• XMonad/Doc/Configuring.hs +28/−30
• XMonad/Doc/Extending.hs +604/−196
• XMonad/Hooks/DynamicHooks.hs +10/−10
• XMonad/Hooks/DynamicLog.hs +97/−70
• XMonad/Hooks/EventHook.hs +0/−108
• XMonad/Hooks/EwmhDesktops.hs +46/−50
• XMonad/Hooks/FadeInactive.hs +43/−24
• XMonad/Hooks/FloatNext.hs +157/−0
• XMonad/Hooks/InsertPosition.hs +74/−0
• XMonad/Hooks/ManageDocks.hs +59/−42
• XMonad/Hooks/ManageHelpers.hs +70/−15
• XMonad/Hooks/Place.hs +460/−0
• XMonad/Hooks/RestoreMinimized.hs +49/−0
• XMonad/Hooks/Script.hs +1/−1
• XMonad/Hooks/ServerMode.hs +20/−17
• XMonad/Hooks/UrgencyHook.hs +113/−48
• XMonad/Hooks/WorkspaceByPos.hs +54/−0
• XMonad/Hooks/XPropManage.hs +2/−2
• XMonad/Layout/Accordion.hs +3/−3
• XMonad/Layout/AutoMaster.hs +123/−0
• XMonad/Layout/BorderResize.hs +164/−0
• XMonad/Layout/BoringWindows.hs +103/−32
• XMonad/Layout/CenteredMaster.hs +110/−0
• XMonad/Layout/Circle.hs +2/−2
• XMonad/Layout/Column.hs +71/−0
• XMonad/Layout/Combo.hs +9/−10
• XMonad/Layout/ComboP.hs +180/−0
• XMonad/Layout/Cross.hs +112/−0
• XMonad/Layout/Decoration.hs +12/−9
• XMonad/Layout/DecorationMadness.hs +10/−10
• XMonad/Layout/Dishes.hs +2/−2
• XMonad/Layout/DragPane.hs +11/−12
• XMonad/Layout/FixedColumn.hs +91/−0
• XMonad/Layout/Gaps.hs +15/−19
• XMonad/Layout/Grid.hs +19/−9
• XMonad/Layout/GridVariants.hs +224/−0
• XMonad/Layout/HintedGrid.hs +20/−11
• XMonad/Layout/HintedTile.hs +4/−3
• XMonad/Layout/IM.hs +5/−5
• XMonad/Layout/IndependentScreens.hs +104/−0
• XMonad/Layout/LayoutBuilder.hs +277/−0
• XMonad/Layout/LayoutCombinators.hs +11/−12
• XMonad/Layout/LayoutHints.hs +195/−14
• XMonad/Layout/LayoutModifier.hs +10/−33
• XMonad/Layout/LayoutScreens.hs +5/−4
• XMonad/Layout/LimitWindows.hs +160/−0
• XMonad/Layout/MagicFocus.hs +61/−9
• XMonad/Layout/Magnifier.hs +13/−14
• XMonad/Layout/Master.hs +50/−74
• XMonad/Layout/Maximize.hs +22/−18
• XMonad/Layout/MessageControl.hs +126/−0
• XMonad/Layout/Minimize.hs +94/−0
• XMonad/Layout/Monitor.hs +172/−0
• XMonad/Layout/Mosaic.hs +210/−0
• XMonad/Layout/MosaicAlt.hs +10/−11
• XMonad/Layout/MouseResizableTile.hs +271/−0
• XMonad/Layout/MultiToggle.hs +3/−6
• XMonad/Layout/MultiToggle/Instances.hs +1/−3
• XMonad/Layout/Named.hs +16/−3
• XMonad/Layout/NoBorders.hs +121/−28
• XMonad/Layout/NoFrillsDecoration.hs +48/−0
• XMonad/Layout/OneBig.hs +133/−0
• XMonad/Layout/Reflect.hs +3/−7
• XMonad/Layout/ResizableTile.hs +20/−8
• XMonad/Layout/Roledex.hs +13/−9
• XMonad/Layout/ShowWName.hs +2/−4
• XMonad/Layout/SimpleFloat.hs +2/−2
• XMonad/Layout/Simplest.hs +2/−2
• XMonad/Layout/SimplestFloat.hs +6/−7
• XMonad/Layout/Spacing.hs +54/−0
• XMonad/Layout/Spiral.hs +2/−2
• XMonad/Layout/StackTile.hs +4/−5
• XMonad/Layout/SubLayouts.hs +506/−0
• XMonad/Layout/Tabbed.hs +25/−11
• XMonad/Layout/ThreeColumns.hs +59/−29
• XMonad/Layout/ToggleLayouts.hs +5/−6
• XMonad/Layout/TwoPane.hs +6/−6
• XMonad/Layout/WindowArranger.hs +18/−22
• XMonad/Layout/WindowNavigation.hs +29/−30
• XMonad/Layout/WorkspaceDir.hs +6/−7
• XMonad/Prompt.hs +241/−169
• XMonad/Prompt/AppLauncher.hs +3/−3
• XMonad/Prompt/AppendFile.hs +3/−5
• XMonad/Prompt/Directory.hs +2/−2
• XMonad/Prompt/Email.hs +2/−2
• XMonad/Prompt/Input.hs +2/−2
• XMonad/Prompt/Layout.hs +3/−6
• XMonad/Prompt/Man.hs +3/−3
• XMonad/Prompt/RunOrRaise.hs +7/−7
• XMonad/Prompt/Shell.hs +8/−8
• XMonad/Prompt/Ssh.hs +3/−3
• XMonad/Prompt/Theme.hs +1/−1
• XMonad/Prompt/Window.hs +20/−9
• XMonad/Prompt/Workspace.hs +3/−6
• XMonad/Prompt/XMonad.hs +1/−1
• XMonad/Util/Cursor.hs +46/−0
• XMonad/Util/Dmenu.hs +16/−8
• XMonad/Util/Dzen.hs +1/−1
• XMonad/Util/EZConfig.hs +320/−24
• XMonad/Util/Font.hsc +2/−15
• XMonad/Util/Invisible.hs +3/−3
• XMonad/Util/Loggers.hs +241/−31
• XMonad/Util/NamedActions.hs +315/−0
• XMonad/Util/NamedScratchpad.hs +158/−0
• XMonad/Util/Paste.hs +94/−0
• XMonad/Util/Replace.hs +116/−0
• XMonad/Util/Run.hs +25/−15
• XMonad/Util/Scratchpad.hs +25/−49
• XMonad/Util/StringProp.hs +56/−0
• XMonad/Util/Themes.hs +137/−0
• XMonad/Util/Timer.hs +2/−1
• XMonad/Util/Types.hs +30/−0
• XMonad/Util/WindowProperties.hs +45/−8
• XMonad/Util/XSelection.hs +15/−43
• XMonad/Util/XUtils.hs +1/−1
• xmonad-contrib.cabal +52/−15

@@ -1,28 +1,82 @@-3rd party xmonad extensions and contributions.+  xmonad-contrib : third party extensions to the xmonad window manager -Build and install through Cabal as for other Haskell packages:+                           http://xmonad.org -        runhaskell Setup configure --user --prefix=$HOME-        runhaskell Setup build-        runhaskell Setup install --user+    You need the ghc compiler and xmonad window manager installed in+    order to use these extensions. -(You may want to remove the --user flag when installing as root.)+    For installation and configuration instructions, please see the+    xmonad website, the documents included with the xmonad source+    distribution, and online haddock documentation: -scripts/ contains further external programs useful with xmonad.+    http://www.xmonad.org/xmonad-docs -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 Mosaic layout, one would import:+------------------------------------------------------------------------ - XMonad.Layout.Mosaic+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.  --------------------------------------------------------------------------Documentation for the extensions and configuration system is available-in Haddock form in the XMonad.Doc module and submodules.

@@ -41,7 +41,7 @@ -- -- Then add a keybinding to the runCommand action: ----- >    , ((modMask x .|. controlMask, xK_y), commands >>= runCommand)+-- >    , ((modm .|. controlMask, xK_y), commands >>= runCommand) -- -- and define the list of commands you want to use: --@@ -82,23 +82,22 @@     wscmds <- workspaceCommands     return $ wscmds ++ screenCommands ++ otherCommands  where-    sr = broadcastMessage ReleaseResources     otherCommands =         [ ("shrink"              , sendMessage Shrink                               )         , ("expand"              , sendMessage Expand                               )         , ("next-layout"         , sendMessage NextLayout                           )         , ("default-layout"      , asks (layoutHook . config) >>= setLayout         )-        , ("restart-wm"          , sr >> restart "xmonad" True                       )-        , ("restart-wm-no-resume", sr >> restart "xmonad" False                      )+        , ("restart-wm"          , restart "xmonad" True                            )+        , ("restart-wm-no-resume", restart "xmonad" False                           )         , ("xterm"               , spawn =<< asks (terminal .  config)              )         , ("run"                 , spawn "exe=`dmenu_path | dmenu -b` && exec $exe" )         , ("kill"                , kill                                             )         , ("refresh"             , refresh                                          )-        , ("focus-up"            , windows $ focusUp                                )-        , ("focus-down"          , windows $ focusDown                              )-        , ("swap-up"             , windows $ swapUp                                 )-        , ("swap-down"           , windows $ swapDown                               )-        , ("swap-master"         , windows $ swapMaster                             )+        , ("focus-up"            , windows focusUp                                  )+        , ("focus-down"          , windows focusDown                                )+        , ("swap-up"             , windows swapUp                                   )+        , ("swap-down"           , windows swapDown                                 )+        , ("swap-master"         , windows swapMaster                               )         , ("sink"                , withFocused $ windows . sink                     )         , ("quit-wm"             , io $ exitWith ExitSuccess                        )         ]

@@ -5,7 +5,7 @@ -- License     :  BSD3-style (see LICENSE) -- -- Maintainer  :  <dougal@dougalstanton.net>--- Stability   :  unstable+-- Stability   :  stable -- Portability :  unportable -- -- Lets you constrain the aspect ratio of a floating@@ -31,8 +31,8 @@ -- -- Then add something like the following to your mouse bindings: ----- >     , ((modMask x, button3),               (\w -> focus w >> Sqr.mouseResizeWindow w False))--- >     , ((modMask x .|. shiftMask, button3), (\w -> focus w >> Sqr.mouseResizeWindow w True ))+-- >     , ((modm, button3),               (\w -> focus w >> Sqr.mouseResizeWindow w False))+-- >     , ((modm .|. shiftMask, button3), (\w -> focus w >> Sqr.mouseResizeWindow w True )) -- -- The line without the shiftMask replaces the standard mouse resize -- function call, so it's not completely necessary but seems neater

@@ -2,14 +2,14 @@ ----------------------------------------------------------------------------- -- | -- Module      :  XMonad.Actions.CopyWindow--- Copyright   :  (c) David Roundy <droundy@darcs.net>, Ivan Veselov <veselov@gmail.com>+-- Copyright   :  (c) David Roundy <droundy@darcs.net>, Ivan Veselov <veselov@gmail.com>, Lanny Ripple <lan3ny@gmail.com> -- License     :  BSD3-style (see LICENSE) -- -- Maintainer  :  ??? -- Stability   :  unstable -- Portability :  unportable ----- Provides a binding to duplicate a window on multiple workspaces,+-- Provides bindings to duplicate a window on multiple workspaces, -- providing dwm-like tagging functionality. -- -----------------------------------------------------------------------------@@ -17,14 +17,21 @@ module XMonad.Actions.CopyWindow (                                  -- * Usage                                  -- $usage-                                 copy, copyToAll, copyWindow, killAllOtherCopies, kill1+                                 copy, copyToAll, copyWindow, runOrCopy+                                 , killAllOtherCopies, kill1+                                 -- * Highlight workspaces containing copies in logHook+                                 -- $logHook+                                 , wsContainingCopies                                 ) where -import Prelude hiding (filter)+import XMonad+import Control.Arrow ((&&&))+import Control.Monad import qualified Data.List as L-import XMonad hiding (modify, workspaces)-import XMonad.StackSet +import XMonad.Actions.WindowGo+import qualified XMonad.StackSet as W+ -- $usage -- -- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@ file:@@ -36,7 +43,7 @@ -- > -- mod-[1..9] @@ Switch to workspace N -- > -- mod-shift-[1..9] @@ Move client to workspace N -- > -- mod-control-shift-[1..9] @@ Copy client to workspace N--- > [((m .|. modMask x, k), windows $ f i)+-- > [((m .|. modm, k), windows $ f i) -- >     | (i, k) <- zip (workspaces x) [xK_1 ..] -- >     , (f, m) <- [(W.view, 0), (W.shift, shiftMask), (copy, shiftMask .|. controlMask)]] --@@ -48,8 +55,13 @@ -- You may also wish to redefine the binding to kill a window so it only -- removes it from the current workspace, if it's present elsewhere: ----- >  , ((modMask x .|. shiftMask, xK_c     ), kill1) -- @@ Close the focused window+-- >  , ((modm .|. shiftMask, xK_c     ), kill1) -- @@ Close the focused window --+-- Instead of copying a window from one workspace to another maybe you don't+-- want to have to remember where you placed it.  For that consider:+--+-- >  , ((modm, xK_b    ), runOrCopy "firefox" (className =? "Firefox")) -- @@ run or copy firefox+-- -- Another possibility which this extension provides is 'making window -- always visible' (i.e. always on current workspace), similar to corresponding -- metacity functionality. This behaviour is emulated through copying given@@ -58,59 +70,95 @@ -- -- Here is the example of keybindings which provide these actions: ----- >  , ((modMask x, xK_v )", windows copyToAll) -- @@ Make focused window always visible--- >  , ((modMask x .|. shiftMask, xK_v ),  killAllOtherCopies) -- @@ Toggle window state back+-- >  , ((modm, xK_v ), windows copyToAll) -- @@ Make focused window always visible+-- >  , ((modm .|. shiftMask, xK_v ),  killAllOtherCopies) -- @@ Toggle window state back -- -- For detailed instructions on editing your key bindings, see -- "XMonad.Doc.Extending#Editing_key_bindings". --- | copy. Copy the focussed window to a new workspace.-copy :: (Eq s, Eq i, Eq a) => i -> StackSet i l a s sd -> StackSet i l a s sd-copy n s | Just w <- peek s = copyWindow w n s+-- $logHook+-- To distinguish workspaces containing copies of the focused window use+-- something like:+--+-- > sampleLogHook h = do+-- >    copies <- wsContainingCopies+-- >    let check ws | ws `elem` copies = pad . xmobarColor "red" "black" $ ws+-- >                 | otherwise = pad ws+-- >    dynamicLogWithPP myPP {ppHidden = check, ppOutput = hPutStrLn h}+-- >+-- > main = do+-- >    h <- spawnPipe "xmobar"+-- >    xmonad defaultConfig { 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+copy n s | Just w <- W.peek s = copyWindow w n s          | otherwise = s --- | copyToAll. Copy the focused window to all of workspaces.-copyToAll :: (Eq s, Eq i, Eq a) => StackSet i l a s sd -> StackSet i l a s sd-copyToAll s = foldr copy s $ map tag (workspaces s)+-- | Copy the focused window to all workspaces.+copyToAll :: (Eq s, Eq i, Eq a) => W.StackSet i l a s sd -> W.StackSet i l a s sd+copyToAll s = foldr copy s $ map W.tag (W.workspaces s) --- | copyWindow.  Copy a window to a new workspace-copyWindow :: (Eq a, Eq i, Eq s) => a -> i -> StackSet i l a s sd -> StackSet i l a s sd+-- | Copy an arbitrary window to a workspace.+copyWindow :: (Eq a, Eq i, Eq s) => a -> i -> W.StackSet i l a s sd -> W.StackSet i l a s sd copyWindow w n = copy'-    where copy' s = if n `tagMember` s-                    then view (tag (workspace (current s))) $ insertUp' w $ view n s+    where copy' s = if n `W.tagMember` s+                    then W.view (W.currentTag s) $ insertUp' w $ W.view n s                     else s-          insertUp' a s = modify (Just $ Stack a [] [])-                          (\(Stack t l r) -> if a `elem` t:l++r-                                             then Just $ Stack t l r-                                             else Just $ Stack a (L.delete a l) (L.delete a (t:r))) s+          insertUp' a s = W.modify (Just $ W.Stack a [] [])+                          (\(W.Stack t l r) -> if a `elem` t:l++r+                                             then Just $ W.Stack t l r+                                             else Just $ W.Stack a (L.delete a l) (L.delete a (t:r))) s  +-- | runOrCopy will run the provided shell command unless it can+--  find a specified window in which case it will copy the window to+--  the current workspace.  Similar to (i.e., stolen from) "XMonad.Actions.WindowGo".+runOrCopy :: String -> Query Bool -> X ()+runOrCopy = copyMaybe . spawn++-- | Copy a window if it exists, run the first argument otherwise.+copyMaybe :: X () -> Query Bool -> X ()+copyMaybe f qry = ifWindow qry copyWin f+    where copyWin = ask >>= \w -> doF (\ws -> copyWindow w (W.currentTag ws) ws)+ -- | Remove the focused window from this workspace.  If it's present in no -- other workspace, then kill it instead. If we do kill it, we'll get a -- delete notify back from X. -- -- There are two ways to delete a window. Either just kill it, or if it--- supports the delete protocol, send a delete event (e.g. firefox)---+-- supports the delete protocol, send a delete event (e.g. firefox). kill1 :: X () kill1 = do ss <- gets windowset-           whenJust (peek ss) $ \w -> if member w $ delete'' w ss+           whenJust (W.peek ss) $ \w -> if W.member w $ delete'' w ss                                       then windows $ delete'' w                                       else kill-    where delete'' w = modify Nothing (filter (/= w))+    where delete'' w = W.modify Nothing (W.filter (/= w)) --- | Kill all other copies of focused window (if they're present)--- 'All other' means here 'copies, which are not on current workspace'------ Consider calling this function after copyToAll---+-- | Kill all other copies of focused window (if they're present).+-- 'All other' means here 'copies which are not on the current workspace'. killAllOtherCopies :: X () killAllOtherCopies = do ss <- gets windowset-                        whenJust (peek ss) $ \w -> windows $-                                                   view (tag (workspace (current ss))) .+                        whenJust (W.peek ss) $ \w -> windows $+                                                   W.view (W.currentTag ss) .                                                    delFromAllButCurrent w     where       delFromAllButCurrent w ss = foldr ($) ss $-                                  map (delWinFromWorkspace w . tag) $-                                  hidden ss ++ map workspace (visible ss)-      delWinFromWorkspace w wid ss = modify Nothing (filter (/= w)) $ view wid ss+                                  map (delWinFromWorkspace w . W.tag) $+                                  W.hidden ss ++ map W.workspace (W.visible ss)+      delWinFromWorkspace w wid = W.modify Nothing (W.filter (/= w)) . W.view wid++-- | A list of hidden workspaces containing a copy of the focused window.+wsContainingCopies :: X [WorkspaceId]+wsContainingCopies = do+    ws <- gets windowset+    return $ copiesOfOn (W.peek ws) (taggedWindows $ W.hidden ws)++-- | Get a list of tuples (tag, [Window]) for each workspace.+taggedWindows :: [W.Workspace i l a] -> [(i, [a])]+taggedWindows = map $ W.tag &&& W.integrate' . W.stack++-- | Get tags with copies of the focused window (if present.)+copiesOfOn :: (Eq a) => Maybe a -> [(i, [a])] -> [i]+copiesOfOn foc tw = maybe [] hasCopyOf foc+  where hasCopyOf f = map fst $ filter ((f `elem` ) . snd) tw

@@ -30,7 +30,7 @@ -- -- > import XMonad.Actions.CycleRecentWS -- >--- >   , ((modMask x, xK_Tab), cycleRecentWS [xK_Alt_L] xK_Tab xK_grave)+-- >   , ((modm, xK_Tab), cycleRecentWS [xK_Alt_L] xK_Tab xK_grave) -- -- For detailed instructions on editing your key bindings, see -- "XMonad.Doc.Extending#Editing_key_bindings".

@@ -25,12 +25,12 @@  -- $usage -- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:--- +-- -- > import XMonad hiding ((|||)) -- > import XMonad.Layout.LayoutCombinators ((|||)) -- > import XMonad.Actions.CycleSelectedLayouts ----- >   , ((modMask x,  xK_t ),   cycleThroughLayouts ["Tall", "Mirror Tall"])+-- >   , ((modm,  xK_t ),   cycleThroughLayouts ["Tall", "Mirror Tall"]) -- -- Make sure you are using NewSelect from XMonad.Layout.LayoutCombinators, -- rather than the Select defined in xmonad core.

@@ -42,7 +42,11 @@                               , prevWS                               , shiftToNext                               , shiftToPrev++                                -- * Toggling the previous workspace+                                -- $toggling                               , toggleWS+                              , toggleOrView                                  -- * Moving between screens (xinerama) @@ -56,7 +60,7 @@                                 -- * Moving between workspaces, take two!                                 -- $taketwo -                              , WSDirection(..)+                              , Direction1D(..)                               , WSType(..)                                , shiftTo@@ -65,14 +69,18 @@                                 -- * The mother-combinator                                , findWorkspace+                              , toggleOrDoSkip+                              , skipTags                               ) where +import Control.Monad ( unless ) import Data.List ( findIndex ) import Data.Maybe ( isNothing, isJust )  import XMonad hiding (workspaces) import XMonad.StackSet hiding (filter)+import XMonad.Util.Types import XMonad.Util.WorkspaceCompare  -- $usage@@ -82,27 +90,27 @@ -- > -- > -- a basic CycleWS setup -- >--- >   , ((modMask x,               xK_Down),  nextWS)--- >   , ((modMask x,               xK_Up),    prevWS)--- >   , ((modMask x .|. shiftMask, xK_Down),  shiftToNext)--- >   , ((modMask x .|. shiftMask, xK_Up),    shiftToPrev)--- >   , ((modMask x,               xK_Right), nextScreen)--- >   , ((modMask x,               xK_Left),  prevScreen)--- >   , ((modMask x .|. shiftMask, xK_Right), shiftNextScreen)--- >   , ((modMask x .|. shiftMask, xK_Left),  shiftPrevScreen)--- >   , ((modMask x,               xK_z),     toggleWS)+-- >   , ((modm,               xK_Down),  nextWS)+-- >   , ((modm,               xK_Up),    prevWS)+-- >   , ((modm .|. shiftMask, xK_Down),  shiftToNext)+-- >   , ((modm .|. shiftMask, xK_Up),    shiftToPrev)+-- >   , ((modm,               xK_Right), nextScreen)+-- >   , ((modm,               xK_Left),  prevScreen)+-- >   , ((modm .|. shiftMask, xK_Right), shiftNextScreen)+-- >   , ((modm .|. shiftMask, xK_Left),  shiftPrevScreen)+-- >   , ((modm,               xK_z),     toggleWS) -- -- If you want to follow the moved window, you can use both actions: ----- >   , ((modMask x .|. shiftMask, xK_Down), shiftToNext >> nextWS)--- >   , ((modMask x .|. shiftMask, xK_Up),   shiftToPrev >> prevWS)+-- >   , ((modm .|. shiftMask, xK_Down), shiftToNext >> nextWS)+-- >   , ((modm .|. shiftMask, xK_Up),   shiftToPrev >> prevWS) -- -- You can also get fancier with 'moveTo', 'shiftTo', and 'findWorkspace'. -- For example: ----- >   , ((modMask x     , xK_f), moveTo Next EmptyWS)  -- find a free workspace--- >   , ((modMask x .|. controlMask, xK_Right),        -- a crazy keybinding!--- >         do t <- findWorkspace getXineramaWsCompare Next NonEmptyWS 2+-- >   , ((modm     , xK_f), moveTo Next EmptyWS)  -- find a free workspace+-- >   , ((modm .|. controlMask, xK_Right),        -- a crazy keybinding!+-- >         do t <- findWorkspace getSortByXineramaRule Next NonEmptyWS 2 -- >            windows . view $ t                                         ) -- -- For detailed instructions on editing your key bindings, see@@ -135,10 +143,48 @@ shiftToPrev :: X () shiftToPrev = shiftBy (-1) +-- $toggling+ -- | Toggle to the workspace displayed previously. toggleWS :: X ()-toggleWS = windows $ view =<< tag . head . hidden+toggleWS = do+    hs <- gets (hidden . windowset)+    unless (null hs) (windows . view . tag $ head hs) +-- | 'XMonad.StackSet.greedyView' a workspace, or if already there, view+-- the previously displayed workspace ala weechat. Change @greedyView@ to+-- @toggleOrView@ in your workspace bindings as in the 'XMonad.StackSet.view'+-- faq at <http://haskell.org/haskellwiki/Xmonad/Frequently_asked_questions>.+-- For more flexibility see 'toggleOrDoSkip'.+toggleOrView :: WorkspaceId -> X ()+toggleOrView = toggleOrDoSkip [] greedyView++-- | Allows ignoring listed workspace tags (such as scratchpad's \"NSP\") while+-- finding the previously displayed workspace, or choice of different actions,+-- like view, shift, etc.  For example:+--+-- > import qualified XMonad.StackSet as W+-- > import XMonad.Actions.CycleWS+-- >+-- > -- toggleOrView for people who prefer view to greedyView+-- > toggleOrView' = toggleOrDoSkip [] W.view+-- >+-- > -- toggleOrView ignoring scratchpad and named scratchpad workspace+-- > toggleOrViewNoSP = toggleOrDoSkip ["NSP"] W.greedyView+toggleOrDoSkip :: [WorkspaceId] -> (WorkspaceId -> WindowSet -> WindowSet)+                                  -> WorkspaceId -> X ()+toggleOrDoSkip skips f toWS = do+    ws <- gets windowset+    let hs' = hidden ws `skipTags` skips+    if toWS == (tag . workspace $ current ws)+        then unless (null hs') (windows . f . tag $ head hs')+        else windows (f toWS)++-- | List difference ('\\') for workspaces and tags. Removes workspaces+-- matching listed tags from the given workspace list.+skipTags :: (Eq i) => [Workspace i l a] -> [i] -> [Workspace i l a]+skipTags wss ids = filter ((`notElem` ids) . tag) wss+ switchWorkspace :: Int -> X () switchWorkspace d = wsBy d >>= windows . greedyView @@ -166,12 +212,10 @@  -} --- | Direction to cycle through the sort order.-data WSDirection = Next | Prev- -- | What type of workspaces should be included in the cycle? 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             | AnyWS       -- ^ cycle through all workspaces             | WSIs (X (WindowSpace -> Bool))@@ -182,19 +226,22 @@ wsTypeToPred :: WSType -> X (WindowSpace -> Bool) wsTypeToPred EmptyWS    = return (isNothing . stack) wsTypeToPred NonEmptyWS = return (isJust . stack)-wsTypeToPred HiddenNonEmptyWS = do hs <- gets (map tag . hidden . windowset)-                                   return (\w -> isJust (stack w) && tag w `elem` hs)+wsTypeToPred HiddenWS   = do hs <- gets (map tag . hidden . windowset)+                             return (\w -> tag w `elem` hs)+wsTypeToPred HiddenNonEmptyWS  = do ne <- wsTypeToPred NonEmptyWS+                                    hi <- wsTypeToPred HiddenWS+                                    return (\w -> hi w && ne w) wsTypeToPred AnyWS      = return (const True) wsTypeToPred (WSIs p)   = p  -- | View the next workspace in the given direction that satisfies --   the given condition.-moveTo :: WSDirection -> WSType -> X ()+moveTo :: Direction1D -> WSType -> X () moveTo dir t = findWorkspace getSortByIndex dir t 1 >>= windows . greedyView  -- | Move the currently focused window to the next workspace in the --   given direction that satisfies the given condition.-shiftTo :: WSDirection -> WSType -> X ()+shiftTo :: Direction1D -> WSType -> X () shiftTo dir t = findWorkspace getSortByIndex dir t 1 >>= windows . shift  -- | Given a function @s@ to sort workspaces, a direction @dir@, a@@ -210,14 +257,14 @@ --   that 'moveTo' and 'shiftTo' are implemented by applying @(>>= --   (windows . greedyView))@ and @(>>= (windows . shift))@, respectively, --   to the output of 'findWorkspace'.-findWorkspace :: X WorkspaceSort -> WSDirection -> WSType -> Int -> X WorkspaceId+findWorkspace :: X WorkspaceSort -> Direction1D -> WSType -> Int -> X WorkspaceId findWorkspace s dir t n = findWorkspaceGen s (wsTypeToPred t) (maybeNegate dir n)   where     maybeNegate Next d = d     maybeNegate Prev d = (-d)  findWorkspaceGen :: X WorkspaceSort -> X (WindowSpace -> Bool) -> Int -> X WorkspaceId-findWorkspaceGen _ _ 0 = (tag . workspace . current) `fmap` gets windowset+findWorkspaceGen _ _ 0 = gets (currentTag . windowset) findWorkspaceGen sortX wsPredX d = do     wsPred <- wsPredX     sort   <- sortX@@ -225,7 +272,7 @@     let cur     = workspace (current ws)         sorted  = sort (workspaces ws)         pivoted = let (a,b) = span ((/= (tag cur)) . tag) sorted in b ++ a-        ws'     = filter wsPred $ pivoted+        ws'     = filter wsPred pivoted         mCurIx  = findWsIndex cur ws'         d'      = if d > 0 then d - 1 else d         next    = if null ws'

@@ -0,0 +1,233 @@+--------------------------------------------------------------------------------+-- |+-- Module       : XMonad.Actions.CycleWindows+-- Copyright    : (c) Wirt Wolff <wirtwolff@gmail.com>+-- License      : BSD3-style (see LICENSE)+--+-- Maintainer   : Wirt Wolff <wirtwolff@gmail.com>+-- Stability    : unstable+-- Portability  : unportable+--+-- Provides bindings to cycle windows up or down on the current workspace+-- stack while maintaining focus in place.+--+-- Bindings are available to:+--+-- * Cycle nearby or nth windows into the focused frame+--+-- * Cycle a window halfway around the stack+--+-- * Cycle windows through the focused position.+--+-- * Cycle unfocused windows.+--+-- These bindings are especially useful with layouts that hide some of+-- the windows in the stack, such as Full, "XMonad.Layout.TwoPane" or+-- when using "XMonad.Layout.LimitWindows" to only show three or four+-- panes. See also "XMonad.Actions.RotSlaves" for related actions.+-----------------------------------------------------------------------------+module XMonad.Actions.CycleWindows (+        -- * Usage+        -- $usage++        -- * Cycling nearby or nth window into current frame+        -- $cycle+        cycleRecentWindows,+        cycleStacks',+        -- * Cycling half the stack to get rid of a boring window+        -- $opposite+        rotOpposite', rotOpposite,+        -- * Cycling windows through the current frame+        -- $focused+        rotFocused', rotFocusedUp, rotFocusedDown, shiftToFocus',+        -- * Cycling windows through other frames+        -- $unfocused+        rotUnfocused', rotUnfocusedUp, rotUnfocusedDown,+        -- * Updating the mouse pointer+        -- $pointer++        -- * Generic list rotations+        -- $generic+        rotUp, rotDown+) where++import XMonad+import qualified XMonad.StackSet as W+import XMonad.Actions.RotSlaves++import Control.Arrow (second)++-- $usage+-- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@ file:+--+-- > import XMonad.Actions.CycleWindows+-- >    -- config+-- >    -- other key bindings with x here your config+-- >+-- >              -- make sure mod matches keysym+-- >  , ((mod4Mask,  xK_s), cycleRecentWindows [xK_Super_L] xK_s xK_w)+-- >  , ((modm, xK_z), rotOpposite)+-- >  , ((modm                , xK_i), rotUnfocusedUp)+-- >  , ((modm                , xK_u), rotUnfocusedDown)+-- >  , ((modm .|. controlMask, xK_i), rotFocusedUp)+-- >  , ((modm .|. controlMask, xK_u), rotFocusedDown)+--+-- Also, if you use focus follows mouse, you will want to read the section+-- on updating the mouse pointer below.  For detailed instructions on+-- editing your key bindings, see "XMonad.Doc.Extending#Editing_key_bindings".+{- $pointer+With FocusFollowsMouse == True, the focus is updated after binding+actions, possibly focusing a window you didn't intend to focus. Most+people using TwoPane probably already have a logHook causing the mouse+to follow focus. (See "XMonad.Actions.UpdatePointer", or "XMonad.Actions.Warp")++If you want this built into the key binding instead, use the appropriate+action from one of those modules to also have your bindings move the pointer+to the point of your choice on the current window:++> import XMonad.Actions.UpdatePointer -- or Actions.Warp++and either++> -- modify the window rotation bindings+> , ((modm .|. controlMask, xK_i   ), rotFocusedUp+>                                            >> updatePointer (Relative 1 1))+> , ((modm .|. controlMask, xK_u   ), rotFocusedDown+>                                            >> updatePointer (Relative 1 1))+>+>    -- or add to xmonad's logHook+>    , logHook = dynamicLogWithPP xmobarPP+>                    >> updatePointer Nearest -- or your preference++-}++-- $cycle+-- Cycle windows into focus from below or above the focused pane by pressing+-- a key while one or more modifier keys is held down. The window order isn't+-- changed until a modifier is released, leaving the previously focused window+-- just below the new one, (or above if the window just above is chosen.) For+-- best results use the same modifier + key combination as the one used to invoke+-- the \"bring from below\" action.  Also, once cycling, pressing a number key n+-- will focus the nth window, with 0 being the one originally focused.+cycleRecentWindows :: [KeySym] -- ^ A list of modifier keys used when invoking this action.+                               --   As soon as one of them is released, the final switch is made.+                    -> KeySym  -- ^ Key used to shift windows from below the current choice into the current frame.+                    -> KeySym  -- ^ Key used to shift windows from above the current choice into the current frame.+                               --   If it's the same as the first key, it is effectively ignored.+                    -> X ()+cycleRecentWindows = cycleStacks' stacks where+    stacks s = map (shiftToFocus' `flip` s) (wins s)+    wins (W.Stack t l r) = t : r ++ reverse l+++-- | Cycle through a /finite/ list of window stacks with repeated presses+--   of a key while a modifier key is held down. For best results use the same+--   mod key + key combination as the one used to invoke the \"bring from below\"+--   action. You could use cycleStacks' with a different stack permutations+--   function to, for example, cycle from one below to one above to two below,+--   etc. instead of in order. You are responsible for having it generate a+--   finite list, though, or xmonad may hang seeking its length.+cycleStacks' :: (W.Stack Window -> [W.Stack Window]) -- ^ A function to a finite list of permutations of a given stack.+                                    -> [KeySym]  -- ^ A list of modifier keys used to invoke 'cycleStacks''.+                                                 --   As soon as any is released, we're no longer cycling on the [Stack Window]+                                    -> KeySym    -- ^ Key used to select a \"next\" stack.+                                    -> KeySym    -- ^ Key used to select a \"previous\" stack.+                                    -> X ()+cycleStacks' filteredPerms mods keyNext keyPrev = do+    XConf {theRoot = root, display = d} <- ask+    stacks <- gets $ maybe [] filteredPerms . W.stack . W.workspace . W.current . windowset++    let evt = allocaXEvent $+                  \p -> do maskEvent d (keyPressMask .|. keyReleaseMask) p+                           KeyEvent {ev_event_type = t, ev_keycode = c} <- getEvent p+                           s <- keycodeToKeysym d c 0+                           return (t, s)+        choose n (t, s)+              | t == keyPress   && s == keyNext  = io evt >>= choose (n+1)+              | t == keyPress   && s == keyPrev  = io evt >>= choose (n-1)+              | t == keyPress   && s `elem` [xK_0..xK_9] = io evt >>= choose (numKeyToN s)+              | t == keyRelease && s `elem` mods = return ()+              | otherwise                        = doStack n >> io evt >>= choose n+        doStack n = windows . W.modify' . const $ stacks `cycref` n++    io $ grabKeyboard d root False grabModeAsync grabModeAsync currentTime+    io evt >>= choose 1+    io $ ungrabKeyboard d currentTime+  where cycref l i = l !! (i `mod` length l) -- modify' ensures l is never [], but must also be finite+        numKeyToN = subtract 48 . read . show++-- | Given a stack element and a stack, shift or insert the element (window)+--   at the currently focused position.+shiftToFocus' :: (Eq a, Show a, Read a) => a -> W.Stack a -> W.Stack a+shiftToFocus' w s@(W.Stack _ ls _) = W.Stack w (reverse revls') rs'+  where (revls', rs') = splitAt (length ls) . filter (/= w) $ W.integrate s+++-- $opposite+-- Shifts the focused window as far as possible from the current focus,+-- i.e. halfway around the stack. Windows above the focus up to the \"opposite\"+-- position remain in place, while those above the insertion shift toward+-- the current focus. This is useful for people who use lots of windows in Full,+-- TwoPane, etc., to get rid of boring windows while cycling and swapping+-- near the focus.+rotOpposite :: X()+rotOpposite = windows $ W.modify' rotOpposite'++-- | The opposite rotation on a Stack.+rotOpposite' :: W.Stack a -> W.Stack a+rotOpposite' (W.Stack t l r) = W.Stack t' l' r'+  where rrvl = r ++ reverse l+        part = (length rrvl + 1) `div` 2+        (l',t':r') =  second reverse . splitAt (length l) $+                                reverse (take part rrvl ++ t : drop part rrvl)+++-- $focused+-- Most people will want the @rotAllUp@ or @rotAllDown@ actions from+-- "XMonad.Actions.RotSlaves" to cycle all windows in the stack.+--+-- The following actions keep the \"next\" window stable, which is+-- mostly useful in two window layouts, or when you have a log viewer or+-- buffer window you want to keep next to the cycled window.++-- | Rotate windows through the focused frame, excluding the \"next\" window.+-- With, e.g. TwoPane, this allows cycling windows through either the+-- master or slave pane, without changing the other frame. When the master+-- is focused, the window below is skipped, when a non-master window is+-- focused, the master is skipped.+rotFocusedUp :: X ()+rotFocusedUp = windows . W.modify' $ rotFocused' rotUp+rotFocusedDown :: X ()+rotFocusedDown = windows . W.modify' $ rotFocused' rotDown++-- | The focused rotation on a stack.+rotFocused' :: ([a] -> [a]) -> W.Stack a -> W.Stack a+rotFocused' _ s@(W.Stack _ [] []) = s+rotFocused' f   (W.Stack t [] (r:rs)) = W.Stack t' [] (r:rs') -- Master has focus+    where (t':rs') = f (t:rs)+rotFocused' f s@(W.Stack _ _ _) = rotSlaves' f s              -- otherwise+++-- $unfocused+-- Rotate windows through the unfocused frames. This is similar to+-- @rotSlaves@, from "XMonad.Actions.RotSlaves", but excludes the current+-- frame rather than master.+rotUnfocusedUp :: X ()+rotUnfocusedUp = windows . W.modify' $ rotUnfocused' rotUp+rotUnfocusedDown :: X ()+rotUnfocusedDown = windows . W.modify' $ rotUnfocused' rotDown++-- | The unfocused rotation on a stack.+rotUnfocused' :: ([a] -> [a]) -> W.Stack a -> W.Stack a+rotUnfocused' _ s@(W.Stack _ [] []) = s+rotUnfocused' f s@(W.Stack _ [] _ ) = rotSlaves' f s                 -- Master has focus+rotUnfocused' f   (W.Stack t ls rs) = W.Stack t (reverse revls') rs' -- otherwise+    where  (master:revls)  = reverse ls+           (revls',rs') = splitAt (length ls) (f $ master:revls ++ rs)++-- $generic+-- Generic list rotations+rotUp :: [a] -> [a]+rotUp   l = tail l ++ [head l]+rotDown :: [a] -> [a]+rotDown l = last l : init l

@@ -5,12 +5,13 @@ -- License     :  BSD3-style (see LICENSE) -- -- Maintainer  :  Spencer Janssen <spencerjanssen@gmail.com>--- Stability   :  unstable+-- Stability   :  stable -- Portability :  unportable -- -- This module provides a method to cease management of a window -- without unmapping it.  This is especially useful for applications--- like kicker and gnome-panel.+-- like kicker and gnome-panel.  See also "XMonad.Hooks.ManageDocks" for+-- more a more automated solution. -- -- To make a panel display correctly with xmonad: --@@ -43,7 +44,7 @@ -- -- And add a keybinding, such as: ----- > , ((modMask x,               xK_d     ), withFocused demanage)+-- > , ((modm,               xK_d     ), withFocused demanage) -- -- For detailed instructions on editing your key bindings, see -- "XMonad.Doc.Extending#Editing_key_bindings".

@@ -5,7 +5,7 @@ -- License     :  BSD3-style (see LICENSE) -- -- Maintainer  :  arcatan@kapsi.fi--- Stability   :  unstable+-- Stability   :  stable -- Portability :  unportable -- -- Dwm-like swap function for xmonad.@@ -33,7 +33,7 @@ -- -- then add a keybinding or substitute 'dwmpromote' in place of promote: ----- >   , ((modMask x,               xK_Return), dwmpromote)+-- >   , ((modm,               xK_Return), dwmpromote) -- -- For detailed instructions on editing your key bindings, see -- "XMonad.Doc.Extending#Editing_key_bindings".

@@ -36,18 +36,18 @@ -- -- Then add keybindings like the following: ----- >   , ((modMask x .|. shiftMask, xK_BackSpace), removeWorkspace)--- >   , ((modMask x .|. shiftMask, xK_v      ), selectWorkspace defaultXPConfig)--- >   , ((modMask x, xK_m                    ), withWorkspace defaultXPConfig (windows . W.shift))--- >   , ((modMask x .|. shiftMask, xK_m      ), withWorkspace defaultXPConfig (windows . copy))--- >   , ((modMask x .|. shiftMask, xK_r      ), renameWorkspace defaultXPConfig)+-- >   , ((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) -- -- > -- mod-[1..9]       %! Switch to workspace N -- > -- mod-shift-[1..9] %! Move client to workspace N -- >    ++--- >    zip (zip (repeat (modMask x)) [xK_1..xK_9]) (map (withNthWorkspace W.greedyView) [0..])+-- >    zip (zip (repeat (modm)) [xK_1..xK_9]) (map (withNthWorkspace W.greedyView) [0..]) -- >    ++--- >    zip (zip (repeat (modMask x .|. shiftMask)) [xK_1..xK_9]) (map (withNthWorkspace W.shift) [0..])+-- >    zip (zip (repeat (modm .|. shiftMask)) [xK_1..xK_9]) (map (withNthWorkspace W.shift) [0..]) -- -- For detailed instructions on editing your key bindings, see -- "XMonad.Doc.Extending#Editing_key_bindings".

@@ -5,7 +5,7 @@ -- License     :  BSD3-style (see LICENSE) -- -- Maintainer  :  arcatan@kapsi.fi--- Stability   :  unstable+-- Stability   :  stable -- Portability :  unportable -- -- Find an empty workspace.@@ -32,8 +32,8 @@ -- -- and add the desired keybindings, for example: -----  >   , ((modMask x,                xK_m    ), viewEmptyWorkspace)---  >   , ((modMask x .|. shiftMask,  xK_m    ), tagToEmptyWorkspace)+--  >   , ((modm,                xK_m    ), viewEmptyWorkspace)+--  >   , ((modm .|. shiftMask,  xK_m    ), tagToEmptyWorkspace) -- -- Now you can jump to an empty workspace with @mod-m@. @Mod-shift-m@ -- will tag the current window to an empty workspace and view it.

@@ -7,7 +7,7 @@ -- License     :  BSD3-style (see LICENSE) -- -- Maintainer  :  <mgsloan@gmail.com>--- Stability   :  unstable+-- Stability   :  stable -- Portability :  unportable -- -- Move and resize floating windows without warping the mouse.@@ -31,7 +31,7 @@ -- -- Now set up the desired mouse binding, for example: ----- >     , ((modMask x, button1), (\w -> focus w >> Flex.mouseWindow Flex.linear w))+-- >     , ((modm, button1), (\w -> focus w >> Flex.mouseWindow Flex.linear w)) -- -- * Flex.'linear' indicates that positions between the edges and the --   middle indicate a combination scale\/position.

@@ -15,7 +15,8 @@ module XMonad.Actions.FlexibleResize (         -- * Usage         -- $usage-        XMonad.Actions.FlexibleResize.mouseResizeWindow+        XMonad.Actions.FlexibleResize.mouseResizeWindow,+        XMonad.Actions.FlexibleResize.mouseResizeEdgeWindow ) where  import XMonad@@ -28,40 +29,53 @@ -- -- Then add an appropriate mouse binding: ----- >     , ((modMask x, button3), (\w -> focus w >> Flex.mouseResizeWindow w))+-- >     , ((modm, button3), (\w -> focus w >> Flex.mouseResizeWindow w)) -- -- For detailed instructions on editing your mouse bindings, see -- "XMonad.Doc.Extending#Editing_mouse_bindings".  -- | Resize a floating window from whichever corner the mouse is --   closest to.-mouseResizeWindow :: Window -> X ()-mouseResizeWindow w = whenX (isClient w) $ withDisplay $ \d -> do+mouseResizeWindow+  :: Window -- ^ The window to resize.+  -> X ()+mouseResizeWindow = mouseResizeEdgeWindow 0+++-- | Resize a floating window from whichever corner or edge the mouse is+--   closest to.+mouseResizeEdgeWindow+  :: Rational -- ^ The size of the area where only one edge is resized.+  -> Window   -- ^ The window to resize.+  -> X ()+mouseResizeEdgeWindow edge w = whenX (isClient w) $ withDisplay $ \d -> do     io $ raiseWindow d w     wa <- io $ getWindowAttributes d w     sh <- io $ getWMNormalHints d w     (_, _, _, _, _, ix, iy, _) <- io $ queryPointer d w     let-        [pos_x, pos_y, width, height] = map (fromIntegral . ($ wa)) [wa_x, wa_y, wa_width, wa_height]-        west  = firstHalf ix width-        north = firstHalf iy height+        [pos_x, pos_y, width, height] = map (fi . ($ wa)) [wa_x, wa_y, wa_width, wa_height]+        west  = findPos ix width+        north = findPos iy height         (cx, fx, gx) = mkSel west  width  pos_x         (cy, fy, gy) = mkSel north height pos_y     io $ warpPointer d none w 0 0 0 0 cx cy-    mouseDrag (\ex ey -> do-                 wa' <- io $ getWindowAttributes d w-                 let [px, py] = map (fromIntegral . ($ wa')) [wa_x, wa_y]-                 io $ moveResizeWindow d w (fx px (fromIntegral ex))-                                           (fy py (fromIntegral ey))-                            `uncurry` applySizeHintsContents sh (gx $ fromIntegral ex, gy $ fromIntegral ey))+    mouseDrag (\ex ey -> do let (nw,nh) = applySizeHintsContents sh (gx ex, gy ey)+                            io $ moveResizeWindow d w (fx nw) (fy nh) nw nh)               (float w)     where-    firstHalf :: CInt -> Position -> Bool-    firstHalf a b = fromIntegral a * 2 <= b-    cfst = curry fst-    csnd = curry snd-    mkSel :: Bool -> Position -> Position -> (Position, a -> a -> a, CInt -> Position)-    mkSel b k p =-        if b-            then (0, csnd, ((k + p) -) . fromIntegral)-            else (k, cfst, subtract p  . fromIntegral)+    findPos :: CInt -> Position -> Maybe Bool+    findPos m s = if p < 0.5 - edge/2+                  then Just True+                  else if p < 0.5 + edge/2+                       then Nothing+                       else Just False+                  where p = fi m / fi s+    mkSel :: Maybe Bool -> Position -> Position -> (Position, Dimension -> Position, Position -> Dimension)+    mkSel b k p = case b of+                      Just True ->  (0, (fi k + fi p -).fi, (fi k + fi p -).fi)+                      Nothing ->    (k `div` 2, const p, const $ fi k)+                      Just False -> (k, const p, subtract (fi p) . fi)++fi :: (Num b, Integral a) => a -> b+fi = fromIntegral

@@ -5,7 +5,7 @@ -- License      : BSD -- -- Maintainer   : Karsten Schoelzel <kuser@gmx.de>--- Stability    : unstable+-- Stability    : stable -- Portability  : unportable -- -- Move and resize floating windows.@@ -28,11 +28,11 @@ -- -- Then add appropriate key bindings, for example: ----- >  , ((modMask x,               xK_d     ), withFocused (keysResizeWindow (-10,-10) (1,1)))--- >  , ((modMask x,               xK_s     ), withFocused (keysResizeWindow (10,10) (1,1)))--- >  , ((modMask x .|. shiftMask, xK_d     ), withFocused (keysAbsResizeWindow (-10,-10) (1024,752)))--- >  , ((modMask x .|. shiftMask, xK_s     ), withFocused (keysAbsResizeWindow (10,10) (1024,752)))--- >  , ((modMask x,               xK_a     ), withFocused (keysMoveWindowTo (512,384) (1%2,1%2)))+-- >  , ((modm,               xK_d     ), withFocused (keysResizeWindow (-10,-10) (1,1)))+-- >  , ((modm,               xK_s     ), withFocused (keysResizeWindow (10,10) (1,1)))+-- >  , ((modm .|. shiftMask, xK_d     ), withFocused (keysAbsResizeWindow (-10,-10) (1024,752)))+-- >  , ((modm .|. shiftMask, xK_s     ), withFocused (keysAbsResizeWindow (10,10) (1024,752)))+-- >  , ((modm,               xK_a     ), withFocused (keysMoveWindowTo (512,384) (1%2,1%2))) -- -- For detailed instructions on editing your key bindings, see -- "XMonad.Doc.Extending#Editing_key_bindings".

@@ -0,0 +1,328 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  XMonad.Layout.FloatSnap+-- Copyright   :  (c) 2009 Anders Engstrom <ankaan@gmail.com>+-- License     :  BSD3-style (see LICENSE)+--+-- Maintainer  :  Anders Engstrom <ankaan@gmail.com>+-- Stability   :  unstable+-- Portability :  unportable+--+-- Move and resize floating windows using other windows and the edge of the+-- screen as guidelines.+-----------------------------------------------------------------------------++module XMonad.Actions.FloatSnap (+                -- * Usage+                -- $usage+                Direction2D(..),+                snapMove,+                snapGrow,+                snapShrink,+                snapMagicMove,+                snapMagicResize,+                snapMagicMouseResize) where++import XMonad+import Control.Applicative((<$>))+import Data.List (sort)+import Data.Maybe (listToMaybe,fromJust,isNothing)+import qualified XMonad.StackSet as W++import XMonad.Hooks.ManageDocks (calcGap)+import XMonad.Util.Types (Direction2D(..))++import qualified Data.Set as S++-- $usage+-- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:+--+-- >    import XMonad.Actions.FloatSnap+--+-- Then add appropriate key bindings, for example:+--+-- >        , ((modm,               xK_Left),  withFocused $ snapMove L Nothing)+-- >        , ((modm,               xK_Right), withFocused $ snapMove R Nothing)+-- >        , ((modm,               xK_Up),    withFocused $ snapMove U Nothing)+-- >        , ((modm,               xK_Down),  withFocused $ snapMove D Nothing)+-- >        , ((modm .|. shiftMask, xK_Left),  withFocused $ snapShrink R Nothing)+-- >        , ((modm .|. shiftMask, xK_Right), withFocused $ snapGrow R Nothing)+-- >        , ((modm .|. shiftMask, xK_Up),    withFocused $ snapShrink D Nothing)+-- >        , ((modm .|. shiftMask, xK_Down),  withFocused $ snapGrow D Nothing)+--+-- For detailed instructions on editing your key bindings, see+-- "XMonad.Doc.Extending#Editing_key_bindings".+--+-- And possibly add an appropriate mouse binding, 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))+--+-- 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.+--+-- 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).+--+-- For 'snapMagicMove', 'snapMagicResize' and 'snapMagicMouseResize', try instead setting it to the same as the maximum snapping distance.+--+-- When a value is specified it can be geometrically conceived as adding a border with the specified width around the window and then checking which+-- windows it should collide with.++-- | Resize the window by each edge independently to snap against the closest part of other windows or the edge of the screen. Use the location of the+--   mouse over the window to decide which edges to snap. In corners, the two adjoining edges will be snapped, along the middle of an edge only that edge+--   will be snapped. In the center of the window all edges will snap. Intended to be used together with "XMonad.Actions.FlexibleResize" or+--   "XMonad.Actions.FlexibleManipulate".+snapMagicMouseResize+    :: Rational  -- ^ How big the middle snap area of each axis should be.+    -> Maybe Int -- ^ The distance in the orthogonal axis to look for windows to snap against. Use Nothing to snap against every window.+    -> Maybe Int -- ^ The maximum distance to snap. Use Nothing to not impose any boundary.+    -> Window    -- ^ The window to move and resize.+    -> X ()+snapMagicMouseResize middle collidedist snapdist w = whenX (isClient w) $ withDisplay $ \d -> do+    wa <- io $ getWindowAttributes d w+    (_, _, _, px, py, _, _, _) <- io $ queryPointer d w+    let x = (fromIntegral px - wx wa)/(ww wa)+        y = (fromIntegral py - wy wa)/(wh wa)+        ml = if x <= (0.5 - middle/2) then [L] else []+        mr = if x >  (0.5 + middle/2) then [R] else []+        mu = if y <= (0.5 - middle/2) then [U] else []+        md = if y >  (0.5 + middle/2) then [D] else []+        mdir = ml++mr++mu++md+        dir = if mdir == []+              then [L,R,U,D]+              else mdir+    snapMagicResize dir collidedist snapdist w+    where+        wx = fromIntegral.wa_x+        wy = fromIntegral.wa_y+        ww = fromIntegral.wa_width+        wh = fromIntegral.wa_height++-- | Resize the window by each edge independently to snap against the closest part of other windows or the edge of the screen.+snapMagicResize+    :: [Direction2D] -- ^ The edges to snap.+    -> Maybe Int   -- ^ The distance in the orthogonal axis to look for windows to snap against. Use Nothing to snap against every window.+    -> Maybe Int   -- ^ The maximum distance to snap. Use Nothing to not impose any boundary.+    -> Window      -- ^ The window to move and resize.+    -> X ()+snapMagicResize dir collidedist snapdist w = whenX (isClient w) $ withDisplay $ \d -> do+    io $ raiseWindow d w+    wa <- io $ getWindowAttributes d w++    (xbegin,xend) <- handleAxis True d wa+    (ybegin,yend) <- handleAxis False d wa++    let xbegin' = if L `elem` dir then xbegin else (wx wa)+        xend'   = if R `elem` dir then xend   else (wx wa + ww wa)+        ybegin' = if U `elem` dir then ybegin else (wy wa)+        yend'   = if D `elem` dir then yend   else (wy wa + wh wa)++    io $ moveWindow d w (fromIntegral $ xbegin') (fromIntegral $ ybegin')+    io $ resizeWindow d w (fromIntegral $ xend' - xbegin') (fromIntegral $ yend' - ybegin')+    float w+    where+        wx = fromIntegral.wa_x+        wy = fromIntegral.wa_y+        ww = fromIntegral.wa_width+        wh = fromIntegral.wa_height++        handleAxis horiz d wa = do+            ((mbl,mbr,bs),(mfl,mfr,fs)) <- getSnap horiz collidedist d w+            let begin = if bs+                        then wpos wa+                        else case (mbl,mbr) of+                            (Just bl,Just br) -> if wpos wa - bl < br - wpos wa then bl else br+                            (Just bl,Nothing) -> bl+                            (Nothing,Just br) -> br+                            (Nothing,Nothing) -> wpos wa+                end = if fs+                      then wpos wa + wdim wa+                      else case (if mfl==(Just begin) then Nothing else mfl,mfr) of+                          (Just fl,Just fr) -> if wpos wa + wdim wa - fl < fr - wpos wa - wdim wa then fl else fr+                          (Just fl,Nothing) -> fl+                          (Nothing,Just fr) -> fr+                          (Nothing,Nothing) -> wpos wa + wdim wa+                begin' = if isNothing snapdist || abs (begin - wpos wa) <= fromJust snapdist then begin else (wpos wa)+                end' = if isNothing snapdist || abs (end - wpos wa - wdim wa) <= fromJust snapdist then end else (wpos wa + wdim wa)+            return (begin',end')+            where+                (wpos, wdim, _, _) = constructors horiz+++-- | Move a window by both axises in any direction to snap against the closest part of other windows or the edge of the screen.+snapMagicMove+    :: Maybe Int -- ^ The distance in the orthogonal axis to look for windows to snap against. Use Nothing to snap against every window.+    -> Maybe Int -- ^ The maximum distance to snap. Use Nothing to not impose any boundary.+    -> Window    -- ^ The window to move.+    -> X ()+snapMagicMove collidedist snapdist w = whenX (isClient w) $ withDisplay $ \d -> do+    io $ raiseWindow d w+    wa <- io $ getWindowAttributes d w++    nx <- handleAxis True d wa+    ny <- handleAxis False d wa++    io $ moveWindow d w (fromIntegral nx) (fromIntegral ny)+    float w+    where+        handleAxis horiz d wa = do+            ((mbl,mbr,bs),(mfl,mfr,fs)) <- getSnap horiz collidedist d w+            return $ if bs || fs+                     then wpos wa+                     else let b = case (mbl,mbr) of+                                    (Just bl,Just br) -> if wpos wa - bl < br - wpos wa then bl else br+                                    (Just bl,Nothing) -> bl+                                    (Nothing,Just br) -> br+                                    (Nothing,Nothing) -> wpos wa+                              f = case (mfl,mfr) of+                                    (Just fl,Just fr) -> if wpos wa + wdim wa - fl < fr - wpos wa - wdim wa then fl else fr+                                    (Just fl,Nothing) -> fl+                                    (Nothing,Just fr) -> fr+                                    (Nothing,Nothing) -> wpos wa+                              newpos = if abs (b - wpos wa) <= abs (f - wpos wa - wdim wa) then b else (f - wdim wa)+                          in if isNothing snapdist || abs (newpos - wpos wa) <= fromJust snapdist then newpos else (wpos wa)+            where+                (wpos, wdim, _, _) = constructors horiz++-- | Move a window in the specified direction until it snaps against another window or the edge of the screen.+snapMove+    :: Direction2D -- ^ What direction to move the window in.+    -> Maybe Int -- ^ The distance in the orthogonal axis to look for windows to snap against. Use Nothing to snap against every window.+    -> Window    -- ^ The window to move.+    -> X ()+snapMove L = doSnapMove True True+snapMove R = doSnapMove True False+snapMove U = doSnapMove False True+snapMove D = doSnapMove False False++doSnapMove :: Bool -> Bool -> Maybe Int -> Window -> X ()+doSnapMove horiz rev collidedist w = whenX (isClient w) $ withDisplay $ \d -> do+    io $ raiseWindow d w+    wa <- io $ getWindowAttributes d w+    ((bl,br,_),(fl,fr,_)) <- getSnap horiz collidedist d w++    let (mb,mf) = if rev then (bl,fl)+                         else (br,fr)++        newpos = fromIntegral $ case (mb,mf) of+                                    (Just b,Nothing) -> b+                                    (Nothing,Just f) -> f - wdim wa+                                    (Just b,Just f) -> if rev /= (b < f - wdim wa)+                                                       then b+                                                       else f - wdim wa+                                    _ -> wpos wa++    if horiz then io $ moveWindow d w newpos (fromIntegral $ wa_y wa)+             else io $ moveWindow d w (fromIntegral $ wa_x wa) newpos+    float w++    where+        (wpos, wdim, _, _) = constructors horiz++-- | Grow the specified edge of a window until it snaps against another window or the edge of the screen.+snapGrow+    :: Direction2D -- ^ What edge of the window to grow.+    -> Maybe Int -- ^ The distance in the orthogonal axis to look for windows to snap against. Use Nothing to snap against every window.+    -> Window    -- ^ The window to grow.+    -> X ()+snapGrow = snapResize True++-- | Shrink the specified edge of a window until it snaps against another window or the edge of the screen.+snapShrink+    :: Direction2D -- ^ What edge of the window to shrink.+    -> Maybe Int -- ^ The distance in the orthogonal axis to look for windows to snap against. Use Nothing to snap against every window.+    -> Window    -- ^ The window to shrink.+    -> X ()+snapShrink = snapResize False++snapResize :: Bool -> Direction2D -> Maybe Int -> Window -> X ()+snapResize grow dir collidedist w = whenX (isClient w) $ withDisplay $ \d -> do+    io $ raiseWindow d w+    wa <- io $ getWindowAttributes d w+    mr <- case dir of+              L -> do ((mg,ms,_),(_,_,_)) <- getSnap True collidedist d w+                      return $ case (if grow then mg else ms) of+                                   Just v -> Just (v, wy wa, ww wa + wx wa - v, wh wa)+                                   _ -> Nothing+              R -> do ((_,_,_),(ms,mg,_)) <- getSnap True collidedist d w+                      return $ case (if grow then mg else ms) of+                                   Just v -> Just (wx wa, wy wa, v - wx wa, wh wa)+                                   _ -> Nothing+              U -> do ((mg,ms,_),(_,_,_)) <- getSnap False collidedist d w+                      return $ case (if grow then mg else ms) of+                                   Just v -> Just (wx wa, v, ww wa, wh wa + wy wa - v)+                                   _ -> Nothing+              D -> do ((_,_,_),(ms,mg,_)) <- getSnap False collidedist d w+                      return $ case (if grow then mg else ms) of+                                   Just v -> Just (wx wa, wy wa, ww wa, v - wy wa)+                                   _ -> Nothing++    case mr of+        Nothing -> return ()+        Just (nx,ny,nw,nh) -> if nw>0 && nh>0 then do io $ moveWindow d w (fromIntegral nx) (fromIntegral ny)+                                                      io $ resizeWindow d w (fromIntegral nw) (fromIntegral nh)+                                              else return ()+    float w+    where+        wx = fromIntegral.wa_x+        wy = fromIntegral.wa_y+        ww = fromIntegral.wa_width+        wh = fromIntegral.wa_height+++getSnap :: Bool -> Maybe Int -> Display -> Window -> X ((Maybe Int,Maybe Int,Bool),(Maybe Int,Maybe Int,Bool))+getSnap horiz collidedist d w = do+    wa <- io $ getWindowAttributes d w+    screen <- W.current <$> gets windowset+    let sr = screenRect $ W.screenDetail screen+        wl = W.integrate' . W.stack $ W.workspace screen+    gr <- fmap ($sr) $ calcGap $ S.fromList [minBound .. maxBound]+    wla <- filter (collides wa) `fmap` (io $ mapM (getWindowAttributes d) $ filter (/=w) wl)++    return ( neighbours (back wa sr gr wla) (wpos wa)+           , neighbours (front wa sr gr wla) (wpos wa + wdim wa)+           )++    where+        wborder = fromIntegral.wa_border_width++        (wpos, wdim, rpos, rdim) = constructors horiz+        (refwpos, refwdim, _, _) = constructors $ not horiz++        back wa sr gr wla = dropWhile (< rpos sr) $+                            takeWhile (< rpos sr + rdim sr) $+                            sort $ (rpos sr):(rpos gr):(rpos gr + rdim gr):+                                   foldr (\a as -> (wpos a):(wpos a + wdim a + wborder a + wborder wa):as) [] wla++        front wa sr gr wla = dropWhile (<= rpos sr) $+                             takeWhile (<= rpos sr + rdim sr) $+                             sort $ (rpos gr - 2*wborder wa):(rpos gr + rdim gr - 2*wborder wa):(rpos sr + rdim sr - 2*wborder wa):+                                    foldr (\a as -> (wpos a - wborder a - wborder wa):(wpos a + wdim a):as) [] wla++        neighbours l v = ( listToMaybe $ reverse $ takeWhile (< v) l+                         , listToMaybe $ dropWhile (<= v) l+                         , v `elem` l+                         )++        collides wa oa = case collidedist of+                             Nothing -> True+                             Just dist -> (  refwpos oa - wborder oa < refwpos wa + refwdim wa + wborder wa + dist+                                          && refwpos wa - wborder wa - dist < refwpos oa + refwdim oa + wborder oa )+++constructors :: Bool -> (WindowAttributes -> Int, WindowAttributes -> Int, Rectangle -> Int, Rectangle -> Int)+constructors True = ( fromIntegral.wa_x+                    , fromIntegral.wa_width+                    , fromIntegral.rect_x+                    , fromIntegral.rect_width+                    )+constructors False = ( fromIntegral.wa_y+                     , fromIntegral.wa_height+                     , fromIntegral.rect_y+                     , fromIntegral.rect_height+                     )

@@ -5,7 +5,7 @@ -- License      : BSD -- -- Maintainer   : Karsten Schoelzel <kuser@gmx.de>--- Stability    : unstable+-- Stability    : stable -- Portability  : unportable -- -- Focus the nth window of the current workspace.@@ -14,7 +14,7 @@ module XMonad.Actions.FocusNth (                  -- * Usage                  -- $usage-                 focusNth) where+                 focusNth,focusNth') where  import XMonad.StackSet import XMonad@@ -27,7 +27,7 @@ -- Then add appropriate keybindings, for example: -- -- > -- mod4-[1..9] @@ Switch to window N--- > ++ [((modMask x, k), focusNth i)+-- > ++ [((modm, k), focusNth i) -- >     | (i, k) <- zip [0 .. 8] [xK_1 ..]] -- -- For detailed instructions on editing your key bindings, see

@@ -0,0 +1,525 @@+{-# LANGUAGE ScopedTypeVariables, GeneralizedNewtypeDeriving, TypeSynonymInstances, FlexibleInstances, OverlappingInstances #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  XMonad.Actions.GridSelect+-- Copyright   :  Clemens Fruhwirth <clemens@endorphin.org>+-- License     :  BSD-style (see LICENSE)+--+-- Maintainer  :  Clemens Fruhwirth <clemens@endorphin.org>+-- Stability   :  unstable+-- Portability :  unportable+--+-- 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.+--+-----------------------------------------------------------------------------++module XMonad.Actions.GridSelect (+    -- * Usage+    -- $usage++    -- ** Customizing+    -- *** Using a common GSConfig+    -- $commonGSConfig++    -- *** Custom keybindings+    -- $keybindings++    -- * Configuration+    GSConfig(..),+    defaultGSConfig,+    NavigateMap,+    TwoDPosition,+    buildDefaultGSConfig,++    -- * Variations on 'gridselect'+    gridselect,+    gridselectWindow,+    withSelectedWindow,+    bringSelected,+    goToSelected,+    spawnSelected,+    runSelectedAction,++    -- * Colorizers+    HasColorizer(defaultColorizer),+    fromClassName,+    stringColorizer,+    colorRangeFromClassName++    -- * Screenshots+    -- $screenshots+    ) where+import Data.Maybe+import Data.Bits+import Control.Applicative+import Control.Monad.State+import Control.Arrow+import Data.List as L+import qualified Data.Map as M+import XMonad hiding (liftX)+import XMonad.Util.Font+import XMonad.Prompt (mkUnmanagedWindow)+import XMonad.StackSet as W+import XMonad.Layout.Decoration+import XMonad.Util.NamedWindows+import XMonad.Actions.WindowBringer (bringWindow)+import Text.Printf+import System.Random (mkStdGen, genRange, next)+import Data.Word (Word8)++-- $usage+--+-- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:+--+-- >    import XMonad.Actions.GridSelect+--+-- Then add a keybinding, e.g.+--+-- >    , ((modm, xK_g), goToSelected defaultGSConfig)+--+-- This module also supports displaying arbitrary information in a grid and letting+-- the user select from it. E.g. to spawn an application from a given list, you+-- can use the following:+--+-- >   , ((modm, xK_s), spawnSelected defaultGSConfig ["xterm","gmplayer","gvim"])++-- $commonGSConfig+--+-- It is possible to bind a @gsconfig@ at top-level in your configuration. Like so:+--+-- > -- the top of your config+-- > {-# LANGUAGE NoMonomorphismRestriction #-}+-- > import XMonad+-- > ...+-- > gsconfig1 = defaultGSConfig { gs_cellheight = 30, gs_cellWidth = 100 }+--+-- An example where 'buildDefaultGSConfig' is used instead of 'defaultGSConfig'+-- in order to specify a custom colorizer is @gsconfig2@ (found in+-- "XMonad.Actions.GridSelect#Colorizers"):+--+-- > gsconfig2 colorizer = (buildDefaultGSConfig colorizer) { gs_cellheight = 30, gs_cellWidth = 100 }+--+-- > -- | A green monochrome colorizer based on window class+-- > greenColorizer = colorRangeFromClassName+-- >                      black            -- lowest inactive bg+-- >                      (0x70,0xFF,0x70) -- highest inactive bg+-- >                      black            -- active bg+-- >                      white            -- inactive fg+-- >                      white            -- active fg+-- >   where black = minBound+-- >         white = maxBound+--+-- Then you can bind to:+--+-- >     ,((modm, xK_g), goToSelected  $ gsconfig2 myWinColorizer)+-- >     ,((modm, xK_p), spawnSelected $ spawnSelected defaultColorizer)++-- $keybindings+--+-- Adding more keybindings for gridselect to listen to is similar:+--+-- At the top of your config:+--+-- > {-# LANGAUGE NoMonomorphismRestriction #-}+-- > import XMonad+-- > import qualified Data.Map as M+--+-- Then define @gsconfig3@ which may be used in exactly the same manner as @gsconfig1@:+--+-- > gsconfig3 = defaultGSConfig+-- >    { gs_cellheight = 30+-- >    , gs_cellwidth = 100+-- >    , gs_navigate = M.unions+-- >            [reset+-- >            ,nethackKeys+-- >            ,gs_navigate                               -- get the default navigation bindings+-- >                $ defaultGSConfig `asTypeOf` gsconfig3 -- needed to fix an ambiguous type variable+-- >            ]+-- >    }+-- >   where addPair (a,b) (x,y) = (a+x,b+y)+-- >         nethackKeys = M.map addPair $ M.fromList+-- >                               [((0,xK_y),(-1,-1))+-- >                               ,((0,xK_i),(1,-1))+-- >                               ,((0,xK_n),(-1,1))+-- >                               ,((0,xK_m),(1,1))+-- >                               ]+-- >         -- jump back to the center with the spacebar, regardless of the current position.+-- >         reset = M.singleton (0,xK_space) (const (0,0))++-- $screenshots+--+-- Selecting a workspace:+--+-- <<http://haskell.org/sitewiki/images/a/a9/Xmonad-gridselect-workspace.png>>+--+-- Selecting a window by title:+--+-- <<http://haskell.org/sitewiki/images/3/35/Xmonad-gridselect-window-aavogt.png>>++data GSConfig a = GSConfig {+      gs_cellheight :: Integer,+      gs_cellwidth :: Integer,+      gs_cellpadding :: Integer,+      gs_colorizer :: a -> Bool -> X (String, String),+      gs_font :: String,+      gs_navigate :: NavigateMap,+      gs_originFractX :: Double,+      gs_originFractY :: Double+}++-- | That is 'fromClassName' if you are selecting a 'Window', or+-- 'defaultColorizer' if you are selecting a 'String'. The catch-all instance+-- @HasColorizer a@ uses the 'focusedBorderColor' and 'normalBorderColor'+-- colors.+class HasColorizer a where+    defaultColorizer :: a -> Bool -> X (String, String)++instance HasColorizer Window where+    defaultColorizer = fromClassName++instance HasColorizer String where+    defaultColorizer = stringColorizer++instance HasColorizer a where+    defaultColorizer _ isFg =+        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.+defaultGSConfig :: HasColorizer a => GSConfig a+defaultGSConfig = buildDefaultGSConfig defaultColorizer++type NavigateMap = M.Map (KeyMask,KeySym) (TwoDPosition -> TwoDPosition)++type TwoDPosition = (Integer, Integer)++type TwoDElementMap a = [(TwoDPosition,(String,a))]++data TwoDState a = TwoDState { td_curpos :: TwoDPosition+                             , td_elementmap :: TwoDElementMap a+                             , td_gsconfig :: GSConfig a+                             , td_font :: XMonadFont+                             , td_paneX :: Integer+                             , td_paneY :: Integer+                             , td_drawingWin :: Window+                             }++newtype TwoD a b = TwoD { unTwoD :: StateT (TwoDState a) X b }+    deriving (Monad,Functor,MonadState (TwoDState a))++instance Applicative (TwoD a) where+    (<*>) = ap+    pure = return++liftX ::  X a1 -> TwoD a a1+liftX = TwoD . lift++evalTwoD ::  TwoD a1 a -> TwoDState a1 -> X a+evalTwoD m s = flip evalStateT s $ unTwoD m++diamondLayer :: (Enum b', Num b') => b' -> [(b', b')]+-- FIXME remove nub+diamondLayer n = let ul = [ (x,n-x) | x <- [0..n] ]+        in nub $ ul ++ (map (negate *** id) ul) +++           (map (negate *** negate) ul) +++           (map (id *** negate) ul)++diamond :: (Enum a, Num a) => [(a, a)]+diamond = concatMap diamondLayer [0..]++diamondRestrict :: Integer -> Integer -> Integer -> Integer -> [(Integer, Integer)]+diamondRestrict x y originX originY =+  L.filter (\(x',y') -> abs x' <= x && abs y' <= y) .+  map (\(x', y') -> (x' + fromInteger originX, y' + fromInteger originY)) .+  take 1000 $ diamond++tupadd :: (Num t1, Num t) => (t, t1) -> (t, t1) -> (t, t1)+tupadd (a,b) (c,d) = (a+c,b+d)++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 =+  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+    setForeground dpy gc fgcolor+    setBackground dpy gc bgcolor+    setForeground dpy bordergc bordercolor+    fillRectangle dpy win gc (fromInteger x) (fromInteger y) (fromInteger cw) (fromInteger ch)+    drawRectangle dpy win bordergc (fromInteger x) (fromInteger y) (fromInteger cw) (fromInteger ch)+  stext <- shrinkWhile (shrinkIt shrinkText)+           (\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+  liftIO $ freeGC dpy gc+  liftIO $ freeGC dpy bordergc++updateAllElements :: TwoD a ()+updateAllElements =+    do+      TwoDState { td_elementmap = els } <- get+      updateElements els++updateElements :: TwoDElementMap a -> TwoD a ()+updateElements elementmap = do+    TwoDState { td_curpos = curpos,+                td_drawingWin = win,+                td_gsconfig = gsconfig,+                td_font = font,+                td_paneX = paneX,+                td_paneY = paneY} <- get+    let cellwidth = gs_cellwidth gsconfig+        cellheight = gs_cellheight gsconfig+        paneX' = div (paneX-cellwidth) 2+        paneY' = div (paneY-cellheight) 2+        updateElement (pos@(x,y),(text, element)) = liftX $ do+            colors <- gs_colorizer gsconfig element (pos == curpos)+            drawWinBox win font+                       colors+                       cellheight+                       cellwidth+                       text+                       (paneX'+x*cellwidth)+                       (paneY'+y*cellheight)+                       (gs_cellpadding gsconfig)+    mapM_ updateElement elementmap++eventLoop :: TwoD a (Maybe a)+eventLoop = do+  (keysym,string,event) <- liftX $ withDisplay $ \d -> liftIO $ allocaXEvent $ \e -> do+                             maskEvent d (exposureMask .|. keyPressMask .|. buttonReleaseMask) e+                             ev <- getEvent e+                             (ks,s) <- if ev_event_type ev == keyPress+                                       then lookupString $ asKeyEvent e+                                       else return (Nothing, "")+                             return (ks,s,ev)+  handle (fromMaybe xK_VoidSymbol keysym,string) event++handle ::  (KeySym, t) -> Event -> TwoD a (Maybe a)+handle (ks,_) (KeyEvent {ev_event_type = t, ev_state = m })+    | t == keyPress && ks == xK_Escape = return Nothing+    | t == keyPress && ks == xK_Return = do+       (TwoDState { td_curpos = pos, td_elementmap = elmap }) <- get+       return $ fmap (snd . snd) $ findInElementMap pos elmap+    | t == keyPress = do+        m' <- liftX (cleanMask m)+        keymap <- gets (gs_navigate . td_gsconfig)+        maybe eventLoop diffAndRefresh . M.lookup (m',ks) $ keymap+  where diffAndRefresh diff = do+          state <- get+          let elmap = td_elementmap state+              oldPos = td_curpos state+              newPos = diff oldPos+              newSelectedEl = findInElementMap newPos elmap+          when (isJust newSelectedEl) $ do+                                put state { td_curpos =  newPos }+                                updateElements (catMaybes [(findInElementMap oldPos elmap), newSelectedEl])+          eventLoop++handle _ (ButtonEvent { ev_event_type = t, ev_x = x, ev_y = y })+    | t == buttonRelease = do+        (TwoDState { td_elementmap = elmap, td_paneX = px, td_paneY = py,+                     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) elmap of+             Just (_,el) -> return (Just el)+             Nothing -> eventLoop+    | otherwise = eventLoop++handle _ (ExposeEvent { }) = updateAllElements >> eventLoop++handle _ _ = eventLoop++-- FIXME probably move that into Utils?+-- Conversion scheme as in http://en.wikipedia.org/wiki/HSV_color_space+hsv2rgb :: Fractional a => (Integer,a,a) -> (a,a,a)+hsv2rgb (h,s,v) =+    let hi = (div h 60) `mod` 6 :: Integer+        f = (((fromInteger h)/60) - (fromInteger hi)) :: Fractional a => a+        q = v * (1-f)+        p = v * (1-s)+        t = v * (1-(1-f)*s)+    in case hi of+         0 -> (v,t,p)+         1 -> (q,v,p)+         2 -> (p,v,t)+         3 -> (p,q,v)+         4 -> (t,p,v)+         5 -> (v,p,q)+         _ -> error "The world is ending. x mod a >= a."++-- | Default colorizer for Strings+stringColorizer :: String -> Bool -> X (String, String)+stringColorizer s active =+    let seed x = toInteger (sum $ map ((*x).fromEnum) s) :: Integer+        (r,g,b) = hsv2rgb ((seed 83) `mod` 360,+                           (fromInteger ((seed 191) `mod` 1000))/2500+0.4,+                           (fromInteger ((seed 121) `mod` 1000))/2500+0.4)+    in if active+         then return ("#faff69", "black")+         else return ("#" ++ concat (map (twodigitHex.(round :: Double -> Word8).(*256)) [r, g, b] ), "white")++-- | Colorize a window depending on it's className.+fromClassName :: Window -> Bool -> X (String, String)+fromClassName w active = runQuery className w >>= flip defaultColorizer active++twodigitHex :: Word8 -> String+twodigitHex a = printf "%02x" a++-- | A colorizer that picks a color inside a range,+-- and depending on the window's class.+colorRangeFromClassName :: (Word8, Word8, Word8) -- ^ Beginning of the color range+                        -> (Word8, Word8, Word8) -- ^ End of the color range+                        -> (Word8, Word8, Word8) -- ^ Background of the active window+                        -> (Word8, Word8, Word8) -- ^ Inactive text color+                        -> (Word8, Word8, Word8) -- ^ Active text color+                        -> Window -> Bool -> X (String, String)+colorRangeFromClassName startC endC activeC inactiveT activeT w active =+    do classname <- runQuery className w+       if active+         then return (rgbToHex activeC, rgbToHex activeT)+         else return (rgbToHex $ mix startC endC+                  $ stringToRatio classname, rgbToHex inactiveT)+    where rgbToHex :: (Word8, Word8, Word8) -> String+          rgbToHex (r, g, b) = '#':twodigitHex r+                               ++twodigitHex g++twodigitHex b++-- | Creates a mix of two colors according to a ratio+-- (1 -> first color, 0 -> second color).+mix :: (Word8, Word8, Word8) -> (Word8, Word8, Word8)+        -> Double -> (Word8, Word8, Word8)+mix (r1, g1, b1) (r2, g2, b2) r = (mix' r1 r2, mix' g1 g2, mix' b1 b2)+    where  mix' a b = truncate $ (fi a * r) + (fi b * (1 - r))++-- | Generates a Double from a string, trying to+-- achieve a random distribution.+-- We create a random seed from the sum of all characters+-- in the string, and use it to generate a ratio between 0 and 1+stringToRatio :: String -> Double+stringToRatio "" = 0+stringToRatio s = let gen = mkStdGen $ sum $ map fromEnum s+                      range = (\(a, b) -> b - a) $ genRange gen+                      randomInt = foldr1 combine $ replicate 20 next+                      combine f1 f2 g = let (_, g') = f1 g in f2 g'+                  in fi (fst $ randomInt gen) / fi range++-- | Brings up a 2D grid of elements in the center of the screen, and one can+-- select an element with cursors keys. The selected element is returned.+gridselect :: GSConfig a -> [(String,a)] -> X (Maybe a)+gridselect gsconfig elmap =+ withDisplay $ \dpy -> do+    rootw <- asks theRoot+    s <- 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)+    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+    font <- initXMF (gs_font gsconfig)+    let screenWidth = toInteger $ rect_width s;+        screenHeight = toInteger $ rect_height s;+    selectedElement <- if (status == grabSuccess) then do+                            let restriction ss cs = (fromInteger ss/fromInteger (cs gsconfig)-1)/2 :: Double+                                restrictX = floor $ restriction screenWidth gs_cellwidth+                                restrictY = floor $ restriction screenHeight gs_cellheight+                                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+                                elmap' = zip coords elmap++                            evalTwoD (updateAllElements >> eventLoop)+                                (TwoDState (head coords)+                                            elmap'+                                            gsconfig+                                            font+                                            screenWidth+                                            screenHeight+                                            win)+                      else+                          return Nothing+    liftIO $ do+      unmapWindow dpy win+      destroyWindow dpy win+      sync dpy False+    releaseXMF font+    return selectedElement++-- | Like `gridSelect' but with the current windows and their titles as elements+gridselectWindow :: GSConfig Window -> X (Maybe Window)+gridselectWindow gsconf = windowMap >>= gridselect gsconf++-- | Brings up a 2D grid of windows in the center of the screen, and one can+-- select a window with cursors keys. The selected window is then passed to+-- a callback function.+withSelectedWindow :: (Window -> X ()) -> GSConfig Window -> X ()+withSelectedWindow callback conf = do+    mbWindow <- gridselectWindow conf+    case mbWindow of+        Just w -> callback w+        Nothing -> return ()++windowMap :: X [(String,Window)]+windowMap = do+    ws <- gets windowset+    wins <- mapM keyValuePair (W.allWindows ws)+    return wins+ where keyValuePair w = flip (,) w `fmap` decorateName' w++decorateName' :: Window -> X String+decorateName' w = do+  fmap show $ getName w++-- | 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" defaultGSNav (1/2) (1/2)++defaultGSNav :: NavigateMap+defaultGSNav = M.map tupadd $ M.fromList+    [((0,xK_Left) ,(-1,0))+    ,((0,xK_h)    ,(-1,0))+    ,((0,xK_Right),(1,0))+    ,((0,xK_l)    ,(1,0))+    ,((0,xK_Down) ,(0,1))+    ,((0,xK_j)    ,(0,1))+    ,((0,xK_Up)   ,(0,-1))+    ,((0,xK_k)    ,(0,-1))+    ]++borderColor :: String+borderColor = "white"++-- | Brings selected window to the current workspace.+bringSelected :: GSConfig Window -> X ()+bringSelected = withSelectedWindow $ \w -> do+    windows (bringWindow w)+    XMonad.focus w+    windows W.shiftMaster++-- | Switches to selected window's workspace and focuses that window.+goToSelected :: GSConfig Window -> X ()+goToSelected = withSelectedWindow $ windows . W.focusWindow++-- | Select an application to spawn from a given list+spawnSelected :: GSConfig String -> [String] -> X ()+spawnSelected conf lst = gridselect conf (zip lst lst) >>= flip whenJust spawn++-- | Select an action and run it in the X monad+runSelectedAction :: GSConfig (X ()) -> [(String, X ())] -> X ()+runSelectedAction conf actions = do+    selectedActionM <- gridselect conf actions+    case selectedActionM of+        Just selectedAction -> selectedAction+        Nothing -> return ()

@@ -0,0 +1,99 @@+-----------------------------------------------------------------------------+-- |+-- Module       : XMonad.Actions.MessageFeedback+-- Copyright    : (c) Quentin Moser <quentin.moser@unifr.ch>+-- License      : BSD3+--+-- Maintainer   : None+-- Stability    : unstable+-- Portability  : unportable+--+-- Alternative to 'XMonad.Operations.sendMessage' that provides knowledge+-- of whether the message was handled, and utility functions based on+-- this facility.+-----------------------------------------------------------------------------++module XMonad.Actions.MessageFeedback (+                                      -- * Usage+                                      -- $usage++                                        send+                                      , tryMessage+                                      , tryMessage_+                                      , tryInOrder+                                      , tryInOrder_+                                      , sm+                                      , sendSM+                                      , sendSM_+                                      ) where++import XMonad.Core ( X (), Message, SomeMessage(..), LayoutClass(..), windowset, catchX )+import XMonad.StackSet ( current, workspace, layout, tag )+import XMonad.Operations ( updateLayout )++import Control.Monad.State ( gets )+import Data.Maybe ( isJust )+import Control.Applicative ((<$>))++-- $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.+--+-- 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+--+-- > -- 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))+--+-- 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:+--+-- > ((modKey, xK_Left), tryMessage_ Shrink (MoveLeft 50))+--+++-- | 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++-- | 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++tryMessage_ :: (Message a, Message b) => a -> b -> X ()+tryMessage_ m1 m2 = tryMessage m1 m2 >> return ()++-- | 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++tryInOrder_ :: [SomeMessage] -> X ()+tryInOrder_ ms = tryInOrder ms >> return ()+++-- | Convenience shorthand for 'XMonad.Core.SomeMessage'.+sm :: Message a => a -> SomeMessage+sm = SomeMessage+++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_ :: SomeMessage -> X ()+sendSM_ m = sendSM m >> return ()

@@ -15,14 +15,14 @@ module XMonad.Actions.MouseGestures (     -- * Usage     -- $usage-    Direction(..),+    Direction2D(..),     mouseGestureH,     mouseGesture,     mkCollect ) where  import XMonad-import XMonad.Hooks.ManageDocks (Direction(..))+import XMonad.Util.Types (Direction2D(..))  import Data.IORef import qualified Data.Map as M@@ -39,7 +39,7 @@ -- -- then add an appropriate mouse binding: ----- >     , ((modMask x .|. shiftMask, button3), mouseGesture gestures)+-- >     , ((modm .|. shiftMask, button3), mouseGesture gestures) -- -- where @gestures@ is a 'Data.Map.Map' from gestures to actions on -- windows, for example:@@ -64,10 +64,10 @@     where     d a b = abs (a - b) -dir :: Pos -> Pos -> Direction+dir :: Pos -> Pos -> Direction2D dir (ax, ay) (bx, by) = trans . (/ pi) $ atan2 (fromIntegral $ ay - by) (fromIntegral $ bx - ax)     where-    trans :: Double -> Direction+    trans :: Double -> Direction2D     trans x         | rg (-3/4) (-1/4) x = D         | rg (-1/4)  (1/4) x = R@@ -75,7 +75,7 @@         | otherwise          = L     rg a z x = a <= x && x < z -gauge :: (Direction -> X ()) -> Pos -> IORef (Maybe (Direction, Pos)) -> Position -> Position -> X ()+gauge :: (Direction2D -> X ()) -> Pos -> IORef (Maybe (Direction2D, Pos)) -> Position -> Position -> X () gauge hook op st nx ny = do     let np = (nx, ny)     stx <- io $ readIORef st@@ -96,7 +96,7 @@ -- | @'mouseGestureH' moveHook endHook@ is a mouse button -- event handler. It collects mouse movements, calling @moveHook@ for each -- update; when the button is released, it calls @endHook@.-mouseGestureH :: (Direction -> X ()) -> X () -> X ()+mouseGestureH :: (Direction2D -> X ()) -> X () -> X () mouseGestureH moveHook endHook = do     dpy <- asks display     root <- asks theRoot@@ -108,7 +108,7 @@  -- | A utility function on top of 'mouseGestureH'. It uses a 'Data.Map.Map' to -- look up the mouse gesture, then executes the corresponding action (if any).-mouseGesture :: Map [Direction] (Window -> X ()) -> Window -> X ()+mouseGesture :: Map [Direction2D] (Window -> X ()) -> Window -> X () mouseGesture tbl win = do     (mov, end) <- mkCollect     mouseGestureH (\d -> mov d >> return ()) $ end >>= \gest ->@@ -121,7 +121,7 @@ -- collect mouse movements (and return the current gesture as a list); the end -- hook will return a list of the completed gesture, which you can access with -- 'Control.Monad.>>='.-mkCollect :: (MonadIO m, MonadIO m') => m (Direction -> m' [Direction], m' [Direction])+mkCollect :: (MonadIO m, MonadIO m') => m (Direction2D -> m' [Direction2D], m' [Direction2D]) mkCollect = liftIO $ do     acc <- newIORef []     let

@@ -47,11 +47,11 @@ -- -- Then edit your @layoutHook@ by modifying a given layout: ----- > myLayouts = mouseResize $ windowArrange $ layoutHook defaultConfig+-- > myLayout = mouseResize $ windowArrange $ layoutHook defaultConfig -- -- and then: ----- > main = xmonad defaultConfig { layoutHook = myLayouts }+-- > main = xmonad defaultConfig { layoutHook = myLayout } -- -- For more detailed instructions on editing the layoutHook see: --@@ -65,7 +65,8 @@ instance Read (MouseResize a) where readsPrec _ s = [(MR [], s)]  instance LayoutModifier MouseResize Window where-    redoLayout (MR st) _ s wrs+    redoLayout _       _ Nothing  wrs = return (wrs, Nothing)+    redoLayout (MR st) _ (Just s) wrs         | [] <- st  = initState    >>= \nst -> return (wrs, Just $ MR nst)         | otherwise = processState >>= \nst -> return (wrs, Just $ MR nst)         where

@@ -5,7 +5,7 @@ -- License     :  BSD3-style (see LICENSE) -- -- Maintainer  :  Lukas Mai <l.mai@web.de>--- Stability   :  unstable+-- Stability   :  stable -- Portability :  unportable -- -- This module provides helper functions for dealing with window borders.@@ -21,7 +21,7 @@ -- | Toggle the border of the currently focused window. To use it, add a -- keybinding like so: ----- > , ((modMask x,  xK_g ),   withFocused toggleBorder)+-- > , ((modm,  xK_g ),   withFocused toggleBorder) -- toggleBorder :: Window -> X () toggleBorder w = do

@@ -0,0 +1,115 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  XMonad.Actions.OnScreen+-- Copyright   :  (c) 2009 Nils Schweinsberg+-- License     :  BSD3-style (see LICENSE)+--+-- Maintainer  :  Nils Schweinsberg <mail@n-sch.de>+-- Stability   :  unstable+-- Portability :  unportable+--+-- Control workspaces on different screens (in xinerama mode).+--+-----------------------------------------------------------------------------++module XMonad.Actions.OnScreen (+    -- * Usage+    -- $usage+    onScreen+    , viewOnScreen+    , greedyViewOnScreen+    , onlyOnScreen+    ) where++import XMonad.StackSet+import Control.Monad(guard)+import Data.List+import Data.Maybe(fromMaybe)+import Data.Function(on)++-- $usage+--+-- This module provides an easy way to control, what you see on other screens in+-- xinerama mode without having to focus them. Put this into your+-- @~\/.xmonad\/xmonad.hs@:+--+-- > import XMonad.Actions.OnScreen+--+-- Then add the appropriate keybindings, for example replace your current keys+-- to switch the workspaces with this at the bottom of your keybindings:+--+-- >     +++-- >     [ ((m .|. modm, k), windows (f i))+-- >       | (i, k) <- zip (workspaces conf) ([xK_1 .. xK_9] ++ [xK_0])+-- >       , (f, m) <- [ (viewOnScreen 0, 0)+-- >                   , (viewOnScreen 1, controlMask)+-- >                   , (greedyView, controlMask .|. shiftMask) ]+-- >     ]+--+-- This will provide you with the following keybindings:+--+--      * modkey + 1-0:+--      Switch to workspace 1-0 on screen 0+--+--      * modkey + control + 1-0:+--      Switch to workspace 1-0 on screen 1+--+--      * modkey + control + shift + 1-0:+--      Default greedyView behaviour+--+--+-- A more basic version inside the default keybindings would be:+--+-- >        , ((modm .|. controlMask, xK_1) windows (viewOnScreen 0 "1"))+--+-- where 0 is the first screen and "1" the workspace with the tag "1".+--+-- For detailed instructions on editing your key bindings, see+-- "XMonad.Doc.Extending#Editing_key_bindings".++-- | Switch to the (hidden) workspace with index 'i' on the screen 'sc'.+-- A default function (for example 'view' or 'greedyView') will be run if 'sc' is+-- the current screen, no valid screen id or workspace 'i' is already visible.+onScreen :: (Eq sid, Eq i)+          => (i -> StackSet i l a sid sd -> StackSet i l a sid sd) -- ^ default action+          -> sid                      -- ^ screen id+          -> i                        -- ^ index of the workspace+          -> StackSet i l a sid sd    -- ^ current stack+          -> StackSet i l a sid sd+onScreen defFunc sc i st = fromMaybe (defFunc i st) $ do+    -- on unfocused current screen+    guard $ screen (current st) /= sc+    x <- find ((i==) . tag    ) (hidden  st)+    s <- find ((sc==) . screen) (screens st)+    o <- find ((sc==) . screen) (visible st)+    let newScreen = s { workspace = x }+    return st { visible   = newScreen : deleteBy ((==) `on` screen) newScreen (visible st)+              , hidden    = workspace o : deleteBy ((==) `on` tag) x (hidden st)+              }++-- | Switch to workspace 'i' on screen 'sc'. If 'i' is visible use 'greedyView'+-- to switch the current workspace with workspace 'i'.+greedyViewOnScreen :: (Eq sid, Eq i)+    => sid                          -- ^ screen id+    -> i                            -- ^ index of the workspace+    -> StackSet i l a sid sd        -- ^ current stack+    -> StackSet i l a sid sd+greedyViewOnScreen = onScreen greedyView++-- | Switch to workspace 'i' on screen 'sc'. If 'i' is visible use 'view' to+-- switch focus to the workspace 'i'.+viewOnScreen :: (Eq sid, Eq i)+    => sid                          -- ^ screen id+    -> i                            -- ^ index of the workspace+    -> StackSet i l a sid sd        -- ^ current stack+    -> StackSet i l a sid sd+viewOnScreen = onScreen view++-- | Switch to workspace 'i' on screen 'sc'. If 'i' is visible do nothing.+onlyOnScreen :: (Eq sid, Eq i)+    => sid                          -- ^ screen id+    -> i                            -- ^ index of the workspace+    -> StackSet i l a sid sd        -- ^ current stack+    -> StackSet i l a sid sd+onlyOnScreen = onScreen doNothing+  where doNothing _ st = st

@@ -36,7 +36,7 @@  -- | Uses supplied function to decide which action to run depending on current workspace name. chooseAction :: (String->X()) -> X()-chooseAction f = withWindowSet (f . S.tag . S.workspace . S.current)+chooseAction f = withWindowSet (f . S.currentTag)  -- | If current workspace is listed, run appropriate action (only the first match counts!) -- If it isn't listed, then run default action (marked with empty string, \"\"), or do nothing if default isn't supplied.

@@ -0,0 +1,88 @@+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+-----------------------------------------------------------------------------+-- |+-- Module       : XMonad.Actions.PhysicalScreens+-- Copyright    : (c) Nelson Elhage <nelhage@mit.edu>+-- License      : BSD+--+-- Maintainer   : Nelson Elhage <nelhage@mit.edu>+-- Stability    : unstable+-- Portability  : unportable+--+-- Manipulate screens ordered by physical location instead of ID+-----------------------------------------------------------------------------++module XMonad.Actions.PhysicalScreens (+                                        -- * Usage+                                        -- $usage+                                        PhysicalScreen(..)+                                      , getScreen+                                      , viewScreen+                                      , sendToScreen+                                      ) where++import XMonad+import qualified XMonad.StackSet as W++import qualified Graphics.X11.Xlib as X+import Graphics.X11.Xinerama++import Data.List (sortBy)+import Data.Function (on)++{- $usage++This module allows you name Xinerama screens from XMonad using their+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+and then left-to-right.++Example usage in your @~\/.xmonad\/xmonad.hs@ file:++> import XMonad.Actions.PhysicalSCreens++> --+> -- mod-{w,e,r}, Switch to physical/Xinerama screens 1, 2, or 3+> -- mod-shift-{w,e,r}, Move client to screen 1, 2, or 3+> --+> [((modm .|. mask, key), f sc)+>     | (key, sc) <- zip [xK_w, xK_e, xK_r] [0..]+>     , (f, mask) <- [(viewScreen, 0), (sendToScreen, shiftMask)]]++For detailed instructions on editing your key bindings, see+"XMonad.Doc.Extending#Editing_key_bindings".+ -}++-- | The type of the index of a screen by location+newtype PhysicalScreen = P Int deriving (Eq,Ord,Show,Read,Enum,Num,Integral,Real)++-- | Translate a physical screen index to a "ScreenId"+getScreen :: PhysicalScreen -> X (Maybe ScreenId)+getScreen (P i) = withDisplay $ \dpy -> do+                    screens <- io $ getScreenInfo dpy+                    if i >= length screens+                     then return Nothing+                     else let ss = sortBy (cmpScreen `on` fst) $ zip screens [0..]+                          in return $ Just $ snd $ 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++-- | 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++-- | 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)

@@ -29,6 +29,9 @@     , Limits (..)     , Lines (..) +    -- * Key bindings+    , planeKeys+     -- * Navigating through workspaces     , planeShift     , planeMove@@ -36,7 +39,8 @@     where  import Control.Monad-import Data.List hiding (union)+import Data.List+import Data.Map hiding (split) import Data.Maybe  import XMonad@@ -52,12 +56,7 @@ -- > -- > myKeys conf = union (keys defaultConfig conf) $ myNewKeys conf -- >--- > myNewkeys (XConfig {modMask = m}) =--- >     fromList--- >     [ ((keyMask .|. m, keySym), function (Lines 3) Finite direction)--- >     | (keySym, direction) <- zip [xK_Left .. xK_Down] $ enumFrom ToLeft--- >     , (keyMask, function) <- [(0, planeMove), (shiftMask, planeShift)]--- >     ]+-- > myNewkeys (XConfig {modMask = modm}) = planeKeys modm (Lines 3) Finite -- -- For detailed instructions on editing your key bindings, see -- "XMonad.Doc.Extending#Editing_key_bindings".@@ -65,13 +64,12 @@ -- | Direction to go in the plane. data Direction =  ToLeft | ToUp | ToRight | ToDown deriving Enum --- | Defines whether it's a finite or a circular organization of workspaces.+-- | Defines the behaviour when you're trying to move out of the limits. data Limits-    = Finite   -- ^ When you're at a edge of the plane, there's no way to move-               -- to the next region.-    | Circular -- ^ If you try to move, you'll get to the other edge, on the-               -- other side.-    | Linear   -- ^ The plan comes as a row.+    = Finite   -- ^ Ignore the function call, and keep in the same workspace.+    | Circular -- ^ Get on the other side, like in the Snake game.+    | Linear   -- ^ The plan comes as a row, so it goes to the next or prev if+               -- the workspaces were numbered.     deriving Eq  -- | The number of lines in which the workspaces will be arranged.  It's@@ -80,28 +78,24 @@ -- divisor, the last line will have the remaining workspaces. data Lines     = GConf     -- ^ Use @gconftool-2@ to find out the number of lines.-    | Lines Int -- ^ Specify the number of lines explicity.+    | Lines Int -- ^ Specify the number of lines explicitly. --- $navigating------ There're two parameters that must be provided to navigate, and it's a good--- idea to use them with the same values in each keybinding.------ The first is the number of lines in which the workspaces are going to be--- organized.  It's possible to use a number of lines that is not a divisor--- of the number of workspaces, but the results are better when using a--- divisor.  If it's not a divisor, the last line will have the remaining--- workspaces.------ The other one is 'Limits'.+-- | This is the way most people would like to use this module.  It attaches the+-- 'KeyMask' passed as a parameter with 'xK_Left', 'xK_Up', 'xK_Right' and+-- 'xK_Down', associating it with 'planeMove' to the corresponding 'Direction'.+-- It also associates these bindings with 'shiftMask' to 'planeShift'.+planeKeys :: KeyMask -> Lines -> Limits -> Map (KeyMask, KeySym) (X ())+planeKeys modm ln limits =+  fromList $+  [ ((keyMask, keySym), function ln limits direction)+  | (keySym, direction) <- zip [xK_Left .. xK_Down] $ enumFrom ToLeft+  , (keyMask, function) <- [(modm, planeMove), (shiftMask .|. modm, planeShift)]+  ]  -- | Shift a window to the next workspace in 'Direction'.  Note that this will--- also move to the next workspace.-planeShift-    :: Lines-    -> Limits-    -> Direction-    -> X ()+-- also move to the next workspace.  It's a good idea to use the same 'Lines'+-- and 'Limits' for all the bindings.+planeShift :: Lines -> Limits -> Direction -> X () planeShift = plane shift'  shift' ::

@@ -33,7 +33,7 @@ -- -- then add a keybinding or substitute 'promote' in place of swapMaster: ----- >   , ((modMask x,               xK_Return), promote)+-- >   , ((modm,               xK_Return), promote) -- -- For detailed instructions on editing your key bindings, see -- "XMonad.Doc.Extending#Editing_key_bindings".

@@ -0,0 +1,72 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  XMonad.Actions.RandomBackground+-- Copyright   :  (c) 2009 Anze Slosar+--                translation to Haskell by Adam Vogt+-- License     :  BSD3-style (see LICENSE)+--+-- Maintainer  :  <vogt.adam@gmail.com>+-- Stability   :  unstable+-- Portability :  unportable+--+-- An action to start terminals with a random background color+--+-----------------------------------------------------------------------------++module XMonad.Actions.RandomBackground (+    -- * Usage+    -- $usage+    randomBg',+    randomBg,+    RandomColor(HSV,RGB)+    ) where++import XMonad(X, XConf(config), XConfig(terminal), io, spawn,+              MonadIO, asks)+import System.Random+import Control.Monad(liftM)+import Numeric(showHex)++-- $usage+--+-- Add to your keybindings something like:+--+-- > ,((modm .|. shiftMask, xK_Return), randomBg $ HSV 0xff 0x20++-- | RandomColor fixes constraints when generating random colors. All+-- parameters should be in the range 0 -- 0xff+data RandomColor = RGB { _colorMin :: Int+                       , _colorMax :: Int+                       } -- ^ specify the minimum and maximum lowest values for each color channel.+                 | HSV { _colorSaturation :: Double+                       , _colorValue :: Double+                       } -- ^ specify the saturation and value, leaving the hue random.++toHex :: [Int] -> String+toHex =  ("'#"++) . (++"'") . concatMap (ensure 2 . ($ "") . showHex)+    where ensure x = reverse . take x . (++repeat '0') . reverse++randPermutation ::  (RandomGen g) => [a] -> g -> [a]+randPermutation xs g = swap $ zip (randoms g) xs+  where+    swap ((True,x):(c,y):ys) = y:swap ((c,x):ys)+    swap ((False,x):ys) = x:swap ys+    swap x = map snd x++-- | @randomBg'@ produces a random hex number in the form @'#xxyyzz'@+randomBg' ::  (MonadIO m) => RandomColor -> m String+randomBg' (RGB l h) = io $ liftM (toHex . take 3 . randomRs (l,h)) newStdGen+randomBg' (HSV s v) = io $ do+    g <- newStdGen+    let x = (^(2::Int)) $ fst $ randomR (0,sqrt $ pi / 3) g+    return $ toHex $ map round $ randPermutation [v,(v-s)*x + s,s] g++-- | @randomBg@ starts a terminal with the background color taken from 'randomBg''+--+-- This depends on the your 'terminal' configuration field accepting an+-- argument like @-bg '#ff0023'@+randomBg :: RandomColor -> X ()+randomBg x = do+    t <- asks (terminal . config)+    c <- randomBg' x+    spawn $ t ++ " -bg " ++ c

@@ -5,7 +5,7 @@ -- License      : BSD3-style (see LICENSE) -- -- Maintainer   : Hans Philipp Annen <haphi@gmx.net>--- Stability    : unstable+-- Stability    : stable -- Portability  : unportable -- -- Rotate all windows except the master window and keep the focus in@@ -28,7 +28,7 @@ -- -- and add whatever keybindings you would like, for example: ----- > , ((modMask x .|. shiftMask, xK_Tab   ), rotSlavesUp)+-- > , ((modm .|. shiftMask, xK_Tab   ), rotSlavesUp) -- -- This operation will rotate all windows except the master window, -- while the focus stays where it is. It is useful together with the

@@ -10,39 +10,56 @@    Modeled after the handy Surfraw CLI search tools at <https://secure.wikimedia.org/wikipedia/en/wiki/Surfraw>.     Additional sites welcomed. -}-module XMonad.Actions.Search (    -- * Usage-                                  -- $usage-                               search,-                               SearchEngine(..),-                               searchEngine,-                               promptSearch,-                               promptSearchBrowser,-                               selectSearch,-                               selectSearchBrowser,--                               amazon,-                               codesearch,-                               dictionary,-                               google,-                               hoogle,-                               imdb,-                               maps,-                               mathworld,-                               scholar,-                               thesaurus,-                               wayback,-                               wikipedia,-                               youtube+module XMonad.Actions.Search (   -- * Usage+                                 -- $usage+                                 search,+                                 SearchEngine(..),+                                 searchEngine,+                                 searchEngineF,+                                 promptSearch,+                                 promptSearchBrowser,+                                 selectSearch,+                                 selectSearchBrowser,+                                 isPrefixOf,+                                 escape,+                                 use,+                                 intelligent,+                                 (!>),+                                 prefixAware,+                                 namedEngine, +                                 amazon,+                                 alpha,+                                 codesearch,+                                 deb,+                                 debbts,+                                 debpts,+                                 dictionary,+                                 google,+                                 hackage,+                                 hoogle,+                                 images,+                                 imdb,+                                 isohunt,+                                 lucky,+                                 maps,+                                 mathworld,+                                 scholar,+                                 thesaurus,+                                 wayback,+                                 wikipedia,+                                 wiktionary,+                                 youtube,+                                 multi                                   -- * Use case: searching with a submap                                   -- $tip-                           ) where  import Data.Char (chr, ord, isAlpha, isMark, isDigit)+import Data.List (isPrefixOf) import Numeric (showIntAtBase) import XMonad (X(), MonadIO, liftIO)-import XMonad.Prompt (XPrompt(showXPrompt), mkXPrompt, XPConfig(), historyCompletion)+import XMonad.Prompt (XPrompt(showXPrompt), mkXPrompt, XPConfig(), historyCompletionP) import XMonad.Prompt.Shell (getBrowser) import XMonad.Util.Run (safeSpawn) import XMonad.Util.XSelection (getSelection)@@ -73,16 +90,32 @@  * 'amazon' -- Amazon keyword search. +* 'alpha' -- Wolfram|Alpha query.+ * 'codesearch' -- Google Labs Code Search search. +* 'deb'    -- Debian package search.++* 'debbts' -- Debian Bug Tracking System.++* 'debpts'  -- Debian Package Tracking System.+ * 'dictionary' -- dictionary.reference.com search.  * 'google' -- basic Google search. -* 'hoogle' -- Hoogle, the Haskell libraries search engine.+* 'hackage' -- Hackage, the Haskell package database. +* 'hoogle' -- Hoogle, the Haskell libraries API search engine.++* 'images' -- Google images.+ * 'imdb'   -- the Internet Movie Database. +* 'isohunt' -- isoHunt search.++* 'lucky' -- Google "I'm feeling lucky" search.+ * 'maps'   -- Google maps.  * 'mathworld' -- Wolfram MathWorld search.@@ -97,6 +130,8 @@  * 'youtube' -- Youtube video search. +* 'multi' -- Search based on the prefix. \"amazon:Potter\" will use amazon, etc. With no prefix searches google.+ Feel free to add more! -}  {- $tip@@ -125,6 +160,22 @@ >       , ((0, xK_w), method S.wikipedia) >       ] +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-s " ++ k, S.selectSearch f) | (k,f) <- searchList ]+>+> ...+>+> searchList :: [(String, S.SearchEngine)]+> searchList = [ ("g", S.google)+>              , ("h", S.hoohle)+>              , ("w", S.wikipedia)+>              ]+ Make sure to set firefox to open new pages in a new window instead of in a new tab: @Firefox -> Edit -> Preferences -> Tabs -> New pages should be opened in...@@@ -154,14 +205,14 @@                (Char -> Bool)      -- a predicate which returns 'False' if should escape                -> String           -- the string to process                -> String           -- the resulting URI string-           escapeURIString p s = concatMap (escapeURIChar p) s+           escapeURIString = concatMap . escapeURIChar            escapeURIChar :: (Char->Bool) -> Char -> String            escapeURIChar p c                | p c       = [c]                | otherwise = '%' : myShowHex (ord c) ""                where                  myShowHex :: Int -> ShowS-                 myShowHex n r =  case showIntAtBase 16 (toChrHex) n r of+                 myShowHex n r =  case showIntAtBase 16 toChrHex n r of                                     []  -> "00"                                     [ch] -> ['0',ch]                                     cs  -> cs@@ -171,14 +222,21 @@  type Browser      = FilePath type Query        = String-type Site         = String+type Site         = String -> String type Name         = String data SearchEngine = SearchEngine Name Site --- | Given a browser, a search engine, and a search term, perform the+-- | Given an already defined search engine, extracts its transformation+--   function, making it easy to create compound search engines.+--   For an instance you can use @use google@ to get a function which+--   makes the same transformation as the google search engine would.+use :: SearchEngine -> Site+use (SearchEngine _ engine) = engine++-- | Given a browser, a search engine's transformation function, and a search term, perform the --   requested search in the browser. search :: Browser -> Site -> Query -> X ()-search browser site query = safeSpawn browser (site ++ (escape query))+search browser site query = safeSpawn browser [site query]  {- | Given a base URL, create the 'SearchEngine' that escapes the query and    appends it to the base. You can easily define a new engine locally using@@ -188,38 +246,113 @@     The important thing is that the site has a interface which accepts the escaped query    string as part of the URL. Alas, the exact URL to feed searchEngine varies-   from site to site, often considerably, so there's no general way to cover this.+   from site to site, often considerably, so there\'s no general way to cover this.     Generally, examining the resultant URL of a search will allow you to reverse-engineer    it if you can't find the necessary URL already described in other projects such as Surfraw. -}-searchEngine :: Name -> Site -> SearchEngine-searchEngine name site = SearchEngine name site+searchEngine :: Name -> String -> SearchEngine+searchEngine name site = searchEngineF name (\s -> site ++ (escape s)) +{- | If your search engine is more complex than this (you may want to identify+   the kind of input and make the search URL dependent on the input or put the query+   inside of a URL instead of in the end) you can use the alternative 'searchEngineF' function.++> searchFunc :: String -> String+> searchFunc s | s `isPrefixOf` "wiki:"   = "http://en.wikipedia.org/wiki/" ++ (escape $ tail $ snd $ break (==':') s)+>              | s `isPrefixOf` "http://" = s+>              | otherwise               = (use google) s+> myNewEngine = searchEngineF "mymulti" searchFunc++   @searchFunc@ here searches for a word in wikipedia if it has a prefix+   of \"wiki:\" (you can use the 'escape' function to escape any forbidden characters), opens an address+   directly if it starts with \"http:\/\/\" and otherwise uses the provided google search engine.+   You can use other engines inside of your own through the 'use' function as shown above to make+   complex searches.++   The user input will be automatically escaped in search engines created with 'searchEngine',+   'searchEngineF', however, completely depends on the transformation function passed to it. -}+searchEngineF :: Name -> Site -> SearchEngine+searchEngineF = SearchEngine+ -- The engines.-amazon, codesearch, dictionary, google, hoogle, imdb, maps, mathworld,-  scholar, thesaurus, wayback, wikipedia, youtube :: SearchEngine+amazon, alpha, codesearch, deb, debbts, debpts, dictionary, google, hackage, hoogle,+  images, imdb, isohunt, lucky, maps, mathworld, scholar, thesaurus, wayback, wikipedia, wiktionary,+  youtube :: SearchEngine amazon     = searchEngine "amazon"     "http://www.amazon.com/exec/obidos/external-search?index=all&keyword="+alpha      = searchEngine "alpha"      "http://www.wolframalpha.com/input/?i=" codesearch = searchEngine "codesearch" "http://www.google.com/codesearch?q="-dictionary = searchEngine "dictionary" "http://dictionary.reference.com/browse/"+deb        = searchEngine "deb"        "http://packages.debian.org/"+debbts     = searchEngine "debbts"     "http://bugs.debian.org/"+debpts     = searchEngine "debpts"     "http://packages.qa.debian.org/"+dictionary = searchEngine "dict"       "http://dictionary.reference.com/browse/" google     = searchEngine "google"     "http://www.google.com/search?num=100&q="+hackage    = searchEngine "hackage"    "http://hackage.haskell.org/package/" hoogle     = searchEngine "hoogle"     "http://www.haskell.org/hoogle/?q="+images     = searchEngine "images"     "http://images.google.fr/images?q=" imdb       = searchEngine "imdb"       "http://www.imdb.com/Find?select=all&for="+isohunt    = searchEngine "isohunt"    "http://isohunt.com/torrents/?ihq="+lucky      = searchEngine "lucky"      "http://www.google.com/search?btnI&q=" maps       = searchEngine "maps"       "http://maps.google.com/maps?q=" mathworld  = searchEngine "mathworld"  "http://mathworld.wolfram.com/search/?query=" scholar    = searchEngine "scholar"    "http://scholar.google.com/scholar?q=" thesaurus  = searchEngine "thesaurus"  "http://thesaurus.reference.com/search?q="-wikipedia  = searchEngine "wikipedia"  "https://secure.wikimedia.org/wikipedia/en/wiki/Special:Search?go=Go&search="+wikipedia  = searchEngine "wiki"       "https://secure.wikimedia.org/wikipedia/en/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=" {- This doesn't seem to work, but nevertheless, it seems to be the official    method at <http://web.archive.org/collections/web/advanced.html> to get the    latest backup. -} wayback   = searchEngine "wayback" "http://web.archive.org/" +multi :: SearchEngine+multi = namedEngine "multi" $ foldr1 (!>) [amazon, alpha, codesearch, deb, debbts, debpts, dictionary, google, hackage, hoogle, images, imdb, isohunt, lucky, maps, mathworld, scholar, thesaurus, wayback, wikipedia, wiktionary, (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+   searching.++> myIntelligentGoogleEngine = intelligent google++   Now if you search for http:\/\/xmonad.org it will directly open in your browser-}+intelligent :: SearchEngine -> SearchEngine+intelligent (SearchEngine name site) = searchEngineF name (\s -> if (fst $ break (==':') s) `elem` ["http", "https", "ftp"] then s else (site s))++-- | > removeColonPrefix "foo://bar" ~> "//bar"+-- > removeColonPrefix "foo//bar" ~> "foo//bar"+removeColonPrefix :: String -> String+removeColonPrefix s = if ':' `elem` s then drop 1 $ dropWhile (':' /=) s else s++{- | Connects a few search engines into one. If the search engines\' names are+   \"s1\", \"s2\" and \"s3\", then the resulting engine will use s1 if the query+   is @s1:word@, s2 if you type @s2:word@ and s3 in all other cases.++   Example:++> multiEngine = intelligent (wikipedia !> mathworld !> (prefixAware google))++  Now if you type \"wiki:Haskell\" it will search for \"Haskell\" in Wikipedia,+  \"mathworld:integral\" will search mathworld, and everything else will fall back to+  google. The use of intelligent will make sure that URLs are opened directly. -}+(!>) :: SearchEngine -> SearchEngine -> SearchEngine+(SearchEngine name1 site1) !> (SearchEngine name2 site2) = searchEngineF (name1 ++ "/" ++ name2) (\s -> if s `isPrefixOf` (name1++":") then site1 (removeColonPrefix s) else site2 s)++{- | Makes a search engine prefix-aware. Especially useful together with '!>'.+   It will automatically remove the prefix from a query so that you don\'t end+     up searching for google:xmonad if google is your fallback engine and you+     explicitly add the prefix. -}+prefixAware :: SearchEngine -> SearchEngine+prefixAware (SearchEngine name site) = SearchEngine name (\s -> if s `isPrefixOf` (name++":") then site $ removeColonPrefix s else site s)++{- | Changes search engine's name -}+namedEngine :: Name -> SearchEngine -> SearchEngine+namedEngine name (SearchEngine _ site) = searchEngineF name site+ {- | Like 'search', but for use with the output from a Prompt; it grabs the    Prompt's result, passes it to a given searchEngine and opens it in a given    browser. -} promptSearchBrowser :: XPConfig -> Browser -> SearchEngine -> X ()-promptSearchBrowser config browser (SearchEngine name site) = mkXPrompt (Search name) config (historyCompletion) $ search browser site+promptSearchBrowser config browser (SearchEngine name site) =+    mkXPrompt (Search name) config (historyCompletionP ("Search [" `isPrefixOf`)) $ search browser site  {- | Like 'search', but in this case, the string is not specified but grabbed  from the user's response to a prompt. Example:

@@ -29,7 +29,7 @@ -- -- and add a keybinding, for example: ----- >    , ((modMask x,               xK_d     ), date)+-- >    , ((modm,               xK_d     ), date) -- -- In this example, a popup date menu will now be bound to @mod-d@. --

@@ -5,17 +5,20 @@ -- Stability    : unstable -- Portability  : unportable ----- Provides a simple binding that pushes all floating windows on the current--- workspace back into tiling.+-- Provides a simple binding that pushes all floating windows on the+-- current workspace back into tiling.  Note that the functionality of+-- this module has been folded into the more general+-- "XMonad.Actions.WithAll"; this module simply re-exports the+-- 'sinkAll' function for backwards compatibility. -----------------------------------------------------------------------------  module XMonad.Actions.SinkAll (     -- * Usage     -- $usage+     sinkAll) where -import XMonad-import XMonad.StackSet+import XMonad.Actions.WithAll (sinkAll)  -- $usage --@@ -25,16 +28,7 @@ -- -- then add a keybinding; for example: -----     , ((modMask x .|. shiftMask, xK_t), sinkAll)+-- >   , ((modm .|. shiftMask, xK_t), sinkAll) -- -- For detailed instructions on editing your key bindings, see -- "XMonad.Doc.Extending#Editing_key_bindings".---- | Un-float all floating windows on the current workspace.-sinkAll :: X ()-sinkAll = withAll sink---- | Apply a function to all windows on current workspace.-withAll :: (Window -> WindowSet -> WindowSet) -> X ()-withAll f = windows $ \ws -> let all' = integrate' . stack . workspace . current $ ws-                             in foldr f ws all'

@@ -0,0 +1,122 @@+-----------------------------------------------------------------------------+-- |+-- Module       : XMonad.Actions.SpawnOn+-- Copyright    : (c) Spencer Janssen+-- License      : BSD+--+-- Maintainer   : Spencer Janssen <spencerjanssen@gmail.com>+-- Stability    : unstable+-- Portability  : unportable+--+-- Provides a way to modify a window spawned by a command(e.g shift it to the workspace+-- it was launched on) by using the _NET_WM_PID property that most windows set on creation.+-- Hence this module won't work on applications that don't set this property.+--+-----------------------------------------------------------------------------++module XMonad.Actions.SpawnOn (+    -- * Usage+    -- $usage+    Spawner,+    mkSpawner,+    manageSpawn,+    spawnHere,+    spawnOn,+    spawnAndDo,+    shellPromptHere,+    shellPromptOn+) where++import Data.List (isInfixOf)+import Data.IORef+import System.Posix.Types (ProcessID)++import XMonad+import qualified XMonad.StackSet as W++import XMonad.Hooks.ManageHelpers+import XMonad.Prompt+import XMonad.Prompt.Shell++-- $usage+-- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:+--+-- >    import XMonad.Actions.SpawnOn+--+-- >    main = do+-- >      sp <- mkSpawner+-- >      xmonad defaultConfig {+-- >         ...+-- >         manageHook = manageSpawn sp <+> manageHook defaultConfig+-- >         ...+-- >      }+--+-- To ensure that application appears on a workspace it was launched at, add keybindings like:+--+-- >  , ((mod1Mask,xK_o), spawnHere sp "urxvt")+-- >  , ((mod1Mask,xK_s), shellPromptHere sp defaultXPConfig)+--+-- The module can also be used to apply other manage hooks to the window of+-- the spawned application(e.g. float or resize it).+--+-- For detailed instructions on editing your key bindings, see+-- "XMonad.Doc.Extending#Editing_key_bindings".++newtype Spawner = Spawner {pidsRef :: IORef [(ProcessID, ManageHook)]}++maxPids :: Int+maxPids = 5++-- | Create 'Spawner' which then has to be passed to other functions.+mkSpawner :: (Functor m, MonadIO m) => m Spawner+mkSpawner = io . fmap Spawner $ newIORef []++-- | Provides a manage hook to react on process spawned with+-- 'spawnOn', 'spawnHere' etc.+manageSpawn :: Spawner -> ManageHook+manageSpawn sp = do+    pids <- io . readIORef $ pidsRef sp+    mp <- pid+    case flip lookup pids =<< mp of+        Nothing -> doF id+        Just mh  -> do+            whenJust mp $ \p ->+                io . modifyIORef (pidsRef sp) $ filter ((/= p) . fst)+            mh++mkPrompt :: (String -> X ()) -> XPConfig -> X ()+mkPrompt cb c = do+    cmds <- io $ getCommands+    mkXPrompt Shell c (getShellCompl cmds) cb++-- | Replacement for Shell prompt ("XMonad.Prompt.Shell") which launches+-- application on current workspace.+shellPromptHere :: Spawner -> XPConfig -> X ()+shellPromptHere sp = mkPrompt (spawnHere sp)++-- | Replacement for Shell prompt ("XMonad.Prompt.Shell") which launches+-- application on given workspace.+shellPromptOn :: Spawner -> WorkspaceId -> XPConfig -> X ()+shellPromptOn sp ws = mkPrompt (spawnOn sp ws)++-- | Replacement for 'spawn' which launches+-- application on current workspace.+spawnHere :: Spawner -> String -> X ()+spawnHere sp cmd = withWindowSet $ \ws -> spawnOn sp (W.currentTag ws) cmd++-- | Replacement for 'spawn' which launches+-- application on given workspace.+spawnOn :: Spawner -> WorkspaceId -> String -> X ()+spawnOn sp ws cmd = spawnAndDo sp (doShift ws) cmd++-- | Spawn an application and apply the manage hook when it opens.+spawnAndDo :: Spawner -> ManageHook -> String -> X ()+spawnAndDo sp mh cmd = do+    p <- spawnPID $ mangle cmd+    io $ modifyIORef (pidsRef sp) (take maxPids . ((p,mh) :))+ where+    -- TODO this is silly, search for a better solution+    mangle xs | any (`elem` metaChars) xs || "exec" `isInfixOf` xs = xs+              | otherwise = "exec " ++ xs+    metaChars = "&|;"+

@@ -15,9 +15,10 @@ module XMonad.Actions.Submap (                              -- * Usage                              -- $usage-                             submap+                             submap,+                             submapDefault                             ) where-+import Data.Bits import XMonad hiding (keys) import qualified Data.Map as M import Control.Monad.Fix (fix)@@ -33,7 +34,7 @@  Allows you to create a sub-mapping of keys. Example: ->    , ((modMask x, xK_a), submap . M.fromList $+>    , ((modm, xK_a), submap . M.fromList $ >        [ ((0, xK_n),     spawn "mpc next") >        , ((0, xK_p),     spawn "mpc prev") >        , ((0, xK_z),     spawn "mpc random")@@ -57,7 +58,11 @@ --   corresponding action, or does nothing if the key is not found in --   the map. submap :: M.Map (KeyMask, KeySym) (X ()) -> X ()-submap keys = do+submap keys = submapDefault (return ()) keys++-- | 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     XConf { theRoot = root, display = d } <- ask      io $ grabKeyboard d root False grabModeAsync grabModeAsync currentTime@@ -69,8 +74,8 @@         if isModifierKey keysym             then nextkey             else return (m, keysym)+    -- Remove num lock mask and Xkb group state bits+    m' <- cleanMask $ m .&. ((1 `shiftL` 12) - 1)+    maybe def id (M.lookup (m', s) keys)      io $ ungrabKeyboard d currentTime--    m' <- cleanMask m-    whenJust (M.lookup (m', s) keys) id

@@ -19,12 +19,13 @@                                      swapWithCurrent,                                      swapTo,                                      swapWorkspaces,-                                     WSDirection(..)+                                     Direction1D(..)                                     ) where  import XMonad (windows, X()) import XMonad.StackSet import XMonad.Actions.CycleWS+import XMonad.Util.Types import XMonad.Util.WorkspaceCompare  @@ -36,7 +37,7 @@ -- Then throw something like this in your keys definition: -- -- > ++--- > [((modMask x .|. controlMask, k), windows $ swapWithCurrent i)+-- > [((modm .|. controlMask, k), windows $ swapWithCurrent i) -- >     | (i, k) <- zip workspaces [xK_1 ..]] -- -- After installing this update, if you're on workspace 1, hitting mod-ctrl-5@@ -48,11 +49,11 @@ -- | Swaps the currently focused workspace with the given workspace tag, via --   @swapWorkspaces@. swapWithCurrent :: Eq i => i -> StackSet i l a s sd -> StackSet i l a s sd-swapWithCurrent t s = swapWorkspaces t (tag $ workspace $ current s) s+swapWithCurrent t s = swapWorkspaces t (currentTag s) s  -- | Say @swapTo Next@ or @swapTo Prev@ to move your current workspace. -- This is an @X ()@ so can be hooked up to your keybindings directly.-swapTo :: WSDirection -> X ()+swapTo :: Direction1D -> X () swapTo dir = findWorkspace getSortByIndex dir AnyWS 1 >>= windows . swapWithCurrent  -- | Takes two workspace tags and an existing XMonad.StackSet and returns a new

@@ -42,16 +42,16 @@ -- -- and add keybindings such as the following: ----- >   , ((modMask x,                 xK_f  ), withFocused (addTag "abc"))--- >   , ((modMask x .|. controlMask, xK_f  ), withFocused (delTag "abc"))--- >   , ((modMask x .|. shiftMask,   xK_f  ), withTaggedGlobal "abc" sink)--- >   , ((modMask x,                 xK_d  ), withTaggedP "abc" (shiftWin "2"))--- >   , ((modMask x .|. shiftMask,   xK_d  ), withTaggedGlobalP "abc" shiftHere)--- >   , ((modMask x .|. controlMask, xK_d  ), focusUpTaggedGlobal "abc")--- >   , ((modMask x,                 xK_g  ), tagPrompt defaultXPConfig (\s -> withFocused (addTag s)))--- >   , ((modMask x .|. controlMask, xK_g  ), tagDelPrompt defaultXPConfig)--- >   , ((modMask x .|. shiftMask,   xK_g  ), tagPrompt defaultXPConfig (\s -> withTaggedGlobal s float))--- >   , ((modWinMask,                xK_g  ), tagPrompt defaultXPConfig (\s -> withTaggedP s (shiftWin "2")))+-- >   , ((modm,                 xK_f  ), withFocused (addTag "abc"))+-- >   , ((modm .|. controlMask, xK_f  ), withFocused (delTag "abc"))+-- >   , ((modm .|. shiftMask,   xK_f  ), withTaggedGlobalP "abc" W.sink)+-- >   , ((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)) --@@ -120,7 +120,7 @@ wsToListGlobal :: (Ord i) => StackSet i l a s sd -> [a] wsToListGlobal ws = concat ([crs] ++ rws ++ lws ++ [cls])     where-        curtag = tag . workspace . current $ ws+        curtag = currentTag ws         (crs, cls) = (cms down, cms (reverse . up))         cms f = maybe [] f (stack . workspace . current $ ws)         (lws, rws) = (mws (<), mws (>))@@ -149,8 +149,7 @@ withTaggedGlobal t f = withTaggedGlobal' t (mapM_ f)  withTagged' :: String -> ([Window] -> X ()) -> X ()-withTagged' t m = gets windowset >>=-    filterM (hasTag t) . integrate' . stack . workspace . current >>= m+withTagged' t m = gets windowset >>= filterM (hasTag t) . index >>= m  withTaggedGlobal' :: String -> ([Window] -> X ()) -> X () withTaggedGlobal' t m = gets windowset >>=@@ -160,7 +159,7 @@ withFocusedP f = withFocused $ windows . f  shiftHere :: (Ord a, Eq s, Eq i) => a -> StackSet i l a s sd -> StackSet i l a s sd-shiftHere w s = shiftWin (tag . workspace . current $ s) w s+shiftHere w s = shiftWin (currentTag s) w s  shiftToScreen :: (Ord a, Eq s, Eq i) => s -> a -> StackSet i l a s sd -> StackSet i l a s sd shiftToScreen sid w s = case filter (\m -> sid /= screen m) ((current s):(visible s)) of

@@ -0,0 +1,317 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  XMonad.Actions.TopicSpace+-- Copyright   :  (c) Nicolas Pouillard+-- License     :  BSD-style (see LICENSE)+--+-- Maintainer  :  Nicolas Pouillard <nicolas.pouillard@gmail.com>+-- Stability   :  unstable+-- Portability :  unportable+--+-- Turns your workspaces into a more topic oriented system.+-----------------------------------------------------------------------------++module XMonad.Actions.TopicSpace+  (+  -- * Overview+  -- $overview++  -- * Usage+  -- $usage+   Topic+  , Dir+  , TopicConfig(..)+  , getLastFocusedTopics+  , setLastFocusedTopic+  , pprWindowSet+  , topicActionWithPrompt+  , topicAction+  , currentTopicAction+  , switchTopic+  , switchNthLastFocused+  , shiftNthLastFocused+  , currentTopicDir+  , checkTopicConfig+  , (>*>)+  )+where++import XMonad++import Data.List+import Data.Maybe (fromMaybe, isNothing, listToMaybe)+import Data.Ord+import qualified Data.Map as M+import Control.Monad ((=<<),liftM2,when,unless,replicateM_)+import System.IO++import XMonad.Operations+import qualified XMonad.StackSet as W++import XMonad.Prompt+import XMonad.Prompt.Workspace++import XMonad.Hooks.UrgencyHook+import XMonad.Hooks.DynamicLog (PP(..))+import qualified XMonad.Hooks.DynamicLog as DL++import XMonad.Util.Run (spawnPipe)+import XMonad.Util.StringProp(getStringListProp,setStringListProp)++-- $overview+-- This module allows to organize your workspaces on a precise topic basis.  So+-- instead of having a workspace called `work' you can setup one workspace per+-- task.  Here we call these workspaces, topics. The great thing with+-- topics is that one can attach a directory that makes sense to each+-- particular topic.  One can also attach an action which will be triggered+-- when switching to a topic that does not have any windows in it.  So you can+-- attach your mail client to the mail topic, some terminals in the right+-- directory to the xmonad topic... This package also provides a nice way to+-- display your topics in an historical way using a custom `pprWindowSet'+-- function. You can also easily switch to recent topics using this history+-- of last focused topics.++-- $usage+-- Here is an example of configuration using TopicSpace:+--+-- @+-- -- The list of all topics/workspaces of your xmonad configuration.+-- -- The order is important, new topics must be inserted+-- -- at the end of the list if you want hot-restarting+-- -- to work.+-- myTopics :: [Topic]+-- myTopics =+--   [ \"dashboard\" -- the first one+--   , \"admin\", \"build\", \"cleaning\", \"conf\", \"darcs\", \"haskell\", \"irc\"+--   , \"mail\", \"movie\", \"music\", \"talk\", \"text\", \"tools\", \"web\", \"xmonad\"+--   , \"yi\", \"documents\", \"twitter\", \"pdf\"+--   ]+-- @+--+-- @+--  myTopicConfig :: TopicConfig+--  myTopicConfig = TopicConfig+--    { topicDirs = M.fromList $+--        [ (\"conf\", \"w\/conf\")+--        , (\"dashboard\", \"Desktop\")+--        , (\"yi\", \"w\/dev-haskell\/yi\")+--        , (\"darcs\", \"w\/dev-haskell\/darcs\")+--        , (\"haskell\", \"w\/dev-haskell\")+--        , (\"xmonad\", \"w\/dev-haskell\/xmonad\")+--        , (\"tools\", \"w\/tools\")+--        , (\"movie\", \"Movies\")+--        , (\"talk\", \"w\/talks\")+--        , (\"music\", \"Music\")+--        , (\"documents\", \"w\/documents\")+--        , (\"pdf\", \"w\/documents\")+--        ]+--    , defaultTopicAction = const $ spawnShell >*> 3+--    , defaultTopic = \"dashboard\"+--    , maxTopicHistory = 10+--    , topicActions = M.fromList $+--        [ (\"conf\",       spawnShell >> spawnShellIn \"wd\/ertai\/private\")+--        , (\"darcs\",      spawnShell >*> 3)+--        , (\"yi\",         spawnShell >*> 3)+--        , (\"haskell\",    spawnShell >*> 2 >>+--                         spawnShellIn \"wd\/dev-haskell\/ghc\")+--        , (\"xmonad\",     spawnShellIn \"wd\/x11-wm\/xmonad\" >>+--                         spawnShellIn \"wd\/x11-wm\/xmonad\/contrib\" >>+--                         spawnShellIn \"wd\/x11-wm\/xmonad\/utils\" >>+--                         spawnShellIn \".xmonad\" >>+--                         spawnShellIn \".xmonad\")+--        , (\"mail\",       mailAction)+--        , (\"irc\",        ssh somewhere)+--        , (\"admin\",      ssh somewhere >>+--                         ssh nowhere)+--        , (\"dashboard\",  spawnShell)+--        , (\"twitter\",    spawnShell)+--        , (\"web\",        spawn browserCmd)+--        , (\"movie\",      spawnShell)+--        , (\"documents\",  spawnShell >*> 2 >>+--                         spawnShellIn \"Documents\" >*> 2)+--        , (\"pdf\",        spawn pdfViewerCmd)+--        ]+--    }+-- @+--+-- @+--  -- extend your keybindings+--  myKeys conf\@XConfig{modMask=modm} =+--    [ ((modm              , xK_n     ), spawnShell) -- %! Launch terminal+--    , ((modm              , xK_a     ), currentTopicAction myTopicConfig)+--    , ((modm              , xK_g     ), promptedGoto)+--    , ((modm .|. shiftMask, xK_g     ), promptedShift)+--    ...+--    ]+--    +++--    [ ((modm, k), switchNthLastFocused myTopicConfig i)+--    | (i, k) <- zip [1..] workspaceKeys]+-- @+--+-- @+--  spawnShell :: X ()+--  spawnShell = currentTopicDir myTopicConfig >>= spawnShellIn+-- @+--+-- @+--  spawnShellIn :: Dir -> X ()+--  spawnShellIn dir = spawn $ \"urxvt '(cd ''\" ++ dir ++ \"'' && \" ++ myShell ++ \" )'\"+-- @+--+-- @+--  goto :: Topic -> X ()+--  goto = switchTopic myTopicConfig+-- @+--+-- @+--  promptedGoto :: X ()+--  promptedGoto = workspacePrompt myXPConfig goto+-- @+--+-- @+--  promptedShift :: X ()+--  promptedShift = workspacePrompt myXPConfig $ windows . W.shift+-- @+--+-- @+--  myConfig = do+--      checkTopicConfig myTopics myTopicConfig+--      myLogHook <- makeMyLogHook+--      return $ defaultConfig+--           { borderWidth = 1 -- Width of the window border in pixels.+--           , workspaces = myTopics+--           , layoutHook = myModifiers myLayout+--           , manageHook = myManageHook+--           , logHook = myLogHook+--           , handleEventHook = myHandleEventHook+--           , terminal = myTerminal -- The preferred terminal program.+--           , normalBorderColor = \"#3f3c6d\"+--           , focusedBorderColor = \"#4f66ff\"+--           , XMonad.modMask = mod1Mask+--           , keys = myKeys+--           , mouseBindings = myMouseBindings+--           }+-- @+--+-- @+--  main :: IO ()+--  main = xmonad =<< myConfig+-- @++-- | An alias for @flip replicateM_@+(>*>) :: Monad m => m a -> Int -> m ()+(>*>) = flip replicateM_+infix >*>++-- | 'Topic' is just an alias for 'WorkspaceId'+type Topic = WorkspaceId++-- | 'Dir' is just an alias for 'FilePath' but should points to a directory.+type Dir = FilePath++-- | Here is the topic space configuration area.+data TopicConfig = TopicConfig { topicDirs          :: M.Map Topic Dir+                                 -- ^ This mapping associate a directory to each topic.+                               , topicActions       :: M.Map Topic (X ())+                                 -- ^ This mapping associate an action to trigger when+                                 -- switching to a given topic which workspace is empty.+                               , defaultTopicAction :: Topic -> X ()+                                 -- ^ This is the default topic action.+                               , defaultTopic       :: Topic+                                 -- ^ This is the default topic.+                               , maxTopicHistory    :: Int+                                 -- ^ This setups the maximum depth of topic history, usually+                                 -- 10 is a good default since we can bind all of them using+                                 -- numeric keypad.+                               }++-- | Returns the list of last focused workspaces the empty list otherwise.+-- This function rely on a reserved property namely _XMONAD_LAST_FOCUSED_WORKSPACES.+getLastFocusedTopics :: X [String]+getLastFocusedTopics = asks display >>= flip getStringListProp "_XMONAD_LAST_FOCUSED_WORKSPACES"++-- | Given a 'TopicConfig', the last focused topic, and a predicate that will+-- select topics that one want to keep, this function will set the property+-- of last focused topics.+setLastFocusedTopic :: TopicConfig -> Topic -> (Topic -> Bool) -> X ()+setLastFocusedTopic tg w predicate = do+  disp <- asks display+  setStringListProp disp "_XMONAD_LAST_FOCUSED_WORKSPACES"+    . take (maxTopicHistory tg) . nub . (w:) . filter predicate =<< getLastFocusedTopics++-- | This function is a variant of 'DL.pprWindowSet' which takes a topic configuration+-- and a pretty-printing record 'PP'. It will show the list of topics sorted historically+-- and highlighting topics with urgent windows.+pprWindowSet :: TopicConfig -> PP -> X String+pprWindowSet tg pp = do+    winset <- gets windowset+    urgents <- readUrgents+    let empty_workspaces = map W.tag $ filter (isNothing . W.stack) $ W.workspaces winset+        maxDepth = maxTopicHistory tg+    setLastFocusedTopic tg (W.tag . W.workspace . W.current $ winset)+                           (`notElem` empty_workspaces)+    lastWs <- getLastFocusedTopics+    let depth topic = elemIndex topic lastWs+        add_depth proj topic = proj pp $ maybe topic (((topic++":")++) . show) $ depth topic+        pp' = pp { ppHidden = add_depth ppHidden, ppVisible = add_depth ppVisible }+        sortWindows = take (maxDepth - 1) . sortBy (comparing $ fromMaybe maxDepth . depth . W.tag)+    return $ DL.pprWindowSet sortWindows urgents pp' winset++-- | Given a prompt configuration and a topic configuration, triggers the action associated with+-- the topic given in prompt.+topicActionWithPrompt :: XPConfig -> TopicConfig -> X ()+topicActionWithPrompt xp tg = workspacePrompt xp (liftM2 (>>) (switchTopic tg) (topicAction tg))++-- | Given a configuration and a topic, triggers the action associated with the given topic.+topicAction :: TopicConfig -> Topic -> X ()+topicAction tg topic = fromMaybe (defaultTopicAction tg topic) $ M.lookup topic $ topicActions tg++-- | Trigger the action associated with the current topic.+currentTopicAction :: TopicConfig -> X ()+currentTopicAction tg = topicAction tg =<< gets (W.tag . W.workspace . W.current . windowset)++-- | Switch to the given topic.+switchTopic :: TopicConfig -> Topic -> X ()+switchTopic tg topic = do+  windows $ W.greedyView topic+  wins <- gets (W.integrate' . W.stack . W.workspace . W.current . windowset)+  when (null wins) $ topicAction tg topic++-- | Switch to the Nth last focused topic or failback to the 'defaultTopic'.+switchNthLastFocused ::TopicConfig -> Int -> X ()+switchNthLastFocused tg depth = do+  lastWs <- getLastFocusedTopics+  switchTopic tg $ (lastWs ++ repeat (defaultTopic tg)) !! depth++-- | Shift the focused window to the Nth last focused topic, or fallback to doing nothing.+shiftNthLastFocused :: Int -> X ()+shiftNthLastFocused n = do+  ws <- fmap (listToMaybe . drop n) getLastFocusedTopics+  whenJust ws $ windows . W.shift++-- | Returns the directory associated with current topic returns the empty string otherwise.+currentTopicDir :: TopicConfig -> X String+currentTopicDir tg = do+  topic <- gets (W.tag . W.workspace . W.current . windowset)+  return . fromMaybe "" . M.lookup topic $ topicDirs tg++-- | Check the given topic configuration for duplicates topics or undefined topics.+checkTopicConfig :: [Topic] -> TopicConfig -> IO ()+checkTopicConfig tags tg = do+    -- tags <- gets $ map W.tag . workspaces . windowset++    let+      seenTopics = nub $ sort $ M.keys (topicDirs tg) ++ M.keys (topicActions tg)+      dups       = tags \\ nub tags+      diffTopic  = seenTopics \\ sort tags+      check lst msg = unless (null lst) $ xmessage $ msg ++ " (tags): " ++ show lst++    check diffTopic "Seen but missing topics/workspaces"+    check dups      "Duplicate topics/workspaces"++-- | Display the given message using the @xmessage@ program.+xmessage :: String -> IO ()+xmessage s = do+  h <- spawnPipe "xmessage -file -"+  hPutStr h s+  hClose h

@@ -0,0 +1,61 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  XMonad.Actions.UpdateFocus+-- Copyright   :  (c) Daniel Schoepe+-- License     :  BSD3-style (see LICENSE)+--+-- Maintainer  :  Daniel Schoepe <asgaroth_@gmx.de>+-- Stability   :  unstable+-- Portability :  unportable+--+-- Updates the focus on mouse move in unfocused windows.+--+-----------------------------------------------------------------------------++module XMonad.Actions.UpdateFocus (+    -- * Usage+    -- $usage+    focusOnMouseMove,+    adjustEventInput+) where++import XMonad+import qualified XMonad.StackSet as W+import Graphics.X11.Xlib.Extras+import Control.Monad (when)+import Data.Monoid++-- $usage+-- To make the focus update on mouse movement within an unfocused window, add the+-- following to your @~\/.xmonad\/xmonad.hs@:+--+-- > import XMonad.Actions.UpdateFocus+-- > xmonad $ defaultConfig {+-- >   ..+-- >   startupHook = adjustEventInput+-- >   handleEventHook = focusOnMouseMove+-- >   ..+-- > }+--+-- This module is probably only useful when focusFollowsMouse is set to True(default).++-- | Changes the focus if the mouse is moved within an unfocused window.+focusOnMouseMove :: Event -> X All+focusOnMouseMove (MotionEvent { ev_x = x, ev_y = y, ev_window = root }) = do+    -- check only every 15 px to avoid excessive calls to translateCoordinates+    when (x `mod` 15 == 0 || y `mod` 15 == 0) $ do+      dpy <- asks display+      Just foc <- withWindowSet $ return . W.peek+      -- get the window under the pointer:+      (_,_,_,w) <- io $ translateCoordinates dpy root root (fromIntegral x) (fromIntegral y)+      when (foc /= w) $ focus w+    return (All True)+focusOnMouseMove _ = return (All True)++-- | Adjusts the event mask to pick up pointer movements.+adjustEventInput :: X ()+adjustEventInput = withDisplay $ \dpy -> do+  rootw <- asks theRoot+  io $ selectInput dpy rootw $  substructureRedirectMask .|. substructureNotifyMask+                                .|. enterWindowMask .|. leaveWindowMask .|. structureNotifyMask+                                .|. buttonPressMask .|. pointerMotionMask

@@ -3,7 +3,7 @@ -- Module      :  XMonadContrib.UpdatePointer -- Copyright   :  (c) Robert Marlow <robreim@bobturf.org> -- License     :  BSD3-style (see LICENSE)--- +-- -- Maintainer  :  Robert Marlow <robreim@bobturf.org> -- Stability   :  stable -- Portability :  portable@@ -14,7 +14,7 @@ -- ----------------------------------------------------------------------------- -module XMonad.Actions.UpdatePointer +module XMonad.Actions.UpdatePointer     (      -- * Usage      -- $usage@@ -25,7 +25,8 @@  import XMonad import Control.Monad-import XMonad.StackSet (member)+import XMonad.StackSet (member, peek, screenDetail, current)+import Data.Maybe  -- $usage -- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:@@ -34,9 +35,9 @@ -- > import XMonad.Actions.UpdatePointer -- -- Enable it by including it in your logHook definition. Eg:--- +-- -- > logHook = updatePointer Nearest--- +-- -- which will move the pointer to the nearest point of a newly focused window, or -- -- > logHook = updatePointer (Relative 0.5 0.5)@@ -50,43 +51,55 @@ -- -- which moves the pointer to the bottom-right corner of the focused window. -data PointerPosition = Nearest | Relative Rational Rational+data PointerPosition = Nearest | Relative Rational Rational | TowardsCentre Rational Rational+    deriving (Read,Show)  -- | Update the pointer's location to the currently focused--- window unless it's already there, or unless the user was changing+-- window or empty screen unless it's already there, or unless the user was changing -- focus with the mouse updatePointer :: PointerPosition -> X ()-updatePointer p = withFocused $ \w -> do+updatePointer p = do   ws <- gets windowset   dpy <- asks display+  rect <- case peek ws of+        Nothing -> return $ (screenRect . screenDetail .current) ws+        Just w  -> windowAttributesToRectangle `fmap` io (getWindowAttributes dpy w)   root <- asks theRoot   mouseIsMoving <- asks mouseFocused-  wa <- io $ getWindowAttributes dpy w   (_sameRoot,_,currentWindow,rootx,rooty,_,_,_) <- io $ queryPointer dpy root-  unless (pointWithinRegion rootx rooty (wa_x wa) (wa_y wa) (wa_width wa) (wa_height wa)+  drag <- gets dragging+  unless (pointWithin (fi rootx) (fi rooty) rect           || mouseIsMoving-          || not (currentWindow `member` ws)) $+          || isJust drag+          || not (currentWindow `member` ws || currentWindow == none)) $     case p of     Nearest -> do-      let x = moveWithin rootx (wa_x wa) ((wa_x wa) + (wa_width  wa))-      let y = moveWithin rooty (wa_y wa) ((wa_y wa) + (wa_height wa))-      io $ warpPointer dpy none root 0 0 0 0 (fromIntegral x) (fromIntegral y)+      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 w 0 0 0 0-           (fraction h (wa_width wa)) (fraction v (wa_height wa))+      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) -moveWithin :: Integral a => a -> a -> a -> a-moveWithin current lower upper =-    if current < lower+windowAttributesToRectangle :: WindowAttributes -> Rectangle+windowAttributesToRectangle wa = Rectangle (fi (wa_x wa))     (fi (wa_y wa))+                                           (fi (wa_width wa)) (fi (wa_height wa))+moveWithin :: Ord a => a -> a -> a -> a+moveWithin now lower upper =+    if now < lower     then lower-    else if current > upper+    else if now > upper          then upper-         else current+         else now --- Test that a point resides within a region. --- This belongs somewhere more generally accessible than this module.-pointWithinRegion :: Integral a => a -> a -> a -> a -> a -> a -> Bool-pointWithinRegion px py rx ry rw rh =-    within px rx (rx + rw) && within py ry (ry + rh)-    where within x left right = x >= left && x <= right+fi :: (Num b, Integral a) => a -> b+fi = fromIntegral

@@ -16,6 +16,7 @@                            -- * Usage                            -- $usage                            banish,+                           banishScreen,                            Corner(..),                            warpToScreen,                            warpToWindow@@ -33,11 +34,11 @@  then add appropriate keybindings to warp the pointer; for example: -> , ((modMask x,   xK_z     ), warpToWindow (1%2) (1%2)) -- @@ Move pointer to currently focused window+> , ((modm,   xK_z     ), warpToWindow (1%2) (1%2)) -- @@ Move pointer to currently focused window > >-- mod-ctrl-{w,e,r} @@ Move mouse pointer to screen 1, 2, or 3 >->   [((modMask x .|. controlMask, key), warpToScreen sc (1%2) (1%2))+>   [((modm .|. controlMask, key), warpToScreen sc (1%2) (1%2)) >       | (key, sc) <- zip [xK_w, xK_e, xK_r] [0..]]  Note that warping to a particular screen may change the focus.@@ -49,7 +50,7 @@  data Corner = UpperLeft | UpperRight | LowerLeft | LowerRight -{- | Move the mouse cursor to a corner of the screen. Useful for+{- | Move the mouse cursor to a corner of the focused window. Useful for    uncluttering things.     Internally, this uses numerical parameters. We parametrize on the 'Corner'@@ -64,7 +65,22 @@                      LowerRight -> warpToWindow 1 1                      LowerLeft  -> warpToWindow 0 1                      UpperLeft  -> warpToWindow 0 0-                     UpperRight  -> warpToWindow 1 0+                     UpperRight -> warpToWindow 1 0++{- | Same as 'banish' but moves the mouse to the corner of the+   currently focused screen -}+banishScreen :: Corner -> X ()+banishScreen direction = case direction of+                           LowerRight -> warpToCurrentScreen 1 1+                           LowerLeft  -> warpToCurrentScreen 0 1+                           UpperLeft  -> warpToCurrentScreen 0 0+                           UpperRight -> warpToCurrentScreen 1 0+    where+      warpToCurrentScreen h v =+          do ws <- gets windowset+             warpToScreen (W.screen $ current ws) h v+             windows (const ws)+  fraction :: (Integral a, Integral b) => Rational -> a -> b fraction f x = floor (f * fromIntegral x)

@@ -5,7 +5,7 @@ -- License     :  BSD-style (see LICENSE) -- -- Maintainer  :  Devin Mullins <me@twifkak.com>--- Stability   :  unstable+-- Stability   :  stable -- Portability :  unportable -- -- dmenu operations to bring windows to you, and bring you to windows.@@ -15,11 +15,11 @@ -----------------------------------------------------------------------------  module XMonad.Actions.WindowBringer (-                                    -- * Usage-                                    -- $usage-                                    gotoMenu, bringMenu, windowMap,-                                    bringWindow-                                   ) where+                    -- * Usage+                    -- $usage+                    gotoMenu, gotoMenu', bringMenu, windowMap,+                    bringWindow+                   ) where  import Data.Char (toLower) import qualified Data.Map as M@@ -27,7 +27,7 @@ import qualified XMonad.StackSet as W import XMonad import qualified XMonad as X-import XMonad.Util.Dmenu (dmenuMap)+import XMonad.Util.Dmenu (menuMap) import XMonad.Util.NamedWindows (getName)  -- $usage@@ -38,8 +38,8 @@ -- -- and define appropriate key bindings: ----- > , ((modMask x .|. shiftMask, xK_g     ), gotoMenu)--- > , ((modMask x .|. shiftMask, xK_b     ), bringMenu)+-- > , ((modm .|. shiftMask, xK_g     ), gotoMenu)+-- > , ((modm .|. shiftMask, xK_b     ), bringMenu) -- -- For detailed instructions on editing your key bindings, see -- "XMonad.Doc.Extending#Editing_key_bindings".@@ -50,6 +50,9 @@ gotoMenu :: X () gotoMenu = actionMenu W.focusWindow +gotoMenu' :: String -> X ()+gotoMenu' menuCmd = actionMenu' menuCmd W.focusWindow+ -- | Pops open a dmenu with window titles. Choose one, and it will be --   dragged, kicking and screaming, into your current workspace. bringMenu :: X ()@@ -57,12 +60,18 @@  -- | Brings the specified window into the current workspace. bringWindow :: Window -> X.WindowSet -> X.WindowSet-bringWindow w ws = W.shiftWin (W.tag . W.workspace . W.current $ ws) w ws+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 :: (Window -> X.WindowSet -> X.WindowSet) -> X()-actionMenu action = windowMap >>= dmenuMap >>= flip X.whenJust (windows . action)+actionMenu action = actionMenu' "dmenu" action++actionMenu' :: String -> (Window -> X.WindowSet -> X.WindowSet) -> X()+actionMenu' menuCmd action = windowMap >>= menuMapFunction >>= flip X.whenJust (windows . action)+    where+      menuMapFunction :: M.Map String a -> X (Maybe a)+      menuMapFunction selectionMap = menuMap menuCmd selectionMap  -- | A map from window names to Windows. windowMap :: X (M.Map String Window)

@@ -24,17 +24,27 @@                   raiseBrowser,                  raiseEditor,+                 runOrRaiseAndDo,+                 runOrRaiseMaster,+                 raiseAndDo,+                 raiseMaster,++                 ifWindows,+                 ifWindow,+                 raiseHook,                  module XMonad.ManageHook                 ) where -import Control.Monad (filterM)+import Control.Monad import Data.Char (toLower)--import XMonad (Query(), X(), withWindowSet, spawn, runQuery, liftIO, focus)+import Data.Monoid+import XMonad (Query(), X(), ManageHook, 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)-+import qualified XMonad.StackSet as W (allWindows, peek, swapMaster, focusWindow)+import XMonad.Util.Run (safeSpawnProg) {- $usage  Import the module into your @~\/.xmonad\/xmonad.hs@:@@ -43,8 +53,8 @@  and define appropriate key bindings: -> , ((modMask x .|. shiftMask, xK_g), raise (className =? "Firefox"))-> , ((modMask x .|. shiftMask, xK_b), runOrRaise "firefox" (className =? "Firefox"))+> , ((modm .|. shiftMask, xK_g), raise (className =? "Firefox"))+> , ((modm .|. shiftMask, xK_b), runOrRaise "firefox" (className =? "Firefox"))  (Note that Firefox v3 and up have a class-name of \"Firefox\" and \"Navigator\"; lower versions use other classnames such as \"Firefox-bin\". Either choose the@@ -54,20 +64,35 @@ For detailed instructions on editing your key bindings, see "XMonad.Doc.Extending#Editing_key_bindings". -} --- | 'action' is an executable to be run via 'spawn' (of "XMonad.Core") if the Window cannot be found.+-- | 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+  case matches of+    [] -> el+    ws -> f ws++-- | The same as ifWindows, but applies a ManageHook to the first match+-- instead and discards the other matches+ifWindow :: Query Bool -> ManageHook -> X () -> X ()+ifWindow qry mh = ifWindows qry (windows . appEndo <=< runQuery mh . head)++-- | 'action' is an executable to be run via 'safeSpawnProg' (of "XMonad.Util.Run") if the Window cannot be found. --   Presumably this executable is the same one that you were looking for. runOrRaise :: String -> Query Bool -> X ()-runOrRaise action = raiseMaybe $ spawn action+runOrRaise = raiseMaybe . safeSpawnProg  -- | See 'raiseMaybe'. If the Window can't be found, quietly give up and do nothing. raise :: Query Bool -> X () raise = raiseMaybe $ return ()  {- | 'raiseMaybe' queries all Windows based on a boolean provided by the-   user. Currently, there are three such useful booleans defined in-   "XMonad.ManageHook": title, resource, className. Each one tests based pretty+   user. Currently, there are 3 such useful booleans defined in+   "XMonad.ManageHook": 'title', 'resource', 'className'. Each one tests based pretty    much as you would think. ManageHook also defines several operators, the most-   useful of which is (=?). So a useful test might be finding a Window whose+   useful of which is (=?). So a useful test might be finding a @Window@ whose    class is Firefox. Firefox 3 declares the class \"Firefox\", so you'd want to    pass in a boolean like @(className =? \"Firefox\")@. @@ -90,15 +115,15 @@   > , ((modm, xK_m), raiseMaybe (runInTerm "-title mutt" "mutt") (title =? "mutt")) -} raiseMaybe :: X () -> Query Bool -> X ()-raiseMaybe f thatUserQuery = withWindowSet $ \s -> do-    maybeResult <- filterM (runQuery thatUserQuery) (W.allWindows s)-    case maybeResult of-      []     -> f-      (x:_)  -> focus x+raiseMaybe f qry = ifWindow qry raiseHook f +-- | A manage hook that raises the window.+raiseHook :: ManageHook+raiseHook = ask >>= doF . W.focusWindow+ -- | See 'runOrRaise' and 'raiseNextMaybe'. Version that allows cycling through matches. runOrRaiseNext :: String -> Query Bool -> X ()-runOrRaiseNext action = raiseNextMaybe $ spawn action+runOrRaiseNext = raiseNextMaybe . safeSpawnProg  -- | See 'raise' and 'raiseNextMaybe'. Version that allows cycling through matches. raiseNext :: Query Bool -> X ()@@ -110,18 +135,14 @@      query the next matching window is raised. If no matches are found      the function f is executed. -}+ raiseNextMaybe :: X () -> Query Bool -> X ()-raiseNextMaybe f thatUserQuery = withWindowSet $ \s -> do-  ws <- filterM (runQuery thatUserQuery) (W.allWindows s)-  case ws of-    []    -> f-    (x:_) -> let go (Just w) | (w `elem` ws) = next w $ cycle ws-                 go _ = focus x-             in go $ W.peek s-  where-    next w (x:y:_) | x==w = focus y-    next w (_:xs)         = next w xs-    next _ _ = error "raiseNextMaybe: empty list"+raiseNextMaybe 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  -- | 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.@@ -130,7 +151,34 @@  {- | 'raiseBrowser' and 'raiseEditor' grab $BROWSER and $EDITOR respectively and they either      take you to the specified program's window, or they try to run it. This is most useful-     if your variables are simple and look like 'firefox' or 'emacs'. -}+     if your variables are simple and look like \"firefox\" or \"emacs\". -} raiseBrowser, raiseEditor :: X () raiseBrowser = raiseVar getBrowser raiseEditor  = raiseVar getEditor++{- | If the window is found the window is focused and the third argument is called+     otherwise, the first argument is called+     See 'raiseMaster' for an example. -}+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 arugment 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++{- | if the window is found the window is focused and set to master+     otherwise, the first argument is called.++     > raiseMaster (runInTerm \"-title ghci\"  \"zsh -c \'ghci\'\") (title =? \"ghci\") -}+raiseMaster :: X () -> Query Bool -> X ()+raiseMaster raisef thatUserQuery = raiseAndDo raisef thatUserQuery (\_ -> windows W.swapMaster)++{- |  If the window is found the window is focused and set to master+      otherwise, action is run.++      > runOrRaiseMaster \"firefox\" (className =? \"Firefox\"))+  -}+runOrRaiseMaster :: String -> Query Bool -> X ()+runOrRaiseMaster run query = runOrRaiseAndDo run query (\_ -> windows W.swapMaster)

@@ -0,0 +1,71 @@+----------------------------------------------------------------------------+-- |+-- Module      :  XMonad.Actions.WindowMenu+-- Copyright   :  (c) Jan Vornberger 2009+-- License     :  BSD3-style (see LICENSE)+--+-- Maintainer  :  jan.vornberger@informatik.uni-oldenburg.de+-- Stability   :  unstable+-- Portability :  not portable+--+-- Uses "XMonad.Actions.GridSelect" to display a number of actions related to+-- window management in the center of the focused window. Actions include: Closing,+-- maximizing, minimizing and shifting the window to another workspace.+--+-- Note: For maximizing and minimizing to actually work, you will need+-- to integrate "XMonad.Layout.Maximize" and "XMonad.Layout.Minimize" into your+-- setup.  See the documentation of those modules for more information.+--+-----------------------------------------------------------------------------++module XMonad.Actions.WindowMenu (+                             -- * Usage+                             -- $usage+                             windowMenu+                              ) where++import XMonad+import qualified XMonad.StackSet as W+import XMonad.Actions.GridSelect+import XMonad.Layout.Maximize+import XMonad.Layout.Minimize+import XMonad.Util.XUtils (fi)++-- $usage+--+-- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:+--+-- >    import XMonad.Actions.WindowMenu+--+-- Then add a keybinding, e.g.+--+-- >    , ((modm,               xK_o ), windowMenu)++windowMenu :: X ()+windowMenu = withFocused $ \w -> do+    tags <- asks (workspaces . config)+    Rectangle x y wh ht <- getSize w+    Rectangle sx sy swh sht <- gets $ screenRect . W.screenDetail . W.current . windowset+    let originFractX = (fi x - fi sx + fi wh / 2) / fi swh+        originFractY = (fi y - fi sy + fi ht / 2) / fi sht+        gsConfig = defaultGSConfig+                    { gs_originFractX = originFractX+                    , gs_originFractY = originFractY }+        actions = [ ("Cancel menu", return ())+                  , ("Close"      , kill)+                  , ("Maximize"   , sendMessage $ maximizeRestore w)+                  , ("Minimize"   , sendMessage $ MinimizeWin w)+                  ] +++                  [ ("Move to " ++ tag, windows $ W.shift tag)+                    | tag <- tags ]+    runSelectedAction gsConfig actions++getSize :: Window -> X (Rectangle)+getSize w = do+  d  <- asks display+  wa <- io $ getWindowAttributes d w+  let x = fi $ wa_x wa+      y = fi $ wa_y wa+      wh = fi $ wa_width wa+      ht = fi $ wa_height wa+  return (Rectangle x y wh ht)

@@ -5,6 +5,8 @@ --                          Devin Mullins <me@twifkak.com> -- Maintainer  :  Devin Mullins <me@twifkak.com> -- License     :  BSD3-style (see LICENSE)+-- Stability   :  unstable+-- Portability :  unportable -- -- This is a rewrite of "XMonad.Layout.WindowNavigation".  WindowNavigation -- lets you assign keys to move up\/down\/left\/right, based on actual cartesian@@ -34,11 +36,11 @@                                        withWindowNavigationKeys,                                        WNAction(..),                                        go, swap,-                                       Direction(..)+                                       Direction2D(..)                                        ) where  import XMonad-import XMonad.Hooks.ManageDocks (Direction(..))+import XMonad.Util.Types (Direction2D(..)) import qualified XMonad.StackSet as W  import Control.Applicative ((<$>))@@ -84,15 +86,15 @@ --  - manageHook to draw window decos?  withWindowNavigation :: (KeySym, KeySym, KeySym, KeySym) -> XConfig l -> IO (XConfig l)-withWindowNavigation (u,l,d,r) conf =-    withWindowNavigationKeys [ ((modMask conf              , u), WNGo   U),-                               ((modMask conf              , l), WNGo   L),-                               ((modMask conf              , d), WNGo   D),-                               ((modMask conf              , r), WNGo   R),-                               ((modMask conf .|. shiftMask, u), WNSwap U),-                               ((modMask conf .|. shiftMask, l), WNSwap L),-                               ((modMask conf .|. shiftMask, d), WNSwap D),-                               ((modMask conf .|. shiftMask, r), WNSwap R) ]+withWindowNavigation (u,l,d,r) conf@XConfig{modMask=modm} =+    withWindowNavigationKeys [ ((modm              , u), WNGo   U),+                               ((modm              , l), WNGo   L),+                               ((modm              , d), WNGo   D),+                               ((modm              , r), WNGo   R),+                               ((modm .|. shiftMask, u), WNSwap U),+                               ((modm .|. shiftMask, l), WNSwap L),+                               ((modm .|. shiftMask, d), WNSwap D),+                               ((modm .|. shiftMask, r), WNSwap R) ]                              conf  withWindowNavigationKeys :: [((KeyMask, KeySym), WNAction)] -> XConfig l -> IO (XConfig l)@@ -104,7 +106,7 @@   where fromWNAction posRef (WNGo dir)   = go   posRef dir         fromWNAction posRef (WNSwap dir) = swap posRef dir -data WNAction = WNGo Direction | WNSwap Direction+data WNAction = WNGo Direction2D | WNSwap Direction2D  type WNState = Map WorkspaceId Point @@ -113,10 +115,10 @@ -- 2. get target windowrect -- 3. focus window -- 4. set new position-go :: IORef WNState -> Direction -> X ()+go :: IORef WNState -> Direction2D -> X () go = withTargetWindow W.focusWindow -swap :: IORef WNState -> Direction -> X ()+swap :: IORef WNState -> Direction2D -> X () swap = withTargetWindow swapWithFocused   where swapWithFocused targetWin winSet =             case W.peek winSet of@@ -128,7 +130,7 @@         mapWindows'' f (W.Stack focused up down) = W.Stack (f focused) (map f up) (map f down)         swapWin win1 win2 win = if win == win1 then win2 else if win == win2 then win1 else win -withTargetWindow :: (Window -> WindowSet -> WindowSet) -> IORef WNState -> Direction -> X ()+withTargetWindow :: (Window -> WindowSet -> WindowSet) -> IORef WNState -> Direction2D -> X () withTargetWindow adj posRef dir = fromCurrentPoint posRef $ \win pos -> do     targets <- filter ((/= win) . fst) <$> navigableTargets pos dir     whenJust (listToMaybe targets) $ \(targetWin, targetRect) -> do@@ -153,7 +155,7 @@     currentWindow <- gets (W.peek . windowset)     currentRect <- maybe (Rectangle 0 0 0 0) snd <$> windowRect (fromMaybe root currentWindow) -    wsid <- gets (W.tag . W.workspace . W.current . windowset)+    wsid <- gets (W.currentTag . windowset)     mp <- M.lookup wsid <$> io (readIORef posRef)      return $ maybe (middleOf currentRect) (`inside` currentRect) mp@@ -162,7 +164,7 @@  setPosition :: IORef WNState -> Point -> Rectangle -> X () setPosition posRef oldPos newRect = do-    wsid <- gets (W.tag . W.workspace . W.current . windowset)+    wsid <- gets (W.currentTag . windowset)     io $ modifyIORef posRef $ M.insert wsid (oldPos `inside` newRect)  inside :: Point -> Rectangle -> Point@@ -175,12 +177,12 @@ midPoint :: Position -> Dimension -> Position midPoint pos dim = pos + fromIntegral dim `div` 2 -navigableTargets :: Point -> Direction -> X [(Window, Rectangle)]+navigableTargets :: Point -> Direction2D -> X [(Window, Rectangle)] navigableTargets point dir = navigable dir point <$> windowRects  -- Filters and sorts the windows in terms of what is closest from the Point in--- the Direction.-navigable :: Direction -> Point -> [(Window, Rectangle)] -> [(Window, Rectangle)]+-- the Direction2D.+navigable :: Direction2D -> Point -> [(Window, Rectangle)] -> [(Window, Rectangle)] navigable d pt = sortby d . filter (inr d pt . snd)  -- Produces a list of normal-state windows, on any screen. Rectangles are@@ -197,7 +199,7 @@  -- Modified from droundy's implementation of WindowNavigation: -inr :: Direction -> Point -> Rectangle -> Bool+inr :: Direction2D -> Point -> Rectangle -> Bool inr D (Point px py) (Rectangle rx ry w h) = px >= rx && px < rx + fromIntegral w &&                                                         py < ry + fromIntegral h inr U (Point px py) (Rectangle rx ry w _) = px >= rx && px < rx + fromIntegral w &&@@ -207,7 +209,7 @@ inr L (Point px py) (Rectangle rx ry w h) =             px > rx + fromIntegral w &&                                             py >= ry && py < ry + fromIntegral h -sortby :: Direction -> [(a,Rectangle)] -> [(a,Rectangle)]+sortby :: Direction2D -> [(a,Rectangle)] -> [(a,Rectangle)] sortby D = sortBy $ comparing (rect_y . snd) sortby R = sortBy $ comparing (rect_x . snd) sortby U = reverse . sortby D

@@ -0,0 +1,54 @@+-----------------------------------------------------------------------------+-- |+-- Module       : XMonad.Actions.WithAll+-- License      : BSD3-style (see LICENSE)+-- Stability    : unstable+-- Portability  : unportable+--+-- Provides functions for performing a given action on all windows of+-- the current workspace.+-----------------------------------------------------------------------------++module XMonad.Actions.WithAll (+    -- * Usage+    -- $usage+    sinkAll, withAll,+    withAll', killAll) where++import Data.Foldable hiding (foldr)++import XMonad+import XMonad.Core+import XMonad.Operations+import XMonad.StackSet++-- $usage+--+-- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:+--+-- > import XMonad.Actions.WithAll+--+-- then add a keybinding; for example:+--+--     , ((modm .|. shiftMask, xK_t), sinkAll)+--+-- For detailed instructions on editing your key bindings, see+-- "XMonad.Doc.Extending#Editing_key_bindings".++-- | Un-float all floating windows on the current workspace.+sinkAll :: X ()+sinkAll = withAll' sink++-- | Apply a function to all windows on the current workspace.+withAll' :: (Window -> WindowSet -> WindowSet) -> X ()+withAll' f = windows $ \ws -> let all' = integrate' . stack . workspace . current $ ws+                              in foldr f ws all'++-- | Execute an 'X' action for each window on the current workspace.+withAll :: (Window -> X ()) -> X()+withAll f = withWindowSet $ \ws -> let all' = integrate' . stack . workspace . current $ ws+                                   in forM_ all' f++-- | Kill all the windows on the current workspace.+killAll :: X()+killAll = withAll killWindow

@@ -0,0 +1,219 @@+{-# LANGUAGE DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+-----------------------------------------------------------------------------+-- |+-- Module       : XMonad.Actions.WorkspaceCursors+-- Copyright    : (c) 2009 Adam Vogt <vogt.adam@gmail.com>+-- License      : BSD+--+-- Maintainer   : Adam Vogt+-- Stability    : unstable+-- Portability  : unportable+--+-- Like "XMonad.Actions.Plane" for an arbitrary number of dimensions.+-----------------------------------------------------------------------------++module XMonad.Actions.WorkspaceCursors+    (+    -- * Usage+    -- $usage++     focusDepth+    ,makeCursors+    ,toList+    ,workspaceCursors++    ,WorkspaceCursors+    ,getFocus++    -- * Modifying the focus+    ,modifyLayer+    ,modifyLayer'+    ,shiftModifyLayer,shiftLayer++    -- * Functions to pass to 'modifyLayer'+    ,focusNth'+    ,noWrapUp,noWrapDown++    -- * Todo+    -- $todo+    ) where++import qualified XMonad.StackSet as W++import XMonad.Actions.FocusNth(focusNth')+import XMonad.Layout.LayoutModifier(ModifiedLayout(..),+                                    LayoutModifier(handleMess, redoLayout))+import XMonad(Typeable, Message, WorkspaceId, X, XState(windowset),+              fromMessage, sendMessage, windows, gets)+import Control.Monad((<=<), guard, liftM, liftM2, when)+import Control.Applicative((<$>))+import Data.Foldable(Foldable(foldMap), toList)+import Data.Maybe(fromJust, listToMaybe)+import Data.Monoid(Monoid(mappend, mconcat))+import Data.Traversable(sequenceA)++-- $usage+--+-- Here is an example config:+--+-- > import XMonad+-- > import XMonad.Actions.WorkspaceCursors+-- > import XMonad.Hooks.DynamicLog+-- > import XMonad.Util.EZConfig+-- > import qualified XMonad.StackSet as W+-- >+-- > main = do+-- >     x <- xmobar conf+-- >     xmonad x+-- >+-- > conf = additionalKeysP defaultConfig+-- >        { layoutHook = workspaceCursors myCursors $ layoutHook defaultConfig+-- >        , workspaces = toList myCursors } $+-- >        [("M-"++shift++control++[k], f direction depth)+-- >          | (f,shift) <- zip [modifyLayer,shiftModifyLayer] ["","S-"]+-- >          , (direction,control) <- zip [W.focusUp',W.focusDown'] ["C-",""]+-- >          , (depth,k) <- zip (reverse [1..focusDepth myCursors]) "asdf"]+-- >        ++ moreKeybindings+-- >+-- > moreKeybindings = []+-- >+-- > myCursors = makeCursors $ map (map (\x -> [x])) [ "1234", "abc", "xyz"]+-- > -- myCursors = makeCursors [["wsA","wsB","wsC"],["-alpha-","-beta-","-gamma-"],["x","y"]]+++-- $todo+--+-- * Find and document how to raise the allowable length of arguments:+--   restoring xmonad's state results in: @xmonad: executeFile: resource+--   exhausted (Argument list too long)@ when you specify more than about 50+--   workspaces. Or change it such that workspaces are created when you try to+--   view it.+--+-- * Function for pretty printing for DynamicLog that groups workspaces by+-- common prefixes+--+-- * Examples of adding workspaces to the cursors, having them appear multiple+--   times for being able to show jumping to some n'th multiple workspace++-- | makeCursors requires a nonempty string, and each sublist must be nonempty+makeCursors ::  [[String]] -> Cursors String+makeCursors [] = error "Workspace Cursors cannot be empty"+makeCursors a = concat . reverse <$> foldl addDim x xs+    where x = end $ map return $ head a+          xs = map (map return) $ tail a+          -- this could probably be simplified, but this true:+          -- toList . makeCursors == map (concat . reverse) . sequence . reverse . map (map (:[]))+          -- the strange order is used because it makes the regular M-1..9+          -- bindings change the prefixes first++addDim ::  (Monoid a) => Cursors a -> [a] -> Cursors a+addDim prev prefixes = Cons . fromJust . W.differentiate+            $ map ((<$> prev) . mappend) prefixes++end :: [a] -> Cursors a+end = Cons . fromJust . W.differentiate . map End++data Cursors a+    = Cons (W.Stack (Cursors a))+    | End a deriving (Eq,Show,Read,Typeable)++instance Foldable Cursors where+    foldMap f (End x) = f x+    foldMap f (Cons (W.Stack x y z)) = foldMap f x `mappend` mconcat (map (foldMap f) $ reverse y ++ z)++instance Functor Cursors where+    fmap f (End a) = End $ f a+    fmap f (Cons (W.Stack x y z)) = Cons $ W.Stack (fmap f x) (fmap (fmap f) y) (fmap (fmap f) z)++changeFocus ::  (Cursors t -> Bool) -> Cursors t -> [Cursors t]+changeFocus p (Cons x) = do+    choose <- chFocus p x+    foc    <- changeFocus p $ W.focus choose+    return . Cons $ choose { W.focus = foc }+changeFocus p x = guard (p x) >> return x++chFocus :: (a -> Bool) -> W.Stack a -> [W.Stack a]+chFocus p st = filter (p . W.focus) $ zipWith const (iterate W.focusDown' st) (W.integrate st)++getFocus ::  Cursors b -> b+getFocus (Cons x) = getFocus $ W.focus x+getFocus (End x) = x++-- This could be made more efficient, if the fact that the suffixes are grouped+focusTo ::  (Eq t) => t -> Cursors t -> Maybe (Cursors t)+focusTo x = listToMaybe . filter ((x==) . getFocus) . changeFocus (const True)++-- | non-wrapping version of 'W.focusUp''+noWrapUp ::  W.Stack t -> W.Stack t+noWrapUp (W.Stack t (l:ls) rs) = W.Stack l ls (t:rs)+noWrapUp x@(W.Stack _ []   _ ) = x++-- | non-wrapping version of 'W.focusDown''+noWrapDown ::  W.Stack t -> W.Stack t+noWrapDown = reverseStack . noWrapUp . reverseStack+    where reverseStack (W.Stack t ls rs) = W.Stack t rs ls++focusDepth ::  Cursors t -> Int+focusDepth (Cons x) = 1 + focusDepth (W.focus x)+focusDepth (End  _) = 0++descend :: Monad m =>(W.Stack (Cursors a) -> m (W.Stack (Cursors a)))-> Int-> Cursors a-> m (Cursors a)+descend f 1 (Cons x) = Cons `liftM` f x+descend f n (Cons x) | n > 1 = liftM Cons $ descend f (pred n) `onFocus` x+descend _ _ x = return x++onFocus :: (Monad m) => (a1 -> m a1) -> W.Stack a1 -> m (W.Stack a1)+onFocus f st = (\x -> st { W.focus = x}) `liftM` f (W.focus st)++-- | @modifyLayer@ is used to change the focus at a given depth+modifyLayer :: (W.Stack (Cursors String) -> W.Stack (Cursors String)) -> Int -> X ()+modifyLayer f depth = modifyCursors (descend (return . f) depth)++-- | @shiftModifyLayer@ is the same as 'modifyLayer', but also shifts the+-- currently focused window to the new workspace+shiftModifyLayer :: (W.Stack (Cursors String) -> W.Stack (Cursors WorkspaceId))-> Int-> X ()+shiftModifyLayer f = modifyLayer' $ \st -> do+    let st' = f st+    windows $ W.shift $ getFocus (Cons st')+    return st'++-- | @shiftLayer@ is the same as 'shiftModifyLayer', but the focus remains on+-- the current workspace.+shiftLayer :: (W.Stack (Cursors String) -> W.Stack (Cursors WorkspaceId))-> Int-> X ()+shiftLayer f = modifyLayer' $ \st -> do+    windows $ W.shift $ getFocus $ Cons $ f st+    return st++-- | example usages are 'shiftLayer' and 'shiftModifyLayer'+modifyLayer' :: (W.Stack (Cursors String) -> X (W.Stack (Cursors String))) -> Int -> X ()+modifyLayer' f depth = modifyCursors (descend f depth)++modifyCursors ::  (Cursors String -> X (Cursors String)) -> X ()+modifyCursors = sendMessage . ChangeCursors . (liftM2 (>>) updateXMD return <=<)++data WorkspaceCursors a = WorkspaceCursors (Cursors String)+    deriving (Typeable,Read,Show)++-- | The state is stored in the 'WorkspaceCursors' layout modifier. Put this as+-- your outermost modifier, unless you want different cursors at different+-- times (using "XMonad.Layout.MultiToggle")+workspaceCursors :: Cursors String -> l a -> ModifiedLayout WorkspaceCursors l a+workspaceCursors = ModifiedLayout . WorkspaceCursors++data ChangeCursors = ChangeCursors { unWrap :: Cursors String -> X (Cursors String) }+    deriving (Typeable)++instance Message ChangeCursors++updateXMD ::  Cursors WorkspaceId -> X ()+updateXMD cs = do+    changed <- gets $ (getFocus cs /=) . W.currentTag . windowset+    when changed $ windows $ W.greedyView $ getFocus cs++instance LayoutModifier WorkspaceCursors a where+    redoLayout (WorkspaceCursors cs) _ _ arrs = do+        cws <- gets $ W.currentTag . windowset+        return (arrs,WorkspaceCursors <$> focusTo cws cs)++    handleMess (WorkspaceCursors cs) m =+        sequenceA $ fmap WorkspaceCursors . ($ cs) . unWrap <$> fromMessage m

@@ -90,8 +90,7 @@                                 map show [7 .. 9 :: Int]          , logHook            = myDynLog xmobar -- REMOVE this line if you do not have xmobar installed!          , manageHook         = newManageHook-         , layoutHook         = eventHook ServerMode $-                                avoidStruts $+         , layoutHook         = avoidStruts $                                 decorated        |||                                 noBorders mytabs |||                                 otherLays@@ -99,6 +98,7 @@          , normalBorderColor  = "white"          , focusedBorderColor = "black"          , keys               = newKeys+         , handleEventHook    = serverModeEventHook          , focusFollowsMouse  = False          }     where

@@ -0,0 +1,48 @@+{-# OPTIONS_GHC -fno-warn-missing-signatures #-}++-----------------------------------------------------------------------------+-- |+-- Module       : XMonad.Config.Azerty+-- Copyright    : (c) Devin Mullins <me@twifkak.com>+-- License      : BSD+--+-- Maintainer   : Devin Mullins <me@twifkak.com>+-- Stability    : stable+-- Portability  : unportable+--+-- This module fixes some of the keybindings for the francophone among you who+-- use an AZERTY keyboard layout. Config stolen from TeXitoi's config on the+-- wiki.++module XMonad.Config.Azerty (+    -- * Usage+    -- $usage+    azertyConfig, azertyKeys+    ) 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.Azerty+-- >+-- > main = xmonad azertyConfig+--+-- 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 }++azertyConfig = defaultConfig { keys = \c -> azertyKeys c `M.union` keys defaultConfig c }++azertyKeys 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],+          (f, m) <- [(W.greedyView, 0), (W.shift, shiftMask)]]

@@ -7,31 +7,173 @@ -- License      : BSD -- -- Maintainer   : Spencer Janssen <spencerjanssen@gmail.com>+-- Stability    :  unstable+-- Portability  :  unportable -- -- This module provides a config suitable for use with a desktop -- environment such as KDE or GNOME.-+----------------------------------------------------------------------------- module XMonad.Config.Desktop (++    -- | Several basic integration settings are common to all of xmonad's+    -- desktop integration configurations. The specific desktop environment+    -- (DE) modules like "XMonad.Config.Gnome" use this module's+    -- @desktopConfig@ to set up basic communication between xmonad and+    -- 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@.+    --+    -- For more information about EWMH see:+    --+    -- <http://standards.freedesktop.org/wm-spec/wm-spec-latest.html>+    --+    -- See also: "XMonad.Hooks.EwmhDesktops", "XMonad.Hooks.ManageDocks",+    -- "XMonad.Util.EZConfig".+     -- * Usage-    -- -- $usage+    -- $usage+     desktopConfig,++    -- * Customizing a desktop config+    -- $customizing++    -- ** Modifying layouts, manageHook, or key bindings+    -- $layouts     desktopLayoutModifiers++    -- ** Modifying the logHook+    -- $logHook++    -- ** Modifying the handleEventHook+    -- $eventHook++    -- ** Modifying the startupHook+    -- $startupHook     ) where  import XMonad import XMonad.Config (defaultConfig) import XMonad.Hooks.ManageDocks import XMonad.Hooks.EwmhDesktops+import XMonad.Util.Cursor  import qualified Data.Map as M -desktopConfig = defaultConfig-    { logHook    = ewmhDesktopsLogHook-    , layoutHook = desktopLayoutModifiers $ layoutHook defaultConfig-    , manageHook = manageHook defaultConfig <+> manageDocks-    , keys       = \c -> desktopKeys c `M.union` keys defaultConfig c }+-- $usage+-- While this document describes how to configure xmonad, you also need+-- to set up your Desktop Environment (DE) and display manager to use+-- xmonad as its window manager. For DE and distro specific tips on+-- how to do so, see the xmonad wiki:+--+-- <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@,+-- 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@.+-- If you are using a specific DE config, import its module instead, and+-- use its config in place of @desktopConfig@ in the following examples.+--+-- > import XMonad+-- > import XMonad.Config.Desktop+-- >+-- > main = xmonad desktopConfig+--+-- @desktopConfig@ is an 'XConfig' that configures xmonad to+-- ignore and leave room for dock type windows like panels and trays, adds+-- the default key binding to toggle panel visibility, and activates basic+-- EWMH support. It also sets a prettier root window mouse pointer. +-- $customizing+-- To customize a desktop config, modify its fields as is illustrated with+-- @defaultConfig@ in the \"Extending xmonad\" section of "XMonad.Doc.Extending".++-- $layouts+-- See also "XMonad.Util.EZConfig" for more options for modifying key bindings.+-- To add to layouts, manageHook or key bindings use something like the following+-- to combine your modifications with the desktop config settings:+--+-- > import XMonad+-- > import XMonad.Config.Desktop+-- > import XMonad.Layout.Tabbed+-- > import XMonad.Util.EZConfig (additionalKeys)+-- >+-- > main =+-- >   xmonad $ desktopConfig {+-- >     -- add manage hooks while still ignoring panels and using default manageHooks+-- >       manageHook = myManageHook <+> manageHook desktopConfig+-- >+-- >     -- add a fullscreen tabbed layout that does not avoid covering+-- >     -- up desktop panels before the desktop layouts+-- >     , layoutHook = simpleTabbed ||| layoutHook desktopConfig+-- >     }+-- >     -- add a screenshot key to the default desktop bindings+-- >     `additionalKeys` [ ((mod4Mask, xK_F8), spawn "scrot") ]+--+-- To replace the desktop layouts with your own choices, but still+-- allow toggling panel visibility, use 'desktopLayoutModifiers' to+-- modify your layouts:+--+-- >  , layoutHook = desktopLayoutModifiers $ simpleTabbed ||| Tall 1 0.03 0.5+--+-- @desktopLayoutModifiers@ modifies a layout to avoid covering docks, panels,+-- etc. that set the @_NET_WM_STRUT_PARTIAL@ property.+-- See also "XMonad.Hooks.ManageDocks".++-- $logHook+-- To add to the logHook while still sending workspace and window information+-- to DE apps use something like:+--+-- >  , logHook = myLogHook >> logHook desktopConfig+--+-- Or for more elaborate logHooks you can use @do@:+--+-- >  , logHook = do+-- >        dynamicLogWithPP xmobarPP+-- >        updatePointer (Relative 0.9 0.9)+-- >        logHook desktopConfig+--++-- $eventHook+-- To customize xmonad's event handling while still having it respond+-- to EWMH events from pagers, task bars, etc. add to your imports:+--+-- > import Data.Monoid+--+-- and use 'Data.Monoid.mappend' to combine event hooks (right to left application like @\<+\>@)+--+-- >  , handleEventHook = mappend myEventHooks (handleEventHook desktopConfig)+--+-- or 'Data.Monoid.mconcat' (like @composeAll@)+--+-- >  , handleEventHook = mconcat+-- >        [ myMouseHandler+-- >        , myMessageHandler+-- >        , handleEventHook desktopConfig ]+--++-- $startupHook+-- To run the desktop startupHook, plus add further actions to be run each+-- time xmonad starts or restarts, use '>>' to combine actions as in the+-- logHook example, or something like:+--+-- >  , startupHook = do+-- >        startupHook desktopConfig+-- >        spawn "xmonad-restart.sh"+-- >        adjustEventInput+--++desktopConfig = ewmh defaultConfig+    { startupHook     = setDefaultCursor xC_left_ptr+    , layoutHook      = desktopLayoutModifiers $ layoutHook defaultConfig+    , manageHook      = manageHook defaultConfig <+> manageDocks+    , keys            = \c -> desktopKeys c `M.union` keys defaultConfig c }+ desktopKeys (XConfig {modMask = modm}) = M.fromList $     [ ((modm, xK_b), sendMessage ToggleStruts) ] -desktopLayoutModifiers layout = avoidStruts $ ewmhDesktopsLayout layout+desktopLayoutModifiers layout = avoidStruts layout+

@@ -22,7 +22,7 @@ import XMonad.Layout.Named ( named ) import XMonad.Layout.LayoutCombinators import XMonad.Layout.Square ( Square(Square) )-import XMonad.Layout.WindowNavigation ( Navigate(Move,Swap,Go), Direction(U,D,R,L),+import XMonad.Layout.WindowNavigation ( Navigate(Move,Swap,Go), Direction2D(U,D,R,L),                                         windowNavigation ) import XMonad.Layout.BoringWindows ( boringWindows, markBoring, clearBoring,                                      focusUp, focusDown )@@ -40,11 +40,10 @@ import XMonad.Actions.DynamicWorkspaces ( withNthWorkspace, withWorkspace,                                           selectWorkspace, renameWorkspace, removeWorkspace ) import XMonad.Actions.CycleWS ( moveTo, WSType( HiddenNonEmptyWS ),-                                WSDirection( Prev, Next) )+                                Direction1D( Prev, Next) )  import XMonad.Hooks.ManageDocks ( avoidStruts, manageDocks )-import XMonad.Hooks.EwmhDesktops ( ewmhDesktopsLogHook,-                                   ewmhDesktopsLayout )+import XMonad.Hooks.EwmhDesktops ( ewmh )  myXPConfig :: XPConfig myXPConfig = defaultXPConfig {font="-*-lucida-medium-r-*-*-14-*-*-*-*-*-*-*"@@ -95,7 +94,7 @@     , ((modMask x .|. controlMask .|. shiftMask, xK_Left), sendMessage $ Move L)     , ((modMask x .|. controlMask .|. shiftMask, xK_Up), sendMessage $ Move U)     , ((modMask x .|. controlMask .|. shiftMask, xK_Down), sendMessage $ Move D)- +     , ((0, xK_F2  ), spawn "gnome-terminal") -- %! Launch gnome-terminal     , ((0, xK_F3  ), shellPrompt myXPConfig) -- %! Launch program     , ((0, xK_F11   ), spawn "ksnapshot") -- %! Take snapshot@@ -112,16 +111,16 @@     , ((modMask x, xK_space), sendMessage Toggle)      ]- +     ++     zip (zip (repeat $ modMask x) [xK_F1..xK_F12]) (map (withNthWorkspace W.greedyView) [0..])     ++     zip (zip (repeat (modMask x .|. shiftMask)) [xK_F1..xK_F12]) (map (withNthWorkspace copy) [0..]) -config = defaultConfig+config = ewmh defaultConfig          { borderWidth = 1 -- Width of the window border in pixels.          , XMonad.workspaces = ["mutt","iceweasel"]-         , layoutHook = ewmhDesktopsLayout $ showWName $ workspaceDir "~" $+         , layoutHook = showWName $ workspaceDir "~" $                         boringWindows $ smartBorders $ windowNavigation $                         maximizeVertical $ toggleLayouts Full $ avoidStruts $                         named "tabbed" mytab |||@@ -131,7 +130,6 @@                                                 ****//* combineTwo Square mytab mytab) --   |||                         --mosaic 0.25 0.5          , manageHook = manageHook defaultConfig <+> manageDocks -- add panel-handling-         , logHook = ewmhDesktopsLogHook -- actually, no logging here, just other stuff          , terminal = "xterm" -- The preferred terminal program.          , normalBorderColor = "#222222" -- Border color for unfocused windows.          , focusedBorderColor = "#00ff00" -- Border color for focused windows.@@ -142,12 +140,12 @@ mytab = tabbed CustomShrink defaultTheme  instance Shrinker CustomShrink where-    shrinkIt shr s | Just s' <- dropFromHead " " s = shrinkIt shr s' -    shrinkIt shr s | Just s' <- dropFromTail " " s = shrinkIt shr s' -    shrinkIt shr s | Just s' <- dropFromTail "- Iceweasel" s = shrinkIt shr s' -    shrinkIt shr s | Just s' <- dropFromTail "- KPDF" s = shrinkIt shr s' -    shrinkIt shr s | Just s' <- dropFromHead "file://" s = shrinkIt shr s' -    shrinkIt shr s | Just s' <- dropFromHead "http://" s = shrinkIt shr s' +    shrinkIt shr s | Just s' <- dropFromHead " " s = shrinkIt shr s'+    shrinkIt shr s | Just s' <- dropFromTail " " s = shrinkIt shr s'+    shrinkIt shr s | Just s' <- dropFromTail "- Iceweasel" s = shrinkIt shr s'+    shrinkIt shr s | Just s' <- dropFromTail "- KPDF" s = shrinkIt shr s'+    shrinkIt shr s | Just s' <- dropFromHead "file://" s = shrinkIt shr s'+    shrinkIt shr s | Just s' <- dropFromHead "http://" s = shrinkIt shr s'     shrinkIt _ s | n > 9 = s : map cut [2..(halfn-3)] ++ shrinkIt shrinkText s                  where n = length s                        halfn = n `div` 2@@ -176,7 +174,7 @@                       s { windowset = until ((Just w ==) . W.peek)                                       W.focusUp $ windowset s }                   | otherwise =-                      let t = W.tag $ W.workspace $ W.current $ windowset s+                      let t = W.currentTag $ windowset s                       in s { windowset = until ((Just w ==) . W.peek)                              W.focusUp $ copyWindow w t $ windowset s }               has _ Nothing         = False

@@ -7,22 +7,28 @@ -- License      : BSD -- -- Maintainer   : Spencer Janssen <spencerjanssen@gmail.com>+-- Stability    :  unstable+-- Portability  :  unportable -- -- This module provides a config suitable for use with the GNOME desktop -- environment.  module XMonad.Config.Gnome (     -- * Usage-    -- -- $usage+    -- $usage     gnomeConfig,-    gnomeRun+    gnomeRun,+    gnomeRegister     ) 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@: --@@ -30,11 +36,13 @@ -- > import XMonad.Config.Gnome -- > -- > main = xmonad gnomeConfig--- +--+-- For examples of how to further customize @gnomeConfig@ see "XMonad.Config.Desktop".  gnomeConfig = desktopConfig     { terminal = "gnome-terminal"-    , keys     = \c -> gnomeKeys c `M.union` keys desktopConfig c }+    , keys     = \c -> gnomeKeys c `M.union` keys desktopConfig c+    , startupHook = gnomeRegister >> startupHook desktopConfig }  gnomeKeys (XConfig {modMask = modm}) = M.fromList $     [ ((modm, xK_p), gnomeRun)@@ -53,3 +61,22 @@         setClientMessageEvent e rw gnome_panel 32 panel_run 0         sendEvent dpy rw False structureNotifyMask e         sync dpy False++-- | Register xmonad with gnome. 'dbus-send' must be in the $PATH with which+-- xmonad is started.+--+-- This action reduces a delay on startup only only if you have configured+-- gnome-session>=2.26: to start xmonad with a command as such:+--+-- > gconftool-2 -s /desktop/gnome/session/required_components/windowmanager xmonad --type string+gnomeRegister :: MonadIO m => m ()+gnomeRegister = io $ do+    x <- lookup "DESKTOP_AUTOSTART_ID" `fmap` getEnvironment+    whenJust x $ \sessionId -> safeSpawn "dbus-send"+            ["--session"+            ,"--print-reply=string"+            ,"--dest=org.gnome.SessionManager"+            ,"/org/gnome/SessionManager"+            ,"org.gnome.SessionManager.RegisterClient"+            ,"string:xmonad"+            ,"string:"++sessionId]

@@ -7,14 +7,17 @@ -- License      : BSD -- -- Maintainer   : Spencer Janssen <spencerjanssen@gmail.com>+-- Stability    :  unstable+-- Portability  :  unportable -- -- This module provides a config suitable for use with the KDE desktop -- environment.  module XMonad.Config.Kde (     -- * Usage-    -- -- $usage-    kdeConfig+    -- $usage+    kdeConfig,+    kde4Config     ) where  import XMonad@@ -29,13 +32,26 @@ -- > import XMonad.Config.Kde -- > -- > main = xmonad kdeConfig--- +--+-- For KDE 4, replace 'kdeConfig' with 'kde4Config'+--+-- For examples of how to further customize @kdeConfig@ see "XMonad.Config.Desktop". + kdeConfig = desktopConfig     { terminal = "konsole"     , keys     = \c -> kdeKeys c `M.union` keys desktopConfig c } +kde4Config = desktopConfig+    { terminal = "konsole"+    , keys     = \c -> kde4Keys c `M.union` keys desktopConfig c }+ kdeKeys (XConfig {modMask = modm}) = M.fromList $     [ ((modm,               xK_p), spawn "dcop kdesktop default popupExecuteCommand")     , ((modm .|. shiftMask, xK_q), spawn "dcop kdesktop default logout")+    ]++kde4Keys (XConfig {modMask = modm}) = M.fromList $+    [ ((modm,               xK_p), spawn "krunner")+    , ((modm .|. shiftMask, xK_q), spawn "dbus-send --print-reply --dest=org.kde.ksmserver /KSMServer org.kde.KSMServerInterface.logout int32:1 int32:0 int32:1")     ]

@@ -1,528 +0,0 @@-{-# LANGUAGE -  FlexibleInstances, -  FlexibleContexts, -  MultiParamTypeClasses, -  ExistentialQuantification -  #-}------------------------------------------------------------------------------ |--- Module      :  XMonad.Config.PlainConfig--- Copyright   :  Braden Shepherdson <Braden.Shepherdson@gmail.com>--- License     :  BSD3--- --- Maintainer  :  Braden Shepherdson <Braden.Shepherdson@gmail.com>------ Proof-of-concept (but usable) plain-text configuration file--- parser, for use instead of xmonad.hs. Does not require recompilation,--- allowing xmonad to be free of the GHC dependency.--------------------------------------------------------------------------------module XMonad.Config.PlainConfig-    (-     -- * Introduction-     -- $usage--     -- * Supported Layouts-     -- $layouts--     -- * Support Key Bindings-     -- $keys--     -- * Other Notes-     -- $notes--     -- * Example Config File-     -- $example--     plainConfig ,readConfig, checkConfig-    )-where---import XMonad-import System.Exit--import qualified XMonad.StackSet as W-import qualified Data.Map        as M-import Data.List-import Data.Maybe (isJust,fromJust)-import Data.Char (isSpace)-----import Control.Monad-import Control.Monad.Error-import Control.Monad.Identity--import Control.Arrow ((&&&))--import Text.ParserCombinators.ReadP--import System.IO-import Control.Exception (bracket)--import XMonad.Util.EZConfig (mkKeymap)------ $usage--- The @xmonad.hs@ file is very minimal when used with PlainConfig.--- It typically contains only the following:------ > module Main where--- > import XMonad--- > import XMonad.Config.PlainConfig (plainConfig)--- > main = plainConfig------ The 'plainConfig' function parses @~\/.xmonad\/xmonad.conf@, --- the format of which is described below.----- $layouts--- Only 'Tall', 'Wide' and 'Full' are supported at present.------ $keys--- --- Key bindings are specified as a pair of an arbitrary EZConfig and --- one of the following:------ @   Name                     Haskell equivalent                                          Default binding(s)@--- --- * @spawn \<cmd\>           spawn \"\<cmd\>\"                                               none@--- --- * @kill                  kill                                                        M-S-c@--- --- * @nextLayout            sendMessage NextLayout                                      M-\<Space\>@--- --- * @refresh               refresh                                                     M-S-\<Space\>@--- --- * @focusDown             windows W.focusDown                                         M-\<Tab\>, M-j@--- --- * @focusUp               windows W.focusUp                                           M-k@--- --- * @focusMaster           windows W.focusMaster                                       M-m@--- --- * @swapDown              windows W.swapDown                                          M-S-j@--- --- * @swapUp                windows W.swapUp                                            M-S-k@--- --- * @swapMaster            windows W.swapMaster                                        M-\<Return\>@--- --- * @shrink                sendMessage Shrink                                          M-h@--- --- * @expand                sendMessage Expand                                          M-l@--- --- * @sink                  withFocused $ windows . W.sink                              M-t@--- --- * @incMaster             sendMessage (IncMasterN 1)                                  M-,@--- --- * @decMaster             sendMessage (IncMasterN (-1))                               M-.@--- --- * @quit                  io $ exitWith ExitSuccess                                   M-S-q@--- --- * @restart               broadcastMessageReleaseResources >> restart \"xmonad\" True   M-q@--- ----- $notes--- Submaps are allowed.--- These settings override the defaults. Changes made here will be used over--- the default bindings for those keys.----- $example--- An example @~\/.xmonad\/xmonad.conf@ file follows:------ @modMask       = 3@------ @numlockMask   = 2@------ @borderWidth   = 1@------ @normalBorderColor    	=   #dddddd@------ @focusedBorderColor      =   #00ff00@------ @terminal=urxvt@------ @workspaces=[\"1: IRC\",\"2: Web\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\"]@------ @focusFollowsMouse=True@------ @layouts=[\"Tall\",\"Full\",\"Wide\"]@------ @key=(\"M-x t\", \"spawn xmessage Test\")@------ @manageHook=(ClassName \"MPlayer\"       , \"float\"  )@------ @manageHook=(ClassName \"Gimp\"          , \"float\"  )@------ @manageHook=(Resource  \"desktop_window\", \"ignore\" )@------ @manageHook=(Resource  \"kdesktop\"      , \"ignore\" )@------ @manageHook=(Resource  \"gnome-panel\"   , \"ignore\" )@--------------------------------------------------------------------------------- Several functions for parsing the key-value file. --------------------------------------------------------------------------parseKVBy :: Char -> ReadP (String,String)-parseKVBy sep = do-  skipSpaces -  k <- munch1 (\x -> x /= ' ' && x /= sep) -  skipSpaces-  char kvSep-  skipSpaces-  v <- munch1 (\x -> x /= ' ') --or EOS -  return (k,v)--parseKVVBy :: Char -> ReadP (String,String)-parseKVVBy sep = do-  skipSpaces -  k <- munch1 (\x -> x /= ' ' && x /= sep) -  skipSpaces-  char kvSep-  skipSpaces-  v <- munch1 (const True) -- until EOS-  return (k,v)---kvSep :: Char-kvSep = '='--parseKV, parseKVV :: ReadP (String,String)-parseKV  = parseKVBy  kvSep-parseKVV = parseKVVBy kvSep----readKV :: String -> Integer -> RC (String,String)-readKV s ln = case readP_to_S parseKV s of-                [((k,v),"")] -> return (k,v) --single, correct parse-                []           -> throwError [(ln,"No parse")]-                _           -> do-                  case readP_to_S parseKVV s of-                    [((k,v),"")] -> return (k,v) --single, correct parse-                    []           -> throwError [(ln,"No parse")]-                    xs           -> throwError [(ln,"Ambiguous parse: "-                                                 ++ show xs)]----isComment :: String -> Bool-isComment = not . null . readP_to_S parseComment -  where parseComment = skipSpaces >> char '#' >> return ()-    -- null means failed parse, so _not_ a comment.---isBlank :: String -> Bool-isBlank = null . filter (not . isSpace)---type RC = ErrorT [(Integer,String)] Identity--instance Error [(Integer,String)] where-    noMsg  = [(-1, "Unknown error.")]-    strMsg s = [(-1, s)]---parseFile :: [String] -> RC (XConfig Layout)-parseFile ss = parseLines baseConfig theLines-  where theLines = filter (not . liftM2 (||) isComment isBlank . snd) -                   $ zip [1..] ss-        ---parseLines :: XConfig Layout -> [(Integer,String)] -> RC (XConfig Layout)-parseLines = foldM parse---parse :: XConfig Layout -> (Integer, String) -> RC (XConfig Layout)-parse xc (ln,s) = do-  (k,v) <- readKV s ln-  case M.lookup k commands of-    Nothing -> throwError [(ln,"Unknown command: "++k)]-    Just f  -> f v ln xc------------------------------------------------------------------------ Now the semantic parts, that convert from the relevant     ----- key-value entries to values in an XConfig                  -----------------------------------------------------------------------type Command = String -> Integer -> XConfig Layout -> RC (XConfig Layout)--commands :: M.Map String Command-commands = M.fromList $ -           [("modMask"             , cmd_modMask           )-           ,("numlockMask"         , cmd_numlockMask       )-           ,("normalBorderColor"   , cmd_normalBorderColor )-           ,("focusedBorderColor"  , cmd_focusedBorderColor)-           ,("terminal"            , cmd_terminal          )-           ,("workspaces"          , cmd_workspaces        )-           ,("focusFollowsMouse"   , cmd_focusFollowsMouse )-           ,("layouts"             , cmd_layouts           )-           ,("key"                 , cmd_key               )-           ,("manageHook"          , cmd_manageHook        )-           ,("borderWidth"         , cmd_borderWidth       )-           ]----- | Behind-the-scenes helper for both 'cmd_modMask' and 'cmd_numlockMask'.-genericModKey :: (KeyMask -> XConfig Layout) -> Command-genericModKey f s ln _ = do-  x <- rcRead s ln :: RC Integer-  case lookup x (zip [1..] [mod1Mask,mod2Mask,mod3Mask,mod4Mask,mod5Mask]) of-    Just y  -> return $ f y-    Nothing -> throwError [(ln,"Invalid mod key number: "++ show x)]-  ---- | Reads the mod key modifier number.-cmd_modMask :: Command-cmd_modMask s ln xc = genericModKey (\k -> xc{modMask = k}) s ln xc---- | Reads the numlock key modifier number.-cmd_numlockMask :: Command-cmd_numlockMask s ln xc = genericModKey (\k -> xc{numlockMask = k}) s ln xc----- | Reads the border width.-cmd_borderWidth :: Command-cmd_borderWidth s ln xc = do-  w <- rcRead s ln-  return $ xc { borderWidth = w }----- | Reads the colors but just keeps them as RRGGBB Strings.-cmd_normalBorderColor, cmd_focusedBorderColor :: Command-cmd_normalBorderColor  s _ xc = return $ xc{ normalBorderColor  = s } -cmd_focusedBorderColor s _ xc = return $ xc{ focusedBorderColor = s }----- | Reads the terminal. It is just a String, no parsing.-cmd_terminal :: Command-cmd_terminal s _ xc = return $ xc{ terminal = s }----- | Reads the workspace tag list. This is given as a Haskell [String].-cmd_workspaces :: Command-cmd_workspaces s ln xc = rcRead s ln >>= \x -> return xc{ workspaces = x }----- | Reads the focusFollowsMouse, as a Haskell Bool.-cmd_focusFollowsMouse :: Command-cmd_focusFollowsMouse s ln xc = rcRead s ln >>= -                                \x -> return xc{focusFollowsMouse = x}----- | The list known layouts, mapped by name.---   An easy location for improvement is to add more contrib layouts here.-layouts :: M.Map String (Layout Window)-layouts = M.fromList-          [("Tall", Layout (Tall 1 (3/100) (1/2)))-          ,("Wide", Layout (Mirror (Tall 1 (3/100) (1/2))))-          ,("Full", Layout Full)-          ]----- | Expects a [String], the strings being layout names. Quotes required.---   Draws from the `layouts' list above.-cmd_layouts :: Command-cmd_layouts s ln xc = do-  xs <- rcRead s ln -- read the list of strings-  let ls = map (id &&& (flip M.lookup) layouts) xs-  when (null ls) $ throwError [(ln,"Empty layout list")]-  case filter (not . isJust . snd) ls of-    [] -> return $ xc{ layoutHook = foldr1 -                       (\(Layout l) (Layout r) -> -                            Layout (l ||| r)) (map (fromJust . snd) ls) -                     }-    ys -> throwError $ map (\(x,_) -> (ln, "Unknown layout: "++ x)) ys------ | A Map from names to key binding actions.-key_actions :: M.Map String (X ())-key_actions = M.fromList-              [("kill"            , kill                   )-              ,("nextLayout"      , sendMessage NextLayout )-              --,("prevLayout"      , sendMessage PrevLayout )-              --,("resetLayout"     , setLayout $ XMonad.layoutHook conf)-              ,("refresh"         , refresh                )-              ,("focusDown"       , windows W.focusDown    )-              ,("focusUp"         , windows W.focusUp      )-              ,("focusMaster"     , windows W.focusMaster  )-              ,("swapMaster"      , windows W.swapMaster   )-              ,("swapDown"        , windows W.swapDown     )-              ,("swapUp"          , windows W.swapUp       )-              ,("shrink"          , sendMessage Shrink     )-              ,("expand"          , sendMessage Expand     )-              ,("sink"            , withFocused $ windows . W.sink)-              ,("incMaster"       , sendMessage (IncMasterN   1))-              ,("decMaster"       , sendMessage (IncMasterN (-1)))-              ,("quit"            , io $ exitWith ExitSuccess)-              ,("restart"         , broadcastMessage ReleaseResources -                                      >> restart "xmonad" True)-              ]----- | Expects keys as described in the preamble, as ---   (\"EZConfig key name\", \"action name\"), ---   eg. (\"M-S-t\", \"spawn thunderbird\")---   One key per "key=" line.-cmd_key :: Command-cmd_key s ln xc = do-  (k,v) <- rcRead s ln-  if "spawn " `isPrefixOf` v-    then return $ xc { -                      keys = \c -> M.union (mkKeymap c -                                            [(k, spawn (drop 6 v))]-                                           ) ((keys xc) c) -                     }-    else do-          case M.lookup v key_actions of-            Nothing -> throwError [(ln, "Unknown key action \"" ++ v ++ "\"")]-            Just ac -> return $ -                       xc { keys = \c -> M.union (mkKeymap c [(k, ac)])-                                   ((keys xc) c) -                          }------ | Map of names to actions for 'ManageHook's.-manageHook_actions :: M.Map String ManageHook-manageHook_actions = M.fromList -                     [("float"  , doFloat  )-                     ,("ignore" , doIgnore )-                     ]----- | Parses 'ManageHook's in the form given in the preamble.---   eg. (ClassName \"MPlayer\", \"float\")-cmd_manageHook :: Command-cmd_manageHook s ln xc = do-  (k,v) <- rcRead s ln-  let q = parseQuery k-  if "toWorkspace " `isPrefixOf` v-    then return $ xc { manageHook = manageHook xc <+> -                       (q --> doShift (drop 12 v))-                     }-    else case M.lookup v manageHook_actions of-           Nothing -> throwError [(ln, "Unknown ManageHook action \"" -                                   ++ v ++ "\"")]-           Just ac -> return $ xc { manageHook = manageHook xc <+> (q --> ac) }------ | Core of the ManageHook expression parser.---   Taken from Roman Cheplyaka's WindowProperties-parseQuery :: Property -> Query Bool-parseQuery (Title s)       = title =? s-parseQuery (ClassName s)   = className =? s-parseQuery (Resource s)    = resource =? s-parseQuery (And p q)       = parseQuery p <&&> parseQuery q-parseQuery (Or  p q)       = parseQuery p <&&> parseQuery q-parseQuery (Not p)         = not `fmap` parseQuery p-parseQuery (Const b)       = return b----- | Property constructors are quite self-explaining.---   Taken from Roman Cheplyaka's WindowProperties-data Property = Title String-              | ClassName String-              | Resource String-              | And Property Property  -              | Or  Property Property-              | Not Property-              | Const Bool-              deriving (Read, Show)------ | A wrapping of the read function into the RC monad.-rcRead :: (Read a) => String -> Integer -> RC a-rcRead s ln = case reads s of -                [(x,"")] -> return x-                _        -> throwError [(ln, "Failed to parse value")]------ | The standard Config.hs 'defaultConfig', with the layout wrapped.-baseConfig :: XConfig Layout-baseConfig = defaultConfig{ layoutHook = Layout (layoutHook defaultConfig) }------ | Core function that attempts to parse @~\/.xmonad\/xmonad.conf@-readConfig :: IO (Maybe (XConfig Layout))-readConfig = do-  dir <- getXMonadDir-  cs <- bracket (openFile (dir++"/xmonad.conf") ReadMode)-             (\h -> hClose h) -- vv force the lazy IO-             (\h -> (lines `fmap` hGetContents h) >>= \ss -> -                    length ss `seq` return ss)-  let xce = runIdentity $ runErrorT $ parseFile cs-  case xce of-    Left es  -> mapM_ (\(ln,e) -> -                           putStrLn $ "readConfig error: line "++show ln++-                                        ": "++ e) es -                >> return Nothing-    Right xc -> return $ Just xc----- | Attempts to run readConfig, and checks if it failed.-checkConfig :: IO Bool-checkConfig = isJust `fmap` readConfig----{-  REMOVED: It was for debugging, and causes an 'orphaned instances'-             warning to boot.------ | Reads in the config, and then prints the resulting XConfig-dumpConfig :: IO ()-dumpConfig = readConfig >>= print---instance Show (XConfig Layout) where-    show x = "XConfig { "-             ++ "normalBorderColor = "++ normalBorderColor x ++", "-             ++ "focusedBorderColor = "++ focusedBorderColor x++", "-             ++ "terminal = "++ terminal x ++", "-             ++ "workspaces = "++ show (workspaces x) ++", "-             ++ "numlockMask = "++ show (numlockMask x) ++", "-             ++ "modMask = "++ show (modMask x) ++", "-             ++ "borderWidth = "++ show (borderWidth x) ++", "-             ++ "focusFollowsMouse = "++ show (focusFollowsMouse x) ++", "-             ++ "layouts = "++ show (layoutHook x) ++" }"---}---- | Handles the unwrapping of the Layout. Intended for use as---   @main = plainConfig@-plainConfig :: IO ()-plainConfig = do-  conf <- readConfig-  case conf of-    (Just xc@XConfig{layoutHook= (Layout l)}) -> -        xmonad (xc{ layoutHook = l })-    Nothing                                   -> -        spawn $ "xmessage Failed to read xmonad.conf. See xmonad.errors."-

@@ -1,5 +1,5 @@ {-# OPTIONS_GHC -fno-warn-missing-signatures #-}-module XMonad.Config.Sjanssen (sjanssenConfig) where+module XMonad.Config.Sjanssen (sjanssenConfig, sjanssenConfigXmobar) where  import XMonad hiding (Tall(..)) import qualified XMonad.StackSet as W@@ -10,41 +10,51 @@ import XMonad.Layout.NoBorders import XMonad.Hooks.DynamicLog hiding (xmobar) import XMonad.Hooks.ManageDocks+import XMonad.Hooks.ManageHelpers (isFullscreen, doFullFloat)+import XMonad.Hooks.EwmhDesktops import XMonad.Prompt-import XMonad.Prompt.Shell-import XMonad.Util.Run (spawnPipe)+import XMonad.Actions.SpawnOn +import XMonad.Layout.LayoutScreens+import XMonad.Layout.TwoPane+ import qualified Data.Map as M-import System.IO (hPutStrLn) +sjanssenConfigXmobar = statusBar "exec xmobar" sjanssenPP strutkey =<< sjanssenConfig+ where+    strutkey (XConfig {modMask = modm}) = (modm, xK_b)+ sjanssenConfig = do-    xmobar <- spawnPipe "xmobar"-    return $ defaultConfig-        { terminal = "urxvtc"+    sp <- mkSpawner+    return . ewmh $ defaultConfig+        { terminal = "exec urxvt"         , workspaces = ["irc", "web"] ++ map show [3 .. 9 :: Int]-        , logHook = dynamicLogWithPP $ sjanssenPP { ppOutput = hPutStrLn xmobar }         , 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-        , layoutHook = modifiers layouts-        , manageHook = composeAll [className =? x --> doF (W.shift w)+        , keys = \c -> mykeys sp c `M.union` keys defaultConfig c+        , layoutHook  = modifiers layouts+        , manageHook  = composeAll [className =? x --> doShift w                                     | (x, w) <- [ ("Firefox", "web")-                                                , ("Ktorrent", "7")]]-                       <+> manageHook defaultConfig <+> manageDocks+                                                , ("Ktorrent", "7")+                                                , ("Amarokapp", "7")]]+                        <+> manageHook defaultConfig <+> manageDocks <+> manageSpawn sp+                        <+> (isFullscreen --> doFullFloat)         }  where     tiled     = HintedTile 1 0.03 0.5 TopLeft     layouts   = (tiled Tall ||| (tiled Wide ||| Full)) ||| tabbed shrinkText myTheme-    modifiers = avoidStruts . smartBorders+    modifiers = smartBorders -    mykeys (XConfig {modMask = modm, workspaces = ws}) = M.fromList $-        [((modm,               xK_p     ), shellPrompt myPromptConfig)+    mykeys sp (XConfig {modMask = modm}) = M.fromList $+        [((modm,               xK_p     ), shellPromptHere sp myPromptConfig)+        ,((modm .|. shiftMask, xK_Return), spawnHere sp =<< asks (terminal . config))         ,((modm .|. shiftMask, xK_c     ), kill1)         ,((modm .|. shiftMask .|. controlMask, xK_c     ), kill)-        ,((modm .|. shiftMask, xK_0     ), windows $ \w -> foldr copy w ws)-        ,((modm,               xK_b     ), sendMessage ToggleStruts)+        ,((modm .|. shiftMask, xK_0     ), windows $ copyToAll)+        ,((modm,               xK_z     ), layoutScreens 2 $ TwoPane 0.5 0.5)+        ,((modm .|. shiftMask, xK_z     ), rescreen)         ]      myFont = "xft:Bitstream Vera Sans Mono:pixelsize=10"@@ -52,4 +62,6 @@     myPromptConfig = defaultXPConfig                         { position = Top                         , font = myFont+                        , showCompletionOnTab = True+                        , historyFilter = deleteConsecutive                         , promptBorderWidth = 0 }

@@ -6,14 +6,16 @@ -- Copyright    : (c) Ivan Miljenovic <Ivan.Miljenovic@gmail.com> -- License      : BSD ----- Maintainer   : Ivan Miljenovic <Ivan.Miljenovic@gmail.com>+-- Maintainer   :  none+-- Stability    :  unstable+-- Portability  :  unportable -- -- This module provides a config suitable for use with the Xfce desktop -- environment.  module XMonad.Config.Xfce (     -- * Usage-    -- -- $usage+    -- $usage     xfceConfig     ) where @@ -29,7 +31,8 @@ -- > import XMonad.Config.Xfce -- > -- > main = xmonad xfceConfig--- +--+-- For examples of how to further customize @xfceConfig@ see "XMonad.Config.Desktop".  xfceConfig = desktopConfig     { terminal = "Terminal"

@@ -49,16 +49,25 @@ that this file can contain arbitrary Haskell code, which means that you have quite a lot of flexibility in configuring xmonad. -NOTE for users of previous versions (< 0.5) of xmonad: this is a major-change in the way xmonad is configured.  Prior to version 0.5,-configuring xmonad required editing an xmonad source file called-Config.hs, recompiling xmonad, and then restarting.  From version 0.5-onwards, however, you should NOT edit this file.  All you have to do-is edit xmonad.hs and restart with @mod-q@; xmonad does the-recompiling itself.  The format of the configuration file has also-changed; it is now simpler and much shorter, only requiring you to-list those settings which are different from the defaults.+HISTORICAL NOTE regarding upgrading from versions (< 0.5) of xmonad+or using old documentation: +xmonad-0.5 delivered a major change in the way xmonad is configured.  Prior+to version 0.5, configuring xmonad required editing a source file called+Config.hs, manually recompiling xmonad, and then restarting.  From+version 0.5 onwards, however, you should NOT edit this file or manually+compile with ghc --make.  All you have to do is edit xmonad.hs and restart+with @mod-q@; xmonad does the recompiling itself. The format of the+configuration file also changed with version 0.5; enabling simpler and+much shorter xmonad.hs files that only require listing those settings which+are different from the defaults.++While the complicated template.hs (man/xmonad.hs) files listing all default+settings are still provided for reference, once you wish to make substantial+changes to your configuration, the template.hs style configuration is not+recommended. It is fine to use top-level definitions to organize your+xmonad.hs, but wherever possible it is better to leave out settings that+simply duplicate defaults. -}  {- $example@@ -90,8 +99,8 @@  As an alternative, you can copy the template @xmonad.hs@ file (found either in the @man@ directory, if you have the xmonad source, or on-the xmonad wiki at-@http:\/\/haskell.org\/haskellwiki\/Xmonad\/Config_archive\/Template_xmonad.hs@)+the xmonad wiki config archive at+<http://haskell.org/haskellwiki/Xmonad/Config_archive>) into your @~\/.xmonad\/@ directory.  This template file contains all the default settings spelled out, and you should be able to simply change the ones you would like to change.@@ -106,18 +115,14 @@ #Checking_whether_your_xmonad.hs_is_correct#  After changing your configuration, it is a good idea to check that it-is syntactically and type correct.  You can do this easily by loading-your configuration file in the Haskell interpreter:+is syntactically and type correct.  You can do this easily by using an xmonad+flag: ->    $ ghci ~/.xmonad/xmonad.hs->    GHCi, version 6.8.2: http://www.haskell.org/ghc/  :? for help->    Loading package base ... linking ... done.->    Ok, modules loaded: Main.->->    Prelude Main> :t main->    main :: IO ()+>    $ xmonad --recompile+>    $ -Ok, looks good.+If there is no output, your xmonad.hs has no errors.  If there are errors, they+will be printed to the console.  Patch them up and try again.  Note, however, that if you skip this step and try restarting xmonad with errors in your xmonad.hs, it's not the end of the world; xmonad@@ -139,15 +144,8 @@ related to your layouts, you may need to hit @mod-shift-space@ after restarting to see the changes take effect.)  If something goes wrong, the previous (default) settings will be used.  Note this requires that-GHC and xmonad are in your @$PATH@. If GHC isn't in your path, you can-still compile @xmonad.hs@ yourself:-->    $ cd ~/.xmonad->    $ /path/to/ghc --make xmonad.hs->    $ ls->    xmonad    xmonad.hi xmonad.hs xmonad.o--When you hit @mod-q@, this newly compiled xmonad will be used.+GHC and xmonad are in the @$PATH@ in the environment from which xmonad+is started.  -} 

@@ -116,82 +116,176 @@ See "XMonad.Doc.Extending#Editing_key_bindings" for instructions on how to edit your key bindings. -* "XMonad.Actions.Commands": running internal xmonad actions-  interactively.+* "XMonad.Actions.Commands":+    Allows you to run internal xmonad commands (X () actions) using+    a dmenu menu in addition to key bindings.  Requires dmenu and+    the Dmenu XMonad.Actions module. -* "XMonad.Actions.ConstrainedResize": an aspect-ratio-constrained-  window resizing mode.+* "XMonad.Actions.ConstrainedResize":+    Lets you constrain the aspect ratio of a floating+    window (by, say, holding shift while you resize).+    Useful for making a nice circular XClock window. -* "XMonad.Actions.CopyWindow": duplicating windows on multiple-  workspaces.+* "XMonad.Actions.CopyWindow":+    Provides bindings to duplicate a window on multiple workspaces,+    providing dwm-like tagging functionality. -* "XMonad.Actions.CycleSelectedLayouts": bind a key to cycle through a-  particular subset of your layouts.+* "XMonad.Actions.CycleRecentWS":+    Provides bindings to cycle through most recently used workspaces+    with repeated presses of a single key (as long as modifier key is+    held down). This is similar to how many window managers handle+    window switching. -* "XMonad.Actions.CycleWS": move between workspaces in various ways.+* "XMonad.Actions.CycleSelectedLayouts":+    This module allows to cycle through the given subset of layouts. -* "XMonad.Actions.DeManage": cease management of a window without-  unmapping it.+* "XMonad.Actions.CycleWS":+    Provides bindings to cycle forward or backward through the list of+    workspaces, to move windows between workspaces, and to cycle+    between screens. Replaces the former XMonad.Actions.RotView. -* "XMonad.Actions.DwmPromote": dwm-like master window swapping.+* "XMonad.Actions.CycleWindows":+    Provides bindings to cycle windows up or down on the current workspace+    stack while maintaining focus in place. -* "XMonad.Actions.DynamicWorkspaces": add, delete, and rename workspaces.+* "XMonad.Actions.DeManage":+    This module provides a method to cease management of a window+    without unmapping it. "XMonad.Hooks.ManageDocks" is a+    more automated solution if your panel supports it. -* "XMonad.Actions.FindEmptyWorkspace": find an empty workspace.+* "XMonad.Actions.DwmPromote":+    Dwm-like swap function for xmonad.+    Swaps focused window with the master window. If focus is in the+    master, swap it with the next window in the stack. Focus stays in the+    master. -* "XMonad.Actions.FlexibleManipulate": move\/resize windows without-  warping the mouse.+* "XMonad.Actions.DynamicWorkspaces":+    Provides bindings to add and delete workspaces.  Note that you may only+    delete a workspace that is already empty. -* "XMonad.Actions.FlexibleResize": resize windows from any corner.+* "XMonad.Actions.FindEmptyWorkspace":+    Find an empty workspace. -* "XMonad.Actions.FloatKeys": move\/resize floating windows with-  keybindings.+* "XMonad.Actions.FlexibleManipulate":+    Move and resize floating windows without warping the mouse. -* "XMonad.Actions.FocusNth": focus the nth window on the screen.+* "XMonad.Actions.FlexibleResize":+    Resize floating windows from any corner. -* "XMonad.Actions.MouseGestures": bind mouse gestures to actions.+* "XMonad.Actions.FloatKeys":+    Move and resize floating windows. -* "XMonad.Actions.MouseResize": use with-  "XMonad.Layout.WindowArranger" to resize windows with the mouse when-  using a floating layout.+* "XMonad.Layout.FloatSnap":+    Move and resize floating windows using other windows and the edge of the+    screen as guidelines. -* "XMonad.Actions.NoBorders": forcibly remove borders from a window.-  Not to be confused with "XMonad.Layout.NoBorders".+* "XMonad.Actions.FocusNth":+    Focus the nth window of the current workspace. -* "XMonad.Actions.PerWorkspaceKeys": configure keybindings-  per-workspace.+* "XMonad.Actions.GridSelect":+    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.Promote": An action to move the focused window to-  the master pane, or swap the master with the next window.+* "XMonad.Actions.MessageFeedback":+    Alternative to 'XMonad.Operations.sendMessage' that provides knowledge+    of whether the message was handled, and utility functions based on+    this facility. -* "XMonad.Actions.RotSlaves": rotate non-master windows.+* "XMonad.Actions.MouseGestures":+    Support for simple mouse gestures. -* "XMonad.Actions.Search": provide helpful functions for easily-  running web searchs.+* "XMonad.Actions.MouseResize":+    A layout modifier to resize windows with the mouse by grabbing the+    window's lower right corner. -* "XMonad.Actions.SimpleDate": display the date in a popup menu.+* "XMonad.Actions.NoBorders":+    This module provides helper functions for dealing with window borders. -* "XMonad.Actions.SinkAll": sink all floating windows.+* "XMonad.Actions.OnScreen":+    Control workspaces on different screens (in xinerama mode). -* "XMonad.Actions.Submap": create key submaps, i.e. the ability to-  bind actions to key sequences rather than being limited to single-  key combinations.+* "XMonad.Actions.PerWorkspaceKeys":+    Define key-bindings on per-workspace basis. -* "XMonad.Actions.SwapWorkspaces": swap workspace tags.+* "XMonad.Actions.PhysicalScreens":+    Manipulate screens ordered by physical location instead of ID -* "XMonad.Actions.TagWindows": tag windows and select by tag.+* "XMonad.Actions.Plane":+    This module has functions to navigate through workspaces in a bidimensional+    manner. -* "XMonad.Actions.UpdatePointer": mouse-follows-focus.+* "XMonad.Actions.Promote":+    Alternate promote function for xmonad. -* "XMonad.Actions.Warp": warp the pointer.+* "XMonad.Actions.RandomBackground":+    An action to start terminals with a random background color -* "XMonad.Actions.WindowBringer": bring windows to you, and you to-  windows.+* "XMonad.Actions.RotSlaves":+    Rotate all windows except the master window and keep the focus in+    place. -* "XMonad.Actions.WindowGo": travel to windows based on various-  criteria; conditionally start a program if a window does not exist,-  or travel to that window if it does.+* "XMonad.Actions.Search":+    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.SimpleDate":+    An example external contrib module for XMonad.+    Provides a simple binding to dzen2 to print the date as a popup menu.++* "XMonad.Actions.SinkAll":+    (Deprecated) Provides a simple binding that pushes all floating windows on the+    current workspace back into tiling. Instead, use the more general+    "XMonad.Actions.WithAll"++* "XMonad.Actions.SpawnOn":+    Provides a way to modify a window spawned by a command(e.g shift it to the workspace+    it was launched on) by using the _NET_WM_PID property that most windows set on creation.++* "XMonad.Actions.Submap":+    A module that allows the user to create a sub-mapping of key bindings.++* "XMonad.Actions.SwapWorkspaces":+    Lets you swap workspace tags, so you can keep related ones next to+    each other, without having to move individual windows.++* "XMonad.Actions.TagWindows":+    Functions for tagging windows and selecting them by tags.++* "XMonad.Actions.TopicSpace":+    Turns your workspaces into a more topic oriented system.++* "XMonad.Actions.UpdateFocus":+    Updates the focus on mouse move in unfocused windows.++* "XMonadContrib.UpdatePointer":+    Causes the pointer to follow whichever window focus changes to.++* "XMonad.Actions.Warp":+    Warp the pointer to a given window or screen.++* "XMonad.Actions.WindowBringer":+    dmenu operations to bring windows to you, and bring you to windows.+    That is to say, it pops up a dmenu with window names, in case you forgot+    where you left your XChat.++* "XMonad.Actions.WindowGo":+    Defines a few convenient operations for raising (traveling to) windows based on XMonad's Query+    monad, such as 'runOrRaise'.++* "XMonad.Actions.WindowMenu":+    Uses "XMonad.Actions.GridSelect" to display a number of actions related to+    window management in the center of the focused window.++* "XMonad.Actions.WindowNavigation":+    Experimental rewrite of "XMonad.Layout.WindowNavigation".++* "XMonad.Actions.WithAll":+    Provides functions for performing a given action on all windows of+    the current workspace.++* "XMonad.Actions.WorkspaceCursors":+    Like "XMonad.Actions.Plane" for an arbitrary number of dimensions.+ -}  {- $configs@@ -202,14 +296,27 @@ configuration; you can also simply import them and use them as your own configuration, possibly with some modifications. + * "XMonad.Config.Arossato"+    This module specifies my xmonad defaults. -* "XMonad.Config.Dons"+* "XMonad.Config.Azerty"+    Fixes some keybindings for users of French keyboard layouts. -* "XMonad.Config.Droundy"+* "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.Kde"+ * "XMonad.Config.Sjanssen" +* "XMonad.Config.Xfce"+ -}  {- $hooks@@ -236,35 +343,80 @@   See "XMonad.Doc.Extending#The_log_hook_and_external_status_bars" for more   information. +* 'XMonad.Core.handleEventHook': this hook is called on all events handled+  by xmonad, thus it is extremely powerful. See "Graphics.X11.Xlib.Extras"+  and xmonad source and development documentation for more details.+ Here is a list of the modules found in @XMonad.Hooks@: +* "XMonad.Hooks.DynamicHooks":+    One-shot and permanent ManageHooks that can be updated at runtime.+ * "XMonad.Hooks.DynamicLog": for use with 'XMonad.Core.logHook'; send   information about xmonad's state to standard output, suitable for   putting in a status bar of some sort. See   "XMonad.Doc.Extending#The_log_hook_and_external_status_bars". -* "XMonad.Hooks.EventHook": a hook to handle X events at the layout level.+* "XMonad.Hooks.EwmhDesktops":+    Makes xmonad use the EWMH hints to tell panel applications about its+    workspaces and the windows therein. It also allows the user to interact+    with xmonad by clicking on panels and window lists. -* "XMonad.Hooks.EwmhDesktops": support for pagers in panel applications.+* "XMonad.Hooks.FadeInactive":+    Makes XMonad set the _NET_WM_WINDOW_OPACITY atom for inactive windows,+    which causes those windows to become slightly translucent if something+    like xcompmgr is running -* "XMonad.Hooks.ManageDocks": handle DOCK and STRUT windows (such as-  status bars) appropriately, by de-managing them and creating-  appropriate gaps so as not to place other windows covering them.+* "XMonad.Hooks.FloatNext":+    Hook and keybindings for automatically sending the next+    spawned window(s) to the floating layer. +* "XMonad.Hooks.InsertPosition":+    Configure where new windows should be added and which window should be+    focused.++* "XMonad.Hooks.ManageDocks":+    This module provides tools to automatically manage 'dock' type programs,+    such as gnome-panel, kicker, dzen, and xmobar.+ * "XMonad.Hooks.ManageHelpers": provide helper functions to be used   in @manageHook@. -* "XMonad.Hooks.ServerMode": example use of "XMonad.Hooks.EventHook".+* "XMonad.Hooks.Place":+    Automatic placement of floating windows. -* "XMonad.Hooks.SetWMName": set the WM name.  Useful when e.g. running-  Java GUI programs.+* "XMonad.Hooks.RestoreMinimized":+    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.UrgencyHook": configure an action to occur when a window-  sets the urgent flag.+* "XMonad.Hooks.Script":+    Provides a simple interface for running a ~\/.xmonad\/hooks script with the+    name of a hook. -* "XMonad.Hooks.XPropManage": match on XProperties in your-  'XMonad.Core.manageHook'.+* "XMonad.Hooks.ServerMode": Allows sending commands to a running xmonad process. +* "XMonad.Hooks.SetCursor":+    Set a default mouse cursor on startup.++* "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.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.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.XPropManage":+    A ManageHook matching on XProperties.+ -}  {- $layouts@@ -274,7 +426,8 @@ three columns, and so on.  You will also find modules which provide facilities for combining-different layouts, such as "XMonad.Layout.Combo", or+different layouts, such as "XMonad.Layout.Combo", "XMonad.Layout.ComboP",+"XMonad.Layout.LayoutBuilder", "XMonad.Layout.SubLayouts", or "XMonad.Layout.LayoutCombinators".  Layouts can be also modified with layout modifiers. A general@@ -284,109 +437,297 @@ For more information on using those modules for customizing your 'XMonad.Core.layoutHook' see "XMonad.Doc.Extending#Editing_the_layout_hook". -* "XMonad.Layout.Accordion": put non-focused windows in ribbons at the-  top and bottom of the screen.+* "XMonad.Layout.Accordion":+    LayoutClass that puts non-focused windows in ribbons at the top and bottom+    of the screen. -* "XMonad.Layout.Circle": an elliptical, overlapping layout.+* "XMonad.Layout.AutoMaster":+    Provides layout modifier AutoMaster. It separates screen in two parts -+    master and slave. Size of slave area automatically changes depending on+    number of slave windows. -* "XMonad.Layout.Combo": combine multiple layouts into one.+* "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+    layouts that react to the SetGeometry message.+    "XMonad.Layout.WindowArranger" can be used to create such a setup.+    BorderResize is probably most useful in floating layouts. -* "XMonad.Layout.Decoration": decorated layouts.+* "XMonad.Layout.BoringWindows":+    BoringWindows is an extension to allow windows to be marked boring -* "XMonad.Layout.DecorationMadness": some examples of decorated layouts.+* "XMonad.Layout.CenteredMaster":+    Two layout modifiers. centerMaster places master window at center,+    on top of all other windows, which are managed by base layout.+    topRightMaster is similar, but places master window in top right corner+    instead of center. -* "XMonad.Layout.Dishes": stack extra windows underneath the master windows.+* "XMonad.Layout.Circle":+    Circle is an elliptical, overlapping layout. -* "XMonad.Layout.DragPane": split the screen into two windows with a-  draggable divider.+* "XMonad.Layout.Column":+    Provides Column layout that places all windows in one column. Windows+    heights are calculated from equation: H1/H2 = H2/H3 = ... = q, where q is+    given. With Shrink/Expand messages you can change the q value. -* "XMonad.Layout.DwmStyle": windows decorated in a dwm-like style.+* "XMonad.Layout.Combo":+    A layout that combines multiple layouts. -* "XMonad.Layout.Grid": put windows in a square grid.+* "XMonad.Layout.ComboP":+    A layout that combines multiple layouts and allows to specify where to put+    new windows. -* "XMonad.Layout.HintedTile": gapless tiled layout that attempts to-  obey window size hints.+* "XMonad.Layout.Cross":+    A Cross Layout with the main window in the center. -* "XMonad.Layout.IM": a layout for multi-window instant message clients.+* "XMonad.Layout.Decoration":+    A layout modifier and a class for easily creating decorated+    layouts. -* "XMonad.Layout.LayoutCombinators": general layout combining.+* "XMonad.Layout.DecorationMadness":+    A collection of decorated layouts: some of them may be nice, some+    usable, others just funny. -* "XMonad.Layout.LayoutHints": make layouts respect window size hints.+* "XMonad.Layout.Dishes":+    Dishes is a layout that stacks extra windows underneath the master+    windows. -* "XMonad.Layout.LayoutModifier": a general framework for creating-  layout \"modifiers\"; useful for creating new layout modules.+* "XMonad.Layout.DragPane":+    Layouts that splits the screen either horizontally or vertically and+    shows two windows.  The first window is always the master window, and+    the other is either the currently focused window or the second window in+    layout order. See also "XMonad.Layout.MouseResizableTall" -* "XMonad.Layout.LayoutScreens": divide the screen into multiple-  virtual \"screens\".+* "XMonad.Layout.DwmStyle":+    A layout modifier for decorating windows in a dwm like style. -* "XMonad.Layout.MagicFocus": automagically put the focused window in-  the master area.+* "XMonad.Layout.FixedColumn":+    A layout much like Tall, but using a multiple of a window's minimum+    resize amount instead of a percentage of screen to decide where to+    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.Magnifier": increase the size of the focused window+* "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+    off. You probably want "XMonad.Hooks.ManageDocks". -* "XMonad.Layout.Maximize": temporarily maximize the focused window.+* "XMonad.Layout.Grid":+    A simple layout that attempts to put all windows in a square grid. -* "XMonad.Layout.MosaicAlt": give each window a specified relative-  amount of screen space.+* "XMonad.Layout.GridVariants":+    Two layouts: one is a variant of the Grid layout that allows the+    desired aspect ratio of windows to be specified.  The other is like+    Tall but places a grid with fixed number of rows and columns in the+    master area and uses an aspect-ratio-specified layout for the+    slaves. -* "XMonad.Layout.MultiToggle": dynamically apply and unapply layout-  transformers.+* "XMonad.Layout.HintedGrid":+    A not so simple layout that attempts to put all windows in a square grid+    while obeying their size hints. -* "XMonad.Layout.Named": change the names of layouts (as reported by-  e.g. "XMonad.Hooks.DynamicLog").+* "XMonad.Layout.HintedTile":+    A gapless tiled layout that attempts to obey window size hints,+    rather than simply ignoring them. -* "XMonad.Layout.NoBorders": display windows without borders.+* "XMonad.Layout.IM":+    Layout modfier suitable for workspace with multi-windowed instant messenger+    (like Psi or Tkabber). -* "XMonad.Layout.PerWorkspace": configure layouts on a per-workspace basis.+* "XMonad.Layout.IndependentScreens":+    Utility functions for simulating independent sets of workspaces on+    each screen (like dwm's workspace model), using internal tags to+    distinguish workspaces associated with each screen. -* "XMonad.Layout.Reflect": reflect any layout vertically or horizontally.+* "XMonad.Layout.LayoutBuilder":+    A layout combinator that sends a specified number of windows to one rectangle+    and the rest to another. -* "XMonad.Layout.ResizableTile": tiled layout allowing you to change-  width and height of windows.+* "XMonad.Layout.LayoutCombinators":+    The "XMonad.Layout.LayoutCombinators" module provides combinators+    for easily combining multiple layouts into one composite layout, as+    well as a way to jump directly to any particular layout (say, with+    a keybinding) without having to cycle through other layouts to get+    to it. -* "XMonad.Layout.ResizeScreen": a layout modifier to change the screen-  geometry on one side.+* "XMonad.Layout.LayoutHints":+    Make layouts respect size hints. -* "XMonad.Layout.Roledex": a \"completely pointless layout which acts-  like Microsoft's Flip 3D\".+* "XMonad.Layout.LayoutModifier":+    A module for writing easy layout modifiers, which do not define a+    layout in and of themselves, but modify the behavior of or add new+    functionality to other layouts.  If you ever find yourself writing+    a layout which takes another layout as a parameter, chances are you+    should be writing a LayoutModifier instead! -* "XMonad.Layout.ScratchWorkspace": implements a scratch workspace-  which can be shown and hidden with keybindings.+    In case it is not clear, this module is not intended to help you+    configure xmonad, it is to help you write other extension modules.+    So get hacking! -* "XMonad.Layout.ShowWName": Show the name of the current workspace when switching.+* "XMonad.Layout.LayoutScreens":+    Divide a single screen into multiple screens. -* "XMonad.Layout.SimpleDecoration": add simple decorations to windows.+* "XMonad.Layout.LimitWindows":+    A layout modifier that limits the number of windows that can be shown. -* "XMonad.Layout.SimpleFloat": a basic floating layout.+* "XMonad.Layout.MagicFocus":+    Automagically put the focused window in the master area. -* "XMonad.Layout.Simplest": a basic, simple layout that just lays out-  all windows with a fullscreen geometry.  Used by-  "XMonad.Layout.Tabbed".+* "XMonad.Layout.Magnifier":+    Screenshot  :  <http://caladan.rave.org/magnifier.png>+    This is a layout modifier that will make a layout increase the size+    of the window that has focus. -* "XMonad.Layout.Spiral": Fibonacci spiral layout.+* "XMonad.Layout.Master":+    Layout modfier that adds a master window to another layout. -* "XMonad.Layout.Square": split the screen into a square area plus the rest.+* "XMonad.Layout.Maximize":+    Temporarily yanks the focused window out of the layout to mostly fill+    the screen. -* "XMonad.Layout.TabBarDecoration": add a bar of tabs to any layout.+* "XMonad.Layout.MessageControl":+    Provides message escaping and filtering facilities which+    help control complex nested layouts. -* "XMonad.Layout.Tabbed": a tabbed layout.+* "XMonad.Layout.Minimize":+    Makes it possible to minimize windows, temporarily removing them+    from the layout until they are restored. -* "XMonad.Layout.ThreeColumns": a layout with three columns instead of two.+* "XMonad.Layout.Monitor":+    Layout modfier for displaying some window (monitor) above other windows -* "XMonad.Layout.ToggleLayouts": toggle between two layouts.+* "XMonad.Layout.Mosaic":+    Based on MosaicAlt, but aspect ratio messages always change the aspect+    ratios, and rearranging the window stack changes the window sizes. -* "XMonad.Layout.TwoPane": split the screen horizontally and show two-  windows.+* "XMonad.Layout.MosaicAlt":+    A layout which gives each window a specified amount of screen space+    relative to the others. Compared to the 'Mosaic' layout, this one+    divides the space in a more balanced way. -* "XMonad.Layout.WindowArranger": make any layout into a-  pseudo-floating layout by allowing you to move and resize windows.+* "XMonad.Layout.MouseResizableTile":+    A layout in the spirit of "XMonad.Layout.ResizableTile", but with the option+    to use the mouse to adjust the layout. -* "XMonad.Layout.WindowNavigation": navigate around a workspace-  directionally instead of using mod-j\/k.+* "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.WorkspaceDir": set the current working directory in a-  workspace.+* "XMonad.Layout.Named":+    A module for assigning a name to a given layout. +* "XMonad.Layout.NoBorders":+    Make a given layout display without borders.  This is useful for+    full-screen or tabbed layouts, where you don't really want to waste a+    couple of pixels of real estate just to inform yourself that the visible+    window has focus.++* "XMonad.Layout.NoFrillsDecoration":+    Most basic version of decoration for windows without any additional+    modifications. In contrast to "XMonad.Layout.SimpleDecoration" this will+    result in title bars that span the entire window instead of being only the+    length of the window title.++* "XMonad.Layout.OneBig":+    Places one (master) window at top left corner of screen, and other (slave)+    windows at the top.++* "XMonad.Layout.PerWorkspace":+    Configure layouts on a per-workspace basis: use layouts and apply+    layout modifiers selectively, depending on the workspace.++* "XMonad.Layout.Reflect":+    Reflect a layout horizontally or vertically.++* "XMonad.Layout.ResizableTile":+    More useful tiled layout that allows you to change a width\/height of window.+    See also "XMonad.Layout.MouseResizableTile".++* "XMonad.Layout.ResizeScreen":+    A layout transformer to have a layout respect a given screen+    geometry. Mostly used with "Decoration" (the Horizontal and the+    Vertical version will react to SetTheme and change their dimension+    accordingly.++* "XMonad.Layout.Roledex":+    This is a completely pointless layout which acts like Microsoft's Flip 3D++* "XMonad.Layout.ShowWName":+    This is a layout modifier that will show the workspace name++* "XMonad.Layout.SimpleDecoration":+    A layout modifier for adding simple decorations to the windows of a+    given layout. The decorations are in the form of ion-like tabs+    for window titles.++* "XMonad.Layout.SimpleFloat":+    A basic floating layout.++* "XMonad.Layout.Simplest":+    A very simple layout. The simplest, afaik. Used as a base for+    decorated layouts.++* "XMonad.Layout.SimplestFloat":+    A basic floating layout like SimpleFloat but without the decoration.++* "XMonad.Layout.Spacing":+    Add a configurable amount of space around windows.++* "XMonad.Layout.Spiral":+    A spiral tiling layout.++* "XMonad.Layout.Square":+    A layout that splits the screen into a square area and the rest of the+    screen.+    This is probably only ever useful in combination with+    "XMonad.Layout.Combo".+    It sticks one window in a square region, and makes the rest+    of the windows live with what's left (in a full-screen sense).++* "XMonad.Layout.StackTile":+    A stacking layout, like dishes but with the ability to resize master pane.+    Mostly useful on small screens.++* "XMonad.Layout.SubLayouts":+    A layout combinator that allows layouts to be nested.++* "XMonad.Layout.TabBarDecoration":+    A layout modifier to add a bar of tabs to your layouts.++* "XMonad.Layout.Tabbed":+    A tabbed layout for the Xmonad Window Manager++* "XMonad.Layout.ThreeColumns":+    A layout similar to tall but with three columns. With 2560x1600 pixels this+    layout can be used for a huge main window and up to six reasonable sized+    slave windows.++* "XMonad.Layout.ToggleLayouts":+    A module to toggle between two layouts.++* "XMonad.Layout.TwoPane":+    A layout that splits the screen horizontally and shows two windows.  The+    left window is always the master window, and the right is either the+    currently focused window or the second window in layout order.++* "XMonad.Layout.WindowArranger":+    This is a pure layout modifier that will let you move and resize+    windows with the keyboard in any layout.++* "XMonad.Layout.WindowNavigation":+    WindowNavigation is an extension to allow easy navigation of a workspace.+    See also "XMonad.Actions.WindowNavigation".++* "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+    know of to attach a behavior to a workspace.  This means that any terminals+    (or other programs) pulled up in that workspace (with that layout) will+    execute in that working directory.  Sort of handy, I think.+    Note this extension requires the 'directory' package to be installed.+ -}  {- $prompts@@ -400,39 +741,69 @@  These are the available prompts: -* "XMonad.Prompt.AppendFile": append lines of text to a file.+* "XMonad.Prompt.AppLauncher":+    A module for launch applicationes that receive parameters in the command+    line. The launcher call a prompt to get the parameters. -* "XMonad.Prompt.Directory": prompt for a directory.+* "XMonad.Prompt.AppendFile":+    A prompt for appending a single line of text to a file.  Useful for+    keeping a file of notes, things to remember for later, and so on---+    using a keybinding, you can write things down just about as quickly+    as you think of them, so it doesn't have to interrupt whatever else+    you're doing.+    Who knows, it might be useful for other purposes as well! -* "XMonad.Prompt.DirExec": put a bunch of scripts you want in a-  directory, then choose from among them with this prompt.+* "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+    executable names, different behavior) - otherwise you might want to use+    "XMonad.Prompt.Shell" instead - but you want to have easy access to these+    executables through the xmonad's prompt. -* "XMonad.Prompt.Email": an example of "XMonad.Prompt.Input", send-  simple short e-mails from a prompt.+* "XMonad.Prompt.Directory":+    A directory prompt for XMonad -* "XMonad.Prompt.Input": useful for building general actions requiring-  input from a prompt.+* "XMonad.Prompt.Email":+    A prompt for sending quick, one-line emails, via the standard GNU+    \'mail\' utility (which must be in your $PATH).  This module is+    intended mostly as an example of using "XMonad.Prompt.Input" to+    build an action requiring user input. -* "XMonad.Prompt.Layout": choose a layout from a prompt.+* "XMonad.Prompt.Input":+    A generic framework for prompting the user for input and passing it+    along to some other action. -* "XMonad.Prompt.Man": open man pages.+* "XMonad.Prompt.Layout":+    A layout-selection prompt for XMonad -* "XMonad.Prompt.RunOrRaise": choose a program, and run it if not-  already running, or raise its window if it is.+* "XMonad.Prompt.Man":+    A manual page prompt for XMonad window manager.+    TODO+    * narrow completions by section number, if the one is specified+    (like @\/etc\/bash_completion@ does) -* "XMonad.Prompt.Shell": run a shell command.+* "XMonad.Prompt.RunOrRaise":+    A prompt for XMonad which will run a program, open a file,+    or raise an already running program, depending on context. -* "XMonad.Prompt.Ssh": open an ssh connection.+* "XMonad.Prompt.Shell":+    A shell prompt for XMonad -* "XMonad.Prompt.Theme": choose a decoration theme.+* "XMonad.Prompt.Ssh":+    A ssh prompt for XMonad -* "XMonad.Prompt.Window": choose an open window.+* "XMonad.Prompt.Theme":+    A prompt for changing the theme of the current workspace -* "XMonad.Prompt.Workspace": choose a workspace.+* "XMonad.Prompt.Window":+    xprompt operations to bring windows to you, and bring you to windows. -* "XMonad.Prompt.XMonad": perform various xmonad actions by choosing-  one from a prompt.+* "XMonad.Prompt.Workspace":+    A workspace prompt for XMonad +* "XMonad.Prompt.XMonad":+    A prompt for running XMonad commands+ Usually a prompt is called by some key binding. See "XMonad.Doc.Extending#Editing_key_bindings", which includes examples of adding some prompts.@@ -450,13 +821,17 @@  A non complete list with a brief description: +* "XMonad.Util.Cursor": configure the default cursor/pointer glyph.+ * "XMonad.Util.CustomKeys": configure key bindings (see   "XMonad.Doc.Extending#Editing_key_bindings"). -* "XMonad.Util.Dmenu": a dmenu binding.+* "XMonad.Util.Dmenu":+    A convenient binding to dmenu.+    Requires the process-1.0 package -* "XMonad.Util.Dzen" "XMonad.Util.Dmenu" provide useful functions for-  running dzen as a xmonad status bar and dmenu as a program launcher;+* "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.@@ -464,38 +839,68 @@ * "XMonad.Util.Font": A module for abstracting a font facility over   Core fonts and Xft -* "XMonad.Util.Invisible": a wrapper data type to store layout state-  which should not be persisted across restarts.+* "XMonad.Util.Invisible":+    A data type to store the layout state -* "XMonad.Util.Loggers": a collection of loggers that can be used in-  conjunction with "XMonad.Hooks.DynamicLog".+* "XMonad.Util.Loggers":+    A collection of simple logger functions and formatting utilities+    which can be used in the 'XMonad.Hooks.DynamicLog.ppExtras' field of+    a pretty-printing status logger format. See "XMonad.Hooks.DynamicLog"+    for more information. -* "XMonad.Util.NamedWindows": associate windows with their X titles.-  Used by, e.g. "XMonad.Layout.Tabbed".+* "XMonad.Util.NamedActions":+    A wrapper for keybinding configuration that can list the available+    keybindings. -* "XMonad.Util.Run": a collection of functions for running external-  processes.+* "XMonad.Util.NamedScratchpad":+    Like "XMonad.Util.Scratchpad" toggle windows to and from the current+    workspace. Supports several arbitrary applications at the same time. -* "XMonad.Util.Scratchpad": hotkey-launched floating terminal window.+* "XMonad.Util.NamedWindows":+    This module allows you to associate the X titles of windows with+    them. -* "XMonad.Util.Themes": a collection of themes to be used with-  floating layouts.+* "XMonad.Util.Paste":+    A module for sending key presses to windows. This modules provides generalized+    and specialized functions for this task. -* "XMonad.Util.Timer": set up a timer to handle deferred events.+* "XMonad.Util.Replace":+    Implements a @--replace@ flag outside of core. -* "XMonad.Util.WindowProperties": an EDSL for specifying and matching-  on window properties.+* "XMonad.Util.Run":+    This modules provides several commands to run an external process.+    It is composed of functions formerly defined in "XMonad.Util.Dmenu" (by+    Spencer Janssen), "XMonad.Util.Dzen" (by glasser\@mit.edu) and+    XMonad.Util.RunInXTerm (by Andrea Rossato). -* "XMonad.Util.WorkspaceCompare": general combinators for sorting-  workspaces in various ways, used by several other modules which need-  to sort workspaces (e.g. "XMonad.Hooks.DynamicLog").+* "XMonad.Util.Scratchpad":+    Very handy hotkey-launched toggleable floating terminal window. -* "XMonad.Util.XSelection" provide utilities for using the mouse-  selection;+* "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,+    persistent between xmonad restarts. -* "XMonad.Util.XUtils" and "XMonad.Util.Font" are libraries for-  accessing Xlib and XFT function in a convenient way.+* "XMonad.Util.Themes":+    A (hopefully) growing collection of themes for decorated layouts. +* "XMonad.Util.Timer":+    A module for setting up timers++* "XMonad.Util.Types":+    Miscellaneous commonly used types.++* "XMonad.Util.WindowProperties":+    EDSL for specifying window properties; various utilities related to window+    properties.++* "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++* "XMonad.Util.XUtils":+    A module for painting on the screen+ -}  --------------------------------------------------------------------------------@@ -527,9 +932,9 @@  and provide an appropriate definition of @myKeys@, such as: ->    myKeys x =->             [ ((modMask x, xK_F12), xmonadPrompt defaultXPConfig)->             , ((modMask x, xK_F3 ), shellPrompt  defaultXPConfig)+> myKeys conf@(XConfig {XMonad.modMask = modm}) =+>             [ ((modm, xK_F12), xmonadPrompt defaultXPConfig)+>             , ((modm, xK_F3 ), shellPrompt  defaultXPConfig) >             ]  This particular definition also requires importing "XMonad.Prompt",@@ -540,7 +945,7 @@  For a list of the names of particular keys (such as xK_F12, and so on), see-<http://hackage.haskell.org/packages/archive/X11/1.4.1/doc/html/Graphics-X11-Types.html>.+<http://hackage.haskell.org/packages/archive/X11/latest/doc/html/Graphics-X11-Types.html>  Usually, rather than completely redefining the key bindings, as we did above, we want to simply add some new bindings and\/or remove existing@@ -551,8 +956,9 @@ {- $keyAdding #Adding_key_bindings# -Adding key bindings can be done in different ways. The type signature-of 'XMonad.Core.XConfig.keys' is:+Adding key bindings can be done in different ways. See the end of this+section for the easiest ways. The type signature of+'XMonad.Core.XConfig.keys' is:  >    keys :: XConfig Layout -> M.Map (ButtonMask,KeySym) (X ()) @@ -571,9 +977,9 @@ For instance, if you have defined some additional key bindings like these: ->    myKeys x =->             [ ((modMask x, xK_F12), xmonadPrompt defaultXPConfig)->             , ((modMask x, xK_F3 ), shellPrompt  defaultXPConfig)+>    myKeys conf@(XConfig {XMonad.modMask = modm}) =+>             [ ((modm, xK_F12), xmonadPrompt defaultXPConfig)+>             , ((modm, xK_F3 ), shellPrompt  defaultXPConfig) >             ]  then you can create a new key bindings map by joining the default one@@ -604,9 +1010,9 @@ > >    newKeys x = M.union (keys defaultConfig x) (M.fromList (myKeys x)) >->    myKeys x =->             [ ((modMask x, xK_F12), xmonadPrompt defaultXPConfig)->             , ((modMask x, xK_F3 ), shellPrompt  defaultXPConfig)+>    myKeys conf@(XConfig {XMonad.modMask = modm}) =+>             [ ((modm, xK_F12), xmonadPrompt defaultXPConfig)+>             , ((modm, xK_F3 ), shellPrompt  defaultXPConfig) >             ]  There are much simpler ways to accomplish this, however, if you are@@ -632,8 +1038,8 @@ > >    keysToRemove :: XConfig Layout ->    [((KeyMask, KeySym),X ())] >    keysToRemove x =->             [ ((modMask x              , xK_q ), return ())->             , ((modMask x .|. shiftMask, xK_q ), return ())+>             [ ((modm              , xK_q ), return ())+>             , ((modm .|. shiftMask, xK_q ), return ()) >             ]  As you can see, it doesn't matter what actions we associate with the@@ -648,8 +1054,8 @@ > >    keysToRemove :: XConfig Layout -> [(KeyMask, KeySym)] >    keysToRemove x =->             [ (modMask x              , xK_q )->             , (modMask x .|. shiftMask, xK_q )+>             [ (modm              , xK_q )+>             , (modm .|. shiftMask, xK_q ) >             ]  Another even simpler possibility is the use of some of the utilities@@ -669,23 +1075,23 @@ >    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->    toRemove x =->        [ (modMask x              , xK_j     )->        , (modMask x              , xK_k     )->        , (modMask x              , xK_p     )->        , (modMask x .|. shiftMask, xK_p     )->        , (modMask x .|. shiftMask, xK_q     )->        , (modMask x              , xK_q     )+>    toRemove XConfig{modMask = modm} =+>        [ (modm              , xK_j     )+>        , (modm              , xK_k     )+>        , (modm              , xK_p     )+>        , (modm .|. shiftMask, xK_p     )+>        , (modm .|. shiftMask, xK_q     )+>        , (modm              , xK_q     ) >        ] ++->        -- I want modMask .|. shiftMask 1-9 to be free!->        [(shiftMask .|. modMask x, k) | k <- [xK_1 .. xK_9]]+>        -- I want modm .|. shiftMask 1-9 to be free!+>        [(shiftMask .|. modm, 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 )+>    toAdd XConfig{modMask = modm} =+>        [ ((modm              , xK_F12   ), xmonadPrompt defaultXPConfig )+>        , ((modm              , xK_F3    ), shellPrompt  defaultXPConfig ) >        ] ++->        -- Use modMask .|. shiftMask .|. controlMask 1-9 instead->        [( (m .|. modMask x, k), windows $ f i)+>        -- Use modm .|. shiftMask .|. controlMask 1-9 instead+>        [( (m .|. modm, k), windows $ f i) >         | (i, k) <- zip (workspaces x) [xK_1 .. xK_9] >        ,  (f, m) <- [(W.greedyView, 0), (W.shift, shiftMask .|. controlMask)] >        ]@@ -694,6 +1100,8 @@ module; take a look at the 'XMonad.Util.CustomKeys.customKeys' function in particular. +NOTE: modm is defined as the modMask you defined (or left as the default) in+your config. -}  {- $mouse