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

diff --git a/src/output/cairo.c b/src/output/cairo.c
index 6eb39b27..68c3eb81 100644
--- a/src/output/cairo.c
+++ b/src/output/cairo.c
@@ -16,31 +16,31 @@
 
 #include <config.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 "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>
@@ -52,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)
@@ -101,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
   {
@@ -124,8 +136,6 @@ 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;
@@ -134,12 +144,14 @@ struct xr_driver
     cairo_t *cairo;
     int page_number;		/* Current page number. */
     int y;
+    struct xr_render_fsm *fsm;
   };
 
 static const struct output_driver_class cairo_driver_class;
 
-static void xr_show_page (struct xr_driver *);
 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 *);
@@ -153,8 +165,11 @@ 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)
@@ -173,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_driver_class, name, device_type);
-  xr->headers = true;
   xr->font_height = XR_POINT * 10;
   xr->fonts[XR_FONT_FIXED].string
     = parse_string (opt (d, o, "fixed-font", "monospace"));
@@ -190,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;
 }
@@ -246,33 +274,17 @@ xr_create (const char *file_name, enum settings_output_devices device_type,
   cairo_surface_t *surface;
   cairo_status_t status;
   double width_pt, length_pt;
-  int paper_width, paper_length;
 
   xr = xr_allocate (file_name, device_type, o);
   d = &xr->driver;
 
-  xr->headers = parse_boolean (opt (d, o, "headers", "true"));
-
-  xr->file_type = file_type;
-
-  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 ();
@@ -289,13 +301,12 @@ xr_create (const char *file_name, enum settings_output_devices 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 "
@@ -317,6 +328,8 @@ xr_create (const char *file_name, enum settings_output_devices device_type,
       goto error;
     }
 
+  draw_headers (xr);
+
   return &xr->driver;
 
  error:
@@ -351,13 +364,12 @@ 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)
@@ -410,147 +422,90 @@ xr_render_table_item (struct xr_driver *xr, const struct table_item *item,
 }
 
 static void
-xr_output_table_item (struct xr_driver *xr,
-                      const struct table_item *table_item)
+xr_submit (struct output_driver *driver, const struct output_item *output_item)
 {
-  struct render_break x_break;
-  struct render_page *page;
-  int caption_height;
-
-  if (xr->y > 0)
-    xr->y += xr->font_height;
+  struct xr_driver *xr = xr_driver_cast (driver);
 
-  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); )
+  xr_driver_output_item (xr, output_item);
+  while (xr_driver_need_new_page (xr))
     {
-      struct render_page *x_slice;
-      struct render_break y_break;
+      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.
 
-      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;
+   Used by PSPPIRE for printing, and by the basic Cairo output driver above as
+   its underlying implementation.
 
-          /* 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;
-            }
+   See the big comment in cairo.h for intended usage. */
 
-          y_slice = render_break_next (&y_break, space);
-          if (caption_height)
-            {
-              struct table_cell cell;
-              int bb[TABLE_N_AXES][2];
+/* 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));
 
-              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;
-            }
+  xr->page_number++;
+  xr->cairo = cairo;
+  xr->y = 0;
+  draw_headers (xr);
+  xr_driver_run_fsm (xr);
+}
 
-          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);
+/* 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);
 }
 
-static void
-xr_output_text (struct xr_driver *xr, const char *text)
+/* 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)
 {
-  struct table_item *table_item;
+  return xr->fsm != NULL;
+}
 
-  table_item = table_item_create (table_from_string (TAB_LEFT, text), NULL);
-  xr_output_table_item (xr, table_item);
-  table_item_unref (table_item);
+/* 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_submit (struct output_driver *driver, const struct output_item *output_item)
+xr_driver_destroy_fsm (struct xr_driver *xr)
 {
-  struct xr_driver *xr = xr_driver_cast (driver);
-  if (is_table_item (output_item))
-    xr_output_table_item (xr, to_table_item (output_item));
-  else if (is_chart_item (output_item))
+  if (xr->fsm != NULL)
     {
-      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);
-
-      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:
-          xr_output_text (xr, text);
-          break;
-        }
-    }
-  else if (is_message_item (output_item))
-    {
-      const struct message_item *message_item = to_message_item (output_item);
-      const struct msg *msg = message_item_get_msg (message_item);
-      char *s = msg_to_string (msg, xr->command_name);
-      xr_output_text (xr, s);
-      free (s);
+      xr->fsm->destroy (xr->fsm);
+      xr->fsm = NULL;
     }
 }
 
 static void
-xr_show_page (struct xr_driver *xr)
+xr_driver_run_fsm (struct xr_driver *xr)
 {
-  if (xr->headers)
-    {
-      xr->y = 0;
-      draw_headers (xr);
-    }
-  cairo_show_page (xr->cairo);
-
-  xr->page_number++;
-  xr->y = 0;
+  if (xr->fsm != NULL && !xr->fsm->render (xr->fsm, xr))
+    xr_driver_destroy_fsm (xr);
 }
 
 static void
@@ -778,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;
 }
@@ -807,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;
@@ -959,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);
@@ -978,6 +928,18 @@ 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)
 {
@@ -1127,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;
+}