pintos-os.org Git - pspp/blob - src/output/cairo.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17 #include <config.h>
  18
  19 #include "output/cairo.h"
  20
  21 #include "libpspp/assertion.h"
  22 #include "libpspp/cast.h"
  23 #include "libpspp/hash-functions.h"
  24 #include "libpspp/message.h"
  25 #include "libpspp/pool.h"
  26 #include "libpspp/start-date.h"
  27 #include "libpspp/str.h"
  28 #include "libpspp/string-map.h"
  29 #include "libpspp/version.h"
  30 #include "data/file-handle-def.h"
  31 #include "output/cairo-chart.h"
  32 #include "output/cairo-fsm.h"
  33 #include "output/chart-item-provider.h"
  34 #include "output/driver-provider.h"
  35 #include "output/group-item.h"
  36 #include "output/message-item.h"
  37 #include "output/options.h"
  38 #include "output/page-eject-item.h"
  39 #include "output/page-setup-item.h"
  40 #include "output/render.h"
  41 #include "output/table-item.h"
  42 #include "output/table.h"
  43 #include "output/text-item.h"
  44
  45 #include <cairo/cairo-pdf.h>
  46 #include <cairo/cairo-ps.h>
  47 #include <cairo/cairo-svg.h>
  48
  49 #include <cairo/cairo.h>
  50 #include <inttypes.h>
  51 #include <math.h>
  52 #include <pango/pango-font.h>
  53 #include <pango/pango-layout.h>
  54 #include <pango/pango.h>
  55 #include <pango/pangocairo.h>
  56 #include <stdlib.h>
  57
  58 #include "gl/c-ctype.h"
  59 #include "gl/c-strcase.h"
  60 #include "gl/intprops.h"
  61 #include "gl/minmax.h"
  62 #include "gl/xalloc.h"
  63
  64 #include "gettext.h"
  65 #define _(msgid) gettext (msgid)
  66
  67 /* This file uses TABLE_HORZ and TABLE_VERT enough to warrant abbreviating. */
  68 #define H TABLE_HORZ
  69 #define V TABLE_VERT
  70
  71 /* The unit used for internal measurements is inch/(72 * XR_POINT).
  72    (Thus, XR_POINT units represent one point.) */
  73 #define XR_POINT PANGO_SCALE
  74
  75 /* Conversions to and from points. */
  76 static double
  77 xr_to_pt (int x)
  78 {
  79   return x / (double) XR_POINT;
  80 }
  81
  82 /* Dimensions for drawing lines in tables. */
  83 #define XR_LINE_WIDTH (XR_POINT / 2) /* Width of an ordinary line. */
  84 #define XR_LINE_SPACE XR_POINT       /* Space between double lines. */
  85
  86 /* Output types. */
  87 enum xr_output_type
  88   {
  89     XR_PDF,
  90     XR_PS,
  91     XR_SVG
  92   };
  93
  94 /* Cairo output driver. */
  95 struct xr_driver
  96   {
  97     struct output_driver driver;
  98
  99     /* User parameters. */
 100     PangoFontDescription *fonts[XR_N_FONTS];
 101
 102     /* Measurements all in inch/(72 * XR_POINT). */
 103     int size[TABLE_N_AXES];     /* Page size with margins subtracted. */
 104     int margins[TABLE_N_AXES][2]; /* Margins. */
 105     int min_break[TABLE_N_AXES]; /* Min cell size to break across pages. */
 106     int object_spacing;         /* Space between output objects. */
 107
 108     struct cell_color bg;       /* Background color */
 109     struct cell_color fg;       /* Foreground color */
 110     bool transparent;           /* true -> do not render background */
 111     bool systemcolors;          /* true -> do not change colors     */
 112
 113     int initial_page_number;
 114
 115     struct page_heading headings[2]; /* Top and bottom headings. */
 116     int headings_height[2];
 117
 118     /* Internal state. */
 119     struct xr_fsm_style *style;
 120     double font_scale;
 121     int char_width, char_height;
 122     cairo_t *cairo;
 123     cairo_surface_t *surface;
 124     int page_number;            /* Current page number. */
 125     int y;
 126     struct xr_fsm *fsm;
 127   };
 128
 129 static const struct output_driver_class cairo_driver_class;
 130
 131 static void xr_driver_destroy_fsm (struct xr_driver *);
 132 static void xr_driver_run_fsm (struct xr_driver *);
 133 \f
 134 /* Output driver basics. */
 135
 136 static struct xr_driver *
 137 xr_driver_cast (struct output_driver *driver)
 138 {
 139   assert (driver->class == &cairo_driver_class);
 140   return UP_CAST (driver, struct xr_driver, driver);
 141 }
 142
 143 static struct driver_option *
 144 opt (struct output_driver *d, struct string_map *options, const char *key,
 145      const char *default_value)
 146 {
 147   return driver_option_get (d, options, key, default_value);
 148 }
 149
 150 static PangoFontDescription *
 151 parse_font (const char *font, int default_size, bool bold, bool italic)
 152 {
 153   if (!c_strcasecmp (font, "Monospaced"))
 154     font = "Monospace";
 155
 156   PangoFontDescription *desc = pango_font_description_from_string (font);
 157   if (desc == NULL)
 158     return NULL;
 159
 160   /* If the font description didn't include an explicit font size, then set it
 161      to DEFAULT_SIZE, which is in inch/72000 units. */
 162   if (!(pango_font_description_get_set_fields (desc) & PANGO_FONT_MASK_SIZE))
 163     pango_font_description_set_size (desc,
 164                                      (default_size / 1000.0) * PANGO_SCALE);
 165
 166   pango_font_description_set_weight (desc, (bold
 167                                             ? PANGO_WEIGHT_BOLD
 168                                             : PANGO_WEIGHT_NORMAL));
 169   pango_font_description_set_style (desc, (italic
 170                                            ? PANGO_STYLE_ITALIC
 171                                            : PANGO_STYLE_NORMAL));
 172
 173   return desc;
 174 }
 175
 176 static PangoFontDescription *
 177 parse_font_option (struct output_driver *d, struct string_map *options,
 178                    const char *key, const char *default_value,
 179                    int default_size, bool bold, bool italic)
 180 {
 181   char *string = parse_string (opt (d, options, key, default_value));
 182   PangoFontDescription *desc = parse_font (string, default_size, bold, italic);
 183   if (!desc)
 184     {
 185       msg (MW, _("`%s': bad font specification"), string);
 186
 187       /* Fall back to DEFAULT_VALUE, which had better be a valid font
 188          description. */
 189       desc = parse_font (default_value, default_size, bold, italic);
 190       assert (desc != NULL);
 191     }
 192   free (string);
 193
 194   return desc;
 195 }
 196
 197 static void
 198 apply_options (struct xr_driver *xr, struct string_map *o)
 199 {
 200   struct output_driver *d = &xr->driver;
 201
 202   /* In inch/72000 units used by parse_paper_size() and parse_dimension(). */
 203
 204   /* Scale factor from inch/72000 to inch/(72 * XR_POINT). */
 205   const double scale = XR_POINT / 1000.;
 206
 207   for (int i = 0; i < XR_N_FONTS; i++)
 208     if (xr->fonts[i] != NULL)
 209       pango_font_description_free (xr->fonts[i]);
 210
 211   int font_size = parse_int (opt (d, o, "font-size", "10000"), 1000, 1000000);
 212   xr->fonts[XR_FONT_FIXED] = parse_font_option
 213     (d, o, "fixed-font", "monospace", font_size, false, false);
 214   xr->fonts[XR_FONT_PROPORTIONAL] = parse_font_option (
 215     d, o, "prop-font", "sans serif", font_size, false, false);
 216
 217   xr->fg = parse_color (opt (d, o, "foreground-color", "#000000000000"));
 218   xr->bg = parse_color (opt (d, o, "background-color", "#FFFFFFFFFFFF"));
 219
 220   xr->transparent = parse_boolean (opt (d, o, "transparent", "false"));
 221   xr->systemcolors = parse_boolean (opt (d, o, "systemcolors", "false"));
 222
 223   /* Get dimensions.  */
 224   int paper[TABLE_N_AXES];
 225   parse_paper_size (opt (d, o, "paper-size", ""), &paper[H], &paper[V]);
 226
 227   int margins[TABLE_N_AXES][2];
 228   margins[H][0] = parse_dimension (opt (d, o, "left-margin", ".5in"));
 229   margins[H][1] = parse_dimension (opt (d, o, "right-margin", ".5in"));
 230   margins[V][0] = parse_dimension (opt (d, o, "top-margin", ".5in"));
 231   margins[V][1] = parse_dimension (opt (d, o, "bottom-margin", ".5in"));
 232
 233   int min_break[TABLE_N_AXES];
 234   min_break[H] = parse_dimension (opt (d, o, "min-hbreak", NULL)) * scale;
 235   min_break[V] = parse_dimension (opt (d, o, "min-vbreak", NULL)) * scale;
 236
 237   int object_spacing = (parse_dimension (opt (d, o, "object-spacing", NULL))
 238                         * scale);
 239
 240   /* Convert to inch/(XR_POINT * 72). */
 241   for (int a = 0; a < TABLE_N_AXES; a++)
 242     {
 243       for (int i = 0; i < 2; i++)
 244         xr->margins[a][i] = margins[a][i] * scale;
 245       xr->size[a] = (paper[a] - margins[a][0] - margins[a][1]) * scale;
 246       xr->min_break[a] = min_break[a] >= 0 ? min_break[a] : xr->size[a] / 2;
 247     }
 248   xr->object_spacing = object_spacing >= 0 ? object_spacing : XR_POINT * 12;
 249
 250   /* There are no headings so headings_height can stay 0. */
 251 }
 252
 253 static struct xr_driver *
 254 xr_allocate (const char *name, int device_type, struct string_map *o,
 255              double font_scale)
 256 {
 257   struct xr_driver *xr = xzalloc (sizeof *xr);
 258   struct output_driver *d = &xr->driver;
 259
 260   output_driver_init (d, &cairo_driver_class, name, device_type);
 261
 262   /* This is a nasty kluge for an issue that does not make sense.  On any
 263      surface other than a screen (e.g. for output to PDF or PS or SVG), the
 264      fonts are way too big by default.  A "9-point" font seems to appear about
 265      16 points tall.  We use a scale factor for these surfaces to help, but the
 266      underlying issue is a mystery. */
 267   xr->font_scale = font_scale;
 268
 269   apply_options (xr, o);
 270
 271   return xr;
 272 }
 273
 274 static int
 275 pango_to_xr (int pango)
 276 {
 277   return (XR_POINT != PANGO_SCALE
 278           ? ceil (pango * (1. * XR_POINT / PANGO_SCALE))
 279           : pango);
 280 }
 281
 282 static int
 283 xr_to_pango (int xr)
 284 {
 285   return (XR_POINT != PANGO_SCALE
 286           ? ceil (xr * (1. / XR_POINT * PANGO_SCALE))
 287           : xr);
 288 }
 289
 290 static void
 291 xr_measure_fonts (cairo_t *cairo, PangoFontDescription *fonts[XR_N_FONTS],
 292                   int *char_width, int *char_height)
 293 {
 294   *char_width = 0;
 295   *char_height = 0;
 296   for (int i = 0; i < XR_N_FONTS; i++)
 297     {
 298       PangoLayout *layout = pango_cairo_create_layout (cairo);
 299       pango_layout_set_font_description (layout, fonts[i]);
 300
 301       pango_layout_set_text (layout, "0", 1);
 302
 303       int cw, ch;
 304       pango_layout_get_size (layout, &cw, &ch);
 305       *char_width = MAX (*char_width, pango_to_xr (cw));
 306       *char_height = MAX (*char_height, pango_to_xr (ch));
 307
 308       g_object_unref (G_OBJECT (layout));
 309     }
 310 }
 311
 312 static int
 313 get_layout_height (PangoLayout *layout)
 314 {
 315   int w, h;
 316   pango_layout_get_size (layout, &w, &h);
 317   return h;
 318 }
 319
 320 static int
 321 xr_render_page_heading (cairo_t *cairo, const PangoFontDescription *font,
 322                         const struct page_heading *ph, int page_number,
 323                         int width, bool draw, int base_y)
 324 {
 325   PangoLayout *layout = pango_cairo_create_layout (cairo);
 326   pango_layout_set_font_description (layout, font);
 327
 328   int y = 0;
 329   for (size_t i = 0; i < ph->n; i++)
 330     {
 331       const struct page_paragraph *pp = &ph->paragraphs[i];
 332
 333       char *markup = output_driver_substitute_heading_vars (pp->markup,
 334                                                             page_number);
 335       pango_layout_set_markup (layout, markup, -1);
 336       free (markup);
 337
 338       pango_layout_set_alignment (
 339         layout,
 340         (pp->halign == TABLE_HALIGN_LEFT ? PANGO_ALIGN_LEFT
 341          : pp->halign == TABLE_HALIGN_CENTER ? PANGO_ALIGN_CENTER
 342          : pp->halign == TABLE_HALIGN_MIXED ? PANGO_ALIGN_LEFT
 343          : PANGO_ALIGN_RIGHT));
 344       pango_layout_set_width (layout, xr_to_pango (width));
 345       if (draw)
 346         {
 347           cairo_save (cairo);
 348           cairo_translate (cairo, 0, xr_to_pt (y + base_y));
 349           pango_cairo_show_layout (cairo, layout);
 350           cairo_restore (cairo);
 351         }
 352
 353       y += pango_to_xr (get_layout_height (layout));
 354     }
 355
 356   g_object_unref (G_OBJECT (layout));
 357
 358   return y;
 359 }
 360
 361 static int
 362 xr_measure_headings (cairo_surface_t *surface,
 363                      const PangoFontDescription *font,
 364                      const struct page_heading headings[2],
 365                      int width, int object_spacing, int height[2])
 366 {
 367   cairo_t *cairo = cairo_create (surface);
 368   int total = 0;
 369   for (int i = 0; i < 2; i++)
 370     {
 371       int h = xr_render_page_heading (cairo, font, &headings[i], -1,
 372                                       width, false, 0);
 373
 374       /* If the top heading is nonempty, add some space below it. */
 375       if (h && i == 0)
 376         h += object_spacing;
 377
 378       if (height)
 379         height[i] = h;
 380       total += h;
 381     }
 382   cairo_destroy (cairo);
 383   return total;
 384 }
 385
 386 static bool
 387 xr_check_fonts (cairo_surface_t *surface,
 388                 PangoFontDescription *fonts[XR_N_FONTS],
 389                 int usable_width, int usable_length)
 390 {
 391   cairo_t *cairo = cairo_create (surface);
 392   int char_width, char_height;
 393   xr_measure_fonts (cairo, fonts, &char_width, &char_height);
 394   cairo_destroy (cairo);
 395
 396   bool ok = true;
 397   enum { MIN_WIDTH = 3, MIN_LENGTH = 3 };
 398   if (usable_width / char_width < MIN_WIDTH)
 399     {
 400       msg (ME, _("The defined page is not wide enough to hold at least %d "
 401                  "characters in the default font.  In fact, there's only "
 402                  "room for %d characters."),
 403            MIN_WIDTH, usable_width / char_width);
 404       ok = false;
 405     }
 406   if (usable_length / char_height < MIN_LENGTH)
 407     {
 408       msg (ME, _("The defined page is not long enough to hold at least %d "
 409                  "lines in the default font.  In fact, there's only "
 410                  "room for %d lines."),
 411            MIN_LENGTH, usable_length / char_height);
 412       ok = false;
 413     }
 414   return ok;
 415 }
 416
 417 static void
 418 xr_set_cairo (struct xr_driver *xr, cairo_t *cairo)
 419 {
 420   xr->cairo = cairo;
 421
 422   cairo_set_line_width (xr->cairo, xr_to_pt (XR_LINE_WIDTH));
 423
 424   xr_measure_fonts (xr->cairo, xr->fonts, &xr->char_width, &xr->char_height);
 425
 426   if (xr->style == NULL)
 427     {
 428       xr->style = xmalloc (sizeof *xr->style);
 429       *xr->style = (struct xr_fsm_style) {
 430         .ref_cnt = 1,
 431         .size = { [H] = xr->size[H], [V] = xr->size[V] },
 432         .min_break = { [H] = xr->min_break[H], [V] = xr->min_break[V] },
 433         .use_system_colors = xr->systemcolors,
 434         .transparent = xr->transparent,
 435         .font_scale = xr->font_scale,
 436       };
 437
 438       for (size_t i = 0; i < XR_N_FONTS; i++)
 439         xr->style->fonts[i] = pango_font_description_copy (xr->fonts[i]);
 440     }
 441
 442   if (!xr->systemcolors)
 443     cairo_set_source_rgb (xr->cairo,
 444                           xr->fg.r / 255.0, xr->fg.g / 255.0, xr->fg.b / 255.0);
 445 }
 446
 447 static struct output_driver *
 448 xr_create (struct file_handle *fh, enum settings_output_devices device_type,
 449            struct string_map *o, enum xr_output_type file_type)
 450 {
 451   const char *file_name = fh_get_file_name (fh);
 452   struct xr_driver *xr = xr_allocate (file_name, device_type, o, 72.0 / 128.0);
 453
 454   double paper_pt[TABLE_N_AXES];
 455   for (int a = 0; a < TABLE_N_AXES; a++)
 456     paper_pt[a] = xr_to_pt (xr->size[a]
 457                             + xr->margins[a][0] + xr->margins[a][1]);
 458   if (file_type == XR_PDF)
 459     xr->surface = cairo_pdf_surface_create (file_name,
 460                                             paper_pt[H], paper_pt[V]);
 461   else if (file_type == XR_PS)
 462     xr->surface = cairo_ps_surface_create (file_name, paper_pt[H], paper_pt[V]);
 463   else if (file_type == XR_SVG)
 464     xr->surface = cairo_svg_surface_create (file_name,
 465                                             paper_pt[H], paper_pt[V]);
 466   else
 467     NOT_REACHED ();
 468
 469   cairo_status_t status = cairo_surface_status (xr->surface);
 470   if (status != CAIRO_STATUS_SUCCESS)
 471     {
 472       msg (ME, _("error opening output file `%s': %s"),
 473            file_name, cairo_status_to_string (status));
 474       goto error;
 475     }
 476
 477   if (!xr_check_fonts (xr->surface, xr->fonts, xr->size[H], xr->size[V]))
 478     goto error;
 479
 480   fh_unref (fh);
 481   return &xr->driver;
 482
 483  error:
 484   fh_unref (fh);
 485   output_driver_destroy (&xr->driver);
 486   return NULL;
 487 }
 488
 489 static struct output_driver *
 490 xr_pdf_create (struct  file_handle *fh, enum settings_output_devices device_type,
 491                struct string_map *o)
 492 {
 493   return xr_create (fh, device_type, o, XR_PDF);
 494 }
 495
 496 static struct output_driver *
 497 xr_ps_create (struct  file_handle *fh, enum settings_output_devices device_type,
 498                struct string_map *o)
 499 {
 500   return xr_create (fh, device_type, o, XR_PS);
 501 }
 502
 503 static struct output_driver *
 504 xr_svg_create (struct file_handle *fh, enum settings_output_devices device_type,
 505                struct string_map *o)
 506 {
 507   return xr_create (fh, device_type, o, XR_SVG);
 508 }
 509
 510 static void
 511 xr_destroy (struct output_driver *driver)
 512 {
 513   struct xr_driver *xr = xr_driver_cast (driver);
 514   size_t i;
 515
 516   xr_driver_destroy_fsm (xr);
 517
 518   if (xr->cairo != NULL)
 519     {
 520       cairo_surface_finish (xr->surface);
 521       cairo_status_t status = cairo_status (xr->cairo);
 522       if (status != CAIRO_STATUS_SUCCESS)
 523         fprintf (stderr,  _("error drawing output for %s driver: %s"),
 524                  output_driver_get_name (driver),
 525                  cairo_status_to_string (status));
 526       cairo_surface_destroy (xr->surface);
 527
 528       cairo_destroy (xr->cairo);
 529     }
 530
 531   for (i = 0; i < XR_N_FONTS; i++)
 532     if (xr->fonts[i] != NULL)
 533       pango_font_description_free (xr->fonts[i]);
 534
 535   xr_fsm_style_unref (xr->style);
 536   free (xr);
 537 }
 538
 539 static void
 540 xr_flush (struct output_driver *driver)
 541 {
 542   struct xr_driver *xr = xr_driver_cast (driver);
 543
 544   cairo_surface_flush (cairo_get_target (xr->cairo));
 545 }
 546
 547 static void
 548 xr_update_page_setup (struct output_driver *driver,
 549                       const struct page_setup *ps)
 550 {
 551   struct xr_driver *xr = xr_driver_cast (driver);
 552
 553   xr->initial_page_number = ps->initial_page_number;
 554   xr->object_spacing = ps->object_spacing * 72 * XR_POINT;
 555
 556   if (xr->cairo)
 557     return;
 558
 559   int size[TABLE_N_AXES];
 560   for (int a = 0; a < TABLE_N_AXES; a++)
 561     {
 562       double total_margin = ps->margins[a][0] + ps->margins[a][1];
 563       size[a] = (ps->paper[a] - total_margin) * 72 * XR_POINT;
 564     }
 565
 566   int headings_height[2];
 567   size[V] -= xr_measure_headings (
 568     xr->surface, xr->fonts[XR_FONT_PROPORTIONAL], ps->headings,
 569     size[H], xr->object_spacing, headings_height);
 570
 571   int swap = ps->orientation == PAGE_LANDSCAPE;
 572   enum table_axis h = H ^ swap;
 573   enum table_axis v = V ^ swap;
 574   if (!xr_check_fonts (xr->surface, xr->fonts, size[h], size[v]))
 575     return;
 576
 577   for (int i = 0; i < 2; i++)
 578     {
 579       page_heading_uninit (&xr->headings[i]);
 580       page_heading_copy (&xr->headings[i], &ps->headings[i]);
 581       xr->headings_height[i] = headings_height[i];
 582     }
 583
 584   for (int a = 0; a < TABLE_N_AXES; a++)
 585     {
 586       xr->size[a] = size[a ^ swap];
 587       for (int i = 0; i < 2; i++)
 588         xr->margins[a][i] = ps->margins[a ^ swap][i] * 72 * XR_POINT;
 589     }
 590   cairo_pdf_surface_set_size (xr->surface,
 591                               ps->paper[h] * 72.0, ps->paper[v] * 72.0);
 592 }
 593
 594 static void
 595 xr_submit (struct output_driver *driver, const struct output_item *output_item)
 596 {
 597   struct xr_driver *xr = xr_driver_cast (driver);
 598
 599   if (is_page_setup_item (output_item))
 600     {
 601       xr_update_page_setup (driver,
 602                             to_page_setup_item (output_item)->page_setup);
 603       return;
 604     }
 605
 606   if (!xr->cairo)
 607     {
 608       xr->page_number = xr->initial_page_number - 1;
 609       xr_set_cairo (xr, cairo_create (xr->surface));
 610       cairo_save (xr->cairo);
 611       xr_driver_next_page (xr, xr->cairo);
 612     }
 613
 614   xr_driver_output_item (xr, output_item);
 615   while (xr_driver_need_new_page (xr))
 616     {
 617       cairo_restore (xr->cairo);
 618       cairo_show_page (xr->cairo);
 619       cairo_save (xr->cairo);
 620       xr_driver_next_page (xr, xr->cairo);
 621     }
 622 }
 623 \f
 624 /* Functions for rendering a series of output items to a series of Cairo
 625    contexts, with pagination.
 626
 627    Used by PSPPIRE for printing, and by the basic Cairo output driver above as
 628    its underlying implementation.
 629
 630    See the big comment in cairo.h for intended usage. */
 631
 632 /* Gives new page CAIRO to XR for output. */
 633 void
 634 xr_driver_next_page (struct xr_driver *xr, cairo_t *cairo)
 635 {
 636   if (!xr->transparent)
 637     {
 638       cairo_save (cairo);
 639       cairo_set_source_rgb (cairo,
 640                             xr->bg.r / 255.0, xr->bg.g / 255.0, xr->bg.b / 255.0);
 641       cairo_rectangle (cairo, 0, 0, xr->size[H], xr->size[V]);
 642       cairo_fill (cairo);
 643       cairo_restore (cairo);
 644     }
 645   cairo_translate (cairo,
 646                    xr_to_pt (xr->margins[H][0]),
 647                    xr_to_pt (xr->margins[V][0] + xr->headings_height[0]));
 648
 649   xr->page_number++;
 650   xr->cairo = cairo;
 651   xr->y = 0;
 652
 653   xr_render_page_heading (xr->cairo, xr->fonts[XR_FONT_PROPORTIONAL],
 654                           &xr->headings[0], xr->page_number, xr->size[H], true,
 655                           -xr->headings_height[0]);
 656   xr_render_page_heading (xr->cairo, xr->fonts[XR_FONT_PROPORTIONAL],
 657                           &xr->headings[1], xr->page_number, xr->size[H], true,
 658                           xr->size[V]);
 659
 660   xr_driver_run_fsm (xr);
 661 }
 662
 663 /* Start rendering OUTPUT_ITEM to XR.  Only valid if XR is not in the middle of
 664    rendering a previous output item, that is, only if xr_driver_need_new_page()
 665    returns false. */
 666 void
 667 xr_driver_output_item (struct xr_driver *xr,
 668                        const struct output_item *output_item)
 669 {
 670   assert (xr->fsm == NULL);
 671   xr->fsm = xr_fsm_create (output_item, xr->style, xr->cairo);
 672   xr_driver_run_fsm (xr);
 673 }
 674
 675 /* Returns true if XR is in the middle of rendering an output item and needs a
 676    new page to be appended using xr_driver_next_page() to make progress,
 677    otherwise false. */
 678 bool
 679 xr_driver_need_new_page (const struct xr_driver *xr)
 680 {
 681   return xr->fsm != NULL;
 682 }
 683
 684 /* Returns true if the current page doesn't have any content yet. */
 685 bool
 686 xr_driver_is_page_blank (const struct xr_driver *xr)
 687 {
 688   return xr->y == 0;
 689 }
 690
 691 static void
 692 xr_driver_destroy_fsm (struct xr_driver *xr)
 693 {
 694   xr_fsm_destroy (xr->fsm);
 695   xr->fsm = NULL;
 696 }
 697
 698 static void
 699 xr_driver_run_fsm (struct xr_driver *xr)
 700 {
 701   if (xr->fsm != NULL)
 702     {
 703       cairo_save (xr->cairo);
 704       cairo_translate (xr->cairo, 0, xr_to_pt (xr->y));
 705       int used = xr_fsm_draw_slice (xr->fsm, xr->cairo, xr->size[V] - xr->y);
 706       xr->y += used;
 707       cairo_restore (xr->cairo);
 708
 709       if (xr_fsm_is_empty (xr->fsm))
 710         xr_driver_destroy_fsm (xr);
 711     }
 712 }
 713 \f
 714 struct output_driver_factory pdf_driver_factory =
 715   { "pdf", "pspp.pdf", xr_pdf_create };
 716 struct output_driver_factory ps_driver_factory =
 717   { "ps", "pspp.ps", xr_ps_create };
 718 struct output_driver_factory svg_driver_factory =
 719   { "svg", "pspp.svg", xr_svg_create };
 720
 721 static const struct output_driver_class cairo_driver_class =
 722 {
 723   "cairo",
 724   xr_destroy,
 725   xr_submit,
 726   xr_flush,
 727 };
 728 \f
 729 struct xr_driver *
 730 xr_driver_create (cairo_t *cairo, struct string_map *options)
 731 {
 732   struct xr_driver *xr = xr_allocate ("cairo", 0, options, 1.0);
 733   xr_set_cairo (xr, cairo);
 734   return xr;
 735 }
 736
 737 /* Destroy XR, which should have been created with xr_driver_create().  Any
 738    cairo_t added to XR is not destroyed, because it is owned by the client. */
 739 void
 740 xr_driver_destroy (struct xr_driver *xr)
 741 {
 742   if (xr != NULL)
 743     {
 744       xr->cairo = NULL;
 745       output_driver_destroy (&xr->driver);
 746     }
 747 }