From: Ben Pfaff <blp@cs.stanford.edu>
Date: Sat, 8 May 2010 21:00:57 +0000 (-0700)
Subject: output: Refactor Cairo output driver to make printing via GTK+ practical.
X-Git-Tag: v0.7.5~32
X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?p=pspp-builds.git;a=commitdiff_plain;h=6071f2f1e380283d430a712c259ecd403f0ed410

output: Refactor Cairo output driver to make printing via GTK+ practical.
---

diff --git a/src/output/cairo.c b/src/output/cairo.c
index f049a305..a415e5bd 100644
--- a/src/output/cairo.c
+++ b/src/output/cairo.c
@@ -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
   {
@@ -134,12 +146,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 +167,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)
@@ -317,6 +334,8 @@ xr_create (const char *file_name, enum settings_output_devices device_type,
       goto error;
     }
 
+  draw_headers (xr);
+
   return &xr->driver;
 
  error:
@@ -351,13 +370,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 +428,83 @@ 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;
-
-      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;
+      cairo_show_page (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.
 
-          /* 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;
-            }
+   Used by PSPPIRE for printing, and by the basic Cairo output driver above as
+   its underlying implementation.
 
-          y_slice = render_break_next (&y_break, space);
-          if (caption_height)
-            {
-              struct table_cell cell;
-              int bb[TABLE_N_AXES][2];
+   See the big comment in cairo.h for intended usage. */
 
-              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;
-            }
+/* 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)
+{
+  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->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))
+  if (xr->fsm != NULL)
     {
-      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 +732,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 +761,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,7 +916,7 @@ struct xr_rendering
 #define CHART_HEIGHT 375
 
 struct xr_driver *
-xr_create_driver (cairo_t *cairo, struct string_map *options)
+xr_driver_create (cairo_t *cairo, struct string_map *options)
 {
   struct xr_driver *xr = xr_allocate ("cairo", 0, options);
   xr->width = INT_MAX / 8;
@@ -1121,3 +1078,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;
+}
diff --git a/src/output/cairo.h b/src/output/cairo.h
index 6fe32733..77889d11 100644
--- a/src/output/cairo.h
+++ b/src/output/cairo.h
@@ -17,6 +17,8 @@
 #ifndef OUTPUT_CAIRO_H
 #define OUTPUT_CAIRO_H 1
 
+#include <stdbool.h>
+
 #ifdef HAVE_CAIRO
 
 #include <cairo/cairo.h>
@@ -25,14 +27,57 @@ struct chart_item;
 struct output_item;
 struct string_map;
 
-/* Used by PSPPIRE to render in the GUI. */
-struct xr_driver *xr_create_driver (cairo_t *, struct string_map *options);
+/* Creating and destroying Cairo output drivers. */
+struct xr_driver *xr_driver_create (cairo_t *, struct string_map *options);
+void xr_driver_destroy (struct xr_driver *);
+
+/* Functions for rendering a single output item to a Cairo context.
+   Output items are never broken across multiple pages.
+   Used by PSPPIRE to render in the GUI. */
 struct xr_rendering *xr_rendering_create (struct xr_driver *,
                                           const struct output_item *,
                                           cairo_t *);
 void xr_rendering_measure (struct xr_rendering *, int *w, int *h);
 void xr_rendering_draw (struct xr_rendering *, cairo_t *);
 
+/* Functions for rendering a series of output items to a series of Cairo
+   contexts, with pagination, possibly including headers.
+
+   The intended usage pattern is this:
+
+     * Create an xr_driver with xr_driver_create().  The cairo_t passed in must
+       accurately reflect the properties of the output (e.g. for the purpose of
+       page size and font selection) but need not be used for rendering.
+
+     * Call xr_driver_next_page() to set up the first real output page's
+       cairo_t.  (You can skip this step if the cairo_t passed to
+       xr_driver_create() can be used.)
+
+     * Then, for each output_item:
+
+       - Pass the output item to xr_driver_output_item().  As much output as
+         fits will be rendered on the current page.
+
+       - Then, as long as xr_driver_need_new_page() returns true, obtain a new
+         page for rendering and pass it to xr_driver_next_page().  As much
+         output as fits on the new page will be rendered on it.
+
+     * When you're done, destroy the output driver with xr_driver_destroy().
+
+   These functions may also be used for counting pages without actually
+   rendering output.  Follow the same steps, except pass NULL as the cairo_t to
+   xr_driver_next_page().  (But xr_driver_create() still needs a valid cairo_t
+   for page setup.)
+
+   (If the cairo_t that you pass to xr_driver_create() won't remain valid, be
+   sure to clear it out one way or another before calling xr_driver_destroy(),
+   so that xr_driver_destroy() won't destroy it itself.)
+*/
+void xr_driver_next_page (struct xr_driver *, cairo_t *);
+void xr_driver_output_item (struct xr_driver *, const struct output_item *);
+bool xr_driver_need_new_page (const struct xr_driver *);
+bool xr_driver_is_page_blank (const struct xr_driver *);
+
 /* Render charts with Cairo. */
 void xr_draw_chart (const struct chart_item *, cairo_t *,
                     double x, double y, double width, double height);
diff --git a/src/output/render.c b/src/output/render.c
index 05db149a..1b92b8bb 100644
--- a/src/output/render.c
+++ b/src/output/render.c
@@ -1,5 +1,5 @@
 /* PSPP - a program for statistical analysis.
-   Copyright (C) 2009 Free Software Foundation, Inc.
+   Copyright (C) 2009, 2010 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -955,6 +955,18 @@ render_break_init (struct render_break *b, struct render_page *page,
   b->hw = headers_width (page, axis);
 }
 
+/* Initializes B as a render_break structure for which
+   render_break_has_next() always returns false. */
+void
+render_break_init_empty (struct render_break *b)
+{
+  b->page = NULL;
+  b->axis = TABLE_HORZ;
+  b->cell = 0;
+  b->pixel = 0;
+  b->hw = 0;
+}
+
 /* Frees B and unrefs the render_page that it owns. */
 void
 render_break_destroy (struct render_break *b)
@@ -971,7 +983,7 @@ render_break_has_next (const struct render_break *b)
   const struct render_page *page = b->page;
   enum table_axis axis = b->axis;
 
-  return b->cell < page->n[axis] - page->h[axis][1];
+  return page != NULL && b->cell < page->n[axis] - page->h[axis][1];
 }
 
 /* Returns the minimum SIZE argument that, if passed to render_break_next(),
diff --git a/src/output/render.h b/src/output/render.h
index cfba52e9..af779843 100644
--- a/src/output/render.h
+++ b/src/output/render.h
@@ -1,5 +1,5 @@
 /* PSPP - a program for statistical analysis.
-   Copyright (C) 2009 Free Software Foundation, Inc.
+   Copyright (C) 2009, 2010 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -106,6 +106,7 @@ struct render_break
 
 void render_break_init (struct render_break *, struct render_page *,
                         enum table_axis);
+void render_break_init_empty (struct render_break *);
 void render_break_destroy (struct render_break *);
 
 bool render_break_has_next (const struct render_break *);
diff --git a/src/ui/gui/psppire-output-window.c b/src/ui/gui/psppire-output-window.c
index 3003fba8..440df86a 100644
--- a/src/ui/gui/psppire-output-window.c
+++ b/src/ui/gui/psppire-output-window.c
@@ -235,7 +235,7 @@ psppire_output_submit (struct output_driver *this,
       g_free (font_name);
       pango_font_description_free (font_desc);
 
-      pod->xr = xr_create_driver (cr, &options);
+      pod->xr = xr_driver_create (cr, &options);
 
       string_map_destroy (&options);
     }