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);
120 /* Sets the width and height of a table, in columns and rows,
121 respectively. Use only to reduce the size of a table, since it
122 does not change the amount of allocated memory. */
124 tab_resize (struct tab_table *t, int nc, int nr)
129 assert (nc + t->col_ofs <= t->cf);
130 t->nc = nc + t->col_ofs;
134 assert (nr + t->row_ofs <= t->nr);
135 t->nr = nr + t->row_ofs;
139 /* Changes either or both dimensions of a table. Consider using the
140 above routine instead if it won't waste a lot of space.
142 Changing the number of columns in a table is particularly expensive
143 in space and time. Avoid doing such. FIXME: In fact, transferring
144 of rules isn't even implemented yet. */
146 tab_realloc (struct tab_table *t, int nc, int nr)
152 assert (t->reallocable);
157 tab_offset (t, 0, 0);
164 assert (nc == t->nc);
168 int mr1 = min (nr, t->nr);
169 int mc1 = min (nc, t->nc);
171 struct len_string *new_cc;
172 unsigned char *new_ct;
175 new_cc = pool_malloc (t->container, nr * nc * sizeof *new_cc);
176 new_ct = pool_malloc (t->container, nr * nc);
177 for (r = 0; r < mr1; r++)
179 memcpy (&new_cc[r * nc], &t->cc[r * t->nc], mc1 * sizeof *t->cc);
180 memcpy (&new_ct[r * nc], &t->ct[r * t->nc], mc1);
181 memset (&new_ct[r * nc + t->nc], TAB_EMPTY, nc - t->nc);
183 pool_free (t->container, t->cc);
184 pool_free (t->container, t->ct);
189 else if (nr != t->nr)
191 t->cc = pool_realloc (t->container, t->cc, nr * nc * sizeof *t->cc);
192 t->ct = pool_realloc (t->container, t->ct, nr * nc);
194 t->rh = pool_realloc (t->container, t->rh, nc * (nr + 1));
195 t->rv = pool_realloc (t->container, t->rv, (nc + 1) * nr);
196 t->trh = pool_realloc (t->container, t->trh, nr + 1);
197 t->hrh = pool_realloc (t->container, t->hrh,
198 sizeof *t->hrh * (nr + 1));
202 memset (&t->rh[nc * (t->nr + 1)], 0, (nr - t->nr) * nc);
203 memset (&t->rv[(nc + 1) * t->nr], 0, (nr - t->nr) * (nc + 1));
204 memset (&t->trh[t->nr + 1], 0, nr - t->nr);
208 memset (&t->ct[nc * t->nr], TAB_EMPTY, nc * (nr - t->nr));
214 tab_offset (t, co, ro);
217 /* Sets the number of header rows on each side of TABLE to L on the
218 left, R on the right, T on the top, B on the bottom. Header rows
219 are repeated when a table is broken across multiple columns or
222 tab_headers (struct tab_table *table, int l, int r, int t, int b)
224 assert (table != NULL);
231 /* Set up table T so that, when it is an appropriate size, it will be
232 displayed across the page in columns.
234 STYLE is a TAB_COL_* constant. GROUP is the number of rows to take
237 tab_columns (struct tab_table *t, int style, int group)
240 t->col_style = style;
241 t->col_group = group;
246 /* Draws a vertical line to the left of cells at horizontal position X
247 from Y1 to Y2 inclusive in style STYLE, if style is not -1. */
249 tab_vline (struct tab_table *t, int style, int x, int y1, int y2)
258 assert (y2 <= t->nr);
261 if (x + t->col_ofs < 0 || x + t->col_ofs > t->nc
262 || y1 + t->row_ofs < 0 || y1 + t->row_ofs >= t->nr
263 || y2 + t->row_ofs < 0 || y2 + t->row_ofs >= t->nr)
265 printf (_("bad vline: x=%d+%d=%d y=(%d+%d=%d,%d+%d=%d) in "
266 "table size (%d,%d)\n"),
267 x, t->col_ofs, x + t->col_ofs,
268 y1, t->row_ofs, y1 + t->row_ofs,
269 y2, t->row_ofs, y2 + t->row_ofs,
281 if ((style & TAL_SPACING) == 0)
282 for (y = y1; y <= y2; y++)
283 t->rv[x + (t->cf + 1) * y] = style;
284 t->trv[x] |= (1 << (style & ~TAL_SPACING));
288 /* Draws a horizontal line above cells at vertical position Y from X1
289 to X2 inclusive in style STYLE, if style is not -1. */
291 tab_hline (struct tab_table * t, int style, int x1, int x2, int y)
309 if ((style & TAL_SPACING) == 0)
310 for (x = x1; x <= x2; x++)
311 t->rh[x + t->cf * y] = style;
312 t->trh[y] |= (1 << (style & ~TAL_SPACING));
316 /* Draws a box around cells (X1,Y1)-(X2,Y2) inclusive with horizontal
317 lines of style F_H and vertical lines of style F_V. Fills the
318 interior of the box with horizontal lines of style I_H and vertical
319 lines of style I_V. Any of the line styles may be -1 to avoid
320 drawing those lines. This is distinct from 0, which draws a null
323 tab_box (struct tab_table *t, int f_h, int f_v, int i_h, int i_v,
324 int x1, int y1, int x2, int y2)
336 if (x1 + t->col_ofs < 0 || x1 + t->col_ofs >= t->nc
337 || x2 + t->col_ofs < 0 || x2 + t->col_ofs >= t->nc
338 || y1 + t->row_ofs < 0 || y1 + t->row_ofs >= t->nr
339 || y2 + t->row_ofs < 0 || y2 + t->row_ofs >= t->nr)
341 printf (_("bad box: (%d+%d=%d,%d+%d=%d)-(%d+%d=%d,%d+%d=%d) "
342 "in table size (%d,%d)\n"),
343 x1, t->col_ofs, x1 + t->col_ofs,
344 y1, t->row_ofs, y1 + t->row_ofs,
345 x2, t->col_ofs, x2 + t->col_ofs,
346 y2, t->row_ofs, y2 + t->row_ofs,
360 if ((f_h & TAL_SPACING) == 0)
361 for (x = x1; x <= x2; x++)
363 t->rh[x + t->cf * y1] = f_h;
364 t->rh[x + t->cf * (y2 + 1)] = f_h;
366 t->trh[y1] |= (1 << (f_h & ~TAL_SPACING));
367 t->trh[y2 + 1] |= (1 << (f_h & ~TAL_SPACING));
372 if ((f_v & TAL_SPACING) == 0)
373 for (y = y1; y <= y2; y++)
375 t->rv[x1 + (t->cf + 1) * y] = f_v;
376 t->rv[(x2 + 1) + (t->cf + 1) * y] = f_v;
378 t->trv[x1] |= (1 << (f_v & ~TAL_SPACING));
379 t->trv[x2 + 1] |= (1 << (f_v & ~TAL_SPACING));
386 for (y = y1 + 1; y <= y2; y++)
390 if ((i_h & TAL_SPACING) == 0)
391 for (x = x1; x <= x2; x++)
392 t->rh[x + t->cf * y] = i_h;
394 t->trh[y] |= (1 << (i_h & ~TAL_SPACING));
401 for (x = x1 + 1; x <= x2; x++)
405 if ((i_v & TAL_SPACING) == 0)
406 for (y = y1; y <= y2; y++)
407 t->rv[x + (t->cf + 1) * y] = i_v;
409 t->trv[x] |= (1 << (i_v & ~TAL_SPACING));
414 /* Formats text TEXT and arguments ARGS as indicated in OPT and sets
415 the resultant string into S in TABLE's pool. */
417 text_format (struct tab_table *table, int opt, const char *text, va_list args,
418 struct len_string *s)
422 assert (table != NULL && text != NULL && s != NULL);
424 if (opt & TAT_PRINTF)
426 char *temp_buf = local_alloc (1024);
428 len = nvsprintf (temp_buf, text, args);
434 ls_create_buffer (table->container, s, text, len);
436 if (opt & TAT_PRINTF)
440 /* Set the title of table T to TITLE, which is formatted with printf
441 if FORMAT is nonzero. */
443 tab_title (struct tab_table *t, int format, const char *title, ...)
447 assert (t != NULL && title != NULL);
448 va_start (args, title);
449 text_format (t, format ? TAT_PRINTF : TAT_NONE, title, args, &t->title);
453 /* Set DIM_FUNC as the dimension function for table T. */
455 tab_dim (struct tab_table *t, tab_dim_func *dim_func)
457 assert (t != NULL && t->dim == NULL);
461 /* Returns the natural width of column C in table T for driver D, that
462 is, the smallest width necessary to display all its cells without
463 wrapping. The width will be no larger than the page width minus
464 left and right rule widths. */
466 tab_natural_width (struct tab_table *t, struct outp_driver *d, int c)
470 assert (t != NULL && c >= 0 && c < t->nc);
474 for (width = r = 0; r < t->nr; r++)
476 struct outp_text text;
477 unsigned char opt = t->ct[c + r * t->cf];
479 if (opt & (TAB_JOIN | TAB_EMPTY))
482 text.s = t->cc[c + r * t->cf];
483 assert (!ls_null_p (&text.s));
484 text.options = OUTP_T_JUST_LEFT;
486 d->class->text_metrics (d, &text);
494 width = d->prop_em_width * 8;
496 printf ("warning: table column %d contains no data.\n", c);
501 const int clamp = d->width - t->wrv[0] - t->wrv[t->nc];
510 /* Returns the natural height of row R in table T for driver D, that
511 is, the minimum height necessary to display the information in the
512 cell at the widths set for each column. */
514 tab_natural_height (struct tab_table *t, struct outp_driver *d, int r)
518 assert (t != NULL && r >= 0 && r < t->nr);
523 for (height = d->font_height, c = 0; c < t->nc; c++)
525 struct outp_text text;
526 unsigned char opt = t->ct[c + r * t->cf];
528 assert (t->w[c] != NOT_INT);
529 if (opt & (TAB_JOIN | TAB_EMPTY))
532 text.s = t->cc[c + r * t->cf];
533 assert (!ls_null_p (&text.s));
534 text.options = OUTP_T_HORZ | OUTP_T_JUST_LEFT;
536 d->class->text_metrics (d, &text);
546 /* Callback function to set all columns and rows to their natural
547 dimensions. Not really meant to be called directly. */
549 tab_natural_dimensions (struct tab_table *t, struct outp_driver *d)
555 for (i = 0; i < t->nc; i++)
556 t->w[i] = tab_natural_width (t, d, i);
558 for (i = 0; i < t->nr; i++)
559 t->h[i] = tab_natural_height (t, d, i);
565 /* Sets cell (C,R) in TABLE, with options OPT, to have a value taken
566 from V, displayed with format spec F. */
568 tab_value (struct tab_table *table, int c, int r, unsigned char opt,
569 const union value *v, const struct fmt_spec *f)
572 union value temp_val;
574 assert (table != NULL && v != NULL && f != NULL);
576 if (c + table->col_ofs < 0 || r + table->row_ofs < 0
577 || c + table->col_ofs >= table->nc
578 || r + table->row_ofs >= table->nr)
580 printf ("tab_value(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
582 c, table->col_ofs, c + table->col_ofs,
583 r, table->row_ofs, r + table->row_ofs,
584 table->nc, table->nr);
589 contents = pool_alloc (table->container, f->w);
590 ls_init (&table->cc[c + r * table->cf], contents, f->w);
591 table->ct[c + r * table->cf] = opt;
593 if (formats[f->type].cat & FCAT_STRING)
595 temp_val.c = (char *) v->s;
598 data_out (contents, f, v);
601 /* Sets cell (C,R) in TABLE, with options OPT, to have value VAL
602 with NDEC decimal places. */
604 tab_float (struct tab_table *table, int c, int r, unsigned char opt,
605 double val, int w, int d)
612 assert (table != NULL && w <= 40);
619 if (c + table->col_ofs < 0 || r + table->row_ofs < 0
620 || c + table->col_ofs >= table->nc
621 || r + table->row_ofs >= table->nr)
623 printf ("tab_float(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
625 c, table->col_ofs, c + table->col_ofs,
626 r, table->row_ofs, r + table->row_ofs,
627 table->nc, table->nr);
632 data_out (buf, &f, (union value *) &val);
634 while (isspace ((unsigned char) *cp) && cp < &buf[w])
636 f.w = w - (cp - buf);
638 contents = pool_alloc (table->container, f.w);
639 ls_init (&table->cc[c + r * table->cf], contents, f.w);
640 table->ct[c + r * table->cf] = opt;
641 memcpy (contents, cp, f.w);
644 /* Sets cell (C,R) in TABLE, with options OPT, to have text value
647 tab_text (struct tab_table *table, int c, int r, unsigned opt, const char *text, ...)
651 assert (table != NULL && text != NULL);
655 assert (c < table->nc);
656 assert (r < table->nr);
660 if (c + table->col_ofs < 0 || r + table->row_ofs < 0
661 || c + table->col_ofs >= table->nc
662 || r + table->row_ofs >= table->nr)
664 printf ("tab_text(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
666 c, table->col_ofs, c + table->col_ofs,
667 r, table->row_ofs, r + table->row_ofs,
668 table->nc, table->nr);
673 va_start (args, text);
674 text_format (table, opt, text, args, &table->cc[c + r * table->cf]);
675 table->ct[c + r * table->cf] = opt;
679 /* Joins cells (X1,X2)-(Y1,Y2) inclusive in TABLE, and sets them with
680 options OPT to have text value TEXT. */
682 tab_joint_text (struct tab_table *table, int x1, int y1, int x2, int y2,
683 unsigned opt, const char *text, ...)
685 struct tab_joined_cell *j;
687 assert (table != NULL && text != NULL);
693 assert (y2 < table->nr);
694 assert (x2 < table->nc);
697 if (x1 + table->col_ofs < 0 || x1 + table->col_ofs >= table->nc
698 || y1 + table->row_ofs < 0 || y1 + table->row_ofs >= table->nr
699 || x2 < x1 || x2 + table->col_ofs >= table->nc
700 || y2 < y2 || y2 + table->row_ofs >= table->nr)
702 printf ("tab_joint_text(): bad cell "
703 "(%d+%d=%d,%d+%d=%d)-(%d+%d=%d,%d+%d=%d) in table size (%d,%d)\n",
704 x1, table->col_ofs, x1 + table->col_ofs,
705 y1, table->row_ofs, y1 + table->row_ofs,
706 x2, table->col_ofs, x2 + table->col_ofs,
707 y2, table->row_ofs, y2 + table->row_ofs,
708 table->nc, table->nr);
713 j = pool_alloc (table->container, sizeof *j);
715 j->x1 = x1 + table->col_ofs;
716 j->y1 = y1 + table->row_ofs;
717 j->x2 = ++x2 + table->col_ofs;
718 j->y2 = ++y2 + table->row_ofs;
723 va_start (args, text);
724 text_format (table, opt, text, args, &j->contents);
731 struct len_string *cc = &table->cc[x1 + y1 * table->cf];
732 unsigned char *ct = &table->ct[x1 + y1 * table->cf];
733 const int ofs = table->cf - (x2 - x1);
737 for (y = y1; y < y2; y++)
741 for (x = x1; x < x2; x++)
743 ls_init (cc++, (char *) j, 0);
753 /* Sets cell (C,R) in TABLE, with options OPT, to contents STRING. */
755 tab_raw (struct tab_table *table, int c, int r, unsigned opt,
756 struct len_string *string)
758 assert (table != NULL && string != NULL);
761 if (c + table->col_ofs < 0 || r + table->row_ofs < 0
762 || c + table->col_ofs >= table->nc
763 || r + table->row_ofs >= table->nr)
765 printf ("tab_float(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
767 c, table->col_ofs, c + table->col_ofs,
768 r, table->row_ofs, r + table->row_ofs,
769 table->nc, table->nr);
774 table->cc[c + r * table->cf] = *string;
775 table->ct[c + r * table->cf] = opt;
780 /* Sets the widths of all the columns and heights of all the rows in
781 table T for driver D. */
783 nowrap_dim (struct tab_table *t, struct outp_driver *d)
785 t->w[0] = tab_natural_width (t, d, 0);
786 t->h[0] = d->font_height;
789 /* Sets the widths of all the columns and heights of all the rows in
790 table T for driver D. */
792 wrap_dim (struct tab_table *t, struct outp_driver *d)
794 t->w[0] = tab_natural_width (t, d, 0);
795 t->h[0] = tab_natural_height (t, d, 0);
798 /* Outputs text BUF as a table with a single cell having cell options
799 OPTIONS, which is a combination of the TAB_* and TAT_*
802 tab_output_text (int options, const char *buf, ...)
804 struct tab_table *t = tab_create (1, 1, 0);
806 assert (buf != NULL);
807 if (options & TAT_PRINTF)
810 char *temp_buf = local_alloc (4096);
812 va_start (args, buf);
813 nvsprintf (temp_buf, buf, args);
818 if (options & TAT_FIX)
820 struct outp_driver *d;
822 for (d = outp_drivers (NULL); d; d = outp_drivers (d))
825 d->class->open_page (d);
827 if (d->class->text_set_font_by_name != NULL)
828 d->class->text_set_font_by_name (d, "FIXED");
836 tab_text (t, 0, 0, options &~ TAT_PRINTF, buf);
837 tab_flags (t, SOMF_NO_TITLE | SOMF_NO_SPACING);
838 if (options & TAT_NOWRAP)
839 tab_dim (t, nowrap_dim);
841 tab_dim (t, wrap_dim);
844 if (options & TAT_FIX)
846 struct outp_driver *d;
848 for (d = outp_drivers (NULL); d; d = outp_drivers (d))
849 if (d->class->text_set_font_by_name != NULL)
850 d->class->text_set_font_by_name (d, "PROP");
857 if (options & TAT_PRINTF)
861 /* Set table flags to FLAGS. */
863 tab_flags (struct tab_table *t, unsigned flags)
869 /* Easy, type-safe way to submit a tab table to som. */
871 tab_submit (struct tab_table *t)
876 s.class = &tab_table_class;
884 /* Set table row and column offsets for all functions that affect
887 tab_offset (struct tab_table *t, int col, int row)
893 if (row < -1 || row >= t->nr)
895 printf ("tab_offset(): row=%d in %d-row table\n", row, t->nr);
898 if (col < -1 || col >= t->nc)
900 printf ("tab_offset(): col=%d in %d-column table\n", col, t->nc);
906 diff += (row - t->row_ofs) * t->cf, t->row_ofs = row;
908 diff += (col - t->col_ofs), t->col_ofs = col;
914 /* Increment the row offset by one. If the table is too small,
915 increase its size. */
917 tab_next_row (struct tab_table *t)
922 if (++t->row_ofs >= t->nr)
923 tab_realloc (t, -1, t->nr * 4 / 3);
926 static struct tab_table *t;
927 static struct outp_driver *d;
930 /* Set the current table to TABLE. */
932 tabi_table (struct som_table *table)
934 assert (table != NULL);
936 tab_offset (t, 0, 0);
938 assert (t->w == NULL && t->h == NULL);
939 t->w = pool_alloc (t->container, sizeof *t->w * t->nc);
940 t->h = pool_alloc (t->container, sizeof *t->h * t->nr);
943 /* Set the current output device to DRIVER. */
945 tabi_driver (struct outp_driver *driver)
949 assert (driver != NULL);
952 /* Figure out sizes of rules. */
953 for (t->hr_tot = i = 0; i <= t->nr; i++)
954 t->hr_tot += t->hrh[i] = d->horiz_line_spacing[t->trh[i]];
955 for (t->vr_tot = i = 0; i <= t->nc; i++)
956 t->vr_tot += t->wrv[i] = d->vert_line_spacing[t->trv[i]];
959 for (i = 0; i < t->nr; i++)
961 for (i = 0; i < t->nc; i++)
965 assert (t->dim != NULL);
972 for (i = 0; i < t->nr; i++)
976 printf ("Table row %d height not initialized.\n", i);
979 assert (t->h[i] > 0);
982 for (i = 0; i < t->nc; i++)
986 printf ("Table column %d width not initialized.\n", i);
989 assert (t->w[i] > 0);
994 /* Add up header sizes. */
995 for (i = 0, t->wl = t->wrv[0]; i < t->l; i++)
996 t->wl += t->w[i] + t->wrv[i + 1];
997 for (i = 0, t->ht = t->hrh[0]; i < t->t; i++)
998 t->ht += t->h[i] + t->hrh[i + 1];
999 for (i = t->nc - t->r, t->wr = t->wrv[i]; i < t->nc; i++)
1000 t->wr += t->w[i] + t->wrv[i + 1];
1001 for (i = t->nr - t->b, t->hb = t->hrh[i]; i < t->nr; i++)
1002 t->hb += t->h[i] + t->hrh[i + 1];
1005 if (!(t->flags & SOMF_NO_TITLE))
1006 t->ht += d->font_height;
1009 /* Return the number of columns and rows in the table into N_COLUMNS
1010 and N_ROWS, respectively. */
1012 tabi_count (int *n_columns, int *n_rows)
1014 assert (n_columns != NULL && n_rows != NULL);
1019 static void tabi_cumulate (int cumtype, int start, int *end, int max, int *actual);
1021 /* Return the horizontal and vertical size of the entire table,
1022 including headers, for the current output device, into HORIZ and
1025 tabi_area (int *horiz, int *vert)
1027 assert (horiz != NULL && vert != NULL);
1032 for (c = t->l + 1, w = t->wl + t->wr + t->w[t->l];
1033 c < t->nc - t->r; c++)
1034 w += t->w[c] + t->wrv[c];
1040 for (r = t->t + 1, h = t->ht + t->hb + t->h[t->t];
1041 r < t->nr - t->b; r++)
1042 h += t->h[r] + t->hrh[r];
1047 /* Return the column style for this table into STYLE. */
1049 tabi_columns (int *style)
1051 assert (style != NULL);
1052 *style = t->col_style;
1055 /* Return the number of header rows/columns on the left, right, top,
1056 and bottom sides into HL, HR, HT, and HB, respectively. */
1058 tabi_headers (int *hl, int *hr, int *ht, int *hb)
1060 assert (hl != NULL && hr != NULL && ht != NULL && hb != NULL);
1067 /* Determines the number of rows or columns (including appropriate
1068 headers), depending on CUMTYPE, that will fit into the space
1069 specified. Takes rows/columns starting at index START and attempts
1070 to fill up available space MAX. Returns in END the index of the
1071 last row/column plus one; returns in ACTUAL the actual amount of
1072 space the selected rows/columns (including appropriate headers)
1075 tabi_cumulate (int cumtype, int start, int *end, int max, int *actual)
1082 assert (end != NULL && (cumtype == SOM_ROWS || cumtype == SOM_COLUMNS));
1083 if (cumtype == SOM_ROWS)
1085 assert (start >= 0 && start < t->nr);
1088 r = &t->hrh[start + 1];
1089 total = t->ht + t->hb;
1091 assert (start >= 0 && start < t->nc);
1094 r = &t->wrv[start + 1];
1095 total = t->wl + t->wr;
1111 for (x = start + 1; x < n; x++)
1113 int amt = *d++ + *r++;
1131 /* Return flags set for the current table into FLAGS. */
1133 tabi_flags (unsigned *flags)
1135 assert (flags != NULL);
1139 /* Render title for current table, with major index X and minor index
1140 Y. Y may be zero, or X and Y may be zero, but X should be nonzero
1143 tabi_title (int x, int y)
1148 if (t->flags & SOMF_NO_TITLE)
1151 cp = spprintf (buf, "%d.%d", table_num, subtable_num);
1153 cp = spprintf (cp, "(%d:%d)", x, y);
1155 cp = spprintf (cp, "(%d)", x);
1157 cp = spprintf (cp, " %s", cur_proc);
1158 cp = stpcpy (cp, ". ");
1159 if (!ls_empty_p (&t->title))
1161 memcpy (cp, ls_value (&t->title), ls_length (&t->title));
1162 cp += ls_length (&t->title);
1167 struct outp_text text;
1169 text.options = OUTP_T_JUST_LEFT | OUTP_T_HORZ | OUTP_T_VERT;
1170 ls_init (&text.s, buf, cp - buf);
1172 text.v = d->font_height;
1175 d->class->text_draw (d, &text);
1179 static int render_strip (int x, int y, int r, int c1, int c2, int r1, int r2);
1181 /* Draws the table region in rectangle (X1,Y1)-(X2,Y2), where column
1182 X2 and row Y2 are not included in the rectangle, at the current
1183 position on the current output device. Draws headers as well. */
1185 tabi_render (int x1, int y1, int x2, int y2)
1193 if (!(t->flags & SOMF_NO_TITLE))
1194 y += d->font_height;
1198 ranges[0][1] = t->t * 2 + 1;
1200 /* Requested rows. */
1201 ranges[1][0] = y1 * 2 + 1;
1202 ranges[1][1] = y2 * 2;
1204 /* Bottom headers. */
1205 ranges[2][0] = (t->nr - t->b) * 2;
1206 ranges[2][1] = t->nr * 2 + 1;
1208 for (i = 0; i < 3; i++)
1212 for (r = ranges[i][0]; r < ranges[i][1]; r++)
1215 x += render_strip (x, y, r, 0, t->l * 2 + 1, y1, y2);
1216 x += render_strip (x, y, r, x1 * 2 + 1, x2 * 2, y1, y2);
1217 x += render_strip (x, y, r, (t->nc - t->r) * 2,
1218 t->nc * 2 + 1, y1, y2);
1219 y += (r & 1) ? t->h[r / 2] : t->hrh[r / 2];
1224 struct som_table_class tab_table_class =
1247 /* Render contiguous strip consisting of columns C1...C2, exclusive,
1248 on row R, at location (X,Y). Return width of the strip thus
1251 Renders joined cells, even those outside the strip, within the
1252 rendering region (C1,R1)-(C2,R2).
1254 For the purposes of counting rows and columns in this function
1255 only, horizontal rules are considered rows and vertical rules are
1258 FIXME: Doesn't use r1? Huh? */
1260 render_strip (int x, int y, int r, int c1, int c2, int r1 unused, int r2)
1264 /* Horizontal rules. */
1267 int hrh = t->hrh[r / 2];
1270 for (c = c1; c < c2; c++)
1274 int style = t->rh[(c / 2) + (r / 2 * t->cf)];
1278 const struct color clr = {0, 0, 0, 0};
1283 rct.x2 = x + t->w[c / 2];
1285 d->class->line_horz (d, &rct, &clr, style);
1289 const struct color clr = {0, 0, 0, 0};
1291 struct outp_styles s;
1295 rct.x2 = x + t->wrv[c / 2];
1298 s.t = r > 0 ? t->rv[(c / 2) + (t->cf + 1) * (r / 2 - 1)] : 0;
1299 s.b = r < 2 * t->nr ? t->rv[(c / 2) + (t->cf + 1) * (r / 2)] : 0;
1300 s.l = c > 0 ? t->rh[(c / 2 - 1) + t->cf * (r / 2)] : 0;
1301 s.r = c < 2 * t->nc ? t->rh[(c / 2) + t->cf * (r / 2)] : 0;
1303 if (s.t | s.b | s.l | s.r)
1304 d->class->line_intersection (d, &rct, &clr, &s);
1312 for (c = c1; c < c2; c++)
1316 const int index = (c / 2) + (r / 2 * t->cf);
1318 if (!(t->ct[index] & TAB_JOIN))
1320 struct outp_text text;
1322 text.options = ((t->ct[index] & OUTP_T_JUST_MASK)
1323 | OUTP_T_HORZ | OUTP_T_VERT);
1324 if ((t->ct[index] & TAB_EMPTY) == 0)
1326 text.s = t->cc[index];
1327 assert (!ls_null_p (&text.s));
1328 text.h = t->w[c / 2];
1329 text.v = t->h[r / 2];
1332 d->class->text_draw (d, &text);
1335 struct tab_joined_cell *j =
1336 (struct tab_joined_cell *) ls_value (&t->cc[index]);
1338 if (j->hit != tab_hit)
1342 if (j->x1 == c / 2 && j->y1 == r / 2
1343 && j->x2 <= c2 && j->y2 <= r2)
1345 struct outp_text text;
1347 text.options = ((t->ct[index] & OUTP_T_JUST_MASK)
1348 | OUTP_T_HORZ | OUTP_T_VERT);
1349 text.s = j->contents;
1356 for (c = j->x1, text.h = -t->wrv[j->x2];
1358 text.h += t->w[c] + t->wrv[c + 1];
1364 for (r = j->y1, text.v = -t->hrh[j->y2];
1366 text.v += t->h[r] + t->hrh[r + 1];
1368 d->class->text_draw (d, &text);
1374 int style = t->rv[(c / 2) + (r / 2 * (t->cf + 1))];
1378 const struct color clr = {0, 0, 0, 0};
1383 rct.x2 = x + t->wrv[c / 2];
1384 rct.y2 = y + t->h[r / 2];
1385 d->class->line_vert (d, &rct, &clr, style);
1392 return x - x_origin;