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


aad2aa3e57cc0e60e41b81c0c8d6f61bb285395c
[wxWidgets.git] / src / html / htmlwin.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: htmlwin.cpp
3 // Purpose: wxHtmlWindow class for parsing & displaying HTML (implementation)
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 #include "wx/defs.h"
13 #if wxUSE_HTML && wxUSE_STREAMS
14
15 #ifdef __BORLANDC__
16 #pragma hdrstop
17 #endif
18
19 #ifndef WXPRECOMP
20 #include "wx/log.h"
21 #include "wx/intl.h"
22 #include "wx/dcclient.h"
23 #include "wx/frame.h"
24 #endif
25
26 #include "wx/html/htmlwin.h"
27 #include "wx/html/htmlproc.h"
28 #include "wx/list.h"
29 #include "wx/clipbrd.h"
30 #include "wx/dataobj.h"
31 #include "wx/timer.h"
32 #include "wx/dcmemory.h"
33 #include "wx/settings.h"
34
35 #include "wx/arrimpl.cpp"
36 #include "wx/listimpl.cpp"
37
38
39 #if wxUSE_CLIPBOARD
40 // ----------------------------------------------------------------------------
41 // wxHtmlWinAutoScrollTimer: the timer used to generate a stream of scroll
42 // events when a captured mouse is held outside the window
43 // ----------------------------------------------------------------------------
44
45 class wxHtmlWinAutoScrollTimer : public wxTimer
46 {
47 public:
48 wxHtmlWinAutoScrollTimer(wxScrolledWindow *win,
49 wxEventType eventTypeToSend,
50 int pos, int orient)
51 {
52 m_win = win;
53 m_eventType = eventTypeToSend;
54 m_pos = pos;
55 m_orient = orient;
56 }
57
58 virtual void Notify();
59
60 private:
61 wxScrolledWindow *m_win;
62 wxEventType m_eventType;
63 int m_pos,
64 m_orient;
65
66 DECLARE_NO_COPY_CLASS(wxHtmlWinAutoScrollTimer)
67 };
68
69 void wxHtmlWinAutoScrollTimer::Notify()
70 {
71 // only do all this as long as the window is capturing the mouse
72 if ( wxWindow::GetCapture() != m_win )
73 {
74 Stop();
75 }
76 else // we still capture the mouse, continue generating events
77 {
78 // first scroll the window if we are allowed to do it
79 wxScrollWinEvent event1(m_eventType, m_pos, m_orient);
80 event1.SetEventObject(m_win);
81 if ( m_win->GetEventHandler()->ProcessEvent(event1) )
82 {
83 // and then send a pseudo mouse-move event to refresh the selection
84 wxMouseEvent event2(wxEVT_MOTION);
85 wxGetMousePosition(&event2.m_x, &event2.m_y);
86
87 // the mouse event coordinates should be client, not screen as
88 // returned by wxGetMousePosition
89 wxWindow *parentTop = m_win;
90 while ( parentTop->GetParent() )
91 parentTop = parentTop->GetParent();
92 wxPoint ptOrig = parentTop->GetPosition();
93 event2.m_x -= ptOrig.x;
94 event2.m_y -= ptOrig.y;
95
96 event2.SetEventObject(m_win);
97
98 // FIXME: we don't fill in the other members - ok?
99 m_win->GetEventHandler()->ProcessEvent(event2);
100 }
101 else // can't scroll further, stop
102 {
103 Stop();
104 }
105 }
106 }
107
108 #endif // wxUSE_CLIPBOARD
109
110
111
112 //-----------------------------------------------------------------------------
113 // wxHtmlHistoryItem
114 //-----------------------------------------------------------------------------
115
116 // item of history list
117 class WXDLLIMPEXP_HTML wxHtmlHistoryItem
118 {
119 public:
120 wxHtmlHistoryItem(const wxString& p, const wxString& a) {m_Page = p, m_Anchor = a, m_Pos = 0;}
121 int GetPos() const {return m_Pos;}
122 void SetPos(int p) {m_Pos = p;}
123 const wxString& GetPage() const {return m_Page;}
124 const wxString& GetAnchor() const {return m_Anchor;}
125
126 private:
127 wxString m_Page;
128 wxString m_Anchor;
129 int m_Pos;
130 };
131
132
133 //-----------------------------------------------------------------------------
134 // our private arrays:
135 //-----------------------------------------------------------------------------
136
137 WX_DECLARE_OBJARRAY(wxHtmlHistoryItem, wxHtmlHistoryArray);
138 WX_DEFINE_OBJARRAY(wxHtmlHistoryArray)
139
140 WX_DECLARE_LIST(wxHtmlProcessor, wxHtmlProcessorList);
141 WX_DEFINE_LIST(wxHtmlProcessorList)
142
143 //-----------------------------------------------------------------------------
144 // wxHtmlWindowMouseHelper
145 //-----------------------------------------------------------------------------
146
147 wxHtmlWindowMouseHelper::wxHtmlWindowMouseHelper(wxHtmlWindowInterface *iface)
148 : m_tmpMouseMoved(false),
149 m_tmpLastLink(NULL),
150 m_tmpLastCell(NULL),
151 m_interface(iface)
152 {
153 }
154
155 void wxHtmlWindowMouseHelper::HandleMouseMoved()
156 {
157 m_tmpMouseMoved = true;
158 }
159
160 bool wxHtmlWindowMouseHelper::HandleMouseClick(wxHtmlCell *rootCell,
161 const wxPoint& pos,
162 const wxMouseEvent& event)
163 {
164 if (!rootCell)
165 return false;
166
167 wxHtmlCell *cell = rootCell->FindCellByPos(pos.x, pos.y);
168 // this check is needed because FindCellByPos returns terminal cell and
169 // containers may have empty borders -- in this case NULL will be
170 // returned
171 if (!cell)
172 return false;
173
174 // adjust the coordinates to be relative to this cell:
175 wxPoint relpos = pos - cell->GetAbsPos(rootCell);
176
177 return OnCellClicked(cell, relpos.x, relpos.y, event);
178 }
179
180 void wxHtmlWindowMouseHelper::HandleIdle(wxHtmlCell *rootCell,
181 const wxPoint& pos)
182 {
183 wxHtmlCell *cell = rootCell ? rootCell->FindCellByPos(pos.x, pos.y) : NULL;
184
185 if (cell != m_tmpLastCell)
186 {
187 wxHtmlLinkInfo *lnk = NULL;
188 if (cell)
189 {
190 // adjust the coordinates to be relative to this cell:
191 wxPoint relpos = pos - cell->GetAbsPos(rootCell);
192 lnk = cell->GetLink(relpos.x, relpos.y);
193 }
194
195 wxCursor cur;
196 if (cell)
197 cur = cell->GetMouseCursor(m_interface);
198 else
199 cur = m_interface->GetHTMLCursor(
200 wxHtmlWindowInterface::HTMLCursor_Default);
201
202 m_interface->GetHTMLWindow()->SetCursor(cur);
203
204 if (lnk != m_tmpLastLink)
205 {
206 if (lnk)
207 m_interface->SetHTMLStatusText(lnk->GetHref());
208 else
209 m_interface->SetHTMLStatusText(wxEmptyString);
210
211 m_tmpLastLink = lnk;
212 }
213
214 m_tmpLastCell = cell;
215 }
216 else // mouse moved but stayed in the same cell
217 {
218 if ( cell )
219 {
220 OnCellMouseHover(cell, pos.x, pos.y);
221 }
222 }
223
224 m_tmpMouseMoved = false;
225 }
226
227 bool wxHtmlWindowMouseHelper::OnCellClicked(wxHtmlCell *cell,
228 wxCoord x, wxCoord y,
229 const wxMouseEvent& event)
230 {
231 wxCHECK_MSG( cell, false, _T("can't be called with NULL cell") );
232
233 return cell->ProcessMouseClick(m_interface, wxPoint(x, y), event);
234 }
235
236 void wxHtmlWindowMouseHelper::OnCellMouseHover(wxHtmlCell * WXUNUSED(cell),
237 wxCoord WXUNUSED(x),
238 wxCoord WXUNUSED(y))
239 {
240 // do nothing here
241 }
242
243 //-----------------------------------------------------------------------------
244 // wxHtmlWindow
245 //-----------------------------------------------------------------------------
246
247 wxList wxHtmlWindow::m_Filters;
248 wxHtmlFilter *wxHtmlWindow::m_DefaultFilter = NULL;
249 wxHtmlProcessorList *wxHtmlWindow::m_GlobalProcessors = NULL;
250 wxCursor *wxHtmlWindow::ms_cursorLink = NULL;
251 wxCursor *wxHtmlWindow::ms_cursorText = NULL;
252
253 void wxHtmlWindow::CleanUpStatics()
254 {
255 wxDELETE(m_DefaultFilter);
256 WX_CLEAR_LIST(wxList, m_Filters);
257 if (m_GlobalProcessors)
258 WX_CLEAR_LIST(wxHtmlProcessorList, *m_GlobalProcessors);
259 wxDELETE(m_GlobalProcessors);
260 wxDELETE(ms_cursorLink);
261 wxDELETE(ms_cursorText);
262 }
263
264 void wxHtmlWindow::Init()
265 {
266 m_tmpCanDrawLocks = 0;
267 m_FS = new wxFileSystem();
268 #if wxUSE_STATUSBAR
269 m_RelatedStatusBar = -1;
270 #endif // wxUSE_STATUSBAR
271 m_RelatedFrame = NULL;
272 m_TitleFormat = wxT("%s");
273 m_OpenedPage = m_OpenedAnchor = m_OpenedPageTitle = wxEmptyString;
274 m_Cell = NULL;
275 m_Parser = new wxHtmlWinParser(this);
276 m_Parser->SetFS(m_FS);
277 m_HistoryPos = -1;
278 m_HistoryOn = true;
279 m_History = new wxHtmlHistoryArray;
280 m_Processors = NULL;
281 m_Style = 0;
282 SetBorders(10);
283 m_selection = NULL;
284 m_makingSelection = false;
285 #if wxUSE_CLIPBOARD
286 m_timerAutoScroll = NULL;
287 m_lastDoubleClick = 0;
288 #endif // wxUSE_CLIPBOARD
289 m_backBuffer = NULL;
290 m_eraseBgInOnPaint = false;
291 m_tmpSelFromCell = NULL;
292 }
293
294 bool wxHtmlWindow::Create(wxWindow *parent, wxWindowID id,
295 const wxPoint& pos, const wxSize& size,
296 long style, const wxString& name)
297 {
298 if (!wxScrolledWindow::Create(parent, id, pos, size,
299 style | wxVSCROLL | wxHSCROLL,
300 name))
301 return false;
302
303 m_Style = style;
304 SetPage(wxT("<html><body></body></html>"));
305 return true;
306 }
307
308
309 wxHtmlWindow::~wxHtmlWindow()
310 {
311 #if wxUSE_CLIPBOARD
312 StopAutoScrolling();
313 #endif // wxUSE_CLIPBOARD
314 HistoryClear();
315
316 delete m_selection;
317
318 delete m_Cell;
319
320 if ( m_Processors )
321 {
322 WX_CLEAR_LIST(wxHtmlProcessorList, *m_Processors);
323 }
324
325 delete m_Parser;
326 delete m_FS;
327 delete m_History;
328 delete m_Processors;
329 delete m_backBuffer;
330 }
331
332
333
334 void wxHtmlWindow::SetRelatedFrame(wxFrame* frame, const wxString& format)
335 {
336 m_RelatedFrame = frame;
337 m_TitleFormat = format;
338 }
339
340
341
342 #if wxUSE_STATUSBAR
343 void wxHtmlWindow::SetRelatedStatusBar(int bar)
344 {
345 m_RelatedStatusBar = bar;
346 }
347 #endif // wxUSE_STATUSBAR
348
349
350
351 void wxHtmlWindow::SetFonts(const wxString& normal_face, const wxString& fixed_face, const int *sizes)
352 {
353 m_Parser->SetFonts(normal_face, fixed_face, sizes);
354
355 // re-layout the page after changing fonts:
356 DoSetPage(*(m_Parser->GetSource()));
357 }
358
359 void wxHtmlWindow::SetStandardFonts(int size,
360 const wxString& normal_face,
361 const wxString& fixed_face)
362 {
363 m_Parser->SetStandardFonts(size, normal_face, fixed_face);
364
365 // re-layout the page after changing fonts:
366 DoSetPage(*(m_Parser->GetSource()));
367 }
368
369 bool wxHtmlWindow::SetPage(const wxString& source)
370 {
371 m_OpenedPage = m_OpenedAnchor = m_OpenedPageTitle = wxEmptyString;
372 return DoSetPage(source);
373 }
374
375 bool wxHtmlWindow::DoSetPage(const wxString& source)
376 {
377 wxString newsrc(source);
378
379 wxDELETE(m_selection);
380
381 // we will soon delete all the cells, so clear pointers to them:
382 m_tmpSelFromCell = NULL;
383
384 // pass HTML through registered processors:
385 if (m_Processors || m_GlobalProcessors)
386 {
387 wxHtmlProcessorList::compatibility_iterator nodeL, nodeG;
388 int prL, prG;
389
390 if ( m_Processors )
391 nodeL = m_Processors->GetFirst();
392 if ( m_GlobalProcessors )
393 nodeG = m_GlobalProcessors->GetFirst();
394
395 // VS: there are two lists, global and local, both of them sorted by
396 // priority. Since we have to go through _both_ lists with
397 // decreasing priority, we "merge-sort" the lists on-line by
398 // processing that one of the two heads that has higher priority
399 // in every iteration
400 while (nodeL || nodeG)
401 {
402 prL = (nodeL) ? nodeL->GetData()->GetPriority() : -1;
403 prG = (nodeG) ? nodeG->GetData()->GetPriority() : -1;
404 if (prL > prG)
405 {
406 if (nodeL->GetData()->IsEnabled())
407 newsrc = nodeL->GetData()->Process(newsrc);
408 nodeL = nodeL->GetNext();
409 }
410 else // prL <= prG
411 {
412 if (nodeG->GetData()->IsEnabled())
413 newsrc = nodeG->GetData()->Process(newsrc);
414 nodeG = nodeG->GetNext();
415 }
416 }
417 }
418
419 // ...and run the parser on it:
420 wxClientDC *dc = new wxClientDC(this);
421 dc->SetMapMode(wxMM_TEXT);
422 SetBackgroundColour(wxColour(0xFF, 0xFF, 0xFF));
423 SetBackgroundImage(wxNullBitmap);
424
425 m_Parser->SetDC(dc);
426 if (m_Cell)
427 {
428 delete m_Cell;
429 m_Cell = NULL;
430 }
431 m_Cell = (wxHtmlContainerCell*) m_Parser->Parse(newsrc);
432 delete dc;
433 m_Cell->SetIndent(m_Borders, wxHTML_INDENT_ALL, wxHTML_UNITS_PIXELS);
434 m_Cell->SetAlignHor(wxHTML_ALIGN_CENTER);
435 CreateLayout();
436 if (m_tmpCanDrawLocks == 0)
437 Refresh();
438 return true;
439 }
440
441 bool wxHtmlWindow::AppendToPage(const wxString& source)
442 {
443 return DoSetPage(*(GetParser()->GetSource()) + source);
444 }
445
446 bool wxHtmlWindow::LoadPage(const wxString& location)
447 {
448 wxBusyCursor busyCursor;
449
450 wxFSFile *f;
451 bool rt_val;
452 bool needs_refresh = false;
453
454 m_tmpCanDrawLocks++;
455 if (m_HistoryOn && (m_HistoryPos != -1))
456 {
457 // store scroll position into history item:
458 int x, y;
459 GetViewStart(&x, &y);
460 (*m_History)[m_HistoryPos].SetPos(y);
461 }
462
463 if (location[0] == wxT('#'))
464 {
465 // local anchor:
466 wxString anch = location.Mid(1) /*1 to end*/;
467 m_tmpCanDrawLocks--;
468 rt_val = ScrollToAnchor(anch);
469 m_tmpCanDrawLocks++;
470 }
471 else if (location.Find(wxT('#')) != wxNOT_FOUND && location.BeforeFirst(wxT('#')) == m_OpenedPage)
472 {
473 wxString anch = location.AfterFirst(wxT('#'));
474 m_tmpCanDrawLocks--;
475 rt_val = ScrollToAnchor(anch);
476 m_tmpCanDrawLocks++;
477 }
478 else if (location.Find(wxT('#')) != wxNOT_FOUND &&
479 (m_FS->GetPath() + location.BeforeFirst(wxT('#'))) == m_OpenedPage)
480 {
481 wxString anch = location.AfterFirst(wxT('#'));
482 m_tmpCanDrawLocks--;
483 rt_val = ScrollToAnchor(anch);
484 m_tmpCanDrawLocks++;
485 }
486
487 else
488 {
489 needs_refresh = true;
490 #if wxUSE_STATUSBAR
491 // load&display it:
492 if (m_RelatedStatusBar != -1)
493 {
494 m_RelatedFrame->SetStatusText(_("Connecting..."), m_RelatedStatusBar);
495 Refresh(false);
496 }
497 #endif // wxUSE_STATUSBAR
498
499 f = m_Parser->OpenURL(wxHTML_URL_PAGE, location);
500
501 // try to interpret 'location' as filename instead of URL:
502 if (f == NULL)
503 {
504 wxFileName fn(location);
505 wxString location2 = wxFileSystem::FileNameToURL(fn);
506 f = m_Parser->OpenURL(wxHTML_URL_PAGE, location2);
507 }
508
509 if (f == NULL)
510 {
511 wxLogError(_("Unable to open requested HTML document: %s"), location.c_str());
512 m_tmpCanDrawLocks--;
513 return false;
514 }
515
516 else
517 {
518 wxList::compatibility_iterator node;
519 wxString src = wxEmptyString;
520
521 #if wxUSE_STATUSBAR
522 if (m_RelatedStatusBar != -1)
523 {
524 wxString msg = _("Loading : ") + location;
525 m_RelatedFrame->SetStatusText(msg, m_RelatedStatusBar);
526 Refresh(false);
527 }
528 #endif // wxUSE_STATUSBAR
529
530 node = m_Filters.GetFirst();
531 while (node)
532 {
533 wxHtmlFilter *h = (wxHtmlFilter*) node->GetData();
534 if (h->CanRead(*f))
535 {
536 src = h->ReadFile(*f);
537 break;
538 }
539 node = node->GetNext();
540 }
541 if (src == wxEmptyString)
542 {
543 if (m_DefaultFilter == NULL) m_DefaultFilter = GetDefaultFilter();
544 src = m_DefaultFilter->ReadFile(*f);
545 }
546
547 m_FS->ChangePathTo(f->GetLocation());
548 rt_val = SetPage(src);
549 m_OpenedPage = f->GetLocation();
550 if (f->GetAnchor() != wxEmptyString)
551 {
552 ScrollToAnchor(f->GetAnchor());
553 }
554
555 delete f;
556
557 #if wxUSE_STATUSBAR
558 if (m_RelatedStatusBar != -1)
559 m_RelatedFrame->SetStatusText(_("Done"), m_RelatedStatusBar);
560 #endif // wxUSE_STATUSBAR
561 }
562 }
563
564 if (m_HistoryOn) // add this page to history there:
565 {
566 int c = m_History->GetCount() - (m_HistoryPos + 1);
567
568 if (m_HistoryPos < 0 ||
569 (*m_History)[m_HistoryPos].GetPage() != m_OpenedPage ||
570 (*m_History)[m_HistoryPos].GetAnchor() != m_OpenedAnchor)
571 {
572 m_HistoryPos++;
573 for (int i = 0; i < c; i++)
574 m_History->RemoveAt(m_HistoryPos);
575 m_History->Add(new wxHtmlHistoryItem(m_OpenedPage, m_OpenedAnchor));
576 }
577 }
578
579 if (m_OpenedPageTitle == wxEmptyString)
580 OnSetTitle(wxFileNameFromPath(m_OpenedPage));
581
582 if (needs_refresh)
583 {
584 m_tmpCanDrawLocks--;
585 Refresh();
586 }
587 else
588 m_tmpCanDrawLocks--;
589
590 return rt_val;
591 }
592
593
594 bool wxHtmlWindow::LoadFile(const wxFileName& filename)
595 {
596 wxString url = wxFileSystem::FileNameToURL(filename);
597 return LoadPage(url);
598 }
599
600
601 bool wxHtmlWindow::ScrollToAnchor(const wxString& anchor)
602 {
603 const wxHtmlCell *c = m_Cell->Find(wxHTML_COND_ISANCHOR, &anchor);
604 if (!c)
605 {
606 wxLogWarning(_("HTML anchor %s does not exist."), anchor.c_str());
607 return false;
608 }
609 else
610 {
611 int y;
612
613 for (y = 0; c != NULL; c = c->GetParent()) y += c->GetPosY();
614 Scroll(-1, y / wxHTML_SCROLL_STEP);
615 m_OpenedAnchor = anchor;
616 return true;
617 }
618 }
619
620
621 void wxHtmlWindow::OnSetTitle(const wxString& title)
622 {
623 if (m_RelatedFrame)
624 {
625 wxString tit;
626 tit.Printf(m_TitleFormat, title.c_str());
627 m_RelatedFrame->SetTitle(tit);
628 }
629 m_OpenedPageTitle = title;
630 }
631
632
633
634
635
636 void wxHtmlWindow::CreateLayout()
637 {
638 int ClientWidth, ClientHeight;
639
640 if (!m_Cell) return;
641
642 if (m_Style & wxHW_SCROLLBAR_NEVER)
643 {
644 SetScrollbars(wxHTML_SCROLL_STEP, 1, m_Cell->GetWidth() / wxHTML_SCROLL_STEP, 0); // always off
645 GetClientSize(&ClientWidth, &ClientHeight);
646 m_Cell->Layout(ClientWidth);
647 }
648
649 else {
650 GetClientSize(&ClientWidth, &ClientHeight);
651 m_Cell->Layout(ClientWidth);
652 if (ClientHeight < m_Cell->GetHeight() + GetCharHeight())
653 {
654 SetScrollbars(
655 wxHTML_SCROLL_STEP, wxHTML_SCROLL_STEP,
656 m_Cell->GetWidth() / wxHTML_SCROLL_STEP,
657 (m_Cell->GetHeight() + GetCharHeight()) / wxHTML_SCROLL_STEP
658 /*cheat: top-level frag is always container*/);
659 }
660 else /* we fit into window, no need for scrollbars */
661 {
662 SetScrollbars(wxHTML_SCROLL_STEP, 1, m_Cell->GetWidth() / wxHTML_SCROLL_STEP, 0); // disable...
663 GetClientSize(&ClientWidth, &ClientHeight);
664 m_Cell->Layout(ClientWidth); // ...and relayout
665 }
666 }
667 }
668
669
670
671 void wxHtmlWindow::ReadCustomization(wxConfigBase *cfg, wxString path)
672 {
673 wxString oldpath;
674 wxString tmp;
675 int p_fontsizes[7];
676 wxString p_fff, p_ffn;
677
678 if (path != wxEmptyString)
679 {
680 oldpath = cfg->GetPath();
681 cfg->SetPath(path);
682 }
683
684 m_Borders = cfg->Read(wxT("wxHtmlWindow/Borders"), m_Borders);
685 p_fff = cfg->Read(wxT("wxHtmlWindow/FontFaceFixed"), m_Parser->m_FontFaceFixed);
686 p_ffn = cfg->Read(wxT("wxHtmlWindow/FontFaceNormal"), m_Parser->m_FontFaceNormal);
687 for (int i = 0; i < 7; i++)
688 {
689 tmp.Printf(wxT("wxHtmlWindow/FontsSize%i"), i);
690 p_fontsizes[i] = cfg->Read(tmp, m_Parser->m_FontsSizes[i]);
691 }
692 SetFonts(p_ffn, p_fff, p_fontsizes);
693
694 if (path != wxEmptyString)
695 cfg->SetPath(oldpath);
696 }
697
698
699
700 void wxHtmlWindow::WriteCustomization(wxConfigBase *cfg, wxString path)
701 {
702 wxString oldpath;
703 wxString tmp;
704
705 if (path != wxEmptyString)
706 {
707 oldpath = cfg->GetPath();
708 cfg->SetPath(path);
709 }
710
711 cfg->Write(wxT("wxHtmlWindow/Borders"), (long) m_Borders);
712 cfg->Write(wxT("wxHtmlWindow/FontFaceFixed"), m_Parser->m_FontFaceFixed);
713 cfg->Write(wxT("wxHtmlWindow/FontFaceNormal"), m_Parser->m_FontFaceNormal);
714 for (int i = 0; i < 7; i++)
715 {
716 tmp.Printf(wxT("wxHtmlWindow/FontsSize%i"), i);
717 cfg->Write(tmp, (long) m_Parser->m_FontsSizes[i]);
718 }
719
720 if (path != wxEmptyString)
721 cfg->SetPath(oldpath);
722 }
723
724
725
726 bool wxHtmlWindow::HistoryBack()
727 {
728 wxString a, l;
729
730 if (m_HistoryPos < 1) return false;
731
732 // store scroll position into history item:
733 int x, y;
734 GetViewStart(&x, &y);
735 (*m_History)[m_HistoryPos].SetPos(y);
736
737 // go to previous position:
738 m_HistoryPos--;
739
740 l = (*m_History)[m_HistoryPos].GetPage();
741 a = (*m_History)[m_HistoryPos].GetAnchor();
742 m_HistoryOn = false;
743 m_tmpCanDrawLocks++;
744 if (a == wxEmptyString) LoadPage(l);
745 else LoadPage(l + wxT("#") + a);
746 m_HistoryOn = true;
747 m_tmpCanDrawLocks--;
748 Scroll(0, (*m_History)[m_HistoryPos].GetPos());
749 Refresh();
750 return true;
751 }
752
753 bool wxHtmlWindow::HistoryCanBack()
754 {
755 if (m_HistoryPos < 1) return false;
756 return true ;
757 }
758
759
760 bool wxHtmlWindow::HistoryForward()
761 {
762 wxString a, l;
763
764 if (m_HistoryPos == -1) return false;
765 if (m_HistoryPos >= (int)m_History->GetCount() - 1)return false;
766
767 m_OpenedPage = wxEmptyString; // this will disable adding new entry into history in LoadPage()
768
769 m_HistoryPos++;
770 l = (*m_History)[m_HistoryPos].GetPage();
771 a = (*m_History)[m_HistoryPos].GetAnchor();
772 m_HistoryOn = false;
773 m_tmpCanDrawLocks++;
774 if (a == wxEmptyString) LoadPage(l);
775 else LoadPage(l + wxT("#") + a);
776 m_HistoryOn = true;
777 m_tmpCanDrawLocks--;
778 Scroll(0, (*m_History)[m_HistoryPos].GetPos());
779 Refresh();
780 return true;
781 }
782
783 bool wxHtmlWindow::HistoryCanForward()
784 {
785 if (m_HistoryPos == -1) return false;
786 if (m_HistoryPos >= (int)m_History->GetCount() - 1)return false;
787 return true ;
788 }
789
790
791 void wxHtmlWindow::HistoryClear()
792 {
793 m_History->Empty();
794 m_HistoryPos = -1;
795 }
796
797 void wxHtmlWindow::AddProcessor(wxHtmlProcessor *processor)
798 {
799 if (!m_Processors)
800 {
801 m_Processors = new wxHtmlProcessorList;
802 }
803 wxHtmlProcessorList::compatibility_iterator node;
804
805 for (node = m_Processors->GetFirst(); node; node = node->GetNext())
806 {
807 if (processor->GetPriority() > node->GetData()->GetPriority())
808 {
809 m_Processors->Insert(node, processor);
810 return;
811 }
812 }
813 m_Processors->Append(processor);
814 }
815
816 /*static */ void wxHtmlWindow::AddGlobalProcessor(wxHtmlProcessor *processor)
817 {
818 if (!m_GlobalProcessors)
819 {
820 m_GlobalProcessors = new wxHtmlProcessorList;
821 }
822 wxHtmlProcessorList::compatibility_iterator node;
823
824 for (node = m_GlobalProcessors->GetFirst(); node; node = node->GetNext())
825 {
826 if (processor->GetPriority() > node->GetData()->GetPriority())
827 {
828 m_GlobalProcessors->Insert(node, processor);
829 return;
830 }
831 }
832 m_GlobalProcessors->Append(processor);
833 }
834
835
836
837 void wxHtmlWindow::AddFilter(wxHtmlFilter *filter)
838 {
839 m_Filters.Append(filter);
840 }
841
842
843 bool wxHtmlWindow::IsSelectionEnabled() const
844 {
845 #if wxUSE_CLIPBOARD
846 return !(m_Style & wxHW_NO_SELECTION);
847 #else
848 return false;
849 #endif
850 }
851
852
853 #if wxUSE_CLIPBOARD
854 wxString wxHtmlWindow::DoSelectionToText(wxHtmlSelection *sel)
855 {
856 if ( !sel )
857 return wxEmptyString;
858
859 wxClientDC dc(this);
860
861 const wxHtmlCell *end = sel->GetToCell();
862 wxString text;
863 wxHtmlTerminalCellsInterator i(sel->GetFromCell(), end);
864 if ( i )
865 {
866 text << i->ConvertToText(sel);
867 ++i;
868 }
869 const wxHtmlCell *prev = *i;
870 while ( i )
871 {
872 if ( prev->GetParent() != i->GetParent() )
873 text << _T('\n');
874 text << i->ConvertToText(*i == end ? sel : NULL);
875 prev = *i;
876 ++i;
877 }
878 return text;
879 }
880
881 wxString wxHtmlWindow::ToText()
882 {
883 if (m_Cell)
884 {
885 wxHtmlSelection sel;
886 sel.Set(m_Cell->GetFirstTerminal(), m_Cell->GetLastTerminal());
887 return DoSelectionToText(&sel);
888 }
889 else
890 return wxEmptyString;
891 }
892
893 #endif // wxUSE_CLIPBOARD
894
895 bool wxHtmlWindow::CopySelection(ClipboardType t)
896 {
897 #if wxUSE_CLIPBOARD
898 if ( m_selection )
899 {
900 #if defined(__UNIX__) && !defined(__WXMAC__)
901 wxTheClipboard->UsePrimarySelection(t == Primary);
902 #else // !__UNIX__
903 // Primary selection exists only under X11, so don't do anything under
904 // the other platforms when we try to access it
905 //
906 // TODO: this should be abstracted at wxClipboard level!
907 if ( t == Primary )
908 return false;
909 #endif // __UNIX__/!__UNIX__
910
911 if ( wxTheClipboard->Open() )
912 {
913 const wxString txt(SelectionToText());
914 wxTheClipboard->SetData(new wxTextDataObject(txt));
915 wxTheClipboard->Close();
916 wxLogTrace(_T("wxhtmlselection"),
917 _("Copied to clipboard:\"%s\""), txt.c_str());
918
919 return true;
920 }
921 }
922 #else
923 wxUnusedVar(t);
924 #endif // wxUSE_CLIPBOARD
925
926 return false;
927 }
928
929
930 void wxHtmlWindow::OnLinkClicked(const wxHtmlLinkInfo& link)
931 {
932 const wxMouseEvent *e = link.GetEvent();
933 if (e == NULL || e->LeftUp())
934 LoadPage(link.GetHref());
935 }
936
937 void wxHtmlWindow::OnEraseBackground(wxEraseEvent& event)
938 {
939 if ( !m_bmpBg.Ok() )
940 {
941 // don't even skip the event, if we don't have a bg bitmap we're going
942 // to overwrite background in OnPaint() below anyhow, so letting the
943 // default handling take place would only result in flicker, just set a
944 // flag to erase the background below
945 m_eraseBgInOnPaint = true;
946 return;
947 }
948
949 wxDC& dc = *event.GetDC();
950
951 // if the image is not fully opaque, we have to erase the background before
952 // drawing it, however avoid doing it for opaque images as this would just
953 // result in extra flicker without any other effect as background is
954 // completely covered anyhow
955 if ( m_bmpBg.GetMask() )
956 {
957 dc.SetBackground(wxBrush(GetBackgroundColour(), wxSOLID));
958 dc.Clear();
959 }
960
961 const wxSize sizeWin(GetClientSize());
962 const wxSize sizeBmp(m_bmpBg.GetWidth(), m_bmpBg.GetHeight());
963 for ( wxCoord x = 0; x < sizeWin.x; x += sizeBmp.x )
964 {
965 for ( wxCoord y = 0; y < sizeWin.y; y += sizeBmp.y )
966 {
967 dc.DrawBitmap(m_bmpBg, x, y, true /* use mask */);
968 }
969 }
970 }
971
972 void wxHtmlWindow::OnPaint(wxPaintEvent& WXUNUSED(event))
973 {
974 wxPaintDC dc(this);
975
976 if (m_tmpCanDrawLocks > 0 || m_Cell == NULL)
977 return;
978
979 int x, y;
980 GetViewStart(&x, &y);
981 wxRect rect = GetUpdateRegion().GetBox();
982 wxSize sz = GetSize();
983
984 wxMemoryDC dcm;
985 if ( !m_backBuffer )
986 m_backBuffer = new wxBitmap(sz.x, sz.y);
987 dcm.SelectObject(*m_backBuffer);
988
989 if ( m_eraseBgInOnPaint )
990 {
991 dcm.SetBackground(wxBrush(GetBackgroundColour(), wxSOLID));
992 dcm.Clear();
993
994 m_eraseBgInOnPaint = false;
995 }
996 else // someone has already erased the background, keep it
997 {
998 // preserve the existing background, otherwise we'd erase anything the
999 // user code had drawn in its EVT_ERASE_BACKGROUND handler when we do
1000 // the Blit back below
1001 dcm.Blit(0, rect.GetTop(),
1002 sz.x, rect.GetBottom() - rect.GetTop() + 1,
1003 &dc,
1004 0, rect.GetTop());
1005 }
1006
1007 PrepareDC(dcm);
1008 dcm.SetMapMode(wxMM_TEXT);
1009 dcm.SetBackgroundMode(wxTRANSPARENT);
1010
1011 wxHtmlRenderingInfo rinfo;
1012 wxDefaultHtmlRenderingStyle rstyle;
1013 rinfo.SetSelection(m_selection);
1014 rinfo.SetStyle(&rstyle);
1015 m_Cell->Draw(dcm, 0, 0,
1016 y * wxHTML_SCROLL_STEP + rect.GetTop(),
1017 y * wxHTML_SCROLL_STEP + rect.GetBottom(),
1018 rinfo);
1019
1020 //#define DEBUG_HTML_SELECTION
1021 #ifdef DEBUG_HTML_SELECTION
1022 {
1023 int xc, yc, x, y;
1024 wxGetMousePosition(&xc, &yc);
1025 ScreenToClient(&xc, &yc);
1026 CalcUnscrolledPosition(xc, yc, &x, &y);
1027 wxHtmlCell *at = m_Cell->FindCellByPos(x, y);
1028 wxHtmlCell *before =
1029 m_Cell->FindCellByPos(x, y, wxHTML_FIND_NEAREST_BEFORE);
1030 wxHtmlCell *after =
1031 m_Cell->FindCellByPos(x, y, wxHTML_FIND_NEAREST_AFTER);
1032
1033 dcm.SetBrush(*wxTRANSPARENT_BRUSH);
1034 dcm.SetPen(*wxBLACK_PEN);
1035 if (at)
1036 dcm.DrawRectangle(at->GetAbsPos(),
1037 wxSize(at->GetWidth(),at->GetHeight()));
1038 dcm.SetPen(*wxGREEN_PEN);
1039 if (before)
1040 dcm.DrawRectangle(before->GetAbsPos().x+1, before->GetAbsPos().y+1,
1041 before->GetWidth()-2,before->GetHeight()-2);
1042 dcm.SetPen(*wxRED_PEN);
1043 if (after)
1044 dcm.DrawRectangle(after->GetAbsPos().x+2, after->GetAbsPos().y+2,
1045 after->GetWidth()-4,after->GetHeight()-4);
1046 }
1047 #endif
1048
1049 dcm.SetDeviceOrigin(0,0);
1050 dc.Blit(0, rect.GetTop(),
1051 sz.x, rect.GetBottom() - rect.GetTop() + 1,
1052 &dcm,
1053 0, rect.GetTop());
1054 }
1055
1056
1057
1058
1059 void wxHtmlWindow::OnSize(wxSizeEvent& event)
1060 {
1061 wxDELETE(m_backBuffer);
1062
1063 wxScrolledWindow::OnSize(event);
1064 CreateLayout();
1065
1066 // Recompute selection if necessary:
1067 if ( m_selection )
1068 {
1069 m_selection->Set(m_selection->GetFromCell(),
1070 m_selection->GetToCell());
1071 m_selection->ClearPrivPos();
1072 }
1073
1074 Refresh();
1075 }
1076
1077
1078 void wxHtmlWindow::OnMouseMove(wxMouseEvent& WXUNUSED(event))
1079 {
1080 wxHtmlWindowMouseHelper::HandleMouseMoved();
1081 }
1082
1083 void wxHtmlWindow::OnMouseDown(wxMouseEvent& event)
1084 {
1085 #if wxUSE_CLIPBOARD
1086 if ( event.LeftDown() && IsSelectionEnabled() )
1087 {
1088 const long TRIPLECLICK_LEN = 200; // 0.2 sec after doubleclick
1089 if ( wxGetLocalTimeMillis() - m_lastDoubleClick <= TRIPLECLICK_LEN )
1090 {
1091 SelectLine(CalcUnscrolledPosition(event.GetPosition()));
1092
1093 (void) CopySelection();
1094 }
1095 else
1096 {
1097 m_makingSelection = true;
1098
1099 if ( m_selection )
1100 {
1101 wxDELETE(m_selection);
1102 Refresh();
1103 }
1104 m_tmpSelFromPos = CalcUnscrolledPosition(event.GetPosition());
1105 m_tmpSelFromCell = NULL;
1106
1107 CaptureMouse();
1108 }
1109 }
1110 #else
1111 wxUnusedVar(event);
1112 #endif // wxUSE_CLIPBOARD
1113 }
1114
1115 void wxHtmlWindow::OnMouseUp(wxMouseEvent& event)
1116 {
1117 #if wxUSE_CLIPBOARD
1118 if ( m_makingSelection )
1119 {
1120 ReleaseMouse();
1121 m_makingSelection = false;
1122
1123 // did the user move the mouse far enough from starting point?
1124 if ( CopySelection(Primary) )
1125 {
1126 // we don't want mouse up event that ended selecting to be
1127 // handled as mouse click and e.g. follow hyperlink:
1128 return;
1129 }
1130 }
1131 #endif // wxUSE_CLIPBOARD
1132
1133 SetFocus();
1134
1135 wxPoint pos = CalcUnscrolledPosition(event.GetPosition());
1136 wxHtmlWindowMouseHelper::HandleMouseClick(m_Cell, pos, event);
1137 }
1138
1139
1140
1141 void wxHtmlWindow::OnInternalIdle()
1142 {
1143 wxWindow::OnInternalIdle();
1144
1145 if (m_Cell != NULL && DidMouseMove())
1146 {
1147 #ifdef DEBUG_HTML_SELECTION
1148 Refresh();
1149 #endif
1150 int xc, yc, x, y;
1151 wxGetMousePosition(&xc, &yc);
1152 ScreenToClient(&xc, &yc);
1153 CalcUnscrolledPosition(xc, yc, &x, &y);
1154
1155 wxHtmlCell *cell = m_Cell->FindCellByPos(x, y);
1156
1157 // handle selection update:
1158 if ( m_makingSelection )
1159 {
1160 if ( !m_tmpSelFromCell )
1161 m_tmpSelFromCell = m_Cell->FindCellByPos(
1162 m_tmpSelFromPos.x,m_tmpSelFromPos.y);
1163
1164 // NB: a trick - we adjust selFromPos to be upper left or bottom
1165 // right corner of the first cell of the selection depending
1166 // on whether the mouse is moving to the right or to the left.
1167 // This gives us more "natural" behaviour when selecting
1168 // a line (specifically, first cell of the next line is not
1169 // included if you drag selection from left to right over
1170 // entire line):
1171 wxPoint dirFromPos;
1172 if ( !m_tmpSelFromCell )
1173 {
1174 dirFromPos = m_tmpSelFromPos;
1175 }
1176 else
1177 {
1178 dirFromPos = m_tmpSelFromCell->GetAbsPos();
1179 if ( x < m_tmpSelFromPos.x )
1180 {
1181 dirFromPos.x += m_tmpSelFromCell->GetWidth();
1182 dirFromPos.y += m_tmpSelFromCell->GetHeight();
1183 }
1184 }
1185 bool goingDown = dirFromPos.y < y ||
1186 (dirFromPos.y == y && dirFromPos.x < x);
1187
1188 // determine selection span:
1189 if ( /*still*/ !m_tmpSelFromCell )
1190 {
1191 if (goingDown)
1192 {
1193 m_tmpSelFromCell = m_Cell->FindCellByPos(
1194 m_tmpSelFromPos.x,m_tmpSelFromPos.y,
1195 wxHTML_FIND_NEAREST_AFTER);
1196 if (!m_tmpSelFromCell)
1197 m_tmpSelFromCell = m_Cell->GetFirstTerminal();
1198 }
1199 else
1200 {
1201 m_tmpSelFromCell = m_Cell->FindCellByPos(
1202 m_tmpSelFromPos.x,m_tmpSelFromPos.y,
1203 wxHTML_FIND_NEAREST_BEFORE);
1204 if (!m_tmpSelFromCell)
1205 m_tmpSelFromCell = m_Cell->GetLastTerminal();
1206 }
1207 }
1208
1209 wxHtmlCell *selcell = cell;
1210 if (!selcell)
1211 {
1212 if (goingDown)
1213 {
1214 selcell = m_Cell->FindCellByPos(x, y,
1215 wxHTML_FIND_NEAREST_BEFORE);
1216 if (!selcell)
1217 selcell = m_Cell->GetLastTerminal();
1218 }
1219 else
1220 {
1221 selcell = m_Cell->FindCellByPos(x, y,
1222 wxHTML_FIND_NEAREST_AFTER);
1223 if (!selcell)
1224 selcell = m_Cell->GetFirstTerminal();
1225 }
1226 }
1227
1228 // NB: it may *rarely* happen that the code above didn't find one
1229 // of the cells, e.g. if wxHtmlWindow doesn't contain any
1230 // visible cells.
1231 if ( selcell && m_tmpSelFromCell )
1232 {
1233 if ( !m_selection )
1234 {
1235 // start selecting only if mouse movement was big enough
1236 // (otherwise it was meant as mouse click, not selection):
1237 const int PRECISION = 2;
1238 wxPoint diff = m_tmpSelFromPos - wxPoint(x,y);
1239 if (abs(diff.x) > PRECISION || abs(diff.y) > PRECISION)
1240 {
1241 m_selection = new wxHtmlSelection();
1242 }
1243 }
1244 if ( m_selection )
1245 {
1246 if ( m_tmpSelFromCell->IsBefore(selcell) )
1247 {
1248 m_selection->Set(m_tmpSelFromPos, m_tmpSelFromCell,
1249 wxPoint(x,y), selcell); }
1250 else
1251 {
1252 m_selection->Set(wxPoint(x,y), selcell,
1253 m_tmpSelFromPos, m_tmpSelFromCell);
1254 }
1255 m_selection->ClearPrivPos();
1256 Refresh();
1257 }
1258 }
1259 }
1260
1261 // handle cursor and status bar text changes:
1262
1263 // NB: because we're passing in 'cell' and not 'm_Cell' (so that the
1264 // leaf cell lookup isn't done twice), we need to adjust the
1265 // position for the new root:
1266 wxPoint posInCell(x, y);
1267 if (cell)
1268 posInCell -= cell->GetAbsPos();
1269 wxHtmlWindowMouseHelper::HandleIdle(cell, posInCell);
1270 }
1271 }
1272
1273 #if wxUSE_CLIPBOARD
1274 void wxHtmlWindow::StopAutoScrolling()
1275 {
1276 if ( m_timerAutoScroll )
1277 {
1278 wxDELETE(m_timerAutoScroll);
1279 }
1280 }
1281
1282 void wxHtmlWindow::OnMouseEnter(wxMouseEvent& event)
1283 {
1284 StopAutoScrolling();
1285 event.Skip();
1286 }
1287
1288 void wxHtmlWindow::OnMouseLeave(wxMouseEvent& event)
1289 {
1290 // don't prevent the usual processing of the event from taking place
1291 event.Skip();
1292
1293 // when a captured mouse leave a scrolled window we start generate
1294 // scrolling events to allow, for example, extending selection beyond the
1295 // visible area in some controls
1296 if ( wxWindow::GetCapture() == this )
1297 {
1298 // where is the mouse leaving?
1299 int pos, orient;
1300 wxPoint pt = event.GetPosition();
1301 if ( pt.x < 0 )
1302 {
1303 orient = wxHORIZONTAL;
1304 pos = 0;
1305 }
1306 else if ( pt.y < 0 )
1307 {
1308 orient = wxVERTICAL;
1309 pos = 0;
1310 }
1311 else // we're lower or to the right of the window
1312 {
1313 wxSize size = GetClientSize();
1314 if ( pt.x > size.x )
1315 {
1316 orient = wxHORIZONTAL;
1317 pos = GetVirtualSize().x / wxHTML_SCROLL_STEP;
1318 }
1319 else if ( pt.y > size.y )
1320 {
1321 orient = wxVERTICAL;
1322 pos = GetVirtualSize().y / wxHTML_SCROLL_STEP;
1323 }
1324 else // this should be impossible
1325 {
1326 // but seems to happen sometimes under wxMSW - maybe it's a bug
1327 // there but for now just ignore it
1328
1329 //wxFAIL_MSG( _T("can't understand where has mouse gone") );
1330
1331 return;
1332 }
1333 }
1334
1335 // only start the auto scroll timer if the window can be scrolled in
1336 // this direction
1337 if ( !HasScrollbar(orient) )
1338 return;
1339
1340 delete m_timerAutoScroll;
1341 m_timerAutoScroll = new wxHtmlWinAutoScrollTimer
1342 (
1343 this,
1344 pos == 0 ? wxEVT_SCROLLWIN_LINEUP
1345 : wxEVT_SCROLLWIN_LINEDOWN,
1346 pos,
1347 orient
1348 );
1349 m_timerAutoScroll->Start(50); // FIXME: make configurable
1350 }
1351 }
1352
1353 void wxHtmlWindow::OnKeyUp(wxKeyEvent& event)
1354 {
1355 if ( IsSelectionEnabled() && event.GetKeyCode() == 'C' && event.CmdDown() )
1356 {
1357 (void) CopySelection();
1358 }
1359 }
1360
1361 void wxHtmlWindow::OnCopy(wxCommandEvent& WXUNUSED(event))
1362 {
1363 (void) CopySelection();
1364 }
1365
1366 void wxHtmlWindow::OnDoubleClick(wxMouseEvent& event)
1367 {
1368 // select word under cursor:
1369 if ( IsSelectionEnabled() )
1370 {
1371 SelectWord(CalcUnscrolledPosition(event.GetPosition()));
1372
1373 (void) CopySelection(Primary);
1374
1375 m_lastDoubleClick = wxGetLocalTimeMillis();
1376 }
1377 else
1378 event.Skip();
1379 }
1380
1381 void wxHtmlWindow::SelectWord(const wxPoint& pos)
1382 {
1383 if ( m_Cell )
1384 {
1385 wxHtmlCell *cell = m_Cell->FindCellByPos(pos.x, pos.y);
1386 if ( cell )
1387 {
1388 delete m_selection;
1389 m_selection = new wxHtmlSelection();
1390 m_selection->Set(cell, cell);
1391 RefreshRect(wxRect(CalcScrolledPosition(cell->GetAbsPos()),
1392 wxSize(cell->GetWidth(), cell->GetHeight())));
1393 }
1394 }
1395 }
1396
1397 void wxHtmlWindow::SelectLine(const wxPoint& pos)
1398 {
1399 if ( m_Cell )
1400 {
1401 wxHtmlCell *cell = m_Cell->FindCellByPos(pos.x, pos.y);
1402 if ( cell )
1403 {
1404 // We use following heuristic to find a "line": let the line be all
1405 // cells in same container as the cell under mouse cursor that are
1406 // neither completely above nor completely bellow the clicked cell
1407 // (i.e. are likely to be words positioned on same line of text).
1408
1409 int y1 = cell->GetAbsPos().y;
1410 int y2 = y1 + cell->GetHeight();
1411 int y;
1412 const wxHtmlCell *c;
1413 const wxHtmlCell *before = NULL;
1414 const wxHtmlCell *after = NULL;
1415
1416 // find last cell of line:
1417 for ( c = cell->GetNext(); c; c = c->GetNext())
1418 {
1419 y = c->GetAbsPos().y;
1420 if ( y + c->GetHeight() > y1 && y < y2 )
1421 after = c;
1422 else
1423 break;
1424 }
1425 if ( !after )
1426 after = cell;
1427
1428 // find first cell of line:
1429 for ( c = cell->GetParent()->GetFirstChild();
1430 c && c != cell; c = c->GetNext())
1431 {
1432 y = c->GetAbsPos().y;
1433 if ( y + c->GetHeight() > y1 && y < y2 )
1434 {
1435 if ( ! before )
1436 before = c;
1437 }
1438 else
1439 before = NULL;
1440 }
1441 if ( !before )
1442 before = cell;
1443
1444 delete m_selection;
1445 m_selection = new wxHtmlSelection();
1446 m_selection->Set(before, after);
1447
1448 Refresh();
1449 }
1450 }
1451 }
1452
1453 void wxHtmlWindow::SelectAll()
1454 {
1455 if ( m_Cell )
1456 {
1457 delete m_selection;
1458 m_selection = new wxHtmlSelection();
1459 m_selection->Set(m_Cell->GetFirstTerminal(), m_Cell->GetLastTerminal());
1460 Refresh();
1461 }
1462 }
1463
1464 #endif // wxUSE_CLIPBOARD
1465
1466
1467
1468 IMPLEMENT_ABSTRACT_CLASS(wxHtmlProcessor,wxObject)
1469
1470 #if wxUSE_EXTENDED_RTTI
1471 IMPLEMENT_DYNAMIC_CLASS_XTI(wxHtmlWindow, wxScrolledWindow,"wx/html/htmlwin.h")
1472
1473 wxBEGIN_PROPERTIES_TABLE(wxHtmlWindow)
1474 /*
1475 TODO PROPERTIES
1476 style , wxHW_SCROLLBAR_AUTO
1477 borders , (dimension)
1478 url , string
1479 htmlcode , string
1480 */
1481 wxEND_PROPERTIES_TABLE()
1482
1483 wxBEGIN_HANDLERS_TABLE(wxHtmlWindow)
1484 wxEND_HANDLERS_TABLE()
1485
1486 wxCONSTRUCTOR_5( wxHtmlWindow , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle )
1487 #else
1488 IMPLEMENT_DYNAMIC_CLASS(wxHtmlWindow,wxScrolledWindow)
1489 #endif
1490
1491 BEGIN_EVENT_TABLE(wxHtmlWindow, wxScrolledWindow)
1492 EVT_SIZE(wxHtmlWindow::OnSize)
1493 EVT_LEFT_DOWN(wxHtmlWindow::OnMouseDown)
1494 EVT_LEFT_UP(wxHtmlWindow::OnMouseUp)
1495 EVT_RIGHT_UP(wxHtmlWindow::OnMouseUp)
1496 EVT_MOTION(wxHtmlWindow::OnMouseMove)
1497 EVT_ERASE_BACKGROUND(wxHtmlWindow::OnEraseBackground)
1498 EVT_PAINT(wxHtmlWindow::OnPaint)
1499 #if wxUSE_CLIPBOARD
1500 EVT_LEFT_DCLICK(wxHtmlWindow::OnDoubleClick)
1501 EVT_ENTER_WINDOW(wxHtmlWindow::OnMouseEnter)
1502 EVT_LEAVE_WINDOW(wxHtmlWindow::OnMouseLeave)
1503 EVT_KEY_UP(wxHtmlWindow::OnKeyUp)
1504 EVT_MENU(wxID_COPY, wxHtmlWindow::OnCopy)
1505 #endif // wxUSE_CLIPBOARD
1506 END_EVENT_TABLE()
1507
1508 //-----------------------------------------------------------------------------
1509 // wxHtmlWindowInterface implementation in wxHtmlWindow
1510 //-----------------------------------------------------------------------------
1511
1512 void wxHtmlWindow::SetHTMLWindowTitle(const wxString& title)
1513 {
1514 OnSetTitle(title);
1515 }
1516
1517 void wxHtmlWindow::OnHTMLLinkClicked(const wxHtmlLinkInfo& link)
1518 {
1519 OnLinkClicked(link);
1520 }
1521
1522 wxHtmlOpeningStatus wxHtmlWindow::OnHTMLOpeningURL(wxHtmlURLType type,
1523 const wxString& url,
1524 wxString *redirect) const
1525 {
1526 return OnOpeningURL(type, url, redirect);
1527 }
1528
1529 wxPoint wxHtmlWindow::HTMLCoordsToWindow(wxHtmlCell *WXUNUSED(cell),
1530 const wxPoint& pos) const
1531 {
1532 return CalcScrolledPosition(pos);
1533 }
1534
1535 wxWindow* wxHtmlWindow::GetHTMLWindow()
1536 {
1537 return this;
1538 }
1539
1540 wxColour wxHtmlWindow::GetHTMLBackgroundColour() const
1541 {
1542 return GetBackgroundColour();
1543 }
1544
1545 void wxHtmlWindow::SetHTMLBackgroundColour(const wxColour& clr)
1546 {
1547 SetBackgroundColour(clr);
1548 }
1549
1550 void wxHtmlWindow::SetHTMLBackgroundImage(const wxBitmap& bmpBg)
1551 {
1552 SetBackgroundImage(bmpBg);
1553 }
1554
1555 void wxHtmlWindow::SetHTMLStatusText(const wxString& text)
1556 {
1557 #if wxUSE_STATUSBAR
1558 if (m_RelatedStatusBar != -1)
1559 m_RelatedFrame->SetStatusText(text, m_RelatedStatusBar);
1560 #endif // wxUSE_STATUSBAR
1561 }
1562
1563 /*static*/
1564 wxCursor wxHtmlWindow::GetDefaultHTMLCursor(HTMLCursor type)
1565 {
1566 switch (type)
1567 {
1568 case HTMLCursor_Link:
1569 if ( !ms_cursorLink )
1570 ms_cursorLink = new wxCursor(wxCURSOR_HAND);
1571 return *ms_cursorLink;
1572
1573 case HTMLCursor_Text:
1574 if ( !ms_cursorText )
1575 ms_cursorText = new wxCursor(wxCURSOR_IBEAM);
1576 return *ms_cursorText;
1577
1578 case HTMLCursor_Default:
1579 default:
1580 return *wxSTANDARD_CURSOR;
1581 }
1582 }
1583
1584 wxCursor wxHtmlWindow::GetHTMLCursor(HTMLCursor type) const
1585 {
1586 return GetDefaultHTMLCursor(type);
1587 }
1588
1589
1590 //-----------------------------------------------------------------------------
1591 // wxHtmlWinModule
1592 //-----------------------------------------------------------------------------
1593
1594 // A module to allow initialization/cleanup
1595 // without calling these functions from app.cpp or from
1596 // the user's application.
1597
1598 class wxHtmlWinModule: public wxModule
1599 {
1600 DECLARE_DYNAMIC_CLASS(wxHtmlWinModule)
1601 public:
1602 wxHtmlWinModule() : wxModule() {}
1603 bool OnInit() { return true; }
1604 void OnExit() { wxHtmlWindow::CleanUpStatics(); }
1605 };
1606
1607 IMPLEMENT_DYNAMIC_CLASS(wxHtmlWinModule, wxModule)
1608
1609
1610 // This hack forces the linker to always link in m_* files
1611 // (wxHTML doesn't work without handlers from these files)
1612 #include "wx/html/forcelnk.h"
1613 FORCE_WXHTML_MODULES()
1614
1615 #endif // wxUSE_HTML
1616
wxWidgets (Impactor)