1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 2009 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 void xr_show_page (struct xr_driver *);
137 static void draw_headers (struct xr_driver *);
139 static bool load_font (struct xr_driver *, struct xr_font *);
140 static void free_font (struct xr_font *);
142 static void xr_draw_line (void *, int bb[TABLE_N_AXES][2],
143 enum render_line_style styles[TABLE_N_AXES][2]);
144 static void xr_measure_cell_width (void *, const struct table_cell *,
146 static int xr_measure_cell_height (void *, const struct table_cell *,
148 static void xr_draw_cell (void *, const struct table_cell *,
149 int bb[TABLE_N_AXES][2],
150 int clip[TABLE_N_AXES][2]);
152 /* Driver initialization. */
154 static struct xr_driver *
155 xr_driver_cast (struct output_driver *driver)
157 assert (driver->class == &cairo_class);
158 return UP_CAST (driver, struct xr_driver, driver);
161 static struct driver_option *
162 opt (struct output_driver *d, struct string_map *options, const char *key,
163 const char *default_value)
165 return driver_option_get (d, options, key, default_value);
168 static struct xr_driver *
169 xr_allocate (const char *name, int device_type, struct string_map *o)
171 struct output_driver *d;
172 struct xr_driver *xr;
174 xr = xzalloc (sizeof *xr);
176 output_driver_init (d, &cairo_class, name, device_type);
178 xr->font_height = XR_POINT * 10;
179 xr->fonts[XR_FONT_FIXED].string
180 = parse_string (opt (d, o, "fixed-font", "monospace"));
181 xr->fonts[XR_FONT_PROPORTIONAL].string
182 = parse_string (opt (d, o, "prop-font", "serif"));
183 xr->fonts[XR_FONT_EMPHASIS].string
184 = parse_string (opt (d, o, "emph-font", "serif italic"));
185 xr->line_gutter = XR_POINT;
186 xr->line_space = XR_POINT;
187 xr->line_width = XR_POINT / 2;
194 xr_set_cairo (struct xr_driver *xr, cairo_t *cairo)
200 cairo_set_line_width (xr->cairo, xr_to_pt (xr->line_width));
202 for (i = 0; i < XR_N_FONTS; i++)
203 if (!load_font (xr, &xr->fonts[i]))
206 if (xr->params == NULL)
208 int single_width, double_width;
210 xr->params = xmalloc (sizeof *xr->params);
211 xr->params->draw_line = xr_draw_line;
212 xr->params->measure_cell_width = xr_measure_cell_width;
213 xr->params->measure_cell_height = xr_measure_cell_height;
214 xr->params->draw_cell = xr_draw_cell;
215 xr->params->aux = xr;
216 xr->params->size[H] = xr->width;
217 xr->params->size[V] = xr->length;
218 xr->params->font_size[H] = xr->font_height / 2; /* XXX */
219 xr->params->font_size[V] = xr->font_height;
221 single_width = 2 * xr->line_gutter + xr->line_width;
222 double_width = 2 * xr->line_gutter + xr->line_space + 2 * xr->line_width;
223 for (i = 0; i < TABLE_N_AXES; i++)
225 xr->params->line_widths[i][RENDER_LINE_NONE] = 0;
226 xr->params->line_widths[i][RENDER_LINE_SINGLE] = single_width;
227 xr->params->line_widths[i][RENDER_LINE_DOUBLE] = double_width;
234 static struct output_driver *
235 xr_create (const char *name, enum output_device_type device_type,
236 struct string_map *o)
238 enum { MIN_LENGTH = 3 };
239 struct output_driver *d;
240 struct xr_driver *xr;
241 cairo_surface_t *surface;
242 cairo_status_t status;
243 double width_pt, length_pt;
244 int paper_width, paper_length;
247 xr = xr_allocate (name, device_type, o);
250 xr->headers = parse_boolean (opt (d, o, "headers", "true"));
252 xr->file_type = parse_enum (opt (d, o, "output-type", "pdf"),
257 file_name = parse_string (opt (d, o, "output-file",
258 (xr->file_type == XR_PDF ? "pspp.pdf"
259 : xr->file_type == XR_PS ? "pspp.ps"
262 parse_paper_size (opt (d, o, "paper-size", ""), &paper_width, &paper_length);
263 xr->left_margin = parse_dimension (opt (d, o, "left-margin", ".5in"));
264 xr->right_margin = parse_dimension (opt (d, o, "right-margin", ".5in"));
265 xr->top_margin = parse_dimension (opt (d, o, "top-margin", ".5in"));
266 xr->bottom_margin = parse_dimension (opt (d, o, "bottom-margin", ".5in"));
269 xr->top_margin += 3 * xr->font_height;
270 xr->width = paper_width - xr->left_margin - xr->right_margin;
271 xr->length = paper_length - xr->top_margin - xr->bottom_margin;
273 width_pt = paper_width / 1000.0;
274 length_pt = paper_length / 1000.0;
275 if (xr->file_type == XR_PDF)
276 surface = cairo_pdf_surface_create (file_name, width_pt, length_pt);
277 else if (xr->file_type == XR_PS)
278 surface = cairo_ps_surface_create (file_name, width_pt, length_pt);
279 else if (xr->file_type == XR_SVG)
280 surface = cairo_svg_surface_create (file_name, width_pt, length_pt);
284 status = cairo_surface_status (surface);
285 if (status != CAIRO_STATUS_SUCCESS)
287 error (0, 0, _("opening output file \"%s\": %s"),
288 file_name, cairo_status_to_string (status));
289 cairo_surface_destroy (surface);
293 xr->cairo = cairo_create (surface);
294 cairo_surface_destroy (surface);
296 cairo_translate (xr->cairo,
297 xr_to_pt (xr->left_margin),
298 xr_to_pt (xr->top_margin));
300 if (!xr_set_cairo (xr, xr->cairo))
303 if (xr->length / xr->font_height < MIN_LENGTH)
305 error (0, 0, _("The defined page is not long "
306 "enough to hold margins and headers, plus least %d "
307 "lines of the default fonts. In fact, there's only "
308 "room for %d lines."),
310 xr->length / xr->font_height);
318 output_driver_destroy (&xr->driver);
323 xr_destroy (struct output_driver *driver)
325 struct xr_driver *xr = xr_driver_cast (driver);
328 if (xr->cairo != NULL)
330 cairo_status_t status;
335 cairo_surface_finish (cairo_get_target (xr->cairo));
336 status = cairo_status (xr->cairo);
337 if (status != CAIRO_STATUS_SUCCESS)
338 error (0, 0, _("error drawing output for %s driver: %s"),
339 output_driver_get_name (driver),
340 cairo_status_to_string (status));
341 cairo_destroy (xr->cairo);
344 for (i = 0; i < XR_N_FONTS; i++)
345 free_font (&xr->fonts[i]);
351 xr_flush (struct output_driver *driver)
353 struct xr_driver *xr = xr_driver_cast (driver);
355 cairo_surface_flush (cairo_get_target (xr->cairo));
359 xr_init_caption_cell (const char *caption, struct table_cell *cell)
361 cell->contents = caption;
362 cell->options = TAB_LEFT;
363 cell->destructor = NULL;
366 static struct render_page *
367 xr_render_table_item (struct xr_driver *xr, const struct table_item *item,
368 int *caption_heightp)
370 const char *caption = table_item_get_caption (item);
374 /* XXX doesn't do well with very large captions */
375 struct table_cell cell;
376 xr_init_caption_cell (caption, &cell);
377 *caption_heightp = xr_measure_cell_height (xr, &cell, xr->width);
380 *caption_heightp = 0;
382 return render_page_create (xr->params, table_item_get_table (item));
386 xr_submit (struct output_driver *driver, const struct output_item *output_item)
388 struct xr_driver *xr = xr_driver_cast (driver);
389 if (is_table_item (output_item))
391 struct table_item *table_item = to_table_item (output_item);
392 struct render_break x_break;
393 struct render_page *page;
397 xr->y += xr->font_height;
399 page = xr_render_table_item (xr, table_item, &caption_height);
400 xr->params->size[V] = xr->length - caption_height;
401 for (render_break_init (&x_break, page, H);
402 render_break_has_next (&x_break); )
404 struct render_page *x_slice;
405 struct render_break y_break;
407 x_slice = render_break_next (&x_break, xr->width);
408 for (render_break_init (&y_break, x_slice, V);
409 render_break_has_next (&y_break); )
411 int space = xr->length - xr->y;
412 struct render_page *y_slice;
414 /* XXX doesn't allow for caption or space between segments */
415 if (render_break_next_size (&y_break) > space)
422 y_slice = render_break_next (&y_break, space);
425 struct table_cell cell;
426 int bb[TABLE_N_AXES][2];
428 xr_init_caption_cell (table_item_get_caption (table_item),
431 bb[H][1] = xr->width;
433 bb[V][1] = caption_height;
434 xr_draw_cell (xr, &cell, bb, bb);
435 xr->y += caption_height;
439 render_page_draw (y_slice);
440 xr->y += render_page_get_size (y_slice, V);
441 render_page_unref (y_slice);
443 render_break_destroy (&y_break);
445 render_break_destroy (&x_break);
447 else if (is_chart_item (output_item))
451 xr_draw_chart (to_chart_item (output_item), xr->cairo, 0.0, 0.0,
452 xr_to_pt (xr->width), xr_to_pt (xr->length));
455 else if (is_text_item (output_item))
457 const struct text_item *text_item = to_text_item (output_item);
458 enum text_item_type type = text_item_get_type (text_item);
459 const char *text = text_item_get_text (text_item);
463 case TEXT_ITEM_TITLE:
465 xr->title = xstrdup (text);
468 case TEXT_ITEM_SUBTITLE:
470 xr->subtitle = xstrdup (text);
473 case TEXT_ITEM_COMMAND_CLOSE:
476 case TEXT_ITEM_BLANK_LINE:
478 xr->y += xr->font_height;
481 case TEXT_ITEM_EJECT_PAGE:
488 struct table_item *item;
490 item = table_item_create (table_from_string (TAB_LEFT, text),
492 xr_submit (&xr->driver, &item->output_item);
493 table_item_unref (item);
502 xr_show_page (struct xr_driver *xr)
509 cairo_show_page (xr->cairo);
516 xr_layout_cell (struct xr_driver *, const struct table_cell *,
517 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
518 PangoWrapMode, int *width, int *height);
521 dump_line (struct xr_driver *xr, int x0, int y0, int x1, int y1)
523 cairo_new_path (xr->cairo);
524 cairo_move_to (xr->cairo, xr_to_pt (x0), xr_to_pt (y0 + xr->y));
525 cairo_line_to (xr->cairo, xr_to_pt (x1), xr_to_pt (y1 + xr->y));
526 cairo_stroke (xr->cairo);
529 /* Draws a horizontal line X0...X2 at Y if LEFT says so,
530 shortening it to X0...X1 if SHORTEN is true.
531 Draws a horizontal line X1...X3 at Y if RIGHT says so,
532 shortening it to X2...X3 if SHORTEN is true. */
534 horz_line (struct xr_driver *xr, int x0, int x1, int x2, int x3, int y,
535 enum render_line_style left, enum render_line_style right,
538 if (left != RENDER_LINE_NONE && right != RENDER_LINE_NONE && !shorten)
539 dump_line (xr, x0, y, x3, y);
542 if (left != RENDER_LINE_NONE)
543 dump_line (xr, x0, y, shorten ? x1 : x2, y);
544 if (right != RENDER_LINE_NONE)
545 dump_line (xr, shorten ? x2 : x1, y, x3, y);
549 /* Draws a vertical line Y0...Y2 at X if TOP says so,
550 shortening it to Y0...Y1 if SHORTEN is true.
551 Draws a vertical line Y1...Y3 at X if BOTTOM says so,
552 shortening it to Y2...Y3 if SHORTEN is true. */
554 vert_line (struct xr_driver *xr, int y0, int y1, int y2, int y3, int x,
555 enum render_line_style top, enum render_line_style bottom,
558 if (top != RENDER_LINE_NONE && bottom != RENDER_LINE_NONE && !shorten)
559 dump_line (xr, x, y0, x, y3);
562 if (top != RENDER_LINE_NONE)
563 dump_line (xr, x, y0, x, shorten ? y1 : y2);
564 if (bottom != RENDER_LINE_NONE)
565 dump_line (xr, x, shorten ? y2 : y1, x, y3);
570 xr_draw_line (void *xr_, int bb[TABLE_N_AXES][2],
571 enum render_line_style styles[TABLE_N_AXES][2])
573 const int x0 = bb[H][0];
574 const int y0 = bb[V][0];
575 const int x3 = bb[H][1];
576 const int y3 = bb[V][1];
577 const int top = styles[H][0];
578 const int left = styles[V][0];
579 const int bottom = styles[H][1];
580 const int right = styles[V][1];
582 /* The algorithm here is somewhat subtle, to allow it to handle
583 all the kinds of intersections that we need.
585 Three additional ordinates are assigned along the x axis. The
586 first is xc, midway between x0 and x3. The others are x1 and
587 x2; for a single vertical line these are equal to xc, and for
588 a double vertical line they are the ordinates of the left and
589 right half of the double line.
591 yc, y1, and y2 are assigned similarly along the y axis.
593 The following diagram shows the coordinate system and output
594 for double top and bottom lines, single left line, and no
598 y0 ________________________
604 y1 = y2 = yc |######### # |
609 y3 |________#_____#_______|
611 struct xr_driver *xr = xr_;
613 /* Offset from center of each line in a pair of double lines. */
614 int double_line_ofs = (xr->line_space + xr->line_width) / 2;
616 /* Are the lines along each axis single or double?
617 (It doesn't make sense to have different kinds of line on the
618 same axis, so we don't try to gracefully handle that case.) */
619 bool double_vert = top == RENDER_LINE_DOUBLE || bottom == RENDER_LINE_DOUBLE;
620 bool double_horz = left == RENDER_LINE_DOUBLE || right == RENDER_LINE_DOUBLE;
622 /* When horizontal lines are doubled,
623 the left-side line along y1 normally runs from x0 to x2,
624 and the right-side line along y1 from x3 to x1.
625 If the top-side line is also doubled, we shorten the y1 lines,
626 so that the left-side line runs only to x1,
627 and the right-side line only to x2.
628 Otherwise, the horizontal line at y = y1 below would cut off
629 the intersection, which looks ugly:
631 y0 ________________________
636 y1 |######### ########|
639 y2 |######################|
642 y3 |______________________|
643 It is more of a judgment call when the horizontal line is
644 single. We actually choose to cut off the line anyhow, as
645 shown in the first diagram above.
647 bool shorten_y1_lines = top == RENDER_LINE_DOUBLE;
648 bool shorten_y2_lines = bottom == RENDER_LINE_DOUBLE;
649 bool shorten_yc_line = shorten_y1_lines && shorten_y2_lines;
650 int horz_line_ofs = double_vert ? double_line_ofs : 0;
651 int xc = (x0 + x3) / 2;
652 int x1 = xc - horz_line_ofs;
653 int x2 = xc + horz_line_ofs;
655 bool shorten_x1_lines = left == RENDER_LINE_DOUBLE;
656 bool shorten_x2_lines = right == RENDER_LINE_DOUBLE;
657 bool shorten_xc_line = shorten_x1_lines && shorten_x2_lines;
658 int vert_line_ofs = double_horz ? double_line_ofs : 0;
659 int yc = (y0 + y3) / 2;
660 int y1 = yc - vert_line_ofs;
661 int y2 = yc + vert_line_ofs;
664 horz_line (xr, x0, x1, x2, x3, yc, left, right, shorten_yc_line);
667 horz_line (xr, x0, x1, x2, x3, y1, left, right, shorten_y1_lines);
668 horz_line (xr, x0, x1, x2, x3, y2, left, right, shorten_y2_lines);
672 vert_line (xr, y0, y1, y2, y3, xc, top, bottom, shorten_xc_line);
675 vert_line (xr, y0, y1, y2, y3, x1, top, bottom, shorten_x1_lines);
676 vert_line (xr, y0, y1, y2, y3, x2, top, bottom, shorten_x2_lines);
681 xr_measure_cell_width (void *xr_, const struct table_cell *cell,
682 int *min_width, int *max_width)
684 struct xr_driver *xr = xr_;
685 int bb[TABLE_N_AXES][2];
686 int clip[TABLE_N_AXES][2];
693 clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
694 xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, max_width, &h);
697 xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, min_width, &h);
701 xr_measure_cell_height (void *xr_, const struct table_cell *cell, int width)
703 struct xr_driver *xr = xr_;
704 int bb[TABLE_N_AXES][2];
705 int clip[TABLE_N_AXES][2];
712 clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
713 xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, &w, &h);
718 xr_draw_cell (void *xr_, const struct table_cell *cell,
719 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2])
721 struct xr_driver *xr = xr_;
724 xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, &w, &h);
727 /* Writes STRING at location (X,Y) trimmed to the given MAX_WIDTH
728 and with the given cell OPTIONS for XR. */
730 draw_text (struct xr_driver *xr, const char *string, int x, int y,
731 int max_width, unsigned int options)
733 struct table_cell cell;
734 int bb[TABLE_N_AXES][2];
737 cell.contents = string;
738 cell.options = options;
741 bb[H][1] = x + max_width;
742 bb[V][1] = xr->font_height;
743 xr_layout_cell (xr, &cell, bb, bb, PANGO_WRAP_WORD_CHAR, &w, &h);
747 /* Writes LEFT left-justified and RIGHT right-justified within
748 (X0...X1) at Y. LEFT or RIGHT or both may be null. */
750 draw_header_line (struct xr_driver *xr, const char *left, const char *right,
751 int x0, int x1, int y)
755 right_width = (draw_text (xr, right, x0, y, x1 - x0, TAB_RIGHT)
756 + xr->font_height / 2);
758 draw_text (xr, left, x0, y, x1 - x0 - right_width, TAB_LEFT);
761 /* Draw top of page headers for XR. */
763 draw_headers (struct xr_driver *xr)
769 y = -3 * xr->font_height;
770 x0 = xr->font_height / 2;
771 x1 = xr->width - xr->font_height / 2;
774 cairo_rectangle (xr->cairo, 0, xr_to_pt (y), xr_to_pt (xr->width),
775 xr_to_pt (2 * (xr->font_height
776 + xr->line_width + xr->line_gutter)));
777 cairo_save (xr->cairo);
778 cairo_set_source_rgb (xr->cairo, 0.9, 0.9, 0.9);
779 cairo_fill_preserve (xr->cairo);
780 cairo_restore (xr->cairo);
781 cairo_stroke (xr->cairo);
783 y += xr->line_width + xr->line_gutter;
785 r1 = xasprintf (_("%s - Page %d"), get_start_date (), xr->page_number);
786 r2 = xasprintf ("%s - %s", version, host_system);
788 draw_header_line (xr, xr->title, r1, x0, x1, y);
789 y += xr->font_height;
791 draw_header_line (xr, xr->subtitle, r2, x0, x1, y);
798 xr_layout_cell (struct xr_driver *xr, const struct table_cell *cell,
799 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
800 PangoWrapMode wrap, int *width, int *height)
802 struct xr_font *font;
804 font = (cell->options & TAB_FIX ? &xr->fonts[XR_FONT_FIXED]
805 : cell->options & TAB_EMPH ? &xr->fonts[XR_FONT_EMPHASIS]
806 : &xr->fonts[XR_FONT_PROPORTIONAL]);
808 pango_layout_set_text (font->layout, cell->contents, -1);
810 pango_layout_set_alignment (
812 ((cell->options & TAB_ALIGNMENT) == TAB_RIGHT ? PANGO_ALIGN_RIGHT
813 : (cell->options & TAB_ALIGNMENT) == TAB_LEFT ? PANGO_ALIGN_LEFT
814 : PANGO_ALIGN_CENTER));
815 pango_layout_set_width (font->layout,
816 bb[H][1] == INT_MAX ? -1 : bb[H][1] - bb[H][0]);
817 pango_layout_set_wrap (font->layout, wrap);
819 if (clip[H][0] != clip[H][1])
821 cairo_save (xr->cairo);
823 if (clip[H][1] != INT_MAX || clip[V][1] != INT_MAX)
825 double x0 = xr_to_pt (clip[H][0]);
826 double y0 = xr_to_pt (clip[V][0] + xr->y);
827 double x1 = xr_to_pt (clip[H][1]);
828 double y1 = xr_to_pt (clip[V][1] + xr->y);
830 cairo_rectangle (xr->cairo, x0, y0, x1 - x0, y1 - y0);
831 cairo_clip (xr->cairo);
834 cairo_translate (xr->cairo,
836 xr_to_pt (bb[V][0] + xr->y));
837 pango_cairo_show_layout (xr->cairo, font->layout);
838 cairo_restore (xr->cairo);
841 if (width != NULL || height != NULL)
845 pango_layout_get_size (font->layout, &w, &h);
853 /* Attempts to load FONT, initializing its other members based on
854 its 'string' member and the information in DRIVER. Returns true
855 if successful, otherwise false. */
857 load_font (struct xr_driver *xr, struct xr_font *font)
859 PangoContext *context;
860 PangoLanguage *language;
862 font->desc = pango_font_description_from_string (font->string);
863 if (font->desc == NULL)
865 error (0, 0, _("\"%s\": bad font specification"), font->string);
868 pango_font_description_set_absolute_size (font->desc, xr->font_height);
870 font->layout = pango_cairo_create_layout (xr->cairo);
871 pango_layout_set_font_description (font->layout, font->desc);
873 language = pango_language_get_default ();
874 context = pango_layout_get_context (font->layout);
875 font->metrics = pango_context_get_metrics (context, font->desc, language);
882 free_font (struct xr_font *font)
885 if (font->desc != NULL)
886 pango_font_description_free (font->desc);
887 pango_font_metrics_unref (font->metrics);
888 g_object_unref (font->layout);
891 /* Cairo driver class. */
892 const struct output_driver_class cairo_class =
901 /* GUI rendering helpers. */
906 struct render_page *page;
907 struct xr_driver *xr;
911 struct chart_item *chart;
914 #define CHART_WIDTH 500
915 #define CHART_HEIGHT 375
918 xr_create_driver (cairo_t *cairo)
920 struct xr_driver *xr;
921 struct string_map map;
923 string_map_init (&map);
924 xr = xr_allocate ("cairo", 0, &map);
925 string_map_destroy (&map);
927 xr->width = INT_MAX / 8;
928 xr->length = INT_MAX / 8;
929 if (!xr_set_cairo (xr, cairo))
931 output_driver_destroy (&xr->driver);
937 struct xr_rendering *
938 xr_rendering_create (struct xr_driver *xr, const struct output_item *item,
941 struct xr_rendering *r = NULL;
943 if (is_text_item (item))
945 const struct text_item *text_item = to_text_item (item);
946 const char *text = text_item_get_text (text_item);
947 struct table_item *table_item;
949 table_item = table_item_create (table_from_string (TAB_LEFT, text),
951 r = xr_rendering_create (xr, &table_item->output_item, cr);
952 table_item_unref (table_item);
954 else if (is_table_item (item))
956 r = xzalloc (sizeof *r);
958 xr_set_cairo (xr, cr);
959 r->page = xr_render_table_item (xr, to_table_item (item),
962 else if (is_chart_item (item))
964 r = xzalloc (sizeof *r);
965 r->chart = to_chart_item (output_item_ref (item));
972 xr_rendering_measure (struct xr_rendering *r, int *w, int *h)
974 if (r->chart == NULL)
976 *w = render_page_get_size (r->page, H) / 1024;
977 *h = (render_page_get_size (r->page, V) + r->title_height) / 1024;
987 xr_rendering_draw (struct xr_rendering *r, cairo_t *cr)
989 if (r->chart == NULL)
991 struct xr_driver *xr = r->xr;
993 xr_set_cairo (xr, cr);
995 render_page_draw (r->page);
998 xr_draw_chart (r->chart, cr, 0, 0, CHART_WIDTH, CHART_HEIGHT);
1002 xr_draw_chart (const struct chart_item *chart_item, cairo_t *cr,
1003 double x, double y, double width, double height)
1005 struct xrchart_geometry geom;
1008 cairo_translate (cr, x, y + height);
1009 cairo_scale (cr, 1.0, -1.0);
1010 xrchart_geometry_init (cr, &geom, width, height);
1011 if (is_boxplot (chart_item))
1012 xrchart_draw_boxplot (chart_item, cr, &geom);
1013 else if (is_histogram_chart (chart_item))
1014 xrchart_draw_histogram (chart_item, cr, &geom);
1015 else if (is_np_plot_chart (chart_item))
1016 xrchart_draw_np_plot (chart_item, cr, &geom);
1017 else if (is_piechart (chart_item))
1018 xrchart_draw_piechart (chart_item, cr, &geom);
1019 else if (is_roc_chart (chart_item))
1020 xrchart_draw_roc (chart_item, cr, &geom);
1021 else if (is_scree (chart_item))
1022 xrchart_draw_scree (chart_item, cr, &geom);
1025 xrchart_geometry_free (cr, &geom);
1031 xr_draw_png_chart (const struct chart_item *item,
1032 const char *file_name_template, int number)
1034 const int width = 640;
1035 const int length = 480;
1037 cairo_surface_t *surface;
1038 cairo_status_t status;
1039 const char *number_pos;
1043 number_pos = strchr (file_name_template, '#');
1044 if (number_pos != NULL)
1045 file_name = xasprintf ("%.*s%d%s", (int) (number_pos - file_name_template),
1046 file_name_template, number, number_pos + 1);
1048 file_name = xstrdup (file_name_template);
1050 surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, width, length);
1051 cr = cairo_create (surface);
1054 cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
1055 cairo_rectangle (cr, 0, 0, width, length);
1059 cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
1061 xr_draw_chart (item, cr, 0.0, 0.0, width, length);
1063 status = cairo_surface_write_to_png (surface, file_name);
1064 if (status != CAIRO_STATUS_SUCCESS)
1065 error (0, 0, _("writing output file \"%s\": %s"),
1066 file_name, cairo_status_to_string (status));
1069 cairo_surface_destroy (surface);