src/html/htmlcell.cpp

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