Safe Haskell	None
Language	Haskell2010

Reflex.SDL2

Contents

All SDL events, packaged into reflex events
Running an app
Debugging
Convenience constraints
Re-exports

Description

This module contains the bare minimum needed to get started writing reflex apps using sdl2.

For a tutorial see app/Main.hs

Synopsis

All SDL events, packaged into reflex events

data SystemEvents t Source #

Holds a slot of Event for each kind of SDL2 event plus a couple extras:

An event for *any* SDL2 event payload.

An event for reflex's post network build event.

An event for each frame tick.

Constructors

SystemEvents

Fields

sysPostBuildEvent :: Event t ()
Fired just after the FRP network is built.
sysTicksEvent :: Event t Word32
Fired once per frame tick, contains the number of milliseconds since SDL library initialization.
sysAnySDLEvent :: Event t EventPayload
Fired when SDL receives any event.
sysWindowShownEvent :: Event t WindowShownEventData
sysWindowHiddenEvent :: Event t WindowHiddenEventData
sysWindowExposedEvent :: Event t WindowExposedEventData
sysWindowMovedEvent :: Event t WindowMovedEventData
sysWindowResizedEvent :: Event t WindowResizedEventData
sysWindowSizeChangedEvent :: Event t WindowSizeChangedEventData
sysWindowMinimizedEvent :: Event t WindowMinimizedEventData
sysWindowMaximizedEvent :: Event t WindowMaximizedEventData
sysWindowRestoredEvent :: Event t WindowRestoredEventData
sysWindowGainedMouseFocusEvent :: Event t WindowGainedMouseFocusEventData
sysWindowLostMouseFocusEvent :: Event t WindowLostMouseFocusEventData
sysWindowGainedKeyboardFocusEvent :: Event t WindowGainedKeyboardFocusEventData
sysWindowLostKeyboardFocusEvent :: Event t WindowLostKeyboardFocusEventData
sysWindowClosedEvent :: Event t WindowClosedEventData
sysKeyboardEvent :: Event t KeyboardEventData
sysTextEditingEvent :: Event t TextEditingEventData
sysTextInputEvent :: Event t TextInputEventData
sysKeymapChangedEvent :: Event t ()
sysMouseMotionEvent :: Event t MouseMotionEventData
sysMouseButtonEvent :: Event t MouseButtonEventData
sysMouseWheelEvent :: Event t MouseWheelEventData
sysJoyAxisEvent :: Event t JoyAxisEventData
sysJoyBallEvent :: Event t JoyBallEventData
sysJoyHatEvent :: Event t JoyHatEventData
sysJoyButtonEvent :: Event t JoyButtonEventData
sysJoyDeviceEvent :: Event t JoyDeviceEventData
sysControllerAxisEvent :: Event t ControllerAxisEventData
sysControllerButtonEvent :: Event t ControllerButtonEventData
sysControllerDeviceEvent :: Event t ControllerDeviceEventData
sysAudioDeviceEvent :: Event t AudioDeviceEventData
sysQuitEvent :: Event t ()
sysUserEvent :: Event t UserEventData
sysSysWMEvent :: Event t SysWMEventData
sysTouchFingerEvent :: Event t TouchFingerEventData
sysMultiGestureEvent :: Event t MultiGestureEventData
sysDollarGestureEvent :: Event t DollarGestureEventData
sysDropEvent :: Event t DropEventData
sysClipboardUpdateEvent :: Event t ()
sysUnknownEvent :: Event t UnknownEventData

Running an app

host Source #

Arguments

:: ReaderT (SystemEvents Spider) (PerformEventT Spider (SpiderHost Global)) a	A concrete reflex-sdl2 network to run.
-> IO ()

Host a reflex-sdl2 app.

Debugging

putDebugLnE Source #

Arguments

:: (PerformEvent t m, Reflex t, MonadIO (Performable m))
=> Event t a	The `Event` to trigger the print.
-> (a -> String)	A function to show the `Event`s value.
-> m ()

Like putStrLn, but for Events.

Convenience constraints

type ReflexSDL2 t m = (Reflex t, MonadHold t m, PerformEvent t m, MonadFix m, MonadIO m, MonadIO (Performable m), MonadReader (SystemEvents t) m) Source #

A collection of constraints that represent a reflex-sdl2 network.

Re-exports

module Reflex

module SDL

class Monad m => MonadReader r m | m -> r #

See examples in Control.Monad.Reader. Note, the partially applied function type (->) r is a simple reader monad. See the instance declaration below.

Minimal complete definition

(ask | reader), local

Instances

MonadReader r m => MonadReader r (MaybeT m)
Methods ask :: MaybeT m r # local :: (r -> r) -> MaybeT m a -> MaybeT m a # reader :: (r -> a) -> MaybeT m a #
MonadReader r m => MonadReader r (ListT m)
Methods ask :: ListT m r # local :: (r -> r) -> ListT m a -> ListT m a # reader :: (r -> a) -> ListT m a #
MonadReader r ((->) r)
Methods ask :: r -> r # local :: (r -> r) -> (r -> a) -> r -> a # reader :: (r -> a) -> r -> a #
(Representable f, (~) * (Rep f) a) => MonadReader a (Co f)
Methods ask :: Co f a # local :: (a -> a) -> Co f a -> Co f a # reader :: (a -> a) -> Co f a #
MonadReader e m => MonadReader e (CatchT m)
Methods ask :: CatchT m e # local :: (e -> e) -> CatchT m a -> CatchT m a # reader :: (e -> a) -> CatchT m a #
MonadReader e m => MonadReader e (IterT m)
Methods ask :: IterT m e # local :: (e -> e) -> IterT m a -> IterT m a # reader :: (e -> a) -> IterT m a #
(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)
Methods ask :: WriterT w m r # local :: (r -> r) -> WriterT w m a -> WriterT w m a # reader :: (r -> a) -> WriterT w m a #
(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)
Methods ask :: WriterT w m r # local :: (r -> r) -> WriterT w m a -> WriterT w m a # reader :: (r -> a) -> WriterT w m a #
MonadReader r m => MonadReader r (StateT s m)
Methods ask :: StateT s m r # local :: (r -> r) -> StateT s m a -> StateT s m a # reader :: (r -> a) -> StateT s m a #
MonadReader r m => MonadReader r (StateT s m)
Methods ask :: StateT s m r # local :: (r -> r) -> StateT s m a -> StateT s m a # reader :: (r -> a) -> StateT s m a #
MonadReader r m => MonadReader r (IdentityT * m)
Methods ask :: IdentityT * m r # local :: (r -> r) -> IdentityT * m a -> IdentityT * m a # reader :: (r -> a) -> IdentityT * m a #
MonadReader r m => MonadReader r (ExceptT e m)
Methods ask :: ExceptT e m r # local :: (r -> r) -> ExceptT e m a -> ExceptT e m a # reader :: (r -> a) -> ExceptT e m a #
(Error e, MonadReader r m) => MonadReader r (ErrorT e m)
Methods ask :: ErrorT e m r # local :: (r -> r) -> ErrorT e m a -> ErrorT e m a # reader :: (r -> a) -> ErrorT e m a #
(Functor f, MonadReader r m) => MonadReader r (FreeT f m)
Methods ask :: FreeT f m r # local :: (r -> r) -> FreeT f m a -> FreeT f m a # reader :: (r -> a) -> FreeT f m a #
Monad m => MonadReader r (ReaderT * r m)
Methods ask :: ReaderT * r m r # local :: (r -> r) -> ReaderT * r m a -> ReaderT * r m a # reader :: (r -> a) -> ReaderT * r m a #
MonadReader r' m => MonadReader r' (ContT * r m)
Methods ask :: ContT * r m r' # local :: (r' -> r') -> ContT * r m a -> ContT * r m a # reader :: (r' -> a) -> ContT * r m a #
MonadReader r m => MonadReader r (DynamicWriterT t w m)
Methods ask :: DynamicWriterT t w m r # local :: (r -> r) -> DynamicWriterT t w m a -> DynamicWriterT t w m a # reader :: (r -> a) -> DynamicWriterT t w m a #
MonadReader r m => MonadReader r (EventWriterT t w m)
Methods ask :: EventWriterT t w m r # local :: (r -> r) -> EventWriterT t w m a -> EventWriterT t w m a # reader :: (r -> a) -> EventWriterT t w m a #
(Monad m, Monoid w) => MonadReader r (RWST r w s m)
Methods ask :: RWST r w s m r # local :: (r -> r) -> RWST r w s m a -> RWST r w s m a # reader :: (r -> a) -> RWST r w s m a #
(Monad m, Monoid w) => MonadReader r (RWST r w s m)
Methods ask :: RWST r w s m r # local :: (r -> r) -> RWST r w s m a -> RWST r w s m a # reader :: (r -> a) -> RWST r w s m a #
MonadReader r m => MonadReader r (RequesterT t request response m)
Methods ask :: RequesterT t request response m r # local :: (r -> r) -> RequesterT t request response m a -> RequesterT t request response m a # reader :: (r -> a) -> RequesterT t request response m a #

asks #

Arguments

:: MonadReader r m
=> (r -> a)	The selector function to apply to the environment.
-> m a

Retrieves a function of the current environment.

class Monad m => MonadIO m where #

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

```
liftIO . return = return
```

liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Minimal complete definition

liftIO

Methods

liftIO :: IO a -> m a #

Lift a computation from the IO monad.

Instances

MonadIO IO
Methods liftIO :: IO a -> IO a #
MonadIO m => MonadIO (CatchT m)
Methods liftIO :: IO a -> CatchT m a #
MonadIO m => MonadIO (IterT m)
Methods liftIO :: IO a -> IterT m a #
MonadIO m => MonadIO (ListT m)
Methods liftIO :: IO a -> ListT m a #
MonadIO m => MonadIO (MaybeT m)
Methods liftIO :: IO a -> MaybeT m a #
MonadIO (BehaviorM x)
Methods liftIO :: IO a -> BehaviorM x a #
MonadIO (EventM x)
Methods liftIO :: IO a -> EventM x a #
MonadIO (ComputeM x)
Methods liftIO :: IO a -> ComputeM x a #
MonadIO (SpiderPullM x)
Methods liftIO :: IO a -> SpiderPullM x a #
MonadIO (SpiderPushM x)
Methods liftIO :: IO a -> SpiderPushM x a #
MonadIO (SpiderHost x)
Methods liftIO :: IO a -> SpiderHost x a #
MonadIO (SpiderHostFrame x)
Methods liftIO :: IO a -> SpiderHostFrame x a #
MonadIO m => MonadIO (IdentityT * m)
Methods liftIO :: IO a -> IdentityT * m a #
(Functor f, MonadIO m) => MonadIO (FreeT f m)
Methods liftIO :: IO a -> FreeT f m a #
(Error e, MonadIO m) => MonadIO (ErrorT e m)
Methods liftIO :: IO a -> ErrorT e m a #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Methods liftIO :: IO a -> WriterT w m a #
MonadIO m => MonadIO (StateT s m)
Methods liftIO :: IO a -> StateT s m a #
MonadIO m => MonadIO (ExceptT e m)
Methods liftIO :: IO a -> ExceptT e m a #
MonadIO m => MonadIO (StateT s m)
Methods liftIO :: IO a -> StateT s m a #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Methods liftIO :: IO a -> WriterT w m a #
MonadIO m => MonadIO (TriggerEventT t m)
Methods liftIO :: IO a -> TriggerEventT t m a #
MonadIO m => MonadIO (PostBuildT t m)
Methods liftIO :: IO a -> PostBuildT t m a #
MonadIO m => MonadIO (ReaderT * r m)
Methods liftIO :: IO a -> ReaderT * r m a #
MonadIO m => MonadIO (ContT * r m)
Methods liftIO :: IO a -> ContT * r m a #
(ReflexHost t, MonadIO (HostFrame t)) => MonadIO (PerformEventT k t m)
Methods liftIO :: IO a -> PerformEventT k t m a #
MonadIO m => MonadIO (QueryT t q m)
Methods liftIO :: IO a -> QueryT t q m a #
MonadIO m => MonadIO (EventWriterT t w m)
Methods liftIO :: IO a -> EventWriterT t w m a #
MonadIO m => MonadIO (DynamicWriterT t w m)
Methods liftIO :: IO a -> DynamicWriterT t w m a #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Methods liftIO :: IO a -> RWST r w s m a #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Methods liftIO :: IO a -> RWST r w s m a #
MonadIO m => MonadIO (RequesterT t request response m)
Methods liftIO :: IO a -> RequesterT t request response m a #

liftIO :: MonadIO m => forall a. IO a -> m a #

Lift a computation from the IO monad.