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 "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 __BORLANDC__
  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 "wx/settings.h"
  33 #include "wx/module.h"
  34 #include "wx/dynarray.h"
  35
  36 #include <stdlib.h>
  37
  38 //-----------------------------------------------------------------------------
  39 // Global variables
  40 //-----------------------------------------------------------------------------
  41
  42 static wxCursor *gs_cursorLink = NULL;
  43 static wxCursor *gs_cursorText = NULL;
  44
  45
  46 //-----------------------------------------------------------------------------
  47 // Helper classes
  48 //-----------------------------------------------------------------------------
  49
  50 void wxHtmlSelection::Set(const wxPoint& fromPos, const wxHtmlCell *fromCell,
  51                           const wxPoint& toPos, const wxHtmlCell *toCell)
  52 {
  53     m_fromCell = fromCell;
  54     m_toCell = toCell;
  55     m_fromPos = fromPos;
  56     m_toPos = toPos;
  57 }
  58
  59 void wxHtmlSelection::Set(const wxHtmlCell *fromCell, const wxHtmlCell *toCell)
  60 {
  61     wxPoint p1 = fromCell ? fromCell->GetAbsPos() : wxDefaultPosition;
  62     wxPoint p2 = toCell ? toCell->GetAbsPos() : wxDefaultPosition;
  63     if ( toCell )
  64     {
  65         p2.x += toCell->GetWidth()-1;
  66         p2.y += toCell->GetHeight()-1;
  67     }
  68     Set(p1, fromCell, p2, toCell);
  69 }
  70
  71 wxColour
  72 wxDefaultHtmlRenderingStyle::
  73 GetSelectedTextColour(const wxColour& WXUNUSED(clr))
  74 {
  75     return wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
  76 }
  77
  78 wxColour
  79 wxDefaultHtmlRenderingStyle::
  80 GetSelectedTextBgColour(const wxColour& WXUNUSED(clr))
  81 {
  82     return wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
  83 }
  84
  85
  86 //-----------------------------------------------------------------------------
  87 // wxHtmlCell
  88 //-----------------------------------------------------------------------------
  89
  90 wxHtmlCell::wxHtmlCell() : wxObject()
  91 {
  92     m_Next = NULL;
  93     m_Parent = NULL;
  94     m_Width = m_Height = m_Descent = 0;
  95     m_CanLiveOnPagebreak = TRUE;
  96     m_Link = NULL;
  97 }
  98
  99 wxHtmlCell::~wxHtmlCell()
 100 {
 101     delete m_Link;
 102 }
 103
 104
 105 void wxHtmlCell::OnMouseClick(wxWindow *parent, int x, int y,
 106                               const wxMouseEvent& event)
 107 {
 108     wxHtmlLinkInfo *lnk = GetLink(x, y);
 109     if (lnk != NULL)
 110     {
 111         wxHtmlLinkInfo lnk2(*lnk);
 112         lnk2.SetEvent(&event);
 113         lnk2.SetHtmlCell(this);
 114
 115         // note : this cast is legal because parent is *always* wxHtmlWindow
 116         wxStaticCast(parent, wxHtmlWindow)->OnLinkClicked(lnk2);
 117     }
 118 }
 119
 120
 121 wxCursor wxHtmlCell::GetCursor() const
 122 {
 123     if ( GetLink() )
 124     {
 125         if ( !gs_cursorLink )
 126             gs_cursorLink = new wxCursor(wxCURSOR_HAND);
 127         return *gs_cursorLink;
 128     }
 129     else
 130         return *wxSTANDARD_CURSOR;
 131 }
 132
 133
 134 bool wxHtmlCell::AdjustPagebreak(int *pagebreak, int* WXUNUSED(known_pagebreaks), int WXUNUSED(number_of_pages)) const
 135 {
 136     if ((!m_CanLiveOnPagebreak) &&
 137                 m_PosY < *pagebreak && m_PosY + m_Height > *pagebreak)
 138     {
 139         *pagebreak = m_PosY;
 140         return TRUE;
 141     }
 142
 143     return FALSE;
 144 }
 145
 146
 147
 148 void wxHtmlCell::SetLink(const wxHtmlLinkInfo& link)
 149 {
 150     if (m_Link) delete m_Link;
 151     m_Link = NULL;
 152     if (link.GetHref() != wxEmptyString)
 153         m_Link = new wxHtmlLinkInfo(link);
 154 }
 155
 156
 157 void wxHtmlCell::Layout(int WXUNUSED(w))
 158 {
 159     SetPos(0, 0);
 160 }
 161
 162
 163
 164 const wxHtmlCell* wxHtmlCell::Find(int WXUNUSED(condition), const void* WXUNUSED(param)) const
 165 {
 166     return NULL;
 167 }
 168
 169
 170 wxHtmlCell *wxHtmlCell::FindCellByPos(wxCoord x, wxCoord y,
 171                                       unsigned flags) const
 172 {
 173     if ( x >= 0 && x < m_Width && y >= 0 && y < m_Height )
 174     {
 175         return wxConstCast(this, wxHtmlCell);
 176     }
 177     else
 178     {
 179         if ((flags & wxHTML_FIND_NEAREST_AFTER) &&
 180                 (y < 0 || (y < 0+m_Height && x < 0+m_Width)))
 181             return wxConstCast(this, wxHtmlCell);
 182         else if ((flags & wxHTML_FIND_NEAREST_BEFORE) &&
 183                 (y >= 0+m_Height || (y >= 0 && x >= 0)))
 184             return wxConstCast(this, wxHtmlCell);
 185         else
 186             return NULL;
 187     }
 188 }
 189
 190
 191 wxPoint wxHtmlCell::GetAbsPos() const
 192 {
 193     wxPoint p(m_PosX, m_PosY);
 194     for (wxHtmlCell *parent = m_Parent; parent; parent = parent->m_Parent)
 195     {
 196         p.x += parent->m_PosX;
 197         p.y += parent->m_PosY;
 198     }
 199     return p;
 200 }
 201
 202 unsigned wxHtmlCell::GetDepth() const
 203 {
 204     unsigned d = 0;
 205     for (wxHtmlCell *p = m_Parent; p; p = p->m_Parent)
 206         d++;
 207     return d;
 208 }
 209
 210 bool wxHtmlCell::IsBefore(wxHtmlCell *cell) const
 211 {
 212     const wxHtmlCell *c1 = this;
 213     const wxHtmlCell *c2 = cell;
 214     unsigned d1 = GetDepth();
 215     unsigned d2 = cell->GetDepth();
 216
 217     if ( d1 > d2 )
 218         for (; d1 != d2; d1-- )
 219             c1 = c1->m_Parent;
 220     else if ( d1 < d2 )
 221         for (; d1 != d2; d2-- )
 222             c2 = c2->m_Parent;
 223
 224     if ( cell == this )
 225         return true;
 226
 227     while ( c1 && c2 )
 228     {
 229         if ( c1->m_Parent == c2->m_Parent )
 230         {
 231             while ( c1 )
 232             {
 233                 if ( c1 == c2 )
 234                     return true;
 235                 c1 = c1->GetNext();
 236             }
 237             return false;
 238         }
 239         else
 240         {
 241             c1 = c1->m_Parent;
 242             c2 = c2->m_Parent;
 243         }
 244     }
 245
 246     wxFAIL_MSG(_T("Cells are in different trees"));
 247     return false;
 248 }
 249
 250
 251 //-----------------------------------------------------------------------------
 252 // wxHtmlWordCell
 253 //-----------------------------------------------------------------------------
 254
 255 wxHtmlWordCell::wxHtmlWordCell(const wxString& word, wxDC& dc) : wxHtmlCell()
 256 {
 257     m_Word = word;
 258     dc.GetTextExtent(m_Word, &m_Width, &m_Height, &m_Descent);
 259     SetCanLiveOnPagebreak(FALSE);
 260     m_allowLinebreak = true;
 261 }
 262
 263 void wxHtmlWordCell::SetPreviousWord(wxHtmlWordCell *cell)
 264 {
 265     if ( cell && m_Parent == cell->m_Parent &&
 266          !wxIsspace(cell->m_Word.Last()) && !wxIsspace(m_Word[0u]) )
 267     {
 268         m_allowLinebreak = false;
 269     }
 270 }
 271
 272 // Splits m_Word into up to three parts according to selection, returns
 273 // substring before, in and after selection and the points (in relative coords)
 274 // where s2 and s3 start:
 275 void wxHtmlWordCell::Split(wxDC& dc,
 276                            const wxPoint& selFrom, const wxPoint& selTo,
 277                            unsigned& pos1, unsigned& pos2) const
 278 {
 279     wxPoint pt1 = (selFrom == wxDefaultPosition) ?
 280                    wxDefaultPosition : selFrom - GetAbsPos();
 281     wxPoint pt2 = (selTo == wxDefaultPosition) ?
 282                    wxPoint(m_Width, -1) : selTo - GetAbsPos();
 283
 284     wxCoord charW, charH;
 285     unsigned len = m_Word.length();
 286     unsigned i = 0;
 287     pos1 = 0;
 288
 289     // adjust for cases when the start/end position is completely
 290     // outside the cell:
 291     if ( pt1.y < 0 )
 292         pt1.x = 0;
 293     if ( pt2.y >= m_Height )
 294         pt2.x = m_Width;
 295
 296     // before selection:
 297     while ( pt1.x > 0 && i < len )
 298     {
 299         dc.GetTextExtent(m_Word[i], &charW, &charH);
 300         pt1.x -= charW;
 301         if ( pt1.x >= 0 )
 302         {
 303             pos1 += charW;
 304             i++;
 305         }
 306     }
 307
 308     // in selection:
 309     unsigned j = i;
 310     pos2 = pos1;
 311     pt2.x -= pos2;
 312     while ( pt2.x > 0 && j < len )
 313     {
 314         dc.GetTextExtent(m_Word[j], &charW, &charH);
 315         pt2.x -= charW;
 316         if ( pt2.x >= 0 )
 317         {
 318             pos2 += charW;
 319             j++;
 320         }
 321     }
 322
 323     pos1 = i;
 324     pos2 = j;
 325 }
 326
 327 void wxHtmlWordCell::SetSelectionPrivPos(wxDC& dc, wxHtmlSelection *s) const
 328 {
 329     unsigned p1, p2;
 330
 331     Split(dc,
 332           this == s->GetFromCell() ? s->GetFromPos() : wxDefaultPosition,
 333           this == s->GetToCell() ? s->GetToPos() : wxDefaultPosition,
 334           p1, p2);
 335
 336     wxPoint p(0, m_Word.length());
 337
 338     if ( this == s->GetFromCell() )
 339         p.x = p1; // selection starts here
 340     if ( this == s->GetToCell() )
 341         p.y = p2; // selection ends here
 342
 343     if ( this == s->GetFromCell() )
 344         s->SetFromPrivPos(p);
 345     if ( this == s->GetToCell() )
 346         s->SetToPrivPos(p);
 347 }
 348
 349
 350 static void SwitchSelState(wxDC& dc, wxHtmlRenderingInfo& info,
 351                            bool toSelection)
 352 {
 353     wxColour fg = info.GetState().GetFgColour();
 354     wxColour bg = info.GetState().GetBgColour();
 355
 356     if ( toSelection )
 357     {
 358         dc.SetBackgroundMode(wxSOLID);
 359         dc.SetTextForeground(info.GetStyle().GetSelectedTextColour(fg));
 360         dc.SetTextBackground(info.GetStyle().GetSelectedTextBgColour(bg));
 361         dc.SetBackground(wxBrush(info.GetStyle().GetSelectedTextBgColour(bg),
 362                                  wxSOLID));
 363     }
 364     else
 365     {
 366         dc.SetBackgroundMode(wxTRANSPARENT);
 367         dc.SetTextForeground(fg);
 368         dc.SetTextBackground(bg);
 369         dc.SetBackground(wxBrush(bg, wxSOLID));
 370     }
 371 }
 372
 373
 374 void wxHtmlWordCell::Draw(wxDC& dc, int x, int y,
 375                           int WXUNUSED(view_y1), int WXUNUSED(view_y2),
 376                           wxHtmlRenderingInfo& info)
 377 {
 378 #if 0 // useful for debugging
 379     dc.SetPen(*wxBLACK_PEN);
 380     dc.DrawRectangle(x+m_PosX,y+m_PosY,m_Width,m_Height);
 381 #endif
 382
 383     bool drawSelectionAfterCell = false;
 384
 385     if ( info.GetState().GetSelectionState() == wxHTML_SEL_CHANGING )
 386     {
 387         // Selection changing, we must draw the word piecewise:
 388         wxHtmlSelection *s = info.GetSelection();
 389         wxString txt;
 390         int w, h;
 391         int ofs = 0;
 392
 393         wxPoint priv = (this == s->GetFromCell()) ?
 394                            s->GetFromPrivPos() : s->GetToPrivPos();
 395
 396         // NB: this is quite a hack: in order to compute selection boundaries
 397         //     (in word's characters) we must know current font, which is only
 398         //     possible inside rendering code. Therefore we update the
 399         //     information here and store it in wxHtmlSelection so that
 400         //     ConvertToText can use it later:
 401         if ( priv == wxDefaultPosition )
 402         {
 403             SetSelectionPrivPos(dc, s);
 404             priv = (this == s->GetFromCell()) ?
 405                     s->GetFromPrivPos() : s->GetToPrivPos();
 406         }
 407
 408         int part1 = priv.x;
 409         int part2 = priv.y;
 410
 411         if ( part1 > 0 )
 412         {
 413             txt = m_Word.Mid(0, part1);
 414             dc.DrawText(txt, x + m_PosX, y + m_PosY);
 415             dc.GetTextExtent(txt, &w, &h);
 416             ofs += w;
 417         }
 418
 419         SwitchSelState(dc, info, true);
 420
 421         txt = m_Word.Mid(part1, part2-part1);
 422         dc.DrawText(txt, ofs + x + m_PosX, y + m_PosY);
 423
 424         if ( (size_t)part2 < m_Word.length() )
 425         {
 426             dc.GetTextExtent(txt, &w, &h);
 427             ofs += w;
 428             SwitchSelState(dc, info, false);
 429             txt = m_Word.Mid(part2);
 430             dc.DrawText(txt, ofs + x + m_PosX, y + m_PosY);
 431         }
 432         else
 433             drawSelectionAfterCell = true;
 434     }
 435     else
 436     {
 437         wxHtmlSelectionState selstate = info.GetState().GetSelectionState();
 438         // Not changing selection state, draw the word in single mode:
 439         if ( selstate != wxHTML_SEL_OUT &&
 440              dc.GetBackgroundMode() != wxSOLID )
 441         {
 442             SwitchSelState(dc, info, true);
 443         }
 444         else if ( selstate == wxHTML_SEL_OUT &&
 445                   dc.GetBackgroundMode() == wxSOLID )
 446         {
 447             SwitchSelState(dc, info, false);
 448         }
 449         dc.DrawText(m_Word, x + m_PosX, y + m_PosY);
 450         drawSelectionAfterCell = (selstate != wxHTML_SEL_OUT);
 451     }
 452
 453     // NB: If the text is justified then there is usually some free space
 454     //     between adjacent cells and drawing the selection only onto cells
 455     //     would result in ugly unselected spaces. The code below detects
 456     //     this special case and renders the selection *outside* the sell,
 457     //     too.
 458     if ( m_Parent->GetAlignHor() == wxHTML_ALIGN_JUSTIFY &&
 459          drawSelectionAfterCell )
 460     {
 461         wxHtmlCell *nextCell = m_Next;
 462         while ( nextCell && nextCell->IsFormattingCell() )
 463             nextCell = nextCell->GetNext();
 464         if ( nextCell )
 465         {
 466             int nextX = nextCell->GetPosX();
 467             if ( m_PosX + m_Width < nextX )
 468             {
 469                 dc.SetBrush(dc.GetBackground());
 470                 dc.SetPen(*wxTRANSPARENT_PEN);
 471                 dc.DrawRectangle(x + m_PosX + m_Width, y + m_PosY,
 472                                  nextX - m_PosX - m_Width, m_Height);
 473             }
 474         }
 475     }
 476 }
 477
 478
 479 wxString wxHtmlWordCell::ConvertToText(wxHtmlSelection *s) const
 480 {
 481     if ( s && (this == s->GetFromCell() || this == s->GetToCell()) )
 482     {
 483         wxPoint priv = this == s->GetFromCell() ? s->GetFromPrivPos()
 484                                                 : s->GetToPrivPos();
 485
 486         // VZ: we may be called before we had a chance to re-render ourselves
 487         //     and in this case GetFrom/ToPrivPos() is not set yet -- assume
 488         //     that this only happens in case of a double/triple click (which
 489         //     seems to be the case now) and so it makes sense to select the
 490         //     entire contents of the cell in this case
 491         //
 492         // TODO: but this really needs to be fixed in some better way later...
 493         if ( priv != wxDefaultPosition )
 494         {
 495             int part1 = priv.x;
 496             int part2 = priv.y;
 497             return m_Word.Mid(part1, part2-part1);
 498         }
 499         //else: return the whole word below
 500     }
 501
 502     return m_Word;
 503 }
 504
 505 wxCursor wxHtmlWordCell::GetCursor() const
 506 {
 507     if ( !GetLink() )
 508     {
 509         if ( !gs_cursorText )
 510             gs_cursorText = new wxCursor(wxCURSOR_IBEAM);
 511         return *gs_cursorText;
 512     }
 513     else
 514         return wxHtmlCell::GetCursor();
 515 }
 516
 517
 518 //-----------------------------------------------------------------------------
 519 // wxHtmlContainerCell
 520 //-----------------------------------------------------------------------------
 521
 522
 523 wxHtmlContainerCell::wxHtmlContainerCell(wxHtmlContainerCell *parent) : wxHtmlCell()
 524 {
 525     m_Cells = m_LastCell = NULL;
 526     m_Parent = parent;
 527     if (m_Parent) m_Parent->InsertCell(this);
 528     m_AlignHor = wxHTML_ALIGN_LEFT;
 529     m_AlignVer = wxHTML_ALIGN_BOTTOM;
 530     m_IndentLeft = m_IndentRight = m_IndentTop = m_IndentBottom = 0;
 531     m_WidthFloat = 100; m_WidthFloatUnits = wxHTML_UNITS_PERCENT;
 532     m_UseBkColour = FALSE;
 533     m_UseBorder = FALSE;
 534     m_MinHeight = 0;
 535     m_MinHeightAlign = wxHTML_ALIGN_TOP;
 536     m_LastLayout = -1;
 537 }
 538
 539 wxHtmlContainerCell::~wxHtmlContainerCell()
 540 {
 541     wxHtmlCell *cell = m_Cells;
 542     while ( cell )
 543     {
 544         wxHtmlCell *cellNext = cell->GetNext();
 545         delete cell;
 546         cell = cellNext;
 547     }
 548 }
 549
 550
 551
 552 void wxHtmlContainerCell::SetIndent(int i, int what, int units)
 553 {
 554     int val = (units == wxHTML_UNITS_PIXELS) ? i : -i;
 555     if (what & wxHTML_INDENT_LEFT) m_IndentLeft = val;
 556     if (what & wxHTML_INDENT_RIGHT) m_IndentRight = val;
 557     if (what & wxHTML_INDENT_TOP) m_IndentTop = val;
 558     if (what & wxHTML_INDENT_BOTTOM) m_IndentBottom = val;
 559     m_LastLayout = -1;
 560 }
 561
 562
 563
 564 int wxHtmlContainerCell::GetIndent(int ind) const
 565 {
 566     if (ind & wxHTML_INDENT_LEFT) return m_IndentLeft;
 567     else if (ind & wxHTML_INDENT_RIGHT) return m_IndentRight;
 568     else if (ind & wxHTML_INDENT_TOP) return m_IndentTop;
 569     else if (ind & wxHTML_INDENT_BOTTOM) return m_IndentBottom;
 570     else return -1; /* BUG! Should not be called... */
 571 }
 572
 573
 574
 575
 576 int wxHtmlContainerCell::GetIndentUnits(int ind) const
 577 {
 578     bool p = FALSE;
 579     if (ind & wxHTML_INDENT_LEFT) p = m_IndentLeft < 0;
 580     else if (ind & wxHTML_INDENT_RIGHT) p = m_IndentRight < 0;
 581     else if (ind & wxHTML_INDENT_TOP) p = m_IndentTop < 0;
 582     else if (ind & wxHTML_INDENT_BOTTOM) p = m_IndentBottom < 0;
 583     if (p) return wxHTML_UNITS_PERCENT;
 584     else return wxHTML_UNITS_PIXELS;
 585 }
 586
 587
 588
 589 bool wxHtmlContainerCell::AdjustPagebreak(int *pagebreak, int* known_pagebreaks, int number_of_pages) const
 590 {
 591     if (!m_CanLiveOnPagebreak)
 592         return wxHtmlCell::AdjustPagebreak(pagebreak, known_pagebreaks, number_of_pages);
 593
 594     else
 595     {
 596         wxHtmlCell *c = GetFirstChild();
 597         bool rt = FALSE;
 598         int pbrk = *pagebreak - m_PosY;
 599
 600         while (c)
 601         {
 602             if (c->AdjustPagebreak(&pbrk, known_pagebreaks, number_of_pages))
 603                 rt = TRUE;
 604             c = c->GetNext();
 605         }
 606         if (rt)
 607             *pagebreak = pbrk + m_PosY;
 608         return rt;
 609     }
 610 }
 611
 612
 613
 614 void wxHtmlContainerCell::Layout(int w)
 615 {
 616     wxHtmlCell::Layout(w);
 617
 618     if (m_LastLayout == w) return;
 619
 620     // VS: Any attempt to layout with negative or zero width leads to hell,
 621     // but we can't ignore such attempts completely, since it sometimes
 622     // happen (e.g. when trying how small a table can be). The best thing we
 623     // can do is to set the width of child cells to zero
 624     if (w < 1)
 625     {
 626        m_Width = 0;
 627        for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
 628             cell->Layout(0);
 629             // this does two things: it recursively calls this code on all
 630             // child contrainers and resets children's position to (0,0)
 631        return;
 632     }
 633
 634     wxHtmlCell *cell = m_Cells, *line = m_Cells;
 635     wxHtmlCell *nextCell;
 636     long xpos = 0, ypos = m_IndentTop;
 637     int xdelta = 0, ybasicpos = 0, ydiff;
 638     int s_width, nextWordWidth, s_indent;
 639     int ysizeup = 0, ysizedown = 0;
 640     int MaxLineWidth = 0;
 641     int xcnt = 0;
 642
 643
 644     /*
 645
 646     WIDTH ADJUSTING :
 647
 648     */
 649
 650     if (m_WidthFloatUnits == wxHTML_UNITS_PERCENT)
 651     {
 652         if (m_WidthFloat < 0) m_Width = (100 + m_WidthFloat) * w / 100;
 653         else m_Width = m_WidthFloat * w / 100;
 654     }
 655     else
 656     {
 657         if (m_WidthFloat < 0) m_Width = w + m_WidthFloat;
 658         else m_Width = m_WidthFloat;
 659     }
 660
 661     if (m_Cells)
 662     {
 663         int l = (m_IndentLeft < 0) ? (-m_IndentLeft * m_Width / 100) : m_IndentLeft;
 664         int r = (m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight;
 665         for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
 666             cell->Layout(m_Width - (l + r));
 667     }
 668
 669     /*
 670
 671     LAYOUTING :
 672
 673     */
 674
 675     // adjust indentation:
 676     s_indent = (m_IndentLeft < 0) ? (-m_IndentLeft * m_Width / 100) : m_IndentLeft;
 677     s_width = m_Width - s_indent - ((m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight);
 678
 679     // my own layouting:
 680     while (cell != NULL)
 681     {
 682         switch (m_AlignVer)
 683         {
 684             case wxHTML_ALIGN_TOP :      ybasicpos = 0; break;
 685             case wxHTML_ALIGN_BOTTOM :   ybasicpos = - cell->GetHeight(); break;
 686             case wxHTML_ALIGN_CENTER :   ybasicpos = - cell->GetHeight() / 2; break;
 687         }
 688         ydiff = cell->GetHeight() + ybasicpos;
 689
 690         if (cell->GetDescent() + ydiff > ysizedown) ysizedown = cell->GetDescent() + ydiff;
 691         if (ybasicpos + cell->GetDescent() < -ysizeup) ysizeup = - (ybasicpos + cell->GetDescent());
 692
 693         // layout nonbreakable run of cells:
 694         cell->SetPos(xpos, ybasicpos + cell->GetDescent());
 695         xpos += cell->GetWidth();
 696         cell = cell->GetNext();
 697         xcnt++;
 698
 699         // compute length of the next word that would be added:
 700         nextWordWidth = 0;
 701         if (cell)
 702         {
 703             nextCell = cell;
 704             do
 705             {
 706                 nextWordWidth += nextCell->GetWidth();
 707                 nextCell = nextCell->GetNext();
 708             } while (nextCell && !nextCell->IsLinebreakAllowed());
 709         }
 710
 711         // force new line if occured:
 712         if ((cell == NULL) ||
 713             (xpos + nextWordWidth > s_width && cell->IsLinebreakAllowed()))
 714         {
 715             if (xpos > MaxLineWidth) MaxLineWidth = xpos;
 716             if (ysizeup < 0) ysizeup = 0;
 717             if (ysizedown < 0) ysizedown = 0;
 718             switch (m_AlignHor) {
 719                 case wxHTML_ALIGN_LEFT :
 720                 case wxHTML_ALIGN_JUSTIFY :
 721                          xdelta = 0;
 722                          break;
 723                 case wxHTML_ALIGN_RIGHT :
 724                          xdelta = 0 + (s_width - xpos);
 725                          break;
 726                 case wxHTML_ALIGN_CENTER :
 727                          xdelta = 0 + (s_width - xpos) / 2;
 728                          break;
 729             }
 730             if (xdelta < 0) xdelta = 0;
 731             xdelta += s_indent;
 732
 733             ypos += ysizeup;
 734
 735             if (m_AlignHor != wxHTML_ALIGN_JUSTIFY || cell == NULL)
 736                 while (line != cell)
 737                 {
 738                     line->SetPos(line->GetPosX() + xdelta,
 739                                    ypos + line->GetPosY());
 740                     line = line->GetNext();
 741                 }
 742             else
 743             {
 744                 int counter = 0;
 745                 int step = (s_width - xpos);
 746                 if (step < 0) step = 0;
 747                 xcnt--;
 748                 if (xcnt > 0) while (line != cell)
 749                 {
 750                     line->SetPos(line->GetPosX() + s_indent +
 751                                    (counter++ * step / xcnt),
 752                                    ypos + line->GetPosY());
 753                     line = line->GetNext();
 754                 }
 755                 xcnt++;
 756             }
 757
 758             ypos += ysizedown;
 759             xpos = xcnt = 0;
 760             ysizeup = ysizedown = 0;
 761             line = cell;
 762         }
 763     }
 764
 765     // setup height & width, depending on container layout:
 766     m_Height = ypos + (ysizedown + ysizeup) + m_IndentBottom;
 767
 768     if (m_Height < m_MinHeight)
 769     {
 770         if (m_MinHeightAlign != wxHTML_ALIGN_TOP)
 771         {
 772             int diff = m_MinHeight - m_Height;
 773             if (m_MinHeightAlign == wxHTML_ALIGN_CENTER) diff /= 2;
 774             cell = m_Cells;
 775             while (cell)
 776             {
 777                 cell->SetPos(cell->GetPosX(), cell->GetPosY() + diff);
 778                 cell = cell->GetNext();
 779             }
 780         }
 781         m_Height = m_MinHeight;
 782     }
 783
 784     MaxLineWidth += s_indent + ((m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight);
 785     if (m_Width < MaxLineWidth) m_Width = MaxLineWidth;
 786
 787     m_LastLayout = w;
 788 }
 789
 790 void wxHtmlContainerCell::UpdateRenderingStatePre(wxHtmlRenderingInfo& info,
 791                                                   wxHtmlCell *cell) const
 792 {
 793     wxHtmlSelection *s = info.GetSelection();
 794     if (!s) return;
 795     if (s->GetFromCell() == cell || s->GetToCell() == cell)
 796     {
 797         info.GetState().SetSelectionState(wxHTML_SEL_CHANGING);
 798     }
 799 }
 800
 801 void wxHtmlContainerCell::UpdateRenderingStatePost(wxHtmlRenderingInfo& info,
 802                                                    wxHtmlCell *cell) const
 803 {
 804     wxHtmlSelection *s = info.GetSelection();
 805     if (!s) return;
 806     if (s->GetToCell() == cell)
 807         info.GetState().SetSelectionState(wxHTML_SEL_OUT);
 808     else if (s->GetFromCell() == cell)
 809         info.GetState().SetSelectionState(wxHTML_SEL_IN);
 810 }
 811
 812 #define mMin(a, b) (((a) < (b)) ? (a) : (b))
 813 #define mMax(a, b) (((a) < (b)) ? (b) : (a))
 814
 815 void wxHtmlContainerCell::Draw(wxDC& dc, int x, int y, int view_y1, int view_y2,
 816                                wxHtmlRenderingInfo& info)
 817 {
 818 #if 0 // useful for debugging
 819     dc.SetPen(*wxRED_PEN);
 820     dc.DrawRectangle(x+m_PosX,y+m_PosY,m_Width,m_Height);
 821 #endif
 822     // container visible, draw it:
 823     if ((y + m_PosY <= view_y2) && (y + m_PosY + m_Height > view_y1))
 824     {
 825         if (m_UseBkColour)
 826         {
 827             wxBrush myb = wxBrush(m_BkColour, wxSOLID);
 828
 829             int real_y1 = mMax(y + m_PosY, view_y1);
 830             int real_y2 = mMin(y + m_PosY + m_Height - 1, view_y2);
 831
 832             dc.SetBrush(myb);
 833             dc.SetPen(*wxTRANSPARENT_PEN);
 834             dc.DrawRectangle(x + m_PosX, real_y1, m_Width, real_y2 - real_y1 + 1);
 835         }
 836
 837         if (m_UseBorder)
 838         {
 839             wxPen mypen1(m_BorderColour1, 1, wxSOLID);
 840             wxPen mypen2(m_BorderColour2, 1, wxSOLID);
 841
 842             dc.SetPen(mypen1);
 843             dc.DrawLine(x + m_PosX, y + m_PosY, x + m_PosX, y + m_PosY + m_Height - 1);
 844             dc.DrawLine(x + m_PosX, y + m_PosY, x + m_PosX + m_Width, y + m_PosY);
 845             dc.SetPen(mypen2);
 846             dc.DrawLine(x + m_PosX + m_Width - 1, y + m_PosY, x + m_PosX +  m_Width - 1, y + m_PosY + m_Height - 1);
 847             dc.DrawLine(x + m_PosX, y + m_PosY + m_Height - 1, x + m_PosX + m_Width, y + m_PosY + m_Height - 1);
 848         }
 849
 850         if (m_Cells)
 851         {
 852             // draw container's contents:
 853             for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
 854             {
 855                 UpdateRenderingStatePre(info, cell);
 856                 cell->Draw(dc,
 857                            x + m_PosX, y + m_PosY, view_y1, view_y2,
 858                            info);
 859                 UpdateRenderingStatePost(info, cell);
 860             }
 861         }
 862     }
 863     // container invisible, just proceed font+color changing:
 864     else
 865     {
 866         DrawInvisible(dc, x, y, info);
 867     }
 868 }
 869
 870
 871
 872 void wxHtmlContainerCell::DrawInvisible(wxDC& dc, int x, int y,
 873                                         wxHtmlRenderingInfo& info)
 874 {
 875     if (m_Cells)
 876     {
 877         for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
 878         {
 879             UpdateRenderingStatePre(info, cell);
 880             cell->DrawInvisible(dc, x + m_PosX, y + m_PosY, info);
 881             UpdateRenderingStatePost(info, cell);
 882         }
 883     }
 884 }
 885
 886
 887 wxColour wxHtmlContainerCell::GetBackgroundColour()
 888 {
 889     if (m_UseBkColour)
 890         return m_BkColour;
 891     else
 892         return wxNullColour;
 893 }
 894
 895
 896
 897 wxHtmlLinkInfo *wxHtmlContainerCell::GetLink(int x, int y) const
 898 {
 899     wxHtmlCell *cell = FindCellByPos(x, y);
 900
 901     // VZ: I don't know if we should pass absolute or relative coords to
 902     //     wxHtmlCell::GetLink()? As the base class version just ignores them
 903     //     anyhow, it hardly matters right now but should still be clarified
 904     return cell ? cell->GetLink(x, y) : NULL;
 905 }
 906
 907
 908
 909 void wxHtmlContainerCell::InsertCell(wxHtmlCell *f)
 910 {
 911     if (!m_Cells) m_Cells = m_LastCell = f;
 912     else
 913     {
 914         m_LastCell->SetNext(f);
 915         m_LastCell = f;
 916         if (m_LastCell) while (m_LastCell->GetNext()) m_LastCell = m_LastCell->GetNext();
 917     }
 918     f->SetParent(this);
 919     m_LastLayout = -1;
 920 }
 921
 922
 923
 924 void wxHtmlContainerCell::SetAlign(const wxHtmlTag& tag)
 925 {
 926     if (tag.HasParam(wxT("ALIGN")))
 927     {
 928         wxString alg = tag.GetParam(wxT("ALIGN"));
 929         alg.MakeUpper();
 930         if (alg == wxT("CENTER"))
 931             SetAlignHor(wxHTML_ALIGN_CENTER);
 932         else if (alg == wxT("LEFT"))
 933             SetAlignHor(wxHTML_ALIGN_LEFT);
 934         else if (alg == wxT("JUSTIFY"))
 935             SetAlignHor(wxHTML_ALIGN_JUSTIFY);
 936         else if (alg == wxT("RIGHT"))
 937             SetAlignHor(wxHTML_ALIGN_RIGHT);
 938         m_LastLayout = -1;
 939     }
 940 }
 941
 942
 943
 944 void wxHtmlContainerCell::SetWidthFloat(const wxHtmlTag& tag, double pixel_scale)
 945 {
 946     if (tag.HasParam(wxT("WIDTH")))
 947     {
 948         int wdi;
 949         wxString wd = tag.GetParam(wxT("WIDTH"));
 950
 951         if (wd[wd.Length()-1] == wxT('%'))
 952         {
 953             wxSscanf(wd.c_str(), wxT("%i%%"), &wdi);
 954             SetWidthFloat(wdi, wxHTML_UNITS_PERCENT);
 955         }
 956         else
 957         {
 958             wxSscanf(wd.c_str(), wxT("%i"), &wdi);
 959             SetWidthFloat((int)(pixel_scale * (double)wdi), wxHTML_UNITS_PIXELS);
 960         }
 961         m_LastLayout = -1;
 962     }
 963 }
 964
 965
 966
 967 const wxHtmlCell* wxHtmlContainerCell::Find(int condition, const void* param) const
 968 {
 969     if (m_Cells)
 970     {
 971         const wxHtmlCell *r = NULL;
 972
 973         for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
 974         {
 975             r = cell->Find(condition, param);
 976             if (r) return r;
 977         }
 978     }
 979     return NULL;
 980 }
 981
 982
 983 wxHtmlCell *wxHtmlContainerCell::FindCellByPos(wxCoord x, wxCoord y,
 984                                                unsigned flags) const
 985 {
 986     if ( flags & wxHTML_FIND_EXACT )
 987     {
 988         for ( const wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext() )
 989         {
 990             int cx = cell->GetPosX(),
 991                 cy = cell->GetPosY();
 992
 993             if ( (cx <= x) && (cx + cell->GetWidth() > x) &&
 994                  (cy <= y) && (cy + cell->GetHeight() > y) )
 995             {
 996                 return cell->FindCellByPos(x - cx, y - cy, flags);
 997             }
 998         }
 999     }
1000     else if ( flags & wxHTML_FIND_NEAREST_AFTER )
1001     {
1002         wxHtmlCell *c;
1003         for ( const wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext() )
1004         {
1005             if ( cell->IsFormattingCell() )
1006                 continue;
1007             int cellY = cell->GetPosY();
1008             if (!( y < cellY || (y < cellY + cell->GetHeight() &&
1009                                  x < cell->GetPosX() + cell->GetWidth()) ))
1010                 continue;
1011
1012             c = cell->FindCellByPos(x - cell->GetPosX(), y - cellY, flags);
1013             if (c) return c;
1014         }
1015     }
1016     else if ( flags & wxHTML_FIND_NEAREST_BEFORE )
1017     {
1018         wxHtmlCell *c2, *c = NULL;
1019         for ( const wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext() )
1020         {
1021             if ( cell->IsFormattingCell() )
1022                 continue;
1023             int cellY = cell->GetPosY();
1024             if (!( cellY + cell->GetHeight() <= y ||
1025                    (y >= cellY && x >= cell->GetPosX()) ))
1026                 break;
1027             c2 = cell->FindCellByPos(x - cell->GetPosX(), y - cellY, flags);
1028             if (c2)
1029                 c = c2;
1030         }
1031         if (c) return c;
1032     }
1033
1034     return NULL;
1035 }
1036
1037
1038 void wxHtmlContainerCell::OnMouseClick(wxWindow *parent, int x, int y, const wxMouseEvent& event)
1039 {
1040     wxHtmlCell *cell = FindCellByPos(x, y);
1041     if ( cell )
1042         cell->OnMouseClick(parent, x, y, event);
1043 }
1044
1045
1046
1047 wxHtmlCell *wxHtmlContainerCell::GetFirstTerminal() const
1048 {
1049     if ( m_Cells )
1050     {
1051         wxHtmlCell *c2;
1052         for (wxHtmlCell *c = m_Cells; c; c = c->GetNext())
1053         {
1054             c2 = c->GetFirstTerminal();
1055             if ( c2 )
1056                 return c2;
1057         }
1058     }
1059     return NULL;
1060 }
1061
1062 wxHtmlCell *wxHtmlContainerCell::GetLastTerminal() const
1063 {
1064     if ( m_Cells )
1065     {
1066         // most common case first:
1067         wxHtmlCell *c = m_LastCell->GetLastTerminal();
1068         if ( c )
1069             return c;
1070
1071         wxHtmlCell *ctmp;
1072         wxHtmlCell *c2 = NULL;
1073         for (c = m_Cells; c; c = c->GetNext())
1074         {
1075             ctmp = c->GetLastTerminal();
1076             if ( ctmp )
1077                 c2 = ctmp;
1078         }
1079         return c2;
1080     }
1081     else
1082         return NULL;
1083 }
1084
1085
1086 static bool IsEmptyContainer(wxHtmlContainerCell *cell)
1087 {
1088     for ( wxHtmlCell *c = cell->GetFirstChild(); c; c = c->GetNext() )
1089     {
1090         if ( !c->IsTerminalCell() || !c->IsFormattingCell() )
1091             return false;
1092     }
1093     return true;
1094 }
1095
1096 void wxHtmlContainerCell::RemoveExtraSpacing(bool top, bool bottom)
1097 {
1098     if ( top )
1099         SetIndent(0, wxHTML_INDENT_TOP);
1100     if ( bottom )
1101         SetIndent(0, wxHTML_INDENT_BOTTOM);
1102
1103     if ( m_Cells )
1104     {
1105         wxHtmlCell *c;
1106         wxHtmlContainerCell *cont;
1107         if ( top )
1108         {
1109             for ( c = m_Cells; c; c = c->GetNext() )
1110             {
1111                 if ( c->IsTerminalCell() )
1112                 {
1113                     if ( !c->IsFormattingCell() )
1114                         break;
1115                 }
1116                 else
1117                 {
1118                     cont = (wxHtmlContainerCell*)c;
1119                     if ( IsEmptyContainer(cont) )
1120                     {
1121                         cont->SetIndent(0, wxHTML_INDENT_VERTICAL);
1122                     }
1123                     else
1124                     {
1125                         cont->RemoveExtraSpacing(true, false);
1126                         break;
1127                     }
1128                 }
1129             }
1130         }
1131
1132         if ( bottom )
1133         {
1134             wxArrayPtrVoid arr;
1135             for ( c = m_Cells; c; c = c->GetNext() )
1136                 arr.Add((void*)c);
1137
1138             for ( int i = arr.GetCount() - 1; i >= 0; i--)
1139             {
1140                 c = (wxHtmlCell*)arr[i];
1141                 if ( c->IsTerminalCell() )
1142                 {
1143                     if ( !c->IsFormattingCell() )
1144                         break;
1145                 }
1146                 else
1147                 {
1148                     cont = (wxHtmlContainerCell*)c;
1149                     if ( IsEmptyContainer(cont) )
1150                     {
1151                         cont->SetIndent(0, wxHTML_INDENT_VERTICAL);                                 }
1152                     else
1153                     {
1154                         cont->RemoveExtraSpacing(false, true);
1155                         break;
1156                     }
1157                 }
1158             }
1159         }
1160     }
1161 }
1162
1163
1164
1165
1166 // --------------------------------------------------------------------------
1167 // wxHtmlColourCell
1168 // --------------------------------------------------------------------------
1169
1170 void wxHtmlColourCell::Draw(wxDC& dc,
1171                             int x, int y,
1172                             int WXUNUSED(view_y1), int WXUNUSED(view_y2),
1173                             wxHtmlRenderingInfo& info)
1174 {
1175     DrawInvisible(dc, x, y, info);
1176 }
1177
1178 void wxHtmlColourCell::DrawInvisible(wxDC& dc,
1179                                      int WXUNUSED(x), int WXUNUSED(y),
1180                                      wxHtmlRenderingInfo& info)
1181 {
1182     wxHtmlRenderingState& state = info.GetState();
1183     if (m_Flags & wxHTML_CLR_FOREGROUND)
1184     {
1185         state.SetFgColour(m_Colour);
1186         if (state.GetSelectionState() != wxHTML_SEL_IN)
1187             dc.SetTextForeground(m_Colour);
1188         else
1189             dc.SetTextForeground(
1190                     info.GetStyle().GetSelectedTextColour(m_Colour));
1191     }
1192     if (m_Flags & wxHTML_CLR_BACKGROUND)
1193     {
1194         state.SetBgColour(m_Colour);
1195         if (state.GetSelectionState() != wxHTML_SEL_IN)
1196         {
1197             dc.SetTextBackground(m_Colour);
1198             dc.SetBackground(wxBrush(m_Colour, wxSOLID));
1199         }
1200         else
1201         {
1202             wxColour c = info.GetStyle().GetSelectedTextBgColour(m_Colour);
1203             dc.SetTextBackground(c);
1204             dc.SetBackground(wxBrush(c, wxSOLID));
1205         }
1206     }
1207 }
1208
1209
1210
1211
1212 // ---------------------------------------------------------------------------
1213 // wxHtmlFontCell
1214 // ---------------------------------------------------------------------------
1215
1216 void wxHtmlFontCell::Draw(wxDC& dc,
1217                           int WXUNUSED(x), int WXUNUSED(y),
1218                           int WXUNUSED(view_y1), int WXUNUSED(view_y2),
1219                           wxHtmlRenderingInfo& WXUNUSED(info))
1220 {
1221     dc.SetFont(m_Font);
1222 }
1223
1224 void wxHtmlFontCell::DrawInvisible(wxDC& dc, int WXUNUSED(x), int WXUNUSED(y),
1225                                    wxHtmlRenderingInfo& WXUNUSED(info))
1226 {
1227     dc.SetFont(m_Font);
1228 }
1229
1230
1231
1232
1233
1234
1235
1236
1237 // ---------------------------------------------------------------------------
1238 // wxHtmlWidgetCell
1239 // ---------------------------------------------------------------------------
1240
1241 wxHtmlWidgetCell::wxHtmlWidgetCell(wxWindow *wnd, int w)
1242 {
1243     int sx, sy;
1244     m_Wnd = wnd;
1245     m_Wnd->GetSize(&sx, &sy);
1246     m_Width = sx, m_Height = sy;
1247     m_WidthFloat = w;
1248 }
1249
1250
1251 void wxHtmlWidgetCell::Draw(wxDC& WXUNUSED(dc),
1252                             int WXUNUSED(x), int WXUNUSED(y),
1253                             int WXUNUSED(view_y1), int WXUNUSED(view_y2),
1254                             wxHtmlRenderingInfo& WXUNUSED(info))
1255 {
1256     int absx = 0, absy = 0, stx, sty;
1257     wxHtmlCell *c = this;
1258
1259     while (c)
1260     {
1261         absx += c->GetPosX();
1262         absy += c->GetPosY();
1263         c = c->GetParent();
1264     }
1265
1266     ((wxScrolledWindow*)(m_Wnd->GetParent()))->GetViewStart(&stx, &sty);
1267     m_Wnd->SetSize(absx - wxHTML_SCROLL_STEP * stx, absy  - wxHTML_SCROLL_STEP * sty, m_Width, m_Height);
1268 }
1269
1270
1271
1272 void wxHtmlWidgetCell::DrawInvisible(wxDC& WXUNUSED(dc),
1273                                      int WXUNUSED(x), int WXUNUSED(y),
1274                                      wxHtmlRenderingInfo& WXUNUSED(info))
1275 {
1276     int absx = 0, absy = 0, stx, sty;
1277     wxHtmlCell *c = this;
1278
1279     while (c)
1280     {
1281         absx += c->GetPosX();
1282         absy += c->GetPosY();
1283         c = c->GetParent();
1284     }
1285
1286     ((wxScrolledWindow*)(m_Wnd->GetParent()))->GetViewStart(&stx, &sty);
1287     m_Wnd->SetSize(absx - wxHTML_SCROLL_STEP * stx, absy  - wxHTML_SCROLL_STEP * sty, m_Width, m_Height);
1288 }
1289
1290
1291
1292 void wxHtmlWidgetCell::Layout(int w)
1293 {
1294     if (m_WidthFloat != 0)
1295     {
1296         m_Width = (w * m_WidthFloat) / 100;
1297         m_Wnd->SetSize(m_Width, m_Height);
1298     }
1299
1300     wxHtmlCell::Layout(w);
1301 }
1302
1303
1304
1305 // ----------------------------------------------------------------------------
1306 // wxHtmlTerminalCellsInterator
1307 // ----------------------------------------------------------------------------
1308
1309 const wxHtmlCell* wxHtmlTerminalCellsInterator::operator++()
1310 {
1311     if ( !m_pos )
1312         return NULL;
1313
1314     do
1315     {
1316         if ( m_pos == m_to )
1317         {
1318             m_pos = NULL;
1319             return NULL;
1320         }
1321
1322         if ( m_pos->GetNext() )
1323             m_pos = m_pos->GetNext();
1324         else
1325         {
1326             // we must go up the hierarchy until we reach container where this
1327             // is not the last child, and then go down to first terminal cell:
1328             while ( m_pos->GetNext() == NULL )
1329             {
1330                 m_pos = m_pos->GetParent();
1331                 if ( !m_pos )
1332                     return NULL;
1333             }
1334             m_pos = m_pos->GetNext();
1335         }
1336         while ( m_pos->GetFirstChild() != NULL )
1337             m_pos = m_pos->GetFirstChild();
1338     } while ( !m_pos->IsTerminalCell() );
1339
1340     return m_pos;
1341 }
1342
1343
1344
1345
1346
1347
1348
1349 //-----------------------------------------------------------------------------
1350 // Cleanup
1351 //-----------------------------------------------------------------------------
1352
1353 class wxHtmlCellModule: public wxModule
1354 {
1355 DECLARE_DYNAMIC_CLASS(wxHtmlCellModule)
1356 public:
1357     wxHtmlCellModule() : wxModule() {}
1358     bool OnInit() { return true; }
1359     void OnExit()
1360     {
1361         wxDELETE(gs_cursorLink);
1362         wxDELETE(gs_cursorText);
1363     }
1364 };
1365
1366 IMPLEMENT_DYNAMIC_CLASS(wxHtmlCellModule, wxModule)
1367
1368 #endif