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