{-# LANGUAGE ExistentialQuantification #-}

module Phi.Panel ( Position(..)
                 , Color
                 , Panel(..)
                 , PanelClass(..)
                 , (<~>)
                 , PanelConfig(..)
                 , defaultPanelConfig
                 , separator
                 ) where

import Data.Function
import Data.Monoid

import Graphics.Rendering.Cairo


data Position = Top | Bottom

type Color = (Double, Double, Double, Double)

class PanelClass a where
  minSize :: a -> Int
  
  weight :: a -> Float
  weight _ = 0

  render :: a -> Int -> Int -> Render ()

data Panel = forall a. PanelClass a => Panel a | CompoundPanel [Panel]

instance Monoid Panel where
  mempty = CompoundPanel []
  mappend a b = makePanel $ (toList a) ++ (toList b)
    where
      toList (Panel p) = [Panel p]
      toList (CompoundPanel panels) = panels
      
      makePanel [p] = p
      makePanel panels = CompoundPanel panels

instance PanelClass Panel where
  minSize (Panel p) = minSize p
  minSize (CompoundPanel panels) = sum $ map minSize panels
  
  weight (Panel p) = weight p
  weight (CompoundPanel panels) = sum $ map weight panels
  
  render (Panel p) w h = render p w h
  render (CompoundPanel panels) _ _ = return ()

(<~>) :: Panel -> Panel -> Panel
(<~>) = mappend


data PanelConfig = PanelConfig { panelPosition :: Position
                               , panelSize     :: Int
                               , panelContent  :: Panel
                               }

defaultPanelConfig :: PanelConfig
defaultPanelConfig = PanelConfig { panelPosition = Top, panelSize = 24, panelContent = mempty }

data Separator = Separator Int Float

instance PanelClass Separator where
  minSize (Separator s _) = s
  weight (Separator _ w) = w
  render (Separator _ _) _ _ = return ()

separator :: Int -> Float -> Panel
separator s w = Panel $ Separator s w