home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2233.zip / wxOS2-2_3_3.zip / wxWindows-2.3.3 / src / html / htmlcell.cpp < prev    next >
C/C++ Source or Header  |  2002-05-08  |  20KB  |  721 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Name:        htmlcell.cpp
  3. // Purpose:     wxHtmlCell - basic element of HTML output
  4. // Author:      Vaclav Slavik
  5. // RCS-ID:      $Id: htmlcell.cpp,v 1.50 2002/05/05 18:26:23 VS Exp $
  6. // Copyright:   (c) 1999 Vaclav Slavik
  7. // Licence:     wxWindows Licence
  8. /////////////////////////////////////////////////////////////////////////////
  9.  
  10. #ifdef __GNUG__
  11. #pragma implementation "htmlcell.h"
  12. #endif
  13.  
  14. #include "wx/wxprec.h"
  15.  
  16. #include "wx/defs.h"
  17.  
  18. #if wxUSE_HTML && wxUSE_STREAMS
  19.  
  20. #ifdef __BORDLANDC__
  21. #pragma hdrstop
  22. #endif
  23.  
  24. #ifndef WXPRECOMP
  25.     #include "wx/brush.h"
  26.     #include "wx/colour.h"
  27.     #include "wx/dc.h"
  28. #endif
  29.  
  30. #include "wx/html/htmlcell.h"
  31. #include "wx/html/htmlwin.h"
  32. #include <stdlib.h>
  33.  
  34.  
  35. //-----------------------------------------------------------------------------
  36. // wxHtmlCell
  37. //-----------------------------------------------------------------------------
  38.  
  39. wxHtmlCell::wxHtmlCell() : wxObject()
  40. {
  41.     m_Next = NULL;
  42.     m_Parent = NULL;
  43.     m_Width = m_Height = m_Descent = 0;
  44.     m_CanLiveOnPagebreak = TRUE;
  45.     m_Link = NULL;
  46. }
  47.  
  48. wxHtmlCell::~wxHtmlCell()
  49. {
  50.     delete m_Link;
  51. }
  52.  
  53.  
  54. void wxHtmlCell::OnMouseClick(wxWindow *parent, int x, int y,
  55.                               const wxMouseEvent& event)
  56. {
  57.     wxHtmlLinkInfo *lnk = GetLink(x, y);
  58.     if (lnk != NULL)
  59.     {
  60.         wxHtmlLinkInfo lnk2(*lnk);
  61.         lnk2.SetEvent(&event);
  62.         lnk2.SetHtmlCell(this);
  63.  
  64.         // note : this cast is legal because parent is *always* wxHtmlWindow
  65.         wxStaticCast(parent, wxHtmlWindow)->OnLinkClicked(lnk2);
  66.     }
  67. }
  68.  
  69.  
  70.  
  71. bool wxHtmlCell::AdjustPagebreak(int *pagebreak) const
  72. {
  73.     if ((!m_CanLiveOnPagebreak) &&
  74.                 m_PosY < *pagebreak && m_PosY + m_Height > *pagebreak)
  75.     {
  76.         *pagebreak = m_PosY;
  77.         return TRUE;
  78.     }
  79.  
  80.     return FALSE;
  81. }
  82.  
  83.  
  84.  
  85. void wxHtmlCell::SetLink(const wxHtmlLinkInfo& link)
  86. {
  87.     if (m_Link) delete m_Link;
  88.     m_Link = NULL;
  89.     if (link.GetHref() != wxEmptyString)
  90.         m_Link = new wxHtmlLinkInfo(link);
  91. }
  92.  
  93.  
  94.  
  95. void wxHtmlCell::Layout(int WXUNUSED(w))
  96. {
  97.     SetPos(0, 0);
  98. }
  99.  
  100.  
  101.  
  102. void wxHtmlCell::GetHorizontalConstraints(int *left, int *right) const
  103. {
  104.     if (left)
  105.         *left = m_PosX;
  106.     if (right)
  107.         *right = m_PosX + m_Width;
  108. }
  109.  
  110.  
  111.  
  112. const wxHtmlCell* wxHtmlCell::Find(int WXUNUSED(condition), const void* WXUNUSED(param)) const
  113. {
  114.     return NULL;
  115. }
  116.  
  117.  
  118. wxHtmlCell *wxHtmlCell::FindCellByPos(wxCoord x, wxCoord y) const
  119. {
  120.     if ( x >= 0 && x < m_Width && y >= 0 && y < m_Height )
  121.         return wxConstCast(this, wxHtmlCell);
  122.  
  123.     return NULL;
  124. }
  125.  
  126.  
  127. //-----------------------------------------------------------------------------
  128. // wxHtmlWordCell
  129. //-----------------------------------------------------------------------------
  130.  
  131. wxHtmlWordCell::wxHtmlWordCell(const wxString& word, wxDC& dc) : wxHtmlCell()
  132. {
  133.     m_Word = word;
  134.     dc.GetTextExtent(m_Word, &m_Width, &m_Height, &m_Descent);
  135.     SetCanLiveOnPagebreak(FALSE);
  136. }
  137.  
  138.  
  139.  
  140. void wxHtmlWordCell::Draw(wxDC& dc, int x, int y, int WXUNUSED(view_y1), int WXUNUSED(view_y2))
  141. {
  142.     dc.DrawText(m_Word, x + m_PosX, y + m_PosY);
  143. }
  144.  
  145.  
  146.  
  147. //-----------------------------------------------------------------------------
  148. // wxHtmlContainerCell
  149. //-----------------------------------------------------------------------------
  150.  
  151.  
  152. wxHtmlContainerCell::wxHtmlContainerCell(wxHtmlContainerCell *parent) : wxHtmlCell()
  153. {
  154.     m_Cells = m_LastCell = NULL;
  155.     m_Parent = parent;
  156.     if (m_Parent) m_Parent->InsertCell(this);
  157.     m_AlignHor = wxHTML_ALIGN_LEFT;
  158.     m_AlignVer = wxHTML_ALIGN_BOTTOM;
  159.     m_IndentLeft = m_IndentRight = m_IndentTop = m_IndentBottom = 0;
  160.     m_WidthFloat = 100; m_WidthFloatUnits = wxHTML_UNITS_PERCENT;
  161.     m_UseBkColour = FALSE;
  162.     m_UseBorder = FALSE;
  163.     m_MinHeight = 0;
  164.     m_MinHeightAlign = wxHTML_ALIGN_TOP;
  165.     m_LastLayout = -1;
  166. }
  167.  
  168. wxHtmlContainerCell::~wxHtmlContainerCell()
  169. {
  170.     wxHtmlCell *cell = m_Cells;
  171.     while ( cell )
  172.     {
  173.         wxHtmlCell *cellNext = cell->GetNext();
  174.         delete cell;
  175.         cell = cellNext;
  176.     }
  177. }
  178.  
  179.  
  180.  
  181. void wxHtmlContainerCell::SetIndent(int i, int what, int units)
  182. {
  183.     int val = (units == wxHTML_UNITS_PIXELS) ? i : -i;
  184.     if (what & wxHTML_INDENT_LEFT) m_IndentLeft = val;
  185.     if (what & wxHTML_INDENT_RIGHT) m_IndentRight = val;
  186.     if (what & wxHTML_INDENT_TOP) m_IndentTop = val;
  187.     if (what & wxHTML_INDENT_BOTTOM) m_IndentBottom = val;
  188.     m_LastLayout = -1;
  189. }
  190.  
  191.  
  192.  
  193. int wxHtmlContainerCell::GetIndent(int ind) const
  194. {
  195.     if (ind & wxHTML_INDENT_LEFT) return m_IndentLeft;
  196.     else if (ind & wxHTML_INDENT_RIGHT) return m_IndentRight;
  197.     else if (ind & wxHTML_INDENT_TOP) return m_IndentTop;
  198.     else if (ind & wxHTML_INDENT_BOTTOM) return m_IndentBottom;
  199.     else return -1; /* BUG! Should not be called... */
  200. }
  201.  
  202.  
  203.  
  204.  
  205. int wxHtmlContainerCell::GetIndentUnits(int ind) const
  206. {
  207.     bool p = FALSE;
  208.     if (ind & wxHTML_INDENT_LEFT) p = m_IndentLeft < 0;
  209.     else if (ind & wxHTML_INDENT_RIGHT) p = m_IndentRight < 0;
  210.     else if (ind & wxHTML_INDENT_TOP) p = m_IndentTop < 0;
  211.     else if (ind & wxHTML_INDENT_BOTTOM) p = m_IndentBottom < 0;
  212.     if (p) return wxHTML_UNITS_PERCENT;
  213.     else return wxHTML_UNITS_PIXELS;
  214. }
  215.  
  216.  
  217.  
  218. bool wxHtmlContainerCell::AdjustPagebreak(int *pagebreak) const
  219. {
  220.     if (!m_CanLiveOnPagebreak)
  221.         return wxHtmlCell::AdjustPagebreak(pagebreak);
  222.  
  223.     else
  224.     {
  225.         wxHtmlCell *c = GetFirstCell();
  226.         bool rt = FALSE;
  227.         int pbrk = *pagebreak - m_PosY;
  228.  
  229.         while (c)
  230.         {
  231.             if (c->AdjustPagebreak(&pbrk))
  232.                 rt = TRUE;
  233.             c = c->GetNext();
  234.         }
  235.         if (rt)
  236.             *pagebreak = pbrk + m_PosY;
  237.         return rt;
  238.     }
  239. }
  240.  
  241.  
  242.  
  243. void wxHtmlContainerCell::Layout(int w)
  244. {
  245.     wxHtmlCell::Layout(w);
  246.  
  247.     if (m_LastLayout == w) return;
  248.  
  249.     // VS: Any attempt to layout with negative or zero width leads to hell,
  250.     // but we can't ignore such attempts completely, since it sometimes
  251.     // happen (e.g. when trying how small a table can be). The best thing we
  252.     // can do is to set the width of child cells to zero
  253.     if (w < 1)
  254.     {
  255.        m_Width = 0;
  256.        for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
  257.             cell->Layout(0);
  258.             // this does two things: it recursively calls this code on all child
  259.             // contrainers and resets children's position to (0,0)
  260.        return;
  261.     }
  262.  
  263.     wxHtmlCell *cell = m_Cells, *line = m_Cells;
  264.     long xpos = 0, ypos = m_IndentTop;
  265.     int xdelta = 0, ybasicpos = 0, ydiff;
  266.     int s_width, s_indent;
  267.     int ysizeup = 0, ysizedown = 0;
  268.     int MaxLineWidth = 0;
  269.     int xcnt = 0;
  270.  
  271.  
  272.     /*
  273.  
  274.     WIDTH ADJUSTING :
  275.  
  276.     */
  277.  
  278.     if (m_WidthFloatUnits == wxHTML_UNITS_PERCENT)
  279.     {
  280.         if (m_WidthFloat < 0) m_Width = (100 + m_WidthFloat) * w / 100;
  281.         else m_Width = m_WidthFloat * w / 100;
  282.     }
  283.     else
  284.     {
  285.         if (m_WidthFloat < 0) m_Width = w + m_WidthFloat;
  286.         else m_Width = m_WidthFloat;
  287.     }
  288.  
  289.     if (m_Cells)
  290.     {
  291.         int l = (m_IndentLeft < 0) ? (-m_IndentLeft * m_Width / 100) : m_IndentLeft;
  292.         int r = (m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight;
  293.         for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
  294.             cell->Layout(m_Width - (l + r));
  295.     }
  296.  
  297.     /*
  298.  
  299.     LAYOUTING :
  300.  
  301.     */
  302.  
  303.     // adjust indentation:
  304.     s_indent = (m_IndentLeft < 0) ? (-m_IndentLeft * m_Width / 100) : m_IndentLeft;
  305.     s_width = m_Width - s_indent - ((m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight);
  306.  
  307.     // my own layouting:
  308.     while (cell != NULL)
  309.     {
  310.         switch (m_AlignVer)
  311.         {
  312.             case wxHTML_ALIGN_TOP :      ybasicpos = 0; break;
  313.             case wxHTML_ALIGN_BOTTOM :   ybasicpos = - cell->GetHeight(); break;
  314.             case wxHTML_ALIGN_CENTER :   ybasicpos = - cell->GetHeight() / 2; break;
  315.         }
  316.         ydiff = cell->GetHeight() + ybasicpos;
  317.  
  318.         if (cell->GetDescent() + ydiff > ysizedown) ysizedown = cell->GetDescent() + ydiff;
  319.         if (ybasicpos + cell->GetDescent() < -ysizeup) ysizeup = - (ybasicpos + cell->GetDescent());
  320.  
  321.         cell->SetPos(xpos, ybasicpos + cell->GetDescent());
  322.         xpos += cell->GetWidth();
  323.         cell = cell->GetNext();
  324.         xcnt++;
  325.  
  326.         // force new line if occured:
  327.         if ((cell == NULL) || (xpos + cell->GetWidth() > s_width))
  328.         {
  329.             if (xpos > MaxLineWidth) MaxLineWidth = xpos;
  330.             if (ysizeup < 0) ysizeup = 0;
  331.             if (ysizedown < 0) ysizedown = 0;
  332.             switch (m_AlignHor) {
  333.                 case wxHTML_ALIGN_LEFT :
  334.                 case wxHTML_ALIGN_JUSTIFY :
  335.                          xdelta = 0;
  336.                          break;
  337.                 case wxHTML_ALIGN_RIGHT :
  338.                          xdelta = 0 + (s_width - xpos);
  339.                          break;
  340.                 case wxHTML_ALIGN_CENTER :
  341.                          xdelta = 0 + (s_width - xpos) / 2;
  342.                          break;
  343.             }
  344.             if (xdelta < 0) xdelta = 0;
  345.             xdelta += s_indent;
  346.  
  347.             ypos += ysizeup;
  348.  
  349.             if (m_AlignHor != wxHTML_ALIGN_JUSTIFY || cell == NULL)
  350.                 while (line != cell)
  351.                 {
  352.                     line->SetPos(line->GetPosX() + xdelta,
  353.                                    ypos + line->GetPosY());
  354.                     line = line->GetNext();
  355.                 }
  356.             else
  357.             {
  358.                 int counter = 0;
  359.                 int step = (s_width - xpos);
  360.                 if (step < 0) step = 0;
  361.                 xcnt--;
  362.                 if (xcnt > 0) while (line != cell)
  363.                 {
  364.                     line->SetPos(line->GetPosX() + s_indent +
  365.                                    (counter++ * step / xcnt),
  366.                                    ypos + line->GetPosY());
  367.                     line = line->GetNext();
  368.                 }
  369.                 xcnt++;
  370.             }
  371.  
  372.             ypos += ysizedown;
  373.             xpos = xcnt = 0;
  374.             ysizeup = ysizedown = 0;
  375.             line = cell;
  376.         }
  377.     }
  378.  
  379.     // setup height & width, depending on container layout:
  380.     m_Height = ypos + (ysizedown + ysizeup) + m_IndentBottom;
  381.  
  382.     if (m_Height < m_MinHeight)
  383.     {
  384.         if (m_MinHeightAlign != wxHTML_ALIGN_TOP)
  385.         {
  386.             int diff = m_MinHeight - m_Height;
  387.             if (m_MinHeightAlign == wxHTML_ALIGN_CENTER) diff /= 2;
  388.             cell = m_Cells;
  389.             while (cell)
  390.             {
  391.                 cell->SetPos(cell->GetPosX(), cell->GetPosY() + diff);
  392.                 cell = cell->GetNext();
  393.             }
  394.         }
  395.         m_Height = m_MinHeight;
  396.     }
  397.  
  398.     MaxLineWidth += s_indent + ((m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight);
  399.     if (m_Width < MaxLineWidth) m_Width = MaxLineWidth;
  400.  
  401.     m_LastLayout = w;
  402. }
  403.  
  404.  
  405. #define mMin(a, b) (((a) < (b)) ? (a) : (b))
  406. #define mMax(a, b) (((a) < (b)) ? (b) : (a))
  407.  
  408. void wxHtmlContainerCell::Draw(wxDC& dc, int x, int y, int view_y1, int view_y2)
  409. {
  410.     // container visible, draw it:
  411.     if ((y + m_PosY < view_y2) && (y + m_PosY + m_Height > view_y1))
  412.     {
  413.  
  414.         if (m_UseBkColour)
  415.         {
  416.             wxBrush myb = wxBrush(m_BkColour, wxSOLID);
  417.  
  418.             int real_y1 = mMax(y + m_PosY, view_y1);
  419.             int real_y2 = mMin(y + m_PosY + m_Height - 1, view_y2);
  420.  
  421.             dc.SetBrush(myb);
  422.             dc.SetPen(*wxTRANSPARENT_PEN);
  423.             dc.DrawRectangle(x + m_PosX, real_y1, m_Width, real_y2 - real_y1 + 1);
  424.         }
  425.  
  426.         if (m_UseBorder)
  427.         {
  428.             wxPen mypen1(m_BorderColour1, 1, wxSOLID);
  429.             wxPen mypen2(m_BorderColour2, 1, wxSOLID);
  430.  
  431.             dc.SetPen(mypen1);
  432.             dc.DrawLine(x + m_PosX, y + m_PosY, x + m_PosX, y + m_PosY + m_Height - 1);
  433.             dc.DrawLine(x + m_PosX, y + m_PosY, x + m_PosX + m_Width - 1, y + m_PosY);
  434.             dc.SetPen(mypen2);
  435.             dc.DrawLine(x + m_PosX + m_Width - 1, y + m_PosY, x + m_PosX +  m_Width - 1, y + m_PosY + m_Height - 1);
  436.             dc.DrawLine(x + m_PosX, y + m_PosY + m_Height - 1, x + m_PosX + m_Width - 1, y + m_PosY + m_Height - 1);
  437.         }
  438.  
  439.         if (m_Cells)
  440.         {
  441.             for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
  442.                 cell->Draw(dc, x + m_PosX, y + m_PosY, view_y1, view_y2);
  443.         }
  444.     }
  445.     // container invisible, just proceed font+color changing:
  446.     else
  447.     {
  448.         if (m_Cells)
  449.         {
  450.             for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
  451.                 cell->DrawInvisible(dc, x + m_PosX, y + m_PosY);
  452.         }
  453.     }
  454. }
  455.  
  456.  
  457.  
  458. void wxHtmlContainerCell::DrawInvisible(wxDC& dc, int x, int y)
  459. {
  460.     if (m_Cells)
  461.     {
  462.         for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
  463.             cell->DrawInvisible(dc, x + m_PosX, y + m_PosY);
  464.     }
  465. }
  466.  
  467.  
  468.  
  469. wxHtmlLinkInfo *wxHtmlContainerCell::GetLink(int x, int y) const
  470. {
  471.     wxHtmlCell *cell = FindCellByPos(x, y);
  472.  
  473.     // VZ: I don't know if we should pass absolute or relative coords to
  474.     //     wxHtmlCell::GetLink()? As the base class version just ignores them
  475.     //     anyhow, it hardly matters right now but should still be clarified
  476.     return cell ? cell->GetLink(x, y) : NULL;
  477. }
  478.  
  479.  
  480.  
  481. void wxHtmlContainerCell::InsertCell(wxHtmlCell *f)
  482. {
  483.     if (!m_Cells) m_Cells = m_LastCell = f;
  484.     else
  485.     {
  486.         m_LastCell->SetNext(f);
  487.         m_LastCell = f;
  488.         if (m_LastCell) while (m_LastCell->GetNext()) m_LastCell = m_LastCell->GetNext();
  489.     }
  490.     f->SetParent(this);
  491.     m_LastLayout = -1;
  492. }
  493.  
  494.  
  495.  
  496. void wxHtmlContainerCell::SetAlign(const wxHtmlTag& tag)
  497. {
  498.     if (tag.HasParam(wxT("ALIGN")))
  499.     {
  500.         wxString alg = tag.GetParam(wxT("ALIGN"));
  501.         alg.MakeUpper();
  502.         if (alg == wxT("CENTER"))
  503.             SetAlignHor(wxHTML_ALIGN_CENTER);
  504.         else if (alg == wxT("LEFT"))
  505.             SetAlignHor(wxHTML_ALIGN_LEFT);
  506.         else if (alg == wxT("JUSTIFY"))
  507.             SetAlignHor(wxHTML_ALIGN_JUSTIFY);
  508.         else if (alg == wxT("RIGHT"))
  509.             SetAlignHor(wxHTML_ALIGN_RIGHT);
  510.         m_LastLayout = -1;
  511.     }
  512. }
  513.  
  514.  
  515.  
  516. void wxHtmlContainerCell::SetWidthFloat(const wxHtmlTag& tag, double pixel_scale)
  517. {
  518.     if (tag.HasParam(wxT("WIDTH")))
  519.     {
  520.         int wdi;
  521.         wxString wd = tag.GetParam(wxT("WIDTH"));
  522.  
  523.         if (wd[wd.Length()-1] == wxT('%'))
  524.         {
  525.             wxSscanf(wd.c_str(), wxT("%i%%"), &wdi);
  526.             SetWidthFloat(wdi, wxHTML_UNITS_PERCENT);
  527.         }
  528.         else
  529.         {
  530.             wxSscanf(wd.c_str(), wxT("%i"), &wdi);
  531.             SetWidthFloat((int)(pixel_scale * (double)wdi), wxHTML_UNITS_PIXELS);
  532.         }
  533.         m_LastLayout = -1;
  534.     }
  535. }
  536.  
  537.  
  538.  
  539. const wxHtmlCell* wxHtmlContainerCell::Find(int condition, const void* param) const
  540. {
  541.     if (m_Cells)
  542.     {
  543.         const wxHtmlCell *r = NULL;
  544.  
  545.         for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
  546.         {
  547.             r = cell->Find(condition, param);
  548.             if (r) return r;
  549.         }
  550.     }
  551.     return NULL;
  552. }
  553.  
  554.  
  555. wxHtmlCell *wxHtmlContainerCell::FindCellByPos(wxCoord x, wxCoord y) const
  556. {
  557.     for ( const wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext() )
  558.     {
  559.         int cx = cell->GetPosX(),
  560.             cy = cell->GetPosY();
  561.  
  562.         if ( (cx <= x) && (cx + cell->GetWidth() > x) &&
  563.              (cy <= y) && (cy + cell->GetHeight() > y) )
  564.         {
  565.             return cell->FindCellByPos(x - cx, y - cy);
  566.         }
  567.     }
  568.  
  569.     return NULL;
  570. }
  571.  
  572.  
  573. void wxHtmlContainerCell::OnMouseClick(wxWindow *parent, int x, int y, const wxMouseEvent& event)
  574. {
  575.     wxHtmlCell *cell = FindCellByPos(x, y);
  576.     if ( cell )
  577.         cell->OnMouseClick(parent, x, y, event);
  578. }
  579.  
  580.  
  581.  
  582. void wxHtmlContainerCell::GetHorizontalConstraints(int *left, int *right) const
  583. {
  584.     int cleft = m_PosX + m_Width, cright = m_PosX; // worst case
  585.     int l, r;
  586.  
  587.     for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
  588.     {
  589.         cell->GetHorizontalConstraints(&l, &r);
  590.         if (l < cleft)
  591.             cleft = l;
  592.         if (r > cright)
  593.             cright = r;
  594.     }
  595.  
  596.     cleft -= (m_IndentLeft < 0) ? (-m_IndentLeft * m_Width / 100) : m_IndentLeft;
  597.     cright += (m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight;
  598.  
  599.     if (left)
  600.         *left = cleft;
  601.     if (right)
  602.         *right = cright;
  603. }
  604.  
  605.  
  606.  
  607.  
  608.  
  609. //--------------------------------------------------------------------------------
  610. // wxHtmlColourCell
  611. //--------------------------------------------------------------------------------
  612.  
  613. void wxHtmlColourCell::Draw(wxDC& dc, int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(view_y1), int WXUNUSED(view_y2))
  614. {
  615.     if (m_Flags & wxHTML_CLR_FOREGROUND)
  616.         dc.SetTextForeground(m_Colour);
  617.     if (m_Flags & wxHTML_CLR_BACKGROUND)
  618.     {
  619.         dc.SetBackground(wxBrush(m_Colour, wxSOLID));
  620.         dc.SetTextBackground(m_Colour);
  621.     }
  622. }
  623.  
  624. void wxHtmlColourCell::DrawInvisible(wxDC& dc, int WXUNUSED(x), int WXUNUSED(y))
  625. {
  626.     if (m_Flags & wxHTML_CLR_FOREGROUND)
  627.         dc.SetTextForeground(m_Colour);
  628.     if (m_Flags & wxHTML_CLR_BACKGROUND)
  629.     {
  630.         dc.SetBackground(wxBrush(m_Colour, wxSOLID));
  631.         dc.SetTextBackground(m_Colour);
  632.     }
  633. }
  634.  
  635.  
  636.  
  637.  
  638. //--------------------------------------------------------------------------------
  639. // wxHtmlFontCell
  640. //--------------------------------------------------------------------------------
  641.  
  642. void wxHtmlFontCell::Draw(wxDC& dc, int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(view_y1), int WXUNUSED(view_y2))
  643. {
  644.     dc.SetFont(m_Font);
  645. }
  646.  
  647. void wxHtmlFontCell::DrawInvisible(wxDC& dc, int WXUNUSED(x), int WXUNUSED(y))
  648. {
  649.     dc.SetFont(m_Font);
  650. }
  651.  
  652.  
  653.  
  654.  
  655.  
  656.  
  657.  
  658.  
  659. //--------------------------------------------------------------------------------
  660. // wxHtmlWidgetCell
  661. //--------------------------------------------------------------------------------
  662.  
  663. wxHtmlWidgetCell::wxHtmlWidgetCell(wxWindow *wnd, int w)
  664. {
  665.     int sx, sy;
  666.     m_Wnd = wnd;
  667.     m_Wnd->GetSize(&sx, &sy);
  668.     m_Width = sx, m_Height = sy;
  669.     m_WidthFloat = w;
  670. }
  671.  
  672.  
  673. void wxHtmlWidgetCell::Draw(wxDC& WXUNUSED(dc), int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(view_y1), int WXUNUSED(view_y2))
  674. {
  675.     int absx = 0, absy = 0, stx, sty;
  676.     wxHtmlCell *c = this;
  677.  
  678.     while (c)
  679.     {
  680.         absx += c->GetPosX();
  681.         absy += c->GetPosY();
  682.         c = c->GetParent();
  683.     }
  684.  
  685.     ((wxScrolledWindow*)(m_Wnd->GetParent()))->GetViewStart(&stx, &sty);
  686.     m_Wnd->SetSize(absx - wxHTML_SCROLL_STEP * stx, absy  - wxHTML_SCROLL_STEP * sty, m_Width, m_Height);
  687. }
  688.  
  689.  
  690.  
  691. void wxHtmlWidgetCell::DrawInvisible(wxDC& WXUNUSED(dc), int WXUNUSED(x), int WXUNUSED(y))
  692. {
  693.     int absx = 0, absy = 0, stx, sty;
  694.     wxHtmlCell *c = this;
  695.  
  696.     while (c)
  697.     {
  698.         absx += c->GetPosX();
  699.         absy += c->GetPosY();
  700.         c = c->GetParent();
  701.     }
  702.  
  703.     ((wxScrolledWindow*)(m_Wnd->GetParent()))->GetViewStart(&stx, &sty);
  704.     m_Wnd->SetSize(absx - wxHTML_SCROLL_STEP * stx, absy  - wxHTML_SCROLL_STEP * sty, m_Width, m_Height);
  705. }
  706.  
  707.  
  708.  
  709. void wxHtmlWidgetCell::Layout(int w)
  710. {
  711.     if (m_WidthFloat != 0)
  712.     {
  713.         m_Width = (w * m_WidthFloat) / 100;
  714.         m_Wnd->SetSize(m_Width, m_Height);
  715.     }
  716.  
  717.     wxHtmlCell::Layout(w);
  718. }
  719.  
  720. #endif
  721.