/* PSPP - a program for statistical analysis.
- Copyright (C) 2009, 2010, 2011, 2012, 2013, 2014, 2015 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/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"
static void xr_draw_line (void *, int bb[TABLE_N_AXES][2],
enum render_line_style styles[TABLE_N_AXES][2]);
static void xr_measure_cell_width (void *, const struct table_cell *,
- int footnote_idx, int *min, int *max);
+ int *min, int *max);
static int xr_measure_cell_height (void *, const struct table_cell *,
- int footnote_idx, int width);
-static void xr_draw_cell (void *, const struct table_cell *, int footnote_idx,
+ int width);
+static void xr_draw_cell (void *, const struct table_cell *,
int bb[TABLE_N_AXES][2],
int clip[TABLE_N_AXES][2]);
-static int xr_adjust_break (void *, const struct table_cell *, int footnote_idx,
+static int xr_adjust_break (void *, const struct table_cell *,
int width, int height);
static struct xr_render_fsm *xr_render_output_item (
for (i = 0; i < TABLE_N_AXES; i++)
xr->params->min_break[i] = xr->min_break[i];
+ xr->params->supports_margins = true;
}
cairo_set_source_rgb (xr->cairo, xr->fg.red, xr->fg.green, xr->fg.blue);
}
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);
+ struct output_driver *od = xr_create (fh_get_file_name (fh), device_type, o, XR_PDF);
+ fh_unref (fh);
+ return od ;
}
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);
+ struct output_driver *od = xr_create (fh_get_file_name (fh), device_type, o, XR_PS);
+ fh_unref (fh);
+ return od ;
}
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);
+ struct output_driver *od = xr_create (fh_get_file_name (fh), device_type, o, XR_SVG);
+ fh_unref (fh);
+ return od ;
}
static void
cairo_destroy (xr->cairo);
}
- free (xr->command_name);
for (i = 0; i < XR_N_FONTS; i++)
{
struct xr_font *font = &xr->fonts[i];
{
struct xr_driver *xr = xr_driver_cast (driver);
- output_driver_track_current_command (output_item, &xr->command_name);
-
xr_driver_output_item (xr, output_item);
while (xr_driver_need_new_page (xr))
{
}
\f
static void
-xr_layout_cell (struct xr_driver *, const struct table_cell *, int footnote_idx,
+xr_layout_cell (struct xr_driver *, const struct table_cell *,
int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
int *width, int *height, int *brk);
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];
+ const int start_of_line = render_direction_rtl() ? styles[V][1]: styles[V][0];
+ const int end_of_line = render_direction_rtl() ? styles[V][0]: styles[V][1];
/* The algorithm here is somewhat subtle, to allow it to handle
all the kinds of intersections that we need.
(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, 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, shorten_y1_lines);
+ horz_line (xr, x0, x1, x2, x3, y2, start_of_line, end_of_line, shorten_y2_lines);
}
if (!double_vert)
static void
xr_measure_cell_width (void *xr_, const struct table_cell *cell,
- int footnote_idx, int *min_width, int *max_width)
+ int *min_width, int *max_width)
{
struct xr_driver *xr = xr_;
int bb[TABLE_N_AXES][2];
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, footnote_idx, bb, clip, max_width, &h, NULL);
+ xr_layout_cell (xr, cell, bb, clip, max_width, &h, NULL);
bb[H][1] = 1;
- xr_layout_cell (xr, cell, footnote_idx, bb, clip, min_width, &h, NULL);
+ xr_layout_cell (xr, cell, bb, clip, min_width, &h, NULL);
if (*min_width > 0)
*min_width += xr->cell_margin * 2;
}
static int
-xr_measure_cell_height (void *xr_, const struct table_cell *cell,
- int footnote_idx, int width)
+xr_measure_cell_height (void *xr_, const struct table_cell *cell, int width)
{
struct xr_driver *xr = xr_;
int bb[TABLE_N_AXES][2];
bb[H][0] = 0;
bb[H][1] = width - xr->cell_margin * 2;
- if (bb[H][1] <= 0)
- return 0;
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, footnote_idx, bb, clip, &w, &h, NULL);
+ xr_layout_cell (xr, cell, bb, clip, &w, &h, NULL);
return h;
}
static void
-xr_draw_cell (void *xr_, const struct table_cell *cell, int footnote_idx,
+xr_draw_cell (void *xr_, const struct table_cell *cell,
int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2])
{
struct xr_driver *xr = xr_;
bb[H][1] -= xr->cell_margin;
if (bb[H][0] >= bb[H][1])
return;
- xr_layout_cell (xr, cell, footnote_idx, bb, clip, &w, &h, &brk);
+ xr_layout_cell (xr, cell, bb, clip, &w, &h, &brk);
}
static int
-xr_adjust_break (void *xr_, const struct table_cell *cell, int footnote_idx,
+xr_adjust_break (void *xr_, const struct table_cell *cell,
int width, int height)
{
struct xr_driver *xr = xr_;
int clip[TABLE_N_AXES][2];
int w, h, brk;
- if (xr_measure_cell_height (xr_, cell, footnote_idx, width) < height)
+ if (xr_measure_cell_height (xr_, cell, width) < height)
return -1;
bb[H][0] = 0;
bb[V][0] = 0;
bb[V][1] = height;
clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
- xr_layout_cell (xr, cell, footnote_idx, bb, clip, &w, &h, &brk);
+ xr_layout_cell (xr, cell, bb, clip, &w, &h, &brk);
return brk;
}
\f
static int
xr_layout_cell_text (struct xr_driver *xr,
- const struct cell_contents *contents, int footnote_idx,
+ const struct cell_contents *contents,
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;
else if (contents->n_footnotes == 1 && (options & TAB_ALIGNMENT) == TAB_RIGHT)
{
PangoAttrList *attrs;
- char marker[16];
font = &xr->fonts[XR_FONT_MARKER];
- str_format_26adic (footnote_idx + 1, false, marker, sizeof marker);
+ const char *marker = contents->footnotes[0]->marker;
pango_layout_set_text (font->layout, marker, strlen (marker));
attrs = pango_attr_list_new ();
xr_clip (xr, clip);
cairo_translate (xr->cairo,
xr_to_pt (bb[H][1] + xr->x),
- xr_to_pt (y + xr->y));
+ xr_to_pt (bb[V][0] + xr->y));
pango_layout_set_alignment (font->layout, PANGO_ALIGN_LEFT);
pango_layout_set_width (font->layout, -1);
pango_cairo_show_layout (xr->cairo, font->layout);
{
PangoAttrList *attrs;
struct string s;
- size_t i;
bb[H][1] += xr->cell_margin;
ds_init_empty (&s);
ds_extend (&s, length + contents->n_footnotes * 10);
ds_put_cstr (&s, contents->text);
- for (i = 0; i < contents->n_footnotes; i++)
- {
- char marker[16];
-
- if (i > 0)
- ds_put_byte (&s, ',');
- str_format_26adic (footnote_idx + i + 1, false, marker, sizeof marker);
- ds_put_cstr (&s, marker);
- }
+ cell_contents_format_footnote_markers (contents, &s);
pango_layout_set_text (font->layout, ds_cstr (&s), ds_length (&s));
ds_destroy (&s);
xr_clip (xr, clip);
cairo_translate (xr->cairo,
xr_to_pt (bb[H][0] + xr->x),
- xr_to_pt (y + xr->y));
+ 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
h = pango_to_xr (h);
if (w > *widthp)
*widthp = w;
- if (y + h >= bb[V][1])
+ if (bb[V][0] + h >= bb[V][1])
{
PangoLayoutIter *iter;
int best UNUSED = 0;
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. */
}
pango_layout_set_attributes (font->layout, NULL);
- return y + h;
-}
-
-static int
-xr_layout_cell_subtable (struct xr_driver *xr,
- const struct cell_contents *contents,
- int footnote_idx UNUSED,
- int bb[TABLE_N_AXES][2],
- int clip[TABLE_N_AXES][2], int *widthp, int *brk)
-{
- int single_width, double_width;
- struct render_params params;
- struct render_pager *p;
- int r[TABLE_N_AXES][2];
- int width, height;
- int i;
-
- 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++)
- {
- 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;
- }
-
- xr->nest++;
- p = render_pager_create (¶ms, contents->table);
- width = render_pager_get_size (p, H);
- height = render_pager_get_size (p, V);
- if (bb[V][0] + height >= bb[V][1])
- *brk = bb[V][0] + render_pager_get_best_breakpoint (p, 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_pager_draw_region (p, 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_pager_destroy (p);
- xr->nest--;
-
- if (width > *widthp)
- *widthp = width;
- return bb[V][0] + height;
+ return bb[V][0] + h;
}
static void
xr_layout_cell (struct xr_driver *xr, const struct table_cell *cell,
- int footnote_idx,
int bb_[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
int *width, int *height, int *brk)
{
*brk = bb[V][0];
}
- if (contents->text)
- bb[V][0] = xr_layout_cell_text (xr, contents, footnote_idx, bb, clip,
- bb[V][0], width, brk);
- else
- bb[V][0] = xr_layout_cell_subtable (xr, contents, footnote_idx,
- bb, clip, width, brk);
- footnote_idx += contents->n_footnotes;
+ bb[V][0] = xr_layout_cell_text (xr, contents, bb, clip, width, brk);
}
*height = bb[V][0] - bb_[V][0];
}
return r;
}
-void
+void
xr_rendering_apply_options (struct xr_rendering *xr, struct string_map *o)
{
if (is_table_item (xr->item))
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)
+xr_rendering_draw_all (struct xr_rendering *r, cairo_t *cr)
{
if (is_table_item (r->item))
{
xr_set_cairo (xr, cr);
- xr->y = 0;
- render_pager_draw_region (r->p,
- x * XR_POINT, y * XR_POINT,
- w * XR_POINT, h * XR_POINT);
+ render_pager_draw (r->p);
+
}
else
xr_draw_chart (to_chart_item (r->item), cr,
{
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;
}
struct xr_render_fsm *fsm;
char *s;
- s = msg_to_string (msg, xr->command_name);
+ s = msg_to_string (msg, message_item->command_name);
fsm = xr_create_text_renderer (xr, s);
free (s);
projects / pspp / blobdiff