Copyright | (c) 2013 Diagrams team (see LICENSE) |
---|---|
License | BSD-style (see LICENSE) |
Maintainer | diagrams-discuss@googlegroups.com |
Safe Haskell | None |
Language | Haskell2010 |
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 likedefaultMain
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) andParseable
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 makingParseable
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
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).
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) # | |