#include "libpspp/i18n.h"
#include "libpspp/message.h"
#include "libpspp/str.h"
-#include "output/group-item.h"
+#include "output/output-item.h"
#include "xmalloca.h"
result = CMD_FAILURE;
goto finish;
}
- group_open_item_submit (
- group_open_item_create_nocopy (utf8_to_title (command->name),
- utf8_to_title (command->name)));
+ output_item_submit (group_open_item_create_nocopy (
+ utf8_to_title (command->name),
+ utf8_to_title (command->name)));
opened = true;
if (command->function == NULL)
lex_get (lexer);
if (opened)
- group_close_item_submit (group_close_item_create ());
+ output_item_submit (group_close_item_create ());
return result;
}
#include "libpspp/message.h"
#include "libpspp/misc.h"
#include "output/pivot-table.h"
-#include "output/table-item.h"
#include "gl/intprops.h"
#include "gl/minmax.h"
#include "language/expressions/public.h"
#include "language/lexer/lexer.h"
#include "libpspp/message.h"
-#include "output/text-item.h"
+#include "output/output-item.h"
#include "gl/xalloc.h"
while (n--)
if (trns->writer == NULL)
- text_item_submit (text_item_create (TEXT_ITEM_LOG, "", NULL));
+ output_item_submit (text_item_create (TEXT_ITEM_LOG, "", NULL));
else
dfm_put_record (trns->writer, " ", 1); /* XXX */
#include "libpspp/u8-line.h"
#include "output/pivot-table.h"
#include "output/table.h"
-#include "output/page-break-item.h"
-#include "output/text-item.h"
+#include "output/output-item.h"
#include "gl/xalloc.h"
{
*eject = false;
if (trns->writer == NULL)
- page_break_item_submit (page_break_item_create ());
+ output_item_submit (page_break_item_create ());
else
leader = '1';
}
*u8_line_reserve (line, 0, 1, 1) = leader;
if (trns->writer == NULL)
- text_item_submit (text_item_create (TEXT_ITEM_LOG,
- ds_cstr (&line->s) + 1,
- NULL));
+ output_item_submit (text_item_create (TEXT_ITEM_LOG,
+ ds_cstr (&line->s) + 1,
+ NULL));
else
{
size_t len = ds_length (&line->s);
#include "libpspp/pool.h"
#include "libpspp/string-array.h"
#include "output/pivot-table.h"
-#include "output/text-item.h"
-#include "output/table-item.h"
+#include "output/output-item.h"
#include "gl/count-one-bits.h"
#include "gl/localcharset.h"
#include "libpspp/str.h"
#include "libpspp/u8-istream.h"
#include "output/journal.h"
-#include "output/text-item.h"
+#include "output/output-item.h"
#include "gl/c-ctype.h"
#include "gl/minmax.h"
copy_len--;
/* Submit the line as syntax. */
- text_item_submit (text_item_create_nocopy (TEXT_ITEM_SYNTAX,
- xmemdup0 (line, copy_len),
- NULL));
+ output_item_submit (text_item_create_nocopy (TEXT_ITEM_SYNTAX,
+ xmemdup0 (line, copy_len),
+ NULL));
src->journal_pos += line_len;
}
#include "libpspp/pool.h"
#include "libpspp/str.h"
#include "output/pivot-table.h"
-#include "output/chart-item.h"
#include "output/charts/barchart.h"
#include "gl/minmax.h"
const struct variable **vars = xcalloc (n_vars, sizeof *vars);
for (size_t i = 0; i < n_vars; i++)
vars[i] = xt->vars[i].var;
- chart_item_submit (barchart_create (vars, n_vars, _("Count"),
- false,
- xt->entries, xt->n_entries));
+ chart_submit (barchart_create (vars, n_vars, _("Count"),
+ false,
+ xt->entries, xt->n_entries));
free (vars);
}
}
int grp;
for (grp = 0; grp < n_cats; ++grp)
{
- struct chart_item *npp, *dnpp;
+ struct chart *npp, *dnpp;
struct casereader *reader;
struct np *np;
if (npp == NULL || dnpp == NULL)
{
msg (MW, _("Not creating NP plot because data set is empty."));
- chart_item_unref (npp);
- chart_item_unref (dnpp);
+ chart_unref (npp);
+ chart_unref (dnpp);
}
else
{
- chart_item_submit (npp);
- chart_item_submit (dnpp);
+ chart_submit (npp);
+ chart_submit (dnpp);
}
casereader_destroy (reader);
for (v = 0; v < cmd->n_dep_vars; ++v)
{
int grp;
- struct chart_item *sl;
+ struct chart *sl;
struct string label;
ds_init_cstr (&label,
if (sl == NULL)
msg (MW, _("Not creating spreadlevel chart for %s"), ds_cstr (&label));
else
- chart_item_submit (sl);
+ chart_submit (sl);
ds_destroy (&label);
}
moments_calculate (es[v].mom, &n, &mean, &var, NULL, NULL);
- chart_item_submit
+ chart_submit
(histogram_chart_create (es[v].histogram->gsl_hist,
ds_cstr (&label), n, mean,
sqrt (var), false));
#include "math/correlation.h"
#include "math/covariance.h"
#include "math/moments.h"
-#include "output/chart-item.h"
#include "output/charts/scree.h"
#include "output/pivot-table.h"
#include "math/chart-geometry.h"
-#include "output/chart-item.h"
#include "output/charts/barchart.h"
#include "output/charts/piechart.h"
#include "output/charts/plot-hist.h"
if (histogram)
{
- chart_item_submit (histogram_chart_create (
- histogram->gsl_hist, var_to_string(vf->var),
- vf->tab.valid_cases,
- d[FRQ_ST_MEAN],
- d[FRQ_ST_STDDEV],
- frq->hist->draw_normal));
+ chart_submit (histogram_chart_create (
+ histogram->gsl_hist, var_to_string(vf->var),
+ vf->tab.valid_cases,
+ d[FRQ_ST_MEAN],
+ d[FRQ_ST_STDDEV],
+ frq->hist->draw_normal));
statistic_destroy (&histogram->parent);
}
msg (SW, _("Omitting pie chart for %s, which has over 50 unique values."),
var_get_name (var));
else
- chart_item_submit (piechart_create (var, slices, n_slices));
+ chart_submit (piechart_create (var, slices, n_slices));
free (slices);
}
int n_slices;
struct freq **slices = pick_cat_counts_ptr (bar, frq_tab, &n_slices);
- chart_item_submit (barchart_create (var, 1,
- (bar->y_scale == FRQ_FREQ) ? _("Count") : _("Percent"),
- (bar->y_scale == FRQ_PERCENT),
- slices, n_slices));
+ chart_submit (barchart_create (var, 1,
+ (bar->y_scale == FRQ_FREQ) ? _("Count") : _("Percent"),
+ (bar->y_scale == FRQ_PERCENT),
+ slices, n_slices));
free (slices);
}
moments_calculate (cmd->es[0].mom, &n, &mean, &var, NULL, NULL);
- chart_item_submit
+ chart_submit
(histogram_chart_create (histogram->gsl_hist,
ds_cstr (&label), n, mean,
sqrt (var), cmd->normal));
ds_put_cstr (&label,
ag_func[cmd->agr].description);
- chart_item_submit (barchart_create (cmd->by_var, cmd->n_by_vars,
- ds_cstr (&label), false,
- cells, n_cells));
+ chart_submit (barchart_create (cmd->by_var, cmd->n_by_vars,
+ ds_cstr (&label), false,
+ cells, n_cells));
ds_destroy (&label);
}
#include "libpspp/str.h"
#include "math/random.h"
#include "output/pivot-table.h"
-#include "output/text-item.h"
+#include "output/output-item.h"
#include "gettext.h"
#define _(msgid) gettext (msgid)
#include "libpspp/str.h"
#include "math/moments.h"
#include "output/pivot-table.h"
-#include "output/text-item.h"
+#include "output/output-item.h"
#include "gettext.h"
#define _(msgid) gettext (msgid)
alpha (s->n_items, s->sum_of_variances, s->variance_of_sums);
}
- text_item_submit (text_item_create_nocopy (
- TEXT_ITEM_TITLE,
- xasprintf (_("Scale: %s"), ds_cstr (&rel->scale_name)),
- NULL));
+ output_item_submit (text_item_create_nocopy (
+ TEXT_ITEM_TITLE,
+ xasprintf (_("Scale: %s"), ds_cstr (&rel->scale_name)),
+ NULL));
case_processing_summary (n_valid, n_missing, dataset_dict (ds));
}
#include "language/lexer/variable-parser.h"
#include "libpspp/misc.h"
#include "math/sort.h"
-#include "output/chart-item.h"
#include "output/charts/roc-chart.h"
#include "output/pivot-table.h"
#include "language/lexer/lexer.h"
#include "libpspp/message.h"
#include "libpspp/str.h"
-#include "output/text-item.h"
+#include "output/output-item.h"
+#include "output/driver.h"
#include "gl/xalloc.h"
if (!lex_force_string (lexer))
return CMD_FAILURE;
- text_item_submit (text_item_create (TEXT_ITEM_LOG, lex_tokcstr (lexer),
- _("Echo")));
+ output_submit (text_item_create (TEXT_ITEM_LOG, lex_tokcstr (lexer),
+ _("Echo")));
lex_get (lexer);
return CMD_SUCCESS;
#include "libpspp/str.h"
#include "libpspp/string-array.h"
#include "libpspp/temp-file.h"
-#include "output/text-item.h"
+#include "output/output-item.h"
#include "gl/error.h"
#include "gl/intprops.h"
if (end > output && end[-1] == '\n')
end[-1] = '\0';
- text_item_submit (text_item_create_nocopy (TEXT_ITEM_LOG, output,
- xstrdup (_("Host Output"))));
+ output_item_submit (text_item_create_nocopy (TEXT_ITEM_LOG, output,
+ xstrdup (_("Host Output"))));
}
free (locale_output);
#include "libpspp/version.h"
#include "output/ascii.h"
#include "output/cairo-chart.h"
-#include "output/chart-item-provider.h"
+#include "output/chart-provider.h"
#include "output/driver-provider.h"
-#include "output/image-item.h"
-#include "output/message-item.h"
#include "output/options.h"
#include "output/pivot-output.h"
#include "output/pivot-table.h"
#include "output/render.h"
-#include "output/table-item.h"
-#include "output/text-item.h"
+#include "output/output-item.h"
#include "gl/minmax.h"
#include "gl/xalloc.h"
static void
ascii_output_table_item (struct ascii_driver *a,
- const struct table_item *table_item)
+ const struct output_item *item)
{
update_page_size (a, false);
- a->pt = table_item->pt;
+ a->pt = item->table;
size_t *layer_indexes;
- PIVOT_OUTPUT_FOR_EACH_LAYER (layer_indexes, table_item->pt, true)
+ PIVOT_OUTPUT_FOR_EACH_LAYER (layer_indexes, item->table, true)
{
- struct render_pager *p = render_pager_create (&a->params, table_item,
+ struct render_pager *p = render_pager_create (&a->params, item->table,
layer_indexes);
for (int i = 0; render_pager_has_next (p); i++)
{
static void
ascii_output_table_item_unref (struct ascii_driver *a,
- struct table_item *table_item)
+ struct output_item *table_item)
{
ascii_output_table_item (a, table_item);
- table_item_unref (table_item);
+ output_item_unref (table_item);
}
static void
ascii_submit (struct output_driver *driver,
- const struct output_item *output_item)
+ const struct output_item *item)
{
struct ascii_driver *a = ascii_driver_cast (driver);
if (a->error)
return;
- if (is_table_item (output_item))
- ascii_output_table_item (a, to_table_item (output_item));
- else if (is_image_item (output_item) && a->chart_file_name != NULL)
+ switch (item->type)
{
- struct image_item *image_item = to_image_item (output_item);
- char *file_name = xr_write_png_image (
- image_item->image, a->chart_file_name, ++a->chart_cnt);
- if (file_name != NULL)
- {
- struct text_item *text_item;
-
- text_item = text_item_create_nocopy (
- TEXT_ITEM_LOG,
- xasprintf (_("See %s for an image."), file_name),
- NULL);
+ case OUTPUT_ITEM_TABLE:
+ ascii_output_table_item (a, item);
+ break;
- ascii_submit (driver, &text_item->output_item);
- text_item_unref (text_item);
- free (file_name);
- }
- }
- else if (is_chart_item (output_item) && a->chart_file_name != NULL)
- {
- struct chart_item *chart_item = to_chart_item (output_item);
- char *file_name;
-
- file_name = xr_draw_png_chart (chart_item, a->chart_file_name,
- ++a->chart_cnt,
- &a->fg,
- &a->bg);
- if (file_name != NULL)
+ case OUTPUT_ITEM_IMAGE:
+ if (a->chart_file_name != NULL)
{
- struct text_item *text_item;
-
- text_item = text_item_create_nocopy (
- TEXT_ITEM_LOG,
- xasprintf (_("See %s for a chart."), file_name),
- NULL);
+ char *file_name = xr_write_png_image (
+ item->image, a->chart_file_name, ++a->chart_cnt);
+ if (file_name != NULL)
+ {
+ struct output_item *text_item = text_item_create_nocopy (
+ TEXT_ITEM_LOG,
+ xasprintf (_("See %s for an image."), file_name),
+ NULL);
+
+ ascii_submit (driver, text_item);
+ output_item_unref (text_item);
+ free (file_name);
+ }
+ }
+ break;
- ascii_submit (driver, &text_item->output_item);
- text_item_unref (text_item);
- free (file_name);
+ case OUTPUT_ITEM_CHART:
+ if (a->chart_file_name != NULL)
+ {
+ char *file_name = xr_draw_png_chart (item->chart, a->chart_file_name,
+ ++a->chart_cnt, &a->fg,
+ &a->bg);
+ if (file_name != NULL)
+ {
+ struct output_item *text_item = text_item_create_nocopy (
+ TEXT_ITEM_LOG,
+ xasprintf (_("See %s for a chart."), file_name),
+ NULL);
+
+ ascii_submit (driver, text_item);
+ output_item_unref (text_item);
+ free (file_name);
+ }
}
- }
- else if (is_text_item (output_item))
- {
- const struct text_item *text_item = to_text_item (output_item);
- enum text_item_type type = text_item_get_type (text_item);
+ break;
- if (type != TEXT_ITEM_PAGE_TITLE)
+ case OUTPUT_ITEM_TEXT:
+ if (item->text.subtype != TEXT_ITEM_PAGE_TITLE)
ascii_output_table_item_unref (
- a, text_item_to_table_item (text_item_ref (text_item)));
+ a, text_item_to_table_item (output_item_ref (item)));
+ break;
+
+ case OUTPUT_ITEM_MESSAGE:
+ ascii_output_table_item_unref (
+ a, text_item_to_table_item (
+ message_item_to_text_item (
+ output_item_ref (item))));
+ break;
+
+ case OUTPUT_ITEM_GROUP_OPEN:
+ case OUTPUT_ITEM_GROUP_CLOSE:
+ case OUTPUT_ITEM_PAGE_BREAK:
+ case OUTPUT_ITEM_PAGE_SETUP:
+ break;
}
- else if (is_message_item (output_item))
- ascii_output_table_item_unref (
- a, text_item_to_table_item (
- message_item_to_text_item (
- to_message_item (
- output_item_ref (output_item)))));
}
const struct output_driver_factory txt_driver_factory =
src/output/cairo-pager.c \
src/output/cairo-pager.h \
src/output/cairo.c \
- src/output/chart-item-provider.h \
- src/output/chart-item.c \
- src/output/chart-item.h \
+ src/output/chart-provider.h \
+ src/output/chart.c \
+ src/output/chart.h \
src/output/charts/barchart-cairo.c \
src/output/charts/barchart.c \
src/output/charts/barchart.h \
src/output/driver-provider.h \
src/output/driver.c \
src/output/driver.h \
- src/output/group-item.c \
- src/output/group-item.h \
src/output/html.c \
- src/output/image-item.c \
- src/output/image-item.h \
src/output/journal.c \
src/output/journal.h \
src/output/measure.c \
src/output/measure.h \
- src/output/message-item.c \
- src/output/message-item.h \
src/output/msglog.c \
src/output/msglog.h \
src/output/odt.c \
src/output/options.c \
src/output/options.h \
- src/output/output-item-provider.h \
src/output/output-item.c \
src/output/output-item.h \
- src/output/page-break-item.c \
- src/output/page-break-item.h \
- src/output/page-setup-item.c \
- src/output/page-setup-item.h \
+ src/output/page-setup.c \
+ src/output/page-setup.h \
src/output/pivot-output.c \
src/output/pivot-output.h \
src/output/pivot-table.c \
src/output/render.c \
src/output/render.h \
src/output/spv-driver.c \
- src/output/table-item.c \
- src/output/table-item.h \
src/output/table-provider.h \
src/output/table.c \
src/output/table.h \
src/output/tex-parsing.h \
src/output/tex-rendering.c \
src/output/tex-rendering.h \
- src/output/tex.c \
- src/output/text-item.c \
- src/output/text-item.h
+ src/output/tex.c
nodist_src_output_liboutput_la_SOURCES =
EXTRA_DIST += \
#include "libpspp/assertion.h"
#include "libpspp/message.h"
#include "math/chart-geometry.h"
-#include "output/chart-item.h"
#include "output/charts/barchart.h"
#include "output/charts/boxplot.h"
#include "output/charts/np-plot.h"
}
\f
void
-xr_draw_chart (const struct chart_item *chart_item, cairo_t *cr,
+xr_draw_chart (const struct chart *chart, cairo_t *cr,
double width, double height)
{
struct xrchart_geometry geom;
cairo_translate (cr, 0, height);
cairo_scale (cr, 1.0, -1.0);
xrchart_geometry_init (cr, &geom, width, height);
- if (is_boxplot (chart_item))
- xrchart_draw_boxplot (chart_item, cr, &geom);
- else if (is_histogram_chart (chart_item))
- xrchart_draw_histogram (chart_item, cr, &geom);
- else if (is_np_plot_chart (chart_item))
- xrchart_draw_np_plot (chart_item, cr, &geom);
- else if (is_piechart (chart_item))
- xrchart_draw_piechart (chart_item, cr, &geom);
- else if (is_barchart (chart_item))
- xrchart_draw_barchart (chart_item, cr, &geom);
- else if (is_roc_chart (chart_item))
- xrchart_draw_roc (chart_item, cr, &geom);
- else if (is_scree (chart_item))
- xrchart_draw_scree (chart_item, cr, &geom);
- else if (is_spreadlevel_plot_chart (chart_item))
- xrchart_draw_spreadlevel (chart_item, cr, &geom);
- else if (is_scatterplot_chart (chart_item))
- xrchart_draw_scatterplot (chart_item, cr, &geom);
+ if (is_boxplot (chart))
+ xrchart_draw_boxplot (chart, cr, &geom);
+ else if (is_histogram_chart (chart))
+ xrchart_draw_histogram (chart, cr, &geom);
+ else if (is_np_plot_chart (chart))
+ xrchart_draw_np_plot (chart, cr, &geom);
+ else if (is_piechart (chart))
+ xrchart_draw_piechart (chart, cr, &geom);
+ else if (is_barchart (chart))
+ xrchart_draw_barchart (chart, cr, &geom);
+ else if (is_roc_chart (chart))
+ xrchart_draw_roc (chart, cr, &geom);
+ else if (is_scree (chart))
+ xrchart_draw_scree (chart, cr, &geom);
+ else if (is_spreadlevel_plot_chart (chart))
+ xrchart_draw_spreadlevel (chart, cr, &geom);
+ else if (is_scatterplot_chart (chart))
+ xrchart_draw_scatterplot (chart, cr, &geom);
else
NOT_REACHED ();
xrchart_geometry_free (cr, &geom);
}
cairo_surface_t *
-xr_draw_image_chart (const struct chart_item *item,
+xr_draw_image_chart (const struct chart *chart,
const struct cell_color *fg,
const struct cell_color *bg)
{
cairo_paint (cr);
cairo_set_source_rgb (cr, fg->r / 255.0, fg->g / 255.0, fg->b / 255.0);
- xr_draw_chart (item, cr, width, length);
+ xr_draw_chart (chart, cr, width, length);
cairo_destroy (cr);
}
char *
-xr_draw_png_chart (const struct chart_item *item,
+xr_draw_png_chart (const struct chart *chart,
const char *file_name_template, int number,
const struct cell_color *fg,
const struct cell_color *bg)
{
- cairo_surface_t *surface = xr_draw_image_chart (item, fg, bg);
+ cairo_surface_t *surface = xr_draw_image_chart (chart, fg, bg);
char *file_name = xr_write_png_image (surface, file_name_template, number);
cairo_surface_destroy (surface);
return file_name;
}
char *
-xr_draw_eps_chart (const struct chart_item *item,
+xr_draw_eps_chart (const struct chart *chart,
const char *file_name_template, int number,
const struct cell_color *fg,
const struct cell_color *bg)
cairo_set_source_rgb (cr, fg->r / 255.0, fg->g / 255.0, fg->b / 255.0);
- xr_draw_chart (item, cr, width, length);
+ xr_draw_chart (chart, cr, width, length);
cairo_destroy (cr);
cairo_surface_destroy (surface);
#include <stdint.h>
#include "libpspp/compiler.h"
-struct chart_item;
struct cell_color;
+struct chart;
struct xrchart_colour
{
double limit1, double limit2, enum xrchart_dim lim_dim);
/* Drawing various kinds of charts. */
-void xrchart_draw_boxplot (const struct chart_item *, cairo_t *,
+void xrchart_draw_boxplot (const struct chart *, cairo_t *,
struct xrchart_geometry *);
-void xrchart_draw_roc (const struct chart_item *, cairo_t *,
+void xrchart_draw_roc (const struct chart *, cairo_t *,
struct xrchart_geometry *);
-void xrchart_draw_piechart (const struct chart_item *, cairo_t *,
+void xrchart_draw_piechart (const struct chart *, cairo_t *,
struct xrchart_geometry *);
-void xrchart_draw_barchart (const struct chart_item *, cairo_t *,
+void xrchart_draw_barchart (const struct chart *, cairo_t *,
struct xrchart_geometry *);
-void xrchart_draw_histogram (const struct chart_item *, cairo_t *,
+void xrchart_draw_histogram (const struct chart *, cairo_t *,
struct xrchart_geometry *);
-void xrchart_draw_np_plot (const struct chart_item *, cairo_t *,
+void xrchart_draw_np_plot (const struct chart *, cairo_t *,
struct xrchart_geometry *);
-void xrchart_draw_scree (const struct chart_item *, cairo_t *,
+void xrchart_draw_scree (const struct chart *, cairo_t *,
struct xrchart_geometry *);
-void xrchart_draw_spreadlevel (const struct chart_item *, cairo_t *,
+void xrchart_draw_spreadlevel (const struct chart *, cairo_t *,
struct xrchart_geometry *);
-void xrchart_draw_scatterplot (const struct chart_item *, cairo_t *,
+void xrchart_draw_scatterplot (const struct chart *, cairo_t *,
struct xrchart_geometry *);
-void xr_draw_chart (const struct chart_item *, cairo_t *,
+void xr_draw_chart (const struct chart *, cairo_t *,
double width, double height);
-cairo_surface_t *xr_draw_image_chart (const struct chart_item *,
+cairo_surface_t *xr_draw_image_chart (const struct chart *,
const struct cell_color *fg,
const struct cell_color *bg);
char *xr_write_png_image (cairo_surface_t *,
const char *file_name_template, int number);
-char *xr_draw_png_chart (const struct chart_item *,
+char *xr_draw_png_chart (const struct chart *,
const char *file_name_template, int number,
const struct cell_color *fg,
const struct cell_color *bg);
-char *xr_draw_eps_chart (const struct chart_item *item,
+char *xr_draw_eps_chart (const struct chart *,
const char *file_name_template, int number,
const struct cell_color *fg,
const struct cell_color *bg);
#include "libpspp/assertion.h"
#include "libpspp/str.h"
#include "output/cairo-chart.h"
-#include "output/chart-item-provider.h"
-#include "output/chart-item.h"
+#include "output/chart-provider.h"
#include "output/charts/barchart.h"
#include "output/charts/boxplot.h"
#include "output/charts/np-plot.h"
#include "output/charts/scatterplot.h"
#include "output/charts/scree.h"
#include "output/charts/spreadlevel-plot.h"
-#include "output/group-item.h"
-#include "output/image-item.h"
-#include "output/message-item.h"
-#include "output/page-break-item.h"
-#include "output/page-setup-item.h"
#include "output/pivot-output.h"
#include "output/pivot-table.h"
#include "output/render.h"
-#include "output/table-item.h"
-#include "output/text-item.h"
+#include "output/output-item.h"
#include "gl/c-ctype.h"
#include "gl/c-strcase.h"
int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
int *widthp, int *brk)
{
- const struct pivot_table *pt = to_table_item (xr->item)->pt;
+ const struct pivot_table *pt = xr->item->table;
const struct font_style *font_style = cell->font_style;
const struct cell_style *cell_style = cell->cell_style;
unsigned int options = cell->options;
const struct xr_fsm_style *style, cairo_t *cr,
bool print)
{
- if (is_page_setup_item (item_)
- || is_group_open_item (item_)
- || is_group_close_item (item_))
- return NULL;
-
struct output_item *item;
- if (is_table_item (item_)
- || is_chart_item (item_)
- || is_image_item (item_)
- || is_page_break_item (item_))
- item = output_item_ref (item_);
- else if (is_message_item (item_))
- item = table_item_super (
- text_item_to_table_item (
- message_item_to_text_item (
- to_message_item (
- output_item_ref (item_)))));
- else if (is_text_item (item_))
+
+ switch (item_->type)
{
- if (to_text_item (item_)->type == TEXT_ITEM_PAGE_TITLE)
+ case OUTPUT_ITEM_CHART:
+ case OUTPUT_ITEM_IMAGE:
+ case OUTPUT_ITEM_PAGE_BREAK:
+ case OUTPUT_ITEM_TABLE:
+ item = output_item_ref (item_);
+ break;
+
+ case OUTPUT_ITEM_GROUP_OPEN:
+ case OUTPUT_ITEM_GROUP_CLOSE:
+ case OUTPUT_ITEM_PAGE_SETUP:
+ return NULL;
+
+ case OUTPUT_ITEM_MESSAGE:
+ item = text_item_to_table_item (message_item_to_text_item (
+ output_item_ref (item_)));
+ break;
+
+ case OUTPUT_ITEM_TEXT:
+ if (item_->text.subtype == TEXT_ITEM_PAGE_TITLE)
return NULL;
- item = table_item_super (
- text_item_to_table_item (
- to_text_item (
- output_item_ref (item_))));
+ item = text_item_to_table_item (output_item_ref (item_));
+ break;
+
+ default:
+ NOT_REACHED ();
}
- else
- NOT_REACHED ();
- assert (is_table_item (item)
- || is_chart_item (item)
- || is_image_item (item)
- || is_page_break_item (item));
+
+ assert (item->type == OUTPUT_ITEM_TABLE
+ || item->type == OUTPUT_ITEM_CHART
+ || item->type == OUTPUT_ITEM_IMAGE
+ || item->type == OUTPUT_ITEM_PAGE_BREAK);
size_t *layer_indexes = NULL;
- if (is_table_item (item))
+ if (item->type == OUTPUT_ITEM_TABLE)
{
- const struct table_item *table_item = to_table_item (item);
- layer_indexes = pivot_output_next_layer (table_item->pt, NULL, print);
+ layer_indexes = pivot_output_next_layer (item->table, NULL, print);
if (!layer_indexes)
return NULL;
}
g_object_unref (G_OBJECT (layout));
- if (is_table_item (item))
+ if (item->type == OUTPUT_ITEM_TABLE)
{
- struct table_item *table_item = to_table_item (item);
-
fsm->cairo = cr;
- fsm->p = render_pager_create (&fsm->rp, table_item, fsm->layer_indexes);
+ fsm->p = render_pager_create (&fsm->rp, item->table, fsm->layer_indexes);
fsm->cairo = NULL;
}
int w, h;
- if (is_table_item (fsm->item))
+ switch (fsm->item->type)
{
+ case OUTPUT_ITEM_CHART:
+ w = CHART_WIDTH;
+ h = CHART_HEIGHT;
+ break;
+
+ case OUTPUT_ITEM_IMAGE:
+ w = cairo_image_surface_get_width (fsm->item->image);
+ h = cairo_image_surface_get_height (fsm->item->image);
+ break;
+
+ case OUTPUT_ITEM_TABLE:
fsm->cairo = cr;
w = render_pager_get_size (fsm->p, H) / XR_POINT;
h = render_pager_get_size (fsm->p, V) / XR_POINT;
fsm->cairo = NULL;
+ break;
+
+ case OUTPUT_ITEM_GROUP_OPEN:
+ case OUTPUT_ITEM_GROUP_CLOSE:
+ case OUTPUT_ITEM_MESSAGE:
+ case OUTPUT_ITEM_PAGE_BREAK:
+ case OUTPUT_ITEM_PAGE_SETUP:
+ case OUTPUT_ITEM_TEXT:
+ default:
+ NOT_REACHED ();
}
- else if (is_chart_item (fsm->item))
- {
- w = CHART_WIDTH;
- h = CHART_HEIGHT;
- }
- else if (is_image_item (fsm->item))
- {
- cairo_surface_t *image = to_image_item (fsm->item)->image;
- w = cairo_image_surface_get_width (image);
- h = cairo_image_surface_get_height (image);
- }
- else
- NOT_REACHED ();
if (wp)
*wp = w;
int x, int y, int w, int h)
{
assert (!fsm->print);
- if (is_table_item (fsm->item))
+ switch (fsm->item->type)
{
+ case OUTPUT_ITEM_CHART:
+ xr_draw_chart (fsm->item->chart, cr, CHART_WIDTH, CHART_HEIGHT);
+ break;
+
+ case OUTPUT_ITEM_IMAGE:
+ draw_image (fsm->item->image, cr);
+ break;
+
+ case OUTPUT_ITEM_TABLE:
fsm->cairo = cr;
render_pager_draw_region (fsm->p, mul_XR_POINT (x), mul_XR_POINT (y),
mul_XR_POINT (w), mul_XR_POINT (h));
fsm->cairo = NULL;
+ break;
+
+ case OUTPUT_ITEM_GROUP_OPEN:
+ case OUTPUT_ITEM_GROUP_CLOSE:
+ case OUTPUT_ITEM_MESSAGE:
+ case OUTPUT_ITEM_PAGE_BREAK:
+ case OUTPUT_ITEM_PAGE_SETUP:
+ case OUTPUT_ITEM_TEXT:
+ NOT_REACHED ();
}
- else if (is_image_item (fsm->item))
- draw_image (to_image_item (fsm->item)->image, cr);
- else if (is_chart_item (fsm->item))
- xr_draw_chart (to_chart_item (fsm->item), cr, CHART_WIDTH, CHART_HEIGHT);
- else if (is_page_break_item (fsm->item))
- {
- /* Nothing to do. */
- }
- else
- NOT_REACHED ();
}
\f
/* Printing API. */
static int
xr_fsm_draw_table (struct xr_fsm *fsm, int space)
{
- struct table_item *table_item = to_table_item (fsm->item);
int used = render_pager_draw_next (fsm->p, space);
if (!render_pager_has_next (fsm->p))
{
render_pager_destroy (fsm->p);
- fsm->layer_indexes = pivot_output_next_layer (table_item->pt,
+ fsm->layer_indexes = pivot_output_next_layer (fsm->item->table,
fsm->layer_indexes, true);
if (fsm->layer_indexes)
{
- fsm->p = render_pager_create (&fsm->rp, table_item,
+ fsm->p = render_pager_create (&fsm->rp, fsm->item->table,
fsm->layer_indexes);
- if (table_item->pt->look->paginate_layers)
+ if (fsm->item->table->look->paginate_layers)
used = space;
else
used += fsm->style->object_spacing;
return 0;
fsm->done = true;
- xr_draw_chart (to_chart_item (fsm->item), fsm->cairo,
+ xr_draw_chart (fsm->item->chart, fsm->cairo,
xr_to_pt (fsm->rp.size[H]), xr_to_pt (chart_height));
return chart_height;
}
static int
xr_fsm_draw_image (struct xr_fsm *fsm, int space)
{
- cairo_surface_t *image = to_image_item (fsm->item)->image;
+ cairo_surface_t *image = fsm->item->image;
int width = cairo_image_surface_get_width (image) * XR_POINT;
int height = cairo_image_surface_get_height (image) * XR_POINT;
if (!width || !height)
cairo_save (cr);
fsm->cairo = cr;
- int used = (is_table_item (fsm->item) ? xr_fsm_draw_table (fsm, space)
- : is_chart_item (fsm->item) ? xr_fsm_draw_chart (fsm, space)
- : is_image_item (fsm->item) ? xr_fsm_draw_image (fsm, space)
- : is_page_break_item (fsm->item) ? xr_fsm_draw_page_break (fsm,
- space)
- : (abort (), 0));
+ int used;
+ switch (fsm->item->type)
+ {
+ case OUTPUT_ITEM_CHART:
+ used = xr_fsm_draw_chart (fsm, space);
+ break;
+
+ case OUTPUT_ITEM_IMAGE:
+ used = xr_fsm_draw_image (fsm, space);
+ break;
+
+ case OUTPUT_ITEM_PAGE_BREAK:
+ used = xr_fsm_draw_page_break (fsm, space);
+ break;
+
+ case OUTPUT_ITEM_TABLE:
+ used = xr_fsm_draw_table (fsm, space);
+ break;
+
+ case OUTPUT_ITEM_GROUP_OPEN:
+ case OUTPUT_ITEM_GROUP_CLOSE:
+ case OUTPUT_ITEM_MESSAGE:
+ case OUTPUT_ITEM_PAGE_SETUP:
+ case OUTPUT_ITEM_TEXT:
+ default:
+ NOT_REACHED ();
+ }
fsm->cairo = NULL;
cairo_restore (cr);
#include <pango/pango-layout.h>
#include <pango/pangocairo.h>
-#include "output/chart-item.h"
#include "output/driver-provider.h"
-#include "output/group-item.h"
-#include "output/message-item.h"
-#include "output/page-setup-item.h"
-#include "output/table-item.h"
-#include "output/text-item.h"
+#include "output/output-item.h"
#include "gl/xalloc.h"
the outline item can be the first object actually output in it). */
int *group_ids;
size_t n_group_ids, allocated_group_ids;
- struct group_open_item **group_opens;
+ struct output_item **group_opens;
size_t n_opens, allocated_opens;
/* Current output page. */
{
free (p->group_ids);
for (size_t i = 0; i < p->n_opens; i++)
- group_open_item_unref (p->group_opens[i]);
+ output_item_unref (p->group_opens[i]);
free (p->group_opens);
xr_page_style_unref (p->page_style);
{
if (!p->fsm)
{
- if (is_group_open_item (p->item))
+ if (p->item->type == OUTPUT_ITEM_GROUP_OPEN)
{
if (p->n_opens >= p->allocated_opens)
p->group_opens = x2nrealloc (p->group_opens,
&p->allocated_opens,
sizeof p->group_opens);
- p->group_opens[p->n_opens++] = group_open_item_ref (
- to_group_open_item (p->item));
+ p->group_opens[p->n_opens++] = output_item_ref (p->item);
}
- else if (is_group_close_item (p->item))
+ else if (p->item->type == OUTPUT_ITEM_GROUP_CLOSE)
{
if (p->n_opens)
- group_open_item_unref (p->group_opens[--p->n_opens]);
+ output_item_unref (p->group_opens[--p->n_opens]);
else if (p->n_group_ids)
p->n_group_ids--;
else
{
parent_group_id = add_outline (
p->cr, parent_group_id,
- output_item_get_label (&p->group_opens[i]->output_item),
+ output_item_get_label (p->group_opens[i]),
attrs, CAIRO_PDF_OUTLINE_FLAG_OPEN);
- group_open_item_unref (p->group_opens[i]);
+ output_item_unref (p->group_opens[i]);
if (p->n_group_ids >= p->allocated_group_ids)
p->group_ids = x2nrealloc (p->group_ids,
#include <cairo/cairo.h>
#include <pango/pango-font.h>
#include "output/cairo-fsm.h"
-#include "output/page-setup-item.h"
+#include "output/page-setup.h"
#include "output/table.h"
struct xr_page_style
#include "output/cairo-pager.h"
#include "output/driver-provider.h"
#include "output/options.h"
+#include "output/output-item.h"
#include "output/table.h"
#include <cairo/cairo-pdf.h>
}
static void
-xr_submit (struct output_driver *driver, const struct output_item *output_item)
+xr_submit (struct output_driver *driver, const struct output_item *item)
{
struct xr_driver *xr = xr_driver_cast (driver);
- if (is_page_setup_item (output_item))
+ if (item->type == OUTPUT_ITEM_PAGE_SETUP)
{
if (!xr->pager)
- xr_update_page_setup (driver,
- to_page_setup_item (output_item)->page_setup);
+ xr_update_page_setup (driver, item->page_setup);
return;
}
xr_pager_add_page (xr->pager, cairo_create (xr->drawing_surface));
}
- xr_pager_add_item (xr->pager, output_item);
+ xr_pager_add_item (xr->pager, item);
while (xr_pager_needs_new_page (xr->pager))
{
xr_finish_page (xr);
+++ /dev/null
-/* PSPP - a program for statistical analysis.
- Copyright (C) 2004, 2009, 2011 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-#ifndef OUTPUT_CHART_ITEM_PROVIDER_H
-#define OUTPUT_CHART_ITEM_PROVIDER_H 1
-
-#include "output/chart-item.h"
-#include "output/output-item.h"
-
-struct chart_item_class
- {
- void (*destroy) (struct chart_item *);
- };
-
-void chart_item_init (struct chart_item *, const struct chart_item_class *,
- const char *title);
-
-#endif /* output/chart-provider.h */
+++ /dev/null
-/* PSPP - a program for statistical analysis.
- Copyright (C) 2004, 2009, 2011 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-#include <config.h>
-
-#include "output/chart-item.h"
-#include "output/chart-item-provider.h"
-
-#include <assert.h>
-#include <stdlib.h>
-
-#include "libpspp/cast.h"
-#include "libpspp/compiler.h"
-#include "libpspp/str.h"
-#include "output/driver.h"
-#include "output/output-item-provider.h"
-
-#include "gl/xalloc.h"
-
-#include "gettext.h"
-#define _(msgid) gettext (msgid)
-
-/* Initializes ITEM as a chart item of the specified CLASS. The new chart item
- initially has the specified TITLE, which may be NULL if no title is yet
- available. The caller retains ownership of TITLE.
-
- A chart item is an abstract class, that is, a plain chart_item is not useful
- on its own. Thus, this function is normally called from the initialization
- function of some subclass of chart_item. */
-void
-chart_item_init (struct chart_item *item, const struct chart_item_class *class,
- const char *title)
-{
- *item = (struct chart_item) {
- .output_item = OUTPUT_ITEM_INITIALIZER (&chart_item_class),
- .class = class,
- .title = xstrdup_if_nonnull (title)
- };
-}
-
-/* Returns ITEM's title, which is a null pointer if no title has been set. */
-const char *
-chart_item_get_title (const struct chart_item *item)
-{
- return item->title;
-}
-
-/* Sets ITEM's title to TITLE, replacing any previous title. Specify NULL for
- TITLE to clear any title from ITEM. The caller retains ownership of
- TITLE.
-
- This function may only be used on a chart_item that is unshared. */
-void
-chart_item_set_title (struct chart_item *item, const char *title)
-{
- assert (!chart_item_is_shared (item));
- free (item->title);
- item->title = xstrdup_if_nonnull (title);
-}
-
-/* Submits ITEM to the configured output drivers, and transfers ownership to
- the output subsystem. */
-void
-chart_item_submit (struct chart_item *item)
-{
- output_submit (&item->output_item);
-}
-\f
-static const char *
-chart_item_get_label (const struct output_item *output_item)
-{
- const struct chart_item *item = to_chart_item (output_item);
- return item->title ? item->title : _("Chart");
-}
-
-static void
-chart_item_destroy (struct output_item *output_item)
-{
- struct chart_item *item = to_chart_item (output_item);
- char *title = item->title;
- item->class->destroy (item);
- free (title);
-}
-
-const struct output_item_class chart_item_class =
- {
- chart_item_get_label,
- chart_item_destroy,
- };
+++ /dev/null
-/* PSPP - a program for statistical analysis.
- Copyright (C) 2009, 2011 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-#ifndef OUTPUT_CHART_ITEM_H
-#define OUTPUT_CHART_ITEM_H 1
-
-/* Chart items.
-
- A chart item is a subclass of an output item (see output/output-item.h).
-
- A chart item is abstract. Every actual chart is a subclass of
- chart_item. */
-
-#include <stdbool.h>
-#include "output/output-item.h"
-
-/* A chart item.
-
- The members of struct chart_item should not be accessed directly. Use one
- of the accessor functions defined below. */
-struct chart_item
- {
- struct output_item output_item; /* Superclass */
- const struct chart_item_class *class; /* Subclass. */
- char *title; /* May be null if there is no title. */
- };
-
-const char *chart_item_get_title (const struct chart_item *);
-void chart_item_set_title (struct chart_item *, const char *);
-\f
-/* This boilerplate for chart_item, a subclass of output_item, was
- autogenerated by mk-class-boilerplate. */
-
-#include <assert.h>
-#include "libpspp/cast.h"
-
-extern const struct output_item_class chart_item_class;
-
-/* Returns true if SUPER is a chart_item, otherwise false. */
-static inline bool
-is_chart_item (const struct output_item *super)
-{
- return super->class == &chart_item_class;
-}
-
-/* Returns SUPER converted to chart_item. SUPER must be a chart_item, as
- reported by is_chart_item. */
-static inline struct chart_item *
-to_chart_item (const struct output_item *super)
-{
- assert (is_chart_item (super));
- return UP_CAST (super, struct chart_item, output_item);
-}
-
-/* Returns INSTANCE converted to output_item. */
-static inline struct output_item *
-chart_item_super (const struct chart_item *instance)
-{
- return CONST_CAST (struct output_item *, &instance->output_item);
-}
-
-/* Increments INSTANCE's reference count and returns INSTANCE. */
-static inline struct chart_item *
-chart_item_ref (const struct chart_item *instance)
-{
- return to_chart_item (output_item_ref (&instance->output_item));
-}
-
-/* Decrements INSTANCE's reference count, then destroys INSTANCE if
- the reference count is now zero. */
-static inline void
-chart_item_unref (struct chart_item *instance)
-{
- output_item_unref (&instance->output_item);
-}
-
-/* Returns true if INSTANCE's reference count is greater than 1,
- false otherwise. */
-static inline bool
-chart_item_is_shared (const struct chart_item *instance)
-{
- return output_item_is_shared (&instance->output_item);
-}
-
-void chart_item_submit (struct chart_item *);
-\f
-#endif /* output/chart-item.h */
--- /dev/null
+/* PSPP - a program for statistical analysis.
+ Copyright (C) 2004, 2009, 2011 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#ifndef OUTPUT_CHART_PROVIDER_H
+#define OUTPUT_CHART_PROVIDER_H 1
+
+#include "output/chart.h"
+
+struct chart_class
+ {
+ void (*destroy) (struct chart *);
+ };
+
+void chart_init (struct chart *, const struct chart_class *,
+ const char *title);
+
+#endif /* output/chart-provider.h */
--- /dev/null
+/* PSPP - a program for statistical analysis.
+ Copyright (C) 2004, 2009, 2011 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#include <config.h>
+
+#include <assert.h>
+#include <stdlib.h>
+
+#include "libpspp/cast.h"
+#include "libpspp/compiler.h"
+#include "libpspp/str.h"
+#include "output/chart-provider.h"
+#include "output/output-item.h"
+
+#include "gl/xalloc.h"
+
+#include "gettext.h"
+#define _(msgid) gettext (msgid)
+
+struct chart *
+chart_ref (const struct chart *chart_)
+{
+ struct chart *chart = CONST_CAST (struct chart *, chart_);
+ assert (chart->ref_cnt > 0);
+ chart->ref_cnt++;
+ return chart;
+}
+
+void
+chart_unref (struct chart *chart)
+{
+ if (chart)
+ {
+ assert (chart->ref_cnt > 0);
+ if (!--chart->ref_cnt)
+ {
+ char *title = chart->title;
+ chart->class->destroy (chart);
+ free (title);
+ }
+ }
+}
+
+bool
+chart_is_shared (const struct chart *chart)
+{
+ assert (chart->ref_cnt > 0);
+ return chart->ref_cnt > 1;
+}
+
+/* Initializes CHART as a chart of the specified CLASS. The new chart
+ initially has the specified TITLE, which may be NULL if no title is yet
+ available. The caller retains ownership of TITLE.
+
+ A chart is abstract, that is, a plain chart is not useful on its own. Thus,
+ this function is normally called from the initialization function of some
+ subclass of chart. */
+void
+chart_init (struct chart *chart, const struct chart_class *class,
+ const char *title)
+{
+ *chart = (struct chart) {
+ .ref_cnt = 1,
+ .class = class,
+ .title = xstrdup_if_nonnull (title),
+ };
+}
+
+/* Returns CHART's title, which is a null pointer if no title has been set. */
+const char *
+chart_get_title (const struct chart *chart)
+{
+ return chart->title;
+}
+
+/* Sets CHART's title to TITLE, replacing any previous title. Specify NULL for
+ TITLE to clear any title from CHART. The caller retains ownership of
+ TITLE.
+
+ This function may only be used on a chart that is unshared. */
+void
+chart_set_title (struct chart *chart, const char *title)
+{
+ assert (!chart_is_shared (chart));
+ free (chart->title);
+ chart->title = xstrdup_if_nonnull (title);
+}
+
+/* Submits CHART to the configured output drivers, and transfers ownership to
+ the output subsystem. */
+void
+chart_submit (struct chart *chart)
+{
+ if (chart)
+ output_item_submit (chart_item_create (chart));
+}
void
-xrchart_draw_barchart (const struct chart_item *chart_item, cairo_t *cr,
+xrchart_draw_barchart (const struct chart *chart, cairo_t *cr,
struct xrchart_geometry *geom)
{
- struct barchart *bc = to_barchart (chart_item);
+ struct barchart *bc = to_barchart (chart);
int i;
xrchart_write_title (cr, geom, _("Bar Chart"));
xrchart_write_ylabel (cr, geom, bc->ylabel);
- xrchart_write_xlabel (cr, geom, chart_item_get_title (chart_item));
+ xrchart_write_xlabel (cr, geom, chart_get_title (chart));
if (! xrchart_write_yscale (cr, geom, 0,
bc->percent ? bc->largest * 100.0 / bc->total_count : bc->largest))
#include "libpspp/cast.h"
#include "libpspp/str.h"
#include "libpspp/array.h"
-#include "output/chart-item-provider.h"
+#include "output/chart-provider.h"
#include "gl/xalloc.h"
#include "data/variable.h"
CATS are the counts of the values of those variables. N_CATS is the
number of distinct values.
*/
-struct chart_item *
+struct chart *
barchart_create (const struct variable **var, int n_vars,
const char *ylabel, bool percent,
struct freq *const *cats, int n_cats)
bar->var = var;
bar->n_vars = n_vars;
bar->n_nzcats = n_cats;
- chart_item_init (&bar->chart_item, &barchart_class, var_to_string (var[pidx]));
+ chart_init (&bar->chart, &barchart_class, var_to_string (var[pidx]));
bar->largest = -1;
bar->ylabel = strdup (ylabel);
if (settings_get_testing_mode ())
barchart_dump (bar, stdout);
- return &bar->chart_item;
+ return &bar->chart;
}
static void
}
static void
-barchart_destroy (struct chart_item *chart_item)
+barchart_destroy (struct chart *chart)
{
- struct barchart *bar = to_barchart (chart_item);
+ struct barchart *bar = to_barchart (chart);
int i;
free (bar);
}
-const struct chart_item_class barchart_class =
+const struct chart_class barchart_class =
{
barchart_destroy
};
#include "libpspp/str.h"
#include "libpspp/hmap.h"
#include "data/value.h"
-#include "output/chart-item.h"
+#include "output/chart.h"
struct category
struct barchart
{
- struct chart_item chart_item;
+ struct chart chart;
/* Should the chart be displayed as percentages */
bool percent;
struct variable;
struct freq;
-struct chart_item *barchart_create (const struct variable **, int n_vars,
+struct chart *barchart_create (const struct variable **, int n_vars,
const char *ylabel, bool percent,
struct freq *const *, int n_cats);
\f
-/* This boilerplate for barchart, a subclass of chart_item, was
+/* This boilerplate for barchart, a subclass of chart, was
autogenerated by mk-class-boilerplate. */
#include <assert.h>
#include "libpspp/cast.h"
-extern const struct chart_item_class barchart_class;
+extern const struct chart_class barchart_class;
/* Returns true if SUPER is a barchart, otherwise false. */
static inline bool
-is_barchart (const struct chart_item *super)
+is_barchart (const struct chart *super)
{
return super->class == &barchart_class;
}
/* Returns SUPER converted to barchart. SUPER must be a barchart, as
reported by is_barchart. */
static inline struct barchart *
-to_barchart (const struct chart_item *super)
+to_barchart (const struct chart *super)
{
assert (is_barchart (super));
- return UP_CAST (super, struct barchart, chart_item);
+ return UP_CAST (super, struct barchart, chart);
}
-/* Returns INSTANCE converted to chart_item. */
-static inline struct chart_item *
+/* Returns INSTANCE converted to chart. */
+static inline struct chart *
barchart_super (const struct barchart *instance)
{
- return CONST_CAST (struct chart_item *, &instance->chart_item);
+ return CONST_CAST (struct chart *, &instance->chart);
}
/* Increments INSTANCE's reference count and returns INSTANCE. */
static inline struct barchart *
barchart_ref (const struct barchart *instance)
{
- return to_barchart (chart_item_ref (&instance->chart_item));
+ return to_barchart (chart_ref (&instance->chart));
}
/* Decrements INSTANCE's reference count, then destroys INSTANCE if
static inline void
barchart_unref (struct barchart *instance)
{
- chart_item_unref (&instance->chart_item);
+ chart_unref (&instance->chart);
}
/* Returns true if INSTANCE's reference count is greater than 1,
static inline bool
barchart_is_shared (const struct barchart *instance)
{
- return chart_item_is_shared (&instance->chart_item);
+ return chart_is_shared (&instance->chart);
}
static inline void
barchart_submit (struct barchart *instance)
{
- chart_item_submit (&instance->chart_item);
+ chart_submit (&instance->chart);
}
\f
#endif /* output/charts/barchart.h */
}
void
-xrchart_draw_boxplot (const struct chart_item *chart_item, cairo_t *cr,
+xrchart_draw_boxplot (const struct chart *chart, cairo_t *cr,
struct xrchart_geometry *geom)
{
- const struct boxplot *boxplot = to_boxplot (chart_item);
+ const struct boxplot *boxplot = to_boxplot (chart);
double box_width;
size_t i;
if (! xrchart_write_yscale (cr, geom, boxplot->y_min, boxplot->y_max))
return;
- xrchart_write_title (cr, geom, "%s", chart_item->title);
+ xrchart_write_title (cr, geom, "%s", chart->title);
box_width = (geom->axis[SCALE_ABSCISSA].data_max - geom->axis[SCALE_ABSCISSA].data_min) / boxplot->n_boxes / 2.0;
for (i = 0; i < boxplot->n_boxes; i++)
#include "output/charts/boxplot.h"
#include "math/box-whisker.h"
-#include "output/chart-item-provider.h"
+#include "output/chart-provider.h"
struct boxplot *
boxplot_create (double y_min, double y_max, const char *title)
if (y_min >= y_max)
return NULL;
struct boxplot *boxplot = xmalloc (sizeof *boxplot);
- chart_item_init (&boxplot->chart_item, &boxplot_class, title);
+ chart_init (&boxplot->chart, &boxplot_class, title);
boxplot->y_min = y_min;
boxplot->y_max = y_max;
boxplot->boxes = NULL;
}
static void
-boxplot_chart_destroy (struct chart_item *chart_item)
+boxplot_chart_destroy (struct chart *chart)
{
- struct boxplot *boxplot = to_boxplot (chart_item);
+ struct boxplot *boxplot = to_boxplot (chart);
if (boxplot == NULL)
return;
free (boxplot);
}
-const struct chart_item_class boxplot_class =
+const struct chart_class boxplot_class =
{
boxplot_chart_destroy
};
#define OUTPUT_CHARTS_BOXPLOT_H 1
#include <stddef.h>
-#include "output/chart-item.h"
+#include "output/chart.h"
/* Box-whiskers plot. */
struct boxplot
{
- struct chart_item chart_item;
+ struct chart chart;
/* Data. */
struct boxplot_box *boxes;
void boxplot_add_box (struct boxplot *,
struct box_whisker *, const char *label);
\f
-/* This boilerplate for boxplot, a subclass of chart_item, was
+/* This boilerplate for boxplot, a subclass of chart, was
autogenerated by mk-class-boilerplate. */
#include <assert.h>
#include "libpspp/cast.h"
-extern const struct chart_item_class boxplot_class;
+extern const struct chart_class boxplot_class;
/* Returns true if SUPER is a boxplot, otherwise false. */
static inline bool
-is_boxplot (const struct chart_item *super)
+is_boxplot (const struct chart *super)
{
return super->class == &boxplot_class;
}
/* Returns SUPER converted to boxplot. SUPER must be a boxplot, as
reported by is_boxplot. */
static inline struct boxplot *
-to_boxplot (const struct chart_item *super)
+to_boxplot (const struct chart *super)
{
assert (is_boxplot (super));
- return UP_CAST (super, struct boxplot, chart_item);
+ return UP_CAST (super, struct boxplot, chart);
}
-/* Returns INSTANCE converted to chart_item. */
-static inline struct chart_item *
+/* Returns INSTANCE converted to chart. */
+static inline struct chart *
boxplot_super (const struct boxplot *instance)
{
- return CONST_CAST (struct chart_item *, &instance->chart_item);
+ return CONST_CAST (struct chart *, &instance->chart);
}
/* Increments INSTANCE's reference count and returns INSTANCE. */
static inline struct boxplot *
boxplot_ref (const struct boxplot *instance)
{
- return to_boxplot (chart_item_ref (&instance->chart_item));
+ return to_boxplot (chart_ref (&instance->chart));
}
/* Decrements INSTANCE's reference count, then destroys INSTANCE if
static inline void
boxplot_unref (struct boxplot *instance)
{
- chart_item_unref (&instance->chart_item);
+ chart_unref (&instance->chart);
}
/* Returns true if INSTANCE's reference count is greater than 1,
static inline bool
boxplot_is_shared (const struct boxplot *instance)
{
- return chart_item_is_shared (&instance->chart_item);
+ return chart_is_shared (&instance->chart);
}
static inline void
boxplot_submit (struct boxplot *instance)
{
- chart_item_submit (&instance->chart_item);
+ chart_submit (&instance->chart);
}
\f
#endif /* output/charts/boxplot.h */
#define _(msgid) gettext (msgid)
static void
-np_plot_chart_draw (const struct chart_item *chart_item, cairo_t *cr,
+np_plot_chart_draw (const struct chart *chart, cairo_t *cr,
struct xrchart_geometry *geom)
{
- const struct np_plot_chart *npp = to_np_plot_chart (chart_item);
+ const struct np_plot_chart *npp = to_np_plot_chart (chart);
struct casereader *data;
struct ccase *c;
- xrchart_write_title (cr, geom, _("Normal Q-Q Plot of %s"), chart_item->title);
+ xrchart_write_title (cr, geom, _("Normal Q-Q Plot of %s"), chart->title);
xrchart_write_xlabel (cr, geom, _("Observed Value"));
xrchart_write_ylabel (cr, geom, _("Expected Normal"));
if (! xrchart_write_xscale (cr, geom,
}
static void
-dnp_plot_chart_draw (const struct chart_item *chart_item, cairo_t *cr,
+dnp_plot_chart_draw (const struct chart *chart, cairo_t *cr,
struct xrchart_geometry *geom)
{
- const struct np_plot_chart *dnpp = to_np_plot_chart (chart_item);
+ const struct np_plot_chart *dnpp = to_np_plot_chart (chart);
struct casereader *data;
struct ccase *c;
- xrchart_write_title (cr, geom, _("Detrended Normal Q-Q Plot of %s"), chart_item->title);
+ xrchart_write_title (cr, geom, _("Detrended Normal Q-Q Plot of %s"), chart->title);
xrchart_write_xlabel (cr, geom, _("Observed Value"));
xrchart_write_ylabel (cr, geom, _("Dev from Normal"));
if (! xrchart_write_xscale (cr, geom, dnpp->y_min, dnpp->y_max))
}
void
-xrchart_draw_np_plot (const struct chart_item *chart_item, cairo_t *cr,
+xrchart_draw_np_plot (const struct chart *chart, cairo_t *cr,
struct xrchart_geometry *geom)
{
- const struct np_plot_chart *npp = to_np_plot_chart (chart_item);
+ const struct np_plot_chart *npp = to_np_plot_chart (chart);
if (npp->detrended)
- dnp_plot_chart_draw (chart_item, cr, geom);
+ dnp_plot_chart_draw (chart, cr, geom);
else
- np_plot_chart_draw (chart_item, cr, geom);
+ np_plot_chart_draw (chart, cr, geom);
}
#include "data/casereader.h"
#include "libpspp/cast.h"
#include "math/np.h"
-#include "output/chart-item-provider.h"
+#include "output/chart-provider.h"
#include "gl/minmax.h"
-static struct chart_item *
+static struct chart *
make_np_plot (const struct np *np, const struct casereader *reader,
const char *label, bool detrended)
{
return NULL;
npp = xzalloc (sizeof *npp);
- chart_item_init (&npp->chart_item, &np_plot_chart_class, label);
+ chart_init (&npp->chart, &np_plot_chart_class, label);
npp->data = casereader_clone (reader);
npp->y_min = np->y_min;
npp->y_max = np->y_max;
npp->x_upper = MAX (np->y_max, (npp->y_last - npp->intercept) / npp->slope);
npp->slack = (npp->x_upper - npp->x_lower) * 0.05;
- return &npp->chart_item;
+ return &npp->chart;
}
/* Creates and returns a normal probability plot corresponding to
Returns a null pointer if the data set is empty.
The caller retains ownership of NP and READER. */
-struct chart_item *
+struct chart *
np_plot_create (const struct np *np, const struct casereader *reader,
const char *label)
{
Returns a null pointer if the data set is empty.
The caller retains ownership of NP and READER. */
-struct chart_item *
+struct chart *
dnp_plot_create (const struct np *np, const struct casereader *reader,
const char *label)
{
}
static void
-np_plot_chart_destroy (struct chart_item *chart_item)
+np_plot_chart_destroy (struct chart *chart)
{
- struct np_plot_chart *npp = to_np_plot_chart (chart_item);
+ struct np_plot_chart *npp = to_np_plot_chart (chart);
casereader_destroy (npp->data);
free (npp);
}
-const struct chart_item_class np_plot_chart_class =
+const struct chart_class np_plot_chart_class =
{
np_plot_chart_destroy
};
#ifndef OUTPUT_CHARTS_NP_PLOT_H
#define OUTPUT_CHARTS_NP_PLOT_H 1
-#include "output/chart-item.h"
+#include "output/chart.h"
struct np;
/* An NP or DNP plot. */
struct np_plot_chart
{
- struct chart_item chart_item;
+ struct chart chart;
struct casereader *data;
bool detrended;
double slack;
};
-struct chart_item *np_plot_create (const struct np *,
+struct chart *np_plot_create (const struct np *,
const struct casereader *,
const char *label);
-struct chart_item *dnp_plot_create (const struct np *,
+struct chart *dnp_plot_create (const struct np *,
const struct casereader *,
const char *label);
\f
-/* This boilerplate for np_plot_chart, a subclass of chart_item, was
+/* This boilerplate for np_plot_chart, a subclass of chart, was
autogenerated by mk-class-boilerplate. */
#include <assert.h>
#include "libpspp/cast.h"
-extern const struct chart_item_class np_plot_chart_class;
+extern const struct chart_class np_plot_chart_class;
/* Returns true if SUPER is a np_plot_chart, otherwise false. */
static inline bool
-is_np_plot_chart (const struct chart_item *super)
+is_np_plot_chart (const struct chart *super)
{
return super->class == &np_plot_chart_class;
}
/* Returns SUPER converted to np_plot_chart. SUPER must be a np_plot_chart, as
reported by is_np_plot_chart. */
static inline struct np_plot_chart *
-to_np_plot_chart (const struct chart_item *super)
+to_np_plot_chart (const struct chart *super)
{
assert (is_np_plot_chart (super));
- return UP_CAST (super, struct np_plot_chart, chart_item);
+ return UP_CAST (super, struct np_plot_chart, chart);
}
-/* Returns INSTANCE converted to chart_item. */
-static inline struct chart_item *
+/* Returns INSTANCE converted to chart. */
+static inline struct chart *
np_plot_chart_super (const struct np_plot_chart *instance)
{
- return CONST_CAST (struct chart_item *, &instance->chart_item);
+ return CONST_CAST (struct chart *, &instance->chart);
}
/* Increments INSTANCE's reference count and returns INSTANCE. */
static inline struct np_plot_chart *
np_plot_chart_ref (const struct np_plot_chart *instance)
{
- return to_np_plot_chart (chart_item_ref (&instance->chart_item));
+ return to_np_plot_chart (chart_ref (&instance->chart));
}
/* Decrements INSTANCE's reference count, then destroys INSTANCE if
static inline void
np_plot_chart_unref (struct np_plot_chart *instance)
{
- chart_item_unref (&instance->chart_item);
+ chart_unref (&instance->chart);
}
/* Returns true if INSTANCE's reference count is greater than 1,
static inline bool
np_plot_chart_is_shared (const struct np_plot_chart *instance)
{
- return chart_item_is_shared (&instance->chart_item);
+ return chart_is_shared (&instance->chart);
}
static inline void
np_plot_chart_submit (struct np_plot_chart *instance)
{
- chart_item_submit (&instance->chart_item);
+ chart_submit (&instance->chart);
}
\f
#endif /* output/charts/np-plot.h */
}
void
-xrchart_draw_piechart (const struct chart_item *chart_item, cairo_t *cr,
+xrchart_draw_piechart (const struct chart *chart, cairo_t *cr,
struct xrchart_geometry *geom)
{
- const struct piechart *pie = to_piechart (chart_item);
+ const struct piechart *pie = to_piechart (chart);
double total_magnitude;
double left_label, right_label;
double centre_x, centre_y;
radius = MIN (5.0 / 12.0 * (geom->axis[SCALE_ORDINATE].data_max - geom->axis[SCALE_ORDINATE].data_min),
1.0 / 4.0 * (geom->axis[SCALE_ABSCISSA].data_max - geom->axis[SCALE_ORDINATE].data_min));
- xrchart_write_title (cr, geom, "%s", chart_item_get_title (chart_item));
+ xrchart_write_title (cr, geom, "%s", chart_get_title (chart));
total_magnitude = 0.0;
for (i = 0; i < pie->n_slices; i++)
#include "libpspp/cast.h"
#include "libpspp/str.h"
#include "data/variable.h"
-#include "output/chart-item-provider.h"
+#include "output/chart-provider.h"
#include "gl/xalloc.h"
/* Creates and returns a chart that will render a piechart with
the of VAR and the N_SLICES described in SLICES. */
-struct chart_item *
+struct chart *
piechart_create (const struct variable *var, const struct freq *slices, int n_slices)
{
struct piechart *pie;
int i;
pie = xmalloc (sizeof *pie);
- chart_item_init (&pie->chart_item, &piechart_class, var_to_string (var));
+ chart_init (&pie->chart, &piechart_class, var_to_string (var));
pie->slices = xnmalloc (n_slices, sizeof *pie->slices);
for (i = 0; i < n_slices; i++)
{
dst->magnitude = src->count;
}
pie->n_slices = n_slices;
- return &pie->chart_item;
+ return &pie->chart;
}
static void
-piechart_destroy (struct chart_item *chart_item)
+piechart_destroy (struct chart *chart)
{
- struct piechart *pie = to_piechart (chart_item);
+ struct piechart *pie = to_piechart (chart);
int i;
for (i = 0; i < pie->n_slices; i++)
free (pie);
}
-const struct chart_item_class piechart_class =
+const struct chart_class piechart_class =
{
piechart_destroy
};
#define PIECHART_H
#include "libpspp/str.h"
-#include "output/chart-item.h"
+#include "output/chart.h"
#include "language/stats/freq.h"
struct piechart
{
- struct chart_item chart_item;
+ struct chart chart;
struct slice *slices;
int n_slices;
};
struct variable;
-struct chart_item *piechart_create (const struct variable *var,
+struct chart *piechart_create (const struct variable *var,
const struct freq *, int n_slices);
\f
-/* This boilerplate for piechart, a subclass of chart_item, was
+/* This boilerplate for piechart, a subclass of chart, was
autogenerated by mk-class-boilerplate. */
#include <assert.h>
#include "libpspp/cast.h"
-extern const struct chart_item_class piechart_class;
+extern const struct chart_class piechart_class;
/* Returns true if SUPER is a piechart, otherwise false. */
static inline bool
-is_piechart (const struct chart_item *super)
+is_piechart (const struct chart *super)
{
return super->class == &piechart_class;
}
/* Returns SUPER converted to piechart. SUPER must be a piechart, as
reported by is_piechart. */
static inline struct piechart *
-to_piechart (const struct chart_item *super)
+to_piechart (const struct chart *super)
{
assert (is_piechart (super));
- return UP_CAST (super, struct piechart, chart_item);
+ return UP_CAST (super, struct piechart, chart);
}
-/* Returns INSTANCE converted to chart_item. */
-static inline struct chart_item *
+/* Returns INSTANCE converted to chart. */
+static inline struct chart *
piechart_super (const struct piechart *instance)
{
- return CONST_CAST (struct chart_item *, &instance->chart_item);
+ return CONST_CAST (struct chart *, &instance->chart);
}
/* Increments INSTANCE's reference count and returns INSTANCE. */
static inline struct piechart *
piechart_ref (const struct piechart *instance)
{
- return to_piechart (chart_item_ref (&instance->chart_item));
+ return to_piechart (chart_ref (&instance->chart));
}
/* Decrements INSTANCE's reference count, then destroys INSTANCE if
static inline void
piechart_unref (struct piechart *instance)
{
- chart_item_unref (&instance->chart_item);
+ chart_unref (&instance->chart);
}
/* Returns true if INSTANCE's reference count is greater than 1,
static inline bool
piechart_is_shared (const struct piechart *instance)
{
- return chart_item_is_shared (&instance->chart_item);
+ return chart_is_shared (&instance->chart);
}
static inline void
piechart_submit (struct piechart *instance)
{
- chart_item_submit (&instance->chart_item);
+ chart_submit (&instance->chart);
}
\f
#endif /* output/charts/piechart.h */
}
void
-xrchart_draw_histogram (const struct chart_item *chart_item, cairo_t *cr,
+xrchart_draw_histogram (const struct chart *chart, cairo_t *cr,
struct xrchart_geometry *geom)
{
- struct histogram_chart *h = to_histogram_chart (chart_item);
+ struct histogram_chart *h = to_histogram_chart (chart);
int i;
int bins;
xrchart_write_title (cr, geom, _("HISTOGRAM"));
xrchart_write_ylabel (cr, geom, _("Frequency"));
- xrchart_write_xlabel (cr, geom, chart_item_get_title (chart_item));
+ xrchart_write_xlabel (cr, geom, chart_get_title (chart));
if (h->gsl_hist == NULL)
{
#include "libpspp/cast.h"
#include "math/histogram.h"
#include "math/moments.h"
-#include "output/chart-item-provider.h"
+#include "output/chart-provider.h"
#include "output/charts/plot-hist.h"
#include "gettext.h"
Labels the histogram with each of N, MEAN, and STDDEV that is
not SYSMIS. If all three are not SYSMIS and SHOW_NORMAL is
true, also draws a normal curve on the histogram. */
-struct chart_item *
+struct chart *
histogram_chart_create (const gsl_histogram *hist, const char *label,
double n, double mean, double stddev,
bool show_normal)
struct histogram_chart *h;
h = xmalloc (sizeof *h);
- chart_item_init (&h->chart_item, &histogram_chart_class, label);
+ chart_init (&h->chart, &histogram_chart_class, label);
h->gsl_hist = hist != NULL ? gsl_histogram_clone (hist) : NULL;
h->n = n;
h->mean = mean;
h->stddev = stddev;
h->show_normal = show_normal;
- return &h->chart_item;
+ return &h->chart;
}
static void
-histogram_chart_destroy (struct chart_item *chart_item)
+histogram_chart_destroy (struct chart *chart)
{
- struct histogram_chart *h = UP_CAST (chart_item, struct histogram_chart,
- chart_item);
+ struct histogram_chart *h = UP_CAST (chart, struct histogram_chart,
+ chart);
if (h->gsl_hist != NULL)
gsl_histogram_free (h->gsl_hist);
free (h);
}
-const struct chart_item_class histogram_chart_class =
+const struct chart_class histogram_chart_class =
{
histogram_chart_destroy
};
#include <gsl/gsl_histogram.h>
#include <stdbool.h>
-#include "output/chart-item.h"
+#include "output/chart.h"
struct histogram_chart
{
- struct chart_item chart_item;
+ struct chart chart;
gsl_histogram *gsl_hist;
double n;
double mean;
with each of N, MEAN, and STDDEV that is not SYSMIS. If all
three are not SYSMIS and SHOW_NORMAL is true, also draws a
normal curve on the histogram. */
-struct chart_item *histogram_chart_create (const gsl_histogram *,
- const char *label, double n,
- double mean, double stddev,
- bool show_normal);
+struct chart *histogram_chart_create (const gsl_histogram *,
+ const char *label, double n,
+ double mean, double stddev,
+ bool show_normal);
\f
-/* This boilerplate for histogram_chart, a subclass of chart_item, was
+/* This boilerplate for histogram_chart, a subclass of chart, was
autogenerated by mk-class-boilerplate. */
#include <assert.h>
#include "libpspp/cast.h"
-extern const struct chart_item_class histogram_chart_class;
+extern const struct chart_class histogram_chart_class;
/* Returns true if SUPER is a histogram_chart, otherwise false. */
static inline bool
-is_histogram_chart (const struct chart_item *super)
+is_histogram_chart (const struct chart *super)
{
return super->class == &histogram_chart_class;
}
/* Returns SUPER converted to histogram_chart. SUPER must be a histogram_chart, as
reported by is_histogram_chart. */
static inline struct histogram_chart *
-to_histogram_chart (const struct chart_item *super)
+to_histogram_chart (const struct chart *super)
{
assert (is_histogram_chart (super));
- return UP_CAST (super, struct histogram_chart, chart_item);
+ return UP_CAST (super, struct histogram_chart, chart);
}
-/* Returns INSTANCE converted to chart_item. */
-static inline struct chart_item *
+/* Returns INSTANCE converted to chart. */
+static inline struct chart *
histogram_chart_super (const struct histogram_chart *instance)
{
- return CONST_CAST (struct chart_item *, &instance->chart_item);
+ return CONST_CAST (struct chart *, &instance->chart);
}
/* Increments INSTANCE's reference count and returns INSTANCE. */
static inline struct histogram_chart *
histogram_chart_ref (const struct histogram_chart *instance)
{
- return to_histogram_chart (chart_item_ref (&instance->chart_item));
+ return to_histogram_chart (chart_ref (&instance->chart));
}
/* Decrements INSTANCE's reference count, then destroys INSTANCE if
static inline void
histogram_chart_unref (struct histogram_chart *instance)
{
- chart_item_unref (&instance->chart_item);
+ chart_unref (&instance->chart);
}
/* Returns true if INSTANCE's reference count is greater than 1,
static inline bool
histogram_chart_is_shared (const struct histogram_chart *instance)
{
- return chart_item_is_shared (&instance->chart_item);
+ return chart_is_shared (&instance->chart);
}
static inline void
histogram_chart_submit (struct histogram_chart *instance)
{
- chart_item_submit (&instance->chart_item);
+ chart_submit (&instance->chart);
}
\f
#endif /* output/plot-hist.h */
#define _(msgid) gettext (msgid)
void
-xrchart_draw_roc (const struct chart_item *chart_item, cairo_t *cr,
+xrchart_draw_roc (const struct chart *chart, cairo_t *cr,
struct xrchart_geometry *geom)
{
- const struct roc_chart *rc = to_roc_chart (chart_item);
+ const struct roc_chart *rc = to_roc_chart (chart);
size_t i;
xrchart_write_title (cr, geom, _("ROC Curve"));
#include "data/casereader.h"
#include "language/stats/roc.h"
-#include "output/chart-item-provider.h"
+#include "output/chart-provider.h"
#include "gl/xalloc.h"
roc_chart_create (bool reference)
{
struct roc_chart *rc = xmalloc (sizeof *rc);
- chart_item_init (&rc->chart_item, &roc_chart_class, NULL);
+ chart_init (&rc->chart, &roc_chart_class, NULL);
rc->reference = reference;
rc->vars = NULL;
rc->n_vars = 0;
}
static void
-roc_chart_destroy (struct chart_item *chart_item)
+roc_chart_destroy (struct chart *chart)
{
- struct roc_chart *rc = UP_CAST (chart_item, struct roc_chart, chart_item);
+ struct roc_chart *rc = UP_CAST (chart, struct roc_chart, chart);
size_t i;
for (i = 0; i < rc->n_vars; i++)
free (rc);
}
-const struct chart_item_class roc_chart_class =
+const struct chart_class roc_chart_class =
{
roc_chart_destroy
};
#include <stdbool.h>
#include <stddef.h>
-#include "output/chart-item.h"
+#include "output/chart.h"
struct roc_chart
{
- struct chart_item chart_item;
+ struct chart chart;
bool reference;
struct roc_var *vars;
size_t n_vars;
void roc_chart_add_var (struct roc_chart *, const char *var_name,
const struct casereader *cutpoint_reader);
\f
-/* This boilerplate for roc_chart, a subclass of chart_item, was
+/* This boilerplate for roc_chart, a subclass of chart, was
autogenerated by mk-class-boilerplate. */
#include <assert.h>
#include "libpspp/cast.h"
-extern const struct chart_item_class roc_chart_class;
+extern const struct chart_class roc_chart_class;
/* Returns true if SUPER is a roc_chart, otherwise false. */
static inline bool
-is_roc_chart (const struct chart_item *super)
+is_roc_chart (const struct chart *super)
{
return super->class == &roc_chart_class;
}
/* Returns SUPER converted to roc_chart. SUPER must be a roc_chart, as
reported by is_roc_chart. */
static inline struct roc_chart *
-to_roc_chart (const struct chart_item *super)
+to_roc_chart (const struct chart *super)
{
assert (is_roc_chart (super));
- return UP_CAST (super, struct roc_chart, chart_item);
+ return UP_CAST (super, struct roc_chart, chart);
}
-/* Returns INSTANCE converted to chart_item. */
-static inline struct chart_item *
+/* Returns INSTANCE converted to chart. */
+static inline struct chart *
roc_chart_super (const struct roc_chart *instance)
{
- return CONST_CAST (struct chart_item *, &instance->chart_item);
+ return CONST_CAST (struct chart *, &instance->chart);
}
/* Increments INSTANCE's reference count and returns INSTANCE. */
static inline struct roc_chart *
roc_chart_ref (const struct roc_chart *instance)
{
- return to_roc_chart (chart_item_ref (&instance->chart_item));
+ return to_roc_chart (chart_ref (&instance->chart));
}
/* Decrements INSTANCE's reference count, then destroys INSTANCE if
static inline void
roc_chart_unref (struct roc_chart *instance)
{
- chart_item_unref (&instance->chart_item);
+ chart_unref (&instance->chart);
}
/* Returns true if INSTANCE's reference count is greater than 1,
static inline bool
roc_chart_is_shared (const struct roc_chart *instance)
{
- return chart_item_is_shared (&instance->chart_item);
+ return chart_is_shared (&instance->chart);
}
static inline void
roc_chart_submit (struct roc_chart *instance)
{
- chart_item_submit (&instance->chart_item);
+ chart_submit (&instance->chart);
}
\f
#endif /* output/charts/roc-chart.h */
static const struct xrchart_colour black = {0,0,0};
void
-xrchart_draw_scatterplot (const struct chart_item *chart_item, cairo_t *cr,
+xrchart_draw_scatterplot (const struct chart *chart, cairo_t *cr,
struct xrchart_geometry *geom)
{
- const struct scatterplot_chart *spc = to_scatterplot_chart (chart_item);
+ const struct scatterplot_chart *spc = to_scatterplot_chart (chart);
struct casereader *data;
struct ccase *c;
/* While reading the cases, a list with categories of the byvar is build */
return;
if (! xrchart_write_yscale (cr, geom, spc->y_min, spc->y_max))
return;
- xrchart_write_title (cr, geom, _("Scatterplot %s"), chart_item->title);
+ xrchart_write_title (cr, geom, _("Scatterplot %s"), chart->title);
xrchart_write_xlabel (cr, geom, spc->xlabel);
xrchart_write_ylabel (cr, geom, spc->ylabel);
#include "data/casereader.h"
#include "data/variable.h"
#include "libpspp/cast.h"
-#include "output/chart-item-provider.h"
+#include "output/chart-provider.h"
#include "gl/minmax.h"
struct scatterplot_chart *spc;
spc = xzalloc (sizeof *spc);
- chart_item_init (&spc->chart_item, &scatterplot_chart_class, label);
+ chart_init (&spc->chart, &scatterplot_chart_class, label);
spc->data = reader;
spc->y_min = ymin;
}
static void
-scatterplot_chart_destroy (struct chart_item *chart_item)
+scatterplot_chart_destroy (struct chart *chart)
{
- struct scatterplot_chart *spc = to_scatterplot_chart (chart_item);
+ struct scatterplot_chart *spc = to_scatterplot_chart (chart);
casereader_destroy (spc->data);
free (spc->xlabel);
free (spc->ylabel);
free (spc);
}
-const struct chart_item_class scatterplot_chart_class =
+const struct chart_class scatterplot_chart_class =
{
scatterplot_chart_destroy
};
#ifndef OUTPUT_CHARTS_SCATTERPLOT_H
#define OUTPUT_CHARTS_SCATTERPLOT_H 1
-#include "output/chart-item.h"
+#include "output/chart.h"
/* Indices for the scatterplot_proto members */
enum
/* A scatterplot. */
struct scatterplot_chart
{
- struct chart_item chart_item;
+ struct chart chart;
struct casereader *data;
struct variable *byvar;
char *xlabel;
const char *label,
double xmin, double xmax, double ymin, double ymax);
\f
-/* This boilerplate for scatterplot_chart, a subclass of chart_item, was
+/* This boilerplate for scatterplot_chart, a subclass of chart, was
autogenerated by mk-class-boilerplate. */
#include <assert.h>
#include "libpspp/cast.h"
-extern const struct chart_item_class scatterplot_chart_class;
+extern const struct chart_class scatterplot_chart_class;
/* Returns true if SUPER is a scatterplot_chart, otherwise false. */
static inline bool
-is_scatterplot_chart (const struct chart_item *super)
+is_scatterplot_chart (const struct chart *super)
{
return super->class == &scatterplot_chart_class;
}
/* Returns SUPER converted to scatterplot_chart. SUPER must be a scatterplot_chart, as
reported by is_scatterplot_chart. */
static inline struct scatterplot_chart *
-to_scatterplot_chart (const struct chart_item *super)
+to_scatterplot_chart (const struct chart *super)
{
assert (is_scatterplot_chart (super));
- return UP_CAST (super, struct scatterplot_chart, chart_item);
+ return UP_CAST (super, struct scatterplot_chart, chart);
}
-/* Returns INSTANCE converted to chart_item. */
-static inline struct chart_item *
+/* Returns INSTANCE converted to chart. */
+static inline struct chart *
scatterplot_chart_super (const struct scatterplot_chart *instance)
{
- return CONST_CAST (struct chart_item *, &instance->chart_item);
+ return CONST_CAST (struct chart *, &instance->chart);
}
/* Increments INSTANCE's reference count and returns INSTANCE. */
static inline struct scatterplot_chart *
scatterplot_chart_ref (const struct scatterplot_chart *instance)
{
- return to_scatterplot_chart (chart_item_ref (&instance->chart_item));
+ return to_scatterplot_chart (chart_ref (&instance->chart));
}
/* Decrements INSTANCE's reference count, then destroys INSTANCE if
static inline void
scatterplot_chart_unref (struct scatterplot_chart *instance)
{
- chart_item_unref (&instance->chart_item);
+ chart_unref (&instance->chart);
}
/* Returns true if INSTANCE's reference count is greater than 1,
static inline bool
scatterplot_chart_is_shared (const struct scatterplot_chart *instance)
{
- return chart_item_is_shared (&instance->chart_item);
+ return chart_is_shared (&instance->chart);
}
static inline void
scatterplot_chart_submit (struct scatterplot_chart *instance)
{
- chart_item_submit (&instance->chart_item);
+ chart_submit (&instance->chart);
}
\f
#endif /* output/charts/scatterplot.h */
#define _(msgid) gettext (msgid)
void
-xrchart_draw_scree (const struct chart_item *chart_item, cairo_t *cr,
+xrchart_draw_scree (const struct chart *chart, cairo_t *cr,
struct xrchart_geometry *geom)
{
- const struct scree *rc = to_scree (chart_item);
+ const struct scree *rc = to_scree (chart);
size_t i;
double min, max;
#include "output/charts/scree.h"
-#include "output/chart-item-provider.h"
+#include "output/chart-provider.h"
#include "gl/xalloc.h"
scree_create (const gsl_vector *eigenvalues, const char *xlabel)
{
struct scree *rc = xmalloc (sizeof *rc);
- chart_item_init (&rc->chart_item, &scree_class, NULL);
+ chart_init (&rc->chart, &scree_class, NULL);
rc->eval = gsl_vector_alloc (eigenvalues->size);
gsl_vector_memcpy (rc->eval, eigenvalues);
}
static void
-scree_destroy (struct chart_item *chart_item)
+scree_destroy (struct chart *chart)
{
- struct scree *rc = to_scree (chart_item);
+ struct scree *rc = to_scree (chart);
gsl_vector_free (rc->eval);
free (rc->xlabel);
free (rc);
}
-const struct chart_item_class scree_class =
+const struct chart_class scree_class =
{
scree_destroy
};
#define OUTPUT_CHARTS_SCREE_H 1
#include <gsl/gsl_vector.h>
-#include "output/chart-item.h"
+#include "output/chart.h"
/* A scree plot. */
struct scree
{
- struct chart_item chart_item;
+ struct chart chart;
gsl_vector *eval;
char *xlabel;
};
/* Return the chart underlying SCREE */
struct chart *scree_get_chart (struct scree *scree);
\f
-/* This boilerplate for scree, a subclass of chart_item, was
+/* This boilerplate for scree, a subclass of chart, was
autogenerated by mk-class-boilerplate. */
#include <assert.h>
#include "libpspp/cast.h"
-extern const struct chart_item_class scree_class;
+extern const struct chart_class scree_class;
/* Returns true if SUPER is a scree, otherwise false. */
static inline bool
-is_scree (const struct chart_item *super)
+is_scree (const struct chart *super)
{
return super->class == &scree_class;
}
/* Returns SUPER converted to scree. SUPER must be a scree, as
reported by is_scree. */
static inline struct scree *
-to_scree (const struct chart_item *super)
+to_scree (const struct chart *super)
{
assert (is_scree (super));
- return UP_CAST (super, struct scree, chart_item);
+ return UP_CAST (super, struct scree, chart);
}
-/* Returns INSTANCE converted to chart_item. */
-static inline struct chart_item *
+/* Returns INSTANCE converted to chart. */
+static inline struct chart *
scree_super (const struct scree *instance)
{
- return CONST_CAST (struct chart_item *, &instance->chart_item);
+ return CONST_CAST (struct chart *, &instance->chart);
}
/* Increments INSTANCE's reference count and returns INSTANCE. */
static inline struct scree *
scree_ref (const struct scree *instance)
{
- return to_scree (chart_item_ref (&instance->chart_item));
+ return to_scree (chart_ref (&instance->chart));
}
/* Decrements INSTANCE's reference count, then destroys INSTANCE if
static inline void
scree_unref (struct scree *instance)
{
- chart_item_unref (&instance->chart_item);
+ chart_unref (&instance->chart);
}
/* Returns true if INSTANCE's reference count is greater than 1,
static inline bool
scree_is_shared (const struct scree *instance)
{
- return chart_item_is_shared (&instance->chart_item);
+ return chart_is_shared (&instance->chart);
}
static inline void
scree_submit (struct scree *instance)
{
- chart_item_submit (&instance->chart_item);
+ chart_submit (&instance->chart);
}
\f
#endif /* output/charts/scree.h */
#define _(msgid) gettext (msgid)
void
-xrchart_draw_spreadlevel (const struct chart_item *chart_item, cairo_t *cr,
- struct xrchart_geometry *geom)
+xrchart_draw_spreadlevel (const struct chart *chart, cairo_t *cr,
+ struct xrchart_geometry *geom)
{
- const struct spreadlevel_plot_chart *sl = to_spreadlevel_plot_chart (chart_item);
+ const struct spreadlevel_plot_chart *sl = to_spreadlevel_plot_chart (chart);
size_t i;
- const char *name = chart_item_get_title (chart_item);
+ const char *name = chart_get_title (chart);
xrchart_write_title (cr, geom, _("Spread vs. Level Plot of %s"), name);
xrchart_write_xlabel (cr, geom, _("Level"));
#include "output/charts/spreadlevel-plot.h"
#include "libpspp/cast.h"
-#include "output/chart-item-provider.h"
+#include "output/chart-provider.h"
#include "gl/xalloc.h"
#include "gl/minmax.h"
#include <float.h>
#include <stdlib.h>
-struct chart_item *
+struct chart *
spreadlevel_plot_create (const char *label, double tx_pwr)
{
struct spreadlevel_plot_chart *sl = xzalloc (sizeof *sl);
- chart_item_init (&sl->chart_item, &spreadlevel_plot_chart_class, label);
+ chart_init (&sl->chart, &spreadlevel_plot_chart_class, label);
sl->x_lower = DBL_MAX;
sl->x_upper = -DBL_MAX;
sl->n_data = 0;
sl->data = NULL;
- return &sl->chart_item;
+ return &sl->chart;
}
void
-spreadlevel_plot_add (struct chart_item *ci, double spread, double level)
+spreadlevel_plot_add (struct chart *ci, double spread, double level)
{
struct spreadlevel_plot_chart *sl = to_spreadlevel_plot_chart (ci);
static void
-spreadlevel_plot_chart_destroy (struct chart_item *chart_item)
+spreadlevel_plot_chart_destroy (struct chart *chart)
{
- struct spreadlevel_plot_chart *sl = to_spreadlevel_plot_chart (chart_item);
+ struct spreadlevel_plot_chart *sl = to_spreadlevel_plot_chart (chart);
free (sl->data);
free (sl);
}
-const struct chart_item_class spreadlevel_plot_chart_class =
+const struct chart_class spreadlevel_plot_chart_class =
{
spreadlevel_plot_chart_destroy
};
#ifndef OUTPUT_CHARTS_SL_PLOT_H
#define OUTPUT_CHARTS_SL_PLOT_H 1
-#include "output/chart-item.h"
+#include "output/chart.h"
+#include <stddef.h>
struct datum
{
struct spreadlevel_plot_chart
{
- struct chart_item chart_item;
+ struct chart chart;
/* Calculated parameters */
double y_lower, y_upper;
struct datum *data;
};
-struct chart_item *spreadlevel_plot_create (const char *label, double slp);
+struct chart *spreadlevel_plot_create (const char *label, double slp);
-void spreadlevel_plot_add (struct chart_item *, double spread, double level);
+void spreadlevel_plot_add (struct chart *, double spread, double level);
\f
-/* This boilerplate for spreadlevel_plot_chart, a subclass of chart_item, was
+/* This boilerplate for spreadlevel_plot_chart, a subclass of chart, was
autogenerated by mk-class-boilerplate. */
#include <assert.h>
#include "libpspp/cast.h"
-extern const struct chart_item_class spreadlevel_plot_chart_class;
+extern const struct chart_class spreadlevel_plot_chart_class;
/* Returns true if SUPER is a spreadlevel_plot_chart, otherwise false. */
static inline bool
-is_spreadlevel_plot_chart (const struct chart_item *super)
+is_spreadlevel_plot_chart (const struct chart *super)
{
return super->class == &spreadlevel_plot_chart_class;
}
/* Returns SUPER converted to spreadlevel_plot_chart. SUPER must be a spreadlevel_plot_chart, as
reported by is_spreadlevel_plot_chart. */
static inline struct spreadlevel_plot_chart *
-to_spreadlevel_plot_chart (const struct chart_item *super)
+to_spreadlevel_plot_chart (const struct chart *super)
{
assert (is_spreadlevel_plot_chart (super));
- return UP_CAST (super, struct spreadlevel_plot_chart, chart_item);
+ return UP_CAST (super, struct spreadlevel_plot_chart, chart);
}
-/* Returns INSTANCE converted to chart_item. */
-static inline struct chart_item *
+/* Returns INSTANCE converted to chart. */
+static inline struct chart *
spreadlevel_plot_chart_super (const struct spreadlevel_plot_chart *instance)
{
- return CONST_CAST (struct chart_item *, &instance->chart_item);
+ return CONST_CAST (struct chart *, &instance->chart);
}
/* Increments INSTANCE's reference count and returns INSTANCE. */
static inline struct spreadlevel_plot_chart *
spreadlevel_plot_chart_ref (const struct spreadlevel_plot_chart *instance)
{
- return to_spreadlevel_plot_chart (chart_item_ref (&instance->chart_item));
+ return to_spreadlevel_plot_chart (chart_ref (&instance->chart));
}
/* Decrements INSTANCE's reference count, then destroys INSTANCE if
static inline void
spreadlevel_plot_chart_unref (struct spreadlevel_plot_chart *instance)
{
- chart_item_unref (&instance->chart_item);
+ chart_unref (&instance->chart);
}
/* Returns true if INSTANCE's reference count is greater than 1,
static inline bool
spreadlevel_plot_chart_is_shared (const struct spreadlevel_plot_chart *instance)
{
- return chart_item_is_shared (&instance->chart_item);
+ return chart_is_shared (&instance->chart);
}
static inline void
spreadlevel_plot_chart_submit (struct spreadlevel_plot_chart *instance)
{
- chart_item_submit (&instance->chart_item);
+ chart_submit (&instance->chart);
}
\f
#endif
#include "libpspp/message.h"
#include "libpspp/str.h"
#include "libpspp/string-map.h"
-#include "output/text-item.h"
#include "output/driver-provider.h"
#include "output/options.h"
-#include "output/message-item.h"
-#include "output/page-break-item.h"
+#include "output/output-item.h"
#include "output/pivot-output.h"
#include "output/pivot-table.h"
-#include "output/table-item.h"
#include "output/table-provider.h"
#include "gl/minmax.h"
static void
csv_submit (struct output_driver *driver,
- const struct output_item *output_item)
+ const struct output_item *item)
{
struct csv_driver *csv = csv_driver_cast (driver);
- if (is_table_item (output_item))
+ switch (item->type)
{
- const struct pivot_table *pt = to_table_item (output_item)->pt;
+ case OUTPUT_ITEM_CHART:
+ break;
- size_t *layer_indexes;
- PIVOT_OUTPUT_FOR_EACH_LAYER (layer_indexes, pt, true)
- csv_output_table_layer (csv, pt, layer_indexes);
- }
- else if (is_text_item (output_item))
- {
- const struct text_item *text_item = to_text_item (output_item);
+ case OUTPUT_ITEM_GROUP_OPEN:
+ break;
- enum text_item_type type = text_item_get_type (text_item);
- if (type == TEXT_ITEM_SYNTAX || type == TEXT_ITEM_PAGE_TITLE)
- return;
+ case OUTPUT_ITEM_GROUP_CLOSE:
+ break;
- csv_put_separator (csv);
+ case OUTPUT_ITEM_IMAGE:
+ break;
- char *text = text_item_get_plain_text (text_item);
- csv_output_lines (csv, text);
- free (text);
- }
- else if (is_page_break_item (output_item))
- {
- csv_put_separator (csv);
- csv_output_lines (csv, "");
- }
- else if (is_message_item (output_item))
- {
- const struct message_item *message_item = to_message_item (output_item);
- char *s = msg_to_string (message_item_get_msg (message_item));
+ case OUTPUT_ITEM_MESSAGE:
csv_put_separator (csv);
+ char *s = msg_to_string (item->message);
csv_output_field (csv, s);
free (s);
putc ('\n', csv->file);
+ break;
+
+ case OUTPUT_ITEM_PAGE_BREAK:
+ csv_put_separator (csv);
+ csv_output_lines (csv, "");
+ break;
+
+ case OUTPUT_ITEM_PAGE_SETUP:
+ break;
+
+ case OUTPUT_ITEM_TABLE:
+ {
+ size_t *layer_indexes;
+ PIVOT_OUTPUT_FOR_EACH_LAYER (layer_indexes, item->table, true)
+ csv_output_table_layer (csv, item->table, layer_indexes);
+ }
+ break;
+
+ case OUTPUT_ITEM_TEXT:
+ if (item->text.subtype == TEXT_ITEM_SYNTAX
+ || item->text.subtype == TEXT_ITEM_PAGE_TITLE)
+ return;
+
+ csv_put_separator (csv);
+
+ char *text = text_item_get_plain_text (item);
+ csv_output_lines (csv, text);
+ free (text);
+ break;
}
}
#include "libpspp/string-map.h"
#include "libpspp/string-set.h"
#include "libpspp/str.h"
-#include "output/group-item.h"
-#include "output/message-item.h"
#include "output/output-item.h"
-#include "output/text-item.h"
#include "gl/error.h"
#include "gl/xalloc.h"
{
struct ll ll; /* Node for this engine. */
struct llx_list drivers; /* Contains "struct output_driver"s. */
- struct text_item *deferred_text; /* Output text being accumulated. */
+ struct output_item *deferred_text; /* Output text being accumulated. */
char *command_name; /* Name of command being processed. */
char *title, *subtitle; /* Components of page title. */
struct output_driver *d = llx_pop_head (&e->drivers, &llx_malloc_mgr);
output_driver_destroy (d);
}
- text_item_unref (e->deferred_text);
+ output_item_unref (e->deferred_text);
free (e->command_name);
free (e->title);
free (e->subtitle);
for (llx = llx_head (&e->drivers); llx != llx_null (&e->drivers); llx = next)
{
struct output_driver *d = llx_data (llx);
- enum settings_output_type type;
next = llx_next (llx);
- if (is_message_item (item))
+ enum settings_output_type type = SETTINGS_OUTPUT_RESULT;
+ switch (item->type)
{
- const struct msg *m = message_item_get_msg (to_message_item (item));
- if (m->severity == MSG_S_NOTE)
- type = SETTINGS_OUTPUT_NOTE;
- else
- type = SETTINGS_OUTPUT_ERROR;
+ case OUTPUT_ITEM_MESSAGE:
+ type = (item->message->severity == MSG_S_NOTE
+ ? SETTINGS_OUTPUT_NOTE
+ : SETTINGS_OUTPUT_ERROR);
+ break;
+
+ case OUTPUT_ITEM_TEXT:
+ if (item->text.subtype == TEXT_ITEM_SYNTAX)
+ type = SETTINGS_OUTPUT_SYNTAX;
+ break;
+
+ case OUTPUT_ITEM_CHART:
+ case OUTPUT_ITEM_GROUP_OPEN:
+ case OUTPUT_ITEM_GROUP_CLOSE:
+ case OUTPUT_ITEM_IMAGE:
+ case OUTPUT_ITEM_PAGE_BREAK:
+ case OUTPUT_ITEM_PAGE_SETUP:
+ case OUTPUT_ITEM_TABLE:
+ break;
}
- else if (is_text_item (item)
- && text_item_get_type (to_text_item (item)) == TEXT_ITEM_SYNTAX)
- type = SETTINGS_OUTPUT_SYNTAX;
- else
- type = SETTINGS_OUTPUT_RESULT;
if (settings_get_output_routing (type) & d->device_type)
d->class->submit (d, item);
static void
flush_deferred_text (struct output_engine *e)
{
- struct text_item *deferred_text = e->deferred_text;
+ struct output_item *deferred_text = e->deferred_text;
if (deferred_text)
{
e->deferred_text = NULL;
- output_submit__ (e, text_item_super (deferred_text));
+ output_submit__ (e, deferred_text);
}
}
static bool
-defer_text (struct output_engine *e, struct output_item *output_item)
+defer_text (struct output_engine *e, struct output_item *item)
{
- if (!is_text_item (output_item))
+ if (item->type != OUTPUT_ITEM_TEXT)
return false;
- struct text_item *text = to_text_item (output_item);
if (!e->deferred_text)
- e->deferred_text = text_item_unshare (text);
- else if (text_item_append (e->deferred_text, text))
- text_item_unref (text);
+ e->deferred_text = output_item_unshare (item);
+ else if (text_item_append (e->deferred_text, item))
+ output_item_unref (item);
else
{
flush_deferred_text (e);
- e->deferred_text = text_item_unshare (text);
+ e->deferred_text = output_item_unshare (item);
}
return true;
}
return;
flush_deferred_text (e);
- if (is_group_open_item (item))
+ switch (item->type)
{
- const struct group_open_item *group_open_item
- = to_group_open_item (item);
+ case OUTPUT_ITEM_GROUP_OPEN:
if (e->n_groups >= e->allocated_groups)
e->groups = x2nrealloc (e->groups, &e->allocated_groups,
sizeof *e->groups);
- e->groups[e->n_groups] = xstrdup_if_nonnull (
- group_open_item->output_item.command_name);
+ e->groups[e->n_groups] = xstrdup_if_nonnull (item->command_name);
e->n_groups++;
- }
- else if (is_group_close_item (item))
- {
+ break;
+
+ case OUTPUT_ITEM_GROUP_CLOSE:
assert (e->n_groups > 0);
size_t idx = --e->n_groups;
char *key = xasprintf ("Head%zu", idx);
free (string_map_find_and_delete (&e->heading_vars, key));
free (key);
- }
- else if (is_text_item (item))
- {
- const struct text_item *text_item = to_text_item (item);
- enum text_item_type type = text_item_get_type (text_item);
- char *key = (type == TEXT_ITEM_TITLE ? xasprintf ("Head%zu", e->n_groups)
- : type == TEXT_ITEM_PAGE_TITLE ? xstrdup ("PageTitle")
- : NULL);
- if (key)
- string_map_replace_nocopy (&e->heading_vars, key,
- text_item_get_plain_text (text_item));
+ break;
+
+ case OUTPUT_ITEM_TEXT:
+ {
+ enum text_item_subtype st = item->text.subtype;
+ char *key = (st == TEXT_ITEM_TITLE ? xasprintf ("Head%zu", e->n_groups)
+ : st == TEXT_ITEM_PAGE_TITLE ? xstrdup ("PageTitle")
+ : NULL);
+ if (key)
+ string_map_replace_nocopy (&e->heading_vars, key,
+ text_item_get_plain_text (item));
+ }
+ break;
+
+ case OUTPUT_ITEM_CHART:
+ case OUTPUT_ITEM_IMAGE:
+ case OUTPUT_ITEM_MESSAGE:
+ case OUTPUT_ITEM_PAGE_BREAK:
+ case OUTPUT_ITEM_PAGE_SETUP:
+ case OUTPUT_ITEM_TABLE:
+ break;
}
output_submit__ (e, item);
: e->title ? xstrdup (e->title)
: e->subtitle ? xstrdup (e->subtitle)
: xzalloc (1));
- text_item_submit (text_item_create_nocopy (TEXT_ITEM_PAGE_TITLE,
- page_title, NULL));
+ output_item_submit (text_item_create_nocopy (TEXT_ITEM_PAGE_TITLE,
+ page_title, NULL));
}
void
+++ /dev/null
-/* PSPP - a program for statistical analysis.
- Copyright (C) 2018 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-#include <config.h>
-
-#include "output/group-item.h"
-
-#include <stdlib.h>
-
-#include "libpspp/compiler.h"
-#include "libpspp/str.h"
-#include "output/driver.h"
-#include "output/output-item-provider.h"
-
-#include "gl/xalloc.h"
-
-#include "gettext.h"
-#define _(msgid) gettext (msgid)
-
-struct group_open_item *
-group_open_item_create (const char *command_name, const char *label)
-{
- return group_open_item_create_nocopy (
- xstrdup_if_nonnull (command_name),
- xstrdup_if_nonnull (label));
-}
-
-struct group_open_item *
-group_open_item_create_nocopy (char *command_name, char *label)
-{
- struct group_open_item *item = xmalloc (sizeof *item);
- *item = (struct group_open_item) {
- .output_item = OUTPUT_ITEM_INITIALIZER (&group_open_item_class),
- .output_item.label = label,
- .output_item.command_name = command_name,
- };
- return item;
-}
-
-/* Submits ITEM to the configured output drivers, and transfers ownership to
- the output subsystem. */
-void
-group_open_item_submit (struct group_open_item *item)
-{
- output_submit (&item->output_item);
-}
-
-static const char *
-group_open_item_get_label (const struct output_item *output_item)
-{
- struct group_open_item *item = to_group_open_item (output_item);
-
- return (item->output_item.command_name
- ? item->output_item.command_name
- : _("Group"));
-}
-
-static void
-group_open_item_destroy (struct output_item *output_item)
-{
- struct group_open_item *item = to_group_open_item (output_item);
-
- free (item);
-}
-
-const struct output_item_class group_open_item_class =
- {
- group_open_item_get_label,
- group_open_item_destroy,
- };
-\f
-struct group_close_item *
-group_close_item_create (void)
-{
- struct group_close_item *item = xmalloc (sizeof *item);
- *item = (struct group_close_item) {
- .output_item = OUTPUT_ITEM_INITIALIZER (&group_close_item_class),
- };
- return item;
-}
-
-/* Submits ITEM to the configured output drivers, and transfers ownership to
- the output subsystem. */
-void
-group_close_item_submit (struct group_close_item *item)
-{
- output_submit (&item->output_item);
-}
-
-static const char *
-group_close_item_get_label (const struct output_item *output_item UNUSED)
-{
- /* Not marked for translation: user should never see it. */
- return "Group Close";
-}
-
-static void
-group_close_item_destroy (struct output_item *output_item)
-{
- struct group_close_item *item = to_group_close_item (output_item);
-
- free (item);
-}
-
-const struct output_item_class group_close_item_class =
- {
- group_close_item_get_label,
- group_close_item_destroy,
- };
+++ /dev/null
-/* PSPP - a program for statistical analysis.
- Copyright (C) 2018 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-#ifndef OUTPUT_GROUP_ITEM_H
-#define OUTPUT_GROUP_ITEM_H 1
-
-/* Grouping items.
-
- A group-open item marks the beginning of a group of related output items. A
- later group-close item ends the group. Groups can nest. */
-
-#include <stdbool.h>
-#include "output/output-item.h"
-
-/* A group_open item. */
-struct group_open_item
- {
- struct output_item output_item;
- };
-
-struct group_open_item *group_open_item_create (const char *command_name,
- const char *label);
-struct group_open_item *group_open_item_create_nocopy (char *command_name,
- char *label);
-
-/* A group_close item. */
-struct group_close_item
- {
- struct output_item output_item;
- };
-struct group_close_item *group_close_item_create (void);
-\f
-/* This boilerplate for group_open_item, a subclass of output_item, was
- autogenerated by mk-class-boilerplate. */
-
-#include <assert.h>
-#include "libpspp/cast.h"
-
-extern const struct output_item_class group_open_item_class;
-
-/* Returns true if SUPER is a group_open_item, otherwise false. */
-static inline bool
-is_group_open_item (const struct output_item *super)
-{
- return super->class == &group_open_item_class;
-}
-
-/* Returns SUPER converted to group_open_item. SUPER must be a
- group_open_item, as reported by is_group_open_item. */
-static inline struct group_open_item *
-to_group_open_item (const struct output_item *super)
-{
- assert (is_group_open_item (super));
- return UP_CAST (super, struct group_open_item, output_item);
-}
-
-/* Returns INSTANCE converted to output_item. */
-static inline struct output_item *
-group_open_item_super (const struct group_open_item *instance)
-{
- return CONST_CAST (struct output_item *, &instance->output_item);
-}
-
-/* Increments INSTANCE's reference count and returns INSTANCE. */
-static inline struct group_open_item *
-group_open_item_ref (const struct group_open_item *instance)
-{
- return to_group_open_item (output_item_ref (&instance->output_item));
-}
-
-/* Decrements INSTANCE's reference count, then destroys INSTANCE if
- the reference count is now zero. */
-static inline void
-group_open_item_unref (struct group_open_item *instance)
-{
- output_item_unref (&instance->output_item);
-}
-
-/* Returns true if INSTANCE's reference count is greater than 1,
- false otherwise. */
-static inline bool
-group_open_item_is_shared (const struct group_open_item *instance)
-{
- return output_item_is_shared (&instance->output_item);
-}
-
-void group_open_item_submit (struct group_open_item *);
-\f
-/* This boilerplate for group_close_item, a subclass of output_item, was
- autogenerated by mk-class-boilerplate. */
-
-#include <assert.h>
-#include "libpspp/cast.h"
-
-extern const struct output_item_class group_close_item_class;
-
-/* Returns true if SUPER is a group_close_item, otherwise false. */
-static inline bool
-is_group_close_item (const struct output_item *super)
-{
- return super->class == &group_close_item_class;
-}
-
-/* Returns SUPER converted to group_close_item. SUPER must be a
- group_close_item, as reported by is_group_close_item. */
-static inline struct group_close_item *
-to_group_close_item (const struct output_item *super)
-{
- assert (is_group_close_item (super));
- return UP_CAST (super, struct group_close_item, output_item);
-}
-
-/* Returns INSTANCE converted to output_item. */
-static inline struct output_item *
-group_close_item_super (const struct group_close_item *instance)
-{
- return CONST_CAST (struct output_item *, &instance->output_item);
-}
-
-/* Increments INSTANCE's reference count and returns INSTANCE. */
-static inline struct group_close_item *
-group_close_item_ref (const struct group_close_item *instance)
-{
- return to_group_close_item (output_item_ref (&instance->output_item));
-}
-
-/* Decrements INSTANCE's reference count, then destroys INSTANCE if
- the reference count is now zero. */
-static inline void
-group_close_item_unref (struct group_close_item *instance)
-{
- output_item_unref (&instance->output_item);
-}
-
-/* Returns true if INSTANCE's reference count is greater than 1,
- false otherwise. */
-static inline bool
-group_close_item_is_shared (const struct group_close_item *instance)
-{
- return output_item_is_shared (&instance->output_item);
-}
-
-void group_close_item_submit (struct group_close_item *);
-\f
-#endif /* output/group-item.h */
#include "libpspp/message.h"
#include "libpspp/version.h"
#include "output/cairo-chart.h"
-#include "output/chart-item.h"
+#include "output/chart.h"
#include "output/driver-provider.h"
-#include "output/image-item.h"
-#include "output/message-item.h"
#include "output/options.h"
-#include "output/output-item-provider.h"
+#include "output/output-item.h"
#include "output/pivot-output.h"
#include "output/pivot-table.h"
#include "output/table-provider.h"
-#include "output/table-item.h"
-#include "output/text-item.h"
#include "gl/minmax.h"
#include "gl/xalloc.h"
static const struct output_driver_class html_driver_class;
-static void html_output_table (struct html_driver *, const struct table_item *);
+static void html_output_table (struct html_driver *,
+ const struct output_item *);
static void escape_string (FILE *file, const char *text,
const char *space, const char *newline);
static void print_title_tag (FILE *file, const char *name,
}
static void
-html_submit (struct output_driver *driver,
- const struct output_item *output_item)
+html_submit (struct output_driver *driver, const struct output_item *item)
{
struct html_driver *html = html_driver_cast (driver);
- if (is_table_item (output_item))
+ switch (item->type)
{
- struct table_item *table_item = to_table_item (output_item);
- html_output_table (html, table_item);
- }
- else if (is_image_item (output_item) && html->chart_file_name != NULL)
- {
- struct image_item *image_item = to_image_item (output_item);
- char *file_name = xr_write_png_image (
- image_item->image, html->chart_file_name, ++html->chart_cnt);
- if (file_name != NULL)
- {
- fprintf (html->file, "<img src=\"%s\">", file_name);
- free (file_name);
- }
- }
- else if (is_chart_item (output_item) && html->chart_file_name != NULL)
- {
- struct chart_item *chart_item = to_chart_item (output_item);
- char *file_name;
-
- file_name = xr_draw_png_chart (chart_item, html->chart_file_name,
- html->chart_cnt++,
- &html->fg,
- &html->bg
- );
- if (file_name != NULL)
+ case OUTPUT_ITEM_CHART:
+ if (html->chart_file_name)
{
- const char *title = chart_item_get_title (chart_item);
- fprintf (html->file, "<img src=\"%s\" alt=\"chart: %s\">",
- file_name, title ? title : _("No description"));
- free (file_name);
+ char *file_name = xr_draw_png_chart (item->chart,
+ html->chart_file_name,
+ html->chart_cnt++,
+ &html->fg, &html->bg);
+ if (file_name != NULL)
+ {
+ const char *title = chart_get_title (item->chart);
+ fprintf (html->file, "<img src=\"%s\" alt=\"chart: %s\">",
+ file_name, title ? title : _("No description"));
+ free (file_name);
+ }
}
- }
- else if (is_text_item (output_item))
- {
- struct text_item *text_item = to_text_item (output_item);
- char *s = text_item_get_plain_text (text_item);
-
- switch (text_item_get_type (text_item))
- {
- case TEXT_ITEM_PAGE_TITLE:
- break;
+ break;
- case TEXT_ITEM_TITLE:
- {
- int level = MIN (5, output_get_group_level ()) + 1;
- char tag[3] = { 'H', level + '1', '\0' };
- print_title_tag (html->file, tag, s);
- }
- break;
+ case OUTPUT_ITEM_GROUP_OPEN:
+ break;
- case TEXT_ITEM_SYNTAX:
- fprintf (html->file, "<pre class=\"syntax\">");
- escape_string (html->file, s, " ", "<br>");
- fprintf (html->file, "</pre>\n");
- break;
+ case OUTPUT_ITEM_GROUP_CLOSE:
+ break;
- case TEXT_ITEM_LOG:
- fprintf (html->file, "<p>");
- escape_string (html->file, s, " ", "<br>");
- fprintf (html->file, "</p>\n");
- break;
+ case OUTPUT_ITEM_IMAGE:
+ if (html->chart_file_name)
+ {
+ char *file_name = xr_write_png_image (
+ item->image, html->chart_file_name, ++html->chart_cnt);
+ if (file_name != NULL)
+ {
+ fprintf (html->file, "<img src=\"%s\">", file_name);
+ free (file_name);
+ }
}
+ break;
- free (s);
- }
- else if (is_message_item (output_item))
- {
- const struct message_item *message_item = to_message_item (output_item);
- char *s = msg_to_string (message_item_get_msg (message_item));
+ case OUTPUT_ITEM_MESSAGE:
fprintf (html->file, "<p>");
+
+ char *s = msg_to_string (item->message);
escape_string (html->file, s, " ", "<br>");
- fprintf (html->file, "</p>\n");
free (s);
+
+ fprintf (html->file, "</p>\n");
+ break;
+
+ case OUTPUT_ITEM_PAGE_BREAK:
+ break;
+
+ case OUTPUT_ITEM_PAGE_SETUP:
+ break;
+
+ case OUTPUT_ITEM_TABLE:
+ html_output_table (html, item);
+ break;
+
+ case OUTPUT_ITEM_TEXT:
+ {
+ char *s = text_item_get_plain_text (item);
+
+ switch (item->text.subtype)
+ {
+ case TEXT_ITEM_PAGE_TITLE:
+ break;
+
+ case TEXT_ITEM_TITLE:
+ {
+ int level = MIN (5, output_get_group_level ()) + 1;
+ char tag[3] = { 'H', level + '1', '\0' };
+ print_title_tag (html->file, tag, s);
+ }
+ break;
+
+ case TEXT_ITEM_SYNTAX:
+ fprintf (html->file, "<pre class=\"syntax\">");
+ escape_string (html->file, s, " ", "<br>");
+ fprintf (html->file, "</pre>\n");
+ break;
+
+ case TEXT_ITEM_LOG:
+ fprintf (html->file, "<p>");
+ escape_string (html->file, s, " ", "<br>");
+ fprintf (html->file, "</p>\n");
+ break;
+ }
+
+ free (s);
+ }
+ break;
}
}
}
static void
-html_output_table (struct html_driver *html, const struct table_item *item)
+html_output_table (struct html_driver *html, const struct output_item *item)
{
size_t *layer_indexes;
- PIVOT_OUTPUT_FOR_EACH_LAYER (layer_indexes, item->pt, true)
- html_output_table_layer (html, item->pt, layer_indexes);
+ PIVOT_OUTPUT_FOR_EACH_LAYER (layer_indexes, item->table, true)
+ html_output_table_layer (html, item->table, layer_indexes);
}
struct output_driver_factory html_driver_factory =
+++ /dev/null
-/* PSPP - a program for statistical analysis.
- Copyright (C) 2020 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-#include <config.h>
-
-#include "output/image-item.h"
-
-#include <stdarg.h>
-#include <stdlib.h>
-
-#include "libpspp/cast.h"
-#include "libpspp/compiler.h"
-#include "output/driver.h"
-#include "output/output-item-provider.h"
-
-#include "gl/xalloc.h"
-#include "gl/xvasprintf.h"
-
-/* Creates and returns a new image item containing IMAGE. Takes ownership of
- IMAGE. */
-struct image_item *
-image_item_create (cairo_surface_t *image)
-{
- struct image_item *item = xmalloc (sizeof *item);
- *item = (struct image_item) {
- .output_item = OUTPUT_ITEM_INITIALIZER (&image_item_class),
- .image = image,
- };
- return item;
-}
-
-/* Submits ITEM to the configured output drivers, and transfers ownership to
- the output subsystem. */
-void
-image_item_submit (struct image_item *item)
-{
- output_submit (&item->output_item);
-}
-
-struct image_item *
-image_item_unshare (struct image_item *old)
-{
- assert (old->output_item.ref_cnt > 0);
- if (!image_item_is_shared (old))
- return old;
- image_item_unref (old);
-
- struct image_item *new = xmalloc (sizeof *new);
- *new = (struct image_item) {
- .output_item = OUTPUT_ITEM_CLONE_INITIALIZER (&old->output_item),
- .image = cairo_surface_reference (old->image),
- };
- return new;
-}
-\f
-static const char *
-image_item_get_label (const struct output_item *output_item UNUSED)
-{
- return "Image";
-}
-
-static void
-image_item_destroy (struct output_item *output_item)
-{
- struct image_item *item = to_image_item (output_item);
- cairo_surface_destroy (item->image);
- free (item);
-}
-
-const struct output_item_class image_item_class =
- {
- image_item_get_label,
- image_item_destroy,
- };
+++ /dev/null
-/* PSPP - a program for statistical analysis.
- Copyright (C) 2020 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-#ifndef OUTPUT_IMAGE_ITEM_H
-#define OUTPUT_IMAGE_ITEM_H 1
-
-#include <cairo.h>
-#include <stdbool.h>
-#include "output/output-item.h"
-
-struct image_item
- {
- struct output_item output_item; /* Superclass */
- cairo_surface_t *image;
- };
-
-struct image_item *image_item_create (cairo_surface_t *);
-struct image_item *image_item_unshare (struct image_item *);
-\f
-/* This boilerplate for image_item, a subclass of output_item, was
- autogenerated by mk-class-boilerplate. */
-
-#include <assert.h>
-#include "libpspp/cast.h"
-
-extern const struct output_item_class image_item_class;
-
-/* Returns true if SUPER is a image_item, otherwise false. */
-static inline bool
-is_image_item (const struct output_item *super)
-{
- return super->class == &image_item_class;
-}
-
-/* Returns SUPER converted to image_item. SUPER must be a image_item, as
- reported by is_image_item. */
-static inline struct image_item *
-to_image_item (const struct output_item *super)
-{
- assert (is_image_item (super));
- return UP_CAST (super, struct image_item, output_item);
-}
-
-/* Returns INSTANCE converted to output_item. */
-static inline struct output_item *
-image_item_super (const struct image_item *instance)
-{
- return CONST_CAST (struct output_item *, &instance->output_item);
-}
-
-/* Increments INSTANCE's reference count and returns INSTANCE. */
-static inline struct image_item *
-image_item_ref (const struct image_item *instance)
-{
- return to_image_item (output_item_ref (&instance->output_item));
-}
-
-/* Decrements INSTANCE's reference count, then destroys INSTANCE if
- the reference count is now zero. */
-static inline void
-image_item_unref (struct image_item *instance)
-{
- output_item_unref (&instance->output_item);
-}
-
-/* Returns true if INSTANCE's reference count is greater than 1,
- false otherwise. */
-static inline bool
-image_item_is_shared (const struct image_item *instance)
-{
- return output_item_is_shared (&instance->output_item);
-}
-
-void image_item_submit (struct image_item *);
-\f
-#endif /* output/image-item.h */
#include "libpspp/message.h"
#include "libpspp/str.h"
#include "output/driver-provider.h"
-#include "output/message-item.h"
-#include "output/text-item.h"
+#include "output/output-item.h"
#include "gl/fwriteerror.h"
#include "gl/xalloc.h"
}
static void
-journal_output (struct journal_driver *j, const char *s)
+journal_output (struct journal_driver *j, char *s)
{
- if (j->file == NULL)
- return;
+ if (j->file)
+ {
+ fprintf (j->file, "%s\n", s);
- fprintf (j->file, "%s\n", s);
+ /* Flush the journal in case the syntax we're about to write
+ causes a crash. Having the syntax already written to disk
+ makes postmortem analysis of the problem possible. */
+ fflush (j->file);
+ }
- /* Flush the journal in case the syntax we're about to write
- causes a crash. Having the syntax already written to disk
- makes postmortem analysis of the problem possible. */
- fflush (j->file);
+ free (s);
}
static void
{
struct journal_driver *j = journal_driver_cast (driver);
- if (is_text_item (item))
- {
- const struct text_item *text_item = to_text_item (item);
- enum text_item_type type = text_item_get_type (text_item);
-
- if (type == TEXT_ITEM_SYNTAX)
- {
- char *text = text_item_get_plain_text (text_item);
- journal_output (j, text);
- free (text);
- }
- }
- else if (is_message_item (item))
+ switch (item->type)
{
- const struct message_item *message_item = to_message_item (item);
- char *s = msg_to_string (message_item_get_msg (message_item));
- journal_output (j, s);
- free (s);
+ case OUTPUT_ITEM_MESSAGE:
+ journal_output (j, msg_to_string (item->message));
+ break;
+
+ case OUTPUT_ITEM_TEXT:
+ if (item->text.subtype == TEXT_ITEM_SYNTAX)
+ journal_output (j, text_item_get_plain_text (item));
+ break;
+
+ case OUTPUT_ITEM_CHART:
+ case OUTPUT_ITEM_GROUP_OPEN:
+ case OUTPUT_ITEM_GROUP_CLOSE:
+ case OUTPUT_ITEM_IMAGE:
+ case OUTPUT_ITEM_PAGE_BREAK:
+ case OUTPUT_ITEM_PAGE_SETUP:
+ case OUTPUT_ITEM_TABLE:
+ break;
}
}
+++ /dev/null
-/* PSPP - a program for statistical analysis.
- Copyright (C) 2010 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-#include <config.h>
-
-#include "output/message-item.h"
-
-#include <stdlib.h>
-
-#include "libpspp/i18n.h"
-#include "libpspp/message.h"
-#include "output/driver.h"
-#include "output/output-item-provider.h"
-#include "output/text-item.h"
-
-#include "gl/xalloc.h"
-
-#include "gettext.h"
-#define _(msgid) gettext (msgid)
-
-struct message_item *
-message_item_create (const struct msg *msg)
-{
- struct message_item *item = xmalloc (sizeof *msg);
- *item = (struct message_item) {
- .output_item = OUTPUT_ITEM_INITIALIZER (&message_item_class),
- .msg = msg_dup (msg)
- };
- return item;
-}
-
-const struct msg *
-message_item_get_msg (const struct message_item *item)
-{
- return item->msg;
-}
-
-struct text_item *
-message_item_to_text_item (struct message_item *message_item)
-{
- struct text_item *text_item = text_item_create_nocopy (
- TEXT_ITEM_LOG,
- msg_to_string (message_item_get_msg (message_item)),
- xstrdup (output_item_get_label (message_item_super (message_item))));
- message_item_unref (message_item);
- return text_item;
-}
-
-static const char *
-message_item_get_label (const struct output_item *output_item)
-{
- const struct message_item *item = to_message_item (output_item);
- return (item->msg->severity == MSG_S_ERROR ? _("Error")
- : item->msg->severity == MSG_S_WARNING ? _("Warning")
- : _("Note"));
-}
-
-static void
-message_item_destroy (struct output_item *output_item)
-{
- struct message_item *item = to_message_item (output_item);
- msg_destroy (item->msg);
- free (item);
-}
-
-/* Submits ITEM to the configured output drivers, and transfers ownership to
- the output subsystem. */
-void
-message_item_submit (struct message_item *item)
-{
- output_submit (&item->output_item);
-}
-
-const struct output_item_class message_item_class =
- {
- message_item_get_label,
- message_item_destroy,
- };
+++ /dev/null
-/* PSPP - a program for statistical analysis.
- Copyright (C) 2010, 2011 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-#ifndef OUTPUT_MESSAGE_ITEM_H
-#define OUTPUT_MESSAGE_ITEM_H 1
-
-/* Message items.
-
- A message item is a subclass of an output item (see
- output/output-item.h).
-
- A message item is an error, warning, or note to the user.
-
- Message items should not be submitted directly to the output subsystem.
- Instead, use the msg() function in libpspp/message.h, which will ensure that
- the message gets routed properly for the PSPP user interface in use. */
-
-#include <stdbool.h>
-#include "output/output-item.h"
-
-/* A message item. */
-struct message_item
- {
- struct output_item output_item;
- struct msg *msg;
- };
-
-struct message_item *message_item_create (const struct msg *);
-
-const struct msg *message_item_get_msg (const struct message_item *);
-
-struct text_item *message_item_to_text_item (struct message_item *);
-\f
-/* This boilerplate for message_item, a subclass of output_item, was
- autogenerated by mk-class-boilerplate. */
-
-#include <assert.h>
-#include "libpspp/cast.h"
-
-extern const struct output_item_class message_item_class;
-
-/* Returns true if SUPER is a message_item, otherwise false. */
-static inline bool
-is_message_item (const struct output_item *super)
-{
- return super->class == &message_item_class;
-}
-
-/* Returns SUPER converted to message_item. SUPER must be a message_item, as
- reported by is_message_item. */
-static inline struct message_item *
-to_message_item (const struct output_item *super)
-{
- assert (is_message_item (super));
- return UP_CAST (super, struct message_item, output_item);
-}
-
-/* Returns INSTANCE converted to output_item. */
-static inline struct output_item *
-message_item_super (const struct message_item *instance)
-{
- return CONST_CAST (struct output_item *, &instance->output_item);
-}
-
-/* Increments INSTANCE's reference count and returns INSTANCE. */
-static inline struct message_item *
-message_item_ref (const struct message_item *instance)
-{
- return to_message_item (output_item_ref (&instance->output_item));
-}
-
-/* Decrements INSTANCE's reference count, then destroys INSTANCE if
- the reference count is now zero. */
-static inline void
-message_item_unref (struct message_item *instance)
-{
- output_item_unref (&instance->output_item);
-}
-
-/* Returns true if INSTANCE's reference count is greater than 1,
- false otherwise. */
-static inline bool
-message_item_is_shared (const struct message_item *instance)
-{
- return output_item_is_shared (&instance->output_item);
-}
-
-void message_item_submit (struct message_item *);
-\f
-#endif /* output/message-item.h */
#include "libpspp/cast.h"
#include "libpspp/message.h"
#include "output/driver-provider.h"
-#include "output/message-item.h"
+#include "output/output-item.h"
#include "gl/fwriteerror.h"
#include "gl/xalloc.h"
{
struct msglog_driver *ml = msglog_driver_cast (driver);
- if (is_message_item (item))
+ if (item->type == OUTPUT_ITEM_MESSAGE)
{
- const struct message_item *message_item = to_message_item (item);
- char *s = msg_to_string (message_item_get_msg (message_item));
+ char *s = msg_to_string (item->message);
fprintf (ml->file, "%s\n", s);
free (s);
}
#include "libpspp/zip-writer.h"
#include "data/file-handle-def.h"
#include "output/driver-provider.h"
-#include "output/message-item.h"
#include "output/options.h"
+#include "output/output-item.h"
#include "output/pivot-table.h"
#include "output/pivot-output.h"
-#include "output/table-item.h"
#include "output/table-provider.h"
-#include "output/text-item.h"
#include "gl/xalloc.h"
}
static void
-write_table (struct odt_driver *odt, const struct table_item *item)
+write_table (struct odt_driver *odt, const struct pivot_table *pt)
{
size_t *layer_indexes;
- PIVOT_OUTPUT_FOR_EACH_LAYER (layer_indexes, item->pt, true)
- write_table_layer (odt, item->pt, layer_indexes);
+ PIVOT_OUTPUT_FOR_EACH_LAYER (layer_indexes, pt, true)
+ write_table_layer (odt, pt, layer_indexes);
}
static void
/* Submit a table to the ODT driver */
static void
-odt_submit (struct output_driver *driver,
- const struct output_item *output_item)
+odt_submit (struct output_driver *driver, const struct output_item *item)
{
struct odt_driver *odt = odt_driver_cast (driver);
- if (is_table_item (output_item))
- write_table (odt, to_table_item (output_item));
- else if (is_text_item (output_item))
+ switch (item->type)
{
- char *text = text_item_get_plain_text (to_text_item (output_item));
- odt_output_text (odt, text);
- free (text);
- }
- else if (is_message_item (output_item))
- {
- const struct message_item *message_item = to_message_item (output_item);
- char *s = msg_to_string (message_item_get_msg (message_item));
- odt_output_text (odt, s);
- free (s);
+ case OUTPUT_ITEM_CHART:
+ break;
+
+ case OUTPUT_ITEM_GROUP_OPEN:
+ break;
+
+ case OUTPUT_ITEM_GROUP_CLOSE:
+ break;
+
+ case OUTPUT_ITEM_IMAGE:
+ break;
+
+ case OUTPUT_ITEM_MESSAGE:
+ {
+ char *s = msg_to_string (item->message);
+ odt_output_text (odt, s);
+ free (s);
+ }
+ break;
+
+ case OUTPUT_ITEM_PAGE_BREAK:
+ break;
+
+ case OUTPUT_ITEM_PAGE_SETUP:
+ break;
+
+ case OUTPUT_ITEM_TABLE:
+ write_table (odt, item->table);
+ break;
+
+ case OUTPUT_ITEM_TEXT:
+ {
+ char *text = text_item_get_plain_text (item);
+ odt_output_text (odt, text);
+ free (text);
+ }
+ break;
}
}
+++ /dev/null
-/* PSPP - a program for statistical analysis.
- Copyright (C) 2009, 2011 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-#ifndef OUTPUT_ITEM_PROVIDER_H
-#define OUTPUT_ITEM_PROVIDER_H 1
-
-#include "libpspp/str.h"
-#include "output/output-item.h"
-
-/* Class structure for an output item.
-
- This structure must be provided by an output_item subclass to initialize an
- instance of output_item. */
-struct output_item_class
- {
- /* Returns the localized label to use for ITEM. This is only called when
- ITEM does not have an explicitly set label, that is, when 'item->label'
- is NULL. */
- const char *(*get_label) (const struct output_item *item);
-
- /* Destroys and frees ITEM. Called when output_item_unref() drops ITEM's
- reference count to 0. */
- void (*destroy) (struct output_item *item);
- };
-
-#define OUTPUT_ITEM_INITIALIZER(CLASS) { .class = CLASS, .ref_cnt = 1 }
-#define OUTPUT_ITEM_CLONE_INITIALIZER(SRC) \
- { \
- .class = (SRC)->class, \
- .ref_cnt = 1, \
- .label = xstrdup_if_nonnull ((SRC)->label), \
- .command_name = xstrdup_if_nonnull ((SRC)->command_name), \
- }
-
-#endif /* output/output-item-provider.h */
#include <config.h>
-#include "output/output-item-provider.h"
+#include "output/output-item.h"
#include <assert.h>
#include <stdlib.h>
#include "libpspp/assertion.h"
#include "libpspp/cast.h"
+#include "libpspp/message.h"
#include "libpspp/str.h"
+#include "output/chart.h"
+#include "output/driver.h"
+#include "output/page-setup.h"
+#include "output/pivot-table.h"
#include "gl/xalloc.h"
#include "gettext.h"
+#define _(msgid) gettext (msgid)
+#define N_(msgid) msgid
\f
+#define OUTPUT_ITEM_INITIALIZER(TYPE) .type = TYPE, .ref_cnt = 1
+
/* Increases ITEM's reference count, indicating that it has an additional
owner. An output item that is shared among multiple owners must not be
modified. */
assert (item->ref_cnt > 0);
if (--item->ref_cnt == 0)
{
- char *label = item->label;
- char *command_name = item->command_name;
- item->class->destroy (item);
- free (label);
- free (command_name);
+ switch (item->type)
+ {
+ case OUTPUT_ITEM_CHART:
+ chart_unref (item->chart);
+ break;
+
+ case OUTPUT_ITEM_GROUP_OPEN:
+ break;
+
+ case OUTPUT_ITEM_GROUP_CLOSE:
+ break;
+
+ case OUTPUT_ITEM_IMAGE:
+ cairo_surface_destroy (item->image);
+ break;
+
+ case OUTPUT_ITEM_MESSAGE:
+ msg_destroy (item->message);
+ break;
+
+ case OUTPUT_ITEM_PAGE_BREAK:
+ break;
+
+ case OUTPUT_ITEM_PAGE_SETUP:
+ page_setup_destroy (item->page_setup);
+ break;
+
+ case OUTPUT_ITEM_TABLE:
+ pivot_table_unref (item->table);
+ break;
+
+ case OUTPUT_ITEM_TEXT:
+ pivot_value_destroy (item->text.content);
+ break;
+ }
+
+ free (item->label);
+ free (item->command_name);
+ free (item->cached_label);
+ free (item);
}
}
}
return item->ref_cnt > 1;
}
+struct output_item *
+output_item_unshare (struct output_item *old)
+{
+ assert (old->ref_cnt > 0);
+ if (!output_item_is_shared (old))
+ return old;
+ output_item_unref (old);
+
+ struct output_item *new = xmalloc (sizeof *new);
+ *new = (struct output_item) {
+ .ref_cnt = 1,
+ .label = xstrdup_if_nonnull (old->label),
+ .command_name = xstrdup_if_nonnull (old->command_name),
+ .type = old->type,
+ };
+ switch (old->type)
+ {
+ case OUTPUT_ITEM_CHART:
+ new->chart = chart_ref (old->chart);
+ break;
+
+ case OUTPUT_ITEM_GROUP_OPEN:
+ break;
+
+ case OUTPUT_ITEM_GROUP_CLOSE:
+ break;
+
+ case OUTPUT_ITEM_IMAGE:
+ new->image = cairo_surface_reference (old->image);
+ break;
+
+ case OUTPUT_ITEM_MESSAGE:
+ new->message = msg_dup (old->message);
+ break;
+
+ case OUTPUT_ITEM_PAGE_BREAK:
+ break;
+
+ case OUTPUT_ITEM_PAGE_SETUP:
+ new->page_setup = page_setup_clone (old->page_setup);
+ break;
+
+ case OUTPUT_ITEM_TABLE:
+ new->table = pivot_table_ref (old->table);
+ break;
+
+ case OUTPUT_ITEM_TEXT:
+ new->text.subtype = old->text.subtype;
+ new->text.content = pivot_value_clone (old->text.content);
+ break;
+ }
+ return new;
+}
+
+void
+output_item_submit (struct output_item *item)
+{
+ output_submit (item);
+}
+
/* Returns the label for ITEM, which the caller must not modify or free. */
const char *
output_item_get_label (const struct output_item *item)
{
- return item->label ? item->label : item->class->get_label (item);
+ if (item->label)
+ return item->label;
+
+ switch (item->type)
+ {
+ case OUTPUT_ITEM_CHART:
+ return item->chart->title ? item->chart->title : _("Chart");
+
+ case OUTPUT_ITEM_GROUP_OPEN:
+ return item->command_name ? item->command_name : _("Group");
+
+ case OUTPUT_ITEM_GROUP_CLOSE:
+ /* Not marked for translation: user should never see it. */
+ return "Group Close";
+
+ case OUTPUT_ITEM_IMAGE:
+ return "Image";
+
+ case OUTPUT_ITEM_MESSAGE:
+ return (item->message->severity == MSG_S_ERROR ? _("Error")
+ : item->message->severity == MSG_S_WARNING ? _("Warning")
+ : _("Note"));
+
+ case OUTPUT_ITEM_PAGE_BREAK:
+ return _("Page Break");
+
+ case OUTPUT_ITEM_PAGE_SETUP:
+ /* Not marked for translation: user should never see it. */
+ return "Page Setup";
+
+ case OUTPUT_ITEM_TABLE:
+ if (!item->cached_label)
+ {
+ if (!item->table->title)
+ return _("Table");
+
+ struct output_item *item_rw = CONST_CAST (struct output_item *, item);
+ item_rw->cached_label = pivot_value_to_string (item->table->title,
+ item->table);
+ }
+ return item->cached_label;
+
+ case OUTPUT_ITEM_TEXT:
+ return text_item_subtype_to_string (item->text.subtype);
+ }
+
+ NOT_REACHED ();
}
/* Sets the label for ITEM to LABEL. The caller retains ownership of LABEL.
free (item->label);
item->label = label;
}
+\f
+struct output_item *
+chart_item_create (struct chart *chart)
+{
+ struct output_item *item = xmalloc (sizeof *item);
+ *item = (struct output_item) {
+ OUTPUT_ITEM_INITIALIZER (OUTPUT_ITEM_CHART),
+ .chart = chart,
+ };
+ return item;
+}
+\f
+struct output_item *
+group_open_item_create (const char *command_name, const char *label)
+{
+ return group_open_item_create_nocopy (
+ xstrdup_if_nonnull (command_name),
+ xstrdup_if_nonnull (label));
+}
+
+struct output_item *
+group_open_item_create_nocopy (char *command_name, char *label)
+{
+ struct output_item *item = xmalloc (sizeof *item);
+ *item = (struct output_item) {
+ OUTPUT_ITEM_INITIALIZER (OUTPUT_ITEM_GROUP_OPEN),
+ .label = label,
+ .command_name = command_name,
+ };
+ return item;
+}
+
+struct output_item *
+group_close_item_create (void)
+{
+ struct output_item *item = xmalloc (sizeof *item);
+ *item = (struct output_item) {
+ OUTPUT_ITEM_INITIALIZER (OUTPUT_ITEM_GROUP_CLOSE),
+ };
+ return item;
+}
+\f
+/* Creates and returns a new output item containing IMAGE. Takes ownership of
+ IMAGE. */
+struct output_item *
+image_item_create (cairo_surface_t *image)
+{
+ struct output_item *item = xmalloc (sizeof *item);
+ *item = (struct output_item) {
+ OUTPUT_ITEM_INITIALIZER (OUTPUT_ITEM_IMAGE),
+ .image = image,
+ };
+ return item;
+}
+\f
+struct output_item *
+message_item_create (const struct msg *msg)
+{
+ struct output_item *item = xmalloc (sizeof *msg);
+ *item = (struct output_item) {
+ OUTPUT_ITEM_INITIALIZER (OUTPUT_ITEM_MESSAGE),
+ .message = msg_dup (msg),
+ };
+ return item;
+}
+
+const struct msg *
+message_item_get_msg (const struct output_item *item)
+{
+ assert (item->type == OUTPUT_ITEM_MESSAGE);
+ return item->message;
+}
+
+struct output_item *
+message_item_to_text_item (struct output_item *message_item)
+{
+ assert (message_item->type == OUTPUT_ITEM_MESSAGE);
+ struct output_item *text_item = text_item_create_nocopy (
+ TEXT_ITEM_LOG,
+ msg_to_string (message_item->message),
+ xstrdup (output_item_get_label (message_item)));
+ output_item_unref (message_item);
+ return text_item;
+}
+\f
+struct output_item *
+page_break_item_create (void)
+{
+ struct output_item *item = xmalloc (sizeof *item);
+ *item = (struct output_item) {
+ OUTPUT_ITEM_INITIALIZER (OUTPUT_ITEM_PAGE_BREAK),
+ };
+ return item;
+}
+\f
+struct output_item *
+page_setup_item_create (const struct page_setup *ps)
+{
+ struct output_item *item = xmalloc (sizeof *item);
+ *item = (struct output_item) {
+ OUTPUT_ITEM_INITIALIZER (OUTPUT_ITEM_PAGE_SETUP),
+ .page_setup = page_setup_clone (ps),
+ };
+ return item;
+}
+\f
+/* Returns a new output_item for rendering TABLE. Takes ownership of
+ TABLE. */
+struct output_item *
+table_item_create (struct pivot_table *table)
+{
+ pivot_table_assign_label_depth (table);
+
+ struct output_item *item = xmalloc (sizeof *item);
+ *item = (struct output_item) {
+ OUTPUT_ITEM_INITIALIZER (OUTPUT_ITEM_TABLE),
+ .command_name = xstrdup_if_nonnull (table->command_c),
+ .table = table,
+ };
+ return item;
+}
+\f
+/* Creates and returns a new text item containing TEXT and the specified
+ SUBTYPE and LABEL. The new text item takes ownership of TEXT and LABEL. If
+ LABEL is NULL, uses the default label for SUBTYPE. */
+struct output_item *
+text_item_create_nocopy (enum text_item_subtype subtype,
+ char *text, char *label)
+{
+ return text_item_create_value (subtype,
+ pivot_value_new_user_text_nocopy (text),
+ label);
+}
+
+/* Creates and returns a new text item containing a copy of TEXT and the
+ specified SUBTYPE and LABEL. The caller retains ownership of TEXT and
+ LABEL. If LABEL is null, uses a default label for SUBTYPE. */
+struct output_item *
+text_item_create (enum text_item_subtype subtype, const char *text,
+ const char *label)
+{
+ return text_item_create_nocopy (subtype, xstrdup (text),
+ xstrdup_if_nonnull (label));
+}
+
+/* Creates and returns a new text item containing VALUE, SUBTYPE, and LABEL.
+ Takes ownership of VALUE and LABEL. If LABEL is null, uses a default label
+ for SUBTYPE. */
+struct output_item *
+text_item_create_value (enum text_item_subtype subtype,
+ struct pivot_value *value, char *label)
+{
+ if (subtype == TEXT_ITEM_SYNTAX || subtype == TEXT_ITEM_LOG)
+ {
+ if (!value->font_style)
+ {
+ value->font_style = xmalloc (sizeof *value->font_style);
+ *value->font_style = (struct font_style) FONT_STYLE_INITIALIZER;
+ }
+
+ free (value->font_style->typeface);
+ value->font_style->typeface = xstrdup ("Monospaced");
+ }
+
+ struct output_item *item = xzalloc (sizeof *item);
+ *item = (struct output_item) {
+ OUTPUT_ITEM_INITIALIZER (OUTPUT_ITEM_TEXT),
+ .command_name = xstrdup_if_nonnull (output_get_command_name ()),
+ .label = label,
+ .text = { .subtype = subtype, .content = value },
+ };
+ return item;
+}
+
+/* Returns ITEM's subtype. */
+enum text_item_subtype
+text_item_get_subtype (const struct output_item *item)
+{
+ assert (item->type == OUTPUT_ITEM_TEXT);
+ return item->text.subtype;
+}
+
+/* Returns ITEM's text, which the caller must eventually free. */
+char *
+text_item_get_plain_text (const struct output_item *item)
+{
+ assert (item->type == OUTPUT_ITEM_TEXT);
+ return pivot_value_to_string_defaults (item->text.content);
+}
+
+static bool
+nullable_font_style_equal (const struct font_style *a,
+ const struct font_style *b)
+{
+ return a && b ? font_style_equal (a, b) : !a && !b;
+}
+
+/* Attempts to append the text in SRC to DST. If successful, returns true,
+ otherwise false.
+
+ Only TEXT_ITEM_SYNTAX and TEXT_ITEM_LOG items can be combined, and not with
+ each other.
+
+ DST must not be shared. */
+bool
+text_item_append (struct output_item *dst, const struct output_item *src)
+{
+ assert (dst->type == OUTPUT_ITEM_TEXT);
+ assert (src->type == OUTPUT_ITEM_TEXT);
+ assert (!output_item_is_shared (dst));
+
+ enum text_item_subtype ds = dst->text.subtype;
+ enum text_item_subtype ss = src->text.subtype;
+
+ struct pivot_value *dc = dst->text.content;
+ const struct pivot_value *sc = src->text.content;
+
+ if (ds != ss
+ || (ds != TEXT_ITEM_SYNTAX && ds != TEXT_ITEM_LOG)
+ || strcmp (output_item_get_label (dst), output_item_get_label (src))
+ || !nullable_font_style_equal (dc->font_style, sc->font_style)
+ || (dc->font_style && dc->font_style->markup)
+ || sc->type != PIVOT_VALUE_TEXT
+ || dc->type != PIVOT_VALUE_TEXT)
+ return false;
+ else
+ {
+ /* Calculate new text. */
+ char *new_text = xasprintf ("%s\n%s", dc->text.local, sc->text.local);
+
+ /* Free the old text. */
+ free (dc->text.local);
+ if (dc->text.c != dc->text.local)
+ free (dc->text.c);
+ if (dc->text.id != dc->text.local && dc->text.id != dc->text.c)
+ free (dc->text.id);
+
+ /* Put in new text. */
+ dc->text.local = new_text;
+ dc->text.c = new_text;
+ dc->text.id = new_text;
+
+ return true;
+ }
+}
+
+static const struct pivot_table_look *
+text_item_table_look (void)
+{
+ static struct pivot_table_look *look;
+ if (!look)
+ {
+ look = pivot_table_look_new_builtin_default ();
+
+ for (int a = 0; a < PIVOT_N_AREAS; a++)
+ memset (look->areas[a].cell_style.margin, 0,
+ sizeof look->areas[a].cell_style.margin);
+ for (int b = 0; b < PIVOT_N_BORDERS; b++)
+ look->borders[b].stroke = TABLE_STROKE_NONE;
+ }
+ return look;
+}
+
+struct output_item *
+text_item_to_table_item (struct output_item *text_item)
+{
+ assert (text_item->type == OUTPUT_ITEM_TEXT);
+
+ /* Create a new table whose contents come from TEXT_ITEM. */
+ struct pivot_table *table = pivot_table_create__ (NULL, "Text");
+ pivot_table_set_look (table, text_item_table_look ());
+
+ struct pivot_dimension *d = pivot_dimension_create (
+ table, PIVOT_AXIS_ROW, N_("Text"));
+ d->hide_all_labels = true;
+ pivot_category_create_leaf (d->root, pivot_value_new_text ("null"));
+
+ pivot_table_put1 (table, 0, pivot_value_clone (text_item->text.content));
+
+ /* Free TEXT_ITEM. */
+ output_item_unref (text_item);
+
+ /* Return a new output item. */
+ return table_item_create (table);
+}
+
+const char *
+text_item_subtype_to_string (enum text_item_subtype subtype)
+{
+ switch (subtype)
+ {
+ case TEXT_ITEM_PAGE_TITLE:
+ return _("Page Title");
+
+ case TEXT_ITEM_TITLE:
+ return _("Title");
+
+ case TEXT_ITEM_SYNTAX:
+ case TEXT_ITEM_LOG:
+ return _("Log");
+
+ default:
+ return _("Text");
+ }
+}
+
/* Output items.
- An output item is a self-contained chunk of output. Several kinds of output
- items exist. See *-item.h for details.
+ An output item is a self-contained chunk of output.
*/
+#include <cairo.h>
#include <stdbool.h>
#include "libpspp/cast.h"
+enum output_item_type
+ {
+ OUTPUT_ITEM_CHART,
+ OUTPUT_ITEM_GROUP_OPEN,
+ OUTPUT_ITEM_GROUP_CLOSE,
+ OUTPUT_ITEM_IMAGE,
+ OUTPUT_ITEM_MESSAGE,
+ OUTPUT_ITEM_PAGE_BREAK,
+ OUTPUT_ITEM_PAGE_SETUP,
+ OUTPUT_ITEM_TABLE,
+ OUTPUT_ITEM_TEXT,
+ };
+
/* A single output item. */
struct output_item
{
- const struct output_item_class *class;
-
/* Reference count. An output item may be shared between multiple owners,
indicated by a reference count greater than 1. When this is the case,
the output item must not be modified. */
which may be NULL if unknown or if a command did not produce this
output. */
char *command_name;
+
+ enum output_item_type type;
+ union
+ {
+ struct chart *chart;
+
+ cairo_surface_t *image;
+
+ struct msg *message;
+
+ struct page_setup *page_setup;
+
+ struct pivot_table *table;
+
+ struct
+ {
+ enum text_item_subtype
+ {
+ TEXT_ITEM_PAGE_TITLE, /* TITLE and SUBTITLE commands. */
+ TEXT_ITEM_TITLE, /* Title. */
+ TEXT_ITEM_SYNTAX, /* Syntax printback logging. */
+ TEXT_ITEM_LOG, /* Other logging. */
+ }
+ subtype;
+ struct pivot_value *content;
+ }
+ text;
+ };
+
+ char *cached_label;
};
struct output_item *output_item_ref (const struct output_item *);
void output_item_unref (struct output_item *);
bool output_item_is_shared (const struct output_item *);
+struct output_item *output_item_unshare (struct output_item *);
+
+void output_item_submit (struct output_item *);
const char *output_item_get_label (const struct output_item *);
void output_item_set_label (struct output_item *, const char *);
void output_item_set_label_nocopy (struct output_item *, char *);
+\f
+/* OUTPUT_ITEM_CHART. */
+struct output_item *chart_item_create (struct chart *);
+\f
+/* OUTPUT_ITEM_GROUP_OPEN. */
+struct output_item *group_open_item_create (const char *command_name,
+ const char *label);
+struct output_item *group_open_item_create_nocopy (char *command_name,
+ char *label);
+\f
+/* OUTPUT_ITEM_GROUP_CLOSE. */
+
+struct output_item *group_close_item_create (void);
+\f
+/* OUTPUT_ITEM_IMAGE. */
+
+struct output_item *image_item_create (cairo_surface_t *);
+\f
+/* OUTPUT_ITEM_MESSAGE. */
+
+struct output_item *message_item_create (const struct msg *);
+
+const struct msg *message_item_get_msg (const struct output_item *);
+
+struct output_item *message_item_to_text_item (struct output_item *);
+\f
+/* OUTPUT_ITEM_PAGE_BREAK. */
+
+struct output_item *page_break_item_create (void);
+\f
+/* OUTPUT_ITEM_PAGE_SETUP. */
+
+struct output_item *page_setup_item_create (const struct page_setup *);
+\f
+/* OUTPUT_ITEM_TABLE. */
+
+struct output_item *table_item_create (struct pivot_table *);
+\f
+/* OUTPUT_ITEM_TEXT. */
+
+struct output_item *text_item_create (enum text_item_subtype,
+ const char *text, const char *label);
+struct output_item *text_item_create_nocopy (enum text_item_subtype,
+ char *text, char *label);
+struct output_item *text_item_create_value (enum text_item_subtype,
+ struct pivot_value *value,
+ char *label);
+
+enum text_item_subtype text_item_get_subtype (const struct output_item *);
+char *text_item_get_plain_text (const struct output_item *);
+
+bool text_item_append (struct output_item *dst, const struct output_item *src);
+
+struct output_item *text_item_to_table_item (struct output_item *);
+
+const char *text_item_subtype_to_string (enum text_item_subtype);
#endif /* output/output-item.h */
+++ /dev/null
-/* PSPP - a program for statistical analysis.
- Copyright (C) 2020 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-#include <config.h>
-
-#include "output/page-break-item.h"
-
-#include <stdlib.h>
-
-#include "output/driver-provider.h"
-#include "output/output-item-provider.h"
-
-#include "gl/xalloc.h"
-
-#include "gettext.h"
-#define _(msgid) gettext (msgid)
-
-struct page_break_item *
-page_break_item_create (void)
-{
- struct page_break_item *item = xmalloc (sizeof *item);
- *item = (struct page_break_item) {
- .output_item = OUTPUT_ITEM_INITIALIZER (&page_break_item_class),
- };
- return item;
-}
-
-/* Submits ITEM to the configured output drivers, and transfers ownership to
- the output subsystem. */
-void
-page_break_item_submit (struct page_break_item *item)
-{
- output_submit (&item->output_item);
-}
-
-static const char *
-page_break_item_get_label (const struct output_item *output_item UNUSED)
-{
- return _("Page Break");
-}
-
-static void
-page_break_item_destroy (struct output_item *output_item)
-{
- free (to_page_break_item (output_item));
-}
-
-const struct output_item_class page_break_item_class =
- {
- page_break_item_get_label,
- page_break_item_destroy,
- };
+++ /dev/null
-/* PSPP - a program for statistical analysis.
- Copyright (C) 2020 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-#ifndef OUTPUT_PAGE_BREAK_ITEM_H
-#define OUTPUT_PAGE_BREAK_ITEM_H 1
-
-/* Page break items.
-
- This ejects the page (for output devices that have pages). */
-
-#include <stdbool.h>
-#include "output/output-item.h"
-
-/* A page break item. */
-struct page_break_item
- {
- struct output_item output_item;
- };
-
-struct page_break_item *page_break_item_create (void);
-\f
-/* This boilerplate for page_break_item, a subclass of output_item, was
- autogenerated by mk-class-boilerplate. */
-
-#include <assert.h>
-#include "libpspp/cast.h"
-
-extern const struct output_item_class page_break_item_class;
-
-/* Returns true if SUPER is a page_break_item, otherwise false. */
-static inline bool
-is_page_break_item (const struct output_item *super)
-{
- return super->class == &page_break_item_class;
-}
-
-/* Returns SUPER converted to page_break_item. SUPER must be a page_break_item, as
- reported by is_page_break_item. */
-static inline struct page_break_item *
-to_page_break_item (const struct output_item *super)
-{
- assert (is_page_break_item (super));
- return UP_CAST (super, struct page_break_item, output_item);
-}
-
-/* Returns INSTANCE converted to output_item. */
-static inline struct output_item *
-page_break_item_super (const struct page_break_item *instance)
-{
- return CONST_CAST (struct output_item *, &instance->output_item);
-}
-
-/* Increments INSTANCE's reference count and returns INSTANCE. */
-static inline struct page_break_item *
-page_break_item_ref (const struct page_break_item *instance)
-{
- return to_page_break_item (output_item_ref (&instance->output_item));
-}
-
-/* Decrements INSTANCE's reference count, then destroys INSTANCE if
- the reference count is now zero. */
-static inline void
-page_break_item_unref (struct page_break_item *instance)
-{
- output_item_unref (&instance->output_item);
-}
-
-/* Returns true if INSTANCE's reference count is greater than 1,
- false otherwise. */
-static inline bool
-page_break_item_is_shared (const struct page_break_item *instance)
-{
- return output_item_is_shared (&instance->output_item);
-}
-
-void page_break_item_submit (struct page_break_item *);
-\f
-#endif /* output/page-break-item.h */
+++ /dev/null
-/* PSPP - a program for statistical analysis.
- Copyright (C) 2018 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-#include <config.h>
-
-#include "output/page-setup-item.h"
-
-#include <stdlib.h>
-
-#include "output/driver-provider.h"
-#include "output/output-item-provider.h"
-
-#include "gl/xalloc.h"
-
-bool
-page_paragraph_equals (const struct page_paragraph *a,
- const struct page_paragraph *b)
-{
- return (!a || !b ? a == b
- : !a->markup || !b->markup ? a->markup == b->markup
- : !strcmp (a->markup, b->markup) && a->halign == b->halign);
-}
-
-void
-page_heading_copy (struct page_heading *dst, const struct page_heading *src)
-{
- dst->n = src->n;
- dst->paragraphs = xmalloc (dst->n * sizeof *dst->paragraphs);
- for (size_t i = 0; i < dst->n; i++)
- {
- dst->paragraphs[i].markup = xstrdup (src->paragraphs[i].markup);
- dst->paragraphs[i].halign = src->paragraphs[i].halign;
- }
-}
-
-void
-page_heading_uninit (struct page_heading *ph)
-{
- if (!ph)
- return;
-
- for (size_t i = 0; i < ph->n; i++)
- free (ph->paragraphs[i].markup);
- free (ph->paragraphs);
-}
-
-bool
-page_heading_equals (const struct page_heading *a,
- const struct page_heading *b)
-{
- if (!a || !b)
- return a == b;
-
- if (a->n != b->n)
- return false;
-
- for (size_t i = 0; i < a->n; i++)
- if (!page_paragraph_equals (&a->paragraphs[i], &b->paragraphs[i]))
- return false;
-
- return true;
-}
-
-struct page_setup *
-page_setup_clone (const struct page_setup *old)
-{
- struct page_setup *new = xmalloc (sizeof *new);
- *new = *old;
- for (int i = 0; i < 2; i++)
- page_heading_copy (&new->headings[i], &old->headings[i]);
- if (new->file_name)
- new->file_name = xstrdup (new->file_name);
- return new;
-}
-
-void
-page_setup_destroy (struct page_setup *ps)
-{
- if (ps)
- {
- for (int i = 0; i < 2; i++)
- page_heading_uninit (&ps->headings[i]);
- free (ps->file_name);
- free (ps);
- }
-}
-\f
-struct page_setup_item *
-page_setup_item_create (const struct page_setup *ps)
-{
- struct page_setup_item *item = xmalloc (sizeof *item);
- *item = (struct page_setup_item) {
- .output_item = OUTPUT_ITEM_INITIALIZER (&page_setup_item_class),
- .page_setup = page_setup_clone (ps),
- };
- return item;
-}
-
-/* Submits ITEM to the configured output drivers, and transfers ownership to
- the output subsystem. */
-void
-page_setup_item_submit (struct page_setup_item *item)
-{
- output_submit (&item->output_item);
-}
-
-static const char *
-page_setup_item_get_label (const struct output_item *output_item UNUSED)
-{
- /* Not marked for translation: user should never see it. */
- return "Page Setup";
-}
-
-static void
-page_setup_item_destroy (struct output_item *output_item)
-{
- struct page_setup_item *item = to_page_setup_item (output_item);
- page_setup_destroy (item->page_setup);
- free (item);
-}
-
-const struct output_item_class page_setup_item_class =
- {
- page_setup_item_get_label,
- page_setup_item_destroy,
- };
+++ /dev/null
-/* PSPP - a program for statistical analysis.
- Copyright (C) 2009, 2010, 2011, 2018 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-#ifndef OUTPUT_PAGE_SETUP_ITEM_H
-#define OUTPUT_PAGE_SETUP_ITEM_H 1
-
-/* Page setup items.
-
- A page setup item configures the paper size, margins, header and footer,
- and other attributes used for printing. */
-
-#include <stdbool.h>
-#include "output/output-item.h"
-#include "table.h"
-
-enum page_orientation
- {
- PAGE_PORTRAIT,
- PAGE_LANDSCAPE
- };
-
-enum page_chart_size
- {
- PAGE_CHART_AS_IS,
- PAGE_CHART_FULL_HEIGHT,
- PAGE_CHART_HALF_HEIGHT,
- PAGE_CHART_QUARTER_HEIGHT,
- };
-
-struct page_paragraph
- {
- char *markup;
- enum table_halign halign;
- };
-
-bool page_paragraph_equals (const struct page_paragraph *,
- const struct page_paragraph *);
-
-struct page_heading
- {
- struct page_paragraph *paragraphs;
- size_t n;
- };
-
-void page_heading_copy (struct page_heading *, const struct page_heading *);
-void page_heading_uninit (struct page_heading *);
-bool page_heading_equals (const struct page_heading *,
- const struct page_heading *);
-
-struct page_setup
- {
- int initial_page_number;
- double paper[TABLE_N_AXES]; /* Paper size in inches. */
- double margins[TABLE_N_AXES][2]; /* In inches. */
- enum page_orientation orientation;
- double object_spacing; /* Space between objects, in inches. */
- enum page_chart_size chart_size;
- struct page_heading headings[2]; /* Header and footer. */
- char *file_name;
- };
-
-#define PAGE_SETUP_INITIALIZER \
- { \
- .initial_page_number = 1, \
- .paper = { [TABLE_HORZ] = 8.5, [TABLE_VERT] = 11.0 }, \
- .margins = { { 0.5, 0.5 }, { 0.5, 0.5 } }, \
- .orientation = PAGE_PORTRAIT, \
- .object_spacing = 12.0 / 72.0, \
- .chart_size = PAGE_CHART_AS_IS, \
- }
-
-struct page_setup *page_setup_clone (const struct page_setup *);
-void page_setup_destroy (struct page_setup *);
-
-/* A page setup item. */
-struct page_setup_item
- {
- struct output_item output_item;
- struct page_setup *page_setup;
- };
-
-struct page_setup_item *page_setup_item_create (const struct page_setup *);
-\f
-/* This boilerplate for page_setup_item, a subclass of output_item, was
- autogenerated by mk-class-boilerplate. */
-
-#include <assert.h>
-#include "libpspp/cast.h"
-
-extern const struct output_item_class page_setup_item_class;
-
-/* Returns true if SUPER is a page_setup_item, otherwise false. */
-static inline bool
-is_page_setup_item (const struct output_item *super)
-{
- return super->class == &page_setup_item_class;
-}
-
-/* Returns SUPER converted to page_setup_item. SUPER must be a page_setup_item, as
- reported by is_page_setup_item. */
-static inline struct page_setup_item *
-to_page_setup_item (const struct output_item *super)
-{
- assert (is_page_setup_item (super));
- return UP_CAST (super, struct page_setup_item, output_item);
-}
-
-/* Returns INSTANCE converted to output_item. */
-static inline struct output_item *
-page_setup_item_super (const struct page_setup_item *instance)
-{
- return CONST_CAST (struct output_item *, &instance->output_item);
-}
-
-/* Increments INSTANCE's reference count and returns INSTANCE. */
-static inline struct page_setup_item *
-page_setup_item_ref (const struct page_setup_item *instance)
-{
- return to_page_setup_item (output_item_ref (&instance->output_item));
-}
-
-/* Decrements INSTANCE's reference count, then destroys INSTANCE if
- the reference count is now zero. */
-static inline void
-page_setup_item_unref (struct page_setup_item *instance)
-{
- output_item_unref (&instance->output_item);
-}
-
-/* Returns true if INSTANCE's reference count is greater than 1,
- false otherwise. */
-static inline bool
-page_setup_item_is_shared (const struct page_setup_item *instance)
-{
- return output_item_is_shared (&instance->output_item);
-}
-
-void page_setup_item_submit (struct page_setup_item *);
-\f
-#endif /* output/page-setup-item.h */
--- /dev/null
+/* PSPP - a program for statistical analysis.
+ Copyright (C) 2018 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#include <config.h>
+
+#include "output/page-setup.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "gl/xalloc.h"
+
+bool
+page_paragraph_equals (const struct page_paragraph *a,
+ const struct page_paragraph *b)
+{
+ return (!a || !b ? a == b
+ : !a->markup || !b->markup ? a->markup == b->markup
+ : !strcmp (a->markup, b->markup) && a->halign == b->halign);
+}
+
+void
+page_heading_copy (struct page_heading *dst, const struct page_heading *src)
+{
+ dst->n = src->n;
+ dst->paragraphs = xmalloc (dst->n * sizeof *dst->paragraphs);
+ for (size_t i = 0; i < dst->n; i++)
+ {
+ dst->paragraphs[i].markup = xstrdup (src->paragraphs[i].markup);
+ dst->paragraphs[i].halign = src->paragraphs[i].halign;
+ }
+}
+
+void
+page_heading_uninit (struct page_heading *ph)
+{
+ if (!ph)
+ return;
+
+ for (size_t i = 0; i < ph->n; i++)
+ free (ph->paragraphs[i].markup);
+ free (ph->paragraphs);
+}
+
+bool
+page_heading_equals (const struct page_heading *a,
+ const struct page_heading *b)
+{
+ if (!a || !b)
+ return a == b;
+
+ if (a->n != b->n)
+ return false;
+
+ for (size_t i = 0; i < a->n; i++)
+ if (!page_paragraph_equals (&a->paragraphs[i], &b->paragraphs[i]))
+ return false;
+
+ return true;
+}
+
+struct page_setup *
+page_setup_clone (const struct page_setup *old)
+{
+ struct page_setup *new = xmalloc (sizeof *new);
+ *new = *old;
+ for (int i = 0; i < 2; i++)
+ page_heading_copy (&new->headings[i], &old->headings[i]);
+ if (new->file_name)
+ new->file_name = xstrdup (new->file_name);
+ return new;
+}
+
+void
+page_setup_destroy (struct page_setup *ps)
+{
+ if (ps)
+ {
+ for (int i = 0; i < 2; i++)
+ page_heading_uninit (&ps->headings[i]);
+ free (ps->file_name);
+ free (ps);
+ }
+}
--- /dev/null
+/* PSPP - a program for statistical analysis.
+ Copyright (C) 2009, 2010, 2011, 2018 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#ifndef OUTPUT_PAGE_SETUP_H
+#define OUTPUT_PAGE_SETUP_H 1
+
+/* Page setup.
+
+ Configures the paper size, margins, header and footer, and other attributes
+ used for printing. */
+
+#include <stdbool.h>
+#include "table.h"
+
+enum page_orientation
+ {
+ PAGE_PORTRAIT,
+ PAGE_LANDSCAPE
+ };
+
+enum page_chart_size
+ {
+ PAGE_CHART_AS_IS,
+ PAGE_CHART_FULL_HEIGHT,
+ PAGE_CHART_HALF_HEIGHT,
+ PAGE_CHART_QUARTER_HEIGHT,
+ };
+
+struct page_paragraph
+ {
+ char *markup;
+ enum table_halign halign;
+ };
+
+bool page_paragraph_equals (const struct page_paragraph *,
+ const struct page_paragraph *);
+
+struct page_heading
+ {
+ struct page_paragraph *paragraphs;
+ size_t n;
+ };
+
+void page_heading_copy (struct page_heading *, const struct page_heading *);
+void page_heading_uninit (struct page_heading *);
+bool page_heading_equals (const struct page_heading *,
+ const struct page_heading *);
+
+struct page_setup
+ {
+ int initial_page_number;
+ double paper[TABLE_N_AXES]; /* Paper size in inches. */
+ double margins[TABLE_N_AXES][2]; /* In inches. */
+ enum page_orientation orientation;
+ double object_spacing; /* Space between objects, in inches. */
+ enum page_chart_size chart_size;
+ struct page_heading headings[2]; /* Header and footer. */
+ char *file_name;
+ };
+
+#define PAGE_SETUP_INITIALIZER \
+ { \
+ .initial_page_number = 1, \
+ .paper = { [TABLE_HORZ] = 8.5, [TABLE_VERT] = 11.0 }, \
+ .margins = { { 0.5, 0.5 }, { 0.5, 0.5 } }, \
+ .orientation = PAGE_PORTRAIT, \
+ .object_spacing = 12.0 / 72.0, \
+ .chart_size = PAGE_CHART_AS_IS, \
+ }
+
+struct page_setup *page_setup_clone (const struct page_setup *);
+void page_setup_destroy (struct page_setup *);
+
+#endif /* output/page-setup.h */
#include "data/settings.h"
#include "libpspp/assertion.h"
#include "libpspp/pool.h"
+#include "output/output-item.h"
#include "output/pivot-table.h"
-#include "output/table-item.h"
#include "output/table-provider.h"
#include "output/table.h"
-#include "output/text-item.h"
#include "gl/minmax.h"
#include "gl/xalloc.h"
void
pivot_table_submit (struct pivot_table *pt)
{
- table_item_submit (table_item_create (pt));
+ output_item_submit (table_item_create (pt));
}
#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"
render_break_init_empty (&p->y_break);
}
-/* Creates and returns a new render_pager for rendering TABLE_ITEM on the
- device with the given PARAMS. */
+/* 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 table_item *table_item,
+ const struct pivot_table *pt,
const size_t *layer_indexes)
{
- const struct pivot_table *pt = table_item->pt;
if (!layer_indexes)
layer_indexes = pt->current_layer;
double scale = 1.0;
if (body_width > params->size[H])
{
- if (table_item->pt
- && table_item->pt->look->shrink_to_fit[H]
- && params->ops->scale)
+ if (pt->look->shrink_to_fit[H] && params->ops->scale)
scale = params->size[H] / (double) body_width;
else
{
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 (table_item->pt
- && table_item->pt->look->shrink_to_fit[V]
- && params->ops->scale)
+ if (pt->look->shrink_to_fit[V] && params->ops->scale)
{
int total_height = 0;
for (size_t i = 0; i < p->n_pages; i++)
/* An iterator for breaking render_pages into smaller chunks. */
struct render_pager *render_pager_create (const struct render_params *,
- const struct table_item *,
+ const struct pivot_table *,
const size_t *layer_indexes);
void render_pager_destroy (struct render_pager *);
#include "data/file-handle-def.h"
#include "libpspp/cast.h"
#include "output/cairo-chart.h"
-#include "output/chart-item.h"
-#include "output/group-item.h"
-#include "output/image-item.h"
-#include "output/page-setup-item.h"
-#include "output/table-item.h"
-#include "output/text-item.h"
+#include "output/output-item.h"
#include "output/spv/spv-writer.h"
#include "gl/xalloc.h"
#include "output/pivot-table.h"
#include "output/spv/spv.h"
-#include "output/text-item.h"
+#include "output/output-item.h"
#include "gl/xalloc.h"
spv_text_submit (const struct spv_item *in)
{
enum spv_item_class class = spv_item_get_class (in);
- struct text_item *item = text_item_create_value (
+ struct output_item *item = text_item_create_value (
(class == SPV_CLASS_HEADINGS ? TEXT_ITEM_TITLE
: class == SPV_CLASS_PAGETITLE ? TEXT_ITEM_PAGE_TITLE
: TEXT_ITEM_LOG),
pivot_value_clone (spv_item_get_text (in)),
xstrdup_if_nonnull (in->label));
- text_item_submit (item);
+ output_item_submit (item);
}
#include "libpspp/version.h"
#include "libpspp/zip-writer.h"
#include "output/cairo-chart.h"
-#include "output/chart-item.h"
#include "output/driver.h"
-#include "output/group-item.h"
-#include "output/image-item.h"
-#include "output/page-break-item.h"
-#include "output/page-setup-item.h"
+#include "output/output-item.h"
+#include "output/page-setup.h"
#include "output/pivot-table.h"
-#include "output/table-item.h"
-#include "output/text-item.h"
#include "gl/xalloc.h"
#include "gl/xvasprintf.h"
}
static void
-spv_writer_put_text (struct spv_writer *w, const struct text_item *text)
+spv_writer_put_text (struct spv_writer *w, struct output_item *item)
{
bool initial_depth = w->heading_depth;
if (!initial_depth)
spv_writer_open_file (w);
- open_container (w, &text->output_item, "vtx:text");
- write_attr (w, "type", (text->type == TEXT_ITEM_TITLE ? "title"
- : text->type == TEXT_ITEM_PAGE_TITLE ? "page-title"
- : "log"));
+ open_container (w, item, "vtx:text");
+ write_attr (w, "type",
+ (item->text.subtype == TEXT_ITEM_TITLE ? "title"
+ : item->text.subtype == TEXT_ITEM_PAGE_TITLE ? "page-title"
+ : "log"));
start_elem (w, "html");
- char *s = text_item_get_plain_text (text);
+ char *s = text_item_get_plain_text (item);
write_text (w, s);
free (s);
end_elem (w);
if (!initial_depth)
spv_writer_close_file (w, "");
+
+ output_item_unref (item);
}
static cairo_status_t
}
static void
-spv_writer_put_table (struct spv_writer *w, const struct table_item *item)
+spv_writer_put_table (struct spv_writer *w, const struct output_item *item)
{
int table_id = ++w->n_tables;
if (!initial_depth)
spv_writer_open_file (w);
- open_container (w, &item->output_item, "vtb:table");
+ open_container (w, item, "vtb:table");
write_attr (w, "type", "table"); /* XXX */
write_attr_format (w, "tableId", "%d", table_id);
- char *subtype = (item->pt->subtype
- ? pivot_value_to_string (item->pt->subtype, item->pt)
+ char *subtype = (item->table->subtype
+ ? pivot_value_to_string (item->table->subtype, item->table)
: xstrdup ("unknown"));
write_attr (w, "subType", subtype);
free (subtype);
spv_writer_close_file (w, "");
struct buf buf = { NULL, 0, 0 };
- put_light_table (&buf, table_id, item->pt);
+ put_light_table (&buf, table_id, item->table);
zip_writer_add_memory (w->zw, data_path, buf.data, buf.len);
free (buf.data);
void
spv_writer_write (struct spv_writer *w, const struct output_item *item)
{
- if (is_group_open_item (item))
- spv_writer_open_heading (w, item);
- else if (is_group_close_item (item))
- spv_writer_close_heading (w);
- else if (is_table_item (item))
- spv_writer_put_table (w, to_table_item (item));
- else if (is_chart_item (item))
- {
- cairo_surface_t *surface = xr_draw_image_chart (
- to_chart_item (item),
- &(struct cell_color) CELL_COLOR_BLACK,
- &(struct cell_color) CELL_COLOR_WHITE);
- if (cairo_surface_status (surface) == CAIRO_STATUS_SUCCESS)
- spv_writer_put_image (w, item, surface);
- cairo_surface_destroy (surface);
- }
- else if (is_image_item (item))
- spv_writer_put_image (w, item, to_image_item (item)->image);
- else if (is_text_item (item))
- spv_writer_put_text (w, to_text_item (item));
- else if (is_page_break_item (item))
- w->need_page_break = true;
- else if (is_page_setup_item (item))
+ switch (item->type)
{
+ case OUTPUT_ITEM_CHART:
+ {
+ cairo_surface_t *surface = xr_draw_image_chart (
+ item->chart,
+ &(struct cell_color) CELL_COLOR_BLACK,
+ &(struct cell_color) CELL_COLOR_WHITE);
+ if (cairo_surface_status (surface) == CAIRO_STATUS_SUCCESS)
+ spv_writer_put_image (w, item, surface);
+ cairo_surface_destroy (surface);
+ }
+ break;
+
+ case OUTPUT_ITEM_GROUP_OPEN:
+ spv_writer_open_heading (w, item);
+ break;
+
+ case OUTPUT_ITEM_GROUP_CLOSE:
+ spv_writer_close_heading (w);
+ break;
+
+ case OUTPUT_ITEM_IMAGE:
+ spv_writer_put_image (w, item, item->image);
+ break;
+
+ case OUTPUT_ITEM_MESSAGE:
+ spv_writer_put_text (
+ w, message_item_to_text_item (output_item_ref (item)));
+ break;
+
+ case OUTPUT_ITEM_PAGE_BREAK:
+ w->need_page_break = true;
+ break;
+
+ case OUTPUT_ITEM_PAGE_SETUP:
page_setup_destroy (w->page_setup);
- w->page_setup = page_setup_clone (to_page_setup_item (item)->page_setup);
+ w->page_setup = page_setup_clone (item->page_setup);
+ break;
+
+ case OUTPUT_ITEM_TABLE:
+ spv_writer_put_table (w, item);
+ break;
+
+ case OUTPUT_ITEM_TEXT:
+ spv_writer_put_text (w, output_item_ref (item));
+ break;
}
}
#include "libpspp/message.h"
#include "libpspp/str.h"
#include "libpspp/zip-reader.h"
-#include "output/page-setup-item.h"
+#include "output/page-setup.h"
#include "output/pivot-table.h"
#include "output/spv/detail-xml-parser.h"
#include "output/spv/light-binary-parser.h"
+++ /dev/null
-/* PSPP - a program for statistical analysis.
- Copyright (C) 2009, 2011, 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-#include <config.h>
-
-#include "output/table-provider.h"
-
-#include <assert.h>
-
-#include "libpspp/assertion.h"
-#include "libpspp/cast.h"
-#include "output/driver.h"
-#include "output/output-item-provider.h"
-#include "output/pivot-table.h"
-#include "output/table-item.h"
-#include "output/table-provider.h"
-
-#include "gl/xalloc.h"
-
-#include "gettext.h"
-#define _(msgid) gettext (msgid)
-
-/* Initializes ITEM as a table item for rendering PT. Takes ownership of
- PT. */
-struct table_item *
-table_item_create (struct pivot_table *pt)
-{
- pivot_table_assign_label_depth (pt);
-
- struct table_item *item = xmalloc (sizeof *item);
- *item = (struct table_item) {
- .output_item = OUTPUT_ITEM_INITIALIZER (&table_item_class),
- .output_item.command_name = xstrdup_if_nonnull (pt->command_c),
- .pt = pt,
- };
- return item;
-}
-
-/* Submits TABLE_ITEM to the configured output drivers, and transfers ownership
- to the output subsystem. */
-void
-table_item_submit (struct table_item *table_item)
-{
- output_submit (&table_item->output_item);
-}
-\f
-static const char *
-table_item_get_label (const struct output_item *output_item)
-{
- struct table_item *item = to_table_item (output_item);
-
- if (!item->cached_label)
- {
- if (!item->pt->title)
- return _("Table");
-
- item->cached_label = pivot_value_to_string (item->pt->title, item->pt);
- }
- return item->cached_label;
-}
-
-static void
-table_item_destroy (struct output_item *output_item)
-{
- struct table_item *item = to_table_item (output_item);
- pivot_table_unref (item->pt);
- free (item->cached_label);
- free (item);
-}
-
-const struct output_item_class table_item_class =
- {
- table_item_get_label,
- table_item_destroy,
- };
+++ /dev/null
-/* PSPP - a program for statistical analysis.
- Copyright (C) 2009, 2011, 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-#ifndef OUTPUT_TABLE_ITEM_H
-#define OUTPUT_TABLE_ITEM_H 1
-
-/* Table items.
-
- A table item is a subclass of an output item (see output-item.h) that
- contains a table (see table.h) and some formatting properties. Currently
- the formatting properties are an optional title (a brief description
- typically displayed above the table) and an optional caption (a more verbose
- description typically displayed below the table). */
-
-#include "libpspp/compiler.h"
-#include "output/output-item.h"
-#include "output/table.h"
-
-/* A table item.
-
- The members of struct table_item should not be accessed directly. Use one
- of the accessor functions defined below. */
-struct table_item
- {
- struct output_item output_item; /* Superclass. */
- struct pivot_table *pt; /* The table to be rendered. */
-
- char *cached_label;
- };
-
-struct table_item *table_item_create (struct pivot_table *);
-\f
-/* This boilerplate for table_item, a subclass of output_item, was
- autogenerated by mk-class-boilerplate. */
-
-#include <assert.h>
-#include "libpspp/cast.h"
-
-extern const struct output_item_class table_item_class;
-
-/* Returns true if SUPER is a table_item, otherwise false. */
-static inline bool
-is_table_item (const struct output_item *super)
-{
- return super->class == &table_item_class;
-}
-
-/* Returns SUPER converted to table_item. SUPER must be a table_item, as
- reported by is_table_item. */
-static inline struct table_item *
-to_table_item (const struct output_item *super)
-{
- assert (is_table_item (super));
- return UP_CAST (super, struct table_item, output_item);
-}
-
-/* Returns INSTANCE converted to output_item. */
-static inline struct output_item *
-table_item_super (const struct table_item *instance)
-{
- return CONST_CAST (struct output_item *, &instance->output_item);
-}
-
-/* Increments INSTANCE's reference count and returns INSTANCE. */
-static inline struct table_item *
-table_item_ref (const struct table_item *instance)
-{
- return to_table_item (output_item_ref (&instance->output_item));
-}
-
-/* Decrements INSTANCE's reference count, then destroys INSTANCE if
- the reference count is now zero. */
-static inline void
-table_item_unref (struct table_item *instance)
-{
- output_item_unref (&instance->output_item);
-}
-
-/* Returns true if INSTANCE's reference count is greater than 1,
- false otherwise. */
-static inline bool
-table_item_is_shared (const struct table_item *instance)
-{
- return output_item_is_shared (&instance->output_item);
-}
-
-void table_item_submit (struct table_item *);
-
-#endif /* output/table-item.h */
#include "libpspp/compiler.h"
#include "libpspp/pool.h"
#include "libpspp/str.h"
+#include "output/output-item.h"
#include "output/pivot-table.h"
-#include "output/table-item.h"
#include "output/table.h"
-#include "output/text-item.h"
#include "gl/xalloc.h"
broken across more than one page, those rows or columns are repeated on each
page.
- A table is not itself an output_item, and thus a table cannot by itself be
- used for output, but they can be embedded inside struct table_item (see
- table-item.h) for that purpose. */
+ Some drivers use tables as an implementation detail of rendering pivot
+ tables.
+*/
#include <stdbool.h>
#include <stdint.h>
#include "libpspp/temp-file.h"
#include "libpspp/version.h"
#include "output/cairo-chart.h"
-#include "output/chart-item.h"
#include "output/driver-provider.h"
-#include "output/image-item.h"
-#include "output/message-item.h"
#include "output/options.h"
-#include "output/output-item-provider.h"
+#include "output/output-item.h"
#include "output/pivot-output.h"
#include "output/pivot-table.h"
#include "output/table-provider.h"
-#include "output/table-item.h"
-#include "output/text-item.h"
#include "output/tex-rendering.h"
#include "output/tex-parsing.h"
static const struct output_driver_class tex_driver_class;
-static void tex_output_table (struct tex_driver *, const struct table_item *);
+static void tex_output_table (struct tex_driver *, const struct pivot_table *);
static struct tex_driver *
tex_driver_cast (struct output_driver *driver)
}
static void
-tex_submit (struct output_driver *driver,
- const struct output_item *output_item)
+tex_submit (struct output_driver *driver, const struct output_item *item)
{
struct tex_driver *tex = tex_driver_cast (driver);
- if (is_table_item (output_item))
+ switch (item->type)
{
- struct table_item *table_item = to_table_item (output_item);
- tex_output_table (tex, table_item);
- }
- else if (is_image_item (output_item) && tex->chart_file_name != NULL)
- {
- struct image_item *image_item = to_image_item (output_item);
- char *file_name = xr_write_png_image (
- image_item->image, tex->chart_file_name, tex->chart_cnt++);
- if (file_name != NULL)
- {
- shipout (&tex->token_list, "\\includegraphics{%s}\n", file_name);
- tex->require_graphics = true;
- free (file_name);
- }
- }
- else if (is_chart_item (output_item) && tex->chart_file_name != NULL)
- {
- struct chart_item *chart_item = to_chart_item (output_item);
- char *file_name = xr_draw_png_chart (chart_item, tex->chart_file_name,
- tex->chart_cnt++,
- &tex->fg,
- &tex->bg);
- if (file_name != NULL)
+ case OUTPUT_ITEM_CHART:
+ if (tex->chart_file_name != NULL)
{
- //const char *title = chart_item_get_title (chart_item);
- // printf ("The chart title is %s\n", title);
-
- shipout (&tex->token_list, "\\includegraphics{%s}\n", file_name);
- tex->require_graphics = true;
- free (file_name);
- }
- }
- else if (is_text_item (output_item))
- {
- struct text_item *text_item = to_text_item (output_item);
- char *s = text_item_get_plain_text (text_item);
+ char *file_name = xr_draw_png_chart (item->chart,
+ tex->chart_file_name,
+ tex->chart_cnt++,
+ &tex->fg, &tex->bg);
+ if (file_name != NULL)
+ {
+ //const char *title = chart_item_get_title (chart_item);
+ // printf ("The chart title is %s\n", title);
- switch (text_item_get_type (text_item))
- {
- case TEXT_ITEM_PAGE_TITLE:
- shipout (&tex->token_list, "\\headline={\\bf ");
- tex_escape_string (tex, s, false);
- shipout (&tex->token_list, "\\hfil}\n");
- break;
-
- case TEXT_ITEM_LOG:
- shipout (&tex->token_list, "{\\tt ");
- tex_escape_string (tex, s, false);
- shipout (&tex->token_list, "}\\par\n\n");
- break;
-
- case TEXT_ITEM_SYNTAX:
- /* So far as I'm aware, this can never happen. */
- default:
- printf ("Unhandled type %d\n", text_item_get_type (text_item));
- break;
+ shipout (&tex->token_list, "\\includegraphics{%s}\n", file_name);
+ tex->require_graphics = true;
+ free (file_name);
+ }
}
- free (s);
- }
- else if (is_message_item (output_item))
- {
- const struct message_item *message_item = to_message_item (output_item);
- char *s = msg_to_string (message_item_get_msg (message_item));
- tex_escape_string (tex, s, false);
- shipout (&tex->token_list, "\\par\n");
- free (s);
+ break;
+
+ case OUTPUT_ITEM_GROUP_OPEN:
+ break;
+
+ case OUTPUT_ITEM_GROUP_CLOSE:
+ break;
+
+ case OUTPUT_ITEM_IMAGE:
+ {
+ char *file_name = xr_write_png_image (
+ item->image, tex->chart_file_name, tex->chart_cnt++);
+ if (file_name != NULL)
+ {
+ shipout (&tex->token_list, "\\includegraphics{%s}\n", file_name);
+ tex->require_graphics = true;
+ free (file_name);
+ }
+ }
+ break;
+
+ case OUTPUT_ITEM_MESSAGE:
+ {
+ char *s = msg_to_string (item->message);
+ tex_escape_string (tex, s, false);
+ shipout (&tex->token_list, "\\par\n");
+ free (s);
+ }
+ break;
+
+ case OUTPUT_ITEM_PAGE_BREAK:
+ break;
+
+ case OUTPUT_ITEM_PAGE_SETUP:
+ break;
+
+ case OUTPUT_ITEM_TABLE:
+ tex_output_table (tex, item->table);
+ break;
+
+ case OUTPUT_ITEM_TEXT:
+ {
+ char *s = text_item_get_plain_text (item);
+
+ switch (item->text.subtype)
+ {
+ case TEXT_ITEM_PAGE_TITLE:
+ shipout (&tex->token_list, "\\headline={\\bf ");
+ tex_escape_string (tex, s, false);
+ shipout (&tex->token_list, "\\hfil}\n");
+ break;
+
+ case TEXT_ITEM_LOG:
+ shipout (&tex->token_list, "{\\tt ");
+ tex_escape_string (tex, s, false);
+ shipout (&tex->token_list, "}\\par\n\n");
+ break;
+
+ case TEXT_ITEM_SYNTAX:
+ /* So far as I'm aware, this can never happen. */
+ default:
+ printf ("Unhandled type %d\n", item->text.subtype);
+ break;
+ }
+ free (s);
+ }
+ break;
}
}
}
static void
-tex_output_table (struct tex_driver *tex, const struct table_item *item)
+tex_output_table (struct tex_driver *tex, const struct pivot_table *pt)
{
size_t *layer_indexes;
- PIVOT_OUTPUT_FOR_EACH_LAYER (layer_indexes, item->pt, true)
- tex_output_table_layer (tex, item->pt, layer_indexes);
+ PIVOT_OUTPUT_FOR_EACH_LAYER (layer_indexes, pt, true)
+ tex_output_table_layer (tex, pt, layer_indexes);
}
struct output_driver_factory tex_driver_factory =
+++ /dev/null
-/* PSPP - a program for statistical analysis.
- Copyright (C) 2009, 2010, 2011 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-#include <config.h>
-
-#include "output/text-item.h"
-
-#include <stdarg.h>
-#include <stdlib.h>
-
-#include "libpspp/cast.h"
-#include "libpspp/pool.h"
-#include "output/driver.h"
-#include "output/output-item-provider.h"
-#include "output/pivot-table.h"
-#include "output/table.h"
-#include "output/table-item.h"
-#include "output/table-provider.h"
-
-#include "gl/xalloc.h"
-#include "gl/xvasprintf.h"
-
-#include "gettext.h"
-#define _(msgid) gettext (msgid)
-#define N_(msgid) msgid
-
-const char *
-text_item_type_to_string (enum text_item_type type)
-{
- switch (type)
- {
- case TEXT_ITEM_PAGE_TITLE:
- return _("Page Title");
-
- case TEXT_ITEM_TITLE:
- return _("Title");
-
- case TEXT_ITEM_SYNTAX:
- case TEXT_ITEM_LOG:
- return _("Log");
-
- default:
- return _("Text");
- }
-}
-
-/* Creates and returns a new text item containing TEXT and the specified TYPE
- and LABEL. The new text item takes ownership of TEXT and LABEL. If LABEL
- is NULL, uses the default label for TYPE. */
-struct text_item *
-text_item_create_nocopy (enum text_item_type type, char *text, char *label)
-{
- return text_item_create_value (type, pivot_value_new_user_text_nocopy (text),
- label);
-}
-
-/* Creates and returns a new text item containing a copy of TEXT and the
- specified TYPE and LABEL. The caller retains ownership of TEXT and LABEL.
- If LABEL is null, uses a default label for TYPE. */
-struct text_item *
-text_item_create (enum text_item_type type, const char *text,
- const char *label)
-{
- return text_item_create_nocopy (type, xstrdup (text),
- xstrdup_if_nonnull (label));
-}
-
-/* Creates and returns a new text item containing VALUE, TYPE, and LABEL.
- Takes ownership of VALUE and LABEL. If LABEL is null, uses a default label
- for TYPE. */
-struct text_item *
-text_item_create_value (enum text_item_type type, struct pivot_value *value,
- char *label)
-{
- if (type == TEXT_ITEM_SYNTAX || type == TEXT_ITEM_LOG)
- {
- if (!value->font_style)
- {
- value->font_style = xmalloc (sizeof *value->font_style);
- *value->font_style = (struct font_style) FONT_STYLE_INITIALIZER;
- }
-
- free (value->font_style->typeface);
- value->font_style->typeface = xstrdup ("Monospaced");
- }
-
- struct text_item *item = xzalloc (sizeof *item);
- *item = (struct text_item) {
- .output_item = OUTPUT_ITEM_INITIALIZER (&text_item_class),
- .output_item.command_name = xstrdup_if_nonnull (output_get_command_name ()),
- .output_item.label = label,
- .type = type,
- .text = value,
- };
- return item;
-}
-
-/* Returns ITEM's type. */
-enum text_item_type
-text_item_get_type (const struct text_item *item)
-{
- return item->type;
-}
-
-/* Returns ITEM's text, which the caller must eventually free. */
-char *
-text_item_get_plain_text (const struct text_item *item)
-{
- return pivot_value_to_string_defaults (item->text);
-}
-
-/* Submits ITEM to the configured output drivers, and transfers ownership to
- the output subsystem. */
-void
-text_item_submit (struct text_item *item)
-{
- output_submit (&item->output_item);
-}
-
-struct text_item *
-text_item_unshare (struct text_item *old)
-{
- assert (old->output_item.ref_cnt > 0);
- if (!text_item_is_shared (old))
- return old;
- text_item_unref (old);
-
- struct text_item *new = xmalloc (sizeof *new);
- *new = (struct text_item) {
- .output_item = OUTPUT_ITEM_CLONE_INITIALIZER (&old->output_item),
- .text = pivot_value_clone (old->text),
- .type = old->type,
- };
- return new;
-}
-
-static bool
-nullable_font_style_equal (const struct font_style *a,
- const struct font_style *b)
-{
- return a && b ? font_style_equal (a, b) : !a && !b;
-}
-
-/* Attempts to append the text in SRC to DST. If successful, returns true,
- otherwise false.
-
- Only TEXT_ITEM_SYNTAX and TEXT_ITEM_LOG items can be combined, and not with
- each other.
-
- DST must not be shared. */
-bool
-text_item_append (struct text_item *dst, const struct text_item *src)
-{
- assert (!text_item_is_shared (dst));
- if (dst->type != src->type
- || (dst->type != TEXT_ITEM_SYNTAX && dst->type != TEXT_ITEM_LOG)
- || strcmp (output_item_get_label (&dst->output_item),
- output_item_get_label (&src->output_item))
- || !nullable_font_style_equal (dst->text->font_style,
- src->text->font_style)
- || (dst->text->font_style && dst->text->font_style->markup)
- || src->text->type != PIVOT_VALUE_TEXT
- || dst->text->type != PIVOT_VALUE_TEXT)
- return false;
- else
- {
- char *new_text = xasprintf ("%s\n%s", dst->text->text.local,
- src->text->text.local);
-
- free (dst->text->text.local);
- if (dst->text->text.c != dst->text->text.local)
- free (dst->text->text.c);
- if (dst->text->text.id != dst->text->text.local
- && dst->text->text.id != dst->text->text.c)
- free (dst->text->text.id);
-
- dst->text->text.local = new_text;
- dst->text->text.c = new_text;
- dst->text->text.id = new_text;
-
- return true;
- }
-}
-
-static const struct pivot_table_look *
-text_item_table_look (void)
-{
- static struct pivot_table_look *look;
- if (!look)
- {
- look = pivot_table_look_new_builtin_default ();
-
- for (int a = 0; a < PIVOT_N_AREAS; a++)
- memset (look->areas[a].cell_style.margin, 0,
- sizeof look->areas[a].cell_style.margin);
- for (int b = 0; b < PIVOT_N_BORDERS; b++)
- look->borders[b].stroke = TABLE_STROKE_NONE;
- }
- return look;
-}
-
-struct table_item *
-text_item_to_table_item (struct text_item *text_item)
-{
- struct pivot_table *table = pivot_table_create__ (NULL, "Text");
- pivot_table_set_look (table, text_item_table_look ());
-
- struct pivot_dimension *d = pivot_dimension_create (
- table, PIVOT_AXIS_ROW, N_("Text"));
- d->hide_all_labels = true;
- pivot_category_create_leaf (d->root, pivot_value_new_text ("null"));
-
- pivot_table_put1 (table, 0, pivot_value_clone (text_item->text));
-
- text_item_unref (text_item);
-
- return table_item_create (table);
-}
-\f
-static const char *
-text_item_get_label (const struct output_item *output_item)
-{
- const struct text_item *item = to_text_item (output_item);
- return text_item_type_to_string (item->type);
-}
-
-static void
-text_item_destroy (struct output_item *output_item)
-{
- struct text_item *item = to_text_item (output_item);
- pivot_value_destroy (item->text);
- free (item);
-}
-
-const struct output_item_class text_item_class =
- {
- text_item_get_label,
- text_item_destroy,
- };
+++ /dev/null
-/* PSPP - a program for statistical analysis.
- Copyright (C) 2009, 2010, 2011 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>. */
-
-#ifndef OUTPUT_TEXT_ITEM_H
-#define OUTPUT_TEXT_ITEM_H 1
-
-/* Text items.
-
- A text item is a subclass of an output item (see
- output/output-item.h).
-
- A text item is just a text string. */
-
-#include <stdbool.h>
-#include "libpspp/compiler.h"
-#include "output/output-item.h"
-#include "output/table.h"
-
-enum text_item_type
- {
- TEXT_ITEM_PAGE_TITLE, /* TITLE and SUBTITLE commands. */
- TEXT_ITEM_TITLE, /* Title. */
- TEXT_ITEM_SYNTAX, /* Syntax printback logging. */
- TEXT_ITEM_LOG, /* Other logging. */
- };
-
-const char *text_item_type_to_string (enum text_item_type);
-
-/* A text item. */
-struct text_item
- {
- struct output_item output_item;
- enum text_item_type type;
- struct pivot_value *text;
- };
-
-struct text_item *text_item_create (enum text_item_type,
- const char *text, const char *label);
-struct text_item *text_item_create_nocopy (enum text_item_type,
- char *text, char *label);
-struct text_item *text_item_create_value (enum text_item_type,
- struct pivot_value *value,
- char *label);
-
-enum text_item_type text_item_get_type (const struct text_item *);
-char *text_item_get_plain_text (const struct text_item *);
-
-struct text_item *text_item_unshare (struct text_item *);
-bool text_item_append (struct text_item *dst, const struct text_item *src);
-
-struct table_item *text_item_to_table_item (struct text_item *);
-\f
-/* This boilerplate for text_item, a subclass of output_item, was
- autogenerated by mk-class-boilerplate. */
-
-#include <assert.h>
-#include "libpspp/cast.h"
-
-extern const struct output_item_class text_item_class;
-
-/* Returns true if SUPER is a text_item, otherwise false. */
-static inline bool
-is_text_item (const struct output_item *super)
-{
- return super->class == &text_item_class;
-}
-
-/* Returns SUPER converted to text_item. SUPER must be a text_item, as
- reported by is_text_item. */
-static inline struct text_item *
-to_text_item (const struct output_item *super)
-{
- assert (is_text_item (super));
- return UP_CAST (super, struct text_item, output_item);
-}
-
-/* Returns INSTANCE converted to output_item. */
-static inline struct output_item *
-text_item_super (const struct text_item *instance)
-{
- return CONST_CAST (struct output_item *, &instance->output_item);
-}
-
-/* Increments INSTANCE's reference count and returns INSTANCE. */
-static inline struct text_item *
-text_item_ref (const struct text_item *instance)
-{
- return to_text_item (output_item_ref (&instance->output_item));
-}
-
-/* Decrements INSTANCE's reference count, then destroys INSTANCE if
- the reference count is now zero. */
-static inline void
-text_item_unref (struct text_item *instance)
-{
- output_item_unref (&instance->output_item);
-}
-
-/* Returns true if INSTANCE's reference count is greater than 1,
- false otherwise. */
-static inline bool
-text_item_is_shared (const struct text_item *instance)
-{
- return output_item_is_shared (&instance->output_item);
-}
-
-void text_item_submit (struct text_item *);
-\f
-#endif /* output/text-item.h */
#include "output/cairo-pager.h"
#include "output/driver-provider.h"
#include "output/driver.h"
-#include "output/chart-item.h"
-#include "output/group-item.h"
-#include "output/message-item.h"
#include "output/output-item.h"
-#include "output/output-item-provider.h"
#include "output/pivot-table.h"
-#include "output/table-item.h"
-#include "output/text-item.h"
#include "gl/c-xvasprintf.h"
#include "gl/minmax.h"
if (view->y > 0)
view->y += view->object_spacing;
- if (is_group_open_item (item->item))
+ if (item->item->type == OUTPUT_ITEM_GROUP_OPEN)
continue;
r = xr_fsm_create_for_scrolling (item->item, view->style, cr);
gtk_layout_move (view->output, item->drawing_area, xpos, view->y);
}
- if (is_table_item (item->item))
- {
- const struct table_item *ti = to_table_item (item->item);
- gtk_widget_set_tooltip_text (item->drawing_area, ti->pt->notes);
- }
+ if (item->item->type == OUTPUT_ITEM_TABLE)
+ gtk_widget_set_tooltip_text (item->drawing_area,
+ item->item->table->notes);
{
gint minw;
GtkWidget *drawing_area;
int tw, th;
- if (is_group_close_item (item))
+ if (item->type == OUTPUT_ITEM_GROUP_CLOSE)
{
if (view->cur_group)
{
}
return;
}
- else if (is_text_item (item))
+ else if (item->type == OUTPUT_ITEM_TEXT)
{
- const struct text_item *text_item = to_text_item (item);
- char *text = text_item_get_plain_text (text_item);
+ char *text = text_item_get_plain_text (item);
bool text_is_empty = text[0] == '\0';
free (text);
if (text_is_empty)
view_item->drawing_area = NULL;
GdkWindow *win = gtk_widget_get_window (GTK_WIDGET (view->output));
- if (is_group_open_item (item))
+ if (item->type == OUTPUT_ITEM_GROUP_OPEN)
tw = th = 0;
else if (win)
{
else
gtk_tree_store_append (store, &iter, NULL);
- if (is_group_open_item (item))
+ if (item->type == OUTPUT_ITEM_GROUP_OPEN)
{
gtk_tree_path_free (view->cur_group);
view->cur_group = gtk_tree_model_get_path (GTK_TREE_MODEL (store),
{
GtkTargetList *tl = gtk_target_list_new (targets, G_N_ELEMENTS (targets));
g_return_val_if_fail (tl, NULL);
- if (is_table_item (item) ||
- is_chart_item (item))
+ if (item->type == OUTPUT_ITEM_TABLE || item->type == OUTPUT_ITEM_CHART)
gtk_target_list_add_image_targets (tl, SELECT_FMT_IMG, TRUE);
return tl;
}
{
struct psppire_output_view_driver *povd = psppire_output_view_driver_cast (this);
- if (is_table_item (item))
+ if (item->type == OUTPUT_ITEM_TABLE)
psppire_output_view_put (povd->view, item);
}
#include "libpspp/cast.h"
#include "libpspp/message.h"
#include "libpspp/string-map.h"
-#include "output/chart-item.h"
#include "output/driver-provider.h"
-#include "output/message-item.h"
#include "output/output-item.h"
-#include "output/table-item.h"
-#include "output/text-item.h"
#include "ui/gui/help-menu.h"
#include "ui/gui/builder-wrapper.h"
#include "ui/gui/psppire-output-view.h"
#include "data/file-handle-def.h"
#include "data/dataset.h"
#include "libpspp/version.h"
-#include "output/group-item.h"
-#include "output/image-item.h"
+#include "output/output-item.h"
#include "output/pivot-table.h"
#include "output/spv/spv.h"
#include "output/spv/spv-output.h"
break;
for (size_t i = common; i < old_path.n; i++)
- group_close_item_submit (group_close_item_create ());
+ output_item_submit (group_close_item_create ());
for (size_t i = common; i < new_path.n; i++)
- group_open_item_submit (group_open_item_create (
+ output_item_submit (group_open_item_create (
new_path.nodes[i]->command_id,
new_path.nodes[i]->label));
else if (items[i]->type == SPV_ITEM_IMAGE)
{
cairo_surface_t *image = spv_item_get_image (items[i]);
- image_item_submit (image_item_create (cairo_surface_reference (
- image)));
+ output_item_submit (image_item_create (cairo_surface_reference (
+ image)));
}
prev_heading = heading;
}
#include "output/driver.h"
#include "output/journal.h"
-#include "output/message-item.h"
+#include "output/output-item.h"
#include "output/spv/spv.h"
#include "ui/gui/dict-display.h"
}
m.command_name = output_get_uppercase_command_name ();
- message_item_submit (message_item_create (&m));
+ output_item_submit (message_item_create (&m));
free (m.command_name);
}
#include "libpspp/version.h"
#include "math/random.h"
#include "output/driver.h"
-#include "output/message-item.h"
+#include "output/output-item.h"
#include "ui/source-init-opts.h"
#include "ui/terminal/terminal-opts.h"
#include "ui/terminal/terminal-reader.h"
m.command_name = output_get_uppercase_command_name ();
- message_item_submit (message_item_create (&m));
+ output_item_submit (message_item_create (&m));
free (m.command_name);
}
#include "libpspp/string-map.h"
#include "output/ascii.h"
#include "output/driver.h"
+#include "output/output-item.h"
#include "output/table.h"
-#include "output/table-item.h"
#include "gl/error.h"
#include "gl/progname.h"
#include "libpspp/i18n.h"
#include "libpspp/string-map.h"
#include "output/driver.h"
-#include "output/message-item.h"
#include "output/options.h"
+#include "output/output-item.h"
#include "output/pivot-table.h"
-#include "output/table-item.h"
#include "gl/error.h"
#include "gl/progname.h"
m.command_name = output_get_uppercase_command_name ();
- message_item_submit (message_item_create (&m));
+ output_item_submit (message_item_create (&m));
free (m.command_name);
}
#include "libpspp/string-map.h"
#include "libpspp/string-set.h"
#include "output/driver.h"
-#include "output/group-item.h"
-#include "output/image-item.h"
-#include "output/page-setup-item.h"
+#include "output/output-item.h"
#include "output/pivot-table.h"
#include "output/spv/light-binary-parser.h"
#include "output/spv/spv-legacy-data.h"
#include "output/spv/spv-select.h"
#include "output/spv/spv-table-look.h"
#include "output/spv/spv.h"
-#include "output/table-item.h"
-#include "output/text-item.h"
#include "gl/c-ctype.h"
#include "gl/error.h"
char *s = (x && b
? xasprintf ("%s and %s:", x, b)
: xasprintf ("%s:", x ? x : b));
- text_item_submit (text_item_create_nocopy (TEXT_ITEM_TITLE, s,
- xstrdup ("Member Names")));
+ output_item_submit (text_item_create_nocopy (TEXT_ITEM_TITLE, s,
+ xstrdup ("Member Names")));
}
switch (spv_item_get_type (item))
break;
case SPV_ITEM_IMAGE:
- image_item_submit (image_item_create (cairo_surface_reference (
- spv_item_get_image (item))));
+ output_item_submit (image_item_create (cairo_surface_reference (
+ spv_item_get_image (item))));
break;
case SPV_ITEM_TREE:
break;
for (size_t i = common; i < old_path.n; i++)
- group_close_item_submit (group_close_item_create ());
+ output_item_submit (group_close_item_create ());
for (size_t i = common; i < new_path.n; i++)
- group_open_item_submit (group_open_item_create (
- new_path.nodes[i]->command_id,
- new_path.nodes[i]->label));
+ output_item_submit (group_open_item_create (
+ new_path.nodes[i]->command_id,
+ new_path.nodes[i]->label));
free_path (&old_path);
free_path (&new_path);
const struct page_setup *ps = spv_get_page_setup (spv);
if (ps)
- page_setup_item_submit (page_setup_item_create (ps));
+ output_item_submit (page_setup_item_create (ps));
struct spv_item **items;
size_t n_items;
projects / pspp / commitdiff