#define _(msgid) gettext (msgid)
\f
-#if DEBUGGING
static const bool debugging = true;
-#else
-static const bool debugging = false;
-#endif
+
/* Cell options. */
#define TAB_JOIN (1u << TAB_FIRST_AVAILABLE)
-#define TAB_SUBTABLE (1u << (TAB_FIRST_AVAILABLE + 1))
-#define TAB_BARE (1u << (TAB_FIRST_AVAILABLE + 2))
/* Joined cell. */
struct tab_joined_cell
u;
size_t n_footnotes;
- char **footnotes;
+ const struct footnote **footnotes;
+
+ const struct area_style *style;
};
static const struct table_class tab_table_class;
t->caption = NULL;
t->cf = nc;
t->cc = pool_calloc (t->container, nr * nc, sizeof *t->cc);
- t->ct = pool_malloc (t->container, nr * nc);
- memset (t->ct, 0, nc * nr);
+ t->ct = pool_calloc (t->container, nr * nc, sizeof *t->ct);
t->rh = pool_nmalloc (t->container, nc, nr + 1);
- memset (t->rh, 0, nc * (nr + 1));
+ memset (t->rh, TAL_0, nc * (nr + 1));
t->rv = pool_nmalloc (t->container, nr, nc + 1);
- memset (t->fmtmap, 0, sizeof (*t->fmtmap) * n_RC);
-
- memset (t->rv, TAL_GAP, nr * (nc + 1));
+ memset (t->rv, TAL_0, nr * (nc + 1));
+ memset (t->fmtmap, 0, sizeof (*t->fmtmap) * n_RC);
t->fmtmap[RC_PVALUE] = ugly[RC_PVALUE];
t->fmtmap[RC_INTEGER] = ugly[RC_INTEGER];
t->fmtmap[RC_OTHER] = *settings_get_format ();
+ memset (t->styles, 0, sizeof t->styles);
+ memset (t->rule_colors, 0, sizeof t->rule_colors);
+
t->col_ofs = t->row_ofs = 0;
return t;
int mc1 = MIN (nc, tab_nc (t));
void **new_cc;
- unsigned char *new_ct;
+ unsigned short *new_ct;
int r;
new_cc = pool_calloc (t->container, nr * nc, sizeof *new_cc);
{
memcpy (&new_cc[r * nc], &t->cc[r * tab_nc (t)],
mc1 * sizeof *t->cc);
- memcpy (&new_ct[r * nc], &t->ct[r * tab_nc (t)], mc1);
+ memcpy (&new_ct[r * nc], &t->ct[r * tab_nc (t)],
+ mc1 * sizeof *t->ct);
memset (&new_ct[r * nc + tab_nc (t)], 0, nc - tab_nc (t));
}
pool_free (t->container, t->cc);
else if (nr != tab_nr (t))
{
t->cc = pool_nrealloc (t->container, t->cc, nr * nc, sizeof *t->cc);
- t->ct = pool_realloc (t->container, t->ct, nr * nc);
+ t->ct = pool_nrealloc (t->container, t->ct, nr * nc, sizeof *t->ct);
t->rh = pool_nrealloc (t->container, t->rh, nc, nr + 1);
t->rv = pool_nrealloc (t->container, t->rv, nr, nc + 1);
{
memset (&t->rh[nc * (tab_nr (t) + 1)], TAL_0,
(nr - tab_nr (t)) * nc);
- memset (&t->rv[(nc + 1) * tab_nr (t)], TAL_GAP,
+ memset (&t->rv[(nc + 1) * tab_nr (t)], TAL_0,
(nr - tab_nr (t)) * (nc + 1));
}
}
- memset (&t->ct[nc * tab_nr (t)], 0, nc * (nr - tab_nr (t)));
+ memset (&t->ct[nc * tab_nr (t)], 0, nc * (nr - tab_nr (t)) * sizeof *t->ct);
memset (&t->cc[nc * tab_nr (t)], 0, nc * (nr - tab_nr (t)) * sizeof *t->cc);
table_set_nr (&t->table, nr);
/* Sets cell (C,R) in TABLE, with options OPT, to have a value taken
from V, displayed with format spec F. */
void
-tab_value (struct tab_table *table, int c, int r, unsigned char opt,
+tab_value (struct tab_table *table, int c, int r, unsigned short opt,
const union value *v, const struct variable *var,
const struct fmt_spec *f)
{
If FMT is null, then the default print format will be used.
*/
void
-tab_double (struct tab_table *table, int c, int r, unsigned char opt,
+tab_double (struct tab_table *table, int c, int r, unsigned short opt,
double val, const struct fmt_spec *fmt, enum result_class rc)
{
union value double_value;
j->d[TABLE_VERT][1] = ++y2 + table->row_ofs;
j->n_footnotes = 0;
j->footnotes = NULL;
+ j->style = NULL;
{
void **cc = &table->cc[x1 + y1 * table->cf];
- unsigned char *ct = &table->ct[x1 + y1 * table->cf];
+ unsigned short *ct = &table->ct[x1 + y1 * table->cf];
const int ofs = table->cf - (x2 - x1);
int y;
unsigned opt, const char *text)
{
char *s = pool_strdup (table->container, text);
- add_joined_cell (table, x1, y1, x2, y2, opt)->u.text = s;
+ if (x1 == x2 && y1 == y2)
+ do_tab_text (table, x1, y1, opt, s);
+ else
+ add_joined_cell (table, x1, y1, x2, y2, opt)->u.text = s;
}
/* Joins cells (X1,X2)-(Y1,Y2) inclusive in TABLE, and sets them
add_joined_cell (table, x1, y1, x2, y2, opt)->u.text = s;
}
+struct footnote *
+tab_create_footnote (struct tab_table *table, size_t idx, const char *content,
+ const char *marker, struct area_style *style)
+{
+ struct footnote *f = pool_alloc (table->container, sizeof *f);
+ f->idx = idx;
+ f->content = pool_strdup (table->container, content);
+ f->marker = pool_strdup (table->container, marker);
+ f->style = style;
+ return f;
+}
+
void
-tab_footnote (struct tab_table *table, int x, int y, const char *format, ...)
+tab_add_footnote (struct tab_table *table, int x, int y,
+ const struct footnote *f)
{
int index = x + y * table->cf;
- unsigned char opt = table->ct[index];
+ unsigned short opt = table->ct[index];
struct tab_joined_cell *j;
- va_list args;
if (opt & TAB_JOIN)
j = table->cc[index];
j->u.text = text ? text : xstrdup ("");
}
- j->footnotes = xrealloc (j->footnotes,
- (j->n_footnotes + 1) * sizeof *j->footnotes);
+ j->footnotes = pool_realloc (table->container, j->footnotes,
+ (j->n_footnotes + 1) * sizeof *j->footnotes);
- va_start (args, format);
- j->footnotes[j->n_footnotes++] =
- pool_vasprintf (table->container, format, args);
- va_end (args);
-}
-
-static void
-subtable_unref (void *subtable)
-{
- table_item_unref (subtable);
+ j->footnotes[j->n_footnotes++] = f;
}
-/* Places SUBTABLE as the content for cells (X1,X2)-(Y1,Y2) inclusive in TABLE
- with options OPT. */
void
-tab_subtable (struct tab_table *table, int x1, int y1, int x2, int y2,
- unsigned opt, struct table_item *subtable)
+tab_add_style (struct tab_table *table, int x, int y,
+ const struct area_style *style)
{
- add_joined_cell (table, x1, y1, x2, y2, opt | TAB_SUBTABLE)->u.subtable
- = subtable;
- pool_register (table->container, subtable_unref, subtable);
-}
+ int index = x + y * table->cf;
+ unsigned short opt = table->ct[index];
+ struct tab_joined_cell *j;
+
+ if (opt & TAB_JOIN)
+ j = table->cc[index];
+ else
+ {
+ char *text = table->cc[index];
-/* Places the contents of SUBTABLE as the content for cells (X1,X2)-(Y1,Y2)
- inclusive in TABLE with options OPT.
+ j = add_joined_cell (table, x, y, x, y, table->ct[index]);
+ j->u.text = text ? text : xstrdup ("");
+ }
- SUBTABLE must have exactly one row and column. The contents of its single
- cell are used as the contents of TABLE's cell; that is, SUBTABLE is not used
- as a nested table but its contents become part of TABLE. */
-void
-tab_subtable_bare (struct tab_table *table, int x1, int y1, int x2, int y2,
- unsigned opt, struct table_item *subtable)
-{
- const struct table *t UNUSED = table_item_get_table (subtable);
- assert (table_nc (t) == 1);
- assert (table_nr (t) == 1);
- tab_subtable (table, x1, y1, x2, y2, opt | TAB_BARE, subtable);
+ j->style = style;
}
bool
void
tab_output_text (int options, const char *string)
{
- enum text_item_type type = (options & TAB_EMPH ? TEXT_ITEM_SUBHEAD
- : options & TAB_FIX ? TEXT_ITEM_MONOSPACE
+ enum text_item_type type = (options & TAB_EMPH ? TEXT_ITEM_TITLE
+ : options & TAB_FIX ? TEXT_ITEM_LOG
: TEXT_ITEM_PARAGRAPH);
text_item_submit (text_item_create (type, string));
}
{
const struct tab_table *t = tab_cast (table);
int index = x + y * t->cf;
- unsigned char opt = t->ct[index];
+ unsigned short opt = t->ct[index];
const void *cc = t->cc[index];
- cell->inline_contents.options = opt;
- cell->inline_contents.table = NULL;
- cell->inline_contents.n_footnotes = 0;
+ cell->options = opt;
+ cell->n_footnotes = 0;
cell->destructor = NULL;
+ int style_idx = (opt & TAB_STYLE_MASK) >> TAB_STYLE_SHIFT;
+ const struct area_style *style = t->styles[style_idx];
+ if (style)
+ cell->style = style;
+ else
+ {
+ static const struct area_style styles[3][3] = {
+#define S(H,V) [H][V] = { AREA_STYLE_INITIALIZER__, \
+ .cell_style.halign = H, \
+ .cell_style.valign = V }
+ S(TABLE_HALIGN_LEFT, TABLE_VALIGN_TOP),
+ S(TABLE_HALIGN_LEFT, TABLE_VALIGN_CENTER),
+ S(TABLE_HALIGN_LEFT, TABLE_VALIGN_BOTTOM),
+ S(TABLE_HALIGN_CENTER, TABLE_VALIGN_TOP),
+ S(TABLE_HALIGN_CENTER, TABLE_VALIGN_CENTER),
+ S(TABLE_HALIGN_CENTER, TABLE_VALIGN_BOTTOM),
+ S(TABLE_HALIGN_RIGHT, TABLE_VALIGN_TOP),
+ S(TABLE_HALIGN_RIGHT, TABLE_VALIGN_CENTER),
+ S(TABLE_HALIGN_RIGHT, TABLE_VALIGN_BOTTOM),
+ };
+
+ enum table_halign halign
+ = ((opt & TAB_HALIGN) == TAB_LEFT ? TABLE_HALIGN_LEFT
+ : (opt & TAB_HALIGN) == TAB_CENTER ? TABLE_HALIGN_CENTER
+ : TABLE_HALIGN_RIGHT);
+ enum table_valign valign
+ = ((opt & TAB_VALIGN) == TAB_TOP ? TABLE_VALIGN_TOP
+ : (opt & TAB_VALIGN) == TAB_CENTER ? TABLE_VALIGN_CENTER
+ : TABLE_VALIGN_BOTTOM);
+
+ cell->style = &styles[halign][valign];
+ }
+
if (opt & TAB_JOIN)
{
const struct tab_joined_cell *jc = cc;
- if (opt & TAB_BARE)
- {
- assert (opt & TAB_SUBTABLE);
-
- /* This overwrites all of the members of CELL. */
- table_get_cell (table_item_get_table (jc->u.subtable), 0, 0, cell);
- }
- else
- {
- cell->contents = &cell->inline_contents;
- cell->n_contents = 1;
- if (opt & TAB_SUBTABLE)
- {
- cell->inline_contents.table = jc->u.subtable;
- cell->inline_contents.text = NULL;
- }
- else
- cell->inline_contents.text = jc->u.text;
- }
+ cell->text = jc->u.text;
- cell->inline_contents.footnotes = jc->footnotes;
- cell->inline_contents.n_footnotes = jc->n_footnotes;
+ cell->footnotes = jc->footnotes;
+ cell->n_footnotes = jc->n_footnotes;
cell->d[TABLE_HORZ][0] = jc->d[TABLE_HORZ][0];
cell->d[TABLE_HORZ][1] = jc->d[TABLE_HORZ][1];
cell->d[TABLE_VERT][0] = jc->d[TABLE_VERT][0];
cell->d[TABLE_VERT][1] = jc->d[TABLE_VERT][1];
+
+ if (jc->style)
+ cell->style = jc->style;
}
else
{
cell->d[TABLE_HORZ][1] = x + 1;
cell->d[TABLE_VERT][0] = y;
cell->d[TABLE_VERT][1] = y + 1;
- if (cc != NULL)
- {
- cell->contents = &cell->inline_contents;
- cell->n_contents = 1;
- cell->inline_contents.text = CONST_CAST (char *, cc);
- }
- else
- {
- cell->contents = NULL;
- cell->n_contents = 0;
- }
+ cell->text = CONST_CAST (char *, cc ? cc : "");
}
}
static int
-tab_get_rule (const struct table *table, enum table_axis axis, int x, int y)
+tab_get_rule (const struct table *table, enum table_axis axis, int x, int y,
+ struct cell_color *color)
{
const struct tab_table *t = tab_cast (table);
- return (axis == TABLE_VERT
- ? t->rh[x + t->cf * y] : t->rv[x + (t->cf + 1) * y]);
+ uint8_t raw = (axis == TABLE_VERT
+ ? t->rh[x + t->cf * y] : t->rv[x + (t->cf + 1) * y]);
+ struct cell_color *p = t->rule_colors[(raw & TAB_RULE_STYLE_MASK)
+ >> TAB_RULE_STYLE_SHIFT];
+ if (p)
+ *color = *p;
+ return (raw & TAB_RULE_TYPE_MASK) >> TAB_RULE_TYPE_SHIFT;
}
static const struct table_class tab_table_class = {
projects / pspp / blobdiff