X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Foutput%2Frender.c;h=11830a3e8e4125addea848732be02f9fb65fe89a;hb=bf03b53a3c0f0d1066062f37919015a8fa6ad436;hp=734914dbf5b039835c961361d7a9fac33361e0d0;hpb=f1db96caae465cb7daaf6efbe69ae17069ea1198;p=pspp diff --git a/src/output/render.c b/src/output/render.c index 734914dbf5..11830a3e8e 100644 --- a/src/output/render.c +++ b/src/output/render.c @@ -1,5 +1,5 @@ /* PSPP - a program for statistical analysis. - Copyright (C) 2009, 2010, 2011, 2013, 2014 Free Software Foundation, Inc. + Copyright (C) 2009, 2010, 2011, 2013, 2014, 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 @@ -26,12 +26,16 @@ #include "libpspp/hash-functions.h" #include "libpspp/hmap.h" #include "output/render.h" +#include "output/tab.h" #include "output/table-item.h" #include "output/table.h" #include "gl/minmax.h" #include "gl/xalloc.h" +#include "gettext.h" +#define _(msgid) gettext (msgid) + /* This file uses TABLE_HORZ and TABLE_VERT enough to warrant abbreviating. */ #define H TABLE_HORZ #define V TABLE_VERT @@ -90,6 +94,15 @@ struct render_page entire page can overflow on all four sides!) */ struct hmap overflows; + /* Contains "struct render_footnote"s, one for each cell with one or more + footnotes. + + 'n_footnotes' is the number of footnotes in the table. There might be + more than hmap_count(&page->footnotes) because there can be more than + one footnote in a cell. */ + struct hmap footnotes; + size_t n_footnotes; + /* If a single column (or row) is too wide (or tall) to fit on a page reasonably, then render_break_next() will split a single row or column across multiple render_pages. This member indicates when this has @@ -127,7 +140,7 @@ struct render_page }; static struct render_page *render_page_create (const struct render_params *, - const struct table *); + struct table *); struct render_page *render_page_ref (const struct render_page *page_); static void render_page_unref (struct render_page *); @@ -301,9 +314,9 @@ struct render_overflow int overflow[TABLE_N_AXES][2]; }; -/* Returns a hash value for (X,Y). */ +/* Returns a hash value for (,Y). */ static unsigned int -hash_overflow (int x, int y) +hash_cell (int x, int y) { return hash_int (x + (y << 16), 0); } @@ -318,7 +331,7 @@ find_overflow (const struct render_page *page, int x, int y) const struct render_overflow *of; HMAP_FOR_EACH_WITH_HASH (of, struct render_overflow, node, - hash_overflow (x, y), &page->overflows) + hash_cell (x, y), &page->overflows) if (x == of->d[H] && y == of->d[V]) return of; } @@ -326,6 +339,55 @@ find_overflow (const struct render_page *page, int x, int y) return NULL; } +/* A footnote. */ +struct render_footnote + { + struct hmap_node node; + + /* The area of the table covered by the cell that has the footnote. + + d[H][0] is the leftmost column. + d[H][1] is the rightmost column, plus 1. + d[V][0] is the top row. + d[V][1] is the bottom row, plus 1. + + The cell in its original table might occupy a larger region. This + member reflects the size of the cell in the current render_page, after + trimming off any rows or columns due to page-breaking. */ + int d[TABLE_N_AXES][2]; + + /* The index of the first footnote in the cell. */ + int idx; + }; + +static int +count_footnotes (const struct table_cell *cell) +{ + size_t i; + int n; + + n = 0; + for (i = 0; i < cell->n_contents; i++) + n += cell->contents[i].n_footnotes; + return n; +} + +static int +find_footnote_idx (const struct table_cell *cell, const struct hmap *footnotes) +{ + const struct render_footnote *f; + + if (!count_footnotes (cell)) + return 0; + + HMAP_FOR_EACH_WITH_HASH (f, struct render_footnote, node, + hash_cell (cell->d[H][0], cell->d[V][0]), footnotes) + if (f->d[H][0] == cell->d[H][0] && f->d[V][0] == cell->d[V][0]) + return f->idx; + + NOT_REACHED (); +} + /* Row or column dimensions. Used to figure the size of a table in render_page_create() and discarded after that. */ struct render_row @@ -529,6 +591,8 @@ render_page_allocate (const struct render_params *params, } hmap_init (&page->overflows); + hmap_init (&page->footnotes); + page->n_footnotes = 0; memset (page->is_edge_cutoff, 0, sizeof page->is_edge_cutoff); return page; @@ -620,22 +684,21 @@ set_join_crossings (struct render_page *page, enum table_axis axis, size is PARAMS->size, but the caller is responsible for actually breaking it up to fit on such a device, using the render_break abstraction. */ static struct render_page * -render_page_create (const struct render_params *params, - const struct table *table_) +render_page_create (const struct render_params *params, struct table *table) { struct render_page *page; - struct table *table; enum { MIN, MAX }; struct render_row *columns[2]; struct render_row *rows; int table_widths[2]; int *rules[TABLE_N_AXES]; + struct hmap footnotes; + int footnote_idx; int nr, nc; int x, y; int i; enum table_axis axis; - table = table_ref (table_); nc = table_nc (table); nr = table_nr (table); @@ -651,7 +714,9 @@ render_page_create (const struct render_params *params, } /* Calculate minimum and maximum widths of cells that do not - span multiple columns. */ + span multiple columns. Assign footnote markers. */ + hmap_init (&footnotes); + footnote_idx = 0; for (i = 0; i < 2; i++) columns[i] = xzalloc (nc * sizeof *columns[i]); for (y = 0; y < nr; y++) @@ -660,15 +725,35 @@ render_page_create (const struct render_params *params, struct table_cell cell; table_get_cell (table, x, y, &cell); - if (y == cell.d[V][0] && table_cell_colspan (&cell) == 1) + if (y == cell.d[V][0]) { - int w[2]; - int i; + int n; - params->measure_cell_width (params->aux, &cell, &w[MIN], &w[MAX]); - for (i = 0; i < 2; i++) - if (columns[i][x].unspanned < w[i]) - columns[i][x].unspanned = w[i]; + if (table_cell_colspan (&cell) == 1) + { + int w[2]; + int i; + + params->measure_cell_width (params->aux, &cell, footnote_idx, + &w[MIN], &w[MAX]); + for (i = 0; i < 2; i++) + if (columns[i][x].unspanned < w[i]) + columns[i][x].unspanned = w[i]; + } + + n = count_footnotes (&cell); + if (n > 0) + { + struct render_footnote *f = xmalloc (sizeof *f); + f->d[H][0] = cell.d[H][0]; + f->d[H][1] = cell.d[H][1]; + f->d[V][0] = cell.d[V][0]; + f->d[V][1] = cell.d[V][1]; + f->idx = footnote_idx; + hmap_insert (&footnotes, &f->node, hash_cell (x, y)); + + footnote_idx += n; + } } x = cell.d[H][1]; table_cell_free (&cell); @@ -688,7 +773,9 @@ render_page_create (const struct render_params *params, { int w[2]; - params->measure_cell_width (params->aux, &cell, &w[MIN], &w[MAX]); + params->measure_cell_width (params->aux, &cell, + find_footnote_idx (&cell, &footnotes), + &w[MIN], &w[MAX]); for (i = 0; i < 2; i++) distribute_spanned_width (w[i], &columns[i][cell.d[H][0]], rules[H], table_cell_colspan (&cell)); @@ -737,7 +824,8 @@ render_page_create (const struct render_params *params, 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->measure_cell_height ( + params->aux, &cell, find_footnote_idx (&cell, &footnotes), w); if (h > r->unspanned) r->unspanned = r->width = h; } @@ -764,7 +852,8 @@ render_page_create (const struct render_params *params, 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->measure_cell_height ( + params->aux, &cell, find_footnote_idx (&cell, &footnotes), w); distribute_spanned_width (h, &rows[cell.d[V][0]], rules[V], table_cell_rowspan (&cell)); } @@ -789,6 +878,10 @@ render_page_create (const struct render_params *params, } } + hmap_swap (&page->footnotes, &footnotes); + hmap_destroy (&footnotes); + page->n_footnotes = footnote_idx; + free (rules[H]); free (rules[V]); @@ -820,7 +913,7 @@ render_page_unref (struct render_page *page) hmap_destroy (&page->overflows); table_unref (page->table); - + for (i = 0; i < TABLE_N_AXES; ++i) { free (page->join_crossing[i]); @@ -834,13 +927,13 @@ render_page_unref (struct render_page *page) /* Returns the size of PAGE along AXIS. (This might be larger than the page size specified in the parameters passed to render_page_create(). Use a render_break to break up a render_page into page-sized chunks.) */ -int +static int render_page_get_size (const struct render_page *page, enum table_axis axis) { return page->cp[axis][page->n[axis] * 2 + 1]; } -int +static int render_page_get_best_breakpoint (const struct render_page *page, int height) { int y; @@ -873,6 +966,23 @@ is_rule (int z) return !(z & 1); } +bool +render_direction_rtl (void) +{ + /* TRANSLATORS: Do not translate this string. If the script of your language + reads from right to left (eg Persian, Arabic, Hebrew etc), then replace + 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)) + return true; + + if ( 0 != strcmp ("output-direction-ltr", dir)) + fprintf (stderr, "This localisation has been incorrectly translated. Complain to the translator.\n"); + + return false; +} + static void render_rule (const struct render_page *page, const int ofs[TABLE_N_AXES], const int d[TABLE_N_AXES]) @@ -916,6 +1026,12 @@ render_rule (const struct render_page *page, const int ofs[TABLE_N_AXES], bb[H][0] = ofs[H] + page->cp[H][d[H]]; bb[H][1] = ofs[H] + page->cp[H][d[H] + 1]; + if (render_direction_rtl ()) + { + int temp = bb[H][0]; + bb[H][0] = render_page_get_size (page, H) - bb[H][1]; + bb[H][1] = render_page_get_size (page, H) - temp; + } 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); @@ -932,6 +1048,12 @@ render_cell (const struct render_page *page, const int ofs[TABLE_N_AXES], bb[H][0] = clip[H][0] = ofs[H] + page->cp[H][cell->d[H][0] * 2 + 1]; bb[H][1] = clip[H][1] = ofs[H] + page->cp[H][cell->d[H][1] * 2]; + if (render_direction_rtl ()) + { + int temp = bb[H][0]; + bb[H][0] = clip[H][0] = render_page_get_size (page, H) - bb[H][1]; + bb[H][1] = clip[H][1] = render_page_get_size (page, H) - temp; + } 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]; @@ -957,7 +1079,8 @@ render_cell (const struct render_page *page, const int ofs[TABLE_N_AXES], } } - page->params->draw_cell (page->params->aux, cell, bb, clip); + page->params->draw_cell (page->params->aux, cell, + find_footnote_idx (cell, &page->footnotes), bb, clip); } /* Draws the cells of PAGE indicated in BB. */ @@ -991,7 +1114,7 @@ render_page_draw_cells (const struct render_page *page, /* Renders PAGE, by calling the 'draw_line' and 'draw_cell' functions from the render_params provided to render_page_create(). */ -void +static void render_page_draw (const struct render_page *page, int ofs[TABLE_N_AXES]) { int bb[TABLE_N_AXES][2]; @@ -1057,7 +1180,7 @@ get_clip_max_extent (int x1, const int cp[], int n) /* Renders the cells of PAGE that intersect (X,Y)-(X+W,Y+H), by calling the 'draw_line' and 'draw_cell' functions from the render_params provided to render_page_create(). */ -void +static void render_page_draw_region (const struct render_page *page, int ofs[TABLE_N_AXES], int clip[TABLE_N_AXES][2]) { @@ -1070,7 +1193,7 @@ render_page_draw_region (const struct render_page *page, render_page_draw_cells (page, ofs, bb); } - + /* Breaking up tables to fit on a page. */ /* An iterator for breaking render_pages into smaller chunks. */ @@ -1090,12 +1213,13 @@ static struct render_page *render_page_select (const struct render_page *, int z0, int p0, int z1, int p1); -/* Initializes render_break B for breaking PAGE along AXIS. */ +/* Initializes render_break B for breaking PAGE along AXIS. + Takes ownership of PAGE. */ static void -render_break_init (struct render_break *b, const struct render_page *page, +render_break_init (struct render_break *b, struct render_page *page, enum table_axis axis) { - b->page = render_page_ref (page); + b->page = page; b->axis = axis; b->z = page->h[axis][0]; b->pixel = 0; @@ -1216,7 +1340,8 @@ render_break_next (struct render_break *b, int size) table_get_cell (page->table, x, z, &cell); w = joined_width (page, H, cell.d[H][0], cell.d[H][1]); better_pixel = page->params->adjust_break ( - page->params->aux, &cell, w, pixel); + page->params->aux, &cell, + find_footnote_idx (&cell, &page->footnotes), w, pixel); x = cell.d[H][1]; table_cell_free (&cell); @@ -1311,49 +1436,109 @@ cell_is_breakable (const struct render_break *b, int cell) struct render_pager { - int width; + const struct render_params *params; + struct render_page **pages; - size_t cur_page, n_pages; + size_t n_pages, allocated_pages; + + size_t cur_page; struct render_break x_break; struct render_break y_break; }; -static void -render_pager_add_table (struct render_pager *p, struct table *table, - const struct render_params *params, - size_t *allocated_pages) +static const struct render_page * +render_pager_add_table (struct render_pager *p, struct table *table) { - if (p->n_pages >= *allocated_pages) - p->pages = x2nrealloc (p->pages, allocated_pages, sizeof *p->pages); - p->pages[p->n_pages++] = render_page_create (params, table); + struct render_page *page; + + if (p->n_pages >= p->allocated_pages) + p->pages = x2nrealloc (p->pages, &p->allocated_pages, sizeof *p->pages); + page = p->pages[p->n_pages++] = render_page_create (p->params, table); + return page; } static void render_pager_start_page (struct render_pager *p) { - render_break_init (&p->x_break, p->pages[p->cur_page++], H); + render_break_init (&p->x_break, render_page_ref (p->pages[p->cur_page++]), + H); render_break_init_empty (&p->y_break); } +static void +add_footnote_page (struct render_pager *p, const struct render_page *body) +{ + const struct table *table = body->table; + int nc = table_nc (table); + int nr = table_nr (table); + int footnote_idx = 0; + struct tab_table *t; + int x, y; + + if (!body->n_footnotes) + return; + + t = tab_create (2, body->n_footnotes); + for (y = 0; y < nr; y++) + for (x = 0; x < nc; ) + { + struct table_cell cell; + + table_get_cell (table, x, y, &cell); + if (y == cell.d[V][0]) + { + size_t i; + + for (i = 0; i < cell.n_contents; i++) + { + const struct cell_contents *cc = &cell.contents[i]; + size_t j; + + for (j = 0; j < cc->n_footnotes; j++) + { + const char *f = cc->footnotes[j]; + + tab_text (t, 0, footnote_idx, TAB_LEFT, ""); + tab_footnote (t, 0, footnote_idx, "(none)"); + tab_text (t, 1, footnote_idx, TAB_LEFT, f); + footnote_idx++; + } + } + } + x = cell.d[H][1]; + table_cell_free (&cell); + } + render_pager_add_table (p, &t->table); +} + /* 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 char *caption = table_item_get_caption (table_item); + const char *title = table_item_get_title (table_item); + const struct render_page *body_page; struct render_pager *p; - size_t allocated_pages = 0; - const char *caption; p = xzalloc (sizeof *p); - p->width = params->size[H]; + p->params = params; + + /* Title. */ + if (title) + render_pager_add_table (p, table_from_string (TAB_LEFT, title)); + + /* Body. */ + body_page = render_pager_add_table (p, table_ref (table_item_get_table ( + table_item))); - caption = table_item_get_caption (table_item); + /* Caption. */ if (caption) - render_pager_add_table (p, table_from_string (TAB_LEFT, caption), params, - &allocated_pages); - render_pager_add_table (p, table_ref (table_item_get_table (table_item)), params, - &allocated_pages); + render_pager_add_table (p, table_from_string (TAB_LEFT, caption)); + + /* Footnotes. */ + add_footnote_page (p, body_page); render_pager_start_page (p); @@ -1400,7 +1585,7 @@ render_pager_has_next (const struct render_pager *p_) } else render_break_init (&p->y_break, - render_break_next (&p->x_break, p->width), V); + render_break_next (&p->x_break, p->params->size[H]), V); } return true; } @@ -1459,11 +1644,14 @@ render_pager_draw_region (const struct render_pager *p, for (i = 0; i < p->n_pages; i++) { const struct render_page *page = p->pages[i]; + int size = render_page_get_size (page, V); clip[V][0] = MAX (y, ofs[V]) - ofs[V]; - clip[V][1] = MIN (y + h, ofs[V] + render_page_get_size (page, 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); + + ofs[V] += size; } } @@ -1524,8 +1712,8 @@ static struct render_overflow *insert_overflow (struct render_page_selection *, const struct table_cell *); /* Creates and returns a new render_page whose contents are a subregion of - PAGE's contents. The new render_page includes cells Z0 through Z1 along - AXIS, plus any headers on AXIS. + PAGE's contents. The new render_page includes cells Z0 through Z1 + (exclusive) along AXIS, plus any headers on AXIS. If P0 is nonzero, then it is a number of pixels to exclude from the left or top (according to AXIS) of cell Z0. Similarly, P1 is a number of pixels to @@ -1541,6 +1729,7 @@ static struct render_page * render_page_select (const struct render_page *page, enum table_axis axis, int z0, int p0, int z1, int p1) { + const struct render_footnote *f; struct render_page_selection s; enum table_axis a = axis; enum table_axis b = !a; @@ -1707,6 +1896,21 @@ render_page_select (const struct render_page *page, enum table_axis axis, table_cell_free (&cell); } + /* Copy footnotes from PAGE into subpage. */ + HMAP_FOR_EACH (f, struct render_footnote, node, &page->footnotes) + if ((f->d[a][0] >= z0 && f->d[a][0] < z1) + || (f->d[a][1] - 1 >= z0 && f->d[a][1] - 1 < z1)) + { + struct render_footnote *nf = xmalloc (sizeof *nf); + nf->d[a][0] = MAX (z0, f->d[a][0]) - z0 + page->h[a][0]; + nf->d[a][1] = MIN (z1, f->d[a][1]) - z0 + page->h[a][0]; + nf->d[b][0] = f->d[b][0]; + nf->d[b][1] = f->d[b][1]; + nf->idx = f->idx; + hmap_insert (&subpage->footnotes, &nf->node, + hash_cell (nf->d[H][0], nf->d[V][0])); + } + return subpage; } @@ -1759,7 +1963,7 @@ insert_overflow (struct render_page_selection *s, of = xzalloc (sizeof *of); cell_to_subpage (s, cell, of->d); hmap_insert (&s->subpage->overflows, &of->node, - hash_overflow (of->d[H], of->d[V])); + hash_cell (of->d[H], of->d[V])); old = find_overflow (s->page, cell->d[H][0], cell->d[V][0]); if (old != NULL)