| Copyright | (c) 2013 Diagrams team (see LICENSE) | 
|---|---|
| License | BSD-style (see LICENSE) | 
| Maintainer | diagrams-discuss@googlegroups.com | 
| Safe Haskell | None | 
| Language | Haskell2010 | 
Diagrams.Backend.SVG.CmdLine
Description
Convenient creation of command-line-driven executables for rendering diagrams using the SVG backend.
- defaultMaincreates an executable which can render a single diagram at various options.
- multiMainis like- defaultMainbut allows for a list of diagrams from which the user can choose one to render.
- mainWithis 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- Parseablearguments.
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 makingParseableinstances for custom argument types.
- Make a new Mainableinstance. 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 mainRenderfrom Diagrams.Backend.CmdLine.
- You can use renderSVGto 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 DoublemainWith
 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
Backend tokens
SVG is simply a token used to identify this rendering backend
   (to aid type inference).
Instances
| Show SVG Source # | |
| SVGFloat n => Backend SVG V2 n Source # | |
| SVGFloat n => Renderable (Text n) SVG Source # | |
| SVGFloat n => Renderable (DImage n Embedded) SVG Source # | |
| SVGFloat n => Renderable (Path V2 n) SVG Source # | |
| Monoid (Render SVG V2 n) Source # | |
| Hashable n => Hashable (Options SVG V2 n) Source # | |
| type V SVG Source # | |
| type N SVG Source # | |
| data Options SVG V2 Source # | |
| data Render SVG V2 Source # | |
| type Result SVG V2 n Source # | |
| type MainOpts [(String, QDiagram SVG V2 n Any)] # | |
| type MainOpts (QDiagram SVG V2 n Any) # | |