1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/html/htmlwin.cpp
3 // Purpose: wxHtmlWindow class for parsing & displaying HTML (implementation)
4 // Author: Vaclav Slavik
6 // Copyright: (c) 1999 Vaclav Slavik
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 #include "wx/wxprec.h"
16 #if wxUSE_HTML && wxUSE_STREAMS
22 #include "wx/dcclient.h"
24 #include "wx/dcmemory.h"
26 #include "wx/settings.h"
27 #include "wx/dataobj.h"
28 #include "wx/statusbr.h"
31 #include "wx/html/htmlwin.h"
32 #include "wx/html/htmlproc.h"
33 #include "wx/clipbrd.h"
35 #include "wx/arrimpl.cpp"
36 #include "wx/listimpl.cpp"
39 IMPLEMENT_DYNAMIC_CLASS(wxHtmlLinkEvent
, wxCommandEvent
)
40 IMPLEMENT_DYNAMIC_CLASS(wxHtmlCellEvent
, wxCommandEvent
)
42 wxDEFINE_EVENT( wxEVT_COMMAND_HTML_CELL_CLICKED
, wxHtmlCellEvent
);
43 wxDEFINE_EVENT( wxEVT_COMMAND_HTML_CELL_HOVER
, wxHtmlCellEvent
);
44 wxDEFINE_EVENT( wxEVT_COMMAND_HTML_LINK_CLICKED
, wxHtmlLinkEvent
);
48 // ----------------------------------------------------------------------------
49 // wxHtmlWinAutoScrollTimer: the timer used to generate a stream of scroll
50 // events when a captured mouse is held outside the window
51 // ----------------------------------------------------------------------------
53 class wxHtmlWinAutoScrollTimer
: public wxTimer
56 wxHtmlWinAutoScrollTimer(wxScrolledWindow
*win
,
57 wxEventType eventTypeToSend
,
61 m_eventType
= eventTypeToSend
;
66 virtual void Notify();
69 wxScrolledWindow
*m_win
;
70 wxEventType m_eventType
;
74 wxDECLARE_NO_COPY_CLASS(wxHtmlWinAutoScrollTimer
);
77 void wxHtmlWinAutoScrollTimer::Notify()
79 // only do all this as long as the window is capturing the mouse
80 if ( wxWindow::GetCapture() != m_win
)
84 else // we still capture the mouse, continue generating events
86 // first scroll the window if we are allowed to do it
87 wxScrollWinEvent
event1(m_eventType
, m_pos
, m_orient
);
88 event1
.SetEventObject(m_win
);
89 if ( m_win
->GetEventHandler()->ProcessEvent(event1
) )
91 // and then send a pseudo mouse-move event to refresh the selection
92 wxMouseEvent
event2(wxEVT_MOTION
);
93 wxGetMousePosition(&event2
.m_x
, &event2
.m_y
);
95 // the mouse event coordinates should be client, not screen as
96 // returned by wxGetMousePosition
97 wxWindow
*parentTop
= m_win
;
98 while ( parentTop
->GetParent() )
99 parentTop
= parentTop
->GetParent();
100 wxPoint ptOrig
= parentTop
->GetPosition();
101 event2
.m_x
-= ptOrig
.x
;
102 event2
.m_y
-= ptOrig
.y
;
104 event2
.SetEventObject(m_win
);
106 // FIXME: we don't fill in the other members - ok?
107 m_win
->GetEventHandler()->ProcessEvent(event2
);
109 else // can't scroll further, stop
116 #endif // wxUSE_CLIPBOARD
120 //-----------------------------------------------------------------------------
122 //-----------------------------------------------------------------------------
124 // item of history list
125 class WXDLLIMPEXP_HTML wxHtmlHistoryItem
128 wxHtmlHistoryItem(const wxString
& p
, const wxString
& a
) {m_Page
= p
, m_Anchor
= a
, m_Pos
= 0;}
129 int GetPos() const {return m_Pos
;}
130 void SetPos(int p
) {m_Pos
= p
;}
131 const wxString
& GetPage() const {return m_Page
;}
132 const wxString
& GetAnchor() const {return m_Anchor
;}
141 //-----------------------------------------------------------------------------
142 // our private arrays:
143 //-----------------------------------------------------------------------------
145 WX_DECLARE_OBJARRAY(wxHtmlHistoryItem
, wxHtmlHistoryArray
);
146 WX_DEFINE_OBJARRAY(wxHtmlHistoryArray
)
148 WX_DECLARE_LIST(wxHtmlProcessor
, wxHtmlProcessorList
);
149 WX_DEFINE_LIST(wxHtmlProcessorList
)
151 //-----------------------------------------------------------------------------
152 // wxHtmlWindowMouseHelper
153 //-----------------------------------------------------------------------------
155 wxHtmlWindowMouseHelper::wxHtmlWindowMouseHelper(wxHtmlWindowInterface
*iface
)
156 : m_tmpMouseMoved(false),
163 void wxHtmlWindowMouseHelper::HandleMouseMoved()
165 m_tmpMouseMoved
= true;
168 bool wxHtmlWindowMouseHelper::HandleMouseClick(wxHtmlCell
*rootCell
,
170 const wxMouseEvent
& event
)
175 wxHtmlCell
*cell
= rootCell
->FindCellByPos(pos
.x
, pos
.y
);
176 // this check is needed because FindCellByPos returns terminal cell and
177 // containers may have empty borders -- in this case NULL will be
182 // adjust the coordinates to be relative to this cell:
183 wxPoint relpos
= pos
- cell
->GetAbsPos(rootCell
);
185 return OnCellClicked(cell
, relpos
.x
, relpos
.y
, event
);
188 void wxHtmlWindowMouseHelper::HandleIdle(wxHtmlCell
*rootCell
,
191 wxHtmlCell
*cell
= rootCell
? rootCell
->FindCellByPos(pos
.x
, pos
.y
) : NULL
;
193 if (cell
!= m_tmpLastCell
)
195 wxHtmlLinkInfo
*lnk
= NULL
;
198 // adjust the coordinates to be relative to this cell:
199 wxPoint relpos
= pos
- cell
->GetAbsPos(rootCell
);
200 lnk
= cell
->GetLink(relpos
.x
, relpos
.y
);
205 cur
= cell
->GetMouseCursor(m_interface
);
207 cur
= m_interface
->GetHTMLCursor(
208 wxHtmlWindowInterface::HTMLCursor_Default
);
210 m_interface
->GetHTMLWindow()->SetCursor(cur
);
212 if (lnk
!= m_tmpLastLink
)
215 m_interface
->SetHTMLStatusText(lnk
->GetHref());
217 m_interface
->SetHTMLStatusText(wxEmptyString
);
222 m_tmpLastCell
= cell
;
224 else // mouse moved but stayed in the same cell
228 OnCellMouseHover(cell
, pos
.x
, pos
.y
);
232 m_tmpMouseMoved
= false;
235 bool wxHtmlWindowMouseHelper::OnCellClicked(wxHtmlCell
*cell
,
236 wxCoord x
, wxCoord y
,
237 const wxMouseEvent
& event
)
239 wxHtmlCellEvent
ev(wxEVT_COMMAND_HTML_CELL_CLICKED
,
240 m_interface
->GetHTMLWindow()->GetId(),
241 cell
, wxPoint(x
,y
), event
);
243 if (!m_interface
->GetHTMLWindow()->GetEventHandler()->ProcessEvent(ev
))
245 // if the event wasn't handled, do the default processing here:
247 wxASSERT_MSG( cell
, _T("can't be called with NULL cell") );
249 cell
->ProcessMouseClick(m_interface
, ev
.GetPoint(), ev
.GetMouseEvent());
252 // true if a link was clicked, false otherwise
253 return ev
.GetLinkClicked();
256 void wxHtmlWindowMouseHelper::OnCellMouseHover(wxHtmlCell
* cell
,
260 wxHtmlCellEvent
ev(wxEVT_COMMAND_HTML_CELL_HOVER
,
261 m_interface
->GetHTMLWindow()->GetId(),
262 cell
, wxPoint(x
,y
), wxMouseEvent());
263 m_interface
->GetHTMLWindow()->GetEventHandler()->ProcessEvent(ev
);
269 //-----------------------------------------------------------------------------
271 //-----------------------------------------------------------------------------
273 wxList
wxHtmlWindow::m_Filters
;
274 wxHtmlFilter
*wxHtmlWindow::m_DefaultFilter
= NULL
;
275 wxHtmlProcessorList
*wxHtmlWindow::m_GlobalProcessors
= NULL
;
276 wxCursor
*wxHtmlWindow::ms_cursorLink
= NULL
;
277 wxCursor
*wxHtmlWindow::ms_cursorText
= NULL
;
279 void wxHtmlWindow::CleanUpStatics()
281 wxDELETE(m_DefaultFilter
);
282 WX_CLEAR_LIST(wxList
, m_Filters
);
283 if (m_GlobalProcessors
)
284 WX_CLEAR_LIST(wxHtmlProcessorList
, *m_GlobalProcessors
);
285 wxDELETE(m_GlobalProcessors
);
286 wxDELETE(ms_cursorLink
);
287 wxDELETE(ms_cursorText
);
290 void wxHtmlWindow::Init()
292 m_tmpCanDrawLocks
= 0;
293 m_FS
= new wxFileSystem();
295 m_RelatedStatusBar
= NULL
;
296 m_RelatedStatusBarIndex
= -1;
297 #endif // wxUSE_STATUSBAR
298 m_RelatedFrame
= NULL
;
299 m_TitleFormat
= wxT("%s");
300 m_OpenedPage
= m_OpenedAnchor
= m_OpenedPageTitle
= wxEmptyString
;
302 m_Parser
= new wxHtmlWinParser(this);
303 m_Parser
->SetFS(m_FS
);
306 m_History
= new wxHtmlHistoryArray
;
310 m_makingSelection
= false;
312 m_timerAutoScroll
= NULL
;
313 m_lastDoubleClick
= 0;
314 #endif // wxUSE_CLIPBOARD
316 m_eraseBgInOnPaint
= false;
317 m_tmpSelFromCell
= NULL
;
320 bool wxHtmlWindow::Create(wxWindow
*parent
, wxWindowID id
,
321 const wxPoint
& pos
, const wxSize
& size
,
322 long style
, const wxString
& name
)
324 if (!wxScrolledWindow::Create(parent
, id
, pos
, size
,
325 style
| wxVSCROLL
| wxHSCROLL
,
329 SetPage(wxT("<html><body></body></html>"));
334 wxHtmlWindow::~wxHtmlWindow()
338 #endif // wxUSE_CLIPBOARD
347 WX_CLEAR_LIST(wxHtmlProcessorList
, *m_Processors
);
359 void wxHtmlWindow::SetRelatedFrame(wxFrame
* frame
, const wxString
& format
)
361 m_RelatedFrame
= frame
;
362 m_TitleFormat
= format
;
368 void wxHtmlWindow::SetRelatedStatusBar(int index
)
370 m_RelatedStatusBarIndex
= index
;
373 void wxHtmlWindow::SetRelatedStatusBar(wxStatusBar
* statusbar
, int index
)
375 m_RelatedStatusBar
= statusbar
;
376 m_RelatedStatusBarIndex
= index
;
379 #endif // wxUSE_STATUSBAR
383 void wxHtmlWindow::SetFonts(const wxString
& normal_face
, const wxString
& fixed_face
, const int *sizes
)
385 m_Parser
->SetFonts(normal_face
, fixed_face
, sizes
);
387 // re-layout the page after changing fonts:
388 DoSetPage(*(m_Parser
->GetSource()));
391 void wxHtmlWindow::SetStandardFonts(int size
,
392 const wxString
& normal_face
,
393 const wxString
& fixed_face
)
395 m_Parser
->SetStandardFonts(size
, normal_face
, fixed_face
);
397 // re-layout the page after changing fonts:
398 DoSetPage(*(m_Parser
->GetSource()));
401 bool wxHtmlWindow::SetPage(const wxString
& source
)
403 m_OpenedPage
= m_OpenedAnchor
= m_OpenedPageTitle
= wxEmptyString
;
404 return DoSetPage(source
);
407 bool wxHtmlWindow::DoSetPage(const wxString
& source
)
409 wxString
newsrc(source
);
411 wxDELETE(m_selection
);
413 // we will soon delete all the cells, so clear pointers to them:
414 m_tmpSelFromCell
= NULL
;
416 // pass HTML through registered processors:
417 if (m_Processors
|| m_GlobalProcessors
)
419 wxHtmlProcessorList::compatibility_iterator nodeL
, nodeG
;
423 nodeL
= m_Processors
->GetFirst();
424 if ( m_GlobalProcessors
)
425 nodeG
= m_GlobalProcessors
->GetFirst();
427 // VS: there are two lists, global and local, both of them sorted by
428 // priority. Since we have to go through _both_ lists with
429 // decreasing priority, we "merge-sort" the lists on-line by
430 // processing that one of the two heads that has higher priority
431 // in every iteration
432 while (nodeL
|| nodeG
)
434 prL
= (nodeL
) ? nodeL
->GetData()->GetPriority() : -1;
435 prG
= (nodeG
) ? nodeG
->GetData()->GetPriority() : -1;
438 if (nodeL
->GetData()->IsEnabled())
439 newsrc
= nodeL
->GetData()->Process(newsrc
);
440 nodeL
= nodeL
->GetNext();
444 if (nodeG
->GetData()->IsEnabled())
445 newsrc
= nodeG
->GetData()->Process(newsrc
);
446 nodeG
= nodeG
->GetNext();
451 // ...and run the parser on it:
452 wxClientDC
*dc
= new wxClientDC(this);
453 dc
->SetMapMode(wxMM_TEXT
);
454 SetBackgroundColour(wxColour(0xFF, 0xFF, 0xFF));
455 SetBackgroundImage(wxNullBitmap
);
463 m_Cell
= (wxHtmlContainerCell
*) m_Parser
->Parse(newsrc
);
465 m_Cell
->SetIndent(m_Borders
, wxHTML_INDENT_ALL
, wxHTML_UNITS_PIXELS
);
466 m_Cell
->SetAlignHor(wxHTML_ALIGN_CENTER
);
468 if (m_tmpCanDrawLocks
== 0)
473 bool wxHtmlWindow::AppendToPage(const wxString
& source
)
475 return DoSetPage(*(GetParser()->GetSource()) + source
);
478 bool wxHtmlWindow::LoadPage(const wxString
& location
)
480 wxCHECK_MSG( !location
.empty(), false, "location must be non-empty" );
482 wxBusyCursor busyCursor
;
485 bool needs_refresh
= false;
488 if (m_HistoryOn
&& (m_HistoryPos
!= -1))
490 // store scroll position into history item:
492 GetViewStart(&x
, &y
);
493 (*m_History
)[m_HistoryPos
].SetPos(y
);
496 // first check if we're moving to an anchor in the same page
497 size_t posLocalAnchor
= location
.Find('#');
498 if ( posLocalAnchor
!= wxString::npos
&& posLocalAnchor
!= 0 )
500 // check if the part before the anchor is the same as the (either
501 // relative or absolute) URI of the current page
502 const wxString beforeAnchor
= location
.substr(0, posLocalAnchor
);
503 if ( beforeAnchor
!= m_OpenedPage
&&
504 m_FS
->GetPath() + beforeAnchor
!= m_OpenedPage
)
506 // indicate that we're not moving to a local anchor
507 posLocalAnchor
= wxString::npos
;
511 if ( posLocalAnchor
!= wxString::npos
)
514 rt_val
= ScrollToAnchor(location
.substr(posLocalAnchor
+ 1));
517 else // moving to another page
519 needs_refresh
= true;
522 if (m_RelatedStatusBarIndex
!= -1)
524 SetHTMLStatusText(_("Connecting..."));
527 #endif // wxUSE_STATUSBAR
529 wxFSFile
*f
= m_Parser
->OpenURL(wxHTML_URL_PAGE
, location
);
531 // try to interpret 'location' as filename instead of URL:
534 wxFileName
fn(location
);
535 wxString location2
= wxFileSystem::FileNameToURL(fn
);
536 f
= m_Parser
->OpenURL(wxHTML_URL_PAGE
, location2
);
541 wxLogError(_("Unable to open requested HTML document: %s"), location
.c_str());
543 SetHTMLStatusText(wxEmptyString
);
549 wxList::compatibility_iterator node
;
550 wxString src
= wxEmptyString
;
553 if (m_RelatedStatusBarIndex
!= -1)
555 wxString msg
= _("Loading : ") + location
;
556 SetHTMLStatusText(msg
);
559 #endif // wxUSE_STATUSBAR
561 node
= m_Filters
.GetFirst();
564 wxHtmlFilter
*h
= (wxHtmlFilter
*) node
->GetData();
567 src
= h
->ReadFile(*f
);
570 node
= node
->GetNext();
572 if (src
== wxEmptyString
)
574 if (m_DefaultFilter
== NULL
) m_DefaultFilter
= GetDefaultFilter();
575 src
= m_DefaultFilter
->ReadFile(*f
);
578 m_FS
->ChangePathTo(f
->GetLocation());
579 rt_val
= SetPage(src
);
580 m_OpenedPage
= f
->GetLocation();
581 if (f
->GetAnchor() != wxEmptyString
)
583 ScrollToAnchor(f
->GetAnchor());
589 if (m_RelatedStatusBarIndex
!= -1)
591 SetHTMLStatusText(_("Done"));
593 #endif // wxUSE_STATUSBAR
597 if (m_HistoryOn
) // add this page to history there:
599 int c
= m_History
->GetCount() - (m_HistoryPos
+ 1);
601 if (m_HistoryPos
< 0 ||
602 (*m_History
)[m_HistoryPos
].GetPage() != m_OpenedPage
||
603 (*m_History
)[m_HistoryPos
].GetAnchor() != m_OpenedAnchor
)
606 for (int i
= 0; i
< c
; i
++)
607 m_History
->RemoveAt(m_HistoryPos
);
608 m_History
->Add(new wxHtmlHistoryItem(m_OpenedPage
, m_OpenedAnchor
));
612 if (m_OpenedPageTitle
== wxEmptyString
)
613 OnSetTitle(wxFileNameFromPath(m_OpenedPage
));
627 bool wxHtmlWindow::LoadFile(const wxFileName
& filename
)
629 wxString url
= wxFileSystem::FileNameToURL(filename
);
630 return LoadPage(url
);
634 bool wxHtmlWindow::ScrollToAnchor(const wxString
& anchor
)
636 const wxHtmlCell
*c
= m_Cell
->Find(wxHTML_COND_ISANCHOR
, &anchor
);
639 wxLogWarning(_("HTML anchor %s does not exist."), anchor
.c_str());
646 for (y
= 0; c
!= NULL
; c
= c
->GetParent()) y
+= c
->GetPosY();
647 Scroll(-1, y
/ wxHTML_SCROLL_STEP
);
648 m_OpenedAnchor
= anchor
;
654 void wxHtmlWindow::OnSetTitle(const wxString
& title
)
659 tit
.Printf(m_TitleFormat
, title
.c_str());
660 m_RelatedFrame
->SetTitle(tit
);
662 m_OpenedPageTitle
= title
;
669 void wxHtmlWindow::CreateLayout()
671 int ClientWidth
, ClientHeight
;
675 if ( HasFlag(wxHW_SCROLLBAR_NEVER
) )
677 SetScrollbars(1, 1, 0, 0); // always off
678 GetClientSize(&ClientWidth
, &ClientHeight
);
679 m_Cell
->Layout(ClientWidth
);
681 else // !wxHW_SCROLLBAR_NEVER
683 GetClientSize(&ClientWidth
, &ClientHeight
);
684 m_Cell
->Layout(ClientWidth
);
685 if (ClientHeight
< m_Cell
->GetHeight() + GetCharHeight())
688 wxHTML_SCROLL_STEP
, wxHTML_SCROLL_STEP
,
689 m_Cell
->GetWidth() / wxHTML_SCROLL_STEP
,
690 (m_Cell
->GetHeight() + GetCharHeight()) / wxHTML_SCROLL_STEP
691 /*cheat: top-level frag is always container*/);
693 else /* we fit into window, no need for scrollbars */
695 SetScrollbars(wxHTML_SCROLL_STEP
, 1, m_Cell
->GetWidth() / wxHTML_SCROLL_STEP
, 0); // disable...
696 GetClientSize(&ClientWidth
, &ClientHeight
);
697 m_Cell
->Layout(ClientWidth
); // ...and relayout
704 void wxHtmlWindow::ReadCustomization(wxConfigBase
*cfg
, wxString path
)
709 wxString p_fff
, p_ffn
;
711 if (path
!= wxEmptyString
)
713 oldpath
= cfg
->GetPath();
717 m_Borders
= cfg
->Read(wxT("wxHtmlWindow/Borders"), m_Borders
);
718 p_fff
= cfg
->Read(wxT("wxHtmlWindow/FontFaceFixed"), m_Parser
->m_FontFaceFixed
);
719 p_ffn
= cfg
->Read(wxT("wxHtmlWindow/FontFaceNormal"), m_Parser
->m_FontFaceNormal
);
720 for (int i
= 0; i
< 7; i
++)
722 tmp
.Printf(wxT("wxHtmlWindow/FontsSize%i"), i
);
723 p_fontsizes
[i
] = cfg
->Read(tmp
, m_Parser
->m_FontsSizes
[i
]);
725 SetFonts(p_ffn
, p_fff
, p_fontsizes
);
727 if (path
!= wxEmptyString
)
728 cfg
->SetPath(oldpath
);
733 void wxHtmlWindow::WriteCustomization(wxConfigBase
*cfg
, wxString path
)
738 if (path
!= wxEmptyString
)
740 oldpath
= cfg
->GetPath();
744 cfg
->Write(wxT("wxHtmlWindow/Borders"), (long) m_Borders
);
745 cfg
->Write(wxT("wxHtmlWindow/FontFaceFixed"), m_Parser
->m_FontFaceFixed
);
746 cfg
->Write(wxT("wxHtmlWindow/FontFaceNormal"), m_Parser
->m_FontFaceNormal
);
747 for (int i
= 0; i
< 7; i
++)
749 tmp
.Printf(wxT("wxHtmlWindow/FontsSize%i"), i
);
750 cfg
->Write(tmp
, (long) m_Parser
->m_FontsSizes
[i
]);
753 if (path
!= wxEmptyString
)
754 cfg
->SetPath(oldpath
);
759 bool wxHtmlWindow::HistoryBack()
763 if (m_HistoryPos
< 1) return false;
765 // store scroll position into history item:
767 GetViewStart(&x
, &y
);
768 (*m_History
)[m_HistoryPos
].SetPos(y
);
770 // go to previous position:
773 l
= (*m_History
)[m_HistoryPos
].GetPage();
774 a
= (*m_History
)[m_HistoryPos
].GetAnchor();
777 if (a
== wxEmptyString
) LoadPage(l
);
778 else LoadPage(l
+ wxT("#") + a
);
781 Scroll(0, (*m_History
)[m_HistoryPos
].GetPos());
786 bool wxHtmlWindow::HistoryCanBack()
788 if (m_HistoryPos
< 1) return false;
793 bool wxHtmlWindow::HistoryForward()
797 if (m_HistoryPos
== -1) return false;
798 if (m_HistoryPos
>= (int)m_History
->GetCount() - 1)return false;
800 m_OpenedPage
= wxEmptyString
; // this will disable adding new entry into history in LoadPage()
803 l
= (*m_History
)[m_HistoryPos
].GetPage();
804 a
= (*m_History
)[m_HistoryPos
].GetAnchor();
807 if (a
== wxEmptyString
) LoadPage(l
);
808 else LoadPage(l
+ wxT("#") + a
);
811 Scroll(0, (*m_History
)[m_HistoryPos
].GetPos());
816 bool wxHtmlWindow::HistoryCanForward()
818 if (m_HistoryPos
== -1) return false;
819 if (m_HistoryPos
>= (int)m_History
->GetCount() - 1)return false;
824 void wxHtmlWindow::HistoryClear()
830 void wxHtmlWindow::AddProcessor(wxHtmlProcessor
*processor
)
834 m_Processors
= new wxHtmlProcessorList
;
836 wxHtmlProcessorList::compatibility_iterator node
;
838 for (node
= m_Processors
->GetFirst(); node
; node
= node
->GetNext())
840 if (processor
->GetPriority() > node
->GetData()->GetPriority())
842 m_Processors
->Insert(node
, processor
);
846 m_Processors
->Append(processor
);
849 /*static */ void wxHtmlWindow::AddGlobalProcessor(wxHtmlProcessor
*processor
)
851 if (!m_GlobalProcessors
)
853 m_GlobalProcessors
= new wxHtmlProcessorList
;
855 wxHtmlProcessorList::compatibility_iterator node
;
857 for (node
= m_GlobalProcessors
->GetFirst(); node
; node
= node
->GetNext())
859 if (processor
->GetPriority() > node
->GetData()->GetPriority())
861 m_GlobalProcessors
->Insert(node
, processor
);
865 m_GlobalProcessors
->Append(processor
);
870 void wxHtmlWindow::AddFilter(wxHtmlFilter
*filter
)
872 m_Filters
.Append(filter
);
876 bool wxHtmlWindow::IsSelectionEnabled() const
879 return !HasFlag(wxHW_NO_SELECTION
);
887 wxString
wxHtmlWindow::DoSelectionToText(wxHtmlSelection
*sel
)
890 return wxEmptyString
;
895 wxHtmlTerminalCellsInterator
i(sel
->GetFromCell(), sel
->GetToCell());
896 const wxHtmlCell
*prev
= NULL
;
900 // When converting HTML content to plain text, the entire paragraph
901 // (container in wxHTML) goes on single line. A new paragraph (that
902 // should go on its own line) has its own container. Therefore, the
903 // simplest way of detecting where to insert newlines in plain text
904 // is to check if the parent container changed -- if it did, we moved
905 // to a new paragraph.
906 if ( prev
&& prev
->GetParent() != i
->GetParent() )
909 // NB: we don't need to pass the selection to ConvertToText() in the
910 // middle of the selected text; it's only useful when only part of
911 // a cell is selected
912 text
<< i
->ConvertToText(sel
);
920 wxString
wxHtmlWindow::ToText()
925 sel
.Set(m_Cell
->GetFirstTerminal(), m_Cell
->GetLastTerminal());
926 return DoSelectionToText(&sel
);
929 return wxEmptyString
;
932 #endif // wxUSE_CLIPBOARD
934 bool wxHtmlWindow::CopySelection(ClipboardType t
)
939 #if defined(__UNIX__) && !defined(__WXMAC__)
940 wxTheClipboard
->UsePrimarySelection(t
== Primary
);
942 // Primary selection exists only under X11, so don't do anything under
943 // the other platforms when we try to access it
945 // TODO: this should be abstracted at wxClipboard level!
948 #endif // __UNIX__/!__UNIX__
950 if ( wxTheClipboard
->Open() )
952 const wxString
txt(SelectionToText());
953 wxTheClipboard
->SetData(new wxTextDataObject(txt
));
954 wxTheClipboard
->Close();
955 wxLogTrace(_T("wxhtmlselection"),
956 _("Copied to clipboard:\"%s\""), txt
.c_str());
963 #endif // wxUSE_CLIPBOARD
969 void wxHtmlWindow::OnLinkClicked(const wxHtmlLinkInfo
& link
)
971 wxHtmlLinkEvent
event(GetId(), link
);
972 event
.SetEventObject(this);
973 if (!GetEventHandler()->ProcessEvent(event
))
975 // the default behaviour is to load the URL in this window
976 const wxMouseEvent
*e
= event
.GetLinkInfo().GetEvent();
977 if (e
== NULL
|| e
->LeftUp())
978 LoadPage(event
.GetLinkInfo().GetHref());
982 void wxHtmlWindow::OnEraseBackground(wxEraseEvent
& event
)
986 // don't even skip the event, if we don't have a bg bitmap we're going
987 // to overwrite background in OnPaint() below anyhow, so letting the
988 // default handling take place would only result in flicker, just set a
989 // flag to erase the background below
990 m_eraseBgInOnPaint
= true;
994 wxDC
& dc
= *event
.GetDC();
996 // if the image is not fully opaque, we have to erase the background before
997 // drawing it, however avoid doing it for opaque images as this would just
998 // result in extra flicker without any other effect as background is
999 // completely covered anyhow
1000 if ( m_bmpBg
.GetMask() )
1002 dc
.SetBackground(wxBrush(GetBackgroundColour(), wxBRUSHSTYLE_SOLID
));
1006 const wxSize
sizeWin(GetClientSize());
1007 const wxSize
sizeBmp(m_bmpBg
.GetWidth(), m_bmpBg
.GetHeight());
1008 for ( wxCoord x
= 0; x
< sizeWin
.x
; x
+= sizeBmp
.x
)
1010 for ( wxCoord y
= 0; y
< sizeWin
.y
; y
+= sizeBmp
.y
)
1012 dc
.DrawBitmap(m_bmpBg
, x
, y
, true /* use mask */);
1017 void wxHtmlWindow::OnPaint(wxPaintEvent
& WXUNUSED(event
))
1021 if (m_tmpCanDrawLocks
> 0 || m_Cell
== NULL
)
1025 GetViewStart(&x
, &y
);
1026 wxRect rect
= GetUpdateRegion().GetBox();
1027 wxSize sz
= GetSize();
1030 if ( !m_backBuffer
)
1031 m_backBuffer
= new wxBitmap(sz
.x
, sz
.y
);
1032 dcm
.SelectObject(*m_backBuffer
);
1034 if ( m_eraseBgInOnPaint
)
1036 dcm
.SetBackground(wxBrush(GetBackgroundColour(), wxBRUSHSTYLE_SOLID
));
1039 m_eraseBgInOnPaint
= false;
1041 else // someone has already erased the background, keep it
1043 // preserve the existing background, otherwise we'd erase anything the
1044 // user code had drawn in its EVT_ERASE_BACKGROUND handler when we do
1045 // the Blit back below
1046 dcm
.Blit(0, rect
.GetTop(),
1047 sz
.x
, rect
.GetBottom() - rect
.GetTop() + 1,
1053 dcm
.SetMapMode(wxMM_TEXT
);
1054 dcm
.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT
);
1056 wxHtmlRenderingInfo rinfo
;
1057 wxDefaultHtmlRenderingStyle rstyle
;
1058 rinfo
.SetSelection(m_selection
);
1059 rinfo
.SetStyle(&rstyle
);
1060 m_Cell
->Draw(dcm
, 0, 0,
1061 y
* wxHTML_SCROLL_STEP
+ rect
.GetTop(),
1062 y
* wxHTML_SCROLL_STEP
+ rect
.GetBottom(),
1065 //#define DEBUG_HTML_SELECTION
1066 #ifdef DEBUG_HTML_SELECTION
1069 wxGetMousePosition(&xc
, &yc
);
1070 ScreenToClient(&xc
, &yc
);
1071 CalcUnscrolledPosition(xc
, yc
, &x
, &y
);
1072 wxHtmlCell
*at
= m_Cell
->FindCellByPos(x
, y
);
1073 wxHtmlCell
*before
=
1074 m_Cell
->FindCellByPos(x
, y
, wxHTML_FIND_NEAREST_BEFORE
);
1076 m_Cell
->FindCellByPos(x
, y
, wxHTML_FIND_NEAREST_AFTER
);
1078 dcm
.SetBrush(*wxTRANSPARENT_BRUSH
);
1079 dcm
.SetPen(*wxBLACK_PEN
);
1081 dcm
.DrawRectangle(at
->GetAbsPos(),
1082 wxSize(at
->GetWidth(),at
->GetHeight()));
1083 dcm
.SetPen(*wxGREEN_PEN
);
1085 dcm
.DrawRectangle(before
->GetAbsPos().x
+1, before
->GetAbsPos().y
+1,
1086 before
->GetWidth()-2,before
->GetHeight()-2);
1087 dcm
.SetPen(*wxRED_PEN
);
1089 dcm
.DrawRectangle(after
->GetAbsPos().x
+2, after
->GetAbsPos().y
+2,
1090 after
->GetWidth()-4,after
->GetHeight()-4);
1094 dcm
.SetDeviceOrigin(0,0);
1095 dc
.Blit(0, rect
.GetTop(),
1096 sz
.x
, rect
.GetBottom() - rect
.GetTop() + 1,
1104 void wxHtmlWindow::OnSize(wxSizeEvent
& event
)
1106 wxDELETE(m_backBuffer
);
1108 wxScrolledWindow::OnSize(event
);
1111 // Recompute selection if necessary:
1114 m_selection
->Set(m_selection
->GetFromCell(),
1115 m_selection
->GetToCell());
1116 m_selection
->ClearPrivPos();
1123 void wxHtmlWindow::OnMouseMove(wxMouseEvent
& WXUNUSED(event
))
1125 wxHtmlWindowMouseHelper::HandleMouseMoved();
1128 void wxHtmlWindow::OnMouseDown(wxMouseEvent
& event
)
1131 if ( event
.LeftDown() && IsSelectionEnabled() )
1133 const long TRIPLECLICK_LEN
= 200; // 0.2 sec after doubleclick
1134 if ( wxGetLocalTimeMillis() - m_lastDoubleClick
<= TRIPLECLICK_LEN
)
1136 SelectLine(CalcUnscrolledPosition(event
.GetPosition()));
1138 (void) CopySelection();
1142 m_makingSelection
= true;
1146 wxDELETE(m_selection
);
1149 m_tmpSelFromPos
= CalcUnscrolledPosition(event
.GetPosition());
1150 m_tmpSelFromCell
= NULL
;
1155 #endif // wxUSE_CLIPBOARD
1157 // in any case, let the default handler set focus to this window
1161 void wxHtmlWindow::OnMouseUp(wxMouseEvent
& event
)
1164 if ( m_makingSelection
)
1167 m_makingSelection
= false;
1169 // if m_selection=NULL, the user didn't move the mouse far enough from
1170 // starting point and the mouse up event is part of a click, the user
1171 // is not selecting text:
1174 CopySelection(Primary
);
1176 // we don't want mouse up event that ended selecting to be
1177 // handled as mouse click and e.g. follow hyperlink:
1181 #endif // wxUSE_CLIPBOARD
1183 wxPoint pos
= CalcUnscrolledPosition(event
.GetPosition());
1184 wxHtmlWindowMouseHelper::HandleMouseClick(m_Cell
, pos
, event
);
1188 void wxHtmlWindow::OnMouseCaptureLost(wxMouseCaptureLostEvent
& WXUNUSED(event
))
1190 if ( !m_makingSelection
)
1193 // discard the selecting operation
1194 m_makingSelection
= false;
1195 wxDELETE(m_selection
);
1196 m_tmpSelFromCell
= NULL
;
1199 #endif // wxUSE_CLIPBOARD
1202 void wxHtmlWindow::OnInternalIdle()
1204 wxWindow::OnInternalIdle();
1206 if (m_Cell
!= NULL
&& DidMouseMove())
1208 #ifdef DEBUG_HTML_SELECTION
1212 wxGetMousePosition(&xc
, &yc
);
1213 ScreenToClient(&xc
, &yc
);
1214 CalcUnscrolledPosition(xc
, yc
, &x
, &y
);
1216 wxHtmlCell
*cell
= m_Cell
->FindCellByPos(x
, y
);
1218 // handle selection update:
1219 if ( m_makingSelection
)
1221 if ( !m_tmpSelFromCell
)
1222 m_tmpSelFromCell
= m_Cell
->FindCellByPos(
1223 m_tmpSelFromPos
.x
,m_tmpSelFromPos
.y
);
1225 // NB: a trick - we adjust selFromPos to be upper left or bottom
1226 // right corner of the first cell of the selection depending
1227 // on whether the mouse is moving to the right or to the left.
1228 // This gives us more "natural" behaviour when selecting
1229 // a line (specifically, first cell of the next line is not
1230 // included if you drag selection from left to right over
1233 if ( !m_tmpSelFromCell
)
1235 dirFromPos
= m_tmpSelFromPos
;
1239 dirFromPos
= m_tmpSelFromCell
->GetAbsPos();
1240 if ( x
< m_tmpSelFromPos
.x
)
1242 dirFromPos
.x
+= m_tmpSelFromCell
->GetWidth();
1243 dirFromPos
.y
+= m_tmpSelFromCell
->GetHeight();
1246 bool goingDown
= dirFromPos
.y
< y
||
1247 (dirFromPos
.y
== y
&& dirFromPos
.x
< x
);
1249 // determine selection span:
1250 if ( /*still*/ !m_tmpSelFromCell
)
1254 m_tmpSelFromCell
= m_Cell
->FindCellByPos(
1255 m_tmpSelFromPos
.x
,m_tmpSelFromPos
.y
,
1256 wxHTML_FIND_NEAREST_AFTER
);
1257 if (!m_tmpSelFromCell
)
1258 m_tmpSelFromCell
= m_Cell
->GetFirstTerminal();
1262 m_tmpSelFromCell
= m_Cell
->FindCellByPos(
1263 m_tmpSelFromPos
.x
,m_tmpSelFromPos
.y
,
1264 wxHTML_FIND_NEAREST_BEFORE
);
1265 if (!m_tmpSelFromCell
)
1266 m_tmpSelFromCell
= m_Cell
->GetLastTerminal();
1270 wxHtmlCell
*selcell
= cell
;
1275 selcell
= m_Cell
->FindCellByPos(x
, y
,
1276 wxHTML_FIND_NEAREST_BEFORE
);
1278 selcell
= m_Cell
->GetLastTerminal();
1282 selcell
= m_Cell
->FindCellByPos(x
, y
,
1283 wxHTML_FIND_NEAREST_AFTER
);
1285 selcell
= m_Cell
->GetFirstTerminal();
1289 // NB: it may *rarely* happen that the code above didn't find one
1290 // of the cells, e.g. if wxHtmlWindow doesn't contain any
1292 if ( selcell
&& m_tmpSelFromCell
)
1296 // start selecting only if mouse movement was big enough
1297 // (otherwise it was meant as mouse click, not selection):
1298 const int PRECISION
= 2;
1299 wxPoint diff
= m_tmpSelFromPos
- wxPoint(x
,y
);
1300 if (abs(diff
.x
) > PRECISION
|| abs(diff
.y
) > PRECISION
)
1302 m_selection
= new wxHtmlSelection();
1307 if ( m_tmpSelFromCell
->IsBefore(selcell
) )
1309 m_selection
->Set(m_tmpSelFromPos
, m_tmpSelFromCell
,
1310 wxPoint(x
,y
), selcell
);
1314 m_selection
->Set(wxPoint(x
,y
), selcell
,
1315 m_tmpSelFromPos
, m_tmpSelFromCell
);
1317 m_selection
->ClearPrivPos();
1323 // handle cursor and status bar text changes:
1325 // NB: because we're passing in 'cell' and not 'm_Cell' (so that the
1326 // leaf cell lookup isn't done twice), we need to adjust the
1327 // position for the new root:
1328 wxPoint
posInCell(x
, y
);
1330 posInCell
-= cell
->GetAbsPos();
1331 wxHtmlWindowMouseHelper::HandleIdle(cell
, posInCell
);
1336 void wxHtmlWindow::StopAutoScrolling()
1338 if ( m_timerAutoScroll
)
1340 wxDELETE(m_timerAutoScroll
);
1344 void wxHtmlWindow::OnMouseEnter(wxMouseEvent
& event
)
1346 StopAutoScrolling();
1350 void wxHtmlWindow::OnMouseLeave(wxMouseEvent
& event
)
1352 // don't prevent the usual processing of the event from taking place
1355 // when a captured mouse leave a scrolled window we start generate
1356 // scrolling events to allow, for example, extending selection beyond the
1357 // visible area in some controls
1358 if ( wxWindow::GetCapture() == this )
1360 // where is the mouse leaving?
1362 wxPoint pt
= event
.GetPosition();
1365 orient
= wxHORIZONTAL
;
1368 else if ( pt
.y
< 0 )
1370 orient
= wxVERTICAL
;
1373 else // we're lower or to the right of the window
1375 wxSize size
= GetClientSize();
1376 if ( pt
.x
> size
.x
)
1378 orient
= wxHORIZONTAL
;
1379 pos
= GetVirtualSize().x
/ wxHTML_SCROLL_STEP
;
1381 else if ( pt
.y
> size
.y
)
1383 orient
= wxVERTICAL
;
1384 pos
= GetVirtualSize().y
/ wxHTML_SCROLL_STEP
;
1386 else // this should be impossible
1388 // but seems to happen sometimes under wxMSW - maybe it's a bug
1389 // there but for now just ignore it
1391 //wxFAIL_MSG( _T("can't understand where has mouse gone") );
1397 // only start the auto scroll timer if the window can be scrolled in
1399 if ( !HasScrollbar(orient
) )
1402 delete m_timerAutoScroll
;
1403 m_timerAutoScroll
= new wxHtmlWinAutoScrollTimer
1406 pos
== 0 ? wxEVT_SCROLLWIN_LINEUP
1407 : wxEVT_SCROLLWIN_LINEDOWN
,
1411 m_timerAutoScroll
->Start(50); // FIXME: make configurable
1415 void wxHtmlWindow::OnKeyUp(wxKeyEvent
& event
)
1417 if ( IsSelectionEnabled() &&
1418 (event
.GetKeyCode() == 'C' && event
.CmdDown()) )
1420 wxClipboardTextEvent
evt(wxEVT_COMMAND_TEXT_COPY
, GetId());
1422 evt
.SetEventObject(this);
1424 GetEventHandler()->ProcessEvent(evt
);
1428 void wxHtmlWindow::OnCopy(wxCommandEvent
& WXUNUSED(event
))
1430 (void) CopySelection();
1433 void wxHtmlWindow::OnClipboardEvent(wxClipboardTextEvent
& WXUNUSED(event
))
1435 (void) CopySelection();
1438 void wxHtmlWindow::OnDoubleClick(wxMouseEvent
& event
)
1440 // select word under cursor:
1441 if ( IsSelectionEnabled() )
1443 SelectWord(CalcUnscrolledPosition(event
.GetPosition()));
1445 (void) CopySelection(Primary
);
1447 m_lastDoubleClick
= wxGetLocalTimeMillis();
1453 void wxHtmlWindow::SelectWord(const wxPoint
& pos
)
1457 wxHtmlCell
*cell
= m_Cell
->FindCellByPos(pos
.x
, pos
.y
);
1461 m_selection
= new wxHtmlSelection();
1462 m_selection
->Set(cell
, cell
);
1463 RefreshRect(wxRect(CalcScrolledPosition(cell
->GetAbsPos()),
1464 wxSize(cell
->GetWidth(), cell
->GetHeight())));
1469 void wxHtmlWindow::SelectLine(const wxPoint
& pos
)
1473 wxHtmlCell
*cell
= m_Cell
->FindCellByPos(pos
.x
, pos
.y
);
1476 // We use following heuristic to find a "line": let the line be all
1477 // cells in same container as the cell under mouse cursor that are
1478 // neither completely above nor completely bellow the clicked cell
1479 // (i.e. are likely to be words positioned on same line of text).
1481 int y1
= cell
->GetAbsPos().y
;
1482 int y2
= y1
+ cell
->GetHeight();
1484 const wxHtmlCell
*c
;
1485 const wxHtmlCell
*before
= NULL
;
1486 const wxHtmlCell
*after
= NULL
;
1488 // find last cell of line:
1489 for ( c
= cell
->GetNext(); c
; c
= c
->GetNext())
1491 y
= c
->GetAbsPos().y
;
1492 if ( y
+ c
->GetHeight() > y1
&& y
< y2
)
1500 // find first cell of line:
1501 for ( c
= cell
->GetParent()->GetFirstChild();
1502 c
&& c
!= cell
; c
= c
->GetNext())
1504 y
= c
->GetAbsPos().y
;
1505 if ( y
+ c
->GetHeight() > y1
&& y
< y2
)
1517 m_selection
= new wxHtmlSelection();
1518 m_selection
->Set(before
, after
);
1525 void wxHtmlWindow::SelectAll()
1530 m_selection
= new wxHtmlSelection();
1531 m_selection
->Set(m_Cell
->GetFirstTerminal(), m_Cell
->GetLastTerminal());
1536 #endif // wxUSE_CLIPBOARD
1540 IMPLEMENT_ABSTRACT_CLASS(wxHtmlProcessor
,wxObject
)
1542 #if wxUSE_EXTENDED_RTTI
1543 IMPLEMENT_DYNAMIC_CLASS_XTI(wxHtmlWindow
, wxScrolledWindow
,"wx/html/htmlwin.h")
1545 wxBEGIN_PROPERTIES_TABLE(wxHtmlWindow
)
1548 style , wxHW_SCROLLBAR_AUTO
1549 borders , (dimension)
1553 wxEND_PROPERTIES_TABLE()
1555 wxBEGIN_HANDLERS_TABLE(wxHtmlWindow
)
1556 wxEND_HANDLERS_TABLE()
1558 wxCONSTRUCTOR_5( wxHtmlWindow
, wxWindow
* , Parent
, wxWindowID
, Id
, wxPoint
, Position
, wxSize
, Size
, long , WindowStyle
)
1560 IMPLEMENT_DYNAMIC_CLASS(wxHtmlWindow
,wxScrolledWindow
)
1563 BEGIN_EVENT_TABLE(wxHtmlWindow
, wxScrolledWindow
)
1564 EVT_SIZE(wxHtmlWindow::OnSize
)
1565 EVT_LEFT_DOWN(wxHtmlWindow::OnMouseDown
)
1566 EVT_LEFT_UP(wxHtmlWindow::OnMouseUp
)
1567 EVT_RIGHT_UP(wxHtmlWindow::OnMouseUp
)
1568 EVT_MOTION(wxHtmlWindow::OnMouseMove
)
1569 EVT_ERASE_BACKGROUND(wxHtmlWindow::OnEraseBackground
)
1570 EVT_PAINT(wxHtmlWindow::OnPaint
)
1572 EVT_LEFT_DCLICK(wxHtmlWindow::OnDoubleClick
)
1573 EVT_ENTER_WINDOW(wxHtmlWindow::OnMouseEnter
)
1574 EVT_LEAVE_WINDOW(wxHtmlWindow::OnMouseLeave
)
1575 EVT_MOUSE_CAPTURE_LOST(wxHtmlWindow::OnMouseCaptureLost
)
1576 EVT_KEY_UP(wxHtmlWindow::OnKeyUp
)
1577 EVT_MENU(wxID_COPY
, wxHtmlWindow::OnCopy
)
1578 EVT_TEXT_COPY(wxID_ANY
, wxHtmlWindow::OnClipboardEvent
)
1579 #endif // wxUSE_CLIPBOARD
1582 //-----------------------------------------------------------------------------
1583 // wxHtmlWindowInterface implementation in wxHtmlWindow
1584 //-----------------------------------------------------------------------------
1586 void wxHtmlWindow::SetHTMLWindowTitle(const wxString
& title
)
1591 void wxHtmlWindow::OnHTMLLinkClicked(const wxHtmlLinkInfo
& link
)
1593 OnLinkClicked(link
);
1596 wxHtmlOpeningStatus
wxHtmlWindow::OnHTMLOpeningURL(wxHtmlURLType type
,
1597 const wxString
& url
,
1598 wxString
*redirect
) const
1600 return OnOpeningURL(type
, url
, redirect
);
1603 wxPoint
wxHtmlWindow::HTMLCoordsToWindow(wxHtmlCell
*WXUNUSED(cell
),
1604 const wxPoint
& pos
) const
1606 return CalcScrolledPosition(pos
);
1609 wxWindow
* wxHtmlWindow::GetHTMLWindow()
1614 wxColour
wxHtmlWindow::GetHTMLBackgroundColour() const
1616 return GetBackgroundColour();
1619 void wxHtmlWindow::SetHTMLBackgroundColour(const wxColour
& clr
)
1621 SetBackgroundColour(clr
);
1624 void wxHtmlWindow::SetHTMLBackgroundImage(const wxBitmap
& bmpBg
)
1626 SetBackgroundImage(bmpBg
);
1629 void wxHtmlWindow::SetHTMLStatusText(const wxString
& text
)
1632 if (m_RelatedStatusBarIndex
!= -1)
1634 if (m_RelatedStatusBar
)
1636 m_RelatedStatusBar
->SetStatusText(text
, m_RelatedStatusBarIndex
);
1638 else if (m_RelatedFrame
)
1640 m_RelatedFrame
->SetStatusText(text
, m_RelatedStatusBarIndex
);
1645 #endif // wxUSE_STATUSBAR
1649 wxCursor
wxHtmlWindow::GetDefaultHTMLCursor(HTMLCursor type
)
1653 case HTMLCursor_Link
:
1654 if ( !ms_cursorLink
)
1655 ms_cursorLink
= new wxCursor(wxCURSOR_HAND
);
1656 return *ms_cursorLink
;
1658 case HTMLCursor_Text
:
1659 if ( !ms_cursorText
)
1660 ms_cursorText
= new wxCursor(wxCURSOR_IBEAM
);
1661 return *ms_cursorText
;
1663 case HTMLCursor_Default
:
1665 return *wxSTANDARD_CURSOR
;
1669 wxCursor
wxHtmlWindow::GetHTMLCursor(HTMLCursor type
) const
1671 return GetDefaultHTMLCursor(type
);
1675 //-----------------------------------------------------------------------------
1677 //-----------------------------------------------------------------------------
1679 // A module to allow initialization/cleanup
1680 // without calling these functions from app.cpp or from
1681 // the user's application.
1683 class wxHtmlWinModule
: public wxModule
1685 DECLARE_DYNAMIC_CLASS(wxHtmlWinModule
)
1687 wxHtmlWinModule() : wxModule() {}
1688 bool OnInit() { return true; }
1689 void OnExit() { wxHtmlWindow::CleanUpStatics(); }
1692 IMPLEMENT_DYNAMIC_CLASS(wxHtmlWinModule
, wxModule
)
1695 // This hack forces the linker to always link in m_* files
1696 // (wxHTML doesn't work without handlers from these files)
1697 #include "wx/html/forcelnk.h"
1698 FORCE_WXHTML_MODULES()
1700 #endif // wxUSE_HTML