Inhibitor.hs

{-# LANGUAGE OverloadedStrings #-}

-----------------------------------------------------------------------------

-----------------------------------------------------------------------------

-- |
-- Module      : System.Taffybar.Widget.Inhibitor
-- Copyright   : (c) Ivan A. Malison
-- License     : BSD3-style (see LICENSE)
--
-- Maintainer  : Ivan A. Malison
-- Stability   : unstable
-- Portability : unportable
--
-- This module provides a widget for controlling idle/sleep inhibitors.
-- The widget displays the current inhibitor state and allows toggling
-- the inhibitor on/off with a click.
--
-- Example usage:
--
-- > import System.Taffybar.Widget.Inhibitor
-- >
-- > main = do
-- >   -- Simple inhibitor widget that inhibits idle
-- >   let inhibitor = inhibitorNew
-- >
-- >   -- Or with custom configuration
-- >   let customInhibitor = inhibitorNewWithConfig defaultInhibitorConfig
-- >         { inhibitWhat = [InhibitIdle, InhibitSleep]
-- >         , inhibitorActiveText = "AWAKE"
-- >         , inhibitorInactiveText = "zzz"
-- >         }
module System.Taffybar.Widget.Inhibitor
  ( -- * Widget constructors
    inhibitorNew,
    inhibitorNewWithConfig,
    inhibitorIconNew,
    inhibitorIconNewWithConfig,
    inhibitorLabelNew,
    inhibitorLabelNewWithConfig,

    -- * Configuration
    InhibitorConfig (..),
    defaultInhibitorConfig,

    -- * Re-exports
    InhibitType (..),
  )
where

import Control.Monad
import Control.Monad.IO.Class
import Control.Monad.Trans.Reader
import qualified Data.Text as T
import qualified GI.Gdk as Gdk
import GI.Gtk as Gtk
import System.Taffybar.Context
import System.Taffybar.Information.Inhibitor
import System.Taffybar.Util
import System.Taffybar.Widget.Generic.ChannelWidget
import System.Taffybar.Widget.Util

-- | Configuration for the inhibitor widget
data InhibitorConfig = InhibitorConfig
  { -- | What types of inhibitors to manage (default: [InhibitIdle])
    inhibitWhat :: [InhibitType],
    -- | Text to display when inhibitor is active
    inhibitorActiveText :: T.Text,
    -- | Text to display when inhibitor is inactive
    inhibitorInactiveText :: T.Text,
    -- | Icon to display when inhibitor is active (default: U+F0F4, nf-fa-coffee)
    inhibitorActiveIcon :: T.Text,
    -- | Icon to display when inhibitor is inactive (default: U+F236, nf-fa-bed)
    inhibitorInactiveIcon :: T.Text,
    -- | CSS class prefix (results in "prefix-active" and "prefix-inactive")
    inhibitorCssPrefix :: T.Text
  }
  deriving (Eq, Show)

-- | Default configuration: inhibits idle, shows simple icon-style text
defaultInhibitorConfig :: InhibitorConfig
defaultInhibitorConfig =
  InhibitorConfig
    { inhibitWhat = [InhibitIdle],
      inhibitorActiveText = "INHIBIT",
      inhibitorInactiveText = "inhibit",
      inhibitorActiveIcon = T.pack "\xF0F4",
      inhibitorInactiveIcon = T.pack "\xF236",
      inhibitorCssPrefix = "inhibitor"
    }

-- | Create a combined icon+label inhibitor widget with default configuration
inhibitorNew :: TaffyIO Widget
inhibitorNew = inhibitorNewWithConfig defaultInhibitorConfig

-- | Create a combined icon+label inhibitor widget with custom configuration.
-- The icon changes dynamically based on inhibitor state.
-- Click to toggle the inhibitor on/off.
inhibitorNewWithConfig :: InhibitorConfig -> TaffyIO Widget
inhibitorNewWithConfig config = do
  let types = inhibitWhat config
  iconWidget <- inhibitorIconNewWithConfig config
  labelWidget <- inhibitorLabelNewWithConfig config
  ctx <- ask
  liftIO $ do
    box <- buildIconLabelBox iconWidget labelWidget
    ebox <- eventBoxNew
    containerAdd ebox box

    _ <- widgetSetClassGI ebox "inhibitor"

    _ <- onWidgetButtonPressEvent ebox $ \event -> do
      button <- Gdk.getEventButtonButton event
      when (button == 1) $
        runReaderT (toggleInhibitor types) ctx
      return True

    widgetShowAll ebox
    toWidget ebox

-- | Create an icon-only inhibitor widget with default configuration
inhibitorIconNew :: TaffyIO Widget
inhibitorIconNew = inhibitorIconNewWithConfig defaultInhibitorConfig

-- | Create an icon-only inhibitor widget with custom configuration.
-- The icon changes dynamically based on inhibitor state.
inhibitorIconNewWithConfig :: InhibitorConfig -> TaffyIO Widget
inhibitorIconNewWithConfig config = do
  let types = inhibitWhat config
  chan <- getInhibitorChan types
  ctx <- ask
  liftIO $ do
    label <- labelNew Nothing
    let updateIcon state =
          postGUIASync $
            labelSetText label $
              if inhibitorActive state
                then inhibitorActiveIcon config
                else inhibitorInactiveIcon config
    void $ onWidgetRealize label $ do
      initialState <- runReaderT (getInhibitorState types) ctx
      updateIcon initialState
    widgetShowAll label
    toWidget =<< channelWidgetNew label chan updateIcon

-- | Create a label-only inhibitor widget with default configuration.
-- Click to toggle the inhibitor on/off.
inhibitorLabelNew :: TaffyIO Widget
inhibitorLabelNew = inhibitorLabelNewWithConfig defaultInhibitorConfig

-- | Create a label-only inhibitor widget with custom configuration.
-- Displays text and CSS classes based on inhibitor state.
-- Click to toggle the inhibitor on/off.
inhibitorLabelNewWithConfig :: InhibitorConfig -> TaffyIO Widget
inhibitorLabelNewWithConfig config = do
  let types = inhibitWhat config
  chan <- getInhibitorChan types
  ctx <- ask
  liftIO $ do
    label <- labelNew Nothing
    ebox <- eventBoxNew

    -- Set initial CSS class
    _ <- widgetSetClassGI ebox "inhibitor"

    containerAdd ebox label

    -- Set up click handler
    _ <- onWidgetButtonPressEvent ebox $ \event -> do
      button <- Gdk.getEventButtonButton event
      when (button == 1) $
        runReaderT (toggleInhibitor types) ctx
      return True

    -- Update function for the widget
    let updateWidget state = postGUIASync $ do
          let (text, activeClass, inactiveClass) =
                if inhibitorActive state
                  then
                    ( inhibitorActiveText config,
                      inhibitorCssPrefix config <> "-active",
                      inhibitorCssPrefix config <> "-inactive"
                    )
                  else
                    ( inhibitorInactiveText config,
                      inhibitorCssPrefix config <> "-inactive",
                      inhibitorCssPrefix config <> "-active"
                    )
          labelSetText label text
          addClassIfMissing activeClass ebox
          removeClassIfPresent inactiveClass ebox

    -- Set initial state
    void $ onWidgetRealize ebox $ do
      initialState <- runReaderT (getInhibitorState types) ctx
      updateWidget initialState

    -- Connect to state changes
    toWidget =<< channelWidgetNew ebox chan updateWidget