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 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/message.h"
  24 #include "libpspp/start-date.h"
  25 #include "libpspp/str.h"
  26 #include "libpspp/string-map.h"
  27 #include "libpspp/version.h"
  28 #include "output/cairo-chart.h"
  29 #include "output/chart-item-provider.h"
  30 #include "output/charts/boxplot.h"
  31 #include "output/charts/np-plot.h"
  32 #include "output/charts/piechart.h"
  33 #include "output/charts/plot-hist.h"
  34 #include "output/charts/roc-chart.h"
  35 #include "output/charts/spreadlevel-plot.h"
  36 #include "output/charts/scree.h"
  37 #include "output/driver-provider.h"
  38 #include "output/message-item.h"
  39 #include "output/options.h"
  40 #include "output/render.h"
  41 #include "output/tab.h"
  42 #include "output/table-item.h"
  43 #include "output/table.h"
  44 #include "output/text-item.h"
  45
  46 #include <cairo/cairo-pdf.h>
  47 #include <cairo/cairo-ps.h>
  48 #include <cairo/cairo-svg.h>
  49 #include <cairo/cairo.h>
  50 #include <pango/pango-font.h>
  51 #include <pango/pango-layout.h>
  52 #include <pango/pango.h>
  53 #include <pango/pangocairo.h>
  54 #include <stdlib.h>
  55
  56 #include "gl/error.h"
  57 #include "gl/intprops.h"
  58 #include "gl/minmax.h"
  59 #include "gl/xalloc.h"
  60
  61 #include "gettext.h"
  62 #define _(msgid) gettext (msgid)
  63
  64 /* This file uses TABLE_HORZ and TABLE_VERT enough to warrant abbreviating. */
  65 #define H TABLE_HORZ
  66 #define V TABLE_VERT
  67
  68 /* Measurements as we present to the rest of PSPP. */
  69 #define XR_POINT 1000
  70
  71 /* Conversions to and from points. */
  72 static double
  73 xr_to_pt (int x)
  74 {
  75   return x / (double) XR_POINT;
  76 }
  77
  78 /* Output types. */
  79 enum xr_output_type
  80   {
  81     XR_PDF,
  82     XR_PS,
  83     XR_SVG
  84   };
  85
  86 /* Cairo fonts. */
  87 enum xr_font_type
  88   {
  89     XR_FONT_PROPORTIONAL,
  90     XR_FONT_EMPHASIS,
  91     XR_FONT_FIXED,
  92     XR_N_FONTS
  93   };
  94
  95 /* A font for use with Cairo. */
  96 struct xr_font
  97   {
  98     PangoFontDescription *desc;
  99     PangoLayout *layout;
 100   };
 101
 102 /* An output item whose rendering is in progress. */
 103 struct xr_render_fsm
 104   {
 105     /* Renders as much of itself as it can on the current page.  Returns true
 106        if rendering is complete, false if the output item needs another
 107        page. */
 108     bool (*render) (struct xr_render_fsm *, struct xr_driver *);
 109
 110     /* Destroys the output item. */
 111     void (*destroy) (struct xr_render_fsm *);
 112   };
 113
 114 /* Cairo output driver. */
 115 struct xr_driver
 116   {
 117     struct output_driver driver;
 118
 119     /* User parameters. */
 120     struct xr_font fonts[XR_N_FONTS];
 121
 122     int width;                  /* Page width minus margins. */
 123     int length;                 /* Page length minus margins and header. */
 124
 125     int left_margin;            /* Left margin in XR units. */
 126     int right_margin;           /* Right margin in XR units. */
 127     int top_margin;             /* Top margin in XR units. */
 128     int bottom_margin;          /* Bottom margin in XR units. */
 129
 130     int line_gutter;            /* Space around lines. */
 131     int line_space;             /* Space between lines. */
 132     int line_width;             /* Width of lines. */
 133
 134     double bg_red, bg_green, bg_blue; /* Background color */
 135     double fg_red, fg_green, fg_blue; /* Foreground color */
 136
 137     /* Internal state. */
 138     struct render_params *params;
 139     int char_width, char_height;
 140     char *command_name;
 141     char *title;
 142     char *subtitle;
 143     cairo_t *cairo;
 144     int page_number;            /* Current page number. */
 145     int y;
 146     struct xr_render_fsm *fsm;
 147   };
 148
 149 static const struct output_driver_class cairo_driver_class;
 150
 151 static void xr_driver_destroy_fsm (struct xr_driver *);
 152 static void xr_driver_run_fsm (struct xr_driver *);
 153
 154 static void xr_draw_line (void *, int bb[TABLE_N_AXES][2],
 155                           enum render_line_style styles[TABLE_N_AXES][2]);
 156 static void xr_measure_cell_width (void *, const struct table_cell *,
 157                                    int *min, int *max);
 158 static int xr_measure_cell_height (void *, const struct table_cell *,
 159                                    int width);
 160 static void xr_draw_cell (void *, const struct table_cell *,
 161                           int bb[TABLE_N_AXES][2],
 162                           int clip[TABLE_N_AXES][2]);
 163
 164 static struct xr_render_fsm *xr_render_output_item (
 165   struct xr_driver *, const struct output_item *);
 166 \f
 167 /* Output driver basics. */
 168
 169 static struct xr_driver *
 170 xr_driver_cast (struct output_driver *driver)
 171 {
 172   assert (driver->class == &cairo_driver_class);
 173   return UP_CAST (driver, struct xr_driver, driver);
 174 }
 175
 176 static struct driver_option *
 177 opt (struct output_driver *d, struct string_map *options, const char *key,
 178      const char *default_value)
 179 {
 180   return driver_option_get (d, options, key, default_value);
 181 }
 182
 183 /* Parse color information specified by KEY into {RED,GREEN,BLUE}.
 184    Currently, the input string must be of the form "#RRRRGGGGBBBB"
 185    Future implementations might allow things like "yellow" and
 186    "sky-blue-ultra-brown"
 187 */
 188 static void
 189 parse_color (struct output_driver *d, struct string_map *options,
 190               const char *key, const char *default_value,
 191               double *dred, double *dgreen, double *dblue)
 192 {
 193   int red, green, blue;
 194   char *string = parse_string (opt (d, options, key, default_value));
 195
 196   if (3 != sscanf (string, "#%04x%04x%04x", &red, &green, &blue))
 197     {
 198       /* If the parsed option string fails, then try the default value */
 199       if ( 3 != sscanf (default_value, "#%04x%04x%04x", &red, &green, &blue))
 200         {
 201           /* ... and if that fails set everything to zero */
 202           red = green = blue = 0;
 203         }
 204     }
 205
 206   free (string);
 207
 208   /* Convert 16 bit ints to float */
 209   *dred = red / (double) 0xFFFF;
 210   *dgreen = green / (double) 0xFFFF;
 211   *dblue = blue / (double) 0xFFFF;
 212 }
 213
 214 static PangoFontDescription *
 215 parse_font (struct output_driver *d, struct string_map *options,
 216             const char *key, const char *default_value,
 217             int default_points)
 218 {
 219   PangoFontDescription *desc;
 220   char *string;
 221
 222   /* Parse KEY as a font description. */
 223   string = parse_string (opt (d, options, key, default_value));
 224   desc = pango_font_description_from_string (string);
 225   if (desc == NULL)
 226     {
 227       error (0, 0, _("`%s': bad font specification"), string);
 228
 229       /* Fall back to DEFAULT_VALUE, which had better be a valid font
 230          description. */
 231       desc = pango_font_description_from_string (default_value);
 232       assert (desc != NULL);
 233     }
 234   free (string);
 235
 236   /* If the font description didn't include an explicit font size, then set it
 237      to DEFAULT_POINTS. */
 238   if (!(pango_font_description_get_set_fields (desc) & PANGO_FONT_MASK_SIZE))
 239     pango_font_description_set_size (desc,
 240                                      default_points / 1000.0 * PANGO_SCALE);
 241
 242   return desc;
 243 }
 244
 245
 246 static void
 247 apply_options (struct xr_driver *xr, struct string_map *o)
 248 {
 249   struct output_driver *d = &xr->driver;
 250
 251   int paper_width, paper_length, i;
 252
 253   int font_points = parse_int (opt (d, o, "font-size", "10000"), 1000, 1000000);
 254
 255   for (i = 0; i < XR_N_FONTS; i++)
 256     {
 257       struct xr_font *font = &xr->fonts[i];
 258
 259       if (font->desc != NULL)
 260         pango_font_description_free (font->desc);
 261     }
 262
 263   xr->fonts[XR_FONT_FIXED].desc = parse_font (d, o, "fixed-font", "monospace",
 264                                               font_points);
 265   xr->fonts[XR_FONT_PROPORTIONAL].desc = parse_font (d, o, "prop-font",
 266                                                      "serif", font_points);
 267   xr->fonts[XR_FONT_EMPHASIS].desc = parse_font (d, o, "emph-font",
 268                                                  "serif italic", font_points);
 269
 270   xr->line_gutter = parse_dimension (opt (d, o, "gutter", "3pt"));
 271   xr->line_space = XR_POINT;
 272   xr->line_width = XR_POINT / 2;
 273   xr->page_number = 0;
 274
 275   parse_color (d, o, "background-color", "#FFFFFFFFFFFF", &xr->bg_red, &xr->bg_green, &xr->bg_blue);
 276   parse_color (d, o, "foreground-color", "#000000000000", &xr->fg_red, &xr->fg_green, &xr->fg_blue);
 277
 278   parse_paper_size (opt (d, o, "paper-size", ""), &paper_width, &paper_length);
 279   xr->left_margin = parse_dimension (opt (d, o, "left-margin", ".5in"));
 280   xr->right_margin = parse_dimension (opt (d, o, "right-margin", ".5in"));
 281   xr->top_margin = parse_dimension (opt (d, o, "top-margin", ".5in"));
 282   xr->bottom_margin = parse_dimension (opt (d, o, "bottom-margin", ".5in"));
 283
 284   xr->width = paper_width - xr->left_margin - xr->right_margin;
 285   xr->length = paper_length - xr->top_margin - xr->bottom_margin;
 286 }
 287
 288 static struct xr_driver *
 289 xr_allocate (const char *name, int device_type, struct string_map *o)
 290 {
 291   struct xr_driver *xr = xzalloc (sizeof *xr);
 292   struct output_driver *d = &xr->driver;
 293
 294   output_driver_init (d, &cairo_driver_class, name, device_type);
 295
 296   apply_options (xr, o);
 297
 298   return xr;
 299 }
 300
 301 static bool
 302 xr_set_cairo (struct xr_driver *xr, cairo_t *cairo)
 303 {
 304   int i;
 305
 306   xr->cairo = cairo;
 307
 308   cairo_set_line_width (xr->cairo, xr_to_pt (xr->line_width));
 309
 310   xr->char_width = 0;
 311   xr->char_height = 0;
 312   for (i = 0; i < XR_N_FONTS; i++)
 313     {
 314       struct xr_font *font = &xr->fonts[i];
 315       int char_width, char_height;
 316
 317       font->layout = pango_cairo_create_layout (cairo);
 318       pango_layout_set_font_description (font->layout, font->desc);
 319
 320       pango_layout_set_text (font->layout, "0", 1);
 321       pango_layout_get_size (font->layout, &char_width, &char_height);
 322       xr->char_width = MAX (xr->char_width, char_width);
 323       xr->char_height = MAX (xr->char_height, char_height);
 324     }
 325
 326   if (xr->params == NULL)
 327     {
 328       int single_width, double_width;
 329
 330       xr->params = xmalloc (sizeof *xr->params);
 331       xr->params->draw_line = xr_draw_line;
 332       xr->params->measure_cell_width = xr_measure_cell_width;
 333       xr->params->measure_cell_height = xr_measure_cell_height;
 334       xr->params->draw_cell = xr_draw_cell;
 335       xr->params->aux = xr;
 336       xr->params->size[H] = xr->width;
 337       xr->params->size[V] = xr->length;
 338       xr->params->font_size[H] = xr->char_width;
 339       xr->params->font_size[V] = xr->char_height;
 340
 341       single_width = 2 * xr->line_gutter + xr->line_width;
 342       double_width = 2 * xr->line_gutter + xr->line_space + 2 * xr->line_width;
 343       for (i = 0; i < TABLE_N_AXES; i++)
 344         {
 345           xr->params->line_widths[i][RENDER_LINE_NONE] = 0;
 346           xr->params->line_widths[i][RENDER_LINE_SINGLE] = single_width;
 347           xr->params->line_widths[i][RENDER_LINE_DOUBLE] = double_width;
 348         }
 349     }
 350
 351   cairo_set_source_rgb (xr->cairo, xr->fg_red, xr->fg_green, xr->fg_blue);
 352
 353   return true;
 354 }
 355
 356 static struct output_driver *
 357 xr_create (const char *file_name, enum settings_output_devices device_type,
 358            struct string_map *o, enum xr_output_type file_type)
 359 {
 360   enum { MIN_WIDTH = 3, MIN_LENGTH = 3 };
 361   struct xr_driver *xr;
 362   cairo_surface_t *surface;
 363   cairo_status_t status;
 364   double width_pt, length_pt;
 365
 366   xr = xr_allocate (file_name, device_type, o);
 367
 368   width_pt = (xr->width + xr->left_margin + xr->right_margin) / 1000.0;
 369   length_pt = (xr->length + xr->top_margin + xr->bottom_margin) / 1000.0;
 370   if (file_type == XR_PDF)
 371     surface = cairo_pdf_surface_create (file_name, width_pt, length_pt);
 372   else if (file_type == XR_PS)
 373     surface = cairo_ps_surface_create (file_name, width_pt, length_pt);
 374   else if (file_type == XR_SVG)
 375     surface = cairo_svg_surface_create (file_name, width_pt, length_pt);
 376   else
 377     NOT_REACHED ();
 378
 379   status = cairo_surface_status (surface);
 380   if (status != CAIRO_STATUS_SUCCESS)
 381     {
 382       error (0, 0, _("error opening output file `%s': %s"),
 383              file_name, cairo_status_to_string (status));
 384       cairo_surface_destroy (surface);
 385       goto error;
 386     }
 387
 388   xr->cairo = cairo_create (surface);
 389   cairo_surface_destroy (surface);
 390
 391   if (!xr_set_cairo (xr, xr->cairo))
 392     goto error;
 393
 394   cairo_save (xr->cairo);
 395   xr_driver_next_page (xr, xr->cairo);
 396
 397   if (xr->width / xr->char_width < MIN_WIDTH)
 398     {
 399       error (0, 0, _("The defined page is not wide enough to hold at least %d "
 400                      "characters in the default font.  In fact, there's only "
 401                      "room for %d characters."),
 402              MIN_WIDTH,
 403              xr->width / xr->char_width);
 404       goto error;
 405     }
 406
 407   if (xr->length / xr->char_height < MIN_LENGTH)
 408     {
 409       error (0, 0, _("The defined page is not long enough to hold at least %d "
 410                      "lines in the default font.  In fact, there's only "
 411                      "room for %d lines."),
 412              MIN_LENGTH,
 413              xr->length / xr->char_height);
 414       goto error;
 415     }
 416
 417   return &xr->driver;
 418
 419  error:
 420   output_driver_destroy (&xr->driver);
 421   return NULL;
 422 }
 423
 424 static struct output_driver *
 425 xr_pdf_create (const char *file_name, enum settings_output_devices device_type,
 426                struct string_map *o)
 427 {
 428   return xr_create (file_name, device_type, o, XR_PDF);
 429 }
 430
 431 static struct output_driver *
 432 xr_ps_create (const char *file_name, enum settings_output_devices device_type,
 433                struct string_map *o)
 434 {
 435   return xr_create (file_name, device_type, o, XR_PS);
 436 }
 437
 438 static struct output_driver *
 439 xr_svg_create (const char *file_name, enum settings_output_devices device_type,
 440                struct string_map *o)
 441 {
 442   return xr_create (file_name, device_type, o, XR_SVG);
 443 }
 444
 445 static void
 446 xr_destroy (struct output_driver *driver)
 447 {
 448   struct xr_driver *xr = xr_driver_cast (driver);
 449   size_t i;
 450
 451   xr_driver_destroy_fsm (xr);
 452
 453   if (xr->cairo != NULL)
 454     {
 455       cairo_status_t status;
 456
 457       cairo_surface_finish (cairo_get_target (xr->cairo));
 458       status = cairo_status (xr->cairo);
 459       if (status != CAIRO_STATUS_SUCCESS)
 460         error (0, 0, _("error drawing output for %s driver: %s"),
 461                output_driver_get_name (driver),
 462                cairo_status_to_string (status));
 463       cairo_destroy (xr->cairo);
 464     }
 465
 466   free (xr->command_name);
 467   for (i = 0; i < XR_N_FONTS; i++)
 468     {
 469       struct xr_font *font = &xr->fonts[i];
 470
 471       if (font->desc != NULL)
 472         pango_font_description_free (font->desc);
 473       if (font->layout != NULL)
 474         g_object_unref (font->layout);
 475     }
 476
 477   free (xr->params);
 478   free (xr);
 479 }
 480
 481 static void
 482 xr_flush (struct output_driver *driver)
 483 {
 484   struct xr_driver *xr = xr_driver_cast (driver);
 485
 486   cairo_surface_flush (cairo_get_target (xr->cairo));
 487 }
 488
 489 static void
 490 xr_init_caption_cell (const char *caption, struct table_cell *cell)
 491 {
 492   cell->contents = caption;
 493   cell->options = TAB_LEFT;
 494   cell->destructor = NULL;
 495 }
 496
 497 static struct render_page *
 498 xr_render_table_item (struct xr_driver *xr, const struct table_item *item,
 499                       int *caption_widthp, int *caption_heightp)
 500 {
 501   const char *caption = table_item_get_caption (item);
 502
 503   if (caption != NULL)
 504     {
 505       /* XXX doesn't do well with very large captions */
 506       int min_width, max_width;
 507       struct table_cell cell;
 508
 509       xr_init_caption_cell (caption, &cell);
 510
 511       xr_measure_cell_width (xr, &cell, &min_width, &max_width);
 512       *caption_widthp = MIN (max_width, xr->width);
 513       *caption_heightp = xr_measure_cell_height (xr, &cell, *caption_widthp);
 514     }
 515   else
 516     *caption_heightp = 0;
 517
 518   return render_page_create (xr->params, table_item_get_table (item));
 519 }
 520
 521 static void
 522 xr_submit (struct output_driver *driver, const struct output_item *output_item)
 523 {
 524   struct xr_driver *xr = xr_driver_cast (driver);
 525
 526   output_driver_track_current_command (output_item, &xr->command_name);
 527
 528   xr_driver_output_item (xr, output_item);
 529   while (xr_driver_need_new_page (xr))
 530     {
 531       cairo_restore (xr->cairo);
 532       cairo_show_page (xr->cairo);
 533       cairo_save (xr->cairo);
 534       xr_driver_next_page (xr, xr->cairo);
 535     }
 536 }
 537 \f
 538 /* Functions for rendering a series of output items to a series of Cairo
 539    contexts, with pagination.
 540
 541    Used by PSPPIRE for printing, and by the basic Cairo output driver above as
 542    its underlying implementation.
 543
 544    See the big comment in cairo.h for intended usage. */
 545
 546 /* Gives new page CAIRO to XR for output.  CAIRO may be null to skip actually
 547    rendering the page (which might be useful to find out how many pages an
 548    output document has without actually rendering it). */
 549 void
 550 xr_driver_next_page (struct xr_driver *xr, cairo_t *cairo)
 551 {
 552   if (cairo != NULL)
 553     {
 554       cairo_save (cairo);
 555       cairo_set_source_rgb (cairo, xr->bg_red, xr->bg_green, xr->bg_blue);
 556       cairo_rectangle (cairo, 0, 0, xr->width, xr->length);
 557       cairo_fill (cairo);
 558       cairo_restore (cairo);
 559
 560       cairo_translate (cairo,
 561                        xr_to_pt (xr->left_margin),
 562                        xr_to_pt (xr->top_margin));
 563     }
 564
 565   xr->page_number++;
 566   xr->cairo = cairo;
 567   xr->y = 0;
 568   xr_driver_run_fsm (xr);
 569 }
 570
 571 /* Start rendering OUTPUT_ITEM to XR.  Only valid if XR is not in the middle of
 572    rendering a previous output item, that is, only if xr_driver_need_new_page()
 573    returns false. */
 574 void
 575 xr_driver_output_item (struct xr_driver *xr,
 576                        const struct output_item *output_item)
 577 {
 578   assert (xr->fsm == NULL);
 579   xr->fsm = xr_render_output_item (xr, output_item);
 580   xr_driver_run_fsm (xr);
 581 }
 582
 583 /* Returns true if XR is in the middle of rendering an output item and needs a
 584    new page to be appended using xr_driver_next_page() to make progress,
 585    otherwise false. */
 586 bool
 587 xr_driver_need_new_page (const struct xr_driver *xr)
 588 {
 589   return xr->fsm != NULL;
 590 }
 591
 592 /* Returns true if the current page doesn't have any content yet. */
 593 bool
 594 xr_driver_is_page_blank (const struct xr_driver *xr)
 595 {
 596   return xr->y == 0;
 597 }
 598
 599 static void
 600 xr_driver_destroy_fsm (struct xr_driver *xr)
 601 {
 602   if (xr->fsm != NULL)
 603     {
 604       xr->fsm->destroy (xr->fsm);
 605       xr->fsm = NULL;
 606     }
 607 }
 608
 609 static void
 610 xr_driver_run_fsm (struct xr_driver *xr)
 611 {
 612   if (xr->fsm != NULL && !xr->fsm->render (xr->fsm, xr))
 613     xr_driver_destroy_fsm (xr);
 614 }
 615 \f
 616 static void
 617 xr_layout_cell (struct xr_driver *, const struct table_cell *,
 618                 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
 619                 PangoWrapMode, int *width, int *height);
 620
 621 static void
 622 dump_line (struct xr_driver *xr, int x0, int y0, int x1, int y1)
 623 {
 624   cairo_new_path (xr->cairo);
 625   cairo_move_to (xr->cairo, xr_to_pt (x0), xr_to_pt (y0 + xr->y));
 626   cairo_line_to (xr->cairo, xr_to_pt (x1), xr_to_pt (y1 + xr->y));
 627   cairo_stroke (xr->cairo);
 628 }
 629
 630 /* Draws a horizontal line X0...X2 at Y if LEFT says so,
 631    shortening it to X0...X1 if SHORTEN is true.
 632    Draws a horizontal line X1...X3 at Y if RIGHT says so,
 633    shortening it to X2...X3 if SHORTEN is true. */
 634 static void
 635 horz_line (struct xr_driver *xr, int x0, int x1, int x2, int x3, int y,
 636            enum render_line_style left, enum render_line_style right,
 637            bool shorten)
 638 {
 639   if (left != RENDER_LINE_NONE && right != RENDER_LINE_NONE && !shorten)
 640     dump_line (xr, x0, y, x3, y);
 641   else
 642     {
 643       if (left != RENDER_LINE_NONE)
 644         dump_line (xr, x0, y, shorten ? x1 : x2, y);
 645       if (right != RENDER_LINE_NONE)
 646         dump_line (xr, shorten ? x2 : x1, y, x3, y);
 647     }
 648 }
 649
 650 /* Draws a vertical line Y0...Y2 at X if TOP says so,
 651    shortening it to Y0...Y1 if SHORTEN is true.
 652    Draws a vertical line Y1...Y3 at X if BOTTOM says so,
 653    shortening it to Y2...Y3 if SHORTEN is true. */
 654 static void
 655 vert_line (struct xr_driver *xr, int y0, int y1, int y2, int y3, int x,
 656            enum render_line_style top, enum render_line_style bottom,
 657            bool shorten)
 658 {
 659   if (top != RENDER_LINE_NONE && bottom != RENDER_LINE_NONE && !shorten)
 660     dump_line (xr, x, y0, x, y3);
 661   else
 662     {
 663       if (top != RENDER_LINE_NONE)
 664         dump_line (xr, x, y0, x, shorten ? y1 : y2);
 665       if (bottom != RENDER_LINE_NONE)
 666         dump_line (xr, x, shorten ? y2 : y1, x, y3);
 667     }
 668 }
 669
 670 static void
 671 xr_draw_line (void *xr_, int bb[TABLE_N_AXES][2],
 672               enum render_line_style styles[TABLE_N_AXES][2])
 673 {
 674   const int x0 = bb[H][0];
 675   const int y0 = bb[V][0];
 676   const int x3 = bb[H][1];
 677   const int y3 = bb[V][1];
 678   const int top = styles[H][0];
 679   const int left = styles[V][0];
 680   const int bottom = styles[H][1];
 681   const int right = styles[V][1];
 682
 683   /* The algorithm here is somewhat subtle, to allow it to handle
 684      all the kinds of intersections that we need.
 685
 686      Three additional ordinates are assigned along the x axis.  The
 687      first is xc, midway between x0 and x3.  The others are x1 and
 688      x2; for a single vertical line these are equal to xc, and for
 689      a double vertical line they are the ordinates of the left and
 690      right half of the double line.
 691
 692      yc, y1, and y2 are assigned similarly along the y axis.
 693
 694      The following diagram shows the coordinate system and output
 695      for double top and bottom lines, single left line, and no
 696      right line:
 697
 698                  x0       x1 xc  x2      x3
 699                y0 ________________________
 700                   |        #     #       |
 701                   |        #     #       |
 702                   |        #     #       |
 703                   |        #     #       |
 704                   |        #     #       |
 705      y1 = y2 = yc |#########     #       |
 706                   |        #     #       |
 707                   |        #     #       |
 708                   |        #     #       |
 709                   |        #     #       |
 710                y3 |________#_____#_______|
 711   */
 712   struct xr_driver *xr = xr_;
 713
 714   /* Offset from center of each line in a pair of double lines. */
 715   int double_line_ofs = (xr->line_space + xr->line_width) / 2;
 716
 717   /* Are the lines along each axis single or double?
 718      (It doesn't make sense to have different kinds of line on the
 719      same axis, so we don't try to gracefully handle that case.) */
 720   bool double_vert = top == RENDER_LINE_DOUBLE || bottom == RENDER_LINE_DOUBLE;
 721   bool double_horz = left == RENDER_LINE_DOUBLE || right == RENDER_LINE_DOUBLE;
 722
 723   /* When horizontal lines are doubled,
 724      the left-side line along y1 normally runs from x0 to x2,
 725      and the right-side line along y1 from x3 to x1.
 726      If the top-side line is also doubled, we shorten the y1 lines,
 727      so that the left-side line runs only to x1,
 728      and the right-side line only to x2.
 729      Otherwise, the horizontal line at y = y1 below would cut off
 730      the intersection, which looks ugly:
 731                x0       x1     x2      x3
 732              y0 ________________________
 733                 |        #     #       |
 734                 |        #     #       |
 735                 |        #     #       |
 736                 |        #     #       |
 737              y1 |#########     ########|
 738                 |                      |
 739                 |                      |
 740              y2 |######################|
 741                 |                      |
 742                 |                      |
 743              y3 |______________________|
 744      It is more of a judgment call when the horizontal line is
 745      single.  We actually choose to cut off the line anyhow, as
 746      shown in the first diagram above.
 747   */
 748   bool shorten_y1_lines = top == RENDER_LINE_DOUBLE;
 749   bool shorten_y2_lines = bottom == RENDER_LINE_DOUBLE;
 750   bool shorten_yc_line = shorten_y1_lines && shorten_y2_lines;
 751   int horz_line_ofs = double_vert ? double_line_ofs : 0;
 752   int xc = (x0 + x3) / 2;
 753   int x1 = xc - horz_line_ofs;
 754   int x2 = xc + horz_line_ofs;
 755
 756   bool shorten_x1_lines = left == RENDER_LINE_DOUBLE;
 757   bool shorten_x2_lines = right == RENDER_LINE_DOUBLE;
 758   bool shorten_xc_line = shorten_x1_lines && shorten_x2_lines;
 759   int vert_line_ofs = double_horz ? double_line_ofs : 0;
 760   int yc = (y0 + y3) / 2;
 761   int y1 = yc - vert_line_ofs;
 762   int y2 = yc + vert_line_ofs;
 763
 764   if (!double_horz)
 765     horz_line (xr, x0, x1, x2, x3, yc, left, right, shorten_yc_line);
 766   else
 767     {
 768       horz_line (xr, x0, x1, x2, x3, y1, left, right, shorten_y1_lines);
 769       horz_line (xr, x0, x1, x2, x3, y2, left, right, shorten_y2_lines);
 770     }
 771
 772   if (!double_vert)
 773     vert_line (xr, y0, y1, y2, y3, xc, top, bottom, shorten_xc_line);
 774   else
 775     {
 776       vert_line (xr, y0, y1, y2, y3, x1, top, bottom, shorten_x1_lines);
 777       vert_line (xr, y0, y1, y2, y3, x2, top, bottom, shorten_x2_lines);
 778     }
 779 }
 780
 781 static void
 782 xr_measure_cell_width (void *xr_, const struct table_cell *cell,
 783                        int *min_width, int *max_width)
 784 {
 785   struct xr_driver *xr = xr_;
 786   int bb[TABLE_N_AXES][2];
 787   int clip[TABLE_N_AXES][2];
 788   int h;
 789
 790   bb[H][0] = 0;
 791   bb[H][1] = INT_MAX;
 792   bb[V][0] = 0;
 793   bb[V][1] = INT_MAX;
 794   clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
 795   xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, max_width, &h);
 796
 797   bb[H][1] = 1;
 798   xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, min_width, &h);
 799 }
 800
 801 static int
 802 xr_measure_cell_height (void *xr_, const struct table_cell *cell, int width)
 803 {
 804   struct xr_driver *xr = xr_;
 805   int bb[TABLE_N_AXES][2];
 806   int clip[TABLE_N_AXES][2];
 807   int w, h;
 808
 809   bb[H][0] = 0;
 810   bb[H][1] = width;
 811   bb[V][0] = 0;
 812   bb[V][1] = INT_MAX;
 813   clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
 814   xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, &w, &h);
 815   return h;
 816 }
 817
 818 static void
 819 xr_draw_cell (void *xr_, const struct table_cell *cell,
 820               int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2])
 821 {
 822   struct xr_driver *xr = xr_;
 823   int w, h;
 824
 825   xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, &w, &h);
 826 }
 827 \f
 828 static void
 829 xr_layout_cell (struct xr_driver *xr, const struct table_cell *cell,
 830                 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
 831                 PangoWrapMode wrap, int *width, int *height)
 832 {
 833   struct xr_font *font;
 834
 835   font = (cell->options & TAB_FIX ? &xr->fonts[XR_FONT_FIXED]
 836           : cell->options & TAB_EMPH ? &xr->fonts[XR_FONT_EMPHASIS]
 837           : &xr->fonts[XR_FONT_PROPORTIONAL]);
 838
 839   pango_layout_set_text (font->layout, cell->contents, -1);
 840
 841   pango_layout_set_alignment (
 842     font->layout,
 843     ((cell->options & TAB_ALIGNMENT) == TAB_RIGHT ? PANGO_ALIGN_RIGHT
 844      : (cell->options & TAB_ALIGNMENT) == TAB_LEFT ? PANGO_ALIGN_LEFT
 845      : PANGO_ALIGN_CENTER));
 846   pango_layout_set_width (font->layout,
 847                           bb[H][1] == INT_MAX ? -1 : bb[H][1] - bb[H][0]);
 848   pango_layout_set_wrap (font->layout, wrap);
 849
 850   if (clip[H][0] != clip[H][1])
 851     {
 852       cairo_save (xr->cairo);
 853
 854       if (clip[H][1] != INT_MAX || clip[V][1] != INT_MAX)
 855         {
 856           double x0 = xr_to_pt (clip[H][0]);
 857           double y0 = xr_to_pt (clip[V][0] + xr->y);
 858           double x1 = xr_to_pt (clip[H][1]);
 859           double y1 = xr_to_pt (clip[V][1] + xr->y);
 860
 861           cairo_rectangle (xr->cairo, x0, y0, x1 - x0, y1 - y0);
 862           cairo_clip (xr->cairo);
 863         }
 864
 865       cairo_translate (xr->cairo,
 866                        xr_to_pt (bb[H][0]),
 867                        xr_to_pt (bb[V][0] + xr->y));
 868       pango_cairo_show_layout (xr->cairo, font->layout);
 869       cairo_restore (xr->cairo);
 870     }
 871
 872   if (width != NULL || height != NULL)
 873     {
 874       int w, h;
 875
 876       pango_layout_get_size (font->layout, &w, &h);
 877       if (width != NULL)
 878         *width = w;
 879       if (height != NULL)
 880         *height = h;
 881     }
 882 }
 883
 884 static void
 885 xr_draw_title (struct xr_driver *xr, const char *title,
 886                int title_width, int title_height)
 887 {
 888   struct table_cell cell;
 889   int bb[TABLE_N_AXES][2];
 890
 891   xr_init_caption_cell (title, &cell);
 892   bb[H][0] = 0;
 893   bb[H][1] = title_width;
 894   bb[V][0] = 0;
 895   bb[V][1] = title_height;
 896   xr_draw_cell (xr, &cell, bb, bb);
 897 }
 898 \f
 899 struct output_driver_factory pdf_driver_factory =
 900   { "pdf", "pspp.pdf", xr_pdf_create };
 901 struct output_driver_factory ps_driver_factory =
 902   { "ps", "pspp.ps", xr_ps_create };
 903 struct output_driver_factory svg_driver_factory =
 904   { "svg", "pspp.svg", xr_svg_create };
 905
 906 static const struct output_driver_class cairo_driver_class =
 907 {
 908   "cairo",
 909   xr_destroy,
 910   xr_submit,
 911   xr_flush,
 912 };
 913 \f
 914 /* GUI rendering helpers. */
 915
 916 struct xr_rendering
 917   {
 918     struct output_item *item;
 919
 920     /* Table items. */
 921     struct render_page *page;
 922     struct xr_driver *xr;
 923     int title_width;
 924     int title_height;
 925   };
 926
 927 #define CHART_WIDTH 500
 928 #define CHART_HEIGHT 375
 929
 930
 931
 932 struct xr_driver *
 933 xr_driver_create (cairo_t *cairo, struct string_map *options)
 934 {
 935   struct xr_driver *xr = xr_allocate ("cairo", 0, options);
 936   if (!xr_set_cairo (xr, cairo))
 937     {
 938       output_driver_destroy (&xr->driver);
 939       return NULL;
 940     }
 941   return xr;
 942 }
 943
 944 /* Destroy XR, which should have been created with xr_driver_create().  Any
 945    cairo_t added to XR is not destroyed, because it is owned by the client. */
 946 void
 947 xr_driver_destroy (struct xr_driver *xr)
 948 {
 949   if (xr != NULL)
 950     {
 951       xr->cairo = NULL;
 952       output_driver_destroy (&xr->driver);
 953     }
 954 }
 955
 956 static struct xr_rendering *
 957 xr_rendering_create_text (struct xr_driver *xr, const char *text, cairo_t *cr)
 958 {
 959   struct table_item *table_item;
 960   struct xr_rendering *r;
 961
 962   table_item = table_item_create (table_from_string (TAB_LEFT, text), NULL);
 963   r = xr_rendering_create (xr, &table_item->output_item, cr);
 964   table_item_unref (table_item);
 965
 966   return r;
 967 }
 968
 969 void
 970 xr_rendering_apply_options (struct xr_rendering *xr, struct string_map *o)
 971 {
 972   if (is_table_item (xr->item))
 973     apply_options (xr->xr, o);
 974 }
 975
 976 struct xr_rendering *
 977 xr_rendering_create (struct xr_driver *xr, const struct output_item *item,
 978                      cairo_t *cr)
 979 {
 980   struct xr_rendering *r = NULL;
 981
 982   if (is_text_item (item))
 983     r = xr_rendering_create_text (xr, text_item_get_text (to_text_item (item)),
 984                                   cr);
 985   else if (is_message_item (item))
 986     {
 987       const struct message_item *message_item = to_message_item (item);
 988       const struct msg *msg = message_item_get_msg (message_item);
 989       char *s = msg_to_string (msg, NULL);
 990       r = xr_rendering_create_text (xr, s, cr);
 991       free (s);
 992     }
 993   else if (is_table_item (item))
 994     {
 995       r = xzalloc (sizeof *r);
 996       r->item = output_item_ref (item);
 997       r->xr = xr;
 998       xr_set_cairo (xr, cr);
 999       r->page = xr_render_table_item (xr, to_table_item (item),
1000                                       &r->title_width, &r->title_height);
1001     }
1002   else if (is_chart_item (item))
1003     {
1004       r = xzalloc (sizeof *r);
1005       r->item = output_item_ref (item);
1006     }
1007
1008   return r;
1009 }
1010
1011 void
1012 xr_rendering_measure (struct xr_rendering *r, int *w, int *h)
1013 {
1014   if (is_table_item (r->item))
1015     {
1016       int w0 = render_page_get_size (r->page, H);
1017       int w1 = r->title_width;
1018       *w = MAX (w0, w1) / XR_POINT;
1019       *h = (render_page_get_size (r->page, V) + r->title_height) / XR_POINT;
1020     }
1021   else
1022     {
1023       *w = CHART_WIDTH;
1024       *h = CHART_HEIGHT;
1025     }
1026 }
1027
1028 static void xr_draw_chart (const struct chart_item *, cairo_t *,
1029                     double x, double y, double width, double height);
1030
1031 /* Draws onto CR at least the region of R that is enclosed in (X,Y)-(X+W,Y+H),
1032    and possibly some additional parts. */
1033 void
1034 xr_rendering_draw (struct xr_rendering *r, cairo_t *cr,
1035                    int x, int y, int w, int h)
1036 {
1037   if (is_table_item (r->item))
1038     {
1039       struct xr_driver *xr = r->xr;
1040
1041       xr_set_cairo (xr, cr);
1042
1043       if (r->title_height > 0)
1044         {
1045           xr->y = 0;
1046           xr_draw_title (xr, table_item_get_caption (to_table_item (r->item)),
1047                          r->title_width, r->title_height);
1048         }
1049
1050       xr->y = r->title_height;
1051       render_page_draw_region (r->page,
1052                                x * XR_POINT, (y * XR_POINT) - r->title_height,
1053                                w * XR_POINT, h * XR_POINT);
1054     }
1055   else
1056     xr_draw_chart (to_chart_item (r->item), cr,
1057                    0, 0, CHART_WIDTH, CHART_HEIGHT);
1058 }
1059
1060 static void
1061 xr_draw_chart (const struct chart_item *chart_item, cairo_t *cr,
1062                double x, double y, double width, double height)
1063 {
1064   struct xrchart_geometry geom;
1065
1066   cairo_save (cr);
1067   cairo_translate (cr, x, y + height);
1068   cairo_scale (cr, 1.0, -1.0);
1069   xrchart_geometry_init (cr, &geom, width, height);
1070   if (is_boxplot (chart_item))
1071     xrchart_draw_boxplot (chart_item, cr, &geom);
1072   else if (is_histogram_chart (chart_item))
1073     xrchart_draw_histogram (chart_item, cr, &geom);
1074   else if (is_np_plot_chart (chart_item))
1075     xrchart_draw_np_plot (chart_item, cr, &geom);
1076   else if (is_piechart (chart_item))
1077     xrchart_draw_piechart (chart_item, cr, &geom);
1078   else if (is_roc_chart (chart_item))
1079     xrchart_draw_roc (chart_item, cr, &geom);
1080   else if (is_scree (chart_item))
1081     xrchart_draw_scree (chart_item, cr, &geom);
1082   else if (is_spreadlevel_plot_chart (chart_item))
1083     xrchart_draw_spreadlevel (chart_item, cr, &geom);
1084   else
1085     NOT_REACHED ();
1086   xrchart_geometry_free (cr, &geom);
1087
1088   cairo_restore (cr);
1089 }
1090
1091 char *
1092 xr_draw_png_chart (const struct chart_item *item,
1093                    const char *file_name_template, int number)
1094 {
1095   const int width = 640;
1096   const int length = 480;
1097
1098   cairo_surface_t *surface;
1099   cairo_status_t status;
1100   const char *number_pos;
1101   char *file_name;
1102   cairo_t *cr;
1103
1104   number_pos = strchr (file_name_template, '#');
1105   if (number_pos != NULL)
1106     file_name = xasprintf ("%.*s%d%s", (int) (number_pos - file_name_template),
1107                            file_name_template, number, number_pos + 1);
1108   else
1109     file_name = xstrdup (file_name_template);
1110
1111   surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, width, length);
1112   cr = cairo_create (surface);
1113
1114   cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
1115
1116   xr_draw_chart (item, cr, 0.0, 0.0, width, length);
1117
1118   status = cairo_surface_write_to_png (surface, file_name);
1119   if (status != CAIRO_STATUS_SUCCESS)
1120     error (0, 0, _("error writing output file `%s': %s"),
1121            file_name, cairo_status_to_string (status));
1122
1123   cairo_destroy (cr);
1124   cairo_surface_destroy (surface);
1125
1126   return file_name;
1127 }
1128 \f
1129 struct xr_table_state
1130   {
1131     struct xr_render_fsm fsm;
1132     struct table_item *table_item;
1133     struct render_break x_break;
1134     struct render_break y_break;
1135     int caption_height;
1136   };
1137
1138 static bool
1139 xr_table_render (struct xr_render_fsm *fsm, struct xr_driver *xr)
1140 {
1141   struct xr_table_state *ts = UP_CAST (fsm, struct xr_table_state, fsm);
1142
1143   for (;;)
1144     {
1145       struct render_page *y_slice;
1146       int space;
1147
1148       while (!render_break_has_next (&ts->y_break))
1149         {
1150           struct render_page *x_slice;
1151
1152           render_break_destroy (&ts->y_break);
1153           if (!render_break_has_next (&ts->x_break))
1154             return false;
1155
1156           x_slice = render_break_next (&ts->x_break, xr->width);
1157           render_break_init (&ts->y_break, x_slice, V);
1158         }
1159
1160       space = xr->length - xr->y;
1161       if (render_break_next_size (&ts->y_break) > space)
1162         {
1163           assert (xr->y > 0);
1164           return true;
1165         }
1166
1167       y_slice = render_break_next (&ts->y_break, space);
1168       if (ts->caption_height)
1169         {
1170           if (xr->cairo)
1171             xr_draw_title (xr, table_item_get_caption (ts->table_item),
1172                            xr->width, ts->caption_height);
1173
1174           xr->y += ts->caption_height;
1175           ts->caption_height = 0;
1176         }
1177
1178       if (xr->cairo)
1179         render_page_draw (y_slice);
1180       xr->y += render_page_get_size (y_slice, V);
1181       render_page_unref (y_slice);
1182     }
1183 }
1184
1185 static void
1186 xr_table_destroy (struct xr_render_fsm *fsm)
1187 {
1188   struct xr_table_state *ts = UP_CAST (fsm, struct xr_table_state, fsm);
1189
1190   table_item_unref (ts->table_item);
1191   render_break_destroy (&ts->x_break);
1192   render_break_destroy (&ts->y_break);
1193   free (ts);
1194 }
1195
1196 static struct xr_render_fsm *
1197 xr_render_table (struct xr_driver *xr, const struct table_item *table_item)
1198 {
1199   struct xr_table_state *ts;
1200   struct render_page *page;
1201   int caption_width;
1202
1203   ts = xmalloc (sizeof *ts);
1204   ts->fsm.render = xr_table_render;
1205   ts->fsm.destroy = xr_table_destroy;
1206   ts->table_item = table_item_ref (table_item);
1207
1208   if (xr->y > 0)
1209     xr->y += xr->char_height;
1210
1211   page = xr_render_table_item (xr, table_item,
1212                                &caption_width, &ts->caption_height);
1213   xr->params->size[V] = xr->length - ts->caption_height;
1214
1215   render_break_init (&ts->x_break, page, H);
1216   render_break_init_empty (&ts->y_break);
1217
1218   return &ts->fsm;
1219 }
1220 \f
1221 struct xr_chart_state
1222   {
1223     struct xr_render_fsm fsm;
1224     struct chart_item *chart_item;
1225   };
1226
1227 static bool
1228 xr_chart_render (struct xr_render_fsm *fsm, struct xr_driver *xr)
1229 {
1230   struct xr_chart_state *cs = UP_CAST (fsm, struct xr_chart_state, fsm);
1231
1232   if (xr->y > 0)
1233     return true;
1234
1235   if (xr->cairo != NULL)
1236     xr_draw_chart (cs->chart_item, xr->cairo, 0.0, 0.0,
1237                    xr_to_pt (xr->width), xr_to_pt (xr->length));
1238   xr->y = xr->length;
1239
1240   return false;
1241 }
1242
1243 static void
1244 xr_chart_destroy (struct xr_render_fsm *fsm)
1245 {
1246   struct xr_chart_state *cs = UP_CAST (fsm, struct xr_chart_state, fsm);
1247
1248   chart_item_unref (cs->chart_item);
1249   free (cs);
1250 }
1251
1252 static struct xr_render_fsm *
1253 xr_render_chart (const struct chart_item *chart_item)
1254 {
1255   struct xr_chart_state *cs;
1256
1257   cs = xmalloc (sizeof *cs);
1258   cs->fsm.render = xr_chart_render;
1259   cs->fsm.destroy = xr_chart_destroy;
1260   cs->chart_item = chart_item_ref (chart_item);
1261
1262   return &cs->fsm;
1263 }
1264 \f
1265 static bool
1266 xr_eject_render (struct xr_render_fsm *fsm UNUSED, struct xr_driver *xr)
1267 {
1268   return xr->y > 0;
1269 }
1270
1271 static void
1272 xr_eject_destroy (struct xr_render_fsm *fsm UNUSED)
1273 {
1274   /* Nothing to do. */
1275 }
1276
1277 static struct xr_render_fsm *
1278 xr_render_eject (void)
1279 {
1280   static struct xr_render_fsm eject_renderer =
1281     {
1282       xr_eject_render,
1283       xr_eject_destroy
1284     };
1285
1286   return &eject_renderer;
1287 }
1288 \f
1289 static struct xr_render_fsm *
1290 xr_create_text_renderer (struct xr_driver *xr, const char *text)
1291 {
1292   struct table_item *table_item;
1293   struct xr_render_fsm *fsm;
1294
1295   table_item = table_item_create (table_from_string (TAB_LEFT, text), NULL);
1296   fsm = xr_render_table (xr, table_item);
1297   table_item_unref (table_item);
1298
1299   return fsm;
1300 }
1301
1302 static struct xr_render_fsm *
1303 xr_render_text (struct xr_driver *xr, const struct text_item *text_item)
1304 {
1305   enum text_item_type type = text_item_get_type (text_item);
1306   const char *text = text_item_get_text (text_item);
1307
1308   switch (type)
1309     {
1310     case TEXT_ITEM_TITLE:
1311       free (xr->title);
1312       xr->title = xstrdup (text);
1313       break;
1314
1315     case TEXT_ITEM_SUBTITLE:
1316       free (xr->subtitle);
1317       xr->subtitle = xstrdup (text);
1318       break;
1319
1320     case TEXT_ITEM_COMMAND_CLOSE:
1321       break;
1322
1323     case TEXT_ITEM_BLANK_LINE:
1324       if (xr->y > 0)
1325         xr->y += xr->char_height;
1326       break;
1327
1328     case TEXT_ITEM_EJECT_PAGE:
1329       if (xr->y > 0)
1330         return xr_render_eject ();
1331       break;
1332
1333     default:
1334       return xr_create_text_renderer (xr, text);
1335     }
1336
1337   return NULL;
1338 }
1339
1340 static struct xr_render_fsm *
1341 xr_render_message (struct xr_driver *xr,
1342                    const struct message_item *message_item)
1343 {
1344   const struct msg *msg = message_item_get_msg (message_item);
1345   struct xr_render_fsm *fsm;
1346   char *s;
1347
1348   s = msg_to_string (msg, xr->command_name);
1349   fsm = xr_create_text_renderer (xr, s);
1350   free (s);
1351
1352   return fsm;
1353 }
1354
1355 static struct xr_render_fsm *
1356 xr_render_output_item (struct xr_driver *xr,
1357                        const struct output_item *output_item)
1358 {
1359   if (is_table_item (output_item))
1360     return xr_render_table (xr, to_table_item (output_item));
1361   else if (is_chart_item (output_item))
1362     return xr_render_chart (to_chart_item (output_item));
1363   else if (is_text_item (output_item))
1364     return xr_render_text (xr, to_text_item (output_item));
1365   else if (is_message_item (output_item))
1366     return xr_render_message (xr, to_message_item (output_item));
1367   else
1368     return NULL;
1369 }