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


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