{-# LANGUAGE CPP #-}
module Xmobar.Run.Loop (LoopFunction, loop) where
import Control.Concurrent (forkIO)
import Control.Exception (bracket_, bracket, handle, SomeException(..))
import Control.Concurrent.STM
import Control.Concurrent.Async (Async, async, cancel)
import Control.Monad (guard, void, unless)
import Data.Maybe (isJust)
import Data.Foldable (for_)
import Xmobar.System.Signal
import Xmobar.Config.Types
import Xmobar.Run.Runnable (Runnable)
import Xmobar.Run.Exec (start, trigger, alias)
import Xmobar.Run.Template
import Xmobar.Run.Timer (withTimer)
#ifdef DBUS
import Xmobar.System.DBus
#endif
newRefreshLock :: IO (TMVar ())
newRefreshLock :: IO (TMVar ())
newRefreshLock = () -> IO (TMVar ())
forall a. a -> IO (TMVar a)
newTMVarIO ()
refreshLock :: TMVar () -> IO a -> IO a
refreshLock :: forall a. TMVar () -> IO a -> IO a
refreshLock TMVar ()
var = IO () -> IO () -> IO a -> IO a
forall a b c. IO a -> IO b -> IO c -> IO c
bracket_ IO ()
lock IO ()
unlock
where
lock :: IO ()
lock = STM () -> IO ()
forall a. STM a -> IO a
atomically (STM () -> IO ()) -> STM () -> IO ()
forall a b. (a -> b) -> a -> b
$ TMVar () -> STM ()
forall a. TMVar a -> STM a
takeTMVar TMVar ()
var
unlock :: IO ()
unlock = STM () -> IO ()
forall a. STM a -> IO a
atomically (STM () -> IO ()) -> STM () -> IO ()
forall a b. (a -> b) -> a -> b
$ TMVar () -> () -> STM ()
forall a. TMVar a -> a -> STM ()
putTMVar TMVar ()
var ()
refreshLockT :: TMVar () -> STM a -> STM a
refreshLockT :: forall a. TMVar () -> STM a -> STM a
refreshLockT TMVar ()
var STM a
action = do
TMVar () -> STM ()
forall a. TMVar a -> STM a
takeTMVar TMVar ()
var
r <- STM a
action
putTMVar var ()
return r
type LoopFunction = TMVar SignalType -> TVar [String] -> IO ()
loop :: Config -> LoopFunction -> IO ()
loop :: Config -> LoopFunction -> IO ()
loop Config
conf LoopFunction
looper = IO () -> IO ()
forall a. IO a -> IO a
withDeferSignals (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
let cls :: [[(Runnable, [Char], [Char])]]
cls = ([Char] -> [(Runnable, [Char], [Char])])
-> [[Char]] -> [[(Runnable, [Char], [Char])]]
forall a b. (a -> b) -> [a] -> [b]
map ([Runnable] -> [Char] -> [Char] -> [(Runnable, [Char], [Char])]
parseTemplate (Config -> [Runnable]
commands Config
conf) (Config -> [Char]
sepChar Config
conf))
([Char] -> [Char] -> [[Char]]
splitTemplate (Config -> [Char]
alignSep Config
conf) (Config -> [Char]
template Config
conf))
let confSig :: Maybe (TMVar SignalType)
confSig = SignalChan -> Maybe (TMVar SignalType)
unSignalChan (Config -> SignalChan
signal Config
conf)
sig <- IO (TMVar SignalType)
-> (TMVar SignalType -> IO (TMVar SignalType))
-> Maybe (TMVar SignalType)
-> IO (TMVar SignalType)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe IO (TMVar SignalType)
forall a. IO (TMVar a)
newEmptyTMVarIO TMVar SignalType -> IO (TMVar SignalType)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (TMVar SignalType)
confSig
unless (isJust confSig) $ setupSignalHandler sig
refLock <- newRefreshLock
withTimer (refreshLock refLock) $
bracket (mapM (mapM $ startCommand sig) cls)
cleanupThreads
$ \[[([Async ()], TVar [Char])]]
vars -> do
tv <- TMVar SignalType
-> TMVar () -> [[([Async ()], TVar [Char])]] -> IO (TVar [[Char]])
initLoop TMVar SignalType
sig TMVar ()
refLock [[([Async ()], TVar [Char])]]
vars
looper sig tv
cleanupThreads :: [[([Async ()], a)]] -> IO ()
cleanupThreads :: forall a. [[([Async ()], a)]] -> IO ()
cleanupThreads [[([Async ()], a)]]
vars =
[([Async ()], a)] -> (([Async ()], a) -> IO ()) -> IO ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ ([[([Async ()], a)]] -> [([Async ()], a)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[([Async ()], a)]]
vars) ((([Async ()], a) -> IO ()) -> IO ())
-> (([Async ()], a) -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \([Async ()]
asyncs, a
_) ->
[Async ()] -> (Async () -> IO ()) -> IO ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Async ()]
asyncs Async () -> IO ()
forall a. Async a -> IO ()
cancel
initLoop :: TMVar SignalType -> TMVar () -> [[([Async ()], TVar String)]]
-> IO (TVar [String])
initLoop :: TMVar SignalType
-> TMVar () -> [[([Async ()], TVar [Char])]] -> IO (TVar [[Char]])
initLoop TMVar SignalType
sig TMVar ()
lock [[([Async ()], TVar [Char])]]
vs = do
tv <- [[Char]] -> IO (TVar [[Char]])
forall a. a -> IO (TVar a)
newTVarIO ([] :: [String])
_ <- forkIO (handle (handler "checker") (checker tv [] vs sig lock))
#ifdef DBUS
runIPC sig
#endif
return tv
where
handler :: [Char] -> SomeException -> IO ()
handler [Char]
thing (SomeException e
e) =
IO () -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ [Char] -> IO ()
putStrLn ([Char]
"Thread " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
thing [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" failed: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ e -> [Char]
forall a. Show a => a -> [Char]
show e
e)
startCommand :: TMVar SignalType
-> (Runnable,String,String)
-> IO ([Async ()], TVar String)
startCommand :: TMVar SignalType
-> (Runnable, [Char], [Char]) -> IO ([Async ()], TVar [Char])
startCommand TMVar SignalType
sig (Runnable
com,[Char]
s,[Char]
ss)
| Runnable -> [Char]
forall e. Exec e => e -> [Char]
alias Runnable
com [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
"" = do var <- [Char] -> IO (TVar [Char])
forall a. a -> IO (TVar a)
newTVarIO [Char]
is
atomically $ writeTVar var (s ++ ss)
return ([], var)
| Bool
otherwise = do var <- [Char] -> IO (TVar [Char])
forall a. a -> IO (TVar a)
newTVarIO [Char]
is
let cb [Char]
str = STM () -> IO ()
forall a. STM a -> IO a
atomically (STM () -> IO ()) -> STM () -> IO ()
forall a b. (a -> b) -> a -> b
$ TVar [Char] -> [Char] -> STM ()
forall a. TVar a -> a -> STM ()
writeTVar TVar [Char]
var ([Char]
s [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
str [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
ss)
a1 <- async $ start com cb
a2 <- async $ trigger com $ maybe (return ())
(atomically . putTMVar sig)
return ([a1, a2], var)
where is :: [Char]
is = [Char]
s [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"Updating..." [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
ss
checker :: TVar [String]
-> [String]
-> [[([Async ()], TVar String)]]
-> TMVar SignalType
-> TMVar ()
-> IO ()
checker :: TVar [[Char]]
-> [[Char]]
-> [[([Async ()], TVar [Char])]]
-> TMVar SignalType
-> TMVar ()
-> IO ()
checker TVar [[Char]]
tvar [[Char]]
ov [[([Async ()], TVar [Char])]]
vs TMVar SignalType
sig TMVar ()
pauser = do
nval <- STM [[Char]] -> IO [[Char]]
forall a. STM a -> IO a
atomically (STM [[Char]] -> IO [[Char]]) -> STM [[Char]] -> IO [[Char]]
forall a b. (a -> b) -> a -> b
$ TMVar () -> STM [[Char]] -> STM [[Char]]
forall a. TMVar () -> STM a -> STM a
refreshLockT TMVar ()
pauser (STM [[Char]] -> STM [[Char]]) -> STM [[Char]] -> STM [[Char]]
forall a b. (a -> b) -> a -> b
$ do
nv <- ([([Async ()], TVar [Char])] -> STM [Char])
-> [[([Async ()], TVar [Char])]] -> STM [[Char]]
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 [([Async ()], TVar [Char])] -> STM [Char]
forall {a} {a}. [(a, TVar [a])] -> STM [a]
concatV [[([Async ()], TVar [Char])]]
vs
guard (nv /= ov)
writeTVar tvar nv
return nv
atomically $ putTMVar sig Wakeup
checker tvar nval vs sig pauser
where
concatV :: [(a, TVar [a])] -> STM [a]
concatV = ([[a]] -> [a]) -> STM [[a]] -> STM [a]
forall a b. (a -> b) -> STM a -> STM b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [[a]] -> [a]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat (STM [[a]] -> STM [a])
-> ([(a, TVar [a])] -> STM [[a]]) -> [(a, TVar [a])] -> STM [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((a, TVar [a]) -> STM [a]) -> [(a, TVar [a])] -> STM [[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 (TVar [a] -> STM [a]
forall a. TVar a -> STM a
readTVar (TVar [a] -> STM [a])
-> ((a, TVar [a]) -> TVar [a]) -> (a, TVar [a]) -> STM [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, TVar [a]) -> TVar [a]
forall a b. (a, b) -> b
snd)