[XMonad.Config.Prime, a do-notation for config me@twifkak.com**20130311094617 Ignore-this: 8bbccaf7d8673f166ce5bb8dcd418fa2 Note that the use of RebindableSyntax is because of the need to vary the layoutHook type throughout the config. The alternative, using the existential Layout type, was rejected because it required TemplateHaskell in order to look nice, and TemplateHaskell is not portable. ] { addfile ./XMonad/Config/Prime.hs hunk ./XMonad/Config/Prime.hs 1 +{-# LANGUAGE FlexibleContexts, FlexibleInstances, MultiParamTypeClasses #-} + +----------------------------------------------------------------------------- +-- | +-- Module : XMonad.Config.Prime +-- Copyright : Devin Mullins +-- License : BSD-style (see LICENSE) +-- +-- Maintainer : Devin Mullins +-- Stability : unstable +-- Portability : unportable +-- +-- This is a draft of a brand new config syntax for xmonad. It aims to be: +-- +-- * easier to copy/paste snippets from the docs +-- +-- * easier to get the gist for what's going on, for you imperative programmers +-- +-- It's brand new, so it's pretty much guaranteed to break or change syntax. +-- But what's the worst that could happen? Xmonad crashes and logs you out? +-- It probably won't do that. Give it a try. +-- +----------------------------------------------------------------------------- + +module XMonad.Config.Prime ( +-- Note: The identifiers here are listed in the order that makes the most sense +-- for a user, while the definitions below are listed in the order that makes +-- the most sense for a developer. + +-- * Start here +-- $start_here +xmonad, +nothing, +-- * Attributes you can set +-- $settables +normalBorderColor, +focusedBorderColor, +terminal, +modMask, +borderWidth, +focusFollowsMouse, +(=:), +(=.), + +-- * Attributes you can add to +-- $summables +manageHook, +handleEventHook, +workspaces, +logHook, +startupHook, +(=+), + +-- * Modifying the keyboard / mouse bindings +-- $bindings +addKeys, +removeKeys, +addMouseBindings, +removeMouseBindings, +keys, +mouseBindings, + +-- * Modifying the layoutHook +-- $layout +addLayout, +resetLayout, +modifyLayout, + +-- * Update entire XConfig +-- $update +apply, + +-- * The rest of the world +-- | Everything you know and love from the core "XMonad" module is available +-- for use in your config file, too. +module XMonad, +-- | (Almost) everything you know and love from the Haskell "Prelude" is +-- available for use in your config file. Note that '>>' and friends have been +-- overriden, so if you want to create do-blocks for normal monads, you'll need +-- some let statements or a separate module. +module Prelude, + +-- * Core +-- | These are the building blocks on which the config language is built. +-- Regular people shouldn't need to know about these. +Prime, +(>>), (>>=), fail, +Summable, +(^+), + +-- * Example config +-- $example +) where + +import Prelude hiding ((>>=), (>>), fail) +import qualified Prelude as P ((>>=), (>>), fail) + +import Data.Accessor (accessor, Accessor, (^=), (^:)) +import qualified Data.Map as M +import Data.Monoid (All, Monoid, mappend) + +import XMonad hiding (xmonad, XConfig(..)) +import XMonad (XConfig(XConfig)) +import qualified XMonad as X (xmonad, XConfig(..)) + +import XMonad.Util.EZConfig (additionalKeysP, additionalMouseBindings, checkKeymap, removeKeysP) +import qualified XMonad.Util.EZConfig as EZ (removeMouseBindings) + +-- $start_here +-- To start with, have a @~\/.xmonad\/xmonad.hs@ that looks like this: +-- +-- > {-# LANGUAGE RebindableSyntax #-} +-- > +-- > import XMonad.Config.Prime +-- > +-- > -- Imports go here. +-- > +-- > main = xmonad $ do +-- > nothing +-- > -- Configs go here. +-- +-- This will give you a default xmonad install, with room to grow. The lines +-- starting with double dashes are comments. You may delete them. Note that +-- Haskell is a bit precise about indentation. Make sure all the statements in +-- your do-block start at the same column, and make sure that any multi-line +-- statements are indented further on the subsequent lines. (For an example, +-- see the 'addKeys' statement in the /Example config/ section, below.) + +-- +-- The Prime "Monad" +-- + +-- | A Prime is a function that transforms an XConfig. It's not a monad, but we +-- turn on RebindableSyntax so we can abuse the pretty do notation. +type Prime l l' = XConfig l -> IO (XConfig l') + +-- | Composes two Primes using 'Prelude.>>=' from "Prelude". +(>>) :: Prime l l' -> Prime l' l'' -> Prime l l'' +(>>) x y c = (P.>>=) (x c) y + +-- | An alias to '>>', passing @()@ as the encapsulated value. @y <- x@ syntax +-- doesn't have any meaning in this config language. Here for completeness. +(>>=) :: Prime l l' -> (() -> Prime l' l'') -> Prime l l'' +(>>=) x y = x >> y () + +-- | Delegates to the 'Prelude.fail' definition for the 'IO' instance. Here for completeness. +fail :: String -> Prime l l'' +fail s = const $ P.fail s + +-- | This is the xmonad main function. It passes 'defaultConfig' to your +-- do-block, takes the modified config out of your do-block, and runs xmonad. +-- +-- The do-block is a 'Prime'. Advanced readers can skip right to that +-- definition. + +-- TODO: Figure out how to type this without hard-coding the defaultConfig layout type. +xmonad :: (Read (l Window), LayoutClass l Window) => + (XConfig (Choose Tall (Choose (Mirror Tall) Full)) -> IO (XConfig l)) -> IO () +xmonad prime = (P.>>=) (prime defaultConfig) X.xmonad + +-- | This doesn't modify the config in any way. It's just here for your initial +-- config because Haskell doesn't allow empty do-blocks. Feel free to delete it +-- once you've added other stuff. +nothing :: Prime l l +nothing = return + +-- $settables +-- These are a bunch of attributes that you can set. Syntax looks like this: +-- +-- > terminal =: "urxvt" +-- +-- Strings are double quoted, Dimensions are unquoted integers, booleans are +-- 'True' or 'False' (case-sensitive), and 'modMask' is usually 'mod1Mask' or +-- 'mod4Mask'. + +-- | This lets you set an attribute. +(=:) :: Accessor (XConfig l) x -> x -> Prime l l +s =: x = return . (s ^= x) + +-- | This lets you apply a function to an attribute (i.e. read, modify, write). +(=.) :: Accessor (XConfig l) x -> (x -> x) -> Prime l l +s =. f = return . (s ^: f) + +-- | Non-focused windows border color. Default: @\"#dddddd\"@ +normalBorderColor :: Accessor (XConfig l) String +normalBorderColor = accessor X.normalBorderColor (\x c -> c { X.normalBorderColor = x }) + +-- | Focused windows border color. Default: @\"#ff0000\"@ +focusedBorderColor :: Accessor (XConfig l) String +focusedBorderColor = accessor X.focusedBorderColor (\x c -> c { X.focusedBorderColor = x }) + +-- | The preferred terminal application. Default: @\"xterm\"@ +terminal :: Accessor (XConfig l) String +terminal = accessor X.terminal (\x c -> c { X.terminal = x }) + +-- | The mod modifier, as used by key bindings. Default: @mod1Mask@ (which is +-- probably alt on your computer). +modMask :: Accessor (XConfig l) KeyMask +modMask = accessor X.modMask (\x c -> c { X.modMask = x }) + +-- | The border width (in pixels). Default: @1@ +borderWidth :: Accessor (XConfig l) Dimension +borderWidth = accessor X.borderWidth (\x c -> c { X.borderWidth = x }) + +-- | Whether window focus follows the mouse cursor on move, or requires a mouse +-- click. (Mouse? What's that?) Default: @True@ +focusFollowsMouse :: Accessor (XConfig l) Bool +focusFollowsMouse = accessor X.focusFollowsMouse (\x c -> c { X.focusFollowsMouse = x }) + +-- $summables +-- In addition to being able to set these attributes, they have a special +-- syntax for being able to add to them. The operator is @=+@ (the plus comes +-- /after/ the equals), but each attribute has a different syntax for what +-- comes after the operator. + +-- | Any old thing which can accumulate stuff. A monoid without the associativity requirement? +class Summable x y where + (.+.) :: x -> y -> x + +-- This covers a suprising number of cases. +instance Monoid m => Summable m m where + (.+.) = mappend + +-- | Adds 'y' to the given accessor 'x'. +(^+) :: Summable x y => Accessor r x -> y -> r -> r +s ^+ y = s ^: (.+. y) +infixr 5 ^+ + +-- | This lets you add to an attribute. +(=+) :: Summable x y => Accessor (XConfig l) x -> y -> Prime l l +s =+ y = return . (s ^+ y) +infix 0 =+ + +-- | The action to run when a new window is opened. Default: +-- +-- > manageHook =: composeAll [className =? "MPlayer" --> doFloat, className =? "Gimp" --> doFloat] +-- +-- To add more rules to this list, you can say, for instance: +-- +-- > manageHook =+ (className =? "Emacs" --> doF . kill =<< ask) +-- > manageHook =+ (className =? "Vim" --> doF . shiftMaster =<< ask) +-- +-- Note that operator precedence mandates the parentheses here. +manageHook :: Accessor (XConfig l) ManageHook +manageHook = accessor X.manageHook (\x c -> c { X.manageHook = x }) + +-- | Custom X event handler. Return @All True@ if the default handler should +-- also be run afterwards. Default does nothing. To add an event handler: +-- +-- > import XMonad.Hooks.ServerMode +-- > ... +-- > handleEventHook =+ serverModeEventHook +handleEventHook :: Accessor (XConfig l) (Event -> X All) +handleEventHook = accessor X.handleEventHook (\x c -> c { X.handleEventHook = x }) + +-- | List of workspaces' names. Default: @map show [1 .. 9 :: Int]@. Adding +-- appends to the end: +-- +-- > workspaces =+ ["0"] +-- +-- This is useless unless you also create keybindings for this. +workspaces :: Accessor (XConfig l) [String] +workspaces = accessor X.workspaces (\x c -> c { X.workspaces = x }) + +-- TODO: Rework the workspaces thing to pair names with keybindings. + +-- | The action to perform when the windows set is changed. This happens +-- whenever focus change, a window is moved, etc. @logHook =+@ takes an @X ()@ +-- and appends it via '(>>)'. For instance: +-- +-- > import XMonad.Hooks.ICCCMFocus +-- > ... +-- > logHook =+ takeTopFocus +-- +-- Note that if your expression is parametrically typed (e.g. of type +-- @MonadIO m => m ()@), you'll need to explicitly annotate it, like so: +-- +-- > logHook =+ (io $ putStrLn "Hello, world!" :: X ()) +logHook :: Accessor (XConfig l) (X ()) +logHook = accessor X.logHook (\x c -> c { X.logHook = x }) + +-- | The action to perform on startup. @startupHook =+@ takes an @X ()@ and +-- appends it via '(>>)'. For instance: +-- +-- > import XMonad.Hooks.SetWMName +-- > ... +-- > startupHook =+ setWMName "LG3D" +-- +-- Note that if your expression is parametrically typed (e.g. of type +-- @MonadIO m => m ()@), you'll need to explicitly annotate it, as documented +-- in 'logHook'. +startupHook :: Accessor (XConfig l) (X ()) +startupHook = accessor X.startupHook (\x c -> c { X.startupHook = x }) + +-- $bindings +-- Technically, you can modify 'keys' and 'mouseBindings' using the @=:@ and +-- @=.@ operators, but you're better off using the following helper functions. + +-- | Add a key binding to an 'X' action. Default: see @`man xmonad`@. 'addKeys' +-- takes a list of keybindings specified emacs-style, as documented in +-- 'XMonad.Util.EZConfig.mkKeyMap'. For example, to add a help button to +-- XMonad: +-- +-- > addKeys [("", spawn "echo RTFS | dzen2 -p 2")] + +-- Note: Since checkKeymap happens on newKeys, it doesn't check for +-- duplicates between repeated applications. Probably OK. (Especially since +-- overriding defaults is a common behavior.) +-- Also note that there's no reference cycle here. Yay! +addKeys :: [(String, X ())] -> Prime l l +addKeys newKeys c = return (c `additionalKeysP` newKeys) { X.startupHook = (P.>>) (X.startupHook c) (checkKeymap c newKeys) } + +-- | Remove a key binding. For example, if you accidentally hit mod-shift-q a +-- lot and would rather @`pkill xmonad`@ to logout: +-- +-- > removeKeys ["M-S-q"] +removeKeys :: [String] -> Prime l l +removeKeys sadKeys c = return (c `removeKeysP` sadKeys) + +-- | Add a mouse button binding to an 'X' action on a window. Default: see @`man +-- xmonad`@. To make mod- switch workspaces: +-- +-- > import XMonad.Actions.CycleWS (nextWS, prevWS) +-- > ... +-- > addMouseBindings [((mod4Mask, button4), const prevWS), +-- > ((mod4Mask, button5), const nextWS)] +-- +-- Note that you need to specify the numbered mod-mask e.g. 'mod4Mask' instead +-- of just 'modMask'. +addMouseBindings :: [((ButtonMask, Button), Window -> X ())] -> Prime l l +addMouseBindings newBindings c = return (c `additionalMouseBindings` newBindings) + +-- | Remove a mouse button binding. For instance: +-- +-- > removeMouseBindings [(mod4Mask, button2)] +removeMouseBindings :: [(ButtonMask, Button)] -> Prime l l +removeMouseBindings sadBindings c = return (c `EZ.removeMouseBindings` sadBindings) + +-- | The keys accessor, if you want to do it the hard way. +keys :: Accessor (XConfig l) (XConfig Layout -> M.Map (ButtonMask, KeySym) (X ())) +keys = accessor X.keys (\x c -> c { X.keys = x }) + +-- | The mouseBindings accessor, if you want to do it the hard way. +mouseBindings :: Accessor (XConfig l) (XConfig Layout -> M.Map (ButtonMask, Button) (Window -> X ())) +mouseBindings = accessor X.mouseBindings (\x c -> c { X.mouseBindings = x }) + +-- $layout +-- Layouts are special. You can't modify them using the @=:@ or @=.@ operator. +-- You need to use the following functions. + +-- | Add a layout to the list of layouts choosable with mod-space. For instance: +-- +-- > import XMonad.Layout.Tabbed +-- > ... +-- > addLayout simpleTabbed +addLayout :: (LayoutClass l Window, LayoutClass r Window) => r Window -> Prime l (Choose l r) +addLayout r c = return c { X.layoutHook = X.layoutHook c ||| r } + +-- | Reset the layoutHook from scratch. For instance, to get rid of the wide +-- layout: +-- +-- > resetLayout $ Tall 1 (3/100) (1/2) ||| Full +-- +-- (The dollar is like an auto-closing parenthesis, so all the stuff to the +-- right of it is treated like an argument to resetLayout.) +resetLayout :: (LayoutClass r Window) => r Window -> Prime l r +resetLayout r c = return c { X.layoutHook = r } + +-- | Modify your 'layoutHook' with some wrapper function. You probably want to call +-- this after you're done calling 'addLayout'. Example: +-- +-- > import XMonad.Layout.NoBorders +-- > ... +-- > modifyLayout smartBorders +modifyLayout :: (LayoutClass r Window) => (l Window -> r Window) -> Prime l r +modifyLayout f c = return c { X.layoutHook = f $ X.layoutHook c } + +-- $update +-- Finally, there are a few contrib modules that bundle multiple attribute +-- updates up into functions that update the entire configuration. There are +-- two types: those that involve IO and those that don't. The syntax for each +-- is different. +-- +-- For instance, 'XMonad.Hooks.UrgencyHook.withUrgencyHook' returns an @XConfig +-- l@, so we need to use 'apply': +-- +-- > import XMonad.Hooks.UrgencyHook +-- > ... +-- > apply $ withUrgencyHook dzenUrgencyHook +-- +-- On the other hand, 'XMonad.Hooks.DynamicLog.xmobar' returns an @IO (XConfig +-- l)@, so we can include it like so: +-- +-- > import XMonad.Hooks.DynamicLog +-- > ... +-- > xmobar + +-- | Turns a pure function on 'XConfig' into a 'Prime'. +apply :: (XConfig l -> XConfig l') -> Prime l l' +apply f = return . f + +-- $example +-- As an example, I've included below a subset of my current config. Note that +-- my import statements specify individual identifiers in parentheticals. +-- That's optional. The default is to import the entire module. I just find it +-- helpful to remind me where things came from. +-- +-- > {-# LANGUAGE RebindableSyntax #-} +-- > import XMonad.Config.Prime +-- > +-- > import XMonad.Actions.CycleWS (prevWS, nextWS) +-- > import XMonad.Actions.WindowNavigation (withWindowNavigation) +-- > import XMonad.Layout.Fullscreen (fullscreenSupport) +-- > import XMonad.Layout.NoBorders (smartBorders) +-- > import XMonad.Layout.Tabbed (simpleTabbed) +-- > +-- > main = xmonad $ do +-- > modMask =: mod4Mask +-- > normalBorderColor =: "#222222" +-- > terminal =: "urxvt" +-- > focusFollowsMouse =: False +-- > resetLayout $ Tall 1 (3/100) (1/2) ||| simpleTabbed +-- > apply fullscreenSupport +-- > modifyLayout smartBorders +-- > withWindowNavigation (xK_w, xK_a, xK_s, xK_d) +-- > addKeys [ +-- > ("M-,", sendMessage $ IncMasterN (-1)), +-- > ("M-.", sendMessage $ IncMasterN 1), +-- > ("M-M1-d", spawn "date | dzen2 -fg '#eeeeee' -p 2"), +-- > ("C-S-q", return ()), +-- > ("", spawn "amixer set Master 5%-"), +-- > ("", spawn "amixer set Master 5%+"), +-- > ("M-M1-x", kill), +-- > ("M-i", prevWS), +-- > ("M-o", nextWS) +-- > ] hunk ./XMonad/Layout/Fullscreen.hs 1 -{-# LANGUAGE DeriveDataTypeable, MultiParamTypeClasses, FlexibleInstances, TypeSynonymInstances #-} +{-# LANGUAGE DeriveDataTypeable, FlexibleContexts, MultiParamTypeClasses, FlexibleInstances, TypeSynonymInstances #-} ----------------------------------------------------------------------------- -- | -- Module : XMonad.Layout.Decoration hunk ./XMonad/Layout/Fullscreen.hs 18 module XMonad.Layout.Fullscreen ( -- * Usage: -- $usage - fullscreenFull + fullscreenSupport + ,fullscreenFull ,fullscreenFocus ,fullscreenFullRect ,fullscreenFocusRect hunk ./XMonad/Layout/Fullscreen.hs 57 -- To use this module, add 'fullscreenEventHook' and 'fullscreenManageHook' -- to your config, i.e. -- --- > xmonad defaultconfig { handleEventHook = fullscreenEventHook, +-- > xmonad defaultConfig { handleEventHook = fullscreenEventHook, -- > manageHook = fullscreenManageHook, -- > layoutHook = myLayouts } -- hunk ./XMonad/Layout/Fullscreen.hs 67 -- > myLayouts = fullscreenFull someLayout -- +-- | Modifies your config to apply basic fullscreen support -- fullscreen +-- windows when they request it. Example usage: +-- +-- > main = xmonad +-- > $ fullscreenSupport +-- > $ defaultConfig { ... } +fullscreenSupport :: LayoutClass l Window => + XConfig l -> XConfig (ModifiedLayout FullscreenFull l) +fullscreenSupport c = c { + layoutHook = fullscreenFull $ layoutHook c, + handleEventHook = handleEventHook c <+> fullscreenEventHook, + manageHook = manageHook c <+> fullscreenManageHook + } + -- | Messages that control the fullscreen state of the window. -- AddFullscreen and RemoveFullscreen are sent to all layouts -- when a window wants or no longer wants to be fullscreen. hunk ./xmonad-contrib.cabal 75 extensions: ForeignFunctionInterface cpp-options: -DXFT - build-depends: mtl >= 1 && < 3, unix, X11>=1.6.1 && < 1.7, xmonad>=0.11 && < 0.12, utf8-string + build-depends: mtl >= 1 && < 3, unix, X11 >= 1.6.1 && < 1.7, xmonad >= 0.11 && < 0.12, utf8-string, + data-accessor >= 0.1.2 if true ghc-options: -fwarn-tabs -Wall hunk ./xmonad-contrib.cabal 158 XMonad.Config.Droundy XMonad.Config.Gnome XMonad.Config.Kde + XMonad.Config.Prime XMonad.Config.Sjanssen XMonad.Config.Xfce XMonad.Hooks.CurrentWorkspaceOnTop }