#include "libpspp/hmap.h"
#include "libpspp/pool.h"
#include "output/render.h"
-#include "output/tab.h"
#include "output/table-item.h"
#include "output/table.h"
{
switch (type)
{
- case TAL_NONE:
+ case TABLE_STROKE_NONE:
return RENDER_LINE_NONE;
- case TAL_SOLID:
+ case TABLE_STROKE_SOLID:
return RENDER_LINE_SINGLE;
- case TAL_DASHED:
+ case TABLE_STROKE_DASHED:
return RENDER_LINE_DASHED;
- case TAL_THICK:
+ case TABLE_STROKE_THICK:
return RENDER_LINE_THICK;
- case TAL_THIN:
+ case TABLE_STROKE_THIN:
return RENDER_LINE_THIN;
- case TAL_DOUBLE:
+ case TABLE_STROKE_DOUBLE:
return RENDER_LINE_DOUBLE;
default:
NOT_REACHED ();
for (d[b] = 0; d[b] < table->n[b]; d[b]++)
rules |= 1u << table_get_rule (table, a, d[H], d[V], &color);
- /* 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[rule_to_render_type (i)]);
return width;
}
for (int i = 0; i < 2; i++)
columns[i] = xzalloc (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;
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. */
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;
{
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++)
/* Calculate heights of cells that do not span multiple rows. */
struct render_row *rows = xzalloc (nr * sizeof *rows);
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;
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;
}
set_join_crossings (page, H, &cell, rules[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;
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. */
{
d[a] = d2;
int r2 = table_get_rule (page->table, axis, d[H], d[V], color);
- r = table_rule_combine (r, r2);
+ r = table_stroke_combine (r, r2);
}
return rule_to_render_type (r);
}
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");
}
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);
}
}
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;
+ 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;
}
}
|| 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, 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. */
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;
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++;
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)
{
if (!n_footnotes)
return;
- struct tab_table *t = tab_create (1, n_footnotes);
+ struct table *t = table_create (1, n_footnotes, 0, 0, 0, 0);
+
for (size_t i = 0; i < n_footnotes; i++)
{
- tab_text_format (t, 0, i, TAB_LEFT, "%s. %s",
- f[i]->marker, f[i]->content);
- if (f[i]->style)
- tab_add_style (t, 0, i, f[i]->style);
+ table_text_format (t, 0, i, 0, "%s. %s", f[i]->marker, f[i]->content);
+ table_add_style (t, 0, i, f[i]->style);
}
- render_pager_add_table (p, &t->table, 0);
+ render_pager_add_table (p, t, 0);
free (f);
}
if (!t)
return;
- struct tab_table *tab = tab_create (1, 1);
- tab_text (tab, 0, 0, 0, t->content);
+ 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++)
- tab_add_footnote (tab, 0, 0, t->footnotes[i]);
+ table_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);
+ tab->styles[0] = table_area_style_clone (tab->container, t->style);
+ render_pager_add_table (p, tab, min_width);
}
static void
if (!layers)
return;
- struct tab_table *tab = tab_create (1, layers->n_layers);
+ struct table *tab = table_create (1, layers->n_layers, 0, 0, 0, 0);
for (size_t i = 0; i < layers->n_layers; i++)
{
const struct table_item_layer *layer = &layers->layers[i];
- tab_text (tab, 0, i, 0, layer->content);
+ table_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]);
+ table_add_footnote (tab, 0, i, layer->footnotes[j]);
}
if (layers->style)
- tab->styles[0] = area_style_clone (tab->container, layers->style);
- render_pager_add_table (p, &tab->table, min_width);
+ 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
};
if (!page->h[a][0] || z0 > page->h[a][0] || p0)
- for (int z = 0; z < page->n[b]; )
+ for (int z = 0; z < page->n[b];)
{
int d[TABLE_N_AXES];
d[a] = z0;
}
}
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]; )
+ for (int z = 0; z < page->n[b];)
{
int d[TABLE_N_AXES];
d[a] = z1 - 1;
cell_ofs (cell.d[a][1]));
}
z = cell.d[b][1];
- table_cell_free (&cell);
}
/* Copy overflows from PAGE into subpage. */
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;
projects / pspp / blobdiff