X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Foutput%2Frender.c;h=32e6f4513710dbd8696a296e207d7362b24b717f;hb=8502b942ecdbc7d5a688f695cebc6f1bfac79868;hp=83641c20622c56b798124142b47312c6ee301914;hpb=0d95a6ff1dff86f7d1578a8bf20a964c7a00b6c3;p=pspp diff --git a/src/output/render.c b/src/output/render.c index 83641c2062..32e6f45137 100644 --- a/src/output/render.c +++ b/src/output/render.c @@ -26,9 +26,9 @@ #include "libpspp/hash-functions.h" #include "libpspp/hmap.h" #include "libpspp/pool.h" +#include "output/pivot-output.h" +#include "output/pivot-table.h" #include "output/render.h" -#include "output/tab.h" -#include "output/table-item.h" #include "output/table.h" #include "gl/minmax.h" @@ -58,16 +58,16 @@ struct render_page /* Region of 'table' to render. - The horizontal cells rendered are the leftmost h[H][0], then - r[H][0] through r[H][1], exclusive, then the rightmost h[H][1]. + The horizontal cells rendered are the leftmost h[H], then + r[H] through r[H][1]. - The vertical cells rendered are the topmost h[V][0], then r[V][0] - through r[V][1], exclusive, then the bottommost h[V][1]. + The vertical cells rendered are the topmost h[V], then r[V][0] + through r[V][1]. - n[H] = h[H][0] + (r[H][1] - r[H][0]) + h[H][1] - n[V] = h[V][0] + (r[V][1] - r[V][0]) + h[V][1] + n[H] = h[H] + (r[H][1] - r[H][0]) + n[V] = h[V] + (r[V][1] - r[V][0]) */ - int h[TABLE_N_AXES][2]; + int h[TABLE_N_AXES]; int r[TABLE_N_AXES][2]; int n[TABLE_N_AXES]; @@ -79,8 +79,8 @@ struct render_page cp[H][2] = cp[H][1] + the width of the leftmost column. cp[H][3] = cp[H][2] + the width of the second-from-left vertical rule. and so on: - cp[H][2 * nc] = x position of the rightmost vertical rule. - cp[H][2 * nc + 1] = total table width including all rules. + cp[H][2 * n[H]] = x position of the rightmost vertical rule. + cp[H][2 * n[H] + 1] = total table width including all rules. Similarly, cp[V] represents y positions within the table. cp[V][0] = 0. @@ -88,8 +88,8 @@ struct render_page cp[V][2] = cp[V][1] + the height of the topmost row. cp[V][3] = cp[V][2] + the height of the second-from-top horizontal rule. and so on: - cp[V][2 * nr] = y position of the bottommost horizontal rule. - cp[V][2 * nr + 1] = total table height including all rules. + cp[V][2 * n[V]] = y position of the bottommost horizontal rule. + cp[V][2 * n[V] + 1] = total table height including all rules. Rules and columns can have width or height 0, in which case consecutive values in this array are equal. */ @@ -128,20 +128,6 @@ struct render_page When is_edge_cutoff is true for a given edge, the 'overflows' hmap will contain a node for each cell along that edge. */ bool is_edge_cutoff[TABLE_N_AXES][2]; - - /* If part of a joined cell would be cut off by breaking a table along - 'axis' at the rule with offset 'z' (where 0 <= z <= n[axis]), then - join_crossing[axis][z] is the thickness of the rule that would be cut - off. - - This is used to know to allocate extra space for breaking at such a - position, so that part of the cell's content is not lost. - - This affects breaking a table only when headers are present. When - headers are not present, the rule's thickness is used for cell content, - so no part of the cell's content is lost (and in fact it is duplicated - across both pages). */ - int *join_crossing[TABLE_N_AXES]; }; static struct render_page *render_page_create (const struct render_params *, @@ -189,16 +175,18 @@ axis_width (const struct render_page *page, int axis, int ofs0, int ofs1) return page->cp[axis][ofs1] - page->cp[axis][ofs0]; } +/* Returns the total width of PAGE along AXIS. */ +static int +table_width (const struct render_page *page, int axis) +{ + return page->cp[axis][2 * page->n[axis] + 1]; +} + /* Returns the width of the headers in PAGE along AXIS. */ static int headers_width (const struct render_page *page, int axis) { - int h0 = page->h[axis][0]; - int w0 = axis_width (page, axis, rule_ofs (0), cell_ofs (h0)); - int n = page->n[axis]; - int h1 = page->h[axis][1]; - int w1 = axis_width (page, axis, rule_ofs_r (page, axis, h1), cell_ofs (n)); - return w0 + w1; + return axis_width (page, axis, rule_ofs (0), cell_ofs (page->h[axis])); } /* Returns the width of cell X along AXIS in PAGE. */ @@ -235,9 +223,8 @@ joined_width (const struct render_page *page, int axis, int x0, int x1) static int max_cell_width (const struct render_page *page, int axis) { - int n = page->n[axis]; - int x0 = page->h[axis][0]; - int x1 = n - page->h[axis][1]; + int x0 = page->h[axis]; + int x1 = page->n[axis]; int max = 0; for (int x = x0; x < x1; x++) @@ -457,29 +444,6 @@ calculate_table_width (int n, const struct render_row *rows, int *rules) /* Rendering utility functions. */ -/* Returns the line style to use for drawing a rule of the given TYPE. */ -static enum render_line_style -rule_to_render_type (unsigned char type) -{ - switch (type) - { - case TAL_NONE: - return RENDER_LINE_NONE; - case TAL_SOLID: - return RENDER_LINE_SINGLE; - case TAL_DASHED: - return RENDER_LINE_DASHED; - case TAL_THICK: - return RENDER_LINE_THICK; - case TAL_THIN: - return RENDER_LINE_THIN; - case TAL_DOUBLE: - return RENDER_LINE_DOUBLE; - default: - NOT_REACHED (); - } -} - /* Returns the width of the rule in TABLE that is at offset Z along axis A, if rendered with PARAMS. */ static int @@ -490,56 +454,53 @@ measure_rule (const struct render_params *params, const struct table *table, /* Determine all types of rules that are present, as a bitmap in 'rules' where rule type 't' is present if bit 2**t is set. */ - struct cell_color color; unsigned int rules = 0; int d[TABLE_N_AXES]; d[a] = z; for (d[b] = 0; d[b] < table->n[b]; d[b]++) - rules |= 1u << table_get_rule (table, a, d[H], d[V], &color); + rules |= 1u << table_get_rule (table, a, d[H], d[V]).stroke; - /* Turn off TAL_NONE because it has width 0 and we needn't bother. However, - if the device doesn't support margins, make sure that there is at least a - small gap between cells (but we don't need any at the left or right edge - of the table). */ - if (rules & (1u << TAL_NONE)) + /* Turn off TABLE_STROKE_NONE because it has width 0 and we needn't bother. + However, if the device doesn't support margins, make sure that there is at + least a small gap between cells (but we don't need any at the left or + right edge of the table). */ + if (rules & (1u << TABLE_STROKE_NONE)) { - rules &= ~(1u << TAL_NONE); + rules &= ~(1u << TABLE_STROKE_NONE); if (z > 0 && z < table->n[a] && !params->supports_margins && a == H) - rules |= 1u << TAL_SOLID; + rules |= 1u << TABLE_STROKE_SOLID; } /* Calculate maximum width of the rules that are present. */ int width = 0; for (size_t i = 0; i < TABLE_N_STROKES; i++) if (rules & (1u << i)) - width = MAX (width, params->line_widths[a][rule_to_render_type (i)]); + width = MAX (width, params->line_widths[i]); return width; } /* Allocates and returns a new render_page using PARAMS and TABLE. Allocates - space for rendering a table with dimensions given in N. The caller must - initialize most of the members itself. */ + space for rendering a table with dimensions given in N, headers in H, and + content in R. The caller must initialize most of the members itself. */ static struct render_page * render_page_allocate__ (const struct render_params *params, - struct table *table, int n[TABLE_N_AXES]) + struct table *table, + const int n[TABLE_N_AXES], + const int h[TABLE_N_AXES], + const int r[TABLE_N_AXES][2]) { struct render_page *page = xmalloc (sizeof *page); - page->params = params; - page->table = table; - page->ref_cnt = 1; - page->n[H] = n[H]; - page->n[V] = n[V]; - - for (int i = 0; i < TABLE_N_AXES; i++) - { - page->cp[i] = xmalloc ((2 * n[i] + 2) * sizeof *page->cp[i]); - page->join_crossing[i] = xzalloc ((n[i] + 1) - * sizeof *page->join_crossing[i]); - } - - hmap_init (&page->overflows); - memset (page->is_edge_cutoff, 0, sizeof page->is_edge_cutoff); - + *page = (struct render_page) { + .params = params, + .table = table, + .ref_cnt = 1, + .n = { [H] = n[H], [V] = n[V] }, + .h = { [H] = h[H], [V] = h[V] }, + .r = { [H] = { r[H][0], r[H][1] }, [V] = { r[V][0], r[V][1] } }, + .cp = { [H] = xcalloc (2 * n[H] + 2, sizeof *page->cp[H]), + [V] = xcalloc (2 * n[V] + 2, sizeof *page->cp[V]) }, + .overflows = HMAP_INITIALIZER (page->overflows), + }; return page; } @@ -549,15 +510,15 @@ render_page_allocate__ (const struct render_params *params, static struct render_page * render_page_allocate (const struct render_params *params, struct table *table) { - struct render_page *page = render_page_allocate__ (params, table, table->n); + int h[TABLE_N_AXES]; + int r[TABLE_N_AXES][2]; for (enum table_axis a = 0; a < TABLE_N_AXES; a++) { - page->h[a][0] = table->h[a][0]; - page->h[a][1] = table->h[a][1]; - page->r[a][0] = table->h[a][0]; - page->r[a][1] = table->n[a] - table->h[a][1]; + h[a] = table->h[a]; + r[a][0] = table->h[a]; + r[a][1] = table->n[a]; } - return page; + return render_page_allocate__ (params, table, table->n, h, r); } /* Allocates and returns a new render_page for PARAMS and TABLE, initializing @@ -618,16 +579,8 @@ create_page_with_interpolated_widths (const struct render_params *params, return page; } -static void -set_join_crossings (struct render_page *page, enum table_axis axis, - const struct table_cell *cell, int *rules) -{ - for (int z = cell->d[axis][0] + 1; z <= cell->d[axis][1] - 1; z++) - page->join_crossing[axis][z] = rules[z]; -} - /* Maps a contiguous range of cells from a page to the underlying table along - the horizpntal or vertical dimension. */ + the horizontal or vertical dimension. */ struct map { int p0; /* First ordinate in the page. */ @@ -641,24 +594,19 @@ static void get_map (const struct render_page *page, enum table_axis a, int z, struct map *m) { - if (z < page->h[a][0]) + if (z < page->h[a]) { m->p0 = 0; m->t0 = 0; - m->n = page->h[a][0]; + m->n = page->h[a]; } - else if (z < page->n[a] - page->h[a][1]) + else { - m->p0 = page->h[a][0]; + assert (z < page->n[a]); + m->p0 = page->h[a]; m->t0 = page->r[a][0]; m->n = page->r[a][1] - page->r[a][0]; } - else - { - m->p0 = page->n[a] - page->h[a][1]; - m->t0 = page->table->n[a] - page->table->h[a][1]; - m->n = page->h[a][1]; - } } /* Initializes CELL with the contents of the table cell at column X and row Y @@ -693,6 +641,12 @@ render_get_cell (const struct render_page *page, int x, int y, cell->d[a][0] = MAX (cell->d[a][0], m->p0); cell->d[a][1] = MIN (cell->d[a][1], m->p0 + m->n); } + + if (cell->options & TABLE_CELL_FULL_WIDTH) + { + cell->d[H][0] = 0; + cell->d[H][1] = page->n[H]; + } } /* Creates and returns a new render_page for rendering TABLE on a device @@ -707,8 +661,8 @@ render_page_create (const struct render_params *params, struct table *table, { enum { MIN, MAX }; - int nc = table_nc (table); - int nr = table_nr (table); + int nc = table->n[H]; + int nr = table->n[V]; /* Figure out rule widths. */ int *rules[TABLE_N_AXES]; @@ -725,9 +679,9 @@ render_page_create (const struct render_params *params, struct table *table, span multiple columns. */ struct render_row *columns[2]; for (int i = 0; i < 2; i++) - columns[i] = xzalloc (nc * sizeof *columns[i]); + columns[i] = xcalloc (nc, sizeof *columns[i]); for (int y = 0; y < nr; y++) - for (int x = 0; x < nc; ) + for (int x = 0; x < nc;) { struct table_cell cell; @@ -737,15 +691,14 @@ render_page_create (const struct render_params *params, struct table *table, if (table_cell_colspan (&cell) == 1) { int w[2]; - params->measure_cell_width (params->aux, &cell, - &w[MIN], &w[MAX]); + params->ops->measure_cell_width (params->aux, &cell, + &w[MIN], &w[MAX]); for (int i = 0; i < 2; i++) if (columns[i][x].unspanned < w[i]) columns[i][x].unspanned = w[i]; } } x = cell.d[H][1]; - table_cell_free (&cell); } /* Distribute widths of spanned columns. */ @@ -753,7 +706,7 @@ render_page_create (const struct render_params *params, struct table *table, for (int x = 0; x < nc; x++) columns[i][x].width = columns[i][x].unspanned; for (int y = 0; y < nr; y++) - for (int x = 0; x < nc; ) + for (int x = 0; x < nc;) { struct table_cell cell; @@ -762,13 +715,13 @@ render_page_create (const struct render_params *params, struct table *table, { int w[2]; - params->measure_cell_width (params->aux, &cell, &w[MIN], &w[MAX]); + params->ops->measure_cell_width (params->aux, &cell, + &w[MIN], &w[MAX]); for (int i = 0; i < 2; i++) distribute_spanned_width (w[i], &columns[i][cell.d[H][0]], rules[H], table_cell_colspan (&cell)); } x = cell.d[H][1]; - table_cell_free (&cell); } if (min_width > 0) for (int i = 0; i < 2; i++) @@ -784,7 +737,7 @@ render_page_create (const struct render_params *params, struct table *table, /* Decide final column widths. */ int table_widths[2]; for (int i = 0; i < 2; i++) - table_widths[i] = calculate_table_width (table_nc (table), + table_widths[i] = calculate_table_width (table->n[H], columns[i], rules[H]); struct render_page *page; @@ -810,38 +763,30 @@ render_page_create (const struct render_params *params, struct table *table, } /* Calculate heights of cells that do not span multiple rows. */ - struct render_row *rows = xzalloc (nr * sizeof *rows); + struct render_row *rows = XCALLOC (nr, struct render_row); for (int y = 0; y < nr; y++) - for (int x = 0; x < nc; ) + for (int x = 0; x < nc;) { struct render_row *r = &rows[y]; struct table_cell cell; render_get_cell (page, x, y, &cell); - if (y == cell.d[V][0]) + if (y == cell.d[V][0] && table_cell_rowspan (&cell) == 1) { - if (table_cell_rowspan (&cell) == 1) - { - int w = joined_width (page, H, cell.d[H][0], cell.d[H][1]); - int h = params->measure_cell_height (params->aux, &cell, w); - if (h > r->unspanned) - r->unspanned = r->width = h; - } - else - set_join_crossings (page, V, &cell, rules[V]); - - if (table_cell_colspan (&cell) > 1) - set_join_crossings (page, H, &cell, rules[H]); + int w = joined_width (page, H, cell.d[H][0], cell.d[H][1]); + int h = params->ops->measure_cell_height (params->aux, + &cell, w); + if (h > r->unspanned) + r->unspanned = r->width = h; } x = cell.d[H][1]; - table_cell_free (&cell); } for (int i = 0; i < 2; i++) free (columns[i]); /* Distribute heights of spanned rows. */ for (int y = 0; y < nr; y++) - for (int x = 0; x < nc; ) + for (int x = 0; x < nc;) { struct table_cell cell; @@ -849,12 +794,11 @@ render_page_create (const struct render_params *params, struct table *table, if (y == cell.d[V][0] && table_cell_rowspan (&cell) > 1) { int w = joined_width (page, H, cell.d[H][0], cell.d[H][1]); - int h = params->measure_cell_height (params->aux, &cell, w); + int h = params->ops->measure_cell_height (params->aux, &cell, w); distribute_spanned_width (h, &rows[cell.d[V][0]], rules[V], table_cell_rowspan (&cell)); } x = cell.d[H][1]; - table_cell_free (&cell); } /* Decide final row heights. */ @@ -868,7 +812,7 @@ render_page_create (const struct render_params *params, struct table *table, if (hw * 2 >= page->params->size[axis] || hw + max_cell_width (page, axis) > page->params->size[axis]) { - page->h[axis][0] = page->h[axis][1] = 0; + page->h[axis] = 0; page->r[axis][0] = 0; page->r[axis][1] = page->n[axis]; } @@ -905,10 +849,7 @@ render_page_unref (struct render_page *page) table_unref (page->table); for (int i = 0; i < TABLE_N_AXES; ++i) - { - free (page->join_crossing[i]); - free (page->cp[i]); - } + free (page->cp[i]); free (page); } @@ -940,47 +881,40 @@ render_page_get_best_breakpoint (const struct render_page *page, int height) /* Drawing render_pages. */ -/* This is like table_get_rule() except: - - - D is in terms of the page's rows and column rather than the underlying - table's. - - - The result is in the form of a render_line_style. */ -static enum render_line_style +/* This is like table_get_rule() except that D is in terms of the page's rows + and column rather than the underlying table's. */ +static struct table_border_style get_rule (const struct render_page *page, enum table_axis axis, - const int d_[TABLE_N_AXES], struct cell_color *color) + const int d_[TABLE_N_AXES]) { int d[TABLE_N_AXES] = { d_[0] / 2, d_[1] / 2 }; int d2 = -1; enum table_axis a = axis; - if (d[a] < page->h[a][0]) + if (d[a] < page->h[a]) /* Nothing to do */; - else if (d[a] <= page->n[a] - page->h[a][1]) + else if (d[a] <= page->n[a]) { - if (page->h[a][0] && d[a] == page->h[a][0]) - d2 = page->h[a][0]; - else if (page->h[a][1] && d[a] == page->n[a] - page->h[a][1]) - d2 = page->table->n[a] - page->h[a][1]; - d[a] += page->r[a][0] - page->h[a][0]; + if (page->h[a] && d[a] == page->h[a]) + d2 = page->h[a]; + d[a] += page->r[a][0] - page->h[a]; } - else - d[a] += ((page->table->n[a] - page->table->h[a][1]) - - (page->n[a] - page->h[a][1])); enum table_axis b = !axis; struct map m; get_map (page, b, d[b], &m); d[b] += m.t0 - m.p0; - int r = table_get_rule (page->table, axis, d[H], d[V], color); + struct table_border_style border + = table_get_rule (page->table, axis, d[H], d[V]); if (d2 >= 0) { d[a] = d2; - int r2 = table_get_rule (page->table, axis, d[H], d[V], color); - r = table_rule_combine (r, r2); + struct table_border_style border2 = table_get_rule (page->table, axis, + d[H], d[V]); + border.stroke = table_stroke_combine (border.stroke, border2.stroke); } - return rule_to_render_type (r); + return border; } static bool @@ -997,10 +931,10 @@ render_direction_rtl (void) this string with "output-direction-rtl". Otherwise either leave it untranslated or copy it verbatim. */ const char *dir = _("output-direction-ltr"); - if ( 0 == strcmp ("output-direction-rtl", dir)) + if (0 == strcmp ("output-direction-rtl", dir)) return true; - if ( 0 != strcmp ("output-direction-ltr", dir)) + if (0 != strcmp ("output-direction-ltr", dir)) fprintf (stderr, "This localisation has been incorrectly translated. " "Complain to the translator.\n"); @@ -1011,21 +945,18 @@ static void render_rule (const struct render_page *page, const int ofs[TABLE_N_AXES], const int d[TABLE_N_AXES]) { - enum render_line_style styles[TABLE_N_AXES][2]; - struct cell_color colors[TABLE_N_AXES][2]; + const struct table_border_style none = { .stroke = TABLE_STROKE_NONE }; + struct table_border_style styles[TABLE_N_AXES][2]; for (enum table_axis a = 0; a < TABLE_N_AXES; a++) { enum table_axis b = !a; - styles[a][0] = styles[a][1] = RENDER_LINE_NONE; - if (!is_rule (d[a]) || (page->is_edge_cutoff[a][0] && d[a] == 0) || (page->is_edge_cutoff[a][1] && d[a] == page->n[a] * 2)) - continue; - - if (is_rule (d[b])) + styles[a][0] = styles[a][1] = none; + else if (is_rule (d[b])) { if (d[b] > 0) { @@ -1033,21 +964,24 @@ render_rule (const struct render_page *page, const int ofs[TABLE_N_AXES], e[H] = d[H]; e[V] = d[V]; e[b]--; - styles[a][0] = get_rule (page, a, e, &colors[a][0]); + styles[a][0] = get_rule (page, a, e); } + else + styles[a][0] = none; if (d[b] / 2 < page->n[b]) - styles[a][1] = get_rule (page, a, d, &colors[a][1]); + styles[a][1] = get_rule (page, a, d); + else + styles[a][1] = none; } else - { - styles[a][0] = styles[a][1] = get_rule (page, a, d, &colors[a][0]); - colors[a][1] = colors[a][0]; - } + styles[a][0] = styles[a][1] = get_rule (page, a, d); } - if (styles[H][0] != RENDER_LINE_NONE || styles[H][1] != RENDER_LINE_NONE - || styles[V][0] != RENDER_LINE_NONE || styles[V][1] != RENDER_LINE_NONE) + if (styles[H][0].stroke != TABLE_STROKE_NONE + || styles[H][1].stroke != TABLE_STROKE_NONE + || styles[V][0].stroke != TABLE_STROKE_NONE + || styles[V][1].stroke != TABLE_STROKE_NONE) { int bb[TABLE_N_AXES][2]; @@ -1061,7 +995,7 @@ render_rule (const struct render_page *page, const int ofs[TABLE_N_AXES], } bb[V][0] = ofs[V] + page->cp[V][d[V]]; bb[V][1] = ofs[V] + page->cp[V][d[V] + 1]; - page->params->draw_line (page->params->aux, bb, styles, colors); + page->params->ops->draw_line (page->params->aux, bb, styles); } } @@ -1069,6 +1003,25 @@ static void render_cell (const struct render_page *page, const int ofs[TABLE_N_AXES], const struct table_cell *cell) { + const bool debugging = false; + if (debugging) + { + printf ("render "); + if (cell->d[H][0] + 1 == cell->d[H][1]) + printf ("%d", cell->d[H][0]); + else + printf ("%d-%d", cell->d[H][0], cell->d[H][1] - 1); + printf (","); + if (cell->d[V][0] + 1 == cell->d[V][1]) + printf ("%d", cell->d[V][0]); + else + printf ("%d-%d", cell->d[V][0], cell->d[V][1] - 1); + + char *value = pivot_value_to_string (cell->value, NULL); + printf (": \"%s\"\n", value); + free (value); + } + int bb[TABLE_N_AXES][2]; int clip[TABLE_N_AXES][2]; @@ -1083,17 +1036,18 @@ render_cell (const struct render_page *page, const int ofs[TABLE_N_AXES], bb[V][0] = clip[V][0] = ofs[V] + page->cp[V][cell->d[V][0] * 2 + 1]; bb[V][1] = clip[V][1] = ofs[V] + page->cp[V][cell->d[V][1] * 2]; - enum table_valign valign = cell->style->cell_style.valign; + enum table_valign valign = cell->cell_style->valign; + int valign_offset = 0; if (valign != TABLE_VALIGN_TOP) { - int height = page->params->measure_cell_height ( + int height = page->params->ops->measure_cell_height ( page->params->aux, cell, bb[H][1] - bb[H][0]); int extra = bb[V][1] - bb[V][0] - height; if (extra > 0) { if (valign == TABLE_VALIGN_CENTER) extra /= 2; - bb[V][0] += extra; + valign_offset += extra; } } @@ -1125,12 +1079,11 @@ render_cell (const struct render_page *page, const int ofs[TABLE_N_AXES], spill[axis][1] = rule_width (page, axis, cell->d[axis][1]) / 2; } - int color_idx = (cell->d[V][0] < page->h[V][0] - || page->n[V] - (cell->d[V][0] + 1) < page->h[V][1] + int color_idx = (cell->d[V][0] < page->h[V] ? 0 - : (cell->d[V][0] - page->h[V][0]) & 1); - page->params->draw_cell (page->params->aux, cell, color_idx, - bb, spill, clip); + : (cell->d[V][0] - page->h[V]) & 1); + page->params->ops->draw_cell (page->params->aux, cell, color_idx, + bb, valign_offset, spill, clip); } /* Draws the cells of PAGE indicated in BB. */ @@ -1139,7 +1092,7 @@ render_page_draw_cells (const struct render_page *page, int ofs[TABLE_N_AXES], int bb[TABLE_N_AXES][2]) { for (int y = bb[V][0]; y < bb[V][1]; y++) - for (int x = bb[H][0]; x < bb[H][1]; ) + for (int x = bb[H][0]; x < bb[H][1];) if (!is_rule (x) && !is_rule (y)) { struct table_cell cell; @@ -1148,7 +1101,6 @@ render_page_draw_cells (const struct render_page *page, if (y / 2 == bb[V][0] / 2 || y / 2 == cell.d[V][0]) render_cell (page, ofs, &cell); x = rule_ofs (cell.d[H][1]); - table_cell_free (&cell); } else x++; @@ -1269,7 +1221,7 @@ render_break_init (struct render_break *b, struct render_page *page, { b->page = page; b->axis = axis; - b->z = page->h[axis][0]; + b->z = page->h[axis]; b->pixel = 0; b->hw = headers_width (page, axis); } @@ -1305,7 +1257,7 @@ render_break_has_next (const struct render_break *b) const struct render_page *page = b->page; enum table_axis axis = b->axis; - return page != NULL && b->z < page->n[axis] - page->h[axis][1]; + return page != NULL && b->z < page->n[axis]; } /* Returns a new render_page that is up to SIZE pixels wide along B's axis. @@ -1325,7 +1277,7 @@ render_break_next (struct render_break *b, int size) int pixel = 0; int z; - for (z = b->z; z < page->n[axis] - page->h[axis][1]; z++) + for (z = b->z; z < page->n[axis]; z++) { int needed = needed_size (b, z + 1); if (needed > size) @@ -1339,9 +1291,7 @@ render_break_next (struct render_break *b, int size) cell. This is similar to code for the left side in needed_size(). */ - int rule_allowance = (page->h[axis][1] - ? 0 - : rule_width (page, axis, z)); + int rule_allowance = rule_width (page, axis, z); /* The amount that, if we added cell 'z', the rendering would overfill the allocated 'size'. */ @@ -1375,17 +1325,16 @@ render_break_next (struct render_break *b, int size) being broken have a better internal breakpoint than the exact number of pixels available, which might look bad e.g. because it breaks in the middle of a line of text. */ - if (axis == TABLE_VERT && page->params->adjust_break) - for (int x = 0; x < page->n[H]; ) + if (axis == TABLE_VERT && page->params->ops->adjust_break) + for (int x = 0; x < page->n[H];) { struct table_cell cell; render_get_cell (page, x, z, &cell); int w = joined_width (page, H, cell.d[H][0], cell.d[H][1]); - int better_pixel = page->params->adjust_break ( + int better_pixel = page->params->ops->adjust_break ( page->params->aux, &cell, w, pixel); x = cell.d[H][1]; - table_cell_free (&cell); if (better_pixel < pixel) { @@ -1427,7 +1376,7 @@ needed_size (const struct render_break *b, int cell) enum table_axis axis = b->axis; /* Width of left header not including its rightmost rule. */ - int size = axis_width (page, axis, 0, rule_ofs (page->h[axis][0])); + int size = axis_width (page, axis, 0, rule_ofs (page->h[axis])); /* If we have a pixel offset and there is no left header, then we omit the leftmost rule of the body. Otherwise the rendering is deceptive because @@ -1437,24 +1386,15 @@ needed_size (const struct render_break *b, int cell) rightmost rule in the header and the leftmost rule in the body. We assume that the width of a merged rule is the larger of the widths of either rule invidiually. */ - if (b->pixel == 0 || page->h[axis][0]) - size += MAX (rule_width (page, axis, page->h[axis][0]), + if (b->pixel == 0 || page->h[axis]) + size += MAX (rule_width (page, axis, page->h[axis]), rule_width (page, axis, b->z)); /* Width of body, minus any pixel offset in the leftmost cell. */ size += joined_width (page, axis, b->z, cell) - b->pixel; /* Width of rightmost rule in body merged with leftmost rule in headers. */ - size += MAX (rule_width_r (page, axis, page->h[axis][1]), - rule_width (page, axis, cell)); - - /* Width of right header not including its leftmost rule. */ - size += axis_width (page, axis, rule_ofs_r (page, axis, page->h[axis][1]), - rule_ofs_r (page, axis, 0)); - - /* Join crossing. */ - if (page->h[axis][0] && page->h[axis][1]) - size += page->join_crossing[axis][b->z]; + size += MAX (rule_width_r (page, axis, 0), rule_width (page, axis, cell)); return size; } @@ -1477,129 +1417,72 @@ cell_is_breakable (const struct render_break *b, int cell) struct render_pager { const struct render_params *params; + double scale; - struct render_page **pages; - size_t n_pages, allocated_pages; + struct render_page *page; - size_t cur_page; struct render_break x_break; struct render_break y_break; }; -static const struct render_page * -render_pager_add_table (struct render_pager *p, struct table *table, - int min_width) -{ - if (p->n_pages >= p->allocated_pages) - p->pages = x2nrealloc (p->pages, &p->allocated_pages, sizeof *p->pages); - - struct render_page *page = render_page_create (p->params, table, min_width); - p->pages[p->n_pages++] = page; - return page; -} - static void render_pager_start_page (struct render_pager *p) { - render_break_init (&p->x_break, render_page_ref (p->pages[p->cur_page++]), - H); + render_break_init (&p->x_break, render_page_ref (p->page), H); render_break_init_empty (&p->y_break); } -static void -add_footnote_page (struct render_pager *p, const struct table_item *item) +/* Creates and returns a new render_pager for rendering PT on the device + with the given PARAMS. */ +struct render_pager * +render_pager_create (const struct render_params *params, + const struct pivot_table *pt, + const size_t *layer_indexes) { - const struct footnote **f; - size_t n_footnotes = table_collect_footnotes (item, &f); - if (!n_footnotes) - return; + if (!layer_indexes) + layer_indexes = pt->current_layer; - struct tab_table *t = tab_create (2, n_footnotes); + struct table *table = pivot_output_monolithic (pt, layer_indexes, + params->printing); - for (size_t i = 0; i < n_footnotes; i++) + /* Measure the table width and use it to determine the base scale. */ + struct render_page *page = render_page_create (params, table, 0); + int width = table_width (page, H); + double scale = 1.0; + if (width > params->size[H]) { - tab_text_format (t, 0, i, TAB_LEFT, "%s.", f[i]->marker); - tab_text (t, 1, i, TAB_LEFT, f[i]->content); - if (f[i]->style) + if (pt->look->shrink_to_fit[H] && params->ops->scale) + scale = params->size[H] / (double) width; + else { - tab_add_style (t, 0, i, f[i]->style); - tab_add_style (t, 1, i, f[i]->style); + struct render_break b; + render_break_init (&b, render_page_ref (page), H); + struct render_page *subpage + = render_break_next (&b, params->size[H]); + width = subpage ? subpage->cp[H][2 * subpage->n[H] + 1] : 0; + render_page_unref (subpage); + render_break_destroy (&b); } } - render_pager_add_table (p, &t->table, 0); - - free (f); -} - -static void -add_text_page (struct render_pager *p, const struct table_item_text *t, - int min_width) -{ - if (!t) - return; - struct tab_table *tab = tab_create (1, 1); - tab_text (tab, 0, 0, 0, t->content); - for (size_t i = 0; i < t->n_footnotes; i++) - tab_add_footnote (tab, 0, 0, t->footnotes[i]); - if (t->style) - tab->styles[0] = area_style_clone (tab->container, t->style); - render_pager_add_table (p, &tab->table, min_width); -} + /* Create the pager. */ + struct render_pager *p = xmalloc (sizeof *p); + *p = (struct render_pager) { .params = params, .scale = scale, .page = page }; -static void -add_layers_page (struct render_pager *p, - const struct table_item_layers *layers, int min_width) -{ - if (!layers) - return; + /* If we're shrinking tables to fit the page length, then adjust the scale + factor. - struct tab_table *tab = tab_create (1, layers->n_layers); - for (size_t i = 0; i < layers->n_layers; i++) + XXX This will sometimes shrink more than needed, because adjusting the + scale factor allows for cells to be "wider", which means that sometimes + they won't break across as much vertical space, thus shrinking the table + vertically more than the scale would imply. Shrinking only as much as + necessary would require an iterative search. */ + if (pt->look->shrink_to_fit[V] && params->ops->scale) { - const struct table_item_layer *layer = &layers->layers[i]; - tab_text (tab, 0, i, 0, layer->content); - for (size_t j = 0; j < layer->n_footnotes; j++) - tab_add_footnote (tab, 0, i, layer->footnotes[j]); + double height = table_width (p->page, V); + if (height * p->scale >= params->size[V]) + p->scale *= params->size[V] / height; } - if (layers->style) - tab->styles[0] = area_style_clone (tab->container, layers->style); - render_pager_add_table (p, &tab->table, min_width); -} - -/* Creates and returns a new render_pager for rendering TABLE_ITEM on the - device with the given PARAMS. */ -struct render_pager * -render_pager_create (const struct render_params *params, - const struct table_item *table_item) -{ - const struct table *table = table_item_get_table (table_item); - - struct render_pager *p = xzalloc (sizeof *p); - p->params = params; - - struct render_page *page = render_page_create (params, table_ref (table), 0); - struct render_break b; - render_break_init (&b, page, H); - struct render_page *subpage = render_break_next (&b, p->params->size[H]); - int title_width = subpage ? subpage->cp[H][2 * subpage->n[H] + 1] : 0; - render_page_unref (subpage); - render_break_destroy (&b); - - /* Title. */ - add_text_page (p, table_item_get_title (table_item), title_width); - - /* Layers. */ - add_layers_page (p, table_item_get_layers (table_item), title_width); - - /* Body. */ - render_pager_add_table (p, table_ref (table_item_get_table (table_item)), 0); - - /* Caption. */ - add_text_page (p, table_item_get_caption (table_item), 0); - - /* Footnotes. */ - add_footnote_page (p, table_item); render_pager_start_page (p); @@ -1614,9 +1497,7 @@ render_pager_destroy (struct render_pager *p) { render_break_destroy (&p->x_break); render_break_destroy (&p->y_break); - for (size_t i = 0; i < p->n_pages; i++) - render_page_unref (p->pages[i]); - free (p->pages); + render_page_unref (p->page); free (p); } } @@ -1634,17 +1515,14 @@ render_pager_has_next (const struct render_pager *p_) if (!render_break_has_next (&p->x_break)) { render_break_destroy (&p->x_break); - if (p->cur_page >= p->n_pages) - { - render_break_init_empty (&p->x_break); - render_break_init_empty (&p->y_break); - return false; - } - render_pager_start_page (p); + render_break_init_empty (&p->x_break); + render_break_init_empty (&p->y_break); + return false; } else render_break_init ( - &p->y_break, render_break_next (&p->x_break, p->params->size[H]), V); + &p->y_break, render_break_next (&p->x_break, + p->params->size[H] / p->scale), V); } return true; } @@ -1658,24 +1536,29 @@ render_pager_has_next (const struct render_pager *p_) int render_pager_draw_next (struct render_pager *p, int space) { + if (p->scale != 1.0) + { + p->params->ops->scale (p->params->aux, p->scale); + space /= p->scale; + } + int ofs[TABLE_N_AXES] = { 0, 0 }; - size_t start_page = SIZE_MAX; - while (render_pager_has_next (p)) + if (render_pager_has_next (p)) { - if (start_page == p->cur_page) - break; - start_page = p->cur_page; - struct render_page *page = render_break_next (&p->y_break, space - ofs[V]); - if (!page) - break; - - render_page_draw (page, ofs); - ofs[V] += render_page_get_size (page, V); - render_page_unref (page); + if (page) + { + render_page_draw (page, ofs); + ofs[V] += render_page_get_size (page, V); + render_page_unref (page); + } } + + if (p->scale != 1.0) + ofs[V] *= p->scale; + return ofs[V]; } @@ -1698,18 +1581,14 @@ render_pager_draw_region (const struct render_pager *p, clip[H][0] = x; clip[H][1] = x + w; - for (size_t i = 0; i < p->n_pages; i++) - { - const struct render_page *page = p->pages[i]; - int size = render_page_get_size (page, V); + int size = render_page_get_size (p->page, V); - clip[V][0] = MAX (y, ofs[V]) - ofs[V]; - clip[V][1] = MIN (y + h, ofs[V] + size) - ofs[V]; - if (clip[V][1] > clip[V][0]) - render_page_draw_region (page, ofs, clip); + clip[V][0] = MAX (y, ofs[V]) - ofs[V]; + clip[V][1] = MIN (y + h, ofs[V] + size) - ofs[V]; + if (clip[V][1] > clip[V][0]) + render_page_draw_region (p->page, ofs, clip); - ofs[V] += size; - } + ofs[V] += size; } /* Returns the size of P's content along AXIS; i.e. the content's width if AXIS @@ -1717,32 +1596,16 @@ render_pager_draw_region (const struct render_pager *p, int render_pager_get_size (const struct render_pager *p, enum table_axis axis) { - int size = 0; - - for (size_t i = 0; i < p->n_pages; i++) - { - int subsize = render_page_get_size (p->pages[i], axis); - size = axis == H ? MAX (size, subsize) : size + subsize; - } - - return size; + return render_page_get_size (p->page, axis); } int render_pager_get_best_breakpoint (const struct render_pager *p, int height) { - int y = 0; - size_t i; - - for (i = 0; i < p->n_pages; i++) - { - int size = render_page_get_size (p->pages[i], V); - if (y + size >= height) - return render_page_get_best_breakpoint (p->pages[i], height - y) + y; - y += size; - } - - return height; + int size = render_page_get_size (p->page, V); + return (size < height + ? height + : render_page_get_best_breakpoint (p->page, height)); } /* render_page_select() and helpers. */ @@ -1790,8 +1653,7 @@ render_page_select (const struct render_page *page, enum table_axis axis, /* Optimize case where all of PAGE is selected by just incrementing the reference count. */ - if (z0 == page->h[a][0] && p0 == 0 - && z1 == page->n[a] - page->h[a][1] && p1 == 0) + if (z0 == page->h[a] && p0 == 0 && z1 == page->n[a] && p1 == 0) { struct render_page *page_rw = CONST_CAST (struct render_page *, page); page_rw->ref_cnt++; @@ -1799,49 +1661,37 @@ render_page_select (const struct render_page *page, enum table_axis axis, } /* Allocate subpage. */ - int trim[2] = { z0 - page->h[a][0], (page->n[a] - page->h[a][1]) - z1 }; + int trim[2] = { z0 - page->h[a], page->n[a] - z1 }; + int n[TABLE_N_AXES] = { [H] = page->n[H], [V] = page->n[V] }; n[a] -= trim[0] + trim[1]; - struct render_page *subpage = render_page_allocate__ ( - page->params, table_ref (page->table), n); + + int r[TABLE_N_AXES][2]; for (enum table_axis k = 0; k < TABLE_N_AXES; k++) { - subpage->h[k][0] = page->h[k][0]; - subpage->h[k][1] = page->h[k][1]; - subpage->r[k][0] = page->r[k][0]; - subpage->r[k][1] = page->r[k][1]; + r[k][0] = page->r[k][0]; + r[k][1] = page->r[k][1]; } - subpage->r[a][0] += trim[0]; - subpage->r[a][1] -= trim[1]; + r[a][0] += trim[0]; + r[a][1] -= trim[1]; + + struct render_page *subpage = render_page_allocate__ ( + page->params, table_ref (page->table), n, page->h, r); /* An edge is cut off if it was cut off in PAGE or if we're trimming pixels off that side of the page and there are no headers. */ subpage->is_edge_cutoff[a][0] = - subpage->h[a][0] == 0 && (p0 || (z0 == 0 && page->is_edge_cutoff[a][0])); + subpage->h[a] == 0 && (p0 || (z0 == 0 && page->is_edge_cutoff[a][0])); subpage->is_edge_cutoff[a][1] = - subpage->h[a][1] == 0 && (p1 || (z1 == page->n[a] - && page->is_edge_cutoff[a][1])); + p1 || (z1 == page->n[a] && page->is_edge_cutoff[a][1]); subpage->is_edge_cutoff[b][0] = page->is_edge_cutoff[b][0]; subpage->is_edge_cutoff[b][1] = page->is_edge_cutoff[b][1]; - /* Select join crossings from PAGE into subpage. */ - int *jc = subpage->join_crossing[a]; - for (int z = 0; z < page->h[a][0]; z++) - *jc++ = page->join_crossing[a][z]; - for (int z = z0; z <= z1; z++) - *jc++ = page->join_crossing[a][z]; - for (int z = page->n[a] - page->h[a][1]; z < page->n[a]; z++) - *jc++ = page->join_crossing[a][z]; - assert (jc == &subpage->join_crossing[a][subpage->n[a] + 1]); - - memcpy (subpage->join_crossing[b], page->join_crossing[b], - (subpage->n[b] + 1) * sizeof **subpage->join_crossing); - /* Select widths from PAGE into subpage. */ int *scp = page->cp[a]; int *dcp = subpage->cp[a]; *dcp = 0; - for (int z = 0; z <= rule_ofs (subpage->h[a][0]); z++, dcp++) + for (int z = 0; z <= rule_ofs (subpage->h[a]); z++, dcp++) { int w = !z && subpage->is_edge_cutoff[a][0] ? 0 : scp[z + 1] - scp[z]; dcp[1] = dcp[0] + w; @@ -1850,15 +1700,11 @@ render_page_select (const struct render_page *page, enum table_axis axis, { dcp[1] = dcp[0] + (scp[z + 1] - scp[z]); if (z == cell_ofs (z0)) - { - dcp[1] -= p0; - if (page->h[a][0] && page->h[a][1]) - dcp[1] += page->join_crossing[a][z / 2]; - } + dcp[1] -= p0; if (z == cell_ofs (z1 - 1)) dcp[1] -= p1; } - for (int z = rule_ofs_r (page, a, subpage->h[a][1]); + for (int z = rule_ofs_r (page, a, 0); z <= rule_ofs_r (page, a, 0); z++, dcp++) { if (z == rule_ofs_r (page, a, 0) && subpage->is_edge_cutoff[a][1]) @@ -1883,8 +1729,8 @@ render_page_select (const struct render_page *page, enum table_axis axis, .subpage = subpage, }; - if (!page->h[a][0] || z0 > page->h[a][0] || p0) - for (int z = 0; z < page->n[b]; ) + if (!page->h[a] || z0 > page->h[a] || p0) + for (int z = 0; z < page->n[b];) { int d[TABLE_N_AXES]; d[a] = z0; @@ -1899,45 +1745,33 @@ render_page_select (const struct render_page *page, enum table_axis axis, struct render_overflow *ro = insert_overflow (&s, &cell); if (overflow0) - { - ro->overflow[a][0] += p0 + axis_width ( - page, a, cell_ofs (cell.d[a][0]), cell_ofs (z0)); - if (page->h[a][0] && page->h[a][1]) - ro->overflow[a][0] -= page->join_crossing[a][cell.d[a][0] - + 1]; - } + ro->overflow[a][0] += p0 + axis_width ( + page, a, cell_ofs (cell.d[a][0]), cell_ofs (z0)); if (overflow1) - { - ro->overflow[a][1] += p1 + axis_width ( - page, a, cell_ofs (z1), cell_ofs (cell.d[a][1])); - if (page->h[a][0] && page->h[a][1]) - ro->overflow[a][1] -= page->join_crossing[a][cell.d[a][1]]; - } + ro->overflow[a][1] += p1 + axis_width ( + page, a, cell_ofs (z1), cell_ofs (cell.d[a][1])); } z = cell.d[b][1]; - table_cell_free (&cell); } - if (!page->h[a][1] || z1 < page->n[a] - page->h[a][1] || p1) - for (int z = 0; z < page->n[b]; ) - { - int d[TABLE_N_AXES]; - d[a] = z1 - 1; - d[b] = z; + for (int z = 0; z < page->n[b];) + { + int d[TABLE_N_AXES]; + d[a] = z1 - 1; + d[b] = z; - struct table_cell cell; - render_get_cell (page, d[H], d[V], &cell); - if ((cell.d[a][1] > z1 || (cell.d[a][1] == z1 && p1)) - && find_overflow_for_cell (&s, &cell) == NULL) - { - struct render_overflow *ro = insert_overflow (&s, &cell); - ro->overflow[a][1] += p1 + axis_width (page, a, cell_ofs (z1), - cell_ofs (cell.d[a][1])); - } - z = cell.d[b][1]; - table_cell_free (&cell); - } + struct table_cell cell; + render_get_cell (page, d[H], d[V], &cell); + if ((cell.d[a][1] > z1 || (cell.d[a][1] == z1 && p1)) + && find_overflow_for_cell (&s, &cell) == NULL) + { + struct render_overflow *ro = insert_overflow (&s, &cell); + ro->overflow[a][1] += p1 + axis_width (page, a, cell_ofs (z1), + cell_ofs (cell.d[a][1])); + } + z = cell.d[b][1]; + } /* Copy overflows from PAGE into subpage. */ struct render_overflow *ro; @@ -1949,7 +1783,6 @@ render_page_select (const struct render_page *page, enum table_axis axis, if (cell.d[a][1] > z0 && cell.d[a][0] < z1 && find_overflow_for_cell (&s, &cell) == NULL) insert_overflow (&s, &cell); - table_cell_free (&cell); } return subpage; @@ -1966,7 +1799,7 @@ cell_to_subpage (struct render_page_selection *s, { enum table_axis a = s->a; enum table_axis b = s->b; - int ha0 = s->subpage->h[a][0]; + int ha0 = s->subpage->h[a]; subcell[a] = MAX (cell->d[a][0] - s->z0 + ha0, ha0); subcell[b] = cell->d[b][0]; @@ -1998,7 +1831,7 @@ static struct render_overflow * insert_overflow (struct render_page_selection *s, const struct table_cell *cell) { - struct render_overflow *of = xzalloc (sizeof *of); + struct render_overflow *of = XZALLOC (struct render_overflow); cell_to_subpage (s, cell, of->d); hmap_insert (&s->subpage->overflows, &of->node, hash_cell (of->d[H], of->d[V]));