]> git.saurik.com Git - wxWidgets.git/blob - src/html/m_tables.cpp
projects / wxWidgets.git / blob
? search:


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