X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Foutput%2Fcairo.c;h=68c3eb81a0f96e54b9ef89da8dd86b5c41a3c290;hb=a456c361c0d324475da63d8420a2f0b108b61243;hp=94dafd886b7914356b856701c09e6564269426b1;hpb=e23e9a06426e80e98fe2021a9a3326f9eea31d15;p=pspp-builds.git

diff --git a/src/output/cairo.c b/src/output/cairo.c
index 94dafd88..68c3eb81 100644
--- a/src/output/cairo.c
+++ b/src/output/cairo.c
@@ -16,29 +16,31 @@
 
 #include <config.h>
 
-#include <output/cairo.h>
-
-#include <libpspp/assertion.h>
-#include <libpspp/cast.h>
-#include <libpspp/start-date.h>
-#include <libpspp/str.h>
-#include <libpspp/string-map.h>
-#include <libpspp/version.h>
-#include <output/cairo-chart.h>
-#include <output/chart-item-provider.h>
-#include <output/charts/boxplot.h>
-#include <output/charts/np-plot.h>
-#include <output/charts/piechart.h>
-#include <output/charts/plot-hist.h>
-#include <output/charts/roc-chart.h>
-#include <output/charts/scree.h>
-#include <output/driver-provider.h>
-#include <output/options.h>
-#include <output/render.h>
-#include <output/tab.h>
-#include <output/table-item.h>
-#include <output/table.h>
-#include <output/text-item.h>
+#include "output/cairo.h"
+
+#include "libpspp/assertion.h"
+#include "libpspp/cast.h"
+#include "libpspp/message.h"
+#include "libpspp/start-date.h"
+#include "libpspp/str.h"
+#include "libpspp/string-map.h"
+#include "libpspp/version.h"
+#include "output/cairo-chart.h"
+#include "output/chart-item-provider.h"
+#include "output/charts/boxplot.h"
+#include "output/charts/np-plot.h"
+#include "output/charts/piechart.h"
+#include "output/charts/plot-hist.h"
+#include "output/charts/roc-chart.h"
+#include "output/charts/scree.h"
+#include "output/driver-provider.h"
+#include "output/message-item.h"
+#include "output/options.h"
+#include "output/render.h"
+#include "output/tab.h"
+#include "output/table-item.h"
+#include "output/table.h"
+#include "output/text-item.h"
 
 #include <cairo/cairo-pdf.h>
 #include <cairo/cairo-ps.h>
@@ -50,10 +52,10 @@
 #include <pango/pangocairo.h>
 #include <stdlib.h>
 
-#include "error.h"
-#include "intprops.h"
-#include "minmax.h"
-#include "xalloc.h"
+#include "gl/error.h"
+#include "gl/intprops.h"
+#include "gl/minmax.h"
+#include "gl/xalloc.h"
 
 #include "gettext.h"
 #define _(msgid) gettext (msgid)
@@ -99,6 +101,18 @@ struct xr_font
     PangoFontMetrics *metrics;
   };
 
+/* An output item whose rendering is in progress. */
+struct xr_render_fsm
+  {
+    /* Renders as much of itself as it can on the current page.  Returns true
+       if rendering is complete, false if the output item needs another
+       page. */
+    bool (*render) (struct xr_render_fsm *, struct xr_driver *);
+
+    /* Destroys the output item. */
+    void (*destroy) (struct xr_render_fsm *);
+  };
+
 /* Cairo output driver. */
 struct xr_driver
   {
@@ -122,19 +136,22 @@ struct xr_driver
     int line_space;		/* Space between lines. */
     int line_width;		/* Width of lines. */
 
-    enum xr_output_type file_type; /* Type of output file. */
-
     /* Internal state. */
     struct render_params *params;
+    char *command_name;
     char *title;
     char *subtitle;
     cairo_t *cairo;
     int page_number;		/* Current page number. */
     int y;
+    struct xr_render_fsm *fsm;
   };
 
-static void xr_show_page (struct xr_driver *);
+static const struct output_driver_class cairo_driver_class;
+
 static void draw_headers (struct xr_driver *);
+static void xr_driver_destroy_fsm (struct xr_driver *);
+static void xr_driver_run_fsm (struct xr_driver *);
 
 static bool load_font (struct xr_driver *, struct xr_font *);
 static void free_font (struct xr_font *);
@@ -148,13 +165,16 @@ static int xr_measure_cell_height (void *, const struct table_cell *,
 static void xr_draw_cell (void *, const struct table_cell *,
                           int bb[TABLE_N_AXES][2],
                           int clip[TABLE_N_AXES][2]);
+
+static struct xr_render_fsm *xr_render_output_item (
+  struct xr_driver *, const struct output_item *);
 
-/* Driver initialization. */
+/* Output driver basics. */
 
 static struct xr_driver *
 xr_driver_cast (struct output_driver *driver)
 {
-  assert (driver->class == &cairo_class);
+  assert (driver->class == &cairo_driver_class);
   return UP_CAST (driver, struct xr_driver, driver);
 }
 
@@ -168,13 +188,13 @@ opt (struct output_driver *d, struct string_map *options, const char *key,
 static struct xr_driver *
 xr_allocate (const char *name, int device_type, struct string_map *o)
 {
+  int paper_width, paper_length;
   struct output_driver *d;
   struct xr_driver *xr;
 
   xr = xzalloc (sizeof *xr);
   d = &xr->driver;
-  output_driver_init (d, &cairo_class, name, device_type);
-  xr->headers = true;
+  output_driver_init (d, &cairo_driver_class, name, device_type);
   xr->font_height = XR_POINT * 10;
   xr->fonts[XR_FONT_FIXED].string
     = parse_string (opt (d, o, "fixed-font", "monospace"));
@@ -185,7 +205,20 @@ xr_allocate (const char *name, int device_type, struct string_map *o)
   xr->line_gutter = XR_POINT;
   xr->line_space = XR_POINT;
   xr->line_width = XR_POINT / 2;
-  xr->page_number = 1;
+  xr->page_number = 0;
+
+  xr->headers = parse_boolean (opt (d, o, "headers", "true"));
+
+  parse_paper_size (opt (d, o, "paper-size", ""), &paper_width, &paper_length);
+  xr->left_margin = parse_dimension (opt (d, o, "left-margin", ".5in"));
+  xr->right_margin = parse_dimension (opt (d, o, "right-margin", ".5in"));
+  xr->top_margin = parse_dimension (opt (d, o, "top-margin", ".5in"));
+  xr->bottom_margin = parse_dimension (opt (d, o, "bottom-margin", ".5in"));
+
+  if (xr->headers)
+    xr->top_margin += 3 * xr->font_height;
+  xr->width = paper_width - xr->left_margin - xr->right_margin;
+  xr->length = paper_length - xr->top_margin - xr->bottom_margin;
 
   return xr;
 }
@@ -232,8 +265,8 @@ xr_set_cairo (struct xr_driver *xr, cairo_t *cairo)
 }
 
 static struct output_driver *
-xr_create (const char *name, enum output_device_type device_type,
-           struct string_map *o)
+xr_create (const char *file_name, enum settings_output_devices device_type,
+           struct string_map *o, enum xr_output_type file_type)
 {
   enum { MIN_WIDTH = 3, MIN_LENGTH = 3 };
   struct output_driver *d;
@@ -241,42 +274,17 @@ xr_create (const char *name, enum output_device_type device_type,
   cairo_surface_t *surface;
   cairo_status_t status;
   double width_pt, length_pt;
-  int paper_width, paper_length;
-  char *file_name;
 
-  xr = xr_allocate (name, device_type, o);
+  xr = xr_allocate (file_name, device_type, o);
   d = &xr->driver;
 
-  xr->headers = parse_boolean (opt (d, o, "headers", "true"));
-
-  xr->file_type = parse_enum (opt (d, o, "output-type", "pdf"),
-                              "pdf", XR_PDF,
-                              "ps", XR_PS,
-                              "svg", XR_SVG,
-                              (char *) NULL);
-  file_name = parse_string (opt (d, o, "output-file",
-                                 (xr->file_type == XR_PDF ? "pspp.pdf"
-                                  : xr->file_type == XR_PS ? "pspp.ps"
-                                  : "pspp.svg")));
-
-  parse_paper_size (opt (d, o, "paper-size", ""), &paper_width, &paper_length);
-  xr->left_margin = parse_dimension (opt (d, o, "left-margin", ".5in"));
-  xr->right_margin = parse_dimension (opt (d, o, "right-margin", ".5in"));
-  xr->top_margin = parse_dimension (opt (d, o, "top-margin", ".5in"));
-  xr->bottom_margin = parse_dimension (opt (d, o, "bottom-margin", ".5in"));
-
-  if (xr->headers)
-    xr->top_margin += 3 * xr->font_height;
-  xr->width = paper_width - xr->left_margin - xr->right_margin;
-  xr->length = paper_length - xr->top_margin - xr->bottom_margin;
-
-  width_pt = paper_width / 1000.0;
-  length_pt = paper_length / 1000.0;
-  if (xr->file_type == XR_PDF)
+  width_pt = (xr->width + xr->left_margin + xr->right_margin) / 1000.0;
+  length_pt = (xr->length + xr->top_margin + xr->bottom_margin) / 1000.0;
+  if (file_type == XR_PDF)
     surface = cairo_pdf_surface_create (file_name, width_pt, length_pt);
-  else if (xr->file_type == XR_PS)
+  else if (file_type == XR_PS)
     surface = cairo_ps_surface_create (file_name, width_pt, length_pt);
-  else if (xr->file_type == XR_SVG)
+  else if (file_type == XR_SVG)
     surface = cairo_svg_surface_create (file_name, width_pt, length_pt);
   else
     NOT_REACHED ();
@@ -284,7 +292,7 @@ xr_create (const char *name, enum output_device_type device_type,
   status = cairo_surface_status (surface);
   if (status != CAIRO_STATUS_SUCCESS)
     {
-      error (0, 0, _("opening output file \"%s\": %s"),
+      error (0, 0, _("error opening output file \"%s\": %s"),
              file_name, cairo_status_to_string (status));
       cairo_surface_destroy (surface);
       goto error;
@@ -293,13 +301,12 @@ xr_create (const char *name, enum output_device_type device_type,
   xr->cairo = cairo_create (surface);
   cairo_surface_destroy (surface);
 
-  cairo_translate (xr->cairo,
-                   xr_to_pt (xr->left_margin),
-                   xr_to_pt (xr->top_margin));
-
   if (!xr_set_cairo (xr, xr->cairo))
     goto error;
 
+  cairo_save (xr->cairo);
+  xr_driver_next_page (xr, xr->cairo);
+
   if (xr->width / (xr->font_height / 2) < MIN_WIDTH)
     {
       error (0, 0, _("The defined page is not wide enough to hold at least %d "
@@ -321,7 +328,8 @@ xr_create (const char *name, enum output_device_type device_type,
       goto error;
     }
 
-  free (file_name);
+  draw_headers (xr);
+
   return &xr->driver;
 
  error:
@@ -329,19 +337,39 @@ xr_create (const char *name, enum output_device_type device_type,
   return NULL;
 }
 
+static struct output_driver *
+xr_pdf_create (const char *file_name, enum settings_output_devices device_type,
+               struct string_map *o)
+{
+  return xr_create (file_name, device_type, o, XR_PDF);
+}
+
+static struct output_driver *
+xr_ps_create (const char *file_name, enum settings_output_devices device_type,
+               struct string_map *o)
+{
+  return xr_create (file_name, device_type, o, XR_PS);
+}
+
+static struct output_driver *
+xr_svg_create (const char *file_name, enum settings_output_devices device_type,
+               struct string_map *o)
+{
+  return xr_create (file_name, device_type, o, XR_SVG);
+}
+
 static void
 xr_destroy (struct output_driver *driver)
 {
   struct xr_driver *xr = xr_driver_cast (driver);
   size_t i;
 
+  xr_driver_destroy_fsm (xr);
+
   if (xr->cairo != NULL)
     {
       cairo_status_t status;
 
-      if (xr->y > 0)
-        xr_show_page (xr);
-
       cairo_surface_finish (cairo_get_target (xr->cairo));
       status = cairo_status (xr->cairo);
       if (status != CAIRO_STATUS_SUCCESS)
@@ -351,6 +379,7 @@ xr_destroy (struct output_driver *driver)
       cairo_destroy (xr->cairo);
     }
 
+  free (xr->command_name);
   for (i = 0; i < XR_N_FONTS; i++)
     free_font (&xr->fonts[i]);
   free (xr->params);
@@ -396,130 +425,87 @@ static void
 xr_submit (struct output_driver *driver, const struct output_item *output_item)
 {
   struct xr_driver *xr = xr_driver_cast (driver);
-  if (is_table_item (output_item))
+
+  xr_driver_output_item (xr, output_item);
+  while (xr_driver_need_new_page (xr))
     {
-      struct table_item *table_item = to_table_item (output_item);
-      struct render_break x_break;
-      struct render_page *page;
-      int caption_height;
+      cairo_restore (xr->cairo);
+      cairo_show_page (xr->cairo);
+      cairo_save (xr->cairo);
+      xr_driver_next_page (xr, xr->cairo);
+    }
+}
+
+/* Functions for rendering a series of output items to a series of Cairo
+   contexts, with pagination, possibly including headers.
 
-      if (xr->y > 0)
-        xr->y += xr->font_height;
+   Used by PSPPIRE for printing, and by the basic Cairo output driver above as
+   its underlying implementation.
 
-      page = xr_render_table_item (xr, table_item, &caption_height);
-      xr->params->size[V] = xr->length - caption_height;
-      for (render_break_init (&x_break, page, H);
-           render_break_has_next (&x_break); )
-        {
-          struct render_page *x_slice;
-          struct render_break y_break;
+   See the big comment in cairo.h for intended usage. */
 
-          x_slice = render_break_next (&x_break, xr->width);
-          for (render_break_init (&y_break, x_slice, V);
-               render_break_has_next (&y_break); )
-            {
-              int space = xr->length - xr->y;
-              struct render_page *y_slice;
-
-              /* XXX doesn't allow for caption or space between segments */
-              if (render_break_next_size (&y_break) > space)
-                {
-                  assert (xr->y > 0);
-                  xr_show_page (xr);
-                  continue;
-                }
-
-              y_slice = render_break_next (&y_break, space);
-              if (caption_height)
-                {
-                  struct table_cell cell;
-                  int bb[TABLE_N_AXES][2];
-
-                  xr_init_caption_cell (table_item_get_caption (table_item),
-                                        &cell);
-                  bb[H][0] = 0;
-                  bb[H][1] = xr->width;
-                  bb[V][0] = 0;
-                  bb[V][1] = caption_height;
-                  xr_draw_cell (xr, &cell, bb, bb);
-                  xr->y += caption_height;
-                  caption_height = 0;
-                }
-
-              render_page_draw (y_slice);
-              xr->y += render_page_get_size (y_slice, V);
-              render_page_unref (y_slice);
-            }
-          render_break_destroy (&y_break);
-        }
-      render_break_destroy (&x_break);
-    }
-  else if (is_chart_item (output_item))
-    {
-      if (xr->y > 0)
-        xr_show_page (xr);
-      xr_draw_chart (to_chart_item (output_item), xr->cairo, 0.0, 0.0,
-                     xr_to_pt (xr->width), xr_to_pt (xr->length));
-      xr_show_page (xr);
-    }
-  else if (is_text_item (output_item))
-    {
-      const struct text_item *text_item = to_text_item (output_item);
-      enum text_item_type type = text_item_get_type (text_item);
-      const char *text = text_item_get_text (text_item);
+/* Gives new page CAIRO to XR for output.  CAIRO may be null to skip actually
+   rendering the page (which might be useful to find out how many pages an
+   output document has without actually rendering it). */
+void
+xr_driver_next_page (struct xr_driver *xr, cairo_t *cairo)
+{
+  if (cairo != NULL)
+    cairo_translate (cairo,
+                     xr_to_pt (xr->left_margin),
+                     xr_to_pt (xr->top_margin));
 
-      switch (type)
-        {
-        case TEXT_ITEM_TITLE:
-          free (xr->title);
-          xr->title = xstrdup (text);
-          break;
-
-        case TEXT_ITEM_SUBTITLE:
-          free (xr->subtitle);
-          xr->subtitle = xstrdup (text);
-          break;
-
-        case TEXT_ITEM_COMMAND_CLOSE:
-          break;
-
-        case TEXT_ITEM_BLANK_LINE:
-          if (xr->y > 0)
-            xr->y += xr->font_height;
-          break;
-
-        case TEXT_ITEM_EJECT_PAGE:
-          if (xr->y > 0)
-            xr_show_page (xr);
-          break;
-
-        default:
-          {
-            struct table_item *item;
-
-            item = table_item_create (table_from_string (TAB_LEFT, text),
-                                      NULL);
-            xr_submit (&xr->driver, &item->output_item);
-            table_item_unref (item);
-          }
-          break;
-        }
+  xr->page_number++;
+  xr->cairo = cairo;
+  xr->y = 0;
+  draw_headers (xr);
+  xr_driver_run_fsm (xr);
+}
 
-    }
+/* Start rendering OUTPUT_ITEM to XR.  Only valid if XR is not in the middle of
+   rendering a previous output item, that is, only if xr_driver_need_new_page()
+   returns false. */
+void
+xr_driver_output_item (struct xr_driver *xr,
+                       const struct output_item *output_item)
+{
+  assert (xr->fsm == NULL);
+  xr->fsm = xr_render_output_item (xr, output_item);
+  xr_driver_run_fsm (xr);
+}
+
+/* Returns true if XR is in the middle of rendering an output item and needs a
+   new page to be appended using xr_driver_next_page() to make progress,
+   otherwise false. */
+bool
+xr_driver_need_new_page (const struct xr_driver *xr)
+{
+  return xr->fsm != NULL;
+}
+
+/* Returns true if the current page doesn't have any content yet (besides
+   headers, if enabled). */
+bool
+xr_driver_is_page_blank (const struct xr_driver *xr)
+{
+  return xr->y == 0;
 }
 
 static void
-xr_show_page (struct xr_driver *xr)
+xr_driver_destroy_fsm (struct xr_driver *xr)
 {
-  if (xr->headers)
+  if (xr->fsm != NULL)
     {
-      xr->y = 0;
-      draw_headers (xr);
+      xr->fsm->destroy (xr->fsm);
+      xr->fsm = NULL;
     }
-  cairo_show_page (xr->cairo);
+}
 
-  xr->page_number++;
-  xr->y = 0;
+static void
+xr_driver_run_fsm (struct xr_driver *xr)
+{
+  if (xr->fsm != NULL && !xr->fsm->render (xr->fsm, xr))
+    xr_driver_destroy_fsm (xr);
 }
 
 static void
@@ -747,9 +733,9 @@ draw_text (struct xr_driver *xr, const char *string, int x, int y,
   cell.contents = string;
   cell.options = options;
   bb[H][0] = x;
-  bb[V][0] = y;
+  bb[V][0] = y - xr->y;
   bb[H][1] = x + max_width;
-  bb[V][1] = xr->font_height;
+  bb[V][1] = xr->font_height - xr->y;
   xr_layout_cell (xr, &cell, bb, bb, PANGO_WRAP_WORD_CHAR, &w, &h);
   return w;
 }
@@ -776,6 +762,9 @@ draw_headers (struct xr_driver *xr)
   int x0, x1;
   int y;
 
+  if (!xr->headers || xr->cairo == NULL)
+    return;
+
   y = -3 * xr->font_height;
   x0 = xr->font_height / 2;
   x1 = xr->width - xr->font_height / 2;
@@ -895,14 +884,17 @@ free_font (struct xr_font *font)
   if (font->desc != NULL)
     pango_font_description_free (font->desc);
   pango_font_metrics_unref (font->metrics);
-  g_object_unref (font->layout);
+  if (font->layout != NULL)
+    g_object_unref (font->layout);
 }
 
-/* Cairo driver class. */
-const struct output_driver_class cairo_class =
+struct output_driver_factory pdf_driver_factory = { "pdf", xr_pdf_create };
+struct output_driver_factory ps_driver_factory = { "ps", xr_ps_create };
+struct output_driver_factory svg_driver_factory = { "svg", xr_svg_create };
+
+static const struct output_driver_class cairo_driver_class =
 {
   "cairo",
-  xr_create,
   xr_destroy,
   xr_submit,
   xr_flush,
@@ -925,17 +917,9 @@ struct xr_rendering
 #define CHART_HEIGHT 375
 
 struct xr_driver *
-xr_create_driver (cairo_t *cairo)
+xr_driver_create (cairo_t *cairo, struct string_map *options)
 {
-  struct xr_driver *xr;
-  struct string_map map;
-
-  string_map_init (&map);
-  xr = xr_allocate ("cairo", 0, &map);
-  string_map_destroy (&map);
-
-  xr->width = INT_MAX / 8;
-  xr->length = INT_MAX / 8;
+  struct xr_driver *xr = xr_allocate ("cairo", 0, options);
   if (!xr_set_cairo (xr, cairo))
     {
       output_driver_destroy (&xr->driver);
@@ -944,6 +928,31 @@ xr_create_driver (cairo_t *cairo)
   return xr;
 }
 
+/* Destroy XR, which should have been created with xr_driver_create().  Any
+   cairo_t added to XR is not destroyed, because it is owned by the client. */
+void
+xr_driver_destroy (struct xr_driver *xr)
+{
+  if (xr != NULL)
+    {
+      xr->cairo = NULL;
+      output_driver_destroy (&xr->driver);
+    }
+}
+
+static struct xr_rendering *
+xr_rendering_create_text (struct xr_driver *xr, const char *text, cairo_t *cr)
+{
+  struct table_item *table_item;
+  struct xr_rendering *r;
+
+  table_item = table_item_create (table_from_string (0, text), NULL);
+  r = xr_rendering_create (xr, &table_item->output_item, cr);
+  table_item_unref (table_item);
+
+  return r;
+}
+
 struct xr_rendering *
 xr_rendering_create (struct xr_driver *xr, const struct output_item *item,
                      cairo_t *cr)
@@ -951,15 +960,15 @@ xr_rendering_create (struct xr_driver *xr, const struct output_item *item,
   struct xr_rendering *r = NULL;
 
   if (is_text_item (item))
+    r = xr_rendering_create_text (xr, text_item_get_text (to_text_item (item)),
+                                  cr);
+  else if (is_message_item (item))
     {
-      const struct text_item *text_item = to_text_item (item);
-      const char *text = text_item_get_text (text_item);
-      struct table_item *table_item;
-
-      table_item = table_item_create (table_from_string (TAB_LEFT, text),
-                                      NULL);
-      r = xr_rendering_create (xr, &table_item->output_item, cr);
-      table_item_unref (table_item);
+      const struct message_item *message_item = to_message_item (item);
+      const struct msg *msg = message_item_get_msg (message_item);
+      char *s = msg_to_string (msg, NULL);
+      r = xr_rendering_create_text (xr, s, cr);
+      free (s);
     }
   else if (is_table_item (item))
     {
@@ -1072,7 +1081,7 @@ xr_draw_png_chart (const struct chart_item *item,
 
   status = cairo_surface_write_to_png (surface, file_name);
   if (status != CAIRO_STATUS_SUCCESS)
-    error (0, 0, _("writing output file \"%s\": %s"),
+    error (0, 0, _("error writing output file \"%s\": %s"),
            file_name, cairo_status_to_string (status));
 
   cairo_destroy (cr);
@@ -1080,3 +1089,254 @@ xr_draw_png_chart (const struct chart_item *item,
 
   return file_name;
 }
+
+struct xr_table_state
+  {
+    struct xr_render_fsm fsm;
+    struct table_item *table_item;
+    struct render_break x_break;
+    struct render_break y_break;
+    int caption_height;
+  };
+
+static bool
+xr_table_render (struct xr_render_fsm *fsm, struct xr_driver *xr)
+{
+  struct xr_table_state *ts = UP_CAST (fsm, struct xr_table_state, fsm);
+
+  for (;;)
+    {
+      struct render_page *y_slice;
+      int space;
+
+      while (!render_break_has_next (&ts->y_break))
+        {
+          struct render_page *x_slice;
+
+          render_break_destroy (&ts->y_break);
+          if (!render_break_has_next (&ts->x_break))
+            return false;
+
+          x_slice = render_break_next (&ts->x_break, xr->width);
+          render_break_init (&ts->y_break, x_slice, V);
+        }
+
+      space = xr->length - xr->y;
+      if (render_break_next_size (&ts->y_break) > space)
+        {
+          assert (xr->y > 0);
+          return true;
+        }
+
+      y_slice = render_break_next (&ts->y_break, space);
+      if (ts->caption_height)
+        {
+          if (xr->cairo)
+            {
+              struct table_cell cell;
+              int bb[TABLE_N_AXES][2];
+
+              xr_init_caption_cell (table_item_get_caption (ts->table_item),
+                                    &cell);
+              bb[H][0] = 0;
+              bb[H][1] = xr->width;
+              bb[V][0] = 0;
+              bb[V][1] = ts->caption_height;
+              xr_draw_cell (xr, &cell, bb, bb);
+            }
+          xr->y += ts->caption_height;
+          ts->caption_height = 0;
+        }
+
+      if (xr->cairo)
+        render_page_draw (y_slice);
+      xr->y += render_page_get_size (y_slice, V);
+      render_page_unref (y_slice);
+    }
+}
+
+static void
+xr_table_destroy (struct xr_render_fsm *fsm)
+{
+  struct xr_table_state *ts = UP_CAST (fsm, struct xr_table_state, fsm);
+
+  table_item_unref (ts->table_item);
+  render_break_destroy (&ts->x_break);
+  render_break_destroy (&ts->y_break);
+  free (ts);
+}
+
+static struct xr_render_fsm *
+xr_render_table (struct xr_driver *xr, const struct table_item *table_item)
+{
+  struct xr_table_state *ts;
+  struct render_page *page;
+
+  ts = xmalloc (sizeof *ts);
+  ts->fsm.render = xr_table_render;
+  ts->fsm.destroy = xr_table_destroy;
+  ts->table_item = table_item_ref (table_item);
+
+  if (xr->y > 0)
+    xr->y += xr->font_height;
+
+  page = xr_render_table_item (xr, table_item, &ts->caption_height);
+  xr->params->size[V] = xr->length - ts->caption_height;
+
+  render_break_init (&ts->x_break, page, H);
+  render_break_init_empty (&ts->y_break);
+
+  return &ts->fsm;
+}
+
+struct xr_chart_state
+  {
+    struct xr_render_fsm fsm;
+    struct chart_item *chart_item;
+  };
+
+static bool
+xr_chart_render (struct xr_render_fsm *fsm, struct xr_driver *xr)
+{
+  struct xr_chart_state *cs = UP_CAST (fsm, struct xr_chart_state, fsm);
+
+  if (xr->y > 0)
+    return true;
+
+  if (xr->cairo != NULL)
+    xr_draw_chart (cs->chart_item, xr->cairo, 0.0, 0.0,
+                   xr_to_pt (xr->width), xr_to_pt (xr->length));
+  xr->y = xr->length;
+
+  return false;
+}
+
+static void
+xr_chart_destroy (struct xr_render_fsm *fsm)
+{
+  struct xr_chart_state *cs = UP_CAST (fsm, struct xr_chart_state, fsm);
+
+  chart_item_unref (cs->chart_item);
+  free (cs);
+}
+
+static struct xr_render_fsm *
+xr_render_chart (const struct chart_item *chart_item)
+{
+  struct xr_chart_state *cs;
+
+  cs = xmalloc (sizeof *cs);
+  cs->fsm.render = xr_chart_render;
+  cs->fsm.destroy = xr_chart_destroy;
+  cs->chart_item = chart_item_ref (chart_item);
+
+  return &cs->fsm;
+}
+
+static bool
+xr_eject_render (struct xr_render_fsm *fsm UNUSED, struct xr_driver *xr)
+{
+  return xr->y > 0;
+}
+
+static void
+xr_eject_destroy (struct xr_render_fsm *fsm UNUSED)
+{
+  /* Nothing to do. */
+}
+
+static struct xr_render_fsm *
+xr_render_eject (void)
+{
+  static struct xr_render_fsm eject_renderer =
+    {
+      xr_eject_render,
+      xr_eject_destroy
+    };
+
+  return &eject_renderer;
+}
+
+static struct xr_render_fsm *
+xr_create_text_renderer (struct xr_driver *xr, const char *text)
+{
+  struct table_item *table_item;
+  struct xr_render_fsm *fsm;
+
+  table_item = table_item_create (table_from_string (TAB_LEFT, text), NULL);
+  fsm = xr_render_table (xr, table_item);
+  table_item_unref (table_item);
+
+  return fsm;
+}
+
+static struct xr_render_fsm *
+xr_render_text (struct xr_driver *xr, const struct text_item *text_item)
+{
+  enum text_item_type type = text_item_get_type (text_item);
+  const char *text = text_item_get_text (text_item);
+
+  switch (type)
+    {
+    case TEXT_ITEM_TITLE:
+      free (xr->title);
+      xr->title = xstrdup (text);
+      draw_headers (xr);
+      break;
+
+    case TEXT_ITEM_SUBTITLE:
+      free (xr->subtitle);
+      xr->subtitle = xstrdup (text);
+      draw_headers (xr);
+      break;
+
+    case TEXT_ITEM_COMMAND_CLOSE:
+      break;
+
+    case TEXT_ITEM_BLANK_LINE:
+      if (xr->y > 0)
+        xr->y += xr->font_height;
+      break;
+
+    case TEXT_ITEM_EJECT_PAGE:
+      if (xr->y > 0)
+        return xr_render_eject ();
+      break;
+
+    default:
+      return xr_create_text_renderer (xr, text);
+    }
+
+  return NULL;
+}
+
+static struct xr_render_fsm *
+xr_render_message (struct xr_driver *xr,
+                   const struct message_item *message_item)
+{
+  const struct msg *msg = message_item_get_msg (message_item);
+  struct xr_render_fsm *fsm;
+  char *s;
+
+  s = msg_to_string (msg, xr->command_name);
+  fsm = xr_create_text_renderer (xr, s);
+  free (s);
+
+  return fsm;
+}
+
+static struct xr_render_fsm *
+xr_render_output_item (struct xr_driver *xr,
+                       const struct output_item *output_item)
+{
+  if (is_table_item (output_item))
+    return xr_render_table (xr, to_table_item (output_item));
+  else if (is_chart_item (output_item))
+    return xr_render_chart (to_chart_item (output_item));
+  else if (is_text_item (output_item))
+    return xr_render_text (xr, to_text_item (output_item));
+  else if (is_message_item (output_item))
+    return xr_render_message (xr, to_message_item (output_item));
+  else
+    return NULL;
+}