--------------------------------------------------------------------------------
-- |
-- Module      : System.Taffybar.Widget.DiskIOMonitor
-- Copyright   : (c) José A. Romero L.
-- License     : BSD3-style (see LICENSE)
--
-- Maintainer  : José A. Romero L. <escherdragon@gmail.com>
-- Stability   : unstable
-- Portability : unportable
--
-- Simple Disk IO monitor that uses a PollingGraph to visualize the speed of
-- read/write operations in one selected disk or partition.
--
--------------------------------------------------------------------------------

module System.Taffybar.Widget.DiskIOMonitor ( dioMonitorNew ) where

import           Control.Monad.IO.Class
import qualified GI.Gtk
import           System.Taffybar.Information.DiskIO ( getDiskTransfer )
import           System.Taffybar.Widget.Generic.PollingGraph ( GraphConfig, pollingGraphNew )

-- | Creates a new disk IO monitor widget. This is a 'PollingGraph' fed by
-- regular calls to 'getDiskTransfer'. The results of calling this function
-- are normalized to the maximum value of the obtained probe (either read or
-- write transfer).
dioMonitorNew
  :: MonadIO m
  => GraphConfig -- ^ Configuration data for the Graph.
  -> Double -- ^ Polling period (in seconds).
  -> String -- ^ Name of the disk or partition to watch (e.g. \"sda\", \"sdb1\").
  -> m GI.Gtk.Widget
dioMonitorNew :: GraphConfig -> Double -> String -> m Widget
dioMonitorNew GraphConfig
cfg Double
pollSeconds =
  GraphConfig -> Double -> IO [Double] -> m Widget
forall (m :: * -> *).
MonadIO m =>
GraphConfig -> Double -> IO [Double] -> m Widget
pollingGraphNew GraphConfig
cfg Double
pollSeconds (IO [Double] -> m Widget)
-> (String -> IO [Double]) -> String -> m Widget
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO [Double]
probeDisk

probeDisk :: String -> IO [Double]
probeDisk :: String -> IO [Double]
probeDisk String
disk = do
  [Double]
transfer <- String -> IO [Double]
getDiskTransfer String
disk
  let top :: Double
top = (Double -> Double -> Double) -> Double -> [Double] -> Double
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Double -> Double -> Double
forall a. Ord a => a -> a -> a
max Double
1.0 [Double]
transfer
  [Double] -> IO [Double]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Double] -> IO [Double]) -> [Double] -> IO [Double]
forall a b. (a -> b) -> a -> b
$ (Double -> Double) -> [Double] -> [Double]
forall a b. (a -> b) -> [a] -> [b]
map (Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/Double
top) [Double]
transfer