-----------------------------------------------------------------------------
-- |
-- Module      :  XMonad.Hooks.ToggleHook
-- Description :  Hook and keybindings for toggling hook behavior.
-- Copyright   :  Ben Boeckel <mathstuf@gmail.com>
-- License     :  BSD-style (see LICENSE)
--
-- Maintainer  :  Ben Boeckel <mathstuf@gmail.com>
-- Stability   :  unstable
-- Portability :  unportable
--
-- Hook and keybindings for toggling hook behavior.
-----------------------------------------------------------------------------

module XMonad.Hooks.ToggleHook ( -- * Usage
                                 -- $usage

                                 -- * The hook
                                 toggleHook
                               , toggleHook'

                                 -- * Actions
                               , hookNext
                               , toggleHookNext
                               , hookAllNew
                               , toggleHookAllNew

                                 -- * Queries
                               , willHook
                               , willHookNext
                               , willHookAllNew

                                 -- * Status bar utilities
                                 -- $pp
                               , willHookNextPP
                               , willHookAllNewPP
                               , runLogHook ) where

import Prelude hiding (all)

import XMonad
import XMonad.Prelude (guard, join)
import qualified XMonad.Util.ExtensibleState as XS

import Control.Arrow (first, second)

import Data.Map

{- Helper functions -}

_set :: String -> ((a -> a) -> (Bool, Bool) -> (Bool, Bool)) -> a -> X ()
_set :: forall a.
[Char] -> ((a -> a) -> (Bool, Bool) -> (Bool, Bool)) -> a -> X ()
_set [Char]
n (a -> a) -> (Bool, Bool) -> (Bool, Bool)
f a
b = [Char] -> ((Bool, Bool) -> (Bool, Bool)) -> X ()
modify' [Char]
n ((a -> a) -> (Bool, Bool) -> (Bool, Bool)
f ((a -> a) -> (Bool, Bool) -> (Bool, Bool))
-> (a -> a) -> (Bool, Bool) -> (Bool, Bool)
forall a b. (a -> b) -> a -> b
$ a -> a -> a
forall a b. a -> b -> a
const a
b)

_toggle :: String -> ((Bool -> Bool) -> (Bool, Bool) -> (Bool, Bool)) -> X ()
_toggle :: [Char] -> ((Bool -> Bool) -> (Bool, Bool) -> (Bool, Bool)) -> X ()
_toggle [Char]
n (Bool -> Bool) -> (Bool, Bool) -> (Bool, Bool)
f = [Char] -> ((Bool, Bool) -> (Bool, Bool)) -> X ()
modify' [Char]
n ((Bool -> Bool) -> (Bool, Bool) -> (Bool, Bool)
f Bool -> Bool
not)

_get :: String -> ((Bool, Bool) -> a) -> X a
_get :: forall a. [Char] -> ((Bool, Bool) -> a) -> X a
_get [Char]
n (Bool, Bool) -> a
f = (HookState -> a) -> X a
forall a (m :: * -> *) b.
(ExtensionClass a, XLike m) =>
(a -> b) -> m b
XS.gets ((HookState -> a) -> X a) -> (HookState -> a) -> X a
forall a b. (a -> b) -> a -> b
$ (Bool, Bool) -> a
f ((Bool, Bool) -> a)
-> (HookState -> (Bool, Bool)) -> HookState -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Bool, Bool) -> [Char] -> Map [Char] (Bool, Bool) -> (Bool, Bool)
forall k a. Ord k => a -> k -> Map k a -> a
findWithDefault (Bool
False, Bool
False) [Char]
n (Map [Char] (Bool, Bool) -> (Bool, Bool))
-> (HookState -> Map [Char] (Bool, Bool))
-> HookState
-> (Bool, Bool)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HookState -> Map [Char] (Bool, Bool)
hooks)

_pp :: String -> ((Bool, Bool) -> Bool) -> String -> (String -> String) -> X (Maybe String)
_pp :: [Char]
-> ((Bool, Bool) -> Bool)
-> [Char]
-> ([Char] -> [Char])
-> X (Maybe [Char])
_pp [Char]
n (Bool, Bool) -> Bool
f [Char]
s [Char] -> [Char]
st = (\Bool
b -> Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard Bool
b Maybe () -> Maybe [Char] -> Maybe [Char]
forall a b. Maybe a -> Maybe b -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just ([Char] -> [Char]
st [Char]
s)) (Bool -> Maybe [Char]) -> X Bool -> X (Maybe [Char])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> ((Bool, Bool) -> Bool) -> X Bool
forall a. [Char] -> ((Bool, Bool) -> a) -> X a
_get [Char]
n (Bool, Bool) -> Bool
f

{- The current state is kept here -}

newtype HookState = HookState { HookState -> Map [Char] (Bool, Bool)
hooks :: Map String (Bool, Bool) } deriving (ReadPrec [HookState]
ReadPrec HookState
Int -> ReadS HookState
ReadS [HookState]
(Int -> ReadS HookState)
-> ReadS [HookState]
-> ReadPrec HookState
-> ReadPrec [HookState]
-> Read HookState
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS HookState
readsPrec :: Int -> ReadS HookState
$creadList :: ReadS [HookState]
readList :: ReadS [HookState]
$creadPrec :: ReadPrec HookState
readPrec :: ReadPrec HookState
$creadListPrec :: ReadPrec [HookState]
readListPrec :: ReadPrec [HookState]
Read, Int -> HookState -> [Char] -> [Char]
[HookState] -> [Char] -> [Char]
HookState -> [Char]
(Int -> HookState -> [Char] -> [Char])
-> (HookState -> [Char])
-> ([HookState] -> [Char] -> [Char])
-> Show HookState
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
$cshowsPrec :: Int -> HookState -> [Char] -> [Char]
showsPrec :: Int -> HookState -> [Char] -> [Char]
$cshow :: HookState -> [Char]
show :: HookState -> [Char]
$cshowList :: [HookState] -> [Char] -> [Char]
showList :: [HookState] -> [Char] -> [Char]
Show)

instance ExtensionClass HookState where
    initialValue :: HookState
initialValue = Map [Char] (Bool, Bool) -> HookState
HookState Map [Char] (Bool, Bool)
forall k a. Map k a
empty
    extensionType :: HookState -> StateExtension
extensionType = HookState -> StateExtension
forall a. (Read a, Show a, ExtensionClass a) => a -> StateExtension
PersistentExtension

modify' :: String -> ((Bool, Bool) -> (Bool, Bool)) -> X ()
modify' :: [Char] -> ((Bool, Bool) -> (Bool, Bool)) -> X ()
modify' [Char]
n (Bool, Bool) -> (Bool, Bool)
f = (HookState -> HookState) -> X ()
forall a (m :: * -> *).
(ExtensionClass a, XLike m) =>
(a -> a) -> m ()
XS.modify (Map [Char] (Bool, Bool) -> HookState
HookState (Map [Char] (Bool, Bool) -> HookState)
-> (HookState -> Map [Char] (Bool, Bool)) -> HookState -> HookState
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map [Char] (Bool, Bool) -> Map [Char] (Bool, Bool)
setter (Map [Char] (Bool, Bool) -> Map [Char] (Bool, Bool))
-> (HookState -> Map [Char] (Bool, Bool))
-> HookState
-> Map [Char] (Bool, Bool)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HookState -> Map [Char] (Bool, Bool)
hooks)
    where
        setter :: Map [Char] (Bool, Bool) -> Map [Char] (Bool, Bool)
setter Map [Char] (Bool, Bool)
m = [Char]
-> (Bool, Bool)
-> Map [Char] (Bool, Bool)
-> Map [Char] (Bool, Bool)
forall k a. Ord k => k -> a -> Map k a -> Map k a
insert [Char]
n ((Bool, Bool) -> (Bool, Bool)
f ((Bool, Bool) -> [Char] -> Map [Char] (Bool, Bool) -> (Bool, Bool)
forall k a. Ord k => a -> k -> Map k a -> a
findWithDefault (Bool
False, Bool
False) [Char]
n Map [Char] (Bool, Bool)
m)) Map [Char] (Bool, Bool)
m

-- $usage
-- This module provides actions (that can be set as keybindings)
-- to be able to cause hooks to be occur on a conditional basis.
--
-- You can use it by including the following in your @xmonad.hs@:
--
-- > import XMonad.Hooks.ToggleHook
--
-- and adding 'toggleHook name hook' to your 'ManageHook' where @name@ is the
-- name of the hook and @hook@ is the hook to execute based on the state.
--
-- > myManageHook = toggleHook "float" doFloat <> manageHook def
--
-- Additionally, toggleHook' is provided to toggle between two hooks (rather
-- than on/off).
--
-- > myManageHook = toggleHook' "oldfocus" (const id) W.focusWindow <> manageHook def
--
-- The 'hookNext' and 'toggleHookNext' functions can be used in key
-- bindings to set whether the hook is applied or not.
--
-- > , ((modm, xK_e), toggleHookNext "float")
--
-- 'hookAllNew' and 'toggleHookAllNew' are similar but float all
-- spawned windows until disabled again.
--
-- > , ((modm, xK_r), toggleHookAllNew "float")

-- | This 'ManageHook' will selectively apply a hook as set
-- by 'hookNext' and 'hookAllNew'.
toggleHook :: String -> ManageHook -> ManageHook
toggleHook :: [Char] -> Query (Endo WindowSet) -> Query (Endo WindowSet)
toggleHook [Char]
n Query (Endo WindowSet)
h = [Char]
-> Query (Endo WindowSet)
-> Query (Endo WindowSet)
-> Query (Endo WindowSet)
toggleHook' [Char]
n Query (Endo WindowSet)
h Query (Endo WindowSet)
forall m. Monoid m => m
idHook

toggleHook' :: String -> ManageHook -> ManageHook -> ManageHook
toggleHook' :: [Char]
-> Query (Endo WindowSet)
-> Query (Endo WindowSet)
-> Query (Endo WindowSet)
toggleHook' [Char]
n Query (Endo WindowSet)
th Query (Endo WindowSet)
fh = do m <- X (Map [Char] (Bool, Bool)) -> Query (Map [Char] (Bool, Bool))
forall a. X a -> Query a
liftX (X (Map [Char] (Bool, Bool)) -> Query (Map [Char] (Bool, Bool)))
-> X (Map [Char] (Bool, Bool)) -> Query (Map [Char] (Bool, Bool))
forall a b. (a -> b) -> a -> b
$ (HookState -> Map [Char] (Bool, Bool))
-> X (Map [Char] (Bool, Bool))
forall a (m :: * -> *) b.
(ExtensionClass a, XLike m) =>
(a -> b) -> m b
XS.gets HookState -> Map [Char] (Bool, Bool)
hooks
                         (next, all) <- return $ findWithDefault (False, False) n m
                         liftX $ XS.put $ HookState $ insert n (False, all) m
                         if next || all then th else fh

-- | @hookNext name True@ arranges for the next spawned window to
-- have the hook @name@ applied, @hookNext name False@ cancels it.
hookNext :: String -> Bool -> X ()
hookNext :: [Char] -> Bool -> X ()
hookNext [Char]
n = [Char]
-> ((Bool -> Bool) -> (Bool, Bool) -> (Bool, Bool)) -> Bool -> X ()
forall a.
[Char] -> ((a -> a) -> (Bool, Bool) -> (Bool, Bool)) -> a -> X ()
_set [Char]
n (Bool -> Bool) -> (Bool, Bool) -> (Bool, Bool)
forall b c d. (b -> c) -> (b, d) -> (c, d)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first

toggleHookNext :: String -> X ()
toggleHookNext :: [Char] -> X ()
toggleHookNext [Char]
n = [Char] -> ((Bool -> Bool) -> (Bool, Bool) -> (Bool, Bool)) -> X ()
_toggle [Char]
n (Bool -> Bool) -> (Bool, Bool) -> (Bool, Bool)
forall b c d. (b -> c) -> (b, d) -> (c, d)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first

-- | @hookAllNew name True@ arranges for new windows to
-- have the hook @name@ applied, @hookAllNew name False@ cancels it
hookAllNew :: String -> Bool -> X ()
hookAllNew :: [Char] -> Bool -> X ()
hookAllNew [Char]
n = [Char]
-> ((Bool -> Bool) -> (Bool, Bool) -> (Bool, Bool)) -> Bool -> X ()
forall a.
[Char] -> ((a -> a) -> (Bool, Bool) -> (Bool, Bool)) -> a -> X ()
_set [Char]
n (Bool -> Bool) -> (Bool, Bool) -> (Bool, Bool)
forall b c d. (b -> c) -> (d, b) -> (d, c)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (d, b) (d, c)
second

toggleHookAllNew :: String -> X ()
toggleHookAllNew :: [Char] -> X ()
toggleHookAllNew [Char]
n = [Char] -> ((Bool -> Bool) -> (Bool, Bool) -> (Bool, Bool)) -> X ()
_toggle [Char]
n (Bool -> Bool) -> (Bool, Bool) -> (Bool, Bool)
forall b c d. (b -> c) -> (d, b) -> (d, c)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (d, b) (d, c)
second

-- | Query what will happen at the next ManageHook call for the hook @name@.
willHook :: String -> X Bool
willHook :: [Char] -> X Bool
willHook [Char]
n = [Char] -> X Bool
willHookNext [Char]
n X Bool -> X Bool -> X Bool
forall (m :: * -> *). Monad m => m Bool -> m Bool -> m Bool
<||> [Char] -> X Bool
willHookAllNew [Char]
n

-- | Whether the next window will trigger the hook @name@.
willHookNext :: String -> X Bool
willHookNext :: [Char] -> X Bool
willHookNext [Char]
n = [Char] -> ((Bool, Bool) -> Bool) -> X Bool
forall a. [Char] -> ((Bool, Bool) -> a) -> X a
_get [Char]
n (Bool, Bool) -> Bool
forall a b. (a, b) -> a
fst

-- | Whether new windows will trigger the hook @name@.
willHookAllNew :: String -> X Bool
willHookAllNew :: [Char] -> X Bool
willHookAllNew [Char]
n = [Char] -> ((Bool, Bool) -> Bool) -> X Bool
forall a. [Char] -> ((Bool, Bool) -> a) -> X a
_get [Char]
n (Bool, Bool) -> Bool
forall a b. (a, b) -> b
snd

-- $pp
-- The following functions are used to display the current
-- state of 'hookNext' and 'hookAllNew' in your
-- "XMonad.Hooks.StatusBar". 'willHookNextPP' and
-- 'willHookAllNewPP' should be added to the
-- 'XMonad.Hooks.StatusBar.PP.ppExtras' field of your
-- "XMonad.Hooks.StatusBar.PP".
--
-- Use 'runLogHook' to refresh the output of your 'logHook', so
-- that the effects of a 'hookNext'/... will be visible
-- immediately:
--
-- > , ((modm, xK_e), toggleHookNext "float" >> runLogHook)
--
-- The @String -> String@ parameters to 'willHookNextPP' and
-- 'willHookAllNewPP' will be applied to their output, you
-- can use them to set the text color, etc., or you can just
-- pass them 'id'.

willHookNextPP :: String -> (String -> String) -> X (Maybe String)
willHookNextPP :: [Char] -> ([Char] -> [Char]) -> X (Maybe [Char])
willHookNextPP [Char]
n = [Char]
-> ((Bool, Bool) -> Bool)
-> [Char]
-> ([Char] -> [Char])
-> X (Maybe [Char])
_pp [Char]
n (Bool, Bool) -> Bool
forall a b. (a, b) -> a
fst [Char]
"Next"

willHookAllNewPP :: String -> (String -> String) -> X (Maybe String)
willHookAllNewPP :: [Char] -> ([Char] -> [Char]) -> X (Maybe [Char])
willHookAllNewPP [Char]
n = [Char]
-> ((Bool, Bool) -> Bool)
-> [Char]
-> ([Char] -> [Char])
-> X (Maybe [Char])
_pp [Char]
n (Bool, Bool) -> Bool
forall a b. (a, b) -> b
snd [Char]
"All"

runLogHook :: X ()
runLogHook :: X ()
runLogHook = X (X ()) -> X ()
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (X (X ()) -> X ()) -> X (X ()) -> X ()
forall a b. (a -> b) -> a -> b
$ (XConf -> X ()) -> X (X ())
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks ((XConf -> X ()) -> X (X ())) -> (XConf -> X ()) -> X (X ())
forall a b. (a -> b) -> a -> b
$ XConfig Layout -> X ()
forall (l :: * -> *). XConfig l -> X ()
logHook (XConfig Layout -> X ())
-> (XConf -> XConfig Layout) -> XConf -> X ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. XConf -> XConfig Layout
config