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