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