Diagrams.Backend.SVG.CmdLine

Convenient creation of command-line-driven executables for rendering diagrams using the SVG backend.

• defaultMain creates an executable which can render a single diagram at various options.
• multiMain is like defaultMain but allows for a list of diagrams from which the user can choose one to render.
• mainWith is a generic form that does all of the above but with a slightly scarier type. See Diagrams.Backend.CmdLine. This form can also take a function type that has a subtable final result (any of arguments to the above types) and Parseable arguments.

If you want to generate diagrams programmatically---i.e. if you want to do anything more complex than what the below functions provide---you have several options.

• Use a function with mainWith. This may require making Parseable instances for custom argument types.
• Make a new Mainable instance. This may require a newtype wrapper on your diagram type to avoid the existing instances. This gives you more control over argument parsing, intervening steps, and diagram creation.
• Build option records and pass them along with a diagram to mainRender from Diagrams.Backend.CmdLine.
• You can use renderSVG to render a diagram to a file directly; see Diagrams.Backend.SVG.
• A more flexible approach is to directly call renderDia; see Diagrams.Backend.SVG for more information.

For a tutorial on command-line diagram creation see http://projects.haskell.org/diagrams/doc/cmdline.html.

General form of main

The mainWith method unifies all of the other forms of main and is now the recommended way to build a command-line diagrams program. It works as a direct replacement for defaultMain or multiMain as well as allowing more general arguments. For example, given a function that produces a diagram when given an Int and a Colour Double, mainWith will produce a program that looks for additional number and color arguments.

... definitions ...
f :: Int -> Colour Double -> Diagram SVG V2 Double
f i c = ...

main = mainWith f

We can run this program as follows:

$ ghc --make MyDiagram

# output image.svg built by `f 20 red`
$ ./MyDiagram -o image.svg -w 200 20 red

mainWith :: (Mainable d, Parseable (MainOpts d)) => d -> IO ()

Main entry point for command-line diagram creation. This is the method that users will call from their program main. For instance an expected user program would take the following form.

import Diagrams.Prelude
import Diagrams.Backend.TheBestBackend.CmdLine

d :: Diagram B R2
d = ...

main = mainWith d

Most backends should be able to use the default implementation. A different implementation should be used to handle more complex interactions with the user.

Supported forms of main

defaultMain :: SVGFloat n => QDiagram SVG V2 n Any -> IO ()

multiMain :: SVGFloat n => [(String, QDiagram SVG V2 n Any)] -> IO ()

Backend tokens

data SVG

SVG is simply a token used to identify this rendering backend (to aid type inference).

Instances

Show SVG

Methods

showsPrec :: Int -> SVG -> ShowS

show :: SVG -> String

showList :: [SVG] -> ShowS

SVGFloat n => Backend SVG V2 n

Associated Types

data Render SVG (V2 :: * -> *) n :: *

type Result SVG (V2 :: * -> *) n :: *

data Options SVG (V2 :: * -> *) n :: *

Methods

adjustDia :: (Additive V2, Monoid' m, Num n) => SVG -> Options SVG V2 n -> QDiagram SVG V2 n m -> (Options SVG V2 n, Transformation V2 n, QDiagram SVG V2 n m)

renderRTree :: SVG -> Options SVG V2 n -> RTree SVG V2 n Annotation -> Result SVG V2 n

SVGFloat n => Renderable (Text n) SVG

Methods

render :: SVG -> Text n -> Render SVG (V (Text n)) (N (Text n))

SVGFloat n => Renderable (DImage n Embedded) SVG

Methods

render :: SVG -> DImage n Embedded -> Render SVG (V (DImage n Embedded)) (N (DImage n Embedded))

SVGFloat n => Renderable (Path V2 n) SVG

Methods

render :: SVG -> Path V2 n -> Render SVG (V (Path V2 n)) (N (Path V2 n))

Monoid (Render SVG V2 n)

Methods

mempty :: Render SVG V2 n

mappend :: Render SVG V2 n -> Render SVG V2 n -> Render SVG V2 n

mconcat :: [Render SVG V2 n] -> Render SVG V2 n

Hashable n => Hashable (Options SVG V2 n)

Methods

hashWithSalt :: Int -> Options SVG V2 n -> Int

hash :: Options SVG V2 n -> Int

type V SVG

type V SVG = V2

type N SVG

type N SVG = Double

data Options SVG V2

data Options SVG V2 = SVGOptions {

• _size :: SizeSpec V2 n
• _svgDefinitions :: Maybe Element
• _idPrefix :: Text
• _svgAttributes :: [Attribute]
• _generateDoctype :: Bool

}

data Render SVG V2

data Render SVG V2 = R (SvgRenderM n)

type Result SVG V2 n

type Result SVG V2 n = Element

type MainOpts [(String, QDiagram SVG V2 n Any)]

type MainOpts [(String, QDiagram SVG V2 n Any)] = (MainOpts (QDiagram SVG V2 n Any), DiagramMultiOpts)

type MainOpts (QDiagram SVG V2 n Any)

type MainOpts (QDiagram SVG V2 n Any)

type B = SVG

Orphan instances

SVGFloat n => Mainable [(String, QDiagram SVG V2 n Any)]

Associated Types

type MainOpts [(String, QDiagram SVG V2 n Any)] :: *

Methods

mainArgs :: [(String, QDiagram SVG V2 n Any)] -> IO (MainOpts [(String, QDiagram SVG V2 n Any)])

mainRender :: MainOpts [(String, QDiagram SVG V2 n Any)] -> [(String, QDiagram SVG V2 n Any)] -> IO ()

mainWith :: [(String, QDiagram SVG V2 n Any)] -> IO ()

SVGFloat n => Mainable (QDiagram SVG V2 n Any)

Associated Types

type MainOpts (QDiagram SVG V2 n Any) :: *

Methods

mainArgs :: QDiagram SVG V2 n Any -> IO (MainOpts (QDiagram SVG V2 n Any))

mainRender :: MainOpts (QDiagram SVG V2 n Any) -> QDiagram SVG V2 n Any -> IO ()

mainWith :: QDiagram SVG V2 n Any -> IO ()