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