X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Foutput%2Frender.c;h=7aa80a6977e69abd92f328429627c22a021e7260;hb=refs%2Fheads%2Fctables7;hp=a7cc3e67b6e6e5b812a7a4c6e74711784c815b29;hpb=f6fd6e894861f4f86d1076dc9d9ea59c58b4a14f;p=pspp diff --git a/src/output/render.c b/src/output/render.c index a7cc3e67b6..7aa80a6977 100644 --- a/src/output/render.c +++ b/src/output/render.c @@ -26,8 +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/table-item.h" #include "output/table.h" #include "gl/minmax.h" @@ -78,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. @@ -87,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. */ @@ -188,6 +189,13 @@ 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) @@ -511,7 +519,7 @@ measure_rule (const struct render_params *params, const struct table *table, 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[rule_to_render_type (i)]); return width; } @@ -531,9 +539,8 @@ render_page_allocate__ (const struct render_params *params, 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]); + page->cp[i] = xcalloc ((2 * n[i] + 2) , sizeof *page->cp[i]); + page->join_crossing[i] = xcalloc ((n[i] + 1) , sizeof *page->join_crossing[i]); } hmap_init (&page->overflows); @@ -706,8 +713,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]; @@ -724,7 +731,7 @@ 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;) { @@ -736,8 +743,8 @@ 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]; @@ -760,7 +767,8 @@ 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)); @@ -781,7 +789,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; @@ -807,7 +815,7 @@ 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;) { @@ -820,7 +828,8 @@ render_page_create (const struct render_params *params, struct table *table, 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); + int h = params->ops->measure_cell_height (params->aux, + &cell, w); if (h > r->unspanned) r->unspanned = r->width = h; } @@ -845,7 +854,7 @@ 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)); } @@ -1056,7 +1065,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, colors); } } @@ -1078,11 +1087,11 @@ 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) @@ -1125,8 +1134,8 @@ render_cell (const struct render_page *page, const int ofs[TABLE_N_AXES], || page->n[V] - (cell->d[V][0] + 1) < page->h[V][1] ? 0 : (cell->d[V][0] - page->h[V][0]) & 1); - page->params->draw_cell (page->params->aux, cell, color_idx, - bb, valign_offset, spill, clip); + page->params->ops->draw_cell (page->params->aux, cell, color_idx, + bb, valign_offset, spill, clip); } /* Draws the cells of PAGE indicated in BB. */ @@ -1370,14 +1379,14 @@ 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) + 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]; @@ -1471,25 +1480,25 @@ 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; + /* An array of "render_page"s to be rendered, in order, vertically. There + may be up to 5 pages, for the pivot table's title, layers, body, + captions, and footnotes. */ + struct render_page *pages[5]; + size_t n_pages; size_t cur_page; struct render_break x_break; struct render_break y_break; }; -static const struct render_page * +static void 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; + if (table) + p->pages[p->n_pages++] = render_page_create (p->params, table, min_width); } static void @@ -1500,95 +1509,67 @@ render_pager_start_page (struct render_pager *p) 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; - - struct table *t = table_create (1, n_footnotes, 0, 0, 0, 0); - - for (size_t i = 0; i < n_footnotes; i++) + if (!layer_indexes) + layer_indexes = pt->current_layer; + + struct table *title, *layers, *body, *caption, *footnotes; + pivot_output (pt, layer_indexes, params->printing, + &title, &layers, &body, &caption, &footnotes, NULL, NULL); + + /* Figure out the width of the body of the table. Use this to determine the + base scale. */ + struct render_page *body_page = render_page_create (params, body, 0); + int body_width = table_width (body_page, H); + double scale = 1.0; + if (body_width > params->size[H]) { - table_text_format (t, 0, i, 0, "%s. %s", f[i]->marker, f[i]->content); - table_add_style (t, 0, i, f[i]->style); + if (pt->look->shrink_to_fit[H] && params->ops->scale) + scale = params->size[H] / (double) body_width; + else + { + struct render_break b; + render_break_init (&b, render_page_ref (body_page), H); + struct render_page *subpage + = render_break_next (&b, params->size[H]); + body_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, 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 table *tab = table_create (1, 1, 0, 0, 0, 0); - table_text (tab, 0, 0, 0, t->content); - for (size_t i = 0; i < t->n_footnotes; i++) - table_add_footnote (tab, 0, 0, t->footnotes[i]); - if (t->style) - tab->styles[0] = table_area_style_clone (tab->container, t->style); - render_pager_add_table (p, tab, min_width); -} - -static void -add_layers_page (struct render_pager *p, - const struct table_item_layers *layers, int min_width) -{ - if (!layers) - return; - struct table *tab = table_create (1, layers->n_layers, 0, 0, 0, 0); - for (size_t i = 0; i < layers->n_layers; i++) + /* Create the pager. */ + struct render_pager *p = xmalloc (sizeof *p); + *p = (struct render_pager) { .params = params, .scale = scale }; + render_pager_add_table (p, title, body_width); + render_pager_add_table (p, layers, body_width); + p->pages[p->n_pages++] = body_page; + render_pager_add_table (p, caption, 0); + render_pager_add_table (p, footnotes, 0); + assert (p->n_pages <= sizeof p->pages / sizeof *p->pages); + + /* If we're shrinking tables to fit the page length, then adjust the scale + factor. + + 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]; - table_text (tab, 0, i, 0, layer->content); - for (size_t j = 0; j < layer->n_footnotes; j++) - table_add_footnote (tab, 0, i, layer->footnotes[j]); + int total_height = 0; + for (size_t i = 0; i < p->n_pages; i++) + total_height += table_width (p->pages[i], V); + if (total_height * p->scale >= params->size[V]) + p->scale *= params->size[V] / (double) total_height; } - if (layers->style) - tab->styles[0] = table_area_style_clone (tab->container, layers->style); - render_pager_add_table (p, tab, 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); @@ -1605,7 +1586,6 @@ render_pager_destroy (struct render_pager *p) 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); free (p); } } @@ -1633,7 +1613,8 @@ render_pager_has_next (const struct render_pager *p_) } 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; } @@ -1647,6 +1628,12 @@ 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; @@ -1665,6 +1652,10 @@ render_pager_draw_next (struct render_pager *p, int space) ofs[V] += render_page_get_size (page, V); render_page_unref (page); } + + if (p->scale != 1.0) + ofs[V] *= p->scale; + return ofs[V]; } @@ -1984,7 +1975,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]));