{-#LANGUAGE RecordWildCards#-}

------------------------------------------------------------------------------
-- |
-- Module: Xmobar.Plugins.Monitors.Strings
-- Copyright: (c) 2018, 2019, 2020, 2022 Jose Antonio Ortega Ruiz
-- License: BSD3-style (see LICENSE)
--
-- Maintainer: jao@gnu.org
-- Stability: unstable
-- Portability: portable
-- Created: Sun Dec 02, 2018 04:25
--
--
-- Utilities for formatting monitor outputs
--
------------------------------------------------------------------------------


module Xmobar.Plugins.Monitors.Common.Output ( IconPattern
                                             , parseIconPattern
                                             , padString
                                             , colorizeString
                                             , showWithPadding
                                             , showWithColors
                                             , showWithColors'
                                             , showPercentWithColors
                                             , showPercentsWithColors
                                             , showPercentBar
                                             , showVerticalBar
                                             , showIconPattern
                                             , showLogBar
                                             , showLogVBar
                                             , showLogIconPattern
                                             , showWithUnits
                                             , takeDigits
                                             , showDigits
                                             , floatToPercent
                                             , parseFloat
                                             , parseInt
                                             , stringParser
                                             , pShowPercentsWithColors
                                             , pShowPercentBar
                                             , pShowVerticalBar
                                             , pShowIconPattern
                                             , pShowPercentWithColors
                                             ) where

import Data.Char
import Data.List (intercalate, sort)
import qualified Data.ByteString.Lazy.Char8 as B
import Numeric
import Control.Monad (zipWithM)
import Control.Monad.IO.Class (MonadIO(..))
import Xmobar.Plugins.Monitors.Common.Types

type IconPattern = Int -> String

pShowVerticalBar :: (MonadIO m) => MonitorConfig -> Float -> Float -> m String
pShowVerticalBar :: forall (m :: * -> *).
MonadIO m =>
MonitorConfig -> Float -> Float -> m String
pShowVerticalBar MonitorConfig
p Float
v Float
x = forall a (m :: * -> *).
(Num a, Ord a, MonadIO m) =>
MonitorConfig -> a -> String -> m String
pColorizeString MonitorConfig
p Float
v [Float -> Char
convert forall a b. (a -> b) -> a -> b
$ Float
100 forall a. Num a => a -> a -> a
* Float
x]
  where convert :: Float -> Char
        convert :: Float -> Char
convert Float
val
          | Int
t forall a. Ord a => a -> a -> Bool
<= Int
9600 = Char
' '
          | Int
t forall a. Ord a => a -> a -> Bool
> Int
9608 = Int -> Char
chr Int
9608
          | Bool
otherwise = Int -> Char
chr Int
t
          where t :: Int
t = Int
9600 forall a. Num a => a -> a -> a
+ (forall a b. (RealFrac a, Integral b) => a -> b
round Float
val forall a. Integral a => a -> a -> a
`div` Int
12)

pShowPercentsWithColors :: (MonadIO m) => MonitorConfig -> [Float] -> m [String]
pShowPercentsWithColors :: forall (m :: * -> *).
MonadIO m =>
MonitorConfig -> [Float] -> m [String]
pShowPercentsWithColors MonitorConfig
p [Float]
fs =
  do let fstrs :: [String]
fstrs = forall a b. (a -> b) -> [a] -> [b]
map (MonitorConfig -> Float -> String
pFloatToPercent MonitorConfig
p) [Float]
fs
         temp :: [Float]
temp = forall a b. (a -> b) -> [a] -> [b]
map (forall a. Num a => a -> a -> a
*Float
100) [Float]
fs
     forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> m c) -> [a] -> [b] -> m [c]
zipWithM (forall a (m :: * -> *).
(Num a, Ord a, MonadIO m) =>
MonitorConfig -> (a -> String) -> a -> m String
pShowWithColors MonitorConfig
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> b -> a
const) [String]
fstrs [Float]
temp

pShowPercentWithColors :: (MonadIO m) => MonitorConfig -> Float -> m String
pShowPercentWithColors :: forall (m :: * -> *).
MonadIO m =>
MonitorConfig -> Float -> m String
pShowPercentWithColors MonitorConfig
p Float
f = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. [a] -> a
head forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *).
MonadIO m =>
MonitorConfig -> [Float] -> m [String]
pShowPercentsWithColors MonitorConfig
p [Float
f]

pShowPercentBar :: (MonadIO m) => MonitorConfig -> Float -> Float -> m String
pShowPercentBar :: forall (m :: * -> *).
MonadIO m =>
MonitorConfig -> Float -> Float -> m String
pShowPercentBar p :: MonitorConfig
p@MonitorConfig{Bool
Int
String
[String]
Maybe String
pMaxTotalWidthEllipsis :: MonitorConfig -> String
pMaxTotalWidth :: MonitorConfig -> Int
pNaString :: MonitorConfig -> String
pUseSuffix :: MonitorConfig -> Bool
pBarWidth :: MonitorConfig -> Int
pBarFore :: MonitorConfig -> String
pBarBack :: MonitorConfig -> String
pPadRight :: MonitorConfig -> Bool
pPadChars :: MonitorConfig -> String
pMaxWidthEllipsis :: MonitorConfig -> String
pMaxWidth :: MonitorConfig -> Int
pMinWidth :: MonitorConfig -> Int
pDecDigits :: MonitorConfig -> Int
pPpad :: MonitorConfig -> Int
pExport :: MonitorConfig -> [String]
pTemplate :: MonitorConfig -> String
pHighColor :: MonitorConfig -> Maybe String
pHigh :: MonitorConfig -> Int
pLowColor :: MonitorConfig -> Maybe String
pLow :: MonitorConfig -> Int
pNormalColor :: MonitorConfig -> Maybe String
pMaxTotalWidthEllipsis :: String
pMaxTotalWidth :: Int
pNaString :: String
pUseSuffix :: Bool
pBarWidth :: Int
pBarFore :: String
pBarBack :: String
pPadRight :: Bool
pPadChars :: String
pMaxWidthEllipsis :: String
pMaxWidth :: Int
pMinWidth :: Int
pDecDigits :: Int
pPpad :: Int
pExport :: [String]
pTemplate :: String
pHighColor :: Maybe String
pHigh :: Int
pLowColor :: Maybe String
pLow :: Int
pNormalColor :: Maybe String
..} Float
v Float
x = do
  let len :: Int
len = forall a. Ord a => a -> a -> a
min Int
pBarWidth forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
pBarWidth forall a. Num a => a -> a -> a
* Float
x)
  String
s <- forall a (m :: * -> *).
(Num a, Ord a, MonadIO m) =>
MonitorConfig -> a -> String -> m String
pColorizeString MonitorConfig
p Float
v (forall a. Int -> [a] -> [a]
take Int
len forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [a]
cycle String
pBarFore)
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ String
s forall a. [a] -> [a] -> [a]
++ forall a. Int -> [a] -> [a]
take (Int
pBarWidth forall a. Num a => a -> a -> a
- Int
len) (forall a. [a] -> [a]
cycle String
pBarBack)

pShowWithColors :: (Num a, Ord a, MonadIO m) => MonitorConfig -> (a -> String) -> a -> m String
pShowWithColors :: forall a (m :: * -> *).
(Num a, Ord a, MonadIO m) =>
MonitorConfig -> (a -> String) -> a -> m String
pShowWithColors MonitorConfig
p a -> String
f a
x = do
  let str :: String
str = MonitorConfig -> String -> String
pShowWithPadding MonitorConfig
p (a -> String
f a
x)
  forall a (m :: * -> *).
(Num a, Ord a, MonadIO m) =>
MonitorConfig -> a -> String -> m String
pColorizeString MonitorConfig
p a
x String
str

pColorizeString :: (Num a, Ord a, MonadIO m) => MonitorConfig -> a -> String -> m String
pColorizeString :: forall a (m :: * -> *).
(Num a, Ord a, MonadIO m) =>
MonitorConfig -> a -> String -> m String
pColorizeString MonitorConfig
p a
x String
s = do
    let col :: (MonitorConfig -> Maybe String) -> String
col = MonitorConfig
-> String -> (MonitorConfig -> Maybe String) -> String
pSetColor MonitorConfig
p String
s
        [a
ll,a
hh] = forall a b. (a -> b) -> [a] -> [b]
map forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall a. Ord a => [a] -> [a]
sort [MonitorConfig -> Int
pLow MonitorConfig
p, MonitorConfig -> Int
pHigh MonitorConfig
p] -- consider high < low
    forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. [a] -> a
head forall a b. (a -> b) -> a -> b
$ [(MonitorConfig -> Maybe String) -> String
col MonitorConfig -> Maybe String
pHighColor   | a
x forall a. Ord a => a -> a -> Bool
> a
hh ] forall a. [a] -> [a] -> [a]
++
                  [(MonitorConfig -> Maybe String) -> String
col MonitorConfig -> Maybe String
pNormalColor | a
x forall a. Ord a => a -> a -> Bool
> a
ll ] forall a. [a] -> [a] -> [a]
++
                  [(MonitorConfig -> Maybe String) -> String
col MonitorConfig -> Maybe String
pLowColor    | Bool
True]

pSetColor :: MonitorConfig -> String -> PSelector (Maybe String) -> String
pSetColor :: MonitorConfig
-> String -> (MonitorConfig -> Maybe String) -> String
pSetColor MonitorConfig
config String
str MonitorConfig -> Maybe String
s =
    do let a :: Maybe String
a = forall a. MonitorConfig -> PSelector a -> a
getPConfigValue MonitorConfig
config MonitorConfig -> Maybe String
s
       case Maybe String
a of
            Maybe String
Nothing -> String
str
            Just String
c -> String
"<fc=" forall a. [a] -> [a] -> [a]
++ String
c forall a. [a] -> [a] -> [a]
++ String
">" forall a. [a] -> [a] -> [a]
++ String
str forall a. [a] -> [a] -> [a]
++ String
"</fc>"

pShowWithPadding :: MonitorConfig -> String -> String
pShowWithPadding :: MonitorConfig -> String -> String
pShowWithPadding MonitorConfig {Bool
Int
String
[String]
Maybe String
pMaxTotalWidthEllipsis :: String
pMaxTotalWidth :: Int
pNaString :: String
pUseSuffix :: Bool
pBarWidth :: Int
pBarFore :: String
pBarBack :: String
pPadRight :: Bool
pPadChars :: String
pMaxWidthEllipsis :: String
pMaxWidth :: Int
pMinWidth :: Int
pDecDigits :: Int
pPpad :: Int
pExport :: [String]
pTemplate :: String
pHighColor :: Maybe String
pHigh :: Int
pLowColor :: Maybe String
pLow :: Int
pNormalColor :: Maybe String
pMaxTotalWidthEllipsis :: MonitorConfig -> String
pMaxTotalWidth :: MonitorConfig -> Int
pNaString :: MonitorConfig -> String
pUseSuffix :: MonitorConfig -> Bool
pBarWidth :: MonitorConfig -> Int
pBarFore :: MonitorConfig -> String
pBarBack :: MonitorConfig -> String
pPadRight :: MonitorConfig -> Bool
pPadChars :: MonitorConfig -> String
pMaxWidthEllipsis :: MonitorConfig -> String
pMaxWidth :: MonitorConfig -> Int
pMinWidth :: MonitorConfig -> Int
pDecDigits :: MonitorConfig -> Int
pPpad :: MonitorConfig -> Int
pExport :: MonitorConfig -> [String]
pTemplate :: MonitorConfig -> String
pHighColor :: MonitorConfig -> Maybe String
pHigh :: MonitorConfig -> Int
pLowColor :: MonitorConfig -> Maybe String
pLow :: MonitorConfig -> Int
pNormalColor :: MonitorConfig -> Maybe String
..} =
  Int -> Int -> String -> Bool -> String -> String -> String
padString Int
pMinWidth Int
pMaxWidth String
pPadChars Bool
pPadRight String
pMaxWidthEllipsis

pFloatToPercent :: MonitorConfig -> Float -> String
pFloatToPercent :: MonitorConfig -> Float -> String
pFloatToPercent MonitorConfig{Bool
Int
String
[String]
Maybe String
pMaxTotalWidthEllipsis :: String
pMaxTotalWidth :: Int
pNaString :: String
pUseSuffix :: Bool
pBarWidth :: Int
pBarFore :: String
pBarBack :: String
pPadRight :: Bool
pPadChars :: String
pMaxWidthEllipsis :: String
pMaxWidth :: Int
pMinWidth :: Int
pDecDigits :: Int
pPpad :: Int
pExport :: [String]
pTemplate :: String
pHighColor :: Maybe String
pHigh :: Int
pLowColor :: Maybe String
pLow :: Int
pNormalColor :: Maybe String
pMaxTotalWidthEllipsis :: MonitorConfig -> String
pMaxTotalWidth :: MonitorConfig -> Int
pNaString :: MonitorConfig -> String
pUseSuffix :: MonitorConfig -> Bool
pBarWidth :: MonitorConfig -> Int
pBarFore :: MonitorConfig -> String
pBarBack :: MonitorConfig -> String
pPadRight :: MonitorConfig -> Bool
pPadChars :: MonitorConfig -> String
pMaxWidthEllipsis :: MonitorConfig -> String
pMaxWidth :: MonitorConfig -> Int
pMinWidth :: MonitorConfig -> Int
pDecDigits :: MonitorConfig -> Int
pPpad :: MonitorConfig -> Int
pExport :: MonitorConfig -> [String]
pTemplate :: MonitorConfig -> String
pHighColor :: MonitorConfig -> Maybe String
pHigh :: MonitorConfig -> Int
pLowColor :: MonitorConfig -> Maybe String
pLow :: MonitorConfig -> Int
pNormalColor :: MonitorConfig -> Maybe String
..} Float
n = let p :: String
p = forall a. RealFloat a => Int -> a -> String
showDigits Int
0 (Float
n forall a. Num a => a -> a -> a
* Float
100)
                                          ps :: String
ps = if Bool
pUseSuffix then String
"%" else String
""
                                      in Int -> Int -> String -> Bool -> String -> String -> String
padString Int
pPpad Int
pPpad String
pPadChars Bool
pPadRight String
"" String
p forall a. [a] -> [a] -> [a]
++ String
ps

parseIconPattern :: String -> IconPattern
parseIconPattern :: String -> IconPattern
parseIconPattern String
path =
    let spl :: [String]
spl = String -> [String]
splitOnPercent String
path
    in \Int
i -> forall a. [a] -> [[a]] -> [a]
intercalate (forall a. Show a => a -> String
show Int
i) [String]
spl
  where splitOnPercent :: String -> [String]
splitOnPercent [] = [[]]
        splitOnPercent (Char
'%':Char
'%':String
xs) = [] forall a. a -> [a] -> [a]
: String -> [String]
splitOnPercent String
xs
        splitOnPercent (Char
x:String
xs) =
            let rest :: [String]
rest = String -> [String]
splitOnPercent String
xs
            in (Char
x forall a. a -> [a] -> [a]
: forall a. [a] -> a
head [String]
rest) forall a. a -> [a] -> [a]
: forall a. [a] -> [a]
tail [String]
rest

type Pos = (Int, Int)

takeDigits :: Int -> Float -> Float
takeDigits :: Int -> Float -> Float
takeDigits Int
d Float
n =
    forall a b. (Integral a, Num b) => a -> b
fromIntegral (forall a b. (RealFrac a, Integral b) => a -> b
round (Float
n forall a. Num a => a -> a -> a
* Float
fact) :: Int) forall a. Fractional a => a -> a -> a
/ Float
fact
  where fact :: Float
fact = Float
10 forall a b. (Num a, Integral b) => a -> b -> a
^ Int
d

showDigits :: (RealFloat a) => Int -> a -> String
showDigits :: forall a. RealFloat a => Int -> a -> String
showDigits Int
d a
n = forall a. RealFloat a => Maybe Int -> a -> String -> String
showFFloat (forall a. a -> Maybe a
Just Int
d) a
n String
""

showWithUnits :: Int -> Int -> Float -> String
showWithUnits :: Int -> Int -> Float -> String
showWithUnits Int
d Int
n Float
x
  | Float
x forall a. Ord a => a -> a -> Bool
< Float
0 = Char
'-' forall a. a -> [a] -> [a]
: Int -> Int -> Float -> String
showWithUnits Int
d Int
n (-Float
x)
  | Int
n forall a. Ord a => a -> a -> Bool
> Int
3 Bool -> Bool -> Bool
|| Float
x forall a. Ord a => a -> a -> Bool
< Float
10forall a b. (Num a, Integral b) => a -> b -> a
^(Int
d forall a. Num a => a -> a -> a
+ Int
1) = forall a. Show a => a -> String
show (forall a b. (RealFrac a, Integral b) => a -> b
round Float
x :: Int) forall a. [a] -> [a] -> [a]
++ IconPattern
units Int
n
  | Float
x forall a. Ord a => a -> a -> Bool
<= Float
1024 = forall a. RealFloat a => Int -> a -> String
showDigits Int
d (Float
xforall a. Fractional a => a -> a -> a
/Float
1024) forall a. [a] -> [a] -> [a]
++ IconPattern
units (Int
nforall a. Num a => a -> a -> a
+Int
1)
  | Bool
otherwise = Int -> Int -> Float -> String
showWithUnits Int
d (Int
nforall a. Num a => a -> a -> a
+Int
1) (Float
xforall a. Fractional a => a -> a -> a
/Float
1024)
  where units :: IconPattern
units = forall a. [a] -> Int -> a
(!!) [String
"B", String
"K", String
"M", String
"G", String
"T"]

padString :: Int -> Int -> String -> Bool -> String -> String -> String
padString :: Int -> Int -> String -> Bool -> String -> String -> String
padString Int
mnw Int
mxw String
pad Bool
pr String
ellipsis String
s =
  let len :: Int
len = forall (t :: * -> *) a. Foldable t => t a -> Int
length String
s
      rmin :: Int
rmin = forall a. Ord a => a -> a -> a
max Int
mnw Int
0
      rmax :: Int
rmax = if Int
mxw forall a. Ord a => a -> a -> Bool
<= Int
0 then forall a. Ord a => a -> a -> a
max Int
len Int
rmin else Int
mxw
      (Int
rmn, Int
rmx) = if Int
rmin forall a. Ord a => a -> a -> Bool
<= Int
rmax then (Int
rmin, Int
rmax) else (Int
rmax, Int
rmin)
      rlen :: Int
rlen = forall a. Ord a => a -> a -> a
min (forall a. Ord a => a -> a -> a
max Int
rmn Int
len) Int
rmx
  in if Int
rlen forall a. Ord a => a -> a -> Bool
< Int
len then
       forall a. Int -> [a] -> [a]
take Int
rlen String
s forall a. [a] -> [a] -> [a]
++ String
ellipsis
     else let ps :: String
ps = forall a. Int -> [a] -> [a]
take (Int
rlen forall a. Num a => a -> a -> a
- Int
len) (forall a. [a] -> [a]
cycle String
pad)
          in if Bool
pr then String
s forall a. [a] -> [a] -> [a]
++ String
ps else String
ps forall a. [a] -> [a] -> [a]
++ String
s

parseFloat :: String -> Float
parseFloat :: String -> Float
parseFloat String
s = case forall a. RealFrac a => ReadS a
readFloat String
s of
  (Float
v, String
_):[(Float, String)]
_ -> Float
v
  [(Float, String)]
_ -> Float
0

parseInt :: String -> Int
parseInt :: String -> Int
parseInt String
s = case forall a. (Eq a, Num a) => ReadS a
readDec String
s of
  (Int
v, String
_):[(Int, String)]
_ -> Int
v
  [(Int, String)]
_ -> Int
0

floatToPercent :: Float -> Monitor String
floatToPercent :: Float -> Monitor String
floatToPercent Float
n =
  do Int
pad <- forall a. Selector a -> Monitor a
getConfigValue MConfig -> IORef Int
ppad
     String
pc <- forall a. Selector a -> Monitor a
getConfigValue MConfig -> IORef String
padChars
     Bool
pr <- forall a. Selector a -> Monitor a
getConfigValue MConfig -> IORef Bool
padRight
     Bool
up <- forall a. Selector a -> Monitor a
getConfigValue MConfig -> IORef Bool
useSuffix
     let p :: String
p = forall a. RealFloat a => Int -> a -> String
showDigits Int
0 (Float
n forall a. Num a => a -> a -> a
* Float
100)
         ps :: String
ps = if Bool
up then String
"%" else String
""
     forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Int -> Int -> String -> Bool -> String -> String -> String
padString Int
pad Int
pad String
pc Bool
pr String
"" String
p forall a. [a] -> [a] -> [a]
++ String
ps

stringParser :: Pos -> B.ByteString -> String
stringParser :: (Int, Int) -> ByteString -> String
stringParser (Int
x,Int
y) =
     ByteString -> String
B.unpack forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [ByteString] -> ByteString
li Int
x forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [ByteString]
B.words forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [ByteString] -> ByteString
li Int
y forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [ByteString]
B.lines
    where li :: Int -> [ByteString] -> ByteString
li Int
i [ByteString]
l | forall (t :: * -> *) a. Foldable t => t a -> Int
length [ByteString]
l forall a. Ord a => a -> a -> Bool
> Int
i = [ByteString]
l forall a. [a] -> Int -> a
!! Int
i
                 | Bool
otherwise    = ByteString
B.empty

setColor :: String -> Selector (Maybe String) -> Monitor String
setColor :: String -> Selector (Maybe String) -> Monitor String
setColor String
str Selector (Maybe String)
s =
    do Maybe String
a <- forall a. Selector a -> Monitor a
getConfigValue Selector (Maybe String)
s
       case Maybe String
a of
            Maybe String
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return String
str
            Just String
c -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$
                String
"<fc=" forall a. [a] -> [a] -> [a]
++ String
c forall a. [a] -> [a] -> [a]
++ String
">" forall a. [a] -> [a] -> [a]
++ String
str forall a. [a] -> [a] -> [a]
++ String
"</fc>"

showWithPadding :: String -> Monitor String
showWithPadding :: String -> Monitor String
showWithPadding String
s =
    do Int
mn <- forall a. Selector a -> Monitor a
getConfigValue MConfig -> IORef Int
minWidth
       Int
mx <- forall a. Selector a -> Monitor a
getConfigValue MConfig -> IORef Int
maxWidth
       String
p <- forall a. Selector a -> Monitor a
getConfigValue MConfig -> IORef String
padChars
       Bool
pr <- forall a. Selector a -> Monitor a
getConfigValue MConfig -> IORef Bool
padRight
       String
ellipsis <- forall a. Selector a -> Monitor a
getConfigValue MConfig -> IORef String
maxWidthEllipsis
       forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Int -> Int -> String -> Bool -> String -> String -> String
padString Int
mn Int
mx String
p Bool
pr String
ellipsis String
s

colorizeString :: (Num a, Ord a) => a -> String -> Monitor String
colorizeString :: forall a. (Num a, Ord a) => a -> String -> Monitor String
colorizeString a
x String
s = do
    Int
h <- forall a. Selector a -> Monitor a
getConfigValue MConfig -> IORef Int
high
    Int
l <- forall a. Selector a -> Monitor a
getConfigValue MConfig -> IORef Int
low
    let col :: Selector (Maybe String) -> Monitor String
col = String -> Selector (Maybe String) -> Monitor String
setColor String
s
        [a
ll,a
hh] = forall a b. (a -> b) -> [a] -> [b]
map forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall a. Ord a => [a] -> [a]
sort [Int
l, Int
h] -- consider high < low
    forall a. [a] -> a
head forall a b. (a -> b) -> a -> b
$ [Selector (Maybe String) -> Monitor String
col Selector (Maybe String)
highColor   | a
x forall a. Ord a => a -> a -> Bool
> a
hh ] forall a. [a] -> [a] -> [a]
++
           [Selector (Maybe String) -> Monitor String
col Selector (Maybe String)
normalColor | a
x forall a. Ord a => a -> a -> Bool
> a
ll ] forall a. [a] -> [a] -> [a]
++
           [Selector (Maybe String) -> Monitor String
col Selector (Maybe String)
lowColor    | Bool
True]

showWithColors :: (Num a, Ord a) => (a -> String) -> a -> Monitor String
showWithColors :: forall a. (Num a, Ord a) => (a -> String) -> a -> Monitor String
showWithColors a -> String
f a
x = String -> Monitor String
showWithPadding (a -> String
f a
x) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a. (Num a, Ord a) => a -> String -> Monitor String
colorizeString a
x

showWithColors' :: (Num a, Ord a) => String -> a -> Monitor String
showWithColors' :: forall a. (Num a, Ord a) => String -> a -> Monitor String
showWithColors' String
str = forall a. (Num a, Ord a) => (a -> String) -> a -> Monitor String
showWithColors (forall a b. a -> b -> a
const String
str)

showPercentsWithColors :: [Float] -> Monitor [String]
showPercentsWithColors :: [Float] -> Monitor [String]
showPercentsWithColors [Float]
fs =
  do [String]
fstrs <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Float -> Monitor String
floatToPercent [Float]
fs
     forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> m c) -> [a] -> [b] -> m [c]
zipWithM (forall a. (Num a, Ord a) => (a -> String) -> a -> Monitor String
showWithColors forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. a -> b -> a
const) [String]
fstrs (forall a b. (a -> b) -> [a] -> [b]
map (forall a. Num a => a -> a -> a
*Float
100) [Float]
fs)

showPercentWithColors :: Float -> Monitor String
showPercentWithColors :: Float -> Monitor String
showPercentWithColors Float
f = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. [a] -> a
head forall a b. (a -> b) -> a -> b
$ [Float] -> Monitor [String]
showPercentsWithColors [Float
f]

showPercentBar :: Float -> Float -> Monitor String
showPercentBar :: Float -> Float -> Monitor String
showPercentBar Float
v Float
x = do
  String
bb <- forall a. Selector a -> Monitor a
getConfigValue MConfig -> IORef String
barBack
  String
bf <- forall a. Selector a -> Monitor a
getConfigValue MConfig -> IORef String
barFore
  Int
bw <- forall a. Selector a -> Monitor a
getConfigValue MConfig -> IORef Int
barWidth
  let c :: Bool
c = Int
bw forall a. Ord a => a -> a -> Bool
< Int
1
      w :: Int
w = if Bool
c then forall (t :: * -> *) a. Foldable t => t a -> Int
length String
bf else Int
bw
      len :: Int
len = forall a. Ord a => a -> a -> a
min Int
w forall a b. (a -> b) -> a -> b
$ (if Bool
c then forall a b. (RealFrac a, Integral b) => a -> b
ceiling else forall a b. (RealFrac a, Integral b) => a -> b
round) (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
w forall a. Num a => a -> a -> a
* Float
x)
      bfs :: String
bfs = if Bool
c then [String
bf forall a. [a] -> Int -> a
!! forall a. Ord a => a -> a -> a
max Int
0 (Int
len forall a. Num a => a -> a -> a
- Int
1)] else forall a. Int -> [a] -> [a]
take Int
len forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [a]
cycle String
bf
  String
s <- forall a. (Num a, Ord a) => a -> String -> Monitor String
colorizeString Float
v String
bfs
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ String
s forall a. [a] -> [a] -> [a]
++ if Bool
c then String
"" else forall a. Int -> [a] -> [a]
take (Int
bw forall a. Num a => a -> a -> a
- Int
len) (forall a. [a] -> [a]
cycle String
bb)

showIconPattern :: Maybe IconPattern -> Float -> Monitor String
showIconPattern :: Maybe IconPattern -> Float -> Monitor String
showIconPattern Maybe IconPattern
Nothing Float
_ = forall (m :: * -> *) a. Monad m => a -> m a
return String
""
showIconPattern (Just IconPattern
str) Float
x = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ IconPattern
str forall a b. (a -> b) -> a -> b
$ forall {a} {p}. (Integral a, RealFrac p) => p -> a
convert forall a b. (a -> b) -> a -> b
$ Float
100 forall a. Num a => a -> a -> a
* Float
x
  where convert :: p -> a
convert p
val
          | a
t forall a. Ord a => a -> a -> Bool
<= a
0 = a
0
          | a
t forall a. Ord a => a -> a -> Bool
> a
8 = a
8
          | Bool
otherwise = a
t
          where t :: a
t = forall a b. (RealFrac a, Integral b) => a -> b
round p
val forall a. Integral a => a -> a -> a
`div` a
12

pShowIconPattern :: Maybe IconPattern -> Float -> IO String
pShowIconPattern :: Maybe IconPattern -> Float -> IO String
pShowIconPattern Maybe IconPattern
Nothing Float
_ = forall (m :: * -> *) a. Monad m => a -> m a
return String
""
pShowIconPattern (Just IconPattern
str) Float
x = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ IconPattern
str forall a b. (a -> b) -> a -> b
$ forall {a} {p}. (Integral a, RealFrac p) => p -> a
convert forall a b. (a -> b) -> a -> b
$ Float
100 forall a. Num a => a -> a -> a
* Float
x
  where convert :: p -> a
convert p
val
          | a
t forall a. Ord a => a -> a -> Bool
<= a
0 = a
0
          | a
t forall a. Ord a => a -> a -> Bool
> a
8 = a
8
          | Bool
otherwise = a
t
          where t :: a
t = forall a b. (RealFrac a, Integral b) => a -> b
round p
val forall a. Integral a => a -> a -> a
`div` a
12

showVerticalBar :: Float -> Float -> Monitor String
showVerticalBar :: Float -> Float -> Monitor String
showVerticalBar Float
v Float
x = forall a. (Num a, Ord a) => a -> String -> Monitor String
colorizeString Float
v [Float -> Char
convert forall a b. (a -> b) -> a -> b
$ Float
100 forall a. Num a => a -> a -> a
* Float
x]
  where convert :: Float -> Char
        convert :: Float -> Char
convert Float
val
          | Int
t forall a. Ord a => a -> a -> Bool
<= Int
9600 = Char
' '
          | Int
t forall a. Ord a => a -> a -> Bool
> Int
9608 = Int -> Char
chr Int
9608
          | Bool
otherwise = Int -> Char
chr Int
t
          where t :: Int
t = Int
9600 forall a. Num a => a -> a -> a
+ (forall a b. (RealFrac a, Integral b) => a -> b
round Float
val forall a. Integral a => a -> a -> a
`div` Int
12)

logScaling :: Float -> Float -> Monitor Float
logScaling :: Float -> Float -> Monitor Float
logScaling Float
f Float
v = do
  Float
h <- forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall a. Selector a -> Monitor a
getConfigValue MConfig -> IORef Int
high
  Float
l <- forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall a. Selector a -> Monitor a
getConfigValue MConfig -> IORef Int
low
  Float
bw <- forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall a. Selector a -> Monitor a
getConfigValue MConfig -> IORef Int
barWidth
  let [Float
ll, Float
hh] = forall a. Ord a => [a] -> [a]
sort [Float
l, Float
h]
      bw' :: Float
bw' = if Float
bw forall a. Ord a => a -> a -> Bool
> Float
0 then Float
bw else Float
10
      scaled :: Float -> Float
scaled Float
x | Float
x forall a. Eq a => a -> a -> Bool
== Float
0.0 = Float
0
               | Float
x forall a. Ord a => a -> a -> Bool
<= Float
ll = Float
1 forall a. Fractional a => a -> a -> a
/ Float
bw'
               | Bool
otherwise = Float
f forall a. Num a => a -> a -> a
+ forall a. Floating a => a -> a -> a
logBase Float
2 (Float
x forall a. Fractional a => a -> a -> a
/ Float
hh) forall a. Fractional a => a -> a -> a
/ Float
bw'
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Float -> Float
scaled Float
v

showLogBar :: Float -> Float -> Monitor String
showLogBar :: Float -> Float -> Monitor String
showLogBar Float
f Float
v = Float -> Float -> Monitor Float
logScaling Float
f Float
v forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Float -> Float -> Monitor String
showPercentBar Float
v

showLogVBar :: Float -> Float -> Monitor String
showLogVBar :: Float -> Float -> Monitor String
showLogVBar Float
f Float
v = Float -> Float -> Monitor Float
logScaling Float
f Float
v forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Float -> Float -> Monitor String
showVerticalBar Float
v

showLogIconPattern :: Maybe IconPattern -> Float -> Float -> Monitor String
showLogIconPattern :: Maybe IconPattern -> Float -> Float -> Monitor String
showLogIconPattern Maybe IconPattern
str Float
f Float
v = Float -> Float -> Monitor Float
logScaling Float
f Float
v forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Maybe IconPattern -> Float -> Monitor String
showIconPattern Maybe IconPattern
str