]> git.saurik.com Git - wxWidgets.git/blob - src/html/m_tables.cpp
cleanup - reformat
[wxWidgets.git] / src / html / m_tables.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: m_tables.cpp
3 // Purpose: wxHtml module for tables
4 // Author: Vaclav Slavik
5 // RCS-ID: $Id$
6 // Copyright: (c) 1999 Vaclav Slavik
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 #include "wx/wxprec.h"
11
12 #include "wx/defs.h"
13 #if wxUSE_HTML && wxUSE_STREAMS
14 #ifdef __BORLANDC__
15 #pragma hdrstop
16 #endif
17
18 #ifndef WXPRECOMP
19 #endif
20
21 #include "wx/html/forcelnk.h"
22 #include "wx/html/m_templ.h"
23
24 #include "wx/html/htmlcell.h"
25
26 FORCE_LINK_ME(m_tables)
27
28
29 #define TABLE_BORDER_CLR_1 wxColour(0xC5, 0xC2, 0xC5)
30 #define TABLE_BORDER_CLR_2 wxColour(0x62, 0x61, 0x62)
31
32
33 //-----------------------------------------------------------------------------
34 // wxHtmlTableCell
35 //-----------------------------------------------------------------------------
36
37
38 struct colStruct
39 {
40 int width, units;
41 // width of the column either in pixels or percents
42 // ('width' is the number, 'units' determines its meaning)
43 int minWidth, maxWidth;
44 // minimal/maximal column width. This is needed by HTML 4.0
45 // layouting algorithm and can be determined by trying to
46 // layout table cells with width=1 and width=infinity
47 int leftpos, pixwidth, maxrealwidth;
48 // temporary (depends on actual width of table)
49 };
50
51 enum cellState
52 {
53 cellSpan,
54 cellUsed,
55 cellFree
56 };
57
58 struct cellStruct
59 {
60 wxHtmlContainerCell *cont;
61 int colspan, rowspan;
62 int minheight, valign;
63 cellState flag;
64 bool nowrap;
65 };
66
67
68 class wxHtmlTableCell : public wxHtmlContainerCell
69 {
70 protected:
71 /* These are real attributes: */
72
73 // should we draw borders or not?
74 bool m_HasBorders;
75 // number of columns; rows
76 int m_NumCols, m_NumRows;
77 // array of column information
78 colStruct *m_ColsInfo;
79 // 2D array of all cells in the table : m_CellInfo[row][column]
80 cellStruct **m_CellInfo;
81 // spaces between cells
82 int m_Spacing;
83 // cells internal indentation
84 int m_Padding;
85
86 private:
87 /* ...and these are valid only when parsing the table: */
88
89 // number of actual column (ranging from 0..m_NumCols)
90 int m_ActualCol, m_ActualRow;
91
92 // default values (for table and row):
93 wxColour m_tBkg, m_rBkg;
94 wxString m_tValign, m_rValign;
95
96 double m_PixelScale;
97
98
99 public:
100 wxHtmlTableCell(wxHtmlContainerCell *parent, const wxHtmlTag& tag, double pixel_scale = 1.0);
101 ~wxHtmlTableCell();
102
103 virtual void RemoveExtraSpacing(bool top, bool bottom);
104
105 virtual void Layout(int w);
106
107 void AddRow(const wxHtmlTag& tag);
108 void AddCell(wxHtmlContainerCell *cell, const wxHtmlTag& tag);
109
110 private:
111 // Reallocates memory to given number of cols/rows
112 // and changes m_NumCols/m_NumRows value to reflect this change
113 // NOTE! You CAN'T change m_NumCols/m_NumRows before calling this!!
114 void ReallocCols(int cols);
115 void ReallocRows(int rows);
116
117 // Computes minimal and maximal widths of columns. Needs to be called
118 // only once, before first Layout().
119 void ComputeMinMaxWidths();
120
121 DECLARE_NO_COPY_CLASS(wxHtmlTableCell)
122 };
123
124
125
126 wxHtmlTableCell::wxHtmlTableCell(wxHtmlContainerCell *parent, const wxHtmlTag& tag, double pixel_scale)
127 : wxHtmlContainerCell(parent)
128 {
129 m_PixelScale = pixel_scale;
130 m_HasBorders =
131 (tag.HasParam(wxT("BORDER")) && tag.GetParam(wxT("BORDER")) != wxT("0"));
132 m_ColsInfo = NULL;
133 m_NumCols = m_NumRows = 0;
134 m_CellInfo = NULL;
135 m_ActualCol = m_ActualRow = -1;
136
137 /* scan params: */
138 if (tag.HasParam(wxT("BGCOLOR")))
139 tag.GetParamAsColour(wxT("BGCOLOR"), &m_tBkg);
140 if (tag.HasParam(wxT("VALIGN")))
141 m_tValign = tag.GetParam(wxT("VALIGN"));
142 else
143 m_tValign = wxEmptyString;
144 if (!tag.GetParamAsInt(wxT("CELLSPACING"), &m_Spacing))
145 m_Spacing = 2;
146 if (!tag.GetParamAsInt(wxT("CELLPADDING"), &m_Padding))
147 m_Padding = 3;
148 m_Spacing = (int)(m_PixelScale * (double)m_Spacing);
149 m_Padding = (int)(m_PixelScale * (double)m_Padding);
150
151 if (m_HasBorders)
152 SetBorder(TABLE_BORDER_CLR_1, TABLE_BORDER_CLR_2);
153 }
154
155
156
157 wxHtmlTableCell::~wxHtmlTableCell()
158 {
159 if (m_ColsInfo) free(m_ColsInfo);
160 if (m_CellInfo)
161 {
162 for (int i = 0; i < m_NumRows; i++)
163 free(m_CellInfo[i]);
164 free(m_CellInfo);
165 }
166 }
167
168
169 void wxHtmlTableCell::RemoveExtraSpacing(bool WXUNUSED(top),
170 bool WXUNUSED(bottom))
171 {
172 // Don't remove any spacing in the table -- it's always desirable,
173 // because it's part of table's definition.
174 // (If wxHtmlContainerCell::RemoveExtraSpacing() was applied to tables,
175 // then upper left cell of a table would be positioned above other cells
176 // if the table was the first element on the page.)
177 }
178
179 void wxHtmlTableCell::ReallocCols(int cols)
180 {
181 int i,j;
182
183 for (i = 0; i < m_NumRows; i++)
184 {
185 m_CellInfo[i] = (cellStruct*) realloc(m_CellInfo[i], sizeof(cellStruct) * cols);
186 for (j = m_NumCols; j < cols; j++)
187 m_CellInfo[i][j].flag = cellFree;
188 }
189
190 m_ColsInfo = (colStruct*) realloc(m_ColsInfo, sizeof(colStruct) * cols);
191 for (j = m_NumCols; j < cols; j++)
192 {
193 m_ColsInfo[j].width = 0;
194 m_ColsInfo[j].units = wxHTML_UNITS_PERCENT;
195 m_ColsInfo[j].minWidth = m_ColsInfo[j].maxWidth = -1;
196 }
197
198 m_NumCols = cols;
199 }
200
201
202
203 void wxHtmlTableCell::ReallocRows(int rows)
204 {
205 m_CellInfo = (cellStruct**) realloc(m_CellInfo, sizeof(cellStruct*) * rows);
206 for (int row = m_NumRows; row < rows ; row++)
207 {
208 if (m_NumCols == 0)
209 m_CellInfo[row] = NULL;
210 else
211 {
212 m_CellInfo[row] = (cellStruct*) malloc(sizeof(cellStruct) * m_NumCols);
213 for (int col = 0; col < m_NumCols; col++)
214 m_CellInfo[row][col].flag = cellFree;
215 }
216 }
217 m_NumRows = rows;
218 }
219
220
221 void wxHtmlTableCell::AddRow(const wxHtmlTag& tag)
222 {
223 m_ActualCol = -1;
224 // VS: real allocation of row entry is done in AddCell in order
225 // to correctly handle empty rows (i.e. "<tr></tr>")
226 // m_ActualCol == -1 indicates that AddCell has to allocate new row.
227
228 // scan params:
229 m_rBkg = m_tBkg;
230 if (tag.HasParam(wxT("BGCOLOR")))
231 tag.GetParamAsColour(wxT("BGCOLOR"), &m_rBkg);
232 if (tag.HasParam(wxT("VALIGN")))
233 m_rValign = tag.GetParam(wxT("VALIGN"));
234 else
235 m_rValign = m_tValign;
236 }
237
238
239
240 void wxHtmlTableCell::AddCell(wxHtmlContainerCell *cell, const wxHtmlTag& tag)
241 {
242 // Is this cell in new row?
243 // VS: we can't do it in AddRow, see my comment there
244 if (m_ActualCol == -1)
245 {
246 if (m_ActualRow + 1 > m_NumRows - 1)
247 ReallocRows(m_ActualRow + 2);
248 m_ActualRow++;
249 }
250
251 // cells & columns:
252 do
253 {
254 m_ActualCol++;
255 } while ((m_ActualCol < m_NumCols) &&
256 (m_CellInfo[m_ActualRow][m_ActualCol].flag != cellFree));
257
258 if (m_ActualCol > m_NumCols - 1)
259 ReallocCols(m_ActualCol + 1);
260
261 int r = m_ActualRow, c = m_ActualCol;
262
263 m_CellInfo[r][c].cont = cell;
264 m_CellInfo[r][c].colspan = 1;
265 m_CellInfo[r][c].rowspan = 1;
266 m_CellInfo[r][c].flag = cellUsed;
267 m_CellInfo[r][c].minheight = 0;
268 m_CellInfo[r][c].valign = wxHTML_ALIGN_TOP;
269
270 /* scan for parameters: */
271
272 // width:
273 {
274 if (tag.HasParam(wxT("WIDTH")))
275 {
276 wxString wd = tag.GetParam(wxT("WIDTH"));
277
278 if (wd[wd.Length()-1] == wxT('%'))
279 {
280 wxSscanf(wd.c_str(), wxT("%i%%"), &m_ColsInfo[c].width);
281 m_ColsInfo[c].units = wxHTML_UNITS_PERCENT;
282 }
283 else
284 {
285 wxSscanf(wd.c_str(), wxT("%i"), &m_ColsInfo[c].width);
286 m_ColsInfo[c].width = (int)(m_PixelScale * (double)m_ColsInfo[c].width);
287 m_ColsInfo[c].units = wxHTML_UNITS_PIXELS;
288 }
289 }
290 }
291
292
293 // spanning:
294 {
295 tag.GetParamAsInt(wxT("COLSPAN"), &m_CellInfo[r][c].colspan);
296 tag.GetParamAsInt(wxT("ROWSPAN"), &m_CellInfo[r][c].rowspan);
297
298 // VS: the standard says this about col/rowspan:
299 // "This attribute specifies the number of rows spanned by the
300 // current cell. The default value of this attribute is one ("1").
301 // The value zero ("0") means that the cell spans all rows from the
302 // current row to the last row of the table." All mainstream
303 // browsers act as if 0==1, though, and so does wxHTML.
304 if (m_CellInfo[r][c].colspan < 1)
305 m_CellInfo[r][c].colspan = 1;
306 if (m_CellInfo[r][c].rowspan < 1)
307 m_CellInfo[r][c].rowspan = 1;
308
309 if ((m_CellInfo[r][c].colspan > 1) || (m_CellInfo[r][c].rowspan > 1))
310 {
311 int i, j;
312
313 if (r + m_CellInfo[r][c].rowspan > m_NumRows)
314 ReallocRows(r + m_CellInfo[r][c].rowspan);
315 if (c + m_CellInfo[r][c].colspan > m_NumCols)
316 ReallocCols(c + m_CellInfo[r][c].colspan);
317 for (i = r; i < r + m_CellInfo[r][c].rowspan; i++)
318 for (j = c; j < c + m_CellInfo[r][c].colspan; j++)
319 m_CellInfo[i][j].flag = cellSpan;
320 m_CellInfo[r][c].flag = cellUsed;
321 }
322 }
323
324 //background color:
325 {
326 wxColour bk = m_rBkg;
327 if (tag.HasParam(wxT("BGCOLOR")))
328 tag.GetParamAsColour(wxT("BGCOLOR"), &bk);
329 if (bk.Ok())
330 cell->SetBackgroundColour(bk);
331 }
332 if (m_HasBorders)
333 cell->SetBorder(TABLE_BORDER_CLR_2, TABLE_BORDER_CLR_1);
334
335 // vertical alignment:
336 {
337 wxString valign;
338 if (tag.HasParam(wxT("VALIGN")))
339 valign = tag.GetParam(wxT("VALIGN"));
340 else
341 valign = m_tValign;
342 valign.MakeUpper();
343 if (valign == wxT("TOP"))
344 m_CellInfo[r][c].valign = wxHTML_ALIGN_TOP;
345 else if (valign == wxT("BOTTOM"))
346 m_CellInfo[r][c].valign = wxHTML_ALIGN_BOTTOM;
347 else m_CellInfo[r][c].valign = wxHTML_ALIGN_CENTER;
348 }
349
350 // nowrap
351 if (tag.HasParam(wxT("NOWRAP")))
352 m_CellInfo[r][c].nowrap = true;
353 else
354 m_CellInfo[r][c].nowrap = false;
355
356 cell->SetIndent(m_Padding, wxHTML_INDENT_ALL, wxHTML_UNITS_PIXELS);
357 }
358
359 void wxHtmlTableCell::ComputeMinMaxWidths()
360 {
361 if (m_NumCols == 0 || m_ColsInfo[0].minWidth != wxDefaultCoord) return;
362
363 m_MaxTotalWidth = 0;
364 int percentage = 0;
365 for (int c = 0; c < m_NumCols; c++)
366 {
367 for (int r = 0; r < m_NumRows; r++)
368 {
369 cellStruct& cell = m_CellInfo[r][c];
370 if (cell.flag == cellUsed)
371 {
372 cell.cont->Layout(2*m_Padding + 1);
373 int maxWidth = cell.cont->GetMaxTotalWidth();
374 int width = cell.nowrap?maxWidth:cell.cont->GetWidth();
375 width -= (cell.colspan-1) * m_Spacing;
376 maxWidth -= (cell.colspan-1) * m_Spacing;
377 // HTML 4.0 says it is acceptable to distribute min/max
378 width /= cell.colspan;
379 maxWidth /= cell.colspan;
380 for (int j = 0; j < cell.colspan; j++) {
381 if (width > m_ColsInfo[c+j].minWidth)
382 m_ColsInfo[c+j].minWidth = width;
383 if (maxWidth > m_ColsInfo[c+j].maxWidth)
384 m_ColsInfo[c+j].maxWidth = maxWidth;
385 }
386 }
387 }
388 // Calculate maximum table width, required for nested tables
389 if (m_ColsInfo[c].units == wxHTML_UNITS_PIXELS)
390 m_MaxTotalWidth += wxMax(m_ColsInfo[c].width, m_ColsInfo[c].minWidth);
391 else if ((m_ColsInfo[c].units == wxHTML_UNITS_PERCENT) && (m_ColsInfo[c].width != 0))
392 percentage += m_ColsInfo[c].width;
393 else
394 m_MaxTotalWidth += m_ColsInfo[c].maxWidth;
395 }
396
397 if (percentage >= 100)
398 {
399 // Table would have infinite length
400 // Make it ridiculous large
401 m_MaxTotalWidth = 0xFFFFFF;
402 }
403 else
404 m_MaxTotalWidth = m_MaxTotalWidth * 100 / (100 - percentage);
405
406 m_MaxTotalWidth += (m_NumCols + 1) * m_Spacing;
407 }
408
409 void wxHtmlTableCell::Layout(int w)
410 {
411 ComputeMinMaxWidths();
412
413 wxHtmlCell::Layout(w);
414
415 /*
416
417 WIDTH ADJUSTING :
418
419 */
420
421 if (m_WidthFloatUnits == wxHTML_UNITS_PERCENT)
422 {
423 if (m_WidthFloat < 0)
424 {
425 if (m_WidthFloat < -100)
426 m_WidthFloat = -100;
427 m_Width = (100 + m_WidthFloat) * w / 100;
428 }
429 else
430 {
431 if (m_WidthFloat > 100)
432 m_WidthFloat = 100;
433 m_Width = m_WidthFloat * w / 100;
434 }
435 }
436 else
437 {
438 if (m_WidthFloat < 0) m_Width = w + m_WidthFloat;
439 else m_Width = m_WidthFloat;
440 }
441
442
443 /*
444
445 LAYOUTING :
446
447 */
448
449 /* 1. setup columns widths:
450
451 The algorithm tries to keep the table size less than w if possible.
452 */
453 {
454 int wpix = m_Width - (m_NumCols + 1) * m_Spacing;
455 int i, j;
456
457 // 1a. setup fixed-width columns:
458 for (i = 0; i < m_NumCols; i++)
459 if (m_ColsInfo[i].units == wxHTML_UNITS_PIXELS)
460 {
461 m_ColsInfo[i].pixwidth = wxMax(m_ColsInfo[i].width,
462 m_ColsInfo[i].minWidth);
463 wpix -= m_ColsInfo[i].pixwidth;
464 }
465
466 // 1b. Calculate maximum possible width if line wrapping would be disabled
467 // Recalculate total width if m_WidthFloat is zero to keep tables as small
468 // as possible.
469 int maxWidth = 0;
470 for (i = 0; i < m_NumCols; i++)
471 if (m_ColsInfo[i].width == 0)
472 {
473 maxWidth += m_ColsInfo[i].maxWidth;
474 }
475
476 if (!m_WidthFloat)
477 {
478 // Recalculate table width since no table width was initially given
479 int newWidth = m_Width - wpix + maxWidth;
480
481 // Make sure that floating-width columns will have the right size.
482 // Calculate sum of all floating-width columns
483 int percentage = 0;
484 for (i = 0; i < m_NumCols; i++)
485 if ((m_ColsInfo[i].units == wxHTML_UNITS_PERCENT) && (m_ColsInfo[i].width != 0))
486 percentage += m_ColsInfo[i].width;
487
488 if (percentage >= 100)
489 newWidth = w;
490 else
491 newWidth = newWidth * 100 / (100 - percentage);
492
493 newWidth = wxMin(newWidth, w - (m_NumCols + 1) * m_Spacing);
494 wpix -= m_Width - newWidth;
495 m_Width = newWidth;
496 }
497
498
499 // 1c. setup floating-width columns:
500 int wtemp = wpix;
501 for (i = 0; i < m_NumCols; i++)
502 if ((m_ColsInfo[i].units == wxHTML_UNITS_PERCENT) && (m_ColsInfo[i].width != 0))
503 {
504 m_ColsInfo[i].pixwidth = wxMin(m_ColsInfo[i].width, 100) * wpix / 100;
505
506 // Make sure to leave enough space for the other columns
507 int minRequired = 0;
508 for (j = 0; j < m_NumCols; j++)
509 {
510 if ((m_ColsInfo[j].units == wxHTML_UNITS_PERCENT && j > i) ||
511 !m_ColsInfo[j].width)
512 minRequired += m_ColsInfo[j].minWidth;
513 }
514 m_ColsInfo[i].pixwidth = wxMax(wxMin(wtemp - minRequired, m_ColsInfo[i].pixwidth), m_ColsInfo[i].minWidth);
515
516 wtemp -= m_ColsInfo[i].pixwidth;
517 }
518 wpix = wtemp;
519
520 // 1d. setup default columns (no width specification supplied):
521 // The algorithm assigns calculates the maximum possible width if line
522 // wrapping would be disabled and assigns column width as a fraction
523 // based upon the maximum width of a column
524 // FIXME: I'm not sure if this algorithm is conform to HTML standard,
525 // though it seems to be much better than the old one
526
527 for (i = j = 0; i < m_NumCols; i++)
528 if (m_ColsInfo[i].width == 0) j++;
529 if (wpix < 0)
530 wpix = 0;
531
532 // Assign widths
533 for (i = 0; i < m_NumCols; i++)
534 if (m_ColsInfo[i].width == 0)
535 {
536 // Assign with, make sure not to drop below minWidth
537 if (maxWidth)
538 m_ColsInfo[i].pixwidth = (int)(wpix * (m_ColsInfo[i].maxWidth / (float)maxWidth) + 0.5);
539 else
540 m_ColsInfo[i].pixwidth = wpix / j;
541
542 // Make sure to leave enough space for the other columns
543 int minRequired = 0;
544 int r;
545 for (r = i + 1; r < m_NumCols; r++)
546 {
547 if (!m_ColsInfo[r].width)
548 minRequired += m_ColsInfo[r].minWidth;
549 }
550 m_ColsInfo[i].pixwidth = wxMax(wxMin(wpix - minRequired, m_ColsInfo[i].pixwidth), m_ColsInfo[i].minWidth);
551
552 if (maxWidth)
553 {
554 if (m_ColsInfo[i].pixwidth > (wpix * (m_ColsInfo[i].maxWidth / (float)maxWidth) + 0.5))
555 {
556 int diff = (int)(m_ColsInfo[i].pixwidth - (wpix * m_ColsInfo[i].maxWidth / (float)maxWidth + 0.5));
557 maxWidth += diff - m_ColsInfo[i].maxWidth;
558 }
559 else
560 maxWidth -= m_ColsInfo[i].maxWidth;
561 }
562 wpix -= m_ColsInfo[i].pixwidth;
563 }
564 }
565
566 /* 2. compute positions of columns: */
567 {
568 int wpos = m_Spacing;
569 for (int i = 0; i < m_NumCols; i++)
570 {
571 m_ColsInfo[i].leftpos = wpos;
572 wpos += m_ColsInfo[i].pixwidth + m_Spacing;
573 }
574 }
575
576 /* 3. sub-layout all cells: */
577 {
578 int *ypos = new int[m_NumRows + 1];
579
580 int actcol, actrow;
581 int fullwid;
582 wxHtmlContainerCell *actcell;
583
584 ypos[0] = m_Spacing;
585 for (actrow = 1; actrow <= m_NumRows; actrow++) ypos[actrow] = -1;
586 for (actrow = 0; actrow < m_NumRows; actrow++)
587 {
588 if (ypos[actrow] == -1) ypos[actrow] = ypos[actrow-1];
589 // 3a. sub-layout and detect max height:
590
591 for (actcol = 0; actcol < m_NumCols; actcol++) {
592 if (m_CellInfo[actrow][actcol].flag != cellUsed) continue;
593 actcell = m_CellInfo[actrow][actcol].cont;
594 fullwid = 0;
595 for (int i = actcol; i < m_CellInfo[actrow][actcol].colspan + actcol; i++)
596 fullwid += m_ColsInfo[i].pixwidth;
597 fullwid += (m_CellInfo[actrow][actcol].colspan - 1) * m_Spacing;
598 actcell->SetMinHeight(m_CellInfo[actrow][actcol].minheight, m_CellInfo[actrow][actcol].valign);
599 actcell->Layout(fullwid);
600
601 if (ypos[actrow] + actcell->GetHeight() + m_CellInfo[actrow][actcol].rowspan * m_Spacing > ypos[actrow + m_CellInfo[actrow][actcol].rowspan])
602 ypos[actrow + m_CellInfo[actrow][actcol].rowspan] =
603 ypos[actrow] + actcell->GetHeight() + m_CellInfo[actrow][actcol].rowspan * m_Spacing;
604 }
605 }
606
607 for (actrow = 0; actrow < m_NumRows; actrow++)
608 {
609 // 3b. place cells in row & let'em all have same height:
610
611 for (actcol = 0; actcol < m_NumCols; actcol++)
612 {
613 if (m_CellInfo[actrow][actcol].flag != cellUsed) continue;
614 actcell = m_CellInfo[actrow][actcol].cont;
615 actcell->SetMinHeight(
616 ypos[actrow + m_CellInfo[actrow][actcol].rowspan] - ypos[actrow] - m_Spacing,
617 m_CellInfo[actrow][actcol].valign);
618 fullwid = 0;
619 for (int i = actcol; i < m_CellInfo[actrow][actcol].colspan + actcol; i++)
620 fullwid += m_ColsInfo[i].pixwidth;
621 fullwid += (m_CellInfo[actrow][actcol].colspan - 1) * m_Spacing;
622 actcell->Layout(fullwid);
623 actcell->SetPos(m_ColsInfo[actcol].leftpos, ypos[actrow]);
624 }
625 }
626 m_Height = ypos[m_NumRows];
627 delete[] ypos;
628 }
629
630 /* 4. adjust table's width if it was too small: */
631 if (m_NumCols > 0)
632 {
633 int twidth = m_ColsInfo[m_NumCols-1].leftpos +
634 m_ColsInfo[m_NumCols-1].pixwidth + m_Spacing;
635 if (twidth > m_Width)
636 m_Width = twidth;
637 }
638 }
639
640
641
642
643
644
645 //-----------------------------------------------------------------------------
646 // The tables handler:
647 //-----------------------------------------------------------------------------
648
649
650 TAG_HANDLER_BEGIN(TABLE, "TABLE,TR,TD,TH")
651
652 TAG_HANDLER_VARS
653 wxHtmlTableCell* m_Table;
654 wxString m_tAlign, m_rAlign;
655
656 TAG_HANDLER_CONSTR(TABLE)
657 {
658 m_Table = NULL;
659 m_tAlign = m_rAlign = wxEmptyString;
660 }
661
662
663 TAG_HANDLER_PROC(tag)
664 {
665 wxHtmlContainerCell *c;
666
667 // new table started, backup upper-level table (if any) and create new:
668 if (tag.GetName() == wxT("TABLE"))
669 {
670 wxHtmlTableCell *oldt = m_Table;
671 wxHtmlContainerCell *oldcont;
672
673 oldcont = c = m_WParser->OpenContainer();
674
675 m_Table = new wxHtmlTableCell(c, tag);
676
677 // width:
678 {
679 if (tag.HasParam(wxT("WIDTH")))
680 {
681 wxString wd = tag.GetParam(wxT("WIDTH"));
682
683 if (wd[wd.Length()-1] == wxT('%'))
684 {
685 int width = 0;
686 wxSscanf(wd.c_str(), wxT("%i%%"), &width);
687 m_Table->SetWidthFloat(width, wxHTML_UNITS_PERCENT);
688 }
689 else
690 {
691 int width = 0;
692 wxSscanf(wd.c_str(), wxT("%i"), &width);
693 m_Table->SetWidthFloat((int)(m_WParser->GetPixelScale() * width), wxHTML_UNITS_PIXELS);
694 }
695 }
696 else
697 m_Table->SetWidthFloat(0, wxHTML_UNITS_PIXELS);
698 }
699 int oldAlign = m_WParser->GetAlign();
700 m_tAlign = wxEmptyString;
701 if (tag.HasParam(wxT("ALIGN")))
702 m_tAlign = tag.GetParam(wxT("ALIGN"));
703
704 ParseInner(tag);
705
706 m_WParser->SetAlign(oldAlign);
707 m_WParser->SetContainer(oldcont);
708 m_WParser->CloseContainer();
709
710 m_Table = oldt;
711 return true;
712 }
713
714
715 else if (m_Table)
716 {
717 // new row in table
718 if (tag.GetName() == wxT("TR"))
719 {
720 m_Table->AddRow(tag);
721 m_rAlign = m_tAlign;
722 if (tag.HasParam(wxT("ALIGN")))
723 m_rAlign = tag.GetParam(wxT("ALIGN"));
724 }
725
726 // new cell
727 else
728 {
729 c = m_WParser->SetContainer(new wxHtmlContainerCell(m_Table));
730 m_Table->AddCell(c, tag);
731
732 m_WParser->OpenContainer();
733
734 if (tag.GetName() == wxT("TH")) /*header style*/
735 m_WParser->SetAlign(wxHTML_ALIGN_CENTER);
736 else
737 m_WParser->SetAlign(wxHTML_ALIGN_LEFT);
738
739 wxString als;
740
741 als = m_rAlign;
742 if (tag.HasParam(wxT("ALIGN")))
743 als = tag.GetParam(wxT("ALIGN"));
744 als.MakeUpper();
745 if (als == wxT("RIGHT"))
746 m_WParser->SetAlign(wxHTML_ALIGN_RIGHT);
747 else if (als == wxT("LEFT"))
748 m_WParser->SetAlign(wxHTML_ALIGN_LEFT);
749 else if (als == wxT("CENTER"))
750 m_WParser->SetAlign(wxHTML_ALIGN_CENTER);
751
752 m_WParser->OpenContainer();
753 }
754 }
755 return false;
756 }
757
758 TAG_HANDLER_END(TABLE)
759
760
761
762
763
764 TAGS_MODULE_BEGIN(Tables)
765
766 TAGS_MODULE_ADD(TABLE)
767
768 TAGS_MODULE_END(Tables)
769
770
771 #endif