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 \f
 844 struct output_driver_factory pdf_driver_factory = { "pdf", xr_pdf_create };
 845 struct output_driver_factory ps_driver_factory = { "ps", xr_ps_create };
 846 struct output_driver_factory svg_driver_factory = { "svg", xr_svg_create };
 847
 848 static const struct output_driver_class cairo_driver_class =
 849 {
 850   "cairo",
 851   xr_destroy,
 852   xr_submit,
 853   xr_flush,
 854 };
 855 \f
 856 /* GUI rendering helpers. */
 857
 858 struct xr_rendering
 859   {
 860     struct output_item *item;
 861
 862     /* Table items. */
 863     struct render_page *page;
 864     struct xr_driver *xr;
 865     int title_height;
 866   };
 867
 868 #define CHART_WIDTH 500
 869 #define CHART_HEIGHT 375
 870
 871 struct xr_driver *
 872 xr_driver_create (cairo_t *cairo, struct string_map *options)
 873 {
 874   struct xr_driver *xr = xr_allocate ("cairo", 0, options);
 875   if (!xr_set_cairo (xr, cairo))
 876     {
 877       output_driver_destroy (&xr->driver);
 878       return NULL;
 879     }
 880   return xr;
 881 }
 882
 883 /* Destroy XR, which should have been created with xr_driver_create().  Any
 884    cairo_t added to XR is not destroyed, because it is owned by the client. */
 885 void
 886 xr_driver_destroy (struct xr_driver *xr)
 887 {
 888   if (xr != NULL)
 889     {
 890       xr->cairo = NULL;
 891       output_driver_destroy (&xr->driver);
 892     }
 893 }
 894
 895 static struct xr_rendering *
 896 xr_rendering_create_text (struct xr_driver *xr, const char *text, cairo_t *cr)
 897 {
 898   struct table_item *table_item;
 899   struct xr_rendering *r;
 900
 901   table_item = table_item_create (table_from_string (0, text), NULL);
 902   r = xr_rendering_create (xr, &table_item->output_item, cr);
 903   table_item_unref (table_item);
 904
 905   return r;
 906 }
 907
 908 struct xr_rendering *
 909 xr_rendering_create (struct xr_driver *xr, const struct output_item *item,
 910                      cairo_t *cr)
 911 {
 912   struct xr_rendering *r = NULL;
 913
 914   if (is_text_item (item))
 915     r = xr_rendering_create_text (xr, text_item_get_text (to_text_item (item)),
 916                                   cr);
 917   else if (is_message_item (item))
 918     {
 919       const struct message_item *message_item = to_message_item (item);
 920       const struct msg *msg = message_item_get_msg (message_item);
 921       char *s = msg_to_string (msg, NULL);
 922       r = xr_rendering_create_text (xr, s, cr);
 923       free (s);
 924     }
 925   else if (is_table_item (item))
 926     {
 927       r = xzalloc (sizeof *r);
 928       r->item = output_item_ref (item);
 929       r->xr = xr;
 930       xr_set_cairo (xr, cr);
 931       r->page = xr_render_table_item (xr, to_table_item (item),
 932                                       &r->title_height);
 933     }
 934   else if (is_chart_item (item))
 935     {
 936       r = xzalloc (sizeof *r);
 937       r->item = output_item_ref (item);
 938     }
 939
 940   return r;
 941 }
 942
 943 void
 944 xr_rendering_measure (struct xr_rendering *r, int *w, int *h)
 945 {
 946   if (is_table_item (r->item))
 947     {
 948       *w = render_page_get_size (r->page, H) / 1024;
 949       *h = (render_page_get_size (r->page, V) + r->title_height) / 1024;
 950     }
 951   else
 952     {
 953       *w = CHART_WIDTH;
 954       *h = CHART_HEIGHT;
 955     }
 956 }
 957
 958 /* Draws onto CR at least the region of R that is enclosed in (X,Y)-(X+W,Y+H),
 959    and possibly some additional parts. */
 960 void
 961 xr_rendering_draw (struct xr_rendering *r, cairo_t *cr,
 962                    int x, int y, int w, int h)
 963 {
 964   if (is_table_item (r->item))
 965     {
 966       struct xr_driver *xr = r->xr;
 967
 968       xr_set_cairo (xr, cr);
 969       xr->y = 0;
 970       render_page_draw_region (r->page,
 971                                x * 1024, y * 1024, w * 1024, h * 1024);
 972     }
 973   else
 974     xr_draw_chart (to_chart_item (r->item), cr,
 975                    0, 0, CHART_WIDTH, CHART_HEIGHT);
 976 }
 977
 978 void
 979 xr_draw_chart (const struct chart_item *chart_item, cairo_t *cr,
 980                double x, double y, double width, double height)
 981 {
 982   struct xrchart_geometry geom;
 983
 984   cairo_save (cr);
 985   cairo_translate (cr, x, y + height);
 986   cairo_scale (cr, 1.0, -1.0);
 987   xrchart_geometry_init (cr, &geom, width, height);
 988   if (is_boxplot (chart_item))
 989     xrchart_draw_boxplot (chart_item, cr, &geom);
 990   else if (is_histogram_chart (chart_item))
 991     xrchart_draw_histogram (chart_item, cr, &geom);
 992   else if (is_np_plot_chart (chart_item))
 993     xrchart_draw_np_plot (chart_item, cr, &geom);
 994   else if (is_piechart (chart_item))
 995     xrchart_draw_piechart (chart_item, cr, &geom);
 996   else if (is_roc_chart (chart_item))
 997     xrchart_draw_roc (chart_item, cr, &geom);
 998   else if (is_scree (chart_item))
 999     xrchart_draw_scree (chart_item, cr, &geom);
1000   else
1001     NOT_REACHED ();
1002   xrchart_geometry_free (cr, &geom);
1003
1004   cairo_restore (cr);
1005 }
1006
1007 char *
1008 xr_draw_png_chart (const struct chart_item *item,
1009                    const char *file_name_template, int number)
1010 {
1011   const int width = 640;
1012   const int length = 480;
1013
1014   cairo_surface_t *surface;
1015   cairo_status_t status;
1016   const char *number_pos;
1017   char *file_name;
1018   cairo_t *cr;
1019
1020   number_pos = strchr (file_name_template, '#');
1021   if (number_pos != NULL)
1022     file_name = xasprintf ("%.*s%d%s", (int) (number_pos - file_name_template),
1023                            file_name_template, number, number_pos + 1);
1024   else
1025     file_name = xstrdup (file_name_template);
1026
1027   surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, width, length);
1028   cr = cairo_create (surface);
1029
1030   cairo_save (cr);
1031   cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
1032   cairo_rectangle (cr, 0, 0, width, length);
1033   cairo_fill (cr);
1034   cairo_restore (cr);
1035
1036   cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
1037
1038   xr_draw_chart (item, cr, 0.0, 0.0, width, length);
1039
1040   status = cairo_surface_write_to_png (surface, file_name);
1041   if (status != CAIRO_STATUS_SUCCESS)
1042     error (0, 0, _("error writing output file `%s': %s"),
1043            file_name, cairo_status_to_string (status));
1044
1045   cairo_destroy (cr);
1046   cairo_surface_destroy (surface);
1047
1048   return file_name;
1049 }
1050 \f
1051 struct xr_table_state
1052   {
1053     struct xr_render_fsm fsm;
1054     struct table_item *table_item;
1055     struct render_break x_break;
1056     struct render_break y_break;
1057     int caption_height;
1058   };
1059
1060 static bool
1061 xr_table_render (struct xr_render_fsm *fsm, struct xr_driver *xr)
1062 {
1063   struct xr_table_state *ts = UP_CAST (fsm, struct xr_table_state, fsm);
1064
1065   for (;;)
1066     {
1067       struct render_page *y_slice;
1068       int space;
1069
1070       while (!render_break_has_next (&ts->y_break))
1071         {
1072           struct render_page *x_slice;
1073
1074           render_break_destroy (&ts->y_break);
1075           if (!render_break_has_next (&ts->x_break))
1076             return false;
1077
1078           x_slice = render_break_next (&ts->x_break, xr->width);
1079           render_break_init (&ts->y_break, x_slice, V);
1080         }
1081
1082       space = xr->length - xr->y;
1083       if (render_break_next_size (&ts->y_break) > space)
1084         {
1085           assert (xr->y > 0);
1086           return true;
1087         }
1088
1089       y_slice = render_break_next (&ts->y_break, space);
1090       if (ts->caption_height)
1091         {
1092           if (xr->cairo)
1093             {
1094               struct table_cell cell;
1095               int bb[TABLE_N_AXES][2];
1096
1097               xr_init_caption_cell (table_item_get_caption (ts->table_item),
1098                                     &cell);
1099               bb[H][0] = 0;
1100               bb[H][1] = xr->width;
1101               bb[V][0] = 0;
1102               bb[V][1] = ts->caption_height;
1103               xr_draw_cell (xr, &cell, bb, bb);
1104             }
1105           xr->y += ts->caption_height;
1106           ts->caption_height = 0;
1107         }
1108
1109       if (xr->cairo)
1110         render_page_draw (y_slice);
1111       xr->y += render_page_get_size (y_slice, V);
1112       render_page_unref (y_slice);
1113     }
1114 }
1115
1116 static void
1117 xr_table_destroy (struct xr_render_fsm *fsm)
1118 {
1119   struct xr_table_state *ts = UP_CAST (fsm, struct xr_table_state, fsm);
1120
1121   table_item_unref (ts->table_item);
1122   render_break_destroy (&ts->x_break);
1123   render_break_destroy (&ts->y_break);
1124   free (ts);
1125 }
1126
1127 static struct xr_render_fsm *
1128 xr_render_table (struct xr_driver *xr, const struct table_item *table_item)
1129 {
1130   struct xr_table_state *ts;
1131   struct render_page *page;
1132
1133   ts = xmalloc (sizeof *ts);
1134   ts->fsm.render = xr_table_render;
1135   ts->fsm.destroy = xr_table_destroy;
1136   ts->table_item = table_item_ref (table_item);
1137
1138   if (xr->y > 0)
1139     xr->y += xr->char_height;
1140
1141   page = xr_render_table_item (xr, table_item, &ts->caption_height);
1142   xr->params->size[V] = xr->length - ts->caption_height;
1143
1144   render_break_init (&ts->x_break, page, H);
1145   render_break_init_empty (&ts->y_break);
1146
1147   return &ts->fsm;
1148 }
1149 \f
1150 struct xr_chart_state
1151   {
1152     struct xr_render_fsm fsm;
1153     struct chart_item *chart_item;
1154   };
1155
1156 static bool
1157 xr_chart_render (struct xr_render_fsm *fsm, struct xr_driver *xr)
1158 {
1159   struct xr_chart_state *cs = UP_CAST (fsm, struct xr_chart_state, fsm);
1160
1161   if (xr->y > 0)
1162     return true;
1163
1164   if (xr->cairo != NULL)
1165     xr_draw_chart (cs->chart_item, xr->cairo, 0.0, 0.0,
1166                    xr_to_pt (xr->width), xr_to_pt (xr->length));
1167   xr->y = xr->length;
1168
1169   return false;
1170 }
1171
1172 static void
1173 xr_chart_destroy (struct xr_render_fsm *fsm)
1174 {
1175   struct xr_chart_state *cs = UP_CAST (fsm, struct xr_chart_state, fsm);
1176
1177   chart_item_unref (cs->chart_item);
1178   free (cs);
1179 }
1180
1181 static struct xr_render_fsm *
1182 xr_render_chart (const struct chart_item *chart_item)
1183 {
1184   struct xr_chart_state *cs;
1185
1186   cs = xmalloc (sizeof *cs);
1187   cs->fsm.render = xr_chart_render;
1188   cs->fsm.destroy = xr_chart_destroy;
1189   cs->chart_item = chart_item_ref (chart_item);
1190
1191   return &cs->fsm;
1192 }
1193 \f
1194 static bool
1195 xr_eject_render (struct xr_render_fsm *fsm UNUSED, struct xr_driver *xr)
1196 {
1197   return xr->y > 0;
1198 }
1199
1200 static void
1201 xr_eject_destroy (struct xr_render_fsm *fsm UNUSED)
1202 {
1203   /* Nothing to do. */
1204 }
1205
1206 static struct xr_render_fsm *
1207 xr_render_eject (void)
1208 {
1209   static struct xr_render_fsm eject_renderer =
1210     {
1211       xr_eject_render,
1212       xr_eject_destroy
1213     };
1214
1215   return &eject_renderer;
1216 }
1217 \f
1218 static struct xr_render_fsm *
1219 xr_create_text_renderer (struct xr_driver *xr, const char *text)
1220 {
1221   struct table_item *table_item;
1222   struct xr_render_fsm *fsm;
1223
1224   table_item = table_item_create (table_from_string (TAB_LEFT, text), NULL);
1225   fsm = xr_render_table (xr, table_item);
1226   table_item_unref (table_item);
1227
1228   return fsm;
1229 }
1230
1231 static struct xr_render_fsm *
1232 xr_render_text (struct xr_driver *xr, const struct text_item *text_item)
1233 {
1234   enum text_item_type type = text_item_get_type (text_item);
1235   const char *text = text_item_get_text (text_item);
1236
1237   switch (type)
1238     {
1239     case TEXT_ITEM_TITLE:
1240       free (xr->title);
1241       xr->title = xstrdup (text);
1242       break;
1243
1244     case TEXT_ITEM_SUBTITLE:
1245       free (xr->subtitle);
1246       xr->subtitle = xstrdup (text);
1247       break;
1248
1249     case TEXT_ITEM_COMMAND_CLOSE:
1250       break;
1251
1252     case TEXT_ITEM_BLANK_LINE:
1253       if (xr->y > 0)
1254         xr->y += xr->char_height;
1255       break;
1256
1257     case TEXT_ITEM_EJECT_PAGE:
1258       if (xr->y > 0)
1259         return xr_render_eject ();
1260       break;
1261
1262     default:
1263       return xr_create_text_renderer (xr, text);
1264     }
1265
1266   return NULL;
1267 }
1268
1269 static struct xr_render_fsm *
1270 xr_render_message (struct xr_driver *xr,
1271                    const struct message_item *message_item)
1272 {
1273   const struct msg *msg = message_item_get_msg (message_item);
1274   struct xr_render_fsm *fsm;
1275   char *s;
1276
1277   s = msg_to_string (msg, xr->command_name);
1278   fsm = xr_create_text_renderer (xr, s);
1279   free (s);
1280
1281   return fsm;
1282 }
1283
1284 static struct xr_render_fsm *
1285 xr_render_output_item (struct xr_driver *xr,
1286                        const struct output_item *output_item)
1287 {
1288   if (is_table_item (output_item))
1289     return xr_render_table (xr, to_table_item (output_item));
1290   else if (is_chart_item (output_item))
1291     return xr_render_chart (to_chart_item (output_item));
1292   else if (is_text_item (output_item))
1293     return xr_render_text (xr, to_text_item (output_item));
1294   else if (is_message_item (output_item))
1295     return xr_render_message (xr, to_message_item (output_item));
1296   else
1297     return NULL;
1298 }