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         GetViewStart(&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             wxLogError(_("Unable to open requested HTML document: %s"), location.c_str());
 255             m_tmpCanDrawLocks--;
 256
 257             SetCursor(*wxSTANDARD_CURSOR);
 258             return FALSE;
 259         }
 260
 261         else
 262         {
 263             wxNode *node;
 264             wxString src = wxEmptyString;
 265
 266             if (m_RelatedStatusBar != -1)
 267             {
 268                 wxString msg = _("Loading : ") + location;
 269                 m_RelatedFrame->SetStatusText(msg, m_RelatedStatusBar);
 270                 Refresh(FALSE);
 271             }
 272
 273             node = m_Filters.GetFirst();
 274             while (node)
 275             {
 276                 wxHtmlFilter *h = (wxHtmlFilter*) node->GetData();
 277                 if (h->CanRead(*f))
 278                 {
 279                     src = h->ReadFile(*f);
 280                     break;
 281                 }
 282                 node = node->GetNext();
 283             }
 284             if (src == wxEmptyString)
 285             {
 286                 if (m_DefaultFilter == NULL) m_DefaultFilter = GetDefaultFilter();
 287                 src = m_DefaultFilter->ReadFile(*f);
 288             }
 289
 290             m_FS->ChangePathTo(f->GetLocation());
 291             rt_val = SetPage(src);
 292             m_OpenedPage = f->GetLocation();
 293             if (f->GetAnchor() != wxEmptyString)
 294             {
 295                 wxYield();
 296                 ScrollToAnchor(f->GetAnchor());
 297             }
 298
 299             delete f;
 300
 301             if (m_RelatedStatusBar != -1) m_RelatedFrame->SetStatusText(_("Done"), m_RelatedStatusBar);
 302         }
 303     }
 304
 305     if (m_HistoryOn) // add this page to history there:
 306     {
 307         int c = m_History->GetCount() - (m_HistoryPos + 1);
 308
 309         m_HistoryPos++;
 310         for (int i = 0; i < c; i++)
 311             m_History->Remove(m_HistoryPos);
 312         m_History->Add(new wxHtmlHistoryItem(m_OpenedPage, m_OpenedAnchor));
 313     }
 314
 315     if (m_OpenedPageTitle == wxEmptyString)
 316         OnSetTitle(wxFileNameFromPath(m_OpenedPage));
 317     SetCursor(*wxSTANDARD_CURSOR);
 318
 319     if (needs_refresh)
 320     {
 321         wxYield();
 322         m_tmpCanDrawLocks--;
 323         Refresh();
 324     }
 325     else
 326         m_tmpCanDrawLocks--;
 327
 328     return rt_val;
 329 }
 330
 331
 332
 333 bool wxHtmlWindow::ScrollToAnchor(const wxString& anchor)
 334 {
 335     const wxHtmlCell *c = m_Cell->Find(wxHTML_COND_ISANCHOR, &anchor);
 336     if (!c)
 337     {
 338         wxLogWarning(_("HTML anchor %s does not exist."), anchor.c_str());
 339         return FALSE;
 340     }
 341     else
 342     {
 343         int y;
 344
 345         for (y = 0; c != NULL; c = c->GetParent()) y += c->GetPosY();
 346         Scroll(-1, y / wxHTML_SCROLL_STEP);
 347         m_OpenedAnchor = anchor;
 348         return TRUE;
 349     }
 350 }
 351
 352
 353 void wxHtmlWindow::OnSetTitle(const wxString& title)
 354 {
 355     if (m_RelatedFrame)
 356     {
 357         wxString tit;
 358         tit.Printf(m_TitleFormat, title.c_str());
 359         m_RelatedFrame->SetTitle(tit);
 360     }
 361     m_OpenedPageTitle = title;
 362 }
 363
 364
 365
 366
 367
 368 void wxHtmlWindow::CreateLayout()
 369 {
 370     int ClientWidth, ClientHeight;
 371
 372     if (!m_Cell) return;
 373
 374     if (m_Style & wxHW_SCROLLBAR_NEVER)
 375     {
 376         SetScrollbars(wxHTML_SCROLL_STEP, 1, m_Cell->GetWidth() / wxHTML_SCROLL_STEP, 0); // always off
 377         GetClientSize(&ClientWidth, &ClientHeight);
 378         m_Cell->Layout(ClientWidth);
 379     }
 380
 381     else {
 382         GetClientSize(&ClientWidth, &ClientHeight);
 383         m_Cell->Layout(ClientWidth);
 384         if (ClientHeight < m_Cell->GetHeight() + GetCharHeight())
 385         {
 386             SetScrollbars(
 387                   wxHTML_SCROLL_STEP, wxHTML_SCROLL_STEP,
 388                   m_Cell->GetWidth() / wxHTML_SCROLL_STEP,
 389                   (m_Cell->GetHeight() + GetCharHeight()) / wxHTML_SCROLL_STEP
 390                   /*cheat: top-level frag is always container*/);
 391         }
 392         else /* we fit into window, no need for scrollbars */
 393         {
 394             SetScrollbars(wxHTML_SCROLL_STEP, 1, m_Cell->GetWidth() / wxHTML_SCROLL_STEP, 0); // disable...
 395             GetClientSize(&ClientWidth, &ClientHeight);
 396             m_Cell->Layout(ClientWidth); // ...and relayout
 397         }
 398     }
 399 }
 400
 401
 402
 403 void wxHtmlWindow::ReadCustomization(wxConfigBase *cfg, wxString path)
 404 {
 405     wxString oldpath;
 406     wxString tmp;
 407     int p_fontsizes[7];
 408     wxString p_fff, p_ffn;
 409
 410     if (path != wxEmptyString)
 411     {
 412         oldpath = cfg->GetPath();
 413         cfg->SetPath(path);
 414     }
 415
 416     m_Borders = cfg->Read(wxT("wxHtmlWindow/Borders"), m_Borders);
 417     p_fff = cfg->Read(wxT("wxHtmlWindow/FontFaceFixed"), m_Parser->m_FontFaceFixed);
 418     p_ffn = cfg->Read(wxT("wxHtmlWindow/FontFaceNormal"), m_Parser->m_FontFaceNormal);
 419     for (int i = 0; i < 7; i++)
 420     {
 421         tmp.Printf(wxT("wxHtmlWindow/FontsSize%i"), i);
 422         p_fontsizes[i] = cfg->Read(tmp, m_Parser->m_FontsSizes[i]);
 423     }
 424     SetFonts(p_ffn, p_fff, p_fontsizes);
 425
 426     if (path != wxEmptyString)
 427         cfg->SetPath(oldpath);
 428 }
 429
 430
 431
 432 void wxHtmlWindow::WriteCustomization(wxConfigBase *cfg, wxString path)
 433 {
 434     wxString oldpath;
 435     wxString tmp;
 436
 437     if (path != wxEmptyString)
 438     {
 439         oldpath = cfg->GetPath();
 440         cfg->SetPath(path);
 441     }
 442
 443     cfg->Write(wxT("wxHtmlWindow/Borders"), (long) m_Borders);
 444     cfg->Write(wxT("wxHtmlWindow/FontFaceFixed"), m_Parser->m_FontFaceFixed);
 445     cfg->Write(wxT("wxHtmlWindow/FontFaceNormal"), m_Parser->m_FontFaceNormal);
 446     for (int i = 0; i < 7; i++)
 447     {
 448         tmp.Printf(wxT("wxHtmlWindow/FontsSize%i"), i);
 449         cfg->Write(tmp, (long) m_Parser->m_FontsSizes[i]);
 450     }
 451
 452     if (path != wxEmptyString)
 453         cfg->SetPath(oldpath);
 454 }
 455
 456
 457
 458 bool wxHtmlWindow::HistoryBack()
 459 {
 460     wxString a, l;
 461
 462     if (m_HistoryPos < 1) return FALSE;
 463
 464     // store scroll position into history item:
 465     int x, y;
 466     GetViewStart(&x, &y);
 467     (*m_History)[m_HistoryPos].SetPos(y);
 468
 469     // go to previous position:
 470     m_HistoryPos--;
 471
 472     l = (*m_History)[m_HistoryPos].GetPage();
 473     a = (*m_History)[m_HistoryPos].GetAnchor();
 474     m_HistoryOn = FALSE;
 475     m_tmpCanDrawLocks++;
 476     if (a == wxEmptyString) LoadPage(l);
 477     else LoadPage(l + wxT("#") + a);
 478     m_HistoryOn = TRUE;
 479     wxYield();
 480     m_tmpCanDrawLocks--;
 481     Scroll(0, (*m_History)[m_HistoryPos].GetPos());
 482     Refresh();
 483     return TRUE;
 484 }
 485
 486 bool wxHtmlWindow::HistoryCanBack()
 487 {
 488     if (m_HistoryPos < 1) return FALSE;
 489     return TRUE ;
 490 }
 491
 492
 493 bool wxHtmlWindow::HistoryForward()
 494 {
 495     wxString a, l;
 496
 497     if (m_HistoryPos == -1) return FALSE;
 498     if (m_HistoryPos >= (int)m_History->GetCount() - 1)return FALSE;
 499
 500     m_OpenedPage = wxEmptyString; // this will disable adding new entry into history in LoadPage()
 501
 502     m_HistoryPos++;
 503     l = (*m_History)[m_HistoryPos].GetPage();
 504     a = (*m_History)[m_HistoryPos].GetAnchor();
 505     m_HistoryOn = FALSE;
 506     m_tmpCanDrawLocks++;
 507     if (a == wxEmptyString) LoadPage(l);
 508     else LoadPage(l + wxT("#") + a);
 509     m_HistoryOn = TRUE;
 510     wxYield();
 511     m_tmpCanDrawLocks--;
 512     Scroll(0, (*m_History)[m_HistoryPos].GetPos());
 513     Refresh();
 514     return TRUE;
 515 }
 516
 517 bool wxHtmlWindow::HistoryCanForward()
 518 {
 519     if (m_HistoryPos == -1) return FALSE;
 520     if (m_HistoryPos >= (int)m_History->GetCount() - 1)return FALSE;
 521     return TRUE ;
 522 }
 523
 524
 525 void wxHtmlWindow::HistoryClear()
 526 {
 527     m_History->Empty();
 528     m_HistoryPos = -1;
 529 }
 530
 531 void wxHtmlWindow::AddProcessor(wxHtmlProcessor *processor)
 532 {
 533     if (!m_Processors)
 534     {
 535         m_Processors = new wxHtmlProcessorList;
 536         m_Processors->DeleteContents(TRUE);
 537     }
 538     wxHtmlProcessorList::Node *node;
 539
 540     for (node = m_Processors->GetFirst(); node; node = node->GetNext())
 541     {
 542         if (processor->GetPriority() > node->GetData()->GetPriority())
 543         {
 544             m_Processors->Insert(node, processor);
 545             return;
 546         }
 547     }
 548     m_Processors->Append(processor);
 549 }
 550
 551 /*static */ void wxHtmlWindow::AddGlobalProcessor(wxHtmlProcessor *processor)
 552 {
 553     if (!m_GlobalProcessors)
 554     {
 555         m_GlobalProcessors = new wxHtmlProcessorList;
 556         m_GlobalProcessors->DeleteContents(TRUE);
 557     }
 558     wxHtmlProcessorList::Node *node;
 559
 560     for (node = m_GlobalProcessors->GetFirst(); node; node = node->GetNext())
 561     {
 562         if (processor->GetPriority() > node->GetData()->GetPriority())
 563         {
 564             m_GlobalProcessors->Insert(node, processor);
 565             return;
 566         }
 567     }
 568     m_GlobalProcessors->Append(processor);
 569 }
 570
 571
 572
 573 wxList wxHtmlWindow::m_Filters;
 574 wxHtmlFilter *wxHtmlWindow::m_DefaultFilter = NULL;
 575 wxCursor *wxHtmlWindow::s_cur_hand = NULL;
 576 wxCursor *wxHtmlWindow::s_cur_arrow = NULL;
 577 wxHtmlProcessorList *wxHtmlWindow::m_GlobalProcessors = NULL;
 578
 579 void wxHtmlWindow::CleanUpStatics()
 580 {
 581     delete m_DefaultFilter;
 582     m_DefaultFilter = NULL;
 583     m_Filters.DeleteContents(TRUE);
 584     m_Filters.Clear();
 585     delete m_GlobalProcessors;
 586     m_GlobalProcessors = NULL;
 587     delete s_cur_hand;
 588     delete s_cur_arrow;
 589 }
 590
 591
 592
 593 void wxHtmlWindow::AddFilter(wxHtmlFilter *filter)
 594 {
 595     m_Filters.Append(filter);
 596 }
 597
 598
 599
 600
 601 void wxHtmlWindow::OnLinkClicked(const wxHtmlLinkInfo& link)
 602 {
 603     LoadPage(link.GetHref());
 604 }
 605
 606
 607
 608 void wxHtmlWindow::OnDraw(wxDC& dc)
 609 {
 610     int x, y;
 611     wxRegionIterator upd(GetUpdateRegion()); // get the update rect list
 612     int v_y, v_h;
 613
 614     if (m_tmpCanDrawLocks > 0) return;
 615
 616     dc.SetMapMode(wxMM_TEXT);
 617 #if 0
 618 /* VS - I don't think this is neccessary any longer
 619         MSC_VER 1200 means MSVC 6.0 and it works fine */
 620 #if defined(_MSC_VER) && (_MSC_VER == 1200)
 621     ::SetMapMode((HDC)dc.GetHDC(), MM_TEXT);
 622 #endif
 623 #endif
 624     dc.SetBackgroundMode(wxTRANSPARENT);
 625     GetViewStart(&x, &y);
 626
 627     while (upd)
 628     {
 629         v_y = upd.GetY();
 630         v_h = upd.GetH();
 631         if (m_Cell) m_Cell->Draw(dc, 0, 0, y * wxHTML_SCROLL_STEP + v_y, y * wxHTML_SCROLL_STEP + v_h + v_y);
 632         upd++;
 633     }
 634 }
 635
 636
 637
 638
 639 void wxHtmlWindow::OnSize(wxSizeEvent& event)
 640 {
 641     wxScrolledWindow::OnSize(event);
 642     CreateLayout();
 643     Refresh();
 644 }
 645
 646
 647 void wxHtmlWindow::OnMouseEvent(wxMouseEvent& event)
 648 {
 649     m_tmpMouseMoved = TRUE;
 650
 651     if (event.ButtonDown())
 652     {
 653         int sx, sy;
 654         wxPoint pos;
 655         wxString lnk;
 656
 657         GetViewStart(&sx, &sy); sx *= wxHTML_SCROLL_STEP; sy *= wxHTML_SCROLL_STEP;
 658         pos = event.GetPosition();
 659
 660         if (m_Cell)
 661             m_Cell->OnMouseClick(this, sx + pos.x, sy + pos.y, event);
 662     }
 663 }
 664
 665
 666
 667 void wxHtmlWindow::OnIdle(wxIdleEvent& WXUNUSED(event))
 668 {
 669     if (s_cur_hand == NULL)
 670     {
 671         s_cur_hand = new wxCursor(wxCURSOR_HAND);
 672         s_cur_arrow = new wxCursor(wxCURSOR_ARROW);
 673     }
 674
 675     if (m_tmpMouseMoved && (m_Cell != NULL))
 676     {
 677         int sx, sy;
 678         int x, y;
 679         wxHtmlLinkInfo *lnk;
 680
 681         GetViewStart(&sx, &sy); sx *= wxHTML_SCROLL_STEP; sy *= wxHTML_SCROLL_STEP;
 682         wxGetMousePosition(&x, &y);
 683         ScreenToClient(&x, &y);
 684         lnk = m_Cell->GetLink(sx + x, sy + y);
 685
 686         if (lnk != m_tmpLastLink)
 687         {
 688             if (lnk == NULL)
 689             {
 690                 SetCursor(*s_cur_arrow);
 691                 if (m_RelatedStatusBar != -1) m_RelatedFrame->SetStatusText(wxEmptyString, m_RelatedStatusBar);
 692             }
 693             else
 694             {
 695                 SetCursor(*s_cur_hand);
 696                 if (m_RelatedStatusBar != -1)
 697                     m_RelatedFrame->SetStatusText(lnk->GetHref(), m_RelatedStatusBar);
 698             }
 699             m_tmpLastLink = lnk;
 700         }
 701         m_tmpMouseMoved = FALSE;
 702     }
 703 }
 704
 705
 706 IMPLEMENT_ABSTRACT_CLASS(wxHtmlProcessor,wxObject)
 707
 708 IMPLEMENT_DYNAMIC_CLASS(wxHtmlWindow,wxScrolledWindow)
 709
 710 BEGIN_EVENT_TABLE(wxHtmlWindow, wxScrolledWindow)
 711     EVT_SIZE(wxHtmlWindow::OnSize)
 712     EVT_LEFT_DOWN(wxHtmlWindow::OnMouseEvent)
 713     EVT_MOTION(wxHtmlWindow::OnMouseEvent)
 714     EVT_IDLE(wxHtmlWindow::OnIdle)
 715 END_EVENT_TABLE()
 716
 717
 718
 719
 720
 721 // A module to allow initialization/cleanup
 722 // without calling these functions from app.cpp or from
 723 // the user's application.
 724
 725 class wxHtmlWinModule: public wxModule
 726 {
 727 DECLARE_DYNAMIC_CLASS(wxHtmlWinModule)
 728 public:
 729     wxHtmlWinModule() : wxModule() {}
 730     bool OnInit() { return TRUE; }
 731     void OnExit() { wxHtmlWindow::CleanUpStatics(); }
 732 };
 733
 734 IMPLEMENT_DYNAMIC_CLASS(wxHtmlWinModule, wxModule)
 735
 736
 737
 738
 739 ///// default mod handlers are forced there:
 740
 741 FORCE_LINK(m_layout)
 742 FORCE_LINK(m_fonts)
 743 FORCE_LINK(m_image)
 744 FORCE_LINK(m_list)
 745 FORCE_LINK(m_dflist)
 746 FORCE_LINK(m_pre)
 747 FORCE_LINK(m_hline)
 748 FORCE_LINK(m_links)
 749 FORCE_LINK(m_tables)
 750 FORCE_LINK(m_meta)
 751
 752
 753 #endif