1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 2009, 2010 Free Software Foundation, Inc.
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.
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.
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/>. */
19 #include <output/cairo.h>
21 #include <libpspp/assertion.h>
22 #include <libpspp/cast.h>
23 #include <libpspp/start-date.h>
24 #include <libpspp/str.h>
25 #include <libpspp/string-map.h>
26 #include <libpspp/version.h>
27 #include <output/cairo-chart.h>
28 #include <output/chart-item-provider.h>
29 #include <output/charts/boxplot.h>
30 #include <output/charts/np-plot.h>
31 #include <output/charts/piechart.h>
32 #include <output/charts/plot-hist.h>
33 #include <output/charts/roc-chart.h>
34 #include <output/charts/scree.h>
35 #include <output/driver-provider.h>
36 #include <output/options.h>
37 #include <output/render.h>
38 #include <output/tab.h>
39 #include <output/table-item.h>
40 #include <output/table.h>
41 #include <output/text-item.h>
43 #include <cairo/cairo-pdf.h>
44 #include <cairo/cairo-ps.h>
45 #include <cairo/cairo-svg.h>
46 #include <cairo/cairo.h>
47 #include <pango/pango-font.h>
48 #include <pango/pango-layout.h>
49 #include <pango/pango.h>
50 #include <pango/pangocairo.h>
59 #define _(msgid) gettext (msgid)
61 /* This file uses TABLE_HORZ and TABLE_VERT enough to warrant abbreviating. */
65 /* Measurements as we present to the rest of PSPP. */
66 #define XR_POINT PANGO_SCALE
67 #define XR_INCH (XR_POINT * 72)
69 /* Conversions to and from points. */
73 return x / (double) XR_POINT;
93 /* A font for use with Cairo. */
97 PangoFontDescription *desc;
99 PangoFontMetrics *metrics;
102 /* Cairo output driver. */
105 struct output_driver driver;
107 /* User parameters. */
108 bool headers; /* Draw headers at top of page? */
110 struct xr_font fonts[XR_N_FONTS];
111 int font_height; /* In XR units. */
113 int width; /* Page width minus margins. */
114 int length; /* Page length minus margins and header. */
116 int left_margin; /* Left margin in XR units. */
117 int right_margin; /* Right margin in XR units. */
118 int top_margin; /* Top margin in XR units. */
119 int bottom_margin; /* Bottom margin in XR units. */
121 int line_gutter; /* Space around lines. */
122 int line_space; /* Space between lines. */
123 int line_width; /* Width of lines. */
125 enum xr_output_type file_type; /* Type of output file. */
127 /* Internal state. */
128 struct render_params *params;
132 int page_number; /* Current page number. */
136 static const struct output_driver_class cairo_driver_class;
138 static void xr_show_page (struct xr_driver *);
139 static void draw_headers (struct xr_driver *);
141 static bool load_font (struct xr_driver *, struct xr_font *);
142 static void free_font (struct xr_font *);
144 static void xr_draw_line (void *, int bb[TABLE_N_AXES][2],
145 enum render_line_style styles[TABLE_N_AXES][2]);
146 static void xr_measure_cell_width (void *, const struct table_cell *,
148 static int xr_measure_cell_height (void *, const struct table_cell *,
150 static void xr_draw_cell (void *, const struct table_cell *,
151 int bb[TABLE_N_AXES][2],
152 int clip[TABLE_N_AXES][2]);
154 /* Driver initialization. */
156 static struct xr_driver *
157 xr_driver_cast (struct output_driver *driver)
159 assert (driver->class == &cairo_driver_class);
160 return UP_CAST (driver, struct xr_driver, driver);
163 static struct driver_option *
164 opt (struct output_driver *d, struct string_map *options, const char *key,
165 const char *default_value)
167 return driver_option_get (d, options, key, default_value);
170 static struct xr_driver *
171 xr_allocate (const char *name, int device_type, struct string_map *o)
173 struct output_driver *d;
174 struct xr_driver *xr;
176 xr = xzalloc (sizeof *xr);
178 output_driver_init (d, &cairo_driver_class, name, device_type);
180 xr->font_height = XR_POINT * 10;
181 xr->fonts[XR_FONT_FIXED].string
182 = parse_string (opt (d, o, "fixed-font", "monospace"));
183 xr->fonts[XR_FONT_PROPORTIONAL].string
184 = parse_string (opt (d, o, "prop-font", "serif"));
185 xr->fonts[XR_FONT_EMPHASIS].string
186 = parse_string (opt (d, o, "emph-font", "serif italic"));
187 xr->line_gutter = XR_POINT;
188 xr->line_space = XR_POINT;
189 xr->line_width = XR_POINT / 2;
196 xr_set_cairo (struct xr_driver *xr, cairo_t *cairo)
202 cairo_set_line_width (xr->cairo, xr_to_pt (xr->line_width));
204 for (i = 0; i < XR_N_FONTS; i++)
205 if (!load_font (xr, &xr->fonts[i]))
208 if (xr->params == NULL)
210 int single_width, double_width;
212 xr->params = xmalloc (sizeof *xr->params);
213 xr->params->draw_line = xr_draw_line;
214 xr->params->measure_cell_width = xr_measure_cell_width;
215 xr->params->measure_cell_height = xr_measure_cell_height;
216 xr->params->draw_cell = xr_draw_cell;
217 xr->params->aux = xr;
218 xr->params->size[H] = xr->width;
219 xr->params->size[V] = xr->length;
220 xr->params->font_size[H] = xr->font_height / 2; /* XXX */
221 xr->params->font_size[V] = xr->font_height;
223 single_width = 2 * xr->line_gutter + xr->line_width;
224 double_width = 2 * xr->line_gutter + xr->line_space + 2 * xr->line_width;
225 for (i = 0; i < TABLE_N_AXES; i++)
227 xr->params->line_widths[i][RENDER_LINE_NONE] = 0;
228 xr->params->line_widths[i][RENDER_LINE_SINGLE] = single_width;
229 xr->params->line_widths[i][RENDER_LINE_DOUBLE] = double_width;
236 static struct output_driver *
237 xr_create (const char *file_name, enum settings_output_devices device_type,
238 struct string_map *o, enum xr_output_type file_type)
240 enum { MIN_WIDTH = 3, MIN_LENGTH = 3 };
241 struct output_driver *d;
242 struct xr_driver *xr;
243 cairo_surface_t *surface;
244 cairo_status_t status;
245 double width_pt, length_pt;
246 int paper_width, paper_length;
248 xr = xr_allocate (file_name, device_type, o);
251 xr->headers = parse_boolean (opt (d, o, "headers", "true"));
253 xr->file_type = file_type;
255 parse_paper_size (opt (d, o, "paper-size", ""), &paper_width, &paper_length);
256 xr->left_margin = parse_dimension (opt (d, o, "left-margin", ".5in"));
257 xr->right_margin = parse_dimension (opt (d, o, "right-margin", ".5in"));
258 xr->top_margin = parse_dimension (opt (d, o, "top-margin", ".5in"));
259 xr->bottom_margin = parse_dimension (opt (d, o, "bottom-margin", ".5in"));
262 xr->top_margin += 3 * xr->font_height;
263 xr->width = paper_width - xr->left_margin - xr->right_margin;
264 xr->length = paper_length - xr->top_margin - xr->bottom_margin;
266 width_pt = paper_width / 1000.0;
267 length_pt = paper_length / 1000.0;
268 if (xr->file_type == XR_PDF)
269 surface = cairo_pdf_surface_create (file_name, width_pt, length_pt);
270 else if (xr->file_type == XR_PS)
271 surface = cairo_ps_surface_create (file_name, width_pt, length_pt);
272 else if (xr->file_type == XR_SVG)
273 surface = cairo_svg_surface_create (file_name, width_pt, length_pt);
277 status = cairo_surface_status (surface);
278 if (status != CAIRO_STATUS_SUCCESS)
280 error (0, 0, _("opening output file \"%s\": %s"),
281 file_name, cairo_status_to_string (status));
282 cairo_surface_destroy (surface);
286 xr->cairo = cairo_create (surface);
287 cairo_surface_destroy (surface);
289 cairo_translate (xr->cairo,
290 xr_to_pt (xr->left_margin),
291 xr_to_pt (xr->top_margin));
293 if (!xr_set_cairo (xr, xr->cairo))
296 if (xr->width / (xr->font_height / 2) < MIN_WIDTH)
298 error (0, 0, _("The defined page is not wide enough to hold at least %d "
299 "characters in the default font. In fact, there's only "
300 "room for %d characters."),
302 xr->width / (xr->font_height / 2));
306 if (xr->length / xr->font_height < MIN_LENGTH)
308 error (0, 0, _("The defined page is not long "
309 "enough to hold margins and headers, plus least %d "
310 "lines of the default fonts. In fact, there's only "
311 "room for %d lines."),
313 xr->length / xr->font_height);
320 output_driver_destroy (&xr->driver);
324 static struct output_driver *
325 xr_pdf_create (const char *file_name, enum settings_output_devices device_type,
326 struct string_map *o)
328 return xr_create (file_name, device_type, o, XR_PDF);
331 static struct output_driver *
332 xr_ps_create (const char *file_name, enum settings_output_devices device_type,
333 struct string_map *o)
335 return xr_create (file_name, device_type, o, XR_PS);
338 static struct output_driver *
339 xr_svg_create (const char *file_name, enum settings_output_devices device_type,
340 struct string_map *o)
342 return xr_create (file_name, device_type, o, XR_SVG);
346 xr_destroy (struct output_driver *driver)
348 struct xr_driver *xr = xr_driver_cast (driver);
351 if (xr->cairo != NULL)
353 cairo_status_t status;
358 cairo_surface_finish (cairo_get_target (xr->cairo));
359 status = cairo_status (xr->cairo);
360 if (status != CAIRO_STATUS_SUCCESS)
361 error (0, 0, _("error drawing output for %s driver: %s"),
362 output_driver_get_name (driver),
363 cairo_status_to_string (status));
364 cairo_destroy (xr->cairo);
367 for (i = 0; i < XR_N_FONTS; i++)
368 free_font (&xr->fonts[i]);
374 xr_flush (struct output_driver *driver)
376 struct xr_driver *xr = xr_driver_cast (driver);
378 cairo_surface_flush (cairo_get_target (xr->cairo));
382 xr_init_caption_cell (const char *caption, struct table_cell *cell)
384 cell->contents = caption;
385 cell->options = TAB_LEFT;
386 cell->destructor = NULL;
389 static struct render_page *
390 xr_render_table_item (struct xr_driver *xr, const struct table_item *item,
391 int *caption_heightp)
393 const char *caption = table_item_get_caption (item);
397 /* XXX doesn't do well with very large captions */
398 struct table_cell cell;
399 xr_init_caption_cell (caption, &cell);
400 *caption_heightp = xr_measure_cell_height (xr, &cell, xr->width);
403 *caption_heightp = 0;
405 return render_page_create (xr->params, table_item_get_table (item));
409 xr_submit (struct output_driver *driver, const struct output_item *output_item)
411 struct xr_driver *xr = xr_driver_cast (driver);
412 if (is_table_item (output_item))
414 struct table_item *table_item = to_table_item (output_item);
415 struct render_break x_break;
416 struct render_page *page;
420 xr->y += xr->font_height;
422 page = xr_render_table_item (xr, table_item, &caption_height);
423 xr->params->size[V] = xr->length - caption_height;
424 for (render_break_init (&x_break, page, H);
425 render_break_has_next (&x_break); )
427 struct render_page *x_slice;
428 struct render_break y_break;
430 x_slice = render_break_next (&x_break, xr->width);
431 for (render_break_init (&y_break, x_slice, V);
432 render_break_has_next (&y_break); )
434 int space = xr->length - xr->y;
435 struct render_page *y_slice;
437 /* XXX doesn't allow for caption or space between segments */
438 if (render_break_next_size (&y_break) > space)
445 y_slice = render_break_next (&y_break, space);
448 struct table_cell cell;
449 int bb[TABLE_N_AXES][2];
451 xr_init_caption_cell (table_item_get_caption (table_item),
454 bb[H][1] = xr->width;
456 bb[V][1] = caption_height;
457 xr_draw_cell (xr, &cell, bb, bb);
458 xr->y += caption_height;
462 render_page_draw (y_slice);
463 xr->y += render_page_get_size (y_slice, V);
464 render_page_unref (y_slice);
466 render_break_destroy (&y_break);
468 render_break_destroy (&x_break);
470 else if (is_chart_item (output_item))
474 xr_draw_chart (to_chart_item (output_item), xr->cairo, 0.0, 0.0,
475 xr_to_pt (xr->width), xr_to_pt (xr->length));
478 else if (is_text_item (output_item))
480 const struct text_item *text_item = to_text_item (output_item);
481 enum text_item_type type = text_item_get_type (text_item);
482 const char *text = text_item_get_text (text_item);
486 case TEXT_ITEM_TITLE:
488 xr->title = xstrdup (text);
491 case TEXT_ITEM_SUBTITLE:
493 xr->subtitle = xstrdup (text);
496 case TEXT_ITEM_COMMAND_CLOSE:
499 case TEXT_ITEM_BLANK_LINE:
501 xr->y += xr->font_height;
504 case TEXT_ITEM_EJECT_PAGE:
511 struct table_item *item;
513 item = table_item_create (table_from_string (TAB_LEFT, text),
515 xr_submit (&xr->driver, &item->output_item);
516 table_item_unref (item);
525 xr_show_page (struct xr_driver *xr)
532 cairo_show_page (xr->cairo);
539 xr_layout_cell (struct xr_driver *, const struct table_cell *,
540 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
541 PangoWrapMode, int *width, int *height);
544 dump_line (struct xr_driver *xr, int x0, int y0, int x1, int y1)
546 cairo_new_path (xr->cairo);
547 cairo_move_to (xr->cairo, xr_to_pt (x0), xr_to_pt (y0 + xr->y));
548 cairo_line_to (xr->cairo, xr_to_pt (x1), xr_to_pt (y1 + xr->y));
549 cairo_stroke (xr->cairo);
552 /* Draws a horizontal line X0...X2 at Y if LEFT says so,
553 shortening it to X0...X1 if SHORTEN is true.
554 Draws a horizontal line X1...X3 at Y if RIGHT says so,
555 shortening it to X2...X3 if SHORTEN is true. */
557 horz_line (struct xr_driver *xr, int x0, int x1, int x2, int x3, int y,
558 enum render_line_style left, enum render_line_style right,
561 if (left != RENDER_LINE_NONE && right != RENDER_LINE_NONE && !shorten)
562 dump_line (xr, x0, y, x3, y);
565 if (left != RENDER_LINE_NONE)
566 dump_line (xr, x0, y, shorten ? x1 : x2, y);
567 if (right != RENDER_LINE_NONE)
568 dump_line (xr, shorten ? x2 : x1, y, x3, y);
572 /* Draws a vertical line Y0...Y2 at X if TOP says so,
573 shortening it to Y0...Y1 if SHORTEN is true.
574 Draws a vertical line Y1...Y3 at X if BOTTOM says so,
575 shortening it to Y2...Y3 if SHORTEN is true. */
577 vert_line (struct xr_driver *xr, int y0, int y1, int y2, int y3, int x,
578 enum render_line_style top, enum render_line_style bottom,
581 if (top != RENDER_LINE_NONE && bottom != RENDER_LINE_NONE && !shorten)
582 dump_line (xr, x, y0, x, y3);
585 if (top != RENDER_LINE_NONE)
586 dump_line (xr, x, y0, x, shorten ? y1 : y2);
587 if (bottom != RENDER_LINE_NONE)
588 dump_line (xr, x, shorten ? y2 : y1, x, y3);
593 xr_draw_line (void *xr_, int bb[TABLE_N_AXES][2],
594 enum render_line_style styles[TABLE_N_AXES][2])
596 const int x0 = bb[H][0];
597 const int y0 = bb[V][0];
598 const int x3 = bb[H][1];
599 const int y3 = bb[V][1];
600 const int top = styles[H][0];
601 const int left = styles[V][0];
602 const int bottom = styles[H][1];
603 const int right = styles[V][1];
605 /* The algorithm here is somewhat subtle, to allow it to handle
606 all the kinds of intersections that we need.
608 Three additional ordinates are assigned along the x axis. The
609 first is xc, midway between x0 and x3. The others are x1 and
610 x2; for a single vertical line these are equal to xc, and for
611 a double vertical line they are the ordinates of the left and
612 right half of the double line.
614 yc, y1, and y2 are assigned similarly along the y axis.
616 The following diagram shows the coordinate system and output
617 for double top and bottom lines, single left line, and no
621 y0 ________________________
627 y1 = y2 = yc |######### # |
632 y3 |________#_____#_______|
634 struct xr_driver *xr = xr_;
636 /* Offset from center of each line in a pair of double lines. */
637 int double_line_ofs = (xr->line_space + xr->line_width) / 2;
639 /* Are the lines along each axis single or double?
640 (It doesn't make sense to have different kinds of line on the
641 same axis, so we don't try to gracefully handle that case.) */
642 bool double_vert = top == RENDER_LINE_DOUBLE || bottom == RENDER_LINE_DOUBLE;
643 bool double_horz = left == RENDER_LINE_DOUBLE || right == RENDER_LINE_DOUBLE;
645 /* When horizontal lines are doubled,
646 the left-side line along y1 normally runs from x0 to x2,
647 and the right-side line along y1 from x3 to x1.
648 If the top-side line is also doubled, we shorten the y1 lines,
649 so that the left-side line runs only to x1,
650 and the right-side line only to x2.
651 Otherwise, the horizontal line at y = y1 below would cut off
652 the intersection, which looks ugly:
654 y0 ________________________
659 y1 |######### ########|
662 y2 |######################|
665 y3 |______________________|
666 It is more of a judgment call when the horizontal line is
667 single. We actually choose to cut off the line anyhow, as
668 shown in the first diagram above.
670 bool shorten_y1_lines = top == RENDER_LINE_DOUBLE;
671 bool shorten_y2_lines = bottom == RENDER_LINE_DOUBLE;
672 bool shorten_yc_line = shorten_y1_lines && shorten_y2_lines;
673 int horz_line_ofs = double_vert ? double_line_ofs : 0;
674 int xc = (x0 + x3) / 2;
675 int x1 = xc - horz_line_ofs;
676 int x2 = xc + horz_line_ofs;
678 bool shorten_x1_lines = left == RENDER_LINE_DOUBLE;
679 bool shorten_x2_lines = right == RENDER_LINE_DOUBLE;
680 bool shorten_xc_line = shorten_x1_lines && shorten_x2_lines;
681 int vert_line_ofs = double_horz ? double_line_ofs : 0;
682 int yc = (y0 + y3) / 2;
683 int y1 = yc - vert_line_ofs;
684 int y2 = yc + vert_line_ofs;
687 horz_line (xr, x0, x1, x2, x3, yc, left, right, shorten_yc_line);
690 horz_line (xr, x0, x1, x2, x3, y1, left, right, shorten_y1_lines);
691 horz_line (xr, x0, x1, x2, x3, y2, left, right, shorten_y2_lines);
695 vert_line (xr, y0, y1, y2, y3, xc, top, bottom, shorten_xc_line);
698 vert_line (xr, y0, y1, y2, y3, x1, top, bottom, shorten_x1_lines);
699 vert_line (xr, y0, y1, y2, y3, x2, top, bottom, shorten_x2_lines);
704 xr_measure_cell_width (void *xr_, const struct table_cell *cell,
705 int *min_width, int *max_width)
707 struct xr_driver *xr = xr_;
708 int bb[TABLE_N_AXES][2];
709 int clip[TABLE_N_AXES][2];
716 clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
717 xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, max_width, &h);
720 xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, min_width, &h);
724 xr_measure_cell_height (void *xr_, const struct table_cell *cell, int width)
726 struct xr_driver *xr = xr_;
727 int bb[TABLE_N_AXES][2];
728 int clip[TABLE_N_AXES][2];
735 clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
736 xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, &w, &h);
741 xr_draw_cell (void *xr_, const struct table_cell *cell,
742 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2])
744 struct xr_driver *xr = xr_;
747 xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, &w, &h);
750 /* Writes STRING at location (X,Y) trimmed to the given MAX_WIDTH
751 and with the given cell OPTIONS for XR. */
753 draw_text (struct xr_driver *xr, const char *string, int x, int y,
754 int max_width, unsigned int options)
756 struct table_cell cell;
757 int bb[TABLE_N_AXES][2];
760 cell.contents = string;
761 cell.options = options;
764 bb[H][1] = x + max_width;
765 bb[V][1] = xr->font_height;
766 xr_layout_cell (xr, &cell, bb, bb, PANGO_WRAP_WORD_CHAR, &w, &h);
770 /* Writes LEFT left-justified and RIGHT right-justified within
771 (X0...X1) at Y. LEFT or RIGHT or both may be null. */
773 draw_header_line (struct xr_driver *xr, const char *left, const char *right,
774 int x0, int x1, int y)
778 right_width = (draw_text (xr, right, x0, y, x1 - x0, TAB_RIGHT)
779 + xr->font_height / 2);
781 draw_text (xr, left, x0, y, x1 - x0 - right_width, TAB_LEFT);
784 /* Draw top of page headers for XR. */
786 draw_headers (struct xr_driver *xr)
792 y = -3 * xr->font_height;
793 x0 = xr->font_height / 2;
794 x1 = xr->width - xr->font_height / 2;
797 cairo_rectangle (xr->cairo, 0, xr_to_pt (y), xr_to_pt (xr->width),
798 xr_to_pt (2 * (xr->font_height
799 + xr->line_width + xr->line_gutter)));
800 cairo_save (xr->cairo);
801 cairo_set_source_rgb (xr->cairo, 0.9, 0.9, 0.9);
802 cairo_fill_preserve (xr->cairo);
803 cairo_restore (xr->cairo);
804 cairo_stroke (xr->cairo);
806 y += xr->line_width + xr->line_gutter;
808 r1 = xasprintf (_("%s - Page %d"), get_start_date (), xr->page_number);
809 r2 = xasprintf ("%s - %s", version, host_system);
811 draw_header_line (xr, xr->title, r1, x0, x1, y);
812 y += xr->font_height;
814 draw_header_line (xr, xr->subtitle, r2, x0, x1, y);
821 xr_layout_cell (struct xr_driver *xr, const struct table_cell *cell,
822 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
823 PangoWrapMode wrap, int *width, int *height)
825 struct xr_font *font;
827 font = (cell->options & TAB_FIX ? &xr->fonts[XR_FONT_FIXED]
828 : cell->options & TAB_EMPH ? &xr->fonts[XR_FONT_EMPHASIS]
829 : &xr->fonts[XR_FONT_PROPORTIONAL]);
831 pango_layout_set_text (font->layout, cell->contents, -1);
833 pango_layout_set_alignment (
835 ((cell->options & TAB_ALIGNMENT) == TAB_RIGHT ? PANGO_ALIGN_RIGHT
836 : (cell->options & TAB_ALIGNMENT) == TAB_LEFT ? PANGO_ALIGN_LEFT
837 : PANGO_ALIGN_CENTER));
838 pango_layout_set_width (font->layout,
839 bb[H][1] == INT_MAX ? -1 : bb[H][1] - bb[H][0]);
840 pango_layout_set_wrap (font->layout, wrap);
842 if (clip[H][0] != clip[H][1])
844 cairo_save (xr->cairo);
846 if (clip[H][1] != INT_MAX || clip[V][1] != INT_MAX)
848 double x0 = xr_to_pt (clip[H][0]);
849 double y0 = xr_to_pt (clip[V][0] + xr->y);
850 double x1 = xr_to_pt (clip[H][1]);
851 double y1 = xr_to_pt (clip[V][1] + xr->y);
853 cairo_rectangle (xr->cairo, x0, y0, x1 - x0, y1 - y0);
854 cairo_clip (xr->cairo);
857 cairo_translate (xr->cairo,
859 xr_to_pt (bb[V][0] + xr->y));
860 pango_cairo_show_layout (xr->cairo, font->layout);
861 cairo_restore (xr->cairo);
864 if (width != NULL || height != NULL)
868 pango_layout_get_size (font->layout, &w, &h);
876 /* Attempts to load FONT, initializing its other members based on
877 its 'string' member and the information in DRIVER. Returns true
878 if successful, otherwise false. */
880 load_font (struct xr_driver *xr, struct xr_font *font)
882 PangoContext *context;
883 PangoLanguage *language;
885 font->desc = pango_font_description_from_string (font->string);
886 if (font->desc == NULL)
888 error (0, 0, _("\"%s\": bad font specification"), font->string);
891 pango_font_description_set_absolute_size (font->desc, xr->font_height);
893 font->layout = pango_cairo_create_layout (xr->cairo);
894 pango_layout_set_font_description (font->layout, font->desc);
896 language = pango_language_get_default ();
897 context = pango_layout_get_context (font->layout);
898 font->metrics = pango_context_get_metrics (context, font->desc, language);
905 free_font (struct xr_font *font)
908 if (font->desc != NULL)
909 pango_font_description_free (font->desc);
910 pango_font_metrics_unref (font->metrics);
911 if (font->layout != NULL)
912 g_object_unref (font->layout);
915 struct output_driver_factory pdf_driver_factory = { "pdf", xr_pdf_create };
916 struct output_driver_factory ps_driver_factory = { "ps", xr_ps_create };
917 struct output_driver_factory svg_driver_factory = { "svg", xr_svg_create };
919 static const struct output_driver_class cairo_driver_class =
927 /* GUI rendering helpers. */
932 struct render_page *page;
933 struct xr_driver *xr;
937 struct chart_item *chart;
940 #define CHART_WIDTH 500
941 #define CHART_HEIGHT 375
944 xr_create_driver (cairo_t *cairo)
946 struct xr_driver *xr;
947 struct string_map map;
949 string_map_init (&map);
950 xr = xr_allocate ("cairo", 0, &map);
951 string_map_destroy (&map);
953 xr->width = INT_MAX / 8;
954 xr->length = INT_MAX / 8;
955 if (!xr_set_cairo (xr, cairo))
957 output_driver_destroy (&xr->driver);
963 struct xr_rendering *
964 xr_rendering_create (struct xr_driver *xr, const struct output_item *item,
967 struct xr_rendering *r = NULL;
969 if (is_text_item (item))
971 const struct text_item *text_item = to_text_item (item);
972 const char *text = text_item_get_text (text_item);
973 struct table_item *table_item;
975 table_item = table_item_create (table_from_string (TAB_LEFT, text),
977 r = xr_rendering_create (xr, &table_item->output_item, cr);
978 table_item_unref (table_item);
980 else if (is_table_item (item))
982 r = xzalloc (sizeof *r);
984 xr_set_cairo (xr, cr);
985 r->page = xr_render_table_item (xr, to_table_item (item),
988 else if (is_chart_item (item))
990 r = xzalloc (sizeof *r);
991 r->chart = to_chart_item (output_item_ref (item));
998 xr_rendering_measure (struct xr_rendering *r, int *w, int *h)
1000 if (r->chart == NULL)
1002 *w = render_page_get_size (r->page, H) / 1024;
1003 *h = (render_page_get_size (r->page, V) + r->title_height) / 1024;
1013 xr_rendering_draw (struct xr_rendering *r, cairo_t *cr)
1015 if (r->chart == NULL)
1017 struct xr_driver *xr = r->xr;
1019 xr_set_cairo (xr, cr);
1021 render_page_draw (r->page);
1024 xr_draw_chart (r->chart, cr, 0, 0, CHART_WIDTH, CHART_HEIGHT);
1028 xr_draw_chart (const struct chart_item *chart_item, cairo_t *cr,
1029 double x, double y, double width, double height)
1031 struct xrchart_geometry geom;
1034 cairo_translate (cr, x, y + height);
1035 cairo_scale (cr, 1.0, -1.0);
1036 xrchart_geometry_init (cr, &geom, width, height);
1037 if (is_boxplot (chart_item))
1038 xrchart_draw_boxplot (chart_item, cr, &geom);
1039 else if (is_histogram_chart (chart_item))
1040 xrchart_draw_histogram (chart_item, cr, &geom);
1041 else if (is_np_plot_chart (chart_item))
1042 xrchart_draw_np_plot (chart_item, cr, &geom);
1043 else if (is_piechart (chart_item))
1044 xrchart_draw_piechart (chart_item, cr, &geom);
1045 else if (is_roc_chart (chart_item))
1046 xrchart_draw_roc (chart_item, cr, &geom);
1047 else if (is_scree (chart_item))
1048 xrchart_draw_scree (chart_item, cr, &geom);
1051 xrchart_geometry_free (cr, &geom);
1057 xr_draw_png_chart (const struct chart_item *item,
1058 const char *file_name_template, int number)
1060 const int width = 640;
1061 const int length = 480;
1063 cairo_surface_t *surface;
1064 cairo_status_t status;
1065 const char *number_pos;
1069 number_pos = strchr (file_name_template, '#');
1070 if (number_pos != NULL)
1071 file_name = xasprintf ("%.*s%d%s", (int) (number_pos - file_name_template),
1072 file_name_template, number, number_pos + 1);
1074 file_name = xstrdup (file_name_template);
1076 surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, width, length);
1077 cr = cairo_create (surface);
1080 cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
1081 cairo_rectangle (cr, 0, 0, width, length);
1085 cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
1087 xr_draw_chart (item, cr, 0.0, 0.0, width, length);
1089 status = cairo_surface_write_to_png (surface, file_name);
1090 if (status != CAIRO_STATUS_SUCCESS)
1091 error (0, 0, _("writing output file \"%s\": %s"),
1092 file_name, cairo_status_to_string (status));
1095 cairo_surface_destroy (surface);