{-# LANGUAGE CPP #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  Plugins.StdinReader
-- Copyright   :  (c) Spencer Janssen
-- License     :  BSD-style (see LICENSE)
--
-- Maintainer  :  Spencer Janssen <spencerjanssen@gmail.com>
-- Stability   :  unstable
-- Portability :  unportable
--
-- A plugin to display information from _XMONAD_LOG, specified at
-- http://code.haskell.org/XMonadContrib/XMonad/Hooks/DynamicLog.hs
--
-----------------------------------------------------------------------------

module Xmobar.Plugins.XMonadLog (XMonadLog(..)) where

import Control.Monad
import Graphics.X11
import Graphics.X11.Xlib.Extras
import Xmobar.Run.Exec
import Xmobar.Run.Actions (stripActions)

import Codec.Binary.UTF8.String as UTF8
import Foreign.C (CChar)
import Data.List (intercalate)
import Xmobar.X11.Events (nextEvent')

data XMonadLog = XMonadLog
               | UnsafeXMonadLog
               | XPropertyLog String
               | UnsafeXPropertyLog String
               | NamedXPropertyLog String String
               | UnsafeNamedXPropertyLog String String
    deriving (ReadPrec [XMonadLog]
ReadPrec XMonadLog
Int -> ReadS XMonadLog
ReadS [XMonadLog]
(Int -> ReadS XMonadLog)
-> ReadS [XMonadLog]
-> ReadPrec XMonadLog
-> ReadPrec [XMonadLog]
-> Read XMonadLog
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS XMonadLog
readsPrec :: Int -> ReadS XMonadLog
$creadList :: ReadS [XMonadLog]
readList :: ReadS [XMonadLog]
$creadPrec :: ReadPrec XMonadLog
readPrec :: ReadPrec XMonadLog
$creadListPrec :: ReadPrec [XMonadLog]
readListPrec :: ReadPrec [XMonadLog]
Read, Int -> XMonadLog -> ShowS
[XMonadLog] -> ShowS
XMonadLog -> [Char]
(Int -> XMonadLog -> ShowS)
-> (XMonadLog -> [Char])
-> ([XMonadLog] -> ShowS)
-> Show XMonadLog
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> XMonadLog -> ShowS
showsPrec :: Int -> XMonadLog -> ShowS
$cshow :: XMonadLog -> [Char]
show :: XMonadLog -> [Char]
$cshowList :: [XMonadLog] -> ShowS
showList :: [XMonadLog] -> ShowS
Show)

instance Exec XMonadLog where
    alias :: XMonadLog -> [Char]
alias XMonadLog
XMonadLog = [Char]
"XMonadLog"
    alias XMonadLog
UnsafeXMonadLog = [Char]
"UnsafeXMonadLog"
    alias (XPropertyLog [Char]
atom) = [Char]
atom
    alias (NamedXPropertyLog [Char]
_ [Char]
name) = [Char]
name
    alias (UnsafeXPropertyLog [Char]
atom) = [Char]
atom
    alias (UnsafeNamedXPropertyLog [Char]
_ [Char]
name) = [Char]
name

    start :: XMonadLog -> ([Char] -> IO ()) -> IO ()
start XMonadLog
x [Char] -> IO ()
cb = do
        let atom :: [Char]
atom = case XMonadLog
x of
                XMonadLog
XMonadLog -> [Char]
"_XMONAD_LOG"
                XMonadLog
UnsafeXMonadLog -> [Char]
"_XMONAD_LOG"
                XPropertyLog [Char]
a -> [Char]
a
                UnsafeXPropertyLog [Char]
a -> [Char]
a
                NamedXPropertyLog [Char]
a [Char]
_ -> [Char]
a
                UnsafeNamedXPropertyLog [Char]
a [Char]
_ -> [Char]
a
            stripNL :: ShowS
stripNL = [Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
intercalate [Char]
" - " ([[Char]] -> [Char]) -> ([Char] -> [[Char]]) -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]]
lines
            sanitize :: ShowS
sanitize = case XMonadLog
x of
                XMonadLog
UnsafeXMonadLog -> ShowS
forall a. a -> a
id
                UnsafeXPropertyLog [Char]
_ -> ShowS
forall a. a -> a
id
                UnsafeNamedXPropertyLog [Char]
_ [Char]
_ -> ShowS
forall a. a -> a
id
                XMonadLog
_ -> ShowS
stripActions ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
stripNL

        d <- [Char] -> IO Display
openDisplay [Char]
""
        xlog <- internAtom d atom False

        root  <- rootWindow d (defaultScreen d)
        selectInput d root propertyChangeMask

        let update = do
                        mwp <- Display -> Word64 -> Word64 -> IO (Maybe [CChar])
getWindowProperty8 Display
d Word64
xlog Word64
root
                        maybe (return ()) (cb . sanitize . decodeCChar) mwp

        update

        allocaXEvent $ \XEventPtr
ep -> IO () -> IO (ZonkAny 0)
forall (f :: * -> *) a b. Applicative f => f a -> f b
forever (IO () -> IO (ZonkAny 0)) -> IO () -> IO (ZonkAny 0)
forall a b. (a -> b) -> a -> b
$ do
            Display -> XEventPtr -> IO ()
nextEvent' Display
d XEventPtr
ep
            e <- XEventPtr -> IO Event
getEvent XEventPtr
ep
            case e of
                PropertyEvent { ev_atom :: Event -> Word64
ev_atom = Word64
a } | Word64
a Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
==  Word64
xlog -> IO ()
update
                Event
_ -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        return ()

decodeCChar :: [CChar] -> String
decodeCChar :: [CChar] -> [Char]
decodeCChar = [Word8] -> [Char]
UTF8.decode ([Word8] -> [Char]) -> ([CChar] -> [Word8]) -> [CChar] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CChar -> Word8) -> [CChar] -> [Word8]
forall a b. (a -> b) -> [a] -> [b]
map CChar -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral