]> git.saurik.com Git - wxWidgets.git/blob - src/html/htmlcell.cpp
made Convert() methods const
[wxWidgets.git] / 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 #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
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();
66 p2.y += toCell->GetHeight();
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