module XMonad.Util.WorkspaceCompare ( WorkspaceCompare, WorkspaceSort
, filterOutWs
, getWsIndex
, getWsCompare
, getWsCompareByTag
, getXineramaPhysicalWsCompare
, getXineramaWsCompare
, mkWsSort
, getSortByIndex
, getSortByTag
, getSortByXineramaPhysicalRule
, getSortByXineramaRule ) where
import XMonad
import qualified XMonad.StackSet as S
import XMonad.Prelude
import XMonad.Actions.PhysicalScreens (ScreenComparator(ScreenComparator), getScreenIdAndRectangle, screenComparatorById)
type WorkspaceCompare = WorkspaceId -> WorkspaceId -> Ordering
type WorkspaceSort = [WindowSpace] -> [WindowSpace]
filterOutWs :: [WorkspaceId] -> WorkspaceSort
filterOutWs :: [[Char]] -> WorkspaceSort
filterOutWs [[Char]]
ws = (WindowSpace -> Bool) -> WorkspaceSort
forall a. (a -> Bool) -> [a] -> [a]
filter (\S.Workspace{ tag :: forall i l a. Workspace i l a -> i
S.tag = [Char]
tag } -> [Char]
tag [Char] -> [[Char]] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [[Char]]
ws)
getWsIndex :: X (WorkspaceId -> Maybe Int)
getWsIndex :: X ([Char] -> Maybe Int)
getWsIndex = do
spaces <- (XConf -> [[Char]]) -> X [[Char]]
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks (XConfig Layout -> [[Char]]
forall (l :: * -> *). XConfig l -> [[Char]]
workspaces (XConfig Layout -> [[Char]])
-> (XConf -> XConfig Layout) -> XConf -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. XConf -> XConfig Layout
config)
return $ flip elemIndex spaces
indexCompare :: Maybe Int -> Maybe Int -> Ordering
indexCompare :: Maybe Int -> Maybe Int -> Ordering
indexCompare Maybe Int
Nothing Maybe Int
Nothing = Ordering
EQ
indexCompare Maybe Int
Nothing (Just Int
_) = Ordering
GT
indexCompare (Just Int
_) Maybe Int
Nothing = Ordering
LT
indexCompare Maybe Int
a Maybe Int
b = Maybe Int -> Maybe Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Maybe Int
a Maybe Int
b
getWsCompare :: X WorkspaceCompare
getWsCompare :: X WorkspaceCompare
getWsCompare = do
wsIndex <- X ([Char] -> Maybe Int)
getWsIndex
return $ mconcat [indexCompare `on` wsIndex, compare]
getWsCompareByTag :: X WorkspaceCompare
getWsCompareByTag :: X WorkspaceCompare
getWsCompareByTag = WorkspaceCompare -> X WorkspaceCompare
forall a. a -> X a
forall (m :: * -> *) a. Monad m => a -> m a
return WorkspaceCompare
forall a. Ord a => a -> a -> Ordering
compare
getXineramaWsCompare :: X WorkspaceCompare
getXineramaWsCompare :: X WorkspaceCompare
getXineramaWsCompare = ScreenComparator -> X WorkspaceCompare
getXineramaPhysicalWsCompare (ScreenComparator -> X WorkspaceCompare)
-> ScreenComparator -> X WorkspaceCompare
forall a b. (a -> b) -> a -> b
$ (ScreenId -> ScreenId -> Ordering) -> ScreenComparator
screenComparatorById ScreenId -> ScreenId -> Ordering
forall a. Ord a => a -> a -> Ordering
compare
getXineramaPhysicalWsCompare :: ScreenComparator -> X WorkspaceCompare
getXineramaPhysicalWsCompare :: ScreenComparator -> X WorkspaceCompare
getXineramaPhysicalWsCompare (ScreenComparator (ScreenId, Rectangle) -> (ScreenId, Rectangle) -> Ordering
sc) = do
w <- (XState
-> StackSet [Char] (Layout Window) Window ScreenId ScreenDetail)
-> X (StackSet [Char] (Layout Window) Window ScreenId ScreenDetail)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets XState
-> StackSet [Char] (Layout Window) Window ScreenId ScreenDetail
windowset
return $ \ [Char]
a [Char]
b -> case ([Char]
-> StackSet [Char] (Layout Window) Window ScreenId ScreenDetail
-> Bool
forall {a} {l} {a} {sid} {sd}.
Eq a =>
a -> StackSet a l a sid sd -> Bool
isOnScreen [Char]
a StackSet [Char] (Layout Window) Window ScreenId ScreenDetail
w, [Char]
-> StackSet [Char] (Layout Window) Window ScreenId ScreenDetail
-> Bool
forall {a} {l} {a} {sid} {sd}.
Eq a =>
a -> StackSet a l a sid sd -> Bool
isOnScreen [Char]
b StackSet [Char] (Layout Window) Window ScreenId ScreenDetail
w) of
(Bool
True, Bool
True) -> StackSet [Char] (Layout Window) Window ScreenId ScreenDetail
-> WorkspaceCompare
forall {i} {l} {a}.
Eq i =>
StackSet i l a ScreenId ScreenDetail -> i -> i -> Ordering
compareUsingScreen StackSet [Char] (Layout Window) Window ScreenId ScreenDetail
w [Char]
a [Char]
b
(Bool
False, Bool
False) -> WorkspaceCompare
forall a. Ord a => a -> a -> Ordering
compare [Char]
a [Char]
b
(Bool
True, Bool
False) -> Ordering
LT
(Bool
False, Bool
True) -> Ordering
GT
where
onScreen :: StackSet i l a sid sd -> [Screen i l a sid sd]
onScreen StackSet i l a sid sd
w = StackSet i l a sid sd -> Screen i l a sid sd
forall i l a sid sd. StackSet i l a sid sd -> Screen i l a sid sd
S.current StackSet i l a sid sd
w Screen i l a sid sd
-> [Screen i l a sid sd] -> [Screen i l a sid sd]
forall a. a -> [a] -> [a]
: StackSet i l a sid sd -> [Screen i l a sid sd]
forall i l a sid sd. StackSet i l a sid sd -> [Screen i l a sid sd]
S.visible StackSet i l a sid sd
w
isOnScreen :: a -> StackSet a l a sid sd -> Bool
isOnScreen a
a StackSet a l a sid sd
w = a
a a -> [a] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (Screen a l a sid sd -> a) -> [Screen a l a sid sd] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map (Workspace a l a -> a
forall i l a. Workspace i l a -> i
S.tag (Workspace a l a -> a)
-> (Screen a l a sid sd -> Workspace a l a)
-> Screen a l a sid sd
-> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Screen a l a sid sd -> Workspace a l a
forall i l a sid sd. Screen i l a sid sd -> Workspace i l a
S.workspace) (StackSet a l a sid sd -> [Screen a l a sid sd]
forall i l a sid sd. StackSet i l a sid sd -> [Screen i l a sid sd]
onScreen StackSet a l a sid sd
w)
tagToScreen :: t (Screen p l a sid sd) -> p -> Screen p l a sid sd
tagToScreen t (Screen p l a sid sd)
s p
x = Maybe (Screen p l a sid sd) -> Screen p l a sid sd
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (Screen p l a sid sd) -> Screen p l a sid sd)
-> Maybe (Screen p l a sid sd) -> Screen p l a sid sd
forall a b. (a -> b) -> a -> b
$ (Screen p l a sid sd -> Bool)
-> t (Screen p l a sid sd) -> Maybe (Screen p l a sid sd)
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find ((p -> p -> Bool
forall a. Eq a => a -> a -> Bool
== p
x) (p -> Bool)
-> (Screen p l a sid sd -> p) -> Screen p l a sid sd -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Workspace p l a -> p
forall i l a. Workspace i l a -> i
S.tag (Workspace p l a -> p)
-> (Screen p l a sid sd -> Workspace p l a)
-> Screen p l a sid sd
-> p
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Screen p l a sid sd -> Workspace p l a
forall i l a sid sd. Screen i l a sid sd -> Workspace i l a
S.workspace) t (Screen p l a sid sd)
s
compareUsingScreen :: StackSet i l a ScreenId ScreenDetail -> i -> i -> Ordering
compareUsingScreen StackSet i l a ScreenId ScreenDetail
w = (ScreenId, Rectangle) -> (ScreenId, Rectangle) -> Ordering
sc ((ScreenId, Rectangle) -> (ScreenId, Rectangle) -> Ordering)
-> (i -> (ScreenId, Rectangle)) -> i -> i -> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` Screen i l a ScreenId ScreenDetail -> (ScreenId, Rectangle)
forall i l a.
Screen i l a ScreenId ScreenDetail -> (ScreenId, Rectangle)
getScreenIdAndRectangle (Screen i l a ScreenId ScreenDetail -> (ScreenId, Rectangle))
-> (i -> Screen i l a ScreenId ScreenDetail)
-> i
-> (ScreenId, Rectangle)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Screen i l a ScreenId ScreenDetail]
-> i -> Screen i l a ScreenId ScreenDetail
forall {t :: * -> *} {p} {l} {a} {sid} {sd}.
(Foldable t, Eq p) =>
t (Screen p l a sid sd) -> p -> Screen p l a sid sd
tagToScreen (StackSet i l a ScreenId ScreenDetail
-> [Screen i l a ScreenId ScreenDetail]
forall i l a sid sd. StackSet i l a sid sd -> [Screen i l a sid sd]
onScreen StackSet i l a ScreenId ScreenDetail
w)
mkWsSort :: X WorkspaceCompare -> X WorkspaceSort
mkWsSort :: X WorkspaceCompare -> X WorkspaceSort
mkWsSort X WorkspaceCompare
cmpX = do
cmp <- X WorkspaceCompare
cmpX
return $ sortBy (\WindowSpace
a WindowSpace
b -> WorkspaceCompare
cmp (WindowSpace -> [Char]
forall i l a. Workspace i l a -> i
S.tag WindowSpace
a) (WindowSpace -> [Char]
forall i l a. Workspace i l a -> i
S.tag WindowSpace
b))
getSortByIndex :: X WorkspaceSort
getSortByIndex :: X WorkspaceSort
getSortByIndex = X WorkspaceCompare -> X WorkspaceSort
mkWsSort X WorkspaceCompare
getWsCompare
getSortByTag :: X WorkspaceSort
getSortByTag :: X WorkspaceSort
getSortByTag = X WorkspaceCompare -> X WorkspaceSort
mkWsSort X WorkspaceCompare
getWsCompareByTag
getSortByXineramaRule :: X WorkspaceSort
getSortByXineramaRule :: X WorkspaceSort
getSortByXineramaRule = X WorkspaceCompare -> X WorkspaceSort
mkWsSort X WorkspaceCompare
getXineramaWsCompare
getSortByXineramaPhysicalRule :: ScreenComparator -> X WorkspaceSort
getSortByXineramaPhysicalRule :: ScreenComparator -> X WorkspaceSort
getSortByXineramaPhysicalRule ScreenComparator
sc = X WorkspaceCompare -> X WorkspaceSort
mkWsSort (X WorkspaceCompare -> X WorkspaceSort)
-> X WorkspaceCompare -> X WorkspaceSort
forall a b. (a -> b) -> a -> b
$ ScreenComparator -> X WorkspaceCompare
getXineramaPhysicalWsCompare ScreenComparator
sc