/* PSPP - a program for statistical analysis.
- Copyright (C) 2009, 2010, 2011, 2012, 2013, 2014 Free Software Foundation, Inc.
+ Copyright (C) 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "libpspp/assertion.h"
#include "libpspp/cast.h"
+#include "libpspp/hash-functions.h"
#include "libpspp/message.h"
+#include "libpspp/pool.h"
#include "libpspp/start-date.h"
#include "libpspp/str.h"
#include "libpspp/string-map.h"
#include "libpspp/version.h"
+#include "data/file-handle-def.h"
#include "output/cairo-chart.h"
#include "output/chart-item-provider.h"
#include "output/charts/boxplot.h"
#include "output/charts/np-plot.h"
#include "output/charts/piechart.h"
+#include "output/charts/barchart.h"
#include "output/charts/plot-hist.h"
#include "output/charts/roc-chart.h"
#include "output/charts/spreadlevel-plot.h"
#include "output/charts/scree.h"
+#include "output/charts/scatterplot.h"
#include "output/driver-provider.h"
+#include "output/group-item.h"
#include "output/message-item.h"
#include "output/options.h"
+#include "output/page-eject-item.h"
+#include "output/page-setup-item.h"
#include "output/render.h"
-#include "output/tab.h"
#include "output/table-item.h"
#include "output/table.h"
#include "output/text-item.h"
#include <cairo/cairo-ps.h>
#include <cairo/cairo-svg.h>
#include <cairo/cairo.h>
+#include <inttypes.h>
#include <math.h>
#include <pango/pango-font.h>
#include <pango/pango-layout.h>
#include <pango/pangocairo.h>
#include <stdlib.h>
+#include "gl/c-ctype.h"
+#include "gl/c-strcase.h"
#include "gl/intprops.h"
#include "gl/minmax.h"
#include "gl/xalloc.h"
#define H TABLE_HORZ
#define V TABLE_VERT
-/* The unit used for internal measurements is inch/(72 * XR_POINT). */
+/* The unit used for internal measurements is inch/(72 * XR_POINT).
+ (Thus, XR_POINT units represent one point.) */
#define XR_POINT PANGO_SCALE
/* Conversions to and from points. */
return x / (double) XR_POINT;
}
+/* Conversion from 1/96" units ("pixels") to Cairo/Pango units. */
+static int
+px_to_xr (int x)
+{
+ return x * (PANGO_SCALE * 72 / 96);
+}
+
+/* Dimensions for drawing lines in tables. */
+#define XR_LINE_WIDTH (XR_POINT / 2) /* Width of an ordinary line. */
+#define XR_LINE_SPACE XR_POINT /* Space between double lines. */
+
/* Output types. */
enum xr_output_type
{
enum xr_font_type
{
XR_FONT_PROPORTIONAL,
- XR_FONT_EMPHASIS,
XR_FONT_FIXED,
XR_N_FONTS
};
int top_margin; /* Top margin in inch/(72 * XR_POINT). */
int bottom_margin; /* Bottom margin in inch/(72 * XR_POINT). */
- int line_gutter; /* Space around lines. */
- int line_space; /* Space between lines. */
- int line_width; /* Width of lines. */
-
int min_break[TABLE_N_AXES]; /* Min cell size to break across pages. */
+ int object_spacing; /* Space between output objects. */
- struct xr_color bg; /* Background color */
- struct xr_color fg; /* Foreground color */
+ struct cell_color bg; /* Background color */
+ struct cell_color fg; /* Foreground color */
+ bool transparent; /* true -> do not render background */
+ bool systemcolors; /* true -> do not change colors */
+
+ int initial_page_number;
+
+ struct page_heading headings[2]; /* Top and bottom headings. */
+ int headings_height[2];
/* Internal state. */
struct render_params *params;
+ double font_scale;
int char_width, char_height;
- char *command_name;
- char *title;
- char *subtitle;
cairo_t *cairo;
+ cairo_surface_t *surface;
int page_number; /* Current page number. */
- int x, y;
+ int y;
struct xr_render_fsm *fsm;
- int nest;
};
static const struct output_driver_class cairo_driver_class;
static void xr_driver_run_fsm (struct xr_driver *);
static void xr_draw_line (void *, int bb[TABLE_N_AXES][2],
- enum render_line_style styles[TABLE_N_AXES][2]);
+ enum render_line_style styles[TABLE_N_AXES][2],
+ struct cell_color colors[TABLE_N_AXES][2]);
static void xr_measure_cell_width (void *, const struct table_cell *,
int *min, int *max);
static int xr_measure_cell_height (void *, const struct table_cell *,
int width);
-static void xr_draw_cell (void *, const struct table_cell *,
- int bb[TABLE_N_AXES][2],
+static void xr_draw_cell (void *, const struct table_cell *, int color_idx,
+ int bb[TABLE_N_AXES][2], int valign_offset,
+ int spill[TABLE_N_AXES][2],
int clip[TABLE_N_AXES][2]);
static int xr_adjust_break (void *, const struct table_cell *,
int width, int height);
return driver_option_get (d, options, key, default_value);
}
-/* Parse color information specified by KEY into {RED,GREEN,BLUE}.
- Currently, the input string must be of the form "#RRRRGGGGBBBB"
- Future implementations might allow things like "yellow" and
- "sky-blue-ultra-brown"
-*/
-void
-parse_color (struct output_driver *d, struct string_map *options,
- const char *key, const char *default_value,
- struct xr_color *color)
+static PangoFontDescription *
+parse_font (const char *font, int default_size, bool bold, bool italic)
{
- int red, green, blue;
- char *string = parse_string (opt (d, options, key, default_value));
+ if (!c_strcasecmp (font, "Monospaced"))
+ font = "Monospace";
- if (3 != sscanf (string, "#%04x%04x%04x", &red, &green, &blue))
- {
- /* If the parsed option string fails, then try the default value */
- if ( 3 != sscanf (default_value, "#%04x%04x%04x", &red, &green, &blue))
- {
- /* ... and if that fails set everything to zero */
- red = green = blue = 0;
- }
- }
+ PangoFontDescription *desc = pango_font_description_from_string (font);
+ if (desc == NULL)
+ return NULL;
- free (string);
+ /* If the font description didn't include an explicit font size, then set it
+ to DEFAULT_SIZE, which is in inch/72000 units. */
+ if (!(pango_font_description_get_set_fields (desc) & PANGO_FONT_MASK_SIZE))
+ pango_font_description_set_size (desc,
+ (default_size / 1000.0) * PANGO_SCALE);
- /* Convert 16 bit ints to float */
- color->red = red / (double) 0xFFFF;
- color->green = green / (double) 0xFFFF;
- color->blue = blue / (double) 0xFFFF;
+ pango_font_description_set_weight (desc, (bold
+ ? PANGO_WEIGHT_BOLD
+ : PANGO_WEIGHT_NORMAL));
+ pango_font_description_set_style (desc, (italic
+ ? PANGO_STYLE_ITALIC
+ : PANGO_STYLE_NORMAL));
+
+ return desc;
}
static PangoFontDescription *
-parse_font (struct output_driver *d, struct string_map *options,
- const char *key, const char *default_value,
- int default_size)
+parse_font_option (struct output_driver *d, struct string_map *options,
+ const char *key, const char *default_value,
+ int default_size, bool bold, bool italic)
{
- PangoFontDescription *desc;
- char *string;
-
- /* Parse KEY as a font description. */
- string = parse_string (opt (d, options, key, default_value));
- desc = pango_font_description_from_string (string);
- if (desc == NULL)
+ char *string = parse_string (opt (d, options, key, default_value));
+ PangoFontDescription *desc = parse_font (string, default_size, bold, italic);
+ if (!desc)
{
msg (MW, _("`%s': bad font specification"), string);
/* Fall back to DEFAULT_VALUE, which had better be a valid font
description. */
- desc = pango_font_description_from_string (default_value);
+ desc = parse_font (default_value, default_size, bold, italic);
assert (desc != NULL);
}
free (string);
- /* If the font description didn't include an explicit font size, then set it
- to DEFAULT_SIZE, which is in inch/72000 units. */
- if (!(pango_font_description_get_set_fields (desc) & PANGO_FONT_MASK_SIZE))
- pango_font_description_set_size (desc,
- (default_size / 1000.0) * PANGO_SCALE);
-
return desc;
}
-
static void
apply_options (struct xr_driver *xr, struct string_map *o)
{
}
font_size = parse_int (opt (d, o, "font-size", "10000"), 1000, 1000000);
- xr->fonts[XR_FONT_FIXED].desc = parse_font (d, o, "fixed-font", "monospace",
- font_size);
- xr->fonts[XR_FONT_PROPORTIONAL].desc = parse_font (d, o, "prop-font",
- "serif", font_size);
- xr->fonts[XR_FONT_EMPHASIS].desc = parse_font (d, o, "emph-font",
- "serif italic", font_size);
+ xr->fonts[XR_FONT_FIXED].desc = parse_font_option
+ (d, o, "fixed-font", "monospace", font_size, false, false);
+ xr->fonts[XR_FONT_PROPORTIONAL].desc = parse_font_option (
+ d, o, "prop-font", "sans serif", font_size, false, false);
- xr->line_gutter = parse_dimension (opt (d, o, "gutter", "3pt")) * scale;
- xr->line_space = XR_POINT;
- xr->line_width = XR_POINT / 2;
- xr->page_number = 0;
+ xr->fg = parse_color (opt (d, o, "foreground-color", "#000000000000"));
+ xr->bg = parse_color (opt (d, o, "background-color", "#FFFFFFFFFFFF"));
- parse_color (d, o, "background-color", "#FFFFFFFFFFFF", &xr->bg);
- parse_color (d, o, "foreground-color", "#000000000000", &xr->fg);
+ xr->transparent = parse_boolean (opt (d, o, "transparent", "false"));
+ xr->systemcolors = parse_boolean (opt (d, o, "systemcolors", "false"));
/* Get dimensions. */
parse_paper_size (opt (d, o, "paper-size", ""), &paper_width, &paper_length);
min_break[H] = parse_dimension (opt (d, o, "min-hbreak", NULL)) * scale;
min_break[V] = parse_dimension (opt (d, o, "min-vbreak", NULL)) * scale;
+ int object_spacing = (parse_dimension (opt (d, o, "object-spacing", NULL))
+ * scale);
+
/* Convert to inch/(XR_POINT * 72). */
xr->left_margin = left_margin * scale;
xr->right_margin = right_margin * scale;
xr->length = (paper_length - top_margin - bottom_margin) * scale;
xr->min_break[H] = min_break[H] >= 0 ? min_break[H] : xr->width / 2;
xr->min_break[V] = min_break[V] >= 0 ? min_break[V] : xr->length / 2;
+ xr->object_spacing = object_spacing >= 0 ? object_spacing : XR_POINT * 12;
+
+ /* There are no headings so headings_height can stay 0. */
}
static struct xr_driver *
-xr_allocate (const char *name, int device_type, struct string_map *o)
+xr_allocate (const char *name, int device_type, struct string_map *o,
+ double font_scale)
{
struct xr_driver *xr = xzalloc (sizeof *xr);
struct output_driver *d = &xr->driver;
output_driver_init (d, &cairo_driver_class, name, device_type);
+ /* This is a nasty kluge for an issue that does not make sense. On any
+ surface other than a screen (e.g. for output to PDF or PS or SVG), the
+ fonts are way too big by default. A "9-point" font seems to appear about
+ 16 points tall. We use a scale factor for these surfaces to help, but the
+ underlying issue is a mystery. */
+ xr->font_scale = font_scale;
+
apply_options (xr, o);
return xr;
: xr);
}
+static void
+xr_measure_fonts (cairo_t *cairo, const struct xr_font fonts[XR_N_FONTS],
+ int *char_width, int *char_height)
+{
+ *char_width = 0;
+ *char_height = 0;
+ for (int i = 0; i < XR_N_FONTS; i++)
+ {
+ PangoLayout *layout = pango_cairo_create_layout (cairo);
+ pango_layout_set_font_description (layout, fonts[i].desc);
+
+ pango_layout_set_text (layout, "0", 1);
+
+ int cw, ch;
+ pango_layout_get_size (layout, &cw, &ch);
+ *char_width = MAX (*char_width, pango_to_xr (cw));
+ *char_height = MAX (*char_height, pango_to_xr (ch));
+
+ g_object_unref (G_OBJECT (layout));
+ }
+}
+
+static int
+get_layout_height (PangoLayout *layout)
+{
+ int w, h;
+ pango_layout_get_size (layout, &w, &h);
+ return h;
+}
+
+static int
+xr_render_page_heading (cairo_t *cairo, const PangoFontDescription *font,
+ const struct page_heading *ph, int page_number,
+ int width, bool draw, int base_y)
+{
+ PangoLayout *layout = pango_cairo_create_layout (cairo);
+ pango_layout_set_font_description (layout, font);
+
+ int y = 0;
+ for (size_t i = 0; i < ph->n; i++)
+ {
+ const struct page_paragraph *pp = &ph->paragraphs[i];
+
+ char *markup = output_driver_substitute_heading_vars (pp->markup,
+ page_number);
+ pango_layout_set_markup (layout, markup, -1);
+ free (markup);
+
+ pango_layout_set_alignment (
+ layout,
+ (pp->halign == TABLE_HALIGN_LEFT ? PANGO_ALIGN_LEFT
+ : pp->halign == TABLE_HALIGN_CENTER ? PANGO_ALIGN_CENTER
+ : pp->halign == TABLE_HALIGN_MIXED ? PANGO_ALIGN_LEFT
+ : PANGO_ALIGN_RIGHT));
+ pango_layout_set_width (layout, xr_to_pango (width));
+ if (draw)
+ {
+ cairo_save (cairo);
+ cairo_translate (cairo, 0, xr_to_pt (y + base_y));
+ pango_cairo_show_layout (cairo, layout);
+ cairo_restore (cairo);
+ }
+
+ y += pango_to_xr (get_layout_height (layout));
+ }
+
+ g_object_unref (G_OBJECT (layout));
+
+ return y;
+}
+
+static int
+xr_measure_headings (cairo_surface_t *surface,
+ const PangoFontDescription *font,
+ const struct page_heading headings[2],
+ int width, int object_spacing, int height[2])
+{
+ cairo_t *cairo = cairo_create (surface);
+ int total = 0;
+ for (int i = 0; i < 2; i++)
+ {
+ int h = xr_render_page_heading (cairo, font, &headings[i], -1,
+ width, false, 0);
+
+ /* If the top heading is nonempty, add some space below it. */
+ if (h && i == 0)
+ h += object_spacing;
+
+ if (height)
+ height[i] = h;
+ total += h;
+ }
+ cairo_destroy (cairo);
+ return total;
+}
+
static bool
-xr_set_cairo (struct xr_driver *xr, cairo_t *cairo)
+xr_check_fonts (cairo_surface_t *surface,
+ const struct xr_font fonts[XR_N_FONTS],
+ int usable_width, int usable_length)
{
- int i;
+ cairo_t *cairo = cairo_create (surface);
+ int char_width, char_height;
+ xr_measure_fonts (cairo, fonts, &char_width, &char_height);
+ cairo_destroy (cairo);
+
+ bool ok = true;
+ enum { MIN_WIDTH = 3, MIN_LENGTH = 3 };
+ if (usable_width / char_width < MIN_WIDTH)
+ {
+ msg (ME, _("The defined page is not wide enough to hold at least %d "
+ "characters in the default font. In fact, there's only "
+ "room for %d characters."),
+ MIN_WIDTH, usable_width / char_width);
+ ok = false;
+ }
+ if (usable_length / char_height < MIN_LENGTH)
+ {
+ msg (ME, _("The defined page is not long enough to hold at least %d "
+ "lines in the default font. In fact, there's only "
+ "room for %d lines."),
+ MIN_LENGTH, usable_length / char_height);
+ ok = false;
+ }
+ return ok;
+}
+static void
+xr_set_cairo (struct xr_driver *xr, cairo_t *cairo)
+{
xr->cairo = cairo;
- cairo_set_line_width (xr->cairo, xr_to_pt (xr->line_width));
+ cairo_set_line_width (xr->cairo, xr_to_pt (XR_LINE_WIDTH));
- xr->char_width = 0;
- xr->char_height = 0;
- for (i = 0; i < XR_N_FONTS; i++)
+ xr_measure_fonts (xr->cairo, xr->fonts, &xr->char_width, &xr->char_height);
+
+ for (int i = 0; i < XR_N_FONTS; i++)
{
struct xr_font *font = &xr->fonts[i];
- int char_width, char_height;
-
font->layout = pango_cairo_create_layout (cairo);
pango_layout_set_font_description (font->layout, font->desc);
-
- pango_layout_set_text (font->layout, "0", 1);
- pango_layout_get_size (font->layout, &char_width, &char_height);
- xr->char_width = MAX (xr->char_width, pango_to_xr (char_width));
- xr->char_height = MAX (xr->char_height, pango_to_xr (char_height));
}
if (xr->params == NULL)
{
- int single_width, double_width;
+ static const struct render_ops xr_render_ops = {
+ .draw_line = xr_draw_line,
+ .measure_cell_width = xr_measure_cell_width,
+ .measure_cell_height = xr_measure_cell_height,
+ .adjust_break = xr_adjust_break,
+ .draw_cell = xr_draw_cell,
+ };
xr->params = xmalloc (sizeof *xr->params);
- xr->params->draw_line = xr_draw_line;
- xr->params->measure_cell_width = xr_measure_cell_width;
- xr->params->measure_cell_height = xr_measure_cell_height;
- xr->params->adjust_break = xr_adjust_break;
- xr->params->draw_cell = xr_draw_cell;
+ xr->params->ops = &xr_render_ops;
xr->params->aux = xr;
xr->params->size[H] = xr->width;
xr->params->size[V] = xr->length;
xr->params->font_size[H] = xr->char_width;
xr->params->font_size[V] = xr->char_height;
- single_width = 2 * xr->line_gutter + xr->line_width;
- double_width = 2 * xr->line_gutter + xr->line_space + 2 * xr->line_width;
- for (i = 0; i < TABLE_N_AXES; i++)
+ enum { LW = XR_LINE_WIDTH, LS = XR_LINE_SPACE };
+ static const int xr_line_widths[RENDER_N_LINES] =
{
- xr->params->line_widths[i][RENDER_LINE_NONE] = 0;
- xr->params->line_widths[i][RENDER_LINE_SINGLE] = single_width;
- xr->params->line_widths[i][RENDER_LINE_DOUBLE] = double_width;
- }
-
- for (i = 0; i < TABLE_N_AXES; i++)
+ [RENDER_LINE_NONE] = 0,
+ [RENDER_LINE_SINGLE] = LW,
+ [RENDER_LINE_DASHED] = LW,
+ [RENDER_LINE_THICK] = LW * 2,
+ [RENDER_LINE_THIN] = LW / 2,
+ [RENDER_LINE_DOUBLE] = 2 * LW + LS,
+ };
+ xr->params->line_widths = xr_line_widths;
+
+ for (int i = 0; i < TABLE_N_AXES; i++)
xr->params->min_break[i] = xr->min_break[i];
+ xr->params->supports_margins = true;
+ xr->params->rtl = render_direction_rtl ();
}
- cairo_set_source_rgb (xr->cairo, xr->fg.red, xr->fg.green, xr->fg.blue);
-
- return true;
+ if (!xr->systemcolors)
+ cairo_set_source_rgb (xr->cairo,
+ xr->fg.r / 255.0, xr->fg.g / 255.0, xr->fg.b / 255.0);
}
static struct output_driver *
-xr_create (const char *file_name, enum settings_output_devices device_type,
+xr_create (struct file_handle *fh, enum settings_output_devices device_type,
struct string_map *o, enum xr_output_type file_type)
{
- enum { MIN_WIDTH = 3, MIN_LENGTH = 3 };
- struct xr_driver *xr;
- cairo_surface_t *surface;
- cairo_status_t status;
- double width_pt, length_pt;
-
- xr = xr_allocate (file_name, device_type, o);
-
- width_pt = xr_to_pt (xr->width + xr->left_margin + xr->right_margin);
- length_pt = xr_to_pt (xr->length + xr->top_margin + xr->bottom_margin);
+ const char *file_name = fh_get_file_name (fh);
+ struct xr_driver *xr = xr_allocate (file_name, device_type, o, 72.0 / 128.0);
+ double width_pt = xr_to_pt (xr->width + xr->left_margin + xr->right_margin);
+ double length_pt = xr_to_pt (xr->length + xr->top_margin + xr->bottom_margin);
if (file_type == XR_PDF)
- surface = cairo_pdf_surface_create (file_name, width_pt, length_pt);
+ xr->surface = cairo_pdf_surface_create (file_name, width_pt, length_pt);
else if (file_type == XR_PS)
- surface = cairo_ps_surface_create (file_name, width_pt, length_pt);
+ xr->surface = cairo_ps_surface_create (file_name, width_pt, length_pt);
else if (file_type == XR_SVG)
- surface = cairo_svg_surface_create (file_name, width_pt, length_pt);
+ xr->surface = cairo_svg_surface_create (file_name, width_pt, length_pt);
else
NOT_REACHED ();
- status = cairo_surface_status (surface);
+ cairo_status_t status = cairo_surface_status (xr->surface);
if (status != CAIRO_STATUS_SUCCESS)
{
msg (ME, _("error opening output file `%s': %s"),
- file_name, cairo_status_to_string (status));
- cairo_surface_destroy (surface);
+ file_name, cairo_status_to_string (status));
goto error;
}
- xr->cairo = cairo_create (surface);
- cairo_surface_destroy (surface);
-
- if (!xr_set_cairo (xr, xr->cairo))
+ if (!xr_check_fonts (xr->surface, xr->fonts, xr->width, xr->length))
goto error;
- cairo_save (xr->cairo);
- xr_driver_next_page (xr, xr->cairo);
-
- if (xr->width / xr->char_width < MIN_WIDTH)
- {
- msg (ME, _("The defined page is not wide enough to hold at least %d "
- "characters in the default font. In fact, there's only "
- "room for %d characters."),
- MIN_WIDTH,
- xr->width / xr->char_width);
- goto error;
- }
-
- if (xr->length / xr->char_height < MIN_LENGTH)
- {
- msg (ME, _("The defined page is not long enough to hold at least %d "
- "lines in the default font. In fact, there's only "
- "room for %d lines."),
- MIN_LENGTH,
- xr->length / xr->char_height);
- goto error;
- }
-
+ fh_unref (fh);
return &xr->driver;
error:
+ fh_unref (fh);
output_driver_destroy (&xr->driver);
return NULL;
}
static struct output_driver *
-xr_pdf_create (const char *file_name, enum settings_output_devices device_type,
+xr_pdf_create (struct file_handle *fh, enum settings_output_devices device_type,
struct string_map *o)
{
- return xr_create (file_name, device_type, o, XR_PDF);
+ return xr_create (fh, device_type, o, XR_PDF);
}
static struct output_driver *
-xr_ps_create (const char *file_name, enum settings_output_devices device_type,
+xr_ps_create (struct file_handle *fh, enum settings_output_devices device_type,
struct string_map *o)
{
- return xr_create (file_name, device_type, o, XR_PS);
+ return xr_create (fh, device_type, o, XR_PS);
}
static struct output_driver *
-xr_svg_create (const char *file_name, enum settings_output_devices device_type,
+xr_svg_create (struct file_handle *fh, enum settings_output_devices device_type,
struct string_map *o)
{
- return xr_create (file_name, device_type, o, XR_SVG);
+ return xr_create (fh, device_type, o, XR_SVG);
}
static void
if (xr->cairo != NULL)
{
- cairo_status_t status;
-
- cairo_surface_finish (cairo_get_target (xr->cairo));
- status = cairo_status (xr->cairo);
+ cairo_surface_finish (xr->surface);
+ cairo_status_t status = cairo_status (xr->cairo);
if (status != CAIRO_STATUS_SUCCESS)
- msg (ME, _("error drawing output for %s driver: %s"),
- output_driver_get_name (driver),
- cairo_status_to_string (status));
+ fprintf (stderr, _("error drawing output for %s driver: %s"),
+ output_driver_get_name (driver),
+ cairo_status_to_string (status));
+ cairo_surface_destroy (xr->surface);
+
cairo_destroy (xr->cairo);
}
- free (xr->command_name);
for (i = 0; i < XR_N_FONTS; i++)
{
struct xr_font *font = &xr->fonts[i];
}
static void
-xr_init_caption_cell (const char *caption, struct table_cell *cell,
- struct cell_contents *contents)
+xr_update_page_setup (struct output_driver *driver,
+ const struct page_setup *ps)
{
- contents->options = TAB_LEFT;
- contents->text = CONST_CAST (char *, caption);
- contents->table = NULL;
- cell->contents = contents;
- cell->n_contents = 1;
- cell->destructor = NULL;
-}
+ struct xr_driver *xr = xr_driver_cast (driver);
-static struct render_page *
-xr_render_table_item (struct xr_driver *xr, const struct table_item *item,
- int *caption_widthp, int *caption_heightp)
-{
- const char *caption = table_item_get_caption (item);
+ xr->initial_page_number = ps->initial_page_number;
+ xr->object_spacing = ps->object_spacing * 72 * XR_POINT;
- if (caption != NULL)
- {
- /* XXX doesn't do well with very large captions */
- struct cell_contents contents;
- int min_width, max_width;
- struct table_cell cell;
+ if (xr->cairo)
+ return;
- xr_init_caption_cell (caption, &cell, &contents);
+ int usable[TABLE_N_AXES];
+ for (int i = 0; i < 2; i++)
+ usable[i] = (ps->paper[i]
+ - (ps->margins[i][0] + ps->margins[i][1])) * 72 * XR_POINT;
- xr_measure_cell_width (xr, &cell, &min_width, &max_width);
- *caption_widthp = MIN (max_width, xr->width);
- *caption_heightp = xr_measure_cell_height (xr, &cell, *caption_widthp);
- }
- else
- *caption_heightp = 0;
+ int headings_height[2];
+ usable[V] -= xr_measure_headings (
+ xr->surface, xr->fonts[XR_FONT_PROPORTIONAL].desc, ps->headings,
+ usable[H], xr->object_spacing, headings_height);
+
+ enum table_axis h = ps->orientation == PAGE_LANDSCAPE;
+ enum table_axis v = !h;
+ if (!xr_check_fonts (xr->surface, xr->fonts, usable[h], usable[v]))
+ return;
- return render_page_create (xr->params, table_item_get_table (item));
+ for (int i = 0; i < 2; i++)
+ {
+ page_heading_uninit (&xr->headings[i]);
+ page_heading_copy (&xr->headings[i], &ps->headings[i]);
+ xr->headings_height[i] = headings_height[i];
+ }
+ xr->width = usable[h];
+ xr->length = usable[v];
+ xr->left_margin = ps->margins[h][0] * 72 * XR_POINT;
+ xr->right_margin = ps->margins[h][1] * 72 * XR_POINT;
+ xr->top_margin = ps->margins[v][0] * 72 * XR_POINT;
+ xr->bottom_margin = ps->margins[v][1] * 72 * XR_POINT;
+ cairo_pdf_surface_set_size (xr->surface,
+ ps->paper[h] * 72.0, ps->paper[v] * 72.0);
}
static void
{
struct xr_driver *xr = xr_driver_cast (driver);
- output_driver_track_current_command (output_item, &xr->command_name);
+ if (is_page_setup_item (output_item))
+ {
+ xr_update_page_setup (driver,
+ to_page_setup_item (output_item)->page_setup);
+ return;
+ }
+
+ if (!xr->cairo)
+ {
+ xr->page_number = xr->initial_page_number - 1;
+ xr_set_cairo (xr, cairo_create (xr->surface));
+ cairo_save (xr->cairo);
+ xr_driver_next_page (xr, xr->cairo);
+ }
xr_driver_output_item (xr, output_item);
while (xr_driver_need_new_page (xr))
See the big comment in cairo.h for intended usage. */
-/* Gives new page CAIRO to XR for output. CAIRO may be null to skip actually
- rendering the page (which might be useful to find out how many pages an
- output document has without actually rendering it). */
+/* Gives new page CAIRO to XR for output. */
void
xr_driver_next_page (struct xr_driver *xr, cairo_t *cairo)
{
- if (cairo != NULL)
+ if (!xr->transparent)
{
cairo_save (cairo);
- cairo_set_source_rgb (cairo, xr->bg.red, xr->bg.green, xr->bg.blue);
+ cairo_set_source_rgb (cairo,
+ xr->bg.r / 255.0, xr->bg.g / 255.0, xr->bg.b / 255.0);
cairo_rectangle (cairo, 0, 0, xr->width, xr->length);
cairo_fill (cairo);
cairo_restore (cairo);
-
- cairo_translate (cairo,
- xr_to_pt (xr->left_margin),
- xr_to_pt (xr->top_margin));
}
+ cairo_translate (cairo,
+ xr_to_pt (xr->left_margin),
+ xr_to_pt (xr->top_margin + xr->headings_height[0]));
xr->page_number++;
xr->cairo = cairo;
- xr->x = xr->y = 0;
+ xr->y = 0;
+
+ xr_render_page_heading (xr->cairo, xr->fonts[XR_FONT_PROPORTIONAL].desc,
+ &xr->headings[0], xr->page_number, xr->width, true,
+ -xr->headings_height[0]);
+ xr_render_page_heading (xr->cairo, xr->fonts[XR_FONT_PROPORTIONAL].desc,
+ &xr->headings[1], xr->page_number, xr->width, true,
+ xr->length);
+
xr_driver_run_fsm (xr);
}
int *width, int *height, int *brk);
static void
-dump_line (struct xr_driver *xr, int x0, int y0, int x1, int y1)
+set_source_rgba (cairo_t *cairo, const struct cell_color *color)
+{
+ cairo_set_source_rgba (cairo,
+ color->r / 255., color->g / 255., color->b / 255.,
+ color->alpha / 255.);
+}
+
+static void
+dump_line (struct xr_driver *xr, int x0, int y0, int x1, int y1, int style,
+ const struct cell_color *color)
{
cairo_new_path (xr->cairo);
- cairo_move_to (xr->cairo, xr_to_pt (x0 + xr->x), xr_to_pt (y0 + xr->y));
- cairo_line_to (xr->cairo, xr_to_pt (x1 + xr->x), xr_to_pt (y1 + xr->y));
+ if (!xr->systemcolors)
+ set_source_rgba (xr->cairo, color);
+ cairo_set_line_width (
+ xr->cairo,
+ xr_to_pt (style == RENDER_LINE_THICK ? XR_LINE_WIDTH * 2
+ : style == RENDER_LINE_THIN ? XR_LINE_WIDTH / 2
+ : XR_LINE_WIDTH));
+ cairo_move_to (xr->cairo, xr_to_pt (x0), xr_to_pt (y0 + xr->y));
+ cairo_line_to (xr->cairo, xr_to_pt (x1), xr_to_pt (y1 + xr->y));
cairo_stroke (xr->cairo);
}
dump_rectangle (struct xr_driver *xr, int x0, int y0, int x1, int y1)
{
cairo_new_path (xr->cairo);
- cairo_move_to (xr->cairo, xr_to_pt (x0 + xr->x), xr_to_pt (y0 + xr->y));
- cairo_line_to (xr->cairo, xr_to_pt (x1 + xr->x), xr_to_pt (y0 + xr->y));
- cairo_line_to (xr->cairo, xr_to_pt (x1 + xr->x), xr_to_pt (y1 + xr->y));
- cairo_line_to (xr->cairo, xr_to_pt (x0 + xr->x), xr_to_pt (y1 + xr->y));
+ cairo_set_line_width (xr->cairo, xr_to_pt (XR_LINE_WIDTH));
cairo_close_path (xr->cairo);
cairo_stroke (xr->cairo);
+ cairo_move_to (xr->cairo, xr_to_pt (x0), xr_to_pt (y0 + xr->y));
+ cairo_line_to (xr->cairo, xr_to_pt (x1), xr_to_pt (y0 + xr->y));
+ cairo_line_to (xr->cairo, xr_to_pt (x1), xr_to_pt (y1 + xr->y));
+ cairo_line_to (xr->cairo, xr_to_pt (x0), xr_to_pt (y1 + xr->y));
+}
+
+static void
+fill_rectangle (struct xr_driver *xr, int x0, int y0, int x1, int y1)
+{
+ cairo_new_path (xr->cairo);
+ cairo_set_line_width (xr->cairo, xr_to_pt (XR_LINE_WIDTH));
+ cairo_rectangle (xr->cairo,
+ xr_to_pt (x0), xr_to_pt (y0 + xr->y),
+ xr_to_pt (x1 - x0), xr_to_pt (y1 - y0));
+ cairo_fill (xr->cairo);
}
/* Draws a horizontal line X0...X2 at Y if LEFT says so,
static void
horz_line (struct xr_driver *xr, int x0, int x1, int x2, int x3, int y,
enum render_line_style left, enum render_line_style right,
+ const struct cell_color *left_color,
+ const struct cell_color *right_color,
bool shorten)
{
- if (left != RENDER_LINE_NONE && right != RENDER_LINE_NONE && !shorten)
- dump_line (xr, x0, y, x3, y);
+ if (left != RENDER_LINE_NONE && right != RENDER_LINE_NONE && !shorten
+ && cell_color_equal (left_color, right_color))
+ dump_line (xr, x0, y, x3, y, left, left_color);
else
{
if (left != RENDER_LINE_NONE)
- dump_line (xr, x0, y, shorten ? x1 : x2, y);
+ dump_line (xr, x0, y, shorten ? x1 : x2, y, left, left_color);
if (right != RENDER_LINE_NONE)
- dump_line (xr, shorten ? x2 : x1, y, x3, y);
+ dump_line (xr, shorten ? x2 : x1, y, x3, y, right, right_color);
}
}
static void
vert_line (struct xr_driver *xr, int y0, int y1, int y2, int y3, int x,
enum render_line_style top, enum render_line_style bottom,
+ const struct cell_color *top_color,
+ const struct cell_color *bottom_color,
bool shorten)
{
- if (top != RENDER_LINE_NONE && bottom != RENDER_LINE_NONE && !shorten)
- dump_line (xr, x, y0, x, y3);
+ if (top != RENDER_LINE_NONE && bottom != RENDER_LINE_NONE && !shorten
+ && cell_color_equal (top_color, bottom_color))
+ dump_line (xr, x, y0, x, y3, top, top_color);
else
{
if (top != RENDER_LINE_NONE)
- dump_line (xr, x, y0, x, shorten ? y1 : y2);
+ dump_line (xr, x, y0, x, shorten ? y1 : y2, top, top_color);
if (bottom != RENDER_LINE_NONE)
- dump_line (xr, x, shorten ? y2 : y1, x, y3);
+ dump_line (xr, x, shorten ? y2 : y1, x, y3, bottom, bottom_color);
}
}
static void
xr_draw_line (void *xr_, int bb[TABLE_N_AXES][2],
- enum render_line_style styles[TABLE_N_AXES][2])
+ enum render_line_style styles[TABLE_N_AXES][2],
+ struct cell_color colors[TABLE_N_AXES][2])
{
const int x0 = bb[H][0];
const int y0 = bb[V][0];
const int x3 = bb[H][1];
const int y3 = bb[V][1];
const int top = styles[H][0];
- const int left = styles[V][0];
const int bottom = styles[H][1];
- const int right = styles[V][1];
+
+ int start_side = render_direction_rtl();
+ int end_side = !start_side;
+ const int start_of_line = styles[V][start_side];
+ const int end_of_line = styles[V][end_side];
+ const struct cell_color *top_color = &colors[H][0];
+ const struct cell_color *bottom_color = &colors[H][1];
+ const struct cell_color *start_color = &colors[V][start_side];
+ const struct cell_color *end_color = &colors[V][end_side];
/* The algorithm here is somewhat subtle, to allow it to handle
all the kinds of intersections that we need.
struct xr_driver *xr = xr_;
/* Offset from center of each line in a pair of double lines. */
- int double_line_ofs = (xr->line_space + xr->line_width) / 2;
+ int double_line_ofs = (XR_LINE_SPACE + XR_LINE_WIDTH) / 2;
/* Are the lines along each axis single or double?
(It doesn't make sense to have different kinds of line on the
same axis, so we don't try to gracefully handle that case.) */
bool double_vert = top == RENDER_LINE_DOUBLE || bottom == RENDER_LINE_DOUBLE;
- bool double_horz = left == RENDER_LINE_DOUBLE || right == RENDER_LINE_DOUBLE;
+ bool double_horz = start_of_line == RENDER_LINE_DOUBLE || end_of_line == RENDER_LINE_DOUBLE;
/* When horizontal lines are doubled,
the left-side line along y1 normally runs from x0 to x2,
int x1 = xc - horz_line_ofs;
int x2 = xc + horz_line_ofs;
- bool shorten_x1_lines = left == RENDER_LINE_DOUBLE;
- bool shorten_x2_lines = right == RENDER_LINE_DOUBLE;
+ bool shorten_x1_lines = start_of_line == RENDER_LINE_DOUBLE;
+ bool shorten_x2_lines = end_of_line == RENDER_LINE_DOUBLE;
bool shorten_xc_line = shorten_x1_lines && shorten_x2_lines;
int vert_line_ofs = double_horz ? double_line_ofs : 0;
int yc = (y0 + y3) / 2;
int y2 = yc + vert_line_ofs;
if (!double_horz)
- horz_line (xr, x0, x1, x2, x3, yc, left, right, shorten_yc_line);
+ horz_line (xr, x0, x1, x2, x3, yc, start_of_line, end_of_line,
+ start_color, end_color, shorten_yc_line);
else
{
- horz_line (xr, x0, x1, x2, x3, y1, left, right, shorten_y1_lines);
- horz_line (xr, x0, x1, x2, x3, y2, left, right, shorten_y2_lines);
+ horz_line (xr, x0, x1, x2, x3, y1, start_of_line, end_of_line,
+ start_color, end_color, shorten_y1_lines);
+ horz_line (xr, x0, x1, x2, x3, y2, start_of_line, end_of_line,
+ start_color, end_color, shorten_y2_lines);
}
if (!double_vert)
- vert_line (xr, y0, y1, y2, y3, xc, top, bottom, shorten_xc_line);
+ vert_line (xr, y0, y1, y2, y3, xc, top, bottom, top_color, bottom_color,
+ shorten_xc_line);
else
{
- vert_line (xr, y0, y1, y2, y3, x1, top, bottom, shorten_x1_lines);
- vert_line (xr, y0, y1, y2, y3, x2, top, bottom, shorten_x2_lines);
+ vert_line (xr, y0, y1, y2, y3, x1, top, bottom, top_color, bottom_color,
+ shorten_x1_lines);
+ vert_line (xr, y0, y1, y2, y3, x2, top, bottom, top_color, bottom_color,
+ shorten_x2_lines);
}
}
bb[H][1] = 1;
xr_layout_cell (xr, cell, bb, clip, min_width, &h, NULL);
+
+ if (*min_width > 0)
+ *min_width += px_to_xr (cell->style->cell_style.margin[H][0]
+ + cell->style->cell_style.margin[H][1]);
+ if (*max_width > 0)
+ *max_width += px_to_xr (cell->style->cell_style.margin[H][0]
+ + cell->style->cell_style.margin[H][1]);
}
static int
int w, h;
bb[H][0] = 0;
- bb[H][1] = width;
+ bb[H][1] = width - px_to_xr (cell->style->cell_style.margin[H][0]
+ + cell->style->cell_style.margin[H][1]);
bb[V][0] = 0;
bb[V][1] = INT_MAX;
clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
xr_layout_cell (xr, cell, bb, clip, &w, &h, NULL);
+ h += px_to_xr (cell->style->cell_style.margin[V][0]
+ + cell->style->cell_style.margin[V][1]);
return h;
}
+static void xr_clip (struct xr_driver *, int clip[TABLE_N_AXES][2]);
+
static void
-xr_draw_cell (void *xr_, const struct table_cell *cell,
- int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2])
+xr_draw_cell (void *xr_, const struct table_cell *cell, int color_idx,
+ int bb[TABLE_N_AXES][2], int valign_offset,
+ int spill[TABLE_N_AXES][2],
+ int clip[TABLE_N_AXES][2])
{
struct xr_driver *xr = xr_;
int w, h, brk;
- xr_layout_cell (xr, cell, bb, clip, &w, &h, &brk);
+ if (!xr->transparent)
+ {
+ cairo_save (xr->cairo);
+ int bg_clip[TABLE_N_AXES][2];
+ for (int axis = 0; axis < TABLE_N_AXES; axis++)
+ {
+ bg_clip[axis][0] = clip[axis][0];
+ if (bb[axis][0] == clip[axis][0])
+ bg_clip[axis][0] -= spill[axis][0];
+
+ bg_clip[axis][1] = clip[axis][1];
+ if (bb[axis][1] == clip[axis][1])
+ bg_clip[axis][1] += spill[axis][1];
+ }
+ xr_clip (xr, bg_clip);
+ set_source_rgba (xr->cairo, &cell->style->font_style.bg[color_idx]);
+ fill_rectangle (xr,
+ bb[H][0] - spill[H][0],
+ bb[V][0] - spill[V][0],
+ bb[H][1] + spill[H][1],
+ bb[V][1] + spill[V][1]);
+ cairo_restore (xr->cairo);
+ }
+ cairo_save (xr->cairo);
+ if (!xr->systemcolors)
+ set_source_rgba (xr->cairo, &cell->style->font_style.fg[color_idx]);
+
+ bb[V][0] += valign_offset;
+
+ for (int axis = 0; axis < TABLE_N_AXES; axis++)
+ {
+ bb[axis][0] += px_to_xr (cell->style->cell_style.margin[axis][0]);
+ bb[axis][1] -= px_to_xr (cell->style->cell_style.margin[axis][1]);
+ }
+ if (bb[H][0] < bb[H][1] && bb[V][0] < bb[V][1])
+ xr_layout_cell (xr, cell, bb, clip, &w, &h, &brk);
+ cairo_restore (xr->cairo);
}
static int
return -1;
bb[H][0] = 0;
- bb[H][1] = width;
+ bb[H][1] = width - px_to_xr (cell->style->cell_style.margin[H][0]
+ + cell->style->cell_style.margin[H][1]);
+ if (bb[H][1] <= 0)
+ return 0;
bb[V][0] = 0;
- bb[V][1] = height;
+ bb[V][1] = height - px_to_xr (cell->style->cell_style.margin[V][0]
+ + cell->style->cell_style.margin[V][1]);
clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
xr_layout_cell (xr, cell, bb, clip, &w, &h, &brk);
return brk;
{
if (clip[H][1] != INT_MAX || clip[V][1] != INT_MAX)
{
- double x0 = xr_to_pt (clip[H][0] + xr->x);
+ double x0 = xr_to_pt (clip[H][0]);
double y0 = xr_to_pt (clip[V][0] + xr->y);
- double x1 = xr_to_pt (clip[H][1] + xr->x);
+ double x1 = xr_to_pt (clip[H][1]);
double y1 = xr_to_pt (clip[V][1] + xr->y);
cairo_rectangle (xr->cairo, x0, y0, x1 - x0, y1 - y0);
}
}
+static void
+add_attr (PangoAttrList *list, PangoAttribute *attr,
+ guint start_index, guint end_index)
+{
+ attr->start_index = start_index;
+ attr->end_index = end_index;
+ pango_attr_list_insert (list, attr);
+}
+
+static void
+markup_escape (struct string *out, unsigned int options,
+ const char *in, size_t len)
+{
+ if (!(options & TAB_MARKUP))
+ {
+ ds_put_substring (out, ss_buffer (in, len == -1 ? strlen (in) : len));
+ return;
+ }
+
+ while (len-- > 0)
+ {
+ int c = *in++;
+ switch (c)
+ {
+ case 0:
+ return;
+ case '&':
+ ds_put_cstr (out, "&");
+ break;
+ case '<':
+ ds_put_cstr (out, "<");
+ break;
+ case '>':
+ ds_put_cstr (out, ">");
+ break;
+ default:
+ ds_put_byte (out, c);
+ break;
+ }
+ }
+}
+
static int
-xr_layout_cell_text (struct xr_driver *xr,
- const struct cell_contents *contents,
+get_layout_dimension (PangoLayout *layout, enum table_axis axis)
+{
+ int size[TABLE_N_AXES];
+ pango_layout_get_size (layout, &size[H], &size[V]);
+ return size[axis];
+}
+
+static int
+xr_layout_cell_text (struct xr_driver *xr, const struct table_cell *cell,
int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
- int y, int *widthp, int *brk)
+ int *widthp, int *brk)
{
- unsigned int options = contents->options;
- struct xr_font *font;
- int w, h;
+ const struct font_style *font_style = &cell->style->font_style;
+ const struct cell_style *cell_style = &cell->style->cell_style;
+ unsigned int options = cell->options;
+
+ enum table_axis X = options & TAB_ROTATE ? V : H;
+ enum table_axis Y = !X;
+ int R = options & TAB_ROTATE ? 0 : 1;
+
+ struct xr_font *font = (options & TAB_FIX ? &xr->fonts[XR_FONT_FIXED]
+ : &xr->fonts[XR_FONT_PROPORTIONAL]);
+ struct xr_font local_font;
+ if (font_style->typeface)
+ {
+ PangoFontDescription *desc = parse_font (
+ font_style->typeface,
+ font_style->size ? font_style->size * 1000 * xr->font_scale : 10000,
+ font_style->bold, font_style->italic);
+ if (desc)
+ {
+ PangoLayout *layout = pango_cairo_create_layout (xr->cairo);
+ pango_layout_set_font_description (layout, desc);
- font = (options & TAB_FIX ? &xr->fonts[XR_FONT_FIXED]
- : options & TAB_EMPH ? &xr->fonts[XR_FONT_EMPHASIS]
- : &xr->fonts[XR_FONT_PROPORTIONAL]);
+ local_font.desc = desc;
+ local_font.layout = layout;
+ font = &local_font;
+ }
+ }
- pango_layout_set_text (font->layout, contents->text, -1);
+ const char *text = cell->text;
+ enum table_halign halign = table_halign_interpret (
+ cell_style->halign, cell->options & TAB_NUMERIC);
+ if (cell_style->halign == TABLE_HALIGN_DECIMAL && !(options & TAB_ROTATE))
+ {
+ int margin_adjustment = -px_to_xr (cell_style->decimal_offset);
- pango_layout_set_alignment (
- font->layout,
- ((options & TAB_ALIGNMENT) == TAB_RIGHT ? PANGO_ALIGN_RIGHT
- : (options & TAB_ALIGNMENT) == TAB_LEFT ? PANGO_ALIGN_LEFT
- : PANGO_ALIGN_CENTER));
+ const char *decimal = strrchr (text, cell_style->decimal_char);
+ if (decimal)
+ {
+ pango_layout_set_text (font->layout, decimal, strlen (decimal));
+ pango_layout_set_width (font->layout, -1);
+ margin_adjustment += get_layout_dimension (font->layout, H);
+ }
+
+ if (margin_adjustment < 0)
+ bb[H][1] += margin_adjustment;
+ }
+
+ struct string tmp = DS_EMPTY_INITIALIZER;
+ PangoAttrList *attrs = NULL;
+
+ /* Deal with an oddity of the Unicode line-breaking algorithm (or perhaps in
+ Pango's implementation of it): it will break after a period or a comma
+ that precedes a digit, e.g. in ".000" it will break after the period.
+ This code looks for such a situation and inserts a U+2060 WORD JOINER
+ to prevent the break.
+
+ This isn't necessary when the decimal point is between two digits
+ (e.g. "0.000" won't be broken) or when the display width is not limited so
+ that word wrapping won't happen.
+
+ It isn't necessary to look for more than one period or comma, as would
+ happen with grouping like 1,234,567.89 or 1.234.567,89 because if groups
+ are present then there will always be a digit on both sides of every
+ period and comma. */
+ if (options & TAB_MARKUP)
+ {
+ PangoAttrList *new_attrs;
+ char *new_text;
+ if (pango_parse_markup (text, -1, 0, &new_attrs, &new_text, NULL, NULL))
+ {
+ attrs = new_attrs;
+ tmp.ss = ss_cstr (new_text);
+ tmp.capacity = tmp.ss.length;
+ }
+ else
+ {
+ /* XXX should we report the error? */
+ ds_put_cstr (&tmp, text);
+ }
+ }
+ else if (options & TAB_ROTATE || bb[H][1] != INT_MAX)
+ {
+ const char *decimal = text + strcspn (text, ".,");
+ if (decimal[0]
+ && c_isdigit (decimal[1])
+ && (decimal == text || !c_isdigit (decimal[-1])))
+ {
+ ds_extend (&tmp, strlen (text) + 16);
+ markup_escape (&tmp, options, text, decimal - text + 1);
+ ds_put_unichar (&tmp, 0x2060 /* U+2060 WORD JOINER */);
+ markup_escape (&tmp, options, decimal + 1, -1);
+ }
+ }
+
+ if (font_style->underline)
+ {
+ if (!attrs)
+ attrs = pango_attr_list_new ();
+ pango_attr_list_insert (attrs, pango_attr_underline_new (
+ PANGO_UNDERLINE_SINGLE));
+ }
+
+ if (cell->n_footnotes || cell->n_subscripts || cell->superscript)
+ {
+ /* If we haven't already put TEXT into tmp, do it now. */
+ if (ds_is_empty (&tmp))
+ {
+ ds_extend (&tmp, strlen (text) + 16);
+ markup_escape (&tmp, options, text, -1);
+ }
+
+ size_t subscript_ofs = ds_length (&tmp);
+ for (size_t i = 0; i < cell->n_subscripts; i++)
+ {
+ if (i)
+ ds_put_byte (&tmp, ',');
+ ds_put_cstr (&tmp, cell->subscripts[i]);
+ }
+
+ size_t superscript_ofs = ds_length (&tmp);
+ if (cell->superscript)
+ ds_put_cstr (&tmp, cell->superscript);
+
+ size_t footnote_ofs = ds_length (&tmp);
+ for (size_t i = 0; i < cell->n_footnotes; i++)
+ {
+ if (i)
+ ds_put_byte (&tmp, ',');
+ ds_put_cstr (&tmp, cell->footnotes[i]->marker);
+ }
+
+ /* Allow footnote markers to occupy the right margin. That way, numbers
+ in the column are still aligned. */
+ if (cell->n_footnotes && halign == TABLE_HALIGN_RIGHT)
+ {
+ /* Measure the width of the footnote marker, so we know how much we
+ need to make room for. */
+ pango_layout_set_text (font->layout, ds_cstr (&tmp) + footnote_ofs,
+ ds_length (&tmp) - footnote_ofs);
+
+ PangoAttrList *fn_attrs = pango_attr_list_new ();
+ pango_attr_list_insert (
+ fn_attrs, pango_attr_scale_new (PANGO_SCALE_SMALL));
+ pango_attr_list_insert (fn_attrs, pango_attr_rise_new (3000));
+ pango_layout_set_attributes (font->layout, fn_attrs);
+ pango_attr_list_unref (fn_attrs);
+ int footnote_width = get_layout_dimension (font->layout, X);
+
+ /* Bound the adjustment by the width of the right margin. */
+ int right_margin = px_to_xr (cell_style->margin[X][R]);
+ int footnote_adjustment = MIN (footnote_width, right_margin);
+
+ /* Adjust the bounding box. */
+ if (options & TAB_ROTATE)
+ footnote_adjustment = -footnote_adjustment;
+ bb[X][R] += footnote_adjustment;
+
+ /* Clean up. */
+ pango_layout_set_attributes (font->layout, NULL);
+ }
+
+ /* Set attributes. */
+ if (!attrs)
+ attrs = pango_attr_list_new ();
+ add_attr (attrs, pango_attr_font_desc_new (font->desc), subscript_ofs,
+ PANGO_ATTR_INDEX_TO_TEXT_END);
+ add_attr (attrs, pango_attr_scale_new (PANGO_SCALE_SMALL),
+ subscript_ofs, PANGO_ATTR_INDEX_TO_TEXT_END);
+ if (cell->n_subscripts)
+ add_attr (attrs, pango_attr_rise_new (-3000), subscript_ofs,
+ superscript_ofs - subscript_ofs);
+ if (cell->superscript || cell->n_footnotes)
+ add_attr (attrs, pango_attr_rise_new (3000), superscript_ofs,
+ PANGO_ATTR_INDEX_TO_TEXT_END);
+ }
+
+ /* Set the attributes, if any. */
+ if (attrs)
+ {
+ pango_layout_set_attributes (font->layout, attrs);
+ pango_attr_list_unref (attrs);
+ }
+
+ /* Set the text. */
+ if (ds_is_empty (&tmp))
+ pango_layout_set_text (font->layout, text, -1);
+ else
+ pango_layout_set_text (font->layout, ds_cstr (&tmp), ds_length (&tmp));
+ ds_destroy (&tmp);
+
+ pango_layout_set_alignment (font->layout,
+ (halign == TABLE_HALIGN_RIGHT ? PANGO_ALIGN_RIGHT
+ : halign == TABLE_HALIGN_LEFT ? PANGO_ALIGN_LEFT
+ : PANGO_ALIGN_CENTER));
pango_layout_set_width (
font->layout,
- bb[H][1] == INT_MAX ? -1 : xr_to_pango (bb[H][1] - bb[H][0]));
+ bb[X][1] == INT_MAX ? -1 : xr_to_pango (bb[X][1] - bb[X][0]));
pango_layout_set_wrap (font->layout, PANGO_WRAP_WORD);
if (clip[H][0] != clip[H][1])
{
cairo_save (xr->cairo);
- xr_clip (xr, clip);
- cairo_translate (xr->cairo,
- xr_to_pt (bb[H][0] + xr->x),
- xr_to_pt (y + xr->y));
+ if (!(options & TAB_ROTATE))
+ xr_clip (xr, clip);
+ if (options & TAB_ROTATE)
+ {
+ cairo_translate (xr->cairo,
+ xr_to_pt (bb[H][0]),
+ xr_to_pt (bb[V][1] + xr->y));
+ cairo_rotate (xr->cairo, -M_PI_2);
+ }
+ else
+ cairo_translate (xr->cairo,
+ xr_to_pt (bb[H][0]),
+ xr_to_pt (bb[V][0] + xr->y));
pango_cairo_show_layout (xr->cairo, font->layout);
/* If enabled, this draws a blue rectangle around the extents of each
cairo_save (xr->cairo);
cairo_set_source_rgb (xr->cairo, 1, 0, 0);
dump_rectangle (xr,
- pango_to_xr (extents.x) - xr->x,
+ pango_to_xr (extents.x),
pango_to_xr (extents.y) - xr->y,
- pango_to_xr (extents.x + extents.width) - xr->x,
+ pango_to_xr (extents.x + extents.width),
pango_to_xr (extents.y + extents.height) - xr->y);
cairo_restore (xr->cairo);
}
cairo_restore (xr->cairo);
}
- pango_layout_get_size (font->layout, &w, &h);
- w = pango_to_xr (w);
- h = pango_to_xr (h);
+ int size[TABLE_N_AXES];
+ pango_layout_get_size (font->layout, &size[H], &size[V]);
+ int w = pango_to_xr (size[X]);
+ int h = pango_to_xr (size[Y]);
if (w > *widthp)
*widthp = w;
- if (y + h >= bb[V][1])
+ if (bb[V][0] + h >= bb[V][1] && !(options & TAB_ROTATE))
{
PangoLayoutIter *iter;
- int best UNUSED = 0;
+ int best = 0;
/* Choose a breakpoint between lines instead of in the middle of one. */
iter = pango_layout_get_iter (font->layout);
extents.y = pango_to_xr (y0);
extents.width = pango_to_xr (extents.width);
extents.height = pango_to_xr (y1 - y0);
- bottom = y + extents.y + extents.height;
+ bottom = bb[V][0] + extents.y + extents.height;
if (bottom < bb[V][1])
{
if (brk && clip[H][0] != clip[H][1])
best = bottom;
- *brk = bottom;
+ if (brk)
+ *brk = bottom;
}
else
break;
}
while (pango_layout_iter_next_line (iter));
+ pango_layout_iter_free (iter);
/* If enabled, draws a green line across the chosen breakpoint, which can
be useful for debugging issues with breaking. */
if (0)
{
- if (best && !xr->nest)
- {
- cairo_save (xr->cairo);
- cairo_set_source_rgb (xr->cairo, 0, 1, 0);
- dump_line (xr, -xr->left_margin, best, xr->width + xr->right_margin, best);
- cairo_restore (xr->cairo);
- }
+ if (best)
+ dump_line (xr, -xr->left_margin, best,
+ xr->width + xr->right_margin, best,
+ RENDER_LINE_SINGLE,
+ &(struct cell_color) CELL_COLOR (0, 255, 0));
}
}
- return y + h;
-}
-static int
-xr_layout_cell_subtable (struct xr_driver *xr,
- const struct cell_contents *contents,
- int bb[TABLE_N_AXES][2],
- int clip[TABLE_N_AXES][2], int *widthp, int *brk)
-{
- const struct table *table = contents->table;
- int single_width, double_width;
- struct render_params params;
- struct render_page *page;
- int r[TABLE_N_AXES][2];
- int width, height;
- int i;
+ pango_layout_set_attributes (font->layout, NULL);
- params.draw_line = xr_draw_line;
- params.measure_cell_width = xr_measure_cell_width;
- params.measure_cell_height = xr_measure_cell_height;
- params.adjust_break = NULL;
- params.draw_cell = xr_draw_cell;
- params.aux = xr;
- params.size[H] = bb[H][1] - bb[H][0];
- params.size[V] = bb[V][1] - bb[V][0];
- params.font_size[H] = xr->char_width;
- params.font_size[V] = xr->char_height;
-
- single_width = 2 * xr->line_gutter + xr->line_width;
- double_width = 2 * xr->line_gutter + xr->line_space + 2 * xr->line_width;
- for (i = 0; i < TABLE_N_AXES; i++)
+ if (font == &local_font)
{
- params.line_widths[i][RENDER_LINE_NONE] = 0;
- params.line_widths[i][RENDER_LINE_SINGLE] = single_width;
- params.line_widths[i][RENDER_LINE_DOUBLE] = double_width;
+ g_object_unref (G_OBJECT (font->layout));
+ pango_font_description_free (font->desc);
}
- xr->nest++;
- page = render_page_create (¶ms, table);
- width = render_page_get_size (page, H);
- height = render_page_get_size (page, V);
- if (bb[V][0] + height >= bb[V][1])
- *brk = bb[V][0] + render_page_get_best_breakpoint (page, bb[V][1] - bb[V][0]);
-
- /* r = intersect(bb, clip) - bb. */
- for (i = 0; i < TABLE_N_AXES; i++)
- {
- r[i][0] = MAX (bb[i][0], clip[i][0]) - bb[i][0];
- r[i][1] = MIN (bb[i][1], clip[i][1]) - bb[i][0];
- }
-
- if (r[H][0] < r[H][1] && r[V][0] < r[V][1])
- {
- unsigned int alignment = contents->options & TAB_ALIGNMENT;
- int save_x = xr->x;
-
- cairo_save (xr->cairo);
- xr_clip (xr, clip);
- xr->x += bb[H][0];
- if (alignment == TAB_RIGHT)
- xr->x += params.size[H] - width;
- else if (alignment == TAB_CENTER)
- xr->x += (params.size[H] - width) / 2;
- xr->y += bb[V][0];
- render_page_draw_region (page, r[H][0], r[V][0],
- r[H][1] - r[H][0], r[V][1] - r[V][0]);
- xr->y -= bb[V][0];
- xr->x = save_x;
- cairo_restore (xr->cairo);
- }
- render_page_unref (page);
- xr->nest--;
-
- if (width > *widthp)
- *widthp = width;
- return bb[V][0] + height;
+ return h;
}
static void
xr_layout_cell (struct xr_driver *xr, const struct table_cell *cell,
- int bb_[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
+ int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
int *width, int *height, int *brk)
{
- int bb[TABLE_N_AXES][2];
- size_t i;
-
*width = 0;
*height = 0;
- if (brk)
- *brk = 0;
-
- memcpy (bb, bb_, sizeof bb);
/* If enabled, draws a blue rectangle around the cell extents, which can be
useful for debugging layout. */
{
if (clip[H][0] != clip[H][1])
{
- int offset = (xr->nest) * XR_POINT;
-
cairo_save (xr->cairo);
cairo_set_source_rgb (xr->cairo, 0, 0, 1);
- dump_rectangle (xr,
- bb[H][0] + offset, bb[V][0] + offset,
- bb[H][1] - offset, bb[V][1] - offset);
+ dump_rectangle (xr, bb[H][0], bb[V][0], bb[H][1], bb[V][1]);
cairo_restore (xr->cairo);
}
}
- for (i = 0; i < cell->n_contents && bb[V][0] < bb[V][1]; i++)
- {
- const struct cell_contents *contents = &cell->contents[i];
-
- if (brk)
- *brk = bb[V][0];
- if (i > 0)
- {
- bb[V][0] += xr->char_height / 2;
- if (bb[V][0] >= bb[V][1])
- break;
- if (brk)
- *brk = bb[V][0];
- }
-
- if (contents->text)
- bb[V][0] = xr_layout_cell_text (xr, contents, bb, clip,
- bb[V][0], width, brk);
- else
- bb[V][0] = xr_layout_cell_subtable (xr, contents, bb, clip, width, brk);
- }
- *height = bb[V][0] - bb_[V][0];
-}
-
-static void
-xr_draw_title (struct xr_driver *xr, const char *title,
- int title_width, int title_height)
-{
- struct cell_contents contents;
- struct table_cell cell;
- int bb[TABLE_N_AXES][2];
-
- xr_init_caption_cell (title, &cell, &contents);
- bb[H][0] = 0;
- bb[H][1] = title_width;
- bb[V][0] = 0;
- bb[V][1] = title_height;
- xr_draw_cell (xr, &cell, bb, bb);
+ if (brk)
+ *brk = bb[V][0];
+ *height = xr_layout_cell_text (xr, cell, bb, clip, width, brk);
}
\f
struct output_driver_factory pdf_driver_factory =
struct output_item *item;
/* Table items. */
- struct render_page *page;
+ struct render_pager *p;
struct xr_driver *xr;
- int title_width;
- int title_height;
};
#define CHART_WIDTH 500
struct xr_driver *
xr_driver_create (cairo_t *cairo, struct string_map *options)
{
- struct xr_driver *xr = xr_allocate ("cairo", 0, options);
- if (!xr_set_cairo (xr, cairo))
- {
- output_driver_destroy (&xr->driver);
- return NULL;
- }
+ struct xr_driver *xr = xr_allocate ("cairo", 0, options, 1.0);
+ xr_set_cairo (xr, cairo);
return xr;
}
struct table_item *table_item;
struct xr_rendering *r;
- table_item = table_item_create (table_from_string (TAB_LEFT, text), NULL);
+ table_item = table_item_create (table_from_string (text), NULL, NULL);
r = xr_rendering_create (xr, &table_item->output_item, cr);
table_item_unref (table_item);
return r;
}
-void
-xr_rendering_apply_options (struct xr_rendering *xr, struct string_map *o)
-{
- if (is_table_item (xr->item))
- apply_options (xr->xr, o);
-}
-
struct xr_rendering *
xr_rendering_create (struct xr_driver *xr, const struct output_item *item,
cairo_t *cr)
else if (is_message_item (item))
{
const struct message_item *message_item = to_message_item (item);
- const struct msg *msg = message_item_get_msg (message_item);
- char *s = msg_to_string (msg, NULL);
+ char *s = msg_to_string (message_item_get_msg (message_item));
r = xr_rendering_create_text (xr, s, cr);
free (s);
}
r->item = output_item_ref (item);
r->xr = xr;
xr_set_cairo (xr, cr);
- r->page = xr_render_table_item (xr, to_table_item (item),
- &r->title_width, &r->title_height);
+ r->p = render_pager_create (xr->params, to_table_item (item));
}
else if (is_chart_item (item))
{
r = xzalloc (sizeof *r);
r->item = output_item_ref (item);
}
+ else if (is_group_open_item (item))
+ r = xr_rendering_create_text (xr, to_group_open_item (item)->command_name,
+ cr);
return r;
}
if (r)
{
output_item_unref (r->item);
- render_page_unref (r->page);
+ render_pager_destroy (r->p);
free (r);
}
}
void
-xr_rendering_measure (struct xr_rendering *r, int *w, int *h)
+xr_rendering_measure (const struct xr_rendering *r, int *wp, int *hp)
{
+ int w, h;
+
if (is_table_item (r->item))
{
- int w0 = render_page_get_size (r->page, H);
- int w1 = r->title_width;
- *w = MAX (w0, w1) / XR_POINT;
- *h = (render_page_get_size (r->page, V) + r->title_height) / XR_POINT;
+ w = render_pager_get_size (r->p, H) / XR_POINT;
+ h = render_pager_get_size (r->p, V) / XR_POINT;
}
else
{
- *w = CHART_WIDTH;
- *h = CHART_HEIGHT;
+ w = CHART_WIDTH;
+ h = CHART_HEIGHT;
}
+
+ if (wp)
+ *wp = w;
+ if (hp)
+ *hp = h;
}
static void xr_draw_chart (const struct chart_item *, cairo_t *,
double x, double y, double width, double height);
-/* Draws onto CR at least the region of R that is enclosed in (X,Y)-(X+W,Y+H),
- and possibly some additional parts. */
+/* Draws onto CR */
void
xr_rendering_draw (struct xr_rendering *r, cairo_t *cr,
- int x, int y, int w, int h)
+ int x0, int y0, int x1, int y1)
{
if (is_table_item (r->item))
{
xr_set_cairo (xr, cr);
- if (r->title_height > 0)
- {
- xr->y = 0;
- xr_draw_title (xr, table_item_get_caption (to_table_item (r->item)),
- r->title_width, r->title_height);
- }
-
- xr->y = r->title_height;
- render_page_draw_region (r->page,
- x * XR_POINT, (y * XR_POINT) - r->title_height,
- w * XR_POINT, h * XR_POINT);
+ render_pager_draw_region (r->p, x0 * XR_POINT, y0 * XR_POINT,
+ (x1 - x0) * XR_POINT, (y1 - y0) * XR_POINT);
}
else
xr_draw_chart (to_chart_item (r->item), cr,
xrchart_draw_np_plot (chart_item, cr, &geom);
else if (is_piechart (chart_item))
xrchart_draw_piechart (chart_item, cr, &geom);
+ else if (is_barchart (chart_item))
+ xrchart_draw_barchart (chart_item, cr, &geom);
else if (is_roc_chart (chart_item))
xrchart_draw_roc (chart_item, cr, &geom);
else if (is_scree (chart_item))
xrchart_draw_scree (chart_item, cr, &geom);
else if (is_spreadlevel_plot_chart (chart_item))
xrchart_draw_spreadlevel (chart_item, cr, &geom);
+ else if (is_scatterplot_chart (chart_item))
+ xrchart_draw_scatterplot (chart_item, cr, &geom);
else
NOT_REACHED ();
xrchart_geometry_free (cr, &geom);
char *
xr_draw_png_chart (const struct chart_item *item,
const char *file_name_template, int number,
- const struct xr_color *fg,
- const struct xr_color *bg
- )
+ const struct cell_color *fg,
+ const struct cell_color *bg)
{
const int width = 640;
const int length = 480;
number_pos = strchr (file_name_template, '#');
if (number_pos != NULL)
- file_name = xasprintf ("%.*s%d%s", (int) (number_pos - file_name_template),
+ file_name = xasprintf ("%.*s%d%s.png", (int) (number_pos - file_name_template),
file_name_template, number, number_pos + 1);
else
- file_name = xstrdup (file_name_template);
+ file_name = xasprintf ("%s.png", file_name_template);
surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, width, length);
cr = cairo_create (surface);
- cairo_set_source_rgb (cr, bg->red, bg->green, bg->blue);
+ cairo_set_source_rgb (cr, bg->r / 255.0, bg->g / 255.0, bg->b / 255.0);
cairo_paint (cr);
- cairo_set_source_rgb (cr, fg->red, fg->green, fg->blue);
+ cairo_set_source_rgb (cr, fg->r / 255.0, fg->g / 255.0, fg->b / 255.0);
xr_draw_chart (item, cr, 0.0, 0.0, width, length);
return file_name;
}
+
+
+char *
+xr_draw_eps_chart (const struct chart_item *item,
+ const char *file_name_template, int number,
+ const struct cell_color *fg,
+ const struct cell_color *bg)
+{
+ const int width = 640;
+ const int length = 480;
+
+ cairo_surface_t *surface;
+ const char *number_pos;
+ char *file_name;
+ cairo_t *cr;
+
+ number_pos = strchr (file_name_template, '#');
+ if (number_pos != NULL)
+ file_name = xasprintf ("%.*s%d%s.eps", (int) (number_pos - file_name_template),
+ file_name_template, number, number_pos + 1);
+ else
+ file_name = xasprintf ("%s.eps", file_name_template);
+
+ surface = cairo_ps_surface_create (file_name, width, length);
+ cairo_ps_surface_set_eps (surface, true);
+ cr = cairo_create (surface);
+
+ cairo_set_source_rgb (cr, bg->r / 255.0, bg->g / 255.0, bg->b / 255.0);
+ cairo_paint (cr);
+
+ cairo_set_source_rgb (cr, fg->r / 255.0, fg->g / 255.0, fg->b / 255.0);
+
+ xr_draw_chart (item, cr, 0.0, 0.0, width, length);
+
+ cairo_destroy (cr);
+ cairo_surface_destroy (surface);
+
+ return file_name;
+}
+
\f
+
struct xr_table_state
{
struct xr_render_fsm fsm;
- struct table_item *table_item;
struct render_pager *p;
- int caption_height;
};
static bool
while (render_pager_has_next (ts->p))
{
- int space = xr->length - xr->y - ts->caption_height;
- struct render_page *slice = render_pager_next (ts->p, space);
+ int used;
- if (!slice)
+ used = render_pager_draw_next (ts->p, xr->length - xr->y);
+ if (!used)
{
assert (xr->y > 0);
return true;
}
-
- if (ts->caption_height)
- {
- if (xr->cairo)
- xr_draw_title (xr, table_item_get_caption (ts->table_item),
- xr->width, ts->caption_height);
-
- xr->y += ts->caption_height;
- ts->caption_height = 0;
- }
-
- if (xr->cairo)
- render_page_draw (slice);
- xr->y += render_page_get_size (slice, V);
- render_page_unref (slice);
+ else
+ xr->y += used;
}
return false;
}
{
struct xr_table_state *ts = UP_CAST (fsm, struct xr_table_state, fsm);
- table_item_unref (ts->table_item);
render_pager_destroy (ts->p);
free (ts);
}
static struct xr_render_fsm *
-xr_render_table (struct xr_driver *xr, const struct table_item *table_item)
+xr_render_table (struct xr_driver *xr, struct table_item *table_item)
{
struct xr_table_state *ts;
- struct render_page *page;
- int caption_width;
ts = xmalloc (sizeof *ts);
ts->fsm.render = xr_table_render;
ts->fsm.destroy = xr_table_destroy;
- ts->table_item = table_item_ref (table_item);
if (xr->y > 0)
xr->y += xr->char_height;
- page = xr_render_table_item (xr, table_item,
- &caption_width, &ts->caption_height);
- xr->params->size[V] = xr->length - ts->caption_height;
-
- ts->p = render_pager_create (page);
+ ts->p = render_pager_create (xr->params, table_item);
+ table_item_unref (table_item);
return &ts->fsm;
}
{
struct xr_chart_state *cs = UP_CAST (fsm, struct xr_chart_state, fsm);
- if (xr->y > 0)
+ const int chart_height = 0.8 * (xr->length < xr->width ? xr->length : xr->width);
+
+ if (xr->y > xr->length - chart_height)
return true;
if (xr->cairo != NULL)
- xr_draw_chart (cs->chart_item, xr->cairo, 0.0, 0.0,
- xr_to_pt (xr->width), xr_to_pt (xr->length));
- xr->y = xr->length;
+ {
+ xr_draw_chart (cs->chart_item, xr->cairo,
+ 0.0,
+ xr_to_pt (xr->y),
+ xr_to_pt (xr->width),
+ xr_to_pt (chart_height));
+ }
+ xr->y += chart_height;
return false;
}
return &eject_renderer;
}
\f
-static struct xr_render_fsm *
-xr_create_text_renderer (struct xr_driver *xr, const char *text)
-{
- struct table_item *table_item;
- struct xr_render_fsm *fsm;
-
- table_item = table_item_create (table_from_string (TAB_LEFT, text), NULL);
- fsm = xr_render_table (xr, table_item);
- table_item_unref (table_item);
-
- return fsm;
-}
-
static struct xr_render_fsm *
xr_render_text (struct xr_driver *xr, const struct text_item *text_item)
{
enum text_item_type type = text_item_get_type (text_item);
- const char *text = text_item_get_text (text_item);
switch (type)
{
- case TEXT_ITEM_TITLE:
- free (xr->title);
- xr->title = xstrdup (text);
- break;
-
- case TEXT_ITEM_SUBTITLE:
- free (xr->subtitle);
- xr->subtitle = xstrdup (text);
- break;
-
- case TEXT_ITEM_COMMAND_CLOSE:
- break;
-
- case TEXT_ITEM_BLANK_LINE:
- if (xr->y > 0)
- xr->y += xr->char_height;
- break;
-
- case TEXT_ITEM_EJECT_PAGE:
- if (xr->y > 0)
- return xr_render_eject ();
+ case TEXT_ITEM_PAGE_TITLE:
break;
default:
- return xr_create_text_renderer (xr, text);
+ return xr_render_table (
+ xr, text_item_to_table_item (text_item_ref (text_item)));
}
return NULL;
xr_render_message (struct xr_driver *xr,
const struct message_item *message_item)
{
- const struct msg *msg = message_item_get_msg (message_item);
- struct xr_render_fsm *fsm;
- char *s;
-
- s = msg_to_string (msg, xr->command_name);
- fsm = xr_create_text_renderer (xr, s);
+ char *s = msg_to_string (message_item_get_msg (message_item));
+ struct text_item *item = text_item_create (TEXT_ITEM_LOG, s);
free (s);
-
- return fsm;
+ return xr_render_table (xr, text_item_to_table_item (item));
}
static struct xr_render_fsm *
const struct output_item *output_item)
{
if (is_table_item (output_item))
- return xr_render_table (xr, to_table_item (output_item));
+ return xr_render_table (xr, table_item_ref (to_table_item (output_item)));
else if (is_chart_item (output_item))
return xr_render_chart (to_chart_item (output_item));
else if (is_text_item (output_item))
return xr_render_text (xr, to_text_item (output_item));
+ else if (is_page_eject_item (output_item))
+ return xr->y > 0 ? xr_render_eject () : NULL;
else if (is_message_item (output_item))
return xr_render_message (xr, to_message_item (output_item));
else
return NULL;
}
+
+bool
+xr_draw_svg_file (struct xr_rendering *r,
+ const char *filename)
+{
+ int width, height;
+ g_assert (r);
+ xr_rendering_measure (r, &width, &height);
+ cairo_surface_t *surface = cairo_svg_surface_create (filename, width, height);
+ if (!surface)
+ {
+ g_error ("Could not create cairo svg surface with file %s", filename);
+ return FALSE;
+ }
+ cairo_t *cr = cairo_create (surface);
+ xr_rendering_draw (r, cr, 0, 0, width, height);
+ cairo_destroy (cr);
+ cairo_surface_destroy (surface);
+ return TRUE;
+}
projects / pspp / blobdiff