1 /* PSPP - computes sample statistics.
2 Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
3 Written by Ben Pfaff <blp@gnu.org>.
5 This program is free software; you can redistribute it and/or
6 modify it under the terms of the GNU General Public License as
7 published by the Free Software Foundation; either version 2 of the
8 License, or (at your option) any later version.
10 This program is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
37 #include "debug-print.h"
39 struct som_table_class tab_table_class;
42 #define DEFFIRST(NAME, LABEL) LABEL,
43 #define DEFTAB(NAME, LABEL) LABEL,
45 static const char *tab_names[] =
54 /* Creates a table with NC columns and NR rows. If REALLOCABLE is
55 nonzero then the table's size can be increased later; otherwise,
56 its size can only be reduced. */
58 tab_create (int nc, int nr, int reallocable)
60 void *(*alloc_func) (struct pool *, size_t);
65 struct pool *container = pool_create ();
66 t = pool_alloc (container, sizeof *t);
67 t->container = container;
70 t->col_style = TAB_COL_NONE;
76 t->l = t->r = t->t = t->b = 0;
78 alloc_func = reallocable ? pool_malloc : pool_alloc;
80 t->reallocable = reallocable;
83 t->cc = alloc_func (t->container, nr * nc * sizeof *t->cc);
84 t->ct = alloc_func (t->container, nr * nc);
85 memset (t->ct, TAB_EMPTY, nc * nr);
87 t->rh = alloc_func (t->container, nc * (nr + 1));
88 memset (t->rh, 0, nc * (nr + 1));
90 t->hrh = alloc_func (t->container, sizeof *t->hrh * (nr + 1));
91 memset (t->hrh, 0, sizeof *t->hrh * (nr + 1));
93 t->trh = alloc_func (t->container, nr + 1);
94 memset (t->trh, 0, nr + 1);
96 t->rv = alloc_func (t->container, (nc + 1) * nr);
97 memset (t->rv, 0, (nc + 1) * nr);
99 t->wrv = alloc_func (t->container, sizeof *t->wrv * (nc + 1));
100 memset (t->wrv, 0, sizeof *t->wrv * (nc + 1));
102 t->trv = alloc_func (t->container, nc + 1);
103 memset (t->trv, 0, nc + 1);
107 t->col_ofs = t->row_ofs = 0;
112 /* Destroys table T. */
114 tab_destroy (struct tab_table *t)
117 pool_destroy (t->container);
121 /* Sets the width and height of a table, in columns and rows,
122 respectively. Use only to reduce the size of a table, since it
123 does not change the amount of allocated memory. */
125 tab_resize (struct tab_table *t, int nc, int nr)
130 assert (nc + t->col_ofs <= t->cf);
131 t->nc = nc + t->col_ofs;
135 assert (nr + t->row_ofs <= t->nr);
136 t->nr = nr + t->row_ofs;
140 /* Changes either or both dimensions of a table. Consider using the
141 above routine instead if it won't waste a lot of space.
143 Changing the number of columns in a table is particularly expensive
144 in space and time. Avoid doing such. FIXME: In fact, transferring
145 of rules isn't even implemented yet. */
147 tab_realloc (struct tab_table *t, int nc, int nr)
153 assert (t->reallocable);
158 tab_offset (t, 0, 0);
165 assert (nc == t->nc);
169 int mr1 = min (nr, t->nr);
170 int mc1 = min (nc, t->nc);
172 struct len_string *new_cc;
173 unsigned char *new_ct;
176 new_cc = pool_malloc (t->container, nr * nc * sizeof *new_cc);
177 new_ct = pool_malloc (t->container, nr * nc);
178 for (r = 0; r < mr1; r++)
180 memcpy (&new_cc[r * nc], &t->cc[r * t->nc], mc1 * sizeof *t->cc);
181 memcpy (&new_ct[r * nc], &t->ct[r * t->nc], mc1);
182 memset (&new_ct[r * nc + t->nc], TAB_EMPTY, nc - t->nc);
184 pool_free (t->container, t->cc);
185 pool_free (t->container, t->ct);
190 else if (nr != t->nr)
192 t->cc = pool_realloc (t->container, t->cc, nr * nc * sizeof *t->cc);
193 t->ct = pool_realloc (t->container, t->ct, nr * nc);
195 t->rh = pool_realloc (t->container, t->rh, nc * (nr + 1));
196 t->rv = pool_realloc (t->container, t->rv, (nc + 1) * nr);
197 t->trh = pool_realloc (t->container, t->trh, nr + 1);
198 t->hrh = pool_realloc (t->container, t->hrh,
199 sizeof *t->hrh * (nr + 1));
203 memset (&t->rh[nc * (t->nr + 1)], 0, (nr - t->nr) * nc);
204 memset (&t->rv[(nc + 1) * t->nr], 0, (nr - t->nr) * (nc + 1));
205 memset (&t->trh[t->nr + 1], 0, nr - t->nr);
209 memset (&t->ct[nc * t->nr], TAB_EMPTY, nc * (nr - t->nr));
215 tab_offset (t, co, ro);
218 /* Sets the number of header rows on each side of TABLE to L on the
219 left, R on the right, T on the top, B on the bottom. Header rows
220 are repeated when a table is broken across multiple columns or
223 tab_headers (struct tab_table *table, int l, int r, int t, int b)
225 assert (table != NULL);
232 /* Set up table T so that, when it is an appropriate size, it will be
233 displayed across the page in columns.
235 STYLE is a TAB_COL_* constant. GROUP is the number of rows to take
238 tab_columns (struct tab_table *t, int style, int group)
241 t->col_style = style;
242 t->col_group = group;
247 /* Draws a vertical line to the left of cells at horizontal position X
248 from Y1 to Y2 inclusive in style STYLE, if style is not -1. */
250 tab_vline (struct tab_table *t, int style, int x, int y1, int y2)
259 assert (y2 <= t->nr);
262 if (x + t->col_ofs < 0 || x + t->col_ofs > t->nc
263 || y1 + t->row_ofs < 0 || y1 + t->row_ofs >= t->nr
264 || y2 + t->row_ofs < 0 || y2 + t->row_ofs >= t->nr)
266 printf (_("bad vline: x=%d+%d=%d y=(%d+%d=%d,%d+%d=%d) in "
267 "table size (%d,%d)\n"),
268 x, t->col_ofs, x + t->col_ofs,
269 y1, t->row_ofs, y1 + t->row_ofs,
270 y2, t->row_ofs, y2 + t->row_ofs,
282 if ((style & TAL_SPACING) == 0)
283 for (y = y1; y <= y2; y++)
284 t->rv[x + (t->cf + 1) * y] = style;
285 t->trv[x] |= (1 << (style & ~TAL_SPACING));
289 /* Draws a horizontal line above cells at vertical position Y from X1
290 to X2 inclusive in style STYLE, if style is not -1. */
292 tab_hline (struct tab_table * t, int style, int x1, int x2, int y)
310 if ((style & TAL_SPACING) == 0)
311 for (x = x1; x <= x2; x++)
312 t->rh[x + t->cf * y] = style;
313 t->trh[y] |= (1 << (style & ~TAL_SPACING));
317 /* Draws a box around cells (X1,Y1)-(X2,Y2) inclusive with horizontal
318 lines of style F_H and vertical lines of style F_V. Fills the
319 interior of the box with horizontal lines of style I_H and vertical
320 lines of style I_V. Any of the line styles may be -1 to avoid
321 drawing those lines. This is distinct from 0, which draws a null
324 tab_box (struct tab_table *t, int f_h, int f_v, int i_h, int i_v,
325 int x1, int y1, int x2, int y2)
337 if (x1 + t->col_ofs < 0 || x1 + t->col_ofs >= t->nc
338 || x2 + t->col_ofs < 0 || x2 + t->col_ofs >= t->nc
339 || y1 + t->row_ofs < 0 || y1 + t->row_ofs >= t->nr
340 || y2 + t->row_ofs < 0 || y2 + t->row_ofs >= t->nr)
342 printf (_("bad box: (%d+%d=%d,%d+%d=%d)-(%d+%d=%d,%d+%d=%d) "
343 "in table size (%d,%d)\n"),
344 x1, t->col_ofs, x1 + t->col_ofs,
345 y1, t->row_ofs, y1 + t->row_ofs,
346 x2, t->col_ofs, x2 + t->col_ofs,
347 y2, t->row_ofs, y2 + t->row_ofs,
361 if ((f_h & TAL_SPACING) == 0)
362 for (x = x1; x <= x2; x++)
364 t->rh[x + t->cf * y1] = f_h;
365 t->rh[x + t->cf * (y2 + 1)] = f_h;
367 t->trh[y1] |= (1 << (f_h & ~TAL_SPACING));
368 t->trh[y2 + 1] |= (1 << (f_h & ~TAL_SPACING));
373 if ((f_v & TAL_SPACING) == 0)
374 for (y = y1; y <= y2; y++)
376 t->rv[x1 + (t->cf + 1) * y] = f_v;
377 t->rv[(x2 + 1) + (t->cf + 1) * y] = f_v;
379 t->trv[x1] |= (1 << (f_v & ~TAL_SPACING));
380 t->trv[x2 + 1] |= (1 << (f_v & ~TAL_SPACING));
387 for (y = y1 + 1; y <= y2; y++)
391 if ((i_h & TAL_SPACING) == 0)
392 for (x = x1; x <= x2; x++)
393 t->rh[x + t->cf * y] = i_h;
395 t->trh[y] |= (1 << (i_h & ~TAL_SPACING));
402 for (x = x1 + 1; x <= x2; x++)
406 if ((i_v & TAL_SPACING) == 0)
407 for (y = y1; y <= y2; y++)
408 t->rv[x + (t->cf + 1) * y] = i_v;
410 t->trv[x] |= (1 << (i_v & ~TAL_SPACING));
415 /* Formats text TEXT and arguments ARGS as indicated in OPT and sets
416 the resultant string into S in TABLE's pool. */
418 text_format (struct tab_table *table, int opt, const char *text, va_list args,
419 struct len_string *s)
423 assert (table != NULL && text != NULL && s != NULL);
425 if (opt & TAT_PRINTF)
427 char *temp_buf = local_alloc (1024);
429 len = nvsprintf (temp_buf, text, args);
435 ls_create_buffer (table->container, s, text, len);
437 if (opt & TAT_PRINTF)
441 /* Set the title of table T to TITLE, which is formatted with printf
442 if FORMAT is nonzero. */
444 tab_title (struct tab_table *t, int format, const char *title, ...)
448 assert (t != NULL && title != NULL);
449 va_start (args, title);
450 text_format (t, format ? TAT_PRINTF : TAT_NONE, title, args, &t->title);
454 /* Set DIM_FUNC as the dimension function for table T. */
456 tab_dim (struct tab_table *t, tab_dim_func *dim_func)
458 assert (t != NULL && t->dim == NULL);
462 /* Returns the natural width of column C in table T for driver D, that
463 is, the smallest width necessary to display all its cells without
464 wrapping. The width will be no larger than the page width minus
465 left and right rule widths. */
467 tab_natural_width (struct tab_table *t, struct outp_driver *d, int c)
471 assert (t != NULL && c >= 0 && c < t->nc);
475 for (width = r = 0; r < t->nr; r++)
477 struct outp_text text;
478 unsigned char opt = t->ct[c + r * t->cf];
480 if (opt & (TAB_JOIN | TAB_EMPTY))
483 text.s = t->cc[c + r * t->cf];
484 assert (!ls_null_p (&text.s));
485 text.options = OUTP_T_JUST_LEFT;
487 d->class->text_metrics (d, &text);
495 width = d->prop_em_width * 8;
497 printf ("warning: table column %d contains no data.\n", c);
502 const int clamp = d->width - t->wrv[0] - t->wrv[t->nc];
511 /* Returns the natural height of row R in table T for driver D, that
512 is, the minimum height necessary to display the information in the
513 cell at the widths set for each column. */
515 tab_natural_height (struct tab_table *t, struct outp_driver *d, int r)
519 assert (t != NULL && r >= 0 && r < t->nr);
524 for (height = d->font_height, c = 0; c < t->nc; c++)
526 struct outp_text text;
527 unsigned char opt = t->ct[c + r * t->cf];
529 assert (t->w[c] != NOT_INT);
530 if (opt & (TAB_JOIN | TAB_EMPTY))
533 text.s = t->cc[c + r * t->cf];
534 assert (!ls_null_p (&text.s));
535 text.options = OUTP_T_HORZ | OUTP_T_JUST_LEFT;
537 d->class->text_metrics (d, &text);
547 /* Callback function to set all columns and rows to their natural
548 dimensions. Not really meant to be called directly. */
550 tab_natural_dimensions (struct tab_table *t, struct outp_driver *d)
556 for (i = 0; i < t->nc; i++)
557 t->w[i] = tab_natural_width (t, d, i);
559 for (i = 0; i < t->nr; i++)
560 t->h[i] = tab_natural_height (t, d, i);
566 /* Sets cell (C,R) in TABLE, with options OPT, to have a value taken
567 from V, displayed with format spec F. */
569 tab_value (struct tab_table *table, int c, int r, unsigned char opt,
570 const union value *v, const struct fmt_spec *f)
573 union value temp_val;
575 assert (table != NULL && v != NULL && f != NULL);
577 if (c + table->col_ofs < 0 || r + table->row_ofs < 0
578 || c + table->col_ofs >= table->nc
579 || r + table->row_ofs >= table->nr)
581 printf ("tab_value(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
583 c, table->col_ofs, c + table->col_ofs,
584 r, table->row_ofs, r + table->row_ofs,
585 table->nc, table->nr);
590 contents = pool_alloc (table->container, f->w);
591 ls_init (&table->cc[c + r * table->cf], contents, f->w);
592 table->ct[c + r * table->cf] = opt;
594 if (formats[f->type].cat & FCAT_STRING)
596 temp_val.c = (char *) v->s;
599 data_out (contents, f, v);
602 /* Sets cell (C,R) in TABLE, with options OPT, to have value VAL
603 with NDEC decimal places. */
605 tab_float (struct tab_table *table, int c, int r, unsigned char opt,
606 double val, int w, int d)
613 assert (table != NULL && w <= 40);
620 if (c + table->col_ofs < 0 || r + table->row_ofs < 0
621 || c + table->col_ofs >= table->nc
622 || r + table->row_ofs >= table->nr)
624 printf ("tab_float(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
626 c, table->col_ofs, c + table->col_ofs,
627 r, table->row_ofs, r + table->row_ofs,
628 table->nc, table->nr);
633 data_out (buf, &f, (union value *) &val);
635 while (isspace ((unsigned char) *cp) && cp < &buf[w])
637 f.w = w - (cp - buf);
639 contents = pool_alloc (table->container, f.w);
640 ls_init (&table->cc[c + r * table->cf], contents, f.w);
641 table->ct[c + r * table->cf] = opt;
642 memcpy (contents, cp, f.w);
645 /* Sets cell (C,R) in TABLE, with options OPT, to have text value
648 tab_text (struct tab_table *table, int c, int r, unsigned opt, const char *text, ...)
652 assert (table != NULL && text != NULL);
656 assert (c < table->nc);
657 assert (r < table->nr);
661 if (c + table->col_ofs < 0 || r + table->row_ofs < 0
662 || c + table->col_ofs >= table->nc
663 || r + table->row_ofs >= table->nr)
665 printf ("tab_text(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
667 c, table->col_ofs, c + table->col_ofs,
668 r, table->row_ofs, r + table->row_ofs,
669 table->nc, table->nr);
674 va_start (args, text);
675 text_format (table, opt, text, args, &table->cc[c + r * table->cf]);
676 table->ct[c + r * table->cf] = opt;
680 /* Joins cells (X1,X2)-(Y1,Y2) inclusive in TABLE, and sets them with
681 options OPT to have text value TEXT. */
683 tab_joint_text (struct tab_table *table, int x1, int y1, int x2, int y2,
684 unsigned opt, const char *text, ...)
686 struct tab_joined_cell *j;
688 assert (table != NULL && text != NULL);
694 assert (y2 < table->nr);
695 assert (x2 < table->nc);
698 if (x1 + table->col_ofs < 0 || x1 + table->col_ofs >= table->nc
699 || y1 + table->row_ofs < 0 || y1 + table->row_ofs >= table->nr
700 || x2 < x1 || x2 + table->col_ofs >= table->nc
701 || y2 < y2 || y2 + table->row_ofs >= table->nr)
703 printf ("tab_joint_text(): bad cell "
704 "(%d+%d=%d,%d+%d=%d)-(%d+%d=%d,%d+%d=%d) in table size (%d,%d)\n",
705 x1, table->col_ofs, x1 + table->col_ofs,
706 y1, table->row_ofs, y1 + table->row_ofs,
707 x2, table->col_ofs, x2 + table->col_ofs,
708 y2, table->row_ofs, y2 + table->row_ofs,
709 table->nc, table->nr);
714 j = pool_alloc (table->container, sizeof *j);
716 j->x1 = x1 + table->col_ofs;
717 j->y1 = y1 + table->row_ofs;
718 j->x2 = ++x2 + table->col_ofs;
719 j->y2 = ++y2 + table->row_ofs;
724 va_start (args, text);
725 text_format (table, opt, text, args, &j->contents);
732 struct len_string *cc = &table->cc[x1 + y1 * table->cf];
733 unsigned char *ct = &table->ct[x1 + y1 * table->cf];
734 const int ofs = table->cf - (x2 - x1);
738 for (y = y1; y < y2; y++)
742 for (x = x1; x < x2; x++)
744 ls_init (cc++, (char *) j, 0);
754 /* Sets cell (C,R) in TABLE, with options OPT, to contents STRING. */
756 tab_raw (struct tab_table *table, int c, int r, unsigned opt,
757 struct len_string *string)
759 assert (table != NULL && string != NULL);
762 if (c + table->col_ofs < 0 || r + table->row_ofs < 0
763 || c + table->col_ofs >= table->nc
764 || r + table->row_ofs >= table->nr)
766 printf ("tab_float(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
768 c, table->col_ofs, c + table->col_ofs,
769 r, table->row_ofs, r + table->row_ofs,
770 table->nc, table->nr);
775 table->cc[c + r * table->cf] = *string;
776 table->ct[c + r * table->cf] = opt;
781 /* Sets the widths of all the columns and heights of all the rows in
782 table T for driver D. */
784 nowrap_dim (struct tab_table *t, struct outp_driver *d)
786 t->w[0] = tab_natural_width (t, d, 0);
787 t->h[0] = d->font_height;
790 /* Sets the widths of all the columns and heights of all the rows in
791 table T for driver D. */
793 wrap_dim (struct tab_table *t, struct outp_driver *d)
795 t->w[0] = tab_natural_width (t, d, 0);
796 t->h[0] = tab_natural_height (t, d, 0);
799 /* Outputs text BUF as a table with a single cell having cell options
800 OPTIONS, which is a combination of the TAB_* and TAT_*
803 tab_output_text (int options, const char *buf, ...)
805 struct tab_table *t = tab_create (1, 1, 0);
807 assert (buf != NULL);
808 if (options & TAT_PRINTF)
811 char *temp_buf = local_alloc (4096);
813 va_start (args, buf);
814 nvsprintf (temp_buf, buf, args);
819 if (options & TAT_FIX)
821 struct outp_driver *d;
823 for (d = outp_drivers (NULL); d; d = outp_drivers (d))
826 d->class->open_page (d);
828 if (d->class->text_set_font_by_name != NULL)
829 d->class->text_set_font_by_name (d, "FIXED");
837 tab_text (t, 0, 0, options &~ TAT_PRINTF, buf);
838 tab_flags (t, SOMF_NO_TITLE | SOMF_NO_SPACING);
839 if (options & TAT_NOWRAP)
840 tab_dim (t, nowrap_dim);
842 tab_dim (t, wrap_dim);
845 if (options & TAT_FIX)
847 struct outp_driver *d;
849 for (d = outp_drivers (NULL); d; d = outp_drivers (d))
850 if (d->class->text_set_font_by_name != NULL)
851 d->class->text_set_font_by_name (d, "PROP");
858 if (options & TAT_PRINTF)
862 /* Set table flags to FLAGS. */
864 tab_flags (struct tab_table *t, unsigned flags)
870 /* Easy, type-safe way to submit a tab table to som. */
872 tab_submit (struct tab_table *t)
877 s.class = &tab_table_class;
885 /* Set table row and column offsets for all functions that affect
888 tab_offset (struct tab_table *t, int col, int row)
894 if (row < -1 || row >= t->nr)
896 printf ("tab_offset(): row=%d in %d-row table\n", row, t->nr);
899 if (col < -1 || col >= t->nc)
901 printf ("tab_offset(): col=%d in %d-column table\n", col, t->nc);
907 diff += (row - t->row_ofs) * t->cf, t->row_ofs = row;
909 diff += (col - t->col_ofs), t->col_ofs = col;
915 /* Increment the row offset by one. If the table is too small,
916 increase its size. */
918 tab_next_row (struct tab_table *t)
923 if (++t->row_ofs >= t->nr)
924 tab_realloc (t, -1, t->nr * 4 / 3);
927 static struct tab_table *t;
928 static struct outp_driver *d;
931 /* Set the current table to TABLE. */
933 tabi_table (struct som_table *table)
935 assert (table != NULL);
937 tab_offset (t, 0, 0);
939 assert (t->w == NULL && t->h == NULL);
940 t->w = pool_alloc (t->container, sizeof *t->w * t->nc);
941 t->h = pool_alloc (t->container, sizeof *t->h * t->nr);
944 /* Set the current output device to DRIVER. */
946 tabi_driver (struct outp_driver *driver)
950 assert (driver != NULL);
953 /* Figure out sizes of rules. */
954 for (t->hr_tot = i = 0; i <= t->nr; i++)
955 t->hr_tot += t->hrh[i] = d->horiz_line_spacing[t->trh[i]];
956 for (t->vr_tot = i = 0; i <= t->nc; i++)
957 t->vr_tot += t->wrv[i] = d->vert_line_spacing[t->trv[i]];
960 for (i = 0; i < t->nr; i++)
962 for (i = 0; i < t->nc; i++)
966 assert (t->dim != NULL);
973 for (i = 0; i < t->nr; i++)
977 printf ("Table row %d height not initialized.\n", i);
980 assert (t->h[i] > 0);
983 for (i = 0; i < t->nc; i++)
987 printf ("Table column %d width not initialized.\n", i);
990 assert (t->w[i] > 0);
995 /* Add up header sizes. */
996 for (i = 0, t->wl = t->wrv[0]; i < t->l; i++)
997 t->wl += t->w[i] + t->wrv[i + 1];
998 for (i = 0, t->ht = t->hrh[0]; i < t->t; i++)
999 t->ht += t->h[i] + t->hrh[i + 1];
1000 for (i = t->nc - t->r, t->wr = t->wrv[i]; i < t->nc; i++)
1001 t->wr += t->w[i] + t->wrv[i + 1];
1002 for (i = t->nr - t->b, t->hb = t->hrh[i]; i < t->nr; i++)
1003 t->hb += t->h[i] + t->hrh[i + 1];
1006 if (!(t->flags & SOMF_NO_TITLE))
1007 t->ht += d->font_height;
1010 /* Return the number of columns and rows in the table into N_COLUMNS
1011 and N_ROWS, respectively. */
1013 tabi_count (int *n_columns, int *n_rows)
1015 assert (n_columns != NULL && n_rows != NULL);
1020 static void tabi_cumulate (int cumtype, int start, int *end, int max, int *actual);
1022 /* Return the horizontal and vertical size of the entire table,
1023 including headers, for the current output device, into HORIZ and
1026 tabi_area (int *horiz, int *vert)
1028 assert (horiz != NULL && vert != NULL);
1033 for (c = t->l + 1, w = t->wl + t->wr + t->w[t->l];
1034 c < t->nc - t->r; c++)
1035 w += t->w[c] + t->wrv[c];
1041 for (r = t->t + 1, h = t->ht + t->hb + t->h[t->t];
1042 r < t->nr - t->b; r++)
1043 h += t->h[r] + t->hrh[r];
1048 /* Return the column style for this table into STYLE. */
1050 tabi_columns (int *style)
1052 assert (style != NULL);
1053 *style = t->col_style;
1056 /* Return the number of header rows/columns on the left, right, top,
1057 and bottom sides into HL, HR, HT, and HB, respectively. */
1059 tabi_headers (int *hl, int *hr, int *ht, int *hb)
1061 assert (hl != NULL && hr != NULL && ht != NULL && hb != NULL);
1068 /* Determines the number of rows or columns (including appropriate
1069 headers), depending on CUMTYPE, that will fit into the space
1070 specified. Takes rows/columns starting at index START and attempts
1071 to fill up available space MAX. Returns in END the index of the
1072 last row/column plus one; returns in ACTUAL the actual amount of
1073 space the selected rows/columns (including appropriate headers)
1076 tabi_cumulate (int cumtype, int start, int *end, int max, int *actual)
1083 assert (end != NULL && (cumtype == SOM_ROWS || cumtype == SOM_COLUMNS));
1084 if (cumtype == SOM_ROWS)
1086 assert (start >= 0 && start < t->nr);
1089 r = &t->hrh[start + 1];
1090 total = t->ht + t->hb;
1092 assert (start >= 0 && start < t->nc);
1095 r = &t->wrv[start + 1];
1096 total = t->wl + t->wr;
1112 for (x = start + 1; x < n; x++)
1114 int amt = *d++ + *r++;
1132 /* Return flags set for the current table into FLAGS. */
1134 tabi_flags (unsigned *flags)
1136 assert (flags != NULL);
1140 /* Render title for current table, with major index X and minor index
1141 Y. Y may be zero, or X and Y may be zero, but X should be nonzero
1144 tabi_title (int x, int y)
1149 if (t->flags & SOMF_NO_TITLE)
1152 cp = spprintf (buf, "%d.%d", table_num, subtable_num);
1154 cp = spprintf (cp, "(%d:%d)", x, y);
1156 cp = spprintf (cp, "(%d)", x);
1158 cp = spprintf (cp, " %s", cur_proc);
1159 cp = stpcpy (cp, ". ");
1160 if (!ls_empty_p (&t->title))
1162 memcpy (cp, ls_value (&t->title), ls_length (&t->title));
1163 cp += ls_length (&t->title);
1168 struct outp_text text;
1170 text.options = OUTP_T_JUST_LEFT | OUTP_T_HORZ | OUTP_T_VERT;
1171 ls_init (&text.s, buf, cp - buf);
1173 text.v = d->font_height;
1176 d->class->text_draw (d, &text);
1180 static int render_strip (int x, int y, int r, int c1, int c2, int r1, int r2);
1182 /* Draws the table region in rectangle (X1,Y1)-(X2,Y2), where column
1183 X2 and row Y2 are not included in the rectangle, at the current
1184 position on the current output device. Draws headers as well. */
1186 tabi_render (int x1, int y1, int x2, int y2)
1194 if (!(t->flags & SOMF_NO_TITLE))
1195 y += d->font_height;
1199 ranges[0][1] = t->t * 2 + 1;
1201 /* Requested rows. */
1202 ranges[1][0] = y1 * 2 + 1;
1203 ranges[1][1] = y2 * 2;
1205 /* Bottom headers. */
1206 ranges[2][0] = (t->nr - t->b) * 2;
1207 ranges[2][1] = t->nr * 2 + 1;
1209 for (i = 0; i < 3; i++)
1213 for (r = ranges[i][0]; r < ranges[i][1]; r++)
1216 x += render_strip (x, y, r, 0, t->l * 2 + 1, y1, y2);
1217 x += render_strip (x, y, r, x1 * 2 + 1, x2 * 2, y1, y2);
1218 x += render_strip (x, y, r, (t->nc - t->r) * 2,
1219 t->nc * 2 + 1, y1, y2);
1220 y += (r & 1) ? t->h[r / 2] : t->hrh[r / 2];
1225 struct som_table_class tab_table_class =
1248 /* Render contiguous strip consisting of columns C1...C2, exclusive,
1249 on row R, at location (X,Y). Return width of the strip thus
1252 Renders joined cells, even those outside the strip, within the
1253 rendering region (C1,R1)-(C2,R2).
1255 For the purposes of counting rows and columns in this function
1256 only, horizontal rules are considered rows and vertical rules are
1259 FIXME: Doesn't use r1? Huh? */
1261 render_strip (int x, int y, int r, int c1, int c2, int r1 unused, int r2)
1265 /* Horizontal rules. */
1268 int hrh = t->hrh[r / 2];
1271 for (c = c1; c < c2; c++)
1275 int style = t->rh[(c / 2) + (r / 2 * t->cf)];
1279 const struct color clr = {0, 0, 0, 0};
1284 rct.x2 = x + t->w[c / 2];
1286 d->class->line_horz (d, &rct, &clr, style);
1290 const struct color clr = {0, 0, 0, 0};
1292 struct outp_styles s;
1296 rct.x2 = x + t->wrv[c / 2];
1299 s.t = r > 0 ? t->rv[(c / 2) + (t->cf + 1) * (r / 2 - 1)] : 0;
1300 s.b = r < 2 * t->nr ? t->rv[(c / 2) + (t->cf + 1) * (r / 2)] : 0;
1301 s.l = c > 0 ? t->rh[(c / 2 - 1) + t->cf * (r / 2)] : 0;
1302 s.r = c < 2 * t->nc ? t->rh[(c / 2) + t->cf * (r / 2)] : 0;
1304 if (s.t | s.b | s.l | s.r)
1305 d->class->line_intersection (d, &rct, &clr, &s);
1313 for (c = c1; c < c2; c++)
1317 const int index = (c / 2) + (r / 2 * t->cf);
1319 if (!(t->ct[index] & TAB_JOIN))
1321 struct outp_text text;
1323 text.options = ((t->ct[index] & OUTP_T_JUST_MASK)
1324 | OUTP_T_HORZ | OUTP_T_VERT);
1325 if ((t->ct[index] & TAB_EMPTY) == 0)
1327 text.s = t->cc[index];
1328 assert (!ls_null_p (&text.s));
1329 text.h = t->w[c / 2];
1330 text.v = t->h[r / 2];
1333 d->class->text_draw (d, &text);
1336 struct tab_joined_cell *j =
1337 (struct tab_joined_cell *) ls_value (&t->cc[index]);
1339 if (j->hit != tab_hit)
1343 if (j->x1 == c / 2 && j->y1 == r / 2
1344 && j->x2 <= c2 && j->y2 <= r2)
1346 struct outp_text text;
1348 text.options = ((t->ct[index] & OUTP_T_JUST_MASK)
1349 | OUTP_T_HORZ | OUTP_T_VERT);
1350 text.s = j->contents;
1357 for (c = j->x1, text.h = -t->wrv[j->x2];
1359 text.h += t->w[c] + t->wrv[c + 1];
1365 for (r = j->y1, text.v = -t->hrh[j->y2];
1367 text.v += t->h[r] + t->hrh[r + 1];
1369 d->class->text_draw (d, &text);
1375 int style = t->rv[(c / 2) + (r / 2 * (t->cf + 1))];
1379 const struct color clr = {0, 0, 0, 0};
1384 rct.x2 = x + t->wrv[c / 2];
1385 rct.y2 = y + t->h[r / 2];
1386 d->class->line_vert (d, &rct, &clr, style);
1393 return x - x_origin;