i18n: Only close valid iconv converters in i18n_done().
[pspp-builds.git] / 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_widthp, 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       int min_width, max_width;
482       struct table_cell cell;
483
484       xr_init_caption_cell (caption, &cell);
485
486       xr_measure_cell_width (xr, &cell, &min_width, &max_width);
487       *caption_widthp = MIN (max_width, xr->width);
488       *caption_heightp = xr_measure_cell_height (xr, &cell, *caption_widthp);
489     }
490   else
491     *caption_heightp = 0;
492
493   return render_page_create (xr->params, table_item_get_table (item));
494 }
495
496 static void
497 xr_submit (struct output_driver *driver, const struct output_item *output_item)
498 {
499   struct xr_driver *xr = xr_driver_cast (driver);
500
501   xr_driver_output_item (xr, output_item);
502   while (xr_driver_need_new_page (xr))
503     {
504       cairo_restore (xr->cairo);
505       cairo_show_page (xr->cairo);
506       cairo_save (xr->cairo);
507       xr_driver_next_page (xr, xr->cairo);
508     }
509 }
510 \f
511 /* Functions for rendering a series of output items to a series of Cairo
512    contexts, with pagination.
513
514    Used by PSPPIRE for printing, and by the basic Cairo output driver above as
515    its underlying implementation.
516
517    See the big comment in cairo.h for intended usage. */
518
519 /* Gives new page CAIRO to XR for output.  CAIRO may be null to skip actually
520    rendering the page (which might be useful to find out how many pages an
521    output document has without actually rendering it). */
522 void
523 xr_driver_next_page (struct xr_driver *xr, cairo_t *cairo)
524 {
525   if (cairo != NULL)
526     cairo_translate (cairo,
527                      xr_to_pt (xr->left_margin),
528                      xr_to_pt (xr->top_margin));
529
530   xr->page_number++;
531   xr->cairo = cairo;
532   xr->y = 0;
533   xr_driver_run_fsm (xr);
534 }
535
536 /* Start rendering OUTPUT_ITEM to XR.  Only valid if XR is not in the middle of
537    rendering a previous output item, that is, only if xr_driver_need_new_page()
538    returns false. */
539 void
540 xr_driver_output_item (struct xr_driver *xr,
541                        const struct output_item *output_item)
542 {
543   assert (xr->fsm == NULL);
544   xr->fsm = xr_render_output_item (xr, output_item);
545   xr_driver_run_fsm (xr);
546 }
547
548 /* Returns true if XR is in the middle of rendering an output item and needs a
549    new page to be appended using xr_driver_next_page() to make progress,
550    otherwise false. */
551 bool
552 xr_driver_need_new_page (const struct xr_driver *xr)
553 {
554   return xr->fsm != NULL;
555 }
556
557 /* Returns true if the current page doesn't have any content yet. */
558 bool
559 xr_driver_is_page_blank (const struct xr_driver *xr)
560 {
561   return xr->y == 0;
562 }
563
564 static void
565 xr_driver_destroy_fsm (struct xr_driver *xr)
566 {
567   if (xr->fsm != NULL)
568     {
569       xr->fsm->destroy (xr->fsm);
570       xr->fsm = NULL;
571     }
572 }
573
574 static void
575 xr_driver_run_fsm (struct xr_driver *xr)
576 {
577   if (xr->fsm != NULL && !xr->fsm->render (xr->fsm, xr))
578     xr_driver_destroy_fsm (xr);
579 }
580 \f
581 static void
582 xr_layout_cell (struct xr_driver *, const struct table_cell *,
583                 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
584                 PangoWrapMode, int *width, int *height);
585
586 static void
587 dump_line (struct xr_driver *xr, int x0, int y0, int x1, int y1)
588 {
589   cairo_new_path (xr->cairo);
590   cairo_move_to (xr->cairo, xr_to_pt (x0), xr_to_pt (y0 + xr->y));
591   cairo_line_to (xr->cairo, xr_to_pt (x1), xr_to_pt (y1 + xr->y));
592   cairo_stroke (xr->cairo);
593 }
594
595 /* Draws a horizontal line X0...X2 at Y if LEFT says so,
596    shortening it to X0...X1 if SHORTEN is true.
597    Draws a horizontal line X1...X3 at Y if RIGHT says so,
598    shortening it to X2...X3 if SHORTEN is true. */
599 static void
600 horz_line (struct xr_driver *xr, int x0, int x1, int x2, int x3, int y,
601            enum render_line_style left, enum render_line_style right,
602            bool shorten)
603 {
604   if (left != RENDER_LINE_NONE && right != RENDER_LINE_NONE && !shorten)
605     dump_line (xr, x0, y, x3, y);
606   else
607     {
608       if (left != RENDER_LINE_NONE)
609         dump_line (xr, x0, y, shorten ? x1 : x2, y);
610       if (right != RENDER_LINE_NONE)
611         dump_line (xr, shorten ? x2 : x1, y, x3, y);
612     }
613 }
614
615 /* Draws a vertical line Y0...Y2 at X if TOP says so,
616    shortening it to Y0...Y1 if SHORTEN is true.
617    Draws a vertical line Y1...Y3 at X if BOTTOM says so,
618    shortening it to Y2...Y3 if SHORTEN is true. */
619 static void
620 vert_line (struct xr_driver *xr, int y0, int y1, int y2, int y3, int x,
621            enum render_line_style top, enum render_line_style bottom,
622            bool shorten)
623 {
624   if (top != RENDER_LINE_NONE && bottom != RENDER_LINE_NONE && !shorten)
625     dump_line (xr, x, y0, x, y3);
626   else
627     {
628       if (top != RENDER_LINE_NONE)
629         dump_line (xr, x, y0, x, shorten ? y1 : y2);
630       if (bottom != RENDER_LINE_NONE)
631         dump_line (xr, x, shorten ? y2 : y1, x, y3);
632     }
633 }
634
635 static void
636 xr_draw_line (void *xr_, int bb[TABLE_N_AXES][2],
637               enum render_line_style styles[TABLE_N_AXES][2])
638 {
639   const int x0 = bb[H][0];
640   const int y0 = bb[V][0];
641   const int x3 = bb[H][1];
642   const int y3 = bb[V][1];
643   const int top = styles[H][0];
644   const int left = styles[V][0];
645   const int bottom = styles[H][1];
646   const int right = styles[V][1];
647
648   /* The algorithm here is somewhat subtle, to allow it to handle
649      all the kinds of intersections that we need.
650
651      Three additional ordinates are assigned along the x axis.  The
652      first is xc, midway between x0 and x3.  The others are x1 and
653      x2; for a single vertical line these are equal to xc, and for
654      a double vertical line they are the ordinates of the left and
655      right half of the double line.
656
657      yc, y1, and y2 are assigned similarly along the y axis.
658
659      The following diagram shows the coordinate system and output
660      for double top and bottom lines, single left line, and no
661      right line:
662
663                  x0       x1 xc  x2      x3
664                y0 ________________________
665                   |        #     #       |
666                   |        #     #       |
667                   |        #     #       |
668                   |        #     #       |
669                   |        #     #       |
670      y1 = y2 = yc |#########     #       |
671                   |        #     #       |
672                   |        #     #       |
673                   |        #     #       |
674                   |        #     #       |
675                y3 |________#_____#_______|
676   */
677   struct xr_driver *xr = xr_;
678
679   /* Offset from center of each line in a pair of double lines. */
680   int double_line_ofs = (xr->line_space + xr->line_width) / 2;
681
682   /* Are the lines along each axis single or double?
683      (It doesn't make sense to have different kinds of line on the
684      same axis, so we don't try to gracefully handle that case.) */
685   bool double_vert = top == RENDER_LINE_DOUBLE || bottom == RENDER_LINE_DOUBLE;
686   bool double_horz = left == RENDER_LINE_DOUBLE || right == RENDER_LINE_DOUBLE;
687
688   /* When horizontal lines are doubled,
689      the left-side line along y1 normally runs from x0 to x2,
690      and the right-side line along y1 from x3 to x1.
691      If the top-side line is also doubled, we shorten the y1 lines,
692      so that the left-side line runs only to x1,
693      and the right-side line only to x2.
694      Otherwise, the horizontal line at y = y1 below would cut off
695      the intersection, which looks ugly:
696                x0       x1     x2      x3
697              y0 ________________________
698                 |        #     #       |
699                 |        #     #       |
700                 |        #     #       |
701                 |        #     #       |
702              y1 |#########     ########|
703                 |                      |
704                 |                      |
705              y2 |######################|
706                 |                      |
707                 |                      |
708              y3 |______________________|
709      It is more of a judgment call when the horizontal line is
710      single.  We actually choose to cut off the line anyhow, as
711      shown in the first diagram above.
712   */
713   bool shorten_y1_lines = top == RENDER_LINE_DOUBLE;
714   bool shorten_y2_lines = bottom == RENDER_LINE_DOUBLE;
715   bool shorten_yc_line = shorten_y1_lines && shorten_y2_lines;
716   int horz_line_ofs = double_vert ? double_line_ofs : 0;
717   int xc = (x0 + x3) / 2;
718   int x1 = xc - horz_line_ofs;
719   int x2 = xc + horz_line_ofs;
720
721   bool shorten_x1_lines = left == RENDER_LINE_DOUBLE;
722   bool shorten_x2_lines = right == RENDER_LINE_DOUBLE;
723   bool shorten_xc_line = shorten_x1_lines && shorten_x2_lines;
724   int vert_line_ofs = double_horz ? double_line_ofs : 0;
725   int yc = (y0 + y3) / 2;
726   int y1 = yc - vert_line_ofs;
727   int y2 = yc + vert_line_ofs;
728
729   if (!double_horz)
730     horz_line (xr, x0, x1, x2, x3, yc, left, right, shorten_yc_line);
731   else
732     {
733       horz_line (xr, x0, x1, x2, x3, y1, left, right, shorten_y1_lines);
734       horz_line (xr, x0, x1, x2, x3, y2, left, right, shorten_y2_lines);
735     }
736
737   if (!double_vert)
738     vert_line (xr, y0, y1, y2, y3, xc, top, bottom, shorten_xc_line);
739   else
740     {
741       vert_line (xr, y0, y1, y2, y3, x1, top, bottom, shorten_x1_lines);
742       vert_line (xr, y0, y1, y2, y3, x2, top, bottom, shorten_x2_lines);
743     }
744 }
745
746 static void
747 xr_measure_cell_width (void *xr_, const struct table_cell *cell,
748                        int *min_width, int *max_width)
749 {
750   struct xr_driver *xr = xr_;
751   int bb[TABLE_N_AXES][2];
752   int clip[TABLE_N_AXES][2];
753   int h;
754
755   bb[H][0] = 0;
756   bb[H][1] = INT_MAX;
757   bb[V][0] = 0;
758   bb[V][1] = INT_MAX;
759   clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
760   xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, max_width, &h);
761
762   bb[H][1] = 1;
763   xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, min_width, &h);
764 }
765
766 static int
767 xr_measure_cell_height (void *xr_, const struct table_cell *cell, int width)
768 {
769   struct xr_driver *xr = xr_;
770   int bb[TABLE_N_AXES][2];
771   int clip[TABLE_N_AXES][2];
772   int w, h;
773
774   bb[H][0] = 0;
775   bb[H][1] = width;
776   bb[V][0] = 0;
777   bb[V][1] = INT_MAX;
778   clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
779   xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, &w, &h);
780   return h;
781 }
782
783 static void
784 xr_draw_cell (void *xr_, const struct table_cell *cell,
785               int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2])
786 {
787   struct xr_driver *xr = xr_;
788   int w, h;
789
790   xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, &w, &h);
791 }
792 \f
793 static void
794 xr_layout_cell (struct xr_driver *xr, const struct table_cell *cell,
795                 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
796                 PangoWrapMode wrap, int *width, int *height)
797 {
798   struct xr_font *font;
799
800   font = (cell->options & TAB_FIX ? &xr->fonts[XR_FONT_FIXED]
801           : cell->options & TAB_EMPH ? &xr->fonts[XR_FONT_EMPHASIS]
802           : &xr->fonts[XR_FONT_PROPORTIONAL]);
803
804   pango_layout_set_text (font->layout, cell->contents, -1);
805
806   pango_layout_set_alignment (
807     font->layout,
808     ((cell->options & TAB_ALIGNMENT) == TAB_RIGHT ? PANGO_ALIGN_RIGHT
809      : (cell->options & TAB_ALIGNMENT) == TAB_LEFT ? PANGO_ALIGN_LEFT
810      : PANGO_ALIGN_CENTER));
811   pango_layout_set_width (font->layout,
812                           bb[H][1] == INT_MAX ? -1 : bb[H][1] - bb[H][0]);
813   pango_layout_set_wrap (font->layout, wrap);
814
815   if (clip[H][0] != clip[H][1])
816     {
817       cairo_save (xr->cairo);
818
819       if (clip[H][1] != INT_MAX || clip[V][1] != INT_MAX)
820         {
821           double x0 = xr_to_pt (clip[H][0]);
822           double y0 = xr_to_pt (clip[V][0] + xr->y);
823           double x1 = xr_to_pt (clip[H][1]);
824           double y1 = xr_to_pt (clip[V][1] + xr->y);
825
826           cairo_rectangle (xr->cairo, x0, y0, x1 - x0, y1 - y0);
827           cairo_clip (xr->cairo);
828         }
829
830       cairo_translate (xr->cairo,
831                        xr_to_pt (bb[H][0]),
832                        xr_to_pt (bb[V][0] + xr->y));
833       pango_cairo_show_layout (xr->cairo, font->layout);
834       cairo_restore (xr->cairo);
835     }
836
837   if (width != NULL || height != NULL)
838     {
839       int w, h;
840
841       pango_layout_get_size (font->layout, &w, &h);
842       if (width != NULL)
843         *width = w;
844       if (height != NULL)
845         *height = h;
846     }
847 }
848
849 static void
850 xr_draw_title (struct xr_driver *xr, const char *title,
851                int title_width, int title_height)
852 {
853   struct table_cell cell;
854   int bb[TABLE_N_AXES][2];
855
856   xr_init_caption_cell (title, &cell);
857   bb[H][0] = 0;
858   bb[H][1] = title_width;
859   bb[V][0] = 0;
860   bb[V][1] = title_height;
861   xr_draw_cell (xr, &cell, bb, bb);
862 }
863 \f
864 struct output_driver_factory pdf_driver_factory = { "pdf", xr_pdf_create };
865 struct output_driver_factory ps_driver_factory = { "ps", xr_ps_create };
866 struct output_driver_factory svg_driver_factory = { "svg", xr_svg_create };
867
868 static const struct output_driver_class cairo_driver_class =
869 {
870   "cairo",
871   xr_destroy,
872   xr_submit,
873   xr_flush,
874 };
875 \f
876 /* GUI rendering helpers. */
877
878 struct xr_rendering
879   {
880     struct output_item *item;
881
882     /* Table items. */
883     struct render_page *page;
884     struct xr_driver *xr;
885     int title_width;
886     int title_height;
887   };
888
889 #define CHART_WIDTH 500
890 #define CHART_HEIGHT 375
891
892 struct xr_driver *
893 xr_driver_create (cairo_t *cairo, struct string_map *options)
894 {
895   struct xr_driver *xr = xr_allocate ("cairo", 0, options);
896   if (!xr_set_cairo (xr, cairo))
897     {
898       output_driver_destroy (&xr->driver);
899       return NULL;
900     }
901   return xr;
902 }
903
904 /* Destroy XR, which should have been created with xr_driver_create().  Any
905    cairo_t added to XR is not destroyed, because it is owned by the client. */
906 void
907 xr_driver_destroy (struct xr_driver *xr)
908 {
909   if (xr != NULL)
910     {
911       xr->cairo = NULL;
912       output_driver_destroy (&xr->driver);
913     }
914 }
915
916 static struct xr_rendering *
917 xr_rendering_create_text (struct xr_driver *xr, const char *text, cairo_t *cr)
918 {
919   struct table_item *table_item;
920   struct xr_rendering *r;
921
922   table_item = table_item_create (table_from_string (0, text), NULL);
923   r = xr_rendering_create (xr, &table_item->output_item, cr);
924   table_item_unref (table_item);
925
926   return r;
927 }
928
929 struct xr_rendering *
930 xr_rendering_create (struct xr_driver *xr, const struct output_item *item,
931                      cairo_t *cr)
932 {
933   struct xr_rendering *r = NULL;
934
935   if (is_text_item (item))
936     r = xr_rendering_create_text (xr, text_item_get_text (to_text_item (item)),
937                                   cr);
938   else if (is_message_item (item))
939     {
940       const struct message_item *message_item = to_message_item (item);
941       const struct msg *msg = message_item_get_msg (message_item);
942       char *s = msg_to_string (msg, NULL);
943       r = xr_rendering_create_text (xr, s, cr);
944       free (s);
945     }
946   else if (is_table_item (item))
947     {
948       r = xzalloc (sizeof *r);
949       r->item = output_item_ref (item);
950       r->xr = xr;
951       xr_set_cairo (xr, cr);
952       r->page = xr_render_table_item (xr, to_table_item (item),
953                                       &r->title_width, &r->title_height);
954     }
955   else if (is_chart_item (item))
956     {
957       r = xzalloc (sizeof *r);
958       r->item = output_item_ref (item);
959     }
960
961   return r;
962 }
963
964 void
965 xr_rendering_measure (struct xr_rendering *r, int *w, int *h)
966 {
967   if (is_table_item (r->item))
968     {
969       int w0 = render_page_get_size (r->page, H);
970       int w1 = r->title_width;
971       *w = MAX (w0, w1) / 1024;
972       *h = (render_page_get_size (r->page, V) + r->title_height) / 1024;
973     }
974   else
975     {
976       *w = CHART_WIDTH;
977       *h = CHART_HEIGHT;
978     }
979 }
980
981 /* Draws onto CR at least the region of R that is enclosed in (X,Y)-(X+W,Y+H),
982    and possibly some additional parts. */
983 void
984 xr_rendering_draw (struct xr_rendering *r, cairo_t *cr,
985                    int x, int y, int w, int h)
986 {
987   if (is_table_item (r->item))
988     {
989       struct xr_driver *xr = r->xr;
990
991       xr_set_cairo (xr, cr);
992
993       if (r->title_height > 0)
994         {
995           xr->y = 0;
996           xr_draw_title (xr, table_item_get_caption (to_table_item (r->item)),
997                          r->title_width, r->title_height);
998         }
999
1000       xr->y = r->title_height;
1001       render_page_draw_region (r->page,
1002                                x * 1024, y * 1024, w * 1024, h * 1024);
1003     }
1004   else
1005     xr_draw_chart (to_chart_item (r->item), cr,
1006                    0, 0, CHART_WIDTH, CHART_HEIGHT);
1007 }
1008
1009 void
1010 xr_draw_chart (const struct chart_item *chart_item, cairo_t *cr,
1011                double x, double y, double width, double height)
1012 {
1013   struct xrchart_geometry geom;
1014
1015   cairo_save (cr);
1016   cairo_translate (cr, x, y + height);
1017   cairo_scale (cr, 1.0, -1.0);
1018   xrchart_geometry_init (cr, &geom, width, height);
1019   if (is_boxplot (chart_item))
1020     xrchart_draw_boxplot (chart_item, cr, &geom);
1021   else if (is_histogram_chart (chart_item))
1022     xrchart_draw_histogram (chart_item, cr, &geom);
1023   else if (is_np_plot_chart (chart_item))
1024     xrchart_draw_np_plot (chart_item, cr, &geom);
1025   else if (is_piechart (chart_item))
1026     xrchart_draw_piechart (chart_item, cr, &geom);
1027   else if (is_roc_chart (chart_item))
1028     xrchart_draw_roc (chart_item, cr, &geom);
1029   else if (is_scree (chart_item))
1030     xrchart_draw_scree (chart_item, cr, &geom);
1031   else
1032     NOT_REACHED ();
1033   xrchart_geometry_free (cr, &geom);
1034
1035   cairo_restore (cr);
1036 }
1037
1038 char *
1039 xr_draw_png_chart (const struct chart_item *item,
1040                    const char *file_name_template, int number)
1041 {
1042   const int width = 640;
1043   const int length = 480;
1044
1045   cairo_surface_t *surface;
1046   cairo_status_t status;
1047   const char *number_pos;
1048   char *file_name;
1049   cairo_t *cr;
1050
1051   number_pos = strchr (file_name_template, '#');
1052   if (number_pos != NULL)
1053     file_name = xasprintf ("%.*s%d%s", (int) (number_pos - file_name_template),
1054                            file_name_template, number, number_pos + 1);
1055   else
1056     file_name = xstrdup (file_name_template);
1057
1058   surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, width, length);
1059   cr = cairo_create (surface);
1060
1061   cairo_save (cr);
1062   cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
1063   cairo_rectangle (cr, 0, 0, width, length);
1064   cairo_fill (cr);
1065   cairo_restore (cr);
1066
1067   cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
1068
1069   xr_draw_chart (item, cr, 0.0, 0.0, width, length);
1070
1071   status = cairo_surface_write_to_png (surface, file_name);
1072   if (status != CAIRO_STATUS_SUCCESS)
1073     error (0, 0, _("error writing output file `%s': %s"),
1074            file_name, cairo_status_to_string (status));
1075
1076   cairo_destroy (cr);
1077   cairo_surface_destroy (surface);
1078
1079   return file_name;
1080 }
1081 \f
1082 struct xr_table_state
1083   {
1084     struct xr_render_fsm fsm;
1085     struct table_item *table_item;
1086     struct render_break x_break;
1087     struct render_break y_break;
1088     int caption_height;
1089   };
1090
1091 static bool
1092 xr_table_render (struct xr_render_fsm *fsm, struct xr_driver *xr)
1093 {
1094   struct xr_table_state *ts = UP_CAST (fsm, struct xr_table_state, fsm);
1095
1096   for (;;)
1097     {
1098       struct render_page *y_slice;
1099       int space;
1100
1101       while (!render_break_has_next (&ts->y_break))
1102         {
1103           struct render_page *x_slice;
1104
1105           render_break_destroy (&ts->y_break);
1106           if (!render_break_has_next (&ts->x_break))
1107             return false;
1108
1109           x_slice = render_break_next (&ts->x_break, xr->width);
1110           render_break_init (&ts->y_break, x_slice, V);
1111         }
1112
1113       space = xr->length - xr->y;
1114       if (render_break_next_size (&ts->y_break) > space)
1115         {
1116           assert (xr->y > 0);
1117           return true;
1118         }
1119
1120       y_slice = render_break_next (&ts->y_break, space);
1121       if (ts->caption_height)
1122         {
1123           if (xr->cairo)
1124             xr_draw_title (xr, table_item_get_caption (ts->table_item),
1125                            xr->width, ts->caption_height);
1126
1127           xr->y += ts->caption_height;
1128           ts->caption_height = 0;
1129         }
1130
1131       if (xr->cairo)
1132         render_page_draw (y_slice);
1133       xr->y += render_page_get_size (y_slice, V);
1134       render_page_unref (y_slice);
1135     }
1136 }
1137
1138 static void
1139 xr_table_destroy (struct xr_render_fsm *fsm)
1140 {
1141   struct xr_table_state *ts = UP_CAST (fsm, struct xr_table_state, fsm);
1142
1143   table_item_unref (ts->table_item);
1144   render_break_destroy (&ts->x_break);
1145   render_break_destroy (&ts->y_break);
1146   free (ts);
1147 }
1148
1149 static struct xr_render_fsm *
1150 xr_render_table (struct xr_driver *xr, const struct table_item *table_item)
1151 {
1152   struct xr_table_state *ts;
1153   struct render_page *page;
1154   int caption_width;
1155
1156   ts = xmalloc (sizeof *ts);
1157   ts->fsm.render = xr_table_render;
1158   ts->fsm.destroy = xr_table_destroy;
1159   ts->table_item = table_item_ref (table_item);
1160
1161   if (xr->y > 0)
1162     xr->y += xr->char_height;
1163
1164   page = xr_render_table_item (xr, table_item,
1165                                &caption_width, &ts->caption_height);
1166   xr->params->size[V] = xr->length - ts->caption_height;
1167
1168   render_break_init (&ts->x_break, page, H);
1169   render_break_init_empty (&ts->y_break);
1170
1171   return &ts->fsm;
1172 }
1173 \f
1174 struct xr_chart_state
1175   {
1176     struct xr_render_fsm fsm;
1177     struct chart_item *chart_item;
1178   };
1179
1180 static bool
1181 xr_chart_render (struct xr_render_fsm *fsm, struct xr_driver *xr)
1182 {
1183   struct xr_chart_state *cs = UP_CAST (fsm, struct xr_chart_state, fsm);
1184
1185   if (xr->y > 0)
1186     return true;
1187
1188   if (xr->cairo != NULL)
1189     xr_draw_chart (cs->chart_item, xr->cairo, 0.0, 0.0,
1190                    xr_to_pt (xr->width), xr_to_pt (xr->length));
1191   xr->y = xr->length;
1192
1193   return false;
1194 }
1195
1196 static void
1197 xr_chart_destroy (struct xr_render_fsm *fsm)
1198 {
1199   struct xr_chart_state *cs = UP_CAST (fsm, struct xr_chart_state, fsm);
1200
1201   chart_item_unref (cs->chart_item);
1202   free (cs);
1203 }
1204
1205 static struct xr_render_fsm *
1206 xr_render_chart (const struct chart_item *chart_item)
1207 {
1208   struct xr_chart_state *cs;
1209
1210   cs = xmalloc (sizeof *cs);
1211   cs->fsm.render = xr_chart_render;
1212   cs->fsm.destroy = xr_chart_destroy;
1213   cs->chart_item = chart_item_ref (chart_item);
1214
1215   return &cs->fsm;
1216 }
1217 \f
1218 static bool
1219 xr_eject_render (struct xr_render_fsm *fsm UNUSED, struct xr_driver *xr)
1220 {
1221   return xr->y > 0;
1222 }
1223
1224 static void
1225 xr_eject_destroy (struct xr_render_fsm *fsm UNUSED)
1226 {
1227   /* Nothing to do. */
1228 }
1229
1230 static struct xr_render_fsm *
1231 xr_render_eject (void)
1232 {
1233   static struct xr_render_fsm eject_renderer =
1234     {
1235       xr_eject_render,
1236       xr_eject_destroy
1237     };
1238
1239   return &eject_renderer;
1240 }
1241 \f
1242 static struct xr_render_fsm *
1243 xr_create_text_renderer (struct xr_driver *xr, const char *text)
1244 {
1245   struct table_item *table_item;
1246   struct xr_render_fsm *fsm;
1247
1248   table_item = table_item_create (table_from_string (TAB_LEFT, text), NULL);
1249   fsm = xr_render_table (xr, table_item);
1250   table_item_unref (table_item);
1251
1252   return fsm;
1253 }
1254
1255 static struct xr_render_fsm *
1256 xr_render_text (struct xr_driver *xr, const struct text_item *text_item)
1257 {
1258   enum text_item_type type = text_item_get_type (text_item);
1259   const char *text = text_item_get_text (text_item);
1260
1261   switch (type)
1262     {
1263     case TEXT_ITEM_TITLE:
1264       free (xr->title);
1265       xr->title = xstrdup (text);
1266       break;
1267
1268     case TEXT_ITEM_SUBTITLE:
1269       free (xr->subtitle);
1270       xr->subtitle = xstrdup (text);
1271       break;
1272
1273     case TEXT_ITEM_COMMAND_CLOSE:
1274       break;
1275
1276     case TEXT_ITEM_BLANK_LINE:
1277       if (xr->y > 0)
1278         xr->y += xr->char_height;
1279       break;
1280
1281     case TEXT_ITEM_EJECT_PAGE:
1282       if (xr->y > 0)
1283         return xr_render_eject ();
1284       break;
1285
1286     default:
1287       return xr_create_text_renderer (xr, text);
1288     }
1289
1290   return NULL;
1291 }
1292
1293 static struct xr_render_fsm *
1294 xr_render_message (struct xr_driver *xr,
1295                    const struct message_item *message_item)
1296 {
1297   const struct msg *msg = message_item_get_msg (message_item);
1298   struct xr_render_fsm *fsm;
1299   char *s;
1300
1301   s = msg_to_string (msg, xr->command_name);
1302   fsm = xr_create_text_renderer (xr, s);
1303   free (s);
1304
1305   return fsm;
1306 }
1307
1308 static struct xr_render_fsm *
1309 xr_render_output_item (struct xr_driver *xr,
1310                        const struct output_item *output_item)
1311 {
1312   if (is_table_item (output_item))
1313     return xr_render_table (xr, to_table_item (output_item));
1314   else if (is_chart_item (output_item))
1315     return xr_render_chart (to_chart_item (output_item));
1316   else if (is_text_item (output_item))
1317     return xr_render_text (xr, to_text_item (output_item));
1318   else if (is_message_item (output_item))
1319     return xr_render_message (xr, to_message_item (output_item));
1320   else
1321     return NULL;
1322 }