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


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