{-# OPTIONS_GHC -fno-warn-name-shadowing -fno-warn-unused-binds #-} {-# LANGUAGE StandaloneDeriving, FlexibleContexts, UndecidableInstances, FlexibleInstances, MultiParamTypeClasses, PatternGuards, Rank2Types #-} ----------------------------------------------------------------------------- -- | -- Module : XMonad.Layout.Groups -- Description : Split windows in layout groups that are managed by another layout. -- Copyright : Quentin Moser <moserq@gmail.com> -- License : BSD-style (see LICENSE) -- -- Maintainer : orphaned -- Stability : unstable -- Portability : unportable -- -- Two-level layout with windows split in individual layout groups, -- themselves managed by a user-provided layout. -- ----------------------------------------------------------------------------- module XMonad.Layout.Groups ( -- * Usage -- $usage -- * Creation group -- * Messages , GroupsMessage(..) , ModifySpec , ModifySpecX -- ** Useful 'ModifySpec's , swapUp , swapDown , swapMaster , focusUp , focusDown , focusMaster , swapGroupUp , swapGroupDown , swapGroupMaster , focusGroupUp , focusGroupDown , focusGroupMaster , moveToGroupUp , moveToGroupDown , moveToNewGroupUp , moveToNewGroupDown , splitGroup -- * Types , Groups , Group(..) , onZipper , onLayout , WithID , sameID ) where import XMonad import XMonad.Prelude hiding (group) import qualified XMonad.StackSet as W import XMonad.Util.Stack import Control.Arrow ((>>>)) -- $usage -- This module provides a layout combinator that allows you -- to manage your windows in independent groups. You can provide -- both the layout with which to arrange the windows inside each -- group, and the layout with which the groups themselves will -- be arranged on the screen. -- -- The "XMonad.Layout.Groups.Examples" and "XMonad.Layout.Groups.Wmii" -- modules contain examples of layouts that can be defined with this -- combinator. They're also the recommended starting point -- if you are a beginner and looking for something you can use easily. -- -- One thing to note is that 'Groups'-based layout have their own -- notion of the order of windows, which is completely separate -- from XMonad's. For this reason, operations like 'XMonad.StackSet.SwapUp' -- will have no visible effect, and those like 'XMonad.StackSet.focusUp' -- will focus the windows in an unpredictable order. For a better way of -- rearranging windows and moving focus in such a layout, see the -- example 'ModifySpec's (to be passed to the 'Modify' message) provided -- by this module. -- -- If you use both 'Groups'-based and other layouts, The "XMonad.Layout.Groups.Helpers" -- module provides actions that can work correctly with both, defined using -- functions from "XMonad.Actions.MessageFeedback". -- | Create a 'Groups' layout. -- -- Note that the second parameter (the layout for arranging the -- groups) is not used on 'Windows', but on 'Group's. For this -- reason, you can only use layouts that don't specifically -- need to manage 'Window's. This is obvious, when you think -- about it. group :: l Window -> l2 (Group l Window) -> Groups l l2 Window group :: forall (l :: * -> *) (l2 :: * -> *). l Window -> l2 (Group l Window) -> Groups l l2 Window group l Window l l2 (Group l Window) l2 = l Window -> l2 (Group l Window) -> Stack (Group l Window) -> Uniq -> Groups l l2 Window forall (l :: * -> *) (l2 :: * -> *) a. l a -> l2 (Group l a) -> Stack (Group l a) -> Uniq -> Groups l l2 a Groups l Window l l2 (Group l Window) l2 Stack (Group l Window) startingGroups (Integer -> Integer -> Uniq U Integer 1 Integer 0) where startingGroups :: Stack (Group l Window) startingGroups = Maybe (Stack (Group l Window)) -> Stack (Group l Window) forall a. HasCallStack => Maybe a -> a fromJust (Maybe (Stack (Group l Window)) -> Stack (Group l Window)) -> Maybe (Stack (Group l Window)) -> Stack (Group l Window) forall a b. (a -> b) -> a -> b $ Group l Window -> Maybe (Stack (Group l Window)) forall a. a -> Zipper a singletonZ (Group l Window -> Maybe (Stack (Group l Window))) -> Group l Window -> Maybe (Stack (Group l Window)) forall a b. (a -> b) -> a -> b $ WithID l Window -> Zipper Window -> Group l Window forall (l :: * -> *) a. WithID l a -> Zipper a -> Group l a G (Uniq -> l Window -> WithID l Window forall (l :: * -> *) a. Uniq -> l a -> WithID l a ID (Integer -> Integer -> Uniq U Integer 0 Integer 0) l Window l) Zipper Window forall a. Zipper a emptyZ -- * Stuff with unique keys data Uniq = U Integer Integer deriving (Uniq -> Uniq -> Bool (Uniq -> Uniq -> Bool) -> (Uniq -> Uniq -> Bool) -> Eq Uniq forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a $c== :: Uniq -> Uniq -> Bool == :: Uniq -> Uniq -> Bool $c/= :: Uniq -> Uniq -> Bool /= :: Uniq -> Uniq -> Bool Eq, Int -> Uniq -> ShowS [Uniq] -> ShowS Uniq -> String (Int -> Uniq -> ShowS) -> (Uniq -> String) -> ([Uniq] -> ShowS) -> Show Uniq forall a. (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a $cshowsPrec :: Int -> Uniq -> ShowS showsPrec :: Int -> Uniq -> ShowS $cshow :: Uniq -> String show :: Uniq -> String $cshowList :: [Uniq] -> ShowS showList :: [Uniq] -> ShowS Show, ReadPrec [Uniq] ReadPrec Uniq Int -> ReadS Uniq ReadS [Uniq] (Int -> ReadS Uniq) -> ReadS [Uniq] -> ReadPrec Uniq -> ReadPrec [Uniq] -> Read Uniq forall a. (Int -> ReadS a) -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a $creadsPrec :: Int -> ReadS Uniq readsPrec :: Int -> ReadS Uniq $creadList :: ReadS [Uniq] readList :: ReadS [Uniq] $creadPrec :: ReadPrec Uniq readPrec :: ReadPrec Uniq $creadListPrec :: ReadPrec [Uniq] readListPrec :: ReadPrec [Uniq] Read) -- | From a seed, generate an infinite list of keys and a new -- seed. All keys generated with this method will be different -- provided you don't use 'gen' again with a key from the list. -- (if you need to do that, see 'split' instead) gen :: Uniq -> (Uniq, Stream Uniq) gen :: Uniq -> (Uniq, Stream Uniq) gen (U Integer i1 Integer i2) = (Integer -> Integer -> Uniq U (Integer i1Integer -> Integer -> Integer forall a. Num a => a -> a -> a +Integer 1) Integer i2, (Integer -> Uniq) -> Stream Integer -> Stream Uniq forall a b. (a -> b) -> Stream a -> Stream b forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap (Integer -> Integer -> Uniq U Integer i1) ([Item (Stream Integer)] -> Stream Integer forall l. IsList l => [Item l] -> l fromList [Integer Item (Stream Integer) i2..])) -- | Split an infinite list into two. I ended up not -- needing this, but let's keep it just in case. -- split :: [a] -> ([a], [a]) -- split as = snd $ foldr step (True, ([], [])) as -- where step a (True, (as1, as2)) = (False, (a:as1, as2)) -- step a (False, (as1, as2)) = (True, (as1, a:as2)) -- | Add a unique identity to a layout so we can -- follow it around. data WithID l a = ID { forall (l :: * -> *) a. WithID l a -> Uniq getID :: Uniq , forall (l :: * -> *) a. WithID l a -> l a unID :: l a} deriving (Int -> WithID l a -> ShowS [WithID l a] -> ShowS WithID l a -> String (Int -> WithID l a -> ShowS) -> (WithID l a -> String) -> ([WithID l a] -> ShowS) -> Show (WithID l a) forall a. (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a forall (l :: * -> *) a. Show (l a) => Int -> WithID l a -> ShowS forall (l :: * -> *) a. Show (l a) => [WithID l a] -> ShowS forall (l :: * -> *) a. Show (l a) => WithID l a -> String $cshowsPrec :: forall (l :: * -> *) a. Show (l a) => Int -> WithID l a -> ShowS showsPrec :: Int -> WithID l a -> ShowS $cshow :: forall (l :: * -> *) a. Show (l a) => WithID l a -> String show :: WithID l a -> String $cshowList :: forall (l :: * -> *) a. Show (l a) => [WithID l a] -> ShowS showList :: [WithID l a] -> ShowS Show, ReadPrec [WithID l a] ReadPrec (WithID l a) Int -> ReadS (WithID l a) ReadS [WithID l a] (Int -> ReadS (WithID l a)) -> ReadS [WithID l a] -> ReadPrec (WithID l a) -> ReadPrec [WithID l a] -> Read (WithID l a) forall a. (Int -> ReadS a) -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a forall (l :: * -> *) a. Read (l a) => ReadPrec [WithID l a] forall (l :: * -> *) a. Read (l a) => ReadPrec (WithID l a) forall (l :: * -> *) a. Read (l a) => Int -> ReadS (WithID l a) forall (l :: * -> *) a. Read (l a) => ReadS [WithID l a] $creadsPrec :: forall (l :: * -> *) a. Read (l a) => Int -> ReadS (WithID l a) readsPrec :: Int -> ReadS (WithID l a) $creadList :: forall (l :: * -> *) a. Read (l a) => ReadS [WithID l a] readList :: ReadS [WithID l a] $creadPrec :: forall (l :: * -> *) a. Read (l a) => ReadPrec (WithID l a) readPrec :: ReadPrec (WithID l a) $creadListPrec :: forall (l :: * -> *) a. Read (l a) => ReadPrec [WithID l a] readListPrec :: ReadPrec [WithID l a] Read) -- | Compare the ids of two 'WithID' values sameID :: WithID l a -> WithID l a -> Bool sameID :: forall (l :: * -> *) a. WithID l a -> WithID l a -> Bool sameID (ID Uniq id1 l a _) (ID Uniq id2 l a _) = Uniq id1 Uniq -> Uniq -> Bool forall a. Eq a => a -> a -> Bool == Uniq id2 instance Eq (WithID l a) where ID Uniq id1 l a _ == :: WithID l a -> WithID l a -> Bool == ID Uniq id2 l a _ = Uniq id1 Uniq -> Uniq -> Bool forall a. Eq a => a -> a -> Bool == Uniq id2 instance LayoutClass l a => LayoutClass (WithID l) a where runLayout :: Workspace String (WithID l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (WithID l a)) runLayout ws :: Workspace String (WithID l a) a ws@W.Workspace { layout :: forall i l a. Workspace i l a -> l W.layout = ID Uniq id l a l } Rectangle r = do ([(a, Rectangle)] placements, Maybe (l a) ml') <- Workspace String (l a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (l a)) forall (layout :: * -> *) a. LayoutClass layout a => Workspace String (layout a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (layout a)) runLayout Workspace String (WithID l a) a ws{ W.layout = l} Rectangle r ([(a, Rectangle)], Maybe (WithID l a)) -> X ([(a, Rectangle)], Maybe (WithID l a)) forall a. a -> X a forall (m :: * -> *) a. Monad m => a -> m a return ([(a, Rectangle)] placements, Uniq -> l a -> WithID l a forall (l :: * -> *) a. Uniq -> l a -> WithID l a ID Uniq id (l a -> WithID l a) -> Maybe (l a) -> Maybe (WithID l a) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Maybe (l a) ml') handleMessage :: WithID l a -> SomeMessage -> X (Maybe (WithID l a)) handleMessage (ID Uniq id l a l) SomeMessage sm = do Maybe (l a) ml' <- l a -> SomeMessage -> X (Maybe (l a)) forall (layout :: * -> *) a. LayoutClass layout a => layout a -> SomeMessage -> X (Maybe (layout a)) handleMessage l a l SomeMessage sm Maybe (WithID l a) -> X (Maybe (WithID l a)) forall a. a -> X a forall (m :: * -> *) a. Monad m => a -> m a return (Maybe (WithID l a) -> X (Maybe (WithID l a))) -> Maybe (WithID l a) -> X (Maybe (WithID l a)) forall a b. (a -> b) -> a -> b $ Uniq -> l a -> WithID l a forall (l :: * -> *) a. Uniq -> l a -> WithID l a ID Uniq id (l a -> WithID l a) -> Maybe (l a) -> Maybe (WithID l a) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> Maybe (l a) ml' description :: WithID l a -> String description (ID Uniq _ l a l) = l a -> String forall (layout :: * -> *) a. LayoutClass layout a => layout a -> String description l a l -- * The 'Groups' layout -- ** Datatypes -- | A group of windows and its layout algorithm. data Group l a = G { forall (l :: * -> *) a. Group l a -> WithID l a gLayout :: WithID l a , forall (l :: * -> *) a. Group l a -> Zipper a gZipper :: Zipper a } deriving (Int -> Group l a -> ShowS [Group l a] -> ShowS Group l a -> String (Int -> Group l a -> ShowS) -> (Group l a -> String) -> ([Group l a] -> ShowS) -> Show (Group l a) forall a. (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a forall (l :: * -> *) a. (Show a, Show (l a)) => Int -> Group l a -> ShowS forall (l :: * -> *) a. (Show a, Show (l a)) => [Group l a] -> ShowS forall (l :: * -> *) a. (Show a, Show (l a)) => Group l a -> String $cshowsPrec :: forall (l :: * -> *) a. (Show a, Show (l a)) => Int -> Group l a -> ShowS showsPrec :: Int -> Group l a -> ShowS $cshow :: forall (l :: * -> *) a. (Show a, Show (l a)) => Group l a -> String show :: Group l a -> String $cshowList :: forall (l :: * -> *) a. (Show a, Show (l a)) => [Group l a] -> ShowS showList :: [Group l a] -> ShowS Show, ReadPrec [Group l a] ReadPrec (Group l a) Int -> ReadS (Group l a) ReadS [Group l a] (Int -> ReadS (Group l a)) -> ReadS [Group l a] -> ReadPrec (Group l a) -> ReadPrec [Group l a] -> Read (Group l a) forall a. (Int -> ReadS a) -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a forall (l :: * -> *) a. (Read a, Read (l a)) => ReadPrec [Group l a] forall (l :: * -> *) a. (Read a, Read (l a)) => ReadPrec (Group l a) forall (l :: * -> *) a. (Read a, Read (l a)) => Int -> ReadS (Group l a) forall (l :: * -> *) a. (Read a, Read (l a)) => ReadS [Group l a] $creadsPrec :: forall (l :: * -> *) a. (Read a, Read (l a)) => Int -> ReadS (Group l a) readsPrec :: Int -> ReadS (Group l a) $creadList :: forall (l :: * -> *) a. (Read a, Read (l a)) => ReadS [Group l a] readList :: ReadS [Group l a] $creadPrec :: forall (l :: * -> *) a. (Read a, Read (l a)) => ReadPrec (Group l a) readPrec :: ReadPrec (Group l a) $creadListPrec :: forall (l :: * -> *) a. (Read a, Read (l a)) => ReadPrec [Group l a] readListPrec :: ReadPrec [Group l a] Read, Group l a -> Group l a -> Bool (Group l a -> Group l a -> Bool) -> (Group l a -> Group l a -> Bool) -> Eq (Group l a) forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a forall (l :: * -> *) a. Eq a => Group l a -> Group l a -> Bool $c== :: forall (l :: * -> *) a. Eq a => Group l a -> Group l a -> Bool == :: Group l a -> Group l a -> Bool $c/= :: forall (l :: * -> *) a. Eq a => Group l a -> Group l a -> Bool /= :: Group l a -> Group l a -> Bool Eq) onLayout :: (WithID l a -> WithID l a) -> Group l a -> Group l a onLayout :: forall (l :: * -> *) a. (WithID l a -> WithID l a) -> Group l a -> Group l a onLayout WithID l a -> WithID l a f Group l a g = Group l a g { gLayout = f $ gLayout g } onZipper :: (Zipper a -> Zipper a) -> Group l a -> Group l a onZipper :: forall a (l :: * -> *). (Zipper a -> Zipper a) -> Group l a -> Group l a onZipper Zipper a -> Zipper a f Group l a g = Group l a g { gZipper = f $ gZipper g } -- | The type of our layouts. data Groups l l2 a = Groups { -- | The starting layout for new groups forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> l a baseLayout :: l a -- | The layout for placing each group on the screen , forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> l2 (Group l a) partitioner :: l2 (Group l a) -- | The window groups , forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Stack (Group l a) groups :: W.Stack (Group l a) -- | A seed for generating unique ids , forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Uniq seed :: Uniq } deriving instance (Show a, Show (l a), Show (l2 (Group l a))) => Show (Groups l l2 a) deriving instance (Read a, Read (l a), Read (l2 (Group l a))) => Read (Groups l l2 a) -- | Messages accepted by 'Groups'-based layouts. -- All other messages are forwarded to the layout of the currently -- focused subgroup (as if they had been wrapped in 'ToFocused'). data GroupsMessage = ToEnclosing SomeMessage -- ^ Send a message to the enclosing layout -- (the one that places the groups themselves) | ToGroup Int SomeMessage -- ^ Send a message to the layout for nth group -- (starting at 0) | ToFocused SomeMessage -- ^ Send a message to the layout for the focused -- group | ToAll SomeMessage -- ^ Send a message to all the sub-layouts | Refocus -- ^ Refocus the window which should be focused according -- to the layout. | Modify ModifySpec -- ^ Modify the ordering\/grouping\/focusing -- of windows according to a 'ModifySpec' | ModifyX ModifySpecX -- ^ Same as 'Modify', but within the 'X' monad instance Show GroupsMessage where show :: GroupsMessage -> String show (ToEnclosing SomeMessage _) = String "ToEnclosing {...}" show (ToGroup Int i SomeMessage _) = String "ToGroup "String -> ShowS forall a. [a] -> [a] -> [a] ++Int -> String forall a. Show a => a -> String show Int iString -> ShowS forall a. [a] -> [a] -> [a] ++String " {...}" show (ToFocused SomeMessage _) = String "ToFocused {...}" show (ToAll SomeMessage _) = String "ToAll {...}" show GroupsMessage Refocus = String "Refocus" show (Modify ModifySpec _) = String "Modify {...}" show (ModifyX ModifySpecX _) = String "ModifyX {...}" instance Message GroupsMessage modifyGroups :: (Zipper (Group l a) -> Zipper (Group l a)) -> Groups l l2 a -> Groups l l2 a modifyGroups :: forall (l :: * -> *) a (l2 :: * -> *). (Zipper (Group l a) -> Zipper (Group l a)) -> Groups l l2 a -> Groups l l2 a modifyGroups Zipper (Group l a) -> Zipper (Group l a) f Groups l l2 a g = let (Uniq seed', Uniq ident :~ Stream Uniq _) = Uniq -> (Uniq, Stream Uniq) gen (Groups l l2 a -> Uniq forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Uniq seed Groups l l2 a g) defaultGroups :: Stack (Group l a) defaultGroups = Zipper (Group l a) -> Stack (Group l a) forall a. HasCallStack => Maybe a -> a fromJust (Zipper (Group l a) -> Stack (Group l a)) -> Zipper (Group l a) -> Stack (Group l a) forall a b. (a -> b) -> a -> b $ Group l a -> Zipper (Group l a) forall a. a -> Zipper a singletonZ (Group l a -> Zipper (Group l a)) -> Group l a -> Zipper (Group l a) forall a b. (a -> b) -> a -> b $ WithID l a -> Zipper a -> Group l a forall (l :: * -> *) a. WithID l a -> Zipper a -> Group l a G (Uniq -> l a -> WithID l a forall (l :: * -> *) a. Uniq -> l a -> WithID l a ID Uniq ident (l a -> WithID l a) -> l a -> WithID l a forall a b. (a -> b) -> a -> b $ Groups l l2 a -> l a forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> l a baseLayout Groups l l2 a g) Zipper a forall a. Zipper a emptyZ in Groups l l2 a g { groups = fromMaybe defaultGroups . f . Just $ groups g , seed = seed' } modifyGroupsX :: (Zipper (Group l a) -> X (Zipper (Group l a))) -> Groups l l2 a -> X (Groups l l2 a) modifyGroupsX :: forall (l :: * -> *) a (l2 :: * -> *). (Zipper (Group l a) -> X (Zipper (Group l a))) -> Groups l l2 a -> X (Groups l l2 a) modifyGroupsX Zipper (Group l a) -> X (Zipper (Group l a)) f Groups l l2 a g = do let (Uniq seed', Uniq ident :~ Stream Uniq _) = Uniq -> (Uniq, Stream Uniq) gen (Groups l l2 a -> Uniq forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Uniq seed Groups l l2 a g) defaultGroups :: Stack (Group l a) defaultGroups = Zipper (Group l a) -> Stack (Group l a) forall a. HasCallStack => Maybe a -> a fromJust (Zipper (Group l a) -> Stack (Group l a)) -> Zipper (Group l a) -> Stack (Group l a) forall a b. (a -> b) -> a -> b $ Group l a -> Zipper (Group l a) forall a. a -> Zipper a singletonZ (Group l a -> Zipper (Group l a)) -> Group l a -> Zipper (Group l a) forall a b. (a -> b) -> a -> b $ WithID l a -> Zipper a -> Group l a forall (l :: * -> *) a. WithID l a -> Zipper a -> Group l a G (Uniq -> l a -> WithID l a forall (l :: * -> *) a. Uniq -> l a -> WithID l a ID Uniq ident (l a -> WithID l a) -> l a -> WithID l a forall a b. (a -> b) -> a -> b $ Groups l l2 a -> l a forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> l a baseLayout Groups l l2 a g) Zipper a forall a. Zipper a emptyZ Zipper (Group l a) g' <- Zipper (Group l a) -> X (Zipper (Group l a)) f (Zipper (Group l a) -> X (Zipper (Group l a))) -> (Stack (Group l a) -> Zipper (Group l a)) -> Stack (Group l a) -> X (Zipper (Group l a)) forall b c a. (b -> c) -> (a -> b) -> a -> c . Stack (Group l a) -> Zipper (Group l a) forall a. a -> Maybe a Just (Stack (Group l a) -> X (Zipper (Group l a))) -> Stack (Group l a) -> X (Zipper (Group l a)) forall a b. (a -> b) -> a -> b $ Groups l l2 a -> Stack (Group l a) forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Stack (Group l a) groups Groups l l2 a g Groups l l2 a -> X (Groups l l2 a) forall a. a -> X a forall (m :: * -> *) a. Monad m => a -> m a return Groups l l2 a g { groups = fromMaybe defaultGroups g', seed = seed' } -- ** Readaptation -- | Adapt our groups to a new stack. -- This algorithm handles window additions and deletions correctly, -- ignores changes in window ordering, and tries to react to any -- other stack changes as gracefully as possible. readapt :: Eq a => Zipper a -> Groups l l2 a -> Groups l l2 a readapt :: forall a (l :: * -> *) (l2 :: * -> *). Eq a => Zipper a -> Groups l l2 a -> Groups l l2 a readapt Zipper a z Groups l l2 a g = let mf :: Maybe a mf = Zipper a -> Maybe a forall a. Zipper a -> Maybe a getFocusZ Zipper a z (Uniq seed', Uniq ident :~ Stream Uniq _) = Uniq -> (Uniq, Stream Uniq) gen (Uniq -> (Uniq, Stream Uniq)) -> Uniq -> (Uniq, Stream Uniq) forall a b. (a -> b) -> a -> b $ Groups l l2 a -> Uniq forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Uniq seed Groups l l2 a g g' :: Groups l l2 a g' = Groups l l2 a g { seed = seed' } in ((Zipper (Group l a) -> Zipper (Group l a)) -> Groups l l2 a -> Groups l l2 a) -> Groups l l2 a -> (Zipper (Group l a) -> Zipper (Group l a)) -> Groups l l2 a forall a b c. (a -> b -> c) -> b -> a -> c flip (Zipper (Group l a) -> Zipper (Group l a)) -> Groups l l2 a -> Groups l l2 a forall (l :: * -> *) a (l2 :: * -> *). (Zipper (Group l a) -> Zipper (Group l a)) -> Groups l l2 a -> Groups l l2 a modifyGroups Groups l l2 a g' ((Zipper (Group l a) -> Zipper (Group l a)) -> Groups l l2 a) -> (Zipper (Group l a) -> Zipper (Group l a)) -> Groups l l2 a forall a b. (a -> b) -> a -> b $ (Group l a -> Group l a) -> Zipper (Group l a) -> Zipper (Group l a) forall a b. (a -> b) -> Zipper a -> Zipper b mapZ_ ((Zipper a -> Zipper a) -> Group l a -> Group l a forall a (l :: * -> *). (Zipper a -> Zipper a) -> Group l a -> Group l a onZipper ((Zipper a -> Zipper a) -> Group l a -> Group l a) -> (Zipper a -> Zipper a) -> Group l a -> Group l a forall a b. (a -> b) -> a -> b $ Zipper a -> Zipper a -> Zipper a forall a. Eq a => Zipper a -> Zipper a -> Zipper a removeDeleted Zipper a z) (Zipper (Group l a) -> Zipper (Group l a)) -> (Zipper (Group l a) -> Zipper (Group l a)) -> Zipper (Group l a) -> Zipper (Group l a) forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c >>> (Group l a -> Bool) -> Zipper (Group l a) -> Zipper (Group l a) forall {a}. (a -> Bool) -> Maybe (Stack a) -> Maybe (Stack a) filterKeepLast (Zipper a -> Bool forall a. Maybe a -> Bool isJust (Zipper a -> Bool) -> (Group l a -> Zipper a) -> Group l a -> Bool forall b c a. (b -> c) -> (a -> b) -> a -> c . Group l a -> Zipper a forall (l :: * -> *) a. Group l a -> Zipper a gZipper) (Zipper (Group l a) -> Zipper (Group l a)) -> (Zipper (Group l a) -> Zipper (Group l a)) -> Zipper (Group l a) -> Zipper (Group l a) forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c >>> [a] -> Zipper (Group l a) -> (Zipper (Group l a), [a]) forall a (l :: * -> *). Eq a => [a] -> Zipper (Group l a) -> (Zipper (Group l a), [a]) findNewWindows (Zipper a -> [a] forall a. Maybe (Stack a) -> [a] W.integrate' Zipper a z) (Zipper (Group l a) -> (Zipper (Group l a), [a])) -> ((Zipper (Group l a), [a]) -> Zipper (Group l a)) -> Zipper (Group l a) -> Zipper (Group l a) forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c >>> WithID l a -> (Zipper (Group l a), [a]) -> Zipper (Group l a) forall (l :: * -> *) a. WithID l a -> (Zipper (Group l a), [a]) -> Zipper (Group l a) addWindows (Uniq -> l a -> WithID l a forall (l :: * -> *) a. Uniq -> l a -> WithID l a ID Uniq ident (l a -> WithID l a) -> l a -> WithID l a forall a b. (a -> b) -> a -> b $ Groups l l2 a -> l a forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> l a baseLayout Groups l l2 a g) ((Zipper (Group l a), [a]) -> Zipper (Group l a)) -> (Zipper (Group l a) -> Zipper (Group l a)) -> (Zipper (Group l a), [a]) -> Zipper (Group l a) forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c >>> Maybe a -> Zipper (Group l a) -> Zipper (Group l a) forall a (l :: * -> *). Eq a => Maybe a -> Zipper (Group l a) -> Zipper (Group l a) focusGroup Maybe a mf (Zipper (Group l a) -> Zipper (Group l a)) -> (Zipper (Group l a) -> Zipper (Group l a)) -> Zipper (Group l a) -> Zipper (Group l a) forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c >>> (Group l a -> Group l a) -> Zipper (Group l a) -> Zipper (Group l a) forall a. (a -> a) -> Zipper a -> Zipper a onFocusedZ ((Zipper a -> Zipper a) -> Group l a -> Group l a forall a (l :: * -> *). (Zipper a -> Zipper a) -> Group l a -> Group l a onZipper ((Zipper a -> Zipper a) -> Group l a -> Group l a) -> (Zipper a -> Zipper a) -> Group l a -> Group l a forall a b. (a -> b) -> a -> b $ Maybe a -> Zipper a -> Zipper a forall a. Eq a => Maybe a -> Zipper a -> Zipper a focusWindow Maybe a mf) where filterKeepLast :: (a -> Bool) -> Maybe (Stack a) -> Maybe (Stack a) filterKeepLast a -> Bool _ Maybe (Stack a) Nothing = Maybe (Stack a) forall a. Maybe a Nothing filterKeepLast a -> Bool f z :: Maybe (Stack a) z@(Just Stack a s) = (a -> Bool) -> Maybe (Stack a) -> Maybe (Stack a) forall {a}. (a -> Bool) -> Maybe (Stack a) -> Maybe (Stack a) filterZ_ a -> Bool f Maybe (Stack a) z Maybe (Stack a) -> Maybe (Stack a) -> Maybe (Stack a) forall a. Maybe a -> Maybe a -> Maybe a forall (f :: * -> *) a. Alternative f => f a -> f a -> f a <|> a -> Maybe (Stack a) forall a. a -> Zipper a singletonZ (Stack a -> a forall a. Stack a -> a W.focus Stack a s) -- | Remove the windows from a group which are no longer present in -- the stack. removeDeleted :: Eq a => Zipper a -> Zipper a -> Zipper a removeDeleted :: forall a. Eq a => Zipper a -> Zipper a -> Zipper a removeDeleted Zipper a z = (a -> Bool) -> Zipper a -> Zipper a forall {a}. (a -> Bool) -> Maybe (Stack a) -> Maybe (Stack a) filterZ_ (a -> Zipper a -> Bool forall a. Eq a => a -> Zipper a -> Bool `elemZ` Zipper a z) -- | Identify the windows not already in a group. findNewWindows :: Eq a => [a] -> Zipper (Group l a) -> (Zipper (Group l a), [a]) findNewWindows :: forall a (l :: * -> *). Eq a => [a] -> Zipper (Group l a) -> (Zipper (Group l a), [a]) findNewWindows [a] as Zipper (Group l a) gs = (Zipper (Group l a) gs, (Group l a -> [a] -> [a]) -> [a] -> Zipper (Group l a) -> [a] forall a b. (a -> b -> b) -> b -> Zipper a -> b foldrZ_ Group l a -> [a] -> [a] forall {a} {l :: * -> *}. Eq a => Group l a -> [a] -> [a] removePresent [a] as Zipper (Group l a) gs) where removePresent :: Group l a -> [a] -> [a] removePresent Group l a g = (a -> Bool) -> [a] -> [a] forall a. (a -> Bool) -> [a] -> [a] filter (Bool -> Bool not (Bool -> Bool) -> (a -> Bool) -> a -> Bool forall b c a. (b -> c) -> (a -> b) -> a -> c . (a -> Zipper a -> Bool) -> Zipper a -> a -> Bool forall a b c. (a -> b -> c) -> b -> a -> c flip a -> Zipper a -> Bool forall a. Eq a => a -> Zipper a -> Bool elemZ (Group l a -> Zipper a forall (l :: * -> *) a. Group l a -> Zipper a gZipper Group l a g)) -- | Add windows to the focused group. If you need to create one, -- use the given layout and an id from the given list. addWindows :: WithID l a -> (Zipper (Group l a), [a]) -> Zipper (Group l a) addWindows :: forall (l :: * -> *) a. WithID l a -> (Zipper (Group l a), [a]) -> Zipper (Group l a) addWindows WithID l a l (Zipper (Group l a) Nothing, [a] as) = Group l a -> Zipper (Group l a) forall a. a -> Zipper a singletonZ (Group l a -> Zipper (Group l a)) -> Group l a -> Zipper (Group l a) forall a b. (a -> b) -> a -> b $ WithID l a -> Zipper a -> Group l a forall (l :: * -> *) a. WithID l a -> Zipper a -> Group l a G WithID l a l ([a] -> Zipper a forall a. [a] -> Maybe (Stack a) W.differentiate [a] as) addWindows WithID l a _ (Zipper (Group l a) z, [a] as) = (Group l a -> Group l a) -> Zipper (Group l a) -> Zipper (Group l a) forall a. (a -> a) -> Zipper a -> Zipper a onFocusedZ ((Zipper a -> Zipper a) -> Group l a -> Group l a forall a (l :: * -> *). (Zipper a -> Zipper a) -> Group l a -> Group l a onZipper Zipper a -> Zipper a add) Zipper (Group l a) z where add :: Zipper a -> Zipper a add Zipper a z = (Zipper a -> a -> Zipper a) -> Zipper a -> [a] -> Zipper a forall b a. (b -> a -> b) -> b -> [a] -> b forall (t :: * -> *) b a. Foldable t => (b -> a -> b) -> b -> t a -> b foldl ((a -> Zipper a -> Zipper a) -> Zipper a -> a -> Zipper a forall a b c. (a -> b -> c) -> b -> a -> c flip a -> Zipper a -> Zipper a forall a. a -> Zipper a -> Zipper a insertUpZ) Zipper a z [a] as -- | Focus the group containing the given window focusGroup :: Eq a => Maybe a -> Zipper (Group l a) -> Zipper (Group l a) focusGroup :: forall a (l :: * -> *). Eq a => Maybe a -> Zipper (Group l a) -> Zipper (Group l a) focusGroup Maybe a Nothing = Zipper (Group l a) -> Zipper (Group l a) forall a. a -> a id focusGroup (Just a a) = [Either (Group l a) (Group l a)] -> Zipper (Group l a) forall a. [Either a a] -> Zipper a fromTags ([Either (Group l a) (Group l a)] -> Zipper (Group l a)) -> (Zipper (Group l a) -> [Either (Group l a) (Group l a)]) -> Zipper (Group l a) -> Zipper (Group l a) forall b c a. (b -> c) -> (a -> b) -> a -> c . (Group l a -> Either (Group l a) (Group l a)) -> [Group l a] -> [Either (Group l a) (Group l a)] forall a b. (a -> b) -> [a] -> [b] map ((Group l a -> Bool) -> Group l a -> Either (Group l a) (Group l a) forall a. (a -> Bool) -> a -> Either a a tagBy ((Group l a -> Bool) -> Group l a -> Either (Group l a) (Group l a)) -> (Group l a -> Bool) -> Group l a -> Either (Group l a) (Group l a) forall a b. (a -> b) -> a -> b $ a -> Zipper a -> Bool forall a. Eq a => a -> Zipper a -> Bool elemZ a a (Zipper a -> Bool) -> (Group l a -> Zipper a) -> Group l a -> Bool forall b c a. (b -> c) -> (a -> b) -> a -> c . Group l a -> Zipper a forall (l :: * -> *) a. Group l a -> Zipper a gZipper) ([Group l a] -> [Either (Group l a) (Group l a)]) -> (Zipper (Group l a) -> [Group l a]) -> Zipper (Group l a) -> [Either (Group l a) (Group l a)] forall b c a. (b -> c) -> (a -> b) -> a -> c . Zipper (Group l a) -> [Group l a] forall a. Maybe (Stack a) -> [a] W.integrate' -- | Focus the given window focusWindow :: Eq a => Maybe a -> Zipper a -> Zipper a focusWindow :: forall a. Eq a => Maybe a -> Zipper a -> Zipper a focusWindow Maybe a Nothing = Zipper a -> Zipper a forall a. a -> a id focusWindow (Just a a) = [Either a a] -> Zipper a forall a. [Either a a] -> Zipper a fromTags ([Either a a] -> Zipper a) -> (Zipper a -> [Either a a]) -> Zipper a -> Zipper a forall b c a. (b -> c) -> (a -> b) -> a -> c . (a -> Either a a) -> [a] -> [Either a a] forall a b. (a -> b) -> [a] -> [b] map ((a -> Bool) -> a -> Either a a forall a. (a -> Bool) -> a -> Either a a tagBy (a -> a -> Bool forall a. Eq a => a -> a -> Bool ==a a)) ([a] -> [Either a a]) -> (Zipper a -> [a]) -> Zipper a -> [Either a a] forall b c a. (b -> c) -> (a -> b) -> a -> c . Zipper a -> [a] forall a. Maybe (Stack a) -> [a] W.integrate' -- * Interface -- ** Layout instance instance (LayoutClass l Window, LayoutClass l2 (Group l Window)) => LayoutClass (Groups l l2) Window where description :: Groups l l2 Window -> String description (Groups l Window _ l2 (Group l Window) p Stack (Group l Window) gs Uniq _) = String s1String -> ShowS forall a. [a] -> [a] -> [a] ++String " by "String -> ShowS forall a. [a] -> [a] -> [a] ++String s2 where s1 :: String s1 = WithID l Window -> String forall (layout :: * -> *) a. LayoutClass layout a => layout a -> String description (WithID l Window -> String) -> WithID l Window -> String forall a b. (a -> b) -> a -> b $ Group l Window -> WithID l Window forall (l :: * -> *) a. Group l a -> WithID l a gLayout (Group l Window -> WithID l Window) -> Group l Window -> WithID l Window forall a b. (a -> b) -> a -> b $ Stack (Group l Window) -> Group l Window forall a. Stack a -> a W.focus Stack (Group l Window) gs s2 :: String s2 = l2 (Group l Window) -> String forall (layout :: * -> *) a. LayoutClass layout a => layout a -> String description l2 (Group l Window) p runLayout :: Workspace String (Groups l l2 Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (Groups l l2 Window)) runLayout ws :: Workspace String (Groups l l2 Window) Window ws@(W.Workspace String _ Groups l l2 Window _l Zipper Window z) Rectangle r = let l :: Groups l l2 Window l = Zipper Window -> Groups l l2 Window -> Groups l l2 Window forall a (l :: * -> *) (l2 :: * -> *). Eq a => Zipper a -> Groups l l2 a -> Groups l l2 a readapt Zipper Window z Groups l l2 Window _l in do ([(Group l Window, Rectangle)] areas, Maybe (l2 (Group l Window)) mpart') <- Workspace String (l2 (Group l Window)) (Group l Window) -> Rectangle -> X ([(Group l Window, Rectangle)], Maybe (l2 (Group l Window))) forall (layout :: * -> *) a. LayoutClass layout a => Workspace String (layout a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (layout a)) runLayout Workspace String (Groups l l2 Window) Window ws { W.layout = partitioner l , W.stack = Just $ groups l } Rectangle r [([(Window, Rectangle)], Maybe (WithID l Window))] results <- [(Group l Window, Rectangle)] -> ((Group l Window, Rectangle) -> X ([(Window, Rectangle)], Maybe (WithID l Window))) -> X [([(Window, Rectangle)], Maybe (WithID l Window))] forall (t :: * -> *) (m :: * -> *) a b. (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b) forM [(Group l Window, Rectangle)] areas (((Group l Window, Rectangle) -> X ([(Window, Rectangle)], Maybe (WithID l Window))) -> X [([(Window, Rectangle)], Maybe (WithID l Window))]) -> ((Group l Window, Rectangle) -> X ([(Window, Rectangle)], Maybe (WithID l Window))) -> X [([(Window, Rectangle)], Maybe (WithID l Window))] forall a b. (a -> b) -> a -> b $ \(Group l Window g, Rectangle r') -> Workspace String (WithID l Window) Window -> Rectangle -> X ([(Window, Rectangle)], Maybe (WithID l Window)) forall (layout :: * -> *) a. LayoutClass layout a => Workspace String (layout a) a -> Rectangle -> X ([(a, Rectangle)], Maybe (layout a)) runLayout Workspace String (Groups l l2 Window) Window ws { W.layout = gLayout g , W.stack = gZipper g } Rectangle r' let hidden :: [WithID l Window] hidden = (Group l Window -> WithID l Window) -> [Group l Window] -> [WithID l Window] forall a b. (a -> b) -> [a] -> [b] map Group l Window -> WithID l Window forall (l :: * -> *) a. Group l a -> WithID l a gLayout (Stack (Group l Window) -> [Group l Window] forall a. Stack a -> [a] W.integrate (Stack (Group l Window) -> [Group l Window]) -> Stack (Group l Window) -> [Group l Window] forall a b. (a -> b) -> a -> b $ Groups l l2 Window -> Stack (Group l Window) forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Stack (Group l a) groups Groups l l2 Window _l) [WithID l Window] -> [WithID l Window] -> [WithID l Window] forall a. Eq a => [a] -> [a] -> [a] \\ ((Group l Window, Rectangle) -> WithID l Window) -> [(Group l Window, Rectangle)] -> [WithID l Window] forall a b. (a -> b) -> [a] -> [b] map (Group l Window -> WithID l Window forall (l :: * -> *) a. Group l a -> WithID l a gLayout (Group l Window -> WithID l Window) -> ((Group l Window, Rectangle) -> Group l Window) -> (Group l Window, Rectangle) -> WithID l Window forall b c a. (b -> c) -> (a -> b) -> a -> c . (Group l Window, Rectangle) -> Group l Window forall a b. (a, b) -> a fst) [(Group l Window, Rectangle)] areas [Maybe (WithID l Window)] hidden' <- (WithID l Window -> X (Maybe (WithID l Window))) -> [WithID l Window] -> X [Maybe (WithID l Window)] forall (t :: * -> *) (m :: * -> *) a b. (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b) forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b] mapM ((WithID l Window -> SomeMessage -> X (Maybe (WithID l Window))) -> SomeMessage -> WithID l Window -> X (Maybe (WithID l Window)) forall a b c. (a -> b -> c) -> b -> a -> c flip WithID l Window -> SomeMessage -> X (Maybe (WithID l Window)) forall (layout :: * -> *) a. LayoutClass layout a => layout a -> SomeMessage -> X (Maybe (layout a)) handleMessage (SomeMessage -> WithID l Window -> X (Maybe (WithID l Window))) -> SomeMessage -> WithID l Window -> X (Maybe (WithID l Window)) forall a b. (a -> b) -> a -> b $ LayoutMessages -> SomeMessage forall a. Message a => a -> SomeMessage SomeMessage LayoutMessages Hide) [WithID l Window] hidden let placements :: [(Window, Rectangle)] placements = (([(Window, Rectangle)], Maybe (WithID l Window)) -> [(Window, Rectangle)]) -> [([(Window, Rectangle)], Maybe (WithID l Window))] -> [(Window, Rectangle)] forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b] concatMap ([(Window, Rectangle)], Maybe (WithID l Window)) -> [(Window, Rectangle)] forall a b. (a, b) -> a fst [([(Window, Rectangle)], Maybe (WithID l Window))] results newL :: Maybe (Groups l l2 Window) newL = Groups l l2 Window -> Maybe (l2 (Group l Window)) -> [Maybe (WithID l Window)] -> Maybe (Groups l l2 Window) forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Maybe (l2 (Group l a)) -> [Maybe (WithID l a)] -> Maybe (Groups l l2 a) justMakeNew Groups l l2 Window l Maybe (l2 (Group l Window)) mpart' ((([(Window, Rectangle)], Maybe (WithID l Window)) -> Maybe (WithID l Window)) -> [([(Window, Rectangle)], Maybe (WithID l Window))] -> [Maybe (WithID l Window)] forall a b. (a -> b) -> [a] -> [b] map ([(Window, Rectangle)], Maybe (WithID l Window)) -> Maybe (WithID l Window) forall a b. (a, b) -> b snd [([(Window, Rectangle)], Maybe (WithID l Window))] results [Maybe (WithID l Window)] -> [Maybe (WithID l Window)] -> [Maybe (WithID l Window)] forall a. [a] -> [a] -> [a] ++ [Maybe (WithID l Window)] hidden') ([(Window, Rectangle)], Maybe (Groups l l2 Window)) -> X ([(Window, Rectangle)], Maybe (Groups l l2 Window)) forall a. a -> X a forall (m :: * -> *) a. Monad m => a -> m a return ([(Window, Rectangle)] placements, Maybe (Groups l l2 Window) newL) handleMessage :: Groups l l2 Window -> SomeMessage -> X (Maybe (Groups l l2 Window)) handleMessage l :: Groups l l2 Window l@(Groups l Window _ l2 (Group l Window) p Stack (Group l Window) _ Uniq _) SomeMessage sm | Just (ToEnclosing SomeMessage sm') <- SomeMessage -> Maybe GroupsMessage forall m. Message m => SomeMessage -> Maybe m fromMessage SomeMessage sm = do Maybe (l2 (Group l Window)) mp' <- l2 (Group l Window) -> SomeMessage -> X (Maybe (l2 (Group l Window))) forall (layout :: * -> *) a. LayoutClass layout a => layout a -> SomeMessage -> X (Maybe (layout a)) handleMessage l2 (Group l Window) p SomeMessage sm' Maybe (Groups l l2 Window) -> X (Maybe (Groups l l2 Window)) forall a. a -> X a forall (m :: * -> *) a. Monad m => a -> m a return (Maybe (Groups l l2 Window) -> X (Maybe (Groups l l2 Window))) -> Maybe (Groups l l2 Window) -> X (Maybe (Groups l l2 Window)) forall a b. (a -> b) -> a -> b $ Groups l l2 Window -> Maybe (l2 (Group l Window)) -> [Maybe (WithID l Window)] -> Maybe (Groups l l2 Window) forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Maybe (l2 (Group l a)) -> [Maybe (WithID l a)] -> Maybe (Groups l l2 a) maybeMakeNew Groups l l2 Window l Maybe (l2 (Group l Window)) mp' [] handleMessage l :: Groups l l2 Window l@(Groups l Window _ l2 (Group l Window) p Stack (Group l Window) gs Uniq _) SomeMessage sm | Just (ToAll SomeMessage sm') <- SomeMessage -> Maybe GroupsMessage forall m. Message m => SomeMessage -> Maybe m fromMessage SomeMessage sm = do Maybe (l2 (Group l Window)) mp' <- l2 (Group l Window) -> SomeMessage -> X (Maybe (l2 (Group l Window))) forall (layout :: * -> *) a. LayoutClass layout a => layout a -> SomeMessage -> X (Maybe (layout a)) handleMessage l2 (Group l Window) p SomeMessage sm' Zipper (Maybe (WithID l Window)) mg's <- (Group l Window -> X (Maybe (WithID l Window))) -> Maybe (Stack (Group l Window)) -> X (Zipper (Maybe (WithID l Window))) forall (m :: * -> *) a b. Monad m => (a -> m b) -> Zipper a -> m (Zipper b) mapZM_ (SomeMessage -> Group l Window -> X (Maybe (WithID l Window)) forall {l :: * -> *} {a}. LayoutClass l a => SomeMessage -> Group l a -> X (Maybe (WithID l a)) handle SomeMessage sm') (Maybe (Stack (Group l Window)) -> X (Zipper (Maybe (WithID l Window)))) -> Maybe (Stack (Group l Window)) -> X (Zipper (Maybe (WithID l Window))) forall a b. (a -> b) -> a -> b $ Stack (Group l Window) -> Maybe (Stack (Group l Window)) forall a. a -> Maybe a Just Stack (Group l Window) gs Maybe (Groups l l2 Window) -> X (Maybe (Groups l l2 Window)) forall a. a -> X a forall (m :: * -> *) a. Monad m => a -> m a return (Maybe (Groups l l2 Window) -> X (Maybe (Groups l l2 Window))) -> Maybe (Groups l l2 Window) -> X (Maybe (Groups l l2 Window)) forall a b. (a -> b) -> a -> b $ Groups l l2 Window -> Maybe (l2 (Group l Window)) -> [Maybe (WithID l Window)] -> Maybe (Groups l l2 Window) forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Maybe (l2 (Group l a)) -> [Maybe (WithID l a)] -> Maybe (Groups l l2 a) maybeMakeNew Groups l l2 Window l Maybe (l2 (Group l Window)) mp' ([Maybe (WithID l Window)] -> Maybe (Groups l l2 Window)) -> [Maybe (WithID l Window)] -> Maybe (Groups l l2 Window) forall a b. (a -> b) -> a -> b $ Zipper (Maybe (WithID l Window)) -> [Maybe (WithID l Window)] forall a. Maybe (Stack a) -> [a] W.integrate' Zipper (Maybe (WithID l Window)) mg's where handle :: SomeMessage -> Group l a -> X (Maybe (WithID l a)) handle SomeMessage sm (G WithID l a l Zipper a _) = WithID l a -> SomeMessage -> X (Maybe (WithID l a)) forall (layout :: * -> *) a. LayoutClass layout a => layout a -> SomeMessage -> X (Maybe (layout a)) handleMessage WithID l a l SomeMessage sm handleMessage Groups l l2 Window l SomeMessage sm | Just LayoutMessages a <- SomeMessage -> Maybe LayoutMessages forall m. Message m => SomeMessage -> Maybe m fromMessage SomeMessage sm = let _rightType :: Bool _rightType = LayoutMessages a LayoutMessages -> LayoutMessages -> Bool forall a. Eq a => a -> a -> Bool == LayoutMessages Hide -- Is there a better-looking way -- of doing this? in Groups l l2 Window -> SomeMessage -> X (Maybe (Groups l l2 Window)) forall (layout :: * -> *) a. LayoutClass layout a => layout a -> SomeMessage -> X (Maybe (layout a)) handleMessage Groups l l2 Window l (SomeMessage -> X (Maybe (Groups l l2 Window))) -> SomeMessage -> X (Maybe (Groups l l2 Window)) forall a b. (a -> b) -> a -> b $ GroupsMessage -> SomeMessage forall a. Message a => a -> SomeMessage SomeMessage (GroupsMessage -> SomeMessage) -> GroupsMessage -> SomeMessage forall a b. (a -> b) -> a -> b $ SomeMessage -> GroupsMessage ToAll SomeMessage sm handleMessage l :: Groups l l2 Window l@(Groups l Window _ l2 (Group l Window) _ Stack (Group l Window) z Uniq _) SomeMessage sm = case SomeMessage -> Maybe GroupsMessage forall m. Message m => SomeMessage -> Maybe m fromMessage SomeMessage sm of Just (ToFocused SomeMessage sm') -> do [Maybe (WithID l Window)] mg's <- Zipper (Maybe (WithID l Window)) -> [Maybe (WithID l Window)] forall a. Maybe (Stack a) -> [a] W.integrate' (Zipper (Maybe (WithID l Window)) -> [Maybe (WithID l Window)]) -> X (Zipper (Maybe (WithID l Window))) -> X [Maybe (WithID l Window)] forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> SomeMessage -> Stack (Group l Window) -> X (Zipper (Maybe (WithID l Window))) forall {l :: * -> *} {a}. LayoutClass l a => SomeMessage -> Stack (Group l a) -> X (Zipper (Maybe (WithID l a))) handleOnFocused SomeMessage sm' Stack (Group l Window) z Maybe (Groups l l2 Window) -> X (Maybe (Groups l l2 Window)) forall a. a -> X a forall (m :: * -> *) a. Monad m => a -> m a return (Maybe (Groups l l2 Window) -> X (Maybe (Groups l l2 Window))) -> Maybe (Groups l l2 Window) -> X (Maybe (Groups l l2 Window)) forall a b. (a -> b) -> a -> b $ Groups l l2 Window -> Maybe (l2 (Group l Window)) -> [Maybe (WithID l Window)] -> Maybe (Groups l l2 Window) forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Maybe (l2 (Group l a)) -> [Maybe (WithID l a)] -> Maybe (Groups l l2 a) maybeMakeNew Groups l l2 Window l Maybe (l2 (Group l Window)) forall a. Maybe a Nothing [Maybe (WithID l Window)] mg's Just (ToGroup Int i SomeMessage sm') -> do [Maybe (WithID l Window)] mg's <- Int -> SomeMessage -> Stack (Group l Window) -> X [Maybe (WithID l Window)] forall {l :: * -> *} {a} {p}. (LayoutClass l a, Num p, Enum p, Eq p) => p -> SomeMessage -> Stack (Group l a) -> X [Maybe (WithID l a)] handleOnIndex Int i SomeMessage sm' Stack (Group l Window) z Maybe (Groups l l2 Window) -> X (Maybe (Groups l l2 Window)) forall a. a -> X a forall (m :: * -> *) a. Monad m => a -> m a return (Maybe (Groups l l2 Window) -> X (Maybe (Groups l l2 Window))) -> Maybe (Groups l l2 Window) -> X (Maybe (Groups l l2 Window)) forall a b. (a -> b) -> a -> b $ Groups l l2 Window -> Maybe (l2 (Group l Window)) -> [Maybe (WithID l Window)] -> Maybe (Groups l l2 Window) forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Maybe (l2 (Group l a)) -> [Maybe (WithID l a)] -> Maybe (Groups l l2 a) maybeMakeNew Groups l l2 Window l Maybe (l2 (Group l Window)) forall a. Maybe a Nothing [Maybe (WithID l Window)] mg's Just (Modify ModifySpec spec) -> case ModifySpec -> Groups l l2 Window -> Maybe (Groups l l2 Window) forall (l :: * -> *) (l2 :: * -> *). ModifySpec -> Groups l l2 Window -> Maybe (Groups l l2 Window) applySpec WithID l Window -> Zipper (Group l Window) -> Zipper (Group l Window) ModifySpec spec Groups l l2 Window l of Just Groups l l2 Window l' -> Groups l l2 Window -> X (Maybe (Groups l l2 Window)) forall (l :: * -> *) (l2 :: * -> *). Groups l l2 Window -> X (Maybe (Groups l l2 Window)) refocus Groups l l2 Window l' Maybe (Groups l l2 Window) Nothing -> Maybe (Groups l l2 Window) -> X (Maybe (Groups l l2 Window)) forall a. a -> X a forall (m :: * -> *) a. Monad m => a -> m a return Maybe (Groups l l2 Window) forall a. Maybe a Nothing Just (ModifyX ModifySpecX spec) -> do Maybe (Groups l l2 Window) ml' <- ModifySpecX -> Groups l l2 Window -> X (Maybe (Groups l l2 Window)) forall (l :: * -> *) (l2 :: * -> *). ModifySpecX -> Groups l l2 Window -> X (Maybe (Groups l l2 Window)) applySpecX WithID l Window -> Zipper (Group l Window) -> X (Zipper (Group l Window)) ModifySpecX spec Groups l l2 Window l Maybe (Groups l l2 Window) -> (Groups l l2 Window -> X ()) -> X () forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m () whenJust Maybe (Groups l l2 Window) ml' (X (Maybe (Groups l l2 Window)) -> X () forall (f :: * -> *) a. Functor f => f a -> f () void (X (Maybe (Groups l l2 Window)) -> X ()) -> (Groups l l2 Window -> X (Maybe (Groups l l2 Window))) -> Groups l l2 Window -> X () forall b c a. (b -> c) -> (a -> b) -> a -> c . Groups l l2 Window -> X (Maybe (Groups l l2 Window)) forall (l :: * -> *) (l2 :: * -> *). Groups l l2 Window -> X (Maybe (Groups l l2 Window)) refocus) Maybe (Groups l l2 Window) -> X (Maybe (Groups l l2 Window)) forall a. a -> X a forall (m :: * -> *) a. Monad m => a -> m a return (Maybe (Groups l l2 Window) ml' Maybe (Groups l l2 Window) -> Maybe (Groups l l2 Window) -> Maybe (Groups l l2 Window) forall a. Maybe a -> Maybe a -> Maybe a forall (f :: * -> *) a. Alternative f => f a -> f a -> f a <|> Groups l l2 Window -> Maybe (Groups l l2 Window) forall a. a -> Maybe a Just Groups l l2 Window l) Just GroupsMessage Refocus -> Groups l l2 Window -> X (Maybe (Groups l l2 Window)) forall (l :: * -> *) (l2 :: * -> *). Groups l l2 Window -> X (Maybe (Groups l l2 Window)) refocus Groups l l2 Window l Just GroupsMessage _ -> Maybe (Groups l l2 Window) -> X (Maybe (Groups l l2 Window)) forall a. a -> X a forall (m :: * -> *) a. Monad m => a -> m a return Maybe (Groups l l2 Window) forall a. Maybe a Nothing Maybe GroupsMessage Nothing -> Groups l l2 Window -> SomeMessage -> X (Maybe (Groups l l2 Window)) forall (layout :: * -> *) a. LayoutClass layout a => layout a -> SomeMessage -> X (Maybe (layout a)) handleMessage Groups l l2 Window l (SomeMessage -> X (Maybe (Groups l l2 Window))) -> SomeMessage -> X (Maybe (Groups l l2 Window)) forall a b. (a -> b) -> a -> b $ GroupsMessage -> SomeMessage forall a. Message a => a -> SomeMessage SomeMessage (SomeMessage -> GroupsMessage ToFocused SomeMessage sm) where handleOnFocused :: SomeMessage -> Stack (Group l a) -> X (Zipper (Maybe (WithID l a))) handleOnFocused SomeMessage sm Stack (Group l a) z = (Bool -> Group l a -> X (Maybe (WithID l a))) -> Zipper (Group l a) -> X (Zipper (Maybe (WithID l a))) forall (m :: * -> *) a b. Monad m => (Bool -> a -> m b) -> Zipper a -> m (Zipper b) mapZM Bool -> Group l a -> X (Maybe (WithID l a)) forall {l :: * -> *} {a}. LayoutClass l a => Bool -> Group l a -> X (Maybe (WithID l a)) step (Zipper (Group l a) -> X (Zipper (Maybe (WithID l a)))) -> Zipper (Group l a) -> X (Zipper (Maybe (WithID l a))) forall a b. (a -> b) -> a -> b $ Stack (Group l a) -> Zipper (Group l a) forall a. a -> Maybe a Just Stack (Group l a) z where step :: Bool -> Group l a -> X (Maybe (WithID l a)) step Bool True (G WithID l a l Zipper a _) = WithID l a -> SomeMessage -> X (Maybe (WithID l a)) forall (layout :: * -> *) a. LayoutClass layout a => layout a -> SomeMessage -> X (Maybe (layout a)) handleMessage WithID l a l SomeMessage sm step Bool False Group l a _ = Maybe (WithID l a) -> X (Maybe (WithID l a)) forall a. a -> X a forall (m :: * -> *) a. Monad m => a -> m a return Maybe (WithID l a) forall a. Maybe a Nothing handleOnIndex :: p -> SomeMessage -> Stack (Group l a) -> X [Maybe (WithID l a)] handleOnIndex p i SomeMessage sm Stack (Group l a) z = ((p, Group l a) -> X (Maybe (WithID l a))) -> [(p, Group l a)] -> X [Maybe (WithID l a)] forall (t :: * -> *) (m :: * -> *) a b. (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b) forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b] mapM (p, Group l a) -> X (Maybe (WithID l a)) forall {l :: * -> *} {a}. LayoutClass l a => (p, Group l a) -> X (Maybe (WithID l a)) step ([(p, Group l a)] -> X [Maybe (WithID l a)]) -> [(p, Group l a)] -> X [Maybe (WithID l a)] forall a b. (a -> b) -> a -> b $ [p] -> [Group l a] -> [(p, Group l a)] forall a b. [a] -> [b] -> [(a, b)] zip [p 0..] ([Group l a] -> [(p, Group l a)]) -> [Group l a] -> [(p, Group l a)] forall a b. (a -> b) -> a -> b $ Stack (Group l a) -> [Group l a] forall a. Stack a -> [a] W.integrate Stack (Group l a) z where step :: (p, Group l a) -> X (Maybe (WithID l a)) step (p j, G WithID l a l Zipper a _) | p i p -> p -> Bool forall a. Eq a => a -> a -> Bool == p j = WithID l a -> SomeMessage -> X (Maybe (WithID l a)) forall (layout :: * -> *) a. LayoutClass layout a => layout a -> SomeMessage -> X (Maybe (layout a)) handleMessage WithID l a l SomeMessage sm step (p, Group l a) _ = Maybe (WithID l a) -> X (Maybe (WithID l a)) forall a. a -> X a forall (m :: * -> *) a. Monad m => a -> m a return Maybe (WithID l a) forall a. Maybe a Nothing justMakeNew :: Groups l l2 a -> Maybe (l2 (Group l a)) -> [Maybe (WithID l a)] -> Maybe (Groups l l2 a) justMakeNew :: forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Maybe (l2 (Group l a)) -> [Maybe (WithID l a)] -> Maybe (Groups l l2 a) justMakeNew Groups l l2 a g Maybe (l2 (Group l a)) mpart' [Maybe (WithID l a)] ml's = Groups l l2 a -> Maybe (Groups l l2 a) forall a. a -> Maybe a Just Groups l l2 a g { partitioner = fromMaybe (partitioner g) mpart' , groups = combine (groups g) ml's } where combine :: Stack (Group l a) -> [Maybe (WithID l a)] -> Stack (Group l a) combine Stack (Group l a) z [Maybe (WithID l a)] ml's = let table :: [(Uniq, l a)] table = (WithID l a -> (Uniq, l a)) -> [WithID l a] -> [(Uniq, l a)] forall a b. (a -> b) -> [a] -> [b] map (\(ID Uniq id l a a) -> (Uniq id, l a a)) ([WithID l a] -> [(Uniq, l a)]) -> [WithID l a] -> [(Uniq, l a)] forall a b. (a -> b) -> a -> b $ [Maybe (WithID l a)] -> [WithID l a] forall a. [Maybe a] -> [a] catMaybes [Maybe (WithID l a)] ml's in ((Group l a -> Group l a) -> Stack (Group l a) -> Stack (Group l a)) -> Stack (Group l a) -> (Group l a -> Group l a) -> Stack (Group l a) forall a b c. (a -> b -> c) -> b -> a -> c flip (Group l a -> Group l a) -> Stack (Group l a) -> Stack (Group l a) forall {a} {b}. (a -> b) -> Stack a -> Stack b mapS_ Stack (Group l a) z ((Group l a -> Group l a) -> Stack (Group l a)) -> (Group l a -> Group l a) -> Stack (Group l a) forall a b. (a -> b) -> a -> b $ \(G (ID Uniq id l a l) Zipper a ws) -> case Uniq -> [(Uniq, l a)] -> Maybe (l a) forall a b. Eq a => a -> [(a, b)] -> Maybe b lookup Uniq id [(Uniq, l a)] table of Maybe (l a) Nothing -> WithID l a -> Zipper a -> Group l a forall (l :: * -> *) a. WithID l a -> Zipper a -> Group l a G (Uniq -> l a -> WithID l a forall (l :: * -> *) a. Uniq -> l a -> WithID l a ID Uniq id l a l) Zipper a ws Just l a l' -> WithID l a -> Zipper a -> Group l a forall (l :: * -> *) a. WithID l a -> Zipper a -> Group l a G (Uniq -> l a -> WithID l a forall (l :: * -> *) a. Uniq -> l a -> WithID l a ID Uniq id l a l') Zipper a ws mapS_ :: (a -> b) -> Stack a -> Stack b mapS_ a -> b f = Maybe (Stack b) -> Stack b forall a. HasCallStack => Maybe a -> a fromJust (Maybe (Stack b) -> Stack b) -> (Stack a -> Maybe (Stack b)) -> Stack a -> Stack b forall b c a. (b -> c) -> (a -> b) -> a -> c . (a -> b) -> Zipper a -> Maybe (Stack b) forall a b. (a -> b) -> Zipper a -> Zipper b mapZ_ a -> b f (Zipper a -> Maybe (Stack b)) -> (Stack a -> Zipper a) -> Stack a -> Maybe (Stack b) forall b c a. (b -> c) -> (a -> b) -> a -> c . Stack a -> Zipper a forall a. a -> Maybe a Just maybeMakeNew :: Groups l l2 a -> Maybe (l2 (Group l a)) -> [Maybe (WithID l a)] -> Maybe (Groups l l2 a) maybeMakeNew :: forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Maybe (l2 (Group l a)) -> [Maybe (WithID l a)] -> Maybe (Groups l l2 a) maybeMakeNew Groups l l2 a _ Maybe (l2 (Group l a)) Nothing [Maybe (WithID l a)] ml's | (Maybe (WithID l a) -> Bool) -> [Maybe (WithID l a)] -> Bool forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool all Maybe (WithID l a) -> Bool forall a. Maybe a -> Bool isNothing [Maybe (WithID l a)] ml's = Maybe (Groups l l2 a) forall a. Maybe a Nothing maybeMakeNew Groups l l2 a g Maybe (l2 (Group l a)) mpart' [Maybe (WithID l a)] ml's = Groups l l2 a -> Maybe (l2 (Group l a)) -> [Maybe (WithID l a)] -> Maybe (Groups l l2 a) forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Maybe (l2 (Group l a)) -> [Maybe (WithID l a)] -> Maybe (Groups l l2 a) justMakeNew Groups l l2 a g Maybe (l2 (Group l a)) mpart' [Maybe (WithID l a)] ml's refocus :: Groups l l2 Window -> X (Maybe (Groups l l2 Window)) refocus :: forall (l :: * -> *) (l2 :: * -> *). Groups l l2 Window -> X (Maybe (Groups l l2 Window)) refocus Groups l l2 Window g = let mw :: Maybe Window mw = (Zipper Window -> Maybe Window forall a. Zipper a -> Maybe a getFocusZ (Zipper Window -> Maybe Window) -> (Groups l l2 Window -> Zipper Window) -> Groups l l2 Window -> Maybe Window forall b c a. (b -> c) -> (a -> b) -> a -> c . Group l Window -> Zipper Window forall (l :: * -> *) a. Group l a -> Zipper a gZipper (Group l Window -> Zipper Window) -> (Groups l l2 Window -> Group l Window) -> Groups l l2 Window -> Zipper Window forall b c a. (b -> c) -> (a -> b) -> a -> c . Stack (Group l Window) -> Group l Window forall a. Stack a -> a W.focus (Stack (Group l Window) -> Group l Window) -> (Groups l l2 Window -> Stack (Group l Window)) -> Groups l l2 Window -> Group l Window forall b c a. (b -> c) -> (a -> b) -> a -> c . Groups l l2 Window -> Stack (Group l Window) forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Stack (Group l a) groups) Groups l l2 Window g in Groups l l2 Window g Groups l l2 Window -> Maybe Window -> Maybe (Groups l l2 Window) forall a b. a -> Maybe b -> Maybe a forall (f :: * -> *) a b. Functor f => a -> f b -> f a <$ Maybe Window mw Maybe (Groups l l2 Window) -> X () -> X (Maybe (Groups l l2 Window)) forall a b. a -> X b -> X a forall (f :: * -> *) a b. Functor f => a -> f b -> f a <$ Maybe Window -> (Window -> X ()) -> X () forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m () whenJust Maybe Window mw ((WindowSet -> WindowSet) -> X () modifyWindowSet ((WindowSet -> WindowSet) -> X ()) -> (Window -> WindowSet -> WindowSet) -> Window -> X () forall b c a. (b -> c) -> (a -> b) -> a -> c . Window -> WindowSet -> WindowSet forall s a i l sd. (Eq s, Eq a, Eq i) => a -> StackSet i l a s sd -> StackSet i l a s sd W.focusWindow) -- ** ModifySpec type -- | Type of functions describing modifications to a 'Groups' layout. They -- are transformations on 'Zipper's of groups. -- -- Things you shouldn't do: -- -- * Forge new windows (they will be ignored) -- -- * Duplicate windows (whatever happens is your problem) -- -- * Remove windows (they will be added again) -- -- * Duplicate layouts (only one will be kept, the rest will -- get the base layout) -- -- Note that 'ModifySpec' is a rank-2 type (indicating that 'ModifySpec's must -- be polymorphic in the layout type), so if you define functions taking -- 'ModifySpec's as arguments, or returning them, you'll need to write a type -- signature and add @{-# LANGUAGE Rank2Types #-}@ at the beginning type ModifySpec = forall l. WithID l Window -> Zipper (Group l Window) -> Zipper (Group l Window) -- ** ModifierSpecX type -- | This is the same as 'ModifySpec', but it allows the function to use -- actions inside the 'X' monad. This is useful, for example, if the function -- has to make decisions based on the results of a 'runQuery'. type ModifySpecX = forall l. WithID l Window -> Zipper (Group l Window) -> X (Zipper (Group l Window)) -- | Apply a ModifySpec. applySpec :: ModifySpec -> Groups l l2 Window -> Maybe (Groups l l2 Window) applySpec :: forall (l :: * -> *) (l2 :: * -> *). ModifySpec -> Groups l l2 Window -> Maybe (Groups l l2 Window) applySpec ModifySpec f Groups l l2 Window g = let (Uniq seed', Uniq ident :~ Stream Uniq ids) = Uniq -> (Uniq, Stream Uniq) gen (Uniq -> (Uniq, Stream Uniq)) -> Uniq -> (Uniq, Stream Uniq) forall a b. (a -> b) -> a -> b $ Groups l l2 Window -> Uniq forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Uniq seed Groups l l2 Window g -- gen generates an infinite list g' :: Groups l l2 Window g' = ((Zipper (Group l Window) -> Zipper (Group l Window)) -> Groups l l2 Window -> Groups l l2 Window) -> Groups l l2 Window -> (Zipper (Group l Window) -> Zipper (Group l Window)) -> Groups l l2 Window forall a b c. (a -> b -> c) -> b -> a -> c flip (Zipper (Group l Window) -> Zipper (Group l Window)) -> Groups l l2 Window -> Groups l l2 Window forall (l :: * -> *) a (l2 :: * -> *). (Zipper (Group l a) -> Zipper (Group l a)) -> Groups l l2 a -> Groups l l2 a modifyGroups Groups l l2 Window g ((Zipper (Group l Window) -> Zipper (Group l Window)) -> Groups l l2 Window) -> (Zipper (Group l Window) -> Zipper (Group l Window)) -> Groups l l2 Window forall a b. (a -> b) -> a -> b $ WithID l Window -> Zipper (Group l Window) -> Zipper (Group l Window) ModifySpec f (Uniq -> l Window -> WithID l Window forall (l :: * -> *) a. Uniq -> l a -> WithID l a ID Uniq ident (l Window -> WithID l Window) -> l Window -> WithID l Window forall a b. (a -> b) -> a -> b $ Groups l l2 Window -> l Window forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> l a baseLayout Groups l l2 Window g) (Zipper (Group l Window) -> Zipper (Group l Window)) -> (Zipper (Group l Window) -> Zipper (Group l Window)) -> Zipper (Group l Window) -> Zipper (Group l Window) forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c >>> Zipper (Group l Window) -> [Either (Group l Window) (Group l Window)] forall a. Zipper a -> [Either a a] toTags (Zipper (Group l Window) -> [Either (Group l Window) (Group l Window)]) -> ([Either (Group l Window) (Group l Window)] -> Zipper (Group l Window)) -> Zipper (Group l Window) -> Zipper (Group l Window) forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c >>> (Either (Group l Window) (Group l Window) -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)])) -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> [Either (Group l Window) (Group l Window)] -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) forall a b. (a -> b -> b) -> b -> [a] -> b forall (t :: * -> *) a b. Foldable t => (a -> b -> b) -> b -> t a -> b foldr (Groups l l2 Window -> Either (Group l Window) (Group l Window) -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) forall (l :: * -> *) (l2 :: * -> *). Groups l l2 Window -> Either (Group l Window) (Group l Window) -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) reID Groups l l2 Window g) ((Stream Uniq ids, []), []) ([Either (Group l Window) (Group l Window)] -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)])) -> (((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> Zipper (Group l Window)) -> [Either (Group l Window) (Group l Window)] -> Zipper (Group l Window) forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c >>> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> [Either (Group l Window) (Group l Window)] forall a b. (a, b) -> b snd (((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> [Either (Group l Window) (Group l Window)]) -> ([Either (Group l Window) (Group l Window)] -> Zipper (Group l Window)) -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> Zipper (Group l Window) forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c >>> [Either (Group l Window) (Group l Window)] -> Zipper (Group l Window) forall a. [Either a a] -> Zipper a fromTags in if Groups l l2 Window -> Stack (Group l Window) forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Stack (Group l a) groups Groups l l2 Window g Stack (Group l Window) -> Stack (Group l Window) -> Bool forall a. Eq a => a -> a -> Bool == Groups l l2 Window -> Stack (Group l Window) forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Stack (Group l a) groups Groups l l2 Window g' then Maybe (Groups l l2 Window) forall a. Maybe a Nothing else Groups l l2 Window -> Maybe (Groups l l2 Window) forall a. a -> Maybe a Just Groups l l2 Window g' { seed = seed' } applySpecX :: ModifySpecX -> Groups l l2 Window -> X (Maybe (Groups l l2 Window)) applySpecX :: forall (l :: * -> *) (l2 :: * -> *). ModifySpecX -> Groups l l2 Window -> X (Maybe (Groups l l2 Window)) applySpecX ModifySpecX f Groups l l2 Window g = do let (Uniq seed', Uniq ident :~ Stream Uniq ids) = Uniq -> (Uniq, Stream Uniq) gen (Uniq -> (Uniq, Stream Uniq)) -> Uniq -> (Uniq, Stream Uniq) forall a b. (a -> b) -> a -> b $ Groups l l2 Window -> Uniq forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Uniq seed Groups l l2 Window g -- gen generates an infinite list Groups l l2 Window g' <- ((Zipper (Group l Window) -> X (Zipper (Group l Window))) -> Groups l l2 Window -> X (Groups l l2 Window)) -> Groups l l2 Window -> (Zipper (Group l Window) -> X (Zipper (Group l Window))) -> X (Groups l l2 Window) forall a b c. (a -> b -> c) -> b -> a -> c flip (Zipper (Group l Window) -> X (Zipper (Group l Window))) -> Groups l l2 Window -> X (Groups l l2 Window) forall (l :: * -> *) a (l2 :: * -> *). (Zipper (Group l a) -> X (Zipper (Group l a))) -> Groups l l2 a -> X (Groups l l2 a) modifyGroupsX Groups l l2 Window g ((Zipper (Group l Window) -> X (Zipper (Group l Window))) -> X (Groups l l2 Window)) -> (Zipper (Group l Window) -> X (Zipper (Group l Window))) -> X (Groups l l2 Window) forall a b. (a -> b) -> a -> b $ WithID l Window -> Zipper (Group l Window) -> X (Zipper (Group l Window)) ModifySpecX f (Uniq -> l Window -> WithID l Window forall (l :: * -> *) a. Uniq -> l a -> WithID l a ID Uniq ident (l Window -> WithID l Window) -> l Window -> WithID l Window forall a b. (a -> b) -> a -> b $ Groups l l2 Window -> l Window forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> l a baseLayout Groups l l2 Window g) (Zipper (Group l Window) -> X (Zipper (Group l Window))) -> (X (Zipper (Group l Window)) -> X (Zipper (Group l Window))) -> Zipper (Group l Window) -> X (Zipper (Group l Window)) forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c >>> (Zipper (Group l Window) -> [Either (Group l Window) (Group l Window)]) -> X (Zipper (Group l Window)) -> X [Either (Group l Window) (Group l Window)] forall a b. (a -> b) -> X a -> X b forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap Zipper (Group l Window) -> [Either (Group l Window) (Group l Window)] forall a. Zipper a -> [Either a a] toTags (X (Zipper (Group l Window)) -> X [Either (Group l Window) (Group l Window)]) -> (X [Either (Group l Window) (Group l Window)] -> X (Zipper (Group l Window))) -> X (Zipper (Group l Window)) -> X (Zipper (Group l Window)) forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c >>> ([Either (Group l Window) (Group l Window)] -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)])) -> X [Either (Group l Window) (Group l Window)] -> X ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) forall a b. (a -> b) -> X a -> X b forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap ((Either (Group l Window) (Group l Window) -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)])) -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> [Either (Group l Window) (Group l Window)] -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) forall a b. (a -> b -> b) -> b -> [a] -> b forall (t :: * -> *) a b. Foldable t => (a -> b -> b) -> b -> t a -> b foldr (Groups l l2 Window -> Either (Group l Window) (Group l Window) -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) forall (l :: * -> *) (l2 :: * -> *). Groups l l2 Window -> Either (Group l Window) (Group l Window) -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) reID Groups l l2 Window g) ((Stream Uniq ids, []), [])) (X [Either (Group l Window) (Group l Window)] -> X ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)])) -> (X ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> X (Zipper (Group l Window))) -> X [Either (Group l Window) (Group l Window)] -> X (Zipper (Group l Window)) forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c >>> (((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> [Either (Group l Window) (Group l Window)]) -> X ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> X [Either (Group l Window) (Group l Window)] forall a b. (a -> b) -> X a -> X b forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> [Either (Group l Window) (Group l Window)] forall a b. (a, b) -> b snd (X ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> X [Either (Group l Window) (Group l Window)]) -> (X [Either (Group l Window) (Group l Window)] -> X (Zipper (Group l Window))) -> X ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> X (Zipper (Group l Window)) forall {k} (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c >>> ([Either (Group l Window) (Group l Window)] -> Zipper (Group l Window)) -> X [Either (Group l Window) (Group l Window)] -> X (Zipper (Group l Window)) forall a b. (a -> b) -> X a -> X b forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b fmap [Either (Group l Window) (Group l Window)] -> Zipper (Group l Window) forall a. [Either a a] -> Zipper a fromTags Maybe (Groups l l2 Window) -> X (Maybe (Groups l l2 Window)) forall a. a -> X a forall (m :: * -> *) a. Monad m => a -> m a return (Maybe (Groups l l2 Window) -> X (Maybe (Groups l l2 Window))) -> Maybe (Groups l l2 Window) -> X (Maybe (Groups l l2 Window)) forall a b. (a -> b) -> a -> b $ if Groups l l2 Window -> Stack (Group l Window) forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Stack (Group l a) groups Groups l l2 Window g Stack (Group l Window) -> Stack (Group l Window) -> Bool forall a. Eq a => a -> a -> Bool == Groups l l2 Window -> Stack (Group l Window) forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> Stack (Group l a) groups Groups l l2 Window g' then Maybe (Groups l l2 Window) forall a. Maybe a Nothing else Groups l l2 Window -> Maybe (Groups l l2 Window) forall a. a -> Maybe a Just Groups l l2 Window g' { seed = seed' } reID :: Groups l l2 Window -> Either (Group l Window) (Group l Window) -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) reID :: forall (l :: * -> *) (l2 :: * -> *). Groups l l2 Window -> Either (Group l Window) (Group l Window) -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) -> ((Stream Uniq, [Uniq]), [Either (Group l Window) (Group l Window)]) reID Groups l l2 Window g Either (Group l Window) (Group l Window) eg ((Uniq ident :~ Stream Uniq ids, [Uniq] seen), [Either (Group l Window) (Group l Window)] egs) | Uniq myID Uniq -> [Uniq] -> Bool forall a. Eq a => a -> [a] -> Bool forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool `elem` [Uniq] seen = ((Stream Uniq ids, [Uniq] seen), (Group l Window -> Group l Window) -> Either (Group l Window) (Group l Window) -> Either (Group l Window) (Group l Window) forall a b. (a -> b) -> Either a a -> Either b b mapE_ (Uniq -> Group l Window -> Group l Window forall {l :: * -> *}. Uniq -> Group l Window -> Group l Window setID Uniq ident) Either (Group l Window) (Group l Window) egEither (Group l Window) (Group l Window) -> [Either (Group l Window) (Group l Window)] -> [Either (Group l Window) (Group l Window)] forall a. a -> [a] -> [a] :[Either (Group l Window) (Group l Window)] egs) | Bool otherwise = ((Uniq ident Uniq -> Stream Uniq -> Stream Uniq forall a. a -> Stream a -> Stream a :~ Stream Uniq ids, Uniq myIDUniq -> [Uniq] -> [Uniq] forall a. a -> [a] -> [a] :[Uniq] seen), Either (Group l Window) (Group l Window) egEither (Group l Window) (Group l Window) -> [Either (Group l Window) (Group l Window)] -> [Either (Group l Window) (Group l Window)] forall a. a -> [a] -> [a] :[Either (Group l Window) (Group l Window)] egs) where myID :: Uniq myID = WithID l Window -> Uniq forall (l :: * -> *) a. WithID l a -> Uniq getID (WithID l Window -> Uniq) -> WithID l Window -> Uniq forall a b. (a -> b) -> a -> b $ Group l Window -> WithID l Window forall (l :: * -> *) a. Group l a -> WithID l a gLayout (Group l Window -> WithID l Window) -> Group l Window -> WithID l Window forall a b. (a -> b) -> a -> b $ Either (Group l Window) (Group l Window) -> Group l Window forall a. Either a a -> a fromE Either (Group l Window) (Group l Window) eg setID :: Uniq -> Group l Window -> Group l Window setID Uniq id (G (ID Uniq _ l Window _) Zipper Window z) = WithID l Window -> Zipper Window -> Group l Window forall (l :: * -> *) a. WithID l a -> Zipper a -> Group l a G (Uniq -> l Window -> WithID l Window forall (l :: * -> *) a. Uniq -> l a -> WithID l a ID Uniq id (l Window -> WithID l Window) -> l Window -> WithID l Window forall a b. (a -> b) -> a -> b $ Groups l l2 Window -> l Window forall (l :: * -> *) (l2 :: * -> *) a. Groups l l2 a -> l a baseLayout Groups l l2 Window g) Zipper Window z -- ** Misc. ModifySpecs -- | helper onFocused :: (Zipper Window -> Zipper Window) -> ModifySpec onFocused :: (Zipper Window -> Zipper Window) -> ModifySpec onFocused Zipper Window -> Zipper Window f WithID l Window _ = (Group l Window -> Group l Window) -> Zipper (Group l Window) -> Zipper (Group l Window) forall a. (a -> a) -> Zipper a -> Zipper a onFocusedZ ((Zipper Window -> Zipper Window) -> Group l Window -> Group l Window forall a (l :: * -> *). (Zipper a -> Zipper a) -> Group l a -> Group l a onZipper Zipper Window -> Zipper Window f) -- | Swap the focused window with the previous one. swapUp :: ModifySpec swapUp :: ModifySpec swapUp = (Zipper Window -> Zipper Window) -> ModifySpec onFocused Zipper Window -> Zipper Window forall a. Zipper a -> Zipper a swapUpZ -- | Swap the focused window with the next one. swapDown :: ModifySpec swapDown :: ModifySpec swapDown = (Zipper Window -> Zipper Window) -> ModifySpec onFocused Zipper Window -> Zipper Window forall a. Zipper a -> Zipper a swapDownZ -- | Swap the focused window with the (group's) master -- window. swapMaster :: ModifySpec swapMaster :: ModifySpec swapMaster = (Zipper Window -> Zipper Window) -> ModifySpec onFocused Zipper Window -> Zipper Window forall a. Zipper a -> Zipper a swapMasterZ -- | Swap the focused group with the previous one. swapGroupUp :: ModifySpec swapGroupUp :: ModifySpec swapGroupUp WithID l Window _ = Zipper (Group l Window) -> Zipper (Group l Window) forall a. Zipper a -> Zipper a swapUpZ -- | Swap the focused group with the next one. swapGroupDown :: ModifySpec swapGroupDown :: ModifySpec swapGroupDown WithID l Window _ = Zipper (Group l Window) -> Zipper (Group l Window) forall a. Zipper a -> Zipper a swapDownZ -- | Swap the focused group with the master group. swapGroupMaster :: ModifySpec swapGroupMaster :: ModifySpec swapGroupMaster WithID l Window _ = Zipper (Group l Window) -> Zipper (Group l Window) forall a. Zipper a -> Zipper a swapMasterZ -- | Move focus to the previous window in the group. focusUp :: ModifySpec focusUp :: ModifySpec focusUp = (Zipper Window -> Zipper Window) -> ModifySpec onFocused Zipper Window -> Zipper Window forall a. Zipper a -> Zipper a focusUpZ -- | Move focus to the next window in the group. focusDown :: ModifySpec focusDown :: ModifySpec focusDown = (Zipper Window -> Zipper Window) -> ModifySpec onFocused Zipper Window -> Zipper Window forall a. Zipper a -> Zipper a focusDownZ -- | Move focus to the group's master window. focusMaster :: ModifySpec focusMaster :: ModifySpec focusMaster = (Zipper Window -> Zipper Window) -> ModifySpec onFocused Zipper Window -> Zipper Window forall a. Zipper a -> Zipper a focusMasterZ -- | Move focus to the previous group. focusGroupUp :: ModifySpec focusGroupUp :: ModifySpec focusGroupUp WithID l Window _ = Zipper (Group l Window) -> Zipper (Group l Window) forall a. Zipper a -> Zipper a focusUpZ -- | Move focus to the next group. focusGroupDown :: ModifySpec focusGroupDown :: ModifySpec focusGroupDown WithID l Window _ = Zipper (Group l Window) -> Zipper (Group l Window) forall a. Zipper a -> Zipper a focusDownZ -- | Move focus to the master group. focusGroupMaster :: ModifySpec focusGroupMaster :: ModifySpec focusGroupMaster WithID l Window _ = Zipper (Group l Window) -> Zipper (Group l Window) forall a. Zipper a -> Zipper a focusMasterZ -- | helper _removeFocused :: W.Stack a -> (a, Zipper a) _removeFocused :: forall a. Stack a -> (a, Zipper a) _removeFocused (W.Stack a f (a u:[a] up) [a] down) = (a f, Stack a -> Maybe (Stack a) forall a. a -> Maybe a Just (Stack a -> Maybe (Stack a)) -> Stack a -> Maybe (Stack a) forall a b. (a -> b) -> a -> b $ a -> [a] -> [a] -> Stack a forall a. a -> [a] -> [a] -> Stack a W.Stack a u [a] up [a] down) _removeFocused (W.Stack a f [] (a d:[a] down)) = (a f, Stack a -> Maybe (Stack a) forall a. a -> Maybe a Just (Stack a -> Maybe (Stack a)) -> Stack a -> Maybe (Stack a) forall a b. (a -> b) -> a -> b $ a -> [a] -> [a] -> Stack a forall a. a -> [a] -> [a] -> Stack a W.Stack a d [] [a] down) _removeFocused (W.Stack a f [] []) = (a f, Maybe (Stack a) forall a. Maybe a Nothing) -- helper _moveToNewGroup :: WithID l Window -> W.Stack (Group l Window) -> (Group l Window -> Zipper (Group l Window) -> Zipper (Group l Window)) -> Zipper (Group l Window) _moveToNewGroup :: forall (l :: * -> *). WithID l Window -> Stack (Group l Window) -> (Group l Window -> Zipper (Group l Window) -> Zipper (Group l Window)) -> Zipper (Group l Window) _moveToNewGroup WithID l Window l0 Stack (Group l Window) s Group l Window -> Zipper (Group l Window) -> Zipper (Group l Window) insertX | G WithID l Window l (Just Stack Window f) <- Stack (Group l Window) -> Group l Window forall a. Stack a -> a W.focus Stack (Group l Window) s = let (Window w, Zipper Window f') = Stack Window -> (Window, Zipper Window) forall a. Stack a -> (a, Zipper a) _removeFocused Stack Window f s' :: Stack (Group l Window) s' = Stack (Group l Window) s { W.focus = G l f' } in Group l Window -> Zipper (Group l Window) -> Zipper (Group l Window) insertX (WithID l Window -> Zipper Window -> Group l Window forall (l :: * -> *) a. WithID l a -> Zipper a -> Group l a G WithID l Window l0 (Zipper Window -> Group l Window) -> Zipper Window -> Group l Window forall a b. (a -> b) -> a -> b $ Window -> Zipper Window forall a. a -> Zipper a singletonZ Window w) (Zipper (Group l Window) -> Zipper (Group l Window)) -> Zipper (Group l Window) -> Zipper (Group l Window) forall a b. (a -> b) -> a -> b $ Stack (Group l Window) -> Zipper (Group l Window) forall a. a -> Maybe a Just Stack (Group l Window) s' _moveToNewGroup WithID l Window _ Stack (Group l Window) s Group l Window -> Zipper (Group l Window) -> Zipper (Group l Window) _ = Stack (Group l Window) -> Zipper (Group l Window) forall a. a -> Maybe a Just Stack (Group l Window) s -- | Move the focused window to a new group before the current one. moveToNewGroupUp :: ModifySpec moveToNewGroupUp :: ModifySpec moveToNewGroupUp WithID l Window _ Maybe (Stack (Group l Window)) Nothing = Maybe (Stack (Group l Window)) forall a. Maybe a Nothing moveToNewGroupUp WithID l Window l0 (Just Stack (Group l Window) s) = WithID l Window -> Stack (Group l Window) -> (Group l Window -> Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window))) -> Maybe (Stack (Group l Window)) forall (l :: * -> *). WithID l Window -> Stack (Group l Window) -> (Group l Window -> Zipper (Group l Window) -> Zipper (Group l Window)) -> Zipper (Group l Window) _moveToNewGroup WithID l Window l0 Stack (Group l Window) s Group l Window -> Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window)) forall a. a -> Zipper a -> Zipper a insertUpZ -- | Move the focused window to a new group after the current one. moveToNewGroupDown :: ModifySpec moveToNewGroupDown :: ModifySpec moveToNewGroupDown WithID l Window _ Maybe (Stack (Group l Window)) Nothing = Maybe (Stack (Group l Window)) forall a. Maybe a Nothing moveToNewGroupDown WithID l Window l0 (Just Stack (Group l Window) s) = WithID l Window -> Stack (Group l Window) -> (Group l Window -> Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window))) -> Maybe (Stack (Group l Window)) forall (l :: * -> *). WithID l Window -> Stack (Group l Window) -> (Group l Window -> Zipper (Group l Window) -> Zipper (Group l Window)) -> Zipper (Group l Window) _moveToNewGroup WithID l Window l0 Stack (Group l Window) s Group l Window -> Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window)) forall a. a -> Zipper a -> Zipper a insertDownZ -- | Move the focused window to the previous group. -- If 'True', when in the first group, wrap around to the last one. -- If 'False', create a new group before it. moveToGroupUp :: Bool -> ModifySpec moveToGroupUp :: Bool -> ModifySpec moveToGroupUp Bool _ WithID l Window _ Maybe (Stack (Group l Window)) Nothing = Maybe (Stack (Group l Window)) forall a. Maybe a Nothing moveToGroupUp Bool False WithID l Window l0 (Just Stack (Group l Window) s) = if [Group l Window] -> Bool forall a. [a] -> Bool forall (t :: * -> *) a. Foldable t => t a -> Bool null (Stack (Group l Window) -> [Group l Window] forall a. Stack a -> [a] W.up Stack (Group l Window) s) then WithID l Window -> Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window)) ModifySpec moveToNewGroupUp WithID l Window l0 (Stack (Group l Window) -> Maybe (Stack (Group l Window)) forall a. a -> Maybe a Just Stack (Group l Window) s) else Bool -> ModifySpec moveToGroupUp Bool True WithID l Window l0 (Stack (Group l Window) -> Maybe (Stack (Group l Window)) forall a. a -> Maybe a Just Stack (Group l Window) s) moveToGroupUp Bool True WithID l Window _ (Just s :: Stack (Group l Window) s@(W.Stack Group l Window _ [] [])) = Stack (Group l Window) -> Maybe (Stack (Group l Window)) forall a. a -> Maybe a Just Stack (Group l Window) s moveToGroupUp Bool True WithID l Window _ (Just s :: Stack (Group l Window) s@(W.Stack (G WithID l Window l (Just Stack Window f)) [Group l Window] _ [Group l Window] _)) = let (Window w, Zipper Window f') = Stack Window -> (Window, Zipper Window) forall a. Stack a -> (a, Zipper a) _removeFocused Stack Window f in (Group l Window -> Group l Window) -> Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window)) forall a. (a -> a) -> Zipper a -> Zipper a onFocusedZ ((Zipper Window -> Zipper Window) -> Group l Window -> Group l Window forall a (l :: * -> *). (Zipper a -> Zipper a) -> Group l a -> Group l a onZipper ((Zipper Window -> Zipper Window) -> Group l Window -> Group l Window) -> (Zipper Window -> Zipper Window) -> Group l Window -> Group l Window forall a b. (a -> b) -> a -> b $ Window -> Zipper Window -> Zipper Window forall a. a -> Zipper a -> Zipper a insertUpZ Window w) (Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window))) -> Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window)) forall a b. (a -> b) -> a -> b $ Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window)) forall a. Zipper a -> Zipper a focusUpZ (Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window))) -> Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window)) forall a b. (a -> b) -> a -> b $ Stack (Group l Window) -> Maybe (Stack (Group l Window)) forall a. a -> Maybe a Just Stack (Group l Window) s { W.focus = G l f' } moveToGroupUp Bool True WithID l Window _ Maybe (Stack (Group l Window)) gs = Maybe (Stack (Group l Window)) gs -- | Move the focused window to the next group. -- If 'True', when in the last group, wrap around to the first one. -- If 'False', create a new group after it. moveToGroupDown :: Bool -> ModifySpec moveToGroupDown :: Bool -> ModifySpec moveToGroupDown Bool _ WithID l Window _ Maybe (Stack (Group l Window)) Nothing = Maybe (Stack (Group l Window)) forall a. Maybe a Nothing moveToGroupDown Bool False WithID l Window l0 (Just Stack (Group l Window) s) = if [Group l Window] -> Bool forall a. [a] -> Bool forall (t :: * -> *) a. Foldable t => t a -> Bool null (Stack (Group l Window) -> [Group l Window] forall a. Stack a -> [a] W.down Stack (Group l Window) s) then WithID l Window -> Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window)) ModifySpec moveToNewGroupDown WithID l Window l0 (Stack (Group l Window) -> Maybe (Stack (Group l Window)) forall a. a -> Maybe a Just Stack (Group l Window) s) else Bool -> ModifySpec moveToGroupDown Bool True WithID l Window l0 (Stack (Group l Window) -> Maybe (Stack (Group l Window)) forall a. a -> Maybe a Just Stack (Group l Window) s) moveToGroupDown Bool True WithID l Window _ (Just s :: Stack (Group l Window) s@(W.Stack Group l Window _ [] [])) = Stack (Group l Window) -> Maybe (Stack (Group l Window)) forall a. a -> Maybe a Just Stack (Group l Window) s moveToGroupDown Bool True WithID l Window _ (Just s :: Stack (Group l Window) s@(W.Stack (G WithID l Window l (Just Stack Window f)) [Group l Window] _ [Group l Window] _)) = let (Window w, Zipper Window f') = Stack Window -> (Window, Zipper Window) forall a. Stack a -> (a, Zipper a) _removeFocused Stack Window f in (Group l Window -> Group l Window) -> Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window)) forall a. (a -> a) -> Zipper a -> Zipper a onFocusedZ ((Zipper Window -> Zipper Window) -> Group l Window -> Group l Window forall a (l :: * -> *). (Zipper a -> Zipper a) -> Group l a -> Group l a onZipper ((Zipper Window -> Zipper Window) -> Group l Window -> Group l Window) -> (Zipper Window -> Zipper Window) -> Group l Window -> Group l Window forall a b. (a -> b) -> a -> b $ Window -> Zipper Window -> Zipper Window forall a. a -> Zipper a -> Zipper a insertUpZ Window w) (Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window))) -> Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window)) forall a b. (a -> b) -> a -> b $ Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window)) forall a. Zipper a -> Zipper a focusDownZ (Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window))) -> Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window)) forall a b. (a -> b) -> a -> b $ Stack (Group l Window) -> Maybe (Stack (Group l Window)) forall a. a -> Maybe a Just Stack (Group l Window) s { W.focus = G l f' } moveToGroupDown Bool True WithID l Window _ Maybe (Stack (Group l Window)) gs = Maybe (Stack (Group l Window)) gs -- | Split the focused group into two at the position of the focused window (below it, -- unless it's the last window - in that case, above it). splitGroup :: ModifySpec splitGroup :: ModifySpec splitGroup WithID l Window _ Maybe (Stack (Group l Window)) Nothing = Maybe (Stack (Group l Window)) forall a. Maybe a Nothing splitGroup WithID l Window l0 z :: Maybe (Stack (Group l Window)) z@(Just Stack (Group l Window) s) | G WithID l Window l (Just Stack Window ws) <- Stack (Group l Window) -> Group l Window forall a. Stack a -> a W.focus Stack (Group l Window) s = case Stack Window ws of W.Stack Window _ [] [] -> Maybe (Stack (Group l Window)) z W.Stack Window f (Window u:[Window] up) [] -> let g1 :: Group l Window g1 = WithID l Window -> Zipper Window -> Group l Window forall (l :: * -> *) a. WithID l a -> Zipper a -> Group l a G WithID l Window l (Zipper Window -> Group l Window) -> Zipper Window -> Group l Window forall a b. (a -> b) -> a -> b $ Stack Window -> Zipper Window forall a. a -> Maybe a Just (Stack Window -> Zipper Window) -> Stack Window -> Zipper Window forall a b. (a -> b) -> a -> b $ Window -> [Window] -> [Window] -> Stack Window forall a. a -> [a] -> [a] -> Stack a W.Stack Window f [] [] g2 :: Group l Window g2 = WithID l Window -> Zipper Window -> Group l Window forall (l :: * -> *) a. WithID l a -> Zipper a -> Group l a G WithID l Window l0 (Zipper Window -> Group l Window) -> Zipper Window -> Group l Window forall a b. (a -> b) -> a -> b $ Stack Window -> Zipper Window forall a. a -> Maybe a Just (Stack Window -> Zipper Window) -> Stack Window -> Zipper Window forall a b. (a -> b) -> a -> b $ Window -> [Window] -> [Window] -> Stack Window forall a. a -> [a] -> [a] -> Stack a W.Stack Window u [Window] up [] in Group l Window -> Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window)) forall a. a -> Zipper a -> Zipper a insertDownZ Group l Window g1 (Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window))) -> Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window)) forall a b. (a -> b) -> a -> b $ (Group l Window -> Group l Window) -> Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window)) forall a. (a -> a) -> Zipper a -> Zipper a onFocusedZ (Group l Window -> Group l Window -> Group l Window forall a b. a -> b -> a const Group l Window g2) Maybe (Stack (Group l Window)) z W.Stack Window f [Window] up (Window d:[Window] down) -> let g1 :: Group l Window g1 = WithID l Window -> Zipper Window -> Group l Window forall (l :: * -> *) a. WithID l a -> Zipper a -> Group l a G WithID l Window l (Zipper Window -> Group l Window) -> Zipper Window -> Group l Window forall a b. (a -> b) -> a -> b $ Stack Window -> Zipper Window forall a. a -> Maybe a Just (Stack Window -> Zipper Window) -> Stack Window -> Zipper Window forall a b. (a -> b) -> a -> b $ Window -> [Window] -> [Window] -> Stack Window forall a. a -> [a] -> [a] -> Stack a W.Stack Window f [Window] up [] g2 :: Group l Window g2 = WithID l Window -> Zipper Window -> Group l Window forall (l :: * -> *) a. WithID l a -> Zipper a -> Group l a G WithID l Window l0 (Zipper Window -> Group l Window) -> Zipper Window -> Group l Window forall a b. (a -> b) -> a -> b $ Stack Window -> Zipper Window forall a. a -> Maybe a Just (Stack Window -> Zipper Window) -> Stack Window -> Zipper Window forall a b. (a -> b) -> a -> b $ Window -> [Window] -> [Window] -> Stack Window forall a. a -> [a] -> [a] -> Stack a W.Stack Window d [] [Window] down in Group l Window -> Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window)) forall a. a -> Zipper a -> Zipper a insertUpZ Group l Window g1 (Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window))) -> Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window)) forall a b. (a -> b) -> a -> b $ (Group l Window -> Group l Window) -> Maybe (Stack (Group l Window)) -> Maybe (Stack (Group l Window)) forall a. (a -> a) -> Zipper a -> Zipper a onFocusedZ (Group l Window -> Group l Window -> Group l Window forall a b. a -> b -> a const Group l Window g2) Maybe (Stack (Group l Window)) z splitGroup WithID l Window _ Maybe (Stack (Group l Window)) _ = Maybe (Stack (Group l Window)) forall a. Maybe a Nothing