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"
38 // uncomment this line to visually show the extent of the selection
39 //#define DEBUG_HTML_SELECTION
42 IMPLEMENT_DYNAMIC_CLASS(wxHtmlLinkEvent
, wxCommandEvent
)
43 IMPLEMENT_DYNAMIC_CLASS(wxHtmlCellEvent
, wxCommandEvent
)
45 wxDEFINE_EVENT( wxEVT_COMMAND_HTML_CELL_CLICKED
, wxHtmlCellEvent
);
46 wxDEFINE_EVENT( wxEVT_COMMAND_HTML_CELL_HOVER
, wxHtmlCellEvent
);
47 wxDEFINE_EVENT( wxEVT_COMMAND_HTML_LINK_CLICKED
, wxHtmlLinkEvent
);
51 // ----------------------------------------------------------------------------
52 // wxHtmlWinAutoScrollTimer: the timer used to generate a stream of scroll
53 // events when a captured mouse is held outside the window
54 // ----------------------------------------------------------------------------
56 class wxHtmlWinAutoScrollTimer
: public wxTimer
59 wxHtmlWinAutoScrollTimer(wxScrolledWindow
*win
,
60 wxEventType eventTypeToSend
,
64 m_eventType
= eventTypeToSend
;
69 virtual void Notify();
72 wxScrolledWindow
*m_win
;
73 wxEventType m_eventType
;
77 wxDECLARE_NO_COPY_CLASS(wxHtmlWinAutoScrollTimer
);
80 void wxHtmlWinAutoScrollTimer::Notify()
82 // only do all this as long as the window is capturing the mouse
83 if ( wxWindow::GetCapture() != m_win
)
87 else // we still capture the mouse, continue generating events
89 // first scroll the window if we are allowed to do it
90 wxScrollWinEvent
event1(m_eventType
, m_pos
, m_orient
);
91 event1
.SetEventObject(m_win
);
92 if ( m_win
->GetEventHandler()->ProcessEvent(event1
) )
94 // and then send a pseudo mouse-move event to refresh the selection
95 wxMouseEvent
event2(wxEVT_MOTION
);
96 wxGetMousePosition(&event2
.m_x
, &event2
.m_y
);
98 // the mouse event coordinates should be client, not screen as
99 // returned by wxGetMousePosition
100 wxWindow
*parentTop
= m_win
;
101 while ( parentTop
->GetParent() )
102 parentTop
= parentTop
->GetParent();
103 wxPoint ptOrig
= parentTop
->GetPosition();
104 event2
.m_x
-= ptOrig
.x
;
105 event2
.m_y
-= ptOrig
.y
;
107 event2
.SetEventObject(m_win
);
109 // FIXME: we don't fill in the other members - ok?
110 m_win
->GetEventHandler()->ProcessEvent(event2
);
112 else // can't scroll further, stop
119 #endif // wxUSE_CLIPBOARD
123 //-----------------------------------------------------------------------------
125 //-----------------------------------------------------------------------------
127 // item of history list
128 class WXDLLIMPEXP_HTML wxHtmlHistoryItem
131 wxHtmlHistoryItem(const wxString
& p
, const wxString
& a
) {m_Page
= p
, m_Anchor
= a
, m_Pos
= 0;}
132 int GetPos() const {return m_Pos
;}
133 void SetPos(int p
) {m_Pos
= p
;}
134 const wxString
& GetPage() const {return m_Page
;}
135 const wxString
& GetAnchor() const {return m_Anchor
;}
144 //-----------------------------------------------------------------------------
145 // our private arrays:
146 //-----------------------------------------------------------------------------
148 WX_DECLARE_OBJARRAY(wxHtmlHistoryItem
, wxHtmlHistoryArray
);
149 WX_DEFINE_OBJARRAY(wxHtmlHistoryArray
)
151 WX_DECLARE_LIST(wxHtmlProcessor
, wxHtmlProcessorList
);
152 WX_DEFINE_LIST(wxHtmlProcessorList
)
154 //-----------------------------------------------------------------------------
155 // wxHtmlWindowMouseHelper
156 //-----------------------------------------------------------------------------
158 wxHtmlWindowMouseHelper::wxHtmlWindowMouseHelper(wxHtmlWindowInterface
*iface
)
159 : m_tmpMouseMoved(false),
166 void wxHtmlWindowMouseHelper::HandleMouseMoved()
168 m_tmpMouseMoved
= true;
171 bool wxHtmlWindowMouseHelper::HandleMouseClick(wxHtmlCell
*rootCell
,
173 const wxMouseEvent
& event
)
178 wxHtmlCell
*cell
= rootCell
->FindCellByPos(pos
.x
, pos
.y
);
179 // this check is needed because FindCellByPos returns terminal cell and
180 // containers may have empty borders -- in this case NULL will be
185 // adjust the coordinates to be relative to this cell:
186 wxPoint relpos
= pos
- cell
->GetAbsPos(rootCell
);
188 return OnCellClicked(cell
, relpos
.x
, relpos
.y
, event
);
191 void wxHtmlWindowMouseHelper::HandleIdle(wxHtmlCell
*rootCell
,
194 wxHtmlCell
*cell
= rootCell
? rootCell
->FindCellByPos(pos
.x
, pos
.y
) : NULL
;
196 if (cell
!= m_tmpLastCell
)
198 wxHtmlLinkInfo
*lnk
= NULL
;
201 // adjust the coordinates to be relative to this cell:
202 wxPoint relpos
= pos
- cell
->GetAbsPos(rootCell
);
203 lnk
= cell
->GetLink(relpos
.x
, relpos
.y
);
208 cur
= cell
->GetMouseCursor(m_interface
);
210 cur
= m_interface
->GetHTMLCursor(
211 wxHtmlWindowInterface::HTMLCursor_Default
);
213 m_interface
->GetHTMLWindow()->SetCursor(cur
);
215 if (lnk
!= m_tmpLastLink
)
218 m_interface
->SetHTMLStatusText(lnk
->GetHref());
220 m_interface
->SetHTMLStatusText(wxEmptyString
);
225 m_tmpLastCell
= cell
;
227 else // mouse moved but stayed in the same cell
231 OnCellMouseHover(cell
, pos
.x
, pos
.y
);
235 m_tmpMouseMoved
= false;
238 bool wxHtmlWindowMouseHelper::OnCellClicked(wxHtmlCell
*cell
,
239 wxCoord x
, wxCoord y
,
240 const wxMouseEvent
& event
)
242 wxHtmlCellEvent
ev(wxEVT_COMMAND_HTML_CELL_CLICKED
,
243 m_interface
->GetHTMLWindow()->GetId(),
244 cell
, wxPoint(x
,y
), event
);
246 if (!m_interface
->GetHTMLWindow()->GetEventHandler()->ProcessEvent(ev
))
248 // if the event wasn't handled, do the default processing here:
250 wxASSERT_MSG( cell
, wxT("can't be called with NULL cell") );
252 cell
->ProcessMouseClick(m_interface
, ev
.GetPoint(), ev
.GetMouseEvent());
255 // true if a link was clicked, false otherwise
256 return ev
.GetLinkClicked();
259 void wxHtmlWindowMouseHelper::OnCellMouseHover(wxHtmlCell
* cell
,
263 wxHtmlCellEvent
ev(wxEVT_COMMAND_HTML_CELL_HOVER
,
264 m_interface
->GetHTMLWindow()->GetId(),
265 cell
, wxPoint(x
,y
), wxMouseEvent());
266 m_interface
->GetHTMLWindow()->GetEventHandler()->ProcessEvent(ev
);
272 //-----------------------------------------------------------------------------
274 //-----------------------------------------------------------------------------
276 wxList
wxHtmlWindow::m_Filters
;
277 wxHtmlFilter
*wxHtmlWindow::m_DefaultFilter
= NULL
;
278 wxHtmlProcessorList
*wxHtmlWindow::m_GlobalProcessors
= NULL
;
279 wxCursor
*wxHtmlWindow::ms_cursorLink
= NULL
;
280 wxCursor
*wxHtmlWindow::ms_cursorText
= NULL
;
282 void wxHtmlWindow::CleanUpStatics()
284 wxDELETE(m_DefaultFilter
);
285 WX_CLEAR_LIST(wxList
, m_Filters
);
286 if (m_GlobalProcessors
)
287 WX_CLEAR_LIST(wxHtmlProcessorList
, *m_GlobalProcessors
);
288 wxDELETE(m_GlobalProcessors
);
289 wxDELETE(ms_cursorLink
);
290 wxDELETE(ms_cursorText
);
293 void wxHtmlWindow::Init()
295 m_tmpCanDrawLocks
= 0;
296 m_FS
= new wxFileSystem();
298 m_RelatedStatusBar
= NULL
;
299 m_RelatedStatusBarIndex
= -1;
300 #endif // wxUSE_STATUSBAR
301 m_RelatedFrame
= NULL
;
302 m_TitleFormat
= wxT("%s");
303 m_OpenedPage
= m_OpenedAnchor
= m_OpenedPageTitle
= wxEmptyString
;
305 m_Parser
= new wxHtmlWinParser(this);
306 m_Parser
->SetFS(m_FS
);
309 m_History
= new wxHtmlHistoryArray
;
313 m_makingSelection
= false;
315 m_timerAutoScroll
= NULL
;
316 m_lastDoubleClick
= 0;
317 #endif // wxUSE_CLIPBOARD
318 m_tmpSelFromCell
= NULL
;
321 bool wxHtmlWindow::Create(wxWindow
*parent
, wxWindowID id
,
322 const wxPoint
& pos
, const wxSize
& size
,
323 long style
, const wxString
& name
)
325 if (!wxScrolledWindow::Create(parent
, id
, pos
, size
,
326 style
| wxVSCROLL
| wxHSCROLL
,
330 // We can't erase our background in EVT_ERASE_BACKGROUND handler and use
331 // double buffering in EVT_PAINT handler as this requires blitting back
332 // something already drawn on the window to the backing store bitmap when
333 // handling EVT_PAINT but blitting in this direction is simply not
334 // supported by OS X.
336 // So instead we use a hack with artificial EVT_ERASE_BACKGROUND generation
337 // from OnPaint() and this means that we never need the "real" erase event
338 // at all so disable it to avoid executing any user-defined handlers twice
339 // (and to avoid processing unnecessary event if no handlers are defined).
340 SetBackgroundStyle(wxBG_STYLE_PAINT
);
342 SetPage(wxT("<html><body></body></html>"));
347 wxHtmlWindow::~wxHtmlWindow()
351 #endif // wxUSE_CLIPBOARD
360 WX_CLEAR_LIST(wxHtmlProcessorList
, *m_Processors
);
371 void wxHtmlWindow::SetRelatedFrame(wxFrame
* frame
, const wxString
& format
)
373 m_RelatedFrame
= frame
;
374 m_TitleFormat
= format
;
380 void wxHtmlWindow::SetRelatedStatusBar(int index
)
382 m_RelatedStatusBarIndex
= index
;
385 void wxHtmlWindow::SetRelatedStatusBar(wxStatusBar
* statusbar
, int index
)
387 m_RelatedStatusBar
= statusbar
;
388 m_RelatedStatusBarIndex
= index
;
391 #endif // wxUSE_STATUSBAR
395 void wxHtmlWindow::SetFonts(const wxString
& normal_face
, const wxString
& fixed_face
, const int *sizes
)
397 m_Parser
->SetFonts(normal_face
, fixed_face
, sizes
);
399 // re-layout the page after changing fonts:
400 DoSetPage(*(m_Parser
->GetSource()));
403 void wxHtmlWindow::SetStandardFonts(int size
,
404 const wxString
& normal_face
,
405 const wxString
& fixed_face
)
407 m_Parser
->SetStandardFonts(size
, normal_face
, fixed_face
);
409 // re-layout the page after changing fonts:
410 DoSetPage(*(m_Parser
->GetSource()));
413 bool wxHtmlWindow::SetPage(const wxString
& source
)
415 m_OpenedPage
= m_OpenedAnchor
= m_OpenedPageTitle
= wxEmptyString
;
416 return DoSetPage(source
);
419 bool wxHtmlWindow::DoSetPage(const wxString
& source
)
421 wxString
newsrc(source
);
423 wxDELETE(m_selection
);
425 // we will soon delete all the cells, so clear pointers to them:
426 m_tmpSelFromCell
= NULL
;
428 // pass HTML through registered processors:
429 if (m_Processors
|| m_GlobalProcessors
)
431 wxHtmlProcessorList::compatibility_iterator nodeL
, nodeG
;
435 nodeL
= m_Processors
->GetFirst();
436 if ( m_GlobalProcessors
)
437 nodeG
= m_GlobalProcessors
->GetFirst();
439 // VS: there are two lists, global and local, both of them sorted by
440 // priority. Since we have to go through _both_ lists with
441 // decreasing priority, we "merge-sort" the lists on-line by
442 // processing that one of the two heads that has higher priority
443 // in every iteration
444 while (nodeL
|| nodeG
)
446 prL
= (nodeL
) ? nodeL
->GetData()->GetPriority() : -1;
447 prG
= (nodeG
) ? nodeG
->GetData()->GetPriority() : -1;
450 if (nodeL
->GetData()->IsEnabled())
451 newsrc
= nodeL
->GetData()->Process(newsrc
);
452 nodeL
= nodeL
->GetNext();
456 if (nodeG
->GetData()->IsEnabled())
457 newsrc
= nodeG
->GetData()->Process(newsrc
);
458 nodeG
= nodeG
->GetNext();
463 // ...and run the parser on it:
464 wxClientDC
*dc
= new wxClientDC(this);
465 dc
->SetMapMode(wxMM_TEXT
);
466 SetBackgroundColour(wxColour(0xFF, 0xFF, 0xFF));
467 SetBackgroundImage(wxNullBitmap
);
475 m_Cell
= (wxHtmlContainerCell
*) m_Parser
->Parse(newsrc
);
477 m_Cell
->SetIndent(m_Borders
, wxHTML_INDENT_ALL
, wxHTML_UNITS_PIXELS
);
478 m_Cell
->SetAlignHor(wxHTML_ALIGN_CENTER
);
480 if (m_tmpCanDrawLocks
== 0)
485 bool wxHtmlWindow::AppendToPage(const wxString
& source
)
487 return DoSetPage(*(GetParser()->GetSource()) + source
);
490 bool wxHtmlWindow::LoadPage(const wxString
& location
)
492 wxCHECK_MSG( !location
.empty(), false, "location must be non-empty" );
494 wxBusyCursor busyCursor
;
497 bool needs_refresh
= false;
500 if (m_HistoryOn
&& (m_HistoryPos
!= -1))
502 // store scroll position into history item:
504 GetViewStart(&x
, &y
);
505 (*m_History
)[m_HistoryPos
].SetPos(y
);
508 // first check if we're moving to an anchor in the same page
509 size_t posLocalAnchor
= location
.Find('#');
510 if ( posLocalAnchor
!= wxString::npos
&& posLocalAnchor
!= 0 )
512 // check if the part before the anchor is the same as the (either
513 // relative or absolute) URI of the current page
514 const wxString beforeAnchor
= location
.substr(0, posLocalAnchor
);
515 if ( beforeAnchor
!= m_OpenedPage
&&
516 m_FS
->GetPath() + beforeAnchor
!= m_OpenedPage
)
518 // indicate that we're not moving to a local anchor
519 posLocalAnchor
= wxString::npos
;
523 if ( posLocalAnchor
!= wxString::npos
)
526 rt_val
= ScrollToAnchor(location
.substr(posLocalAnchor
+ 1));
529 else // moving to another page
531 needs_refresh
= true;
534 if (m_RelatedStatusBarIndex
!= -1)
536 SetHTMLStatusText(_("Connecting..."));
539 #endif // wxUSE_STATUSBAR
541 wxFSFile
*f
= m_Parser
->OpenURL(wxHTML_URL_PAGE
, location
);
543 // try to interpret 'location' as filename instead of URL:
546 wxFileName
fn(location
);
547 wxString location2
= wxFileSystem::FileNameToURL(fn
);
548 f
= m_Parser
->OpenURL(wxHTML_URL_PAGE
, location2
);
553 wxLogError(_("Unable to open requested HTML document: %s"), location
.c_str());
555 SetHTMLStatusText(wxEmptyString
);
561 wxList::compatibility_iterator node
;
562 wxString src
= wxEmptyString
;
565 if (m_RelatedStatusBarIndex
!= -1)
567 wxString msg
= _("Loading : ") + location
;
568 SetHTMLStatusText(msg
);
571 #endif // wxUSE_STATUSBAR
573 node
= m_Filters
.GetFirst();
576 wxHtmlFilter
*h
= (wxHtmlFilter
*) node
->GetData();
579 src
= h
->ReadFile(*f
);
582 node
= node
->GetNext();
584 if (src
== wxEmptyString
)
586 if (m_DefaultFilter
== NULL
) m_DefaultFilter
= GetDefaultFilter();
587 src
= m_DefaultFilter
->ReadFile(*f
);
590 m_FS
->ChangePathTo(f
->GetLocation());
591 rt_val
= SetPage(src
);
592 m_OpenedPage
= f
->GetLocation();
593 if (f
->GetAnchor() != wxEmptyString
)
595 ScrollToAnchor(f
->GetAnchor());
601 if (m_RelatedStatusBarIndex
!= -1)
603 SetHTMLStatusText(_("Done"));
605 #endif // wxUSE_STATUSBAR
609 if (m_HistoryOn
) // add this page to history there:
611 int c
= m_History
->GetCount() - (m_HistoryPos
+ 1);
613 if (m_HistoryPos
< 0 ||
614 (*m_History
)[m_HistoryPos
].GetPage() != m_OpenedPage
||
615 (*m_History
)[m_HistoryPos
].GetAnchor() != m_OpenedAnchor
)
618 for (int i
= 0; i
< c
; i
++)
619 m_History
->RemoveAt(m_HistoryPos
);
620 m_History
->Add(new wxHtmlHistoryItem(m_OpenedPage
, m_OpenedAnchor
));
624 if (m_OpenedPageTitle
== wxEmptyString
)
625 OnSetTitle(wxFileNameFromPath(m_OpenedPage
));
639 bool wxHtmlWindow::LoadFile(const wxFileName
& filename
)
641 wxString url
= wxFileSystem::FileNameToURL(filename
);
642 return LoadPage(url
);
646 bool wxHtmlWindow::ScrollToAnchor(const wxString
& anchor
)
648 const wxHtmlCell
*c
= m_Cell
->Find(wxHTML_COND_ISANCHOR
, &anchor
);
651 wxLogWarning(_("HTML anchor %s does not exist."), anchor
.c_str());
658 for (y
= 0; c
!= NULL
; c
= c
->GetParent()) y
+= c
->GetPosY();
659 Scroll(-1, y
/ wxHTML_SCROLL_STEP
);
660 m_OpenedAnchor
= anchor
;
666 void wxHtmlWindow::OnSetTitle(const wxString
& title
)
671 tit
.Printf(m_TitleFormat
, title
.c_str());
672 m_RelatedFrame
->SetTitle(tit
);
674 m_OpenedPageTitle
= title
;
681 void wxHtmlWindow::CreateLayout()
683 int ClientWidth
, ClientHeight
;
687 if ( HasFlag(wxHW_SCROLLBAR_NEVER
) )
689 SetScrollbars(1, 1, 0, 0); // always off
690 GetClientSize(&ClientWidth
, &ClientHeight
);
691 m_Cell
->Layout(ClientWidth
);
693 else // !wxHW_SCROLLBAR_NEVER
695 GetClientSize(&ClientWidth
, &ClientHeight
);
696 m_Cell
->Layout(ClientWidth
);
697 if (ClientHeight
< m_Cell
->GetHeight() + GetCharHeight())
700 wxHTML_SCROLL_STEP
, wxHTML_SCROLL_STEP
,
701 m_Cell
->GetWidth() / wxHTML_SCROLL_STEP
,
702 (m_Cell
->GetHeight() + GetCharHeight()) / wxHTML_SCROLL_STEP
703 /*cheat: top-level frag is always container*/);
705 else /* we fit into window, no need for scrollbars */
707 SetScrollbars(wxHTML_SCROLL_STEP
, 1, m_Cell
->GetWidth() / wxHTML_SCROLL_STEP
, 0); // disable...
708 GetClientSize(&ClientWidth
, &ClientHeight
);
709 m_Cell
->Layout(ClientWidth
); // ...and relayout
716 void wxHtmlWindow::ReadCustomization(wxConfigBase
*cfg
, wxString path
)
721 wxString p_fff
, p_ffn
;
723 if (path
!= wxEmptyString
)
725 oldpath
= cfg
->GetPath();
729 m_Borders
= cfg
->Read(wxT("wxHtmlWindow/Borders"), m_Borders
);
730 p_fff
= cfg
->Read(wxT("wxHtmlWindow/FontFaceFixed"), m_Parser
->m_FontFaceFixed
);
731 p_ffn
= cfg
->Read(wxT("wxHtmlWindow/FontFaceNormal"), m_Parser
->m_FontFaceNormal
);
732 for (int i
= 0; i
< 7; i
++)
734 tmp
.Printf(wxT("wxHtmlWindow/FontsSize%i"), i
);
735 p_fontsizes
[i
] = cfg
->Read(tmp
, m_Parser
->m_FontsSizes
[i
]);
737 SetFonts(p_ffn
, p_fff
, p_fontsizes
);
739 if (path
!= wxEmptyString
)
740 cfg
->SetPath(oldpath
);
745 void wxHtmlWindow::WriteCustomization(wxConfigBase
*cfg
, wxString path
)
750 if (path
!= wxEmptyString
)
752 oldpath
= cfg
->GetPath();
756 cfg
->Write(wxT("wxHtmlWindow/Borders"), (long) m_Borders
);
757 cfg
->Write(wxT("wxHtmlWindow/FontFaceFixed"), m_Parser
->m_FontFaceFixed
);
758 cfg
->Write(wxT("wxHtmlWindow/FontFaceNormal"), m_Parser
->m_FontFaceNormal
);
759 for (int i
= 0; i
< 7; i
++)
761 tmp
.Printf(wxT("wxHtmlWindow/FontsSize%i"), i
);
762 cfg
->Write(tmp
, (long) m_Parser
->m_FontsSizes
[i
]);
765 if (path
!= wxEmptyString
)
766 cfg
->SetPath(oldpath
);
771 bool wxHtmlWindow::HistoryBack()
775 if (m_HistoryPos
< 1) return false;
777 // store scroll position into history item:
779 GetViewStart(&x
, &y
);
780 (*m_History
)[m_HistoryPos
].SetPos(y
);
782 // go to previous position:
785 l
= (*m_History
)[m_HistoryPos
].GetPage();
786 a
= (*m_History
)[m_HistoryPos
].GetAnchor();
789 if (a
== wxEmptyString
) LoadPage(l
);
790 else LoadPage(l
+ wxT("#") + a
);
793 Scroll(0, (*m_History
)[m_HistoryPos
].GetPos());
798 bool wxHtmlWindow::HistoryCanBack()
800 if (m_HistoryPos
< 1) return false;
805 bool wxHtmlWindow::HistoryForward()
809 if (m_HistoryPos
== -1) return false;
810 if (m_HistoryPos
>= (int)m_History
->GetCount() - 1)return false;
812 m_OpenedPage
= wxEmptyString
; // this will disable adding new entry into history in LoadPage()
815 l
= (*m_History
)[m_HistoryPos
].GetPage();
816 a
= (*m_History
)[m_HistoryPos
].GetAnchor();
819 if (a
== wxEmptyString
) LoadPage(l
);
820 else LoadPage(l
+ wxT("#") + a
);
823 Scroll(0, (*m_History
)[m_HistoryPos
].GetPos());
828 bool wxHtmlWindow::HistoryCanForward()
830 if (m_HistoryPos
== -1) return false;
831 if (m_HistoryPos
>= (int)m_History
->GetCount() - 1)return false;
836 void wxHtmlWindow::HistoryClear()
842 void wxHtmlWindow::AddProcessor(wxHtmlProcessor
*processor
)
846 m_Processors
= new wxHtmlProcessorList
;
848 wxHtmlProcessorList::compatibility_iterator node
;
850 for (node
= m_Processors
->GetFirst(); node
; node
= node
->GetNext())
852 if (processor
->GetPriority() > node
->GetData()->GetPriority())
854 m_Processors
->Insert(node
, processor
);
858 m_Processors
->Append(processor
);
861 /*static */ void wxHtmlWindow::AddGlobalProcessor(wxHtmlProcessor
*processor
)
863 if (!m_GlobalProcessors
)
865 m_GlobalProcessors
= new wxHtmlProcessorList
;
867 wxHtmlProcessorList::compatibility_iterator node
;
869 for (node
= m_GlobalProcessors
->GetFirst(); node
; node
= node
->GetNext())
871 if (processor
->GetPriority() > node
->GetData()->GetPriority())
873 m_GlobalProcessors
->Insert(node
, processor
);
877 m_GlobalProcessors
->Append(processor
);
882 void wxHtmlWindow::AddFilter(wxHtmlFilter
*filter
)
884 m_Filters
.Append(filter
);
888 bool wxHtmlWindow::IsSelectionEnabled() const
891 return !HasFlag(wxHW_NO_SELECTION
);
899 wxString
wxHtmlWindow::DoSelectionToText(wxHtmlSelection
*sel
)
902 return wxEmptyString
;
907 wxHtmlTerminalCellsInterator
i(sel
->GetFromCell(), sel
->GetToCell());
908 const wxHtmlCell
*prev
= NULL
;
912 // When converting HTML content to plain text, the entire paragraph
913 // (container in wxHTML) goes on single line. A new paragraph (that
914 // should go on its own line) has its own container. Therefore, the
915 // simplest way of detecting where to insert newlines in plain text
916 // is to check if the parent container changed -- if it did, we moved
917 // to a new paragraph.
918 if ( prev
&& prev
->GetParent() != i
->GetParent() )
921 // NB: we don't need to pass the selection to ConvertToText() in the
922 // middle of the selected text; it's only useful when only part of
923 // a cell is selected
924 text
<< i
->ConvertToText(sel
);
932 wxString
wxHtmlWindow::ToText()
937 sel
.Set(m_Cell
->GetFirstTerminal(), m_Cell
->GetLastTerminal());
938 return DoSelectionToText(&sel
);
941 return wxEmptyString
;
944 #endif // wxUSE_CLIPBOARD
946 bool wxHtmlWindow::CopySelection(ClipboardType t
)
951 #if defined(__UNIX__) && !defined(__WXMAC__)
952 wxTheClipboard
->UsePrimarySelection(t
== Primary
);
954 // Primary selection exists only under X11, so don't do anything under
955 // the other platforms when we try to access it
957 // TODO: this should be abstracted at wxClipboard level!
960 #endif // __UNIX__/!__UNIX__
962 if ( wxTheClipboard
->Open() )
964 const wxString
txt(SelectionToText());
965 wxTheClipboard
->SetData(new wxTextDataObject(txt
));
966 wxTheClipboard
->Close();
967 wxLogTrace(wxT("wxhtmlselection"),
968 _("Copied to clipboard:\"%s\""), txt
.c_str());
975 #endif // wxUSE_CLIPBOARD
981 void wxHtmlWindow::OnLinkClicked(const wxHtmlLinkInfo
& link
)
983 wxHtmlLinkEvent
event(GetId(), link
);
984 event
.SetEventObject(this);
985 if (!GetEventHandler()->ProcessEvent(event
))
987 // the default behaviour is to load the URL in this window
988 const wxMouseEvent
*e
= event
.GetLinkInfo().GetEvent();
989 if (e
== NULL
|| e
->LeftUp())
990 LoadPage(event
.GetLinkInfo().GetHref());
994 void wxHtmlWindow::DoEraseBackground(wxDC
& dc
)
996 // if we don't have any background bitmap we just fill it with background
997 // colour and we also must do it if the background bitmap is not fully
998 // opaque as otherwise junk could be left there
999 if ( !m_bmpBg
.IsOk() || m_bmpBg
.GetMask() )
1001 dc
.SetBackground(GetBackgroundColour());
1005 if ( m_bmpBg
.IsOk() )
1007 // draw the background bitmap tiling it over the entire window area
1008 const wxSize sz
= GetClientSize();
1009 const wxSize
sizeBmp(m_bmpBg
.GetWidth(), m_bmpBg
.GetHeight());
1010 for ( wxCoord x
= 0; x
< sz
.x
; x
+= sizeBmp
.x
)
1012 for ( wxCoord y
= 0; y
< sz
.y
; y
+= sizeBmp
.y
)
1014 dc
.DrawBitmap(m_bmpBg
, x
, y
, true /* use mask */);
1020 void wxHtmlWindow::OnPaint(wxPaintEvent
& WXUNUSED(event
))
1022 wxPaintDC
dcPaint(this);
1024 if (m_tmpCanDrawLocks
> 0 || m_Cell
== NULL
)
1028 GetViewStart(&x
, &y
);
1029 const wxRect rect
= GetUpdateRegion().GetBox();
1030 const wxSize sz
= GetClientSize();
1032 // set up the DC we're drawing on: if the window is already double buffered
1033 // we do it directly on wxPaintDC, otherwise we allocate a backing store
1034 // buffer and compose the drawing there and then blit it to screen all at
1038 if ( IsDoubleBuffered() )
1042 else // window is not double buffered by the system, do it ourselves
1044 if ( !m_backBuffer
.IsOk() )
1045 m_backBuffer
.Create(sz
.x
, sz
.y
);
1046 dcm
.SelectObject(m_backBuffer
);
1052 // erase the background: for compatibility, we must generate the event to
1053 // allow the user-defined handlers to do it
1054 wxEraseEvent
eraseEvent(GetId(), dc
);
1055 eraseEvent
.SetEventObject(this);
1056 if ( !ProcessWindowEvent(eraseEvent
) )
1058 // erase background ourselves
1059 DoEraseBackground(*dc
);
1061 //else: background erased by the user-defined handler
1064 // draw the HTML window contents
1065 dc
->SetMapMode(wxMM_TEXT
);
1066 dc
->SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT
);
1068 wxHtmlRenderingInfo rinfo
;
1069 wxDefaultHtmlRenderingStyle rstyle
;
1070 rinfo
.SetSelection(m_selection
);
1071 rinfo
.SetStyle(&rstyle
);
1072 m_Cell
->Draw(*dc
, 0, 0,
1073 y
* wxHTML_SCROLL_STEP
+ rect
.GetTop(),
1074 y
* wxHTML_SCROLL_STEP
+ rect
.GetBottom(),
1077 #ifdef DEBUG_HTML_SELECTION
1080 wxGetMousePosition(&xc
, &yc
);
1081 ScreenToClient(&xc
, &yc
);
1082 CalcUnscrolledPosition(xc
, yc
, &x
, &y
);
1083 wxHtmlCell
*at
= m_Cell
->FindCellByPos(x
, y
);
1084 wxHtmlCell
*before
=
1085 m_Cell
->FindCellByPos(x
, y
, wxHTML_FIND_NEAREST_BEFORE
);
1087 m_Cell
->FindCellByPos(x
, y
, wxHTML_FIND_NEAREST_AFTER
);
1089 dc
->SetBrush(*wxTRANSPARENT_BRUSH
);
1090 dc
->SetPen(*wxBLACK_PEN
);
1092 dc
->DrawRectangle(at
->GetAbsPos(),
1093 wxSize(at
->GetWidth(),at
->GetHeight()));
1094 dc
->SetPen(*wxGREEN_PEN
);
1096 dc
->DrawRectangle(before
->GetAbsPos().x
+1, before
->GetAbsPos().y
+1,
1097 before
->GetWidth()-2,before
->GetHeight()-2);
1098 dc
->SetPen(*wxRED_PEN
);
1100 dc
->DrawRectangle(after
->GetAbsPos().x
+2, after
->GetAbsPos().y
+2,
1101 after
->GetWidth()-4,after
->GetHeight()-4);
1103 #endif // DEBUG_HTML_SELECTION
1105 if ( dc
!= &dcPaint
)
1107 dc
->SetDeviceOrigin(0,0);
1108 dcPaint
.Blit(0, rect
.GetTop(),
1109 sz
.x
, rect
.GetBottom() - rect
.GetTop() + 1,
1118 void wxHtmlWindow::OnSize(wxSizeEvent
& event
)
1122 m_backBuffer
= wxNullBitmap
;
1126 // Recompute selection if necessary:
1129 m_selection
->Set(m_selection
->GetFromCell(),
1130 m_selection
->GetToCell());
1131 m_selection
->ClearPrivPos();
1138 void wxHtmlWindow::OnMouseMove(wxMouseEvent
& WXUNUSED(event
))
1140 wxHtmlWindowMouseHelper::HandleMouseMoved();
1143 void wxHtmlWindow::OnMouseDown(wxMouseEvent
& event
)
1146 if ( event
.LeftDown() && IsSelectionEnabled() )
1148 const long TRIPLECLICK_LEN
= 200; // 0.2 sec after doubleclick
1149 if ( wxGetLocalTimeMillis() - m_lastDoubleClick
<= TRIPLECLICK_LEN
)
1151 SelectLine(CalcUnscrolledPosition(event
.GetPosition()));
1153 (void) CopySelection();
1157 m_makingSelection
= true;
1161 wxDELETE(m_selection
);
1164 m_tmpSelFromPos
= CalcUnscrolledPosition(event
.GetPosition());
1165 m_tmpSelFromCell
= NULL
;
1170 #endif // wxUSE_CLIPBOARD
1172 // in any case, let the default handler set focus to this window
1176 void wxHtmlWindow::OnMouseUp(wxMouseEvent
& event
)
1179 if ( m_makingSelection
)
1182 m_makingSelection
= false;
1184 // if m_selection=NULL, the user didn't move the mouse far enough from
1185 // starting point and the mouse up event is part of a click, the user
1186 // is not selecting text:
1189 CopySelection(Primary
);
1191 // we don't want mouse up event that ended selecting to be
1192 // handled as mouse click and e.g. follow hyperlink:
1196 #endif // wxUSE_CLIPBOARD
1198 wxPoint pos
= CalcUnscrolledPosition(event
.GetPosition());
1199 wxHtmlWindowMouseHelper::HandleMouseClick(m_Cell
, pos
, event
);
1203 void wxHtmlWindow::OnMouseCaptureLost(wxMouseCaptureLostEvent
& WXUNUSED(event
))
1205 if ( !m_makingSelection
)
1208 // discard the selecting operation
1209 m_makingSelection
= false;
1210 wxDELETE(m_selection
);
1211 m_tmpSelFromCell
= NULL
;
1214 #endif // wxUSE_CLIPBOARD
1217 void wxHtmlWindow::OnInternalIdle()
1219 wxWindow::OnInternalIdle();
1221 if (m_Cell
!= NULL
&& DidMouseMove())
1223 #ifdef DEBUG_HTML_SELECTION
1227 wxGetMousePosition(&xc
, &yc
);
1228 ScreenToClient(&xc
, &yc
);
1229 CalcUnscrolledPosition(xc
, yc
, &x
, &y
);
1231 wxHtmlCell
*cell
= m_Cell
->FindCellByPos(x
, y
);
1233 // handle selection update:
1234 if ( m_makingSelection
)
1236 if ( !m_tmpSelFromCell
)
1237 m_tmpSelFromCell
= m_Cell
->FindCellByPos(
1238 m_tmpSelFromPos
.x
,m_tmpSelFromPos
.y
);
1240 // NB: a trick - we adjust selFromPos to be upper left or bottom
1241 // right corner of the first cell of the selection depending
1242 // on whether the mouse is moving to the right or to the left.
1243 // This gives us more "natural" behaviour when selecting
1244 // a line (specifically, first cell of the next line is not
1245 // included if you drag selection from left to right over
1248 if ( !m_tmpSelFromCell
)
1250 dirFromPos
= m_tmpSelFromPos
;
1254 dirFromPos
= m_tmpSelFromCell
->GetAbsPos();
1255 if ( x
< m_tmpSelFromPos
.x
)
1257 dirFromPos
.x
+= m_tmpSelFromCell
->GetWidth();
1258 dirFromPos
.y
+= m_tmpSelFromCell
->GetHeight();
1261 bool goingDown
= dirFromPos
.y
< y
||
1262 (dirFromPos
.y
== y
&& dirFromPos
.x
< x
);
1264 // determine selection span:
1265 if ( /*still*/ !m_tmpSelFromCell
)
1269 m_tmpSelFromCell
= m_Cell
->FindCellByPos(
1270 m_tmpSelFromPos
.x
,m_tmpSelFromPos
.y
,
1271 wxHTML_FIND_NEAREST_AFTER
);
1272 if (!m_tmpSelFromCell
)
1273 m_tmpSelFromCell
= m_Cell
->GetFirstTerminal();
1277 m_tmpSelFromCell
= m_Cell
->FindCellByPos(
1278 m_tmpSelFromPos
.x
,m_tmpSelFromPos
.y
,
1279 wxHTML_FIND_NEAREST_BEFORE
);
1280 if (!m_tmpSelFromCell
)
1281 m_tmpSelFromCell
= m_Cell
->GetLastTerminal();
1285 wxHtmlCell
*selcell
= cell
;
1290 selcell
= m_Cell
->FindCellByPos(x
, y
,
1291 wxHTML_FIND_NEAREST_BEFORE
);
1293 selcell
= m_Cell
->GetLastTerminal();
1297 selcell
= m_Cell
->FindCellByPos(x
, y
,
1298 wxHTML_FIND_NEAREST_AFTER
);
1300 selcell
= m_Cell
->GetFirstTerminal();
1304 // NB: it may *rarely* happen that the code above didn't find one
1305 // of the cells, e.g. if wxHtmlWindow doesn't contain any
1307 if ( selcell
&& m_tmpSelFromCell
)
1311 // start selecting only if mouse movement was big enough
1312 // (otherwise it was meant as mouse click, not selection):
1313 const int PRECISION
= 2;
1314 wxPoint diff
= m_tmpSelFromPos
- wxPoint(x
,y
);
1315 if (abs(diff
.x
) > PRECISION
|| abs(diff
.y
) > PRECISION
)
1317 m_selection
= new wxHtmlSelection();
1322 if ( m_tmpSelFromCell
->IsBefore(selcell
) )
1324 m_selection
->Set(m_tmpSelFromPos
, m_tmpSelFromCell
,
1325 wxPoint(x
,y
), selcell
);
1329 m_selection
->Set(wxPoint(x
,y
), selcell
,
1330 m_tmpSelFromPos
, m_tmpSelFromCell
);
1332 m_selection
->ClearPrivPos();
1338 // handle cursor and status bar text changes:
1340 // NB: because we're passing in 'cell' and not 'm_Cell' (so that the
1341 // leaf cell lookup isn't done twice), we need to adjust the
1342 // position for the new root:
1343 wxPoint
posInCell(x
, y
);
1345 posInCell
-= cell
->GetAbsPos();
1346 wxHtmlWindowMouseHelper::HandleIdle(cell
, posInCell
);
1351 void wxHtmlWindow::StopAutoScrolling()
1353 if ( m_timerAutoScroll
)
1355 wxDELETE(m_timerAutoScroll
);
1359 void wxHtmlWindow::OnMouseEnter(wxMouseEvent
& event
)
1361 StopAutoScrolling();
1365 void wxHtmlWindow::OnMouseLeave(wxMouseEvent
& event
)
1367 // don't prevent the usual processing of the event from taking place
1370 // when a captured mouse leave a scrolled window we start generate
1371 // scrolling events to allow, for example, extending selection beyond the
1372 // visible area in some controls
1373 if ( wxWindow::GetCapture() == this )
1375 // where is the mouse leaving?
1377 wxPoint pt
= event
.GetPosition();
1380 orient
= wxHORIZONTAL
;
1383 else if ( pt
.y
< 0 )
1385 orient
= wxVERTICAL
;
1388 else // we're lower or to the right of the window
1390 wxSize size
= GetClientSize();
1391 if ( pt
.x
> size
.x
)
1393 orient
= wxHORIZONTAL
;
1394 pos
= GetVirtualSize().x
/ wxHTML_SCROLL_STEP
;
1396 else if ( pt
.y
> size
.y
)
1398 orient
= wxVERTICAL
;
1399 pos
= GetVirtualSize().y
/ wxHTML_SCROLL_STEP
;
1401 else // this should be impossible
1403 // but seems to happen sometimes under wxMSW - maybe it's a bug
1404 // there but for now just ignore it
1406 //wxFAIL_MSG( wxT("can't understand where has mouse gone") );
1412 // only start the auto scroll timer if the window can be scrolled in
1414 if ( !HasScrollbar(orient
) )
1417 delete m_timerAutoScroll
;
1418 m_timerAutoScroll
= new wxHtmlWinAutoScrollTimer
1421 pos
== 0 ? wxEVT_SCROLLWIN_LINEUP
1422 : wxEVT_SCROLLWIN_LINEDOWN
,
1426 m_timerAutoScroll
->Start(50); // FIXME: make configurable
1430 void wxHtmlWindow::OnKeyUp(wxKeyEvent
& event
)
1432 if ( IsSelectionEnabled() &&
1433 (event
.GetKeyCode() == 'C' && event
.CmdDown()) )
1435 wxClipboardTextEvent
evt(wxEVT_COMMAND_TEXT_COPY
, GetId());
1437 evt
.SetEventObject(this);
1439 GetEventHandler()->ProcessEvent(evt
);
1443 void wxHtmlWindow::OnCopy(wxCommandEvent
& WXUNUSED(event
))
1445 (void) CopySelection();
1448 void wxHtmlWindow::OnClipboardEvent(wxClipboardTextEvent
& WXUNUSED(event
))
1450 (void) CopySelection();
1453 void wxHtmlWindow::OnDoubleClick(wxMouseEvent
& event
)
1455 // select word under cursor:
1456 if ( IsSelectionEnabled() )
1458 SelectWord(CalcUnscrolledPosition(event
.GetPosition()));
1460 (void) CopySelection(Primary
);
1462 m_lastDoubleClick
= wxGetLocalTimeMillis();
1468 void wxHtmlWindow::SelectWord(const wxPoint
& pos
)
1472 wxHtmlCell
*cell
= m_Cell
->FindCellByPos(pos
.x
, pos
.y
);
1476 m_selection
= new wxHtmlSelection();
1477 m_selection
->Set(cell
, cell
);
1478 RefreshRect(wxRect(CalcScrolledPosition(cell
->GetAbsPos()),
1479 wxSize(cell
->GetWidth(), cell
->GetHeight())));
1484 void wxHtmlWindow::SelectLine(const wxPoint
& pos
)
1488 wxHtmlCell
*cell
= m_Cell
->FindCellByPos(pos
.x
, pos
.y
);
1491 // We use following heuristic to find a "line": let the line be all
1492 // cells in same container as the cell under mouse cursor that are
1493 // neither completely above nor completely bellow the clicked cell
1494 // (i.e. are likely to be words positioned on same line of text).
1496 int y1
= cell
->GetAbsPos().y
;
1497 int y2
= y1
+ cell
->GetHeight();
1499 const wxHtmlCell
*c
;
1500 const wxHtmlCell
*before
= NULL
;
1501 const wxHtmlCell
*after
= NULL
;
1503 // find last cell of line:
1504 for ( c
= cell
->GetNext(); c
; c
= c
->GetNext())
1506 y
= c
->GetAbsPos().y
;
1507 if ( y
+ c
->GetHeight() > y1
&& y
< y2
)
1515 // find first cell of line:
1516 for ( c
= cell
->GetParent()->GetFirstChild();
1517 c
&& c
!= cell
; c
= c
->GetNext())
1519 y
= c
->GetAbsPos().y
;
1520 if ( y
+ c
->GetHeight() > y1
&& y
< y2
)
1532 m_selection
= new wxHtmlSelection();
1533 m_selection
->Set(before
, after
);
1540 void wxHtmlWindow::SelectAll()
1545 m_selection
= new wxHtmlSelection();
1546 m_selection
->Set(m_Cell
->GetFirstTerminal(), m_Cell
->GetLastTerminal());
1551 #endif // wxUSE_CLIPBOARD
1555 IMPLEMENT_ABSTRACT_CLASS(wxHtmlProcessor
,wxObject
)
1557 #if wxUSE_EXTENDED_RTTI
1558 IMPLEMENT_DYNAMIC_CLASS_XTI(wxHtmlWindow
, wxScrolledWindow
,"wx/html/htmlwin.h")
1560 wxBEGIN_PROPERTIES_TABLE(wxHtmlWindow
)
1563 style , wxHW_SCROLLBAR_AUTO
1564 borders , (dimension)
1568 wxEND_PROPERTIES_TABLE()
1570 wxBEGIN_HANDLERS_TABLE(wxHtmlWindow
)
1571 wxEND_HANDLERS_TABLE()
1573 wxCONSTRUCTOR_5( wxHtmlWindow
, wxWindow
* , Parent
, wxWindowID
, Id
, wxPoint
, Position
, wxSize
, Size
, long , WindowStyle
)
1575 IMPLEMENT_DYNAMIC_CLASS(wxHtmlWindow
,wxScrolledWindow
)
1578 BEGIN_EVENT_TABLE(wxHtmlWindow
, wxScrolledWindow
)
1579 EVT_SIZE(wxHtmlWindow::OnSize
)
1580 EVT_LEFT_DOWN(wxHtmlWindow::OnMouseDown
)
1581 EVT_LEFT_UP(wxHtmlWindow::OnMouseUp
)
1582 EVT_RIGHT_UP(wxHtmlWindow::OnMouseUp
)
1583 EVT_MOTION(wxHtmlWindow::OnMouseMove
)
1584 EVT_PAINT(wxHtmlWindow::OnPaint
)
1586 EVT_LEFT_DCLICK(wxHtmlWindow::OnDoubleClick
)
1587 EVT_ENTER_WINDOW(wxHtmlWindow::OnMouseEnter
)
1588 EVT_LEAVE_WINDOW(wxHtmlWindow::OnMouseLeave
)
1589 EVT_MOUSE_CAPTURE_LOST(wxHtmlWindow::OnMouseCaptureLost
)
1590 EVT_KEY_UP(wxHtmlWindow::OnKeyUp
)
1591 EVT_MENU(wxID_COPY
, wxHtmlWindow::OnCopy
)
1592 EVT_TEXT_COPY(wxID_ANY
, wxHtmlWindow::OnClipboardEvent
)
1593 #endif // wxUSE_CLIPBOARD
1596 //-----------------------------------------------------------------------------
1597 // wxHtmlWindowInterface implementation in wxHtmlWindow
1598 //-----------------------------------------------------------------------------
1600 void wxHtmlWindow::SetHTMLWindowTitle(const wxString
& title
)
1605 void wxHtmlWindow::OnHTMLLinkClicked(const wxHtmlLinkInfo
& link
)
1607 OnLinkClicked(link
);
1610 wxHtmlOpeningStatus
wxHtmlWindow::OnHTMLOpeningURL(wxHtmlURLType type
,
1611 const wxString
& url
,
1612 wxString
*redirect
) const
1614 return OnOpeningURL(type
, url
, redirect
);
1617 wxPoint
wxHtmlWindow::HTMLCoordsToWindow(wxHtmlCell
*WXUNUSED(cell
),
1618 const wxPoint
& pos
) const
1620 return CalcScrolledPosition(pos
);
1623 wxWindow
* wxHtmlWindow::GetHTMLWindow()
1628 wxColour
wxHtmlWindow::GetHTMLBackgroundColour() const
1630 return GetBackgroundColour();
1633 void wxHtmlWindow::SetHTMLBackgroundColour(const wxColour
& clr
)
1635 SetBackgroundColour(clr
);
1638 void wxHtmlWindow::SetHTMLBackgroundImage(const wxBitmap
& bmpBg
)
1640 SetBackgroundImage(bmpBg
);
1643 void wxHtmlWindow::SetHTMLStatusText(const wxString
& text
)
1646 if (m_RelatedStatusBarIndex
!= -1)
1648 if (m_RelatedStatusBar
)
1650 m_RelatedStatusBar
->SetStatusText(text
, m_RelatedStatusBarIndex
);
1652 else if (m_RelatedFrame
)
1654 m_RelatedFrame
->SetStatusText(text
, m_RelatedStatusBarIndex
);
1659 #endif // wxUSE_STATUSBAR
1663 wxCursor
wxHtmlWindow::GetDefaultHTMLCursor(HTMLCursor type
)
1667 case HTMLCursor_Link
:
1668 if ( !ms_cursorLink
)
1669 ms_cursorLink
= new wxCursor(wxCURSOR_HAND
);
1670 return *ms_cursorLink
;
1672 case HTMLCursor_Text
:
1673 if ( !ms_cursorText
)
1674 ms_cursorText
= new wxCursor(wxCURSOR_IBEAM
);
1675 return *ms_cursorText
;
1677 case HTMLCursor_Default
:
1679 return *wxSTANDARD_CURSOR
;
1683 wxCursor
wxHtmlWindow::GetHTMLCursor(HTMLCursor type
) const
1685 return GetDefaultHTMLCursor(type
);
1689 //-----------------------------------------------------------------------------
1691 //-----------------------------------------------------------------------------
1693 // A module to allow initialization/cleanup
1694 // without calling these functions from app.cpp or from
1695 // the user's application.
1697 class wxHtmlWinModule
: public wxModule
1699 DECLARE_DYNAMIC_CLASS(wxHtmlWinModule
)
1701 wxHtmlWinModule() : wxModule() {}
1702 bool OnInit() { return true; }
1703 void OnExit() { wxHtmlWindow::CleanUpStatics(); }
1706 IMPLEMENT_DYNAMIC_CLASS(wxHtmlWinModule
, wxModule
)
1709 // This hack forces the linker to always link in m_* files
1710 // (wxHTML doesn't work without handlers from these files)
1711 #include "wx/html/forcelnk.h"
1712 FORCE_WXHTML_MODULES()
1714 #endif // wxUSE_HTML