/* PSPP - a program for statistical analysis.
- Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011, 2013, 2014 Free Software Foundation, Inc.
+ Copyright (C) 1997-9, 2000, 2006, 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
#include "gettext.h"
#define _(msgid) gettext (msgid)
\f
+
+static const bool debugging = true;
+
+
/* 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
+{
+ int d[TABLE_N_AXES][2]; /* Table region, same as struct table_cell. */
+ union
{
- int d[TABLE_N_AXES][2]; /* Table region, same as struct table_cell. */
- union
- {
- char *text;
- struct table_item *subtable;
- }
+ char *text;
+ struct table_item *subtable;
+ }
u;
- };
+
+ size_t n_footnotes;
+ const struct footnote **footnotes;
+
+ const struct area_style *style;
+};
static const struct table_class tab_table_class;
-struct fmt_spec ugly [n_RC] =
- {
- {FMT_F, 8, 0}, /* INTEGER */
- {FMT_F, 8, 3}, /* WEIGHT (ignored) */
- {FMT_F, 8, 3}, /* PVALUE */
- {FMT_F, 8, 3} /* OTHER (ignored) */
- };
+struct fmt_spec ugly[n_RC] = {
+ {FMT_F, 8, 0}, /* INTEGER */
+ {FMT_F, 8, 3}, /* WEIGHT (ignored) */
+ {FMT_F, 8, 3}, /* PVALUE */
+ {FMT_F, 8, 3} /* OTHER (ignored) */
+};
/* Creates and returns a new table with NC columns and NR rows and initially no
table_set_nr (&t->table, nr);
t->title = NULL;
+ 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;
}
-void
-tab_set_format (struct tab_table *t, enum result_class rc, const struct fmt_spec *fmt)
+void
+tab_set_format (struct tab_table *t, enum result_class rc,
+ const struct fmt_spec *fmt)
{
t->fmtmap[rc] = *fmt;
}
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);
new_ct = pool_malloc (t->container, nr * nc);
for (r = 0; r < mr1; r++)
- {
- 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);
- memset (&new_ct[r * nc + tab_nc (t)], 0, nc - tab_nc (t));
- }
+ {
+ 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 * sizeof *t->ct);
+ memset (&new_ct[r * nc + tab_nc (t)], 0, nc - tab_nc (t));
+ }
pool_free (t->container, t->cc);
pool_free (t->container, t->ct);
t->cc = new_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);
if (nr > tab_nr (t))
- {
- 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->rh[nc * (tab_nr (t) + 1)], TAL_0,
+ (nr - tab_nr (t)) * nc);
+ 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);
void
tab_vline (struct tab_table *t, int style, int x, int y1, int y2)
{
-#if DEBUGGING
- if (x + t->col_ofs < 0 || x + t->col_ofs > tab_nc (t)
- || y1 + t->row_ofs < 0 || y1 + t->row_ofs >= tab_nr (t)
- || y2 + t->row_ofs < 0 || y2 + t->row_ofs >= tab_nr (t))
+ if (debugging)
{
- printf (_("bad vline: x=%d+%d=%d y=(%d+%d=%d,%d+%d=%d) in "
- "table size (%d,%d)\n"),
- x, t->col_ofs, x + t->col_ofs,
- y1, t->row_ofs, y1 + t->row_ofs,
- y2, t->row_ofs, y2 + t->row_ofs,
- tab_nc (t), tab_nr (t));
- return;
+ if (x + t->col_ofs < 0 || x + t->col_ofs > tab_nc (t)
+ || y1 + t->row_ofs < 0 || y1 + t->row_ofs >= tab_nr (t)
+ || y2 + t->row_ofs < 0 || y2 + t->row_ofs >= tab_nr (t))
+ {
+ printf (_("bad vline: x=%d+%d=%d y=(%d+%d=%d,%d+%d=%d) in "
+ "table size (%d,%d)\n"),
+ x, t->col_ofs, x + t->col_ofs,
+ y1, t->row_ofs, y1 + t->row_ofs,
+ y2, t->row_ofs, y2 + t->row_ofs, tab_nc (t), tab_nr (t));
+ return;
+ }
}
-#endif
x += t->col_ofs;
y1 += t->row_ofs;
/* Draws a horizontal line above cells at vertical position Y from X1
to X2 inclusive in style STYLE, if style is not -1. */
void
-tab_hline (struct tab_table * t, int style, int x1, int x2, int y)
+tab_hline (struct tab_table *t, int style, int x1, int x2, int y)
{
-#if DEBUGGING
- if (y + t->row_ofs < 0 || y + t->row_ofs > tab_nr (t)
- || x1 + t->col_ofs < 0 || x1 + t->col_ofs >= tab_nc (t)
- || x2 + t->col_ofs < 0 || x2 + t->col_ofs >= tab_nc (t))
+ if (debugging)
{
- printf (_("bad hline: x=(%d+%d=%d,%d+%d=%d) y=%d+%d=%d in "
- "table size (%d,%d)\n"),
- x1, t->col_ofs, x1 + t->col_ofs,
- x2, t->col_ofs, x2 + t->col_ofs,
- y, t->row_ofs, y + t->row_ofs,
- tab_nc (t), tab_nr (t));
- return;
+ if (y + t->row_ofs < 0 || y + t->row_ofs > tab_nr (t)
+ || x1 + t->col_ofs < 0 || x1 + t->col_ofs >= tab_nc (t)
+ || x2 + t->col_ofs < 0 || x2 + t->col_ofs >= tab_nc (t))
+ {
+ printf (_("bad hline: x=(%d+%d=%d,%d+%d=%d) y=%d+%d=%d in "
+ "table size (%d,%d)\n"),
+ x1, t->col_ofs, x1 + t->col_ofs,
+ x2, t->col_ofs, x2 + t->col_ofs,
+ y, t->row_ofs, y + t->row_ofs, tab_nc (t), tab_nr (t));
+ return;
+ }
}
-#endif
x1 += t->col_ofs;
x2 += t->col_ofs;
assert (y >= 0);
assert (y <= tab_nr (t));
- assert (x2 >= x1 );
- assert (x1 >= 0 );
+ assert (x2 >= x1);
+ assert (x1 >= 0);
assert (x2 < tab_nc (t));
if (style != -1)
line. */
void
tab_box (struct tab_table *t, int f_h, int f_v, int i_h, int i_v,
- int x1, int y1, int x2, int y2)
+ int x1, int y1, int x2, int y2)
{
-#if DEBUGGING
- if (x1 + t->col_ofs < 0 || x1 + t->col_ofs >= tab_nc (t)
- || x2 + t->col_ofs < 0 || x2 + t->col_ofs >= tab_nc (t)
- || y1 + t->row_ofs < 0 || y1 + t->row_ofs >= tab_nr (t)
- || y2 + t->row_ofs < 0 || y2 + t->row_ofs >= tab_nr (t))
+ if (debugging)
{
- printf (_("bad box: (%d+%d=%d,%d+%d=%d)-(%d+%d=%d,%d+%d=%d) "
- "in table size (%d,%d)\n"),
- x1, t->col_ofs, x1 + t->col_ofs,
- y1, t->row_ofs, y1 + t->row_ofs,
- x2, t->col_ofs, x2 + t->col_ofs,
- y2, t->row_ofs, y2 + t->row_ofs,
- tab_nc (t), tab_nr (t));
- NOT_REACHED ();
+ if (x1 + t->col_ofs < 0 || x1 + t->col_ofs >= tab_nc (t)
+ || x2 + t->col_ofs < 0 || x2 + t->col_ofs >= tab_nc (t)
+ || y1 + t->row_ofs < 0 || y1 + t->row_ofs >= tab_nr (t)
+ || y2 + t->row_ofs < 0 || y2 + t->row_ofs >= tab_nr (t))
+ {
+ printf (_("bad box: (%d+%d=%d,%d+%d=%d)-(%d+%d=%d,%d+%d=%d) "
+ "in table size (%d,%d)\n"),
+ x1, t->col_ofs, x1 + t->col_ofs,
+ y1, t->row_ofs, y1 + t->row_ofs,
+ x2, t->col_ofs, x2 + t->col_ofs,
+ y2, t->row_ofs, y2 + t->row_ofs, tab_nc (t), tab_nr (t));
+ NOT_REACHED ();
+ }
}
-#endif
x1 += t->col_ofs;
x2 += t->col_ofs;
int y;
for (y = y1 + 1; y <= y2; y++)
- {
- int x;
+ {
+ int x;
for (x = x1; x <= x2; x++)
t->rh[x + t->cf * y] = i_h;
- }
+ }
}
if (i_v != -1)
{
int x;
for (x = x1 + 1; x <= x2; x++)
- {
- int y;
+ {
+ int y;
for (y = y1; y <= y2; y++)
t->rv[x + (t->cf + 1) * y] = i_v;
- }
+ }
}
}
\f
/* 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,
- const union value *v, const struct variable *var,
- const struct fmt_spec *f)
+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)
{
char *contents;
-#if DEBUGGING
- if (c + table->col_ofs < 0 || r + table->row_ofs < 0
- || c + table->col_ofs >= tab_nc (table)
- || r + table->row_ofs >= tab_nr (table))
+ if (debugging)
{
- printf ("tab_value(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
- "(%d,%d)\n",
- c, table->col_ofs, c + table->col_ofs,
- r, table->row_ofs, r + table->row_ofs,
- tab_nc (table), tab_nr (table));
- return;
+ if (c + table->col_ofs < 0 || r + table->row_ofs < 0
+ || c + table->col_ofs >= tab_nc (table)
+ || r + table->row_ofs >= tab_nr (table))
+ {
+ printf ("tab_value(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
+ "(%d,%d)\n",
+ c, table->col_ofs, c + table->col_ofs,
+ r, table->row_ofs, r + table->row_ofs,
+ tab_nc (table), tab_nr (table));
+ return;
+ }
}
-#endif
contents = data_out_stretchy (v, var_get_encoding (var),
f != NULL ? f : var_get_print_format (var),
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,
- double val, const struct fmt_spec *fmt, enum result_class rc)
+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 ;
+ union value double_value;
char *s;
assert (c >= 0);
if (fmt == NULL)
fmt = &table->fmtmap[rc];
-
+
fmt_check_output (fmt);
-#if DEBUGGING
- if (c + table->col_ofs < 0 || r + table->row_ofs < 0
- || c + table->col_ofs >= tab_nc (table)
- || r + table->row_ofs >= tab_nr (table))
+ if (debugging)
{
- printf ("tab_double(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
- "(%d,%d)\n",
- c, table->col_ofs, c + table->col_ofs,
- r, table->row_ofs, r + table->row_ofs,
- tab_nc (table), tab_nr (table));
- return;
+ if (c + table->col_ofs < 0 || r + table->row_ofs < 0
+ || c + table->col_ofs >= tab_nc (table)
+ || r + table->row_ofs >= tab_nr (table))
+ {
+ printf ("tab_double(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
+ "(%d,%d)\n",
+ c, table->col_ofs, c + table->col_ofs,
+ r, table->row_ofs, r + table->row_ofs,
+ tab_nc (table), tab_nr (table));
+ return;
+ }
}
-#endif
double_value.f = val;
s = data_out_stretchy (&double_value, C_ENCODING, fmt, table->container);
static void
do_tab_text (struct tab_table *table, int c, int r, unsigned opt, char *text)
{
- assert (c >= 0 );
- assert (r >= 0 );
+ assert (c >= 0);
+ assert (r >= 0);
assert (c < tab_nc (table));
assert (r < tab_nr (table));
-#if DEBUGGING
- if (c + table->col_ofs < 0 || r + table->row_ofs < 0
- || c + table->col_ofs >= tab_nc (table)
- || r + table->row_ofs >= tab_nr (table))
+ if (debugging)
{
- printf ("tab_text(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
- "(%d,%d)\n",
- c, table->col_ofs, c + table->col_ofs,
- r, table->row_ofs, r + table->row_ofs,
- tab_nc (table), tab_nr (table));
- return;
+ if (c + table->col_ofs < 0 || r + table->row_ofs < 0
+ || c + table->col_ofs >= tab_nc (table)
+ || r + table->row_ofs >= tab_nr (table))
+ {
+ printf ("tab_text(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
+ "(%d,%d)\n",
+ c, table->col_ofs, c + table->col_ofs,
+ r, table->row_ofs, r + table->row_ofs,
+ tab_nc (table), tab_nr (table));
+ return;
+ }
}
-#endif
table->cc[c + r * table->cf] = text;
table->ct[c + r * table->cf] = opt;
assert (y2 + table->row_ofs < tab_nr (table));
assert (x2 + table->col_ofs < tab_nc (table));
-#if DEBUGGING
- if (x1 + table->col_ofs < 0 || x1 + table->col_ofs >= tab_nc (table)
- || y1 + table->row_ofs < 0 || y1 + table->row_ofs >= tab_nr (table)
- || x2 < x1 || x2 + table->col_ofs >= tab_nc (table)
- || y2 < y2 || y2 + table->row_ofs >= tab_nr (table))
+ if (debugging)
{
- printf ("tab_joint_text(): bad cell "
- "(%d+%d=%d,%d+%d=%d)-(%d+%d=%d,%d+%d=%d) in table size (%d,%d)\n",
- x1, table->col_ofs, x1 + table->col_ofs,
- y1, table->row_ofs, y1 + table->row_ofs,
- x2, table->col_ofs, x2 + table->col_ofs,
- y2, table->row_ofs, y2 + table->row_ofs,
- tab_nc (table), tab_nr (table));
- return;
+ if (x1 + table->col_ofs < 0 || x1 + table->col_ofs >= tab_nc (table)
+ || y1 + table->row_ofs < 0 || y1 + table->row_ofs >= tab_nr (table)
+ || x2 < x1 || x2 + table->col_ofs >= tab_nc (table)
+ || y2 < y1 || y2 + table->row_ofs >= tab_nr (table))
+ {
+ printf ("tab_joint_text(): bad cell "
+ "(%d+%d=%d,%d+%d=%d)-(%d+%d=%d,%d+%d=%d) in table size (%d,%d)\n",
+ x1, table->col_ofs, x1 + table->col_ofs,
+ y1, table->row_ofs, y1 + table->row_ofs,
+ x2, table->col_ofs, x2 + table->col_ofs,
+ y2, table->row_ofs, y2 + table->row_ofs,
+ tab_nc (table), tab_nr (table));
+ return NULL;
+ }
}
-#endif
tab_box (table, -1, -1, TAL_0, TAL_0, x1, y1, x2, y2);
j->d[TABLE_VERT][0] = y1 + table->row_ofs;
j->d[TABLE_HORZ][1] = ++x2 + table->col_ofs;
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;
for (y = y1; y < y2; y++)
{
- int x;
+ int x;
- for (x = x1; x < x2; x++)
- {
- *cc++ = j;
- *ct++ = opt | TAB_JOIN;
- }
+ for (x = x1; x < x2; x++)
+ {
+ *cc++ = j;
+ *ct++ = opt | TAB_JOIN;
+ }
- cc += ofs;
- ct += ofs;
+ cc += ofs;
+ ct += ofs;
}
}
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
with options OPT to have text value FORMAT, which is formatted
as if passed to printf. */
void
-tab_joint_text_format (struct tab_table *table, int x1, int y1, int x2, int y2,
- unsigned opt, const char *format, ...)
+tab_joint_text_format (struct tab_table *table, int x1, int y1, int x2,
+ int y2, unsigned opt, const char *format, ...)
{
va_list args;
char *s;
add_joined_cell (table, x1, y1, x2, y2, opt)->u.text = s;
}
-static void
-subtable_unref (void *subtable)
+struct footnote *
+tab_create_footnote (struct tab_table *table, size_t idx, const char *content,
+ const char *marker, struct area_style *style)
{
- table_item_unref (subtable);
+ 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;
}
-/* 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_footnote (struct tab_table *table, int x, int y,
+ const struct footnote *f)
{
- 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];
+
+ j = add_joined_cell (table, x, y, x, y, table->ct[index]);
+ j->u.text = text ? text : xstrdup ("");
+ }
+
+ j->footnotes = pool_realloc (table->container, j->footnotes,
+ (j->n_footnotes + 1) * sizeof *j->footnotes);
-/* Places the contents of SUBTABLE as the content for cells (X1,X2)-(Y1,Y2)
- inclusive in TABLE with options OPT.
+ j->footnotes[j->n_footnotes++] = f;
+}
- 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)
+tab_add_style (struct tab_table *table, int x, int y,
+ const struct area_style *style)
{
- 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);
+ 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];
+
+ j = add_joined_cell (table, x, y, x, y, table->ct[index]);
+ j->u.text = text ? text : xstrdup ("");
+ }
+
+ j->style = style;
}
bool
va_end (args);
}
+/* Set the caption of table T to CAPTION, which is formatted as if
+ passed to printf(). */
+void
+tab_caption (struct tab_table *t, const char *caption, ...)
+{
+ va_list args;
+
+ free (t->caption);
+ va_start (args, caption);
+ t->caption = xvasprintf (caption, args);
+ va_end (args);
+}
+
/* Easy, type-safe way to submit a tab table to som. */
void
tab_submit (struct tab_table *t)
{
- table_item_submit (table_item_create (&t->table, t->title));
+ table_item_submit (table_item_create (&t->table, t->title, t->caption));
}
\f
/* Editing. */
{
int diff = 0;
-#if DEBUGGING
- if (row < -1 || row > tab_nr (t))
- {
- printf ("tab_offset(): row=%d in %d-row table\n", row, tab_nr (t));
- NOT_REACHED ();
- }
- if (col < -1 || col > tab_nc (t))
+ if (debugging)
{
- printf ("tab_offset(): col=%d in %d-column table\n", col, tab_nc (t));
- NOT_REACHED ();
+ if (row < -1 || row > tab_nr (t))
+ {
+ printf ("tab_offset(): row=%d in %d-row table\n", row, tab_nr (t));
+ NOT_REACHED ();
+ }
+ if (col < -1 || col > tab_nc (t))
+ {
+ printf ("tab_offset(): col=%d in %d-column table\n", col,
+ tab_nc (t));
+ NOT_REACHED ();
+ }
}
-#endif
if (row != -1)
diff += (row - t->row_ofs) * t->cf, t->row_ofs = row;
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));
}
struct tab_table *t = tab_cast (table);
free (t->title);
t->title = NULL;
+ free (t->caption);
+ t->caption = NULL;
pool_destroy (t->container);
}
static void
-tab_get_cell (const struct table *table, int x, int y, struct table_cell *cell)
+tab_get_cell (const struct table *table, int x, int y,
+ struct table_cell *cell)
{
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->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);
+ cell->text = jc->u.text;
- /* 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->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 =
- {
- tab_destroy,
- tab_get_cell,
- tab_get_rule,
- NULL, /* paste */
- NULL, /* select */
- };
+static const struct table_class tab_table_class = {
+ tab_destroy,
+ tab_get_cell,
+ tab_get_rule,
+ NULL, /* paste */
+ NULL, /* select */
+};
struct tab_table *
tab_cast (const struct table *table)
projects / pspp / blobdiff