Diagrams.Backend.Cairo.Internal

This module contains the internal implementation guts of the diagrams cairo backend. If you want to see how the cairo backend works under the hood, you are in the right place (try clicking on the "Source" links). (Guts under the hood, what an awful mixed metaphor.) If you know what you are doing and really want access to the internals of the implementation, you are also in the right place. Otherwise, you should have no need of this module; import Diagrams.Backend.Cairo.CmdLine or Diagrams.Backend.Cairo instead.

The one exception is that this module may have to be imported sometimes to work around an apparent bug in certain versions of GHC, which results in a "not in scope" error for CairoOptions.

The types of all the fromX functions look funny in the Haddock output, which displays them like Type -> Type. In fact they are all of the form Type -> Graphics.Rendering.Cairo.Type, i.e. they convert from a diagrams type to a cairo type of the same name.

Documentation

data Cairo

This data declaration is simply used as a token to distinguish the cairo backend: (1) when calling functions where the type inference engine would otherwise have no way to know which backend you wanted to use, and (2) as an argument to the Backend and Renderable type classes.

Constructors

Cairo

Instances

Eq Cairo

Ord Cairo

Read Cairo

Show Cairo

Typeable * Cairo

Backend Cairo R2

Renderable Text Cairo

Mainable [(String, Diagram Cairo R2)]

Mainable [(Diagram Cairo R2, GifDelay)]

Renderable (DImage External) Cairo

Renderable (Trail R2) Cairo

Renderable (Path R2) Cairo

Show (Options Cairo R2)

Monoid (Render Cairo R2)

Hashable (Options Cairo R2)

Mainable (Animation Cairo R2)

Mainable (Diagram Cairo R2)

Renderable (Segment Closed R2) Cairo

type Result Cairo R2 = (IO (), Render ())

data Options Cairo R2 = CairoOptions {

• _cairoFileName :: String
• _cairoSizeSpec :: SizeSpec2D
• _cairoOutputType :: OutputType
• _cairoBypassAdjust :: Bool

}

data Render Cairo R2 = C (RenderM ())

type MainOpts [(String, Diagram Cairo R2)] = (MainOpts (Diagram Cairo R2), DiagramMultiOpts)

type MainOpts [(Diagram Cairo R2, GifDelay)] = (DiagramOpts, GifOpts)

type MainOpts (Animation Cairo R2) = (MainOpts (Diagram Cairo R2), DiagramAnimOpts)

type MainOpts (Diagram Cairo R2) = (DiagramOpts, DiagramLoopOpts)

type B = Cairo

data OutputType

Output types supported by cairo, including four different file types (PNG, PS, PDF, SVG). If you want to output directly to GTK windows, see the diagrams-gtk package.

Constructors

PNG

Portable Network Graphics output.

PS

PostScript output

PDF

Portable Document Format output.

SVG

Scalable Vector Graphics output.

RenderOnly

Don't output any file; the returned IO () action will do nothing, but the Render () action can be used (e.g. to draw to a Gtk window; see the diagrams-gtk package).

Instances

Bounded OutputType

Enum OutputType

Eq OutputType

Ord OutputType

Read OutputType

Show OutputType

Generic OutputType

Hashable OutputType

Typeable * OutputType

type Rep OutputType

data CairoState

Custom state tracked in the RenderM monad.

Constructors

CairoState

Fields

_accumStyle :: Style R2

The current accumulated style.

_ignoreFill :: Bool

Whether or not we saw any lines in the most recent path (as opposed to loops). If we did, we should ignore any fill attribute. diagrams-lib separates lines and loops into separate path primitives so we don't have to worry about seeing them together in the same path.

Instances

Default CairoState

ignoreFill :: Lens' CairoState Bool

accumStyle :: Lens' CairoState (Style R2)

type RenderM a = StateStackT CairoState Render a

The custom monad in which intermediate drawing options take place; Render is cairo's own rendering monad.

liftC :: Render a -> RenderM a

runRenderM :: RenderM a -> Render a

save :: RenderM ()

Push the current context onto a stack.

restore :: RenderM ()

Restore the context from a stack.

runC :: Render Cairo R2 -> RenderM ()

toRender :: RTree Cairo R2 a -> Render Cairo R2

cairoFileName :: Lens' (Options Cairo R2) String

cairoSizeSpec :: Lens' (Options Cairo R2) SizeSpec2D

cairoOutputType :: Lens' (Options Cairo R2) OutputType

cairoBypassAdjust :: Lens' (Options Cairo R2) Bool

renderC :: (Renderable a Cairo, V a ~ R2) => a -> RenderM ()

Render an object that the cairo backend knows how to render.

getStyleAttrib :: AttributeClass a => (a -> b) -> RenderM (Maybe b)

Get an accumulated style attribute from the render monad state.

cairoStyle :: Style v -> RenderM ()

Handle those style attributes for which we can immediately emit cairo instructions as we encounter them in the tree (clip, font size, fill rule, line width, cap, join, and dashing). Other attributes (font face, slant, weight; fill color, stroke color, opacity) must be accumulated.

fromFontSlant :: FontSlant -> FontStyle

fromFontWeight :: FontWeight -> Weight

applyOpacity :: Color c => c -> Style v -> AlphaColour Double

Apply the opacity from a style to a given color.

cairoTransf :: T2 -> Render ()

Multiply the current transformation matrix by the given 2D transformation.

fromLineCap :: LineCap -> LineCap

fromLineJoin :: LineJoin -> LineJoin

fromFillRule :: FillRule -> FillRule

cairoPath :: Path R2 -> RenderM ()

addStop :: MonadIO m => Pattern -> GradientStop -> m ()

cairoSpreadMethod :: SpreadMethod -> Extend

setTexture :: Maybe Texture -> RenderM ()

if' :: Monad m => (a -> m ()) -> Maybe a -> m ()