module XMonad.Actions.CycleWS (
nextWS
, prevWS
, shiftToNext
, shiftToPrev
, toggleWS
, toggleWS'
, toggleOrView
, nextScreen
, prevScreen
, shiftNextScreen
, shiftPrevScreen
, swapNextScreen
, swapPrevScreen
, Direction1D(..)
, WSType(..)
, emptyWS
, hiddenWS
, anyWS
, wsTagGroup
, ignoringWSs
, shiftTo
, moveTo
, doTo
, findWorkspace
, toggleOrDoSkip
, skipTags
, screenBy
) where
import XMonad.Prelude (find, findIndex, isJust, isNothing, liftM2)
import XMonad hiding (workspaces)
import qualified XMonad.Hooks.WorkspaceHistory as WH
import XMonad.StackSet hiding (filter)
import XMonad.Util.Types
import XMonad.Util.WorkspaceCompare
nextWS :: X ()
nextWS :: X ()
nextWS = Int -> X ()
switchWorkspace Int
1
prevWS :: X ()
prevWS :: X ()
prevWS = Int -> X ()
switchWorkspace (-Int
1)
shiftToNext :: X ()
shiftToNext :: X ()
shiftToNext = Int -> X ()
shiftBy Int
1
shiftToPrev :: X ()
shiftToPrev :: X ()
shiftToPrev = Int -> X ()
shiftBy (-Int
1)
toggleWS :: X ()
toggleWS :: X ()
toggleWS = [WorkspaceId] -> X ()
toggleWS' []
toggleWS' :: [WorkspaceId] -> X ()
toggleWS' :: [WorkspaceId] -> X ()
toggleWS' [WorkspaceId]
skips = [WorkspaceId] -> X (Maybe WorkspaceId)
lastViewedHiddenExcept [WorkspaceId]
skips forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a b c. (a -> b -> c) -> b -> a -> c
flip forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust ((WindowSet -> WindowSet) -> X ()
windows forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s i l a sd.
(Eq s, Eq i) =>
i -> StackSet i l a s sd -> StackSet i l a s sd
view)
toggleOrView :: WorkspaceId -> X ()
toggleOrView :: WorkspaceId -> X ()
toggleOrView = [WorkspaceId]
-> (WorkspaceId -> WindowSet -> WindowSet) -> WorkspaceId -> X ()
toggleOrDoSkip [] forall s i l a sd.
(Eq s, Eq i) =>
i -> StackSet i l a s sd -> StackSet i l a s sd
greedyView
toggleOrDoSkip :: [WorkspaceId] -> (WorkspaceId -> WindowSet -> WindowSet)
-> WorkspaceId -> X ()
toggleOrDoSkip :: [WorkspaceId]
-> (WorkspaceId -> WindowSet -> WindowSet) -> WorkspaceId -> X ()
toggleOrDoSkip [WorkspaceId]
skips WorkspaceId -> WindowSet -> WindowSet
f WorkspaceId
toWS = do
WorkspaceId
cur <- forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets (forall i l a s sd. StackSet i l a s sd -> i
currentTag forall b c a. (b -> c) -> (a -> b) -> a -> c
. XState -> WindowSet
windowset)
if WorkspaceId
toWS forall a. Eq a => a -> a -> Bool
== WorkspaceId
cur
then [WorkspaceId] -> X (Maybe WorkspaceId)
lastViewedHiddenExcept [WorkspaceId]
skips forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a b c. (a -> b -> c) -> b -> a -> c
flip forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust ((WindowSet -> WindowSet) -> X ()
windows forall b c a. (b -> c) -> (a -> b) -> a -> c
. WorkspaceId -> WindowSet -> WindowSet
f)
else (WindowSet -> WindowSet) -> X ()
windows (WorkspaceId -> WindowSet -> WindowSet
f WorkspaceId
toWS)
skipTags :: (Eq i) => [Workspace i l a] -> [i] -> [Workspace i l a]
skipTags :: forall i l a. Eq i => [Workspace i l a] -> [i] -> [Workspace i l a]
skipTags [Workspace i l a]
wss [i]
ids = forall a. (a -> Bool) -> [a] -> [a]
filter ((forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [i]
ids) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i l a. Workspace i l a -> i
tag) [Workspace i l a]
wss
lastViewedHiddenExcept :: [WorkspaceId] -> X (Maybe WorkspaceId)
lastViewedHiddenExcept :: [WorkspaceId] -> X (Maybe WorkspaceId)
lastViewedHiddenExcept [WorkspaceId]
skips = do
[WorkspaceId]
hs <- forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map forall i l a. Workspace i l a -> i
tag forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b c. (a -> b -> c) -> b -> a -> c
flip forall i l a. Eq i => [Workspace i l a] -> [i] -> [Workspace i l a]
skipTags [WorkspaceId]
skips forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i l a sid sd. StackSet i l a sid sd -> [Workspace i l a]
hidden forall b c a. (b -> c) -> (a -> b) -> a -> c
. XState -> WindowSet
windowset
forall {a}. [a] -> Maybe a -> Maybe a
choose [WorkspaceId]
hs forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find (forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [WorkspaceId]
hs) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> X [WorkspaceId]
WH.workspaceHistory
where choose :: [a] -> Maybe a -> Maybe a
choose [] Maybe a
_ = forall a. Maybe a
Nothing
choose (a
h:[a]
_) Maybe a
Nothing = forall a. a -> Maybe a
Just a
h
choose [a]
_ vh :: Maybe a
vh@(Just a
_) = Maybe a
vh
switchWorkspace :: Int -> X ()
switchWorkspace :: Int -> X ()
switchWorkspace Int
d = Int -> X WorkspaceId
wsBy Int
d forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (WindowSet -> WindowSet) -> X ()
windows forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s i l a sd.
(Eq s, Eq i) =>
i -> StackSet i l a s sd -> StackSet i l a s sd
greedyView
shiftBy :: Int -> X ()
shiftBy :: Int -> X ()
shiftBy Int
d = Int -> X WorkspaceId
wsBy Int
d forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (WindowSet -> WindowSet) -> X ()
windows forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a s i l sd.
(Ord a, Eq s, Eq i) =>
i -> StackSet i l a s sd -> StackSet i l a s sd
shift
wsBy :: Int -> X WorkspaceId
wsBy :: Int -> X WorkspaceId
wsBy = X WorkspaceSort -> Direction1D -> WSType -> Int -> X WorkspaceId
findWorkspace X WorkspaceSort
getSortByIndex Direction1D
Next WSType
anyWS
{-# DEPRECATED EmptyWS "Use emptyWS instead." #-}
{-# DEPRECATED HiddenWS "Use hiddenWS instead." #-}
{-# DEPRECATED NonEmptyWS "Use Not emptyWS instead." #-}
{-# DEPRECATED HiddenNonEmptyWS "Use hiddenWS :&: Not emptyWS instead." #-}
{-# DEPRECATED HiddenEmptyWS "Use hiddenWS :&: emptyWS instead." #-}
{-# DEPRECATED AnyWS "Use anyWS instead." #-}
{-# DEPRECATED WSTagGroup "Use wsTagGroup instead." #-}
data WSType = EmptyWS
| NonEmptyWS
| HiddenWS
| HiddenNonEmptyWS
| HiddenEmptyWS
| AnyWS
| WSTagGroup Char
| WSIs (X (WindowSpace -> Bool))
| WSType :&: WSType
| WSType :|: WSType
| Not WSType
wsTypeToPred :: WSType -> X (WindowSpace -> Bool)
wsTypeToPred :: WSType -> X (WindowSpace -> Bool)
wsTypeToPred WSType
EmptyWS = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. Maybe a -> Bool
isNothing forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i l a. Workspace i l a -> Maybe (Stack a)
stack)
wsTypeToPred WSType
NonEmptyWS = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. Maybe a -> Bool
isJust forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i l a. Workspace i l a -> Maybe (Stack a)
stack)
wsTypeToPred WSType
HiddenWS = do [WorkspaceId]
hs <- forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets (forall a b. (a -> b) -> [a] -> [b]
map forall i l a. Workspace i l a -> i
tag forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i l a sid sd. StackSet i l a sid sd -> [Workspace i l a]
hidden forall b c a. (b -> c) -> (a -> b) -> a -> c
. XState -> WindowSet
windowset)
forall (m :: * -> *) a. Monad m => a -> m a
return (\WindowSpace
w -> forall i l a. Workspace i l a -> i
tag WindowSpace
w forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [WorkspaceId]
hs)
wsTypeToPred WSType
HiddenNonEmptyWS = do WindowSpace -> Bool
ne <- WSType -> X (WindowSpace -> Bool)
wsTypeToPred WSType
NonEmptyWS
WindowSpace -> Bool
hi <- WSType -> X (WindowSpace -> Bool)
wsTypeToPred WSType
HiddenWS
forall (m :: * -> *) a. Monad m => a -> m a
return (\WindowSpace
w -> WindowSpace -> Bool
hi WindowSpace
w Bool -> Bool -> Bool
&& WindowSpace -> Bool
ne WindowSpace
w)
wsTypeToPred WSType
HiddenEmptyWS = do WindowSpace -> Bool
ne <- WSType -> X (WindowSpace -> Bool)
wsTypeToPred WSType
EmptyWS
WindowSpace -> Bool
hi <- WSType -> X (WindowSpace -> Bool)
wsTypeToPred WSType
HiddenWS
forall (m :: * -> *) a. Monad m => a -> m a
return (\WindowSpace
w -> WindowSpace -> Bool
hi WindowSpace
w Bool -> Bool -> Bool
&& WindowSpace -> Bool
ne WindowSpace
w)
wsTypeToPred WSType
AnyWS = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. a -> b -> a
const Bool
True)
wsTypeToPred (WSTagGroup Char
sep) = do WorkspaceId
cur <- forall {l} {a}. Workspace WorkspaceId l a -> WorkspaceId
groupNameforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall i l a sid sd. Screen i l a sid sd -> Workspace i l a
workspaceforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall i l a sid sd. StackSet i l a sid sd -> Screen i l a sid sd
current forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets XState -> WindowSet
windowset
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ (WorkspaceId
cur forall a. Eq a => a -> a -> Bool
==)forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall {l} {a}. Workspace WorkspaceId l a -> WorkspaceId
groupName
where groupName :: Workspace WorkspaceId l a -> WorkspaceId
groupName = forall a. (a -> Bool) -> [a] -> [a]
takeWhile (forall a. Eq a => a -> a -> Bool
/=Char
sep)forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall i l a. Workspace i l a -> i
tag
wsTypeToPred (WSIs X (WindowSpace -> Bool)
p ) = X (WindowSpace -> Bool)
p
wsTypeToPred (WSType
p :&: WSType
q) = forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Bool -> Bool -> Bool
(&&) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WSType -> X (WindowSpace -> Bool)
wsTypeToPred WSType
p forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> WSType -> X (WindowSpace -> Bool)
wsTypeToPred WSType
q
wsTypeToPred (WSType
p :|: WSType
q) = forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Bool -> Bool -> Bool
(||) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WSType -> X (WindowSpace -> Bool)
wsTypeToPred WSType
p forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> WSType -> X (WindowSpace -> Bool)
wsTypeToPred WSType
q
wsTypeToPred (Not WSType
p ) = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> Bool
not forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WSType -> X (WindowSpace -> Bool)
wsTypeToPred WSType
p
emptyWS :: WSType
emptyWS :: WSType
emptyWS = X (WindowSpace -> Bool) -> WSType
WSIs forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. Maybe a -> Bool
isNothing forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i l a. Workspace i l a -> Maybe (Stack a)
stack
hiddenWS :: WSType
hiddenWS :: WSType
hiddenWS = X (WindowSpace -> Bool) -> WSType
WSIs forall a b. (a -> b) -> a -> b
$ do
[WorkspaceId]
hs <- forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets (forall a b. (a -> b) -> [a] -> [b]
map forall i l a. Workspace i l a -> i
tag forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i l a sid sd. StackSet i l a sid sd -> [Workspace i l a]
hidden forall b c a. (b -> c) -> (a -> b) -> a -> c
. XState -> WindowSet
windowset)
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ (forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [WorkspaceId]
hs) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i l a. Workspace i l a -> i
tag
anyWS :: WSType
anyWS :: WSType
anyWS = X (WindowSpace -> Bool) -> WSType
WSIs forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. a -> b -> a
const Bool
True
ignoringWSs :: [WorkspaceId] -> WSType
ignoringWSs :: [WorkspaceId] -> WSType
ignoringWSs [WorkspaceId]
ts = X (WindowSpace -> Bool) -> WSType
WSIs forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ (forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [WorkspaceId]
ts) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i l a. Workspace i l a -> i
tag
wsTagGroup :: Char -> WSType
wsTagGroup :: Char -> WSType
wsTagGroup Char
sep = X (WindowSpace -> Bool) -> WSType
WSIs forall a b. (a -> b) -> a -> b
$ do
WorkspaceId
cur <- forall {l} {a}. Workspace WorkspaceId l a -> WorkspaceId
groupName forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i l a sid sd. Screen i l a sid sd -> Workspace i l a
workspace forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i l a sid sd. StackSet i l a sid sd -> Screen i l a sid sd
current forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets XState -> WindowSet
windowset
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ (WorkspaceId
cur forall a. Eq a => a -> a -> Bool
==) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {l} {a}. Workspace WorkspaceId l a -> WorkspaceId
groupName
where groupName :: Workspace WorkspaceId l a -> WorkspaceId
groupName = forall a. (a -> Bool) -> [a] -> [a]
takeWhile (forall a. Eq a => a -> a -> Bool
/= Char
sep) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i l a. Workspace i l a -> i
tag
moveTo :: Direction1D -> WSType -> X ()
moveTo :: Direction1D -> WSType -> X ()
moveTo Direction1D
dir WSType
t = Direction1D
-> WSType -> X WorkspaceSort -> (WorkspaceId -> X ()) -> X ()
doTo Direction1D
dir WSType
t X WorkspaceSort
getSortByIndex ((WindowSet -> WindowSet) -> X ()
windows forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s i l a sd.
(Eq s, Eq i) =>
i -> StackSet i l a s sd -> StackSet i l a s sd
greedyView)
shiftTo :: Direction1D -> WSType -> X ()
shiftTo :: Direction1D -> WSType -> X ()
shiftTo Direction1D
dir WSType
t = Direction1D
-> WSType -> X WorkspaceSort -> (WorkspaceId -> X ()) -> X ()
doTo Direction1D
dir WSType
t X WorkspaceSort
getSortByIndex ((WindowSet -> WindowSet) -> X ()
windows forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a s i l sd.
(Ord a, Eq s, Eq i) =>
i -> StackSet i l a s sd -> StackSet i l a s sd
shift)
doTo :: Direction1D -> WSType -> X WorkspaceSort -> (WorkspaceId -> X ()) -> X ()
doTo :: Direction1D
-> WSType -> X WorkspaceSort -> (WorkspaceId -> X ()) -> X ()
doTo Direction1D
dir WSType
t X WorkspaceSort
srt WorkspaceId -> X ()
act = X WorkspaceSort -> Direction1D -> WSType -> Int -> X WorkspaceId
findWorkspace X WorkspaceSort
srt Direction1D
dir WSType
t Int
1 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= WorkspaceId -> X ()
act
findWorkspace :: X WorkspaceSort -> Direction1D -> WSType -> Int -> X WorkspaceId
findWorkspace :: X WorkspaceSort -> Direction1D -> WSType -> Int -> X WorkspaceId
findWorkspace X WorkspaceSort
s Direction1D
dir WSType
t Int
n = X WorkspaceSort -> X (WindowSpace -> Bool) -> Int -> X WorkspaceId
findWorkspaceGen X WorkspaceSort
s (WSType -> X (WindowSpace -> Bool)
wsTypeToPred WSType
t) (forall {p}. Num p => Direction1D -> p -> p
maybeNegate Direction1D
dir Int
n)
where
maybeNegate :: Direction1D -> p -> p
maybeNegate Direction1D
Next p
d = p
d
maybeNegate Direction1D
Prev p
d = -p
d
findWorkspaceGen :: X WorkspaceSort -> X (WindowSpace -> Bool) -> Int -> X WorkspaceId
findWorkspaceGen :: X WorkspaceSort -> X (WindowSpace -> Bool) -> Int -> X WorkspaceId
findWorkspaceGen X WorkspaceSort
_ X (WindowSpace -> Bool)
_ Int
0 = forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets (forall i l a s sd. StackSet i l a s sd -> i
currentTag forall b c a. (b -> c) -> (a -> b) -> a -> c
. XState -> WindowSet
windowset)
findWorkspaceGen X WorkspaceSort
sortX X (WindowSpace -> Bool)
wsPredX Int
d = do
WindowSpace -> Bool
wsPred <- X (WindowSpace -> Bool)
wsPredX
WorkspaceSort
sort <- X WorkspaceSort
sortX
WindowSet
ws <- forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets XState -> WindowSet
windowset
let cur :: WindowSpace
cur = forall i l a sid sd. Screen i l a sid sd -> Workspace i l a
workspace (forall i l a sid sd. StackSet i l a sid sd -> Screen i l a sid sd
current WindowSet
ws)
sorted :: [WindowSpace]
sorted = WorkspaceSort
sort (forall i l a sid sd. StackSet i l a sid sd -> [Workspace i l a]
workspaces WindowSet
ws)
pivoted :: [WindowSpace]
pivoted = let ([WindowSpace]
a,[WindowSpace]
b) = forall a. (a -> Bool) -> [a] -> ([a], [a])
span ((forall a. Eq a => a -> a -> Bool
/= forall i l a. Workspace i l a -> i
tag WindowSpace
cur) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i l a. Workspace i l a -> i
tag) [WindowSpace]
sorted in [WindowSpace]
b forall a. [a] -> [a] -> [a]
++ [WindowSpace]
a
ws' :: [WindowSpace]
ws' = forall a. (a -> Bool) -> [a] -> [a]
filter WindowSpace -> Bool
wsPred [WindowSpace]
pivoted
mCurIx :: Maybe Int
mCurIx = WindowSpace -> [WindowSpace] -> Maybe Int
findWsIndex WindowSpace
cur [WindowSpace]
ws'
d' :: Int
d' = if Int
d forall a. Ord a => a -> a -> Bool
> Int
0 then Int
d forall a. Num a => a -> a -> a
- Int
1 else Int
d
next :: WindowSpace
next = if forall (t :: * -> *) a. Foldable t => t a -> Bool
null [WindowSpace]
ws'
then WindowSpace
cur
else case Maybe Int
mCurIx of
Maybe Int
Nothing -> [WindowSpace]
ws' forall a. [a] -> Int -> a
!! (Int
d' forall a. Integral a => a -> a -> a
`mod` forall (t :: * -> *) a. Foldable t => t a -> Int
length [WindowSpace]
ws')
Just Int
ix -> [WindowSpace]
ws' forall a. [a] -> Int -> a
!! ((Int
ix forall a. Num a => a -> a -> a
+ Int
d) forall a. Integral a => a -> a -> a
`mod` forall (t :: * -> *) a. Foldable t => t a -> Int
length [WindowSpace]
ws')
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall i l a. Workspace i l a -> i
tag WindowSpace
next
findWsIndex :: WindowSpace -> [WindowSpace] -> Maybe Int
findWsIndex :: WindowSpace -> [WindowSpace] -> Maybe Int
findWsIndex WindowSpace
ws = forall a. (a -> Bool) -> [a] -> Maybe Int
findIndex ((forall a. Eq a => a -> a -> Bool
== forall i l a. Workspace i l a -> i
tag WindowSpace
ws) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i l a. Workspace i l a -> i
tag)
nextScreen :: X ()
nextScreen :: X ()
nextScreen = Int -> X ()
switchScreen Int
1
prevScreen :: X ()
prevScreen :: X ()
prevScreen = Int -> X ()
switchScreen (-Int
1)
switchScreen :: Int -> X ()
switchScreen :: Int -> X ()
switchScreen Int
d = do ScreenId
s <- Int -> X ScreenId
screenBy Int
d
Maybe WorkspaceId
mws <- ScreenId -> X (Maybe WorkspaceId)
screenWorkspace ScreenId
s
case Maybe WorkspaceId
mws of
Maybe WorkspaceId
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
Just WorkspaceId
ws -> (WindowSet -> WindowSet) -> X ()
windows (forall s i l a sd.
(Eq s, Eq i) =>
i -> StackSet i l a s sd -> StackSet i l a s sd
view WorkspaceId
ws)
screenBy :: Int -> X ScreenId
screenBy :: Int -> X ScreenId
screenBy Int
d = do WindowSet
ws <- forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets XState -> WindowSet
windowset
let now :: ScreenId
now = forall i l a sid sd. Screen i l a sid sd -> sid
screen (forall i l a sid sd. StackSet i l a sid sd -> Screen i l a sid sd
current WindowSet
ws)
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ (ScreenId
now forall a. Num a => a -> a -> a
+ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
d) forall a. Integral a => a -> a -> a
`mod` forall a b. (Integral a, Num b) => a -> b
fromIntegral (forall (t :: * -> *) a. Foldable t => t a -> Int
length (forall i l a s sd. StackSet i l a s sd -> [Screen i l a s sd]
screens WindowSet
ws))
swapNextScreen :: X ()
swapNextScreen :: X ()
swapNextScreen = Int -> X ()
swapScreen Int
1
swapPrevScreen :: X ()
swapPrevScreen :: X ()
swapPrevScreen = Int -> X ()
swapScreen (-Int
1)
swapScreen :: Int -> X ()
swapScreen :: Int -> X ()
swapScreen Int
d = do ScreenId
s <- Int -> X ScreenId
screenBy Int
d
Maybe WorkspaceId
mws <- ScreenId -> X (Maybe WorkspaceId)
screenWorkspace ScreenId
s
case Maybe WorkspaceId
mws of
Maybe WorkspaceId
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
Just WorkspaceId
ws -> (WindowSet -> WindowSet) -> X ()
windows (forall s i l a sd.
(Eq s, Eq i) =>
i -> StackSet i l a s sd -> StackSet i l a s sd
greedyView WorkspaceId
ws)
shiftNextScreen :: X ()
shiftNextScreen :: X ()
shiftNextScreen = Int -> X ()
shiftScreenBy Int
1
shiftPrevScreen :: X ()
shiftPrevScreen :: X ()
shiftPrevScreen = Int -> X ()
shiftScreenBy (-Int
1)
shiftScreenBy :: Int -> X ()
shiftScreenBy :: Int -> X ()
shiftScreenBy Int
d = do ScreenId
s <- Int -> X ScreenId
screenBy Int
d
Maybe WorkspaceId
mws <- ScreenId -> X (Maybe WorkspaceId)
screenWorkspace ScreenId
s
case Maybe WorkspaceId
mws of
Maybe WorkspaceId
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
Just WorkspaceId
ws -> (WindowSet -> WindowSet) -> X ()
windows (forall a s i l sd.
(Ord a, Eq s, Eq i) =>
i -> StackSet i l a s sd -> StackSet i l a s sd
shift WorkspaceId
ws)