xmonad-contrib-bluetilebranch 0.8.1.3 → 0.9.1.4

raw patch · 193 files changed

+7949/−2865 lines, 193 filesdep +extensible-exceptionsdep ~X11dep ~basedep ~xmonad-bluetilebranchPVP ok

version bump matches the API change (PVP)

Dependencies added: extensible-exceptions

Dependency ranges changed: X11, base, xmonad-bluetilebranch

API changes (from Hackage documentation)

Files

• README +69/−15
• XMonad/Actions/BluetileCommands.hs +27/−4
• XMonad/Actions/Commands.hs +8/−9
• XMonad/Actions/ConstrainedResize.hs +3/−3
• XMonad/Actions/CopyWindow.hs +53/−27
• XMonad/Actions/CycleRecentWS.hs +1/−1
• XMonad/Actions/CycleSelectedLayouts.hs +2/−2
• XMonad/Actions/CycleWS.hs +81/−25
• XMonad/Actions/CycleWindows.hs +31/−18
• XMonad/Actions/DeManage.hs +4/−3
• XMonad/Actions/DwmPromote.hs +2/−2
• XMonad/Actions/DynamicWorkspaceGroups.hs +137/−0
• XMonad/Actions/DynamicWorkspaceOrder.hs +165/−0
• XMonad/Actions/DynamicWorkspaces.hs +70/−21
• 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 +197/−59
• XMonad/Actions/MessageFeedback.hs +2/−2
• XMonad/Actions/MouseGestures.hs +9/−9
• XMonad/Actions/MouseResize.hs +7/−6
• XMonad/Actions/NoBorders.hs +2/−2
• XMonad/Actions/OnScreen.hs +188/−0
• XMonad/Actions/PerWorkspaceKeys.hs +4/−5
• XMonad/Actions/PhysicalScreens.hs +40/−13
• XMonad/Actions/Plane.hs +2/−2
• XMonad/Actions/Promote.hs +1/−1
• XMonad/Actions/RandomBackground.hs +72/−0
• XMonad/Actions/RotSlaves.hs +2/−2
• XMonad/Actions/Search.hs +51/−43
• XMonad/Actions/SimpleDate.hs +1/−1
• XMonad/Actions/SinkAll.hs +1/−1
• XMonad/Actions/SpawnOn.hs +39/−30
• XMonad/Actions/Submap.hs +4/−4
• XMonad/Actions/SwapWorkspaces.hs +3/−3
• XMonad/Actions/TagWindows.hs +11/−11
• XMonad/Actions/TopicSpace.hs +156/−182
• XMonad/Actions/UpdateFocus.hs +3/−4
• XMonad/Actions/UpdatePointer.hs +7/−2
• XMonad/Actions/Warp.hs +2/−3
• XMonad/Actions/WindowBringer.hs +8/−8
• XMonad/Actions/WindowGo.hs +59/−46
• XMonad/Actions/WindowMenu.hs +30/−18
• XMonad/Actions/WindowNavigation.hs +22/−21
• XMonad/Actions/WithAll.hs +1/−3
• XMonad/Actions/WorkspaceCursors.hs +219/−0
• XMonad/Actions/WorkspaceNames.hs +155/−0
• XMonad/Config/Arossato.hs +2/−1
• XMonad/Config/Azerty.hs +3/−1
• XMonad/Config/Bluetile.hs +217/−0
• XMonad/Config/Desktop.hs +150/−8
• XMonad/Config/Droundy.hs +12/−16
• XMonad/Config/Gnome.hs +30/−3
• XMonad/Config/Kde.hs +7/−3
• XMonad/Config/Sjanssen.hs +26/−20
• XMonad/Config/Xfce.hs +6/−3
• XMonad/Doc/Configuring.hs +22/−12
• XMonad/Doc/Extending.hs +614/−205
• XMonad/Hooks/BluetileDock.hs +0/−43
• XMonad/Hooks/CurrentWorkspaceOnTop.hs +62/−0
• XMonad/Hooks/CustomRestart.hs +0/−32
• XMonad/Hooks/DynamicHooks.hs +23/−52
• XMonad/Hooks/DynamicLog.hs +53/−39
• XMonad/Hooks/EventHook.hs +0/−107
• XMonad/Hooks/EwmhDesktops.hs +61/−32
• XMonad/Hooks/FadeInactive.hs +32/−28
• XMonad/Hooks/FloatNext.hs +26/−31
• XMonad/Hooks/InsertPosition.hs +1/−1
• XMonad/Hooks/ManageDocks.hs +63/−38
• XMonad/Hooks/ManageHelpers.hs +29/−10
• XMonad/Hooks/Place.hs +48/−48
• XMonad/Hooks/PositionStoreHooks.hs +95/−0
• XMonad/Hooks/RestoreMinimized.hs +16/−1
• XMonad/Hooks/ScreenCorners.hs +170/−0
• XMonad/Hooks/Script.hs +1/−2
• XMonad/Hooks/ServerMode.hs +11/−7
• XMonad/Hooks/UrgencyHook.hs +26/−23
• XMonad/Hooks/WorkspaceByPos.hs +28/−24
• XMonad/Hooks/XPropManage.hs +2/−4
• XMonad/Layout/Accordion.hs +4/−4
• XMonad/Layout/AutoMaster.hs +123/−0
• XMonad/Layout/BorderResize.hs +158/−87
• XMonad/Layout/BoringWindows.hs +14/−9
• XMonad/Layout/ButtonDecoration.hs +55/−0
• XMonad/Layout/CenteredMaster.hs +11/−11
• XMonad/Layout/Circle.hs +2/−2
• XMonad/Layout/Column.hs +71/−0
• XMonad/Layout/Combo.hs +4/−4
• XMonad/Layout/ComboP.hs +7/−7
• XMonad/Layout/Cross.hs +2/−2
• XMonad/Layout/Decoration.hs +68/−106
• XMonad/Layout/DecorationAddons.hs +123/−0
• XMonad/Layout/DecorationMadness.hs +10/−11
• XMonad/Layout/DecorationUtils.hs +0/−45
• XMonad/Layout/Dishes.hs +2/−3
• XMonad/Layout/DragPane.hs +11/−12
• XMonad/Layout/DraggingVisualizer.hs +5/−1
• XMonad/Layout/Drawer.hs +129/−0
• XMonad/Layout/FixedColumn.hs +2/−2
• XMonad/Layout/Gaps.hs +15/−19
• XMonad/Layout/Grid.hs +3/−3
• XMonad/Layout/GridVariants.hs +4/−4
• XMonad/Layout/HintedGrid.hs +3/−3
• XMonad/Layout/IM.hs +3/−5
• XMonad/Layout/IndependentScreens.hs +58/−12
• XMonad/Layout/LayoutBuilder.hs +9/−12
• XMonad/Layout/LayoutCombinators.hs +11/−12
• XMonad/Layout/LayoutHints.hs +167/−16
• XMonad/Layout/LayoutModifier.hs +1/−2
• XMonad/Layout/LayoutScreens.hs +21/−5
• XMonad/Layout/LimitWindows.hs +159/−0
• XMonad/Layout/MagicFocus.hs +19/−3
• XMonad/Layout/Magnifier.hs +8/−8
• XMonad/Layout/Master.hs +1/−1
• XMonad/Layout/Maximize.hs +4/−5
• XMonad/Layout/MessageControl.hs +126/−0
• XMonad/Layout/Minimize.hs +75/−17
• XMonad/Layout/Monitor.hs +18/−18
• XMonad/Layout/Mosaic.hs +116/−106
• XMonad/Layout/MosaicAlt.hs +10/−11
• XMonad/Layout/MouseResizableTile.hs +73/−47
• XMonad/Layout/MultiColumns.hs +145/−0
• XMonad/Layout/MultiToggle.hs +35/−67
• XMonad/Layout/MultiToggle/Instances.hs +7/−8
• XMonad/Layout/Named.hs +2/−2
• XMonad/Layout/NoBorders.hs +0/−1
• XMonad/Layout/NoFrillsDecoration.hs +21/−1
• XMonad/Layout/OneBig.hs +4/−4
• XMonad/Layout/PositionStoreFloat.hs +31/−3
• XMonad/Layout/Reflect.hs +7/−10
• XMonad/Layout/ResizableTile.hs +20/−8
• XMonad/Layout/Roledex.hs +13/−9
• XMonad/Layout/ShowWName.hs +1/−1
• 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 +120/−67
• XMonad/Layout/TabBarDecoration.hs +1/−0
• XMonad/Layout/Tabbed.hs +26/−13
• XMonad/Layout/ThreeColumns.hs +13/−9
• XMonad/Layout/ThreeColumnsMiddle.hs +0/−4
• XMonad/Layout/ToggleLayouts.hs +5/−6
• XMonad/Layout/TwoPane.hs +6/−6
• XMonad/Layout/WindowArranger.hs +31/−51
• XMonad/Layout/WindowNavigation.hs +22/−30
• XMonad/Layout/WindowSwitcherDecoration.hs +45/−6
• XMonad/Layout/WorkspaceDir.hs +4/−5
• XMonad/Prompt.hs +234/−144
• XMonad/Prompt/AppLauncher.hs +2/−2
• XMonad/Prompt/AppendFile.hs +4/−6
• XMonad/Prompt/Directory.hs +2/−2
• XMonad/Prompt/Email.hs +3/−3
• XMonad/Prompt/Input.hs +2/−2
• XMonad/Prompt/Layout.hs +3/−6
• XMonad/Prompt/Man.hs +4/−3
• XMonad/Prompt/RunOrRaise.hs +7/−8
• XMonad/Prompt/Shell.hs +6/−7
• XMonad/Prompt/Ssh.hs +3/−4
• XMonad/Prompt/Theme.hs +1/−2
• XMonad/Prompt/Window.hs +9/−10
• XMonad/Prompt/Workspace.hs +3/−6
• XMonad/Prompt/XMonad.hs +1/−1
• XMonad/Util/Cursor.hs +46/−0
• XMonad/Util/Dmenu.hs +21/−8
• XMonad/Util/Dzen.hs +145/−13
• XMonad/Util/EZConfig.hs +25/−9
• XMonad/Util/ExtensibleState.hs +115/−0
• XMonad/Util/Font.hsc +3/−15
• XMonad/Util/Invisible.hs +3/−3
• XMonad/Util/Loggers.hs +1/−1
• XMonad/Util/NamedActions.hs +305/−0
• XMonad/Util/NamedScratchpad.hs +34/−16
• XMonad/Util/NamedWindows.hs +3/−3
• XMonad/Util/Paste.hs +5/−2
• XMonad/Util/PositionStore.hs +77/−0
• XMonad/Util/Replace.hs +116/−0
• XMonad/Util/Run.hs +27/−19
• XMonad/Util/Scratchpad.hs +13/−48
• XMonad/Util/SpawnOnce.hs +39/−0
• XMonad/Util/StringProp.hs +56/−0
• XMonad/Util/Themes.hs +8/−8
• XMonad/Util/Timer.hs +1/−2
• XMonad/Util/Types.hs +30/−0
• XMonad/Util/WindowProperties.hs +4/−9
• XMonad/Util/WorkspaceCompare.hs +20/−2
• XMonad/Util/XSelection.hs +10/−92
• xmonad-contrib-bluetilebranch.cabal +59/−24

@@ -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.

@@ -8,18 +8,39 @@ -- Stability   :  unstable -- Portability :  not portable --+-- This is a list of selected commands that can be made available using+-- "XMonad.Hooks.ServerMode" to allow external programs to control+-- the window manager. Bluetile (<http://projects.haskell.org/bluetile/>)+-- uses this to enable its dock application to do things like changing+-- workspaces and layouts.+-- -----------------------------------------------------------------------------  module XMonad.Actions.BluetileCommands (-                             bluetileCommands-                              ) where+    -- * Usage+    -- $usage+    bluetileCommands+    ) where  import XMonad import qualified XMonad.StackSet as W import XMonad.Layout.LayoutCombinators import System.Exit --- | Generate a list of commands to switch to workspaces (on the given screen).+-- $usage+--+-- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:+--+-- >    import XMonad.Hooks.ServerMode+-- >    import XMonad.Actions.BluetileCommands+--+-- Then edit your @handleEventHook@:+--+-- > main = xmonad defaultConfig { handleEventHook = serverModeEventHook' bluetileCommands }+--+-- See the documentation of "XMonad.Hooks.ServerMode" for details on+-- how to actually invoke the commands from external programs.+ workspaceCommands :: Int -> X [(String, X ())] workspaceCommands sid = asks (workspaces . config) >>= \spaces -> return                             [(("greedyView" ++ show i),@@ -51,9 +72,11 @@  bluetileCommands :: X [(String, X ())] bluetileCommands = do+    let restartCommand = [ ("restart bluetile", restart "bluetile" True) ]     wscmds0 <- workspaceCommands 0     wscmds1 <- workspaceCommands 1-    return $ wscmds0 ++ layoutCommands 0 ++ masterAreaCommands 0 ++ quitCommands+    return $ restartCommand+                ++ wscmds0 ++ layoutCommands 0 ++ masterAreaCommands 0 ++ quitCommands                 ++ wscmds1 ++ layoutCommands 1 ++ masterAreaCommands 1 ++ quitCommands  activateScreen :: Int -> X ()

@@ -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

@@ -9,7 +9,7 @@ -- 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. -- -----------------------------------------------------------------------------@@ -19,12 +19,16 @@                                  -- $usage                                  copy, copyToAll, copyWindow, runOrCopy                                  , killAllOtherCopies, kill1+                                 -- * Highlight workspaces containing copies in logHook+                                 -- $logHook+                                 , wsContainingCopies                                 ) where -import Prelude hiding (filter)-import Control.Monad (filterM)+import XMonad+import Control.Arrow ((&&&)) import qualified Data.List as L-import XMonad hiding (modify, workspaces)++import XMonad.Actions.WindowGo import qualified XMonad.StackSet as W  -- $usage@@ -38,7 +42,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)]] --@@ -50,12 +54,12 @@ -- 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 a workset to a workset maybe you don't+-- 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: ----- >  , ((modMask x, xK_b    ), runOrCopy "firefox" (className =? "Firefox")) -- @@ run or copy firefox+-- >  , ((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@@ -65,22 +69,36 @@ -- -- 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 focused window to a new workspace.+-- $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.+-- | 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+-- | 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 `W.tagMember` s@@ -92,28 +110,23 @@                                              else Just $ W.Stack a (L.delete a l) (L.delete a (t:r))) s  --- | runOrCopy .  runOrCopy will run the provided shell command unless it can+-- | 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 --- | copyMaybe. Copies "XMonad.Actions.WindowGo" ('raiseMaybe')---   TODO: Factor out and improve with regard to WindowGo.+-- | Copy a window if it exists, run the first argument otherwise. copyMaybe :: X () -> Query Bool -> X ()-copyMaybe f thatUserQuery = withWindowSet $ \s -> do-    maybeResult <- filterM (runQuery thatUserQuery) (W.allWindows s)-    case maybeResult of-        []    -> f-        (x:_) -> windows $ copyWindow x (W.currentTag s)-+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 (W.peek ss) $ \w -> if W.member w $ delete'' w ss@@ -121,10 +134,8 @@                                       else kill     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'------ TODO: Call 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 (W.peek ss) $ \w -> windows $@@ -135,3 +146,18 @@                                   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,23 +60,28 @@                                 -- * Moving between workspaces, take two!                                 -- $taketwo -                              , WSDirection(..)+                              , Direction1D(..)                               , WSType(..)                                , shiftTo                               , moveTo+                              , doTo                                  -- * 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 +91,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 +144,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,15 +213,16 @@  -} --- | 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+            | WSTagGroup Char+                          -- ^ cycle through workspaces in the same group, the+                          --   group name is all characters up to the first+                          --   separator character or the end of the tag             | WSIs (X (WindowSpace -> Bool))                           -- ^ cycle through workspaces satisfying                           --   an arbitrary predicate@@ -189,18 +237,26 @@                                     hi <- wsTypeToPred HiddenWS                                     return (\w -> hi w && ne w) wsTypeToPred AnyWS      = return (const True)+wsTypeToPred (WSTagGroup sep) = do cur <- (groupName.workspace.current) `fmap` gets windowset+                                   return $ (cur ==).groupName+                                   where groupName = takeWhile (/=sep).tag wsTypeToPred (WSIs p)   = p  -- | View the next workspace in the given direction that satisfies --   the given condition.-moveTo :: WSDirection -> WSType -> X ()-moveTo dir t = findWorkspace getSortByIndex dir t 1 >>= windows . greedyView+moveTo :: Direction1D -> WSType -> X ()+moveTo dir t = doTo dir t getSortByIndex (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 dir t = findWorkspace getSortByIndex dir t 1 >>= windows . shift+shiftTo :: Direction1D -> WSType -> X ()+shiftTo dir t = doTo dir t getSortByIndex (windows . shift) +-- | Using the given sort, find the next workspace in the given+-- direction of the given type, and perform the given action on it.+doTo :: Direction1D -> WSType -> X WorkspaceSort -> (WorkspaceId -> X ()) -> X ()+doTo dir t srt act = findWorkspace srt dir t 1 >>= act+ -- | Given a function @s@ to sort workspaces, a direction @dir@, a --   predicate @p@ on workspaces, and an integer @n@, find the tag of --   the workspace which is @n@ away from the current workspace in@@ -214,7 +270,7 @@ --   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@@ -229,7 +285,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'

@@ -9,8 +9,10 @@ -- Portability  : unportable -- -- Provides bindings to cycle windows up or down on the current workspace--- stack while maintaining focus in place. Bindings are available to:+-- 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@@ -18,11 +20,11 @@ -- * 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--- "XMonad.Layout.Mosaic" with three or four panes. See also--- "XMonad.Actions.RotSlaves" for related actions.+-- 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@@ -53,6 +55,8 @@ 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: --@@ -62,15 +66,15 @@ -- > -- >              -- make sure mod matches keysym -- >  , ((mod4Mask,  xK_s), cycleRecentWindows [xK_Super_L] xK_s xK_w)--- >  , ((modMask x, xK_z), rotOpposite)--- >  , ((modMask x                , xK_i), rotUnfocusedUp)--- >  , ((modMask x                , xK_u), rotUnfocusedDown)--- >  , ((modMask x .|. controlMask, xK_i), rotFocusedUp)--- >  , ((modMask x .|. controlMask, xK_u), rotFocusedDown)+-- >  , ((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". +-- 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@@ -86,9 +90,9 @@ and either  > -- modify the window rotation bindings-> , ((modMask x .|. controlMask, xK_i   ), rotFocusedUp+> , ((modm .|. controlMask, xK_i   ), rotFocusedUp >                                            >> updatePointer (Relative 1 1))-> , ((modMask x .|. controlMask, xK_u   ), rotFocusedDown+> , ((modm .|. controlMask, xK_u   ), rotFocusedDown >                                            >> updatePointer (Relative 1 1)) > >    -- or add to xmonad's logHook@@ -174,12 +178,19 @@ 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') = (\(f,s) -> (f, reverse s)) . splitAt (length l) $+        (l',t':r') =  second reverse . splitAt (length l) $                                 reverse (take part rrvl ++ t : drop part rrvl)   -- $focused--- Rotate windows through the focused frame, excluding the \"next\" window.+-- 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@@ -199,7 +210,7 @@  -- $unfocused -- Rotate windows through the unfocused frames. This is similar to--- rotSlaves, from "XMonad.Actions.RotSlaves", but excludes the current+-- @rotSlaves@, from "XMonad.Actions.RotSlaves", but excludes the current -- frame rather than master. rotUnfocusedUp :: X () rotUnfocusedUp = windows . W.modify' $ rotUnfocused' rotUp@@ -215,8 +226,10 @@            (revls',rs') = splitAt (length ls) (f $ master:revls ++ rs)  -- $generic--- Generic list rotations+-- Generic list rotations such that @rotUp [1..4]@ is equivalent to+-- @[2,3,4,1]@ and @rotDown [1..4]@ to @[4,1,2,3]@. They both are+-- @id@ for null or singleton lists. rotUp :: [a] -> [a]-rotUp   l = tail l ++ [head l]+rotUp   l = drop 1 l ++ take 1 l rotDown :: [a] -> [a]-rotDown l = last l : init l+rotDown = reverse . rotUp . reverse

@@ -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".

@@ -0,0 +1,137 @@+{-# LANGUAGE DeriveDataTypeable #-}++-----------------------------------------------------------------------------+-- |+-- Module      :  XMonad.Actions.DynamicWorkspaceGroups+-- Copyright   :  (c) Brent Yorgey 2009+-- License     :  BSD-style (see LICENSE)+--+-- Maintainer  :  <byorgey@gmail.com>+-- Stability   :  experimental+-- Portability :  unportable+--+-- Dynamically manage \"workspace groups\", sets of workspaces being+-- used together for some common task or purpose, to allow switching+-- between workspace groups in a single action.  Note that this only+-- makes sense for multi-head setups.+--+-----------------------------------------------------------------------------++module XMonad.Actions.DynamicWorkspaceGroups+    ( -- * Usage+      -- $usage++      WSGroupId++    , addWSGroup+    , addCurrentWSGroup+    , forgetWSGroup+    , viewWSGroup++    , promptWSGroupView+    , promptWSGroupAdd+    , promptWSGroupForget+    ) where++import Data.List (find)+import Control.Arrow ((&&&))+import qualified Data.Map as M++import XMonad+import qualified XMonad.StackSet as W++import XMonad.Prompt+import qualified XMonad.Util.ExtensibleState as XS++-- $usage+-- You can use this module by importing it into your ~\/.xmonad\/xmonad.hs file:+--+-- > import XMonad.Actions.DynamicWorkspaceGroups+--+-- Then add keybindings like the following (this example uses+-- "XMonad.Util.EZConfig"-style keybindings, but this is not necessary):+--+-- >    , ("M-y n", promptWSGroupAdd myXPConfig "Name this group: ")+-- >    , ("M-y g", promptWSGroupView myXPConfig "Go to group: ")+-- >    , ("M-y d", promptWSGroupForget myXPConfig "Forget group: ")+--++type WSGroup = [(ScreenId,WorkspaceId)]++type WSGroupId = String++data WSGroupStorage = WSG { unWSG :: M.Map WSGroupId WSGroup }+  deriving (Typeable, Read, Show)++withWSG :: (M.Map WSGroupId WSGroup -> M.Map WSGroupId WSGroup) -> WSGroupStorage -> WSGroupStorage+withWSG f = WSG . f . unWSG++instance ExtensionClass WSGroupStorage where+  initialValue = WSG $ M.empty+  extensionType = PersistentExtension++-- | Add a new workspace group with the given name.+addWSGroup :: WSGroupId -> [WorkspaceId] -> X ()+addWSGroup name wids = withWindowSet $ \w -> do+  let wss  = map ((W.tag . W.workspace) &&& W.screen) $ W.screens w+      wmap = mapM (strength . (flip lookup wss &&& id)) wids+  case wmap of+    Just ps -> XS.modify . withWSG . M.insert name $ ps+    Nothing -> return ()+ where strength (ma, b) = ma >>= \a -> return (a,b)++-- | Give a name to the current workspace group.+addCurrentWSGroup :: WSGroupId -> X ()+addCurrentWSGroup name = withWindowSet $ \w ->+  addWSGroup name $ map (W.tag . W.workspace) (W.current w : W.visible w)++-- | Delete the named workspace group from the list of workspace+--   groups.  Note that this has no effect on the workspaces involved;+--   it simply forgets the given name.+forgetWSGroup :: WSGroupId -> X ()+forgetWSGroup = XS.modify . withWSG . M.delete++-- | View the workspace group with the given name.+viewWSGroup :: WSGroupId -> X ()+viewWSGroup name = do+  WSG m <- XS.get+  case M.lookup name m of+    Just grp -> mapM_ (uncurry viewWS) grp+    Nothing -> return ()++-- | View the given workspace on the given screen.+viewWS :: ScreenId -> WorkspaceId -> X ()+viewWS sid wid = do+  mw <- findScreenWS sid+  case mw of+    Just w -> do+      windows $ W.view w+      windows $ W.greedyView wid+    Nothing -> return ()++-- | Find the workspace which is currently on the given screen.+findScreenWS :: ScreenId -> X (Maybe WorkspaceId)+findScreenWS sid = withWindowSet $+  return . fmap (W.tag . W.workspace) . find ((==sid) . W.screen) . W.screens++data WSGPrompt = WSGPrompt String++instance XPrompt WSGPrompt where+  showXPrompt (WSGPrompt s) = s++-- | Prompt for a workspace group to view.+promptWSGroupView :: XPConfig -> String -> X ()+promptWSGroupView xp s = do+  gs <- fmap (M.keys . unWSG) XS.get+  mkXPrompt (WSGPrompt s) xp (mkComplFunFromList' gs) viewWSGroup++-- | Prompt for a name for the current workspace group.+promptWSGroupAdd :: XPConfig -> String -> X ()+promptWSGroupAdd xp s =+  mkXPrompt (WSGPrompt s) xp (const $ return []) addCurrentWSGroup++-- | Prompt for a workspace group to forget.+promptWSGroupForget :: XPConfig -> String -> X ()+promptWSGroupForget xp s = do+  gs <- fmap (M.keys . unWSG) XS.get+  mkXPrompt (WSGPrompt s) xp (mkComplFunFromList' gs) forgetWSGroup

@@ -0,0 +1,165 @@+{-# LANGUAGE DeriveDataTypeable #-}++-----------------------------------------------------------------------------+-- |+-- Module      :  XMonad.Actions.DynamicWorkspaceOrder+-- Copyright   :  (c) Brent Yorgey 2009+-- License     :  BSD-style (see LICENSE)+--+-- Maintainer  :  <byorgey@gmail.com>+-- Stability   :  experimental+-- Portability :  unportable+--+-- Remember a dynamically updateable ordering on workspaces, together+-- with tools for using this ordering with "XMonad.Actions.CycleWS"+-- and "XMonad.Hooks.DynamicLog".+--+-----------------------------------------------------------------------------++module XMonad.Actions.DynamicWorkspaceOrder+    ( -- * Usage+      -- $usage++      getWsCompareByOrder+    , getSortByOrder+    , swapWith++    , moveTo+    , moveToGreedy+    , shiftTo++    ) where++import XMonad+import qualified XMonad.StackSet as W+import qualified XMonad.Util.ExtensibleState as XS++import XMonad.Util.WorkspaceCompare (WorkspaceCompare, WorkspaceSort, mkWsSort)+import XMonad.Actions.CycleWS (findWorkspace, WSType(..), Direction1D(..), doTo)++import qualified Data.Map as M+import qualified Data.Set as S+import Data.Maybe (fromJust, fromMaybe)+import Data.Ord (comparing)++-- $usage+-- You can use this module by importing it into your ~\/.xmonad\/xmonad.hs file:+--+-- > import qualified XMonad.Actions.DynamicWorkspaceOrder as DO+--+-- Then add keybindings to swap the order of workspaces (these+-- examples use "XMonad.Util.EZConfig" emacs-style keybindings):+--+-- >        , ("M-C-<R>",   DO.swapWith Next NonEmptyWS)+-- >        , ("M-C-<L>",   DO.swapWith Prev NonEmptyWS)+--+-- See "XMonad.Actions.CycleWS" for information on the possible+-- arguments to 'swapWith'.+--+-- However, by itself this will do nothing; 'swapWith' does not change+-- the actual workspaces in any way.  It simply keeps track of an+-- auxiliary ordering on workspaces.  Anything which cares about the+-- order of workspaces must be updated to use the auxiliary ordering.+--+-- To change the order in which workspaces are displayed by+-- "XMonad.Hooks.DynamicLog", use 'getSortByOrder' in your+-- 'XMonad.Hooks.DynamicLog.ppSort' field, for example:+--+-- >   ... dynamicLogWithPP $ byorgeyPP {+-- >     ...+-- >     , ppSort = DO.getSortByOrder+-- >     ...+-- >   }+--+-- To use workspace cycling commands like those from+-- "XMonad.Actions.CycleWS", use the versions of 'moveTo',+-- 'moveToGreedy', and 'shiftTo' exported by this module.  For example:+--+-- >     , ("M-S-<R>",   DO.shiftTo Next HiddenNonEmptyWS)+-- >     , ("M-S-<L>",   DO.shiftTo Prev HiddenNonEmptyWS)+-- >     , ("M-<R>",     DO.moveTo Next HiddenNonEmptyWS)+-- >     , ("M-<L>",     DO.moveTo Prev HiddenNonEmptyWS)+--+-- For slight variations on these, use the source for examples and+-- tweak as desired.++-- | Extensible state storage for the workspace order.+data WSOrderStorage = WSO { unWSO :: Maybe (M.Map WorkspaceId Int) }+  deriving (Typeable, Read, Show)++instance ExtensionClass WSOrderStorage where+  initialValue = WSO Nothing+  extensionType = PersistentExtension++-- | Lift a Map function to a function on WSOrderStorage.+withWSO :: (M.Map WorkspaceId Int -> M.Map WorkspaceId Int)+           -> (WSOrderStorage -> WSOrderStorage)+withWSO f = WSO . fmap f . unWSO++-- | Update the ordering storage: initialize if it doesn't yet exist;+-- add newly created workspaces at the end as necessary.+updateOrder :: X ()+updateOrder = do+  WSO mm <- XS.get+  case mm of+    Nothing -> do+      -- initialize using ordering of workspaces from the user's config+      ws <- asks (workspaces . config)+      XS.put . WSO . Just . M.fromList $ zip ws [0..]+    Just m -> do+      -- check for new workspaces and add them at the end+      curWs <- gets (S.fromList . map W.tag . W.workspaces . windowset)+      let mappedWs  = M.keysSet m+          newWs     = curWs `S.difference` mappedWs+          nextIndex = 1 + maximum (-1 : M.elems m)+          newWsIxs  = zip (S.toAscList newWs) [nextIndex..]+      XS.modify . withWSO . M.union . M.fromList $ newWsIxs++-- | A comparison function which orders workspaces according to the+-- stored dynamic ordering.+getWsCompareByOrder :: X WorkspaceCompare+getWsCompareByOrder = do+  updateOrder+  -- after the call to updateOrder we are guaranteed that the dynamic+  -- workspace order is initialized and contains all existing+  -- workspaces.+  WSO (Just m) <- XS.get+  return $ comparing (fromMaybe 1000 . flip M.lookup m)++-- | Sort workspaces according to the stored dynamic ordering.+getSortByOrder :: X WorkspaceSort+getSortByOrder = mkWsSort getWsCompareByOrder++-- | Swap the current workspace with another workspace in the stored+-- dynamic order.+swapWith :: Direction1D -> WSType -> X ()+swapWith dir which = findWorkspace getSortByOrder dir which 1 >>= swapWithCurrent++-- | Swap the given workspace with the current one.+swapWithCurrent :: WorkspaceId -> X ()+swapWithCurrent w = do+  cur <- gets (W.currentTag . windowset)+  swapOrder w cur++-- | Swap the two given workspaces in the dynamic order.+swapOrder :: WorkspaceId -> WorkspaceId -> X ()+swapOrder w1 w2 = do+  io $ print (w1,w2)+  WSO (Just m) <- XS.get+  let [i1,i2] = map (fromJust . flip M.lookup m) [w1,w2]+  XS.modify (withWSO (M.insert w1 i2 . M.insert w2 i1))+  windows id  -- force a status bar update++-- | View the next workspace of the given type in the given direction,+-- where \"next\" is determined using the dynamic workspace order.+moveTo :: Direction1D -> WSType -> X ()+moveTo dir t = doTo dir t getSortByOrder (windows . W.view)++-- | Same as 'moveTo', but using 'greedyView' instead of 'view'.+moveToGreedy :: Direction1D -> WSType -> X ()+moveToGreedy dir t = doTo dir t getSortByOrder (windows . W.greedyView)++-- | Shift the currently focused window to the next workspace of the+-- given type in the given direction, using the dynamic workspace order.+shiftTo :: Direction1D -> WSType -> X ()+shiftTo dir t = doTo dir t getSortByOrder (windows . W.shift)

@@ -8,15 +8,18 @@ -- Stability   :  unstable -- Portability :  unportable ----- Provides bindings to add and delete workspaces.  Note that you may only--- delete a workspace that is already empty.+-- Provides bindings to add and delete workspaces. -- -----------------------------------------------------------------------------  module XMonad.Actions.DynamicWorkspaces (                                          -- * Usage                                          -- $usage-                                         addWorkspace, removeWorkspace,+                                         addWorkspace, addWorkspacePrompt,+                                         removeWorkspace,+                                         removeEmptyWorkspace,+                                         removeEmptyWorkspaceAfter,+                                         removeEmptyWorkspaceAfterExcept,                                          addHiddenWorkspace,                                          withWorkspace,                                          selectWorkspace, renameWorkspace,@@ -28,6 +31,9 @@ import XMonad.Prompt.Workspace import XMonad.Prompt ( XPConfig, mkXPrompt, XPrompt(..) ) import XMonad.Util.WorkspaceCompare ( getSortByIndex )+import Data.List (find)+import Data.Maybe (isNothing)+import Control.Monad (when)  -- $usage -- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@ file:@@ -36,18 +42,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".@@ -97,25 +103,68 @@                             then windows $ greedyView w                             else addWorkspace w --- | Add a new workspace with the given name.+-- | Add a new workspace with the given name, or do nothing if a+--   workspace with the given name already exists; then switch to the+--   newly created workspace. addWorkspace :: String -> X () addWorkspace newtag = addHiddenWorkspace newtag >> windows (greedyView newtag) +-- | Prompt for the name of a new workspace, add it if it does not+--   already exist, and switch to it.+addWorkspacePrompt :: XPConfig -> X ()+addWorkspacePrompt conf = mkXPrompt (Wor "New workspace name: ") conf (const (return [])) addWorkspace --- | Add a new hidden workspace with the given name.+-- | Add a new hidden workspace with the given name, or do nothing if+--   a workspace with the given name already exists. addHiddenWorkspace :: String -> X ()-addHiddenWorkspace newtag = do l <- asks (layoutHook . config)-                               windows (addHiddenWorkspace' newtag l)+addHiddenWorkspace newtag =+  whenX (gets (not . tagMember newtag . windowset)) $ do+    l <- asks (layoutHook . config)+    windows (addHiddenWorkspace' newtag l)  -- | Remove the current workspace if it contains no windows.+removeEmptyWorkspace :: X ()+removeEmptyWorkspace = gets (currentTag . windowset) >>= removeEmptyWorkspaceByTag++-- | Remove the current workspace. removeWorkspace :: X ()-removeWorkspace = do s <- gets windowset-                     case s of-                       StackSet { current = Screen { workspace = torem }-                                , hidden = (w:_) }-                           -> do windows $ view (tag w)-                                 windows (removeWorkspace' (tag torem))-                       _ -> return ()+removeWorkspace = gets (currentTag . windowset) >>= removeWorkspaceByTag++-- | Remove workspace with specific tag if it contains no windows. Only works+--   on the current or the last workspace.+removeEmptyWorkspaceByTag :: String -> X ()+removeEmptyWorkspaceByTag t = whenX (isEmpty t) $ removeWorkspaceByTag t++-- | Remove workspace with specific tag. Only works on the current or the last workspace.+removeWorkspaceByTag :: String -> X ()+removeWorkspaceByTag torem = do+    s <- gets windowset+    case s of+        StackSet { current = Screen { workspace = cur }, hidden = (w:_) } -> do+                when (torem==tag cur) $ windows $ view $ tag w+                windows $ removeWorkspace' torem+        _ -> return ()++-- | Remove the current workspace after an operation if it is empty and hidden.+--   Can be used to remove a workspace if it is empty when leaving it. The+--   operation may only change workspace once, otherwise the workspace will not+--   be removed.+removeEmptyWorkspaceAfter :: X () -> X ()+removeEmptyWorkspaceAfter = removeEmptyWorkspaceAfterExcept []++-- | Like 'removeEmptyWorkspaceAfter' but use a list of sticky workspaces,+--   whose entries will never be removed.+removeEmptyWorkspaceAfterExcept :: [String] -> X () -> X ()+removeEmptyWorkspaceAfterExcept sticky f = do+    before <- gets (currentTag . windowset)+    f+    after <- gets (currentTag . windowset)+    when (before/=after && before `notElem` sticky) $ removeEmptyWorkspaceByTag before++isEmpty :: String -> X Bool+isEmpty t = do wsl <- gets $ workspaces . windowset+               let mws = find (\ws -> tag ws == t) wsl+               return $ maybe True (isNothing . stack) mws  addHiddenWorkspace' :: i -> l -> StackSet i l a sid sd -> StackSet i l a sid sd addHiddenWorkspace' newtag l s@(StackSet { hidden = ws }) = s { hidden = Workspace newtag l Nothing:ws }

@@ -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

@@ -1,4 +1,4 @@-{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE ScopedTypeVariables, GeneralizedNewtypeDeriving, TypeSynonymInstances, FlexibleInstances, OverlappingInstances #-} ----------------------------------------------------------------------------- -- | -- Module      :  XMonad.Actions.GridSelect@@ -17,31 +17,52 @@ module XMonad.Actions.GridSelect (     -- * Usage     -- $usage++    -- ** Customizing+    -- *** Using a common GSConfig+    -- $commonGSConfig++    -- *** Custom keybindings+    -- $keybindings++    -- * Configuration     GSConfig(..),     defaultGSConfig,-    defaultGSSpawnConfig,+    NavigateMap,+    TwoDPosition,     buildDefaultGSConfig,++    -- * Variations on 'gridselect'     gridselect,     gridselectWindow,     withSelectedWindow,     bringSelected,     goToSelected,+    gridselectWorkspace,     spawnSelected,     runSelectedAction,++    -- * Colorizers+    HasColorizer(defaultColorizer),     fromClassName,-    defaultColorizer,+    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 XMonad+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.DecorationUtils+import XMonad.Layout.Decoration import XMonad.Util.NamedWindows import XMonad.Actions.WindowBringer (bringWindow) import Text.Printf@@ -56,26 +77,125 @@ -- -- Then add a keybinding, e.g. ----- >    , ((modMask x, xK_g), goToSelected defaultGSConfig)------ Screenshot: <http://clemens.endorphin.org/gridselect.png>+-- >    , ((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: ----- >   , ((modMask x, xK_s), spawnSelected defaultGSSpawnConfig ["xterm","gmplayer","gvim"])+-- >   , ((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))]@@ -89,8 +209,19 @@                              , td_drawingWin :: Window                              } -type TwoD a b = StateT (TwoDState a) X b+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] ]@@ -107,9 +238,6 @@   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) @@ -153,8 +281,8 @@         cellheight = gs_cellheight gsconfig         paneX' = div (paneX-cellwidth) 2         paneY' = div (paneY-cellheight) 2-        updateElement (pos@(x,y),(text, element)) = lift $ do-            colors <- (gs_colorizer gsconfig) element (pos == curpos)+        updateElement (pos@(x,y),(text, element)) = liftX $ do+            colors <- gs_colorizer gsconfig element (pos == curpos)             drawWinBox win font                        colors                        cellheight@@ -163,13 +291,12 @@                        (paneX'+x*cellwidth)                        (paneY'+y*cellheight)                        (gs_cellpadding gsconfig)-    mapM updateElement elementmap-    return ()+    mapM_ updateElement elementmap  eventLoop :: TwoD a (Maybe a) eventLoop = do-  (keysym,string,event) <- lift $ withDisplay $ \d -> liftIO $ allocaXEvent $ \e -> do-                             nextEvent d e+  (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@@ -177,23 +304,21 @@                              return (ks,s,ev)   handle (fromMaybe xK_VoidSymbol keysym,string) event -handle :: (KeySym, String)-       -> Event-       -> StateT (TwoDState a) X (Maybe a)-handle (ks,_) (KeyEvent {ev_event_type = t})+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_Left || ks == xK_h)  = diffAndRefresh (-1,0)-    | t == keyPress && (ks == xK_Right || ks == xK_l) = diffAndRefresh (1,0)-    | t == keyPress && (ks == xK_Down || ks == xK_j) = diffAndRefresh (0,1)-    | t == keyPress && (ks == xK_Up || ks == xK_k) = diffAndRefresh (0,-1)     | 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 = oldPos `tupadd` diff+              newPos = diff oldPos               newSelectedEl = findInElementMap newPos elmap           when (isJust newSelectedEl) $ do                                 put state { td_curpos =  newPos }@@ -203,7 +328,7 @@ 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+                     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@@ -234,8 +359,8 @@          _ -> error "The world is ending. x mod a >= a."  -- | Default colorizer for Strings-defaultColorizer :: String -> Bool -> X (String, String)-defaultColorizer s active = +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,@@ -259,17 +384,17 @@                         -> (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 = +colorRangeFromClassName startC endC activeC inactiveT activeT w active =     do classname <- runQuery className w-       if active +       if active          then return (rgbToHex activeC, rgbToHex activeT)-         else return (rgbToHex $ mix startC endC +         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 +-- | 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)@@ -290,7 +415,8 @@  -- | 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 :: forall a . GSConfig a -> [(String,a)] -> X (Maybe a)+gridselect :: GSConfig a -> [(String,a)] -> X (Maybe a)+gridselect _ [] = return Nothing gridselect gsconfig elmap =  withDisplay $ \dpy -> do     rootw <- asks theRoot@@ -304,25 +430,23 @@     font <- initXMF (gs_font gsconfig)     let screenWidth = toInteger $ rect_width s;         screenHeight = toInteger $ rect_height s;-    selectedElement <- if (status == grabSuccess) then-                          do-                            let restriction :: Integer -> (GSConfig a -> Integer) -> Double-                                restriction ss cs = ((fromInteger ss)/(fromInteger $ cs gsconfig)-1)/2+    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-                            selectedElement <- evalStateT (updateAllElements >> eventLoop)-                                                          (TwoDState (head coords)-                                                           elmap'-                                                           gsconfig-                                                           font-                                                           screenWidth-                                                           screenHeight-                                                           win)-                            return selectedElement++                            evalTwoD (updateAllElements >> eventLoop)+                                (TwoDState (head coords)+                                            elmap'+                                            gsconfig+                                            font+                                            screenWidth+                                            screenHeight+                                            win)                       else                           return Nothing     liftIO $ do@@ -357,13 +481,22 @@ decorateName' w = do   fmap show $ getName w -defaultGSConfig :: GSConfig Window-defaultGSConfig = buildDefaultGSConfig fromClassName- -- | 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" (1/2) (1/2)+buildDefaultGSConfig col = GSConfig 50 130 10 col "xft:Sans-8" defaultGSNav (1/2) (1/2) +defaultGSNav :: NavigateMap+defaultGSNav = M.map (\(x,y) (a,b) -> (x+a,y+b)) $ 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" @@ -378,9 +511,6 @@ goToSelected :: GSConfig Window -> X () goToSelected = withSelectedWindow $ windows . W.focusWindow -defaultGSSpawnConfig :: GSConfig String-defaultGSSpawnConfig = buildDefaultGSConfig defaultColorizer- -- | 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@@ -393,6 +523,14 @@         Just selectedAction -> selectedAction         Nothing -> return () --- | Short-hand for 'fromIntegral'-fi :: (Integral a, Num b) => a -> b-fi = fromIntegral+-- | Select a workspace and view it using the given function+-- (normally 'W.view' or 'W.greedyView')+--+-- Another option is to shift the current window to the selected workspace:+--+-- > gridselectWorkspace (\ws -> W.greedyView ws . W.shift ws)+gridselectWorkspace :: GSConfig WorkspaceId ->+                          (WorkspaceId -> WindowSet -> WindowSet) -> X ()+gridselectWorkspace conf viewFunc = withWindowSet $ \ws -> do+    let wss = map W.tag $ W.hidden ws ++ map W.workspace (W.current ws : W.visible ws)+    gridselect conf (zip wss wss) >>= flip whenJust (windows . viewFunc)

@@ -52,8 +52,8 @@ -- -- 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: --- +-- For example, to correct the previous example:+-- -- > ((modKey, xK_Left), tryMessage_ Shrink (MoveLeft 50)) -- 

@@ -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

@@ -23,12 +23,8 @@     , MouseResize (..)     ) where -import Control.Monad-import Data.Maybe- import XMonad import XMonad.Layout.Decoration-import XMonad.Layout.LayoutModifier  import XMonad.Layout.WindowArranger import XMonad.Util.XUtils@@ -47,11 +43,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: --@@ -114,6 +110,11 @@     Just tr  -> withDisplay $ \d -> do                   tw <- mkInputWindow d tr                   io $ selectInput d tw (exposureMask .|. buttonPressMask)++                  cursor <- io $ createFontCursor d xC_bottom_right_corner+                  io $ defineCursor d tw cursor+                  io $ freeCursor d cursor+                   showWindow tw                   return ((w,r), Just tw)     Nothing ->    return ((w,r), Nothing)

@@ -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,188 @@+-----------------------------------------------------------------------------+-- |+-- 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+    , onScreen'+    , Focus(..)+    , viewOnScreen+    , greedyViewOnScreen+    , onlyOnScreen+    , toggleOnScreen+    , toggleGreedyOnScreen+    ) where++import XMonad+import XMonad.StackSet hiding (new)++import Control.Monad (guard)+-- import Control.Monad.State.Class (gets)+import Data.Maybe (fromMaybe)+++-- | Focus data definitions+data Focus = FocusNew                       -- ^ always focus the new screen+           | FocusCurrent                   -- ^ always keep the focus on the current screen+           | FocusTag WorkspaceId           -- ^ always focus tag i on the new stack+           | FocusTagVisible WorkspaceId    -- ^ focus tag i only if workspace with tag i is visible on the old stack+++-- | Run any function that modifies the stack on a given screen. This function+-- will also need to know which Screen to focus after the function has been+-- run.+onScreen :: (WindowSet -> WindowSet) -- ^ function to run+         -> Focus                    -- ^ what to do with the focus+         -> ScreenId                 -- ^ screen id+         -> WindowSet                -- ^ current stack+         -> WindowSet+onScreen f foc sc st = fromMaybe st $ do+    ws <- lookupWorkspace sc st++    let fStack      = f $ view ws st++    return $ setFocus foc st fStack+++-- set focus for new stack+setFocus :: Focus+         -> WindowSet -- ^ old stack+         -> WindowSet -- ^ new stack+         -> WindowSet+setFocus FocusNew _ new             = new+setFocus FocusCurrent old new        =+    case lookupWorkspace (screen $ current old) new of+         Nothing -> new+         Just i -> view i new+setFocus (FocusTag i) _ new         = view i new+setFocus (FocusTagVisible i) old new =+    if i `elem` map (tag . workspace) (visible old)+       then setFocus (FocusTag i) old new+       else setFocus FocusCurrent old new++-- | A variation of @onScreen@ which will take any @X ()@ function and run it+-- on the given screen.+-- Warning: This function will change focus even if the function it's supposed+-- to run doesn't succeed.+onScreen' :: X ()       -- ^ X function to run+          -> Focus      -- ^ focus+          -> ScreenId   -- ^ screen id+          -> X ()+onScreen' x foc sc = do+    st <- gets windowset+    case lookupWorkspace sc st of+         Nothing -> return ()+         Just ws -> do+             windows $ view ws+             x+             windows $ setFocus foc st+++-- | Switch to workspace @i@ on screen @sc@. If @i@ is visible use @view@ to+-- switch focus to the workspace @i@.+viewOnScreen :: ScreenId    -- ^ screen id+             -> WorkspaceId -- ^ index of the workspace+             -> WindowSet   -- ^ current stack+             -> WindowSet+viewOnScreen sid i =+    onScreen (view i) (FocusTag i) sid++-- | Switch to workspace @i@ on screen @sc@. If @i@ is visible use @greedyView@+-- to switch the current workspace with workspace @i@.+greedyViewOnScreen :: ScreenId    -- ^ screen id+                   -> WorkspaceId -- ^ index of the workspace+                   -> WindowSet   -- ^ current stack+                   -> WindowSet+greedyViewOnScreen sid i =+    onScreen (greedyView i) (FocusTagVisible i) sid++-- | Switch to workspace @i@ on screen @sc@. If @i@ is visible do nothing.+onlyOnScreen :: ScreenId    -- ^ screen id+             -> WorkspaceId -- ^ index of the workspace+             -> WindowSet   -- ^ current stack+             -> WindowSet+onlyOnScreen sid i =+    onScreen (view i) FocusCurrent sid++-- | @toggleOrView@ as in "XMonad.Actions.CycleWS" for @onScreen@ with view+toggleOnScreen :: ScreenId    -- ^ screen id+               -> WorkspaceId -- ^ index of the workspace+               -> WindowSet   -- ^ current stack+               -> WindowSet+toggleOnScreen sid i =+    onScreen (toggleOrView' view i) FocusCurrent sid++-- | @toggleOrView@ from "XMonad.Actions.CycleWS" for @onScreen@ with greedyView+toggleGreedyOnScreen :: ScreenId    -- ^ screen id+                     -> WorkspaceId -- ^ index of the workspace+                     -> WindowSet   -- ^ current stack+                     -> WindowSet+toggleGreedyOnScreen sid i =+    onScreen (toggleOrView' greedyView i) FocusCurrent sid+++-- a \"pure\" version of X.A.CycleWS.toggleOrDoSkip+toggleOrView' :: (WorkspaceId -> WindowSet -> WindowSet)   -- ^ function to run+              -> WorkspaceId                               -- ^ tag to look for+              -> WindowSet                                 -- ^ current stackset+              -> WindowSet+toggleOrView' f i st = fromMaybe (f i st) $ do+    let st' = hidden st+    -- make sure we actually have to do something+    guard $ i == (tag . workspace $ current st)+    guard $ not (null st')+    -- finally, toggle!+    return $ f (tag . head $ st') st+++-- $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".

@@ -21,7 +21,6 @@  import XMonad import XMonad.StackSet as S-import Data.List (find)  -- $usage --@@ -42,9 +41,9 @@ -- If it isn't listed, then run default action (marked with empty string, \"\"), or do nothing if default isn't supplied. bindOn :: [(String, X())] -> X() bindOn bindings = chooseAction chooser where-    chooser ws = case find ((ws==).fst) bindings of-        Just (_, action) -> action-        Nothing -> case find ((""==).fst) bindings of-            Just (_, action) -> action+    chooser ws = case lookup ws bindings of+        Just action -> action+        Nothing -> case lookup "" bindings of+            Just action -> action             Nothing -> return () 

@@ -19,21 +19,20 @@                                       , getScreen                                       , viewScreen                                       , sendToScreen+                                      , onNextNeighbour+                                      , onPrevNeighbour                                       ) 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.List (sortBy,findIndex) import Data.Function (on)  {- $usage  This module allows you name Xinerama screens from XMonad using their-physical location reletive to each other (as reported by Xinerama),+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. @@ -44,11 +43,16 @@  > import XMonad.Actions.PhysicalSCreens +> , ((modMask, xK_a), onPrevNeighbour W.view)+> , ((modMask, xK_o), onNextNeighbour W.view)+> , ((modMask .|. shiftMask, xK_a), onPrevNeighbour W.shift)+> , ((modMask .|. shiftMask, xK_o), onNextNeighbour W.shift)+ > -- > -- 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 > ---> [((modMask .|. mask, key), f sc)+> [((modm .|. mask, key), f sc) >     | (key, sc) <- zip [xK_w, xK_e, xK_r] [0..] >     , (f, mask) <- [(viewScreen, 0), (sendToScreen, shiftMask)]] @@ -61,12 +65,12 @@  -- | 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+getScreen (P i) = do w <- gets windowset+                     let screens = W.current w : W.visible w+                     if i<0 || i >= length screens+                      then return Nothing+                      else let ss = sortBy (cmpScreen `on` (screenRect . W.screenDetail)) screens+                           in return $ Just $ W.screen $ ss !! i  -- | Switch to a given physical screen viewScreen :: PhysicalScreen -> X ()@@ -85,4 +89,27 @@ -- | 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)+cmpScreen (Rectangle x1 y1 _ _) (Rectangle x2 y2 _ _) = compare (y1,x1) (y2,x2)+++-- | Get ScreenId for neighbours of the current screen based on position offset.+getNeighbour :: Int -> X ScreenId+getNeighbour d = do w <- gets windowset+                    let ss = map W.screen $ sortBy (cmpScreen `on` (screenRect . W.screenDetail)) $ W.current w : W.visible w+                        curPos = maybe 0 id $ findIndex (== W.screen (W.current w)) ss+                        pos = (curPos + d) `mod` length ss+                    return $ ss !! pos++neighbourWindows :: Int -> (WorkspaceId -> WindowSet -> WindowSet) -> X ()+neighbourWindows d f = do s <- getNeighbour d+                          w <- screenWorkspace s+                          whenJust w $ windows . f++-- | Apply operation on a WindowSet with the WorkspaceId of the next screen in the physical order as parameter.+onNextNeighbour :: (WorkspaceId -> WindowSet -> WindowSet) -> X ()+onNextNeighbour = neighbourWindows 1++-- | Apply operation on a WindowSet with the WorkspaceId of the previous screen in the physical order as parameter.+onPrevNeighbour :: (WorkspaceId -> WindowSet -> WindowSet) -> X ()+onPrevNeighbour = neighbourWindows (-1)+

@@ -78,9 +78,9 @@ -- 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. --- | This is the way most people would like to use this module.  It ataches the+-- | 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'.

@@ -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

@@ -20,7 +20,7 @@                                  promptSearchBrowser,                                  selectSearch,                                  selectSearchBrowser,-                                 hasPrefix,+                                 isPrefixOf,                                  escape,                                  use,                                  intelligent,@@ -29,6 +29,7 @@                                  namedEngine,                                   amazon,+                                 alpha,                                  codesearch,                                  deb,                                  debbts,@@ -40,12 +41,15 @@                                  images,                                  imdb,                                  isohunt,+                                 lucky,                                  maps,                                  mathworld,+                                 openstreetmap,                                  scholar,                                  thesaurus,                                  wayback,                                  wikipedia,+                                 wiktionary,                                  youtube,                                  multi                                   -- * Use case: searching with a submap@@ -53,9 +57,10 @@                           ) 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)@@ -86,6 +91,8 @@  * 'amazon' -- Amazon keyword search. +* 'alpha' -- Wolfram|Alpha query.+ * 'codesearch' -- Google Labs Code Search search.  * 'deb'    -- Debian package search.@@ -108,10 +115,14 @@  * 'isohunt' -- isoHunt search. +* 'lucky' -- Google "I'm feeling lucky" search.+ * 'maps'   -- Google maps.  * 'mathworld' -- Wolfram MathWorld search. +* 'openstreetmap' -- OpenStreetMap free wiki world map.+ * 'scholar' -- Google scholar academic search.  * 'thesaurus' -- thesaurus.reference.com search.@@ -228,7 +239,7 @@ -- | 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 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@@ -250,8 +261,8 @@    inside of a URL instead of in the end) you can use the alternative 'searchEngineF' function.  > searchFunc :: String -> String-> searchFunc s | s `hasPrefix` "wiki:"   = "http://en.wikipedia.org/wiki/" ++ (escape $ tail $ snd $ break (==':') s)->              | s `hasPrefix` "http://" = s+> 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 @@ -266,36 +277,36 @@ searchEngineF :: Name -> Site -> SearchEngine searchEngineF = SearchEngine - -- The engines.-amazon, codesearch, deb, debbts, debpts, dictionary, google, hackage, hoogle, images,-  imdb, isohunt, maps, mathworld, scholar, thesaurus, wayback, wikipedia,+amazon, alpha, codesearch, deb, debbts, debpts, dictionary, google, hackage, hoogle,+  images, imdb, isohunt, lucky, maps, mathworld, openstreetmap, scholar, thesaurus, wayback, wikipedia, wiktionary,   youtube :: SearchEngine-amazon     = searchEngine "amazon"     "http://www.amazon.com/exec/obidos/external-search?index=all&keyword="-codesearch = searchEngine "codesearch" "http://www.google.com/codesearch?q="-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/cgi-bin/hackage-scripts/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="-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 "wiki"       "https://secure.wikimedia.org/wikipedia/en/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/"+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="+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?s=all&q="+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="+openstreetmap = searchEngine "openstreetmap" "http://gazetteer.openstreetmap.org/namefinder/?find="+scholar       = searchEngine "scholar"       "http://scholar.google.com/scholar?q="+thesaurus     = searchEngine "thesaurus"     "http://thesaurus.reference.com/search?q="+wikipedia     = searchEngine "wiki"          "http://en.wikipedia.org/wiki/Special:Search?go=Go&search="+wiktionary    = searchEngine "wikt"          "http://en.wiktionary.org/wiki/Special:Search?go=Go&search="+youtube       = searchEngine "youtube"       "http://www.youtube.com/results?search_type=search_videos&search_query="+wayback       = searchEngineF "wayback"      ("http://web.archive.org/web/*/"++)  multi :: SearchEngine-multi = namedEngine "multi" $ foldr1 (!>) [amazon, codesearch, deb, debbts, debpts, dictionary, google, hackage, hoogle, images, imdb, isohunt, maps, mathworld, scholar, thesaurus, wayback, wikipedia, (prefixAware google)]+multi = namedEngine "multi" $ foldr1 (!>) [amazon, alpha, codesearch, deb, debbts, debpts, dictionary, google, hackage, hoogle, images, imdb, isohunt, lucky, maps, mathworld, openstreetmap, scholar, thesaurus, wayback, wikipedia, wiktionary, (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@@ -307,14 +318,10 @@ intelligent :: SearchEngine -> SearchEngine intelligent (SearchEngine name site) = searchEngineF name (\s -> if (fst $ break (==':') s) `elem` ["http", "https", "ftp"] then s else (site s)) -{- | Checks if a string starts with a given prefix -}-hasPrefix :: String -> String -> Bool-hasPrefix _ [] = True-hasPrefix [] (_:_) = False-hasPrefix (t:ts) (p:ps) = if t == p then hasPrefix ts ps else False-+-- | > removeColonPrefix "foo://bar" ~> "//bar"+-- > removeColonPrefix "foo//bar" ~> "foo//bar" removeColonPrefix :: String -> String-removeColonPrefix str = tail $ snd $ break (==':') str+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@@ -328,14 +335,14 @@   \"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 `hasPrefix` (name1++":") then site1 (removeColonPrefix s) else site2 s)+(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. -}+     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 `hasPrefix` (name++":") then site $ removeColonPrefix s else site s)+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@@ -345,7 +352,8 @@    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@. --

@@ -28,7 +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".

@@ -1,3 +1,4 @@+{-# LANGUAGE DeriveDataTypeable #-} ----------------------------------------------------------------------------- -- | -- Module       : XMonad.Actions.SpawnOn@@ -8,9 +9,9 @@ -- Stability    : unstable -- Portability  : unportable ----- Provides a way to spawn an application on a specific workspace 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.+-- 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. -- ----------------------------------------------------------------------------- @@ -18,16 +19,15 @@     -- * 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@@ -36,6 +36,7 @@ import XMonad.Hooks.ManageHelpers import XMonad.Prompt import XMonad.Prompt.Shell+import qualified XMonad.Util.ExtensibleState as XS  -- $usage -- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:@@ -43,42 +44,47 @@ -- >    import XMonad.Actions.SpawnOn -- -- >    main = do--- >      sp <- mkSpawner -- >      xmonad defaultConfig { -- >         ...--- >         manageHook = manageSpawn sp <+> manageHook defaultConfig+-- >         manageHook = manageSpawn <+> 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)+-- >  , ((mod1Mask,xK_o), spawnHere "urxvt")+-- >  , ((mod1Mask,xK_s), shellPromptHere 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, WorkspaceId)]}+newtype Spawner = Spawner {pidsRef :: [(ProcessID, ManageHook)]} deriving Typeable +instance ExtensionClass Spawner where+    initialValue = Spawner []+ 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 []+-- | Get the current Spawner or create one if it doesn't exist.+modifySpawner :: ([(ProcessID, ManageHook)] -> [(ProcessID, ManageHook)]) -> X ()+modifySpawner f = XS.modify (Spawner . f . pidsRef)  -- | Provides a manage hook to react on process spawned with -- 'spawnOn', 'spawnHere' etc.-manageSpawn :: Spawner -> ManageHook-manageSpawn sp = do-    pids <- io . readIORef $ pidsRef sp+manageSpawn :: ManageHook+manageSpawn = do+    Spawner pids <- liftX XS.get     mp <- pid     case flip lookup pids =<< mp of-        Nothing -> doF id-        Just w  -> do+        Nothing -> idHook+        Just mh  -> do             whenJust mp $ \p ->-                io . modifyIORef (pidsRef sp) $ filter ((/= p) . fst)-            doShift w+                liftX . modifySpawner $ filter ((/= p) . fst)+            mh  mkPrompt :: (String -> X ()) -> XPConfig -> X () mkPrompt cb c = do@@ -87,28 +93,31 @@  -- | Replacement for Shell prompt ("XMonad.Prompt.Shell") which launches -- application on current workspace.-shellPromptHere :: Spawner -> XPConfig -> X ()-shellPromptHere sp = mkPrompt (spawnHere sp)+shellPromptHere :: XPConfig -> X ()+shellPromptHere = mkPrompt spawnHere  -- | 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)+shellPromptOn :: WorkspaceId -> XPConfig -> X ()+shellPromptOn ws = mkPrompt (spawnOn 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+spawnHere :: String -> X ()+spawnHere cmd = withWindowSet $ \ws -> spawnOn (W.currentTag ws) cmd  -- | Replacement for 'spawn' which launches -- application on given workspace.-spawnOn :: Spawner -> WorkspaceId -> String -> X ()-spawnOn sp ws cmd = do+spawnOn :: WorkspaceId -> String -> X ()+spawnOn ws cmd = spawnAndDo (doShift ws) cmd++-- | Spawn an application and apply the manage hook when it opens.+spawnAndDo :: ManageHook -> String -> X ()+spawnAndDo mh cmd = do     p <- spawnPID $ mangle cmd-    io $ modifyIORef (pidsRef sp) (take maxPids . ((p, ws) :))+    modifySpawner $ (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 = "&|;"-

@@ -18,7 +18,7 @@                              submap,                              submapDefault                             ) where-+import Data.Bits import XMonad hiding (keys) import qualified Data.Map as M import Control.Monad.Fix (fix)@@ -34,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")@@ -74,8 +74,8 @@         if isModifierKey keysym             then nextkey             else return (m, keysym)--    m' <- cleanMask m+    -- 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

@@ -19,7 +19,7 @@                                      swapWithCurrent,                                      swapTo,                                      swapWorkspaces,-                                     WSDirection(..)+                                     Direction1D(..)                                     ) where  import XMonad (windows, X())@@ -36,7 +36,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@@ -52,7 +52,7 @@  -- | 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

@@ -25,7 +25,7 @@                  tagDelPrompt                  ) where -import Data.List (nub,concat,sortBy)+import Data.List (nub,sortBy) import Control.Monad  import XMonad.StackSet hiding (filter)@@ -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)) --

@@ -1,3 +1,4 @@+{-# LANGUAGE DeriveDataTypeable #-} ----------------------------------------------------------------------------- -- | -- Module      :  XMonad.Actions.TopicSpace@@ -9,148 +10,19 @@ -- Portability :  unportable -- -- Turns your workspaces into a more topic oriented system.------ 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 recents topics using this history--- of last focused topics.------ 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 =---    [ ((modMask              , xK_n     ), spawnShell) -- %! Launch terminal---    , ((modMask              , xK_a     ), currentTopicAction myTopicConfig)---    , ((modMask              , xK_g     ), promptedGoto)---    , ((modMask .|. shiftMask, xK_g     ), promptedShift)---    ...---    ]---    ++---    [ ((modMask, k), switchNthLastFocused defaultTopic 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 myLayouts---           , 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--- @+-----------------------------------------------------------------------------+ module XMonad.Actions.TopicSpace-  ( Topic+  (+  -- * Overview+  -- $overview++  -- * Usage+  -- $usage+   Topic   , Dir   , TopicConfig(..)+  , defaultTopicConfig   , getLastFocusedTopics   , setLastFocusedTopic   , pprWindowSet@@ -159,6 +31,7 @@   , currentTopicAction   , switchTopic   , switchNthLastFocused+  , shiftNthLastFocused   , currentTopicDir   , checkTopicConfig   , (>*>)@@ -168,16 +41,12 @@ import XMonad  import Data.List-import Data.Maybe (fromMaybe, isNothing)+import Data.Maybe (fromMaybe, isNothing, listToMaybe) import Data.Ord import qualified Data.Map as M-import Graphics.X11.Xlib-import Control.Monad ((=<<),liftM2,when,unless,replicateM_)+import Control.Monad (liftM2,when,unless,replicateM_) import System.IO-import Foreign.C.String (castCCharToChar,castCharToCChar) -import XMonad.Operations-import Control.Applicative ((<$>)) import qualified XMonad.StackSet as W  import XMonad.Prompt@@ -188,7 +57,127 @@ import qualified XMonad.Hooks.DynamicLog as DL  import XMonad.Util.Run (spawnPipe)+import qualified XMonad.Util.ExtensibleState as XS +-- $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 = defaultTopicConfig+-- >   { 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"+-- >   , 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)+-- >   {- more  keys ... -}+-- >   ]+-- >   +++-- >   [ ((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_@@ -216,19 +205,31 @@                                  -- numeric keypad.                                } +defaultTopicConfig :: TopicConfig+defaultTopicConfig = TopicConfig { topicDirs = M.empty+                                 , topicActions = M.empty+                                 , defaultTopicAction = const (ask >>= spawn . terminal . config)+                                 , defaultTopic = "1"+                                 , maxTopicHistory = 10+                                 }++newtype PrevTopics = PrevTopics { getPrevTopics :: [String] } deriving (Read,Show,Typeable)+instance ExtensionClass PrevTopics where+    initialValue = PrevTopics []+    extensionType = PersistentExtension+ -- | 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 = getStringListProp "_XMONAD_LAST_FOCUSED_WORKSPACES"+getLastFocusedTopics = XS.gets getPrevTopics  -- | 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 =-  getLastFocusedTopics >>=-    setStringListProp "_XMONAD_LAST_FOCUSED_WORKSPACES"+  XS.modify $ PrevTopics     . take (maxTopicHistory tg) . nub . (w:) . filter predicate+    . getPrevTopics  -- | 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@@ -274,6 +275,12 @@   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@@ -294,42 +301,9 @@     check diffTopic "Seen but missing topics/workspaces"     check dups      "Duplicate topics/workspaces" -type StringProp = String--withStringProp :: StringProp -> (Display -> Window -> Atom -> X a) -> X a-withStringProp prop f =-  withDisplay $ \dpy -> do-    rootw <- asks theRoot-    a     <- io $ internAtom dpy prop False-    f dpy rootw a---- | Get the name of a string property and returns it as a 'Maybe'.-getStringProp :: StringProp -> X (Maybe String)-getStringProp prop =-  withStringProp prop $ \dpy rootw a -> do-    p <- io $ getWindowProperty8 dpy a rootw-    return $ map castCCharToChar <$> p---- | Set the value of a string property.-setStringProp :: StringProp -> String -> X ()-setStringProp prop string =-  withStringProp prop $ \dpy rootw a ->-    io $ changeProperty8 dpy rootw a a propModeReplace $ map castCharToCChar string---- | Given a property name, returns its contents as a list. It uses the empty--- list as default value.-getStringListProp :: StringProp -> X [String]-getStringListProp prop = return . maybe [] words =<< getStringProp prop---- | Given a property name and a list, sets the value of this property with--- the list given as argument.-setStringListProp :: StringProp -> [String] -> X ()-setStringListProp prop = setStringProp prop . unwords- -- | Display the given message using the @xmessage@ program. xmessage :: String -> IO () xmessage s = do   h <- spawnPipe "xmessage -file -"   hPutStr h s   hClose h-

@@ -1,6 +1,6 @@ ----------------------------------------------------------------------------- -- |--- Module      :  XMonadContrib.UpdateFocus+-- Module      :  XMonad.Actions.UpdateFocus -- Copyright   :  (c) Daniel Schoepe -- License     :  BSD3-style (see LICENSE) --@@ -21,7 +21,6 @@  import XMonad import qualified XMonad.StackSet as W-import Graphics.X11.Xlib.Extras import Control.Monad (when) import Data.Monoid @@ -45,10 +44,10 @@     -- 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+      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+      when (foc /= Just w) $ focus w     return (All True) focusOnMouseMove _ = return (All True) 

@@ -26,6 +26,7 @@ import XMonad import Control.Monad import XMonad.StackSet (member, peek, screenDetail, current)+import Data.Maybe  -- $usage -- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:@@ -66,8 +67,10 @@   root <- asks theRoot   mouseIsMoving <- asks mouseFocused   (_sameRoot,_,currentWindow,rootx,rooty,_,_,_) <- io $ queryPointer dpy root+  drag <- gets dragging   unless (pointWithin (fi rootx) (fi rooty) rect           || mouseIsMoving+          || isJust drag           || not (currentWindow `member` ws || currentWindow == none)) $     case p of     Nearest -> do@@ -88,8 +91,10 @@         where fraction x y = floor (x * fromIntegral y)  windowAttributesToRectangle :: WindowAttributes -> Rectangle-windowAttributesToRectangle wa = Rectangle (fi (wa_x wa))     (fi (wa_y wa))-                                           (fi (wa_width wa)) (fi (wa_height wa))+windowAttributesToRectangle wa = Rectangle (fi (wa_x wa))+                                           (fi (wa_y wa))+                                           (fi (wa_width wa + 2 * wa_border_width wa))+                                           (fi (wa_height wa + 2 * wa_border_width wa)) moveWithin :: Ord a => a -> a -> a -> a moveWithin now lower upper =     if now < lower

@@ -22,7 +22,6 @@                            warpToWindow                           ) where -import Data.Ratio import Data.List import XMonad import XMonad.StackSet as W@@ -34,11 +33,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.

@@ -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, gotoMenu', bringMenu, windowMap,-				    bringWindow-				   ) where+                    -- * Usage+                    -- $usage+                    gotoMenu, gotoMenu', bringMenu, windowMap,+                    bringWindow+                   ) where  import Data.Char (toLower) import qualified Data.Map as M@@ -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".

@@ -28,18 +28,23 @@                  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)+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, swapMaster, focusWindow)+import XMonad.Util.Run (safeSpawnProg) {- $usage  Import the module into your @~\/.xmonad\/xmonad.hs@:@@ -48,31 +53,47 @@  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-appropriate one, or cover your bases by using instead something like- @(className =? \"Firefox\" <||> className =? \"Firefox-bin\")@.)+appropriate one, or cover your bases by using instead something like: +> (className =? "Firefox" <||> className =? "Firefox-bin")+ 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 = raiseMaybe . spawn+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\")@. @@ -95,15 +116,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:_)  -> windows $ W.focusWindow 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 = raiseNextMaybe . spawn+runOrRaiseNext = raiseNextMaybe . safeSpawnProg  -- | See 'raise' and 'raiseNextMaybe'. Version that allows cycling through matches. raiseNext :: Query Bool -> X ()@@ -115,18 +136,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 _ = windows $ W.focusWindow x-             in go $ W.peek s-  where-    next w (x:y:_) | x==w = windows $ W.focusWindow 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.@@ -135,38 +152,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+{- | 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 -}+     See 'raiseMaster' for an example. -} raiseAndDo :: X () -> Query Bool -> (Window -> X ())-> X ()-raiseAndDo raisef thatUserQuery afterRaise = withWindowSet $ \s -> do-    maybeResult <- filterM (runQuery thatUserQuery) (W.allWindows s)-    case maybeResult of-      []     -> raisef-      (x:_)  -> do windows $ W.focusWindow x-                   afterRaise x+raiseAndDo f qry after = ifWindow qry (afterRaise `mappend` raiseHook) f+    where afterRaise = ask >>= (>> idHook) . liftX . after -{- | if the window is found the window is focused and the third argument is called-     otherwise, raisef is called -}+{- | 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 . spawn+runOrRaiseAndDo = raiseAndDo . safeSpawnProg  {- | if the window is found the window is focused and set to master-     otherwise, the first argument is called+     otherwise, the first argument is called. -     raiseMaster (runInTerm \"-title ghci\"  \"zsh -c \'ghci\'\") (title =? \"ghci\") -}+     > 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+{- |  If the window is found the window is focused and set to master+      otherwise, action is run. -      runOrRaiseMaster \"firefox\" (className =? \"Firefox\")) +      > runOrRaiseMaster "firefox" (className =? "Firefox"))   -} runOrRaiseMaster :: String -> Query Bool -> X () runOrRaiseMaster run query = runOrRaiseAndDo run query (\_ -> windows W.swapMaster)

@@ -8,9 +8,19 @@ -- 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 @@ -19,26 +29,28 @@ import XMonad.Actions.GridSelect import XMonad.Layout.Maximize import XMonad.Layout.Minimize+import XMonad.Util.XUtils (fi) -simpleColorizer :: (Monad m) => t -> t -> t1 -> Bool -> m (t, [Char])-simpleColorizer nBC _ _ False  = return (nBC, "black")-simpleColorizer _ fBC _ True  = return (fBC, "black")+-- $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-    nBC <- asks (normalBorderColor . config)-    fBC <- asks (focusedBorderColor . config)     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 = (fromIntegral x - fromIntegral sx + (fromIntegral wh / 2))-                        / fromIntegral swh-        originFractY = (fromIntegral y -fromIntegral sy + (fromIntegral ht / 2))-                        / fromIntegral sht-        colorizer = simpleColorizer nBC fBC-        gsConfig = buildDefaultGSConfig colorizer-        gsConfig' = gsConfig { gs_originFractX = originFractX,-                               gs_originFractY = originFractY }+    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)@@ -46,14 +58,14 @@                   ] ++                   [ ("Move to " ++ tag, windows $ W.shift tag)                     | tag <- tags ]-    runSelectedAction gsConfig' actions+    runSelectedAction gsConfig actions  getSize :: Window -> X (Rectangle) getSize w = do   d  <- asks display   wa <- io $ getWindowAttributes d w-  let x = fromIntegral $ wa_x wa-      y = fromIntegral $ wa_y wa-      wh = fromIntegral $ wa_width wa-      ht = fromIntegral $ wa_height wa+  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 ((<$>))@@ -50,7 +52,6 @@ import Data.Maybe (catMaybes, fromMaybe, listToMaybe) import Data.Ord (comparing) import qualified Data.Set as S-import Graphics.X11.Xlib  -- $usage --@@ -84,15 +85,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 +105,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 +114,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 +129,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@@ -175,12 +176,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 +198,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 +208,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

@@ -18,8 +18,6 @@ import Data.Foldable hiding (foldr)  import XMonad-import XMonad.Core-import XMonad.Operations import XMonad.StackSet  -- $usage@@ -30,7 +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".

@@ -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

@@ -0,0 +1,155 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  XMonad.Actions.WorkspaceNames+-- Copyright   :  (c) Tomas Janousek <tomi@nomi.cz>+-- License     :  BSD3-style (see LICENSE)+--+-- Maintainer  :  Tomas Janousek <tomi@nomi.cz>+-- Stability   :  experimental+-- Portability :  unportable+--+-- Provides bindings to rename workspaces, show these names in DynamicLog and+-- swap workspaces along with their names. These names survive restart.+-- Together with "XMonad.Layout.WorkspaceDir" this provides for a fully+-- dynamic topic space workflow.+--+-----------------------------------------------------------------------------++{-# LANGUAGE DeriveDataTypeable #-}++module XMonad.Actions.WorkspaceNames (+    -- * Usage+    -- $usage++    -- * Workspace naming+    renameWorkspace,+    workspaceNamesPP,+    getWorkspaceNames,+    setWorkspaceName,+    setCurrentWorkspaceName,++    -- * Workspace swapping+    swapTo,+    swapTo',+    swapWithCurrent,+    ) where++import XMonad+import qualified XMonad.StackSet as W+import qualified XMonad.Util.ExtensibleState as XS++import XMonad.Actions.CycleWS (findWorkspace, WSType(..), Direction1D(..))+import qualified XMonad.Actions.SwapWorkspaces as Swap+import XMonad.Hooks.DynamicLog (PP(..))+import XMonad.Prompt (showXPrompt, mkXPrompt, XPrompt, XPConfig)+import XMonad.Util.WorkspaceCompare (getSortByIndex)++import qualified Data.Map as M+import Data.Maybe (fromMaybe)++-- $usage+-- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@ file:+--+-- > import XMonad.Actions.WorkspaceNames+--+-- Then add keybindings like the following:+--+-- >   , ((modm .|. shiftMask, xK_r      ), renameWorkspace defaultXPConfig)+--+-- and apply workspaceNamesPP to your DynamicLog pretty-printer:+--+-- > myLogHook =+-- >     workspaceNamesPP xmobarPP >>= dynamicLogString >>= xmonadPropLog+--+-- We also provide a modification of "XMonad.Actions.SwapWorkspaces"\'s+-- functionality, which may be used this way:+--+-- >   , ((modMask .|. shiftMask, xK_Left  ), swapTo Prev)+-- >   , ((modMask .|. shiftMask, xK_Right ), swapTo Next)+--+-- > [((modm .|. controlMask, k), swapWithCurrent i)+-- >     | (i, k) <- zip workspaces [xK_1 ..]]+--+-- For detailed instructions on editing your key bindings, see+-- "XMonad.Doc.Extending#Editing_key_bindings".++++-- | Workspace names container.+newtype WorkspaceNames = WorkspaceNames (M.Map WorkspaceId String)+    deriving (Typeable, Read, Show)++instance ExtensionClass WorkspaceNames where+    initialValue = WorkspaceNames M.empty+    extensionType = PersistentExtension++-- | Returns a function that maps workspace tag @\"t\"@ to @\"t:name\"@ for+-- workspaces with a name, and to @\"t\"@ otherwise.+getWorkspaceNames :: X (WorkspaceId -> String)+getWorkspaceNames = do+    WorkspaceNames m <- XS.get+    return $ \wks -> case M.lookup wks m of+        Nothing -> wks+        Just s  -> wks ++ ":" ++ s++-- | Sets the name of a workspace. Empty string makes the workspace unnamed+-- again.+setWorkspaceName :: WorkspaceId -> String -> X ()+setWorkspaceName w name = do+    WorkspaceNames m <- XS.get+    XS.put $ WorkspaceNames $ if null name then M.delete w m else M.insert w name m+    refresh++-- | Sets the name of the current workspace. See 'setWorkspaceName'.+setCurrentWorkspaceName :: String -> X ()+setCurrentWorkspaceName name = do+    current <- gets (W.currentTag . windowset)+    setWorkspaceName current name++data Wor = Wor String+instance XPrompt Wor where+    showXPrompt (Wor x) = x++-- | Prompt for a new name for the current workspace and set it.+renameWorkspace :: XPConfig -> X ()+renameWorkspace conf = do+    mkXPrompt pr conf (const (return [])) setCurrentWorkspaceName+    where pr = Wor "Workspace name: "++-- | Modify "XMonad.Hooks.DynamicLog"\'s pretty-printing format to show+-- workspace names as well.+workspaceNamesPP :: PP -> X PP+workspaceNamesPP pp = do+    names <- getWorkspaceNames+    return $+        pp {+            ppCurrent         = ppCurrent         pp . names,+            ppVisible         = ppVisible         pp . names,+            ppHidden          = ppHidden          pp . names,+            ppHiddenNoWindows = ppHiddenNoWindows pp . names,+            ppUrgent          = ppUrgent          pp . names+        }++-- | See 'XMonad.Actions.SwapWorkspaces.swapTo'. This is the same with names.+swapTo :: Direction1D -> X ()+swapTo dir = swapTo' dir AnyWS++-- | Swap with the previous or next workspace of the given type.+swapTo' :: Direction1D -> WSType -> X ()+swapTo' dir which = findWorkspace getSortByIndex dir which 1 >>= swapWithCurrent++-- | See 'XMonad.Actions.SwapWorkspaces.swapWithCurrent'. This is almost the+-- same with names.+swapWithCurrent :: WorkspaceId -> X ()+swapWithCurrent t = do+    current <- gets (W.currentTag . windowset)+    swapNames t current+    windows $ Swap.swapWorkspaces t current++-- | Swap names of the two workspaces.+swapNames :: WorkspaceId -> WorkspaceId -> X ()+swapNames w1 w2 = do+    WorkspaceNames m <- XS.get+    let getname w = fromMaybe "" $ M.lookup w m+        set w name m' = if null name then M.delete w m' else M.insert w name m'+    XS.put $ WorkspaceNames $ set w1 (getname w2) $ set w2 (getname w1) $ m

@@ -1,4 +1,5 @@-{-# OPTIONS_GHC -fglasgow-exts -fno-warn-missing-signatures #-}+{-# OPTIONS_GHC -fno-warn-missing-signatures #-}+{-# LANGUAGE NoMonomorphismRestriction #-} ----------------------------------------------------------------------------- -- | -- Module      :  XMonad.Config.Arossato

@@ -7,6 +7,8 @@ -- 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@@ -36,7 +38,7 @@ -- > 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 }+azertyConfig = defaultConfig { keys = azertyKeys <+> keys defaultConfig }  azertyKeys conf@(XConfig {modMask = modm}) = M.fromList $     [((modm, xK_semicolon), sendMessage (IncMasterN (-1)))]

@@ -0,0 +1,217 @@+{-# OPTIONS -fno-warn-missing-signatures #-}+----------------------------------------------------------------------------+-- |+-- Module      :  XMonad.Config.Bluetile+-- Copyright   :  (c) Jan Vornberger 2009+-- License     :  BSD3-style (see LICENSE)+--+-- Maintainer  :  jan.vornberger@informatik.uni-oldenburg.de+-- Stability   :  unstable+-- Portability :  not portable+--+-- This is the default configuration of Bluetile+-- (<http://projects.haskell.org/bluetile/>). If you+-- are migrating from Bluetile to xmonad or want to create+-- a similar setup, then this will give you pretty much+-- the same thing, except for Bluetile's helper applications+-- such as the dock.+--+-----------------------------------------------------------------------------++module XMonad.Config.Bluetile (+    -- * Usage+    -- $usage+    bluetileConfig+    ) where++import XMonad hiding ( (|||) )++import XMonad.Layout.BorderResize+import XMonad.Layout.BoringWindows+import XMonad.Layout.ButtonDecoration+import XMonad.Layout.Decoration+import XMonad.Layout.DecorationAddons+import XMonad.Layout.DraggingVisualizer+import XMonad.Layout.LayoutCombinators+import XMonad.Layout.Maximize+import XMonad.Layout.Minimize+import XMonad.Layout.MouseResizableTile+import XMonad.Layout.Named+import XMonad.Layout.NoBorders+import XMonad.Layout.PositionStoreFloat+import XMonad.Layout.WindowSwitcherDecoration++import XMonad.Actions.BluetileCommands+import XMonad.Actions.CycleWS+import XMonad.Actions.WindowMenu++import XMonad.Hooks.CurrentWorkspaceOnTop+import XMonad.Hooks.EwmhDesktops+import XMonad.Hooks.ManageDocks+import XMonad.Hooks.ManageHelpers+import XMonad.Hooks.PositionStoreHooks+import XMonad.Hooks.RestoreMinimized+import XMonad.Hooks.ServerMode+import XMonad.Hooks.WorkspaceByPos++import XMonad.Config.Gnome++import qualified XMonad.StackSet as W+import qualified Data.Map as M++import System.Exit+import Data.Monoid+import Control.Monad(when)++-- $usage+-- To use this module, start with the following @~\/.xmonad\/xmonad.hs@:+--+-- > import XMonad+-- > import XMonad.Config.Bluetile+-- > import XMonad.Util.Replace+-- >+-- > main = replace >> xmonad bluetileConfig+--+-- The invocation of 'replace' will replace a currently running+-- window manager. This is the default behaviour of Bluetile as well.+-- See "XMonad.Util.Replace" for more information.++bluetileWorkspaces :: [String]+bluetileWorkspaces = ["1","2","3","4","5","6","7","8","9","0"]++bluetileKeys :: XConfig Layout -> M.Map (KeyMask, KeySym) (X ())+bluetileKeys conf@(XConfig {XMonad.modMask = modMask'}) = M.fromList $+    -- launching and killing programs+    [ ((modMask'              , xK_Return), spawn $ XMonad.terminal conf) -- %! Launch terminal+    , ((modMask',               xK_p     ), gnomeRun)    --  %! Launch Gnome "Run application" dialog+    , ((modMask' .|. shiftMask, xK_c     ), kill) -- %! Close the focused window++    , ((modMask',               xK_F5 ), refresh) -- %! Resize viewed windows to the correct size+    , ((modMask' .|. shiftMask, xK_F5 ), setLayout $ XMonad.layoutHook conf) -- %!  Reset the layouts on the current workspace to default++    , ((modMask',               xK_o ), windowMenu)++    -- move focus up or down the window stack+    , ((modMask',               xK_Tab   ), focusDown) -- %! Move focus to the next window+    , ((modMask' .|. shiftMask, xK_Tab   ), focusUp) -- %! Move focus to the previous window+    , ((modMask',               xK_j     ), focusDown) -- %! Move focus to the next window+    , ((modMask',               xK_k     ), focusUp) -- %! Move focus to the previous window+    , ((modMask',               xK_space ), focusMaster) -- %! Move focus to the master window++    -- modifying the window order+    , ((modMask' .|. shiftMask, xK_space ), windows W.swapMaster) -- %! Swap the focused window and the master window+    , ((modMask' .|. shiftMask, xK_j     ), windows W.swapDown  ) -- %! Swap the focused window with the next window+    , ((modMask' .|. shiftMask, xK_k     ), windows W.swapUp    ) -- %! Swap the focused window with the previous window++    -- resizing the master/slave ratio+    , ((modMask',               xK_h     ), sendMessage Shrink) -- %! Shrink the master area+    , ((modMask',               xK_l     ), sendMessage Expand) -- %! Expand the master area+    , ((modMask',               xK_u     ), sendMessage ShrinkSlave) -- %! Shrink a slave area+    , ((modMask',               xK_i     ), sendMessage ExpandSlave) -- %! Expand a slave area++    -- floating layer support+    , ((modMask',               xK_t     ), withFocused $ windows . W.sink) -- %! Push window back into tiling+    , ((modMask' .|. shiftMask, xK_t     ), withFocused $ float ) -- %! Float window++    -- increase or decrease number of windows in the master area+    , ((modMask'              , xK_comma ), sendMessage (IncMasterN 1)) -- %! Increment the number of windows in the master area+    , ((modMask'              , xK_period), sendMessage (IncMasterN (-1))) -- %! Deincrement the number of windows in the master area++    -- quit, or restart+    , ((modMask' .|. shiftMask, xK_q     ), io (exitWith ExitSuccess)) -- %! Quit+    , ((modMask'              , xK_q     ), restart "xmonad" True) -- %! Restart++    -- Metacity-like workspace switching+    , ((mod1Mask .|. controlMask, xK_Left), prevWS)+    , ((mod1Mask .|. controlMask, xK_Right), nextWS)+    , ((mod1Mask .|. controlMask .|. shiftMask,   xK_Left), shiftToPrev >> prevWS)+    , ((mod1Mask .|. controlMask .|. shiftMask,   xK_Right), shiftToNext >> nextWS)++    -- more Metacity keys+    , ((mod1Mask             , xK_F2), gnomeRun)+    , ((mod1Mask             , xK_F4), kill)++    -- Switching to layouts+    , ((modMask'              , xK_a), sendMessage $ JumpToLayout "Floating")+    , ((modMask'              , xK_s), sendMessage $ JumpToLayout "Tiled1")+    , ((modMask'              , xK_d), sendMessage $ JumpToLayout "Tiled2")+    , ((modMask'              , xK_f), sendMessage $ JumpToLayout "Fullscreen")++    -- Maximizing+    , ((modMask'              , xK_z), withFocused (sendMessage . maximizeRestore))++    -- Minimizing+    , ((modMask',               xK_m     ), withFocused (\f -> sendMessage (MinimizeWin f)))+    , ((modMask' .|. shiftMask, xK_m     ), sendMessage RestoreNextMinimizedWin)+    ]+    +++    -- mod-[1..9] ++ [0] %! Switch to workspace N+    -- mod-shift-[1..9] ++ [0] %! Move client to workspace N+    [((m .|. modMask', k), windows $ f i)+        | (i, k) <- zip (XMonad.workspaces conf) ([xK_1 .. xK_9] ++ [xK_0])+        , (f, m) <- [(W.greedyView, 0), (W.shift, shiftMask)]]+    +++    -- 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+    [((m .|. modMask', key), screenWorkspace sc >>= flip whenJust (windows . f))+        | (key, sc) <- zip [xK_w, xK_e, xK_r] [0..]+        , (f, m) <- [(W.view, 0), (W.shift, shiftMask)]]++bluetileMouseBindings :: XConfig Layout -> M.Map (KeyMask, Button) (Window -> X ())+bluetileMouseBindings (XConfig {XMonad.modMask = modMask'}) = M.fromList $+    -- mod-button1 %! Move a floated window by dragging+    [ ((modMask', button1), (\w -> isFloating w >>= \isF -> when (isF) $+                                focus w >> mouseMoveWindow w >> windows W.shiftMaster))+    -- mod-button2 %! Switch to next and first layout+    , ((modMask', button2), (\_ -> sendMessage NextLayout))+    , ((modMask' .|. shiftMask, button2), (\_ -> sendMessage $ JumpToLayout "Floating"))+    -- mod-button3 %! Resize a floated window by dragging+    , ((modMask', button3), (\w -> isFloating w >>= \isF -> when (isF) $+                                focus w >> mouseResizeWindow w >> windows W.shiftMaster))+    ]++isFloating :: Window -> X (Bool)+isFloating w = do+    ws <- gets windowset+    return $ M.member w (W.floating ws)++bluetileManageHook :: ManageHook+bluetileManageHook = composeAll+               [ workspaceByPos, positionStoreManageHook+                , className =? "MPlayer" --> doFloat+                , isFullscreen --> doFullFloat+                , manageDocks]++bluetileLayoutHook = avoidStruts $ minimize $ boringWindows $ (+                        named "Floating" floating |||+                        named "Tiled1" tiled1 |||+                        named "Tiled2" tiled2 |||+                        named "Fullscreen" fullscreen+                        )+        where+            floating = floatingDeco $ maximize $ borderResize $ positionStoreFloat+            tiled1 = tilingDeco $ maximize $ mouseResizableTileMirrored+            tiled2 = tilingDeco $ maximize $ mouseResizableTile+            fullscreen = tilingDeco $ maximize $ smartBorders Full++            tilingDeco l = windowSwitcherDecorationWithButtons shrinkText defaultThemeWithButtons (draggingVisualizer l)+            floatingDeco l = buttonDeco shrinkText defaultThemeWithButtons l++bluetileConfig =+    defaultConfig+        { modMask = mod4Mask,   -- logo key+          manageHook = bluetileManageHook,+          layoutHook = bluetileLayoutHook,+          logHook = currentWorkspaceOnTop >> ewmhDesktopsLogHook,+          handleEventHook = ewmhDesktopsEventHook+                                `mappend` fullscreenEventHook+                                `mappend` restoreMinimizedEventHook+                                `mappend` serverModeEventHook' bluetileCommands+                                `mappend` positionStoreEventHook,+          workspaces = bluetileWorkspaces,+          keys = bluetileKeys,+          mouseBindings = bluetileMouseBindings,+          focusFollowsMouse = False,+          focusedBorderColor = "#000000",+          terminal = "gnome-terminal"+        }

@@ -7,30 +7,172 @@ -- 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+     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-    , handleEventHook = ewmhDesktopsEventHook-    , 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 "XMonad.Doc.Extending#Extending xmonad".++-- $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            = desktopKeys <+> keys defaultConfig }+ desktopKeys (XConfig {modMask = modm}) = M.fromList $     [ ((modm, xK_b), sendMessage ToggleStruts) ]  desktopLayoutModifiers layout = avoidStruts layout+

@@ -10,7 +10,6 @@  import XMonad hiding (keys, config, (|||)) import qualified XMonad (keys)-import XMonad.Config ( defaultConfig )  import qualified XMonad.StackSet as W import qualified Data.Map as M@@ -22,7 +21,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 +39,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,-                                   ewmhDesktopsEventHook )+import XMonad.Hooks.EwmhDesktops ( ewmh )  myXPConfig :: XPConfig myXPConfig = defaultXPConfig {font="-*-lucida-medium-r-*-*-14-*-*-*-*-*-*-*"@@ -95,7 +93,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,13 +110,13 @@     , ((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 = showWName $ workspaceDir "~" $@@ -131,11 +129,9 @@                                                 ****//* 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.-         , handleEventHook = ewmhDesktopsEventHook          , XMonad.modMask = mod1Mask          , XMonad.keys = keys          }@@ -143,12 +139,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

@@ -7,6 +7,8 @@ -- 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.@@ -15,14 +17,18 @@     -- * 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     = gnomeKeys <+> keys desktopConfig+    , 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,6 +7,8 @@ -- 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.@@ -32,15 +34,17 @@ -- > 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 }+    , keys     = kdeKeys <+> keys desktopConfig }  kde4Config = desktopConfig     { terminal = "konsole"-    , keys     = \c -> kde4Keys c `M.union` keys desktopConfig c }+    , keys     = kde4Keys <+> keys desktopConfig }  kdeKeys (XConfig {modMask = modm}) = M.fromList $     [ ((modm,               xK_p), spawn "dcop kdesktop default popupExecuteCommand")

@@ -1,58 +1,64 @@ {-# OPTIONS_GHC -fno-warn-missing-signatures #-}-module XMonad.Config.Sjanssen (sjanssenConfig, sjanssenConfigXmobar) where+module XMonad.Config.Sjanssen (sjanssenConfig) where  import XMonad hiding (Tall(..)) import qualified XMonad.StackSet as W import XMonad.Actions.CopyWindow import XMonad.Layout.Tabbed import XMonad.Layout.HintedTile-import XMonad.Config (defaultConfig) import XMonad.Layout.NoBorders-import XMonad.Hooks.DynamicLog hiding (xmobar)+import XMonad.Hooks.DynamicLog import XMonad.Hooks.ManageDocks+import XMonad.Hooks.ManageHelpers (isFullscreen, doFullFloat) import XMonad.Hooks.EwmhDesktops import XMonad.Prompt import XMonad.Actions.SpawnOn+import XMonad.Util.SpawnOnce  import XMonad.Layout.LayoutScreens import XMonad.Layout.TwoPane  import qualified Data.Map as M -sjanssenConfigXmobar = statusBar "xmobar" sjanssenPP strutkey =<< sjanssenConfig- where-    strutkey (XConfig {modMask = modm}) = (modm, xK_b)--sjanssenConfig = do-    sp <- mkSpawner-    return $ defaultConfig-        { terminal = "urxvtc"+sjanssenConfig =+    ewmh $ defaultConfig+        { terminal = "exec urxvt"         , workspaces = ["irc", "web"] ++ map show [3 .. 9 :: Int]         , mouseBindings = \(XConfig {modMask = modm}) -> M.fromList $                 [ ((modm, button1), (\w -> focus w >> mouseMoveWindow w))                 , ((modm, button2), (\w -> focus w >> windows W.swapMaster))                 , ((modm.|. shiftMask, button1), (\w -> focus w >> mouseResizeWindow w)) ]-        , keys = \c -> mykeys sp c `M.union` keys defaultConfig c-        , layoutHook = modifiers layouts-        , logHook    = ewmhDesktopsLogHook-        , manageHook = composeAll [className =? x --> doShift w+        , keys = \c -> mykeys c `M.union` keys defaultConfig c+        , logHook = dynamicLogString sjanssenPP >>= xmonadPropLog+        , layoutHook  = modifiers layouts+        , manageHook  = composeAll [className =? x --> doShift w                                     | (x, w) <- [ ("Firefox", "web")                                                 , ("Ktorrent", "7")                                                 , ("Amarokapp", "7")]]-                       <+> manageHook defaultConfig <+> manageDocks <+> manageSpawn sp+                        <+> manageHook defaultConfig <+> manageDocks <+> manageSpawn+                        <+> (isFullscreen --> doFullFloat)+        , startupHook = mapM_ spawnOnce spawns         }  where     tiled     = HintedTile 1 0.03 0.5 TopLeft     layouts   = (tiled Tall ||| (tiled Wide ||| Full)) ||| tabbed shrinkText myTheme-    modifiers = smartBorders+    modifiers = avoidStruts . smartBorders -    mykeys sp (XConfig {modMask = modm, workspaces = ws}) = M.fromList $-        [((modm,               xK_p     ), shellPromptHere sp myPromptConfig)+    spawns = [ "xmobar"+             , "xset -b", "xset s off", "xset dpms 0 600 1200"+             , "nitrogen --set-tiled wallpaper/wallpaper.jpg"+             , "trayer --transparent true --expand true --align right "+               ++ "--edge bottom --widthtype request" ]++    mykeys (XConfig {modMask = modm}) = M.fromList $+        [((modm,               xK_p     ), shellPromptHere myPromptConfig)+        ,((modm .|. shiftMask, xK_Return), spawnHere =<< 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 .|. shiftMask, xK_0     ), windows $ copyToAll)         ,((modm,               xK_z     ), layoutScreens 2 $ TwoPane 0.5 0.5)         ,((modm .|. shiftMask, xK_z     ), rescreen)+        , ((modm             , xK_b     ), sendMessage ToggleStruts)         ]      myFont = "xft:Bitstream Vera Sans Mono:pixelsize=10"

@@ -6,7 +6,9 @@ -- 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.@@ -29,11 +31,12 @@ -- > import XMonad.Config.Xfce -- > -- > main = xmonad xfceConfig--- +--+-- For examples of how to further customize @xfceConfig@ see "XMonad.Config.Desktop".  xfceConfig = desktopConfig     { terminal = "Terminal"-    , keys     = \c -> xfceKeys c `M.union` keys desktopConfig c }+    , keys     = xfceKeys <+> keys desktopConfig }  xfceKeys (XConfig {modMask = modm}) = M.fromList $     [ ((modm,               xK_p), spawn "xfrun4")

@@ -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.@@ -135,7 +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@.+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,41 +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.Paste" provides utilities for pasting or sending keys and-  strings to windows;+* "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.XSelection" provide utilities for using the mouse-  selection;+* "XMonad.Util.Themes":+    A (hopefully) growing collection of themes for decorated layouts. -* "XMonad.Util.XUtils" and "XMonad.Util.Font" are libraries for-  accessing Xlib and XFT function in a convenient way.+* "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+ -}  --------------------------------------------------------------------------------@@ -530,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",@@ -543,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@@ -554,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 ()) @@ -574,21 +977,27 @@ 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}) = M.fromList+>             [ ((modm, xK_F12), xmonadPrompt defaultXPConfig)+>             , ((modm, xK_F3 ), shellPrompt  defaultXPConfig) >             ]  then you can create a new key bindings map by joining the default one with yours: ->    newKeys x  = M.union (keys defaultConfig x) (M.fromList (myKeys x))+>    newKeys x  = myKeys x `M.union` keys defaultConfig x  Finally, you can use @newKeys@ in the 'XMonad.Core.XConfig.keys' field of the configuration:  >    main = xmonad $ defaultConfig { keys = newKeys } +Alternatively, the '<+>' operator can be used which in this usage does exactly+the same as the explicit usage of 'M.union' and propagation of the config+argument, thanks to appropriate instances in "Data.Monoid".++>    main = xmonad $ defaultConfig { keys = myKeys <+> keys defaultConfig }+ All together, your @~\/.xmonad\/xmonad.hs@ would now look like this:  @@ -603,13 +1012,11 @@ >    import XMonad.Prompt.XMonad > >    main :: IO ()->    main = xmonad $ defaultConfig { keys = newKeys }->->    newKeys x = M.union (keys defaultConfig x) (M.fromList (myKeys x))+>    main = xmonad $ defaultConfig { keys = myKeys <+> keys defaultConfig } >->    myKeys x =->             [ ((modMask x, xK_F12), xmonadPrompt defaultXPConfig)->             , ((modMask x, xK_F3 ), shellPrompt  defaultXPConfig)+>    myKeys conf@(XConfig {XMonad.modMask = modm}) = M.fromList+>             [ ((modm, xK_F12), xmonadPrompt defaultXPConfig)+>             , ((modm, xK_F3 ), shellPrompt  defaultXPConfig) >             ]  There are much simpler ways to accomplish this, however, if you are@@ -631,12 +1038,12 @@ to define @newKeys@ as a 'Data.Map.difference' between the default map and the map of the key bindings you want to remove.  Like so: ->    newKeys x = M.difference (keys defaultConfig x) (M.fromList $ keysToRemove x)+>    newKeys x = keys defaultConfig x `M.difference` keysToRemove x >->    keysToRemove :: XConfig Layout ->    [((KeyMask, KeySym),X ())]->    keysToRemove x =->             [ ((modMask x              , xK_q ), return ())->             , ((modMask x .|. shiftMask, xK_q ), return ())+>    keysToRemove :: XConfig Layout ->    M.Map (KeyMask, KeySym) (X ())+>    keysToRemove x = M.fromList+>             [ ((modm              , xK_q ), return ())+>             , ((modm .|. shiftMask, xK_q ), return ()) >             ]  As you can see, it doesn't matter what actions we associate with the@@ -651,8 +1058,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@@ -672,23 +1079,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)] >        ]@@ -697,6 +1104,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

@@ -1,43 +0,0 @@-------------------------------------------------------------------------------- |--- Module      :  XMonad.Hooks.BluetileDock--- Copyright   :  (c) Jan Vornberger 2009--- License     :  BSD3-style (see LICENSE)------ Maintainer  :  jan.vornberger@informatik.uni-oldenburg.de--- Stability   :  unstable--- Portability :  not portable-----------------------------------------------------------------------------------module XMonad.Hooks.BluetileDock (-    bluetileDock-  ) where--import XMonad-import qualified XMonad.StackSet as S-import System.IO-import Control.Monad(forM_)--data DockOutput = DO Int String String deriving (Show, Read)--bluetileDock :: Handle -> X ()-bluetileDock outputHandle = do-    ws <- gets windowset-    let allscreens = S.screens ws-    let outputs = for allscreens $ \s -> DO (getScreenId (S.screen s))-                                            (getLayoutDesc s)-                                            (getCurrentWorkspace s)-    forM_ outputs $ \o -> io $ hPutStrLn outputHandle $ show o--getScreenId :: ScreenId -> Int-getScreenId (S sid) = sid--getLayoutDesc :: S.Screen i (Layout Window) a sid sd -> String-getLayoutDesc = description . S.layout . S.workspace--getCurrentWorkspace :: S.Screen i l a sid sd -> i-getCurrentWorkspace = S.tag . S.workspace--for :: [a] -> (a -> b) -> [b]-for = flip map

@@ -0,0 +1,62 @@+{-# LANGUAGE DeriveDataTypeable #-}+----------------------------------------------------------------------------+-- |+-- Module      :  XMonad.Hooks.CurrentWorkspaceOnTop+-- Copyright   :  (c) Jan Vornberger 2009+-- License     :  BSD3-style (see LICENSE)+--+-- Maintainer  :  jan.vornberger@informatik.uni-oldenburg.de+-- Stability   :  unstable+-- Portability :  not portable+--+-- Ensures that the windows of the current workspace are always in front+-- of windows that are located on other visible screens. This becomes important+-- if you use decoration and drag windows from one screen to another. Using this+-- module, the dragged window will always be in front of other windows.+--+-----------------------------------------------------------------------------++module XMonad.Hooks.CurrentWorkspaceOnTop (+    -- * Usage+    -- $usage+    currentWorkspaceOnTop+    ) where++import XMonad+import qualified XMonad.StackSet as S+import qualified XMonad.Util.ExtensibleState as XS+import Control.Monad(when)++-- $usage+-- You can use this module with the following in your @~\/.xmonad\/xmonad.hs@:+--+-- > import XMonad.Hooks.CurrentWorkspaceOnTop+-- >+-- > main = xmonad $ defaultConfig {+-- >    ...+-- >    logHook = currentWorkspaceOnTop+-- >    ...+-- >  }+--++data CWOTState = CWOTS String deriving Typeable++instance ExtensionClass CWOTState where+  initialValue = CWOTS ""++currentWorkspaceOnTop :: X ()+currentWorkspaceOnTop = withDisplay $ \d -> do+    ws <- gets windowset+    (CWOTS lastTag) <- XS.get+    let curTag = S.tag . S.workspace . S.current $ ws+    when (curTag /= lastTag) $ do+        let s = S.current ws+            wsp = S.workspace s+            viewrect = screenRect $ S.screenDetail s+            tmpStack = S.stack . S.workspace $ s+        (rs, _) <- runLayout wsp { S.stack = tmpStack } viewrect+        let wins = map fst rs+        when (not . null $ wins) $ do+            io $ raiseWindow d (head wins)  -- raise first window of current workspace to the very top,+            io $ restackWindows d wins      -- then use restackWindows to let all other windows from the workspace follow+        XS.put(CWOTS curTag)

@@ -1,32 +0,0 @@-------------------------------------------------------------------------------- |--- Module      :  XMonad.Hooks.CustomRestart--- Copyright   :  (c) Jan Vornberger 2009--- License     :  BSD3-style (see LICENSE)------ Maintainer  :  jan.vornberger@informatik.uni-oldenburg.de--- Stability   :  unstable--- Portability :  not portable-----------------------------------------------------------------------------------module XMonad.Hooks.CustomRestart-    ( CustomRestart (..)-    , customRestartEventHook-    ) where--import Control.Monad (when)-import Data.Monoid--import XMonad--data CustomRestart = CustomRestart deriving ( Show, Read )--customRestartEventHook :: String -> Event -> X All-customRestartEventHook prog (ClientMessageEvent {ev_message_type = mt}) = do-        d <- asks display-        a <- io $ internAtom d "XMONAD_CUSTOM_RESTART" False-        when (mt == a) $ do-            restart prog True-        return (All True)-customRestartEventHook _ _ = return (All True)