#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"
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.
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. */
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)
{
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];
/* 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;
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)
{
struct render_pager
{
const struct render_params *params;
+ double scale;
- /* An array of "render_page"s to be rendered, in order, vertically. From
- the user's perspective, there's only one table per render_pager, but the
- implementation treats the title, table body, caption, footnotes,
- etc. each as a table, and that's why we have an array here. */
- 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
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);
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);
}
}
}
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;
}
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;
ofs[V] += render_page_get_size (page, V);
render_page_unref (page);
}
+
+ if (p->scale != 1.0)
+ ofs[V] *= p->scale;
+
return ofs[V];
}