]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/html/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 | #ifdef __BORLANDC__ | |
13 | #pragma hdrstop | |
14 | #endif | |
15 | ||
16 | #if wxUSE_HTML && wxUSE_STREAMS | |
17 | ||
18 | #ifndef WX_PRECOMP | |
19 | #include "wx/list.h" | |
20 | #include "wx/log.h" | |
21 | #include "wx/intl.h" | |
22 | #include "wx/dcclient.h" | |
23 | #include "wx/frame.h" | |
24 | #include "wx/dcmemory.h" | |
25 | #include "wx/timer.h" | |
26 | #include "wx/settings.h" | |
27 | #include "wx/dataobj.h" | |
28 | #include "wx/statusbr.h" | |
29 | #endif | |
30 | ||
31 | #include "wx/html/htmlwin.h" | |
32 | #include "wx/html/htmlproc.h" | |
33 | #include "wx/clipbrd.h" | |
34 | ||
35 | #include "wx/arrimpl.cpp" | |
36 | #include "wx/listimpl.cpp" | |
37 | ||
38 | // uncomment this line to visually show the extent of the selection | |
39 | //#define DEBUG_HTML_SELECTION | |
40 | ||
41 | // HTML events: | |
42 | IMPLEMENT_DYNAMIC_CLASS(wxHtmlLinkEvent, wxCommandEvent) | |
43 | IMPLEMENT_DYNAMIC_CLASS(wxHtmlCellEvent, wxCommandEvent) | |
44 | ||
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 ); | |
48 | ||
49 | ||
50 | #if wxUSE_CLIPBOARD | |
51 | // ---------------------------------------------------------------------------- | |
52 | // wxHtmlWinAutoScrollTimer: the timer used to generate a stream of scroll | |
53 | // events when a captured mouse is held outside the window | |
54 | // ---------------------------------------------------------------------------- | |
55 | ||
56 | class wxHtmlWinAutoScrollTimer : public wxTimer | |
57 | { | |
58 | public: | |
59 | wxHtmlWinAutoScrollTimer(wxScrolledWindow *win, | |
60 | wxEventType eventTypeToSend, | |
61 | int pos, int orient) | |
62 | { | |
63 | m_win = win; | |
64 | m_eventType = eventTypeToSend; | |
65 | m_pos = pos; | |
66 | m_orient = orient; | |
67 | } | |
68 | ||
69 | virtual void Notify(); | |
70 | ||
71 | private: | |
72 | wxScrolledWindow *m_win; | |
73 | wxEventType m_eventType; | |
74 | int m_pos, | |
75 | m_orient; | |
76 | ||
77 | wxDECLARE_NO_COPY_CLASS(wxHtmlWinAutoScrollTimer); | |
78 | }; | |
79 | ||
80 | void wxHtmlWinAutoScrollTimer::Notify() | |
81 | { | |
82 | // only do all this as long as the window is capturing the mouse | |
83 | if ( wxWindow::GetCapture() != m_win ) | |
84 | { | |
85 | Stop(); | |
86 | } | |
87 | else // we still capture the mouse, continue generating events | |
88 | { | |
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) ) | |
93 | { | |
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); | |
97 | ||
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; | |
106 | ||
107 | event2.SetEventObject(m_win); | |
108 | ||
109 | // FIXME: we don't fill in the other members - ok? | |
110 | m_win->GetEventHandler()->ProcessEvent(event2); | |
111 | } | |
112 | else // can't scroll further, stop | |
113 | { | |
114 | Stop(); | |
115 | } | |
116 | } | |
117 | } | |
118 | ||
119 | #endif // wxUSE_CLIPBOARD | |
120 | ||
121 | ||
122 | ||
123 | //----------------------------------------------------------------------------- | |
124 | // wxHtmlHistoryItem | |
125 | //----------------------------------------------------------------------------- | |
126 | ||
127 | // item of history list | |
128 | class WXDLLIMPEXP_HTML wxHtmlHistoryItem | |
129 | { | |
130 | public: | |
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;} | |
136 | ||
137 | private: | |
138 | wxString m_Page; | |
139 | wxString m_Anchor; | |
140 | int m_Pos; | |
141 | }; | |
142 | ||
143 | ||
144 | //----------------------------------------------------------------------------- | |
145 | // our private arrays: | |
146 | //----------------------------------------------------------------------------- | |
147 | ||
148 | WX_DECLARE_OBJARRAY(wxHtmlHistoryItem, wxHtmlHistoryArray); | |
149 | WX_DEFINE_OBJARRAY(wxHtmlHistoryArray) | |
150 | ||
151 | WX_DECLARE_LIST(wxHtmlProcessor, wxHtmlProcessorList); | |
152 | WX_DEFINE_LIST(wxHtmlProcessorList) | |
153 | ||
154 | //----------------------------------------------------------------------------- | |
155 | // wxHtmlWindowMouseHelper | |
156 | //----------------------------------------------------------------------------- | |
157 | ||
158 | wxHtmlWindowMouseHelper::wxHtmlWindowMouseHelper(wxHtmlWindowInterface *iface) | |
159 | : m_tmpMouseMoved(false), | |
160 | m_tmpLastLink(NULL), | |
161 | m_tmpLastCell(NULL), | |
162 | m_interface(iface) | |
163 | { | |
164 | } | |
165 | ||
166 | void wxHtmlWindowMouseHelper::HandleMouseMoved() | |
167 | { | |
168 | m_tmpMouseMoved = true; | |
169 | } | |
170 | ||
171 | bool wxHtmlWindowMouseHelper::HandleMouseClick(wxHtmlCell *rootCell, | |
172 | const wxPoint& pos, | |
173 | const wxMouseEvent& event) | |
174 | { | |
175 | if (!rootCell) | |
176 | return false; | |
177 | ||
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 | |
181 | // returned | |
182 | if (!cell) | |
183 | return false; | |
184 | ||
185 | // adjust the coordinates to be relative to this cell: | |
186 | wxPoint relpos = pos - cell->GetAbsPos(rootCell); | |
187 | ||
188 | return OnCellClicked(cell, relpos.x, relpos.y, event); | |
189 | } | |
190 | ||
191 | void wxHtmlWindowMouseHelper::HandleIdle(wxHtmlCell *rootCell, | |
192 | const wxPoint& pos) | |
193 | { | |
194 | wxHtmlCell *cell = rootCell ? rootCell->FindCellByPos(pos.x, pos.y) : NULL; | |
195 | ||
196 | if (cell != m_tmpLastCell) | |
197 | { | |
198 | wxHtmlLinkInfo *lnk = NULL; | |
199 | if (cell) | |
200 | { | |
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); | |
204 | } | |
205 | ||
206 | wxCursor cur; | |
207 | if (cell) | |
208 | cur = cell->GetMouseCursor(m_interface); | |
209 | else | |
210 | cur = m_interface->GetHTMLCursor( | |
211 | wxHtmlWindowInterface::HTMLCursor_Default); | |
212 | ||
213 | m_interface->GetHTMLWindow()->SetCursor(cur); | |
214 | ||
215 | if (lnk != m_tmpLastLink) | |
216 | { | |
217 | if (lnk) | |
218 | m_interface->SetHTMLStatusText(lnk->GetHref()); | |
219 | else | |
220 | m_interface->SetHTMLStatusText(wxEmptyString); | |
221 | ||
222 | m_tmpLastLink = lnk; | |
223 | } | |
224 | ||
225 | m_tmpLastCell = cell; | |
226 | } | |
227 | else // mouse moved but stayed in the same cell | |
228 | { | |
229 | if ( cell ) | |
230 | { | |
231 | OnCellMouseHover(cell, pos.x, pos.y); | |
232 | } | |
233 | } | |
234 | ||
235 | m_tmpMouseMoved = false; | |
236 | } | |
237 | ||
238 | bool wxHtmlWindowMouseHelper::OnCellClicked(wxHtmlCell *cell, | |
239 | wxCoord x, wxCoord y, | |
240 | const wxMouseEvent& event) | |
241 | { | |
242 | wxHtmlCellEvent ev(wxEVT_COMMAND_HTML_CELL_CLICKED, | |
243 | m_interface->GetHTMLWindow()->GetId(), | |
244 | cell, wxPoint(x,y), event); | |
245 | ||
246 | if (!m_interface->GetHTMLWindow()->GetEventHandler()->ProcessEvent(ev)) | |
247 | { | |
248 | // if the event wasn't handled, do the default processing here: | |
249 | ||
250 | wxASSERT_MSG( cell, wxT("can't be called with NULL cell") ); | |
251 | ||
252 | cell->ProcessMouseClick(m_interface, ev.GetPoint(), ev.GetMouseEvent()); | |
253 | } | |
254 | ||
255 | // true if a link was clicked, false otherwise | |
256 | return ev.GetLinkClicked(); | |
257 | } | |
258 | ||
259 | void wxHtmlWindowMouseHelper::OnCellMouseHover(wxHtmlCell * cell, | |
260 | wxCoord x, | |
261 | wxCoord y) | |
262 | { | |
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); | |
267 | } | |
268 | ||
269 | ||
270 | ||
271 | ||
272 | //----------------------------------------------------------------------------- | |
273 | // wxHtmlWindow | |
274 | //----------------------------------------------------------------------------- | |
275 | ||
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; | |
281 | ||
282 | void wxHtmlWindow::CleanUpStatics() | |
283 | { | |
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); | |
291 | } | |
292 | ||
293 | void wxHtmlWindow::Init() | |
294 | { | |
295 | m_tmpCanDrawLocks = 0; | |
296 | m_FS = new wxFileSystem(); | |
297 | #if wxUSE_STATUSBAR | |
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; | |
304 | m_Cell = NULL; | |
305 | m_Parser = new wxHtmlWinParser(this); | |
306 | m_Parser->SetFS(m_FS); | |
307 | m_HistoryPos = -1; | |
308 | m_HistoryOn = true; | |
309 | m_History = new wxHtmlHistoryArray; | |
310 | m_Processors = NULL; | |
311 | SetBorders(10); | |
312 | m_selection = NULL; | |
313 | m_makingSelection = false; | |
314 | #if wxUSE_CLIPBOARD | |
315 | m_timerAutoScroll = NULL; | |
316 | m_lastDoubleClick = 0; | |
317 | #endif // wxUSE_CLIPBOARD | |
318 | m_tmpSelFromCell = NULL; | |
319 | } | |
320 | ||
321 | bool wxHtmlWindow::Create(wxWindow *parent, wxWindowID id, | |
322 | const wxPoint& pos, const wxSize& size, | |
323 | long style, const wxString& name) | |
324 | { | |
325 | if (!wxScrolledWindow::Create(parent, id, pos, size, | |
326 | style | wxVSCROLL | wxHSCROLL, | |
327 | name)) | |
328 | return false; | |
329 | ||
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. | |
335 | // | |
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); | |
341 | ||
342 | SetPage(wxT("<html><body></body></html>")); | |
343 | return true; | |
344 | } | |
345 | ||
346 | ||
347 | wxHtmlWindow::~wxHtmlWindow() | |
348 | { | |
349 | #if wxUSE_CLIPBOARD | |
350 | StopAutoScrolling(); | |
351 | #endif // wxUSE_CLIPBOARD | |
352 | HistoryClear(); | |
353 | ||
354 | delete m_selection; | |
355 | ||
356 | delete m_Cell; | |
357 | ||
358 | if ( m_Processors ) | |
359 | { | |
360 | WX_CLEAR_LIST(wxHtmlProcessorList, *m_Processors); | |
361 | } | |
362 | ||
363 | delete m_Parser; | |
364 | delete m_FS; | |
365 | delete m_History; | |
366 | delete m_Processors; | |
367 | } | |
368 | ||
369 | ||
370 | ||
371 | void wxHtmlWindow::SetRelatedFrame(wxFrame* frame, const wxString& format) | |
372 | { | |
373 | m_RelatedFrame = frame; | |
374 | m_TitleFormat = format; | |
375 | } | |
376 | ||
377 | ||
378 | ||
379 | #if wxUSE_STATUSBAR | |
380 | void wxHtmlWindow::SetRelatedStatusBar(int index) | |
381 | { | |
382 | m_RelatedStatusBarIndex = index; | |
383 | } | |
384 | ||
385 | void wxHtmlWindow::SetRelatedStatusBar(wxStatusBar* statusbar, int index) | |
386 | { | |
387 | m_RelatedStatusBar = statusbar; | |
388 | m_RelatedStatusBarIndex = index; | |
389 | } | |
390 | ||
391 | #endif // wxUSE_STATUSBAR | |
392 | ||
393 | ||
394 | ||
395 | void wxHtmlWindow::SetFonts(const wxString& normal_face, const wxString& fixed_face, const int *sizes) | |
396 | { | |
397 | m_Parser->SetFonts(normal_face, fixed_face, sizes); | |
398 | ||
399 | // re-layout the page after changing fonts: | |
400 | DoSetPage(*(m_Parser->GetSource())); | |
401 | } | |
402 | ||
403 | void wxHtmlWindow::SetStandardFonts(int size, | |
404 | const wxString& normal_face, | |
405 | const wxString& fixed_face) | |
406 | { | |
407 | m_Parser->SetStandardFonts(size, normal_face, fixed_face); | |
408 | ||
409 | // re-layout the page after changing fonts: | |
410 | DoSetPage(*(m_Parser->GetSource())); | |
411 | } | |
412 | ||
413 | bool wxHtmlWindow::SetPage(const wxString& source) | |
414 | { | |
415 | m_OpenedPage = m_OpenedAnchor = m_OpenedPageTitle = wxEmptyString; | |
416 | return DoSetPage(source); | |
417 | } | |
418 | ||
419 | bool wxHtmlWindow::DoSetPage(const wxString& source) | |
420 | { | |
421 | wxString newsrc(source); | |
422 | ||
423 | wxDELETE(m_selection); | |
424 | ||
425 | // we will soon delete all the cells, so clear pointers to them: | |
426 | m_tmpSelFromCell = NULL; | |
427 | ||
428 | // pass HTML through registered processors: | |
429 | if (m_Processors || m_GlobalProcessors) | |
430 | { | |
431 | wxHtmlProcessorList::compatibility_iterator nodeL, nodeG; | |
432 | int prL, prG; | |
433 | ||
434 | if ( m_Processors ) | |
435 | nodeL = m_Processors->GetFirst(); | |
436 | if ( m_GlobalProcessors ) | |
437 | nodeG = m_GlobalProcessors->GetFirst(); | |
438 | ||
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) | |
445 | { | |
446 | prL = (nodeL) ? nodeL->GetData()->GetPriority() : -1; | |
447 | prG = (nodeG) ? nodeG->GetData()->GetPriority() : -1; | |
448 | if (prL > prG) | |
449 | { | |
450 | if (nodeL->GetData()->IsEnabled()) | |
451 | newsrc = nodeL->GetData()->Process(newsrc); | |
452 | nodeL = nodeL->GetNext(); | |
453 | } | |
454 | else // prL <= prG | |
455 | { | |
456 | if (nodeG->GetData()->IsEnabled()) | |
457 | newsrc = nodeG->GetData()->Process(newsrc); | |
458 | nodeG = nodeG->GetNext(); | |
459 | } | |
460 | } | |
461 | } | |
462 | ||
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); | |
468 | ||
469 | m_Parser->SetDC(dc); | |
470 | if (m_Cell) | |
471 | { | |
472 | delete m_Cell; | |
473 | m_Cell = NULL; | |
474 | } | |
475 | m_Cell = (wxHtmlContainerCell*) m_Parser->Parse(newsrc); | |
476 | delete dc; | |
477 | m_Cell->SetIndent(m_Borders, wxHTML_INDENT_ALL, wxHTML_UNITS_PIXELS); | |
478 | m_Cell->SetAlignHor(wxHTML_ALIGN_CENTER); | |
479 | CreateLayout(); | |
480 | if (m_tmpCanDrawLocks == 0) | |
481 | Refresh(); | |
482 | return true; | |
483 | } | |
484 | ||
485 | bool wxHtmlWindow::AppendToPage(const wxString& source) | |
486 | { | |
487 | return DoSetPage(*(GetParser()->GetSource()) + source); | |
488 | } | |
489 | ||
490 | bool wxHtmlWindow::LoadPage(const wxString& location) | |
491 | { | |
492 | wxCHECK_MSG( !location.empty(), false, "location must be non-empty" ); | |
493 | ||
494 | wxBusyCursor busyCursor; | |
495 | ||
496 | bool rt_val; | |
497 | bool needs_refresh = false; | |
498 | ||
499 | m_tmpCanDrawLocks++; | |
500 | if (m_HistoryOn && (m_HistoryPos != -1)) | |
501 | { | |
502 | // store scroll position into history item: | |
503 | int x, y; | |
504 | GetViewStart(&x, &y); | |
505 | (*m_History)[m_HistoryPos].SetPos(y); | |
506 | } | |
507 | ||
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 ) | |
511 | { | |
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 ) | |
517 | { | |
518 | // indicate that we're not moving to a local anchor | |
519 | posLocalAnchor = wxString::npos; | |
520 | } | |
521 | } | |
522 | ||
523 | if ( posLocalAnchor != wxString::npos ) | |
524 | { | |
525 | m_tmpCanDrawLocks--; | |
526 | rt_val = ScrollToAnchor(location.substr(posLocalAnchor + 1)); | |
527 | m_tmpCanDrawLocks++; | |
528 | } | |
529 | else // moving to another page | |
530 | { | |
531 | needs_refresh = true; | |
532 | #if wxUSE_STATUSBAR | |
533 | // load&display it: | |
534 | if (m_RelatedStatusBarIndex != -1) | |
535 | { | |
536 | SetHTMLStatusText(_("Connecting...")); | |
537 | Refresh(false); | |
538 | } | |
539 | #endif // wxUSE_STATUSBAR | |
540 | ||
541 | wxFSFile *f = m_Parser->OpenURL(wxHTML_URL_PAGE, location); | |
542 | ||
543 | // try to interpret 'location' as filename instead of URL: | |
544 | if (f == NULL) | |
545 | { | |
546 | wxFileName fn(location); | |
547 | wxString location2 = wxFileSystem::FileNameToURL(fn); | |
548 | f = m_Parser->OpenURL(wxHTML_URL_PAGE, location2); | |
549 | } | |
550 | ||
551 | if (f == NULL) | |
552 | { | |
553 | wxLogError(_("Unable to open requested HTML document: %s"), location.c_str()); | |
554 | m_tmpCanDrawLocks--; | |
555 | SetHTMLStatusText(wxEmptyString); | |
556 | return false; | |
557 | } | |
558 | ||
559 | else | |
560 | { | |
561 | wxList::compatibility_iterator node; | |
562 | wxString src = wxEmptyString; | |
563 | ||
564 | #if wxUSE_STATUSBAR | |
565 | if (m_RelatedStatusBarIndex != -1) | |
566 | { | |
567 | wxString msg = _("Loading : ") + location; | |
568 | SetHTMLStatusText(msg); | |
569 | Refresh(false); | |
570 | } | |
571 | #endif // wxUSE_STATUSBAR | |
572 | ||
573 | node = m_Filters.GetFirst(); | |
574 | while (node) | |
575 | { | |
576 | wxHtmlFilter *h = (wxHtmlFilter*) node->GetData(); | |
577 | if (h->CanRead(*f)) | |
578 | { | |
579 | src = h->ReadFile(*f); | |
580 | break; | |
581 | } | |
582 | node = node->GetNext(); | |
583 | } | |
584 | if (src == wxEmptyString) | |
585 | { | |
586 | if (m_DefaultFilter == NULL) m_DefaultFilter = GetDefaultFilter(); | |
587 | src = m_DefaultFilter->ReadFile(*f); | |
588 | } | |
589 | ||
590 | m_FS->ChangePathTo(f->GetLocation()); | |
591 | rt_val = SetPage(src); | |
592 | m_OpenedPage = f->GetLocation(); | |
593 | if (f->GetAnchor() != wxEmptyString) | |
594 | { | |
595 | ScrollToAnchor(f->GetAnchor()); | |
596 | } | |
597 | ||
598 | delete f; | |
599 | ||
600 | #if wxUSE_STATUSBAR | |
601 | if (m_RelatedStatusBarIndex != -1) | |
602 | { | |
603 | SetHTMLStatusText(_("Done")); | |
604 | } | |
605 | #endif // wxUSE_STATUSBAR | |
606 | } | |
607 | } | |
608 | ||
609 | if (m_HistoryOn) // add this page to history there: | |
610 | { | |
611 | int c = m_History->GetCount() - (m_HistoryPos + 1); | |
612 | ||
613 | if (m_HistoryPos < 0 || | |
614 | (*m_History)[m_HistoryPos].GetPage() != m_OpenedPage || | |
615 | (*m_History)[m_HistoryPos].GetAnchor() != m_OpenedAnchor) | |
616 | { | |
617 | m_HistoryPos++; | |
618 | for (int i = 0; i < c; i++) | |
619 | m_History->RemoveAt(m_HistoryPos); | |
620 | m_History->Add(new wxHtmlHistoryItem(m_OpenedPage, m_OpenedAnchor)); | |
621 | } | |
622 | } | |
623 | ||
624 | if (m_OpenedPageTitle == wxEmptyString) | |
625 | OnSetTitle(wxFileNameFromPath(m_OpenedPage)); | |
626 | ||
627 | if (needs_refresh) | |
628 | { | |
629 | m_tmpCanDrawLocks--; | |
630 | Refresh(); | |
631 | } | |
632 | else | |
633 | m_tmpCanDrawLocks--; | |
634 | ||
635 | return rt_val; | |
636 | } | |
637 | ||
638 | ||
639 | bool wxHtmlWindow::LoadFile(const wxFileName& filename) | |
640 | { | |
641 | wxString url = wxFileSystem::FileNameToURL(filename); | |
642 | return LoadPage(url); | |
643 | } | |
644 | ||
645 | ||
646 | bool wxHtmlWindow::ScrollToAnchor(const wxString& anchor) | |
647 | { | |
648 | const wxHtmlCell *c = m_Cell->Find(wxHTML_COND_ISANCHOR, &anchor); | |
649 | if (!c) | |
650 | { | |
651 | wxLogWarning(_("HTML anchor %s does not exist."), anchor.c_str()); | |
652 | return false; | |
653 | } | |
654 | else | |
655 | { | |
656 | int y; | |
657 | ||
658 | for (y = 0; c != NULL; c = c->GetParent()) y += c->GetPosY(); | |
659 | Scroll(-1, y / wxHTML_SCROLL_STEP); | |
660 | m_OpenedAnchor = anchor; | |
661 | return true; | |
662 | } | |
663 | } | |
664 | ||
665 | ||
666 | void wxHtmlWindow::OnSetTitle(const wxString& title) | |
667 | { | |
668 | if (m_RelatedFrame) | |
669 | { | |
670 | wxString tit; | |
671 | tit.Printf(m_TitleFormat, title.c_str()); | |
672 | m_RelatedFrame->SetTitle(tit); | |
673 | } | |
674 | m_OpenedPageTitle = title; | |
675 | } | |
676 | ||
677 | ||
678 | ||
679 | ||
680 | ||
681 | void wxHtmlWindow::CreateLayout() | |
682 | { | |
683 | int ClientWidth, ClientHeight; | |
684 | ||
685 | if (!m_Cell) return; | |
686 | ||
687 | if ( HasFlag(wxHW_SCROLLBAR_NEVER) ) | |
688 | { | |
689 | SetScrollbars(1, 1, 0, 0); // always off | |
690 | GetClientSize(&ClientWidth, &ClientHeight); | |
691 | m_Cell->Layout(ClientWidth); | |
692 | } | |
693 | else // !wxHW_SCROLLBAR_NEVER | |
694 | { | |
695 | GetClientSize(&ClientWidth, &ClientHeight); | |
696 | m_Cell->Layout(ClientWidth); | |
697 | if (ClientHeight < m_Cell->GetHeight() + GetCharHeight()) | |
698 | { | |
699 | SetScrollbars( | |
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*/); | |
704 | } | |
705 | else /* we fit into window, no need for scrollbars */ | |
706 | { | |
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 | |
710 | } | |
711 | } | |
712 | } | |
713 | ||
714 | ||
715 | ||
716 | void wxHtmlWindow::ReadCustomization(wxConfigBase *cfg, wxString path) | |
717 | { | |
718 | wxString oldpath; | |
719 | wxString tmp; | |
720 | int p_fontsizes[7]; | |
721 | wxString p_fff, p_ffn; | |
722 | ||
723 | if (path != wxEmptyString) | |
724 | { | |
725 | oldpath = cfg->GetPath(); | |
726 | cfg->SetPath(path); | |
727 | } | |
728 | ||
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++) | |
733 | { | |
734 | tmp.Printf(wxT("wxHtmlWindow/FontsSize%i"), i); | |
735 | p_fontsizes[i] = cfg->Read(tmp, m_Parser->m_FontsSizes[i]); | |
736 | } | |
737 | SetFonts(p_ffn, p_fff, p_fontsizes); | |
738 | ||
739 | if (path != wxEmptyString) | |
740 | cfg->SetPath(oldpath); | |
741 | } | |
742 | ||
743 | ||
744 | ||
745 | void wxHtmlWindow::WriteCustomization(wxConfigBase *cfg, wxString path) | |
746 | { | |
747 | wxString oldpath; | |
748 | wxString tmp; | |
749 | ||
750 | if (path != wxEmptyString) | |
751 | { | |
752 | oldpath = cfg->GetPath(); | |
753 | cfg->SetPath(path); | |
754 | } | |
755 | ||
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++) | |
760 | { | |
761 | tmp.Printf(wxT("wxHtmlWindow/FontsSize%i"), i); | |
762 | cfg->Write(tmp, (long) m_Parser->m_FontsSizes[i]); | |
763 | } | |
764 | ||
765 | if (path != wxEmptyString) | |
766 | cfg->SetPath(oldpath); | |
767 | } | |
768 | ||
769 | ||
770 | ||
771 | bool wxHtmlWindow::HistoryBack() | |
772 | { | |
773 | wxString a, l; | |
774 | ||
775 | if (m_HistoryPos < 1) return false; | |
776 | ||
777 | // store scroll position into history item: | |
778 | int x, y; | |
779 | GetViewStart(&x, &y); | |
780 | (*m_History)[m_HistoryPos].SetPos(y); | |
781 | ||
782 | // go to previous position: | |
783 | m_HistoryPos--; | |
784 | ||
785 | l = (*m_History)[m_HistoryPos].GetPage(); | |
786 | a = (*m_History)[m_HistoryPos].GetAnchor(); | |
787 | m_HistoryOn = false; | |
788 | m_tmpCanDrawLocks++; | |
789 | if (a == wxEmptyString) LoadPage(l); | |
790 | else LoadPage(l + wxT("#") + a); | |
791 | m_HistoryOn = true; | |
792 | m_tmpCanDrawLocks--; | |
793 | Scroll(0, (*m_History)[m_HistoryPos].GetPos()); | |
794 | Refresh(); | |
795 | return true; | |
796 | } | |
797 | ||
798 | bool wxHtmlWindow::HistoryCanBack() | |
799 | { | |
800 | if (m_HistoryPos < 1) return false; | |
801 | return true ; | |
802 | } | |
803 | ||
804 | ||
805 | bool wxHtmlWindow::HistoryForward() | |
806 | { | |
807 | wxString a, l; | |
808 | ||
809 | if (m_HistoryPos == -1) return false; | |
810 | if (m_HistoryPos >= (int)m_History->GetCount() - 1)return false; | |
811 | ||
812 | m_OpenedPage = wxEmptyString; // this will disable adding new entry into history in LoadPage() | |
813 | ||
814 | m_HistoryPos++; | |
815 | l = (*m_History)[m_HistoryPos].GetPage(); | |
816 | a = (*m_History)[m_HistoryPos].GetAnchor(); | |
817 | m_HistoryOn = false; | |
818 | m_tmpCanDrawLocks++; | |
819 | if (a == wxEmptyString) LoadPage(l); | |
820 | else LoadPage(l + wxT("#") + a); | |
821 | m_HistoryOn = true; | |
822 | m_tmpCanDrawLocks--; | |
823 | Scroll(0, (*m_History)[m_HistoryPos].GetPos()); | |
824 | Refresh(); | |
825 | return true; | |
826 | } | |
827 | ||
828 | bool wxHtmlWindow::HistoryCanForward() | |
829 | { | |
830 | if (m_HistoryPos == -1) return false; | |
831 | if (m_HistoryPos >= (int)m_History->GetCount() - 1)return false; | |
832 | return true ; | |
833 | } | |
834 | ||
835 | ||
836 | void wxHtmlWindow::HistoryClear() | |
837 | { | |
838 | m_History->Empty(); | |
839 | m_HistoryPos = -1; | |
840 | } | |
841 | ||
842 | void wxHtmlWindow::AddProcessor(wxHtmlProcessor *processor) | |
843 | { | |
844 | if (!m_Processors) | |
845 | { | |
846 | m_Processors = new wxHtmlProcessorList; | |
847 | } | |
848 | wxHtmlProcessorList::compatibility_iterator node; | |
849 | ||
850 | for (node = m_Processors->GetFirst(); node; node = node->GetNext()) | |
851 | { | |
852 | if (processor->GetPriority() > node->GetData()->GetPriority()) | |
853 | { | |
854 | m_Processors->Insert(node, processor); | |
855 | return; | |
856 | } | |
857 | } | |
858 | m_Processors->Append(processor); | |
859 | } | |
860 | ||
861 | /*static */ void wxHtmlWindow::AddGlobalProcessor(wxHtmlProcessor *processor) | |
862 | { | |
863 | if (!m_GlobalProcessors) | |
864 | { | |
865 | m_GlobalProcessors = new wxHtmlProcessorList; | |
866 | } | |
867 | wxHtmlProcessorList::compatibility_iterator node; | |
868 | ||
869 | for (node = m_GlobalProcessors->GetFirst(); node; node = node->GetNext()) | |
870 | { | |
871 | if (processor->GetPriority() > node->GetData()->GetPriority()) | |
872 | { | |
873 | m_GlobalProcessors->Insert(node, processor); | |
874 | return; | |
875 | } | |
876 | } | |
877 | m_GlobalProcessors->Append(processor); | |
878 | } | |
879 | ||
880 | ||
881 | ||
882 | void wxHtmlWindow::AddFilter(wxHtmlFilter *filter) | |
883 | { | |
884 | m_Filters.Append(filter); | |
885 | } | |
886 | ||
887 | ||
888 | bool wxHtmlWindow::IsSelectionEnabled() const | |
889 | { | |
890 | #if wxUSE_CLIPBOARD | |
891 | return !HasFlag(wxHW_NO_SELECTION); | |
892 | #else | |
893 | return false; | |
894 | #endif | |
895 | } | |
896 | ||
897 | ||
898 | #if wxUSE_CLIPBOARD | |
899 | wxString wxHtmlWindow::DoSelectionToText(wxHtmlSelection *sel) | |
900 | { | |
901 | if ( !sel ) | |
902 | return wxEmptyString; | |
903 | ||
904 | wxClientDC dc(this); | |
905 | wxString text; | |
906 | ||
907 | wxHtmlTerminalCellsInterator i(sel->GetFromCell(), sel->GetToCell()); | |
908 | const wxHtmlCell *prev = NULL; | |
909 | ||
910 | while ( i ) | |
911 | { | |
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() ) | |
919 | text << '\n'; | |
920 | ||
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); | |
925 | ||
926 | prev = *i; | |
927 | ++i; | |
928 | } | |
929 | return text; | |
930 | } | |
931 | ||
932 | wxString wxHtmlWindow::ToText() | |
933 | { | |
934 | if (m_Cell) | |
935 | { | |
936 | wxHtmlSelection sel; | |
937 | sel.Set(m_Cell->GetFirstTerminal(), m_Cell->GetLastTerminal()); | |
938 | return DoSelectionToText(&sel); | |
939 | } | |
940 | else | |
941 | return wxEmptyString; | |
942 | } | |
943 | ||
944 | #endif // wxUSE_CLIPBOARD | |
945 | ||
946 | bool wxHtmlWindow::CopySelection(ClipboardType t) | |
947 | { | |
948 | #if wxUSE_CLIPBOARD | |
949 | if ( m_selection ) | |
950 | { | |
951 | #if defined(__UNIX__) && !defined(__WXMAC__) | |
952 | wxTheClipboard->UsePrimarySelection(t == Primary); | |
953 | #else // !__UNIX__ | |
954 | // Primary selection exists only under X11, so don't do anything under | |
955 | // the other platforms when we try to access it | |
956 | // | |
957 | // TODO: this should be abstracted at wxClipboard level! | |
958 | if ( t == Primary ) | |
959 | return false; | |
960 | #endif // __UNIX__/!__UNIX__ | |
961 | ||
962 | if ( wxTheClipboard->Open() ) | |
963 | { | |
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()); | |
969 | ||
970 | return true; | |
971 | } | |
972 | } | |
973 | #else | |
974 | wxUnusedVar(t); | |
975 | #endif // wxUSE_CLIPBOARD | |
976 | ||
977 | return false; | |
978 | } | |
979 | ||
980 | ||
981 | void wxHtmlWindow::OnLinkClicked(const wxHtmlLinkInfo& link) | |
982 | { | |
983 | wxHtmlLinkEvent event(GetId(), link); | |
984 | event.SetEventObject(this); | |
985 | if (!GetEventHandler()->ProcessEvent(event)) | |
986 | { | |
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()); | |
991 | } | |
992 | } | |
993 | ||
994 | void wxHtmlWindow::DoEraseBackground(wxDC& dc) | |
995 | { | |
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() ) | |
1000 | { | |
1001 | dc.SetBackground(GetBackgroundColour()); | |
1002 | dc.Clear(); | |
1003 | } | |
1004 | ||
1005 | if ( m_bmpBg.IsOk() ) | |
1006 | { | |
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 ) | |
1011 | { | |
1012 | for ( wxCoord y = 0; y < sz.y; y += sizeBmp.y ) | |
1013 | { | |
1014 | dc.DrawBitmap(m_bmpBg, x, y, true /* use mask */); | |
1015 | } | |
1016 | } | |
1017 | } | |
1018 | } | |
1019 | ||
1020 | void wxHtmlWindow::OnPaint(wxPaintEvent& WXUNUSED(event)) | |
1021 | { | |
1022 | wxPaintDC dcPaint(this); | |
1023 | ||
1024 | if (m_tmpCanDrawLocks > 0 || m_Cell == NULL) | |
1025 | return; | |
1026 | ||
1027 | int x, y; | |
1028 | GetViewStart(&x, &y); | |
1029 | const wxRect rect = GetUpdateRegion().GetBox(); | |
1030 | const wxSize sz = GetClientSize(); | |
1031 | ||
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 | |
1035 | // once | |
1036 | wxDC *dc; | |
1037 | wxMemoryDC dcm; | |
1038 | if ( IsDoubleBuffered() ) | |
1039 | { | |
1040 | dc = &dcPaint; | |
1041 | } | |
1042 | else // window is not double buffered by the system, do it ourselves | |
1043 | { | |
1044 | if ( !m_backBuffer.IsOk() ) | |
1045 | m_backBuffer.Create(sz.x, sz.y); | |
1046 | dcm.SelectObject(m_backBuffer); | |
1047 | dc = &dcm; | |
1048 | } | |
1049 | ||
1050 | PrepareDC(*dc); | |
1051 | ||
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) ) | |
1057 | { | |
1058 | // erase background ourselves | |
1059 | DoEraseBackground(*dc); | |
1060 | } | |
1061 | //else: background erased by the user-defined handler | |
1062 | ||
1063 | ||
1064 | // draw the HTML window contents | |
1065 | dc->SetMapMode(wxMM_TEXT); | |
1066 | dc->SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT); | |
1067 | ||
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(), | |
1075 | rinfo); | |
1076 | ||
1077 | #ifdef DEBUG_HTML_SELECTION | |
1078 | { | |
1079 | int xc, yc, x, y; | |
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); | |
1086 | wxHtmlCell *after = | |
1087 | m_Cell->FindCellByPos(x, y, wxHTML_FIND_NEAREST_AFTER); | |
1088 | ||
1089 | dc->SetBrush(*wxTRANSPARENT_BRUSH); | |
1090 | dc->SetPen(*wxBLACK_PEN); | |
1091 | if (at) | |
1092 | dc->DrawRectangle(at->GetAbsPos(), | |
1093 | wxSize(at->GetWidth(),at->GetHeight())); | |
1094 | dc->SetPen(*wxGREEN_PEN); | |
1095 | if (before) | |
1096 | dc->DrawRectangle(before->GetAbsPos().x+1, before->GetAbsPos().y+1, | |
1097 | before->GetWidth()-2,before->GetHeight()-2); | |
1098 | dc->SetPen(*wxRED_PEN); | |
1099 | if (after) | |
1100 | dc->DrawRectangle(after->GetAbsPos().x+2, after->GetAbsPos().y+2, | |
1101 | after->GetWidth()-4,after->GetHeight()-4); | |
1102 | } | |
1103 | #endif // DEBUG_HTML_SELECTION | |
1104 | ||
1105 | if ( dc != &dcPaint ) | |
1106 | { | |
1107 | dc->SetDeviceOrigin(0,0); | |
1108 | dcPaint.Blit(0, rect.GetTop(), | |
1109 | sz.x, rect.GetBottom() - rect.GetTop() + 1, | |
1110 | dc, | |
1111 | 0, rect.GetTop()); | |
1112 | } | |
1113 | } | |
1114 | ||
1115 | ||
1116 | ||
1117 | ||
1118 | void wxHtmlWindow::OnSize(wxSizeEvent& event) | |
1119 | { | |
1120 | event.Skip(); | |
1121 | ||
1122 | m_backBuffer = wxNullBitmap; | |
1123 | ||
1124 | CreateLayout(); | |
1125 | ||
1126 | // Recompute selection if necessary: | |
1127 | if ( m_selection ) | |
1128 | { | |
1129 | m_selection->Set(m_selection->GetFromCell(), | |
1130 | m_selection->GetToCell()); | |
1131 | m_selection->ClearPrivPos(); | |
1132 | } | |
1133 | ||
1134 | Refresh(); | |
1135 | } | |
1136 | ||
1137 | ||
1138 | void wxHtmlWindow::OnMouseMove(wxMouseEvent& WXUNUSED(event)) | |
1139 | { | |
1140 | wxHtmlWindowMouseHelper::HandleMouseMoved(); | |
1141 | } | |
1142 | ||
1143 | void wxHtmlWindow::OnMouseDown(wxMouseEvent& event) | |
1144 | { | |
1145 | #if wxUSE_CLIPBOARD | |
1146 | if ( event.LeftDown() && IsSelectionEnabled() ) | |
1147 | { | |
1148 | const long TRIPLECLICK_LEN = 200; // 0.2 sec after doubleclick | |
1149 | if ( wxGetLocalTimeMillis() - m_lastDoubleClick <= TRIPLECLICK_LEN ) | |
1150 | { | |
1151 | SelectLine(CalcUnscrolledPosition(event.GetPosition())); | |
1152 | ||
1153 | (void) CopySelection(); | |
1154 | } | |
1155 | else | |
1156 | { | |
1157 | m_makingSelection = true; | |
1158 | ||
1159 | if ( m_selection ) | |
1160 | { | |
1161 | wxDELETE(m_selection); | |
1162 | Refresh(); | |
1163 | } | |
1164 | m_tmpSelFromPos = CalcUnscrolledPosition(event.GetPosition()); | |
1165 | m_tmpSelFromCell = NULL; | |
1166 | ||
1167 | CaptureMouse(); | |
1168 | } | |
1169 | } | |
1170 | #endif // wxUSE_CLIPBOARD | |
1171 | ||
1172 | // in any case, let the default handler set focus to this window | |
1173 | event.Skip(); | |
1174 | } | |
1175 | ||
1176 | void wxHtmlWindow::OnMouseUp(wxMouseEvent& event) | |
1177 | { | |
1178 | #if wxUSE_CLIPBOARD | |
1179 | if ( m_makingSelection ) | |
1180 | { | |
1181 | ReleaseMouse(); | |
1182 | m_makingSelection = false; | |
1183 | ||
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: | |
1187 | if ( m_selection ) | |
1188 | { | |
1189 | CopySelection(Primary); | |
1190 | ||
1191 | // we don't want mouse up event that ended selecting to be | |
1192 | // handled as mouse click and e.g. follow hyperlink: | |
1193 | return; | |
1194 | } | |
1195 | } | |
1196 | #endif // wxUSE_CLIPBOARD | |
1197 | ||
1198 | wxPoint pos = CalcUnscrolledPosition(event.GetPosition()); | |
1199 | wxHtmlWindowMouseHelper::HandleMouseClick(m_Cell, pos, event); | |
1200 | } | |
1201 | ||
1202 | #if wxUSE_CLIPBOARD | |
1203 | void wxHtmlWindow::OnMouseCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event)) | |
1204 | { | |
1205 | if ( !m_makingSelection ) | |
1206 | return; | |
1207 | ||
1208 | // discard the selecting operation | |
1209 | m_makingSelection = false; | |
1210 | wxDELETE(m_selection); | |
1211 | m_tmpSelFromCell = NULL; | |
1212 | Refresh(); | |
1213 | } | |
1214 | #endif // wxUSE_CLIPBOARD | |
1215 | ||
1216 | ||
1217 | void wxHtmlWindow::OnInternalIdle() | |
1218 | { | |
1219 | wxWindow::OnInternalIdle(); | |
1220 | ||
1221 | if (m_Cell != NULL && DidMouseMove()) | |
1222 | { | |
1223 | #ifdef DEBUG_HTML_SELECTION | |
1224 | Refresh(); | |
1225 | #endif | |
1226 | int xc, yc, x, y; | |
1227 | wxGetMousePosition(&xc, &yc); | |
1228 | ScreenToClient(&xc, &yc); | |
1229 | CalcUnscrolledPosition(xc, yc, &x, &y); | |
1230 | ||
1231 | wxHtmlCell *cell = m_Cell->FindCellByPos(x, y); | |
1232 | ||
1233 | // handle selection update: | |
1234 | if ( m_makingSelection ) | |
1235 | { | |
1236 | if ( !m_tmpSelFromCell ) | |
1237 | m_tmpSelFromCell = m_Cell->FindCellByPos( | |
1238 | m_tmpSelFromPos.x,m_tmpSelFromPos.y); | |
1239 | ||
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 | |
1246 | // entire line): | |
1247 | wxPoint dirFromPos; | |
1248 | if ( !m_tmpSelFromCell ) | |
1249 | { | |
1250 | dirFromPos = m_tmpSelFromPos; | |
1251 | } | |
1252 | else | |
1253 | { | |
1254 | dirFromPos = m_tmpSelFromCell->GetAbsPos(); | |
1255 | if ( x < m_tmpSelFromPos.x ) | |
1256 | { | |
1257 | dirFromPos.x += m_tmpSelFromCell->GetWidth(); | |
1258 | dirFromPos.y += m_tmpSelFromCell->GetHeight(); | |
1259 | } | |
1260 | } | |
1261 | bool goingDown = dirFromPos.y < y || | |
1262 | (dirFromPos.y == y && dirFromPos.x < x); | |
1263 | ||
1264 | // determine selection span: | |
1265 | if ( /*still*/ !m_tmpSelFromCell ) | |
1266 | { | |
1267 | if (goingDown) | |
1268 | { | |
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(); | |
1274 | } | |
1275 | else | |
1276 | { | |
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(); | |
1282 | } | |
1283 | } | |
1284 | ||
1285 | wxHtmlCell *selcell = cell; | |
1286 | if (!selcell) | |
1287 | { | |
1288 | if (goingDown) | |
1289 | { | |
1290 | selcell = m_Cell->FindCellByPos(x, y, | |
1291 | wxHTML_FIND_NEAREST_BEFORE); | |
1292 | if (!selcell) | |
1293 | selcell = m_Cell->GetLastTerminal(); | |
1294 | } | |
1295 | else | |
1296 | { | |
1297 | selcell = m_Cell->FindCellByPos(x, y, | |
1298 | wxHTML_FIND_NEAREST_AFTER); | |
1299 | if (!selcell) | |
1300 | selcell = m_Cell->GetFirstTerminal(); | |
1301 | } | |
1302 | } | |
1303 | ||
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 | |
1306 | // visible cells. | |
1307 | if ( selcell && m_tmpSelFromCell ) | |
1308 | { | |
1309 | if ( !m_selection ) | |
1310 | { | |
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) | |
1316 | { | |
1317 | m_selection = new wxHtmlSelection(); | |
1318 | } | |
1319 | } | |
1320 | if ( m_selection ) | |
1321 | { | |
1322 | if ( m_tmpSelFromCell->IsBefore(selcell) ) | |
1323 | { | |
1324 | m_selection->Set(m_tmpSelFromPos, m_tmpSelFromCell, | |
1325 | wxPoint(x,y), selcell); | |
1326 | } | |
1327 | else | |
1328 | { | |
1329 | m_selection->Set(wxPoint(x,y), selcell, | |
1330 | m_tmpSelFromPos, m_tmpSelFromCell); | |
1331 | } | |
1332 | m_selection->ClearPrivPos(); | |
1333 | Refresh(); | |
1334 | } | |
1335 | } | |
1336 | } | |
1337 | ||
1338 | // handle cursor and status bar text changes: | |
1339 | ||
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); | |
1344 | if (cell) | |
1345 | posInCell -= cell->GetAbsPos(); | |
1346 | wxHtmlWindowMouseHelper::HandleIdle(cell, posInCell); | |
1347 | } | |
1348 | } | |
1349 | ||
1350 | #if wxUSE_CLIPBOARD | |
1351 | void wxHtmlWindow::StopAutoScrolling() | |
1352 | { | |
1353 | if ( m_timerAutoScroll ) | |
1354 | { | |
1355 | wxDELETE(m_timerAutoScroll); | |
1356 | } | |
1357 | } | |
1358 | ||
1359 | void wxHtmlWindow::OnMouseEnter(wxMouseEvent& event) | |
1360 | { | |
1361 | StopAutoScrolling(); | |
1362 | event.Skip(); | |
1363 | } | |
1364 | ||
1365 | void wxHtmlWindow::OnMouseLeave(wxMouseEvent& event) | |
1366 | { | |
1367 | // don't prevent the usual processing of the event from taking place | |
1368 | event.Skip(); | |
1369 | ||
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 ) | |
1374 | { | |
1375 | // where is the mouse leaving? | |
1376 | int pos, orient; | |
1377 | wxPoint pt = event.GetPosition(); | |
1378 | if ( pt.x < 0 ) | |
1379 | { | |
1380 | orient = wxHORIZONTAL; | |
1381 | pos = 0; | |
1382 | } | |
1383 | else if ( pt.y < 0 ) | |
1384 | { | |
1385 | orient = wxVERTICAL; | |
1386 | pos = 0; | |
1387 | } | |
1388 | else // we're lower or to the right of the window | |
1389 | { | |
1390 | wxSize size = GetClientSize(); | |
1391 | if ( pt.x > size.x ) | |
1392 | { | |
1393 | orient = wxHORIZONTAL; | |
1394 | pos = GetVirtualSize().x / wxHTML_SCROLL_STEP; | |
1395 | } | |
1396 | else if ( pt.y > size.y ) | |
1397 | { | |
1398 | orient = wxVERTICAL; | |
1399 | pos = GetVirtualSize().y / wxHTML_SCROLL_STEP; | |
1400 | } | |
1401 | else // this should be impossible | |
1402 | { | |
1403 | // but seems to happen sometimes under wxMSW - maybe it's a bug | |
1404 | // there but for now just ignore it | |
1405 | ||
1406 | //wxFAIL_MSG( wxT("can't understand where has mouse gone") ); | |
1407 | ||
1408 | return; | |
1409 | } | |
1410 | } | |
1411 | ||
1412 | // only start the auto scroll timer if the window can be scrolled in | |
1413 | // this direction | |
1414 | if ( !HasScrollbar(orient) ) | |
1415 | return; | |
1416 | ||
1417 | delete m_timerAutoScroll; | |
1418 | m_timerAutoScroll = new wxHtmlWinAutoScrollTimer | |
1419 | ( | |
1420 | this, | |
1421 | pos == 0 ? wxEVT_SCROLLWIN_LINEUP | |
1422 | : wxEVT_SCROLLWIN_LINEDOWN, | |
1423 | pos, | |
1424 | orient | |
1425 | ); | |
1426 | m_timerAutoScroll->Start(50); // FIXME: make configurable | |
1427 | } | |
1428 | } | |
1429 | ||
1430 | void wxHtmlWindow::OnKeyUp(wxKeyEvent& event) | |
1431 | { | |
1432 | if ( IsSelectionEnabled() && | |
1433 | (event.GetKeyCode() == 'C' && event.CmdDown()) ) | |
1434 | { | |
1435 | wxClipboardTextEvent evt(wxEVT_COMMAND_TEXT_COPY, GetId()); | |
1436 | ||
1437 | evt.SetEventObject(this); | |
1438 | ||
1439 | GetEventHandler()->ProcessEvent(evt); | |
1440 | } | |
1441 | } | |
1442 | ||
1443 | void wxHtmlWindow::OnCopy(wxCommandEvent& WXUNUSED(event)) | |
1444 | { | |
1445 | (void) CopySelection(); | |
1446 | } | |
1447 | ||
1448 | void wxHtmlWindow::OnClipboardEvent(wxClipboardTextEvent& WXUNUSED(event)) | |
1449 | { | |
1450 | (void) CopySelection(); | |
1451 | } | |
1452 | ||
1453 | void wxHtmlWindow::OnDoubleClick(wxMouseEvent& event) | |
1454 | { | |
1455 | // select word under cursor: | |
1456 | if ( IsSelectionEnabled() ) | |
1457 | { | |
1458 | SelectWord(CalcUnscrolledPosition(event.GetPosition())); | |
1459 | ||
1460 | (void) CopySelection(Primary); | |
1461 | ||
1462 | m_lastDoubleClick = wxGetLocalTimeMillis(); | |
1463 | } | |
1464 | else | |
1465 | event.Skip(); | |
1466 | } | |
1467 | ||
1468 | void wxHtmlWindow::SelectWord(const wxPoint& pos) | |
1469 | { | |
1470 | if ( m_Cell ) | |
1471 | { | |
1472 | wxHtmlCell *cell = m_Cell->FindCellByPos(pos.x, pos.y); | |
1473 | if ( cell ) | |
1474 | { | |
1475 | delete m_selection; | |
1476 | m_selection = new wxHtmlSelection(); | |
1477 | m_selection->Set(cell, cell); | |
1478 | RefreshRect(wxRect(CalcScrolledPosition(cell->GetAbsPos()), | |
1479 | wxSize(cell->GetWidth(), cell->GetHeight()))); | |
1480 | } | |
1481 | } | |
1482 | } | |
1483 | ||
1484 | void wxHtmlWindow::SelectLine(const wxPoint& pos) | |
1485 | { | |
1486 | if ( m_Cell ) | |
1487 | { | |
1488 | wxHtmlCell *cell = m_Cell->FindCellByPos(pos.x, pos.y); | |
1489 | if ( cell ) | |
1490 | { | |
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). | |
1495 | ||
1496 | int y1 = cell->GetAbsPos().y; | |
1497 | int y2 = y1 + cell->GetHeight(); | |
1498 | int y; | |
1499 | const wxHtmlCell *c; | |
1500 | const wxHtmlCell *before = NULL; | |
1501 | const wxHtmlCell *after = NULL; | |
1502 | ||
1503 | // find last cell of line: | |
1504 | for ( c = cell->GetNext(); c; c = c->GetNext()) | |
1505 | { | |
1506 | y = c->GetAbsPos().y; | |
1507 | if ( y + c->GetHeight() > y1 && y < y2 ) | |
1508 | after = c; | |
1509 | else | |
1510 | break; | |
1511 | } | |
1512 | if ( !after ) | |
1513 | after = cell; | |
1514 | ||
1515 | // find first cell of line: | |
1516 | for ( c = cell->GetParent()->GetFirstChild(); | |
1517 | c && c != cell; c = c->GetNext()) | |
1518 | { | |
1519 | y = c->GetAbsPos().y; | |
1520 | if ( y + c->GetHeight() > y1 && y < y2 ) | |
1521 | { | |
1522 | if ( ! before ) | |
1523 | before = c; | |
1524 | } | |
1525 | else | |
1526 | before = NULL; | |
1527 | } | |
1528 | if ( !before ) | |
1529 | before = cell; | |
1530 | ||
1531 | delete m_selection; | |
1532 | m_selection = new wxHtmlSelection(); | |
1533 | m_selection->Set(before, after); | |
1534 | ||
1535 | Refresh(); | |
1536 | } | |
1537 | } | |
1538 | } | |
1539 | ||
1540 | void wxHtmlWindow::SelectAll() | |
1541 | { | |
1542 | if ( m_Cell ) | |
1543 | { | |
1544 | delete m_selection; | |
1545 | m_selection = new wxHtmlSelection(); | |
1546 | m_selection->Set(m_Cell->GetFirstTerminal(), m_Cell->GetLastTerminal()); | |
1547 | Refresh(); | |
1548 | } | |
1549 | } | |
1550 | ||
1551 | #endif // wxUSE_CLIPBOARD | |
1552 | ||
1553 | ||
1554 | ||
1555 | IMPLEMENT_ABSTRACT_CLASS(wxHtmlProcessor,wxObject) | |
1556 | ||
1557 | #if wxUSE_EXTENDED_RTTI | |
1558 | IMPLEMENT_DYNAMIC_CLASS_XTI(wxHtmlWindow, wxScrolledWindow,"wx/html/htmlwin.h") | |
1559 | ||
1560 | wxBEGIN_PROPERTIES_TABLE(wxHtmlWindow) | |
1561 | /* | |
1562 | TODO PROPERTIES | |
1563 | style , wxHW_SCROLLBAR_AUTO | |
1564 | borders , (dimension) | |
1565 | url , string | |
1566 | htmlcode , string | |
1567 | */ | |
1568 | wxEND_PROPERTIES_TABLE() | |
1569 | ||
1570 | wxBEGIN_HANDLERS_TABLE(wxHtmlWindow) | |
1571 | wxEND_HANDLERS_TABLE() | |
1572 | ||
1573 | wxCONSTRUCTOR_5( wxHtmlWindow , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle ) | |
1574 | #else | |
1575 | IMPLEMENT_DYNAMIC_CLASS(wxHtmlWindow,wxScrolledWindow) | |
1576 | #endif | |
1577 | ||
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) | |
1585 | #if wxUSE_CLIPBOARD | |
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 | |
1594 | END_EVENT_TABLE() | |
1595 | ||
1596 | //----------------------------------------------------------------------------- | |
1597 | // wxHtmlWindowInterface implementation in wxHtmlWindow | |
1598 | //----------------------------------------------------------------------------- | |
1599 | ||
1600 | void wxHtmlWindow::SetHTMLWindowTitle(const wxString& title) | |
1601 | { | |
1602 | OnSetTitle(title); | |
1603 | } | |
1604 | ||
1605 | void wxHtmlWindow::OnHTMLLinkClicked(const wxHtmlLinkInfo& link) | |
1606 | { | |
1607 | OnLinkClicked(link); | |
1608 | } | |
1609 | ||
1610 | wxHtmlOpeningStatus wxHtmlWindow::OnHTMLOpeningURL(wxHtmlURLType type, | |
1611 | const wxString& url, | |
1612 | wxString *redirect) const | |
1613 | { | |
1614 | return OnOpeningURL(type, url, redirect); | |
1615 | } | |
1616 | ||
1617 | wxPoint wxHtmlWindow::HTMLCoordsToWindow(wxHtmlCell *WXUNUSED(cell), | |
1618 | const wxPoint& pos) const | |
1619 | { | |
1620 | return CalcScrolledPosition(pos); | |
1621 | } | |
1622 | ||
1623 | wxWindow* wxHtmlWindow::GetHTMLWindow() | |
1624 | { | |
1625 | return this; | |
1626 | } | |
1627 | ||
1628 | wxColour wxHtmlWindow::GetHTMLBackgroundColour() const | |
1629 | { | |
1630 | return GetBackgroundColour(); | |
1631 | } | |
1632 | ||
1633 | void wxHtmlWindow::SetHTMLBackgroundColour(const wxColour& clr) | |
1634 | { | |
1635 | SetBackgroundColour(clr); | |
1636 | } | |
1637 | ||
1638 | void wxHtmlWindow::SetHTMLBackgroundImage(const wxBitmap& bmpBg) | |
1639 | { | |
1640 | SetBackgroundImage(bmpBg); | |
1641 | } | |
1642 | ||
1643 | void wxHtmlWindow::SetHTMLStatusText(const wxString& text) | |
1644 | { | |
1645 | #if wxUSE_STATUSBAR | |
1646 | if (m_RelatedStatusBarIndex != -1) | |
1647 | { | |
1648 | if (m_RelatedStatusBar) | |
1649 | { | |
1650 | m_RelatedStatusBar->SetStatusText(text, m_RelatedStatusBarIndex); | |
1651 | } | |
1652 | else if (m_RelatedFrame) | |
1653 | { | |
1654 | m_RelatedFrame->SetStatusText(text, m_RelatedStatusBarIndex); | |
1655 | } | |
1656 | } | |
1657 | #else | |
1658 | wxUnusedVar(text); | |
1659 | #endif // wxUSE_STATUSBAR | |
1660 | } | |
1661 | ||
1662 | /*static*/ | |
1663 | wxCursor wxHtmlWindow::GetDefaultHTMLCursor(HTMLCursor type) | |
1664 | { | |
1665 | switch (type) | |
1666 | { | |
1667 | case HTMLCursor_Link: | |
1668 | if ( !ms_cursorLink ) | |
1669 | ms_cursorLink = new wxCursor(wxCURSOR_HAND); | |
1670 | return *ms_cursorLink; | |
1671 | ||
1672 | case HTMLCursor_Text: | |
1673 | if ( !ms_cursorText ) | |
1674 | ms_cursorText = new wxCursor(wxCURSOR_IBEAM); | |
1675 | return *ms_cursorText; | |
1676 | ||
1677 | case HTMLCursor_Default: | |
1678 | default: | |
1679 | return *wxSTANDARD_CURSOR; | |
1680 | } | |
1681 | } | |
1682 | ||
1683 | wxCursor wxHtmlWindow::GetHTMLCursor(HTMLCursor type) const | |
1684 | { | |
1685 | return GetDefaultHTMLCursor(type); | |
1686 | } | |
1687 | ||
1688 | ||
1689 | //----------------------------------------------------------------------------- | |
1690 | // wxHtmlWinModule | |
1691 | //----------------------------------------------------------------------------- | |
1692 | ||
1693 | // A module to allow initialization/cleanup | |
1694 | // without calling these functions from app.cpp or from | |
1695 | // the user's application. | |
1696 | ||
1697 | class wxHtmlWinModule: public wxModule | |
1698 | { | |
1699 | DECLARE_DYNAMIC_CLASS(wxHtmlWinModule) | |
1700 | public: | |
1701 | wxHtmlWinModule() : wxModule() {} | |
1702 | bool OnInit() { return true; } | |
1703 | void OnExit() { wxHtmlWindow::CleanUpStatics(); } | |
1704 | }; | |
1705 | ||
1706 | IMPLEMENT_DYNAMIC_CLASS(wxHtmlWinModule, wxModule) | |
1707 | ||
1708 | ||
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() | |
1713 | ||
1714 | #endif // wxUSE_HTML |