MiniLight

MiniLight module exports all basic concepts and oprations except for concrete components.

Documentation

module MiniLight.Light

module MiniLight.Event

module MiniLight.Figure

module MiniLight.Component

runLightT :: (MonadIO m, MonadMask m) => LightT LightEnv m a -> m a

Run a Light monad.

data LoopState

The state in the mainloop.

Constructors

LoopState

Fields

• light :: LightEnv
• loop :: LoopEnv
• loader :: LoaderEnv

Instances

HasLightEnv LoopState

Defined in MiniLight

Methods

lightEnv :: Lens' LoopState LightEnv

_fontCache :: Lens' LoopState FontMap

_logger :: Lens' LoopState LogQueue

_renderer :: Lens' LoopState Renderer

HasLoopEnv LoopState

Defined in MiniLight

Methods

loopEnv :: Lens' LoopState LoopEnv

_events :: Lens' LoopState (MVar [Event])

_keyStates :: Lens' LoopState (HashMap Scancode Int)

_signalQueue :: Lens' LoopState (IORef [Event])

HasLoaderEnv LoopState

Defined in MiniLight

Methods

loaderEnv :: Lens' LoopState LoaderEnv

_appConfig :: Lens' LoopState (IORef AppConfig)

_registry :: Lens' LoopState (Registry Component)

data LoopConfig

Use defConfig for a default setting.

Constructors

LoopConfig

Fields

• watchKeys :: Maybe [Scancode]

  Set Nothing if all keys should be watched. See also LoopState.

• appConfigFile :: Maybe FilePath

  Specify a yaml file which describes component settings. See Component for the yaml syntax.

• hotConfigReplacement :: Maybe FilePath

  The directory path to be watched. If set, the config file modification will replace the component dynamically.

• componentResolver :: Resolver

  Your custom mappings between a component name and its type.

• additionalComponents :: [Component]

  The components here would be added during the initialization.

defConfig :: LoopConfig

Default configurations for the mainloop. You need to set componentResolver if you use a component.

runMainloop

Arguments

:: (HasLightEnv env, HasLightEnv env', HasLoopEnv env', HasLoaderEnv env', MonadIO m, MonadMask m)

=> (env -> LoopEnv -> LoaderEnv -> env')

Environment conversion

-> LoopConfig

Loop config

-> s

Initial state

-> (s -> LightT env' m s)

A function called in every loop

-> LightT env m ()

Run a mainloop. In a mainloop, components and events are managed.

Components in a mainloop: draw ~ update ~ (user-defined function) ~ event handling

type MiniLoop = LightT LoopState IO

Type synonym to the minimal type of the mainloop

runMiniloop :: LoopConfig -> s -> (s -> MiniLoop s) -> MiniLight ()

Same as runMainloop but fixing the type.

Orphan instances

Hashable Scancode

Methods

hashWithSalt :: Int -> Scancode -> Int

hash :: Scancode -> Int

HasLightEnv env' => HasLightEnv (env, env')

Methods

lightEnv :: Lens' (env, env') LightEnv

_fontCache :: Lens' (env, env') FontMap

_logger :: Lens' (env, env') LogQueue

_renderer :: Lens' (env, env') Renderer

HasLoopEnv env' => HasLoopEnv (env, env')

Methods

loopEnv :: Lens' (env, env') LoopEnv

_events :: Lens' (env, env') (MVar [Event])

_keyStates :: Lens' (env, env') (HashMap Scancode Int)

_signalQueue :: Lens' (env, env') (IORef [Event])

HasComponentEnv (Text, env)

Methods

uidL :: Lens' (Text, env) Text

HasLoaderEnv env' => HasLoaderEnv (env, env')

Methods

loaderEnv :: Lens' (env, env') LoaderEnv

_appConfig :: Lens' (env, env') (IORef AppConfig)

_registry :: Lens' (env, env') (Registry Component)