]>
Commit | Line | Data |
---|---|---|
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 | #ifdef __GNUG__ | |
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 __BORDLANDC__ | |
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/forcelnk.h" | |
34 | #include "wx/html/htmlproc.h" | |
35 | #include "wx/list.h" | |
36 | ||
37 | #include "wx/arrimpl.cpp" | |
38 | #include "wx/listimpl.cpp" | |
39 | ||
40 | //----------------------------------------------------------------------------- | |
41 | // wxHtmlHistoryItem | |
42 | //----------------------------------------------------------------------------- | |
43 | ||
44 | // item of history list | |
45 | class WXDLLEXPORT wxHtmlHistoryItem : public wxObject | |
46 | { | |
47 | public: | |
48 | wxHtmlHistoryItem(const wxString& p, const wxString& a) {m_Page = p, m_Anchor = a, m_Pos = 0;} | |
49 | int GetPos() const {return m_Pos;} | |
50 | void SetPos(int p) {m_Pos = p;} | |
51 | const wxString& GetPage() const {return m_Page;} | |
52 | const wxString& GetAnchor() const {return m_Anchor;} | |
53 | ||
54 | private: | |
55 | wxString m_Page; | |
56 | wxString m_Anchor; | |
57 | int m_Pos; | |
58 | }; | |
59 | ||
60 | ||
61 | //----------------------------------------------------------------------------- | |
62 | // our private arrays: | |
63 | //----------------------------------------------------------------------------- | |
64 | ||
65 | WX_DECLARE_OBJARRAY(wxHtmlHistoryItem, wxHtmlHistoryArray); | |
66 | WX_DEFINE_OBJARRAY(wxHtmlHistoryArray); | |
67 | ||
68 | WX_DECLARE_LIST(wxHtmlProcessor, wxHtmlProcessorList); | |
69 | WX_DEFINE_LIST(wxHtmlProcessorList); | |
70 | ||
71 | //----------------------------------------------------------------------------- | |
72 | // wxHtmlWindow | |
73 | //----------------------------------------------------------------------------- | |
74 | ||
75 | ||
76 | wxHtmlWindow::wxHtmlWindow(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, | |
77 | long style, const wxString& name) : wxScrolledWindow(parent, id, pos, size, style | wxVSCROLL | wxHSCROLL, name) | |
78 | { | |
79 | m_tmpMouseMoved = FALSE; | |
80 | m_tmpLastLink = NULL; | |
81 | m_tmpCanDrawLocks = 0; | |
82 | m_FS = new wxFileSystem(); | |
83 | m_RelatedStatusBar = -1; | |
84 | m_RelatedFrame = NULL; | |
85 | m_TitleFormat = wxT("%s"); | |
86 | m_OpenedPage = m_OpenedAnchor = m_OpenedPageTitle = wxEmptyString; | |
87 | m_Cell = NULL; | |
88 | m_Parser = new wxHtmlWinParser(this); | |
89 | m_Parser->SetFS(m_FS); | |
90 | SetBorders(10); | |
91 | m_HistoryPos = -1; | |
92 | m_HistoryOn = TRUE; | |
93 | m_History = new wxHtmlHistoryArray; | |
94 | m_Processors = NULL; | |
95 | m_Style = style; | |
96 | SetPage(wxT("<html><body></body></html>")); | |
97 | } | |
98 | ||
99 | ||
100 | ||
101 | wxHtmlWindow::~wxHtmlWindow() | |
102 | { | |
103 | HistoryClear(); | |
104 | ||
105 | if (m_Cell) delete m_Cell; | |
106 | ||
107 | delete m_Parser; | |
108 | delete m_FS; | |
109 | delete m_History; | |
110 | delete m_Processors; | |
111 | } | |
112 | ||
113 | ||
114 | ||
115 | void wxHtmlWindow::SetRelatedFrame(wxFrame* frame, const wxString& format) | |
116 | { | |
117 | m_RelatedFrame = frame; | |
118 | m_TitleFormat = format; | |
119 | } | |
120 | ||
121 | ||
122 | ||
123 | void wxHtmlWindow::SetRelatedStatusBar(int bar) | |
124 | { | |
125 | m_RelatedStatusBar = bar; | |
126 | } | |
127 | ||
128 | ||
129 | ||
130 | void wxHtmlWindow::SetFonts(wxString normal_face, wxString fixed_face, const int *sizes) | |
131 | { | |
132 | wxString op = m_OpenedPage; | |
133 | ||
134 | m_Parser->SetFonts(normal_face, fixed_face, sizes); | |
135 | // fonts changed => contents invalid, so reload the page: | |
136 | SetPage(wxT("<html><body></body></html>")); | |
137 | if (!op.IsEmpty()) LoadPage(op); | |
138 | } | |
139 | ||
140 | ||
141 | ||
142 | bool wxHtmlWindow::SetPage(const wxString& source) | |
143 | { | |
144 | wxString newsrc(source); | |
145 | ||
146 | // pass HTML through registered processors: | |
147 | if (m_Processors || m_GlobalProcessors) | |
148 | { | |
149 | wxHtmlProcessorList::Node *nodeL, *nodeG; | |
150 | int prL, prG; | |
151 | ||
152 | nodeL = (m_Processors) ? m_Processors->GetFirst() : NULL; | |
153 | nodeG = (m_GlobalProcessors) ? m_GlobalProcessors->GetFirst() : NULL; | |
154 | ||
155 | // VS: there are two lists, global and local, both of them sorted by | |
156 | // priority. Since we have to go through _both_ lists with | |
157 | // decreasing priority, we "merge-sort" the lists on-line by | |
158 | // processing that one of the two heads that has higher priority | |
159 | // in every iteration | |
160 | while (nodeL || nodeG) | |
161 | { | |
162 | prL = (nodeL) ? nodeL->GetData()->GetPriority() : -1; | |
163 | prG = (nodeG) ? nodeG->GetData()->GetPriority() : -1; | |
164 | if (prL > prG) | |
165 | { | |
166 | if (nodeL->GetData()->IsEnabled()) | |
167 | newsrc = nodeL->GetData()->Process(newsrc); | |
168 | nodeL = nodeL->GetNext(); | |
169 | } | |
170 | else // prL <= prG | |
171 | { | |
172 | if (nodeG->GetData()->IsEnabled()) | |
173 | newsrc = nodeG->GetData()->Process(newsrc); | |
174 | nodeG = nodeG->GetNext(); | |
175 | } | |
176 | } | |
177 | } | |
178 | ||
179 | // ...and run the parser on it: | |
180 | wxClientDC *dc = new wxClientDC(this); | |
181 | dc->SetMapMode(wxMM_TEXT); | |
182 | SetBackgroundColour(wxColour(0xFF, 0xFF, 0xFF)); | |
183 | m_OpenedPage = m_OpenedAnchor = m_OpenedPageTitle = wxEmptyString; | |
184 | m_Parser->SetDC(dc); | |
185 | if (m_Cell) | |
186 | { | |
187 | delete m_Cell; | |
188 | m_Cell = NULL; | |
189 | } | |
190 | m_Cell = (wxHtmlContainerCell*) m_Parser->Parse(newsrc); | |
191 | delete dc; | |
192 | m_Cell->SetIndent(m_Borders, wxHTML_INDENT_ALL, wxHTML_UNITS_PIXELS); | |
193 | m_Cell->SetAlignHor(wxHTML_ALIGN_CENTER); | |
194 | CreateLayout(); | |
195 | if (m_tmpCanDrawLocks == 0) | |
196 | Refresh(); | |
197 | return TRUE; | |
198 | } | |
199 | ||
200 | ||
201 | bool wxHtmlWindow::LoadPage(const wxString& location) | |
202 | { | |
203 | wxFSFile *f; | |
204 | bool rt_val; | |
205 | bool needs_refresh = FALSE; | |
206 | ||
207 | SetCursor(*wxHOURGLASS_CURSOR); | |
208 | wxYield(); Refresh(FALSE); | |
209 | ||
210 | m_tmpCanDrawLocks++; | |
211 | if (m_HistoryOn && (m_HistoryPos != -1)) | |
212 | { | |
213 | // store scroll position into history item: | |
214 | int x, y; | |
215 | GetViewStart(&x, &y); | |
216 | (*m_History)[m_HistoryPos].SetPos(y); | |
217 | } | |
218 | ||
219 | if (location[0] == wxT('#')) | |
220 | { | |
221 | // local anchor: | |
222 | wxString anch = location.Mid(1) /*1 to end*/; | |
223 | m_tmpCanDrawLocks--; | |
224 | rt_val = ScrollToAnchor(anch); | |
225 | m_tmpCanDrawLocks++; | |
226 | } | |
227 | else if (location.Find(wxT('#')) != wxNOT_FOUND && location.BeforeFirst(wxT('#')) == m_OpenedPage) | |
228 | { | |
229 | wxString anch = location.AfterFirst(wxT('#')); | |
230 | m_tmpCanDrawLocks--; | |
231 | rt_val = ScrollToAnchor(anch); | |
232 | m_tmpCanDrawLocks++; | |
233 | } | |
234 | else if (location.Find(wxT('#')) != wxNOT_FOUND && | |
235 | (m_FS->GetPath() + location.BeforeFirst(wxT('#'))) == m_OpenedPage) | |
236 | { | |
237 | wxString anch = location.AfterFirst(wxT('#')); | |
238 | m_tmpCanDrawLocks--; | |
239 | rt_val = ScrollToAnchor(anch); | |
240 | m_tmpCanDrawLocks++; | |
241 | } | |
242 | ||
243 | else | |
244 | { | |
245 | needs_refresh = TRUE; | |
246 | // load&display it: | |
247 | if (m_RelatedStatusBar != -1) | |
248 | { | |
249 | m_RelatedFrame->SetStatusText(_("Connecting..."), m_RelatedStatusBar); | |
250 | Refresh(FALSE); | |
251 | } | |
252 | ||
253 | f = m_FS->OpenFile(location); | |
254 | ||
255 | if (f == NULL) | |
256 | { | |
257 | wxLogError(_("Unable to open requested HTML document: %s"), location.c_str()); | |
258 | m_tmpCanDrawLocks--; | |
259 | ||
260 | SetCursor(*wxSTANDARD_CURSOR); | |
261 | return FALSE; | |
262 | } | |
263 | ||
264 | else | |
265 | { | |
266 | wxNode *node; | |
267 | wxString src = wxEmptyString; | |
268 | ||
269 | if (m_RelatedStatusBar != -1) | |
270 | { | |
271 | wxString msg = _("Loading : ") + location; | |
272 | m_RelatedFrame->SetStatusText(msg, m_RelatedStatusBar); | |
273 | Refresh(FALSE); | |
274 | } | |
275 | ||
276 | node = m_Filters.GetFirst(); | |
277 | while (node) | |
278 | { | |
279 | wxHtmlFilter *h = (wxHtmlFilter*) node->GetData(); | |
280 | if (h->CanRead(*f)) | |
281 | { | |
282 | src = h->ReadFile(*f); | |
283 | break; | |
284 | } | |
285 | node = node->GetNext(); | |
286 | } | |
287 | if (src == wxEmptyString) | |
288 | { | |
289 | if (m_DefaultFilter == NULL) m_DefaultFilter = GetDefaultFilter(); | |
290 | src = m_DefaultFilter->ReadFile(*f); | |
291 | } | |
292 | ||
293 | m_FS->ChangePathTo(f->GetLocation()); | |
294 | rt_val = SetPage(src); | |
295 | m_OpenedPage = f->GetLocation(); | |
296 | if (f->GetAnchor() != wxEmptyString) | |
297 | { | |
298 | wxYield(); | |
299 | ScrollToAnchor(f->GetAnchor()); | |
300 | } | |
301 | ||
302 | delete f; | |
303 | ||
304 | if (m_RelatedStatusBar != -1) m_RelatedFrame->SetStatusText(_("Done"), m_RelatedStatusBar); | |
305 | } | |
306 | } | |
307 | ||
308 | if (m_HistoryOn) // add this page to history there: | |
309 | { | |
310 | int c = m_History->GetCount() - (m_HistoryPos + 1); | |
311 | ||
312 | if (m_HistoryPos < 0 || | |
313 | (*m_History)[m_HistoryPos].GetPage() != m_OpenedPage || | |
314 | (*m_History)[m_HistoryPos].GetAnchor() != m_OpenedAnchor) | |
315 | { | |
316 | m_HistoryPos++; | |
317 | for (int i = 0; i < c; i++) | |
318 | m_History->Remove(m_HistoryPos); | |
319 | m_History->Add(new wxHtmlHistoryItem(m_OpenedPage, m_OpenedAnchor)); | |
320 | } | |
321 | } | |
322 | ||
323 | if (m_OpenedPageTitle == wxEmptyString) | |
324 | OnSetTitle(wxFileNameFromPath(m_OpenedPage)); | |
325 | SetCursor(*wxSTANDARD_CURSOR); | |
326 | ||
327 | if (needs_refresh) | |
328 | { | |
329 | wxYield(); | |
330 | m_tmpCanDrawLocks--; | |
331 | Refresh(); | |
332 | } | |
333 | else | |
334 | m_tmpCanDrawLocks--; | |
335 | ||
336 | return rt_val; | |
337 | } | |
338 | ||
339 | ||
340 | ||
341 | bool wxHtmlWindow::ScrollToAnchor(const wxString& anchor) | |
342 | { | |
343 | const wxHtmlCell *c = m_Cell->Find(wxHTML_COND_ISANCHOR, &anchor); | |
344 | if (!c) | |
345 | { | |
346 | wxLogWarning(_("HTML anchor %s does not exist."), anchor.c_str()); | |
347 | return FALSE; | |
348 | } | |
349 | else | |
350 | { | |
351 | int y; | |
352 | ||
353 | for (y = 0; c != NULL; c = c->GetParent()) y += c->GetPosY(); | |
354 | Scroll(-1, y / wxHTML_SCROLL_STEP); | |
355 | m_OpenedAnchor = anchor; | |
356 | return TRUE; | |
357 | } | |
358 | } | |
359 | ||
360 | ||
361 | void wxHtmlWindow::OnSetTitle(const wxString& title) | |
362 | { | |
363 | if (m_RelatedFrame) | |
364 | { | |
365 | wxString tit; | |
366 | tit.Printf(m_TitleFormat, title.c_str()); | |
367 | m_RelatedFrame->SetTitle(tit); | |
368 | } | |
369 | m_OpenedPageTitle = title; | |
370 | } | |
371 | ||
372 | ||
373 | ||
374 | ||
375 | ||
376 | void wxHtmlWindow::CreateLayout() | |
377 | { | |
378 | int ClientWidth, ClientHeight; | |
379 | ||
380 | if (!m_Cell) return; | |
381 | ||
382 | if (m_Style & wxHW_SCROLLBAR_NEVER) | |
383 | { | |
384 | SetScrollbars(wxHTML_SCROLL_STEP, 1, m_Cell->GetWidth() / wxHTML_SCROLL_STEP, 0); // always off | |
385 | GetClientSize(&ClientWidth, &ClientHeight); | |
386 | m_Cell->Layout(ClientWidth); | |
387 | } | |
388 | ||
389 | else { | |
390 | GetClientSize(&ClientWidth, &ClientHeight); | |
391 | m_Cell->Layout(ClientWidth); | |
392 | if (ClientHeight < m_Cell->GetHeight() + GetCharHeight()) | |
393 | { | |
394 | SetScrollbars( | |
395 | wxHTML_SCROLL_STEP, wxHTML_SCROLL_STEP, | |
396 | m_Cell->GetWidth() / wxHTML_SCROLL_STEP, | |
397 | (m_Cell->GetHeight() + GetCharHeight()) / wxHTML_SCROLL_STEP | |
398 | /*cheat: top-level frag is always container*/); | |
399 | } | |
400 | else /* we fit into window, no need for scrollbars */ | |
401 | { | |
402 | SetScrollbars(wxHTML_SCROLL_STEP, 1, m_Cell->GetWidth() / wxHTML_SCROLL_STEP, 0); // disable... | |
403 | GetClientSize(&ClientWidth, &ClientHeight); | |
404 | m_Cell->Layout(ClientWidth); // ...and relayout | |
405 | } | |
406 | } | |
407 | } | |
408 | ||
409 | ||
410 | ||
411 | void wxHtmlWindow::ReadCustomization(wxConfigBase *cfg, wxString path) | |
412 | { | |
413 | wxString oldpath; | |
414 | wxString tmp; | |
415 | int p_fontsizes[7]; | |
416 | wxString p_fff, p_ffn; | |
417 | ||
418 | if (path != wxEmptyString) | |
419 | { | |
420 | oldpath = cfg->GetPath(); | |
421 | cfg->SetPath(path); | |
422 | } | |
423 | ||
424 | m_Borders = cfg->Read(wxT("wxHtmlWindow/Borders"), m_Borders); | |
425 | p_fff = cfg->Read(wxT("wxHtmlWindow/FontFaceFixed"), m_Parser->m_FontFaceFixed); | |
426 | p_ffn = cfg->Read(wxT("wxHtmlWindow/FontFaceNormal"), m_Parser->m_FontFaceNormal); | |
427 | for (int i = 0; i < 7; i++) | |
428 | { | |
429 | tmp.Printf(wxT("wxHtmlWindow/FontsSize%i"), i); | |
430 | p_fontsizes[i] = cfg->Read(tmp, m_Parser->m_FontsSizes[i]); | |
431 | } | |
432 | SetFonts(p_ffn, p_fff, p_fontsizes); | |
433 | ||
434 | if (path != wxEmptyString) | |
435 | cfg->SetPath(oldpath); | |
436 | } | |
437 | ||
438 | ||
439 | ||
440 | void wxHtmlWindow::WriteCustomization(wxConfigBase *cfg, wxString path) | |
441 | { | |
442 | wxString oldpath; | |
443 | wxString tmp; | |
444 | ||
445 | if (path != wxEmptyString) | |
446 | { | |
447 | oldpath = cfg->GetPath(); | |
448 | cfg->SetPath(path); | |
449 | } | |
450 | ||
451 | cfg->Write(wxT("wxHtmlWindow/Borders"), (long) m_Borders); | |
452 | cfg->Write(wxT("wxHtmlWindow/FontFaceFixed"), m_Parser->m_FontFaceFixed); | |
453 | cfg->Write(wxT("wxHtmlWindow/FontFaceNormal"), m_Parser->m_FontFaceNormal); | |
454 | for (int i = 0; i < 7; i++) | |
455 | { | |
456 | tmp.Printf(wxT("wxHtmlWindow/FontsSize%i"), i); | |
457 | cfg->Write(tmp, (long) m_Parser->m_FontsSizes[i]); | |
458 | } | |
459 | ||
460 | if (path != wxEmptyString) | |
461 | cfg->SetPath(oldpath); | |
462 | } | |
463 | ||
464 | ||
465 | ||
466 | bool wxHtmlWindow::HistoryBack() | |
467 | { | |
468 | wxString a, l; | |
469 | ||
470 | if (m_HistoryPos < 1) return FALSE; | |
471 | ||
472 | // store scroll position into history item: | |
473 | int x, y; | |
474 | GetViewStart(&x, &y); | |
475 | (*m_History)[m_HistoryPos].SetPos(y); | |
476 | ||
477 | // go to previous position: | |
478 | m_HistoryPos--; | |
479 | ||
480 | l = (*m_History)[m_HistoryPos].GetPage(); | |
481 | a = (*m_History)[m_HistoryPos].GetAnchor(); | |
482 | m_HistoryOn = FALSE; | |
483 | m_tmpCanDrawLocks++; | |
484 | if (a == wxEmptyString) LoadPage(l); | |
485 | else LoadPage(l + wxT("#") + a); | |
486 | m_HistoryOn = TRUE; | |
487 | wxYield(); | |
488 | m_tmpCanDrawLocks--; | |
489 | Scroll(0, (*m_History)[m_HistoryPos].GetPos()); | |
490 | Refresh(); | |
491 | return TRUE; | |
492 | } | |
493 | ||
494 | bool wxHtmlWindow::HistoryCanBack() | |
495 | { | |
496 | if (m_HistoryPos < 1) return FALSE; | |
497 | return TRUE ; | |
498 | } | |
499 | ||
500 | ||
501 | bool wxHtmlWindow::HistoryForward() | |
502 | { | |
503 | wxString a, l; | |
504 | ||
505 | if (m_HistoryPos == -1) return FALSE; | |
506 | if (m_HistoryPos >= (int)m_History->GetCount() - 1)return FALSE; | |
507 | ||
508 | m_OpenedPage = wxEmptyString; // this will disable adding new entry into history in LoadPage() | |
509 | ||
510 | m_HistoryPos++; | |
511 | l = (*m_History)[m_HistoryPos].GetPage(); | |
512 | a = (*m_History)[m_HistoryPos].GetAnchor(); | |
513 | m_HistoryOn = FALSE; | |
514 | m_tmpCanDrawLocks++; | |
515 | if (a == wxEmptyString) LoadPage(l); | |
516 | else LoadPage(l + wxT("#") + a); | |
517 | m_HistoryOn = TRUE; | |
518 | wxYield(); | |
519 | m_tmpCanDrawLocks--; | |
520 | Scroll(0, (*m_History)[m_HistoryPos].GetPos()); | |
521 | Refresh(); | |
522 | return TRUE; | |
523 | } | |
524 | ||
525 | bool wxHtmlWindow::HistoryCanForward() | |
526 | { | |
527 | if (m_HistoryPos == -1) return FALSE; | |
528 | if (m_HistoryPos >= (int)m_History->GetCount() - 1)return FALSE; | |
529 | return TRUE ; | |
530 | } | |
531 | ||
532 | ||
533 | void wxHtmlWindow::HistoryClear() | |
534 | { | |
535 | m_History->Empty(); | |
536 | m_HistoryPos = -1; | |
537 | } | |
538 | ||
539 | void wxHtmlWindow::AddProcessor(wxHtmlProcessor *processor) | |
540 | { | |
541 | if (!m_Processors) | |
542 | { | |
543 | m_Processors = new wxHtmlProcessorList; | |
544 | m_Processors->DeleteContents(TRUE); | |
545 | } | |
546 | wxHtmlProcessorList::Node *node; | |
547 | ||
548 | for (node = m_Processors->GetFirst(); node; node = node->GetNext()) | |
549 | { | |
550 | if (processor->GetPriority() > node->GetData()->GetPriority()) | |
551 | { | |
552 | m_Processors->Insert(node, processor); | |
553 | return; | |
554 | } | |
555 | } | |
556 | m_Processors->Append(processor); | |
557 | } | |
558 | ||
559 | /*static */ void wxHtmlWindow::AddGlobalProcessor(wxHtmlProcessor *processor) | |
560 | { | |
561 | if (!m_GlobalProcessors) | |
562 | { | |
563 | m_GlobalProcessors = new wxHtmlProcessorList; | |
564 | m_GlobalProcessors->DeleteContents(TRUE); | |
565 | } | |
566 | wxHtmlProcessorList::Node *node; | |
567 | ||
568 | for (node = m_GlobalProcessors->GetFirst(); node; node = node->GetNext()) | |
569 | { | |
570 | if (processor->GetPriority() > node->GetData()->GetPriority()) | |
571 | { | |
572 | m_GlobalProcessors->Insert(node, processor); | |
573 | return; | |
574 | } | |
575 | } | |
576 | m_GlobalProcessors->Append(processor); | |
577 | } | |
578 | ||
579 | ||
580 | ||
581 | wxList wxHtmlWindow::m_Filters; | |
582 | wxHtmlFilter *wxHtmlWindow::m_DefaultFilter = NULL; | |
583 | wxCursor *wxHtmlWindow::s_cur_hand = NULL; | |
584 | wxCursor *wxHtmlWindow::s_cur_arrow = NULL; | |
585 | wxHtmlProcessorList *wxHtmlWindow::m_GlobalProcessors = NULL; | |
586 | ||
587 | void wxHtmlWindow::CleanUpStatics() | |
588 | { | |
589 | delete m_DefaultFilter; | |
590 | m_DefaultFilter = NULL; | |
591 | m_Filters.DeleteContents(TRUE); | |
592 | m_Filters.Clear(); | |
593 | delete m_GlobalProcessors; | |
594 | m_GlobalProcessors = NULL; | |
595 | delete s_cur_hand; | |
596 | delete s_cur_arrow; | |
597 | } | |
598 | ||
599 | ||
600 | ||
601 | void wxHtmlWindow::AddFilter(wxHtmlFilter *filter) | |
602 | { | |
603 | m_Filters.Append(filter); | |
604 | } | |
605 | ||
606 | ||
607 | ||
608 | ||
609 | void wxHtmlWindow::OnLinkClicked(const wxHtmlLinkInfo& link) | |
610 | { | |
611 | LoadPage(link.GetHref()); | |
612 | } | |
613 | ||
614 | ||
615 | ||
616 | void wxHtmlWindow::OnDraw(wxDC& dc) | |
617 | { | |
618 | int x, y; | |
619 | wxRegionIterator upd(GetUpdateRegion()); // get the update rect list | |
620 | int v_y, v_h; | |
621 | ||
622 | if (m_tmpCanDrawLocks > 0) return; | |
623 | ||
624 | dc.SetMapMode(wxMM_TEXT); | |
625 | #if 0 | |
626 | /* VS - I don't think this is neccessary any longer | |
627 | MSC_VER 1200 means MSVC 6.0 and it works fine */ | |
628 | #if defined(_MSC_VER) && (_MSC_VER == 1200) | |
629 | ::SetMapMode((HDC)dc.GetHDC(), MM_TEXT); | |
630 | #endif | |
631 | #endif | |
632 | dc.SetBackgroundMode(wxTRANSPARENT); | |
633 | GetViewStart(&x, &y); | |
634 | ||
635 | while (upd) | |
636 | { | |
637 | v_y = upd.GetY(); | |
638 | v_h = upd.GetH(); | |
639 | if (m_Cell) m_Cell->Draw(dc, 0, 0, y * wxHTML_SCROLL_STEP + v_y, y * wxHTML_SCROLL_STEP + v_h + v_y); | |
640 | upd++; | |
641 | } | |
642 | } | |
643 | ||
644 | ||
645 | ||
646 | ||
647 | void wxHtmlWindow::OnSize(wxSizeEvent& event) | |
648 | { | |
649 | wxScrolledWindow::OnSize(event); | |
650 | CreateLayout(); | |
651 | Refresh(); | |
652 | } | |
653 | ||
654 | ||
655 | void wxHtmlWindow::OnMouseEvent(wxMouseEvent& event) | |
656 | { | |
657 | m_tmpMouseMoved = TRUE; | |
658 | ||
659 | if (event.ButtonDown()) | |
660 | { | |
661 | int sx, sy; | |
662 | wxPoint pos; | |
663 | wxString lnk; | |
664 | ||
665 | GetViewStart(&sx, &sy); sx *= wxHTML_SCROLL_STEP; sy *= wxHTML_SCROLL_STEP; | |
666 | pos = event.GetPosition(); | |
667 | ||
668 | if (m_Cell) | |
669 | m_Cell->OnMouseClick(this, sx + pos.x, sy + pos.y, event); | |
670 | } | |
671 | } | |
672 | ||
673 | ||
674 | ||
675 | void wxHtmlWindow::OnIdle(wxIdleEvent& WXUNUSED(event)) | |
676 | { | |
677 | if (s_cur_hand == NULL) | |
678 | { | |
679 | s_cur_hand = new wxCursor(wxCURSOR_HAND); | |
680 | s_cur_arrow = new wxCursor(wxCURSOR_ARROW); | |
681 | } | |
682 | ||
683 | if (m_tmpMouseMoved && (m_Cell != NULL)) | |
684 | { | |
685 | int sx, sy; | |
686 | int x, y; | |
687 | wxHtmlLinkInfo *lnk; | |
688 | ||
689 | GetViewStart(&sx, &sy); sx *= wxHTML_SCROLL_STEP; sy *= wxHTML_SCROLL_STEP; | |
690 | wxGetMousePosition(&x, &y); | |
691 | ScreenToClient(&x, &y); | |
692 | lnk = m_Cell->GetLink(sx + x, sy + y); | |
693 | ||
694 | if (lnk != m_tmpLastLink) | |
695 | { | |
696 | if (lnk == NULL) | |
697 | { | |
698 | SetCursor(*s_cur_arrow); | |
699 | if (m_RelatedStatusBar != -1) m_RelatedFrame->SetStatusText(wxEmptyString, m_RelatedStatusBar); | |
700 | } | |
701 | else | |
702 | { | |
703 | SetCursor(*s_cur_hand); | |
704 | if (m_RelatedStatusBar != -1) | |
705 | m_RelatedFrame->SetStatusText(lnk->GetHref(), m_RelatedStatusBar); | |
706 | } | |
707 | m_tmpLastLink = lnk; | |
708 | } | |
709 | m_tmpMouseMoved = FALSE; | |
710 | } | |
711 | } | |
712 | ||
713 | ||
714 | IMPLEMENT_ABSTRACT_CLASS(wxHtmlProcessor,wxObject) | |
715 | ||
716 | IMPLEMENT_DYNAMIC_CLASS(wxHtmlWindow,wxScrolledWindow) | |
717 | ||
718 | BEGIN_EVENT_TABLE(wxHtmlWindow, wxScrolledWindow) | |
719 | EVT_SIZE(wxHtmlWindow::OnSize) | |
720 | EVT_LEFT_DOWN(wxHtmlWindow::OnMouseEvent) | |
721 | EVT_MOTION(wxHtmlWindow::OnMouseEvent) | |
722 | EVT_IDLE(wxHtmlWindow::OnIdle) | |
723 | END_EVENT_TABLE() | |
724 | ||
725 | ||
726 | ||
727 | ||
728 | ||
729 | // A module to allow initialization/cleanup | |
730 | // without calling these functions from app.cpp or from | |
731 | // the user's application. | |
732 | ||
733 | class wxHtmlWinModule: public wxModule | |
734 | { | |
735 | DECLARE_DYNAMIC_CLASS(wxHtmlWinModule) | |
736 | public: | |
737 | wxHtmlWinModule() : wxModule() {} | |
738 | bool OnInit() { return TRUE; } | |
739 | void OnExit() { wxHtmlWindow::CleanUpStatics(); } | |
740 | }; | |
741 | ||
742 | IMPLEMENT_DYNAMIC_CLASS(wxHtmlWinModule, wxModule) | |
743 | ||
744 | ||
745 | ||
746 | ||
747 | ///// default mod handlers are forced there: | |
748 | ||
749 | FORCE_LINK(m_layout) | |
750 | FORCE_LINK(m_fonts) | |
751 | FORCE_LINK(m_image) | |
752 | FORCE_LINK(m_list) | |
753 | FORCE_LINK(m_dflist) | |
754 | FORCE_LINK(m_pre) | |
755 | FORCE_LINK(m_hline) | |
756 | FORCE_LINK(m_links) | |
757 | FORCE_LINK(m_tables) | |
758 | FORCE_LINK(m_meta) | |
759 | ||
760 | ||
761 | #endif |