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