{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses #-}
-----------------------------------------------------------------------------
-- |
-- Module       : XMonad.Actions.WorkspaceCursors
-- Description  : Like "XMonad.Actions.Plane" for an arbitrary number of dimensions.
-- Copyright    : (c) 2009 Adam Vogt <vogt.adam@gmail.com>
-- License      : BSD
--
-- Maintainer   : Adam Vogt
-- Stability    : unstable
-- Portability  : unportable
--
-- Like "XMonad.Actions.Plane" for an arbitrary number of dimensions.
-----------------------------------------------------------------------------

module XMonad.Actions.WorkspaceCursors
    (
    -- * Usage
    -- $usage

     focusDepth
    ,makeCursors
    ,toList
    ,workspaceCursors

    ,WorkspaceCursors
    ,getFocus

    -- * Modifying the focus
    ,modifyLayer
    ,modifyLayer'
    ,shiftModifyLayer,shiftLayer

    -- * Functions to pass to 'modifyLayer'
    ,focusNth'
    ,noWrapUp,noWrapDown,

    -- * Todo
    -- $todo

    -- * Types
    Cursors,
    ) where

import qualified XMonad.StackSet as W

import XMonad.Actions.FocusNth(focusNth')
import XMonad.Layout.LayoutModifier(ModifiedLayout(..),
                                    LayoutModifier(handleMess, redoLayout))
import XMonad(Message, WorkspaceId, X, XState(windowset),
              fromMessage, sendMessage, windows, gets)
import XMonad.Util.Stack (reverseS)
import XMonad.Prelude

-- $usage
--
-- Here is an example config:
--
-- > import XMonad
-- > import XMonad.Actions.WorkspaceCursors
-- > import XMonad.Util.EZConfig
-- > import qualified XMonad.StackSet as W
-- >
-- > main = xmonad conf
-- >
-- > conf = additionalKeysP def
-- >        { layoutHook = workspaceCursors myCursors $ layoutHook def
-- >        , workspaces = toList myCursors } $
-- >        [("M-"++shift++control++[k], f direction depth)
-- >          | (f,shift) <- zip [modifyLayer,shiftModifyLayer] ["","S-"]
-- >          , (direction,control) <- zip [W.focusUp',W.focusDown'] ["C-",""]
-- >          , (depth,k) <- zip (reverse [1..focusDepth myCursors]) "asdf"]
-- >        ++ moreKeybindings
-- >
-- > moreKeybindings = []
-- >
-- > myCursors = makeCursors $ map (map (\x -> [x])) [ "1234", "abc", "xyz"]
-- > -- myCursors = makeCursors [["wsA","wsB","wsC"],["-alpha-","-beta-","-gamma-"],["x","y"]]


-- $todo
--
-- * Find and document how to raise the allowable length of arguments:
--   restoring xmonad's state results in: @xmonad: executeFile: resource
--   exhausted (Argument list too long)@ when you specify more than about 50
--   workspaces. Or change it such that workspaces are created when you try to
--   view it.
--
-- * Function for pretty printing for "XMonad.Hooks.StatusBar.PP" that groups
--   workspaces by
-- common prefixes
--
-- * Examples of adding workspaces to the cursors, having them appear multiple
--   times for being able to show jumping to some n'th multiple workspace

-- | makeCursors requires a nonempty string, and each sublist must be nonempty
makeCursors ::  [[String]] -> Cursors String
makeCursors :: [[WorkspaceId]] -> Cursors WorkspaceId
makeCursors []       = WorkspaceId -> Cursors WorkspaceId
forall a. HasCallStack => WorkspaceId -> a
error WorkspaceId
"Workspace Cursors cannot be empty"
makeCursors ([WorkspaceId]
a : [[WorkspaceId]]
as) = [WorkspaceId] -> WorkspaceId
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([WorkspaceId] -> WorkspaceId)
-> ([WorkspaceId] -> [WorkspaceId]) -> [WorkspaceId] -> WorkspaceId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [WorkspaceId] -> [WorkspaceId]
forall a. [a] -> [a]
reverse ([WorkspaceId] -> WorkspaceId)
-> Cursors [WorkspaceId] -> Cursors WorkspaceId
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Cursors [WorkspaceId] -> [[WorkspaceId]] -> Cursors [WorkspaceId])
-> Cursors [WorkspaceId]
-> [[[WorkspaceId]]]
-> Cursors [WorkspaceId]
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl Cursors [WorkspaceId] -> [[WorkspaceId]] -> Cursors [WorkspaceId]
forall a. Monoid a => Cursors a -> [a] -> Cursors a
addDim Cursors [WorkspaceId]
x [[[WorkspaceId]]]
xs
    where x :: Cursors [WorkspaceId]
x = [[WorkspaceId]] -> Cursors [WorkspaceId]
forall a. [a] -> Cursors a
end ([[WorkspaceId]] -> Cursors [WorkspaceId])
-> [[WorkspaceId]] -> Cursors [WorkspaceId]
forall a b. (a -> b) -> a -> b
$ (WorkspaceId -> [WorkspaceId]) -> [WorkspaceId] -> [[WorkspaceId]]
forall a b. (a -> b) -> [a] -> [b]
map WorkspaceId -> [WorkspaceId]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return [WorkspaceId]
a
          xs :: [[[WorkspaceId]]]
xs = ([WorkspaceId] -> [[WorkspaceId]])
-> [[WorkspaceId]] -> [[[WorkspaceId]]]
forall a b. (a -> b) -> [a] -> [b]
map ((WorkspaceId -> [WorkspaceId]) -> [WorkspaceId] -> [[WorkspaceId]]
forall a b. (a -> b) -> [a] -> [b]
map WorkspaceId -> [WorkspaceId]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return) [[WorkspaceId]]
as
          -- this could probably be simplified, but this true:
          -- toList . makeCursors == map (concat . reverse) . sequence . reverse . map (map (:[]))
          -- the strange order is used because it makes the regular M-1..9
          -- bindings change the prefixes first

addDim ::  (Monoid a) => Cursors a -> [a] -> Cursors a
addDim :: forall a. Monoid a => Cursors a -> [a] -> Cursors a
addDim Cursors a
prev [a]
prefixes = Stack (Cursors a) -> Cursors a
forall a. Stack (Cursors a) -> Cursors a
Cons (Stack (Cursors a) -> Cursors a)
-> ([Cursors a] -> Stack (Cursors a)) -> [Cursors a] -> Cursors a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe (Stack (Cursors a)) -> Stack (Cursors a)
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (Stack (Cursors a)) -> Stack (Cursors a))
-> ([Cursors a] -> Maybe (Stack (Cursors a)))
-> [Cursors a]
-> Stack (Cursors a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Cursors a] -> Maybe (Stack (Cursors a))
forall a. [a] -> Maybe (Stack a)
W.differentiate
            ([Cursors a] -> Cursors a) -> [Cursors a] -> Cursors a
forall a b. (a -> b) -> a -> b
$ (a -> Cursors a) -> [a] -> [Cursors a]
forall a b. (a -> b) -> [a] -> [b]
map (((a -> a) -> Cursors a -> Cursors a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Cursors a
prev) ((a -> a) -> Cursors a) -> (a -> a -> a) -> a -> Cursors a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a
forall a. Monoid a => a -> a -> a
mappend) [a]
prefixes

end :: [a] -> Cursors a
end :: forall a. [a] -> Cursors a
end = Stack (Cursors a) -> Cursors a
forall a. Stack (Cursors a) -> Cursors a
Cons (Stack (Cursors a) -> Cursors a)
-> ([a] -> Stack (Cursors a)) -> [a] -> Cursors a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe (Stack (Cursors a)) -> Stack (Cursors a)
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (Stack (Cursors a)) -> Stack (Cursors a))
-> ([a] -> Maybe (Stack (Cursors a))) -> [a] -> Stack (Cursors a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Cursors a] -> Maybe (Stack (Cursors a))
forall a. [a] -> Maybe (Stack a)
W.differentiate ([Cursors a] -> Maybe (Stack (Cursors a)))
-> ([a] -> [Cursors a]) -> [a] -> Maybe (Stack (Cursors a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Cursors a) -> [a] -> [Cursors a]
forall a b. (a -> b) -> [a] -> [b]
map a -> Cursors a
forall a. a -> Cursors a
End

data Cursors a
    = Cons (W.Stack (Cursors a))
    | End a deriving (Cursors a -> Cursors a -> Bool
(Cursors a -> Cursors a -> Bool)
-> (Cursors a -> Cursors a -> Bool) -> Eq (Cursors a)
forall a. Eq a => Cursors a -> Cursors a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Cursors a -> Cursors a -> Bool
== :: Cursors a -> Cursors a -> Bool
$c/= :: forall a. Eq a => Cursors a -> Cursors a -> Bool
/= :: Cursors a -> Cursors a -> Bool
Eq,Int -> Cursors a -> ShowS
[Cursors a] -> ShowS
Cursors a -> WorkspaceId
(Int -> Cursors a -> ShowS)
-> (Cursors a -> WorkspaceId)
-> ([Cursors a] -> ShowS)
-> Show (Cursors a)
forall a. Show a => Int -> Cursors a -> ShowS
forall a. Show a => [Cursors a] -> ShowS
forall a. Show a => Cursors a -> WorkspaceId
forall a.
(Int -> a -> ShowS)
-> (a -> WorkspaceId) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Cursors a -> ShowS
showsPrec :: Int -> Cursors a -> ShowS
$cshow :: forall a. Show a => Cursors a -> WorkspaceId
show :: Cursors a -> WorkspaceId
$cshowList :: forall a. Show a => [Cursors a] -> ShowS
showList :: [Cursors a] -> ShowS
Show,ReadPrec [Cursors a]
ReadPrec (Cursors a)
Int -> ReadS (Cursors a)
ReadS [Cursors a]
(Int -> ReadS (Cursors a))
-> ReadS [Cursors a]
-> ReadPrec (Cursors a)
-> ReadPrec [Cursors a]
-> Read (Cursors a)
forall a. Read a => ReadPrec [Cursors a]
forall a. Read a => ReadPrec (Cursors a)
forall a. Read a => Int -> ReadS (Cursors a)
forall a. Read a => ReadS [Cursors a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (Cursors a)
readsPrec :: Int -> ReadS (Cursors a)
$creadList :: forall a. Read a => ReadS [Cursors a]
readList :: ReadS [Cursors a]
$creadPrec :: forall a. Read a => ReadPrec (Cursors a)
readPrec :: ReadPrec (Cursors a)
$creadListPrec :: forall a. Read a => ReadPrec [Cursors a]
readListPrec :: ReadPrec [Cursors a]
Read)

instance Foldable Cursors where
    foldMap :: forall m a. Monoid m => (a -> m) -> Cursors a -> m
foldMap a -> m
f (End a
x) = a -> m
f a
x
    foldMap a -> m
f (Cons (W.Stack Cursors a
x [Cursors a]
y [Cursors a]
z)) = (a -> m) -> Cursors a -> m
forall m a. Monoid m => (a -> m) -> Cursors a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap a -> m
f Cursors a
x m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` [m] -> m
forall a. Monoid a => [a] -> a
mconcat ((Cursors a -> m) -> [Cursors a] -> [m]
forall a b. (a -> b) -> [a] -> [b]
map ((a -> m) -> Cursors a -> m
forall m a. Monoid m => (a -> m) -> Cursors a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap a -> m
f) ([Cursors a] -> [m]) -> [Cursors a] -> [m]
forall a b. (a -> b) -> a -> b
$ [Cursors a] -> [Cursors a]
forall a. [a] -> [a]
reverse [Cursors a]
y [Cursors a] -> [Cursors a] -> [Cursors a]
forall a. [a] -> [a] -> [a]
++ [Cursors a]
z)

instance Functor Cursors where
    fmap :: forall a b. (a -> b) -> Cursors a -> Cursors b
fmap a -> b
f (End a
a) = b -> Cursors b
forall a. a -> Cursors a
End (b -> Cursors b) -> b -> Cursors b
forall a b. (a -> b) -> a -> b
$ a -> b
f a
a
    fmap a -> b
f (Cons (W.Stack Cursors a
x [Cursors a]
y [Cursors a]
z)) = Stack (Cursors b) -> Cursors b
forall a. Stack (Cursors a) -> Cursors a
Cons (Stack (Cursors b) -> Cursors b) -> Stack (Cursors b) -> Cursors b
forall a b. (a -> b) -> a -> b
$ Cursors b -> [Cursors b] -> [Cursors b] -> Stack (Cursors b)
forall a. a -> [a] -> [a] -> Stack a
W.Stack ((a -> b) -> Cursors a -> Cursors b
forall a b. (a -> b) -> Cursors a -> Cursors b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Cursors a
x) ((Cursors a -> Cursors b) -> [Cursors a] -> [Cursors b]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Cursors a -> Cursors b
forall a b. (a -> b) -> Cursors a -> Cursors b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f) [Cursors a]
y) ((Cursors a -> Cursors b) -> [Cursors a] -> [Cursors b]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> Cursors a -> Cursors b
forall a b. (a -> b) -> Cursors a -> Cursors b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f) [Cursors a]
z)

changeFocus ::  (Cursors t -> Bool) -> Cursors t -> [Cursors t]
changeFocus :: forall t. (Cursors t -> Bool) -> Cursors t -> [Cursors t]
changeFocus Cursors t -> Bool
p (Cons Stack (Cursors t)
x) = do
    Stack (Cursors t)
choose <- (Cursors t -> Bool) -> Stack (Cursors t) -> [Stack (Cursors t)]
forall a. (a -> Bool) -> Stack a -> [Stack a]
chFocus Cursors t -> Bool
p Stack (Cursors t)
x
    Cursors t
foc    <- (Cursors t -> Bool) -> Cursors t -> [Cursors t]
forall t. (Cursors t -> Bool) -> Cursors t -> [Cursors t]
changeFocus Cursors t -> Bool
p (Cursors t -> [Cursors t]) -> Cursors t -> [Cursors t]
forall a b. (a -> b) -> a -> b
$ Stack (Cursors t) -> Cursors t
forall a. Stack a -> a
W.focus Stack (Cursors t)
choose
    Cursors t -> [Cursors t]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return (Cursors t -> [Cursors t])
-> (Stack (Cursors t) -> Cursors t)
-> Stack (Cursors t)
-> [Cursors t]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Stack (Cursors t) -> Cursors t
forall a. Stack (Cursors a) -> Cursors a
Cons (Stack (Cursors t) -> [Cursors t])
-> Stack (Cursors t) -> [Cursors t]
forall a b. (a -> b) -> a -> b
$ Stack (Cursors t)
choose { W.focus = foc }
changeFocus Cursors t -> Bool
p Cursors t
x = Bool -> [()]
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Cursors t -> Bool
p Cursors t
x) [()] -> [Cursors t] -> [Cursors t]
forall a b. [a] -> [b] -> [b]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Cursors t -> [Cursors t]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return Cursors t
x

chFocus :: (a -> Bool) -> W.Stack a -> [W.Stack a]
chFocus :: forall a. (a -> Bool) -> Stack a -> [Stack a]
chFocus a -> Bool
p Stack a
st = (Stack a -> Bool) -> [Stack a] -> [Stack a]
forall a. (a -> Bool) -> [a] -> [a]
filter (a -> Bool
p (a -> Bool) -> (Stack a -> a) -> Stack a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Stack a -> a
forall a. Stack a -> a
W.focus) ([Stack a] -> [Stack a]) -> [Stack a] -> [Stack a]
forall a b. (a -> b) -> a -> b
$ (Stack a -> a -> Stack a) -> [Stack a] -> [a] -> [Stack a]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith Stack a -> a -> Stack a
forall a b. a -> b -> a
const ((Stack a -> Stack a) -> Stack a -> [Stack a]
forall a. (a -> a) -> a -> [a]
iterate Stack a -> Stack a
forall a. Stack a -> Stack a
W.focusDown' Stack a
st) (Stack a -> [a]
forall a. Stack a -> [a]
W.integrate Stack a
st)

getFocus ::  Cursors b -> b
getFocus :: forall b. Cursors b -> b
getFocus (Cons Stack (Cursors b)
x) = Cursors b -> b
forall b. Cursors b -> b
getFocus (Cursors b -> b) -> Cursors b -> b
forall a b. (a -> b) -> a -> b
$ Stack (Cursors b) -> Cursors b
forall a. Stack a -> a
W.focus Stack (Cursors b)
x
getFocus (End b
x) = b
x

-- This could be made more efficient, if the fact that the suffixes are grouped
focusTo ::  (Eq t) => t -> Cursors t -> Maybe (Cursors t)
focusTo :: forall t. Eq t => t -> Cursors t -> Maybe (Cursors t)
focusTo t
x = (Cursors t -> Bool) -> [Cursors t] -> Maybe (Cursors t)
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find ((t
xt -> t -> Bool
forall a. Eq a => a -> a -> Bool
==) (t -> Bool) -> (Cursors t -> t) -> Cursors t -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cursors t -> t
forall b. Cursors b -> b
getFocus) ([Cursors t] -> Maybe (Cursors t))
-> (Cursors t -> [Cursors t]) -> Cursors t -> Maybe (Cursors t)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Cursors t -> Bool) -> Cursors t -> [Cursors t]
forall t. (Cursors t -> Bool) -> Cursors t -> [Cursors t]
changeFocus (Bool -> Cursors t -> Bool
forall a b. a -> b -> a
const Bool
True)

-- | non-wrapping version of 'W.focusUp''
noWrapUp ::  W.Stack t -> W.Stack t
noWrapUp :: forall a. Stack a -> Stack a
noWrapUp (W.Stack t
t (t
l:[t]
ls) [t]
rs) = t -> [t] -> [t] -> Stack t
forall a. a -> [a] -> [a] -> Stack a
W.Stack t
l [t]
ls (t
tt -> [t] -> [t]
forall a. a -> [a] -> [a]
:[t]
rs)
noWrapUp x :: Stack t
x@(W.Stack t
_ []   [t]
_ ) = Stack t
x

-- | non-wrapping version of 'W.focusDown''
noWrapDown ::  W.Stack t -> W.Stack t
noWrapDown :: forall a. Stack a -> Stack a
noWrapDown = Stack t -> Stack t
forall a. Stack a -> Stack a
reverseS (Stack t -> Stack t) -> (Stack t -> Stack t) -> Stack t -> Stack t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Stack t -> Stack t
forall a. Stack a -> Stack a
noWrapUp (Stack t -> Stack t) -> (Stack t -> Stack t) -> Stack t -> Stack t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Stack t -> Stack t
forall a. Stack a -> Stack a
reverseS

focusDepth ::  Cursors t -> Int
focusDepth :: forall a. Cursors a -> Int
focusDepth (Cons Stack (Cursors t)
x) = Int
1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Cursors t -> Int
forall a. Cursors a -> Int
focusDepth (Stack (Cursors t) -> Cursors t
forall a. Stack a -> a
W.focus Stack (Cursors t)
x)
focusDepth (End  t
_) = Int
0

descend :: Monad m =>(W.Stack (Cursors a) -> m (W.Stack (Cursors a)))-> Int-> Cursors a-> m (Cursors a)
descend :: forall (m :: * -> *) a.
Monad m =>
(Stack (Cursors a) -> m (Stack (Cursors a)))
-> Int -> Cursors a -> m (Cursors a)
descend Stack (Cursors a) -> m (Stack (Cursors a))
f Int
1 (Cons Stack (Cursors a)
x) = Stack (Cursors a) -> Cursors a
forall a. Stack (Cursors a) -> Cursors a
Cons (Stack (Cursors a) -> Cursors a)
-> m (Stack (Cursors a)) -> m (Cursors a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Stack (Cursors a) -> m (Stack (Cursors a))
f Stack (Cursors a)
x
descend Stack (Cursors a) -> m (Stack (Cursors a))
f Int
n (Cons Stack (Cursors a)
x) | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1 = (Stack (Cursors a) -> Cursors a)
-> m (Stack (Cursors a)) -> m (Cursors a)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Stack (Cursors a) -> Cursors a
forall a. Stack (Cursors a) -> Cursors a
Cons (m (Stack (Cursors a)) -> m (Cursors a))
-> m (Stack (Cursors a)) -> m (Cursors a)
forall a b. (a -> b) -> a -> b
$ (Stack (Cursors a) -> m (Stack (Cursors a)))
-> Int -> Cursors a -> m (Cursors a)
forall (m :: * -> *) a.
Monad m =>
(Stack (Cursors a) -> m (Stack (Cursors a)))
-> Int -> Cursors a -> m (Cursors a)
descend Stack (Cursors a) -> m (Stack (Cursors a))
f (Int -> Int
forall a. Enum a => a -> a
pred Int
n) (Cursors a -> m (Cursors a))
-> Stack (Cursors a) -> m (Stack (Cursors a))
forall (m :: * -> *) a1.
Monad m =>
(a1 -> m a1) -> Stack a1 -> m (Stack a1)
`onFocus` Stack (Cursors a)
x
descend Stack (Cursors a) -> m (Stack (Cursors a))
_ Int
_ Cursors a
x = Cursors a -> m (Cursors a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Cursors a
x

onFocus :: (Monad m) => (a1 -> m a1) -> W.Stack a1 -> m (W.Stack a1)
onFocus :: forall (m :: * -> *) a1.
Monad m =>
(a1 -> m a1) -> Stack a1 -> m (Stack a1)
onFocus a1 -> m a1
f Stack a1
st = (\a1
x -> Stack a1
st { W.focus = x}) (a1 -> Stack a1) -> m a1 -> m (Stack a1)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a1 -> m a1
f (Stack a1 -> a1
forall a. Stack a -> a
W.focus Stack a1
st)

-- | @modifyLayer@ is used to change the focus at a given depth
modifyLayer :: (W.Stack (Cursors String) -> W.Stack (Cursors String)) -> Int -> X ()
modifyLayer :: (Stack (Cursors WorkspaceId) -> Stack (Cursors WorkspaceId))
-> Int -> X ()
modifyLayer Stack (Cursors WorkspaceId) -> Stack (Cursors WorkspaceId)
f Int
depth = (Cursors WorkspaceId -> X (Cursors WorkspaceId)) -> X ()
modifyCursors ((Stack (Cursors WorkspaceId) -> X (Stack (Cursors WorkspaceId)))
-> Int -> Cursors WorkspaceId -> X (Cursors WorkspaceId)
forall (m :: * -> *) a.
Monad m =>
(Stack (Cursors a) -> m (Stack (Cursors a)))
-> Int -> Cursors a -> m (Cursors a)
descend (Stack (Cursors WorkspaceId) -> X (Stack (Cursors WorkspaceId))
forall a. a -> X a
forall (m :: * -> *) a. Monad m => a -> m a
return (Stack (Cursors WorkspaceId) -> X (Stack (Cursors WorkspaceId)))
-> (Stack (Cursors WorkspaceId) -> Stack (Cursors WorkspaceId))
-> Stack (Cursors WorkspaceId)
-> X (Stack (Cursors WorkspaceId))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Stack (Cursors WorkspaceId) -> Stack (Cursors WorkspaceId)
f) Int
depth)

-- | @shiftModifyLayer@ is the same as 'modifyLayer', but also shifts the
-- currently focused window to the new workspace
shiftModifyLayer :: (W.Stack (Cursors String) -> W.Stack (Cursors WorkspaceId))-> Int-> X ()
shiftModifyLayer :: (Stack (Cursors WorkspaceId) -> Stack (Cursors WorkspaceId))
-> Int -> X ()
shiftModifyLayer Stack (Cursors WorkspaceId) -> Stack (Cursors WorkspaceId)
f = (Stack (Cursors WorkspaceId) -> X (Stack (Cursors WorkspaceId)))
-> Int -> X ()
modifyLayer' ((Stack (Cursors WorkspaceId) -> X (Stack (Cursors WorkspaceId)))
 -> Int -> X ())
-> (Stack (Cursors WorkspaceId) -> X (Stack (Cursors WorkspaceId)))
-> Int
-> X ()
forall a b. (a -> b) -> a -> b
$ \Stack (Cursors WorkspaceId)
st -> do
    let st' :: Stack (Cursors WorkspaceId)
st' = Stack (Cursors WorkspaceId) -> Stack (Cursors WorkspaceId)
f Stack (Cursors WorkspaceId)
st
    (WindowSet -> WindowSet) -> X ()
windows ((WindowSet -> WindowSet) -> X ())
-> (WindowSet -> WindowSet) -> X ()
forall a b. (a -> b) -> a -> b
$ WorkspaceId -> WindowSet -> WindowSet
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
W.shift (WorkspaceId -> WindowSet -> WindowSet)
-> WorkspaceId -> WindowSet -> WindowSet
forall a b. (a -> b) -> a -> b
$ Cursors WorkspaceId -> WorkspaceId
forall b. Cursors b -> b
getFocus (Stack (Cursors WorkspaceId) -> Cursors WorkspaceId
forall a. Stack (Cursors a) -> Cursors a
Cons Stack (Cursors WorkspaceId)
st')
    Stack (Cursors WorkspaceId) -> X (Stack (Cursors WorkspaceId))
forall a. a -> X a
forall (m :: * -> *) a. Monad m => a -> m a
return Stack (Cursors WorkspaceId)
st'

-- | @shiftLayer@ is the same as 'shiftModifyLayer', but the focus remains on
-- the current workspace.
shiftLayer :: (W.Stack (Cursors String) -> W.Stack (Cursors WorkspaceId))-> Int-> X ()
shiftLayer :: (Stack (Cursors WorkspaceId) -> Stack (Cursors WorkspaceId))
-> Int -> X ()
shiftLayer Stack (Cursors WorkspaceId) -> Stack (Cursors WorkspaceId)
f = (Stack (Cursors WorkspaceId) -> X (Stack (Cursors WorkspaceId)))
-> Int -> X ()
modifyLayer' ((Stack (Cursors WorkspaceId) -> X (Stack (Cursors WorkspaceId)))
 -> Int -> X ())
-> (Stack (Cursors WorkspaceId) -> X (Stack (Cursors WorkspaceId)))
-> Int
-> X ()
forall a b. (a -> b) -> a -> b
$ \Stack (Cursors WorkspaceId)
st -> do
    (WindowSet -> WindowSet) -> X ()
windows ((WindowSet -> WindowSet) -> X ())
-> (WindowSet -> WindowSet) -> X ()
forall a b. (a -> b) -> a -> b
$ WorkspaceId -> WindowSet -> WindowSet
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
W.shift (WorkspaceId -> WindowSet -> WindowSet)
-> WorkspaceId -> WindowSet -> WindowSet
forall a b. (a -> b) -> a -> b
$ Cursors WorkspaceId -> WorkspaceId
forall b. Cursors b -> b
getFocus (Cursors WorkspaceId -> WorkspaceId)
-> Cursors WorkspaceId -> WorkspaceId
forall a b. (a -> b) -> a -> b
$ Stack (Cursors WorkspaceId) -> Cursors WorkspaceId
forall a. Stack (Cursors a) -> Cursors a
Cons (Stack (Cursors WorkspaceId) -> Cursors WorkspaceId)
-> Stack (Cursors WorkspaceId) -> Cursors WorkspaceId
forall a b. (a -> b) -> a -> b
$ Stack (Cursors WorkspaceId) -> Stack (Cursors WorkspaceId)
f Stack (Cursors WorkspaceId)
st
    Stack (Cursors WorkspaceId) -> X (Stack (Cursors WorkspaceId))
forall a. a -> X a
forall (m :: * -> *) a. Monad m => a -> m a
return Stack (Cursors WorkspaceId)
st

-- | example usages are 'shiftLayer' and 'shiftModifyLayer'
modifyLayer' :: (W.Stack (Cursors String) -> X (W.Stack (Cursors String))) -> Int -> X ()
modifyLayer' :: (Stack (Cursors WorkspaceId) -> X (Stack (Cursors WorkspaceId)))
-> Int -> X ()
modifyLayer' Stack (Cursors WorkspaceId) -> X (Stack (Cursors WorkspaceId))
f Int
depth = (Cursors WorkspaceId -> X (Cursors WorkspaceId)) -> X ()
modifyCursors ((Stack (Cursors WorkspaceId) -> X (Stack (Cursors WorkspaceId)))
-> Int -> Cursors WorkspaceId -> X (Cursors WorkspaceId)
forall (m :: * -> *) a.
Monad m =>
(Stack (Cursors a) -> m (Stack (Cursors a)))
-> Int -> Cursors a -> m (Cursors a)
descend Stack (Cursors WorkspaceId) -> X (Stack (Cursors WorkspaceId))
f Int
depth)

modifyCursors ::  (Cursors String -> X (Cursors String)) -> X ()
modifyCursors :: (Cursors WorkspaceId -> X (Cursors WorkspaceId)) -> X ()
modifyCursors = ChangeCursors -> X ()
forall a. Message a => a -> X ()
sendMessage (ChangeCursors -> X ())
-> ((Cursors WorkspaceId -> X (Cursors WorkspaceId))
    -> ChangeCursors)
-> (Cursors WorkspaceId -> X (Cursors WorkspaceId))
-> X ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Cursors WorkspaceId -> X (Cursors WorkspaceId)) -> ChangeCursors
ChangeCursors ((Cursors WorkspaceId -> X (Cursors WorkspaceId)) -> ChangeCursors)
-> ((Cursors WorkspaceId -> X (Cursors WorkspaceId))
    -> Cursors WorkspaceId -> X (Cursors WorkspaceId))
-> (Cursors WorkspaceId -> X (Cursors WorkspaceId))
-> ChangeCursors
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((X () -> X (Cursors WorkspaceId) -> X (Cursors WorkspaceId))
-> (Cursors WorkspaceId -> X ())
-> (Cursors WorkspaceId -> X (Cursors WorkspaceId))
-> Cursors WorkspaceId
-> X (Cursors WorkspaceId)
forall a b c.
(a -> b -> c)
-> (Cursors WorkspaceId -> a)
-> (Cursors WorkspaceId -> b)
-> Cursors WorkspaceId
-> c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 X () -> X (Cursors WorkspaceId) -> X (Cursors WorkspaceId)
forall a b. X a -> X b -> X b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
(>>) Cursors WorkspaceId -> X ()
updateXMD Cursors WorkspaceId -> X (Cursors WorkspaceId)
forall a. a -> X a
forall (m :: * -> *) a. Monad m => a -> m a
return (Cursors WorkspaceId -> X (Cursors WorkspaceId))
-> (Cursors WorkspaceId -> X (Cursors WorkspaceId))
-> Cursors WorkspaceId
-> X (Cursors WorkspaceId)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=<)

newtype WorkspaceCursors a = WorkspaceCursors (Cursors String)
    deriving (ReadPrec [WorkspaceCursors a]
ReadPrec (WorkspaceCursors a)
Int -> ReadS (WorkspaceCursors a)
ReadS [WorkspaceCursors a]
(Int -> ReadS (WorkspaceCursors a))
-> ReadS [WorkspaceCursors a]
-> ReadPrec (WorkspaceCursors a)
-> ReadPrec [WorkspaceCursors a]
-> Read (WorkspaceCursors a)
forall a. ReadPrec [WorkspaceCursors a]
forall a. ReadPrec (WorkspaceCursors a)
forall a. Int -> ReadS (WorkspaceCursors a)
forall a. ReadS [WorkspaceCursors a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Int -> ReadS (WorkspaceCursors a)
readsPrec :: Int -> ReadS (WorkspaceCursors a)
$creadList :: forall a. ReadS [WorkspaceCursors a]
readList :: ReadS [WorkspaceCursors a]
$creadPrec :: forall a. ReadPrec (WorkspaceCursors a)
readPrec :: ReadPrec (WorkspaceCursors a)
$creadListPrec :: forall a. ReadPrec [WorkspaceCursors a]
readListPrec :: ReadPrec [WorkspaceCursors a]
Read,Int -> WorkspaceCursors a -> ShowS
[WorkspaceCursors a] -> ShowS
WorkspaceCursors a -> WorkspaceId
(Int -> WorkspaceCursors a -> ShowS)
-> (WorkspaceCursors a -> WorkspaceId)
-> ([WorkspaceCursors a] -> ShowS)
-> Show (WorkspaceCursors a)
forall a. Int -> WorkspaceCursors a -> ShowS
forall a. [WorkspaceCursors a] -> ShowS
forall a. WorkspaceCursors a -> WorkspaceId
forall a.
(Int -> a -> ShowS)
-> (a -> WorkspaceId) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Int -> WorkspaceCursors a -> ShowS
showsPrec :: Int -> WorkspaceCursors a -> ShowS
$cshow :: forall a. WorkspaceCursors a -> WorkspaceId
show :: WorkspaceCursors a -> WorkspaceId
$cshowList :: forall a. [WorkspaceCursors a] -> ShowS
showList :: [WorkspaceCursors a] -> ShowS
Show)

-- | The state is stored in the 'WorkspaceCursors' layout modifier. Put this as
-- your outermost modifier, unless you want different cursors at different
-- times (using "XMonad.Layout.MultiToggle")
workspaceCursors :: Cursors String -> l a -> ModifiedLayout WorkspaceCursors l a
workspaceCursors :: forall (l :: * -> *) a.
Cursors WorkspaceId -> l a -> ModifiedLayout WorkspaceCursors l a
workspaceCursors = WorkspaceCursors a -> l a -> ModifiedLayout WorkspaceCursors l a
forall (m :: * -> *) (l :: * -> *) a.
m a -> l a -> ModifiedLayout m l a
ModifiedLayout (WorkspaceCursors a -> l a -> ModifiedLayout WorkspaceCursors l a)
-> (Cursors WorkspaceId -> WorkspaceCursors a)
-> Cursors WorkspaceId
-> l a
-> ModifiedLayout WorkspaceCursors l a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cursors WorkspaceId -> WorkspaceCursors a
forall a. Cursors WorkspaceId -> WorkspaceCursors a
WorkspaceCursors

newtype ChangeCursors = ChangeCursors { ChangeCursors -> Cursors WorkspaceId -> X (Cursors WorkspaceId)
unWrap :: Cursors String -> X (Cursors String) }

instance Message ChangeCursors

updateXMD ::  Cursors WorkspaceId -> X ()
updateXMD :: Cursors WorkspaceId -> X ()
updateXMD Cursors WorkspaceId
cs = do
    Bool
changed <- (XState -> Bool) -> X Bool
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ((XState -> Bool) -> X Bool) -> (XState -> Bool) -> X Bool
forall a b. (a -> b) -> a -> b
$ (Cursors WorkspaceId -> WorkspaceId
forall b. Cursors b -> b
getFocus Cursors WorkspaceId
cs WorkspaceId -> WorkspaceId -> Bool
forall a. Eq a => a -> a -> Bool
/=) (WorkspaceId -> Bool) -> (XState -> WorkspaceId) -> XState -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WindowSet -> WorkspaceId
forall i l a s sd. StackSet i l a s sd -> i
W.currentTag (WindowSet -> WorkspaceId)
-> (XState -> WindowSet) -> XState -> WorkspaceId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. XState -> WindowSet
windowset
    Bool -> X () -> X ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
changed (X () -> X ()) -> X () -> X ()
forall a b. (a -> b) -> a -> b
$ (WindowSet -> WindowSet) -> X ()
windows ((WindowSet -> WindowSet) -> X ())
-> (WindowSet -> WindowSet) -> X ()
forall a b. (a -> b) -> a -> b
$ WorkspaceId -> WindowSet -> WindowSet
forall s i l a sd.
(Eq s, Eq i) =>
i -> StackSet i l a s sd -> StackSet i l a s sd
W.greedyView (WorkspaceId -> WindowSet -> WindowSet)
-> WorkspaceId -> WindowSet -> WindowSet
forall a b. (a -> b) -> a -> b
$ Cursors WorkspaceId -> WorkspaceId
forall b. Cursors b -> b
getFocus Cursors WorkspaceId
cs

instance LayoutModifier WorkspaceCursors a where
    redoLayout :: WorkspaceCursors a
-> Rectangle
-> Maybe (Stack a)
-> [(a, Rectangle)]
-> X ([(a, Rectangle)], Maybe (WorkspaceCursors a))
redoLayout (WorkspaceCursors Cursors WorkspaceId
cs) Rectangle
_ Maybe (Stack a)
_ [(a, Rectangle)]
arrs = do
        WorkspaceId
cws <- (XState -> WorkspaceId) -> X WorkspaceId
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ((XState -> WorkspaceId) -> X WorkspaceId)
-> (XState -> WorkspaceId) -> X WorkspaceId
forall a b. (a -> b) -> a -> b
$ WindowSet -> WorkspaceId
forall i l a s sd. StackSet i l a s sd -> i
W.currentTag (WindowSet -> WorkspaceId)
-> (XState -> WindowSet) -> XState -> WorkspaceId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. XState -> WindowSet
windowset
        ([(a, Rectangle)], Maybe (WorkspaceCursors a))
-> X ([(a, Rectangle)], Maybe (WorkspaceCursors a))
forall a. a -> X a
forall (m :: * -> *) a. Monad m => a -> m a
return ([(a, Rectangle)]
arrs,Cursors WorkspaceId -> WorkspaceCursors a
forall a. Cursors WorkspaceId -> WorkspaceCursors a
WorkspaceCursors (Cursors WorkspaceId -> WorkspaceCursors a)
-> Maybe (Cursors WorkspaceId) -> Maybe (WorkspaceCursors a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WorkspaceId -> Cursors WorkspaceId -> Maybe (Cursors WorkspaceId)
forall t. Eq t => t -> Cursors t -> Maybe (Cursors t)
focusTo WorkspaceId
cws Cursors WorkspaceId
cs)

    handleMess :: WorkspaceCursors a -> SomeMessage -> X (Maybe (WorkspaceCursors a))
handleMess (WorkspaceCursors Cursors WorkspaceId
cs) SomeMessage
m =
        (ChangeCursors -> X (WorkspaceCursors a))
-> Maybe ChangeCursors -> X (Maybe (WorkspaceCursors a))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe b)
traverse ((Cursors WorkspaceId -> WorkspaceCursors a)
-> X (Cursors WorkspaceId) -> X (WorkspaceCursors a)
forall a b. (a -> b) -> X a -> X b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Cursors WorkspaceId -> WorkspaceCursors a
forall a. Cursors WorkspaceId -> WorkspaceCursors a
WorkspaceCursors (X (Cursors WorkspaceId) -> X (WorkspaceCursors a))
-> (ChangeCursors -> X (Cursors WorkspaceId))
-> ChangeCursors
-> X (WorkspaceCursors a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Cursors WorkspaceId -> X (Cursors WorkspaceId))
-> Cursors WorkspaceId -> X (Cursors WorkspaceId)
forall a b. (a -> b) -> a -> b
$ Cursors WorkspaceId
cs) ((Cursors WorkspaceId -> X (Cursors WorkspaceId))
 -> X (Cursors WorkspaceId))
-> (ChangeCursors
    -> Cursors WorkspaceId -> X (Cursors WorkspaceId))
-> ChangeCursors
-> X (Cursors WorkspaceId)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ChangeCursors -> Cursors WorkspaceId -> X (Cursors WorkspaceId)
unWrap) (SomeMessage -> Maybe ChangeCursors
forall m. Message m => SomeMessage -> Maybe m
fromMessage SomeMessage
m)