module Termbox.Tea
(
Program (..),
run,
Termbox.InitError (..),
Termbox.Scene,
Termbox.cell,
Termbox.fill,
Termbox.cursor,
Termbox.Cell,
Termbox.char,
Termbox.fg,
Termbox.bg,
Termbox.bold,
Termbox.underline,
Termbox.blink,
Termbox.Color,
Termbox.defaultColor,
Termbox.red,
Termbox.green,
Termbox.yellow,
Termbox.blue,
Termbox.magenta,
Termbox.cyan,
Termbox.white,
Termbox.bright,
Termbox.color,
Termbox.gray,
Termbox.Event (..),
Termbox.Key (..),
Termbox.Mouse (..),
Termbox.MouseButton (..),
Termbox.Pos (..),
Termbox.posUp,
Termbox.posDown,
Termbox.posLeft,
Termbox.posRight,
Termbox.Size (..),
)
where
import Control.Concurrent.MVar
import Control.Monad (forever)
import qualified Ki
import qualified Termbox
data Program s = forall e.
Program
{
forall s. Program s -> Size -> s
initialize :: Termbox.Size -> s,
()
pollEvent :: Maybe (IO e),
()
handleEvent :: s -> Termbox.Event e -> IO s,
forall s. Program s -> s -> Scene
render :: s -> Termbox.Scene,
forall s. Program s -> s -> Bool
finished :: s -> Bool
}
run :: Program s -> IO (Either Termbox.InitError s)
run :: forall s. Program s -> IO (Either InitError s)
run Program s
program =
forall a. IO a -> IO (Either InitError a)
Termbox.run (forall s. Program s -> IO s
run_ Program s
program)
run_ :: Program s -> IO s
run_ :: forall s. Program s -> IO s
run_ Program {Size -> s
initialize :: Size -> s
$sel:initialize:Program :: forall s. Program s -> Size -> s
initialize, Maybe (IO e)
pollEvent :: Maybe (IO e)
$sel:pollEvent:Program :: ()
pollEvent, s -> Event e -> IO s
handleEvent :: s -> Event e -> IO s
$sel:handleEvent:Program :: ()
handleEvent, s -> Scene
render :: s -> Scene
$sel:render:Program :: forall s. Program s -> s -> Scene
render, s -> Bool
finished :: s -> Bool
$sel:finished:Program :: forall s. Program s -> s -> Bool
finished} = do
s
state0 <- Size -> s
initialize forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO Size
Termbox.getSize
let loop0 :: IO (Event e) -> s -> IO s
loop0 IO (Event e)
doPoll =
let loop :: s -> IO s
loop s
s0 =
if s -> Bool
finished s
s0
then forall (f :: * -> *) a. Applicative f => a -> f a
pure s
s0
else do
Scene -> IO ()
Termbox.render (s -> Scene
render s
s0)
Event e
event <- IO (Event e)
doPoll
s
s1 <- s -> Event e -> IO s
handleEvent s
s0 Event e
event
s -> IO s
loop s
s1
in s -> IO s
loop
case Maybe (IO e)
pollEvent of
Maybe (IO e)
Nothing -> IO (Event e) -> s -> IO s
loop0 forall e. IO (Event e)
Termbox.poll s
state0
Just IO e
pollEvent1 -> do
MVar (Event e)
eventVar <- forall a. IO (MVar a)
newEmptyMVar
forall a. (Scope -> IO a) -> IO a
Ki.scoped \Scope
scope -> do
Scope -> IO Void -> IO ()
Ki.fork_ Scope
scope do
forall (f :: * -> *) a b. Applicative f => f a -> f b
forever do
e
event <- IO e
pollEvent1
forall a. MVar a -> a -> IO ()
putMVar MVar (Event e)
eventVar (forall e. e -> Event e
Termbox.EventUser e
event)
Scope -> IO Void -> IO ()
Ki.fork_ Scope
scope do
forall (f :: * -> *) a b. Applicative f => f a -> f b
forever do
Event e
event <- forall e. IO (Event e)
Termbox.poll
forall a. MVar a -> a -> IO ()
putMVar MVar (Event e)
eventVar Event e
event
IO (Event e) -> s -> IO s
loop0 (forall a. MVar a -> IO a
takeMVar MVar (Event e)
eventVar) s
state0