The type of x-coordinates.

The type of y-coordinates.

The type of colors.

A enumeration type for base fonts. For the time being, we only offer TimesRoman and Helvetica.

A type representing font metrics for a given base font. The first component is the default width of characters; the second component is a map from characters to widths.

Define a font metric for each base font.

Font metrics for TimesRoman.

Font metrics for Helvetica.

Look up the width of a character in the given metric.

Look up with width of a string in the given metric.

A data type describing a scaled font. This consists of a base font and a point size.

Return the nominal point size of a font.

Return the width of the given string in the given font.

A real number representing text alignment. 0 = left aligned, 0.5 = centered, 1 = right aligned. Intermediate values are also possible. For example, an alignment value of 0.25 means one quarter of the way between left aligned and right aligned.

Left alignment.

Centered alignment.

Right alignment.

The Document monad.

Skip document without rendering.

Create a page of the given bounding box, containing the given drawing.

Create a page containing the given drawing, with the bounding box computed at the end of the drawing routines.

End the page with the given bounding box.

An abstract data type describing individual drawing commands.

The Draw monad.

Write the given command to the Draw monad.

Create a new subroutine.

Write a block to the Draw monad.

Skip draw actions without rendering.

Set the current path to empty.

Start a new subpath at (x,y). The point (x,y) becomes the current point.

Extend the current subpath by a straight line segment from the current point to (x,y). The point (x,y) becomes the current point.

curveto x1 y1 x2 y2 x y: Extend the current subpath by a Bezier curve segment from the current point to (x,y), with control points (x1,y1) and (x2,y2). The point (x,y) becomes the current point.

Close the current subpath. If necessary, connect the subpath's final and initial points by a straight line segment. Note that a closed path is rendered differently than a non-closed path whose initial and final points coincide, because in the latter case, the endpoints are capped rather than mitered.

Use the current path as a clipping path. The non-zero winding number determines which points lie "inside" the path. All subsequent drawing operations only paint inside the clipping path. This operation implicitly resets the curent path to empty. There is no way to undo this operation, except by enclosing it in the local block.

Stroke the current path, using the current line color, line width, and other graphics parameters. This operation implicitly resets the current path to empty.

Fill the current path, using the given color. This operation implicitly resets the current path to empty.

Fill the current path, using the given color; also stroke the path using the current line color. This operation implicitly resets the current path to empty.

textbox a f c x0 y0 x1 y1 b s: Write the given string on an imaginary line from point (x0,y0) to (x1,y1), using font f and color c. If the text is too wide to fit on the line, it is scaled down. Otherwise, it is aligned according to the alignment parameter a. The parameter b specifies an additional offset by which to lower the text, with respect to the text's nominal size. For example, if b=0, then the above-mentioned imaginary line from (x0,y0) to (x1,y1) coincides with the text's usual baseline. If b=0.5, then this line approximately goes through the center of each character.

Set the line width. The initial line width is 1.

Set the current color for stroking. The initial stroke color is black.

Translate the current coordinate system by (x,y).

Scale the current coordinate system by (s,t). Here, s is the scaling factor in the x-direction, and t is the scaling factor in the y-direction.

Rotate the current coordinate system by angle, measured counterclockwise in degrees.

Insert a human-readable comment in the content stream. This is for information only, and is not rendered in the graphical output.

Perform a block of commands in a local copy of the graphics state. This is intended to be used like this:

    block $ do
      <<drawing commands>>

Start a new subpath consisting of a circular arc segment. The arc segment is centered at (x,y), has radius r, and extends from angle a1 to angle a2, measured in degrees, counterclockwise from the x-axis. The arc is drawn counterclockwise if a2 ≥ a1, and clockwise otherwise. The final point becomes the new current point.

Like arc, except append to the current subpath. If necessary, add a straight line segment from the current point to the starting point of the arc.

Append a new closed subpath consisting of an oval centered at (x,y), with horizontal and vertical radii rx and ry, respectively.

The common implementation of arc, arc_append, and oval. The first parameter is a boolean flag indicating whether to append to an existing subpath or start a new subpath. The fourth and fifth parameter are the horizontal and vertical radius.

rectangle x y w h: Draw a rectangle of width w and height h, starting from (x,y). If w and h are positive, then (x,y) is the lower left corner.

An enumeration of backend languages, for the purpose of defining custom drawing commands. Note that several backends (e.g. EPS and PostScript) may share the same language, and therefore they are only represented once in this enumeration.

The type of custom definitions, to be used with the draw_subroutine command.

Define a custom PostScript definition.

Define a custom PDF definition.

Define a custom ASCII definition.

Look up an element in a list of CustomDefs.

A data structure that holds application-specific meta-data and customization information.

An empty customization structure. Customizations should be specified by modifying custom, for example:

custom { creator = "MyApp 1.0" }

A WriterMonad is any monad that one can output strings to.

Minimal complete definition: wPutChar or wPutStr.

Like wPutStr, but adds a newline character.

Write a value of any printable type, and add a newline.

A generic WriterMonad.

Isomorphically map a Writer computation to a pair of a string and a value.

Important usage note: the String in the output is produced lazily, and before a is produced. To preserve laziness, do not evaluate a before the end of String has been reached.

The inverse of writer_to_pair.

Run a Writer computation in any WriterMonad.

Run a writer in the IO monad by printing to a file.

Run a writer by printing to a string.

Create an identical "boxed" copy of a type constructor. This is used for technical reasons, to allow the wprintf operation to be typed.

Unbox a boxed item.

A class to curry/uncurry functions in any boxed monad. This establishes an isomorphism

@fun  ≅  args -> Boxed m res,@

where

fun = a1 -> a2 -> ... -> an -> Boxed m res,
args = (a1, (a2, (..., (an, ())))).

Print a formatted value in the context of a boxed WriterMonad. Usage:

wprintf "%f %f" x y :: Boxed Writer

In any WriterMonad, introduce a block in which wprintf can be used. This has no computational overhead, i.e., is compiled to the identity operation; it exists only to please the type system, due to the fancy typing of wprintf.

Wrap a filter around a Writer computation. This introduces a local block within the Writer monad; all text written within the block is encoded through the given filter. Filters can be composed and nested.

A filter for performing "flate" (also known as "zlib") compression.

Note: both the input and output strings are regarded as sequences of bytes, not characters. Any characters outside the byte range are truncated to 8 bits.

Ensure that the last line of the string ends in a newline character, adding one if necessary. An empty string is considered to contain zero lines, so no newline character needs to be added.

Render draw actions as ASCII.

Render drawing commands as ASCII.

Render a document as ASCII.

Render a document as ASCII. This is for debugging purposes only. The output is a sequence of drawing commands, rather than a graphical representation.

Escape special characters in a string literal.

Remove newline characters in a string.

The type of page numbers.

A state to keep track of a current bounding box and page number.

The initial PS_State.

The PSWriter monad. This is just a PS_State wrapped around the Writer monad.

Run function for the PSWriter monad.

Get the bounding box.

Add to the bounding box.

Get the page count.

Return the next page number.

Render draw actions as PostScript.

Set the color.

Set the font.

Draw a single drawing command to PostScript.

Render a document as PostScript.

Global PostScript definitions used by the rendering engine.

Render pages as PostScript.

Render document as PostScript. The first argument is a customization data structure.

Render a document as EPS. Since EPS only permits a single page of output, the Page parameter is used to specify which page (of a potential multi-page document) should be printed. An error will be thrown if the page number was out of range.

Note: if the return value is not used, the remaining pages are lazily skipped.

Render document as EPS. The first argument is a customization data structure, and the second argument is the number of the page to extract from the document.

Escape special characters in a string literal.

A position in a file. The first byte is 0.

A PDF object reference.

A state to keep track of PDF document structure: current character count, current TOC, current page, etc.

The initial PDF_State.

The RawPDFWriter monad is just a PDF_State wrapped around the Writer monad. Its wPutChar and wPutStr methods automatically keep track of the file position.

Boxed version of the RawPDFWriter monad.

Run function for the PDFWriter monad.

Get the file position.

Add to the file position.

Get the number of allocated objects. Note that objects are allocated as 1, 2, ..., n; this function returns n.

Allocate an unused object identifier.

Add a cross reference to the cross reference table.

Retrieve the cross reference table.

Get the page count.

Return the next page number.

Add a page to the page table.

Retrieve the page table.

Look up the local font identifier for a font.

Retrieve the font table.

Clear the font table.

A version of with_filter tailored to the PDFWriter monad.

This allows certain global state updates within the local block. Specifically, updates to everything except the file position are propagated from the inner to the outer block. The outer block's file position is updated to reflect the encoded content's length. From the inner block's point of view, the file position starts from 0.

Define an indirect PDF object with the given object id, which must have previously been uniquely obtained with pdf_next_object.

This can be used to define objects with forward references: first obtain an object id, then create references to the object, and finally define the object.

It should be used like this:

obj <- pdf_next_object
...
pdf_deferred_object obj $ do
  <<object definition>>

Define an indirect PDF object with a newly generated object id. Return the object id. This essentially combines pdf_next_object and pdf_deferred_object into a single function, and should be used like this:

obj <- pdf_define_object $ do
  <<object definition>>

Define a PDF stream object with the given object id, which must have previously been uniquely obtained with pdf_next_object. It should be used like this:

obj <- pdf_next_object
...
pdf_deferred_stream obj $ do
  <<stream contents>>

Define a PDF stream object with a newly generated object id. Return the object id. This should be used like this:

obj <- pdf_define_stream $ do
  <<stream contents>>

Define a compressed PDF stream object with the given object id, which must have previously been uniquely obtained with pdf_next_object. It should be used like this:

obj <- pdf_next_object
...
pdf_deferred_flate_stream obj $ do
  <<stream contents>>

Create a direct object from a reference to an indirect object.

Write one line in the cross reference table. This must be exactly 20 characters long, including the terminating newline.

Format the cross reference table. Return the file position of the cross reference table.

Set the fill color.

Set the stroke color.

Set the font.

Render a drawing command to PDF.

Render a draw action to PDF.

Render pages as PDF. The first argument is a reference to the document's page tree node.

Note: Acrobat reader cannot handle pages whose bounding box width or height exceed 200 inches (14400 points). Therefore, we automatically scale pages to be no greater than 199 inches.

Render a document as PDF.

Render document as PDF. The first argument is a customization data structure.

Available graphics formats for rendering.

Does the format require raw binary output?

Render a document to the Writer monad, using the given output format and customization data structure.

Render a document to a file, using the given output format and customization data structure.

Render a document to standard output, using the given output format and customization data structure.

Render a document to a string, using the given output format and customization data structure.

Render a document to the Writer monad, using the given output format.

Render a document to a file, using the given output format.

Render a document to standard output, using the given output format.

Render a document to a string, using the given output format.