1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 1997-9, 2000, 2007, 2009, 2010 Free Software Foundation, Inc.
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include <data/file-name.h>
26 #include <data/settings.h>
27 #include <libpspp/assertion.h>
28 #include <libpspp/compiler.h>
29 #include <libpspp/start-date.h>
30 #include <libpspp/string-map.h>
31 #include <libpspp/version.h>
32 #include <output/cairo.h>
33 #include <output/chart-item-provider.h>
34 #include "output/options.h"
35 #include <output/tab.h>
36 #include <output/text-item.h>
37 #include <output/driver-provider.h>
38 #include <output/render.h>
39 #include <output/table-item.h>
46 #define _(msgid) gettext (msgid)
48 /* This file uses TABLE_HORZ and TABLE_VERT enough to warrant abbreviating. */
52 /* Line styles bit shifts. */
64 make_box_index (int left, int right, int top, int bottom)
66 return ((left << LNS_LEFT) | (right << LNS_RIGHT)
67 | (top << LNS_TOP) | (bottom << LNS_BOTTOM));
70 /* Character attributes. */
71 #define ATTR_EMPHASIS 0x100 /* Bold-face. */
72 #define ATTR_BOX 0x200 /* Line drawing character. */
77 unsigned short *chars; /* Characters and attributes. */
78 int n_chars; /* Length. */
79 int allocated_chars; /* Allocated "chars" elements. */
82 /* How to emphasize text. */
85 EMPH_BOLD, /* Overstrike for bold. */
86 EMPH_UNDERLINE, /* Overstrike for underlining. */
87 EMPH_NONE /* No emphasis. */
90 /* ASCII output driver. */
93 struct output_driver driver;
95 /* User parameters. */
96 bool append; /* Append if output file already exists? */
97 bool headers; /* Print headers at top of page? */
98 bool paginate; /* Insert formfeeds? */
99 bool squeeze_blank_lines; /* Squeeze multiple blank lines into one? */
100 enum emphasis_style emphasis; /* How to emphasize text. */
101 char *chart_file_name; /* Name of files used for charts. */
103 int width; /* Page width. */
104 int length; /* Page length minus margins and header. */
105 bool auto_width; /* Use viewwidth as page width? */
106 bool auto_length; /* Use viewlength as page width? */
108 int top_margin; /* Top margin in lines. */
109 int bottom_margin; /* Bottom margin in lines. */
111 char *box[LNS_COUNT]; /* Line & box drawing characters. */
112 char *init; /* Device initialization string. */
114 /* Internal state. */
117 char *file_name; /* Output file name. */
118 FILE *file; /* Output file. */
119 bool error; /* Output error? */
120 int page_number; /* Current page number. */
121 struct ascii_line *lines; /* Page content. */
122 int allocated_lines; /* Number of lines allocated. */
123 int chart_cnt; /* Number of charts so far. */
127 static const struct output_driver_class ascii_driver_class;
129 static void ascii_submit (struct output_driver *, const struct output_item *);
131 static int vertical_margins (const struct ascii_driver *);
133 static const char *get_default_box (int right, int bottom, int left, int top);
134 static bool update_page_size (struct ascii_driver *, bool issue_error);
135 static int parse_page_size (struct driver_option *);
137 static void ascii_close_page (struct ascii_driver *);
138 static bool ascii_open_page (struct ascii_driver *);
140 static void ascii_draw_line (void *, int bb[TABLE_N_AXES][2],
141 enum render_line_style styles[TABLE_N_AXES][2]);
142 static void ascii_measure_cell_width (void *, const struct table_cell *,
144 static int ascii_measure_cell_height (void *, const struct table_cell *,
146 static void ascii_draw_cell (void *, const struct table_cell *,
147 int bb[TABLE_N_AXES][2],
148 int clip[TABLE_N_AXES][2]);
150 static struct ascii_driver *
151 ascii_driver_cast (struct output_driver *driver)
153 assert (driver->class == &ascii_driver_class);
154 return UP_CAST (driver, struct ascii_driver, driver);
157 static struct driver_option *
158 opt (struct output_driver *d, struct string_map *options, const char *key,
159 const char *default_value)
161 return driver_option_get (d, options, key, default_value);
164 static struct output_driver *
165 ascii_create (const char *file_name, enum settings_output_devices device_type,
166 struct string_map *o)
168 struct output_driver *d;
169 struct ascii_driver *a;
171 int right, bottom, left, top;
173 a = xzalloc (sizeof *a);
175 output_driver_init (&a->driver, &ascii_driver_class, file_name, device_type);
176 a->append = parse_boolean (opt (d, o, "append", "false"));
177 a->headers = parse_boolean (opt (d, o, "headers", "false"));
178 a->paginate = parse_boolean (opt (d, o, "paginate", "false"));
179 a->squeeze_blank_lines = parse_boolean (opt (d, o, "squeeze", "true"));
180 a->emphasis = parse_enum (opt (d, o, "emphasis", "none"),
182 "underline", EMPH_UNDERLINE,
186 a->chart_file_name = parse_chart_file_name (opt (d, o, "charts", file_name));
188 a->top_margin = parse_int (opt (d, o, "top-margin", "0"), 0, INT_MAX);
189 a->bottom_margin = parse_int (opt (d, o, "bottom-margin", "0"), 0, INT_MAX);
191 a->width = parse_page_size (opt (d, o, "width", "79"));
192 paper_length = parse_page_size (opt (d, o, "length", "66"));
193 a->auto_width = a->width < 0;
194 a->auto_length = paper_length < 0;
195 a->length = paper_length - vertical_margins (a);
197 for (right = 0; right < 4; right++)
198 for (bottom = 0; bottom < 4; bottom++)
199 for (left = 0; left < 4; left++)
200 for (top = 0; top < 4; top++)
202 int indx = make_box_index (left, right, top, bottom);
203 const char *default_value;
206 sprintf (name, "box[%d%d%d%d]", right, bottom, left, top);
207 default_value = get_default_box (right, bottom, left, top);
208 a->box[indx] = parse_string (opt (d, o, name, default_value));
210 a->init = parse_string (opt (d, o, "init", ""));
212 a->title = xstrdup ("");
213 a->subtitle = xstrdup ("");
214 a->file_name = xstrdup (file_name);
219 a->allocated_lines = 0;
222 if (!update_page_size (a, true))
228 output_driver_destroy (d);
233 get_default_box (int right, int bottom, int left, int top)
235 switch ((top << 12) | (left << 8) | (bottom << 4) | (right << 0))
240 case 0x0100: case 0x0101: case 0x0001:
243 case 0x1000: case 0x1010: case 0x0010:
246 case 0x0300: case 0x0303: case 0x0003:
247 case 0x0200: case 0x0202: case 0x0002:
251 return left > 1 || top > 1 || right > 1 || bottom > 1 ? "#" : "+";
256 parse_page_size (struct driver_option *option)
258 int dim = atol (option->default_value);
260 if (option->value != NULL)
262 if (!strcmp (option->value, "auto"))
270 value = strtol (option->value, &tail, 0);
271 if (dim >= 1 && errno != ERANGE && *tail == '\0')
274 error (0, 0, _("%s: %s must be positive integer or `auto'"),
275 option->driver_name, option->name);
279 driver_option_destroy (option);
285 vertical_margins (const struct ascii_driver *a)
287 return a->top_margin + a->bottom_margin + (a->headers ? 3 : 0);
290 /* Re-calculates the page width and length based on settings,
291 margins, and, if "auto" is set, the size of the user's
292 terminal window or GUI output window. */
294 update_page_size (struct ascii_driver *a, bool issue_error)
296 enum { MIN_WIDTH = 6, MIN_LENGTH = 6 };
299 a->width = settings_get_viewwidth ();
301 a->length = settings_get_viewlength () - vertical_margins (a);
303 if (a->width < MIN_WIDTH || a->length < MIN_LENGTH)
307 _("ascii: page excluding margins and headers "
308 "must be at least %d characters wide by %d lines long, but "
309 "as configured is only %d characters by %d lines"),
310 MIN_WIDTH, MIN_LENGTH,
311 a->width, a->length);
312 if (a->width < MIN_WIDTH)
313 a->width = MIN_WIDTH;
314 if (a->length < MIN_LENGTH)
315 a->length = MIN_LENGTH;
323 ascii_destroy (struct output_driver *driver)
325 struct ascii_driver *a = ascii_driver_cast (driver);
329 ascii_close_page (a);
332 fn_close (a->file_name, a->file);
336 free (a->chart_file_name);
337 for (i = 0; i < LNS_COUNT; i++)
340 for (i = 0; i < a->allocated_lines; i++)
341 free (a->lines[i].chars);
347 ascii_flush (struct output_driver *driver)
349 struct ascii_driver *a = ascii_driver_cast (driver);
352 ascii_close_page (a);
354 if (fn_close (a->file_name, a->file) != 0)
355 error (0, errno, _("ascii: closing output file \"%s\""),
362 ascii_init_caption_cell (const char *caption, struct table_cell *cell)
364 cell->contents = caption;
365 cell->options = TAB_LEFT;
366 cell->destructor = NULL;
370 ascii_submit (struct output_driver *driver,
371 const struct output_item *output_item)
373 struct ascii_driver *a = ascii_driver_cast (driver);
376 if (is_table_item (output_item))
378 struct table_item *table_item = to_table_item (output_item);
379 const char *caption = table_item_get_caption (table_item);
380 struct render_params params;
381 struct render_page *page;
382 struct render_break x_break;
386 update_page_size (a, false);
390 /* XXX doesn't do well with very large captions */
391 struct table_cell cell;
392 ascii_init_caption_cell (caption, &cell);
393 caption_height = ascii_measure_cell_height (a, &cell, a->width);
398 params.draw_line = ascii_draw_line;
399 params.measure_cell_width = ascii_measure_cell_width;
400 params.measure_cell_height = ascii_measure_cell_height;
401 params.draw_cell = ascii_draw_cell,
403 params.size[H] = a->width;
404 params.size[V] = a->length - caption_height;
405 params.font_size[H] = 1;
406 params.font_size[V] = 1;
407 for (i = 0; i < RENDER_N_LINES; i++)
409 int width = i == RENDER_LINE_NONE ? 0 : 1;
410 params.line_widths[H][i] = width;
411 params.line_widths[V][i] = width;
414 if (a->file == NULL && !ascii_open_page (a))
417 page = render_page_create (¶ms, table_item_get_table (table_item));
418 for (render_break_init (&x_break, page, H);
419 render_break_has_next (&x_break); )
421 struct render_page *x_slice;
422 struct render_break y_break;
424 x_slice = render_break_next (&x_break, a->width);
425 for (render_break_init (&y_break, x_slice, V);
426 render_break_has_next (&y_break); )
428 struct render_page *y_slice;
434 space = a->length - a->y - caption_height;
435 if (render_break_next_size (&y_break) > space)
438 ascii_close_page (a);
439 if (!ascii_open_page (a))
444 y_slice = render_break_next (&y_break, space);
447 struct table_cell cell;
448 int bb[TABLE_N_AXES][2];
450 ascii_init_caption_cell (caption, &cell);
454 bb[V][1] = caption_height;
455 ascii_draw_cell (a, &cell, bb, bb);
456 a->y += caption_height;
459 render_page_draw (y_slice);
460 a->y += render_page_get_size (y_slice, V);
461 render_page_unref (y_slice);
463 render_break_destroy (&y_break);
465 render_break_destroy (&x_break);
467 else if (is_chart_item (output_item) && a->chart_file_name != NULL)
469 struct chart_item *chart_item = to_chart_item (output_item);
472 file_name = xr_draw_png_chart (chart_item, a->chart_file_name,
474 if (file_name != NULL)
476 struct text_item *text_item;
478 text_item = text_item_create_format (
479 TEXT_ITEM_PARAGRAPH, _("See %s for a chart."), file_name);
481 ascii_submit (driver, &text_item->output_item);
482 text_item_unref (text_item);
486 else if (is_text_item (output_item))
488 const struct text_item *text_item = to_text_item (output_item);
489 enum text_item_type type = text_item_get_type (text_item);
490 const char *text = text_item_get_text (text_item);
494 case TEXT_ITEM_TITLE:
496 a->title = xstrdup (text);
499 case TEXT_ITEM_SUBTITLE:
501 a->subtitle = xstrdup (text);
504 case TEXT_ITEM_COMMAND_CLOSE:
507 case TEXT_ITEM_BLANK_LINE:
512 case TEXT_ITEM_EJECT_PAGE:
514 ascii_close_page (a);
519 struct table_item *item;
521 item = table_item_create (table_from_string (TAB_LEFT, text),
523 ascii_submit (&a->driver, &item->output_item);
524 table_item_unref (item);
531 const struct output_driver_factory txt_driver_factory =
532 { "txt", ascii_create };
533 const struct output_driver_factory list_driver_factory =
534 { "list", ascii_create };
536 static const struct output_driver_class ascii_driver_class =
551 static void ascii_expand_line (struct ascii_driver *, int y, int length);
552 static void ascii_layout_cell (struct ascii_driver *,
553 const struct table_cell *,
554 int bb[TABLE_N_AXES][2],
555 int clip[TABLE_N_AXES][2], enum wrap_mode wrap,
556 int *width, int *height);
559 ascii_draw_line (void *a_, int bb[TABLE_N_AXES][2],
560 enum render_line_style styles[TABLE_N_AXES][2])
562 struct ascii_driver *a = a_;
563 unsigned short int value;
567 /* Clip to the page. */
568 if (bb[H][0] >= a->width || bb[V][0] + a->y >= a->length)
570 x1 = MIN (bb[H][1], a->width);
571 y1 = MIN (bb[V][1] + a->y, a->length);
574 value = ATTR_BOX | make_box_index (styles[V][0], styles[V][1],
575 styles[H][0], styles[H][1]);
576 for (y = bb[V][0] + a->y; y < y1; y++)
578 ascii_expand_line (a, y, x1);
579 for (x = bb[H][0]; x < x1; x++)
580 a->lines[y].chars[x] = value;
585 ascii_measure_cell_width (void *a_, const struct table_cell *cell,
586 int *min_width, int *max_width)
588 struct ascii_driver *a = a_;
589 int bb[TABLE_N_AXES][2];
590 int clip[TABLE_N_AXES][2];
597 clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
598 ascii_layout_cell (a, cell, bb, clip, WRAP_WORD, max_width, &h);
600 if (strchr (cell->contents, ' '))
603 ascii_layout_cell (a, cell, bb, clip, WRAP_WORD, min_width, &h);
606 *min_width = *max_width;
610 ascii_measure_cell_height (void *a_, const struct table_cell *cell, int width)
612 struct ascii_driver *a = a_;
613 int bb[TABLE_N_AXES][2];
614 int clip[TABLE_N_AXES][2];
621 clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
622 ascii_layout_cell (a, cell, bb, clip, WRAP_WORD, &w, &h);
627 ascii_draw_cell (void *a_, const struct table_cell *cell,
628 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2])
630 struct ascii_driver *a = a_;
633 ascii_layout_cell (a, cell, bb, clip, WRAP_WORD, &w, &h);
636 /* Ensures that at least the first LENGTH characters of line Y in
637 ascii driver A have been cleared out. */
639 ascii_expand_line (struct ascii_driver *a, int y, int length)
641 struct ascii_line *line = &a->lines[y];
642 if (line->n_chars < length)
645 if (line->allocated_chars < length)
647 line->allocated_chars = MAX (length, MIN (length * 2, a->width));
648 line->chars = xnrealloc (line->chars, line->allocated_chars,
649 sizeof *line->chars);
651 for (x = line->n_chars; x < length; x++)
652 line->chars[x] = ' ';
653 line->n_chars = length;
658 text_draw (struct ascii_driver *a, const struct table_cell *cell,
659 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
660 int y, const char *string, int n)
662 int x0 = MAX (0, clip[H][0]);
663 int y0 = MAX (0, clip[V][0] + a->y);
665 int y1 = MIN (a->length, clip[V][1] + a->y);
669 if (y < y0 || y >= y1)
672 switch (cell->options & TAB_ALIGNMENT)
678 x = (bb[H][0] + bb[H][1] - n + 1) / 2;
700 int attr = cell->options & TAB_EMPH ? ATTR_EMPHASIS : 0;
703 ascii_expand_line (a, y, x + n);
704 for (i = 0; i < n; i++)
705 a->lines[y].chars[x + i] = string[i] | attr;
710 ascii_layout_cell (struct ascii_driver *a, const struct table_cell *cell,
711 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
712 enum wrap_mode wrap, int *width, int *height)
714 size_t length = strlen (cell->contents);
719 for (y = bb[V][0]; y < bb[V][1] && pos < length; y++)
721 const char *line = &cell->contents[pos];
722 const char *new_line;
725 /* Find line length without considering word wrap. */
726 line_len = MIN (bb[H][1] - bb[H][0], length - pos);
727 new_line = memchr (line, '\n', line_len);
728 if (new_line != NULL)
729 line_len = new_line - line;
732 if (pos + line_len < length && wrap != WRAP_CHAR)
734 size_t space_len = line_len;
735 while (space_len > 0 && !isspace ((unsigned char) line[space_len]))
738 line_len = space_len;
739 else if (wrap == WRAP_WORD)
741 while (pos + line_len < length
742 && !isspace ((unsigned char) line[line_len]))
746 if (line_len > *width)
750 text_draw (a, cell, bb, clip, y, line, line_len);
754 if (pos < length && isspace ((unsigned char) cell->contents[pos]))
757 *height = y - bb[V][0];
760 /* ascii_close_page () and support routines. */
763 ascii_open_page (struct ascii_driver *a)
772 a->file = fn_open (a->file_name, a->append ? "a" : "w");
776 fputs (a->init, a->file);
780 error (0, errno, _("ascii: opening output file \"%s\""),
789 if (a->length > a->allocated_lines)
791 a->lines = xnrealloc (a->lines, a->length, sizeof *a->lines);
792 for (i = a->allocated_lines; i < a->length; i++)
794 struct ascii_line *line = &a->lines[i];
796 line->allocated_chars = 0;
798 a->allocated_lines = a->length;
801 for (i = 0; i < a->length; i++)
802 a->lines[i].n_chars = 0;
807 /* Writes LINE to A's output file. */
809 output_line (struct ascii_driver *a, const struct ascii_line *line)
814 length = line->n_chars;
815 while (length > 0 && line->chars[length - 1] == ' ')
818 for (i = 0; i < length; i++)
820 int attribute = line->chars[i] & (ATTR_BOX | ATTR_EMPHASIS);
821 int ch = line->chars[i] & ~(ATTR_BOX | ATTR_EMPHASIS);
826 fputs (a->box[ch], a->file);
830 if (a->emphasis == EMPH_BOLD)
831 fprintf (a->file, "%c\b%c", ch, ch);
832 else if (a->emphasis == EMPH_UNDERLINE)
833 fprintf (a->file, "_\b%c", ch);
844 putc ('\n', a->file);
848 output_title_line (FILE *out, int width, const char *left, const char *right)
850 struct string s = DS_EMPTY_INITIALIZER;
851 ds_put_char_multiple (&s, ' ', width);
854 size_t length = MIN (strlen (left), width);
855 memcpy (ds_end (&s) - width, left, length);
859 size_t length = MIN (strlen (right), width);
860 memcpy (ds_end (&s) - length, right, length);
862 ds_put_char (&s, '\n');
863 fputs (ds_cstr (&s), out);
868 ascii_close_page (struct ascii_driver *a)
877 if (!a->top_margin && !a->bottom_margin && a->squeeze_blank_lines
878 && !a->paginate && a->page_number > 1)
879 putc ('\n', a->file);
881 for (i = 0; i < a->top_margin; i++)
882 putc ('\n', a->file);
887 r1 = xasprintf (_("%s - Page %d"), get_start_date (), a->page_number);
888 r2 = xasprintf ("%s - %s" , version, host_system);
890 output_title_line (a->file, a->width, a->title, r1);
891 output_title_line (a->file, a->width, a->subtitle, r2);
892 putc ('\n', a->file);
899 for (y = 0; y < a->allocated_lines; y++)
901 struct ascii_line *line = &a->lines[y];
903 if (a->squeeze_blank_lines && y > 0 && line->n_chars == 0)
909 putc ('\n', a->file);
913 output_line (a, line);
916 if (!a->squeeze_blank_lines)
917 for (y = a->allocated_lines; y < a->length; y++)
918 putc ('\n', a->file);
920 for (i = 0; i < a->bottom_margin; i++)
921 putc ('\n', a->file);
923 putc ('\f', a->file);