{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PatternGuards, FlexibleContexts, FlexibleInstances #-}
-----------------------------------------------------------------------------
-- |
-- Module      :  XMonad.Layout.BoringWindows
-- Description :  Mark windows as boring.
-- Copyright   :  (c) 2008  David Roundy <droundy@darcs.net>
-- License     :  BSD3-style (see LICENSE)
--
-- Maintainer  :  Adam Vogt <vogt.adam@gmail.com>
-- Stability   :  unstable
-- Portability :  unportable
--
-- BoringWindows is an extension to allow windows to be marked boring
--
-----------------------------------------------------------------------------

module XMonad.Layout.BoringWindows (
                                   -- * Usage
                                   -- $usage
                                   boringWindows, boringAuto,
                                   markBoring, markBoringEverywhere,
                                   clearBoring, focusUp, focusDown,
                                   focusMaster, swapUp, swapDown,
                                   siftUp, siftDown,

                                   UpdateBoring(UpdateBoring),
                                   BoringMessage(Replace,Merge),
                                   BoringWindows()

                                   -- * Tips
                                   -- ** variant of 'Full'
                                   -- $simplest
                                  ) where

import XMonad.Layout.LayoutModifier(ModifiedLayout(..),
                                    LayoutModifier(handleMessOrMaybeModifyIt, redoLayout))
import XMonad(LayoutClass, Message, X, fromMessage,
              broadcastMessage, sendMessage, windows, withFocused, Window)
import XMonad.Prelude
import XMonad.Util.Stack (reverseS)
import qualified Data.List.NonEmpty as NE
import qualified Data.Map as M
import qualified XMonad.StackSet as W

-- $usage
-- You can use this module with the following in your
-- @xmonad.hs@:
--
-- > import XMonad.Layout.BoringWindows
--
-- Then edit your @layoutHook@ by adding the layout modifier:
--
-- > myLayout = boringWindows (Full ||| etc..)
-- > main = xmonad def { layoutHook = myLayout }
--
-- Then to your keybindings, add:
--
-- > , ((modm, xK_j), focusUp)
-- > , ((modm, xK_k), focusDown)
-- > , ((modm, xK_m), focusMaster)
--
-- For more detailed instructions on editing the layoutHook see
-- <https://xmonad.org/TUTORIAL.html#customizing-xmonad the tutorial> and
-- "XMonad.Doc.Extending#Editing_the_layout_hook".


data BoringMessage = FocusUp | FocusDown | FocusMaster | IsBoring Window | ClearBoring
                     | Replace String [Window]
                     | Merge String [Window]
                     | SwapUp
                     | SwapDown
                     | SiftUp
                     | SiftDown
                     deriving ( ReadPrec [BoringMessage]
ReadPrec BoringMessage
Int -> ReadS BoringMessage
ReadS [BoringMessage]
(Int -> ReadS BoringMessage)
-> ReadS [BoringMessage]
-> ReadPrec BoringMessage
-> ReadPrec [BoringMessage]
-> Read BoringMessage
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BoringMessage
readsPrec :: Int -> ReadS BoringMessage
$creadList :: ReadS [BoringMessage]
readList :: ReadS [BoringMessage]
$creadPrec :: ReadPrec BoringMessage
readPrec :: ReadPrec BoringMessage
$creadListPrec :: ReadPrec [BoringMessage]
readListPrec :: ReadPrec [BoringMessage]
Read, Int -> BoringMessage -> ShowS
[BoringMessage] -> ShowS
BoringMessage -> [Char]
(Int -> BoringMessage -> ShowS)
-> (BoringMessage -> [Char])
-> ([BoringMessage] -> ShowS)
-> Show BoringMessage
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BoringMessage -> ShowS
showsPrec :: Int -> BoringMessage -> ShowS
$cshow :: BoringMessage -> [Char]
show :: BoringMessage -> [Char]
$cshowList :: [BoringMessage] -> ShowS
showList :: [BoringMessage] -> ShowS
Show )

instance Message BoringMessage

-- | UpdateBoring is sent before attempting to view another boring window, so
-- that layouts have a chance to mark boring windows.
data UpdateBoring = UpdateBoring
instance Message UpdateBoring

markBoring, clearBoring, focusUp, focusDown, focusMaster, swapUp, swapDown, siftUp, siftDown :: X ()
markBoring :: X ()
markBoring = (Word64 -> X ()) -> X ()
withFocused (BoringMessage -> X ()
forall a. Message a => a -> X ()
sendMessage (BoringMessage -> X ())
-> (Word64 -> BoringMessage) -> Word64 -> X ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> BoringMessage
IsBoring)
clearBoring :: X ()
clearBoring = BoringMessage -> X ()
forall a. Message a => a -> X ()
sendMessage BoringMessage
ClearBoring
focusUp :: X ()
focusUp = UpdateBoring -> X ()
forall a. Message a => a -> X ()
sendMessage UpdateBoring
UpdateBoring X () -> X () -> X ()
forall a b. X a -> X b -> X b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> BoringMessage -> X ()
forall a. Message a => a -> X ()
sendMessage BoringMessage
FocusUp
focusDown :: X ()
focusDown = UpdateBoring -> X ()
forall a. Message a => a -> X ()
sendMessage UpdateBoring
UpdateBoring X () -> X () -> X ()
forall a b. X a -> X b -> X b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> BoringMessage -> X ()
forall a. Message a => a -> X ()
sendMessage BoringMessage
FocusDown
focusMaster :: X ()
focusMaster = UpdateBoring -> X ()
forall a. Message a => a -> X ()
sendMessage UpdateBoring
UpdateBoring X () -> X () -> X ()
forall a b. X a -> X b -> X b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> BoringMessage -> X ()
forall a. Message a => a -> X ()
sendMessage BoringMessage
FocusMaster
swapUp :: X ()
swapUp = UpdateBoring -> X ()
forall a. Message a => a -> X ()
sendMessage UpdateBoring
UpdateBoring X () -> X () -> X ()
forall a b. X a -> X b -> X b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> BoringMessage -> X ()
forall a. Message a => a -> X ()
sendMessage BoringMessage
SwapUp
swapDown :: X ()
swapDown = UpdateBoring -> X ()
forall a. Message a => a -> X ()
sendMessage UpdateBoring
UpdateBoring X () -> X () -> X ()
forall a b. X a -> X b -> X b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> BoringMessage -> X ()
forall a. Message a => a -> X ()
sendMessage BoringMessage
SwapDown
siftUp :: X ()
siftUp = UpdateBoring -> X ()
forall a. Message a => a -> X ()
sendMessage UpdateBoring
UpdateBoring X () -> X () -> X ()
forall a b. X a -> X b -> X b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> BoringMessage -> X ()
forall a. Message a => a -> X ()
sendMessage BoringMessage
SiftUp
siftDown :: X ()
siftDown = UpdateBoring -> X ()
forall a. Message a => a -> X ()
sendMessage UpdateBoring
UpdateBoring X () -> X () -> X ()
forall a b. X a -> X b -> X b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> BoringMessage -> X ()
forall a. Message a => a -> X ()
sendMessage BoringMessage
SiftDown

-- | Mark current focused window boring for all layouts.
-- This is useful in combination with the "XMonad.Actions.CopyWindow" module.
markBoringEverywhere :: X ()
markBoringEverywhere :: X ()
markBoringEverywhere = (Word64 -> X ()) -> X ()
withFocused (BoringMessage -> X ()
forall a. Message a => a -> X ()
broadcastMessage (BoringMessage -> X ())
-> (Word64 -> BoringMessage) -> Word64 -> X ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> BoringMessage
IsBoring)

data BoringWindows a = BoringWindows
    { forall a. BoringWindows a -> Map [Char] [a]
namedBoring :: M.Map String [a] -- ^ store borings with a specific source
    , forall a. BoringWindows a -> [a]
chosenBoring :: [a]             -- ^ user-chosen borings
    , forall a. BoringWindows a -> Maybe [a]
hiddenBoring :: Maybe [a]       -- ^ maybe mark hidden windows
    } deriving (Int -> BoringWindows a -> ShowS
[BoringWindows a] -> ShowS
BoringWindows a -> [Char]
(Int -> BoringWindows a -> ShowS)
-> (BoringWindows a -> [Char])
-> ([BoringWindows a] -> ShowS)
-> Show (BoringWindows a)
forall a. Show a => Int -> BoringWindows a -> ShowS
forall a. Show a => [BoringWindows a] -> ShowS
forall a. Show a => BoringWindows a -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> BoringWindows a -> ShowS
showsPrec :: Int -> BoringWindows a -> ShowS
$cshow :: forall a. Show a => BoringWindows a -> [Char]
show :: BoringWindows a -> [Char]
$cshowList :: forall a. Show a => [BoringWindows a] -> ShowS
showList :: [BoringWindows a] -> ShowS
Show,ReadPrec [BoringWindows a]
ReadPrec (BoringWindows a)
Int -> ReadS (BoringWindows a)
ReadS [BoringWindows a]
(Int -> ReadS (BoringWindows a))
-> ReadS [BoringWindows a]
-> ReadPrec (BoringWindows a)
-> ReadPrec [BoringWindows a]
-> Read (BoringWindows a)
forall a. Read a => ReadPrec [BoringWindows a]
forall a. Read a => ReadPrec (BoringWindows a)
forall a. Read a => Int -> ReadS (BoringWindows a)
forall a. Read a => ReadS [BoringWindows a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (BoringWindows a)
readsPrec :: Int -> ReadS (BoringWindows a)
$creadList :: forall a. Read a => ReadS [BoringWindows a]
readList :: ReadS [BoringWindows a]
$creadPrec :: forall a. Read a => ReadPrec (BoringWindows a)
readPrec :: ReadPrec (BoringWindows a)
$creadListPrec :: forall a. Read a => ReadPrec [BoringWindows a]
readListPrec :: ReadPrec [BoringWindows a]
Read)

boringWindows :: (LayoutClass l a, Eq a) => l a -> ModifiedLayout BoringWindows l a
boringWindows :: forall (l :: * -> *) a.
(LayoutClass l a, Eq a) =>
l a -> ModifiedLayout BoringWindows l a
boringWindows = BoringWindows a -> l a -> ModifiedLayout BoringWindows l a
forall (m :: * -> *) (l :: * -> *) a.
m a -> l a -> ModifiedLayout m l a
ModifiedLayout (Map [Char] [a] -> [a] -> Maybe [a] -> BoringWindows a
forall a. Map [Char] [a] -> [a] -> Maybe [a] -> BoringWindows a
BoringWindows Map [Char] [a]
forall k a. Map k a
M.empty [] Maybe [a]
forall a. Maybe a
Nothing)

-- | Mark windows that are not given rectangles as boring
boringAuto :: (LayoutClass l a, Eq a) => l a -> ModifiedLayout BoringWindows l a
boringAuto :: forall (l :: * -> *) a.
(LayoutClass l a, Eq a) =>
l a -> ModifiedLayout BoringWindows l a
boringAuto = BoringWindows a -> l a -> ModifiedLayout BoringWindows l a
forall (m :: * -> *) (l :: * -> *) a.
m a -> l a -> ModifiedLayout m l a
ModifiedLayout (Map [Char] [a] -> [a] -> Maybe [a] -> BoringWindows a
forall a. Map [Char] [a] -> [a] -> Maybe [a] -> BoringWindows a
BoringWindows Map [Char] [a]
forall k a. Map k a
M.empty [] ([a] -> Maybe [a]
forall a. a -> Maybe a
Just []))

instance LayoutModifier BoringWindows Window where
    redoLayout :: BoringWindows Word64
-> Rectangle
-> Maybe (Stack Word64)
-> [(Word64, Rectangle)]
-> X ([(Word64, Rectangle)], Maybe (BoringWindows Word64))
redoLayout b :: BoringWindows Word64
b@BoringWindows{ hiddenBoring :: forall a. BoringWindows a -> Maybe [a]
hiddenBoring = Maybe [Word64]
bs } Rectangle
_r Maybe (Stack Word64)
mst [(Word64, Rectangle)]
arrs = do
        let bs' :: [Word64]
bs' = Maybe (Stack Word64) -> [Word64]
forall a. Maybe (Stack a) -> [a]
W.integrate' Maybe (Stack Word64)
mst [Word64] -> [Word64] -> [Word64]
forall a. Eq a => [a] -> [a] -> [a]
\\ ((Word64, Rectangle) -> Word64)
-> [(Word64, Rectangle)] -> [Word64]
forall a b. (a -> b) -> [a] -> [b]
map (Word64, Rectangle) -> Word64
forall a b. (a, b) -> a
fst [(Word64, Rectangle)]
arrs
        ([(Word64, Rectangle)], Maybe (BoringWindows Word64))
-> X ([(Word64, Rectangle)], Maybe (BoringWindows Word64))
forall a. a -> X a
forall (m :: * -> *) a. Monad m => a -> m a
return ([(Word64, Rectangle)]
arrs, BoringWindows Word64 -> Maybe (BoringWindows Word64)
forall a. a -> Maybe a
Just (BoringWindows Word64 -> Maybe (BoringWindows Word64))
-> BoringWindows Word64 -> Maybe (BoringWindows Word64)
forall a b. (a -> b) -> a -> b
$ BoringWindows Word64
b { hiddenBoring = bs' <$ bs } )

    handleMessOrMaybeModifyIt :: BoringWindows Word64
-> SomeMessage
-> X (Maybe (Either (BoringWindows Word64) SomeMessage))
handleMessOrMaybeModifyIt bst :: BoringWindows Word64
bst@(BoringWindows Map [Char] [Word64]
nbs [Word64]
cbs Maybe [Word64]
lbs) SomeMessage
m
        | Just (Replace [Char]
k [Word64]
ws) <- SomeMessage -> Maybe BoringMessage
forall m. Message m => SomeMessage -> Maybe m
fromMessage SomeMessage
m
        , [Word64] -> Maybe [Word64]
forall a. a -> Maybe a
Just [Word64]
ws Maybe [Word64] -> Maybe [Word64] -> Bool
forall a. Eq a => a -> a -> Bool
/= [Char] -> Map [Char] [Word64] -> Maybe [Word64]
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup [Char]
k Map [Char] [Word64]
nbs =
            let nnb :: Map [Char] [Word64]
nnb = if [Word64] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Word64]
ws then [Char] -> Map [Char] [Word64] -> Map [Char] [Word64]
forall k a. Ord k => k -> Map k a -> Map k a
M.delete [Char]
k Map [Char] [Word64]
nbs
                          else [Char] -> [Word64] -> Map [Char] [Word64] -> Map [Char] [Word64]
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert [Char]
k [Word64]
ws Map [Char] [Word64]
nbs
            in BoringWindows Word64
-> X (Maybe (Either (BoringWindows Word64) SomeMessage))
forall {a} {b}. a -> X (Maybe (Either a b))
rjl BoringWindows Word64
bst { namedBoring = nnb }
        | Just (Merge [Char]
k [Word64]
ws) <- SomeMessage -> Maybe BoringMessage
forall m. Message m => SomeMessage -> Maybe m
fromMessage SomeMessage
m
        , Bool -> ([Word64] -> Bool) -> Maybe [Word64] -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
True (Bool -> Bool
not (Bool -> Bool) -> ([Word64] -> Bool) -> [Word64] -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word64] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ([Word64] -> Bool) -> ([Word64] -> [Word64]) -> [Word64] -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Word64]
ws [Word64] -> [Word64] -> [Word64]
forall a. Eq a => [a] -> [a] -> [a]
\\)) ([Char] -> Map [Char] [Word64] -> Maybe [Word64]
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup [Char]
k Map [Char] [Word64]
nbs) =
            BoringWindows Word64
-> X (Maybe (Either (BoringWindows Word64) SomeMessage))
forall {a} {b}. a -> X (Maybe (Either a b))
rjl BoringWindows Word64
bst { namedBoring = M.insertWith union k ws nbs }
        | Just (IsBoring Word64
w) <- SomeMessage -> Maybe BoringMessage
forall m. Message m => SomeMessage -> Maybe m
fromMessage SomeMessage
m , Word64
w Word64 -> [Word64] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [Word64]
cbs =
            BoringWindows Word64
-> X (Maybe (Either (BoringWindows Word64) SomeMessage))
forall {a} {b}. a -> X (Maybe (Either a b))
rjl BoringWindows Word64
bst { chosenBoring = w:cbs }
        | Just BoringMessage
ClearBoring <- SomeMessage -> Maybe BoringMessage
forall m. Message m => SomeMessage -> Maybe m
fromMessage SomeMessage
m, Bool -> Bool
not ([Word64] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Word64]
cbs) =
            BoringWindows Word64
-> X (Maybe (Either (BoringWindows Word64) SomeMessage))
forall {a} {b}. a -> X (Maybe (Either a b))
rjl BoringWindows Word64
bst { namedBoring = M.empty, chosenBoring = []}
        | Just BoringMessage
FocusUp <- SomeMessage -> Maybe BoringMessage
forall m. Message m => SomeMessage -> Maybe m
fromMessage SomeMessage
m =
                            do (WindowSet -> WindowSet) -> X ()
windows ((WindowSet -> WindowSet) -> X ())
-> (WindowSet -> WindowSet) -> X ()
forall a b. (a -> b) -> a -> b
$ (Stack Word64 -> Stack Word64) -> WindowSet -> WindowSet
forall a i l s sd.
(Stack a -> Stack a) -> StackSet i l a s sd -> StackSet i l a s sd
W.modify' ((Stack Word64 -> Stack Word64) -> WindowSet -> WindowSet)
-> (Stack Word64 -> Stack Word64) -> WindowSet -> WindowSet
forall a b. (a -> b) -> a -> b
$ (Stack Word64 -> Stack Word64) -> Stack Word64 -> Stack Word64
skipBoring Stack Word64 -> Stack Word64
forall a. Stack a -> Stack a
W.focusUp'
                               Maybe (Either (BoringWindows Word64) SomeMessage)
-> X (Maybe (Either (BoringWindows Word64) SomeMessage))
forall a. a -> X a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Either (BoringWindows Word64) SomeMessage)
forall a. Maybe a
Nothing
        | Just BoringMessage
FocusDown <- SomeMessage -> Maybe BoringMessage
forall m. Message m => SomeMessage -> Maybe m
fromMessage SomeMessage
m =
                            do (WindowSet -> WindowSet) -> X ()
windows ((WindowSet -> WindowSet) -> X ())
-> (WindowSet -> WindowSet) -> X ()
forall a b. (a -> b) -> a -> b
$ (Stack Word64 -> Stack Word64) -> WindowSet -> WindowSet
forall a i l s sd.
(Stack a -> Stack a) -> StackSet i l a s sd -> StackSet i l a s sd
W.modify' ((Stack Word64 -> Stack Word64) -> WindowSet -> WindowSet)
-> (Stack Word64 -> Stack Word64) -> WindowSet -> WindowSet
forall a b. (a -> b) -> a -> b
$ (Stack Word64 -> Stack Word64) -> Stack Word64 -> Stack Word64
skipBoring Stack Word64 -> Stack Word64
forall a. Stack a -> Stack a
W.focusDown'
                               Maybe (Either (BoringWindows Word64) SomeMessage)
-> X (Maybe (Either (BoringWindows Word64) SomeMessage))
forall a. a -> X a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Either (BoringWindows Word64) SomeMessage)
forall a. Maybe a
Nothing
        | Just BoringMessage
FocusMaster <- SomeMessage -> Maybe BoringMessage
forall m. Message m => SomeMessage -> Maybe m
fromMessage SomeMessage
m =
                            do (WindowSet -> WindowSet) -> X ()
windows ((WindowSet -> WindowSet) -> X ())
-> (WindowSet -> WindowSet) -> X ()
forall a b. (a -> b) -> a -> b
$ (Stack Word64 -> Stack Word64) -> WindowSet -> WindowSet
forall a i l s sd.
(Stack a -> Stack a) -> StackSet i l a s sd -> StackSet i l a s sd
W.modify'
                                            ((Stack Word64 -> Stack Word64) -> WindowSet -> WindowSet)
-> (Stack Word64 -> Stack Word64) -> WindowSet -> WindowSet
forall a b. (a -> b) -> a -> b
$ (Stack Word64 -> Stack Word64) -> Stack Word64 -> Stack Word64
skipBoring Stack Word64 -> Stack Word64
forall a. Stack a -> Stack a
W.focusDown' -- wiggle focus to make sure
                                            (Stack Word64 -> Stack Word64)
-> (Stack Word64 -> Stack Word64) -> Stack Word64 -> Stack Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Stack Word64 -> Stack Word64) -> Stack Word64 -> Stack Word64
skipBoring Stack Word64 -> Stack Word64
forall a. Stack a -> Stack a
W.focusUp'   -- no boring window gets the focus
                                            (Stack Word64 -> Stack Word64)
-> (Stack Word64 -> Stack Word64) -> Stack Word64 -> Stack Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Stack Word64 -> Stack Word64
forall a. Stack a -> Stack a
focusMaster'
                               Maybe (Either (BoringWindows Word64) SomeMessage)
-> X (Maybe (Either (BoringWindows Word64) SomeMessage))
forall a. a -> X a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Either (BoringWindows Word64) SomeMessage)
forall a. Maybe a
Nothing
        | Just BoringMessage
SwapUp <- SomeMessage -> Maybe BoringMessage
forall m. Message m => SomeMessage -> Maybe m
fromMessage SomeMessage
m =
                            do (WindowSet -> WindowSet) -> X ()
windows ((WindowSet -> WindowSet) -> X ())
-> (WindowSet -> WindowSet) -> X ()
forall a b. (a -> b) -> a -> b
$ (Stack Word64 -> Stack Word64) -> WindowSet -> WindowSet
forall a i l s sd.
(Stack a -> Stack a) -> StackSet i l a s sd -> StackSet i l a s sd
W.modify' Stack Word64 -> Stack Word64
skipBoringSwapUp
                               Maybe (Either (BoringWindows Word64) SomeMessage)
-> X (Maybe (Either (BoringWindows Word64) SomeMessage))
forall a. a -> X a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Either (BoringWindows Word64) SomeMessage)
forall a. Maybe a
Nothing
        | Just BoringMessage
SwapDown <- SomeMessage -> Maybe BoringMessage
forall m. Message m => SomeMessage -> Maybe m
fromMessage SomeMessage
m =
                            do (WindowSet -> WindowSet) -> X ()
windows ((WindowSet -> WindowSet) -> X ())
-> (WindowSet -> WindowSet) -> X ()
forall a b. (a -> b) -> a -> b
$ (Stack Word64 -> Stack Word64) -> WindowSet -> WindowSet
forall a i l s sd.
(Stack a -> Stack a) -> StackSet i l a s sd -> StackSet i l a s sd
W.modify' (Stack Word64 -> Stack Word64
forall a. Stack a -> Stack a
reverseS (Stack Word64 -> Stack Word64)
-> (Stack Word64 -> Stack Word64) -> Stack Word64 -> Stack Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Stack Word64 -> Stack Word64
skipBoringSwapUp (Stack Word64 -> Stack Word64)
-> (Stack Word64 -> Stack Word64) -> Stack Word64 -> Stack Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Stack Word64 -> Stack Word64
forall a. Stack a -> Stack a
reverseS)
                               Maybe (Either (BoringWindows Word64) SomeMessage)
-> X (Maybe (Either (BoringWindows Word64) SomeMessage))
forall a. a -> X a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Either (BoringWindows Word64) SomeMessage)
forall a. Maybe a
Nothing
        | Just BoringMessage
SiftUp <- SomeMessage -> Maybe BoringMessage
forall m. Message m => SomeMessage -> Maybe m
fromMessage SomeMessage
m =
                            do (WindowSet -> WindowSet) -> X ()
windows ((WindowSet -> WindowSet) -> X ())
-> (WindowSet -> WindowSet) -> X ()
forall a b. (a -> b) -> a -> b
$ (Stack Word64 -> Stack Word64) -> WindowSet -> WindowSet
forall a i l s sd.
(Stack a -> Stack a) -> StackSet i l a s sd -> StackSet i l a s sd
W.modify' ([Word64] -> Stack Word64 -> Stack Word64
forall a. Eq a => [a] -> Stack a -> Stack a
siftUpSkipping [Word64]
bs)
                               Maybe (Either (BoringWindows Word64) SomeMessage)
-> X (Maybe (Either (BoringWindows Word64) SomeMessage))
forall a. a -> X a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Either (BoringWindows Word64) SomeMessage)
forall a. Maybe a
Nothing
        | Just BoringMessage
SiftDown <- SomeMessage -> Maybe BoringMessage
forall m. Message m => SomeMessage -> Maybe m
fromMessage SomeMessage
m =
                            do (WindowSet -> WindowSet) -> X ()
windows ((WindowSet -> WindowSet) -> X ())
-> (WindowSet -> WindowSet) -> X ()
forall a b. (a -> b) -> a -> b
$ (Stack Word64 -> Stack Word64) -> WindowSet -> WindowSet
forall a i l s sd.
(Stack a -> Stack a) -> StackSet i l a s sd -> StackSet i l a s sd
W.modify' (Stack Word64 -> Stack Word64
forall a. Stack a -> Stack a
reverseS (Stack Word64 -> Stack Word64)
-> (Stack Word64 -> Stack Word64) -> Stack Word64 -> Stack Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word64] -> Stack Word64 -> Stack Word64
forall a. Eq a => [a] -> Stack a -> Stack a
siftUpSkipping [Word64]
bs (Stack Word64 -> Stack Word64)
-> (Stack Word64 -> Stack Word64) -> Stack Word64 -> Stack Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Stack Word64 -> Stack Word64
forall a. Stack a -> Stack a
reverseS)
                               Maybe (Either (BoringWindows Word64) SomeMessage)
-> X (Maybe (Either (BoringWindows Word64) SomeMessage))
forall a. a -> X a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Either (BoringWindows Word64) SomeMessage)
forall a. Maybe a
Nothing
        where skipBoring :: (Stack Word64 -> Stack Word64) -> Stack Word64 -> Stack Word64
skipBoring = (Stack Word64 -> Bool)
-> (Stack Word64 -> Stack Word64) -> Stack Word64 -> Stack Word64
forall {a}.
(Stack a -> Bool) -> (Stack a -> Stack a) -> Stack a -> Stack a
skipBoring' ((Word64 -> [Word64] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [Word64]
bs) (Word64 -> Bool)
-> (Stack Word64 -> Word64) -> Stack Word64 -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Stack Word64 -> Word64
forall a. Stack a -> a
W.focus)
              skipBoringSwapUp :: Stack Word64 -> Stack Word64
skipBoringSwapUp = (Stack Word64 -> Bool)
-> (Stack Word64 -> Stack Word64) -> Stack Word64 -> Stack Word64
forall {a}.
(Stack a -> Bool) -> (Stack a -> Stack a) -> Stack a -> Stack a
skipBoring'
                                   (Bool -> (Word64 -> Bool) -> Maybe Word64 -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
True (Word64 -> [Word64] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [Word64]
bs) (Maybe Word64 -> Bool)
-> (Stack Word64 -> Maybe Word64) -> Stack Word64 -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word64] -> Maybe Word64
forall a. [a] -> Maybe a
listToMaybe ([Word64] -> Maybe Word64)
-> (Stack Word64 -> [Word64]) -> Stack Word64 -> Maybe Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Stack Word64 -> [Word64]
forall a. Stack a -> [a]
W.down)
                                   Stack Word64 -> Stack Word64
forall a. Stack a -> Stack a
swapUp'
              skipBoring' :: (Stack a -> Bool) -> (Stack a -> Stack a) -> Stack a -> Stack a
skipBoring' Stack a -> Bool
p Stack a -> Stack a
f Stack a
st = Stack a -> Maybe (Stack a) -> Stack a
forall a. a -> Maybe a -> a
fromMaybe Stack a
st
                                   (Maybe (Stack a) -> Stack a) -> Maybe (Stack a) -> Stack a
forall a b. (a -> b) -> a -> b
$ (Stack a -> Bool) -> [Stack a] -> Maybe (Stack a)
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find Stack a -> Bool
p
                                   ([Stack a] -> Maybe (Stack a)) -> [Stack a] -> Maybe (Stack a)
forall a b. (a -> b) -> a -> b
$ Int -> [Stack a] -> [Stack a]
forall a. Int -> [a] -> [a]
drop Int
1
                                   ([Stack a] -> [Stack a]) -> [Stack a] -> [Stack a]
forall a b. (a -> b) -> a -> b
$ Int -> [Stack a] -> [Stack a]
forall a. Int -> [a] -> [a]
take ([a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([a] -> Int) -> [a] -> Int
forall a b. (a -> b) -> a -> b
$ Stack a -> [a]
forall a. Stack a -> [a]
W.integrate Stack a
st)
                                   ([Stack a] -> [Stack a]) -> [Stack a] -> [Stack a]
forall a b. (a -> b) -> a -> b
$ (Stack a -> Stack a) -> Stack a -> [Stack a]
forall a. (a -> a) -> a -> [a]
iterate Stack a -> Stack a
f Stack a
st
              bs :: [Word64]
bs = [[Word64]] -> [Word64]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[Word64]] -> [Word64]) -> [[Word64]] -> [Word64]
forall a b. (a -> b) -> a -> b
$ [Word64]
cbs[Word64] -> [[Word64]] -> [[Word64]]
forall a. a -> [a] -> [a]
:Maybe [Word64] -> [[Word64]]
forall a. Maybe a -> [a]
maybeToList Maybe [Word64]
lbs [[Word64]] -> [[Word64]] -> [[Word64]]
forall a. [a] -> [a] -> [a]
++ Map [Char] [Word64] -> [[Word64]]
forall k a. Map k a -> [a]
M.elems Map [Char] [Word64]
nbs
              rjl :: a -> X (Maybe (Either a b))
rjl = Maybe (Either a b) -> X (Maybe (Either a b))
forall a. a -> X a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (Either a b) -> X (Maybe (Either a b)))
-> (a -> Maybe (Either a b)) -> a -> X (Maybe (Either a b))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either a b -> Maybe (Either a b)
forall a. a -> Maybe a
Just (Either a b -> Maybe (Either a b))
-> (a -> Either a b) -> a -> Maybe (Either a b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either a b
forall a b. a -> Either a b
Left
    handleMessOrMaybeModifyIt BoringWindows Word64
_ SomeMessage
_ = Maybe (Either (BoringWindows Word64) SomeMessage)
-> X (Maybe (Either (BoringWindows Word64) SomeMessage))
forall a. a -> X a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Either (BoringWindows Word64) SomeMessage)
forall a. Maybe a
Nothing

-- | Variant of 'focusMaster' that works on a
-- 'Stack' rather than an entire 'StackSet'.
focusMaster' :: W.Stack a -> W.Stack a
focusMaster' :: forall a. Stack a -> Stack a
focusMaster' c :: Stack a
c@(W.Stack a
_ [] [a]
_) = Stack a
c
focusMaster' (W.Stack a
t (a
l:[a]
ls) [a]
rs) = a -> [a] -> [a] -> Stack a
forall a. a -> [a] -> [a] -> Stack a
W.Stack a
x [] ([a]
xs [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ a
t a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
rs) where (a
x :| [a]
xs) = NonEmpty a -> NonEmpty a
forall a. NonEmpty a -> NonEmpty a
NE.reverse (a
l a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| [a]
ls)

swapUp' :: W.Stack a -> W.Stack a
swapUp' :: forall a. Stack a -> Stack a
swapUp' (W.Stack a
t (a
l:[a]
ls) [a]
rs) = a -> [a] -> [a] -> Stack a
forall a. a -> [a] -> [a] -> Stack a
W.Stack a
t [a]
ls (a
la -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
rs)
swapUp' (W.Stack a
t []     [a]
rs) = a -> [a] -> [a] -> Stack a
forall a. a -> [a] -> [a] -> Stack a
W.Stack a
t ([a] -> [a]
forall a. [a] -> [a]
reverse [a]
rs) []

siftUpSkipping :: Eq a => [a] -> W.Stack a -> W.Stack a
siftUpSkipping :: forall a. Eq a => [a] -> Stack a -> Stack a
siftUpSkipping [a]
bs (W.Stack a
t [a]
ls [a]
rs)
  | ([a]
skips, a
l:[a]
ls') <- ([a], [a])
spanLeft  = a -> [a] -> [a] -> Stack a
forall a. a -> [a] -> [a] -> Stack a
W.Stack a
t [a]
ls' ([a] -> [a]
forall a. [a] -> [a]
reverse [a]
skips [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ a
l a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
rs)
  | ([a]
skips, a
r:[a]
rs') <- ([a], [a])
spanRight = a -> [a] -> [a] -> Stack a
forall a. a -> [a] -> [a] -> Stack a
W.Stack a
t ([a]
rs' [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ a
r a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
ls) ([a] -> [a]
forall a. [a] -> [a]
reverse [a]
skips)
  | Bool
otherwise                   = a -> [a] -> [a] -> Stack a
forall a. a -> [a] -> [a] -> Stack a
W.Stack a
t [a]
ls [a]
rs
  where
    spanLeft :: ([a], [a])
spanLeft  = (a -> Bool) -> [a] -> ([a], [a])
forall a. (a -> Bool) -> [a] -> ([a], [a])
span (a -> [a] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [a]
bs) [a]
ls
    spanRight :: ([a], [a])
spanRight = (a -> Bool) -> [a] -> ([a], [a])
forall a. (a -> Bool) -> [a] -> ([a], [a])
span (a -> [a] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [a]
bs) ([a] -> [a]
forall a. [a] -> [a]
reverse [a]
rs)

{- $simplest

An alternative to 'Full' is "XMonad.Layout.Simplest".  Less windows are
ignored by 'focusUp' and 'focusDown'. This may be helpful when you want windows
to be uninteresting by some other layout modifier (ex.
"XMonad.Layout.Minimize")

-}