From 1716ffd9d025fb22b53644c434803b0007b51a6e Mon Sep 17 00:00:00 2001
From: Adam Vogt <vogt.adam@gmail.com>
Date: Fri, 9 Nov 2012 01:23:16 +0000
Subject: [PATCH] Rename variables "state" to avoid warnings about shadowing
XMonad core re-exports Control.Monad.State, which includes
a function "state" if you happen to use mtl-2. Since there's
a chance xmonad still works with mtl-1 avoid imports like:
import XMonad hiding (state)
---
XMonad/Actions/Plane.hs | 4 +-
XMonad/Hooks/DynamicBars.hs | 6 +--
XMonad/Hooks/EwmhDesktops.hs | 8 ++--
XMonad/Layout/Fullscreen.hs | 14 +++---
XMonad/Layout/MouseResizableTile.hs | 74 ++++++++++++++---------------
XMonad/Layout/WindowNavigation.hs | 10 ++--
6 files changed, 58 insertions(+), 58 deletions(-)
diff --git a/XMonad/Actions/Plane.hs b/XMonad/Actions/Plane.hs
index 8126d41e..30377196 100644
--- a/XMonad/Actions/Plane.hs
+++ b/XMonad/Actions/Plane.hs
@@ -110,7 +110,7 @@ plane ::
(WorkspaceId -> WindowSet -> WindowSet) -> Lines -> Limits -> Direction ->
X ()
plane function numberLines_ limits direction = do
- state <- get
+ st <- get
xconf <- ask
numberLines <-
@@ -205,7 +205,7 @@ plane function numberLines_ limits direction = do
preColumns = div areas numberLines
mCurrentWS :: Maybe Int
- mCurrentWS = elemIndex (currentTag $ windowset state) areaNames
+ mCurrentWS = elemIndex (currentTag $ windowset st) areaNames
areas :: Int
areas = length areaNames
diff --git a/XMonad/Hooks/DynamicBars.hs b/XMonad/Hooks/DynamicBars.hs
index d8c40fea..993aec5e 100644
--- a/XMonad/Hooks/DynamicBars.hs
+++ b/XMonad/Hooks/DynamicBars.hs
@@ -112,11 +112,11 @@ multiPP focusPP unfocusPP = do
multiPP' :: (PP -> X String) -> PP -> PP -> [Handle] -> X ()
multiPP' dynlStr focusPP unfocusPP handles = do
- state <- get
+ st <- get
let pickPP :: WorkspaceId -> WriterT (Last XState) X String
pickPP ws = do
- let isFoc = (ws ==) . W.tag . W.workspace . W.current $ windowset state
- put state{ windowset = W.view ws $ windowset state }
+ let isFoc = (ws ==) . W.tag . W.workspace . W.current $ windowset st
+ put st{ windowset = W.view ws $ windowset st }
out <- lift $ dynlStr $ if isFoc then focusPP else unfocusPP
when isFoc $ get >>= tell . Last . Just
return out
diff --git a/XMonad/Hooks/EwmhDesktops.hs b/XMonad/Hooks/EwmhDesktops.hs
index b3bed775..060079a2 100644
--- a/XMonad/Hooks/EwmhDesktops.hs
+++ b/XMonad/Hooks/EwmhDesktops.hs
@@ -170,9 +170,9 @@ handle _ _ = return ()
-- Note this is not included in 'ewmh'.
fullscreenEventHook :: Event -> X All
fullscreenEventHook (ClientMessageEvent _ _ _ dpy win typ (action:dats)) = do
- state <- getAtom "_NET_WM_STATE"
+ wmstate <- getAtom "_NET_WM_STATE"
fullsc <- getAtom "_NET_WM_STATE_FULLSCREEN"
- wstate <- fromMaybe [] `fmap` getProp32 state win
+ wstate <- fromMaybe [] `fmap` getProp32 wmstate win
let isFull = fromIntegral fullsc `elem` wstate
@@ -181,9 +181,9 @@ fullscreenEventHook (ClientMessageEvent _ _ _ dpy win typ (action:dats)) = do
add = 1
toggle = 2
ptype = 4 -- The atom property type for changeProperty
- chWstate f = io $ changeProperty32 dpy win state ptype propModeReplace (f wstate)
+ chWstate f = io $ changeProperty32 dpy win wmstate ptype propModeReplace (f wstate)
- when (typ == state && fi fullsc `elem` dats) $ do
+ when (typ == wmstate && fi fullsc `elem` dats) $ do
when (action == add || (action == toggle && not isFull)) $ do
chWstate (fi fullsc:)
windows $ W.float win $ W.RationalRect 0 0 1 1
diff --git a/XMonad/Layout/Fullscreen.hs b/XMonad/Layout/Fullscreen.hs
index d6dd5892..1b9b0b9c 100644
--- a/XMonad/Layout/Fullscreen.hs
+++ b/XMonad/Layout/Fullscreen.hs
@@ -124,11 +124,11 @@ instance LayoutModifier FullscreenFloat Window where
-- Modify the floating member of the stack set directly; this is the hackish part.
Just FullscreenChanged -> do
- state <- get
- let ws = windowset state
+ st <- get
+ let ws = windowset st
flt = W.floating ws
flt' = M.intersectionWith doFull fulls flt
- put state {windowset = ws {W.floating = M.union flt' flt}}
+ put st {windowset = ws {W.floating = M.union flt' flt}}
return $ Just $ FullscreenFloat frect $ M.filter snd fulls
where doFull (_, True) _ = frect
doFull (rect, False) _ = rect
@@ -174,9 +174,9 @@ fullscreenFloatRect r = ModifiedLayout $ FullscreenFloat r M.empty
-- | The event hook required for the layout modifiers to work
fullscreenEventHook :: Event -> X All
fullscreenEventHook (ClientMessageEvent _ _ _ dpy win typ (action:dats)) = do
- state <- getAtom "_NET_WM_STATE"
+ wmstate <- getAtom "_NET_WM_STATE"
fullsc <- getAtom "_NET_WM_STATE_FULLSCREEN"
- wstate <- fromMaybe [] `fmap` getProp32 state win
+ wstate <- fromMaybe [] `fmap` getProp32 wmstate win
let fi :: (Integral i, Num n) => i -> n
fi = fromIntegral
isFull = fi fullsc `elem` wstate
@@ -184,8 +184,8 @@ fullscreenEventHook (ClientMessageEvent _ _ _ dpy win typ (action:dats)) = do
add = 1
toggle = 2
ptype = 4
- chWState f = io $ changeProperty32 dpy win state ptype propModeReplace (f wstate)
- when (typ == state && fi fullsc `elem` dats) $ do
+ chWState f = io $ changeProperty32 dpy win wmstate ptype propModeReplace (f wstate)
+ when (typ == wmstate && fi fullsc `elem` dats) $ do
when (action == add || (action == toggle && not isFull)) $ do
chWState (fi fullsc:)
broadcastMessage $ AddFullscreen win
diff --git a/XMonad/Layout/MouseResizableTile.hs b/XMonad/Layout/MouseResizableTile.hs
index 15286d67..1b6e5588 100644
--- a/XMonad/Layout/MouseResizableTile.hs
+++ b/XMonad/Layout/MouseResizableTile.hs
@@ -136,55 +136,55 @@ mouseResizableTileMirrored :: MouseResizableTile a
mouseResizableTileMirrored = mouseResizableTile { isMirrored = True }
instance LayoutClass MouseResizableTile Window where
- doLayout state sr (W.Stack w l r) = do
- drg <- draggerGeometry $ draggerType state
+ doLayout st sr (W.Stack w l r) = do
+ drg <- draggerGeometry $ draggerType st
let wins = reverse l ++ w : r
num = length wins
sr' = mirrorAdjust sr (mirrorRect sr)
- (rects, preparedDraggers) = tile (nmaster state) (masterFrac state)
- (leftFracs state ++ repeat (slaveFrac state))
- (rightFracs state ++ repeat (slaveFrac state)) sr' num drg
+ (rects, preparedDraggers) = tile (nmaster st) (masterFrac st)
+ (leftFracs st ++ repeat (slaveFrac st))
+ (rightFracs st ++ repeat (slaveFrac st)) sr' num drg
rects' = map (mirrorAdjust id mirrorRect . sanitizeRectangle sr') rects
- mapM_ deleteDragger $ draggers state
+ mapM_ deleteDragger $ draggers st
(draggerWrs, newDraggers) <- unzip <$> mapM
- (createDragger sr . adjustForMirror (isMirrored state))
+ (createDragger sr . adjustForMirror (isMirrored st))
preparedDraggers
- return (draggerWrs ++ zip wins rects', Just $ state { draggers = newDraggers,
+ return (draggerWrs ++ zip wins rects', Just $ st { draggers = newDraggers,
focusPos = length l,
numWindows = length wins })
where
- mirrorAdjust a b = if (isMirrored state)
+ mirrorAdjust a b = if (isMirrored st)
then b
else a
- handleMessage state m
+ handleMessage st m
| Just (IncMasterN d) <- fromMessage m =
- return $ Just $ state { nmaster = max 0 (nmaster state + d) }
+ return $ Just $ st { nmaster = max 0 (nmaster st + d) }
| Just Shrink <- fromMessage m =
- return $ Just $ state { masterFrac = max 0 (masterFrac state - fracIncrement state) }
+ return $ Just $ st { masterFrac = max 0 (masterFrac st - fracIncrement st) }
| Just Expand <- fromMessage m =
- return $ Just $ state { masterFrac = min 1 (masterFrac state + fracIncrement state) }
+ return $ Just $ st { masterFrac = min 1 (masterFrac st + fracIncrement st) }
| Just ShrinkSlave <- fromMessage m =
- return $ Just $ modifySlave state (- fracIncrement state)
+ return $ Just $ modifySlave st (- fracIncrement st)
| Just ExpandSlave <- fromMessage m =
- return $ Just $ modifySlave state (fracIncrement state)
+ return $ Just $ modifySlave st (fracIncrement st)
| Just (SetMasterFraction f) <- fromMessage m =
- return $ Just $ state { masterFrac = max 0 (min 1 f) }
+ return $ Just $ st { masterFrac = max 0 (min 1 f) }
| Just (SetLeftSlaveFraction pos f) <- fromMessage m =
- return $ Just $ state { leftFracs = replaceAtPos (slaveFrac state)
- (leftFracs state) pos (max 0 (min 1 f)) }
+ return $ Just $ st { leftFracs = replaceAtPos (slaveFrac st)
+ (leftFracs st) pos (max 0 (min 1 f)) }
| Just (SetRightSlaveFraction pos f) <- fromMessage m =
- return $ Just $ state { rightFracs = replaceAtPos (slaveFrac state)
- (rightFracs state) pos (max 0 (min 1 f)) }
+ return $ Just $ st { rightFracs = replaceAtPos (slaveFrac st)
+ (rightFracs st) pos (max 0 (min 1 f)) }
- | Just e <- fromMessage m :: Maybe Event = handleResize (draggers state) (isMirrored state) e >> return Nothing
- | Just Hide <- fromMessage m = releaseResources >> return (Just $ state { draggers = [] })
- | Just ReleaseResources <- fromMessage m = releaseResources >> return (Just $ state { draggers = [] })
- where releaseResources = mapM_ deleteDragger $ draggers state
+ | Just e <- fromMessage m :: Maybe Event = handleResize (draggers st) (isMirrored st) e >> return Nothing
+ | Just Hide <- fromMessage m = releaseResources >> return (Just $ st { draggers = [] })
+ | Just ReleaseResources <- fromMessage m = releaseResources >> return (Just $ st { draggers = [] })
+ where releaseResources = mapM_ deleteDragger $ draggers st
handleMessage _ _ = return Nothing
- description state = mirror "MouseResizableTile"
- where mirror = if isMirrored state then ("Mirror " ++) else id
+ description st = mirror "MouseResizableTile"
+ where mirror = if isMirrored st then ("Mirror " ++) else id
draggerGeometry :: DraggerType -> X DraggerGeometry
draggerGeometry (FixedDragger g d) =
@@ -203,28 +203,28 @@ adjustForMirror True (draggerRect, draggerCursor, draggerInfo) =
else xC_sb_h_double_arrow
modifySlave :: MouseResizableTile a -> Rational -> MouseResizableTile a
-modifySlave state delta =
- let pos = focusPos state
- num = numWindows state
- nmaster' = nmaster state
- leftFracs' = leftFracs state
- rightFracs' = rightFracs state
- slFrac = slaveFrac state
+modifySlave st delta =
+ let pos = focusPos st
+ num = numWindows st
+ nmaster' = nmaster st
+ leftFracs' = leftFracs st
+ rightFracs' = rightFracs st
+ slFrac = slaveFrac st
draggersLeft = nmaster' - 1
draggersRight = (num - nmaster') - 1
in if pos < nmaster'
then if draggersLeft > 0
then let draggerPos = min (draggersLeft - 1) pos
oldFraction = (leftFracs' ++ repeat slFrac) !! draggerPos
- in state { leftFracs = replaceAtPos slFrac leftFracs' draggerPos
+ in st { leftFracs = replaceAtPos slFrac leftFracs' draggerPos
(max 0 (min 1 (oldFraction + delta))) }
- else state
+ else st
else if draggersRight > 0
then let draggerPos = min (draggersRight - 1) (pos - nmaster')
oldFraction = (rightFracs' ++ repeat slFrac) !! draggerPos
- in state { rightFracs = replaceAtPos slFrac rightFracs' draggerPos
+ in st { rightFracs = replaceAtPos slFrac rightFracs' draggerPos
(max 0 (min 1 (oldFraction + delta))) }
- else state
+ else st
replaceAtPos :: (Num t, Eq t) => Rational -> [Rational] -> t -> Rational -> [Rational]
replaceAtPos _ [] 0 x' = [x']
diff --git a/XMonad/Layout/WindowNavigation.hs b/XMonad/Layout/WindowNavigation.hs
index 5587b73c..02445324 100644
--- a/XMonad/Layout/WindowNavigation.hs
+++ b/XMonad/Layout/WindowNavigation.hs
@@ -105,7 +105,7 @@ configurableNavigation :: LayoutClass l a => WNConfig -> l a -> ModifiedLayout W
configurableNavigation conf = ModifiedLayout (WindowNavigation conf (I Nothing))
instance LayoutModifier WindowNavigation Window where
- redoLayout (WindowNavigation conf (I state)) rscr (Just s) origwrs =
+ redoLayout (WindowNavigation conf (I st)) rscr (Just s) origwrs =
do XConf { normalBorder = nbc, focusedBorder = fbc, display = dpy } <- ask
[uc,dc,lc,rc] <-
case brightness conf of
@@ -120,8 +120,8 @@ instance LayoutModifier WindowNavigation Window where
let w = W.focus s
r = case filter ((==w).fst) origwrs of ((_,x):_) -> x
[] -> rscr
- pt = case state of Just (NS ptold _) | ptold `inrect` r -> ptold
- _ -> center r
+ pt = case st of Just (NS ptold _) | ptold `inrect` r -> ptold
+ _ -> center r
existing_wins = W.integrate s
wrs = filter ((`elem` existing_wins) . fst) $ filter ((/=r) . snd) $
filter ((/=w) . fst) origwrs
@@ -130,8 +130,8 @@ instance LayoutModifier WindowNavigation Window where
wnavigablec = nub $ concatMap
(\d -> map (\(win,_) -> (win,dirc d)) $
take 1 $ navigable d pt wrs) [U,D,R,L]
- wothers = case state of Just (NS _ wo) -> map fst wo
- _ -> []
+ wothers = case st of Just (NS _ wo) -> map fst wo
+ _ -> []
mapM_ (sc nbc) (wothers \\ map fst wnavigable)
mapM_ (\(win,c) -> sc c win) wnavigablec
return (origwrs, Just $ WindowNavigation conf $ I $ Just $ NS pt wnavigable)