/* PSPP - a program for statistical analysis.
- Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011, 2013, 2014 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 "output/table-provider.h"
#include "output/text-item.h"
-#include "gl/error.h"
#include "gl/minmax.h"
#include "gl/xalloc.h"
#include "gettext.h"
#define _(msgid) gettext (msgid)
\f
-/* Set in the options field of cells that */
-#define TAB_JOIN (1u << TAB_FIRST_AVAILABLE)
+/* 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. */
- char *contents;
+ union
+ {
+ char *text;
+ struct table_item *subtable;
+ }
+ u;
+
+ size_t n_footnotes;
+ char **footnotes;
};
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) */
+ };
+
+
/* Creates and returns a new table with NC columns and NR rows and initially no
header rows or columns. The table's cells are initially empty. */
struct tab_table *
memset (t->rh, 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));
+ t->fmtmap[RC_PVALUE] = ugly[RC_PVALUE];
+ t->fmtmap[RC_INTEGER] = ugly[RC_INTEGER];
+ t->fmtmap[RC_OTHER] = *settings_get_format ();
+
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)
+{
+ t->fmtmap[rc] = *fmt;
+}
+
+
/* Sets the width and height of a table, in columns and rows,
respectively. Use only to reduce the size of a table, since it
does not change the amount of allocated memory.
}
#endif
- contents = data_out_pool (v, var_get_encoding (var),
- f != NULL ? f : var_get_print_format (var),
- table->container);
+ contents = data_out_stretchy (v, var_get_encoding (var),
+ f != NULL ? f : var_get_print_format (var),
+ table->container);
table->cc[c + r * table->cf] = contents;
table->ct[c + r * table->cf] = opt;
}
-/* Sets cell (C,R) in TABLE, with options OPT, to have value VAL
- with NDEC decimal places. */
-void
-tab_fixed (struct tab_table *table, int c, int r, unsigned char opt,
- double val, int w, int d)
-{
- struct fmt_spec f;
- union value double_value;
- char *s;
-
- assert (c >= 0);
- assert (c < tab_nc (table));
- assert (r >= 0);
- assert (r < tab_nr (table));
-
- f = fmt_for_output (FMT_F, w, d);
-
-#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))
- {
- printf ("tab_fixed(): 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_pool (&double_value, C_ENCODING, &f, table->container);
-
- table->cc[c + r * table->cf] = s + strspn (s, " ");
- table->ct[c + r * table->cf] = opt;
-}
-
/* Sets cell (C,R) in TABLE, with options OPT, to have value VAL as
formatted by FMT.
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)
+ double val, const struct fmt_spec *fmt, enum result_class rc)
{
union value double_value ;
char *s;
assert (r >= 0);
assert (r < tab_nr (table));
- if ( fmt == NULL)
- fmt = settings_get_format ();
-
+ if (fmt == NULL)
+ fmt = &table->fmtmap[rc];
+
fmt_check_output (fmt);
#if DEBUGGING
#endif
double_value.f = val;
- s = data_out_pool (&double_value, C_ENCODING, fmt, table->container);
+ s = data_out_stretchy (&double_value, C_ENCODING, fmt, table->container);
table->cc[c + r * table->cf] = s + strspn (s, " ");
table->ct[c + r * table->cf] = opt;
}
va_end (args);
}
-static void
-do_tab_joint_text (struct tab_table *table, int x1, int y1, int x2, int y2,
- unsigned opt, char *text)
+static struct tab_joined_cell *
+add_joined_cell (struct tab_table *table, int x1, int y1, int x2, int y2,
+ unsigned opt)
{
struct tab_joined_cell *j;
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->contents = text;
-
- opt |= TAB_JOIN;
+ j->n_footnotes = 0;
+ j->footnotes = NULL;
{
void **cc = &table->cc[x1 + y1 * table->cf];
for (x = x1; x < x2; x++)
{
*cc++ = j;
- *ct++ = opt;
+ *ct++ = opt | TAB_JOIN;
}
cc += ofs;
ct += ofs;
}
}
+
+ return j;
}
/* Joins cells (X1,X2)-(Y1,Y2) inclusive in TABLE, and sets them with
tab_joint_text (struct tab_table *table, int x1, int y1, int x2, int y2,
unsigned opt, const char *text)
{
- do_tab_joint_text (table, x1, y1, x2, y2, opt,
- pool_strdup (table->container, text));
+ char *s = pool_strdup (table->container, text);
+ add_joined_cell (table, x1, y1, x2, y2, opt)->u.text = s;
}
/* Joins cells (X1,X2)-(Y1,Y2) inclusive in TABLE, and sets them
unsigned opt, const char *format, ...)
{
va_list args;
+ char *s;
va_start (args, format);
- do_tab_joint_text (table, x1, y1, x2, y2, opt,
- pool_vasprintf (table->container, format, args));
+ s = pool_vasprintf (table->container, format, args);
va_end (args);
+
+ add_joined_cell (table, x1, y1, x2, y2, opt)->u.text = s;
+}
+
+void
+tab_footnote (struct tab_table *table, int x, int y, const char *format, ...)
+{
+ int index = x + y * table->cf;
+ unsigned char opt = table->ct[index];
+ struct tab_joined_cell *j;
+ va_list args;
+
+ 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 = xrealloc (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);
+}
+
+/* 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)
+{
+ add_joined_cell (table, x1, y1, x2, y2, opt | TAB_SUBTABLE)->u.subtable
+ = subtable;
+ pool_register (table->container, subtable_unref, subtable);
+}
+
+/* Places the contents of SUBTABLE as the content for cells (X1,X2)-(Y1,Y2)
+ inclusive in TABLE with options OPT.
+
+ 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);
}
bool
const struct tab_table *t = tab_cast (table);
int index = x + y * t->cf;
unsigned char opt = t->ct[index];
- const void *content = t->cc[index];
+ const void *cc = t->cc[index];
+
+ cell->inline_contents.options = opt;
+ cell->inline_contents.table = NULL;
+ cell->inline_contents.n_footnotes = 0;
+ cell->destructor = NULL;
- cell->options = opt;
if (opt & TAB_JOIN)
{
- const struct tab_joined_cell *jc = content;
+ 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->inline_contents.footnotes = jc->footnotes;
+ cell->inline_contents.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];
- cell->contents = jc->contents;
}
else
{
cell->d[TABLE_HORZ][1] = x + 1;
cell->d[TABLE_VERT][0] = y;
cell->d[TABLE_VERT][1] = y + 1;
- cell->contents = content != NULL ? content : "";
+ 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->destructor = NULL;
}
static int
struct tab_table *
tab_cast (const struct table *table)
{
- assert (table->class == &tab_table_class);
+ assert (table->klass == &tab_table_class);
return UP_CAST (table, struct tab_table, table);
}
projects / pspp / blobdiff