Sound.Pulse.Mainloop.Simple

Maintianer : ongy Stability : experimental

This implementation lacks support for anything but IOInput and IOOutput!.

The main appeal of this is, that it runs in the Haskell RTS system and does not block the RTS in any way. If the doLoop function is called in an forkIO, all functions will "just work", and may be wrapped into a synchronous api wrapper.

If the callback style application flow should be used, this will dispatch all callbacks in the same (Haskell)-thread.

Most function *should* be thread safe (adding multiple events etc.) but there are no checks done for incompatible things happening (modifying and removing the same event).

Documentation

data MainloopImpl

Implementation type, keeping state about existing events.

Instances

PAMainloop MainloopImpl

Associated Types

data PAIOEvent MainloopImpl :: *

data PATimeEvent MainloopImpl :: *

data PADeferEvent MainloopImpl :: *

Methods

ioNew :: MainloopImpl -> Fd -> [PAIOEventFlags] -> ([PAIOEventFlags] -> IO ()) -> IO (PAIOEvent MainloopImpl)

ioEnable :: PAIOEvent MainloopImpl -> [PAIOEventFlags] -> IO ()

ioFree :: PAIOEvent MainloopImpl -> IO ()

ioSetDestroy :: PAIOEvent MainloopImpl -> IO () -> IO ()

timeNew :: MainloopImpl -> PATime -> (PATime -> IO ()) -> IO (PATimeEvent MainloopImpl)

timeRestart :: PATimeEvent MainloopImpl -> PATime -> IO ()

timeFree :: PATimeEvent MainloopImpl -> IO ()

timeSetDestroy :: PATimeEvent MainloopImpl -> IO () -> IO ()

deferNew :: MainloopImpl -> IO () -> IO (PADeferEvent MainloopImpl)

deferEnable :: PADeferEvent MainloopImpl -> Bool -> IO ()

deferFree :: PADeferEvent MainloopImpl -> IO ()

deferSetDestroy :: PADeferEvent MainloopImpl -> IO () -> IO ()

quitLoop :: MainloopImpl -> Int -> IO ()

data PAIOEvent MainloopImpl

data PAIOEvent MainloopImpl = PAIOEvent IOEvent

data PATimeEvent MainloopImpl

data PATimeEvent MainloopImpl = PATimeEvent TimeEvent

data PADeferEvent MainloopImpl

data PADeferEvent MainloopImpl = PADeferEvent DeferEvent

getMainloopImpl :: IO MainloopImpl

Create a new MainloopImpl with initial state

doIteration :: MainloopImpl -> IO ()

Do one iteration of events. This may be dispatchin defered events, a timer, an io event, or simply a wakeup. Event callback will be called in the same thread as this!

doLoop :: MainloopImpl -> IO Int

Loop in the pulse main loop until eternety