twin/xmonad
1
0
Fork 0
mirror of https://github.com/xmonad/xmonad.git synced 2025-05-19 08:30:21 -07:00
Code Issues Packages Projects Releases Wiki Activity

haddock compatibility

Browse Source
This commit is contained in:
Andrea Rossato 2007-06-10 12:37:46 +00:00
parent 6365601c77
commit e1885f27e1
5 changed files with 107 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
Config.hs
View File

@ -8,12 +8,12 @@
-- Stability : stable
-- Portability : portable
--
------------------------------------------------------------------------
--
-- This module specifies configurable defaults for xmonad. If you change
-- values here, be sure to recompile and restart (mod-q) xmonad,
-- for the changes to take effect.
--
------------------------------------------------------------------------
module Config where
@ -34,7 +34,7 @@ import Graphics.X11.Xlib
workspaces :: Int
workspaces = 9
--
-- |
-- modMask lets you specify which modkey you want to use. The default is
-- mod1Mask ("left alt"). You may also consider using mod3Mask ("right
-- alt"), which does not conflict with emacs keybindings. The "windows
@ -43,7 +43,7 @@ workspaces = 9
modMask :: KeyMask
modMask = mod1Mask
--
-- |
-- Default offset of drawable screen boundaries from each physical screen.
-- Anything non-zero here will leave a gap of that many pixels on the
-- given edge, on the that screen. A useful gap at top of screen for a
@ -54,7 +54,7 @@ modMask = mod1Mask
defaultGaps :: [(Int,Int,Int,Int)]
defaultGaps = [(0,0,0,0)] -- 15 for default dzen
--
-- |
-- numlock handling:
--
-- The mask for the numlock key. You may need to change this on some systems.
@ -68,20 +68,20 @@ defaultGaps = [(0,0,0,0)] -- 15 for default dzen
numlockMask :: KeyMask
numlockMask = mod2Mask
--
-- |
-- Border colors for unfocused and focused windows, respectively.
--
normalBorderColor, focusedBorderColor :: String
normalBorderColor = "#dddddd"
focusedBorderColor = "#ff0000"
--
-- |
-- Width of the window border in pixels
--
borderWidth :: Dimension
borderWidth = 1
--
-- |
-- The default set of tiling algorithms
--
defaultLayouts :: [Layout]
@ -99,7 +99,7 @@ defaultLayouts = [ tiled , mirror tiled , full ]
-- Percent of screen to increment by when resizing panes
delta = 3%100
--
-- |
-- Perform an arbitrary action on each state change.
-- Examples include:
-- * do nothing
@ -108,7 +108,7 @@ defaultLayouts = [ tiled , mirror tiled , full ]
logHook :: X ()
logHook = return ()
--
-- |
-- The key bindings list.
--
-- The unusual comment format is used to generate the documentation
@ -167,7 +167,7 @@ keys = M.fromList $
| (key, sc) <- zip [xK_w, xK_e, xK_r] [0..]
, (f, m) <- [(view, 0), (shift, shiftMask)]]
--
-- |
-- default actions bound to mouse events
--
mouseBindings :: M.Map (KeyMask, Button) (Window -> X ())

7
Main.hs
View File

@ -8,10 +8,11 @@
-- Stability : unstable
-- Portability : not portable, uses mtl, X11, posix
--
-----------------------------------------------------------------------------
--
-- xmonad, a minimalist, tiling window manager for X11
--
-----------------------------------------------------------------------------
module Main where
import Data.Bits
import qualified Data.Map as M
@ -34,7 +35,7 @@ import Operations
import System.IO
--
-- |
-- The main entry point
--
main :: IO ()

14
Operations.hs
View File

@ -1,5 +1,5 @@
{-# OPTIONS -fglasgow-exts #-}
-- ^^ deriving Typeable
-- \^^ deriving Typeable
-- --------------------------------------------------------------------------
-- |
-- Module : Operations.hs
@ -10,6 +10,8 @@
-- Stability : unstable
-- Portability : not portable, Typeable deriving, mtl, posix
--
-- Operations.
--
-----------------------------------------------------------------------------
module Operations where
@ -35,9 +37,9 @@ import Graphics.X11.Xinerama (getScreenInfo)
import Graphics.X11.Xlib.Extras
-- ---------------------------------------------------------------------
-- |
-- Window manager operations
-- | manage. Add a new window to be managed in the current workspace.
-- manage. Add a new window to be managed in the current workspace.
-- Bring it into focus.
--
-- Whether the window is already managed, or not, it is mapped, has its
@ -54,7 +56,7 @@ manage w = withDisplay $ \d -> do
isTransient <- isJust `liftM` io (getTransientForHint d w)
if isTransient
then do modify $ \s -> s { windowset = W.insertUp w (windowset s) }
float w -- ^^ now go the refresh.
float w -- \^^ now go the refresh.
else windows $ W.insertUp w
-- | unmanage. A window no longer exists, remove it from the window
@ -447,12 +449,12 @@ withFocused f = withWindowSet $ \w -> whenJust (W.peek w) f
isClient :: Window -> X Bool
isClient w = withWindowSet $ return . W.member w
-- | Combinations of extra modifier masks we need to grab keys/buttons for.
-- | Combinations of extra modifier masks we need to grab keys\/buttons for.
-- (numlock and capslock)
extraModifiers :: [KeyMask]
extraModifiers = [0, numlockMask, lockMask, numlockMask .|. lockMask ]
-- | Strip numlock/capslock from a mask
-- | Strip numlock\/capslock from a mask
cleanMask :: KeyMask -> KeyMask
cleanMask = (complement (numlockMask .|. lockMask) .&.)

147
StackSet.hs
View File

@ -8,9 +8,7 @@
-- Stability : experimental
-- Portability : portable, Haskell 98
--
-----------------------------------------------------------------------------
--
-- ** Introduction
-- Introduction
--
-- The 'StackSet' data type encodes a window manager abstraction. The
-- window manager is a set of virtual workspaces. On each workspace is a
@ -19,17 +17,17 @@
-- workspace is the one which will take user input. It can be visualised
-- as follows:
--
-- Workspace { 0*} { 1 } { 2 } { 3 } { 4 }
--
-- Windows [1 [] [3* [6*] []
-- ,2*] ,4
-- ,5]
-- > Workspace { 0*} { 1 } { 2 } { 3 } { 4 }
-- >
-- > Windows [1 [] [3* [6*] []
-- > ,2*] ,4
-- > ,5]
--
-- Note that workspaces are indexed from 0, windows are numbered
-- uniquely. A '*' indicates the window on each workspace that has
-- focus, and which workspace is current.
--
-- ** Zipper
-- Zipper
--
-- We encode all the focus tracking directly in the data structure, with a 'zipper':
--
@ -42,7 +40,7 @@
-- resulting data structure will share as much of its components with
-- the old structure as possible.
--
-- Oleg Kiselyov, 27 Apr 2005, haskell@, "Zipper as a delimited continuation"
-- Oleg Kiselyov, 27 Apr 2005, haskell\@, "Zipper as a delimited continuation"
--
-- We use the zipper to keep track of the focused workspace and the
-- focused window on each workspace, allowing us to have correct focus
@ -58,7 +56,7 @@
--
-- The Zipper, Haskell wikibook
--
-- ** Xinerama support:
-- Xinerama support:
--
-- Xinerama in X11 lets us view multiple virtual workspaces
-- simultaneously. While only one will ever be in focus (i.e. will
@ -67,13 +65,14 @@
-- (viewed) on which physical screens. We use a simple Map Workspace
-- Screen for this.
--
-- ** Master and Focus
-- Master and Focus
--
-- Each stack tracks a focused item, and for tiling purposes also tracks
-- a 'master' position. The connection between 'master' and 'focus'
-- needs to be well defined. Particular in relation to 'insert' and
-- 'delete'.
--
module StackSet (
StackSet(..), Workspace(..), Screen(..), Stack(..), RationalRect(..),
new, view, lookupWorkspace, peek, index, integrate, focusUp, focusDown,
@ -85,45 +84,60 @@ import Data.Maybe (listToMaybe)
import qualified Data.List as L (delete,find,genericSplitAt)
import qualified Data.Map as M (Map,insert,delete,empty)
-- |
-- API changes from xmonad 0.1:
-- StackSet constructor arguments changed. StackSet workspace window screen
-- new, -- was: empty
-- view,
-- index,
-- peek, -- was: peek/peekStack
-- focusUp, focusDown, -- was: rotate
-- swapUp, swapDown
-- focus -- was: raiseFocus
-- insertUp, -- was: insert/push
-- delete,
-- swapMaster, -- was: promote/swap
-- member,
-- shift,
-- lookupWorkspace, -- was: workspace
-- visibleWorkspaces -- gone.
--
-- * new, -- was: empty
--
-- * view,
--
-- * index,
--
-- * peek, -- was: peek\/peekStack
--
-- * focusUp, focusDown, -- was: rotate
--
-- * swapUp, swapDown
--
-- * focus -- was: raiseFocus
--
-- * insertUp, -- was: insert\/push
--
-- * delete,
--
-- * swapMaster, -- was: promote\/swap
--
-- * member,
--
-- * shift,
--
-- * lookupWorkspace, -- was: workspace
--
-- * visibleWorkspaces -- gone.
--
------------------------------------------------------------------------
--
-- |
-- A cursor into a non-empty list of workspaces.
--
-- We puncture the workspace list, producing a hole in the structure
-- used to track the currently focused workspace. The two other lists
-- that are produced are used to track those workspaces visible as
-- Xinerama screens, and those workspaces not visible anywhere.
--
data StackSet i a sid =
StackSet { size :: !i -- number of workspaces
, current :: !(Screen i a sid) -- currently focused workspace
, visible :: [Screen i a sid] -- non-focused workspaces, visible in xinerama
, hidden :: [Workspace i a] -- workspaces not visible anywhere
, floating :: M.Map a RationalRect -- floating windows
StackSet { size :: !i -- ^ number of workspaces
, current :: !(Screen i a sid) -- ^ currently focused workspace
, visible :: [Screen i a sid] -- ^ non-focused workspaces, visible in xinerama
, hidden :: [Workspace i a] -- ^ workspaces not visible anywhere
, floating :: M.Map a RationalRect -- ^ floating windows
} deriving (Show, Read, Eq)
-- Visible workspaces, and their Xinerama screens.
-- | Visible workspaces, and their Xinerama screens.
data Screen i a sid = Screen { workspace :: !(Workspace i a), screen :: !sid }
deriving (Show, Read, Eq)
--
-- |
-- A workspace is just a tag - its index - and a stack
--
data Workspace i a = Workspace { tag :: !i, stack :: Stack a }
@ -132,21 +146,21 @@ data Workspace i a = Workspace { tag :: !i, stack :: Stack a }
data RationalRect = RationalRect Rational Rational Rational Rational
deriving (Show, Read, Eq)
--
-- |
-- A stack is a cursor onto a (possibly empty) window list.
-- The data structure tracks focus by construction, and
-- the master window is by convention the top-most item.
-- Focus operations will not reorder the list that results from
-- flattening the cursor. The structure can be envisaged as:
--
-- +-- master: < '7' >
-- up | [ '2' ]
-- +--------- [ '3' ]
-- focus: < '4' >
-- dn +----------- [ '8' ]
-- > +-- master: < '7' >
-- > up | [ '2' ]
-- > +--------- [ '3' ]
-- > focus: < '4' >
-- > dn +----------- [ '8' ]
--
-- A 'Stack' can be viewed as a list with a hole punched in it to make
-- the focused position. Under the zipper/calculus view of such
-- the focused position. Under the zipper\/calculus view of such
-- structures, it is the differentiation of a [a], and integrating it
-- back has a natural implementation used in 'index'.
--
@ -162,7 +176,7 @@ abort :: String -> a
abort x = error $ "xmonad: StackSet: " ++ x
-- ---------------------------------------------------------------------
-- Construction
-- | Construction
-- | /O(n)/. Create a new stackset, of empty stacks, of size 'n', with
-- 'm' physical screens. 'm' should be less than or equal to 'n'.
@ -178,14 +192,14 @@ new n m | n > 0 && m > 0 = StackSet n cur visi unseen M.empty
(cur:visi) = [ Screen i s | (i,s) <- zip seen [0..] ]
-- now zip up visibles with their screen id
--
-- /O(w)/. Set focus to the workspace with index 'i'.
-- |
-- /O(w)/. Set focus to the workspace with index \'i\'.
-- If the index is out of range, return the original StackSet.
--
-- Xinerama: If the workspace is not visible on any Xinerama screen, it
-- becomes the current screen. If it is in the visible list, it becomes
-- current.
--
view :: (Eq a, Eq s, Integral i) => i -> StackSet i a s -> StackSet i a s
view i s
| i < 0 && i >= size s || i == tag (workspace (current s)) = s -- out of bounds or current
@ -205,7 +219,7 @@ view i s
-- workspace tags defined in 'new'
-- ---------------------------------------------------------------------
-- Xinerama operations
-- | Xinerama operations
-- | Find the tag of the workspace visible on Xinerama screen 'sc'.
-- Nothing if screen is out of bounds.
@ -215,7 +229,7 @@ lookupWorkspace sc w = listToMaybe [ tag i | Screen i s <- current w : visible w
-- ---------------------------------------------------------------------
-- Operations on the current stack
--
-- |
-- The 'with' function takes a default value, a function, and a
-- StackSet. If the current stack is Empty, 'with' returns the
-- default value. Otherwise, it applies the function to the stack,
@ -226,28 +240,28 @@ with dflt f s = case stack (workspace (current s)) of Empty -> dflt; v -> f v
-- TODO: ndm: a 'catch' proof here that 'f' only gets Node
-- constructors, hence all 'f's are safe below?
--
-- |
-- Apply a function, and a default value for Empty, to modify the current stack.
--
modify :: Stack a -> (Stack a -> Stack a) -> StackSet i a s -> StackSet i a s
modify d f s = s { current = (current s)
{ workspace = (workspace (current s)) { stack = with d f s }}}
--
-- |
-- /O(1)/. Extract the focused element of the current stack.
-- Return Just that element, or Nothing for an empty stack.
--
peek :: StackSet i a s -> Maybe a
peek = with Nothing (return . focus)
--
-- |
-- /O(n)/. Flatten a Stack into a list.
--
integrate :: Stack a -> [a]
integrate Empty = []
integrate (Node x l r) = reverse l ++ x : r
--
-- |
-- /O(s)/. Extract the stack on the current workspace, as a list.
-- The order of the stack is determined by the master window -- it will be
-- the head of the list. The implementation is given by the natural
@ -258,7 +272,7 @@ index = with [] integrate
-- let is = t : r ++ reverse l in take (length is) (dropWhile (/= m) (cycle is))
--
-- |
-- /O(1), O(w) on the wrapping case/.
--
-- focusUp, focusDown. Move the window focus up or down the stack,
@ -284,7 +298,7 @@ focusUp' (Node t [] rs) = Node x xs [] where (x:xs) = reverse (t:rs)
swapUp' (Node t (l:ls) rs) = Node t ls (l:rs)
swapUp' (Node t [] rs) = Node t (reverse rs) []
-- reverse a stack: up becomes down and down becomes up.
-- | reverse a stack: up becomes down and down becomes up.
reverseStack :: Stack a -> Stack a
reverseStack (Node t ls rs) = Node t rs ls
reverseStack x = x
@ -299,7 +313,7 @@ focusWindow w s | Just w == peek s = s
n <- findIndex w s
return $ until ((Just w ==) . peek) focusUp (view n s)
--
-- |
-- Finding if a window is in the stackset is a little tedious. We could
-- keep a cache :: Map a i, but with more bookkeeping.
--
@ -318,9 +332,9 @@ findIndex a s = listToMaybe
has x (Node t l r) = x `elem` (t : l ++ r)
-- ---------------------------------------------------------------------
-- Modifying the stackset
-- | Modifying the stackset
--
-- |
-- /O(n)/. (Complexity due to duplicate check). Insert a new element into
-- the stack, above the currently focused element.
--
@ -343,7 +357,7 @@ insertUp a s = if member a s then s else insert
-- Old semantics, from Huet.
-- > w { down = a : down w }
--
-- |
-- /O(1) on current window, O(n) in general/. Delete window 'w' if it exists.
-- There are 4 cases to consider:
--
@ -385,8 +399,8 @@ sink :: Ord a => a -> StackSet i a s -> StackSet i a s
sink w s = s { floating = M.delete w (floating s) }
------------------------------------------------------------------------
-- Setting the master window
-- | Setting the master window
--
-- /O(s)/. Set the master window to the focused window.
-- The old master window is swapped in the tiling order with the focused window.
-- Focus stays with the item moved.
@ -395,12 +409,11 @@ swapMaster = modify Empty $ \c -> case c of
Node _ [] _ -> c -- already master.
Node t ls rs -> Node t [] (ys ++ x : rs) where (x:ys) = reverse ls
-- natural! keep focus, move current to the top, move top to current.
-- ---------------------------------------------------------------------
-- Composite operations
-- natural! keep focus, move current to the top, move top to current.
--
-- ---------------------------------------------------------------------
-- | Composite operations
--
-- /O(w)/. shift. Move the focused element of the current stack to stack
-- 'n', leaving it as the focused element on that stack. The item is
-- inserted above the currently focused element on that workspace. --
@ -411,4 +424,4 @@ shift :: (Ord a, Eq s, Integral i) => i -> StackSet i a s -> StackSet i a s
shift n s = if and [n >= 0,n < size s,n /= tag (workspace (current s))]
then maybe s go (peek s) else s
where go w = foldr ($) s [view (tag (workspace (current s))),insertUp w,view n,delete w]
-- ^^ poor man's state monad :-)
-- ^^ poor man's state monad :-)

3
XMonad.hs
View File

@ -9,11 +9,10 @@
-- Stability : unstable
-- Portability : not portable, uses cunning newtype deriving
--
-----------------------------------------------------------------------------
--
-- The X monad, a state monad transformer over IO, for the window
-- manager state, and support routines.
--
-----------------------------------------------------------------------------
module XMonad (
X, WindowSet, WorkspaceId(..), ScreenId(..), XState(..), XConf(..), Layout(..),