-----------------------------------------------------------------------------
-- |
-- Module      :  Plugins.MarqueePipeReader
-- Copyright   :  (c) Reto Habluetzel
-- License     :  BSD-style (see LICENSE)
--
-- Maintainer  :  Jose A. Ortega Ruiz <jao@gnu.org>
-- Stability   :  unstable
-- Portability :  unportable
--
-- A plugin for reading from named pipes for long texts with marquee
--
-----------------------------------------------------------------------------

module Xmobar.Plugins.MarqueePipeReader(MarqueePipeReader(..)) where

import System.IO (openFile, IOMode(ReadWriteMode), Handle, hGetLine)
import Xmobar.System.Environment
import Xmobar.Run.Exec(Exec(alias, start), tenthSeconds)
import System.Posix.Files (getFileStatus, isNamedPipe)
import Control.Concurrent(forkIO, threadDelay)
import Control.Concurrent.STM (TChan, atomically, writeTChan, tryReadTChan, newTChan)
import Control.Exception
import Control.Monad(forever, unless)

type Length = Int       -- length of the text to display
type Rate = Int         -- delay in tenth seconds
type Separator = String -- if text wraps around, use separator

data MarqueePipeReader = MarqueePipeReader String (Length, Rate, Separator) String
    deriving (ReadPrec [MarqueePipeReader]
ReadPrec MarqueePipeReader
Int -> ReadS MarqueePipeReader
ReadS [MarqueePipeReader]
(Int -> ReadS MarqueePipeReader)
-> ReadS [MarqueePipeReader]
-> ReadPrec MarqueePipeReader
-> ReadPrec [MarqueePipeReader]
-> Read MarqueePipeReader
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MarqueePipeReader
readsPrec :: Int -> ReadS MarqueePipeReader
$creadList :: ReadS [MarqueePipeReader]
readList :: ReadS [MarqueePipeReader]
$creadPrec :: ReadPrec MarqueePipeReader
readPrec :: ReadPrec MarqueePipeReader
$creadListPrec :: ReadPrec [MarqueePipeReader]
readListPrec :: ReadPrec [MarqueePipeReader]
Read, Int -> MarqueePipeReader -> ShowS
[MarqueePipeReader] -> ShowS
MarqueePipeReader -> [Char]
(Int -> MarqueePipeReader -> ShowS)
-> (MarqueePipeReader -> [Char])
-> ([MarqueePipeReader] -> ShowS)
-> Show MarqueePipeReader
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MarqueePipeReader -> ShowS
showsPrec :: Int -> MarqueePipeReader -> ShowS
$cshow :: MarqueePipeReader -> [Char]
show :: MarqueePipeReader -> [Char]
$cshowList :: [MarqueePipeReader] -> ShowS
showList :: [MarqueePipeReader] -> ShowS
Show)

instance Exec MarqueePipeReader where
    alias :: MarqueePipeReader -> [Char]
alias (MarqueePipeReader [Char]
_ (Int, Int, [Char])
_ [Char]
a)    = [Char]
a
    start :: MarqueePipeReader -> ([Char] -> IO ()) -> IO ()
start (MarqueePipeReader [Char]
p (Int
len, Int
rate, [Char]
sep) [Char]
_) [Char] -> IO ()
cb = do
        (def, pipe) <- Char -> [Char] -> ([Char], [Char])
forall {a}. Eq a => a -> [a] -> ([a], [a])
split Char
':' ([Char] -> ([Char], [Char])) -> IO [Char] -> IO ([Char], [Char])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> IO [Char]
expandEnv [Char]
p
        unless (null def) (cb def)
        checkPipe pipe
        h <- openFile pipe ReadWriteMode
        line <- hGetLine h
        chan <- atomically newTChan
        forkIO $ writer (toInfTxt line sep) sep len rate chan cb
        forever $ pipeToChan h chan
      where
        split :: a -> [a] -> ([a], [a])
split a
c [a]
xs | a
c a -> [a] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [a]
xs = let ([a]
pre, [a]
post) = (a -> Bool) -> [a] -> ([a], [a])
forall a. (a -> Bool) -> [a] -> ([a], [a])
span (a
c a -> a -> Bool
forall a. Eq a => a -> a -> Bool
/=) [a]
xs
                                   in ([a]
pre, (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
dropWhile (a
c a -> a -> Bool
forall a. Eq a => a -> a -> Bool
==) [a]
post)
                   | Bool
otherwise   = ([], [a]
xs)

pipeToChan :: Handle -> TChan String -> IO ()
pipeToChan :: Handle -> TChan [Char] -> IO ()
pipeToChan Handle
h TChan [Char]
chan = do
    line <- Handle -> IO [Char]
hGetLine Handle
h
    atomically $ writeTChan chan line

writer :: String -> Separator -> Length -> Rate -> TChan String -> (String -> IO ()) -> IO ()
writer :: [Char]
-> [Char]
-> Int
-> Int
-> TChan [Char]
-> ([Char] -> IO ())
-> IO ()
writer [Char]
txt [Char]
sep Int
len Int
rate TChan [Char]
chan [Char] -> IO ()
cb = do
    [Char] -> IO ()
cb (Int -> ShowS
forall a. Int -> [a] -> [a]
take Int
len [Char]
txt)
    mbnext <- STM (Maybe [Char]) -> IO (Maybe [Char])
forall a. STM a -> IO a
atomically (STM (Maybe [Char]) -> IO (Maybe [Char]))
-> STM (Maybe [Char]) -> IO (Maybe [Char])
forall a b. (a -> b) -> a -> b
$ TChan [Char] -> STM (Maybe [Char])
forall a. TChan a -> STM (Maybe a)
tryReadTChan TChan [Char]
chan
    case mbnext of
        Just [Char]
new -> [Char]
-> [Char]
-> Int
-> Int
-> TChan [Char]
-> ([Char] -> IO ())
-> IO ()
writer ([Char] -> ShowS
toInfTxt [Char]
new [Char]
sep) [Char]
sep Int
len Int
rate TChan [Char]
chan [Char] -> IO ()
cb
        Maybe [Char]
Nothing -> Int -> IO ()
tenthSeconds Int
rate IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Char]
-> Int
-> Int
-> TChan [Char]
-> ([Char] -> IO ())
-> IO ()
writer (Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
1 [Char]
txt) [Char]
sep Int
len Int
rate TChan [Char]
chan [Char] -> IO ()
cb

toInfTxt :: String -> String -> String
toInfTxt :: [Char] -> ShowS
toInfTxt [Char]
line [Char]
sep = ShowS
forall a. HasCallStack => [a] -> [a]
cycle ([Char]
line [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
sep [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" ")

checkPipe :: FilePath -> IO ()
checkPipe :: [Char] -> IO ()
checkPipe [Char]
file = (SomeException -> IO ()) -> IO () -> IO ()
forall e a. Exception e => (e -> IO a) -> IO a -> IO a
handle (\(SomeException e
_) -> IO ()
waitForPipe) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
                    status <- [Char] -> IO FileStatus
getFileStatus [Char]
file
                    unless (isNamedPipe status) waitForPipe
    where waitForPipe :: IO ()
waitForPipe = Int -> IO ()
threadDelay Int
1000 IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> IO ()
checkPipe [Char]
file