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 __BORDLANDC__
  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
 130
 131
 132 wxHtmlTableCell::wxHtmlTableCell(wxHtmlContainerCell *parent, const wxHtmlTag& tag, double pixel_scale)
 133  : wxHtmlContainerCell(parent)
 134 {
 135     m_PixelScale = pixel_scale;
 136     m_HasBorders =
 137             (tag.HasParam(wxT("BORDER")) && tag.GetParam(wxT("BORDER")) != wxT("0"));
 138     m_ColsInfo = NULL;
 139     m_NumCols = m_NumRows = 0;
 140     m_CellInfo = NULL;
 141     m_ActualCol = m_ActualRow = -1;
 142
 143     /* scan params: */
 144     if (tag.HasParam(wxT("BGCOLOR")))
 145         tag.GetParamAsColour(wxT("BGCOLOR"), &m_tBkg);
 146     if (tag.HasParam(wxT("VALIGN")))
 147         m_tValign = tag.GetParam(wxT("VALIGN"));
 148     else
 149         m_tValign = wxEmptyString;
 150     if (!tag.GetParamAsInt(wxT("CELLSPACING"), &m_Spacing))
 151         m_Spacing = 2;
 152     if (!tag.GetParamAsInt(wxT("CELLPADDING"), &m_Padding))
 153         m_Padding = 3;
 154     m_Spacing = (int)(m_PixelScale * (double)m_Spacing);
 155     m_Padding = (int)(m_PixelScale * (double)m_Padding);
 156
 157     if (m_HasBorders)
 158         SetBorder(TABLE_BORDER_CLR_1, TABLE_BORDER_CLR_2);
 159 }
 160
 161
 162
 163 wxHtmlTableCell::~wxHtmlTableCell()
 164 {
 165     if (m_ColsInfo) free(m_ColsInfo);
 166     if (m_CellInfo)
 167     {
 168         for (int i = 0; i < m_NumRows; i++)
 169             free(m_CellInfo[i]);
 170         free(m_CellInfo);
 171     }
 172 }
 173
 174
 175
 176 void wxHtmlTableCell::ReallocCols(int cols)
 177 {
 178     int i,j;
 179
 180     for (i = 0; i < m_NumRows; i++)
 181     {
 182         m_CellInfo[i] = (cellStruct*) realloc(m_CellInfo[i], sizeof(cellStruct) * cols);
 183         for (j = m_NumCols; j < cols; j++)
 184             m_CellInfo[i][j].flag = cellFree;
 185     }
 186
 187     m_ColsInfo = (colStruct*) realloc(m_ColsInfo, sizeof(colStruct) * cols);
 188     for (j = m_NumCols; j < cols; j++)
 189     {
 190            m_ColsInfo[j].width = 0;
 191            m_ColsInfo[j].units = wxHTML_UNITS_PERCENT;
 192            m_ColsInfo[j].minWidth = m_ColsInfo[j].maxWidth = -1;
 193     }
 194
 195     m_NumCols = cols;
 196 }
 197
 198
 199
 200 void wxHtmlTableCell::ReallocRows(int rows)
 201 {
 202     m_CellInfo = (cellStruct**) realloc(m_CellInfo, sizeof(cellStruct*) * rows);
 203     for (int row = m_NumRows; row < rows ; row++)
 204     {
 205         if (m_NumCols == 0)
 206             m_CellInfo[row] = NULL;
 207         else
 208         {
 209             m_CellInfo[row] = (cellStruct*) malloc(sizeof(cellStruct) * m_NumCols);
 210             for (int col = 0; col < m_NumCols; col++)
 211                 m_CellInfo[row][col].flag = cellFree;
 212         }
 213     }
 214     m_NumRows = rows;
 215 }
 216
 217
 218 void wxHtmlTableCell::AddRow(const wxHtmlTag& tag)
 219 {
 220     m_ActualCol = -1;
 221     // VS: real allocation of row entry is done in AddCell in order
 222     //     to correctly handle empty rows (i.e. "<tr></tr>")
 223     //     m_ActualCol == -1 indicates that AddCell has to allocate new row.
 224
 225     // scan params:
 226     m_rBkg = m_tBkg;
 227     if (tag.HasParam(wxT("BGCOLOR")))
 228         tag.GetParamAsColour(wxT("BGCOLOR"), &m_rBkg);
 229     if (tag.HasParam(wxT("VALIGN")))
 230         m_rValign = tag.GetParam(wxT("VALIGN"));
 231     else
 232         m_rValign = m_tValign;
 233 }
 234
 235
 236
 237 void wxHtmlTableCell::AddCell(wxHtmlContainerCell *cell, const wxHtmlTag& tag)
 238 {
 239     // Is this cell in new row?
 240     // VS: we can't do it in AddRow, see my comment there
 241     if (m_ActualCol == -1)
 242     {
 243         if (m_ActualRow + 1 > m_NumRows - 1)
 244             ReallocRows(m_ActualRow + 2);
 245         m_ActualRow++;
 246     }
 247
 248     // cells & columns:
 249     do
 250     {
 251         m_ActualCol++;
 252     } while ((m_ActualCol < m_NumCols) &&
 253              (m_CellInfo[m_ActualRow][m_ActualCol].flag != cellFree));
 254
 255     if (m_ActualCol > m_NumCols - 1)
 256         ReallocCols(m_ActualCol + 1);
 257
 258     int r = m_ActualRow, c = m_ActualCol;
 259
 260     m_CellInfo[r][c].cont = cell;
 261     m_CellInfo[r][c].colspan = 1;
 262     m_CellInfo[r][c].rowspan = 1;
 263     m_CellInfo[r][c].flag = cellUsed;
 264     m_CellInfo[r][c].minheight = 0;
 265     m_CellInfo[r][c].valign = wxHTML_ALIGN_TOP;
 266
 267     /* scan for parameters: */
 268
 269     // width:
 270     {
 271         if (tag.HasParam(wxT("WIDTH")))
 272         {
 273             wxString wd = tag.GetParam(wxT("WIDTH"));
 274
 275             if (wd[wd.Length()-1] == wxT('%'))
 276             {
 277                 wxSscanf(wd.c_str(), wxT("%i%%"), &m_ColsInfo[c].width);
 278                 m_ColsInfo[c].units = wxHTML_UNITS_PERCENT;
 279             }
 280             else
 281             {
 282                 wxSscanf(wd.c_str(), wxT("%i"), &m_ColsInfo[c].width);
 283                 m_ColsInfo[c].width = (int)(m_PixelScale * (double)m_ColsInfo[c].width);
 284                 m_ColsInfo[c].units = wxHTML_UNITS_PIXELS;
 285             }
 286         }
 287     }
 288
 289
 290     // spanning:
 291     {
 292         tag.GetParamAsInt(wxT("COLSPAN"), &m_CellInfo[r][c].colspan);
 293         tag.GetParamAsInt(wxT("ROWSPAN"), &m_CellInfo[r][c].rowspan);
 294         if ((m_CellInfo[r][c].colspan != 1) || (m_CellInfo[r][c].rowspan != 1))
 295         {
 296             int i, j;
 297
 298             if (r + m_CellInfo[r][c].rowspan > m_NumRows)
 299                 ReallocRows(r + m_CellInfo[r][c].rowspan);
 300             if (c + m_CellInfo[r][c].colspan > m_NumCols)
 301                 ReallocCols(c + m_CellInfo[r][c].colspan);
 302             for (i = r; i < r + m_CellInfo[r][c].rowspan; i++)
 303                 for (j = c; j < c + m_CellInfo[r][c].colspan; j++)
 304                     m_CellInfo[i][j].flag = cellSpan;
 305             m_CellInfo[r][c].flag = cellUsed;
 306         }
 307     }
 308
 309     //background color:
 310     {
 311         wxColour bk = m_rBkg;
 312         if (tag.HasParam(wxT("BGCOLOR")))
 313             tag.GetParamAsColour(wxT("BGCOLOR"), &bk);
 314         if (bk.Ok())
 315             cell->SetBackgroundColour(bk);
 316     }
 317     if (m_HasBorders)
 318         cell->SetBorder(TABLE_BORDER_CLR_2, TABLE_BORDER_CLR_1);
 319
 320     // vertical alignment:
 321     {
 322         wxString valign;
 323         if (tag.HasParam(wxT("VALIGN")))
 324             valign = tag.GetParam(wxT("VALIGN"));
 325         else
 326             valign = m_tValign;
 327         valign.MakeUpper();
 328         if (valign == wxT("TOP"))
 329             m_CellInfo[r][c].valign = wxHTML_ALIGN_TOP;
 330         else if (valign == wxT("BOTTOM"))
 331             m_CellInfo[r][c].valign = wxHTML_ALIGN_BOTTOM;
 332         else m_CellInfo[r][c].valign = wxHTML_ALIGN_CENTER;
 333     }
 334
 335     cell->SetIndent(m_Padding, wxHTML_INDENT_ALL, wxHTML_UNITS_PIXELS);
 336 }
 337
 338
 339
 340 void wxHtmlTableCell::ComputeMinMaxWidths()
 341 {
 342     if (m_NumCols == 0 || m_ColsInfo[0].minWidth != -1) return;
 343
 344     int left, right, width;
 345
 346     m_ColsInfo[0].minWidth = 0; // avoid recursion
 347     Layout(1);
 348     for (int c = 0; c < m_NumCols; c++)
 349     {
 350         for (int r = 0; r < m_NumRows; r++)
 351         {
 352             cellStruct& cell = m_CellInfo[r][c];
 353             if (cell.flag == cellUsed)
 354             {
 355                 cell.cont->GetHorizontalConstraints(&left, &right);
 356                 width = right - left + 1;
 357                 // HTML 4.0 says it is acceptable to distribute min/max
 358                 // width of spanning cells evently
 359                 width /= cell.colspan;
 360                 width += m_Spacing + 2*m_Padding;
 361                 for (int j = 0; j < cell.colspan; j++)
 362                     if (width > m_ColsInfo[c+j].minWidth)
 363                         m_ColsInfo[c+j].minWidth = width;
 364             }
 365         }
 366     }
 367
 368     // FIXME -- compute maxWidth as well. Not needed yet, so there's no
 369     //          point in computing it.
 370 }
 371
 372
 373 void wxHtmlTableCell::Layout(int w)
 374 {
 375     ComputeMinMaxWidths();
 376
 377     /*
 378
 379     WIDTH ADJUSTING :
 380
 381     */
 382
 383     if (m_WidthFloatUnits == wxHTML_UNITS_PERCENT)
 384     {
 385         if (m_WidthFloat < 0) m_Width = (100 + m_WidthFloat) * w / 100;
 386         else m_Width = m_WidthFloat * w / 100;
 387     }
 388     else
 389     {
 390         if (m_WidthFloat < 0) m_Width = w + m_WidthFloat;
 391         else m_Width = m_WidthFloat;
 392     }
 393
 394
 395     /*
 396
 397     LAYOUTING :
 398
 399     */
 400
 401     /* 1.  setup columns widths: */
 402     {
 403         int wpix = m_Width - (m_NumCols + 1) * m_Spacing;
 404         int i, j;
 405
 406         // 1a. setup fixed-width columns:
 407         for (i = 0; i < m_NumCols; i++)
 408             if (m_ColsInfo[i].units == wxHTML_UNITS_PIXELS)
 409             {
 410                 m_ColsInfo[i].pixwidth = wxMax(m_ColsInfo[i].width,
 411                                                m_ColsInfo[i].minWidth);
 412                 wpix -= m_ColsInfo[i].pixwidth;
 413             }
 414
 415         // 1b. setup floating-width columns:
 416         int wtemp = 0;
 417         for (i = 0; i < m_NumCols; i++)
 418             if ((m_ColsInfo[i].units == wxHTML_UNITS_PERCENT) && (m_ColsInfo[i].width != 0))
 419             {
 420                 m_ColsInfo[i].pixwidth = wxMax(m_ColsInfo[i].width * wpix / 100,
 421                                                m_ColsInfo[i].minWidth);
 422                 wtemp += m_ColsInfo[i].pixwidth;
 423             }
 424         wpix -= wtemp;
 425
 426         // 1c. setup defalut columns (no width specification supplied):
 427         // NOTE! This algorithm doesn't conform to HTML standard : it assigns equal widths
 428         // instead of optimal
 429         for (i = j = 0; i < m_NumCols; i++)
 430             if (m_ColsInfo[i].width == 0) j++;
 431         for (i = 0; i < m_NumCols; i++)
 432             if (m_ColsInfo[i].width == 0)
 433                 m_ColsInfo[i].pixwidth = wpix / j;
 434     }
 435
 436     /* 2.  compute positions of columns: */
 437     {
 438         int wpos = m_Spacing;
 439         for (int i = 0; i < m_NumCols; i++)
 440         {
 441             m_ColsInfo[i].leftpos = wpos;
 442             wpos += m_ColsInfo[i].pixwidth + m_Spacing;
 443         }
 444     }
 445
 446     /* 3.  sub-layout all cells: */
 447     {
 448         int *ypos = new int[m_NumRows + 1];
 449
 450         int actcol, actrow;
 451         int fullwid;
 452         wxHtmlContainerCell *actcell;
 453
 454         ypos[0] = m_Spacing;
 455         for (actrow = 1; actrow <= m_NumRows; actrow++) ypos[actrow] = -1;
 456         for (actrow = 0; actrow < m_NumRows; actrow++)
 457         {
 458             if (ypos[actrow] == -1) ypos[actrow] = ypos[actrow-1];
 459             // 3a. sub-layout and detect max height:
 460
 461             for (actcol = 0; actcol < m_NumCols; actcol++) {
 462                 if (m_CellInfo[actrow][actcol].flag != cellUsed) continue;
 463                 actcell = m_CellInfo[actrow][actcol].cont;
 464                 fullwid = 0;
 465                 for (int i = actcol; i < m_CellInfo[actrow][actcol].colspan + actcol; i++)
 466                     fullwid += m_ColsInfo[i].pixwidth;
 467                 fullwid += (m_CellInfo[actrow][actcol].colspan - 1) * m_Spacing;
 468                 actcell->SetMinHeight(m_CellInfo[actrow][actcol].minheight, m_CellInfo[actrow][actcol].valign);
 469                 actcell->Layout(fullwid);
 470
 471                 if (ypos[actrow] + actcell->GetHeight() + m_CellInfo[actrow][actcol].rowspan * m_Spacing > ypos[actrow + m_CellInfo[actrow][actcol].rowspan])
 472                     ypos[actrow + m_CellInfo[actrow][actcol].rowspan] =
 473                             ypos[actrow] + actcell->GetHeight() + m_CellInfo[actrow][actcol].rowspan * m_Spacing;
 474             }
 475         }
 476
 477         for (actrow = 0; actrow < m_NumRows; actrow++)
 478         {
 479             // 3b. place cells in row & let'em all have same height:
 480
 481             for (actcol = 0; actcol < m_NumCols; actcol++)
 482             {
 483                 if (m_CellInfo[actrow][actcol].flag != cellUsed) continue;
 484                 actcell = m_CellInfo[actrow][actcol].cont;
 485                 actcell->SetMinHeight(
 486                                  ypos[actrow + m_CellInfo[actrow][actcol].rowspan] - ypos[actrow] -  m_Spacing,
 487                                  m_CellInfo[actrow][actcol].valign);
 488                 fullwid = 0;
 489                 for (int i = actcol; i < m_CellInfo[actrow][actcol].colspan + actcol; i++)
 490                     fullwid += m_ColsInfo[i].pixwidth;
 491                 fullwid += (m_CellInfo[actrow][actcol].colspan - 1) * m_Spacing;
 492                 actcell->Layout(fullwid);
 493                 actcell->SetPos(m_ColsInfo[actcol].leftpos, ypos[actrow]);
 494             }
 495         }
 496         m_Height = ypos[m_NumRows];
 497         delete[] ypos;
 498     }
 499 }
 500
 501
 502
 503
 504
 505
 506 //-----------------------------------------------------------------------------
 507 // The tables handler:
 508 //-----------------------------------------------------------------------------
 509
 510
 511 TAG_HANDLER_BEGIN(TABLE, "TABLE,TR,TD,TH")
 512
 513     TAG_HANDLER_VARS
 514         wxHtmlTableCell* m_Table;
 515         wxString m_tAlign, m_rAlign;
 516         int m_OldAlign;
 517
 518     TAG_HANDLER_CONSTR(TABLE)
 519     {
 520         m_Table = NULL;
 521         m_tAlign = m_rAlign = wxEmptyString;
 522         m_OldAlign = wxHTML_ALIGN_LEFT;
 523     }
 524
 525
 526     TAG_HANDLER_PROC(tag)
 527     {
 528         wxHtmlContainerCell *c;
 529
 530         // new table started, backup upper-level table (if any) and create new:
 531         if (tag.GetName() == wxT("TABLE"))
 532         {
 533             wxHtmlTableCell *oldt = m_Table;
 534             wxHtmlContainerCell *oldcont;
 535             int m_OldAlign;
 536
 537             oldcont = c = m_WParser->OpenContainer();
 538
 539             c->SetWidthFloat(tag, m_WParser->GetPixelScale());
 540             m_Table = new wxHtmlTableCell(c, tag, m_WParser->GetPixelScale());
 541             m_OldAlign = m_WParser->GetAlign();
 542             m_tAlign = wxEmptyString;
 543             if (tag.HasParam(wxT("ALIGN")))
 544                 m_tAlign = tag.GetParam(wxT("ALIGN"));
 545
 546             ParseInner(tag);
 547
 548             m_WParser->SetAlign(m_OldAlign);
 549             m_WParser->SetContainer(oldcont);
 550             m_WParser->CloseContainer();
 551             m_Table = oldt;
 552             return TRUE;
 553         }
 554
 555
 556         else if (m_Table)
 557         {
 558             // new row in table
 559             if (tag.GetName() == wxT("TR"))
 560             {
 561                 m_Table->AddRow(tag);
 562                 m_rAlign = m_tAlign;
 563                 if (tag.HasParam(wxT("ALIGN")))
 564                     m_rAlign = tag.GetParam(wxT("ALIGN"));
 565             }
 566
 567             // new cell
 568             else
 569             {
 570                 m_WParser->SetAlign(m_OldAlign);
 571                 c = m_WParser->SetContainer(new wxHtmlContainerCell(m_Table));
 572                 m_Table->AddCell(c, tag);
 573
 574                 m_WParser->OpenContainer();
 575
 576                 if (tag.GetName() == wxT("TH")) /*header style*/
 577                 {
 578                     m_WParser->SetAlign(wxHTML_ALIGN_CENTER);
 579                 }
 580
 581                 {
 582                     wxString als;
 583
 584                     als = m_rAlign;
 585                     if (tag.HasParam(wxT("ALIGN")))
 586                         als = tag.GetParam(wxT("ALIGN"));
 587                     als.MakeUpper();
 588                     if (als == wxT("RIGHT"))
 589                         m_WParser->SetAlign(wxHTML_ALIGN_RIGHT);
 590                     else if (als == wxT("CENTER"))
 591                         m_WParser->SetAlign(wxHTML_ALIGN_CENTER);
 592                 }
 593                 m_WParser->OpenContainer();
 594             }
 595         }
 596         return FALSE;
 597     }
 598
 599 TAG_HANDLER_END(TABLE)
 600
 601
 602
 603
 604
 605 TAGS_MODULE_BEGIN(Tables)
 606
 607     TAGS_MODULE_ADD(TABLE)
 608
 609 TAGS_MODULE_END(Tables)
 610
 611
 612 #endif