]> git.saurik.com Git - wxWidgets.git/blob - src/html/htmlcell.cpp
projects / wxWidgets.git / blob
? search:


bfb558506f3bd0416ac11cc6e77ecad2f38653c4
[wxWidgets.git] / src / html / htmlcell.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/html/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 #include "wx/wxprec.h"
11
12 #ifdef __BORLANDC__
13 #pragma hdrstop
14 #endif
15
16 #if wxUSE_HTML && wxUSE_STREAMS
17
18 #ifndef WX_PRECOMP
19 #include "wx/dynarray.h"
20 #include "wx/brush.h"
21 #include "wx/colour.h"
22 #include "wx/dc.h"
23 #include "wx/settings.h"
24 #include "wx/module.h"
25 #include "wx/wxcrtvararg.h"
26 #endif
27
28 #include "wx/html/htmlcell.h"
29 #include "wx/html/htmlwin.h"
30
31 #include <stdlib.h>
32
33 //-----------------------------------------------------------------------------
34 // Helper classes
35 //-----------------------------------------------------------------------------
36
37 void wxHtmlSelection::Set(const wxPoint& fromPos, const wxHtmlCell *fromCell,
38 const wxPoint& toPos, const wxHtmlCell *toCell)
39 {
40 m_fromCell = fromCell;
41 m_toCell = toCell;
42 m_fromPos = fromPos;
43 m_toPos = toPos;
44 }
45
46 void wxHtmlSelection::Set(const wxHtmlCell *fromCell, const wxHtmlCell *toCell)
47 {
48 wxPoint p1 = fromCell ? fromCell->GetAbsPos() : wxDefaultPosition;
49 wxPoint p2 = toCell ? toCell->GetAbsPos() : wxDefaultPosition;
50 if ( toCell )
51 {
52 p2.x += toCell->GetWidth();
53 p2.y += toCell->GetHeight();
54 }
55 Set(p1, fromCell, p2, toCell);
56 }
57
58 wxColour
59 wxDefaultHtmlRenderingStyle::
60 GetSelectedTextColour(const wxColour& WXUNUSED(clr))
61 {
62 return wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
63 }
64
65 wxColour
66 wxDefaultHtmlRenderingStyle::
67 GetSelectedTextBgColour(const wxColour& WXUNUSED(clr))
68 {
69 return wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
70 }
71
72
73 //-----------------------------------------------------------------------------
74 // wxHtmlCell
75 //-----------------------------------------------------------------------------
76
77 IMPLEMENT_ABSTRACT_CLASS(wxHtmlCell, wxObject)
78
79 wxHtmlCell::wxHtmlCell() : wxObject()
80 {
81 m_Next = NULL;
82 m_Parent = NULL;
83 m_Width = m_Height = m_Descent = 0;
84 m_ScriptMode = wxHTML_SCRIPT_NORMAL; // <sub> or <sup> mode
85 m_ScriptBaseline = 0; // <sub> or <sup> baseline
86 m_CanLiveOnPagebreak = true;
87 m_Link = NULL;
88 }
89
90 wxHtmlCell::~wxHtmlCell()
91 {
92 delete m_Link;
93 }
94
95 // Update the descent value when whe are in a <sub> or <sup>.
96 // prevbase is the parent base
97 void wxHtmlCell::SetScriptMode(wxHtmlScriptMode mode, long previousBase)
98 {
99 m_ScriptMode = mode;
100
101 if (mode == wxHTML_SCRIPT_SUP)
102 m_ScriptBaseline = previousBase - (m_Height + 1) / 2;
103 else if (mode == wxHTML_SCRIPT_SUB)
104 m_ScriptBaseline = previousBase + (m_Height + 1) / 6;
105 else
106 m_ScriptBaseline = 0;
107
108 m_Descent += m_ScriptBaseline;
109 }
110
111 #if WXWIN_COMPATIBILITY_2_6
112
113 struct wxHtmlCellOnMouseClickCompatHelper;
114
115 static wxHtmlCellOnMouseClickCompatHelper *gs_helperOnMouseClick = NULL;
116
117 // helper for routing calls to new ProcessMouseClick() method to deprecated
118 // OnMouseClick() method
119 struct wxHtmlCellOnMouseClickCompatHelper
120 {
121 wxHtmlCellOnMouseClickCompatHelper(wxHtmlWindowInterface *window_,
122 const wxPoint& pos_,
123 const wxMouseEvent& event_)
124 : window(window_), pos(pos_), event(event_), retval(false)
125 {
126 }
127
128 bool CallOnMouseClick(wxHtmlCell *cell)
129 {
130 wxHtmlCellOnMouseClickCompatHelper *oldHelper = gs_helperOnMouseClick;
131 gs_helperOnMouseClick = this;
132 cell->OnMouseClick
133 (
134 window ? window->GetHTMLWindow() : NULL,
135 pos.x, pos.y,
136 event
137 );
138 gs_helperOnMouseClick = oldHelper;
139 return retval;
140 }
141
142 wxHtmlWindowInterface *window;
143 const wxPoint& pos;
144 const wxMouseEvent& event;
145 bool retval;
146 };
147 #endif // WXWIN_COMPATIBILITY_2_6
148
149 bool wxHtmlCell::ProcessMouseClick(wxHtmlWindowInterface *window,
150 const wxPoint& pos,
151 const wxMouseEvent& event)
152 {
153 wxCHECK_MSG( window, false, wxT("window interface must be provided") );
154
155 #if WXWIN_COMPATIBILITY_2_6
156 // NB: this hack puts the body of ProcessMouseClick() into OnMouseClick()
157 // (for which it has to pass the arguments and return value via a
158 // helper variable because these two methods have different
159 // signatures), so that old code overriding OnMouseClick will continue
160 // to work
161 wxHtmlCellOnMouseClickCompatHelper compat(window, pos, event);
162 return compat.CallOnMouseClick(this);
163 }
164
165 void wxHtmlCell::OnMouseClick(wxWindow *, int, int, const wxMouseEvent& event)
166 {
167 wxCHECK_RET( gs_helperOnMouseClick, wxT("unexpected call to OnMouseClick") );
168 wxHtmlWindowInterface *window = gs_helperOnMouseClick->window;
169 const wxPoint& pos = gs_helperOnMouseClick->pos;
170 #endif // WXWIN_COMPATIBILITY_2_6
171
172 wxHtmlLinkInfo *lnk = GetLink(pos.x, pos.y);
173 bool retval = false;
174
175 if (lnk)
176 {
177 wxHtmlLinkInfo lnk2(*lnk);
178 lnk2.SetEvent(&event);
179 lnk2.SetHtmlCell(this);
180
181 window->OnHTMLLinkClicked(lnk2);
182 retval = true;
183 }
184
185 #if WXWIN_COMPATIBILITY_2_6
186 gs_helperOnMouseClick->retval = retval;
187 #else
188 return retval;
189 #endif // WXWIN_COMPATIBILITY_2_6
190 }
191
192 #if WXWIN_COMPATIBILITY_2_6
193 wxCursor wxHtmlCell::GetCursor() const
194 {
195 return wxNullCursor;
196 }
197 #endif // WXWIN_COMPATIBILITY_2_6
198
199 wxCursor
200 wxHtmlCell::GetMouseCursor(wxHtmlWindowInterface* WXUNUSED(window)) const
201 {
202 // This is never called directly, only from GetMouseCursorAt() and we
203 // return an invalid cursor by default to let it delegate to the window.
204 return wxNullCursor;
205 }
206
207 wxCursor
208 wxHtmlCell::GetMouseCursorAt(wxHtmlWindowInterface *window,
209 const wxPoint& relPos) const
210 {
211 #if WXWIN_COMPATIBILITY_2_6
212 // NB: Older versions of wx used GetCursor() virtual method in place of
213 // GetMouseCursor(interface). This code ensures that user code that
214 // overridden GetCursor() continues to work. The trick is that the base
215 // wxHtmlCell::GetCursor() method simply returns wxNullCursor, so we
216 // know that GetCursor() was overridden iff it returns valid cursor.
217 wxCursor cur = GetCursor();
218 if (cur.IsOk())
219 return cur;
220 #endif // WXWIN_COMPATIBILITY_2_6
221
222 const wxCursor curCell = GetMouseCursor(window);
223 if ( curCell.IsOk() )
224 return curCell;
225
226 if ( GetLink(relPos.x, relPos.y) )
227 {
228 return window->GetHTMLCursor(wxHtmlWindowInterface::HTMLCursor_Link);
229 }
230 else
231 {
232 return window->GetHTMLCursor(wxHtmlWindowInterface::HTMLCursor_Default);
233 }
234 }
235
236
237 bool
238 wxHtmlCell::AdjustPagebreak(int *pagebreak,
239 const wxArrayInt& WXUNUSED(known_pagebreaks),
240 int pageHeight) const
241 {
242 // Notice that we always break the cells bigger than the page height here
243 // as otherwise we wouldn't be able to break them at all.
244 if ( m_Height <= pageHeight &&
245 (!m_CanLiveOnPagebreak &&
246 m_PosY < *pagebreak && m_PosY + m_Height > *pagebreak) )
247 {
248 *pagebreak = m_PosY;
249 return true;
250 }
251
252 return false;
253 }
254
255
256
257 void wxHtmlCell::SetLink(const wxHtmlLinkInfo& link)
258 {
259 wxDELETE(m_Link);
260 if (link.GetHref() != wxEmptyString)
261 m_Link = new wxHtmlLinkInfo(link);
262 }
263
264
265 void wxHtmlCell::Layout(int WXUNUSED(w))
266 {
267 SetPos(0, 0);
268 }
269
270
271
272 const wxHtmlCell* wxHtmlCell::Find(int WXUNUSED(condition), const void* WXUNUSED(param)) const
273 {
274 return NULL;
275 }
276
277
278 wxHtmlCell *wxHtmlCell::FindCellByPos(wxCoord x, wxCoord y,
279 unsigned flags) const
280 {
281 if ( x >= 0 && x < m_Width && y >= 0 && y < m_Height )
282 {
283 return wxConstCast(this, wxHtmlCell);
284 }
285 else
286 {
287 if ((flags & wxHTML_FIND_NEAREST_AFTER) &&
288 (y < 0 || (y < 0+m_Height && x < 0+m_Width)))
289 return wxConstCast(this, wxHtmlCell);
290 else if ((flags & wxHTML_FIND_NEAREST_BEFORE) &&
291 (y >= 0+m_Height || (y >= 0 && x >= 0)))
292 return wxConstCast(this, wxHtmlCell);
293 else
294 return NULL;
295 }
296 }
297
298
299 wxPoint wxHtmlCell::GetAbsPos(wxHtmlCell *rootCell) const
300 {
301 wxPoint p(m_PosX, m_PosY);
302 for (wxHtmlCell *parent = m_Parent; parent && parent != rootCell;
303 parent = parent->m_Parent)
304 {
305 p.x += parent->m_PosX;
306 p.y += parent->m_PosY;
307 }
308 return p;
309 }
310
311 wxHtmlCell *wxHtmlCell::GetRootCell() const
312 {
313 wxHtmlCell *c = wxConstCast(this, wxHtmlCell);
314 while ( c->m_Parent )
315 c = c->m_Parent;
316 return c;
317 }
318
319 unsigned wxHtmlCell::GetDepth() const
320 {
321 unsigned d = 0;
322 for (wxHtmlCell *p = m_Parent; p; p = p->m_Parent)
323 d++;
324 return d;
325 }
326
327 bool wxHtmlCell::IsBefore(wxHtmlCell *cell) const
328 {
329 const wxHtmlCell *c1 = this;
330 const wxHtmlCell *c2 = cell;
331 unsigned d1 = GetDepth();
332 unsigned d2 = cell->GetDepth();
333
334 if ( d1 > d2 )
335 for (; d1 != d2; d1-- )
336 c1 = c1->m_Parent;
337 else if ( d1 < d2 )
338 for (; d1 != d2; d2-- )
339 c2 = c2->m_Parent;
340
341 if ( cell == this )
342 return true;
343
344 while ( c1 && c2 )
345 {
346 if ( c1->m_Parent == c2->m_Parent )
347 {
348 while ( c1 )
349 {
350 if ( c1 == c2 )
351 return true;
352 c1 = c1->GetNext();
353 }
354 return false;
355 }
356 else
357 {
358 c1 = c1->m_Parent;
359 c2 = c2->m_Parent;
360 }
361 }
362
363 wxFAIL_MSG(wxT("Cells are in different trees"));
364 return false;
365 }
366
367
368 //-----------------------------------------------------------------------------
369 // wxHtmlWordCell
370 //-----------------------------------------------------------------------------
371
372 IMPLEMENT_ABSTRACT_CLASS(wxHtmlWordCell, wxHtmlCell)
373
374 wxHtmlWordCell::wxHtmlWordCell(const wxString& word, const wxDC& dc) : wxHtmlCell()
375 {
376 m_Word = word;
377 wxCoord w, h, d;
378 dc.GetTextExtent(m_Word, &w, &h, &d);
379 m_Width = w;
380 m_Height = h;
381 m_Descent = d;
382 SetCanLiveOnPagebreak(false);
383 m_allowLinebreak = true;
384 }
385
386 void wxHtmlWordCell::SetPreviousWord(wxHtmlWordCell *cell)
387 {
388 if ( cell && m_Parent == cell->m_Parent &&
389 !wxIsspace(cell->m_Word.Last()) && !wxIsspace(m_Word[0u]) )
390 {
391 m_allowLinebreak = false;
392 }
393 }
394
395 // Splits m_Word into up to three parts according to selection, returns
396 // substring before, in and after selection and the points (in relative coords)
397 // where s2 and s3 start:
398 void wxHtmlWordCell::Split(const wxDC& dc,
399 const wxPoint& selFrom, const wxPoint& selTo,
400 unsigned& pos1, unsigned& pos2) const
401 {
402 wxPoint pt1 = (selFrom == wxDefaultPosition) ?
403 wxDefaultPosition : selFrom - GetAbsPos();
404 wxPoint pt2 = (selTo == wxDefaultPosition) ?
405 wxPoint(m_Width, wxDefaultCoord) : selTo - GetAbsPos();
406
407 // if the selection is entirely within this cell, make sure pt1 < pt2 in
408 // order to make the rest of this function simpler:
409 if ( selFrom != wxDefaultPosition && selTo != wxDefaultPosition &&
410 selFrom.x > selTo.x )
411 {
412 wxPoint tmp = pt1;
413 pt1 = pt2;
414 pt2 = tmp;
415 }
416
417 unsigned len = m_Word.length();
418 unsigned i = 0;
419 pos1 = 0;
420
421 // adjust for cases when the start/end position is completely
422 // outside the cell:
423 if ( pt1.y < 0 )
424 pt1.x = 0;
425 if ( pt2.y >= m_Height )
426 pt2.x = m_Width;
427
428 // before selection:
429 // (include character under caret only if in first half of width)
430 #ifdef __WXMAC__
431 // implementation using PartialExtents to support fractional widths
432 wxArrayInt widths ;
433 dc.GetPartialTextExtents(m_Word,widths) ;
434 while( i < len && pt1.x >= widths[i] )
435 i++ ;
436 if ( i < len )
437 {
438 int charW = (i > 0) ? widths[i] - widths[i-1] : widths[i];
439 if ( widths[i] - pt1.x < charW/2 )
440 i++;
441 }
442 #else // !__WXMAC__
443 wxCoord charW, charH;
444 while ( pt1.x > 0 && i < len )
445 {
446 dc.GetTextExtent(m_Word[i], &charW, &charH);
447 pt1.x -= charW;
448 if ( pt1.x >= -charW/2 )
449 {
450 pos1 += charW;
451 i++;
452 }
453 }
454 #endif // __WXMAC__/!__WXMAC__
455
456 // in selection:
457 // (include character under caret only if in first half of width)
458 unsigned j = i;
459 #ifdef __WXMAC__
460 while( j < len && pt2.x >= widths[j] )
461 j++ ;
462 if ( j < len )
463 {
464 int charW = (j > 0) ? widths[j] - widths[j-1] : widths[j];
465 if ( widths[j] - pt2.x < charW/2 )
466 j++;
467 }
468 #else // !__WXMAC__
469 pos2 = pos1;
470 pt2.x -= pos2;
471 while ( pt2.x > 0 && j < len )
472 {
473 dc.GetTextExtent(m_Word[j], &charW, &charH);
474 pt2.x -= charW;
475 if ( pt2.x >= -charW/2 )
476 {
477 pos2 += charW;
478 j++;
479 }
480 }
481 #endif // __WXMAC__/!__WXMAC__
482
483 pos1 = i;
484 pos2 = j;
485
486 wxASSERT( pos2 >= pos1 );
487 }
488
489 void wxHtmlWordCell::SetSelectionPrivPos(const wxDC& dc, wxHtmlSelection *s) const
490 {
491 unsigned p1, p2;
492
493 Split(dc,
494 this == s->GetFromCell() ? s->GetFromPos() : wxDefaultPosition,
495 this == s->GetToCell() ? s->GetToPos() : wxDefaultPosition,
496 p1, p2);
497
498 if ( this == s->GetFromCell() )
499 s->SetFromCharacterPos (p1); // selection starts here
500 if ( this == s->GetToCell() )
501 s->SetToCharacterPos (p2); // selection ends here
502 }
503
504
505 static void SwitchSelState(wxDC& dc, wxHtmlRenderingInfo& info,
506 bool toSelection)
507 {
508 wxColour fg = info.GetState().GetFgColour();
509 wxColour bg = info.GetState().GetBgColour();
510
511 if ( toSelection )
512 {
513 dc.SetBackgroundMode(wxSOLID);
514 dc.SetTextForeground(info.GetStyle().GetSelectedTextColour(fg));
515 dc.SetTextBackground(info.GetStyle().GetSelectedTextBgColour(bg));
516 dc.SetBackground(wxBrush(info.GetStyle().GetSelectedTextBgColour(bg),
517 wxBRUSHSTYLE_SOLID));
518 }
519 else
520 {
521 const int mode = info.GetState().GetBgMode();
522 dc.SetBackgroundMode(mode);
523 dc.SetTextForeground(fg);
524 dc.SetTextBackground(bg);
525 if ( mode != wxTRANSPARENT )
526 dc.SetBackground(wxBrush(bg, mode));
527 }
528 }
529
530
531 void wxHtmlWordCell::Draw(wxDC& dc, int x, int y,
532 int WXUNUSED(view_y1), int WXUNUSED(view_y2),
533 wxHtmlRenderingInfo& info)
534 {
535 #if 0 // useful for debugging
536 dc.SetPen(*wxBLACK_PEN);
537 dc.DrawRectangle(x+m_PosX,y+m_PosY,m_Width /* VZ: +1? */ ,m_Height);
538 #endif
539
540 bool drawSelectionAfterCell = false;
541
542 if ( info.GetState().GetSelectionState() == wxHTML_SEL_CHANGING )
543 {
544 // Selection changing, we must draw the word piecewise:
545 wxHtmlSelection *s = info.GetSelection();
546 wxString txt;
547 int w, h;
548 int ofs = 0;
549
550 // NB: this is quite a hack: in order to compute selection boundaries
551 // (in word's characters) we must know current font, which is only
552 // possible inside rendering code. Therefore we update the
553 // information here and store it in wxHtmlSelection so that
554 // ConvertToText can use it later:
555 if ( !s->AreFromToCharacterPosSet () )
556 {
557 SetSelectionPrivPos(dc, s);
558 }
559
560 int part1 = s->GetFromCell()==this ? s->GetFromCharacterPos() : 0;
561 int part2 = s->GetToCell()==this ? s->GetToCharacterPos() : m_Word.Length();
562
563 if ( part1 > 0 )
564 {
565 txt = m_Word.Mid(0, part1);
566 dc.DrawText(txt, x + m_PosX, y + m_PosY);
567 dc.GetTextExtent(txt, &w, &h);
568 ofs += w;
569 }
570
571 SwitchSelState(dc, info, true);
572
573 txt = m_Word.Mid(part1, part2-part1);
574 dc.DrawText(txt, ofs + x + m_PosX, y + m_PosY);
575
576 if ( (size_t)part2 < m_Word.length() )
577 {
578 dc.GetTextExtent(txt, &w, &h);
579 ofs += w;
580 SwitchSelState(dc, info, false);
581 txt = m_Word.Mid(part2);
582 dc.DrawText(txt, ofs + x + m_PosX, y + m_PosY);
583 }
584 else
585 drawSelectionAfterCell = true;
586 }
587 else
588 {
589 wxHtmlSelectionState selstate = info.GetState().GetSelectionState();
590 // Not changing selection state, draw the word in single mode:
591 SwitchSelState(dc, info, selstate != wxHTML_SEL_OUT);
592 dc.DrawText(m_Word, x + m_PosX, y + m_PosY);
593 drawSelectionAfterCell = (selstate != wxHTML_SEL_OUT);
594 }
595
596 // NB: If the text is justified then there is usually some free space
597 // between adjacent cells and drawing the selection only onto cells
598 // would result in ugly unselected spaces. The code below detects
599 // this special case and renders the selection *outside* the sell,
600 // too.
601 if ( m_Parent->GetAlignHor() == wxHTML_ALIGN_JUSTIFY &&
602 drawSelectionAfterCell )
603 {
604 wxHtmlCell *nextCell = m_Next;
605 while ( nextCell && nextCell->IsFormattingCell() )
606 nextCell = nextCell->GetNext();
607 if ( nextCell )
608 {
609 int nextX = nextCell->GetPosX();
610 if ( m_PosX + m_Width < nextX )
611 {
612 dc.SetBrush(dc.GetBackground());
613 dc.SetPen(*wxTRANSPARENT_PEN);
614 dc.DrawRectangle(x + m_PosX + m_Width, y + m_PosY,
615 nextX - m_PosX - m_Width, m_Height);
616 }
617 }
618 }
619 }
620
621 wxCursor wxHtmlWordCell::GetMouseCursor(wxHtmlWindowInterface *window) const
622 {
623 if ( !GetLink() )
624 {
625 return window->GetHTMLCursor(wxHtmlWindowInterface::HTMLCursor_Text);
626 }
627 else
628 {
629 return wxHtmlCell::GetMouseCursor(window);
630 }
631 }
632
633 wxString wxHtmlWordCell::ConvertToText(wxHtmlSelection *s) const
634 {
635 if ( s && (this == s->GetFromCell() || this == s->GetToCell()) )
636 {
637 // VZ: we may be called before we had a chance to re-render ourselves
638 // and in this case GetFrom/ToPrivPos() is not set yet -- assume
639 // that this only happens in case of a double/triple click (which
640 // seems to be the case now) and so it makes sense to select the
641 // entire contents of the cell in this case
642 //
643 // TODO: but this really needs to be fixed in some better way later...
644 if ( s->AreFromToCharacterPosSet() )
645 {
646 const int part1 = s->GetFromCell()==this ? s->GetFromCharacterPos() : 0;
647 const int part2 = s->GetToCell()==this ? s->GetToCharacterPos() : m_Word.Length();
648 if ( part1 == part2 )
649 return wxEmptyString;
650 return GetPartAsText(part1, part2);
651 }
652 //else: return the whole word below
653 }
654
655 return GetAllAsText();
656 }
657
658 wxString wxHtmlWordWithTabsCell::GetAllAsText() const
659 {
660 return m_wordOrig;
661 }
662
663 wxString wxHtmlWordWithTabsCell::GetPartAsText(int begin, int end) const
664 {
665 // NB: The 'begin' and 'end' positions are in the _displayed_ text
666 // (stored in m_Word) and not in the text with tabs that should
667 // be copied to clipboard (m_wordOrig).
668 //
669 // NB: Because selection is performed on displayed text, it's possible
670 // to select e.g. "half of TAB character" -- IOW, 'begin' and 'end'
671 // may be in the middle of TAB character expansion into ' 's. In this
672 // case, we copy the TAB character to clipboard once.
673
674 wxASSERT( begin < end );
675
676 const unsigned SPACES_PER_TAB = 8;
677
678 wxString sel;
679
680 int pos = 0;
681 wxString::const_iterator i = m_wordOrig.begin();
682
683 // find the beginning of text to copy:
684 for ( ; pos < begin; ++i )
685 {
686 if ( *i == '\t' )
687 {
688 pos += 8 - (m_linepos + pos) % SPACES_PER_TAB;
689 if ( pos >= begin )
690 {
691 sel += '\t';
692 }
693 }
694 else
695 {
696 ++pos;
697 }
698 }
699
700 // copy the content until we reach 'end':
701 for ( ; pos < end; ++i )
702 {
703 const wxChar c = *i;
704 sel += c;
705
706 if ( c == '\t' )
707 pos += 8 - (m_linepos + pos) % SPACES_PER_TAB;
708 else
709 ++pos;
710 }
711
712 return sel;
713 }
714
715
716
717 //-----------------------------------------------------------------------------
718 // wxHtmlContainerCell
719 //-----------------------------------------------------------------------------
720
721 IMPLEMENT_ABSTRACT_CLASS(wxHtmlContainerCell, wxHtmlCell)
722
723 wxHtmlContainerCell::wxHtmlContainerCell(wxHtmlContainerCell *parent) : wxHtmlCell()
724 {
725 m_Cells = m_LastCell = NULL;
726 m_Parent = parent;
727 m_MaxTotalWidth = 0;
728 if (m_Parent) m_Parent->InsertCell(this);
729 m_AlignHor = wxHTML_ALIGN_LEFT;
730 m_AlignVer = wxHTML_ALIGN_BOTTOM;
731 m_IndentLeft = m_IndentRight = m_IndentTop = m_IndentBottom = 0;
732 m_WidthFloat = 100; m_WidthFloatUnits = wxHTML_UNITS_PERCENT;
733 m_BkColour = wxNullColour;
734 m_Border = 0;
735 m_MinHeight = 0;
736 m_MinHeightAlign = wxHTML_ALIGN_TOP;
737 m_LastLayout = -1;
738 }
739
740 wxHtmlContainerCell::~wxHtmlContainerCell()
741 {
742 wxHtmlCell *cell = m_Cells;
743 while ( cell )
744 {
745 wxHtmlCell *cellNext = cell->GetNext();
746 delete cell;
747 cell = cellNext;
748 }
749 }
750
751
752
753 void wxHtmlContainerCell::SetIndent(int i, int what, int units)
754 {
755 int val = (units == wxHTML_UNITS_PIXELS) ? i : -i;
756 if (what & wxHTML_INDENT_LEFT) m_IndentLeft = val;
757 if (what & wxHTML_INDENT_RIGHT) m_IndentRight = val;
758 if (what & wxHTML_INDENT_TOP) m_IndentTop = val;
759 if (what & wxHTML_INDENT_BOTTOM) m_IndentBottom = val;
760 m_LastLayout = -1;
761 }
762
763
764
765 int wxHtmlContainerCell::GetIndent(int ind) const
766 {
767 if (ind & wxHTML_INDENT_LEFT) return m_IndentLeft;
768 else if (ind & wxHTML_INDENT_RIGHT) return m_IndentRight;
769 else if (ind & wxHTML_INDENT_TOP) return m_IndentTop;
770 else if (ind & wxHTML_INDENT_BOTTOM) return m_IndentBottom;
771 else return -1; /* BUG! Should not be called... */
772 }
773
774
775
776
777 int wxHtmlContainerCell::GetIndentUnits(int ind) const
778 {
779 bool p = false;
780 if (ind & wxHTML_INDENT_LEFT) p = m_IndentLeft < 0;
781 else if (ind & wxHTML_INDENT_RIGHT) p = m_IndentRight < 0;
782 else if (ind & wxHTML_INDENT_TOP) p = m_IndentTop < 0;
783 else if (ind & wxHTML_INDENT_BOTTOM) p = m_IndentBottom < 0;
784 if (p) return wxHTML_UNITS_PERCENT;
785 else return wxHTML_UNITS_PIXELS;
786 }
787
788
789 bool
790 wxHtmlContainerCell::AdjustPagebreak(int *pagebreak,
791 const wxArrayInt& known_pagebreaks,
792 int pageHeight) const
793 {
794 if (!m_CanLiveOnPagebreak)
795 return wxHtmlCell::AdjustPagebreak(pagebreak, known_pagebreaks, pageHeight);
796
797 wxHtmlCell *c = GetFirstChild();
798 bool rt = false;
799 int pbrk = *pagebreak - m_PosY;
800
801 while (c)
802 {
803 if (c->AdjustPagebreak(&pbrk, known_pagebreaks, pageHeight))
804 rt = true;
805 c = c->GetNext();
806 }
807 if (rt)
808 *pagebreak = pbrk + m_PosY;
809 return rt;
810 }
811
812
813 void wxHtmlContainerCell::Layout(int w)
814 {
815 wxHtmlCell::Layout(w);
816
817 if (m_LastLayout == w)
818 return;
819 m_LastLayout = w;
820
821 // VS: Any attempt to layout with negative or zero width leads to hell,
822 // but we can't ignore such attempts completely, since it sometimes
823 // happen (e.g. when trying how small a table can be). The best thing we
824 // can do is to set the width of child cells to zero
825 if (w < 1)
826 {
827 m_Width = 0;
828 for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
829 cell->Layout(0);
830 // this does two things: it recursively calls this code on all
831 // child contrainers and resets children's position to (0,0)
832 return;
833 }
834
835 wxHtmlCell *nextCell;
836 long xpos = 0, ypos = m_IndentTop;
837 int xdelta = 0, ybasicpos = 0, ydiff;
838 int s_width, nextWordWidth, s_indent;
839 int ysizeup = 0, ysizedown = 0;
840 int MaxLineWidth = 0;
841 int curLineWidth = 0;
842 m_MaxTotalWidth = 0;
843
844
845 /*
846
847 WIDTH ADJUSTING :
848
849 */
850
851 if (m_WidthFloatUnits == wxHTML_UNITS_PERCENT)
852 {
853 if (m_WidthFloat < 0) m_Width = (100 + m_WidthFloat) * w / 100;
854 else m_Width = m_WidthFloat * w / 100;
855 }
856 else
857 {
858 if (m_WidthFloat < 0) m_Width = w + m_WidthFloat;
859 else m_Width = m_WidthFloat;
860 }
861
862 if (m_Cells)
863 {
864 int l = (m_IndentLeft < 0) ? (-m_IndentLeft * m_Width / 100) : m_IndentLeft;
865 int r = (m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight;
866 for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
867 cell->Layout(m_Width - (l + r));
868 }
869
870 /*
871
872 LAYOUT :
873
874 */
875
876 // adjust indentation:
877 s_indent = (m_IndentLeft < 0) ? (-m_IndentLeft * m_Width / 100) : m_IndentLeft;
878 s_width = m_Width - s_indent - ((m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight);
879
880 // my own layout:
881 wxHtmlCell *cell = m_Cells,
882 *line = m_Cells;
883 while (cell != NULL)
884 {
885 switch (m_AlignVer)
886 {
887 case wxHTML_ALIGN_TOP : ybasicpos = 0; break;
888 case wxHTML_ALIGN_BOTTOM : ybasicpos = - cell->GetHeight(); break;
889 case wxHTML_ALIGN_CENTER : ybasicpos = - cell->GetHeight() / 2; break;
890 }
891 ydiff = cell->GetHeight() + ybasicpos;
892
893 if (cell->GetDescent() + ydiff > ysizedown) ysizedown = cell->GetDescent() + ydiff;
894 if (ybasicpos + cell->GetDescent() < -ysizeup) ysizeup = - (ybasicpos + cell->GetDescent());
895
896 // layout nonbreakable run of cells:
897 cell->SetPos(xpos, ybasicpos + cell->GetDescent());
898 xpos += cell->GetWidth();
899 if (!cell->IsTerminalCell())
900 {
901 // Container cell indicates new line
902 if (curLineWidth > m_MaxTotalWidth)
903 m_MaxTotalWidth = curLineWidth;
904
905 if (wxMax(cell->GetWidth(), cell->GetMaxTotalWidth()) > m_MaxTotalWidth)
906 m_MaxTotalWidth = cell->GetMaxTotalWidth();
907 curLineWidth = 0;
908 }
909 else
910 // Normal cell, add maximum cell width to line width
911 curLineWidth += cell->GetMaxTotalWidth();
912
913 cell = cell->GetNext();
914
915 // compute length of the next word that would be added:
916 nextWordWidth = 0;
917 if (cell)
918 {
919 nextCell = cell;
920 do
921 {
922 nextWordWidth += nextCell->GetWidth();
923 nextCell = nextCell->GetNext();
924 } while (nextCell && !nextCell->IsLinebreakAllowed());
925 }
926
927 // force new line if occurred:
928 if ((cell == NULL) ||
929 (xpos + nextWordWidth > s_width && cell->IsLinebreakAllowed()))
930 {
931 if (xpos > MaxLineWidth) MaxLineWidth = xpos;
932 if (ysizeup < 0) ysizeup = 0;
933 if (ysizedown < 0) ysizedown = 0;
934 switch (m_AlignHor) {
935 case wxHTML_ALIGN_LEFT :
936 case wxHTML_ALIGN_JUSTIFY :
937 xdelta = 0;
938 break;
939 case wxHTML_ALIGN_RIGHT :
940 xdelta = 0 + (s_width - xpos);
941 break;
942 case wxHTML_ALIGN_CENTER :
943 xdelta = 0 + (s_width - xpos) / 2;
944 break;
945 }
946 if (xdelta < 0) xdelta = 0;
947 xdelta += s_indent;
948
949 ypos += ysizeup;
950
951 if (m_AlignHor != wxHTML_ALIGN_JUSTIFY || cell == NULL)
952 {
953 while (line != cell)
954 {
955 line->SetPos(line->GetPosX() + xdelta,
956 ypos + line->GetPosY());
957 line = line->GetNext();
958 }
959 }
960 else // align == justify
961 {
962 // we have to distribute the extra horz space between the cells
963 // on this line
964
965 // an added complication is that some cells have fixed size and
966 // shouldn't get any increment (it so happens that these cells
967 // also don't allow line break on them which provides with an
968 // easy way to test for this) -- and neither should the cells
969 // adjacent to them as this could result in a visible space
970 // between two cells separated by, e.g. font change, cell which
971 // is wrong
972
973 int step = s_width - xpos;
974 if ( step > 0 )
975 {
976 // first count the cells which will get extra space
977 int total = -1;
978
979 const wxHtmlCell *c;
980 if ( line != cell )
981 {
982 for ( c = line; c != cell; c = c->GetNext() )
983 {
984 if ( c->IsLinebreakAllowed() )
985 {
986 total++;
987 }
988 }
989 }
990
991 // and now extra space to those cells which merit it
992 if ( total )
993 {
994 // first visible cell on line is not moved:
995 while (line !=cell && !line->IsLinebreakAllowed())
996 {
997 line->SetPos(line->GetPosX() + s_indent,
998 line->GetPosY() + ypos);
999 line = line->GetNext();
1000 }
1001
1002 if (line != cell)
1003 {
1004 line->SetPos(line->GetPosX() + s_indent,
1005 line->GetPosY() + ypos);
1006
1007 line = line->GetNext();
1008 }
1009
1010 for ( int n = 0; line != cell; line = line->GetNext() )
1011 {
1012 if ( line->IsLinebreakAllowed() )
1013 {
1014 // offset the next cell relative to this one
1015 // thus increasing our size
1016 n++;
1017 }
1018
1019 line->SetPos(line->GetPosX() + s_indent +
1020 ((n * step) / total),
1021 line->GetPosY() + ypos);
1022 }
1023 }
1024 else
1025 {
1026 // this will cause the code to enter "else branch" below:
1027 step = 0;
1028 }
1029 }
1030 // else branch:
1031 if ( step <= 0 ) // no extra space to distribute
1032 {
1033 // just set the indent properly
1034 while (line != cell)
1035 {
1036 line->SetPos(line->GetPosX() + s_indent,
1037 line->GetPosY() + ypos);
1038 line = line->GetNext();
1039 }
1040 }
1041 }
1042
1043 ypos += ysizedown;
1044 xpos = 0;
1045 ysizeup = ysizedown = 0;
1046 line = cell;
1047 }
1048 }
1049
1050 // setup height & width, depending on container layout:
1051 m_Height = ypos + (ysizedown + ysizeup) + m_IndentBottom;
1052
1053 if (m_Height < m_MinHeight)
1054 {
1055 if (m_MinHeightAlign != wxHTML_ALIGN_TOP)
1056 {
1057 int diff = m_MinHeight - m_Height;
1058 if (m_MinHeightAlign == wxHTML_ALIGN_CENTER) diff /= 2;
1059 cell = m_Cells;
1060 while (cell)
1061 {
1062 cell->SetPos(cell->GetPosX(), cell->GetPosY() + diff);
1063 cell = cell->GetNext();
1064 }
1065 }
1066 m_Height = m_MinHeight;
1067 }
1068
1069 if (curLineWidth > m_MaxTotalWidth)
1070 m_MaxTotalWidth = curLineWidth;
1071
1072 m_MaxTotalWidth += s_indent + ((m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight);
1073 MaxLineWidth += s_indent + ((m_IndentRight < 0) ? (-m_IndentRight * m_Width / 100) : m_IndentRight);
1074 if (m_Width < MaxLineWidth) m_Width = MaxLineWidth;
1075 }
1076
1077 void wxHtmlContainerCell::UpdateRenderingStatePre(wxHtmlRenderingInfo& info,
1078 wxHtmlCell *cell) const
1079 {
1080 wxHtmlSelection *s = info.GetSelection();
1081 if (!s) return;
1082 if (s->GetFromCell() == cell || s->GetToCell() == cell)
1083 {
1084 info.GetState().SetSelectionState(wxHTML_SEL_CHANGING);
1085 }
1086 }
1087
1088 void wxHtmlContainerCell::UpdateRenderingStatePost(wxHtmlRenderingInfo& info,
1089 wxHtmlCell *cell) const
1090 {
1091 wxHtmlSelection *s = info.GetSelection();
1092 if (!s) return;
1093 if (s->GetToCell() == cell)
1094 info.GetState().SetSelectionState(wxHTML_SEL_OUT);
1095 else if (s->GetFromCell() == cell)
1096 info.GetState().SetSelectionState(wxHTML_SEL_IN);
1097 }
1098
1099 #define mMin(a, b) (((a) < (b)) ? (a) : (b))
1100 #define mMax(a, b) (((a) < (b)) ? (b) : (a))
1101
1102 void wxHtmlContainerCell::Draw(wxDC& dc, int x, int y, int view_y1, int view_y2,
1103 wxHtmlRenderingInfo& info)
1104 {
1105 #if 0 // useful for debugging
1106 dc.SetPen(*wxRED_PEN);
1107 dc.DrawRectangle(x+m_PosX,y+m_PosY,m_Width,m_Height);
1108 #endif
1109
1110 int xlocal = x + m_PosX;
1111 int ylocal = y + m_PosY;
1112
1113 if (m_BkColour.IsOk())
1114 {
1115 wxBrush myb = wxBrush(m_BkColour, wxBRUSHSTYLE_SOLID);
1116
1117 int real_y1 = mMax(ylocal, view_y1);
1118 int real_y2 = mMin(ylocal + m_Height - 1, view_y2);
1119
1120 dc.SetBrush(myb);
1121 dc.SetPen(*wxTRANSPARENT_PEN);
1122 dc.DrawRectangle(xlocal, real_y1, m_Width, real_y2 - real_y1 + 1);
1123 }
1124
1125 if (m_Border == 1)
1126 {
1127 // draw thin border using lines
1128 wxPen mypen1(m_BorderColour1, 1, wxPENSTYLE_SOLID);
1129 wxPen mypen2(m_BorderColour2, 1, wxPENSTYLE_SOLID);
1130
1131 dc.SetPen(mypen1);
1132 dc.DrawLine(xlocal, ylocal, xlocal, ylocal + m_Height - 1);
1133 dc.DrawLine(xlocal, ylocal, xlocal + m_Width, ylocal);
1134 dc.SetPen(mypen2);
1135 dc.DrawLine(xlocal + m_Width - 1, ylocal, xlocal + m_Width - 1, ylocal + m_Height - 1);
1136 dc.DrawLine(xlocal, ylocal + m_Height - 1, xlocal + m_Width, ylocal + m_Height - 1);
1137 }
1138 else if (m_Border> 0)
1139 {
1140 wxBrush mybrush1(m_BorderColour1, wxBRUSHSTYLE_SOLID);
1141 wxBrush mybrush2(m_BorderColour2, wxBRUSHSTYLE_SOLID);
1142
1143 // draw upper left corner
1144 // 0---------------5
1145 // | /
1146 // | 3-----------4
1147 // | |
1148 // | 2
1149 // |/
1150 // 1
1151
1152 wxPoint poly[6];
1153 poly[0].x =m_PosX; poly[0].y = m_PosY ;
1154 poly[1].x =m_PosX; poly[1].y = m_PosY + m_Height;
1155 poly[2].x =m_PosX + m_Border; poly[2].y = poly[1].y - m_Border;
1156 poly[3].x =poly[2].x ; poly[3].y = m_PosY + m_Border;
1157 poly[4].x =m_PosX + m_Width - m_Border; poly[4].y = poly[3].y;
1158 poly[5].x =m_PosX + m_Width; poly[5].y = m_PosY;
1159
1160 dc.SetBrush(mybrush1);
1161 dc.SetPen(*wxTRANSPARENT_PEN);
1162 dc.DrawPolygon(6, poly, x, y);
1163
1164 // draw lower right corner reusing point 1,2,4 and 5
1165 // 5
1166 // /|
1167 // 4 |
1168 // | |
1169 // 2-----------3 |
1170 // / |
1171 // 1---------------0
1172 dc.SetBrush(mybrush2);
1173 poly[0].x = poly[5].x; poly[0].y = poly[1].y;
1174 poly[3].x = poly[4].x; poly[3].y = poly[2].y;
1175 dc.DrawPolygon(6, poly, x, y);
1176
1177 // smooth color transition like firefox
1178 wxColour borderMediumColour(
1179 (m_BorderColour1.Red() + m_BorderColour2.Red()) /2 ,
1180 (m_BorderColour1.Green() + m_BorderColour2.Green()) /2 ,
1181 (m_BorderColour1.Blue() + m_BorderColour2.Blue()) /2
1182 );
1183 wxPen mypen3(borderMediumColour, 1, wxPENSTYLE_SOLID);
1184 dc.SetPen(mypen3);
1185 dc.DrawLines(2, &poly[1], x, y - 1); // between 1 and 2
1186 dc.DrawLines(2, &poly[4], x, y - 1); // between 4 and 5
1187 }
1188 if (m_Cells)
1189 {
1190 // draw container's contents:
1191 for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
1192 {
1193
1194 // optimize drawing: don't render off-screen content:
1195 if ((ylocal + cell->GetPosY() <= view_y2) &&
1196 (ylocal + cell->GetPosY() + cell->GetHeight() > view_y1))
1197 {
1198 // the cell is visible, draw it:
1199 UpdateRenderingStatePre(info, cell);
1200 cell->Draw(dc,
1201 xlocal, ylocal, view_y1, view_y2,
1202 info);
1203 UpdateRenderingStatePost(info, cell);
1204 }
1205 else
1206 {
1207 // the cell is off-screen, proceed with font+color+etc.
1208 // changes only:
1209 cell->DrawInvisible(dc, xlocal, ylocal, info);
1210 }
1211 }
1212 }
1213 }
1214
1215
1216
1217 void wxHtmlContainerCell::DrawInvisible(wxDC& dc, int x, int y,
1218 wxHtmlRenderingInfo& info)
1219 {
1220 if (m_Cells)
1221 {
1222 for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
1223 {
1224 UpdateRenderingStatePre(info, cell);
1225 cell->DrawInvisible(dc, x + m_PosX, y + m_PosY, info);
1226 UpdateRenderingStatePost(info, cell);
1227 }
1228 }
1229 }
1230
1231
1232 wxColour wxHtmlContainerCell::GetBackgroundColour()
1233 {
1234 return m_BkColour;
1235 }
1236
1237
1238
1239 wxHtmlLinkInfo *wxHtmlContainerCell::GetLink(int x, int y) const
1240 {
1241 wxHtmlCell *cell = FindCellByPos(x, y);
1242
1243 // VZ: I don't know if we should pass absolute or relative coords to
1244 // wxHtmlCell::GetLink()? As the base class version just ignores them
1245 // anyhow, it hardly matters right now but should still be clarified
1246 return cell ? cell->GetLink(x, y) : NULL;
1247 }
1248
1249
1250
1251 void wxHtmlContainerCell::InsertCell(wxHtmlCell *f)
1252 {
1253 if (!m_Cells) m_Cells = m_LastCell = f;
1254 else
1255 {
1256 m_LastCell->SetNext(f);
1257 m_LastCell = f;
1258 if (m_LastCell) while (m_LastCell->GetNext()) m_LastCell = m_LastCell->GetNext();
1259 }
1260 f->SetParent(this);
1261 m_LastLayout = -1;
1262 }
1263
1264
1265
1266 void wxHtmlContainerCell::SetAlign(const wxHtmlTag& tag)
1267 {
1268 if (tag.HasParam(wxT("ALIGN")))
1269 {
1270 wxString alg = tag.GetParam(wxT("ALIGN"));
1271 alg.MakeUpper();
1272 if (alg == wxT("CENTER"))
1273 SetAlignHor(wxHTML_ALIGN_CENTER);
1274 else if (alg == wxT("LEFT"))
1275 SetAlignHor(wxHTML_ALIGN_LEFT);
1276 else if (alg == wxT("JUSTIFY"))
1277 SetAlignHor(wxHTML_ALIGN_JUSTIFY);
1278 else if (alg == wxT("RIGHT"))
1279 SetAlignHor(wxHTML_ALIGN_RIGHT);
1280 m_LastLayout = -1;
1281 }
1282 }
1283
1284
1285
1286 void wxHtmlContainerCell::SetWidthFloat(const wxHtmlTag& tag, double pixel_scale)
1287 {
1288 if (tag.HasParam(wxT("WIDTH")))
1289 {
1290 int wdi;
1291 wxString wd = tag.GetParam(wxT("WIDTH"));
1292
1293 if (wd[wd.length()-1] == wxT('%'))
1294 {
1295 wxSscanf(wd.c_str(), wxT("%i%%"), &wdi);
1296 SetWidthFloat(wdi, wxHTML_UNITS_PERCENT);
1297 }
1298 else
1299 {
1300 wxSscanf(wd.c_str(), wxT("%i"), &wdi);
1301 SetWidthFloat((int)(pixel_scale * (double)wdi), wxHTML_UNITS_PIXELS);
1302 }
1303 m_LastLayout = -1;
1304 }
1305 }
1306
1307
1308
1309 const wxHtmlCell* wxHtmlContainerCell::Find(int condition, const void* param) const
1310 {
1311 if (m_Cells)
1312 {
1313 for (wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext())
1314 {
1315 const wxHtmlCell *r = cell->Find(condition, param);
1316 if (r) return r;
1317 }
1318 }
1319 return NULL;
1320 }
1321
1322
1323 wxHtmlCell *wxHtmlContainerCell::FindCellByPos(wxCoord x, wxCoord y,
1324 unsigned flags) const
1325 {
1326 if ( flags & wxHTML_FIND_EXACT )
1327 {
1328 for ( const wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext() )
1329 {
1330 int cx = cell->GetPosX(),
1331 cy = cell->GetPosY();
1332
1333 if ( (cx <= x) && (cx + cell->GetWidth() > x) &&
1334 (cy <= y) && (cy + cell->GetHeight() > y) )
1335 {
1336 return cell->FindCellByPos(x - cx, y - cy, flags);
1337 }
1338 }
1339 }
1340 else if ( flags & wxHTML_FIND_NEAREST_AFTER )
1341 {
1342 wxHtmlCell *c;
1343 for ( const wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext() )
1344 {
1345 if ( cell->IsFormattingCell() )
1346 continue;
1347 int cellY = cell->GetPosY();
1348 if (!( y < cellY || (y < cellY + cell->GetHeight() &&
1349 x < cell->GetPosX() + cell->GetWidth()) ))
1350 continue;
1351
1352 c = cell->FindCellByPos(x - cell->GetPosX(), y - cellY, flags);
1353 if (c) return c;
1354 }
1355 }
1356 else if ( flags & wxHTML_FIND_NEAREST_BEFORE )
1357 {
1358 wxHtmlCell *c2, *c = NULL;
1359 for ( const wxHtmlCell *cell = m_Cells; cell; cell = cell->GetNext() )
1360 {
1361 if ( cell->IsFormattingCell() )
1362 continue;
1363 int cellY = cell->GetPosY();
1364 if (!( cellY + cell->GetHeight() <= y ||
1365 (y >= cellY && x >= cell->GetPosX()) ))
1366 break;
1367 c2 = cell->FindCellByPos(x - cell->GetPosX(), y - cellY, flags);
1368 if (c2)
1369 c = c2;
1370 }
1371 if (c) return c;
1372 }
1373
1374 return NULL;
1375 }
1376
1377
1378 bool wxHtmlContainerCell::ProcessMouseClick(wxHtmlWindowInterface *window,
1379 const wxPoint& pos,
1380 const wxMouseEvent& event)
1381 {
1382 #if WXWIN_COMPATIBILITY_2_6
1383 wxHtmlCellOnMouseClickCompatHelper compat(window, pos, event);
1384 return compat.CallOnMouseClick(this);
1385 }
1386
1387 void wxHtmlContainerCell::OnMouseClick(wxWindow*,
1388 int, int, const wxMouseEvent& event)
1389 {
1390 wxCHECK_RET( gs_helperOnMouseClick, wxT("unexpected call to OnMouseClick") );
1391 wxHtmlWindowInterface *window = gs_helperOnMouseClick->window;
1392 const wxPoint& pos = gs_helperOnMouseClick->pos;
1393 #endif // WXWIN_COMPATIBILITY_2_6
1394
1395 bool retval = false;
1396 wxHtmlCell *cell = FindCellByPos(pos.x, pos.y);
1397 if ( cell )
1398 retval = cell->ProcessMouseClick(window, pos, event);
1399
1400 #if WXWIN_COMPATIBILITY_2_6
1401 gs_helperOnMouseClick->retval = retval;
1402 #else
1403 return retval;
1404 #endif // WXWIN_COMPATIBILITY_2_6
1405 }
1406
1407
1408 wxHtmlCell *wxHtmlContainerCell::GetFirstTerminal() const
1409 {
1410 if ( m_Cells )
1411 {
1412 wxHtmlCell *c2;
1413 for (wxHtmlCell *c = m_Cells; c; c = c->GetNext())
1414 {
1415 c2 = c->GetFirstTerminal();
1416 if ( c2 )
1417 return c2;
1418 }
1419 }
1420 return NULL;
1421 }
1422
1423 wxHtmlCell *wxHtmlContainerCell::GetLastTerminal() const
1424 {
1425 if ( m_Cells )
1426 {
1427 // most common case first:
1428 wxHtmlCell *c = m_LastCell->GetLastTerminal();
1429 if ( c )
1430 return c;
1431
1432 wxHtmlCell *ctmp;
1433 wxHtmlCell *c2 = NULL;
1434 for (c = m_Cells; c; c = c->GetNext())
1435 {
1436 ctmp = c->GetLastTerminal();
1437 if ( ctmp )
1438 c2 = ctmp;
1439 }
1440 return c2;
1441 }
1442 else
1443 return NULL;
1444 }
1445
1446
1447 static bool IsEmptyContainer(wxHtmlContainerCell *cell)
1448 {
1449 for ( wxHtmlCell *c = cell->GetFirstChild(); c; c = c->GetNext() )
1450 {
1451 if ( !c->IsTerminalCell() || !c->IsFormattingCell() )
1452 return false;
1453 }
1454 return true;
1455 }
1456
1457 void wxHtmlContainerCell::RemoveExtraSpacing(bool top, bool bottom)
1458 {
1459 if ( top )
1460 SetIndent(0, wxHTML_INDENT_TOP);
1461 if ( bottom )
1462 SetIndent(0, wxHTML_INDENT_BOTTOM);
1463
1464 if ( m_Cells )
1465 {
1466 wxHtmlCell *c;
1467 wxHtmlContainerCell *cont;
1468 if ( top )
1469 {
1470 for ( c = m_Cells; c; c = c->GetNext() )
1471 {
1472 if ( c->IsTerminalCell() )
1473 {
1474 if ( !c->IsFormattingCell() )
1475 break;
1476 }
1477 else
1478 {
1479 cont = (wxHtmlContainerCell*)c;
1480 if ( IsEmptyContainer(cont) )
1481 {
1482 cont->SetIndent(0, wxHTML_INDENT_VERTICAL);
1483 }
1484 else
1485 {
1486 cont->RemoveExtraSpacing(true, false);
1487 break;
1488 }
1489 }
1490 }
1491 }
1492
1493 if ( bottom )
1494 {
1495 wxArrayPtrVoid arr;
1496 for ( c = m_Cells; c; c = c->GetNext() )
1497 arr.Add((void*)c);
1498
1499 for ( int i = arr.GetCount() - 1; i >= 0; i--)
1500 {
1501 c = (wxHtmlCell*)arr[i];
1502 if ( c->IsTerminalCell() )
1503 {
1504 if ( !c->IsFormattingCell() )
1505 break;
1506 }
1507 else
1508 {
1509 cont = (wxHtmlContainerCell*)c;
1510 if ( IsEmptyContainer(cont) )
1511 {
1512 cont->SetIndent(0, wxHTML_INDENT_VERTICAL);
1513 }
1514 else
1515 {
1516 cont->RemoveExtraSpacing(false, true);
1517 break;
1518 }
1519 }
1520 }
1521 }
1522 }
1523 }
1524
1525
1526
1527
1528 // --------------------------------------------------------------------------
1529 // wxHtmlColourCell
1530 // --------------------------------------------------------------------------
1531
1532 IMPLEMENT_ABSTRACT_CLASS(wxHtmlColourCell, wxHtmlCell)
1533
1534 void wxHtmlColourCell::Draw(wxDC& dc,
1535 int x, int y,
1536 int WXUNUSED(view_y1), int WXUNUSED(view_y2),
1537 wxHtmlRenderingInfo& info)
1538 {
1539 DrawInvisible(dc, x, y, info);
1540 }
1541
1542 void wxHtmlColourCell::DrawInvisible(wxDC& dc,
1543 int WXUNUSED(x), int WXUNUSED(y),
1544 wxHtmlRenderingInfo& info)
1545 {
1546 wxHtmlRenderingState& state = info.GetState();
1547 if (m_Flags & wxHTML_CLR_FOREGROUND)
1548 {
1549 state.SetFgColour(m_Colour);
1550 if (state.GetSelectionState() != wxHTML_SEL_IN)
1551 dc.SetTextForeground(m_Colour);
1552 else
1553 dc.SetTextForeground(
1554 info.GetStyle().GetSelectedTextColour(m_Colour));
1555 }
1556 if (m_Flags & wxHTML_CLR_BACKGROUND)
1557 {
1558 state.SetBgColour(m_Colour);
1559 state.SetBgMode(wxSOLID);
1560 const wxColour c = state.GetSelectionState() == wxHTML_SEL_IN
1561 ? info.GetStyle().GetSelectedTextBgColour(m_Colour)
1562 : m_Colour;
1563 dc.SetTextBackground(c);
1564 dc.SetBackground(c);
1565 dc.SetBackgroundMode(wxSOLID);
1566 }
1567 if (m_Flags & wxHTML_CLR_TRANSPARENT_BACKGROUND)
1568 {
1569 state.SetBgColour(m_Colour);
1570 state.SetBgMode(wxTRANSPARENT);
1571 const wxColour c = state.GetSelectionState() == wxHTML_SEL_IN
1572 ? info.GetStyle().GetSelectedTextBgColour(m_Colour)
1573 : m_Colour;
1574 dc.SetTextBackground(c);
1575 dc.SetBackgroundMode(wxTRANSPARENT);
1576 }
1577 }
1578
1579
1580
1581
1582 // ---------------------------------------------------------------------------
1583 // wxHtmlFontCell
1584 // ---------------------------------------------------------------------------
1585
1586 IMPLEMENT_ABSTRACT_CLASS(wxHtmlFontCell, wxHtmlCell)
1587
1588 void wxHtmlFontCell::Draw(wxDC& dc,
1589 int WXUNUSED(x), int WXUNUSED(y),
1590 int WXUNUSED(view_y1), int WXUNUSED(view_y2),
1591 wxHtmlRenderingInfo& WXUNUSED(info))
1592 {
1593 dc.SetFont(m_Font);
1594 }
1595
1596 void wxHtmlFontCell::DrawInvisible(wxDC& dc, int WXUNUSED(x), int WXUNUSED(y),
1597 wxHtmlRenderingInfo& WXUNUSED(info))
1598 {
1599 dc.SetFont(m_Font);
1600 }
1601
1602
1603
1604
1605
1606
1607
1608
1609 // ---------------------------------------------------------------------------
1610 // wxHtmlWidgetCell
1611 // ---------------------------------------------------------------------------
1612
1613 IMPLEMENT_ABSTRACT_CLASS(wxHtmlWidgetCell, wxHtmlCell)
1614
1615 wxHtmlWidgetCell::wxHtmlWidgetCell(wxWindow *wnd, int w)
1616 {
1617 int sx, sy;
1618 m_Wnd = wnd;
1619 m_Wnd->GetSize(&sx, &sy);
1620 m_Width = sx, m_Height = sy;
1621 m_WidthFloat = w;
1622 }
1623
1624
1625 void wxHtmlWidgetCell::Draw(wxDC& WXUNUSED(dc),
1626 int WXUNUSED(x), int WXUNUSED(y),
1627 int WXUNUSED(view_y1), int WXUNUSED(view_y2),
1628 wxHtmlRenderingInfo& WXUNUSED(info))
1629 {
1630 int absx = 0, absy = 0, stx, sty;
1631 wxHtmlCell *c = this;
1632
1633 while (c)
1634 {
1635 absx += c->GetPosX();
1636 absy += c->GetPosY();
1637 c = c->GetParent();
1638 }
1639
1640 wxScrolledWindow *scrolwin =
1641 wxDynamicCast(m_Wnd->GetParent(), wxScrolledWindow);
1642 wxCHECK_RET( scrolwin,
1643 wxT("widget cells can only be placed in wxHtmlWindow") );
1644
1645 scrolwin->GetViewStart(&stx, &sty);
1646 m_Wnd->SetSize(absx - wxHTML_SCROLL_STEP * stx,
1647 absy - wxHTML_SCROLL_STEP * sty,
1648 m_Width, m_Height);
1649 }
1650
1651
1652
1653 void wxHtmlWidgetCell::DrawInvisible(wxDC& WXUNUSED(dc),
1654 int WXUNUSED(x), int WXUNUSED(y),
1655 wxHtmlRenderingInfo& WXUNUSED(info))
1656 {
1657 int absx = 0, absy = 0, stx, sty;
1658 wxHtmlCell *c = this;
1659
1660 while (c)
1661 {
1662 absx += c->GetPosX();
1663 absy += c->GetPosY();
1664 c = c->GetParent();
1665 }
1666
1667 ((wxScrolledWindow*)(m_Wnd->GetParent()))->GetViewStart(&stx, &sty);
1668 m_Wnd->SetSize(absx - wxHTML_SCROLL_STEP * stx, absy - wxHTML_SCROLL_STEP * sty, m_Width, m_Height);
1669 }
1670
1671
1672
1673 void wxHtmlWidgetCell::Layout(int w)
1674 {
1675 if (m_WidthFloat != 0)
1676 {
1677 m_Width = (w * m_WidthFloat) / 100;
1678 m_Wnd->SetSize(m_Width, m_Height);
1679 }
1680
1681 wxHtmlCell::Layout(w);
1682 }
1683
1684
1685
1686 // ----------------------------------------------------------------------------
1687 // wxHtmlTerminalCellsInterator
1688 // ----------------------------------------------------------------------------
1689
1690 const wxHtmlCell* wxHtmlTerminalCellsInterator::operator++()
1691 {
1692 if ( !m_pos )
1693 return NULL;
1694
1695 do
1696 {
1697 if ( m_pos == m_to )
1698 {
1699 m_pos = NULL;
1700 return NULL;
1701 }
1702
1703 if ( m_pos->GetNext() )
1704 m_pos = m_pos->GetNext();
1705 else
1706 {
1707 // we must go up the hierarchy until we reach container where this
1708 // is not the last child, and then go down to first terminal cell:
1709 while ( m_pos->GetNext() == NULL )
1710 {
1711 m_pos = m_pos->GetParent();
1712 if ( !m_pos )
1713 return NULL;
1714 }
1715 m_pos = m_pos->GetNext();
1716 }
1717 while ( m_pos->GetFirstChild() != NULL )
1718 m_pos = m_pos->GetFirstChild();
1719 } while ( !m_pos->IsTerminalCell() );
1720
1721 return m_pos;
1722 }
1723
1724 #endif
wxWidgets (Impactor)