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 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_WIDTH = 3, 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->width / (xr->font_height / 2) < MIN_WIDTH)
305 error (0, 0, _("The defined page is not wide enough to hold at least %d "
306 "characters in the default font. In fact, there's only "
307 "room for %d characters."),
309 xr->width / (xr->font_height / 2));
313 if (xr->length / xr->font_height < MIN_LENGTH)
315 error (0, 0, _("The defined page is not long "
316 "enough to hold margins and headers, plus least %d "
317 "lines of the default fonts. In fact, there's only "
318 "room for %d lines."),
320 xr->length / xr->font_height);
328 output_driver_destroy (&xr->driver);
333 xr_destroy (struct output_driver *driver)
335 struct xr_driver *xr = xr_driver_cast (driver);
338 if (xr->cairo != NULL)
340 cairo_status_t status;
345 cairo_surface_finish (cairo_get_target (xr->cairo));
346 status = cairo_status (xr->cairo);
347 if (status != CAIRO_STATUS_SUCCESS)
348 error (0, 0, _("error drawing output for %s driver: %s"),
349 output_driver_get_name (driver),
350 cairo_status_to_string (status));
351 cairo_destroy (xr->cairo);
354 for (i = 0; i < XR_N_FONTS; i++)
355 free_font (&xr->fonts[i]);
361 xr_flush (struct output_driver *driver)
363 struct xr_driver *xr = xr_driver_cast (driver);
365 cairo_surface_flush (cairo_get_target (xr->cairo));
369 xr_init_caption_cell (const char *caption, struct table_cell *cell)
371 cell->contents = caption;
372 cell->options = TAB_LEFT;
373 cell->destructor = NULL;
376 static struct render_page *
377 xr_render_table_item (struct xr_driver *xr, const struct table_item *item,
378 int *caption_heightp)
380 const char *caption = table_item_get_caption (item);
384 /* XXX doesn't do well with very large captions */
385 struct table_cell cell;
386 xr_init_caption_cell (caption, &cell);
387 *caption_heightp = xr_measure_cell_height (xr, &cell, xr->width);
390 *caption_heightp = 0;
392 return render_page_create (xr->params, table_item_get_table (item));
396 xr_submit (struct output_driver *driver, const struct output_item *output_item)
398 struct xr_driver *xr = xr_driver_cast (driver);
399 if (is_table_item (output_item))
401 struct table_item *table_item = to_table_item (output_item);
402 struct render_break x_break;
403 struct render_page *page;
407 xr->y += xr->font_height;
409 page = xr_render_table_item (xr, table_item, &caption_height);
410 xr->params->size[V] = xr->length - caption_height;
411 for (render_break_init (&x_break, page, H);
412 render_break_has_next (&x_break); )
414 struct render_page *x_slice;
415 struct render_break y_break;
417 x_slice = render_break_next (&x_break, xr->width);
418 for (render_break_init (&y_break, x_slice, V);
419 render_break_has_next (&y_break); )
421 int space = xr->length - xr->y;
422 struct render_page *y_slice;
424 /* XXX doesn't allow for caption or space between segments */
425 if (render_break_next_size (&y_break) > space)
432 y_slice = render_break_next (&y_break, space);
435 struct table_cell cell;
436 int bb[TABLE_N_AXES][2];
438 xr_init_caption_cell (table_item_get_caption (table_item),
441 bb[H][1] = xr->width;
443 bb[V][1] = caption_height;
444 xr_draw_cell (xr, &cell, bb, bb);
445 xr->y += caption_height;
449 render_page_draw (y_slice);
450 xr->y += render_page_get_size (y_slice, V);
451 render_page_unref (y_slice);
453 render_break_destroy (&y_break);
455 render_break_destroy (&x_break);
457 else if (is_chart_item (output_item))
461 xr_draw_chart (to_chart_item (output_item), xr->cairo, 0.0, 0.0,
462 xr_to_pt (xr->width), xr_to_pt (xr->length));
465 else if (is_text_item (output_item))
467 const struct text_item *text_item = to_text_item (output_item);
468 enum text_item_type type = text_item_get_type (text_item);
469 const char *text = text_item_get_text (text_item);
473 case TEXT_ITEM_TITLE:
475 xr->title = xstrdup (text);
478 case TEXT_ITEM_SUBTITLE:
480 xr->subtitle = xstrdup (text);
483 case TEXT_ITEM_COMMAND_CLOSE:
486 case TEXT_ITEM_BLANK_LINE:
488 xr->y += xr->font_height;
491 case TEXT_ITEM_EJECT_PAGE:
498 struct table_item *item;
500 item = table_item_create (table_from_string (TAB_LEFT, text),
502 xr_submit (&xr->driver, &item->output_item);
503 table_item_unref (item);
512 xr_show_page (struct xr_driver *xr)
519 cairo_show_page (xr->cairo);
526 xr_layout_cell (struct xr_driver *, const struct table_cell *,
527 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
528 PangoWrapMode, int *width, int *height);
531 dump_line (struct xr_driver *xr, int x0, int y0, int x1, int y1)
533 cairo_new_path (xr->cairo);
534 cairo_move_to (xr->cairo, xr_to_pt (x0), xr_to_pt (y0 + xr->y));
535 cairo_line_to (xr->cairo, xr_to_pt (x1), xr_to_pt (y1 + xr->y));
536 cairo_stroke (xr->cairo);
539 /* Draws a horizontal line X0...X2 at Y if LEFT says so,
540 shortening it to X0...X1 if SHORTEN is true.
541 Draws a horizontal line X1...X3 at Y if RIGHT says so,
542 shortening it to X2...X3 if SHORTEN is true. */
544 horz_line (struct xr_driver *xr, int x0, int x1, int x2, int x3, int y,
545 enum render_line_style left, enum render_line_style right,
548 if (left != RENDER_LINE_NONE && right != RENDER_LINE_NONE && !shorten)
549 dump_line (xr, x0, y, x3, y);
552 if (left != RENDER_LINE_NONE)
553 dump_line (xr, x0, y, shorten ? x1 : x2, y);
554 if (right != RENDER_LINE_NONE)
555 dump_line (xr, shorten ? x2 : x1, y, x3, y);
559 /* Draws a vertical line Y0...Y2 at X if TOP says so,
560 shortening it to Y0...Y1 if SHORTEN is true.
561 Draws a vertical line Y1...Y3 at X if BOTTOM says so,
562 shortening it to Y2...Y3 if SHORTEN is true. */
564 vert_line (struct xr_driver *xr, int y0, int y1, int y2, int y3, int x,
565 enum render_line_style top, enum render_line_style bottom,
568 if (top != RENDER_LINE_NONE && bottom != RENDER_LINE_NONE && !shorten)
569 dump_line (xr, x, y0, x, y3);
572 if (top != RENDER_LINE_NONE)
573 dump_line (xr, x, y0, x, shorten ? y1 : y2);
574 if (bottom != RENDER_LINE_NONE)
575 dump_line (xr, x, shorten ? y2 : y1, x, y3);
580 xr_draw_line (void *xr_, int bb[TABLE_N_AXES][2],
581 enum render_line_style styles[TABLE_N_AXES][2])
583 const int x0 = bb[H][0];
584 const int y0 = bb[V][0];
585 const int x3 = bb[H][1];
586 const int y3 = bb[V][1];
587 const int top = styles[H][0];
588 const int left = styles[V][0];
589 const int bottom = styles[H][1];
590 const int right = styles[V][1];
592 /* The algorithm here is somewhat subtle, to allow it to handle
593 all the kinds of intersections that we need.
595 Three additional ordinates are assigned along the x axis. The
596 first is xc, midway between x0 and x3. The others are x1 and
597 x2; for a single vertical line these are equal to xc, and for
598 a double vertical line they are the ordinates of the left and
599 right half of the double line.
601 yc, y1, and y2 are assigned similarly along the y axis.
603 The following diagram shows the coordinate system and output
604 for double top and bottom lines, single left line, and no
608 y0 ________________________
614 y1 = y2 = yc |######### # |
619 y3 |________#_____#_______|
621 struct xr_driver *xr = xr_;
623 /* Offset from center of each line in a pair of double lines. */
624 int double_line_ofs = (xr->line_space + xr->line_width) / 2;
626 /* Are the lines along each axis single or double?
627 (It doesn't make sense to have different kinds of line on the
628 same axis, so we don't try to gracefully handle that case.) */
629 bool double_vert = top == RENDER_LINE_DOUBLE || bottom == RENDER_LINE_DOUBLE;
630 bool double_horz = left == RENDER_LINE_DOUBLE || right == RENDER_LINE_DOUBLE;
632 /* When horizontal lines are doubled,
633 the left-side line along y1 normally runs from x0 to x2,
634 and the right-side line along y1 from x3 to x1.
635 If the top-side line is also doubled, we shorten the y1 lines,
636 so that the left-side line runs only to x1,
637 and the right-side line only to x2.
638 Otherwise, the horizontal line at y = y1 below would cut off
639 the intersection, which looks ugly:
641 y0 ________________________
646 y1 |######### ########|
649 y2 |######################|
652 y3 |______________________|
653 It is more of a judgment call when the horizontal line is
654 single. We actually choose to cut off the line anyhow, as
655 shown in the first diagram above.
657 bool shorten_y1_lines = top == RENDER_LINE_DOUBLE;
658 bool shorten_y2_lines = bottom == RENDER_LINE_DOUBLE;
659 bool shorten_yc_line = shorten_y1_lines && shorten_y2_lines;
660 int horz_line_ofs = double_vert ? double_line_ofs : 0;
661 int xc = (x0 + x3) / 2;
662 int x1 = xc - horz_line_ofs;
663 int x2 = xc + horz_line_ofs;
665 bool shorten_x1_lines = left == RENDER_LINE_DOUBLE;
666 bool shorten_x2_lines = right == RENDER_LINE_DOUBLE;
667 bool shorten_xc_line = shorten_x1_lines && shorten_x2_lines;
668 int vert_line_ofs = double_horz ? double_line_ofs : 0;
669 int yc = (y0 + y3) / 2;
670 int y1 = yc - vert_line_ofs;
671 int y2 = yc + vert_line_ofs;
674 horz_line (xr, x0, x1, x2, x3, yc, left, right, shorten_yc_line);
677 horz_line (xr, x0, x1, x2, x3, y1, left, right, shorten_y1_lines);
678 horz_line (xr, x0, x1, x2, x3, y2, left, right, shorten_y2_lines);
682 vert_line (xr, y0, y1, y2, y3, xc, top, bottom, shorten_xc_line);
685 vert_line (xr, y0, y1, y2, y3, x1, top, bottom, shorten_x1_lines);
686 vert_line (xr, y0, y1, y2, y3, x2, top, bottom, shorten_x2_lines);
691 xr_measure_cell_width (void *xr_, const struct table_cell *cell,
692 int *min_width, int *max_width)
694 struct xr_driver *xr = xr_;
695 int bb[TABLE_N_AXES][2];
696 int clip[TABLE_N_AXES][2];
703 clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
704 xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, max_width, &h);
707 xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, min_width, &h);
711 xr_measure_cell_height (void *xr_, const struct table_cell *cell, int width)
713 struct xr_driver *xr = xr_;
714 int bb[TABLE_N_AXES][2];
715 int clip[TABLE_N_AXES][2];
722 clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
723 xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, &w, &h);
728 xr_draw_cell (void *xr_, const struct table_cell *cell,
729 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2])
731 struct xr_driver *xr = xr_;
734 xr_layout_cell (xr, cell, bb, clip, PANGO_WRAP_WORD, &w, &h);
737 /* Writes STRING at location (X,Y) trimmed to the given MAX_WIDTH
738 and with the given cell OPTIONS for XR. */
740 draw_text (struct xr_driver *xr, const char *string, int x, int y,
741 int max_width, unsigned int options)
743 struct table_cell cell;
744 int bb[TABLE_N_AXES][2];
747 cell.contents = string;
748 cell.options = options;
751 bb[H][1] = x + max_width;
752 bb[V][1] = xr->font_height;
753 xr_layout_cell (xr, &cell, bb, bb, PANGO_WRAP_WORD_CHAR, &w, &h);
757 /* Writes LEFT left-justified and RIGHT right-justified within
758 (X0...X1) at Y. LEFT or RIGHT or both may be null. */
760 draw_header_line (struct xr_driver *xr, const char *left, const char *right,
761 int x0, int x1, int y)
765 right_width = (draw_text (xr, right, x0, y, x1 - x0, TAB_RIGHT)
766 + xr->font_height / 2);
768 draw_text (xr, left, x0, y, x1 - x0 - right_width, TAB_LEFT);
771 /* Draw top of page headers for XR. */
773 draw_headers (struct xr_driver *xr)
779 y = -3 * xr->font_height;
780 x0 = xr->font_height / 2;
781 x1 = xr->width - xr->font_height / 2;
784 cairo_rectangle (xr->cairo, 0, xr_to_pt (y), xr_to_pt (xr->width),
785 xr_to_pt (2 * (xr->font_height
786 + xr->line_width + xr->line_gutter)));
787 cairo_save (xr->cairo);
788 cairo_set_source_rgb (xr->cairo, 0.9, 0.9, 0.9);
789 cairo_fill_preserve (xr->cairo);
790 cairo_restore (xr->cairo);
791 cairo_stroke (xr->cairo);
793 y += xr->line_width + xr->line_gutter;
795 r1 = xasprintf (_("%s - Page %d"), get_start_date (), xr->page_number);
796 r2 = xasprintf ("%s - %s", version, host_system);
798 draw_header_line (xr, xr->title, r1, x0, x1, y);
799 y += xr->font_height;
801 draw_header_line (xr, xr->subtitle, r2, x0, x1, y);
808 xr_layout_cell (struct xr_driver *xr, const struct table_cell *cell,
809 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
810 PangoWrapMode wrap, int *width, int *height)
812 struct xr_font *font;
814 font = (cell->options & TAB_FIX ? &xr->fonts[XR_FONT_FIXED]
815 : cell->options & TAB_EMPH ? &xr->fonts[XR_FONT_EMPHASIS]
816 : &xr->fonts[XR_FONT_PROPORTIONAL]);
818 pango_layout_set_text (font->layout, cell->contents, -1);
820 pango_layout_set_alignment (
822 ((cell->options & TAB_ALIGNMENT) == TAB_RIGHT ? PANGO_ALIGN_RIGHT
823 : (cell->options & TAB_ALIGNMENT) == TAB_LEFT ? PANGO_ALIGN_LEFT
824 : PANGO_ALIGN_CENTER));
825 pango_layout_set_width (font->layout,
826 bb[H][1] == INT_MAX ? -1 : bb[H][1] - bb[H][0]);
827 pango_layout_set_wrap (font->layout, wrap);
829 if (clip[H][0] != clip[H][1])
831 cairo_save (xr->cairo);
833 if (clip[H][1] != INT_MAX || clip[V][1] != INT_MAX)
835 double x0 = xr_to_pt (clip[H][0]);
836 double y0 = xr_to_pt (clip[V][0] + xr->y);
837 double x1 = xr_to_pt (clip[H][1]);
838 double y1 = xr_to_pt (clip[V][1] + xr->y);
840 cairo_rectangle (xr->cairo, x0, y0, x1 - x0, y1 - y0);
841 cairo_clip (xr->cairo);
844 cairo_translate (xr->cairo,
846 xr_to_pt (bb[V][0] + xr->y));
847 pango_cairo_show_layout (xr->cairo, font->layout);
848 cairo_restore (xr->cairo);
851 if (width != NULL || height != NULL)
855 pango_layout_get_size (font->layout, &w, &h);
863 /* Attempts to load FONT, initializing its other members based on
864 its 'string' member and the information in DRIVER. Returns true
865 if successful, otherwise false. */
867 load_font (struct xr_driver *xr, struct xr_font *font)
869 PangoContext *context;
870 PangoLanguage *language;
872 font->desc = pango_font_description_from_string (font->string);
873 if (font->desc == NULL)
875 error (0, 0, _("\"%s\": bad font specification"), font->string);
878 pango_font_description_set_absolute_size (font->desc, xr->font_height);
880 font->layout = pango_cairo_create_layout (xr->cairo);
881 pango_layout_set_font_description (font->layout, font->desc);
883 language = pango_language_get_default ();
884 context = pango_layout_get_context (font->layout);
885 font->metrics = pango_context_get_metrics (context, font->desc, language);
892 free_font (struct xr_font *font)
895 if (font->desc != NULL)
896 pango_font_description_free (font->desc);
897 pango_font_metrics_unref (font->metrics);
898 if (font->layout != NULL)
899 g_object_unref (font->layout);
902 /* Cairo driver class. */
903 const struct output_driver_class cairo_class =
912 /* GUI rendering helpers. */
917 struct render_page *page;
918 struct xr_driver *xr;
922 struct chart_item *chart;
925 #define CHART_WIDTH 500
926 #define CHART_HEIGHT 375
929 xr_create_driver (cairo_t *cairo)
931 struct xr_driver *xr;
932 struct string_map map;
934 string_map_init (&map);
935 xr = xr_allocate ("cairo", 0, &map);
936 string_map_destroy (&map);
938 xr->width = INT_MAX / 8;
939 xr->length = INT_MAX / 8;
940 if (!xr_set_cairo (xr, cairo))
942 output_driver_destroy (&xr->driver);
948 struct xr_rendering *
949 xr_rendering_create (struct xr_driver *xr, const struct output_item *item,
952 struct xr_rendering *r = NULL;
954 if (is_text_item (item))
956 const struct text_item *text_item = to_text_item (item);
957 const char *text = text_item_get_text (text_item);
958 struct table_item *table_item;
960 table_item = table_item_create (table_from_string (TAB_LEFT, text),
962 r = xr_rendering_create (xr, &table_item->output_item, cr);
963 table_item_unref (table_item);
965 else if (is_table_item (item))
967 r = xzalloc (sizeof *r);
969 xr_set_cairo (xr, cr);
970 r->page = xr_render_table_item (xr, to_table_item (item),
973 else if (is_chart_item (item))
975 r = xzalloc (sizeof *r);
976 r->chart = to_chart_item (output_item_ref (item));
983 xr_rendering_measure (struct xr_rendering *r, int *w, int *h)
985 if (r->chart == NULL)
987 *w = render_page_get_size (r->page, H) / 1024;
988 *h = (render_page_get_size (r->page, V) + r->title_height) / 1024;
998 xr_rendering_draw (struct xr_rendering *r, cairo_t *cr)
1000 if (r->chart == NULL)
1002 struct xr_driver *xr = r->xr;
1004 xr_set_cairo (xr, cr);
1006 render_page_draw (r->page);
1009 xr_draw_chart (r->chart, cr, 0, 0, CHART_WIDTH, CHART_HEIGHT);
1013 xr_draw_chart (const struct chart_item *chart_item, cairo_t *cr,
1014 double x, double y, double width, double height)
1016 struct xrchart_geometry geom;
1019 cairo_translate (cr, x, y + height);
1020 cairo_scale (cr, 1.0, -1.0);
1021 xrchart_geometry_init (cr, &geom, width, height);
1022 if (is_boxplot (chart_item))
1023 xrchart_draw_boxplot (chart_item, cr, &geom);
1024 else if (is_histogram_chart (chart_item))
1025 xrchart_draw_histogram (chart_item, cr, &geom);
1026 else if (is_np_plot_chart (chart_item))
1027 xrchart_draw_np_plot (chart_item, cr, &geom);
1028 else if (is_piechart (chart_item))
1029 xrchart_draw_piechart (chart_item, cr, &geom);
1030 else if (is_roc_chart (chart_item))
1031 xrchart_draw_roc (chart_item, cr, &geom);
1032 else if (is_scree (chart_item))
1033 xrchart_draw_scree (chart_item, cr, &geom);
1036 xrchart_geometry_free (cr, &geom);
1042 xr_draw_png_chart (const struct chart_item *item,
1043 const char *file_name_template, int number)
1045 const int width = 640;
1046 const int length = 480;
1048 cairo_surface_t *surface;
1049 cairo_status_t status;
1050 const char *number_pos;
1054 number_pos = strchr (file_name_template, '#');
1055 if (number_pos != NULL)
1056 file_name = xasprintf ("%.*s%d%s", (int) (number_pos - file_name_template),
1057 file_name_template, number, number_pos + 1);
1059 file_name = xstrdup (file_name_template);
1061 surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, width, length);
1062 cr = cairo_create (surface);
1065 cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
1066 cairo_rectangle (cr, 0, 0, width, length);
1070 cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
1072 xr_draw_chart (item, cr, 0.0, 0.0, width, length);
1074 status = cairo_surface_write_to_png (surface, file_name);
1075 if (status != CAIRO_STATUS_SUCCESS)
1076 error (0, 0, _("writing output file \"%s\": %s"),
1077 file_name, cairo_status_to_string (status));
1080 cairo_surface_destroy (surface);