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)
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 data_out (contents, f, v);
596 /* Sets cell (C,R) in TABLE, with options OPT, to have value VAL
597 with NDEC decimal places. */
599 tab_float (struct tab_table *table, int c, int r, unsigned char opt,
600 double val, int w, int d)
606 union value double_value;
608 assert (table != NULL && w <= 40);
611 assert (c < table->nc);
613 assert (r < table->nr);
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 double_value.f = val;
634 data_out (buf, &f, &double_value);
637 while (isspace ((unsigned char) *cp) && cp < &buf[w])
639 f.w = w - (cp - buf);
641 contents = pool_alloc (table->container, f.w);
642 ls_init (&table->cc[c + r * table->cf], contents, f.w);
643 table->ct[c + r * table->cf] = opt;
644 memcpy (contents, cp, f.w);
647 /* Sets cell (C,R) in TABLE, with options OPT, to have text value
650 tab_text (struct tab_table *table, int c, int r, unsigned opt, const char *text, ...)
654 assert (table != NULL && text != NULL);
658 assert (c < table->nc);
659 assert (r < table->nr);
663 if (c + table->col_ofs < 0 || r + table->row_ofs < 0
664 || c + table->col_ofs >= table->nc
665 || r + table->row_ofs >= table->nr)
667 printf ("tab_text(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
669 c, table->col_ofs, c + table->col_ofs,
670 r, table->row_ofs, r + table->row_ofs,
671 table->nc, table->nr);
676 va_start (args, text);
677 text_format (table, opt, text, args, &table->cc[c + r * table->cf]);
678 table->ct[c + r * table->cf] = opt;
682 /* Joins cells (X1,X2)-(Y1,Y2) inclusive in TABLE, and sets them with
683 options OPT to have text value TEXT. */
685 tab_joint_text (struct tab_table *table, int x1, int y1, int x2, int y2,
686 unsigned opt, const char *text, ...)
688 struct tab_joined_cell *j;
690 assert (table != NULL && text != NULL);
696 assert (y2 < table->nr);
697 assert (x2 < table->nc);
700 if (x1 + table->col_ofs < 0 || x1 + table->col_ofs >= table->nc
701 || y1 + table->row_ofs < 0 || y1 + table->row_ofs >= table->nr
702 || x2 < x1 || x2 + table->col_ofs >= table->nc
703 || y2 < y2 || y2 + table->row_ofs >= table->nr)
705 printf ("tab_joint_text(): bad cell "
706 "(%d+%d=%d,%d+%d=%d)-(%d+%d=%d,%d+%d=%d) in table size (%d,%d)\n",
707 x1, table->col_ofs, x1 + table->col_ofs,
708 y1, table->row_ofs, y1 + table->row_ofs,
709 x2, table->col_ofs, x2 + table->col_ofs,
710 y2, table->row_ofs, y2 + table->row_ofs,
711 table->nc, table->nr);
716 j = pool_alloc (table->container, sizeof *j);
718 j->x1 = x1 + table->col_ofs;
719 j->y1 = y1 + table->row_ofs;
720 j->x2 = ++x2 + table->col_ofs;
721 j->y2 = ++y2 + table->row_ofs;
726 va_start (args, text);
727 text_format (table, opt, text, args, &j->contents);
734 struct len_string *cc = &table->cc[x1 + y1 * table->cf];
735 unsigned char *ct = &table->ct[x1 + y1 * table->cf];
736 const int ofs = table->cf - (x2 - x1);
740 for (y = y1; y < y2; y++)
744 for (x = x1; x < x2; x++)
746 ls_init (cc++, (char *) j, 0);
756 /* Sets cell (C,R) in TABLE, with options OPT, to contents STRING. */
758 tab_raw (struct tab_table *table, int c, int r, unsigned opt,
759 struct len_string *string)
761 assert (table != NULL && string != NULL);
764 if (c + table->col_ofs < 0 || r + table->row_ofs < 0
765 || c + table->col_ofs >= table->nc
766 || r + table->row_ofs >= table->nr)
768 printf ("tab_float(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
770 c, table->col_ofs, c + table->col_ofs,
771 r, table->row_ofs, r + table->row_ofs,
772 table->nc, table->nr);
777 table->cc[c + r * table->cf] = *string;
778 table->ct[c + r * table->cf] = opt;
783 /* Sets the widths of all the columns and heights of all the rows in
784 table T for driver D. */
786 nowrap_dim (struct tab_table *t, struct outp_driver *d)
788 t->w[0] = tab_natural_width (t, d, 0);
789 t->h[0] = d->font_height;
792 /* Sets the widths of all the columns and heights of all the rows in
793 table T for driver D. */
795 wrap_dim (struct tab_table *t, struct outp_driver *d)
797 t->w[0] = tab_natural_width (t, d, 0);
798 t->h[0] = tab_natural_height (t, d, 0);
801 /* Outputs text BUF as a table with a single cell having cell options
802 OPTIONS, which is a combination of the TAB_* and TAT_*
805 tab_output_text (int options, const char *buf, ...)
807 struct tab_table *t = tab_create (1, 1, 0);
809 assert (buf != NULL);
810 if (options & TAT_PRINTF)
813 char *temp_buf = local_alloc (4096);
815 va_start (args, buf);
816 nvsprintf (temp_buf, buf, args);
821 if (options & TAT_FIX)
823 struct outp_driver *d;
825 for (d = outp_drivers (NULL); d; d = outp_drivers (d))
828 d->class->open_page (d);
830 if (d->class->text_set_font_by_name != NULL)
831 d->class->text_set_font_by_name (d, "FIXED");
839 tab_text (t, 0, 0, options &~ TAT_PRINTF, buf);
840 tab_flags (t, SOMF_NO_TITLE | SOMF_NO_SPACING);
841 if (options & TAT_NOWRAP)
842 tab_dim (t, nowrap_dim);
844 tab_dim (t, wrap_dim);
847 if (options & TAT_FIX)
849 struct outp_driver *d;
851 for (d = outp_drivers (NULL); d; d = outp_drivers (d))
852 if (d->class->text_set_font_by_name != NULL)
853 d->class->text_set_font_by_name (d, "PROP");
860 if (options & TAT_PRINTF)
864 /* Set table flags to FLAGS. */
866 tab_flags (struct tab_table *t, unsigned flags)
872 /* Easy, type-safe way to submit a tab table to som. */
874 tab_submit (struct tab_table *t)
879 s.class = &tab_table_class;
887 /* Set table row and column offsets for all functions that affect
890 tab_offset (struct tab_table *t, int col, int row)
896 if (row < -1 || row >= t->nr)
898 printf ("tab_offset(): row=%d in %d-row table\n", row, t->nr);
901 if (col < -1 || col >= t->nc)
903 printf ("tab_offset(): col=%d in %d-column table\n", col, t->nc);
909 diff += (row - t->row_ofs) * t->cf, t->row_ofs = row;
911 diff += (col - t->col_ofs), t->col_ofs = col;
917 /* Increment the row offset by one. If the table is too small,
918 increase its size. */
920 tab_next_row (struct tab_table *t)
925 if (++t->row_ofs >= t->nr)
926 tab_realloc (t, -1, t->nr * 4 / 3);
929 static struct tab_table *t;
930 static struct outp_driver *d;
933 /* Set the current table to TABLE. */
935 tabi_table (struct som_table *table)
937 assert (table != NULL);
939 tab_offset (t, 0, 0);
941 assert (t->w == NULL && t->h == NULL);
942 t->w = pool_alloc (t->container, sizeof *t->w * t->nc);
943 t->h = pool_alloc (t->container, sizeof *t->h * t->nr);
946 /* Set the current output device to DRIVER. */
948 tabi_driver (struct outp_driver *driver)
952 assert (driver != NULL);
955 /* Figure out sizes of rules. */
956 for (t->hr_tot = i = 0; i <= t->nr; i++)
957 t->hr_tot += t->hrh[i] = d->horiz_line_spacing[t->trh[i]];
958 for (t->vr_tot = i = 0; i <= t->nc; i++)
959 t->vr_tot += t->wrv[i] = d->vert_line_spacing[t->trv[i]];
962 for (i = 0; i < t->nr; i++)
964 for (i = 0; i < t->nc; i++)
968 assert (t->dim != NULL);
975 for (i = 0; i < t->nr; i++)
979 printf ("Table row %d height not initialized.\n", i);
982 assert (t->h[i] > 0);
985 for (i = 0; i < t->nc; i++)
989 printf ("Table column %d width not initialized.\n", i);
992 assert (t->w[i] > 0);
997 /* Add up header sizes. */
998 for (i = 0, t->wl = t->wrv[0]; i < t->l; i++)
999 t->wl += t->w[i] + t->wrv[i + 1];
1000 for (i = 0, t->ht = t->hrh[0]; i < t->t; i++)
1001 t->ht += t->h[i] + t->hrh[i + 1];
1002 for (i = t->nc - t->r, t->wr = t->wrv[i]; i < t->nc; i++)
1003 t->wr += t->w[i] + t->wrv[i + 1];
1004 for (i = t->nr - t->b, t->hb = t->hrh[i]; i < t->nr; i++)
1005 t->hb += t->h[i] + t->hrh[i + 1];
1008 if (!(t->flags & SOMF_NO_TITLE))
1009 t->ht += d->font_height;
1012 /* Return the number of columns and rows in the table into N_COLUMNS
1013 and N_ROWS, respectively. */
1015 tabi_count (int *n_columns, int *n_rows)
1017 assert (n_columns != NULL && n_rows != NULL);
1022 static void tabi_cumulate (int cumtype, int start, int *end, int max, int *actual);
1024 /* Return the horizontal and vertical size of the entire table,
1025 including headers, for the current output device, into HORIZ and
1028 tabi_area (int *horiz, int *vert)
1030 assert (horiz != NULL && vert != NULL);
1035 for (c = t->l + 1, w = t->wl + t->wr + t->w[t->l];
1036 c < t->nc - t->r; c++)
1037 w += t->w[c] + t->wrv[c];
1043 for (r = t->t + 1, h = t->ht + t->hb + t->h[t->t];
1044 r < t->nr - t->b; r++)
1045 h += t->h[r] + t->hrh[r];
1050 /* Return the column style for this table into STYLE. */
1052 tabi_columns (int *style)
1054 assert (style != NULL);
1055 *style = t->col_style;
1058 /* Return the number of header rows/columns on the left, right, top,
1059 and bottom sides into HL, HR, HT, and HB, respectively. */
1061 tabi_headers (int *hl, int *hr, int *ht, int *hb)
1063 assert (hl != NULL && hr != NULL && ht != NULL && hb != NULL);
1070 /* Determines the number of rows or columns (including appropriate
1071 headers), depending on CUMTYPE, that will fit into the space
1072 specified. Takes rows/columns starting at index START and attempts
1073 to fill up available space MAX. Returns in END the index of the
1074 last row/column plus one; returns in ACTUAL the actual amount of
1075 space the selected rows/columns (including appropriate headers)
1078 tabi_cumulate (int cumtype, int start, int *end, int max, int *actual)
1085 assert (end != NULL && (cumtype == SOM_ROWS || cumtype == SOM_COLUMNS));
1086 if (cumtype == SOM_ROWS)
1088 assert (start >= 0 && start < t->nr);
1091 r = &t->hrh[start + 1];
1092 total = t->ht + t->hb;
1094 assert (start >= 0 && start < t->nc);
1097 r = &t->wrv[start + 1];
1098 total = t->wl + t->wr;
1114 for (x = start + 1; x < n; x++)
1116 int amt = *d++ + *r++;
1134 /* Return flags set for the current table into FLAGS. */
1136 tabi_flags (unsigned *flags)
1138 assert (flags != NULL);
1142 /* Render title for current table, with major index X and minor index
1143 Y. Y may be zero, or X and Y may be zero, but X should be nonzero
1146 tabi_title (int x, int y)
1151 if (t->flags & SOMF_NO_TITLE)
1154 cp = spprintf (buf, "%d.%d", table_num, subtable_num);
1156 cp = spprintf (cp, "(%d:%d)", x, y);
1158 cp = spprintf (cp, "(%d)", x);
1160 cp = spprintf (cp, " %s", cur_proc);
1161 cp = stpcpy (cp, ". ");
1162 if (!ls_empty_p (&t->title))
1164 memcpy (cp, ls_value (&t->title), ls_length (&t->title));
1165 cp += ls_length (&t->title);
1170 struct outp_text text;
1172 text.options = OUTP_T_JUST_LEFT | OUTP_T_HORZ | OUTP_T_VERT;
1173 ls_init (&text.s, buf, cp - buf);
1175 text.v = d->font_height;
1178 d->class->text_draw (d, &text);
1182 static int render_strip (int x, int y, int r, int c1, int c2, int r1, int r2);
1184 /* Draws the table region in rectangle (X1,Y1)-(X2,Y2), where column
1185 X2 and row Y2 are not included in the rectangle, at the current
1186 position on the current output device. Draws headers as well. */
1188 tabi_render (int x1, int y1, int x2, int y2)
1196 if (!(t->flags & SOMF_NO_TITLE))
1197 y += d->font_height;
1201 ranges[0][1] = t->t * 2 + 1;
1203 /* Requested rows. */
1204 ranges[1][0] = y1 * 2 + 1;
1205 ranges[1][1] = y2 * 2;
1207 /* Bottom headers. */
1208 ranges[2][0] = (t->nr - t->b) * 2;
1209 ranges[2][1] = t->nr * 2 + 1;
1211 for (i = 0; i < 3; i++)
1215 for (r = ranges[i][0]; r < ranges[i][1]; r++)
1218 x += render_strip (x, y, r, 0, t->l * 2 + 1, y1, y2);
1219 x += render_strip (x, y, r, x1 * 2 + 1, x2 * 2, y1, y2);
1220 x += render_strip (x, y, r, (t->nc - t->r) * 2,
1221 t->nc * 2 + 1, y1, y2);
1222 y += (r & 1) ? t->h[r / 2] : t->hrh[r / 2];
1227 struct som_table_class tab_table_class =
1250 /* Render contiguous strip consisting of columns C1...C2, exclusive,
1251 on row R, at location (X,Y). Return width of the strip thus
1254 Renders joined cells, even those outside the strip, within the
1255 rendering region (C1,R1)-(C2,R2).
1257 For the purposes of counting rows and columns in this function
1258 only, horizontal rules are considered rows and vertical rules are
1261 FIXME: Doesn't use r1? Huh? */
1263 render_strip (int x, int y, int r, int c1, int c2, int r1 UNUSED, int r2)
1267 /* Horizontal rules. */
1270 int hrh = t->hrh[r / 2];
1273 for (c = c1; c < c2; c++)
1277 int style = t->rh[(c / 2) + (r / 2 * t->cf)];
1281 const struct color clr = {0, 0, 0, 0};
1286 rct.x2 = x + t->w[c / 2];
1288 d->class->line_horz (d, &rct, &clr, style);
1292 const struct color clr = {0, 0, 0, 0};
1294 struct outp_styles s;
1298 rct.x2 = x + t->wrv[c / 2];
1301 s.t = r > 0 ? t->rv[(c / 2) + (t->cf + 1) * (r / 2 - 1)] : 0;
1302 s.b = r < 2 * t->nr ? t->rv[(c / 2) + (t->cf + 1) * (r / 2)] : 0;
1303 s.l = c > 0 ? t->rh[(c / 2 - 1) + t->cf * (r / 2)] : 0;
1304 s.r = c < 2 * t->nc ? t->rh[(c / 2) + t->cf * (r / 2)] : 0;
1306 if (s.t | s.b | s.l | s.r)
1307 d->class->line_intersection (d, &rct, &clr, &s);
1315 for (c = c1; c < c2; c++)
1319 const int index = (c / 2) + (r / 2 * t->cf);
1321 if (!(t->ct[index] & TAB_JOIN))
1323 struct outp_text text;
1325 text.options = ((t->ct[index] & OUTP_T_JUST_MASK)
1326 | OUTP_T_HORZ | OUTP_T_VERT);
1327 if ((t->ct[index] & TAB_EMPTY) == 0)
1329 text.s = t->cc[index];
1330 assert (!ls_null_p (&text.s));
1331 text.h = t->w[c / 2];
1332 text.v = t->h[r / 2];
1335 d->class->text_draw (d, &text);
1338 struct tab_joined_cell *j =
1339 (struct tab_joined_cell *) ls_value (&t->cc[index]);
1341 if (j->hit != tab_hit)
1345 if (j->x1 == c / 2 && j->y1 == r / 2)
1347 struct outp_text text;
1349 text.options = ((t->ct[index] & OUTP_T_JUST_MASK)
1350 | OUTP_T_HORZ | OUTP_T_VERT);
1351 text.s = j->contents;
1358 for (c = j->x1, text.h = -t->wrv[j->x2];
1359 c < j->x2 && c < c2 / 2; c++)
1360 text.h += t->w[c] + t->wrv[c + 1];
1366 for (r = j->y1, text.v = -t->hrh[j->y2];
1367 r < j->y2 && r < r2 / 2; r++)
1368 text.v += t->h[r] + t->hrh[r + 1];
1370 d->class->text_draw (d, &text);
1376 int style = t->rv[(c / 2) + (r / 2 * (t->cf + 1))];
1380 const struct color clr = {0, 0, 0, 0};
1385 rct.x2 = x + t->wrv[c / 2];
1386 rct.y2 = y + t->h[r / 2];
1387 d->class->line_vert (d, &rct, &clr, style);
1394 return x - x_origin;