| 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 | #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) |
| 11 | #pragma implementation |
| 12 | #endif |
| 13 | |
| 14 | #include "wx/wxprec.h" |
| 15 | |
| 16 | #include "wx/defs.h" |
| 17 | #if wxUSE_HTML && wxUSE_STREAMS |
| 18 | #ifdef __BORLANDC__ |
| 19 | #pragma hdrstop |
| 20 | #endif |
| 21 | |
| 22 | #ifndef WXPRECOMP |
| 23 | #endif |
| 24 | |
| 25 | |
| 26 | /* |
| 27 | REMARKS: |
| 28 | 1. This version of m_tables doesn't support auto-layout algorithm. |
| 29 | This means that all columns are of same width unless explicitly specified. |
| 30 | */ |
| 31 | |
| 32 | |
| 33 | #include "wx/html/forcelnk.h" |
| 34 | #include "wx/html/m_templ.h" |
| 35 | |
| 36 | #include "wx/html/htmlcell.h" |
| 37 | |
| 38 | FORCE_LINK_ME(m_tables) |
| 39 | |
| 40 | |
| 41 | #define TABLE_BORDER_CLR_1 wxColour(0xC5, 0xC2, 0xC5) |
| 42 | #define TABLE_BORDER_CLR_2 wxColour(0x62, 0x61, 0x62) |
| 43 | |
| 44 | |
| 45 | //----------------------------------------------------------------------------- |
| 46 | // wxHtmlTableCell |
| 47 | //----------------------------------------------------------------------------- |
| 48 | |
| 49 | |
| 50 | struct colStruct |
| 51 | { |
| 52 | int width, units; |
| 53 | // width of the column either in pixels or percents |
| 54 | // ('width' is the number, 'units' determines its meaning) |
| 55 | int minWidth, maxWidth; |
| 56 | // minimal/maximal column width. This is needed by HTML 4.0 |
| 57 | // layouting algorithm and can be determined by trying to |
| 58 | // layout table cells with width=1 and width=infinity |
| 59 | int leftpos, pixwidth, maxrealwidth; |
| 60 | // temporary (depends on actual width of table) |
| 61 | }; |
| 62 | |
| 63 | enum cellState |
| 64 | { |
| 65 | cellSpan, |
| 66 | cellUsed, |
| 67 | cellFree |
| 68 | }; |
| 69 | |
| 70 | struct cellStruct |
| 71 | { |
| 72 | wxHtmlContainerCell *cont; |
| 73 | int colspan, rowspan; |
| 74 | int minheight, valign; |
| 75 | cellState flag; |
| 76 | }; |
| 77 | |
| 78 | |
| 79 | class wxHtmlTableCell : public wxHtmlContainerCell |
| 80 | { |
| 81 | protected: |
| 82 | /* These are real attributes: */ |
| 83 | |
| 84 | // should we draw borders or not? |
| 85 | bool m_HasBorders; |
| 86 | // number of columns; rows |
| 87 | int m_NumCols, m_NumRows; |
| 88 | // array of column information |
| 89 | colStruct *m_ColsInfo; |
| 90 | // 2D array of all cells in the table : m_CellInfo[row][column] |
| 91 | cellStruct **m_CellInfo; |
| 92 | // spaces between cells |
| 93 | int m_Spacing; |
| 94 | // cells internal indentation |
| 95 | int m_Padding; |
| 96 | |
| 97 | private: |
| 98 | /* ...and these are valid only when parsing the table: */ |
| 99 | |
| 100 | // number of actual column (ranging from 0..m_NumCols) |
| 101 | int m_ActualCol, m_ActualRow; |
| 102 | |
| 103 | // default values (for table and row): |
| 104 | wxColour m_tBkg, m_rBkg; |
| 105 | wxString m_tValign, m_rValign; |
| 106 | |
| 107 | double m_PixelScale; |
| 108 | |
| 109 | |
| 110 | public: |
| 111 | wxHtmlTableCell(wxHtmlContainerCell *parent, const wxHtmlTag& tag, double pixel_scale = 1.0); |
| 112 | ~wxHtmlTableCell(); |
| 113 | virtual void Layout(int w); |
| 114 | |
| 115 | void AddRow(const wxHtmlTag& tag); |
| 116 | void AddCell(wxHtmlContainerCell *cell, const wxHtmlTag& tag); |
| 117 | |
| 118 | private: |
| 119 | // Reallocates memory to given number of cols/rows |
| 120 | // and changes m_NumCols/m_NumRows value to reflect this change |
| 121 | // NOTE! You CAN'T change m_NumCols/m_NumRows before calling this!! |
| 122 | void ReallocCols(int cols); |
| 123 | void ReallocRows(int rows); |
| 124 | |
| 125 | // Computes minimal and maximal widths of columns. Needs to be called |
| 126 | // only once, before first Layout(). |
| 127 | void ComputeMinMaxWidths(); |
| 128 | |
| 129 | DECLARE_NO_COPY_CLASS(wxHtmlTableCell) |
| 130 | }; |
| 131 | |
| 132 | |
| 133 | |
| 134 | wxHtmlTableCell::wxHtmlTableCell(wxHtmlContainerCell *parent, const wxHtmlTag& tag, double pixel_scale) |
| 135 | : wxHtmlContainerCell(parent) |
| 136 | { |
| 137 | m_PixelScale = pixel_scale; |
| 138 | m_HasBorders = |
| 139 | (tag.HasParam(wxT("BORDER")) && tag.GetParam(wxT("BORDER")) != wxT("0")); |
| 140 | m_ColsInfo = NULL; |
| 141 | m_NumCols = m_NumRows = 0; |
| 142 | m_CellInfo = NULL; |
| 143 | m_ActualCol = m_ActualRow = -1; |
| 144 | |
| 145 | /* scan params: */ |
| 146 | if (tag.HasParam(wxT("BGCOLOR"))) |
| 147 | tag.GetParamAsColour(wxT("BGCOLOR"), &m_tBkg); |
| 148 | if (tag.HasParam(wxT("VALIGN"))) |
| 149 | m_tValign = tag.GetParam(wxT("VALIGN")); |
| 150 | else |
| 151 | m_tValign = wxEmptyString; |
| 152 | if (!tag.GetParamAsInt(wxT("CELLSPACING"), &m_Spacing)) |
| 153 | m_Spacing = 2; |
| 154 | if (!tag.GetParamAsInt(wxT("CELLPADDING"), &m_Padding)) |
| 155 | m_Padding = 3; |
| 156 | m_Spacing = (int)(m_PixelScale * (double)m_Spacing); |
| 157 | m_Padding = (int)(m_PixelScale * (double)m_Padding); |
| 158 | |
| 159 | if (m_HasBorders) |
| 160 | SetBorder(TABLE_BORDER_CLR_1, TABLE_BORDER_CLR_2); |
| 161 | } |
| 162 | |
| 163 | |
| 164 | |
| 165 | wxHtmlTableCell::~wxHtmlTableCell() |
| 166 | { |
| 167 | if (m_ColsInfo) free(m_ColsInfo); |
| 168 | if (m_CellInfo) |
| 169 | { |
| 170 | for (int i = 0; i < m_NumRows; i++) |
| 171 | free(m_CellInfo[i]); |
| 172 | free(m_CellInfo); |
| 173 | } |
| 174 | } |
| 175 | |
| 176 | |
| 177 | |
| 178 | void wxHtmlTableCell::ReallocCols(int cols) |
| 179 | { |
| 180 | int i,j; |
| 181 | |
| 182 | for (i = 0; i < m_NumRows; i++) |
| 183 | { |
| 184 | m_CellInfo[i] = (cellStruct*) realloc(m_CellInfo[i], sizeof(cellStruct) * cols); |
| 185 | for (j = m_NumCols; j < cols; j++) |
| 186 | m_CellInfo[i][j].flag = cellFree; |
| 187 | } |
| 188 | |
| 189 | m_ColsInfo = (colStruct*) realloc(m_ColsInfo, sizeof(colStruct) * cols); |
| 190 | for (j = m_NumCols; j < cols; j++) |
| 191 | { |
| 192 | m_ColsInfo[j].width = 0; |
| 193 | m_ColsInfo[j].units = wxHTML_UNITS_PERCENT; |
| 194 | m_ColsInfo[j].minWidth = m_ColsInfo[j].maxWidth = -1; |
| 195 | } |
| 196 | |
| 197 | m_NumCols = cols; |
| 198 | } |
| 199 | |
| 200 | |
| 201 | |
| 202 | void wxHtmlTableCell::ReallocRows(int rows) |
| 203 | { |
| 204 | m_CellInfo = (cellStruct**) realloc(m_CellInfo, sizeof(cellStruct*) * rows); |
| 205 | for (int row = m_NumRows; row < rows ; row++) |
| 206 | { |
| 207 | if (m_NumCols == 0) |
| 208 | m_CellInfo[row] = NULL; |
| 209 | else |
| 210 | { |
| 211 | m_CellInfo[row] = (cellStruct*) malloc(sizeof(cellStruct) * m_NumCols); |
| 212 | for (int col = 0; col < m_NumCols; col++) |
| 213 | m_CellInfo[row][col].flag = cellFree; |
| 214 | } |
| 215 | } |
| 216 | m_NumRows = rows; |
| 217 | } |
| 218 | |
| 219 | |
| 220 | void wxHtmlTableCell::AddRow(const wxHtmlTag& tag) |
| 221 | { |
| 222 | m_ActualCol = -1; |
| 223 | // VS: real allocation of row entry is done in AddCell in order |
| 224 | // to correctly handle empty rows (i.e. "<tr></tr>") |
| 225 | // m_ActualCol == -1 indicates that AddCell has to allocate new row. |
| 226 | |
| 227 | // scan params: |
| 228 | m_rBkg = m_tBkg; |
| 229 | if (tag.HasParam(wxT("BGCOLOR"))) |
| 230 | tag.GetParamAsColour(wxT("BGCOLOR"), &m_rBkg); |
| 231 | if (tag.HasParam(wxT("VALIGN"))) |
| 232 | m_rValign = tag.GetParam(wxT("VALIGN")); |
| 233 | else |
| 234 | m_rValign = m_tValign; |
| 235 | } |
| 236 | |
| 237 | |
| 238 | |
| 239 | void wxHtmlTableCell::AddCell(wxHtmlContainerCell *cell, const wxHtmlTag& tag) |
| 240 | { |
| 241 | // Is this cell in new row? |
| 242 | // VS: we can't do it in AddRow, see my comment there |
| 243 | if (m_ActualCol == -1) |
| 244 | { |
| 245 | if (m_ActualRow + 1 > m_NumRows - 1) |
| 246 | ReallocRows(m_ActualRow + 2); |
| 247 | m_ActualRow++; |
| 248 | } |
| 249 | |
| 250 | // cells & columns: |
| 251 | do |
| 252 | { |
| 253 | m_ActualCol++; |
| 254 | } while ((m_ActualCol < m_NumCols) && |
| 255 | (m_CellInfo[m_ActualRow][m_ActualCol].flag != cellFree)); |
| 256 | |
| 257 | if (m_ActualCol > m_NumCols - 1) |
| 258 | ReallocCols(m_ActualCol + 1); |
| 259 | |
| 260 | int r = m_ActualRow, c = m_ActualCol; |
| 261 | |
| 262 | m_CellInfo[r][c].cont = cell; |
| 263 | m_CellInfo[r][c].colspan = 1; |
| 264 | m_CellInfo[r][c].rowspan = 1; |
| 265 | m_CellInfo[r][c].flag = cellUsed; |
| 266 | m_CellInfo[r][c].minheight = 0; |
| 267 | m_CellInfo[r][c].valign = wxHTML_ALIGN_TOP; |
| 268 | |
| 269 | /* scan for parameters: */ |
| 270 | |
| 271 | // width: |
| 272 | { |
| 273 | if (tag.HasParam(wxT("WIDTH"))) |
| 274 | { |
| 275 | wxString wd = tag.GetParam(wxT("WIDTH")); |
| 276 | |
| 277 | if (wd[wd.Length()-1] == wxT('%')) |
| 278 | { |
| 279 | wxSscanf(wd.c_str(), wxT("%i%%"), &m_ColsInfo[c].width); |
| 280 | m_ColsInfo[c].units = wxHTML_UNITS_PERCENT; |
| 281 | } |
| 282 | else |
| 283 | { |
| 284 | wxSscanf(wd.c_str(), wxT("%i"), &m_ColsInfo[c].width); |
| 285 | m_ColsInfo[c].width = (int)(m_PixelScale * (double)m_ColsInfo[c].width); |
| 286 | m_ColsInfo[c].units = wxHTML_UNITS_PIXELS; |
| 287 | } |
| 288 | } |
| 289 | } |
| 290 | |
| 291 | |
| 292 | // spanning: |
| 293 | { |
| 294 | tag.GetParamAsInt(wxT("COLSPAN"), &m_CellInfo[r][c].colspan); |
| 295 | tag.GetParamAsInt(wxT("ROWSPAN"), &m_CellInfo[r][c].rowspan); |
| 296 | |
| 297 | // VS: the standard says this about col/rowspan: |
| 298 | // "This attribute specifies the number of rows spanned by the |
| 299 | // current cell. The default value of this attribute is one ("1"). |
| 300 | // The value zero ("0") means that the cell spans all rows from the |
| 301 | // current row to the last row of the table." All mainstream |
| 302 | // browsers act as if 0==1, though, and so does wxHTML. |
| 303 | if (m_CellInfo[r][c].colspan < 1) |
| 304 | m_CellInfo[r][c].colspan = 1; |
| 305 | if (m_CellInfo[r][c].rowspan < 1) |
| 306 | m_CellInfo[r][c].rowspan = 1; |
| 307 | |
| 308 | if ((m_CellInfo[r][c].colspan > 1) || (m_CellInfo[r][c].rowspan > 1)) |
| 309 | { |
| 310 | int i, j; |
| 311 | |
| 312 | if (r + m_CellInfo[r][c].rowspan > m_NumRows) |
| 313 | ReallocRows(r + m_CellInfo[r][c].rowspan); |
| 314 | if (c + m_CellInfo[r][c].colspan > m_NumCols) |
| 315 | ReallocCols(c + m_CellInfo[r][c].colspan); |
| 316 | for (i = r; i < r + m_CellInfo[r][c].rowspan; i++) |
| 317 | for (j = c; j < c + m_CellInfo[r][c].colspan; j++) |
| 318 | m_CellInfo[i][j].flag = cellSpan; |
| 319 | m_CellInfo[r][c].flag = cellUsed; |
| 320 | } |
| 321 | } |
| 322 | |
| 323 | //background color: |
| 324 | { |
| 325 | wxColour bk = m_rBkg; |
| 326 | if (tag.HasParam(wxT("BGCOLOR"))) |
| 327 | tag.GetParamAsColour(wxT("BGCOLOR"), &bk); |
| 328 | if (bk.Ok()) |
| 329 | cell->SetBackgroundColour(bk); |
| 330 | } |
| 331 | if (m_HasBorders) |
| 332 | cell->SetBorder(TABLE_BORDER_CLR_2, TABLE_BORDER_CLR_1); |
| 333 | |
| 334 | // vertical alignment: |
| 335 | { |
| 336 | wxString valign; |
| 337 | if (tag.HasParam(wxT("VALIGN"))) |
| 338 | valign = tag.GetParam(wxT("VALIGN")); |
| 339 | else |
| 340 | valign = m_tValign; |
| 341 | valign.MakeUpper(); |
| 342 | if (valign == wxT("TOP")) |
| 343 | m_CellInfo[r][c].valign = wxHTML_ALIGN_TOP; |
| 344 | else if (valign == wxT("BOTTOM")) |
| 345 | m_CellInfo[r][c].valign = wxHTML_ALIGN_BOTTOM; |
| 346 | else m_CellInfo[r][c].valign = wxHTML_ALIGN_CENTER; |
| 347 | } |
| 348 | |
| 349 | cell->SetIndent(m_Padding, wxHTML_INDENT_ALL, wxHTML_UNITS_PIXELS); |
| 350 | } |
| 351 | |
| 352 | void wxHtmlTableCell::ComputeMinMaxWidths() |
| 353 | { |
| 354 | if (m_NumCols == 0 || m_ColsInfo[0].minWidth != -1) return; |
| 355 | |
| 356 | for (int c = 0; c < m_NumCols; c++) |
| 357 | { |
| 358 | for (int r = 0; r < m_NumRows; r++) |
| 359 | { |
| 360 | cellStruct& cell = m_CellInfo[r][c]; |
| 361 | if (cell.flag == cellUsed) |
| 362 | { |
| 363 | cell.cont->Layout(2*m_Padding + 1); |
| 364 | int width = cell.cont->GetWidth(); |
| 365 | width -= (cell.colspan-1) * m_Spacing; |
| 366 | // HTML 4.0 says it is acceptable to distribute min/max |
| 367 | width /= cell.colspan; |
| 368 | for (int j = 0; j < cell.colspan; j++) |
| 369 | if (width > m_ColsInfo[c+j].minWidth) |
| 370 | m_ColsInfo[c+j].minWidth = width; |
| 371 | } |
| 372 | } |
| 373 | } |
| 374 | |
| 375 | // FIXME -- compute maxWidth as well. Not needed yet, so there's no |
| 376 | // point in computing it. |
| 377 | } |
| 378 | |
| 379 | |
| 380 | void wxHtmlTableCell::Layout(int w) |
| 381 | { |
| 382 | ComputeMinMaxWidths(); |
| 383 | |
| 384 | wxHtmlCell::Layout(w); |
| 385 | |
| 386 | /* |
| 387 | |
| 388 | WIDTH ADJUSTING : |
| 389 | |
| 390 | */ |
| 391 | |
| 392 | if (m_WidthFloatUnits == wxHTML_UNITS_PERCENT) |
| 393 | { |
| 394 | if (m_WidthFloat < 0) m_Width = (100 + m_WidthFloat) * w / 100; |
| 395 | else m_Width = m_WidthFloat * w / 100; |
| 396 | } |
| 397 | else |
| 398 | { |
| 399 | if (m_WidthFloat < 0) m_Width = w + m_WidthFloat; |
| 400 | else m_Width = m_WidthFloat; |
| 401 | } |
| 402 | |
| 403 | |
| 404 | /* |
| 405 | |
| 406 | LAYOUTING : |
| 407 | |
| 408 | */ |
| 409 | |
| 410 | /* 1. setup columns widths: */ |
| 411 | { |
| 412 | int wpix = m_Width - (m_NumCols + 1) * m_Spacing; |
| 413 | int i, j; |
| 414 | |
| 415 | // 1a. setup fixed-width columns: |
| 416 | for (i = 0; i < m_NumCols; i++) |
| 417 | if (m_ColsInfo[i].units == wxHTML_UNITS_PIXELS) |
| 418 | { |
| 419 | m_ColsInfo[i].pixwidth = wxMax(m_ColsInfo[i].width, |
| 420 | m_ColsInfo[i].minWidth); |
| 421 | wpix -= m_ColsInfo[i].pixwidth; |
| 422 | } |
| 423 | |
| 424 | // 1b. setup floating-width columns: |
| 425 | int wtemp = 0; |
| 426 | for (i = 0; i < m_NumCols; i++) |
| 427 | if ((m_ColsInfo[i].units == wxHTML_UNITS_PERCENT) && (m_ColsInfo[i].width != 0)) |
| 428 | { |
| 429 | m_ColsInfo[i].pixwidth = wxMax(m_ColsInfo[i].width * wpix / 100, |
| 430 | m_ColsInfo[i].minWidth); |
| 431 | wtemp += m_ColsInfo[i].pixwidth; |
| 432 | } |
| 433 | wpix -= wtemp; |
| 434 | |
| 435 | // 1c. setup defalut columns (no width specification supplied): |
| 436 | // FIXME: This algorithm doesn't conform to HTML standard : it assigns |
| 437 | // equal widths instead of optimal |
| 438 | for (i = j = 0; i < m_NumCols; i++) |
| 439 | if (m_ColsInfo[i].width == 0) j++; |
| 440 | for (i = 0; i < m_NumCols; i++) |
| 441 | if (m_ColsInfo[i].width == 0) |
| 442 | { |
| 443 | // FIXME: this is not optimal, because if we allocate more than |
| 444 | // wpix/j pixels to one column, we should try to allocate |
| 445 | // smaller place to other columns |
| 446 | m_ColsInfo[i].pixwidth = wxMax(wpix/j, m_ColsInfo[i].minWidth); |
| 447 | } |
| 448 | } |
| 449 | |
| 450 | /* 2. compute positions of columns: */ |
| 451 | { |
| 452 | int wpos = m_Spacing; |
| 453 | for (int i = 0; i < m_NumCols; i++) |
| 454 | { |
| 455 | m_ColsInfo[i].leftpos = wpos; |
| 456 | wpos += m_ColsInfo[i].pixwidth + m_Spacing; |
| 457 | } |
| 458 | } |
| 459 | |
| 460 | /* 3. sub-layout all cells: */ |
| 461 | { |
| 462 | int *ypos = new int[m_NumRows + 1]; |
| 463 | |
| 464 | int actcol, actrow; |
| 465 | int fullwid; |
| 466 | wxHtmlContainerCell *actcell; |
| 467 | |
| 468 | ypos[0] = m_Spacing; |
| 469 | for (actrow = 1; actrow <= m_NumRows; actrow++) ypos[actrow] = -1; |
| 470 | for (actrow = 0; actrow < m_NumRows; actrow++) |
| 471 | { |
| 472 | if (ypos[actrow] == -1) ypos[actrow] = ypos[actrow-1]; |
| 473 | // 3a. sub-layout and detect max height: |
| 474 | |
| 475 | for (actcol = 0; actcol < m_NumCols; actcol++) { |
| 476 | if (m_CellInfo[actrow][actcol].flag != cellUsed) continue; |
| 477 | actcell = m_CellInfo[actrow][actcol].cont; |
| 478 | fullwid = 0; |
| 479 | for (int i = actcol; i < m_CellInfo[actrow][actcol].colspan + actcol; i++) |
| 480 | fullwid += m_ColsInfo[i].pixwidth; |
| 481 | fullwid += (m_CellInfo[actrow][actcol].colspan - 1) * m_Spacing; |
| 482 | actcell->SetMinHeight(m_CellInfo[actrow][actcol].minheight, m_CellInfo[actrow][actcol].valign); |
| 483 | actcell->Layout(fullwid); |
| 484 | |
| 485 | if (ypos[actrow] + actcell->GetHeight() + m_CellInfo[actrow][actcol].rowspan * m_Spacing > ypos[actrow + m_CellInfo[actrow][actcol].rowspan]) |
| 486 | ypos[actrow + m_CellInfo[actrow][actcol].rowspan] = |
| 487 | ypos[actrow] + actcell->GetHeight() + m_CellInfo[actrow][actcol].rowspan * m_Spacing; |
| 488 | } |
| 489 | } |
| 490 | |
| 491 | for (actrow = 0; actrow < m_NumRows; actrow++) |
| 492 | { |
| 493 | // 3b. place cells in row & let'em all have same height: |
| 494 | |
| 495 | for (actcol = 0; actcol < m_NumCols; actcol++) |
| 496 | { |
| 497 | if (m_CellInfo[actrow][actcol].flag != cellUsed) continue; |
| 498 | actcell = m_CellInfo[actrow][actcol].cont; |
| 499 | actcell->SetMinHeight( |
| 500 | ypos[actrow + m_CellInfo[actrow][actcol].rowspan] - ypos[actrow] - m_Spacing, |
| 501 | m_CellInfo[actrow][actcol].valign); |
| 502 | fullwid = 0; |
| 503 | for (int i = actcol; i < m_CellInfo[actrow][actcol].colspan + actcol; i++) |
| 504 | fullwid += m_ColsInfo[i].pixwidth; |
| 505 | fullwid += (m_CellInfo[actrow][actcol].colspan - 1) * m_Spacing; |
| 506 | actcell->Layout(fullwid); |
| 507 | actcell->SetPos(m_ColsInfo[actcol].leftpos, ypos[actrow]); |
| 508 | } |
| 509 | } |
| 510 | m_Height = ypos[m_NumRows]; |
| 511 | delete[] ypos; |
| 512 | } |
| 513 | |
| 514 | /* 4. adjust table's width if it was too small: */ |
| 515 | if (m_NumCols > 0) |
| 516 | { |
| 517 | int twidth = m_ColsInfo[m_NumCols-1].leftpos + |
| 518 | m_ColsInfo[m_NumCols-1].pixwidth + m_Spacing; |
| 519 | if (twidth > m_Width) |
| 520 | m_Width = twidth; |
| 521 | } |
| 522 | } |
| 523 | |
| 524 | |
| 525 | |
| 526 | |
| 527 | |
| 528 | |
| 529 | //----------------------------------------------------------------------------- |
| 530 | // The tables handler: |
| 531 | //----------------------------------------------------------------------------- |
| 532 | |
| 533 | |
| 534 | TAG_HANDLER_BEGIN(TABLE, "TABLE,TR,TD,TH") |
| 535 | |
| 536 | TAG_HANDLER_VARS |
| 537 | wxHtmlTableCell* m_Table; |
| 538 | wxString m_tAlign, m_rAlign; |
| 539 | |
| 540 | TAG_HANDLER_CONSTR(TABLE) |
| 541 | { |
| 542 | m_Table = NULL; |
| 543 | m_tAlign = m_rAlign = wxEmptyString; |
| 544 | } |
| 545 | |
| 546 | |
| 547 | TAG_HANDLER_PROC(tag) |
| 548 | { |
| 549 | wxHtmlContainerCell *c; |
| 550 | |
| 551 | // new table started, backup upper-level table (if any) and create new: |
| 552 | if (tag.GetName() == wxT("TABLE")) |
| 553 | { |
| 554 | wxHtmlTableCell *oldt = m_Table; |
| 555 | wxHtmlContainerCell *oldcont; |
| 556 | |
| 557 | oldcont = c = m_WParser->OpenContainer(); |
| 558 | |
| 559 | c->SetWidthFloat(tag, m_WParser->GetPixelScale()); |
| 560 | m_Table = new wxHtmlTableCell(c, tag, m_WParser->GetPixelScale()); |
| 561 | int oldAlign = m_WParser->GetAlign(); |
| 562 | m_tAlign = wxEmptyString; |
| 563 | if (tag.HasParam(wxT("ALIGN"))) |
| 564 | m_tAlign = tag.GetParam(wxT("ALIGN")); |
| 565 | |
| 566 | ParseInner(tag); |
| 567 | |
| 568 | m_WParser->SetAlign(oldAlign); |
| 569 | m_WParser->SetContainer(oldcont); |
| 570 | m_WParser->CloseContainer(); |
| 571 | |
| 572 | m_Table = oldt; |
| 573 | return TRUE; |
| 574 | } |
| 575 | |
| 576 | |
| 577 | else if (m_Table) |
| 578 | { |
| 579 | // new row in table |
| 580 | if (tag.GetName() == wxT("TR")) |
| 581 | { |
| 582 | m_Table->AddRow(tag); |
| 583 | m_rAlign = m_tAlign; |
| 584 | if (tag.HasParam(wxT("ALIGN"))) |
| 585 | m_rAlign = tag.GetParam(wxT("ALIGN")); |
| 586 | } |
| 587 | |
| 588 | // new cell |
| 589 | else |
| 590 | { |
| 591 | c = m_WParser->SetContainer(new wxHtmlContainerCell(m_Table)); |
| 592 | m_Table->AddCell(c, tag); |
| 593 | |
| 594 | m_WParser->OpenContainer(); |
| 595 | |
| 596 | if (tag.GetName() == wxT("TH")) /*header style*/ |
| 597 | m_WParser->SetAlign(wxHTML_ALIGN_CENTER); |
| 598 | else |
| 599 | m_WParser->SetAlign(wxHTML_ALIGN_LEFT); |
| 600 | |
| 601 | wxString als; |
| 602 | |
| 603 | als = m_rAlign; |
| 604 | if (tag.HasParam(wxT("ALIGN"))) |
| 605 | als = tag.GetParam(wxT("ALIGN")); |
| 606 | als.MakeUpper(); |
| 607 | if (als == wxT("RIGHT")) |
| 608 | m_WParser->SetAlign(wxHTML_ALIGN_RIGHT); |
| 609 | else if (als == wxT("LEFT")) |
| 610 | m_WParser->SetAlign(wxHTML_ALIGN_LEFT); |
| 611 | else if (als == wxT("CENTER")) |
| 612 | m_WParser->SetAlign(wxHTML_ALIGN_CENTER); |
| 613 | |
| 614 | m_WParser->OpenContainer(); |
| 615 | } |
| 616 | } |
| 617 | return FALSE; |
| 618 | } |
| 619 | |
| 620 | TAG_HANDLER_END(TABLE) |
| 621 | |
| 622 | |
| 623 | |
| 624 | |
| 625 | |
| 626 | TAGS_MODULE_BEGIN(Tables) |
| 627 | |
| 628 | TAGS_MODULE_ADD(TABLE) |
| 629 | |
| 630 | TAGS_MODULE_END(Tables) |
| 631 | |
| 632 | |
| 633 | #endif |