-----------------------------------------------------------------------------
-- |
-- Module      :  Plugins.Monitors.CpuFreq
-- Copyright   :  (c) Juraj Hercek
-- License     :  BSD-style (see LICENSE)
--
-- Maintainer  :  Juraj Hercek <juhe_haskell@hck.sk>
-- Stability   :  unstable
-- Portability :  unportable
--
-- A cpu frequency monitor for Xmobar
--
-----------------------------------------------------------------------------

module Xmobar.Plugins.Monitors.CpuFreq where

import Xmobar.Plugins.Monitors.Common

-- |
-- Cpu frequency default configuration. Default template contains only
-- one core frequency, user should specify custom template in order to
-- get more cpu frequencies.
cpuFreqConfig :: IO MConfig
cpuFreqConfig :: IO MConfig
cpuFreqConfig =
  String -> [String] -> IO MConfig
mkMConfig String
"Freq: <cpu0>"
            ([String
"max", String
"min", String
"avg"] [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ (Int -> String) -> [Int] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String -> String -> String
forall a. [a] -> [a] -> [a]
(++) String
"cpu" (String -> String) -> (Int -> String) -> Int -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> String
forall a. Show a => a -> String
show) [Int
0 :: Int ..])


-- |
-- Function retrieves monitor string holding the cpu frequency (or
-- frequencies)
runCpuFreq :: [String] -> Monitor String
runCpuFreq :: [String] -> Monitor String
runCpuFreq [String]
_ = do
  Bool
suffix <- Selector Bool -> Monitor Bool
forall a. Selector a -> Monitor a
getConfigValue Selector Bool
useSuffix
  Int
ddigits <- Selector Int -> Monitor Int
forall a. Selector a -> Monitor a
getConfigValue Selector Int
decDigits
  let paths :: [String]
paths = [String
"/sys/devices/system/cpu/cpu", String
"/cpufreq/scaling_cur_freq"]
      divisor :: Double
divisor = Double
1e6 :: Double
      fmt :: Double -> String
fmt Double
x | Double
x Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
< Double
1 = if Bool
suffix then Double -> String
forall a. RealFrac a => a -> String
mhzFmt Double
x String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"MHz"
                                else Double -> String
ghzFmt Double
x
            | Bool
otherwise = Double -> String
ghzFmt Double
x String -> String -> String
forall a. [a] -> [a] -> [a]
++ if Bool
suffix then String
"GHz" else String
""
      mhzFmt :: a -> String
mhzFmt a
x = Integer -> String
forall a. Show a => a -> String
show (a -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
round (a
x a -> a -> a
forall a. Num a => a -> a -> a
* a
1000) :: Integer)
      ghzFmt :: Double -> String
ghzFmt = Int -> Double -> String
forall a. RealFloat a => Int -> a -> String
showDigits Int
ddigits
      sts :: t a -> [a]
sts t a
xs = [t a -> a
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum t a
xs, t a -> a
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
minimum t a
xs, t a -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum t a
xs a -> a -> a
forall a. Fractional a => a -> a -> a
/ Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (t a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length t a
xs)]
  [Double]
vs <- [[String]] -> Monitor [Double]
checkedDataRead [[String]
paths]
  if [Double] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Double]
vs then Selector String -> Monitor String
forall a. Selector a -> Monitor a
getConfigValue Selector String
naString
  else (Double -> Monitor String)
-> [Double] -> ReaderT MConfig IO [String]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((Double -> String) -> Double -> Monitor String
forall a. (Num a, Ord a) => (a -> String) -> a -> Monitor String
showWithColors Double -> String
fmt (Double -> Monitor String)
-> (Double -> Double) -> Double -> Monitor String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/Double
divisor)) ([Double] -> [Double]
forall (t :: * -> *) a.
(Foldable t, Ord a, Fractional a) =>
t a -> [a]
sts [Double]
vs [Double] -> [Double] -> [Double]
forall a. [a] -> [a] -> [a]
++ [Double]
vs) ReaderT MConfig IO [String]
-> ([String] -> Monitor String) -> Monitor String
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [String] -> Monitor String
parseTemplate