src/output/cairo.c

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