table-stomp: Remove dead code.
[pspp] / src / output / cairo.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Free Software Foundation, Inc.
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, either version 3 of the License, or
7    (at your option) any later version.
8
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12    GNU General Public License for more details.
13
14    You should have received a copy of the GNU General Public License
15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
16
17 #include <config.h>
18
19 #include "output/cairo.h"
20
21 #include "libpspp/assertion.h"
22 #include "libpspp/cast.h"
23 #include "libpspp/message.h"
24 #include "libpspp/pool.h"
25 #include "libpspp/start-date.h"
26 #include "libpspp/str.h"
27 #include "libpspp/string-map.h"
28 #include "libpspp/version.h"
29 #include "data/file-handle-def.h"
30 #include "output/cairo-chart.h"
31 #include "output/chart-item-provider.h"
32 #include "output/charts/boxplot.h"
33 #include "output/charts/np-plot.h"
34 #include "output/charts/piechart.h"
35 #include "output/charts/barchart.h"
36 #include "output/charts/plot-hist.h"
37 #include "output/charts/roc-chart.h"
38 #include "output/charts/spreadlevel-plot.h"
39 #include "output/charts/scree.h"
40 #include "output/charts/scatterplot.h"
41 #include "output/driver-provider.h"
42 #include "output/message-item.h"
43 #include "output/options.h"
44 #include "output/render.h"
45 #include "output/tab.h"
46 #include "output/table-item.h"
47 #include "output/table.h"
48 #include "output/text-item.h"
49
50 #include <cairo/cairo-pdf.h>
51 #include <cairo/cairo-ps.h>
52 #include <cairo/cairo-svg.h>
53 #include <cairo/cairo.h>
54 #include <math.h>
55 #include <pango/pango-font.h>
56 #include <pango/pango-layout.h>
57 #include <pango/pango.h>
58 #include <pango/pangocairo.h>
59 #include <stdlib.h>
60
61 #include "gl/c-ctype.h"
62 #include "gl/c-strcase.h"
63 #include "gl/intprops.h"
64 #include "gl/minmax.h"
65 #include "gl/xalloc.h"
66
67 #include "gettext.h"
68 #define _(msgid) gettext (msgid)
69
70 /* This file uses TABLE_HORZ and TABLE_VERT enough to warrant abbreviating. */
71 #define H TABLE_HORZ
72 #define V TABLE_VERT
73
74 /* The unit used for internal measurements is inch/(72 * XR_POINT).
75    (Thus, XR_POINT units represent one point.) */
76 #define XR_POINT PANGO_SCALE
77
78 /* Conversions to and from points. */
79 static double
80 xr_to_pt (int x)
81 {
82   return x / (double) XR_POINT;
83 }
84
85 /* Conversion from 1/96" units ("pixels") to Cairo/Pango units. */
86 static int
87 px_to_xr (int x)
88 {
89   return x * (PANGO_SCALE * 72 / 96);
90 }
91
92 /* Dimensions for drawing lines in tables. */
93 #define XR_LINE_WIDTH (XR_POINT / 2) /* Width of an ordinary line. */
94 #define XR_LINE_SPACE XR_POINT       /* Space between double lines. */
95
96 /* Output types. */
97 enum xr_output_type
98   {
99     XR_PDF,
100     XR_PS,
101     XR_SVG
102   };
103
104 /* Cairo fonts. */
105 enum xr_font_type
106   {
107     XR_FONT_PROPORTIONAL,
108     XR_FONT_EMPHASIS,
109     XR_FONT_FIXED,
110     XR_N_FONTS
111   };
112
113 /* A font for use with Cairo. */
114 struct xr_font
115   {
116     PangoFontDescription *desc;
117     PangoLayout *layout;
118   };
119
120 /* An output item whose rendering is in progress. */
121 struct xr_render_fsm
122   {
123     /* Renders as much of itself as it can on the current page.  Returns true
124        if rendering is complete, false if the output item needs another
125        page. */
126     bool (*render) (struct xr_render_fsm *, struct xr_driver *);
127
128     /* Destroys the output item. */
129     void (*destroy) (struct xr_render_fsm *);
130   };
131
132 /* Cairo output driver. */
133 struct xr_driver
134   {
135     struct output_driver driver;
136
137     /* User parameters. */
138     struct xr_font fonts[XR_N_FONTS];
139
140     int width;                  /* Page width minus margins. */
141     int length;                 /* Page length minus margins and header. */
142
143     int left_margin;            /* Left margin in inch/(72 * XR_POINT). */
144     int right_margin;           /* Right margin in inch/(72 * XR_POINT). */
145     int top_margin;             /* Top margin in inch/(72 * XR_POINT). */
146     int bottom_margin;          /* Bottom margin in inch/(72 * XR_POINT). */
147
148     int line_space;             /* Space between lines. */
149     int line_width;             /* Width of lines. */
150
151     int min_break[TABLE_N_AXES]; /* Min cell size to break across pages. */
152
153     struct xr_color bg;    /* Background color */
154     struct xr_color fg;    /* Foreground color */
155
156     /* Internal state. */
157     struct render_params *params;
158     int char_width, char_height;
159     char *command_name;
160     char *title;
161     char *subtitle;
162     cairo_t *cairo;
163     int page_number;            /* Current page number. */
164     int x, y;
165     struct xr_render_fsm *fsm;
166     int nest;
167   };
168
169 static const struct output_driver_class cairo_driver_class;
170
171 static void xr_driver_destroy_fsm (struct xr_driver *);
172 static void xr_driver_run_fsm (struct xr_driver *);
173
174 static void xr_draw_line (void *, int bb[TABLE_N_AXES][2],
175                           enum render_line_style styles[TABLE_N_AXES][2],
176                           struct cell_color colors[TABLE_N_AXES][2]);
177 static void xr_measure_cell_width (void *, const struct table_cell *,
178                                    int *min, int *max);
179 static int xr_measure_cell_height (void *, const struct table_cell *,
180                                    int width);
181 static void xr_draw_cell (void *, const struct table_cell *, int color_idx,
182                           int bb[TABLE_N_AXES][2],
183                           int spill[TABLE_N_AXES][2],
184                           int clip[TABLE_N_AXES][2]);
185 static int xr_adjust_break (void *, const struct table_cell *,
186                             int width, int height);
187
188 static struct xr_render_fsm *xr_render_output_item (
189   struct xr_driver *, const struct output_item *);
190 \f
191 /* Output driver basics. */
192
193 static struct xr_driver *
194 xr_driver_cast (struct output_driver *driver)
195 {
196   assert (driver->class == &cairo_driver_class);
197   return UP_CAST (driver, struct xr_driver, driver);
198 }
199
200 static struct driver_option *
201 opt (struct output_driver *d, struct string_map *options, const char *key,
202      const char *default_value)
203 {
204   return driver_option_get (d, options, key, default_value);
205 }
206
207 /* Parse color information specified by KEY into {RED,GREEN,BLUE}.
208    Currently, the input string must be of the form "#RRRRGGGGBBBB"
209    Future implementations might allow things like "yellow" and
210    "sky-blue-ultra-brown"
211 */
212 void
213 parse_color (struct output_driver *d, struct string_map *options,
214              const char *key, const char *default_value,
215              struct xr_color *color)
216 {
217   int red, green, blue;
218   char *string = parse_string (opt (d, options, key, default_value));
219
220   if (3 != sscanf (string, "#%04x%04x%04x", &red, &green, &blue))
221     {
222       /* If the parsed option string fails, then try the default value */
223       if ( 3 != sscanf (default_value, "#%04x%04x%04x", &red, &green, &blue))
224         {
225           /* ... and if that fails set everything to zero */
226           red = green = blue = 0;
227         }
228     }
229
230   free (string);
231
232   /* Convert 16 bit ints to float */
233   color->red = red / (double) 0xFFFF;
234   color->green = green / (double) 0xFFFF;
235   color->blue = blue / (double) 0xFFFF;
236 }
237
238 static PangoFontDescription *
239 parse_font (const char *font, int default_size, bool bold, bool italic)
240 {
241   if (!c_strcasecmp (font, "Monospaced"))
242     font = "Monospace";
243
244   PangoFontDescription *desc = pango_font_description_from_string (font);
245   if (desc == NULL)
246     return NULL;
247
248   /* If the font description didn't include an explicit font size, then set it
249      to DEFAULT_SIZE, which is in inch/72000 units. */
250   if (!(pango_font_description_get_set_fields (desc) & PANGO_FONT_MASK_SIZE))
251     pango_font_description_set_size (desc,
252                                      (default_size / 1000.0) * PANGO_SCALE);
253
254   pango_font_description_set_weight (desc, (bold
255                                             ? PANGO_WEIGHT_BOLD
256                                             : PANGO_WEIGHT_NORMAL));
257   pango_font_description_set_style (desc, (italic
258                                            ? PANGO_STYLE_ITALIC
259                                            : PANGO_STYLE_NORMAL));
260
261   return desc;
262 }
263
264 static PangoFontDescription *
265 parse_font_option (struct output_driver *d, struct string_map *options,
266                    const char *key, const char *default_value,
267                    int default_size, bool bold, bool italic)
268 {
269   char *string = parse_string (opt (d, options, key, default_value));
270   PangoFontDescription *desc = parse_font (string, default_size, bold, italic);
271   if (!desc)
272     {
273       msg (MW, _("`%s': bad font specification"), string);
274
275       /* Fall back to DEFAULT_VALUE, which had better be a valid font
276          description. */
277       desc = parse_font (default_value, default_size, bold, italic);
278       assert (desc != NULL);
279     }
280   free (string);
281
282   return desc;
283 }
284
285 static void
286 apply_options (struct xr_driver *xr, struct string_map *o)
287 {
288   struct output_driver *d = &xr->driver;
289
290   /* In inch/72000 units used by parse_paper_size() and parse_dimension(). */
291   int left_margin, right_margin;
292   int top_margin, bottom_margin;
293   int paper_width, paper_length;
294   int font_size;
295   int min_break[TABLE_N_AXES];
296
297   /* Scale factor from inch/72000 to inch/(72 * XR_POINT). */
298   const double scale = XR_POINT / 1000.;
299
300   int i;
301
302   for (i = 0; i < XR_N_FONTS; i++)
303     {
304       struct xr_font *font = &xr->fonts[i];
305
306       if (font->desc != NULL)
307         pango_font_description_free (font->desc);
308     }
309
310   font_size = parse_int (opt (d, o, "font-size", "10000"), 1000, 1000000);
311   xr->fonts[XR_FONT_FIXED].desc = parse_font_option
312     (d, o, "fixed-font", "monospace", font_size, false, false);
313   xr->fonts[XR_FONT_PROPORTIONAL].desc = parse_font_option (
314     d, o, "prop-font", "sans serif", font_size, false, false);
315   xr->fonts[XR_FONT_EMPHASIS].desc = parse_font_option (
316     d, o, "emph-font", "sans serif", font_size, false, true);
317
318   xr->page_number = 0;
319
320   parse_color (d, o, "background-color", "#FFFFFFFFFFFF", &xr->bg);
321   parse_color (d, o, "foreground-color", "#000000000000", &xr->fg);
322
323   /* Get dimensions.  */
324   parse_paper_size (opt (d, o, "paper-size", ""), &paper_width, &paper_length);
325   left_margin = parse_dimension (opt (d, o, "left-margin", ".5in"));
326   right_margin = parse_dimension (opt (d, o, "right-margin", ".5in"));
327   top_margin = parse_dimension (opt (d, o, "top-margin", ".5in"));
328   bottom_margin = parse_dimension (opt (d, o, "bottom-margin", ".5in"));
329
330   min_break[H] = parse_dimension (opt (d, o, "min-hbreak", NULL)) * scale;
331   min_break[V] = parse_dimension (opt (d, o, "min-vbreak", NULL)) * scale;
332
333   /* Convert to inch/(XR_POINT * 72). */
334   xr->left_margin = left_margin * scale;
335   xr->right_margin = right_margin * scale;
336   xr->top_margin = top_margin * scale;
337   xr->bottom_margin = bottom_margin * scale;
338   xr->width = (paper_width - left_margin - right_margin) * scale;
339   xr->length = (paper_length - top_margin - bottom_margin) * scale;
340   xr->min_break[H] = min_break[H] >= 0 ? min_break[H] : xr->width / 2;
341   xr->min_break[V] = min_break[V] >= 0 ? min_break[V] : xr->length / 2;
342 }
343
344 static struct xr_driver *
345 xr_allocate (const char *name, int device_type, struct string_map *o)
346 {
347   struct xr_driver *xr = xzalloc (sizeof *xr);
348   struct output_driver *d = &xr->driver;
349
350   output_driver_init (d, &cairo_driver_class, name, device_type);
351
352   apply_options (xr, o);
353
354   return xr;
355 }
356
357 static int
358 pango_to_xr (int pango)
359 {
360   return (XR_POINT != PANGO_SCALE
361           ? ceil (pango * (1. * XR_POINT / PANGO_SCALE))
362           : pango);
363 }
364
365 static int
366 xr_to_pango (int xr)
367 {
368   return (XR_POINT != PANGO_SCALE
369           ? ceil (xr * (1. / XR_POINT * PANGO_SCALE))
370           : xr);
371 }
372
373 static bool
374 xr_set_cairo (struct xr_driver *xr, cairo_t *cairo)
375 {
376   int i;
377
378   xr->cairo = cairo;
379
380   cairo_set_line_width (xr->cairo, xr_to_pt (XR_LINE_WIDTH));
381
382   xr->char_width = 0;
383   xr->char_height = 0;
384   for (i = 0; i < XR_N_FONTS; i++)
385     {
386       struct xr_font *font = &xr->fonts[i];
387       int char_width, char_height;
388
389       font->layout = pango_cairo_create_layout (cairo);
390       pango_layout_set_font_description (font->layout, font->desc);
391
392       pango_layout_set_text (font->layout, "0", 1);
393       pango_layout_get_size (font->layout, &char_width, &char_height);
394       xr->char_width = MAX (xr->char_width, pango_to_xr (char_width));
395       xr->char_height = MAX (xr->char_height, pango_to_xr (char_height));
396     }
397
398   if (xr->params == NULL)
399     {
400       xr->params = xmalloc (sizeof *xr->params);
401       xr->params->draw_line = xr_draw_line;
402       xr->params->measure_cell_width = xr_measure_cell_width;
403       xr->params->measure_cell_height = xr_measure_cell_height;
404       xr->params->adjust_break = xr_adjust_break;
405       xr->params->draw_cell = xr_draw_cell;
406       xr->params->aux = xr;
407       xr->params->size[H] = xr->width;
408       xr->params->size[V] = xr->length;
409       xr->params->font_size[H] = xr->char_width;
410       xr->params->font_size[V] = xr->char_height;
411
412       int lw = XR_LINE_WIDTH;
413       int ls = XR_LINE_SPACE;
414       for (i = 0; i < TABLE_N_AXES; i++)
415         {
416           xr->params->line_widths[i][RENDER_LINE_NONE] = 0;
417           xr->params->line_widths[i][RENDER_LINE_SINGLE] = lw;
418           xr->params->line_widths[i][RENDER_LINE_DASHED] = lw;
419           xr->params->line_widths[i][RENDER_LINE_THICK] = lw * 2;
420           xr->params->line_widths[i][RENDER_LINE_THIN] = lw / 2;
421           xr->params->line_widths[i][RENDER_LINE_DOUBLE] = 2 * lw + ls;
422         }
423
424       for (i = 0; i < TABLE_N_AXES; i++)
425         xr->params->min_break[i] = xr->min_break[i];
426       xr->params->supports_margins = true;
427     }
428
429   cairo_set_source_rgb (xr->cairo, xr->fg.red, xr->fg.green, xr->fg.blue);
430
431   return true;
432 }
433
434 static struct output_driver *
435 xr_create (const char *file_name, enum settings_output_devices device_type,
436            struct string_map *o, enum xr_output_type file_type)
437 {
438   enum { MIN_WIDTH = 3, MIN_LENGTH = 3 };
439   struct xr_driver *xr;
440   cairo_surface_t *surface;
441   cairo_status_t status;
442   double width_pt, length_pt;
443
444   xr = xr_allocate (file_name, device_type, o);
445
446   width_pt = xr_to_pt (xr->width + xr->left_margin + xr->right_margin);
447   length_pt = xr_to_pt (xr->length + xr->top_margin + xr->bottom_margin);
448   if (file_type == XR_PDF)
449     surface = cairo_pdf_surface_create (file_name, width_pt, length_pt);
450   else if (file_type == XR_PS)
451     surface = cairo_ps_surface_create (file_name, width_pt, length_pt);
452   else if (file_type == XR_SVG)
453     surface = cairo_svg_surface_create (file_name, width_pt, length_pt);
454   else
455     NOT_REACHED ();
456
457   status = cairo_surface_status (surface);
458   if (status != CAIRO_STATUS_SUCCESS)
459     {
460       msg (ME, _("error opening output file `%s': %s"),
461              file_name, cairo_status_to_string (status));
462       cairo_surface_destroy (surface);
463       goto error;
464     }
465
466   xr->cairo = cairo_create (surface);
467   cairo_surface_destroy (surface);
468
469   if (!xr_set_cairo (xr, xr->cairo))
470     goto error;
471
472   cairo_save (xr->cairo);
473   xr_driver_next_page (xr, xr->cairo);
474
475   if (xr->width / xr->char_width < MIN_WIDTH)
476     {
477       msg (ME, _("The defined page is not wide enough to hold at least %d "
478                      "characters in the default font.  In fact, there's only "
479                      "room for %d characters."),
480              MIN_WIDTH,
481              xr->width / xr->char_width);
482       goto error;
483     }
484
485   if (xr->length / xr->char_height < MIN_LENGTH)
486     {
487       msg (ME, _("The defined page is not long enough to hold at least %d "
488                      "lines in the default font.  In fact, there's only "
489                      "room for %d lines."),
490              MIN_LENGTH,
491              xr->length / xr->char_height);
492       goto error;
493     }
494
495   return &xr->driver;
496
497  error:
498   output_driver_destroy (&xr->driver);
499   return NULL;
500 }
501
502 static struct output_driver *
503 xr_pdf_create (struct  file_handle *fh, enum settings_output_devices device_type,
504                struct string_map *o)
505 {
506   struct output_driver *od = xr_create (fh_get_file_name (fh), device_type, o, XR_PDF);
507   fh_unref (fh);
508   return od ;
509 }
510
511 static struct output_driver *
512 xr_ps_create (struct  file_handle *fh, enum settings_output_devices device_type,
513                struct string_map *o)
514 {
515   struct output_driver *od =  xr_create (fh_get_file_name (fh), device_type, o, XR_PS);
516   fh_unref (fh);
517   return od ;
518 }
519
520 static struct output_driver *
521 xr_svg_create (struct file_handle *fh, enum settings_output_devices device_type,
522                struct string_map *o)
523 {
524   struct output_driver *od = xr_create (fh_get_file_name (fh), device_type, o, XR_SVG);
525   fh_unref (fh);
526   return od ;
527 }
528
529 static void
530 xr_destroy (struct output_driver *driver)
531 {
532   struct xr_driver *xr = xr_driver_cast (driver);
533   size_t i;
534
535   xr_driver_destroy_fsm (xr);
536
537   if (xr->cairo != NULL)
538     {
539       cairo_status_t status;
540
541       cairo_surface_finish (cairo_get_target (xr->cairo));
542       status = cairo_status (xr->cairo);
543       if (status != CAIRO_STATUS_SUCCESS)
544         msg (ME, _("error drawing output for %s driver: %s"),
545                output_driver_get_name (driver),
546                cairo_status_to_string (status));
547       cairo_destroy (xr->cairo);
548     }
549
550   for (i = 0; i < XR_N_FONTS; i++)
551     {
552       struct xr_font *font = &xr->fonts[i];
553
554       if (font->desc != NULL)
555         pango_font_description_free (font->desc);
556       if (font->layout != NULL)
557         g_object_unref (font->layout);
558     }
559
560   free (xr->params);
561   free (xr);
562 }
563
564 static void
565 xr_flush (struct output_driver *driver)
566 {
567   struct xr_driver *xr = xr_driver_cast (driver);
568
569   cairo_surface_flush (cairo_get_target (xr->cairo));
570 }
571
572 static void
573 xr_submit (struct output_driver *driver, const struct output_item *output_item)
574 {
575   struct xr_driver *xr = xr_driver_cast (driver);
576
577   xr_driver_output_item (xr, output_item);
578   while (xr_driver_need_new_page (xr))
579     {
580       cairo_restore (xr->cairo);
581       cairo_show_page (xr->cairo);
582       cairo_save (xr->cairo);
583       xr_driver_next_page (xr, xr->cairo);
584     }
585 }
586 \f
587 /* Functions for rendering a series of output items to a series of Cairo
588    contexts, with pagination.
589
590    Used by PSPPIRE for printing, and by the basic Cairo output driver above as
591    its underlying implementation.
592
593    See the big comment in cairo.h for intended usage. */
594
595 /* Gives new page CAIRO to XR for output. */
596 void
597 xr_driver_next_page (struct xr_driver *xr, cairo_t *cairo)
598 {
599   cairo_save (cairo);
600   cairo_set_source_rgb (cairo, xr->bg.red, xr->bg.green, xr->bg.blue);
601   cairo_rectangle (cairo, 0, 0, xr->width, xr->length);
602   cairo_fill (cairo);
603   cairo_restore (cairo);
604
605   cairo_translate (cairo,
606                    xr_to_pt (xr->left_margin),
607                    xr_to_pt (xr->top_margin));
608
609   xr->page_number++;
610   xr->cairo = cairo;
611   xr->x = xr->y = 0;
612   xr_driver_run_fsm (xr);
613 }
614
615 /* Start rendering OUTPUT_ITEM to XR.  Only valid if XR is not in the middle of
616    rendering a previous output item, that is, only if xr_driver_need_new_page()
617    returns false. */
618 void
619 xr_driver_output_item (struct xr_driver *xr,
620                        const struct output_item *output_item)
621 {
622   assert (xr->fsm == NULL);
623   xr->fsm = xr_render_output_item (xr, output_item);
624   xr_driver_run_fsm (xr);
625 }
626
627 /* Returns true if XR is in the middle of rendering an output item and needs a
628    new page to be appended using xr_driver_next_page() to make progress,
629    otherwise false. */
630 bool
631 xr_driver_need_new_page (const struct xr_driver *xr)
632 {
633   return xr->fsm != NULL;
634 }
635
636 /* Returns true if the current page doesn't have any content yet. */
637 bool
638 xr_driver_is_page_blank (const struct xr_driver *xr)
639 {
640   return xr->y == 0;
641 }
642
643 static void
644 xr_driver_destroy_fsm (struct xr_driver *xr)
645 {
646   if (xr->fsm != NULL)
647     {
648       xr->fsm->destroy (xr->fsm);
649       xr->fsm = NULL;
650     }
651 }
652
653 static void
654 xr_driver_run_fsm (struct xr_driver *xr)
655 {
656   if (xr->fsm != NULL && !xr->fsm->render (xr->fsm, xr))
657     xr_driver_destroy_fsm (xr);
658 }
659 \f
660 static void
661 xr_layout_cell (struct xr_driver *, const struct table_cell *,
662                 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
663                 int *width, int *height, int *brk);
664
665 static void
666 dump_line (struct xr_driver *xr, int x0, int y0, int x1, int y1, int style,
667            const struct cell_color *color)
668 {
669   cairo_new_path (xr->cairo);
670   cairo_set_source_rgb (xr->cairo,
671                         color->r / 255.0, color->g / 255.0, color->b / 255.0);
672   cairo_set_line_width (
673     xr->cairo,
674     xr_to_pt (style == RENDER_LINE_THICK ? XR_LINE_WIDTH * 2
675               : style == RENDER_LINE_THIN ? XR_LINE_WIDTH / 2
676               : XR_LINE_WIDTH));
677   cairo_move_to (xr->cairo, xr_to_pt (x0 + xr->x), xr_to_pt (y0 + xr->y));
678   cairo_line_to (xr->cairo, xr_to_pt (x1 + xr->x), xr_to_pt (y1 + xr->y));
679   cairo_stroke (xr->cairo);
680 }
681
682 static void UNUSED
683 dump_rectangle (struct xr_driver *xr, int x0, int y0, int x1, int y1)
684 {
685   cairo_new_path (xr->cairo);
686   cairo_set_line_width (xr->cairo, xr_to_pt (XR_LINE_WIDTH));
687   cairo_move_to (xr->cairo, xr_to_pt (x0 + xr->x), xr_to_pt (y0 + xr->y));
688   cairo_line_to (xr->cairo, xr_to_pt (x1 + xr->x), xr_to_pt (y0 + xr->y));
689   cairo_line_to (xr->cairo, xr_to_pt (x1 + xr->x), xr_to_pt (y1 + xr->y));
690   cairo_line_to (xr->cairo, xr_to_pt (x0 + xr->x), xr_to_pt (y1 + xr->y));
691   cairo_close_path (xr->cairo);
692   cairo_stroke (xr->cairo);
693 }
694
695 static void
696 fill_rectangle (struct xr_driver *xr, int x0, int y0, int x1, int y1)
697 {
698   cairo_new_path (xr->cairo);
699   cairo_set_line_width (xr->cairo, xr_to_pt (XR_LINE_WIDTH));
700   cairo_rectangle (xr->cairo,
701                    xr_to_pt (x0 + xr->x), xr_to_pt (y0 + xr->y),
702                    xr_to_pt (x1 - x0), xr_to_pt (y1 - y0));
703   cairo_fill (xr->cairo);
704 }
705
706 /* Draws a horizontal line X0...X2 at Y if LEFT says so,
707    shortening it to X0...X1 if SHORTEN is true.
708    Draws a horizontal line X1...X3 at Y if RIGHT says so,
709    shortening it to X2...X3 if SHORTEN is true. */
710 static void
711 horz_line (struct xr_driver *xr, int x0, int x1, int x2, int x3, int y,
712            enum render_line_style left, enum render_line_style right,
713            const struct cell_color *left_color,
714            const struct cell_color *right_color,
715            bool shorten)
716 {
717   if (left != RENDER_LINE_NONE && right != RENDER_LINE_NONE && !shorten
718       && cell_color_equal (left_color, right_color))
719     dump_line (xr, x0, y, x3, y, left, left_color);
720   else
721     {
722       if (left != RENDER_LINE_NONE)
723         dump_line (xr, x0, y, shorten ? x1 : x2, y, left, left_color);
724       if (right != RENDER_LINE_NONE)
725         dump_line (xr, shorten ? x2 : x1, y, x3, y, right, right_color);
726     }
727 }
728
729 /* Draws a vertical line Y0...Y2 at X if TOP says so,
730    shortening it to Y0...Y1 if SHORTEN is true.
731    Draws a vertical line Y1...Y3 at X if BOTTOM says so,
732    shortening it to Y2...Y3 if SHORTEN is true. */
733 static void
734 vert_line (struct xr_driver *xr, int y0, int y1, int y2, int y3, int x,
735            enum render_line_style top, enum render_line_style bottom,
736            const struct cell_color *top_color,
737            const struct cell_color *bottom_color,
738            bool shorten)
739 {
740   if (top != RENDER_LINE_NONE && bottom != RENDER_LINE_NONE && !shorten
741       && cell_color_equal (top_color, bottom_color))
742     dump_line (xr, x, y0, x, y3, top, top_color);
743   else
744     {
745       if (top != RENDER_LINE_NONE)
746         dump_line (xr, x, y0, x, shorten ? y1 : y2, top, top_color);
747       if (bottom != RENDER_LINE_NONE)
748         dump_line (xr, x, shorten ? y2 : y1, x, y3, bottom, bottom_color);
749     }
750 }
751
752 static void
753 xr_draw_line (void *xr_, int bb[TABLE_N_AXES][2],
754               enum render_line_style styles[TABLE_N_AXES][2],
755               struct cell_color colors[TABLE_N_AXES][2])
756 {
757   const int x0 = bb[H][0];
758   const int y0 = bb[V][0];
759   const int x3 = bb[H][1];
760   const int y3 = bb[V][1];
761   const int top = styles[H][0];
762   const int bottom = styles[H][1];
763
764   int start_side = render_direction_rtl();
765   int end_side = !start_side;
766   const int start_of_line = styles[V][start_side];
767   const int end_of_line   = styles[V][end_side];
768   const struct cell_color *top_color = &colors[H][0];
769   const struct cell_color *bottom_color = &colors[H][1];
770   const struct cell_color *start_color = &colors[V][start_side];
771   const struct cell_color *end_color = &colors[V][end_side];
772
773   /* The algorithm here is somewhat subtle, to allow it to handle
774      all the kinds of intersections that we need.
775
776      Three additional ordinates are assigned along the x axis.  The
777      first is xc, midway between x0 and x3.  The others are x1 and
778      x2; for a single vertical line these are equal to xc, and for
779      a double vertical line they are the ordinates of the left and
780      right half of the double line.
781
782      yc, y1, and y2 are assigned similarly along the y axis.
783
784      The following diagram shows the coordinate system and output
785      for double top and bottom lines, single left line, and no
786      right line:
787
788                  x0       x1 xc  x2      x3
789                y0 ________________________
790                   |        #     #       |
791                   |        #     #       |
792                   |        #     #       |
793                   |        #     #       |
794                   |        #     #       |
795      y1 = y2 = yc |#########     #       |
796                   |        #     #       |
797                   |        #     #       |
798                   |        #     #       |
799                   |        #     #       |
800                y3 |________#_____#_______|
801   */
802   struct xr_driver *xr = xr_;
803
804   /* Offset from center of each line in a pair of double lines. */
805   int double_line_ofs = (XR_LINE_SPACE + XR_LINE_WIDTH) / 2;
806
807   /* Are the lines along each axis single or double?
808      (It doesn't make sense to have different kinds of line on the
809      same axis, so we don't try to gracefully handle that case.) */
810   bool double_vert = top == RENDER_LINE_DOUBLE || bottom == RENDER_LINE_DOUBLE;
811   bool double_horz = start_of_line == RENDER_LINE_DOUBLE || end_of_line == RENDER_LINE_DOUBLE;
812
813   /* When horizontal lines are doubled,
814      the left-side line along y1 normally runs from x0 to x2,
815      and the right-side line along y1 from x3 to x1.
816      If the top-side line is also doubled, we shorten the y1 lines,
817      so that the left-side line runs only to x1,
818      and the right-side line only to x2.
819      Otherwise, the horizontal line at y = y1 below would cut off
820      the intersection, which looks ugly:
821                x0       x1     x2      x3
822              y0 ________________________
823                 |        #     #       |
824                 |        #     #       |
825                 |        #     #       |
826                 |        #     #       |
827              y1 |#########     ########|
828                 |                      |
829                 |                      |
830              y2 |######################|
831                 |                      |
832                 |                      |
833              y3 |______________________|
834      It is more of a judgment call when the horizontal line is
835      single.  We actually choose to cut off the line anyhow, as
836      shown in the first diagram above.
837   */
838   bool shorten_y1_lines = top == RENDER_LINE_DOUBLE;
839   bool shorten_y2_lines = bottom == RENDER_LINE_DOUBLE;
840   bool shorten_yc_line = shorten_y1_lines && shorten_y2_lines;
841   int horz_line_ofs = double_vert ? double_line_ofs : 0;
842   int xc = (x0 + x3) / 2;
843   int x1 = xc - horz_line_ofs;
844   int x2 = xc + horz_line_ofs;
845
846   bool shorten_x1_lines = start_of_line == RENDER_LINE_DOUBLE;
847   bool shorten_x2_lines = end_of_line == RENDER_LINE_DOUBLE;
848   bool shorten_xc_line = shorten_x1_lines && shorten_x2_lines;
849   int vert_line_ofs = double_horz ? double_line_ofs : 0;
850   int yc = (y0 + y3) / 2;
851   int y1 = yc - vert_line_ofs;
852   int y2 = yc + vert_line_ofs;
853
854   if (!double_horz)
855     horz_line (xr, x0, x1, x2, x3, yc, start_of_line, end_of_line,
856                start_color, end_color, shorten_yc_line);
857   else
858     {
859       horz_line (xr, x0, x1, x2, x3, y1, start_of_line, end_of_line,
860                  start_color, end_color, shorten_y1_lines);
861       horz_line (xr, x0, x1, x2, x3, y2, start_of_line, end_of_line,
862                  start_color, end_color, shorten_y2_lines);
863     }
864
865   if (!double_vert)
866     vert_line (xr, y0, y1, y2, y3, xc, top, bottom, top_color, bottom_color,
867                shorten_xc_line);
868   else
869     {
870       vert_line (xr, y0, y1, y2, y3, x1, top, bottom, top_color, bottom_color,
871                  shorten_x1_lines);
872       vert_line (xr, y0, y1, y2, y3, x2, top, bottom, top_color, bottom_color,
873                  shorten_x2_lines);
874     }
875 }
876
877 static void
878 xr_measure_cell_width (void *xr_, const struct table_cell *cell,
879                        int *min_width, int *max_width)
880 {
881   struct xr_driver *xr = xr_;
882   int bb[TABLE_N_AXES][2];
883   int clip[TABLE_N_AXES][2];
884   int h;
885
886   bb[H][0] = 0;
887   bb[H][1] = INT_MAX;
888   bb[V][0] = 0;
889   bb[V][1] = INT_MAX;
890   clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
891   xr_layout_cell (xr, cell, bb, clip, max_width, &h, NULL);
892
893   bb[H][1] = 1;
894   xr_layout_cell (xr, cell, bb, clip, min_width, &h, NULL);
895
896   if (*min_width > 0)
897     *min_width += px_to_xr (cell->style->margin[H][0]
898                             + cell->style->margin[H][1]);
899   if (*max_width > 0)
900     *max_width += px_to_xr (cell->style->margin[H][0]
901                             + cell->style->margin[H][1]);
902 }
903
904 static int
905 xr_measure_cell_height (void *xr_, const struct table_cell *cell, int width)
906 {
907   struct xr_driver *xr = xr_;
908   int bb[TABLE_N_AXES][2];
909   int clip[TABLE_N_AXES][2];
910   int w, h;
911
912   bb[H][0] = 0;
913   bb[H][1] = width - px_to_xr (cell->style->margin[H][0]
914                                + cell->style->margin[H][1]);
915   bb[V][0] = 0;
916   bb[V][1] = INT_MAX;
917   clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
918   xr_layout_cell (xr, cell, bb, clip, &w, &h, NULL);
919   h += px_to_xr (cell->style->margin[V][0] + cell->style->margin[V][1]);
920   return h;
921 }
922
923 static void xr_clip (struct xr_driver *, int clip[TABLE_N_AXES][2]);
924
925 static void
926 xr_draw_cell (void *xr_, const struct table_cell *cell, int color_idx,
927               int bb[TABLE_N_AXES][2],
928               int spill[TABLE_N_AXES][2],
929               int clip[TABLE_N_AXES][2])
930 {
931   struct xr_driver *xr = xr_;
932   int w, h, brk;
933
934   cairo_save (xr->cairo);
935   int bg_clip[TABLE_N_AXES][2];
936   for (int axis = 0; axis < TABLE_N_AXES; axis++)
937     {
938       bg_clip[axis][0] = clip[axis][0];
939       if (bb[axis][0] == clip[axis][0])
940         bg_clip[axis][0] -= spill[axis][0];
941
942       bg_clip[axis][1] = clip[axis][1];
943       if (bb[axis][1] == clip[axis][1])
944         bg_clip[axis][1] += spill[axis][1];
945     }
946   xr_clip (xr, bg_clip);
947   cairo_set_source_rgb (xr->cairo,
948                         cell->style->bg[color_idx].r / 255.,
949                         cell->style->bg[color_idx].g / 255.,
950                         cell->style->bg[color_idx].b / 255.);
951   fill_rectangle (xr,
952                   bb[H][0] - spill[H][0],
953                   bb[V][0] - spill[V][0],
954                   bb[H][1] + spill[H][1],
955                   bb[V][1] + spill[V][1]);
956   cairo_restore (xr->cairo);
957
958   cairo_save (xr->cairo);
959   cairo_set_source_rgb (xr->cairo,
960                         cell->style->fg[color_idx].r / 255.,
961                         cell->style->fg[color_idx].g / 255.,
962                         cell->style->fg[color_idx].b / 255.);
963
964   for (int axis = 0; axis < TABLE_N_AXES; axis++)
965     {
966       bb[axis][0] += px_to_xr (cell->style->margin[axis][0]);
967       bb[axis][1] -= px_to_xr (cell->style->margin[axis][1]);
968     }
969   if (bb[H][0] < bb[H][1] && bb[V][0] < bb[V][1])
970     xr_layout_cell (xr, cell, bb, clip, &w, &h, &brk);
971   cairo_restore (xr->cairo);
972 }
973
974 static int
975 xr_adjust_break (void *xr_, const struct table_cell *cell,
976                  int width, int height)
977 {
978   struct xr_driver *xr = xr_;
979   int bb[TABLE_N_AXES][2];
980   int clip[TABLE_N_AXES][2];
981   int w, h, brk;
982
983   if (xr_measure_cell_height (xr_, cell, width) < height)
984     return -1;
985
986   bb[H][0] = 0;
987   bb[H][1] = width - px_to_xr (cell->style->margin[H][0]
988                                + cell->style->margin[H][1]);
989   if (bb[H][1] <= 0)
990     return 0;
991   bb[V][0] = 0;
992   bb[V][1] = height - px_to_xr (cell->style->margin[V][0]
993                                 + cell->style->margin[V][1]);
994   clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
995   xr_layout_cell (xr, cell, bb, clip, &w, &h, &brk);
996   return brk;
997 }
998 \f
999 static void
1000 xr_clip (struct xr_driver *xr, int clip[TABLE_N_AXES][2])
1001 {
1002   if (clip[H][1] != INT_MAX || clip[V][1] != INT_MAX)
1003     {
1004       double x0 = xr_to_pt (clip[H][0] + xr->x);
1005       double y0 = xr_to_pt (clip[V][0] + xr->y);
1006       double x1 = xr_to_pt (clip[H][1] + xr->x);
1007       double y1 = xr_to_pt (clip[V][1] + xr->y);
1008
1009       cairo_rectangle (xr->cairo, x0, y0, x1 - x0, y1 - y0);
1010       cairo_clip (xr->cairo);
1011     }
1012 }
1013
1014 static void
1015 add_attr_with_start (PangoAttrList *list, PangoAttribute *attr, guint start_index)
1016 {
1017   attr->start_index = start_index;
1018   pango_attr_list_insert (list, attr);
1019 }
1020
1021 static int
1022 xr_layout_cell_text (struct xr_driver *xr,
1023                      const struct cell_contents *contents,
1024                      const struct cell_style *style,
1025                      int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
1026                      int *widthp, int *brk)
1027 {
1028   unsigned int options = contents->options;
1029   int w, h;
1030
1031   struct xr_font *font = (options & TAB_FIX ? &xr->fonts[XR_FONT_FIXED]
1032                           : options & TAB_EMPH ? &xr->fonts[XR_FONT_EMPHASIS]
1033                           : &xr->fonts[XR_FONT_PROPORTIONAL]);
1034   struct xr_font local_font;
1035   if (style->font)
1036     {
1037       PangoFontDescription *desc = parse_font (
1038         style->font,
1039         style->font_size ? style->font_size * 1000 * 72 / 128 : 10000,
1040         style->bold, style->italic);
1041       if (desc)
1042         {
1043           PangoLayout *layout = pango_cairo_create_layout (xr->cairo);
1044           pango_layout_set_font_description (layout, desc);
1045
1046           local_font.desc = desc;
1047           local_font.layout = layout;
1048           font = &local_font;
1049         }
1050     }
1051
1052   int footnote_adjustment;
1053   if (contents->n_footnotes == 0)
1054     footnote_adjustment = 0;
1055   else if (contents->n_footnotes == 1 && (options & TAB_HALIGN) == TAB_RIGHT)
1056     {
1057       PangoAttrList *attrs;
1058
1059       const char *marker = contents->footnotes[0]->marker;
1060       pango_layout_set_text (font->layout, marker, strlen (marker));
1061
1062       attrs = pango_attr_list_new ();
1063       pango_attr_list_insert (attrs, pango_attr_rise_new (7000));
1064       pango_layout_set_attributes (font->layout, attrs);
1065       pango_attr_list_unref (attrs);
1066
1067       pango_layout_get_size (font->layout, &w, &h);
1068       footnote_adjustment = MIN (w, px_to_xr (style->margin[H][1]));
1069     }
1070   else
1071     footnote_adjustment = px_to_xr (style->margin[H][1]);
1072
1073   struct string tmp = DS_EMPTY_INITIALIZER;
1074   const char *text = contents->text;
1075
1076   /* Deal with an oddity of the Unicode line-breaking algorithm (or perhaps in
1077      Pango's implementation of it): it will break after a period or a comma
1078      that precedes a digit, e.g. in ".000" it will break after the period.
1079      This code looks for such a situation and inserts a U+2060 WORD JOINER
1080      to prevent the break.
1081
1082      This isn't necessary when the decimal point is between two digits
1083      (e.g. "0.000" won't be broken) or when the display width is not limited so
1084      that word wrapping won't happen.
1085
1086      It isn't necessary to look for more than one period or comma, as would
1087      happen with grouping like 1,234,567.89 or 1.234.567,89 because if groups
1088      are present then there will always be a digit on both sides of every
1089      period and comma. */
1090   if (bb[H][1] != INT_MAX)
1091     {
1092       const char *decimal = text + strcspn (text, ".,");
1093       if (decimal[0]
1094           && c_isdigit (decimal[1])
1095           && (decimal == text || !c_isdigit (decimal[-1])))
1096         {
1097           ds_extend (&tmp, strlen (text) + 16);
1098           ds_put_substring (&tmp, ss_buffer (text, decimal - text + 1));
1099           ds_put_unichar (&tmp, 0x2060 /* U+2060 WORD JOINER */);
1100           ds_put_cstr (&tmp, decimal + 1);
1101         }
1102     }
1103
1104   if (footnote_adjustment)
1105     {
1106       bb[H][1] += footnote_adjustment;
1107
1108       if (ds_is_empty (&tmp))
1109         {
1110           ds_extend (&tmp, strlen (text) + 16);
1111           ds_put_cstr (&tmp, text);
1112         }
1113       size_t initial_length = ds_length (&tmp);
1114
1115       cell_contents_format_footnote_markers (contents, &tmp);
1116       pango_layout_set_text (font->layout, ds_cstr (&tmp), ds_length (&tmp));
1117
1118       PangoAttrList *attrs = pango_attr_list_new ();
1119       if (style->underline)
1120         pango_attr_list_insert (attrs, pango_attr_underline_new (
1121                                PANGO_UNDERLINE_SINGLE));
1122       add_attr_with_start (attrs, pango_attr_rise_new (7000), initial_length);
1123       add_attr_with_start (
1124         attrs, pango_attr_font_desc_new (font->desc), initial_length);
1125       pango_layout_set_attributes (font->layout, attrs);
1126       pango_attr_list_unref (attrs);
1127     }
1128   else
1129     {
1130       const char *content = ds_is_empty (&tmp) ? text : ds_cstr (&tmp);
1131       pango_layout_set_text (font->layout, content, -1);
1132
1133       if (style->underline)
1134         {
1135           PangoAttrList *attrs = pango_attr_list_new ();
1136           pango_attr_list_insert (attrs, pango_attr_underline_new (
1137                                     PANGO_UNDERLINE_SINGLE));
1138           pango_layout_set_attributes (font->layout, attrs);
1139           pango_attr_list_unref (attrs);
1140         }
1141     }
1142   ds_destroy (&tmp);
1143
1144   pango_layout_set_alignment (
1145     font->layout,
1146     ((options & TAB_HALIGN) == TAB_RIGHT ? PANGO_ALIGN_RIGHT
1147      : (options & TAB_HALIGN) == TAB_LEFT ? PANGO_ALIGN_LEFT
1148      : PANGO_ALIGN_CENTER));
1149   pango_layout_set_width (
1150     font->layout,
1151     bb[H][1] == INT_MAX ? -1 : xr_to_pango (bb[H][1] - bb[H][0]));
1152   pango_layout_set_wrap (font->layout, PANGO_WRAP_WORD);
1153
1154   if (clip[H][0] != clip[H][1])
1155     {
1156       cairo_save (xr->cairo);
1157       xr_clip (xr, clip);
1158       cairo_translate (xr->cairo,
1159                        xr_to_pt (bb[H][0] + xr->x),
1160                        xr_to_pt (bb[V][0] + xr->y));
1161       pango_cairo_show_layout (xr->cairo, font->layout);
1162
1163       /* If enabled, this draws a blue rectangle around the extents of each
1164          line of text, which can be rather useful for debugging layout
1165          issues. */
1166       if (0)
1167         {
1168           PangoLayoutIter *iter;
1169           iter = pango_layout_get_iter (font->layout);
1170           do
1171             {
1172               PangoRectangle extents;
1173
1174               pango_layout_iter_get_line_extents (iter, &extents, NULL);
1175               cairo_save (xr->cairo);
1176               cairo_set_source_rgb (xr->cairo, 1, 0, 0);
1177               dump_rectangle (xr,
1178                               pango_to_xr (extents.x) - xr->x,
1179                               pango_to_xr (extents.y) - xr->y,
1180                               pango_to_xr (extents.x + extents.width) - xr->x,
1181                               pango_to_xr (extents.y + extents.height) - xr->y);
1182               cairo_restore (xr->cairo);
1183             }
1184           while (pango_layout_iter_next_line (iter));
1185           pango_layout_iter_free (iter);
1186         }
1187
1188       cairo_restore (xr->cairo);
1189     }
1190
1191   pango_layout_get_size (font->layout, &w, &h);
1192   w = pango_to_xr (w);
1193   h = pango_to_xr (h);
1194   if (w > *widthp)
1195     *widthp = w;
1196   if (bb[V][0] + h >= bb[V][1])
1197     {
1198       PangoLayoutIter *iter;
1199       int best UNUSED = 0;
1200
1201       /* Choose a breakpoint between lines instead of in the middle of one. */
1202       iter = pango_layout_get_iter (font->layout);
1203       do
1204         {
1205           PangoRectangle extents;
1206           int y0, y1;
1207           int bottom;
1208
1209           pango_layout_iter_get_line_extents (iter, NULL, &extents);
1210           pango_layout_iter_get_line_yrange (iter, &y0, &y1);
1211           extents.x = pango_to_xr (extents.x);
1212           extents.y = pango_to_xr (y0);
1213           extents.width = pango_to_xr (extents.width);
1214           extents.height = pango_to_xr (y1 - y0);
1215           bottom = bb[V][0] + extents.y + extents.height;
1216           if (bottom < bb[V][1])
1217             {
1218               if (brk && clip[H][0] != clip[H][1])
1219                 best = bottom;
1220               if (brk)
1221                 *brk = bottom;
1222             }
1223           else
1224             break;
1225         }
1226       while (pango_layout_iter_next_line (iter));
1227       pango_layout_iter_free (iter);
1228
1229       /* If enabled, draws a green line across the chosen breakpoint, which can
1230          be useful for debugging issues with breaking.  */
1231       if (0)
1232         {
1233           if (best && !xr->nest)
1234             dump_line (xr, -xr->left_margin, best,
1235                        xr->width + xr->right_margin, best,
1236                        RENDER_LINE_SINGLE, &CELL_COLOR (0, 255, 0));
1237         }
1238     }
1239
1240   pango_layout_set_attributes (font->layout, NULL);
1241
1242   if (font == &local_font)
1243     {
1244       g_object_unref (G_OBJECT (font->layout));
1245       pango_font_description_free (font->desc);
1246     }
1247
1248   return bb[V][0] + h;
1249 }
1250
1251 static void
1252 xr_layout_cell (struct xr_driver *xr, const struct table_cell *cell,
1253                 int bb_[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
1254                 int *width, int *height, int *brk)
1255 {
1256   int bb[TABLE_N_AXES][2];
1257   size_t i;
1258
1259   *width = 0;
1260   *height = 0;
1261   if (brk)
1262     *brk = 0;
1263
1264   memcpy (bb, bb_, sizeof bb);
1265
1266   /* If enabled, draws a blue rectangle around the cell extents, which can be
1267      useful for debugging layout. */
1268   if (0)
1269     {
1270       if (clip[H][0] != clip[H][1])
1271         {
1272           int offset = (xr->nest) * XR_POINT;
1273
1274           cairo_save (xr->cairo);
1275           cairo_set_source_rgb (xr->cairo, 0, 0, 1);
1276           dump_rectangle (xr,
1277                           bb[H][0] + offset, bb[V][0] + offset,
1278                           bb[H][1] - offset, bb[V][1] - offset);
1279           cairo_restore (xr->cairo);
1280         }
1281     }
1282
1283   for (i = 0; i < cell->n_contents && bb[V][0] < bb[V][1]; i++)
1284     {
1285       const struct cell_contents *contents = &cell->contents[i];
1286
1287       if (brk)
1288         *brk = bb[V][0];
1289       if (i > 0)
1290         {
1291           bb[V][0] += xr->char_height / 2;
1292           if (bb[V][0] >= bb[V][1])
1293             break;
1294           if (brk)
1295             *brk = bb[V][0];
1296         }
1297
1298       bb[V][0] = xr_layout_cell_text (xr, contents, cell->style, bb, clip,
1299                                       width, brk);
1300     }
1301   *height = bb[V][0] - bb_[V][0];
1302 }
1303 \f
1304 struct output_driver_factory pdf_driver_factory =
1305   { "pdf", "pspp.pdf", xr_pdf_create };
1306 struct output_driver_factory ps_driver_factory =
1307   { "ps", "pspp.ps", xr_ps_create };
1308 struct output_driver_factory svg_driver_factory =
1309   { "svg", "pspp.svg", xr_svg_create };
1310
1311 static const struct output_driver_class cairo_driver_class =
1312 {
1313   "cairo",
1314   xr_destroy,
1315   xr_submit,
1316   xr_flush,
1317 };
1318 \f
1319 /* GUI rendering helpers. */
1320
1321 struct xr_rendering
1322   {
1323     struct output_item *item;
1324
1325     /* Table items. */
1326     struct render_pager *p;
1327     struct xr_driver *xr;
1328   };
1329
1330 #define CHART_WIDTH 500
1331 #define CHART_HEIGHT 375
1332
1333
1334
1335 struct xr_driver *
1336 xr_driver_create (cairo_t *cairo, struct string_map *options)
1337 {
1338   struct xr_driver *xr = xr_allocate ("cairo", 0, options);
1339   if (!xr_set_cairo (xr, cairo))
1340     {
1341       output_driver_destroy (&xr->driver);
1342       return NULL;
1343     }
1344   return xr;
1345 }
1346
1347 /* Destroy XR, which should have been created with xr_driver_create().  Any
1348    cairo_t added to XR is not destroyed, because it is owned by the client. */
1349 void
1350 xr_driver_destroy (struct xr_driver *xr)
1351 {
1352   if (xr != NULL)
1353     {
1354       xr->cairo = NULL;
1355       output_driver_destroy (&xr->driver);
1356     }
1357 }
1358
1359 static struct xr_rendering *
1360 xr_rendering_create_text (struct xr_driver *xr, const char *text, cairo_t *cr)
1361 {
1362   struct table_item *table_item;
1363   struct xr_rendering *r;
1364
1365   table_item = table_item_create (table_from_string (TAB_LEFT, text),
1366                                   NULL, NULL);
1367   r = xr_rendering_create (xr, &table_item->output_item, cr);
1368   table_item_unref (table_item);
1369
1370   return r;
1371 }
1372
1373 void
1374 xr_rendering_apply_options (struct xr_rendering *xr, struct string_map *o)
1375 {
1376   if (is_table_item (xr->item))
1377     apply_options (xr->xr, o);
1378 }
1379
1380 struct xr_rendering *
1381 xr_rendering_create (struct xr_driver *xr, const struct output_item *item,
1382                      cairo_t *cr)
1383 {
1384   struct xr_rendering *r = NULL;
1385
1386   if (is_text_item (item))
1387     r = xr_rendering_create_text (xr, text_item_get_text (to_text_item (item)),
1388                                   cr);
1389   else if (is_message_item (item))
1390     {
1391       const struct message_item *message_item = to_message_item (item);
1392       char *s = msg_to_string (message_item_get_msg (message_item));
1393       r = xr_rendering_create_text (xr, s, cr);
1394       free (s);
1395     }
1396   else if (is_table_item (item))
1397     {
1398       r = xzalloc (sizeof *r);
1399       r->item = output_item_ref (item);
1400       r->xr = xr;
1401       xr_set_cairo (xr, cr);
1402       r->p = render_pager_create (xr->params, to_table_item (item));
1403     }
1404   else if (is_chart_item (item))
1405     {
1406       r = xzalloc (sizeof *r);
1407       r->item = output_item_ref (item);
1408     }
1409
1410   return r;
1411 }
1412
1413 void
1414 xr_rendering_destroy (struct xr_rendering *r)
1415 {
1416   if (r)
1417     {
1418       output_item_unref (r->item);
1419       render_pager_destroy (r->p);
1420       free (r);
1421     }
1422 }
1423
1424 void
1425 xr_rendering_measure (struct xr_rendering *r, int *w, int *h)
1426 {
1427   if (is_table_item (r->item))
1428     {
1429       *w = render_pager_get_size (r->p, H) / XR_POINT;
1430       *h = render_pager_get_size (r->p, V) / XR_POINT;
1431     }
1432   else
1433     {
1434       *w = CHART_WIDTH;
1435       *h = CHART_HEIGHT;
1436     }
1437 }
1438
1439 static void xr_draw_chart (const struct chart_item *, cairo_t *,
1440                     double x, double y, double width, double height);
1441
1442 /* Draws onto CR */
1443 void
1444 xr_rendering_draw_all (struct xr_rendering *r, cairo_t *cr)
1445 {
1446   if (is_table_item (r->item))
1447     {
1448       struct xr_driver *xr = r->xr;
1449
1450       xr_set_cairo (xr, cr);
1451
1452       render_pager_draw (r->p);
1453
1454     }
1455   else
1456     xr_draw_chart (to_chart_item (r->item), cr,
1457                    0, 0, CHART_WIDTH, CHART_HEIGHT);
1458 }
1459
1460 static void
1461 xr_draw_chart (const struct chart_item *chart_item, cairo_t *cr,
1462                double x, double y, double width, double height)
1463 {
1464   struct xrchart_geometry geom;
1465
1466   cairo_save (cr);
1467   cairo_translate (cr, x, y + height);
1468   cairo_scale (cr, 1.0, -1.0);
1469   xrchart_geometry_init (cr, &geom, width, height);
1470   if (is_boxplot (chart_item))
1471     xrchart_draw_boxplot (chart_item, cr, &geom);
1472   else if (is_histogram_chart (chart_item))
1473     xrchart_draw_histogram (chart_item, cr, &geom);
1474   else if (is_np_plot_chart (chart_item))
1475     xrchart_draw_np_plot (chart_item, cr, &geom);
1476   else if (is_piechart (chart_item))
1477     xrchart_draw_piechart (chart_item, cr, &geom);
1478   else if (is_barchart (chart_item))
1479     xrchart_draw_barchart (chart_item, cr, &geom);
1480   else if (is_roc_chart (chart_item))
1481     xrchart_draw_roc (chart_item, cr, &geom);
1482   else if (is_scree (chart_item))
1483     xrchart_draw_scree (chart_item, cr, &geom);
1484   else if (is_spreadlevel_plot_chart (chart_item))
1485     xrchart_draw_spreadlevel (chart_item, cr, &geom);
1486   else if (is_scatterplot_chart (chart_item))
1487     xrchart_draw_scatterplot (chart_item, cr, &geom);
1488   else
1489     NOT_REACHED ();
1490   xrchart_geometry_free (cr, &geom);
1491
1492   cairo_restore (cr);
1493 }
1494
1495 char *
1496 xr_draw_png_chart (const struct chart_item *item,
1497                    const char *file_name_template, int number,
1498                    const struct xr_color *fg,
1499                    const struct xr_color *bg
1500                    )
1501 {
1502   const int width = 640;
1503   const int length = 480;
1504
1505   cairo_surface_t *surface;
1506   cairo_status_t status;
1507   const char *number_pos;
1508   char *file_name;
1509   cairo_t *cr;
1510
1511   number_pos = strchr (file_name_template, '#');
1512   if (number_pos != NULL)
1513     file_name = xasprintf ("%.*s%d%s", (int) (number_pos - file_name_template),
1514                            file_name_template, number, number_pos + 1);
1515   else
1516     file_name = xstrdup (file_name_template);
1517
1518   surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, width, length);
1519   cr = cairo_create (surface);
1520
1521   cairo_set_source_rgb (cr, bg->red, bg->green, bg->blue);
1522   cairo_paint (cr);
1523
1524   cairo_set_source_rgb (cr, fg->red, fg->green, fg->blue);
1525
1526   xr_draw_chart (item, cr, 0.0, 0.0, width, length);
1527
1528   status = cairo_surface_write_to_png (surface, file_name);
1529   if (status != CAIRO_STATUS_SUCCESS)
1530     msg (ME, _("error writing output file `%s': %s"),
1531            file_name, cairo_status_to_string (status));
1532
1533   cairo_destroy (cr);
1534   cairo_surface_destroy (surface);
1535
1536   return file_name;
1537 }
1538 \f
1539 struct xr_table_state
1540   {
1541     struct xr_render_fsm fsm;
1542     struct table_item *table_item;
1543     struct render_pager *p;
1544   };
1545
1546 static bool
1547 xr_table_render (struct xr_render_fsm *fsm, struct xr_driver *xr)
1548 {
1549   struct xr_table_state *ts = UP_CAST (fsm, struct xr_table_state, fsm);
1550
1551   while (render_pager_has_next (ts->p))
1552     {
1553       int used;
1554
1555       used = render_pager_draw_next (ts->p, xr->length - xr->y);
1556       if (!used)
1557         {
1558           assert (xr->y > 0);
1559           return true;
1560         }
1561       else
1562         xr->y += used;
1563     }
1564   return false;
1565 }
1566
1567 static void
1568 xr_table_destroy (struct xr_render_fsm *fsm)
1569 {
1570   struct xr_table_state *ts = UP_CAST (fsm, struct xr_table_state, fsm);
1571
1572   table_item_unref (ts->table_item);
1573   render_pager_destroy (ts->p);
1574   free (ts);
1575 }
1576
1577 static struct xr_render_fsm *
1578 xr_render_table (struct xr_driver *xr, const struct table_item *table_item)
1579 {
1580   struct xr_table_state *ts;
1581
1582   ts = xmalloc (sizeof *ts);
1583   ts->fsm.render = xr_table_render;
1584   ts->fsm.destroy = xr_table_destroy;
1585   ts->table_item = table_item_ref (table_item);
1586
1587   if (xr->y > 0)
1588     xr->y += xr->char_height;
1589
1590   ts->p = render_pager_create (xr->params, table_item);
1591
1592   return &ts->fsm;
1593 }
1594 \f
1595 struct xr_chart_state
1596   {
1597     struct xr_render_fsm fsm;
1598     struct chart_item *chart_item;
1599   };
1600
1601 static bool
1602 xr_chart_render (struct xr_render_fsm *fsm, struct xr_driver *xr)
1603 {
1604   struct xr_chart_state *cs = UP_CAST (fsm, struct xr_chart_state, fsm);
1605
1606   const int chart_height = 0.8 * (xr->length < xr->width ? xr->length : xr->width);
1607
1608   if (xr->y > xr->length - chart_height)
1609     return true;
1610
1611   if (xr->cairo != NULL)
1612     {
1613       xr_draw_chart (cs->chart_item, xr->cairo,
1614                      0.0,
1615                      xr_to_pt (xr->y),
1616                      xr_to_pt (xr->width),
1617                      xr_to_pt (chart_height));
1618     }
1619   xr->y += chart_height;
1620
1621   return false;
1622 }
1623
1624 static void
1625 xr_chart_destroy (struct xr_render_fsm *fsm)
1626 {
1627   struct xr_chart_state *cs = UP_CAST (fsm, struct xr_chart_state, fsm);
1628
1629   chart_item_unref (cs->chart_item);
1630   free (cs);
1631 }
1632
1633 static struct xr_render_fsm *
1634 xr_render_chart (const struct chart_item *chart_item)
1635 {
1636   struct xr_chart_state *cs;
1637
1638   cs = xmalloc (sizeof *cs);
1639   cs->fsm.render = xr_chart_render;
1640   cs->fsm.destroy = xr_chart_destroy;
1641   cs->chart_item = chart_item_ref (chart_item);
1642
1643   return &cs->fsm;
1644 }
1645 \f
1646 static bool
1647 xr_eject_render (struct xr_render_fsm *fsm UNUSED, struct xr_driver *xr)
1648 {
1649   return xr->y > 0;
1650 }
1651
1652 static void
1653 xr_eject_destroy (struct xr_render_fsm *fsm UNUSED)
1654 {
1655   /* Nothing to do. */
1656 }
1657
1658 static struct xr_render_fsm *
1659 xr_render_eject (void)
1660 {
1661   static struct xr_render_fsm eject_renderer =
1662     {
1663       xr_eject_render,
1664       xr_eject_destroy
1665     };
1666
1667   return &eject_renderer;
1668 }
1669 \f
1670 static struct xr_render_fsm *
1671 xr_create_text_renderer (struct xr_driver *xr, const struct text_item *item)
1672 {
1673   struct tab_table *tab = tab_create (1, 1);
1674
1675   struct cell_style *style = pool_alloc (tab->container, sizeof *style);
1676   *style = (struct cell_style) CELL_STYLE_INITIALIZER;
1677   if (item->font)
1678     style->font = pool_strdup (tab->container, item->font);
1679   style->font_size = item->font_size;
1680   style->bold = item->bold;
1681   style->italic = item->italic;
1682   style->underline = item->underline;
1683   tab->styles[0] = style;
1684
1685   tab_text (tab, 0, 0, TAB_LEFT, text_item_get_text (item));
1686   struct table_item *table_item = table_item_create (&tab->table, NULL, NULL);
1687   struct xr_render_fsm *fsm = xr_render_table (xr, table_item);
1688   table_item_unref (table_item);
1689
1690   return fsm;
1691 }
1692
1693 static struct xr_render_fsm *
1694 xr_render_text (struct xr_driver *xr, const struct text_item *text_item)
1695 {
1696   enum text_item_type type = text_item_get_type (text_item);
1697
1698   switch (type)
1699     {
1700     case TEXT_ITEM_PAGE_TITLE:
1701       break;
1702
1703     case TEXT_ITEM_BLANK_LINE:
1704       if (xr->y > 0)
1705         xr->y += xr->char_height;
1706       break;
1707
1708     case TEXT_ITEM_EJECT_PAGE:
1709       if (xr->y > 0)
1710         return xr_render_eject ();
1711       break;
1712
1713     default:
1714       return xr_create_text_renderer (xr, text_item);
1715     }
1716
1717   return NULL;
1718 }
1719
1720 static struct xr_render_fsm *
1721 xr_render_message (struct xr_driver *xr,
1722                    const struct message_item *message_item)
1723 {
1724   char *s = msg_to_string (message_item_get_msg (message_item));
1725   struct text_item *item = text_item_create (TEXT_ITEM_PARAGRAPH, s);
1726   free (s);
1727   struct xr_render_fsm *fsm = xr_create_text_renderer (xr, item);
1728   text_item_unref (item);
1729
1730   return fsm;
1731 }
1732
1733 static struct xr_render_fsm *
1734 xr_render_output_item (struct xr_driver *xr,
1735                        const struct output_item *output_item)
1736 {
1737   if (is_table_item (output_item))
1738     return xr_render_table (xr, to_table_item (output_item));
1739   else if (is_chart_item (output_item))
1740     return xr_render_chart (to_chart_item (output_item));
1741   else if (is_text_item (output_item))
1742     return xr_render_text (xr, to_text_item (output_item));
1743   else if (is_message_item (output_item))
1744     return xr_render_message (xr, to_message_item (output_item));
1745   else
1746     return NULL;
1747 }