Data.Renderable

Documentation

renderData :: (Monad m, Renderable a, Monoid (RenderTfrm a)) => Cache m (RenderTfrm a) -> a -> m ()

Render a datatype using renderings stored in the given cache.

renderDataHidden :: (Renderable a, Monad m, Monoid (RenderTfrm a)) => Cache m (RenderTfrm a) -> RenderTfrm a -> a -> m ()

Render only the hidden layers of a datatype using renderings stored in the given cache. This is sometimes useful for debugging.

renderComposite :: (Monad m, Monoid t) => Cache m t -> t -> Composite t -> m ()

Render the composite of a datatype using renderings stored in the given cache.

attachIfNeeded :: (Renderable a, Monad (RenderMonad a), Monoid (RenderTfrm a), Hashable a) => RenderRsrc a -> Cache (RenderMonad a) (RenderTfrm a) -> a -> RenderMonad a (Cache (RenderMonad a) (RenderTfrm a))

If needed, create a new rendering given some resources, insert it in the cache and return the new cache.

detachUnused :: (Monad m, Renderable a) => Cache m t -> a -> m (Cache m t)

Detach any renderings that are not needed to render the given data.

detach :: Monad m => Cache m t -> Int -> m (Cache m t)

Remove a rendering from a cache and clean up the resources allocated for that rendering.

data Element m r t where

Element is a generic existential type that can be used to enclose instances of Renderable in order to contain them all in a heterogeneous list. m, r and t must be shared with all Renderable instances stored in a heterogeneous list of Elements.

Constructors

Element :: (Monad m, Show a, Hashable a, Renderable a, m ~ RenderMonad a, r ~ RenderRsrc a, t ~ RenderTfrm a) => a -> Element m r t

Instances

Eq (Element m r t)

Show (Element m r t)

Hashable (Element m r t)

Renderable (Element m r t)

type RenderMonad (Element m r t) = m

type RenderTfrm (Element m r t) = t

type RenderRsrc (Element m r t) = r

class Renderable a where

Associated Types

type RenderMonad a :: * -> *

type RenderTfrm a :: *

type RenderRsrc a :: *

Methods

nameOf :: a -> String

The name of a renderable datatype. This is mostly for debugging.

cache :: (Monad (RenderMonad a), Monoid (RenderTfrm a)) => RenderRsrc a -> Cache (RenderMonad a) (RenderTfrm a) -> a -> RenderMonad a (Cache (RenderMonad a) (RenderTfrm a))

Store the rendering of a datatype in a cache keyed by the hash of that datatype. Returns the new cache.

composite :: a -> Composite (RenderTfrm a)

The entire composite list of renderings for a given datatype.

Instances

(Renderable a, Hashable a) => Renderable [a]

(Renderable a, Hashable a, Show a) => Renderable (Maybe a)

Renderable (Element m r t)

type Cache m t = IntMap (Rendering m t)

A cache of renderings.

data Rendering m t

A rendering is a type that contains some effectful computation for displaying something given a transform. It also contains an effectful computation for cleaning up any resources allocated during its creation.

Constructors

Rendering

Fields

render :: t -> m ()

clean :: m ()

Instances

Monad m => Monoid (Rendering m t)

type Composite a = [(Int, Maybe a)]

A composite is a representation of the entire rendered datatype. It is a flattened list of all the renderings (denoted by hash), along with that renderings local transformation. If a rendering is explicitly run by another rendering (as in a Renderable class definition) then the transformation for that rendering should be Nothing, which will keep renderComposite from running that rendering in addition to the rendering its included in. For example: [(0, Just $ Transform (10,10) (0.5,0.5) 0) ,(1, Nothing) ] The above is a composite of two renderings, the first will be rendered by renderComposite using the given transform while the second is effectively hidden but present. Being present in the composite will keep detachUnused from detaching and cleaning the rendering.