?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
grafthistory: support curl
[elinks/elinks-j605.git] / src / document / html / tables.c
blobd9a6ecc96ed8c8a8ea2f668c42365d948f1fa644
1 /* HTML tables renderer */
2
3 #ifdef HAVE_CONFIG_H
4 #include "config.h"
5 #endif
6
7 #include <stdlib.h>
8 #include <string.h>
9
10 #include "elinks.h"
11
12 #include "document/html/parser/parse.h"
13 #include "document/html/parser/table.h"
14 #include "document/html/parser.h"
15 #include "document/html/renderer.h"
16 #include "document/html/tables.h"
17 #include "document/options.h"
18 #include "terminal/draw.h"
19 #include "util/color.h"
20 #include "util/conv.h"
21 #include "util/error.h"
22 #include "util/memory.h"
23 #include "util/string.h"
24
25 /* Unsafe macros */
26 #include "document/html/internal.h"
27
28
29 struct table_frames {
30 unsigned int top:1;
31 unsigned int bottom:1;
32 unsigned int left:1;
33 unsigned int right:1;
34 };
35
36 static void
37 get_table_frames(struct table *table, struct table_frames *result)
38 {
39 assert(table && result);
40
41 if (table->border) {
42 result->top = !!(table->frame & TABLE_FRAME_ABOVE);
43 result->bottom = !!(table->frame & TABLE_FRAME_BELOW);
44 result->left = !!(table->frame & TABLE_FRAME_LHS);
45 result->right = !!(table->frame & TABLE_FRAME_RHS);
46 } else {
47 memset(result, 0, sizeof(*result));
48 }
49 }
50
51 /* Distance of the table from the left margin. */
52 static int
53 get_table_indent(struct html_context *html_context, struct table *table)
54 {
55 int width = par_format.width - table->real_width;
56 int indent;
57
58 switch (table->align) {
59 case ALIGN_CENTER:
60 indent = (width + par_format.leftmargin - par_format.rightmargin) / 2;
61 break;
62
63 case ALIGN_RIGHT:
64 indent = width - par_format.rightmargin;
65 break;
66
67 case ALIGN_LEFT:
68 case ALIGN_JUSTIFY:
69 default:
70 indent = par_format.leftmargin;
71 }
72
73 /* Don't use int_bounds(&x, 0, width) here,
74 * width may be < 0. --Zas */
75 if (indent > width) indent = width;
76 if (indent < 0) indent = 0;
77
78 return indent;
79 }
80
81 static inline struct part *
82 format_cell(struct html_context *html_context, struct table *table,
83 struct table_cell *cell, struct document *document,
84 int x, int y, int width)
85 {
86 if (document) {
87 x += table->part->box.x;
88 y += table->part->box.y;
89 }
90
91 return format_html_part(html_context, cell->start, cell->end,
92 cell->align, table->cellpadding, width,
93 document, x, y, NULL, cell->link_num);
94 }
95
96 static inline void
97 get_cell_width(struct html_context *html_context,
98 unsigned char *start, unsigned char *end,
99 int cellpadding, int width,
100 int a, int *min, int *max,
101 int link_num, int *new_link_num)
102 {
103 struct part *part;
104
105 if (min) *min = -1;
106 if (max) *max = -1;
107 if (new_link_num) *new_link_num = link_num;
108
109 part = format_html_part(html_context, start, end, ALIGN_LEFT,
110 cellpadding, width, NULL,
111 !!a, !!a, NULL, link_num);
112 if (!part) return;
113
114 if (min) *min = part->box.width;
115 if (max) *max = part->max_width;
116 if (new_link_num) *new_link_num = part->link_num;
117
118 if (min && max) {
119 assertm(*min <= *max, "get_cell_width: %d > %d", *min, *max);
120 }
121
122 mem_free(part);
123 }
124
125 static void
126 get_cell_widths(struct html_context *html_context, struct table *table)
127 {
128 int link_num = table->part->link_num;
129
130 if (!html_context->options->table_order) {
131 int col, row;
132
133 for (row = 0; row < table->rows; row++)
134 for (col = 0; col < table->cols; col++) {
135 struct table_cell *cell = CELL(table, col, row);
136
137 if (!cell->start) continue;
138 cell->link_num = link_num;
139 get_cell_width(html_context, cell->start,
140 cell->end, table->cellpadding,
141 0, 0, &cell->min_width,
142 &cell->max_width,
143 link_num, &link_num);
144 }
145 } else {
146 int col, row;
147
148 for (col = 0; col < table->cols; col++)
149 for (row = 0; row < table->rows; row++) {
150 struct table_cell *cell = CELL(table, col, row);
151
152 if (!cell->start) continue;
153 cell->link_num = link_num;
154 get_cell_width(html_context, cell->start,
155 cell->end, table->cellpadding,
156 0, 0, &cell->min_width,
157 &cell->max_width,
158 link_num, &link_num);
159 }
160 }
161
162 table->link_num = link_num;
163 }
164
165 static inline void
166 distribute_values(int *values, int count, int wanted, int *limits)
167 {
168 int i;
169 int sum = 0, d, r, t;
170
171 for (i = 0; i < count; i++) sum += values[i];
172 if (sum >= wanted) return;
173
174 again:
175 t = wanted - sum;
176 d = t / count;
177 r = t % count;
178 wanted = 0;
179
180 if (limits) {
181 for (i = 0; i < count; i++) {
182 int delta;
183
184 values[i] += d + (i < r);
185
186 delta = values[i] - limits[i];
187 if (delta > 0) {
188 wanted += delta;
189 values[i] = limits[i];
190 }
191 }
192 } else {
193 for (i = 0; i < count; i++) {
194 values[i] += d + (i < r);
195 }
196 }
197
198 if (wanted) {
199 assertm(limits, "bug in distribute_values()");
200 limits = NULL;
201 sum = 0;
202 goto again;
203 }
204 }
205
206
207 /* Returns: -1 none, 0, space, 1 line, 2 double */
208 static inline int
209 get_vline_width(struct table *table, int col)
210 {
211 int width = 0;
212
213 if (!col) return -1;
214
215 if (table->rules == TABLE_RULE_COLS || table->rules == TABLE_RULE_ALL)
216 width = table->cellspacing;
217 else if (table->rules == TABLE_RULE_GROUPS)
218 width = (col < table->columns_count && table->columns[col].group);
219
220 if (!width && table->cellpadding) width = -1;
221
222 return width;
223 }
224
225 static int
226 get_hline_width(struct table *table, int row)
227 {
228 if (!row) return -1;
229
230 if (table->rules == TABLE_RULE_ROWS || table->rules == TABLE_RULE_ALL) {
231 if (table->cellspacing || table->vcellpadding)
232 return table->cellspacing;
233 return -1;
234
235 } else if (table->rules == TABLE_RULE_GROUPS) {
236 int col;
237
238 for (col = 0; col < table->cols; col++)
239 if (CELL(table, col, row)->is_group) {
240 if (table->cellspacing || table->vcellpadding)
241 return table->cellspacing;
242 return -1;
243 }
244 }
245
246 return table->vcellpadding ? 0 : -1;
247 }
248
249 #define has_vline_width(table, col) (get_vline_width(table, col) >= 0)
250 #define has_hline_width(table, row) (get_hline_width(table, row) >= 0)
251
252
253 static int
254 get_column_widths(struct table *table)
255 {
256 int colspan;
257
258 if (!table->cols) return -1; /* prevents calloc(0, ...) calls */
259
260 if (!table->min_cols_widths) {
261 table->min_cols_widths = mem_calloc(table->cols, sizeof(*table->min_cols_widths));
262 if (!table->min_cols_widths) return -1;
263 }
264
265 if (!table->max_cols_widths) {
266 table->max_cols_widths = mem_calloc(table->cols, sizeof(*table->max_cols_widths));
267 if (!table->max_cols_widths) {
268 mem_free_set(&table->min_cols_widths, NULL);
269 return -1;
270 }
271 }
272
273 if (!table->cols_widths) {
274 table->cols_widths = mem_calloc(table->cols, sizeof(*table->cols_widths));
275 if (!table->cols_widths) {
276 mem_free_set(&table->min_cols_widths, NULL);
277 mem_free_set(&table->max_cols_widths, NULL);
278 return -1;
279 }
280 }
281
282 colspan = 1;
283 do {
284 int col, row;
285 int new_colspan = INT_MAX;
286
287 for (col = 0; col < table->cols; col++) for (row = 0; row < table->rows; row++) {
288 struct table_cell *cell = CELL(table, col, row);
289
290 if (cell->is_spanned || !cell->is_used) continue;
291
292 assertm(cell->colspan + col <= table->cols, "colspan out of table");
293 if_assert_failed return -1;
294
295 if (cell->colspan == colspan) {
296 int k, p = 0;
297
298 for (k = 1; k < colspan; k++)
299 p += has_vline_width(table, col + k);
300
301 distribute_values(&table->min_cols_widths[col],
302 colspan,
303 cell->min_width - p,
304 &table->max_cols_widths[col]);
305
306 distribute_values(&table->max_cols_widths[col],
307 colspan,
308 cell->max_width - p,
309 NULL);
310
311 for (k = 0; k < colspan; k++) {
312 int tmp = col + k;
313
314 int_lower_bound(&table->max_cols_widths[tmp],
315 table->min_cols_widths[tmp]);
316 }
317
318 } else if (cell->colspan > colspan
319 && cell->colspan < new_colspan) {
320 new_colspan = cell->colspan;
321 }
322 }
323 colspan = new_colspan;
324 } while (colspan != INT_MAX);
325
326 return 0;
327 }
328
329 static void
330 get_table_width(struct table *table)
331 {
332 struct table_frames table_frames;
333 int min = 0;
334 int max = 0;
335 int col;
336
337 for (col = 0; col < table->cols; col++) {
338 int vl = has_vline_width(table, col);
339
340 min += vl + table->min_cols_widths[col];
341 max += vl + table->max_cols_widths[col];
342 if (table->cols_x[col] > table->max_cols_widths[col])
343 max += table->cols_x[col];
344 }
345
346 get_table_frames(table, &table_frames);
347
348 table->min_width = min + table_frames.left + table_frames.right;
349 table->max_width = max + table_frames.left + table_frames.right;
350
351 assertm(min <= max, "min(%d) > max(%d)", min, max);
352 /* XXX: Recovery path? --pasky */
353 }
354
355
356 /* Initialize @width and @max_width arrays depending on the @stretch_method */
357 static inline int
358 apply_stretch_method(struct table *table, int widths[], int max_widths[],
359 int stretch_method, int max_cols_width)
360 {
361 int col, total_width = 0;
362
363 for (col = 0; col < table->cols; col++) {
364 switch (stretch_method) {
365 case 0:
366 if (table->cols_widths[col] >= table->cols_x[col])
367 break;
368
369 widths[col] = 1;
370 max_widths[col] = int_min(table->cols_x[col],
371 table->max_cols_widths[col])
372 - table->cols_widths[col];
373 if (max_widths[col] <= 0) widths[col] = 0;
374 break;
375 case 1:
376 if (table->cols_x[col] > WIDTH_RELATIVE)
377 break;
378
379 widths[col] = WIDTH_RELATIVE - table->cols_x[col];
380 max_widths[col] = table->max_cols_widths[col]
381 - table->cols_widths[col];
382 if (max_widths[col] <= 0) widths[col] = 0;
383 break;
384 case 2:
385 if (table->cols_x[col] != WIDTH_AUTO)
386 break;
387 /* Fall-through */
388 case 3:
389 if (table->cols_widths[col] >= table->max_cols_widths[col])
390 break;
391 max_widths[col] = table->max_cols_widths[col]
392 - table->cols_widths[col];
393 if (max_cols_width) {
394 widths[col] = 5 + table->max_cols_widths[col] * 10 / max_cols_width;
395 } else {
396 widths[col] = 1;
397 }
398 break;
399 case 4:
400 if (table->cols_x[col] < 0)
401 break;
402 widths[col] = 1;
403 max_widths[col] = table->cols_x[col]
404 - table->cols_widths[col];
405 if (max_widths[col] <= 0) widths[col] = 0;
406 break;
407 case 5:
408 if (table->cols_x[col] >= 0)
409 break;
410 if (table->cols_x[col] <= WIDTH_RELATIVE) {
411 widths[col] = WIDTH_RELATIVE - table->cols_x[col];
412 } else {
413 widths[col] = 1;
414 }
415 max_widths[col] = INT_MAX;
416 break;
417 case 6:
418 widths[col] = 1;
419 max_widths[col] = INT_MAX;
420 break;
421 default:
422 return -1;
423 }
424
425 total_width += widths[col];
426 }
427
428 return total_width;
429 }
430
431 /* Stretches the table columns by distributed the @spare_width among them.
432 * Returns how much of @spare_width was actually distributed. */
433 static inline int
434 stretch_columns(struct table *table, int widths[], int max_widths[],
435 int spare_width, int total_width)
436 {
437 int total_spare_width = spare_width;
438
439 while (spare_width) {
440 int stretch_width = 0;
441 int stretch_col = -1;
442 int col;
443
444 for (col = 0; col < table->cols; col++) {
445 int col_spare_width;
446
447 if (!widths[col])
448 continue;
449
450 col_spare_width = total_spare_width * widths[col] / total_width;
451 int_bounds(&col_spare_width, 1, max_widths[col]);
452
453 if (col_spare_width > stretch_width) {
454 stretch_width = col_spare_width;
455 stretch_col = col;
456 }
457 }
458
459 /* Got stretch column? */
460 if (stretch_col == -1)
461 break;
462
463 /* Mark the column as visited */
464 widths[stretch_col] = 0;
465
466 if (stretch_width > spare_width)
467 stretch_width = spare_width;
468 assertm(stretch_width >= 0, "shrinking cell");
469
470 table->cols_widths[stretch_col] += stretch_width;
471 spare_width -= stretch_width;
472 }
473
474 return total_spare_width - spare_width;
475 }
476
477 /* This function distributes space evenly between @table columns so that it
478 * stretches to @width. */
479 static void
480 distribute_widths(struct table *table, int width)
481 {
482 int col;
483 int spare_width = width - table->min_width;
484 int stretch_method = 0;
485 int *widths, *max_widths;
486 int max_cols_width = 0;
487 int cols_array_size;
488
489 if (!table->cols)
490 return;
491
492 assertm(spare_width >= 0, "too small width %d, required %d",
493 width, table->min_width);
494
495 for (col = 0; col < table->cols; col++)
496 int_lower_bound(&max_cols_width, table->max_cols_widths[col]);
497
498 cols_array_size = table->cols * sizeof(*table->cols_widths);
499 memcpy(table->cols_widths, table->min_cols_widths, cols_array_size);
500 table->real_width = width;
501
502 widths = fmem_alloc(cols_array_size);
503 if (!widths) return;
504
505 max_widths = fmem_alloc(cols_array_size);
506 if (!max_widths) goto free_widths;
507
508 while (spare_width) {
509 int stretched, total_width;
510
511 memset(widths, 0, cols_array_size);
512 memset(max_widths, 0, cols_array_size);
513
514 total_width = apply_stretch_method(table, widths, max_widths, stretch_method, max_cols_width);
515 assertm(total_width != -1, "Could not expand table");
516 if_assert_failed break;
517
518 if (!total_width) {
519 stretch_method++;
520 continue;
521 }
522
523 stretched = stretch_columns(table, widths, max_widths, spare_width, total_width);
524 if (!stretched)
525 stretch_method++;
526 else
527 spare_width -= stretched;
528 }
529
530 fmem_free(max_widths);
531 free_widths:
532 fmem_free(widths);
533 }
534
535
536 static int
537 get_table_cellpadding(struct html_context *html_context, struct table *table)
538 {
539 struct part *part = table->part;
540 int cpd_pass = 0, cpd_width = 0, cpd_last = table->cellpadding;
541 int margins = par_format.leftmargin + par_format.rightmargin;
542
543 again:
544 get_cell_widths(html_context, table);
545 if (get_column_widths(table)) return -1;
546
547 get_table_width(table);
548
549 if (!part->document && !part->box.x) {
550 if (!table->full_width)
551 int_upper_bound(&table->max_width, table->width);
552 int_lower_bound(&table->max_width, table->min_width);
553
554 int_lower_bound(&part->max_width, table->max_width + margins);
555 int_lower_bound(&part->box.width, table->min_width + margins);
556
557 return -1;
558 }
559
560 if (!cpd_pass && table->min_width > table->width && table->cellpadding) {
561 table->cellpadding = 0;
562 cpd_pass = 1;
563 cpd_width = table->min_width;
564 goto again;
565 }
566 if (cpd_pass == 1 && table->min_width > cpd_width) {
567 table->cellpadding = cpd_last;
568 cpd_pass = 2;
569 goto again;
570 }
571
572 return 0;
573 }
574
575
576
577 #ifdef HTML_TABLE_2ND_PASS /* This is by default ON! (<setup.h>) */
578 static void
579 check_table_widths(struct html_context *html_context, struct table *table)
580 {
581 int col, row;
582 int colspan;
583 int width, new_width;
584 int max, max_index = 0; /* go away, warning! */
585 int *widths = mem_calloc(table->cols, sizeof(*widths));
586
587 if (!widths) return;
588
589 for (row = 0; row < table->rows; row++) for (col = 0; col < table->cols; col++) {
590 struct table_cell *cell = CELL(table, col, row);
591 int k, p = 0;
592
593 if (!cell->start) continue;
594
595 for (k = 0; k < cell->colspan; k++) {
596 p += table->cols_widths[col + k] +
597 (k && has_vline_width(table, col + k));
598 }
599
600 get_cell_width(html_context, cell->start, cell->end,
601 table->cellpadding, p, 1, &cell->width,
602 NULL, cell->link_num, NULL);
603
604 int_upper_bound(&cell->width, p);
605 }
606
607 colspan = 1;
608 do {
609 int new_colspan = INT_MAX;
610
611 for (col = 0; col < table->cols; col++) for (row = 0; row < table->rows; row++) {
612 struct table_cell *cell = CELL(table, col, row);
613
614 if (!cell->start) continue;
615
616 assertm(cell->colspan + col <= table->cols, "colspan out of table");
617 if_assert_failed goto end;
618
619 if (cell->colspan == colspan) {
620 int k, p = 0;
621
622 for (k = 1; k < colspan; k++)
623 p += has_vline_width(table, col + k);
624
625 distribute_values(&widths[col],
626 colspan,
627 cell->width - p,
628 &table->max_cols_widths[col]);
629
630 } else if (cell->colspan > colspan
631 && cell->colspan < new_colspan) {
632 new_colspan = cell->colspan;
633 }
634 }
635 colspan = new_colspan;
636 } while (colspan != INT_MAX);
637
638 width = new_width = 0;
639 for (col = 0; col < table->cols; col++) {
640 width += table->cols_widths[col];
641 new_width += widths[col];
642 }
643
644 if (new_width > width) {
645 /* INTERNAL("new width(%d) is larger than previous(%d)", new_width, width); */
646 goto end;
647 }
648
649 max = -1;
650 for (col = 0; col < table->cols; col++)
651 if (table->max_cols_widths[col] > max) {
652 max = table->max_cols_widths[col];
653 max_index = col;
654 }
655
656 if (max != -1) {
657 widths[max_index] += width - new_width;
658 if (widths[max_index] <= table->max_cols_widths[max_index]) {
659 mem_free(table->cols_widths);
660 table->cols_widths = widths;
661 return;
662 }
663 }
664
665 end:
666 mem_free(widths);
667 }
668 #endif
669
670
671 static void
672 check_table_height(struct table *table, struct table_frames *frames, int y)
673 {
674 #ifndef CONFIG_FASTMEM
675 /* XXX: Cannot we simply use the @yp value we just calculated
676 * in draw_table_cells()? --pasky */
677 int old_height = table->real_height + table->part->cy;
678 int our_height = frames->top + y + frames->bottom + table->caption_height;
679 int row;
680
681 /* XXX: We cannot use get_table_real_height() because we are
682 * looking one row ahead - which is completely arcane to me.
683 * It makes a difference only when a table uses ruler="groups"
684 * and has non-zero cellspacing or vcellpadding. --pasky */
685
686 for (row = 0; row < table->rows; row++) {
687 our_height += table->rows_heights[row] +
688 (row < table->rows - 1 &&
689 has_hline_width(table, row + 1));
690 }
691
692 assertm(old_height == our_height, "size not matching! %d vs %d",
693 old_height, our_height);
694 #endif
695 }
696
697 static int
698 get_table_caption_height(struct html_context *html_context, struct table *table)
699 {
700 unsigned char *start = table->caption.start;
701 unsigned char *end = table->caption.end;
702 struct part *part;
703
704 if (!start || !end) return 0;
705
706 while (start < end && isspace(*start))
707 start++;
708
709 while (start < end && isspace(end[-1]))
710 end--;
711
712 if (start >= end) return 0;
713
714 part = format_html_part(html_context, start, end, table->align,
715 0, table->real_width, NULL, 0, 0,
716 NULL, table->link_num);
717
718 if (!part) {
719 return 0;
720
721 } else {
722 int height = part->box.height;
723 mem_free(part);
724
725 return height;
726 }
727 }
728
729 static int
730 get_table_real_height(struct table *table)
731 {
732 struct table_frames table_frames;
733 int height;
734 int row;
735
736 get_table_frames(table, &table_frames);
737
738 height = table_frames.top + table_frames.bottom;
739 height += table->caption_height;
740 for (row = 0; row < table->rows; row++) {
741 height += table->rows_heights[row];
742 if (row && has_hline_width(table, row))
743 height++;
744 }
745
746 return height;
747 }
748
749 static void
750 get_table_heights(struct html_context *html_context, struct table *table)
751 {
752 int rowspan;
753 int col, row;
754
755 table->caption_height = get_table_caption_height(html_context, table);
756
757 for (row = 0; row < table->rows; row++) {
758 for (col = 0; col < table->cols; col++) {
759 struct table_cell *cell = CELL(table, col, row);
760 struct part *part;
761 int width = 0, sp;
762
763 if (!cell->is_used || cell->is_spanned) continue;
764
765 for (sp = 0; sp < cell->colspan; sp++) {
766 width += table->cols_widths[col + sp] +
767 (sp < cell->colspan - 1 &&
768 has_vline_width(table, col + sp + 1));
769 }
770
771 part = format_cell(html_context, table, cell, NULL,
772 2, 2, width);
773 if (!part) return;
774
775 cell->height = part->box.height;
776 /* DBG("%d, %d.", width, cell->height); */
777 mem_free(part);
778 }
779 }
780
781 rowspan = 1;
782 do {
783 int new_rowspan = INT_MAX;
784
785 for (row = 0; row < table->rows; row++) {
786 for (col = 0; col < table->cols; col++) {
787 struct table_cell *cell = CELL(table, col, row);
788
789 if (!cell->is_used || cell->is_spanned) continue;
790
791 if (cell->rowspan == rowspan) {
792 int k, p = 0;
793
794 for (k = 1; k < rowspan; k++)
795 p += has_hline_width(table, row + k);
796
797 distribute_values(&table->rows_heights[row],
798 rowspan,
799 cell->height - p,
800 NULL);
801
802 } else if (cell->rowspan > rowspan &&
803 cell->rowspan < new_rowspan) {
804 new_rowspan = cell->rowspan;
805 }
806
807 }
808 }
809 rowspan = new_rowspan;
810 } while (rowspan != INT_MAX);
811
812 table->real_height = get_table_real_height(table);
813 }
814
815 static void
816 draw_table_cell(struct table *table, int col, int row, int x, int y,
817 struct html_context *html_context)
818 {
819 struct table_cell *cell = CELL(table, col, row);
820 struct document *document = table->part->document;
821 struct part *part;
822 int width = 0;
823 int height = 0;
824 int s, tmpy = y;
825 struct html_element *state;
826
827 if (!cell->start) return;
828
829 for (s = 0; s < cell->colspan; s++) {
830 width += table->cols_widths[col + s] +
831 (s < cell->colspan - 1 &&
832 has_vline_width(table, col + s + 1));
833 }
834
835 for (s = 0; s < cell->rowspan; s++) {
836 height += table->rows_heights[row + s] +
837 (s < cell->rowspan - 1 &&
838 has_hline_width(table, row + s + 1));
839 }
840
841 state = init_html_parser_state(html_context, ELEMENT_DONT_KILL,
842 cell->align, 0, 0);
843
844 if (cell->is_header) format.style.attr |= AT_BOLD;
845
846 format.style.bg = cell->bgcolor;
847 par_format.bgcolor = cell->bgcolor;
848
849 if (cell->valign == VALIGN_MIDDLE)
850 tmpy += (height - cell->height) / 2;
851 else if (cell->valign == VALIGN_BOTTOM)
852 tmpy += (height - cell->height);
853
854 part = format_cell(html_context, table, cell, document, x, tmpy, width);
855 if (part) {
856 /* The cell content doesn't necessarily fill out the whole cell
857 * height so use the calculated @height because it is an upper
858 * bound. */
859 assert(height >= cell->height);
860
861 /* The line expansion draws the _remaining_ background color of
862 * both untouched lines and lines that doesn't stretch the
863 * whole cell width. */
864 expand_lines(html_context, table->part, x + width - 1, y, height, cell->bgcolor);
865
866 if (cell->fragment_id)
867 add_fragment_identifier(html_context, part,
868 cell->fragment_id);
869 }
870
871 done_html_parser_state(html_context, state);
872
873 if (part) mem_free(part);
874 }
875
876 static void
877 draw_table_cells(struct table *table, int x, int y,
878 struct html_context *html_context)
879 {
880 int col, row;
881 int xp;
882 color_T bgcolor = par_format.bgcolor;
883 struct table_frames table_frames;
884
885 get_table_frames(table, &table_frames);
886
887 if (table->fragment_id)
888 add_fragment_identifier(html_context, table->part,
889 table->fragment_id);
890
891 /* Expand using the background color of the ``parent context'' all the
892 * way down the start of the left edge of the table. */
893 expand_lines(html_context, table->part, x - 1, y, table->real_height, bgcolor);
894
895 xp = x + table_frames.left;
896 for (col = 0; col < table->cols; col++) {
897 int yp = y + table_frames.top;
898
899 for (row = 0; row < table->rows; row++) {
900 int row_height = table->rows_heights[row] +
901 (row < table->rows - 1 && has_hline_width(table, row + 1));
902
903 draw_table_cell(table, col, row, xp, yp, html_context);
904
905 yp += row_height;
906 }
907
908 if (col < table->cols - 1) {
909 xp += table->cols_widths[col] + has_vline_width(table, col + 1);
910 }
911 }
912
913 /* Finish the table drawing by aligning the right and bottom edge of
914 * the table */
915 x += table->real_width - 1;
916 expand_lines(html_context, table->part, x, y, table->real_height, table->bgcolor);
917
918 /* Tables are renderer column-wise which breaks forms where the
919 * form items appears in a column before the actual form tag is
920 * parsed. Consider the folloing example:
921 *
922 * +--------+--------+ Where cell 2 has a <form>-tag
923 * | cell 1 | cell 2 | and cell 3 has an <input>-tag.
924 * +--------+--------+
925 * | cell 3 | cell 4 | The table is rendered by drawing
926 * +--------+--------+ the cells in the order: 1, 3, 2, 4.
927 *
928 * That is the <input>-tag form-item is added before the <form>-tag,
929 * which means a ``dummy'' form to hold it is added too.
930 * Calling check_html_form_hierarchy() will join the the form-item
931 * to the correct form from cell 2. */
932 check_html_form_hierarchy(table->part);
933
934 /* Do a sanity check whether the height is correct */
935 check_table_height(table, &table_frames, y);
936 }
937
938
939 static inline int
940 get_frame_pos(int a, int a_size, int b, int b_size)
941 {
942 assert(a >= -1 || a < a_size + 2 || b >= 0 || b <= b_size);
943 if_assert_failed return 0;
944 return a + 1 + (a_size + 2) * b;
945 }
946
947 #define H_FRAME_POSITION(table, col, row) frame[0][get_frame_pos(col, (table)->cols, row, (table)->rows)]
948 #define V_FRAME_POSITION(table, col, row) frame[1][get_frame_pos(row, (table)->rows, col, (table)->cols)]
949
950 static inline void
951 draw_frame_point(struct table *table, signed char *frame[2], int x, int y,
952 int col, int row, struct html_context *html_context)
953 {
954 static enum border_char const border_chars[81] = {
955 BORDER_NONE, BORDER_SVLINE, BORDER_DVLINE,
956 BORDER_SHLINE, BORDER_SDLCORNER, BORDER_DSDLCORNER,
957 BORDER_DHLINE, BORDER_SDDLCORNER, BORDER_DDLCORNER,
958
959 BORDER_SHLINE, BORDER_SDRCORNER, BORDER_DSDRCORNER,
960 BORDER_SHLINE, BORDER_SUTEE, BORDER_DSUTEE,
961 BORDER_DHLINE, BORDER_SDDLCORNER, BORDER_DDLCORNER,
962
963 BORDER_DHLINE, BORDER_SDDRCORNER, BORDER_DDRCORNER,
964 BORDER_DHLINE, BORDER_SDDRCORNER, BORDER_DDRCORNER,
965 BORDER_DHLINE, BORDER_SDUTEE, BORDER_DUTEE,
966
967 BORDER_SVLINE, BORDER_SVLINE, BORDER_DVLINE,
968 BORDER_SULCORNER, BORDER_SRTEE, BORDER_DSDLCORNER,
969 BORDER_SDULCORNER, BORDER_SDRTEE, BORDER_DDLCORNER,
970
971 BORDER_SURCORNER, BORDER_SLTEE, BORDER_DSDRCORNER,
972 BORDER_SDTEE, BORDER_SCROSS, BORDER_DSUTEE,
973 BORDER_SDULCORNER, BORDER_SDRTEE, BORDER_DDLCORNER,
974
975 BORDER_SDURCORNER, BORDER_SDLTEE, BORDER_DDRCORNER,
976 BORDER_SDURCORNER, BORDER_SDLTEE, BORDER_DDRCORNER,
977 BORDER_SDDTEE, BORDER_SDCROSS, BORDER_DUTEE,
978
979 BORDER_DVLINE, BORDER_DVLINE, BORDER_DVLINE,
980 BORDER_DSULCORNER, BORDER_DSULCORNER, BORDER_DSRTEE,
981 BORDER_DULCORNER, BORDER_DULCORNER, BORDER_DRTEE,
982
983 BORDER_DSURCORNER, BORDER_DSURCORNER, BORDER_DSLTEE,
984 BORDER_DSDTEE, BORDER_DSDTEE, BORDER_DSCROSS,
985 BORDER_DULCORNER, BORDER_DULCORNER, BORDER_DRTEE,
986
987 BORDER_DURCORNER, BORDER_DURCORNER, BORDER_DLTEE,
988 BORDER_DURCORNER, BORDER_DURCORNER, BORDER_DLTEE,
989 BORDER_DDTEE, BORDER_DDTEE, BORDER_DCROSS,
990 };
991 /* Note: I have no clue wether any of these names are suitable but they
992 * should give an idea of what is going on. --jonas */
993 signed char left = H_FRAME_POSITION(table, col - 1, row);
994 signed char right = H_FRAME_POSITION(table, col, row);
995 signed char top = V_FRAME_POSITION(table, col, row - 1);
996 signed char bottom = V_FRAME_POSITION(table, col, row);
997 int pos;
998
999 if (left < 0 && right < 0 && top < 0 && bottom < 0) return;
1000
1001 pos = int_max(top, 0)
1002 + 3 * int_max(right, 0)
1003 + 9 * int_max(left, 0)
1004 + 27 * int_max(bottom, 0);
1005
1006 draw_frame_hchars(table->part, x, y, 1, border_chars[pos],
1007 par_format.bgcolor, table->bordercolor, html_context);
1008 }
1009
1010 static inline void
1011 draw_frame_hline(struct table *table, signed char *frame[2], int x, int y,
1012 int col, int row, struct html_context *html_context)
1013 {
1014 static unsigned char const hltable[] = { ' ', BORDER_SHLINE, BORDER_DHLINE };
1015 int pos = H_FRAME_POSITION(table, col, row);
1016
1017 assertm(pos < 3, "Horizontal table position out of bound [%d]", pos);
1018 if_assert_failed return;
1019
1020 if (pos < 0 || table->cols_widths[col] <= 0) return;
1021
1022 draw_frame_hchars(table->part, x, y, table->cols_widths[col], hltable[pos],
1023 par_format.bgcolor, table->bordercolor, html_context);
1024 }
1025
1026 static inline void
1027 draw_frame_vline(struct table *table, signed char *frame[2], int x, int y,
1028 int col, int row, struct html_context *html_context)
1029 {
1030 static unsigned char const vltable[] = { ' ', BORDER_SVLINE, BORDER_DVLINE };
1031 int pos = V_FRAME_POSITION(table, col, row);
1032
1033 assertm(pos < 3, "Vertical table position out of bound [%d]", pos);
1034 if_assert_failed return;
1035
1036 if (pos < 0 || table->rows_heights[row] <= 0) return;
1037
1038 draw_frame_vchars(table->part, x, y, table->rows_heights[row], vltable[pos],
1039 par_format.bgcolor, table->bordercolor, html_context);
1040 }
1041
1042 static inline int
1043 table_row_has_group(struct table *table, int row)
1044 {
1045 int col;
1046
1047 for (col = 0; col < table->cols; col++)
1048 if (CELL(table, col, row)->is_group)
1049 return 1;
1050
1051 return 0;
1052 }
1053
1054 static void
1055 init_table_rules(struct table *table, signed char *frame[2])
1056 {
1057 int col, row;
1058
1059 for (row = 0; row < table->rows; row++) for (col = 0; col < table->cols; col++) {
1060 int xsp, ysp;
1061 struct table_cell *cell = CELL(table, col, row);
1062
1063 if (!cell->is_used || cell->is_spanned) continue;
1064
1065 xsp = cell->colspan ? cell->colspan : table->cols - col;
1066 ysp = cell->rowspan ? cell->rowspan : table->rows - row;
1067
1068 if (table->rules != TABLE_RULE_COLS) {
1069 memset(&H_FRAME_POSITION(table, col, row), table->cellspacing, xsp);
1070 memset(&H_FRAME_POSITION(table, col, row + ysp), table->cellspacing, xsp);
1071 }
1072
1073 if (table->rules != TABLE_RULE_ROWS) {
1074 memset(&V_FRAME_POSITION(table, col, row), table->cellspacing, ysp);
1075 memset(&V_FRAME_POSITION(table, col + xsp, row), table->cellspacing, ysp);
1076 }
1077 }
1078
1079 if (table->rules == TABLE_RULE_GROUPS) {
1080 for (col = 1; col < table->cols; col++) {
1081 if (table->cols_x[col])
1082 continue;
1083
1084 memset(&V_FRAME_POSITION(table, col, 0), 0, table->rows);
1085 }
1086
1087 for (row = 1; row < table->rows; row++) {
1088 if (table_row_has_group(table, row))
1089 continue;
1090
1091 memset(&H_FRAME_POSITION(table, 0, row), 0, table->cols);
1092 }
1093 }
1094 }
1095
1096 static void
1097 draw_table_frames(struct table *table, int indent, int y,
1098 struct html_context *html_context)
1099 {
1100 struct table_frames table_frames;
1101 signed char *frame[2];
1102 int col, row;
1103 int cx, cy;
1104 int fh_size = (table->cols + 2) * (table->rows + 1);
1105 int fv_size = (table->cols + 1) * (table->rows + 2);
1106
1107 frame[0] = fmem_alloc(fh_size + fv_size);
1108 if (!frame[0]) return;
1109 memset(frame[0], -1, fh_size + fv_size);
1110
1111 frame[1] = &frame[0][fh_size];
1112
1113 if (table->rules != TABLE_RULE_NONE)
1114 init_table_rules(table, frame);
1115
1116 get_table_frames(table, &table_frames);
1117 memset(&H_FRAME_POSITION(table, 0, 0), table_frames.top, table->cols);
1118 memset(&H_FRAME_POSITION(table, 0, table->rows), table_frames.bottom, table->cols);
1119 memset(&V_FRAME_POSITION(table, 0, 0), table_frames.left, table->rows);
1120 memset(&V_FRAME_POSITION(table, table->cols, 0), table_frames.right, table->rows);
1121
1122 cy = y;
1123 for (row = 0; row <= table->rows; row++) {
1124 cx = indent;
1125 if ((row > 0 && row < table->rows && has_hline_width(table, row))
1126 || (row == 0 && table_frames.top)
1127 || (row == table->rows && table_frames.bottom)) {
1128 int w = table_frames.left ? table->border : -1;
1129
1130 for (col = 0; col < table->cols; col++) {
1131 if (col > 0)
1132 w = get_vline_width(table, col);
1133
1134 if (w >= 0) {
1135 draw_frame_point(table, frame, cx, cy, col, row,
1136 html_context);
1137 if (row < table->rows)
1138 draw_frame_vline(table, frame, cx, cy + 1, col, row, html_context);
1139 cx++;
1140 }
1141
1142 draw_frame_hline(table, frame, cx, cy, col, row,
1143 html_context);
1144 cx += table->cols_widths[col];
1145 }
1146
1147 if (table_frames.right) {
1148 draw_frame_point(table, frame, cx, cy, col, row,
1149 html_context);
1150 if (row < table->rows)
1151 draw_frame_vline(table, frame, cx, cy + 1, col, row, html_context);
1152 cx++;
1153 }
1154
1155 cy++;
1156
1157 } else if (row < table->rows) {
1158 for (col = 0; col <= table->cols; col++) {
1159 if ((col > 0 && col < table->cols && has_vline_width(table, col))
1160 || (col == 0 && table_frames.left)
1161 || (col == table->cols && table_frames.right)) {
1162 draw_frame_vline(table, frame, cx, cy, col, row, html_context);
1163 cx++;
1164 }
1165 if (col < table->cols) cx += table->cols_widths[col];
1166 }
1167 }
1168
1169 if (row < table->rows) cy += table->rows_heights[row];
1170 }
1171
1172 fmem_free(frame[0]);
1173 }
1174
1175 static void
1176 draw_table_caption(struct html_context *html_context, struct table *table,
1177 int x, int y)
1178 {
1179 unsigned char *start = table->caption.start;
1180 unsigned char *end = table->caption.end;
1181 struct part *part;
1182
1183 if (!start || !end) return;
1184
1185 while (start < end && isspace(*start))
1186 start++;
1187
1188 while (start < end && isspace(end[-1]))
1189 end--;
1190
1191 if (start >= end) return;
1192
1193 part = format_html_part(html_context, start, end, table->align,
1194 0, table->real_width, table->part->document, x, y,
1195 NULL, table->link_num);
1196
1197 if (!part) return;
1198
1199 table->part->cy += part->box.height;
1200 table->part->cx = -1;
1201 table->part->link_num = part->link_num;
1202 mem_free(part);
1203 }
1204
1205 /* This renders tag soup elements that the parser detected while chewing it's
1206 * way through the table HTML. */
1207 static void
1208 draw_table_bad_html(struct html_context *html_context, struct table *table)
1209 {
1210 int i;
1211
1212 for (i = 0; i < table->bad_html_size; i++) {
1213 struct html_start_end *html = &table->bad_html[i];
1214 unsigned char *start = html->start;
1215 unsigned char *end = html->end;
1216
1217 while (start < end && isspace(*start))
1218 start++;
1219
1220 while (start < end && isspace(end[-1]))
1221 end--;
1222
1223 if (start >= end) continue;
1224
1225 parse_html(start, end, table->part, NULL, html_context);
1226 }
1227 }
1228
1229 static void
1230 distribute_table_widths(struct table *table)
1231 {
1232 int width = table->width;
1233
1234 if (table->min_width >= width)
1235 width = table->min_width;
1236 else if (table->max_width < width && table->full_width)
1237 width = table->max_width;
1238
1239 distribute_widths(table, width);
1240 }
1241
1242 void
1243 format_table(unsigned char *attr, unsigned char *html, unsigned char *eof,
1244 unsigned char **end, struct html_context *html_context)
1245 {
1246 struct part *part = html_context->part;
1247 struct table *table;
1248 struct node *node, *new_node;
1249 struct html_element *state;
1250 int indent, margins;
1251
1252 html_context->table_level++;
1253
1254 table = parse_table(html, eof, end, attr, (part->document || part->box.x),
1255 html_context);
1256 if (!table) goto ret0;
1257
1258 table->part = part;
1259
1260 /* XXX: This tag soup handling needs to be done outside the create
1261 * parser state. Something to do with link numbering. */
1262 /* It needs to be done _before_ processing the actual table, too.
1263 * Otherwise i.e. <form> tags between <table> and <tr> are broken. */
1264 draw_table_bad_html(html_context, table);
1265
1266 state = init_html_parser_state(html_context, ELEMENT_DONT_KILL,
1267 ALIGN_LEFT, 0, 0);
1268
1269 margins = par_format.leftmargin + par_format.rightmargin;
1270 if (get_table_cellpadding(html_context, table)) goto ret2;
1271
1272 distribute_table_widths(table);
1273
1274 if (!part->document && part->box.x == 1) {
1275 int total_width = table->real_width + margins;
1276
1277 int_bounds(&total_width, table->real_width, par_format.width);
1278 int_lower_bound(&part->box.width, total_width);
1279 part->cy += table->real_height;
1280
1281 goto ret2;
1282 }
1283
1284 #ifdef HTML_TABLE_2ND_PASS
1285 check_table_widths(html_context, table);
1286 #endif
1287
1288 get_table_heights(html_context, table);
1289
1290 if (!part->document) {
1291 int_lower_bound(&part->box.width, table->real_width + margins);
1292 part->cy += table->real_height;
1293 goto ret2;
1294 }
1295
1296 node = part->document->nodes.next;
1297 node->box.height = part->box.y - node->box.y + part->cy;
1298
1299 indent = get_table_indent(html_context, table);
1300
1301 /* FIXME: See bug 432. It should be possible to align the caption at
1302 * the top, bottom or the sides. */
1303 draw_table_caption(html_context, table, indent + part->box.x, part->box.y + part->cy);
1304 draw_table_cells(table, indent, part->cy, html_context);
1305 draw_table_frames(table, indent, part->cy, html_context);
1306
1307 part->cy += table->real_height;
1308 part->cx = -1;
1309
1310 new_node = mem_alloc(sizeof(*new_node));
1311 if (new_node) {
1312 set_box(&new_node->box, node->box.x, part->box.y + part->cy,
1313 node->box.width, 0);
1314 add_to_list(part->document->nodes, new_node);
1315 }
1316
1317 ret2:
1318 part->link_num = table->link_num;
1319 int_lower_bound(&part->box.height, part->cy);
1320 html_context->part = part; /* Might've changed in draw_table_cells(). */
1321 done_html_parser_state(html_context, state);
1322
1323 free_table(table);
1324
1325 ret0:
1326 html_context->table_level--;
1327 if (!html_context->table_level) free_table_cache();
1328 }