]> git.saurik.com Git - wxWidgets.git/blob - src/html/htmlwin.cpp
Allow entering minus sign in wxMSW wxSpinCtrl if needed.
[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 #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