aboutsummaryrefslogtreecommitdiffstats
path: root/XMonad
diff options
context:
space:
mode:
Diffstat (limited to 'XMonad')
-rw-r--r--XMonad/Config/Prime.hs495
-rw-r--r--XMonad/Layout/Fullscreen.hs19
2 files changed, 512 insertions, 2 deletions
diff --git a/XMonad/Config/Prime.hs b/XMonad/Config/Prime.hs
new file mode 100644
index 0000000..50a4e8c
--- /dev/null
+++ b/XMonad/Config/Prime.hs
@@ -0,0 +1,495 @@
+{-# LANGUAGE FlexibleContexts, FlexibleInstances, FunctionalDependencies, KindSignatures, MultiParamTypeClasses, UndecidableInstances #-}
+
+-----------------------------------------------------------------------------
+-- |
+-- Module : XMonad.Config.Prime
+-- Copyright : Devin Mullins <devinmullins@gmail.com>
+-- License : BSD-style (see LICENSE)
+--
+-- Maintainer : Devin Mullins <devinmullins@gmail.com>
+-- Stability : unstable
+-- Portability : unportable
+--
+-- This is a draft of a brand new config syntax for xmonad. It aims to be:
+--
+-- * easier to copy/paste snippets from the docs
+--
+-- * easier to get the gist for what's going on, for you imperative programmers
+--
+-- It's brand new, so it's pretty much guaranteed to break or change syntax.
+-- But what's the worst that could happen? Xmonad crashes and logs you out?
+-- It probably won't do that. Give it a try.
+--
+-----------------------------------------------------------------------------
+
+module XMonad.Config.Prime (
+-- Note: The identifiers here are listed in the order that makes the most sense
+-- for a user, while the definitions below are listed in the order that makes
+-- the most sense for a developer.
+
+-- * Start here
+-- $start_here
+xmonad,
+nothing,
+-- * Attributes you can set
+-- $settables
+normalBorderColor,
+focusedBorderColor,
+terminal,
+modMask,
+borderWidth,
+focusFollowsMouse,
+clickJustFocuses,
+SettableClass(..),
+UpdateableClass(..),
+
+-- * Attributes you can add to
+-- $summables
+manageHook,
+handleEventHook,
+workspaces,
+logHook,
+startupHook,
+clientMask,
+rootMask,
+SummableClass(..),
+
+-- * Attributes you can add to or remove from
+-- $removables
+keys,
+mouseBindings,
+RemovableClass(..),
+
+-- * Modifying the layoutHook
+-- $layout
+addLayout,
+resetLayout,
+modifyLayout,
+
+-- * Update entire XConfig
+-- $update
+startWith,
+apply,
+applyIO,
+
+-- * The rest of the world
+-- | Everything you know and love from the core "XMonad" module is available
+-- for use in your config file, too.
+module XMonad,
+-- | (Almost) everything you know and love from the Haskell "Prelude" is
+-- available for use in your config file. Note that '>>' has been overriden, so
+-- if you want to create do-blocks for normal monads, you'll need some let
+-- statements or a separate module. (See the Troubleshooting section.)
+module Prelude,
+
+-- * Core
+-- | These are the building blocks on which the config language is built.
+-- Regular people shouldn't need to know about these.
+Prime,
+(>>),
+
+-- * Example config
+-- $example
+
+-- * Troubleshooting
+-- $troubleshooting
+) where
+
+import Prelude hiding ((>>))
+import qualified Prelude as P ((>>=), (>>))
+
+import qualified Data.Map as M
+import Data.Monoid (All)
+
+import XMonad hiding (xmonad, XConfig(..))
+import XMonad (XConfig(XConfig))
+import qualified XMonad as X (xmonad, XConfig(..))
+
+import XMonad.Util.EZConfig (additionalKeysP, additionalMouseBindings, checkKeymap, mkKeymap, removeKeysP, removeMouseBindings)
+
+-- $start_here
+-- To start with, create a @~\/.xmonad\/xmonad.hs@ that looks like this:
+--
+-- > {-# LANGUAGE RebindableSyntax #-}
+-- > import XMonad.Config.Prime
+-- >
+-- > -- Imports go here.
+-- >
+-- > main = xmonad $ do
+-- > nothing
+-- > -- Configs go here.
+--
+-- This will give you a default xmonad install, with room to grow. The lines
+-- starting with double dashes are comments. You may delete them. Note that
+-- Haskell is a bit precise about indentation. Make sure all the statements in
+-- your do-block start at the same column, and make sure that any multi-line
+-- statements are 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
+
+-- | This is the xmonad main function. It passes the default config 'def' 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.
+
+xmonad :: (Default a, Read (l Window), LayoutClass l Window) =>
+ (a -> IO (XConfig l)) -> IO ()
+xmonad prime = (P.>>=) (prime def) X.xmonad
+
+-- | This doesn't modify the config in any way. It's just here for your initial
+-- config because Haskell doesn't allow empty do-blocks. Feel free to delete it
+-- once you've added other stuff.
+nothing :: Prime l l
+nothing = return
+
+-- $settables
+-- These are a bunch of attributes that you can set. Syntax looks like this:
+--
+-- > terminal =: "urxvt"
+--
+-- Strings are double quoted, Dimensions are unquoted integers, booleans are
+-- 'True' or 'False' (case-sensitive), and 'modMask' is usually 'mod1Mask' or
+-- 'mod4Mask'.
+
+class UpdateableClass s x y | s -> x y where
+ -- | This lets you apply a function to an attribute (i.e. read, modify, write).
+ (=.) :: s l -> (x -> y) -> Prime l l
+
+class SettableClass s x y | s -> x y where
+ -- | This lets you modify an attribute.
+ (=:) :: s l -> y -> Prime l l
+
+-- Undecideable instance. But it's nice to leave open the possibility to write
+-- fields you can't read (e.g. `wmName =: ...`).
+instance UpdateableClass s x y => SettableClass s x y where
+ s =: y = s =. const y
+
+data Settable x l = Settable (XConfig l -> x) -- getter
+ (x -> XConfig l -> XConfig l) -- setter
+
+instance UpdateableClass (Settable x) x x where
+ (Settable g s =. f) c = return $ s (f $ g c) c
+
+-- | Non-focused windows border color. Default: @\"#dddddd\"@
+normalBorderColor :: Settable String l
+normalBorderColor = Settable X.normalBorderColor (\x c -> c { X.normalBorderColor = x })
+
+-- | Focused windows border color. Default: @\"#ff0000\"@
+focusedBorderColor :: Settable String l
+focusedBorderColor = Settable X.focusedBorderColor (\x c -> c { X.focusedBorderColor = x })
+
+-- | The preferred terminal application. Default: @\"xterm\"@
+terminal :: Settable String l
+terminal = Settable X.terminal (\x c -> c { X.terminal = x })
+
+-- | The mod modifier, as used by key bindings. Default: @mod1Mask@ (which is
+-- probably alt on your computer).
+modMask :: Settable KeyMask l
+modMask = Settable X.modMask (\x c -> c { X.modMask = x })
+
+-- | The border width (in pixels). Default: @1@
+borderWidth :: Settable Dimension l
+borderWidth = Settable X.borderWidth (\x c -> c { X.borderWidth = x })
+
+-- | Whether window focus follows the mouse cursor on move, or requires a mouse
+-- click. (Mouse? What's that?) Default: @True@
+focusFollowsMouse :: Settable Bool l
+focusFollowsMouse = Settable X.focusFollowsMouse (\x c -> c { X.focusFollowsMouse = x })
+
+-- | If True, a mouse click on an inactive window focuses it, but the click is
+-- not passed to the window. If False, the click is also passed to the window.
+-- Default @True@
+clickJustFocuses :: Settable Bool l
+clickJustFocuses = Settable X.clickJustFocuses (\x c -> c { X.clickJustFocuses = x })
+
+-- $summables
+-- In addition to being able to set these attributes, they have a special
+-- syntax for being able to add to them. The operator is @=+@ (the plus comes
+-- /after/ the equals), but each attribute has a different syntax for what
+-- comes after the operator.
+
+class SummableClass s y | s -> y where
+ -- | This lets you add to an attribute.
+ (=+) :: s l -> y -> Prime l l
+ infix 0 =+
+
+data Summable x y l = Summable (XConfig l -> x) -- getter
+ (x -> XConfig l -> XConfig l) -- setter
+ (x -> y -> x) -- accumulator
+
+instance UpdateableClass (Summable x y) x x where
+ (Summable g s _ =. f) c = return $ s (f $ g c) c
+
+instance SummableClass (Summable x y) y where
+ (Summable g s a =+ y) c = return $ s (g c `a` y) c
+
+-- | The action to run when a new window is opened. Default:
+--
+-- > manageHook =: composeAll [className =? "MPlayer" --> doFloat, className =? "Gimp" --> doFloat]
+--
+-- To add more rules to this list, you can say, for instance:
+--
+-- > import XMonad.StackSet
+-- > ...
+-- > manageHook =+ (className =? "Emacs" --> doF kill)
+-- > manageHook =+ (className =? "Vim" --> doF shiftMaster)
+--
+-- Note that operator precedence mandates the parentheses here.
+manageHook :: Summable ManageHook ManageHook l
+manageHook = Summable X.manageHook (\x c -> c { X.manageHook = x }) (<+>)
+
+-- | Custom X event handler. Return @All True@ if the default handler should
+-- also be run afterwards. Default does nothing. To add an event handler:
+--
+-- > import XMonad.Hooks.ServerMode
+-- > ...
+-- > handleEventHook =+ serverModeEventHook
+handleEventHook :: Summable (Event -> X All) (Event -> X All) l
+handleEventHook = Summable X.handleEventHook (\x c -> c { X.handleEventHook = x }) (<+>)
+
+-- | List of workspaces' names. Default: @map show [1 .. 9 :: Int]@. Adding
+-- appends to the end:
+--
+-- > workspaces =+ ["0"]
+--
+-- This is useless unless you also create keybindings for this.
+workspaces :: Summable [String] [String] l
+workspaces = Summable 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 :: Summable (X ()) (X ()) l
+logHook = Summable X.logHook (\x c -> c { X.logHook = x }) (P.>>)
+
+-- | The action to perform on startup. @startupHook =+@ takes an @X ()@ and
+-- appends it via '(>>)'. For instance:
+--
+-- > import XMonad.Hooks.SetWMName
+-- > ...
+-- > startupHook =+ setWMName "LG3D"
+--
+-- Note that if your expression is parametrically typed (e.g. of type
+-- @MonadIO m => m ()@), you'll need to explicitly annotate it, as documented
+-- in 'logHook'.
+startupHook :: Summable (X ()) (X ()) l
+startupHook = Summable X.startupHook (\x c -> c { X.startupHook = x }) (P.>>)
+
+-- | The client events that xmonad is interested in. This is useful in
+-- combination with handleEventHook. Default: @structureNotifyMask .|.
+-- enterWindowMask .|. propertyChangeMask@
+--
+-- > clientMask =+ keyPressMask .|. keyReleaseMask
+clientMask :: Summable EventMask EventMask l
+clientMask = Summable X.clientMask (\x c -> c { X.clientMask = x }) (.|.)
+
+-- | The root events that xmonad is interested in. This is useful in
+-- combination with handleEventHook. Default: @substructureRedirectMask .|.
+-- substructureNotifyMask .|. enterWindowMask .|. leaveWindowMask .|.
+-- structureNotifyMask .|. buttonPressMask@
+rootMask :: Summable EventMask EventMask l
+rootMask = Summable X.rootMask (\x c -> c { X.rootMask = x }) (.|.)
+
+-- $removables
+-- The following support the the @=+@ for adding items and the @=-@ operator
+-- for removing items.
+
+class RemovableClass r y | r -> y where
+ -- | This lets you remove from an attribute.
+ (=-) :: r l -> y -> Prime l l
+ infix 0 =-
+
+data Keys (l :: * -> *) = Keys
+
+-- Note that since checkKeymap happens on newKeys, it doesn't check for
+-- duplicates between repeated applications. Probably OK. (Especially since
+-- overriding defaults is a common behavior.) Also note that there's no
+-- reference cycle here. Yay!
+
+instance UpdateableClass Keys (XConfig Layout -> M.Map (ButtonMask, KeySym) (X ())) [(String, X ())] where
+ (_ =. f) c = return c { X.keys = \c' -> mkKeymap c' newKeys,
+ X.startupHook = (P.>>) (X.startupHook c) (checkKeymap c newKeys) }
+ where newKeys = f $ X.keys c
+
+instance SummableClass Keys [(String, X ())] where
+ (_ =+ newKeys) c = return (c `additionalKeysP` newKeys) { X.startupHook = (P.>>) (X.startupHook c) (checkKeymap c newKeys) }
+
+instance RemovableClass Keys [String] where
+ (_ =- sadKeys) c = return (c `removeKeysP` sadKeys)
+
+-- | Key bindings to 'X' actions. Default: see @`man xmonad`@. 'keys'
+-- takes a list of keybindings specified emacs-style, as documented in
+-- 'XMonad.Util.EZConfig.mkKeyMap'. For example, to change the "kill window"
+-- key:
+--
+-- > keys =- ["M-S-c"]
+-- > keys =+ [("M-M1-x", kill)]
+keys :: Keys l
+keys = Keys
+
+data MouseBindings (l :: * -> *) = MouseBindings
+
+instance SummableClass MouseBindings [((ButtonMask, Button), Window -> X ())] where
+ (_ =+ newBindings) c = return (c `additionalMouseBindings` newBindings)
+
+instance RemovableClass MouseBindings [(ButtonMask, Button)] where
+ (_ =- sadBindings) c = return (c `removeMouseBindings` sadBindings)
+
+-- | Mouse button bindings to an 'X' actions on a window. Default: see @`man
+-- xmonad`@. To make mod-<scrollwheel> switch workspaces:
+--
+-- > import XMonad.Actions.CycleWS (nextWS, prevWS)
+-- > ...
+-- > mouseBindings =+ [((mod4Mask, button4), const prevWS),
+-- > ((mod4Mask, button5), const nextWS)]
+--
+-- Note that you need to specify the numbered mod-mask e.g. 'mod4Mask' instead
+-- of just 'modMask'.
+mouseBindings :: MouseBindings l
+mouseBindings = MouseBindings
+
+-- $layout
+-- Layouts are special. You can't modify them using the @=:@ or @=.@ operator.
+-- You need to use the following functions.
+
+-- | Add a layout to the list of layouts choosable with mod-space. For instance:
+--
+-- > import XMonad.Layout.Tabbed
+-- > ...
+-- > addLayout simpleTabbed
+addLayout :: (LayoutClass l Window, LayoutClass r Window) => r Window -> Prime l (Choose l r)
+addLayout r c = return c { X.layoutHook = X.layoutHook c ||| r }
+
+-- | Reset the layoutHook from scratch. For instance, to get rid of the wide
+-- layout:
+--
+-- > resetLayout $ Tall 1 (3/100) (1/2) ||| Full
+--
+-- (The dollar is like an auto-closing parenthesis, so all the stuff to the
+-- right of it is treated like an argument to resetLayout.)
+resetLayout :: (LayoutClass r Window) => r Window -> Prime l r
+resetLayout r c = return c { X.layoutHook = r }
+
+-- | Modify your 'layoutHook' with some wrapper function. You probably want to call
+-- this after you're done calling 'addLayout'. Example:
+--
+-- > import XMonad.Layout.NoBorders
+-- > ...
+-- > modifyLayout smartBorders
+modifyLayout :: (LayoutClass r Window) => (l Window -> r Window) -> Prime l r
+modifyLayout f c = return c { X.layoutHook = f $ X.layoutHook c }
+
+-- $update
+-- Finally, there are a few contrib modules that bundle multiple attribute
+-- updates together. There are three types: 1) wholesale replacements for the
+-- default config, 2) pure functions on the config, and 3) IO actions on the
+-- config. The syntax for each is different. Examples:
+--
+-- 1) To start with a 'XMonad.Config.Gnome.gnomeConfig' instead of the default,
+-- we use 'startWith':
+--
+-- > import XMonad.Config.Gnome
+-- > ...
+-- > startWith gnomeConfig
+--
+-- 2) 'XMonad.Hooks.UrgencyHook.withUrgencyHook' is a pure function, so we need
+-- to use 'apply':
+--
+-- > import XMonad.Hooks.UrgencyHook
+-- > ...
+-- > apply $ withUrgencyHook dzenUrgencyHook
+--
+-- 3) 'XMonad.Hooks.DynamicLog.xmobar' returns an @IO (XConfig l)@, so we need
+-- to use 'applyIO':
+--
+-- > import XMonad.Hooks.DynamicLog
+-- > ...
+-- > applyIO xmobar
+
+-- | Replace the current 'XConfig' with the given one. If you use this, you
+-- probably want it to be the first line of your config.
+startWith :: XConfig l' -> Prime l l'
+startWith = const . return
+
+-- | Turns a pure function on 'XConfig' into a 'Prime'.
+apply :: (XConfig l -> XConfig l') -> Prime l l'
+apply f = return . f
+
+-- | Turns an IO function on 'XConfig' into a 'Prime'.
+applyIO :: (XConfig l -> IO (XConfig l')) -> Prime l l'
+applyIO = id -- This is here in case we want to change the Prime type later.
+
+-- $example
+-- As an example, I've included below a subset of my current config. Note that
+-- my import statements specify individual identifiers in parentheticals.
+-- That's optional. The default is to import the entire module. I just find it
+-- helpful to remind me where things came from.
+--
+-- > {-# LANGUAGE RebindableSyntax #-}
+-- > import XMonad.Config.Prime
+-- >
+-- > import XMonad.Actions.CycleWS (prevWS, nextWS)
+-- > import XMonad.Actions.WindowNavigation (withWindowNavigation)
+-- > import XMonad.Layout.Fullscreen (fullscreenSupport)
+-- > import XMonad.Layout.NoBorders (smartBorders)
+-- > import XMonad.Layout.Tabbed (simpleTabbed)
+-- >
+-- > main = xmonad $ do
+-- > modMask =: mod4Mask
+-- > normalBorderColor =: "#222222"
+-- > terminal =: "urxvt"
+-- > focusFollowsMouse =: False
+-- > resetLayout $ Tall 1 (3/100) (1/2) ||| simpleTabbed
+-- > modifyLayout smartBorders
+-- > apply fullscreenSupport
+-- > applyIO $ withWindowNavigation (xK_w, xK_a, xK_s, xK_d)
+-- > keys =+ [
+-- > ("M-,", sendMessage $ IncMasterN (-1)),
+-- > ("M-.", sendMessage $ IncMasterN 1),
+-- > ("M-M1-d", spawn "date | dzen2 -fg '#eeeeee' -p 2"),
+-- > ("C-S-q", return ()),
+-- > ("<XF86AudioLowerVolume>", spawn "amixer set Master 5%-"),
+-- > ("<XF86AudioRaiseVolume>", spawn "amixer set Master 5%+"),
+-- > ("M-M1-x", kill),
+-- > ("M-i", prevWS),
+-- > ("M-o", nextWS)
+-- > ]
+
+-- $troubleshooting
+-- === Only the last line of my config seems to take effect. What gives?
+-- You're missing the @{-\# LANGUAGE RebindableSyntax \#-}@ line at the top.
+--
+-- === How do I do use normal monads like 'X' or 'IO'?
+-- Here are a couple of ways:
+--
+-- > import qualified Prelude as P
+-- > ...
+-- > test1, test2 :: X ()
+-- > test1 = spawn "echo Hi" P.>> spawn "echo Bye"
+-- > test2 = do spawn "echo Hi"
+-- > spawn "echo Bye"
+-- > where (>>) = (P.>>)
diff --git a/XMonad/Layout/Fullscreen.hs b/XMonad/Layout/Fullscreen.hs
index 386baab..779a1e9 100644
--- a/XMonad/Layout/Fullscreen.hs
+++ b/XMonad/Layout/Fullscreen.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE DeriveDataTypeable, MultiParamTypeClasses, FlexibleInstances, TypeSynonymInstances #-}
+{-# LANGUAGE DeriveDataTypeable, FlexibleContexts, MultiParamTypeClasses, FlexibleInstances, TypeSynonymInstances #-}
-----------------------------------------------------------------------------
-- |
-- Module : XMonad.Layout.Fullscreen
@@ -15,7 +15,8 @@
module XMonad.Layout.Fullscreen
( -- * Usage:
-- $usage
- fullscreenFull
+ fullscreenSupport
+ ,fullscreenFull
,fullscreenFocus
,fullscreenFullRect
,fullscreenFocusRect
@@ -63,6 +64,20 @@ import Control.Arrow (second)
-- > 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.