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/log.h"
  27     #include "wx/intl.h"
  28     #include "wx/dcclient.h"
  29     #include "wx/frame.h"
  30 #endif
  31
  32 #include "wx/html/htmlwin.h"
  33 #include "wx/html/htmlproc.h"
  34 #include "wx/list.h"
  35
  36 #include "wx/arrimpl.cpp"
  37 #include "wx/listimpl.cpp"
  38
  39 //-----------------------------------------------------------------------------
  40 // wxHtmlHistoryItem
  41 //-----------------------------------------------------------------------------
  42
  43 // item of history list
  44 class WXDLLEXPORT wxHtmlHistoryItem : public wxObject
  45 {
  46 public:
  47     wxHtmlHistoryItem(const wxString& p, const wxString& a) {m_Page = p, m_Anchor = a, m_Pos = 0;}
  48     int GetPos() const {return m_Pos;}
  49     void SetPos(int p) {m_Pos = p;}
  50     const wxString& GetPage() const {return m_Page;}
  51     const wxString& GetAnchor() const {return m_Anchor;}
  52
  53 private:
  54     wxString m_Page;
  55     wxString m_Anchor;
  56     int m_Pos;
  57 };
  58
  59
  60 //-----------------------------------------------------------------------------
  61 // our private arrays:
  62 //-----------------------------------------------------------------------------
  63
  64 WX_DECLARE_OBJARRAY(wxHtmlHistoryItem, wxHtmlHistoryArray);
  65 WX_DEFINE_OBJARRAY(wxHtmlHistoryArray);
  66
  67 WX_DECLARE_LIST(wxHtmlProcessor, wxHtmlProcessorList);
  68 WX_DEFINE_LIST(wxHtmlProcessorList);
  69
  70 //-----------------------------------------------------------------------------
  71 // wxHtmlWindow
  72 //-----------------------------------------------------------------------------
  73
  74
  75 wxHtmlWindow::wxHtmlWindow(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
  76                 long style, const wxString& name) : wxScrolledWindow(parent, id, pos, size, style | wxVSCROLL | wxHSCROLL, name)
  77 {
  78     m_tmpMouseMoved = FALSE;
  79     m_tmpLastLink = NULL;
  80     m_tmpLastCell = 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 bool wxHtmlWindow::AppendToPage(const wxString& source)
 201 {
 202     return SetPage(*(GetParser()->GetSource()) + source);
 203 }
 204
 205 bool wxHtmlWindow::LoadPage(const wxString& location)
 206 {
 207     wxFSFile *f;
 208     bool rt_val;
 209     bool needs_refresh = FALSE;
 210
 211     SetCursor(*wxHOURGLASS_CURSOR);
 212     wxYield(); Refresh(FALSE);
 213
 214     m_tmpCanDrawLocks++;
 215     if (m_HistoryOn && (m_HistoryPos != -1))
 216     {
 217         // store scroll position into history item:
 218         int x, y;
 219         GetViewStart(&x, &y);
 220         (*m_History)[m_HistoryPos].SetPos(y);
 221     }
 222
 223     if (location[0] == wxT('#'))
 224     {
 225         // local anchor:
 226         wxString anch = location.Mid(1) /*1 to end*/;
 227         m_tmpCanDrawLocks--;
 228         rt_val = ScrollToAnchor(anch);
 229         m_tmpCanDrawLocks++;
 230     }
 231     else if (location.Find(wxT('#')) != wxNOT_FOUND && location.BeforeFirst(wxT('#')) == m_OpenedPage)
 232     {
 233         wxString anch = location.AfterFirst(wxT('#'));
 234         m_tmpCanDrawLocks--;
 235         rt_val = ScrollToAnchor(anch);
 236         m_tmpCanDrawLocks++;
 237     }
 238     else if (location.Find(wxT('#')) != wxNOT_FOUND &&
 239              (m_FS->GetPath() + location.BeforeFirst(wxT('#'))) == m_OpenedPage)
 240     {
 241         wxString anch = location.AfterFirst(wxT('#'));
 242         m_tmpCanDrawLocks--;
 243         rt_val = ScrollToAnchor(anch);
 244         m_tmpCanDrawLocks++;
 245     }
 246
 247     else
 248     {
 249         needs_refresh = TRUE;
 250         // load&display it:
 251         if (m_RelatedStatusBar != -1)
 252         {
 253             m_RelatedFrame->SetStatusText(_("Connecting..."), m_RelatedStatusBar);
 254             Refresh(FALSE);
 255         }
 256
 257         f = m_FS->OpenFile(location);
 258
 259         if (f == NULL)
 260         {
 261             wxLogError(_("Unable to open requested HTML document: %s"), location.c_str());
 262             m_tmpCanDrawLocks--;
 263
 264             SetCursor(*wxSTANDARD_CURSOR);
 265             return FALSE;
 266         }
 267
 268         else
 269         {
 270             wxNode *node;
 271             wxString src = wxEmptyString;
 272
 273             if (m_RelatedStatusBar != -1)
 274             {
 275                 wxString msg = _("Loading : ") + location;
 276                 m_RelatedFrame->SetStatusText(msg, m_RelatedStatusBar);
 277                 Refresh(FALSE);
 278             }
 279
 280             node = m_Filters.GetFirst();
 281             while (node)
 282             {
 283                 wxHtmlFilter *h = (wxHtmlFilter*) node->GetData();
 284                 if (h->CanRead(*f))
 285                 {
 286                     src = h->ReadFile(*f);
 287                     break;
 288                 }
 289                 node = node->GetNext();
 290             }
 291             if (src == wxEmptyString)
 292             {
 293                 if (m_DefaultFilter == NULL) m_DefaultFilter = GetDefaultFilter();
 294                 src = m_DefaultFilter->ReadFile(*f);
 295             }
 296
 297             m_FS->ChangePathTo(f->GetLocation());
 298             rt_val = SetPage(src);
 299             m_OpenedPage = f->GetLocation();
 300             if (f->GetAnchor() != wxEmptyString)
 301             {
 302                 wxYield();
 303                 ScrollToAnchor(f->GetAnchor());
 304             }
 305
 306             delete f;
 307
 308             if (m_RelatedStatusBar != -1) m_RelatedFrame->SetStatusText(_("Done"), m_RelatedStatusBar);
 309         }
 310     }
 311
 312     if (m_HistoryOn) // add this page to history there:
 313     {
 314         int c = m_History->GetCount() - (m_HistoryPos + 1);
 315
 316         if (m_HistoryPos < 0 ||
 317             (*m_History)[m_HistoryPos].GetPage() != m_OpenedPage ||
 318             (*m_History)[m_HistoryPos].GetAnchor() != m_OpenedAnchor)
 319         {
 320             m_HistoryPos++;
 321             for (int i = 0; i < c; i++)
 322                 m_History->RemoveAt(m_HistoryPos);
 323             m_History->Add(new wxHtmlHistoryItem(m_OpenedPage, m_OpenedAnchor));
 324         }
 325     }
 326
 327     if (m_OpenedPageTitle == wxEmptyString)
 328         OnSetTitle(wxFileNameFromPath(m_OpenedPage));
 329     SetCursor(*wxSTANDARD_CURSOR);
 330
 331     if (needs_refresh)
 332     {
 333         wxYield();
 334         m_tmpCanDrawLocks--;
 335         Refresh();
 336     }
 337     else
 338         m_tmpCanDrawLocks--;
 339
 340     return rt_val;
 341 }
 342
 343
 344
 345 bool wxHtmlWindow::ScrollToAnchor(const wxString& anchor)
 346 {
 347     const wxHtmlCell *c = m_Cell->Find(wxHTML_COND_ISANCHOR, &anchor);
 348     if (!c)
 349     {
 350         wxLogWarning(_("HTML anchor %s does not exist."), anchor.c_str());
 351         return FALSE;
 352     }
 353     else
 354     {
 355         int y;
 356
 357         for (y = 0; c != NULL; c = c->GetParent()) y += c->GetPosY();
 358         Scroll(-1, y / wxHTML_SCROLL_STEP);
 359         m_OpenedAnchor = anchor;
 360         return TRUE;
 361     }
 362 }
 363
 364
 365 void wxHtmlWindow::OnSetTitle(const wxString& title)
 366 {
 367     if (m_RelatedFrame)
 368     {
 369         wxString tit;
 370         tit.Printf(m_TitleFormat, title.c_str());
 371         m_RelatedFrame->SetTitle(tit);
 372     }
 373     m_OpenedPageTitle = title;
 374 }
 375
 376
 377
 378
 379
 380 void wxHtmlWindow::CreateLayout()
 381 {
 382     int ClientWidth, ClientHeight;
 383
 384     if (!m_Cell) return;
 385
 386     if (m_Style & wxHW_SCROLLBAR_NEVER)
 387     {
 388         SetScrollbars(wxHTML_SCROLL_STEP, 1, m_Cell->GetWidth() / wxHTML_SCROLL_STEP, 0); // always off
 389         GetClientSize(&ClientWidth, &ClientHeight);
 390         m_Cell->Layout(ClientWidth);
 391     }
 392
 393     else {
 394         GetClientSize(&ClientWidth, &ClientHeight);
 395         m_Cell->Layout(ClientWidth);
 396         if (ClientHeight < m_Cell->GetHeight() + GetCharHeight())
 397         {
 398             SetScrollbars(
 399                   wxHTML_SCROLL_STEP, wxHTML_SCROLL_STEP,
 400                   m_Cell->GetWidth() / wxHTML_SCROLL_STEP,
 401                   (m_Cell->GetHeight() + GetCharHeight()) / wxHTML_SCROLL_STEP
 402                   /*cheat: top-level frag is always container*/);
 403         }
 404         else /* we fit into window, no need for scrollbars */
 405         {
 406             SetScrollbars(wxHTML_SCROLL_STEP, 1, m_Cell->GetWidth() / wxHTML_SCROLL_STEP, 0); // disable...
 407             GetClientSize(&ClientWidth, &ClientHeight);
 408             m_Cell->Layout(ClientWidth); // ...and relayout
 409         }
 410     }
 411 }
 412
 413
 414
 415 void wxHtmlWindow::ReadCustomization(wxConfigBase *cfg, wxString path)
 416 {
 417     wxString oldpath;
 418     wxString tmp;
 419     int p_fontsizes[7];
 420     wxString p_fff, p_ffn;
 421
 422     if (path != wxEmptyString)
 423     {
 424         oldpath = cfg->GetPath();
 425         cfg->SetPath(path);
 426     }
 427
 428     m_Borders = cfg->Read(wxT("wxHtmlWindow/Borders"), m_Borders);
 429     p_fff = cfg->Read(wxT("wxHtmlWindow/FontFaceFixed"), m_Parser->m_FontFaceFixed);
 430     p_ffn = cfg->Read(wxT("wxHtmlWindow/FontFaceNormal"), m_Parser->m_FontFaceNormal);
 431     for (int i = 0; i < 7; i++)
 432     {
 433         tmp.Printf(wxT("wxHtmlWindow/FontsSize%i"), i);
 434         p_fontsizes[i] = cfg->Read(tmp, m_Parser->m_FontsSizes[i]);
 435     }
 436     SetFonts(p_ffn, p_fff, p_fontsizes);
 437
 438     if (path != wxEmptyString)
 439         cfg->SetPath(oldpath);
 440 }
 441
 442
 443
 444 void wxHtmlWindow::WriteCustomization(wxConfigBase *cfg, wxString path)
 445 {
 446     wxString oldpath;
 447     wxString tmp;
 448
 449     if (path != wxEmptyString)
 450     {
 451         oldpath = cfg->GetPath();
 452         cfg->SetPath(path);
 453     }
 454
 455     cfg->Write(wxT("wxHtmlWindow/Borders"), (long) m_Borders);
 456     cfg->Write(wxT("wxHtmlWindow/FontFaceFixed"), m_Parser->m_FontFaceFixed);
 457     cfg->Write(wxT("wxHtmlWindow/FontFaceNormal"), m_Parser->m_FontFaceNormal);
 458     for (int i = 0; i < 7; i++)
 459     {
 460         tmp.Printf(wxT("wxHtmlWindow/FontsSize%i"), i);
 461         cfg->Write(tmp, (long) m_Parser->m_FontsSizes[i]);
 462     }
 463
 464     if (path != wxEmptyString)
 465         cfg->SetPath(oldpath);
 466 }
 467
 468
 469
 470 bool wxHtmlWindow::HistoryBack()
 471 {
 472     wxString a, l;
 473
 474     if (m_HistoryPos < 1) return FALSE;
 475
 476     // store scroll position into history item:
 477     int x, y;
 478     GetViewStart(&x, &y);
 479     (*m_History)[m_HistoryPos].SetPos(y);
 480
 481     // go to previous position:
 482     m_HistoryPos--;
 483
 484     l = (*m_History)[m_HistoryPos].GetPage();
 485     a = (*m_History)[m_HistoryPos].GetAnchor();
 486     m_HistoryOn = FALSE;
 487     m_tmpCanDrawLocks++;
 488     if (a == wxEmptyString) LoadPage(l);
 489     else LoadPage(l + wxT("#") + a);
 490     m_HistoryOn = TRUE;
 491     wxYield();
 492     m_tmpCanDrawLocks--;
 493     Scroll(0, (*m_History)[m_HistoryPos].GetPos());
 494     Refresh();
 495     return TRUE;
 496 }
 497
 498 bool wxHtmlWindow::HistoryCanBack()
 499 {
 500     if (m_HistoryPos < 1) return FALSE;
 501     return TRUE ;
 502 }
 503
 504
 505 bool wxHtmlWindow::HistoryForward()
 506 {
 507     wxString a, l;
 508
 509     if (m_HistoryPos == -1) return FALSE;
 510     if (m_HistoryPos >= (int)m_History->GetCount() - 1)return FALSE;
 511
 512     m_OpenedPage = wxEmptyString; // this will disable adding new entry into history in LoadPage()
 513
 514     m_HistoryPos++;
 515     l = (*m_History)[m_HistoryPos].GetPage();
 516     a = (*m_History)[m_HistoryPos].GetAnchor();
 517     m_HistoryOn = FALSE;
 518     m_tmpCanDrawLocks++;
 519     if (a == wxEmptyString) LoadPage(l);
 520     else LoadPage(l + wxT("#") + a);
 521     m_HistoryOn = TRUE;
 522     wxYield();
 523     m_tmpCanDrawLocks--;
 524     Scroll(0, (*m_History)[m_HistoryPos].GetPos());
 525     Refresh();
 526     return TRUE;
 527 }
 528
 529 bool wxHtmlWindow::HistoryCanForward()
 530 {
 531     if (m_HistoryPos == -1) return FALSE;
 532     if (m_HistoryPos >= (int)m_History->GetCount() - 1)return FALSE;
 533     return TRUE ;
 534 }
 535
 536
 537 void wxHtmlWindow::HistoryClear()
 538 {
 539     m_History->Empty();
 540     m_HistoryPos = -1;
 541 }
 542
 543 void wxHtmlWindow::AddProcessor(wxHtmlProcessor *processor)
 544 {
 545     if (!m_Processors)
 546     {
 547         m_Processors = new wxHtmlProcessorList;
 548         m_Processors->DeleteContents(TRUE);
 549     }
 550     wxHtmlProcessorList::Node *node;
 551
 552     for (node = m_Processors->GetFirst(); node; node = node->GetNext())
 553     {
 554         if (processor->GetPriority() > node->GetData()->GetPriority())
 555         {
 556             m_Processors->Insert(node, processor);
 557             return;
 558         }
 559     }
 560     m_Processors->Append(processor);
 561 }
 562
 563 /*static */ void wxHtmlWindow::AddGlobalProcessor(wxHtmlProcessor *processor)
 564 {
 565     if (!m_GlobalProcessors)
 566     {
 567         m_GlobalProcessors = new wxHtmlProcessorList;
 568         m_GlobalProcessors->DeleteContents(TRUE);
 569     }
 570     wxHtmlProcessorList::Node *node;
 571
 572     for (node = m_GlobalProcessors->GetFirst(); node; node = node->GetNext())
 573     {
 574         if (processor->GetPriority() > node->GetData()->GetPriority())
 575         {
 576             m_GlobalProcessors->Insert(node, processor);
 577             return;
 578         }
 579     }
 580     m_GlobalProcessors->Append(processor);
 581 }
 582
 583
 584
 585 wxList wxHtmlWindow::m_Filters;
 586 wxHtmlFilter *wxHtmlWindow::m_DefaultFilter = NULL;
 587 wxCursor *wxHtmlWindow::s_cur_hand = NULL;
 588 wxCursor *wxHtmlWindow::s_cur_arrow = NULL;
 589 wxHtmlProcessorList *wxHtmlWindow::m_GlobalProcessors = NULL;
 590
 591 void wxHtmlWindow::CleanUpStatics()
 592 {
 593     delete m_DefaultFilter;
 594     m_DefaultFilter = NULL;
 595     m_Filters.DeleteContents(TRUE);
 596     m_Filters.Clear();
 597     delete m_GlobalProcessors;
 598     m_GlobalProcessors = NULL;
 599     delete s_cur_hand;
 600     delete s_cur_arrow;
 601 }
 602
 603
 604
 605 void wxHtmlWindow::AddFilter(wxHtmlFilter *filter)
 606 {
 607     m_Filters.Append(filter);
 608 }
 609
 610
 611
 612
 613 void wxHtmlWindow::OnLinkClicked(const wxHtmlLinkInfo& link)
 614 {
 615     LoadPage(link.GetHref());
 616 }
 617
 618 void wxHtmlWindow::OnCellClicked(wxHtmlCell *cell,
 619                                  wxCoord x, wxCoord y,
 620                                  const wxMouseEvent& event)
 621 {
 622     wxCHECK_RET( cell, _T("can't be called with NULL cell") );
 623
 624     cell->OnMouseClick(this, x, y, event);
 625 }
 626
 627 void wxHtmlWindow::OnCellMouseHover(wxHtmlCell * WXUNUSED(cell),
 628                                     wxCoord WXUNUSED(x), wxCoord WXUNUSED(y))
 629 {
 630     // do nothing here
 631 }
 632
 633 void wxHtmlWindow::OnDraw(wxDC& dc)
 634 {
 635     int x, y;
 636     wxRegionIterator upd(GetUpdateRegion()); // get the update rect list
 637     int v_y, v_h;
 638
 639     if (m_tmpCanDrawLocks > 0) return;
 640
 641     dc.SetMapMode(wxMM_TEXT);
 642     dc.SetBackgroundMode(wxTRANSPARENT);
 643     GetViewStart(&x, &y);
 644
 645     while (upd)
 646     {
 647         v_y = upd.GetY();
 648         v_h = upd.GetH();
 649         if (m_Cell) m_Cell->Draw(dc, 0, 0, y * wxHTML_SCROLL_STEP + v_y, y * wxHTML_SCROLL_STEP + v_h + v_y);
 650         upd++;
 651     }
 652 }
 653
 654
 655
 656
 657 void wxHtmlWindow::OnSize(wxSizeEvent& event)
 658 {
 659     wxScrolledWindow::OnSize(event);
 660     CreateLayout();
 661     Refresh();
 662 }
 663
 664
 665 void wxHtmlWindow::OnMouseEvent(wxMouseEvent& event)
 666 {
 667     m_tmpMouseMoved = TRUE;
 668
 669     if (event.ButtonDown())
 670     {
 671         if ( m_Cell )
 672         {
 673             int sx, sy;
 674             GetViewStart(&sx, &sy);
 675             sx *= wxHTML_SCROLL_STEP;
 676             sy *= wxHTML_SCROLL_STEP;
 677
 678             wxPoint pos = event.GetPosition();
 679             pos.x += sx;
 680             pos.y += sy;
 681
 682             wxHtmlCell *cell = m_Cell->FindCellByPos(pos.x, pos.y);
 683
 684             // VZ: is it possible that we don't find anything at all?
 685             // VS: yes. FindCellByPos returns terminal cell and
 686             //     containers may have empty borders
 687             if ( cell )
 688                 OnCellClicked(cell, pos.x, pos.y, event);
 689         }
 690     }
 691 }
 692
 693
 694
 695 void wxHtmlWindow::OnIdle(wxIdleEvent& WXUNUSED(event))
 696 {
 697     if (s_cur_hand == NULL)
 698     {
 699         s_cur_hand = new wxCursor(wxCURSOR_HAND);
 700         s_cur_arrow = new wxCursor(wxCURSOR_ARROW);
 701     }
 702
 703     if (m_tmpMouseMoved && (m_Cell != NULL))
 704     {
 705         int sx, sy;
 706         GetViewStart(&sx, &sy);
 707         sx *= wxHTML_SCROLL_STEP;
 708         sy *= wxHTML_SCROLL_STEP;
 709
 710         int x, y;
 711         wxGetMousePosition(&x, &y);
 712         ScreenToClient(&x, &y);
 713         x += sx;
 714         y += sy;
 715
 716         wxHtmlCell *cell = m_Cell->FindCellByPos(x, y);
 717         if ( cell != m_tmpLastCell )
 718         {
 719             wxHtmlLinkInfo *lnk = cell ? cell->GetLink(x, y) : NULL;
 720
 721             if (lnk != m_tmpLastLink)
 722             {
 723                 if (lnk == NULL)
 724                 {
 725                     SetCursor(*s_cur_arrow);
 726                     if (m_RelatedStatusBar != -1)
 727                         m_RelatedFrame->SetStatusText(wxEmptyString, m_RelatedStatusBar);
 728                 }
 729                 else
 730                 {
 731                     SetCursor(*s_cur_hand);
 732                     if (m_RelatedStatusBar != -1)
 733                         m_RelatedFrame->SetStatusText(lnk->GetHref(), m_RelatedStatusBar);
 734                 }
 735                 m_tmpLastLink = lnk;
 736             }
 737
 738             m_tmpLastCell = cell;
 739         }
 740         else // mouse moved but stayed in the same cell
 741         {
 742             if ( cell )
 743                 OnCellMouseHover(cell, x, y);
 744         }
 745
 746         m_tmpMouseMoved = FALSE;
 747     }
 748 }
 749
 750
 751 IMPLEMENT_ABSTRACT_CLASS(wxHtmlProcessor,wxObject)
 752
 753 IMPLEMENT_DYNAMIC_CLASS(wxHtmlWindow,wxScrolledWindow)
 754
 755 BEGIN_EVENT_TABLE(wxHtmlWindow, wxScrolledWindow)
 756     EVT_SIZE(wxHtmlWindow::OnSize)
 757     EVT_LEFT_DOWN(wxHtmlWindow::OnMouseEvent)
 758     EVT_RIGHT_DOWN(wxHtmlWindow::OnMouseEvent)
 759     EVT_MOTION(wxHtmlWindow::OnMouseEvent)
 760     EVT_IDLE(wxHtmlWindow::OnIdle)
 761 END_EVENT_TABLE()
 762
 763
 764
 765
 766
 767 // A module to allow initialization/cleanup
 768 // without calling these functions from app.cpp or from
 769 // the user's application.
 770
 771 class wxHtmlWinModule: public wxModule
 772 {
 773 DECLARE_DYNAMIC_CLASS(wxHtmlWinModule)
 774 public:
 775     wxHtmlWinModule() : wxModule() {}
 776     bool OnInit() { return TRUE; }
 777     void OnExit() { wxHtmlWindow::CleanUpStatics(); }
 778 };
 779
 780 IMPLEMENT_DYNAMIC_CLASS(wxHtmlWinModule, wxModule)
 781
 782
 783 // This hack forces the linker to always link in m_* files
 784 // (wxHTML doesn't work without handlers from these files)
 785 #include "wx/html/forcelnk.h"
 786 FORCE_WXHTML_MODULES()
 787
 788 #endif