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 #ifdef __GNUG__
  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