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