home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2240.zip / wxWindows-2.4.0 / src / html / m_tables.cpp < prev    next >
C/C++ Source or Header  |  2002-11-09  |  19KB  |  622 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Name:        m_tables.cpp
  3. // Purpose:     wxHtml module for tables
  4. // Author:      Vaclav Slavik
  5. // RCS-ID:      $Id: m_tables.cpp,v 1.27.2.3 2002/11/09 00:07:36 VS Exp $
  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.  
  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.  
  295.         // VS: the standard says this about col/rowspan:
  296.         //     "This attribute specifies the number of rows spanned by the 
  297.         //     current cell. The default value of this attribute is one ("1"). 
  298.         //     The value zero ("0") means that the cell spans all rows from the 
  299.         //     current row to the last row of the table." All mainstream 
  300.         //     browsers act as if 0==1, though, and so does wxHTML.
  301.         if (m_CellInfo[r][c].colspan < 1) 
  302.             m_CellInfo[r][c].colspan = 1;
  303.         if (m_CellInfo[r][c].rowspan < 1) 
  304.             m_CellInfo[r][c].rowspan = 1;
  305.  
  306.         if ((m_CellInfo[r][c].colspan > 1) || (m_CellInfo[r][c].rowspan > 1))
  307.         {
  308.             int i, j;
  309.  
  310.             if (r + m_CellInfo[r][c].rowspan > m_NumRows)
  311.                 ReallocRows(r + m_CellInfo[r][c].rowspan);
  312.             if (c + m_CellInfo[r][c].colspan > m_NumCols)
  313.                 ReallocCols(c + m_CellInfo[r][c].colspan);
  314.             for (i = r; i < r + m_CellInfo[r][c].rowspan; i++)
  315.                 for (j = c; j < c + m_CellInfo[r][c].colspan; j++)
  316.                     m_CellInfo[i][j].flag = cellSpan;
  317.             m_CellInfo[r][c].flag = cellUsed;
  318.         }
  319.     }
  320.  
  321.     //background color:
  322.     {
  323.         wxColour bk = m_rBkg;
  324.         if (tag.HasParam(wxT("BGCOLOR")))
  325.             tag.GetParamAsColour(wxT("BGCOLOR"), &bk);
  326.         if (bk.Ok())
  327.             cell->SetBackgroundColour(bk);
  328.     }
  329.     if (m_HasBorders)
  330.         cell->SetBorder(TABLE_BORDER_CLR_2, TABLE_BORDER_CLR_1);
  331.  
  332.     // vertical alignment:
  333.     {
  334.         wxString valign;
  335.         if (tag.HasParam(wxT("VALIGN")))
  336.             valign = tag.GetParam(wxT("VALIGN"));
  337.         else
  338.             valign = m_tValign;
  339.         valign.MakeUpper();
  340.         if (valign == wxT("TOP"))
  341.             m_CellInfo[r][c].valign = wxHTML_ALIGN_TOP;
  342.         else if (valign == wxT("BOTTOM"))
  343.             m_CellInfo[r][c].valign = wxHTML_ALIGN_BOTTOM;
  344.         else m_CellInfo[r][c].valign = wxHTML_ALIGN_CENTER;
  345.     }
  346.  
  347.     cell->SetIndent(m_Padding, wxHTML_INDENT_ALL, wxHTML_UNITS_PIXELS);
  348. }
  349.  
  350. void wxHtmlTableCell::ComputeMinMaxWidths()
  351. {
  352.     if (m_NumCols == 0 || m_ColsInfo[0].minWidth != -1) return;
  353.     
  354.     int left, right, width;
  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.                 cell.cont->GetHorizontalConstraints(&left, &right);
  365.                 width = right - left;
  366.                 width -= (cell.colspan-1) * m_Spacing;
  367.                 // HTML 4.0 says it is acceptable to distribute min/max
  368.                 // width of spanning cells evently
  369.                 width /= cell.colspan;
  370.                 for (int j = 0; j < cell.colspan; j++)
  371.                     if (width > m_ColsInfo[c+j].minWidth)
  372.                         m_ColsInfo[c+j].minWidth = width;
  373.             }
  374.         }
  375.     }
  376.     
  377.     // FIXME -- compute maxWidth as well. Not needed yet, so there's no
  378.     //          point in computing it. 
  379. }
  380.  
  381.  
  382. void wxHtmlTableCell::Layout(int w)
  383. {
  384.     ComputeMinMaxWidths();
  385.     
  386.     wxHtmlCell::Layout(w);
  387.  
  388.     /*
  389.  
  390.     WIDTH ADJUSTING :
  391.  
  392.     */
  393.  
  394.     if (m_WidthFloatUnits == wxHTML_UNITS_PERCENT)
  395.     {
  396.         if (m_WidthFloat < 0) m_Width = (100 + m_WidthFloat) * w / 100;
  397.         else m_Width = m_WidthFloat * w / 100;
  398.     }
  399.     else
  400.     {
  401.         if (m_WidthFloat < 0) m_Width = w + m_WidthFloat;
  402.         else m_Width = m_WidthFloat;
  403.     }
  404.  
  405.  
  406.     /*
  407.  
  408.     LAYOUTING :
  409.  
  410.     */
  411.  
  412.     /* 1.  setup columns widths: */
  413.     {
  414.         int wpix = m_Width - (m_NumCols + 1) * m_Spacing;
  415.         int i, j;
  416.  
  417.         // 1a. setup fixed-width columns:
  418.         for (i = 0; i < m_NumCols; i++)
  419.             if (m_ColsInfo[i].units == wxHTML_UNITS_PIXELS)
  420.             {
  421.                 m_ColsInfo[i].pixwidth = wxMax(m_ColsInfo[i].width, 
  422.                                                m_ColsInfo[i].minWidth);
  423.                 wpix -= m_ColsInfo[i].pixwidth;
  424.             }
  425.  
  426.         // 1b. setup floating-width columns:
  427.         int wtemp = 0;
  428.         for (i = 0; i < m_NumCols; i++)
  429.             if ((m_ColsInfo[i].units == wxHTML_UNITS_PERCENT) && (m_ColsInfo[i].width != 0))
  430.             {
  431.                 m_ColsInfo[i].pixwidth = wxMax(m_ColsInfo[i].width * wpix / 100,
  432.                                                m_ColsInfo[i].minWidth);
  433.                 wtemp += m_ColsInfo[i].pixwidth;
  434.             }
  435.         wpix -= wtemp;
  436.  
  437.         // 1c. setup defalut columns (no width specification supplied):
  438.         // NOTE! This algorithm doesn't conform to HTML standard : it assigns equal widths
  439.         // instead of optimal
  440.         for (i = j = 0; i < m_NumCols; i++)
  441.             if (m_ColsInfo[i].width == 0) j++;
  442.         for (i = 0; i < m_NumCols; i++)
  443.             if (m_ColsInfo[i].width == 0)
  444.                 m_ColsInfo[i].pixwidth = wpix / j;
  445.     }
  446.  
  447.     /* 2.  compute positions of columns: */
  448.     {
  449.         int wpos = m_Spacing;
  450.         for (int i = 0; i < m_NumCols; i++)
  451.         {
  452.             m_ColsInfo[i].leftpos = wpos;
  453.             wpos += m_ColsInfo[i].pixwidth + m_Spacing;
  454.         }
  455.     }
  456.  
  457.     /* 3.  sub-layout all cells: */
  458.     {
  459.         int *ypos = new int[m_NumRows + 1];
  460.  
  461.         int actcol, actrow;
  462.         int fullwid;
  463.         wxHtmlContainerCell *actcell;
  464.  
  465.         ypos[0] = m_Spacing;
  466.         for (actrow = 1; actrow <= m_NumRows; actrow++) ypos[actrow] = -1;
  467.         for (actrow = 0; actrow < m_NumRows; actrow++)
  468.         {
  469.             if (ypos[actrow] == -1) ypos[actrow] = ypos[actrow-1];
  470.             // 3a. sub-layout and detect max height:
  471.  
  472.             for (actcol = 0; actcol < m_NumCols; actcol++) {
  473.                 if (m_CellInfo[actrow][actcol].flag != cellUsed) continue;
  474.                 actcell = m_CellInfo[actrow][actcol].cont;
  475.                 fullwid = 0;
  476.                 for (int i = actcol; i < m_CellInfo[actrow][actcol].colspan + actcol; i++)
  477.                     fullwid += m_ColsInfo[i].pixwidth;
  478.                 fullwid += (m_CellInfo[actrow][actcol].colspan - 1) * m_Spacing;
  479.                 actcell->SetMinHeight(m_CellInfo[actrow][actcol].minheight, m_CellInfo[actrow][actcol].valign);
  480.                 actcell->Layout(fullwid);
  481.  
  482.                 if (ypos[actrow] + actcell->GetHeight() + m_CellInfo[actrow][actcol].rowspan * m_Spacing > ypos[actrow + m_CellInfo[actrow][actcol].rowspan])
  483.                     ypos[actrow + m_CellInfo[actrow][actcol].rowspan] =
  484.                             ypos[actrow] + actcell->GetHeight() + m_CellInfo[actrow][actcol].rowspan * m_Spacing;
  485.             }
  486.         }
  487.  
  488.         for (actrow = 0; actrow < m_NumRows; actrow++)
  489.         {
  490.             // 3b. place cells in row & let'em all have same height:
  491.  
  492.             for (actcol = 0; actcol < m_NumCols; actcol++)
  493.             {
  494.                 if (m_CellInfo[actrow][actcol].flag != cellUsed) continue;
  495.                 actcell = m_CellInfo[actrow][actcol].cont;
  496.                 actcell->SetMinHeight(
  497.                                  ypos[actrow + m_CellInfo[actrow][actcol].rowspan] - ypos[actrow] -  m_Spacing,
  498.                                  m_CellInfo[actrow][actcol].valign);
  499.                 fullwid = 0;
  500.                 for (int i = actcol; i < m_CellInfo[actrow][actcol].colspan + actcol; i++)
  501.                     fullwid += m_ColsInfo[i].pixwidth;
  502.                 fullwid += (m_CellInfo[actrow][actcol].colspan - 1) * m_Spacing;
  503.                 actcell->Layout(fullwid);
  504.                 actcell->SetPos(m_ColsInfo[actcol].leftpos, ypos[actrow]);
  505.             }
  506.         }
  507.         m_Height = ypos[m_NumRows];
  508.         delete[] ypos;
  509.     }
  510. }
  511.  
  512.  
  513.  
  514.  
  515.  
  516.  
  517. //-----------------------------------------------------------------------------
  518. // The tables handler:
  519. //-----------------------------------------------------------------------------
  520.  
  521.  
  522. TAG_HANDLER_BEGIN(TABLE, "TABLE,TR,TD,TH")
  523.  
  524.     TAG_HANDLER_VARS
  525.         wxHtmlTableCell* m_Table;
  526.         wxString m_tAlign, m_rAlign;
  527.  
  528.     TAG_HANDLER_CONSTR(TABLE)
  529.     {
  530.         m_Table = NULL;
  531.         m_tAlign = m_rAlign = wxEmptyString;
  532.     }
  533.  
  534.  
  535.     TAG_HANDLER_PROC(tag)
  536.     {
  537.         wxHtmlContainerCell *c;
  538.  
  539.         // new table started, backup upper-level table (if any) and create new:
  540.         if (tag.GetName() == wxT("TABLE"))
  541.         {
  542.             wxHtmlTableCell *oldt = m_Table;
  543.             wxHtmlContainerCell *oldcont;
  544.  
  545.             oldcont = c = m_WParser->OpenContainer();
  546.  
  547.             c->SetWidthFloat(tag, m_WParser->GetPixelScale());
  548.             m_Table = new wxHtmlTableCell(c, tag, m_WParser->GetPixelScale());
  549.             int oldAlign = m_WParser->GetAlign();
  550.             m_tAlign = wxEmptyString;
  551.             if (tag.HasParam(wxT("ALIGN")))
  552.                 m_tAlign = tag.GetParam(wxT("ALIGN"));
  553.  
  554.             ParseInner(tag);
  555.  
  556.             m_WParser->SetAlign(oldAlign);
  557.             m_WParser->SetContainer(oldcont);
  558.             m_WParser->CloseContainer();
  559.             
  560.             m_Table = oldt;
  561.             return TRUE;
  562.         }
  563.  
  564.  
  565.         else if (m_Table)
  566.         {
  567.             // new row in table
  568.             if (tag.GetName() == wxT("TR"))
  569.             {
  570.                 m_Table->AddRow(tag);
  571.                 m_rAlign = m_tAlign;
  572.                 if (tag.HasParam(wxT("ALIGN")))
  573.                     m_rAlign = tag.GetParam(wxT("ALIGN"));
  574.             }
  575.  
  576.             // new cell
  577.             else
  578.             {
  579.                 c = m_WParser->SetContainer(new wxHtmlContainerCell(m_Table));
  580.                 m_Table->AddCell(c, tag);
  581.  
  582.                 m_WParser->OpenContainer();
  583.  
  584.                 if (tag.GetName() == wxT("TH")) /*header style*/
  585.                     m_WParser->SetAlign(wxHTML_ALIGN_CENTER);
  586.                 else
  587.                     m_WParser->SetAlign(wxHTML_ALIGN_LEFT);
  588.  
  589.                 wxString als;
  590.  
  591.                 als = m_rAlign;
  592.                 if (tag.HasParam(wxT("ALIGN")))
  593.                     als = tag.GetParam(wxT("ALIGN"));
  594.                 als.MakeUpper();
  595.                 if (als == wxT("RIGHT"))
  596.                     m_WParser->SetAlign(wxHTML_ALIGN_RIGHT);
  597.                 else if (als == wxT("LEFT"))
  598.                     m_WParser->SetAlign(wxHTML_ALIGN_LEFT);
  599.                 else if (als == wxT("CENTER"))
  600.                     m_WParser->SetAlign(wxHTML_ALIGN_CENTER);
  601.  
  602.                 m_WParser->OpenContainer();
  603.             }
  604.         }
  605.         return FALSE;
  606.     }
  607.  
  608. TAG_HANDLER_END(TABLE)
  609.  
  610.  
  611.  
  612.  
  613.  
  614. TAGS_MODULE_BEGIN(Tables)
  615.  
  616.     TAGS_MODULE_ADD(TABLE)
  617.  
  618. TAGS_MODULE_END(Tables)
  619.  
  620.  
  621. #endif
  622.