Wumpus.Basic.Graphic.Base

Base types for Drawing Objects, Graphics / Images (a Graphic that also returns an answer), etc.

Base classes for monadic drawing.

Notes on prefix and suffix names:

Function types suffixed F are functions from same-to-same, e.g.:

 type Point2F u = Point2 u -> Point2 u

Functional types subfixed R are functions from some static context to the answer type (c.f the ReaderMonad), e.g.:

 newtype DrawingR a = DrawingR { getDrawingR :: DrawingContext -> a }

The suffix M is used for classes defining monadic actions.

The prefix Loc indicates a functional type from Point2 to something...

The prefix ThetaLoc indicates a functional type from Direction (radian) then Point to something...

** WARNING ** - some names are expected to change.

Documentation

class OPlus t where

A Semigroup class.

Methods

oplus :: t -> t -> t

Instances

OPlus (Primitive u)

OPlus (PrimGraphic u)

OPlus a => OPlus (DrawingR a)

OPlus a => OPlus (r -> a)

(OPlus a, OPlus b) => OPlus (a, b)

oconcat :: OPlus t => t -> [t] -> t

anterior :: OPlus t => t -> t -> t

superior :: OPlus t => t -> t -> t

Drawing monads.

type family MonUnit m :: *

DUnit is always for fully saturated type constructors, so (seemingly) an equivalent type family is needed for monads.

class Monad m => TraceM m where

Collect elementary graphics as part of a larger drawing.

TraceM works much like a writer monad.

Methods

trace :: HPrim (MonUnit m) -> m ()

Instances

TraceM (Drawing u)

Monad m => TraceM (DrawingT u m)

(u ~ MonUnit m, Monad m, TraceM m) => TraceM (TurtleT u m)

(u ~ MonUnit m, Monad m, TraceM m) => TraceM (ScalingT ux uy u m)

class (Applicative m, Monad m) => DrawingCtxM m where

Methods

askDC :: m DrawingContext

localize :: (DrawingContext -> DrawingContext) -> m a -> m a

Instances

DrawingCtxM DrawingR

DrawingCtxM (Drawing u)

Monad m => DrawingCtxM (DrawingT u m)

DrawingCtxM m => DrawingCtxM (TurtleT u m)

DrawingCtxM m => DrawingCtxM (ScalingT ux uy u m)

asksDC :: DrawingCtxM m => (DrawingContext -> a) -> m a

Project a value out of a context.

class Monad m => PointSupplyM m where

A monad that supplies points, e.g. a turtle monad.

Methods

position :: u ~ MonUnit m => m (Point2 u)

Instances

(u ~ MonUnit m, Monad m, Num u) => PointSupplyM (TurtleT u m)

Base types

data HPrim u

Graphics objects, even simple ones (line, arrow, dot) might need more than one primitive (path or text label) for their construction. Hence, the primary representation that all the others are built upon must support concatenation of primitives.

Wumpus-Core has a type Picture - made from one or more Primitives - but Pictures include support for affine frames. For drawing many simple graphics (dots, connector lines...) that do not need individual affine transformations this is a penalty. A list of Primitives is therefore more suitable representation, and a Hughes list which supports efficient concatenation is wise.

Instances

Monoid (HPrim u)

hprimToList :: HPrim u -> [Primitive u]

singleH :: Primitive u -> HPrim u

type Point2F u = Point2 u -> Point2 u

Point transformation function.

type DPoint2F = Point2F Double

data DrawingR a

Drawings in Wumpus-Basic have an implicit graphics state the DrawingContext, the most primitive building block is a function from the DrawingContext to some polymorphic answer.

This functional type is represented concretely as DrawingR.

 DrawingR :: DrawingContext -> a 

Instances

Monad DrawingR

Functor DrawingR

Applicative DrawingR

DrawingCtxM DrawingR

Monoid a => Monoid (DrawingR a)

OPlus a => OPlus (DrawingR a)

type LocDrawingR u a = Point2 u -> DrawingR a

type DLocDrawingR a = LocDrawingR Double a

type DrawingTrafoF a = DrawingR a -> DrawingR a

runDrawingR :: DrawingContext -> DrawingR a -> a

Run a Drawing Function with the supplied Drawing Context.

data PrimGraphic u

Instances

Eq u => Eq (PrimGraphic u)

Show u => Show (PrimGraphic u)

(Real u, Floating u) => Rotate (PrimGraphic u)

(Real u, Floating u) => RotateAbout (PrimGraphic u)

Num u => Scale (PrimGraphic u)

Num u => Translate (PrimGraphic u)

OPlus (PrimGraphic u)

getPrimGraphic :: PrimGraphic u -> Primitive u

wrapPrim :: Primitive u -> PrimGraphic u

collectH :: PrimGraphic u -> HPrim u

type Graphic u = DrawingR (PrimGraphic u)

type DGraphic = Graphic Double

type GraphicTrafoF u = Graphic u -> Graphic u

superiorGraphic :: Graphic u -> GraphicTrafoF u

anteriorGraphic :: Graphic u -> GraphicTrafoF u

runGraphic :: DrawingContext -> Graphic u -> PrimGraphic u

xlinkGraphic :: XLink -> Graphic u -> Graphic u

type LocGraphic u = Point2 u -> Graphic u

Commonly graphics take a start point as well as a drawing context.

Here they are called a LocGraphic - graphic with a (starting) location.

type DLocGraphic = LocGraphic Double

type Image u a = DrawingR (a, PrimGraphic u)

Images return a value as well as drawing. A node is a typical example - nodes are drawing but the also support taking anchor points.

type DImage a = Image Double a

type ImageTrafoF u a = Image u a -> Image u a

intoImageTrafo :: DrawingTrafoF a -> GraphicTrafoF u -> ImageTrafoF u a

imageTrafoDrawing :: DrawingTrafoF a -> ImageTrafoF u a

imageTrafoGraphic :: GraphicTrafoF u -> ImageTrafoF u a

type LocImage u a = Point2 u -> Image u a

type DLocImage a = LocImage Double a

runImage :: DrawingContext -> Image u a -> (a, PrimGraphic u)

intoImage :: DrawingR a -> Graphic u -> Image u a

intoLocImage :: LocDrawingR u a -> LocGraphic u -> LocImage u a

xlinkImage :: XLink -> Image u a -> Image u a

type ConnectorDrawingR u a = Point2 u -> Point2 u -> DrawingR a

type DConnectorDrawingR a = ConnectorDrawingR Double a

type ConnectorGraphic u = Point2 u -> Point2 u -> Graphic u

ConnectorGraphic is a connector drawn between two points contructing a Graphic.

type DConnectorGraphic = ConnectorGraphic Double

type ConnectorImage u a = Point2 u -> Point2 u -> Image u a

ConnectorImage is a connector drawn between two points constructing an Image.

Usually the answer type of a ConnectorImage will be a Path so the Points ar midway, atstart etc. can be taken on it.

type DConnectorImage a = ConnectorImage Double a

intoConnectorImage :: ConnectorDrawingR u a -> ConnectorGraphic u -> ConnectorImage u a

type ThetaLocDrawingR u a = Radian -> LocDrawingR u a

type DThetaLocDrawingR a = ThetaLocDrawingR Double a

type ThetaLocGraphic u = Radian -> LocGraphic u

A function from Radian -\> Point -\> Graphic...

type DThetaLocGraphic = ThetaLocGraphic Double

type ThetaLocImage u a = Radian -> LocImage u a

type DThetaLocImage a = ThetaLocImage Double a

intoThetaLocImage :: ThetaLocDrawingR u a -> ThetaLocGraphic u -> ThetaLocImage u a