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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  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 __BORLANDC__
  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 #include "wx/clipbrd.h"
  36 #include "wx/dataobj.h"
  37 #include "wx/timer.h"
  38 #include "wx/dcmemory.h"
  39
  40 #include "wx/arrimpl.cpp"
  41 #include "wx/listimpl.cpp"
  42
  43
  44
  45 #if wxUSE_CLIPBOARD
  46 // ----------------------------------------------------------------------------
  47 // wxHtmlWinAutoScrollTimer: the timer used to generate a stream of scroll
  48 // events when a captured mouse is held outside the window
  49 // ----------------------------------------------------------------------------
  50
  51 class wxHtmlWinAutoScrollTimer : public wxTimer
  52 {
  53 public:
  54     wxHtmlWinAutoScrollTimer(wxScrolledWindow *win,
  55                       wxEventType eventTypeToSend,
  56                       int pos, int orient)
  57     {
  58         m_win = win;
  59         m_eventType = eventTypeToSend;
  60         m_pos = pos;
  61         m_orient = orient;
  62     }
  63
  64     virtual void Notify();
  65
  66 private:
  67     wxScrolledWindow *m_win;
  68     wxEventType m_eventType;
  69     int m_pos,
  70         m_orient;
  71
  72     DECLARE_NO_COPY_CLASS(wxHtmlWinAutoScrollTimer)
  73 };
  74
  75 void wxHtmlWinAutoScrollTimer::Notify()
  76 {
  77     // only do all this as long as the window is capturing the mouse
  78     if ( wxWindow::GetCapture() != m_win )
  79     {
  80         Stop();
  81     }
  82     else // we still capture the mouse, continue generating events
  83     {
  84         // first scroll the window if we are allowed to do it
  85         wxScrollWinEvent event1(m_eventType, m_pos, m_orient);
  86         event1.SetEventObject(m_win);
  87         if ( m_win->GetEventHandler()->ProcessEvent(event1) )
  88         {
  89             // and then send a pseudo mouse-move event to refresh the selection
  90             wxMouseEvent event2(wxEVT_MOTION);
  91             wxGetMousePosition(&event2.m_x, &event2.m_y);
  92
  93             // the mouse event coordinates should be client, not screen as
  94             // returned by wxGetMousePosition
  95             wxWindow *parentTop = m_win;
  96             while ( parentTop->GetParent() )
  97                 parentTop = parentTop->GetParent();
  98             wxPoint ptOrig = parentTop->GetPosition();
  99             event2.m_x -= ptOrig.x;
 100             event2.m_y -= ptOrig.y;
 101
 102             event2.SetEventObject(m_win);
 103
 104             // FIXME: we don't fill in the other members - ok?
 105             m_win->GetEventHandler()->ProcessEvent(event2);
 106         }
 107         else // can't scroll further, stop
 108         {
 109             Stop();
 110         }
 111     }
 112 }
 113
 114 #endif // wxUSE_CLIPBOARD
 115
 116
 117
 118 //-----------------------------------------------------------------------------
 119 // wxHtmlHistoryItem
 120 //-----------------------------------------------------------------------------
 121
 122 // item of history list
 123 class WXDLLIMPEXP_HTML wxHtmlHistoryItem
 124 {
 125 public:
 126     wxHtmlHistoryItem(const wxString& p, const wxString& a) {m_Page = p, m_Anchor = a, m_Pos = 0;}
 127     int GetPos() const {return m_Pos;}
 128     void SetPos(int p) {m_Pos = p;}
 129     const wxString& GetPage() const {return m_Page;}
 130     const wxString& GetAnchor() const {return m_Anchor;}
 131
 132 private:
 133     wxString m_Page;
 134     wxString m_Anchor;
 135     int m_Pos;
 136 };
 137
 138
 139 //-----------------------------------------------------------------------------
 140 // our private arrays:
 141 //-----------------------------------------------------------------------------
 142
 143 WX_DECLARE_OBJARRAY(wxHtmlHistoryItem, wxHtmlHistoryArray);
 144 WX_DEFINE_OBJARRAY(wxHtmlHistoryArray);
 145
 146 WX_DECLARE_LIST(wxHtmlProcessor, wxHtmlProcessorList);
 147 WX_DEFINE_LIST(wxHtmlProcessorList);
 148
 149 //-----------------------------------------------------------------------------
 150 // wxHtmlWindow
 151 //-----------------------------------------------------------------------------
 152
 153
 154 void wxHtmlWindow::Init()
 155 {
 156     m_tmpMouseMoved = FALSE;
 157     m_tmpLastLink = NULL;
 158     m_tmpLastCell = NULL;
 159     m_tmpCanDrawLocks = 0;
 160     m_FS = new wxFileSystem();
 161     m_RelatedStatusBar = -1;
 162     m_RelatedFrame = NULL;
 163     m_TitleFormat = wxT("%s");
 164     m_OpenedPage = m_OpenedAnchor = m_OpenedPageTitle = wxEmptyString;
 165     m_Cell = NULL;
 166     m_Parser = new wxHtmlWinParser(this);
 167     m_Parser->SetFS(m_FS);
 168     m_HistoryPos = -1;
 169     m_HistoryOn = TRUE;
 170     m_History = new wxHtmlHistoryArray;
 171     m_Processors = NULL;
 172     m_Style = 0;
 173     SetBorders(10);
 174     m_selection = NULL;
 175     m_makingSelection = false;
 176 #if wxUSE_CLIPBOARD
 177     m_timerAutoScroll = NULL;
 178     m_lastDoubleClick = 0;
 179 #endif // wxUSE_CLIPBOARD
 180     m_backBuffer = NULL;
 181 }
 182
 183 bool wxHtmlWindow::Create(wxWindow *parent, wxWindowID id,
 184                           const wxPoint& pos, const wxSize& size,
 185                           long style, const wxString& name)
 186 {
 187     if (!wxScrolledWindow::Create(parent, id, pos, size,
 188                                   style | wxVSCROLL | wxHSCROLL,
 189                                   name))
 190         return FALSE;
 191
 192     m_Style = style;
 193     SetPage(wxT("<html><body></body></html>"));
 194     return TRUE;
 195 }
 196
 197
 198 wxHtmlWindow::~wxHtmlWindow()
 199 {
 200 #if wxUSE_CLIPBOARD
 201     StopAutoScrolling();
 202 #endif // wxUSE_CLIPBOARD
 203     HistoryClear();
 204
 205     delete m_selection;
 206
 207     delete m_Cell;
 208
 209     if ( m_Processors )
 210     {
 211         WX_CLEAR_LIST(wxHtmlProcessorList, *m_Processors);
 212     }
 213
 214     delete m_Parser;
 215     delete m_FS;
 216     delete m_History;
 217     delete m_Processors;
 218     delete m_backBuffer;
 219 }
 220
 221
 222
 223 void wxHtmlWindow::SetRelatedFrame(wxFrame* frame, const wxString& format)
 224 {
 225     m_RelatedFrame = frame;
 226     m_TitleFormat = format;
 227 }
 228
 229
 230
 231 void wxHtmlWindow::SetRelatedStatusBar(int bar)
 232 {
 233     m_RelatedStatusBar = bar;
 234 }
 235
 236
 237
 238 void wxHtmlWindow::SetFonts(wxString normal_face, wxString fixed_face, const int *sizes)
 239 {
 240     wxString op = m_OpenedPage;
 241
 242     m_Parser->SetFonts(normal_face, fixed_face, sizes);
 243     // fonts changed => contents invalid, so reload the page:
 244     SetPage(wxT("<html><body></body></html>"));
 245     if (!op.IsEmpty()) LoadPage(op);
 246 }
 247
 248
 249
 250 bool wxHtmlWindow::SetPage(const wxString& source)
 251 {
 252     wxString newsrc(source);
 253
 254     wxDELETE(m_selection);
 255
 256     // pass HTML through registered processors:
 257     if (m_Processors || m_GlobalProcessors)
 258     {
 259         wxHtmlProcessorList::compatibility_iterator nodeL, nodeG;
 260         int prL, prG;
 261
 262         nodeL = (m_Processors) ? m_Processors->GetFirst() : wxHtmlProcessorList::compatibility_iterator();
 263         nodeG = (m_GlobalProcessors) ? m_GlobalProcessors->GetFirst() : wxHtmlProcessorList::compatibility_iterator();
 264
 265         // VS: there are two lists, global and local, both of them sorted by
 266         //     priority. Since we have to go through _both_ lists with
 267         //     decreasing priority, we "merge-sort" the lists on-line by
 268         //     processing that one of the two heads that has higher priority
 269         //     in every iteration
 270         while (nodeL || nodeG)
 271         {
 272             prL = (nodeL) ? nodeL->GetData()->GetPriority() : -1;
 273             prG = (nodeG) ? nodeG->GetData()->GetPriority() : -1;
 274             if (prL > prG)
 275             {
 276                 if (nodeL->GetData()->IsEnabled())
 277                     newsrc = nodeL->GetData()->Process(newsrc);
 278                 nodeL = nodeL->GetNext();
 279             }
 280             else // prL <= prG
 281             {
 282                 if (nodeG->GetData()->IsEnabled())
 283                     newsrc = nodeG->GetData()->Process(newsrc);
 284                 nodeG = nodeG->GetNext();
 285             }
 286         }
 287     }
 288
 289     // ...and run the parser on it:
 290     wxClientDC *dc = new wxClientDC(this);
 291     dc->SetMapMode(wxMM_TEXT);
 292     SetBackgroundColour(wxColour(0xFF, 0xFF, 0xFF));
 293     m_OpenedPage = m_OpenedAnchor = m_OpenedPageTitle = wxEmptyString;
 294     m_Parser->SetDC(dc);
 295     if (m_Cell)
 296     {
 297         delete m_Cell;
 298         m_Cell = NULL;
 299     }
 300     m_Cell = (wxHtmlContainerCell*) m_Parser->Parse(newsrc);
 301     delete dc;
 302     m_Cell->SetIndent(m_Borders, wxHTML_INDENT_ALL, wxHTML_UNITS_PIXELS);
 303     m_Cell->SetAlignHor(wxHTML_ALIGN_CENTER);
 304     CreateLayout();
 305     if (m_tmpCanDrawLocks == 0)
 306         Refresh();
 307     return TRUE;
 308 }
 309
 310 bool wxHtmlWindow::AppendToPage(const wxString& source)
 311 {
 312     return SetPage(*(GetParser()->GetSource()) + source);
 313 }
 314
 315 bool wxHtmlWindow::LoadPage(const wxString& location)
 316 {
 317     wxBusyCursor busyCursor;
 318
 319     wxFSFile *f;
 320     bool rt_val;
 321     bool needs_refresh = FALSE;
 322
 323     m_tmpCanDrawLocks++;
 324     if (m_HistoryOn && (m_HistoryPos != -1))
 325     {
 326         // store scroll position into history item:
 327         int x, y;
 328         GetViewStart(&x, &y);
 329         (*m_History)[m_HistoryPos].SetPos(y);
 330     }
 331
 332     if (location[0] == wxT('#'))
 333     {
 334         // local anchor:
 335         wxString anch = location.Mid(1) /*1 to end*/;
 336         m_tmpCanDrawLocks--;
 337         rt_val = ScrollToAnchor(anch);
 338         m_tmpCanDrawLocks++;
 339     }
 340     else if (location.Find(wxT('#')) != wxNOT_FOUND && location.BeforeFirst(wxT('#')) == m_OpenedPage)
 341     {
 342         wxString anch = location.AfterFirst(wxT('#'));
 343         m_tmpCanDrawLocks--;
 344         rt_val = ScrollToAnchor(anch);
 345         m_tmpCanDrawLocks++;
 346     }
 347     else if (location.Find(wxT('#')) != wxNOT_FOUND &&
 348              (m_FS->GetPath() + location.BeforeFirst(wxT('#'))) == m_OpenedPage)
 349     {
 350         wxString anch = location.AfterFirst(wxT('#'));
 351         m_tmpCanDrawLocks--;
 352         rt_val = ScrollToAnchor(anch);
 353         m_tmpCanDrawLocks++;
 354     }
 355
 356     else
 357     {
 358         needs_refresh = TRUE;
 359         // load&display it:
 360         if (m_RelatedStatusBar != -1)
 361         {
 362             m_RelatedFrame->SetStatusText(_("Connecting..."), m_RelatedStatusBar);
 363             Refresh(FALSE);
 364         }
 365
 366         f = m_Parser->OpenURL(wxHTML_URL_PAGE, location);
 367
 368         // try to interpret 'location' as filename instead of URL:
 369         if (f == NULL)
 370         {
 371             wxFileName fn(location);
 372             wxString location2 = wxFileSystem::FileNameToURL(fn);
 373             f = m_Parser->OpenURL(wxHTML_URL_PAGE, location2);
 374         }
 375
 376         if (f == NULL)
 377         {
 378             wxLogError(_("Unable to open requested HTML document: %s"), location.c_str());
 379             m_tmpCanDrawLocks--;
 380             return FALSE;
 381         }
 382
 383         else
 384         {
 385             wxList::compatibility_iterator node;
 386             wxString src = wxEmptyString;
 387
 388             if (m_RelatedStatusBar != -1)
 389             {
 390                 wxString msg = _("Loading : ") + location;
 391                 m_RelatedFrame->SetStatusText(msg, m_RelatedStatusBar);
 392                 Refresh(FALSE);
 393             }
 394
 395             node = m_Filters.GetFirst();
 396             while (node)
 397             {
 398                 wxHtmlFilter *h = (wxHtmlFilter*) node->GetData();
 399                 if (h->CanRead(*f))
 400                 {
 401                     src = h->ReadFile(*f);
 402                     break;
 403                 }
 404                 node = node->GetNext();
 405             }
 406             if (src == wxEmptyString)
 407             {
 408                 if (m_DefaultFilter == NULL) m_DefaultFilter = GetDefaultFilter();
 409                 src = m_DefaultFilter->ReadFile(*f);
 410             }
 411
 412             m_FS->ChangePathTo(f->GetLocation());
 413             rt_val = SetPage(src);
 414             m_OpenedPage = f->GetLocation();
 415             if (f->GetAnchor() != wxEmptyString)
 416             {
 417                 ScrollToAnchor(f->GetAnchor());
 418             }
 419
 420             delete f;
 421
 422             if (m_RelatedStatusBar != -1) m_RelatedFrame->SetStatusText(_("Done"), m_RelatedStatusBar);
 423         }
 424     }
 425
 426     if (m_HistoryOn) // add this page to history there:
 427     {
 428         int c = m_History->GetCount() - (m_HistoryPos + 1);
 429
 430         if (m_HistoryPos < 0 ||
 431             (*m_History)[m_HistoryPos].GetPage() != m_OpenedPage ||
 432             (*m_History)[m_HistoryPos].GetAnchor() != m_OpenedAnchor)
 433         {
 434             m_HistoryPos++;
 435             for (int i = 0; i < c; i++)
 436                 m_History->RemoveAt(m_HistoryPos);
 437             m_History->Add(new wxHtmlHistoryItem(m_OpenedPage, m_OpenedAnchor));
 438         }
 439     }
 440
 441     if (m_OpenedPageTitle == wxEmptyString)
 442         OnSetTitle(wxFileNameFromPath(m_OpenedPage));
 443
 444     if (needs_refresh)
 445     {
 446         m_tmpCanDrawLocks--;
 447         Refresh();
 448     }
 449     else
 450         m_tmpCanDrawLocks--;
 451
 452     return rt_val;
 453 }
 454
 455
 456 bool wxHtmlWindow::LoadFile(const wxFileName& filename)
 457 {
 458     wxString url = wxFileSystem::FileNameToURL(filename);
 459     return LoadPage(url);
 460 }
 461
 462
 463 bool wxHtmlWindow::ScrollToAnchor(const wxString& anchor)
 464 {
 465     const wxHtmlCell *c = m_Cell->Find(wxHTML_COND_ISANCHOR, &anchor);
 466     if (!c)
 467     {
 468         wxLogWarning(_("HTML anchor %s does not exist."), anchor.c_str());
 469         return FALSE;
 470     }
 471     else
 472     {
 473         int y;
 474
 475         for (y = 0; c != NULL; c = c->GetParent()) y += c->GetPosY();
 476         Scroll(-1, y / wxHTML_SCROLL_STEP);
 477         m_OpenedAnchor = anchor;
 478         return TRUE;
 479     }
 480 }
 481
 482
 483 void wxHtmlWindow::OnSetTitle(const wxString& title)
 484 {
 485     if (m_RelatedFrame)
 486     {
 487         wxString tit;
 488         tit.Printf(m_TitleFormat, title.c_str());
 489         m_RelatedFrame->SetTitle(tit);
 490     }
 491     m_OpenedPageTitle = title;
 492 }
 493
 494
 495
 496
 497
 498 void wxHtmlWindow::CreateLayout()
 499 {
 500     int ClientWidth, ClientHeight;
 501
 502     if (!m_Cell) return;
 503
 504     if (m_Style & wxHW_SCROLLBAR_NEVER)
 505     {
 506         SetScrollbars(wxHTML_SCROLL_STEP, 1, m_Cell->GetWidth() / wxHTML_SCROLL_STEP, 0); // always off
 507         GetClientSize(&ClientWidth, &ClientHeight);
 508         m_Cell->Layout(ClientWidth);
 509     }
 510
 511     else {
 512         GetClientSize(&ClientWidth, &ClientHeight);
 513         m_Cell->Layout(ClientWidth);
 514         if (ClientHeight < m_Cell->GetHeight() + GetCharHeight())
 515         {
 516             SetScrollbars(
 517                   wxHTML_SCROLL_STEP, wxHTML_SCROLL_STEP,
 518                   m_Cell->GetWidth() / wxHTML_SCROLL_STEP,
 519                   (m_Cell->GetHeight() + GetCharHeight()) / wxHTML_SCROLL_STEP
 520                   /*cheat: top-level frag is always container*/);
 521         }
 522         else /* we fit into window, no need for scrollbars */
 523         {
 524             SetScrollbars(wxHTML_SCROLL_STEP, 1, m_Cell->GetWidth() / wxHTML_SCROLL_STEP, 0); // disable...
 525             GetClientSize(&ClientWidth, &ClientHeight);
 526             m_Cell->Layout(ClientWidth); // ...and relayout
 527         }
 528     }
 529 }
 530
 531
 532
 533 void wxHtmlWindow::ReadCustomization(wxConfigBase *cfg, wxString path)
 534 {
 535     wxString oldpath;
 536     wxString tmp;
 537     int p_fontsizes[7];
 538     wxString p_fff, p_ffn;
 539
 540     if (path != wxEmptyString)
 541     {
 542         oldpath = cfg->GetPath();
 543         cfg->SetPath(path);
 544     }
 545
 546     m_Borders = cfg->Read(wxT("wxHtmlWindow/Borders"), m_Borders);
 547     p_fff = cfg->Read(wxT("wxHtmlWindow/FontFaceFixed"), m_Parser->m_FontFaceFixed);
 548     p_ffn = cfg->Read(wxT("wxHtmlWindow/FontFaceNormal"), m_Parser->m_FontFaceNormal);
 549     for (int i = 0; i < 7; i++)
 550     {
 551         tmp.Printf(wxT("wxHtmlWindow/FontsSize%i"), i);
 552         p_fontsizes[i] = cfg->Read(tmp, m_Parser->m_FontsSizes[i]);
 553     }
 554     SetFonts(p_ffn, p_fff, p_fontsizes);
 555
 556     if (path != wxEmptyString)
 557         cfg->SetPath(oldpath);
 558 }
 559
 560
 561
 562 void wxHtmlWindow::WriteCustomization(wxConfigBase *cfg, wxString path)
 563 {
 564     wxString oldpath;
 565     wxString tmp;
 566
 567     if (path != wxEmptyString)
 568     {
 569         oldpath = cfg->GetPath();
 570         cfg->SetPath(path);
 571     }
 572
 573     cfg->Write(wxT("wxHtmlWindow/Borders"), (long) m_Borders);
 574     cfg->Write(wxT("wxHtmlWindow/FontFaceFixed"), m_Parser->m_FontFaceFixed);
 575     cfg->Write(wxT("wxHtmlWindow/FontFaceNormal"), m_Parser->m_FontFaceNormal);
 576     for (int i = 0; i < 7; i++)
 577     {
 578         tmp.Printf(wxT("wxHtmlWindow/FontsSize%i"), i);
 579         cfg->Write(tmp, (long) m_Parser->m_FontsSizes[i]);
 580     }
 581
 582     if (path != wxEmptyString)
 583         cfg->SetPath(oldpath);
 584 }
 585
 586
 587
 588 bool wxHtmlWindow::HistoryBack()
 589 {
 590     wxString a, l;
 591
 592     if (m_HistoryPos < 1) return FALSE;
 593
 594     // store scroll position into history item:
 595     int x, y;
 596     GetViewStart(&x, &y);
 597     (*m_History)[m_HistoryPos].SetPos(y);
 598
 599     // go to previous position:
 600     m_HistoryPos--;
 601
 602     l = (*m_History)[m_HistoryPos].GetPage();
 603     a = (*m_History)[m_HistoryPos].GetAnchor();
 604     m_HistoryOn = FALSE;
 605     m_tmpCanDrawLocks++;
 606     if (a == wxEmptyString) LoadPage(l);
 607     else LoadPage(l + wxT("#") + a);
 608     m_HistoryOn = TRUE;
 609     m_tmpCanDrawLocks--;
 610     Scroll(0, (*m_History)[m_HistoryPos].GetPos());
 611     Refresh();
 612     return TRUE;
 613 }
 614
 615 bool wxHtmlWindow::HistoryCanBack()
 616 {
 617     if (m_HistoryPos < 1) return FALSE;
 618     return TRUE ;
 619 }
 620
 621
 622 bool wxHtmlWindow::HistoryForward()
 623 {
 624     wxString a, l;
 625
 626     if (m_HistoryPos == -1) return FALSE;
 627     if (m_HistoryPos >= (int)m_History->GetCount() - 1)return FALSE;
 628
 629     m_OpenedPage = wxEmptyString; // this will disable adding new entry into history in LoadPage()
 630
 631     m_HistoryPos++;
 632     l = (*m_History)[m_HistoryPos].GetPage();
 633     a = (*m_History)[m_HistoryPos].GetAnchor();
 634     m_HistoryOn = FALSE;
 635     m_tmpCanDrawLocks++;
 636     if (a == wxEmptyString) LoadPage(l);
 637     else LoadPage(l + wxT("#") + a);
 638     m_HistoryOn = TRUE;
 639     m_tmpCanDrawLocks--;
 640     Scroll(0, (*m_History)[m_HistoryPos].GetPos());
 641     Refresh();
 642     return TRUE;
 643 }
 644
 645 bool wxHtmlWindow::HistoryCanForward()
 646 {
 647     if (m_HistoryPos == -1) return FALSE;
 648     if (m_HistoryPos >= (int)m_History->GetCount() - 1)return FALSE;
 649     return TRUE ;
 650 }
 651
 652
 653 void wxHtmlWindow::HistoryClear()
 654 {
 655     m_History->Empty();
 656     m_HistoryPos = -1;
 657 }
 658
 659 void wxHtmlWindow::AddProcessor(wxHtmlProcessor *processor)
 660 {
 661     if (!m_Processors)
 662     {
 663         m_Processors = new wxHtmlProcessorList;
 664     }
 665     wxHtmlProcessorList::compatibility_iterator node;
 666
 667     for (node = m_Processors->GetFirst(); node; node = node->GetNext())
 668     {
 669         if (processor->GetPriority() > node->GetData()->GetPriority())
 670         {
 671             m_Processors->Insert(node, processor);
 672             return;
 673         }
 674     }
 675     m_Processors->Append(processor);
 676 }
 677
 678 /*static */ void wxHtmlWindow::AddGlobalProcessor(wxHtmlProcessor *processor)
 679 {
 680     if (!m_GlobalProcessors)
 681     {
 682         m_GlobalProcessors = new wxHtmlProcessorList;
 683     }
 684     wxHtmlProcessorList::compatibility_iterator node;
 685
 686     for (node = m_GlobalProcessors->GetFirst(); node; node = node->GetNext())
 687     {
 688         if (processor->GetPriority() > node->GetData()->GetPriority())
 689         {
 690             m_GlobalProcessors->Insert(node, processor);
 691             return;
 692         }
 693     }
 694     m_GlobalProcessors->Append(processor);
 695 }
 696
 697
 698
 699 wxList wxHtmlWindow::m_Filters;
 700 wxHtmlFilter *wxHtmlWindow::m_DefaultFilter = NULL;
 701 wxHtmlProcessorList *wxHtmlWindow::m_GlobalProcessors = NULL;
 702
 703 void wxHtmlWindow::CleanUpStatics()
 704 {
 705     wxDELETE(m_DefaultFilter);
 706     WX_CLEAR_LIST(wxList, m_Filters);
 707     if (m_GlobalProcessors)
 708         WX_CLEAR_LIST(wxHtmlProcessorList, *m_GlobalProcessors);
 709     wxDELETE(m_GlobalProcessors);
 710 }
 711
 712
 713
 714 void wxHtmlWindow::AddFilter(wxHtmlFilter *filter)
 715 {
 716     m_Filters.Append(filter);
 717 }
 718
 719
 720 bool wxHtmlWindow::IsSelectionEnabled() const
 721 {
 722 #if wxUSE_CLIPBOARD
 723     return !(m_Style & wxHW_NO_SELECTION);
 724 #else
 725     return false;
 726 #endif
 727 }
 728
 729
 730 #if wxUSE_CLIPBOARD
 731 wxString wxHtmlWindow::DoSelectionToText(wxHtmlSelection *sel)
 732 {
 733     if ( !sel )
 734         return wxEmptyString;
 735
 736     wxClientDC dc(this);
 737
 738     const wxHtmlCell *end = sel->GetToCell();
 739     wxString text;
 740     wxHtmlTerminalCellsInterator i(sel->GetFromCell(), end);
 741     if ( i )
 742     {
 743         text << i->ConvertToText(sel);
 744         ++i;
 745     }
 746     const wxHtmlCell *prev = *i;
 747     while ( i )
 748     {
 749         if ( prev->GetParent() != i->GetParent() )
 750             text << _T('\n');
 751         text << i->ConvertToText(*i == end ? sel : NULL);
 752         prev = *i;
 753         ++i;
 754     }
 755     return text;
 756 }
 757
 758 wxString wxHtmlWindow::ToText()
 759 {
 760     if (m_Cell)
 761     {
 762         wxHtmlSelection sel;
 763         sel.Set(m_Cell->GetFirstTerminal(), m_Cell->GetLastTerminal());
 764         return DoSelectionToText(&sel);
 765     }
 766     else
 767         return wxEmptyString;
 768 }
 769
 770 #endif // wxUSE_CLIPBOARD
 771
 772 bool wxHtmlWindow::CopySelection(ClipboardType t)
 773 {
 774 #if wxUSE_CLIPBOARD
 775     if ( m_selection )
 776     {
 777 #ifdef __UNIX__
 778         wxTheClipboard->UsePrimarySelection(t == Primary);
 779 #else // !__UNIX__
 780         // Primary selection exists only under X11, so don't do anything under
 781         // the other platforms when we try to access it
 782         //
 783         // TODO: this should be abstracted at wxClipboard level!
 784         if ( t == Primary )
 785             return false;
 786 #endif // __UNIX__/!__UNIX__
 787
 788         if ( wxTheClipboard->Open() )
 789         {
 790             const wxString txt(SelectionToText());
 791             wxTheClipboard->SetData(new wxTextDataObject(txt));
 792             wxTheClipboard->Close();
 793             wxLogTrace(_T("wxhtmlselection"),
 794                        _("Copied to clipboard:\"%s\""), txt.c_str());
 795
 796             return true;
 797         }
 798     }
 799 #endif // wxUSE_CLIPBOARD
 800
 801     return false;
 802 }
 803
 804
 805 void wxHtmlWindow::OnLinkClicked(const wxHtmlLinkInfo& link)
 806 {
 807     const wxMouseEvent *e = link.GetEvent();
 808     if (e == NULL || e->LeftUp())
 809         LoadPage(link.GetHref());
 810 }
 811
 812 void wxHtmlWindow::OnCellClicked(wxHtmlCell *cell,
 813                                  wxCoord x, wxCoord y,
 814                                  const wxMouseEvent& event)
 815 {
 816     wxCHECK_RET( cell, _T("can't be called with NULL cell") );
 817
 818     cell->OnMouseClick(this, x, y, event);
 819 }
 820
 821 void wxHtmlWindow::OnCellMouseHover(wxHtmlCell * WXUNUSED(cell),
 822                                     wxCoord WXUNUSED(x), wxCoord WXUNUSED(y))
 823 {
 824     // do nothing here
 825 }
 826
 827 void wxHtmlWindow::OnEraseBackground(wxEraseEvent& WXUNUSED(event))
 828 {
 829 }
 830
 831 void wxHtmlWindow::OnPaint(wxPaintEvent& WXUNUSED(event))
 832 {
 833     wxPaintDC dc(this);
 834
 835     if (m_tmpCanDrawLocks > 0 || m_Cell == NULL) return;
 836
 837     int x, y;
 838     GetViewStart(&x, &y);
 839     wxRect rect = GetUpdateRegion().GetBox();
 840     wxSize sz = GetSize();
 841
 842     wxMemoryDC dcm;
 843     if ( !m_backBuffer )
 844         m_backBuffer = new wxBitmap(sz.x, sz.y);
 845     dcm.SelectObject(*m_backBuffer);
 846     dcm.SetBackground(wxBrush(GetBackgroundColour(), wxSOLID));
 847     dcm.Clear();
 848     PrepareDC(dcm);
 849     dcm.SetMapMode(wxMM_TEXT);
 850     dcm.SetBackgroundMode(wxTRANSPARENT);
 851
 852     wxHtmlRenderingInfo rinfo;
 853     wxDefaultHtmlRenderingStyle rstyle;
 854     rinfo.SetSelection(m_selection);
 855     rinfo.SetStyle(&rstyle);
 856     m_Cell->Draw(dcm, 0, 0,
 857                  y * wxHTML_SCROLL_STEP + rect.GetTop(),
 858                  y * wxHTML_SCROLL_STEP + rect.GetBottom(),
 859                  rinfo);
 860
 861 //#define DEBUG_HTML_SELECTION
 862 #ifdef DEBUG_HTML_SELECTION
 863     {
 864     int xc, yc, x, y;
 865     wxGetMousePosition(&xc, &yc);
 866     ScreenToClient(&xc, &yc);
 867     CalcUnscrolledPosition(xc, yc, &x, &y);
 868     wxHtmlCell *at = m_Cell->FindCellByPos(x, y);
 869     wxHtmlCell *before =
 870         m_Cell->FindCellByPos(x, y, wxHTML_FIND_NEAREST_BEFORE);
 871     wxHtmlCell *after =
 872         m_Cell->FindCellByPos(x, y, wxHTML_FIND_NEAREST_AFTER);
 873
 874     dcm.SetBrush(*wxTRANSPARENT_BRUSH);
 875     dcm.SetPen(*wxBLACK_PEN);
 876     if (at)
 877         dcm.DrawRectangle(at->GetAbsPos(),
 878                           wxSize(at->GetWidth(),at->GetHeight()));
 879     dcm.SetPen(*wxGREEN_PEN);
 880     if (before)
 881         dcm.DrawRectangle(before->GetAbsPos().x+1, before->GetAbsPos().y+1,
 882                           before->GetWidth()-2,before->GetHeight()-2);
 883     dcm.SetPen(*wxRED_PEN);
 884     if (after)
 885         dcm.DrawRectangle(after->GetAbsPos().x+2, after->GetAbsPos().y+2,
 886                           after->GetWidth()-4,after->GetHeight()-4);
 887     }
 888 #endif
 889
 890     dcm.SetDeviceOrigin(0,0);
 891     dc.Blit(0, rect.GetTop(),
 892             sz.x, rect.GetBottom() - rect.GetTop() + 1,
 893             &dcm,
 894             0, rect.GetTop());
 895 }
 896
 897
 898
 899
 900 void wxHtmlWindow::OnSize(wxSizeEvent& event)
 901 {
 902     wxDELETE(m_backBuffer);
 903
 904     wxScrolledWindow::OnSize(event);
 905     CreateLayout();
 906
 907     // Recompute selection if necessary:
 908     if ( m_selection )
 909     {
 910         m_selection->Set(m_selection->GetFromCell(),
 911                          m_selection->GetToCell());
 912         m_selection->ClearPrivPos();
 913     }
 914
 915     Refresh();
 916 }
 917
 918
 919 void wxHtmlWindow::OnMouseMove(wxMouseEvent& WXUNUSED(event))
 920 {
 921     m_tmpMouseMoved = true;
 922 }
 923
 924 void wxHtmlWindow::OnMouseDown(wxMouseEvent& event)
 925 {
 926 #if wxUSE_CLIPBOARD
 927     if ( event.LeftDown() && IsSelectionEnabled() )
 928     {
 929         const long TRIPLECLICK_LEN = 200; // 0.2 sec after doubleclick
 930         if ( wxGetLocalTimeMillis() - m_lastDoubleClick <= TRIPLECLICK_LEN )
 931         {
 932             SelectLine(CalcUnscrolledPosition(event.GetPosition()));
 933
 934             (void) CopySelection();
 935         }
 936         else
 937         {
 938             m_makingSelection = true;
 939
 940             if ( m_selection )
 941             {
 942                 wxDELETE(m_selection);
 943                 Refresh();
 944             }
 945             m_tmpSelFromPos = CalcUnscrolledPosition(event.GetPosition());
 946             m_tmpSelFromCell = NULL;
 947
 948             CaptureMouse();
 949         }
 950     }
 951 #endif // wxUSE_CLIPBOARD
 952 }
 953
 954 void wxHtmlWindow::OnMouseUp(wxMouseEvent& event)
 955 {
 956 #if wxUSE_CLIPBOARD
 957     if ( m_makingSelection )
 958     {
 959         ReleaseMouse();
 960         m_makingSelection = false;
 961
 962         // did the user move the mouse far enough from starting point?
 963         if ( CopySelection(Primary) )
 964         {
 965             // we don't want mouse up event that ended selecting to be
 966             // handled as mouse click and e.g. follow hyperlink:
 967             return;
 968         }
 969     }
 970 #endif // wxUSE_CLIPBOARD
 971
 972     SetFocus();
 973     if ( m_Cell )
 974     {
 975         wxPoint pos = CalcUnscrolledPosition(event.GetPosition());
 976         wxHtmlCell *cell = m_Cell->FindCellByPos(pos.x, pos.y);
 977
 978         // check is needed because FindCellByPos returns terminal cell and
 979         // containers may have empty borders -- in this case NULL will be
 980         // returned
 981         if ( cell )
 982             OnCellClicked(cell, pos.x, pos.y, event);
 983     }
 984 }
 985
 986
 987
 988 void wxHtmlWindow::OnInternalIdle()
 989 {
 990     wxWindow::OnInternalIdle();
 991
 992     if (m_tmpMouseMoved && (m_Cell != NULL))
 993     {
 994 #ifdef DEBUG_HTML_SELECTION
 995         Refresh();
 996 #endif
 997         int xc, yc, x, y;
 998         wxGetMousePosition(&xc, &yc);
 999         ScreenToClient(&xc, &yc);
1000         CalcUnscrolledPosition(xc, yc, &x, &y);
1001
1002         wxHtmlCell *cell = m_Cell->FindCellByPos(x, y);
1003
1004         // handle selection update:
1005         if ( m_makingSelection )
1006         {
1007             if ( !m_tmpSelFromCell )
1008                 m_tmpSelFromCell = m_Cell->FindCellByPos(
1009                                          m_tmpSelFromPos.x,m_tmpSelFromPos.y);
1010
1011             // NB: a trick - we adjust selFromPos to be upper left or bottom
1012             //     right corner of the first cell of the selection depending
1013             //     on whether the mouse is moving to the right or to the left.
1014             //     This gives us more "natural" behaviour when selecting
1015             //     a line (specifically, first cell of the next line is not
1016             //     included if you drag selection from left to right over
1017             //     entire line):
1018             wxPoint dirFromPos;
1019             if ( !m_tmpSelFromCell )
1020             {
1021                 dirFromPos = m_tmpSelFromPos;
1022             }
1023             else
1024             {
1025                 dirFromPos = m_tmpSelFromCell->GetAbsPos();
1026                 if ( x < m_tmpSelFromPos.x )
1027                 {
1028                     dirFromPos.x += m_tmpSelFromCell->GetWidth();
1029                     dirFromPos.y += m_tmpSelFromCell->GetHeight();
1030                 }
1031             }
1032             bool goingDown = dirFromPos.y < y ||
1033                              (dirFromPos.y == y && dirFromPos.x < x);
1034
1035             // determine selection span:
1036             if ( /*still*/ !m_tmpSelFromCell )
1037             {
1038                 if (goingDown)
1039                 {
1040                     m_tmpSelFromCell = m_Cell->FindCellByPos(
1041                                          m_tmpSelFromPos.x,m_tmpSelFromPos.y,
1042                                          wxHTML_FIND_NEAREST_AFTER);
1043                     if (!m_tmpSelFromCell)
1044                         m_tmpSelFromCell = m_Cell->GetFirstTerminal();
1045                 }
1046                 else
1047                 {
1048                     m_tmpSelFromCell = m_Cell->FindCellByPos(
1049                                          m_tmpSelFromPos.x,m_tmpSelFromPos.y,
1050                                          wxHTML_FIND_NEAREST_BEFORE);
1051                     if (!m_tmpSelFromCell)
1052                         m_tmpSelFromCell = m_Cell->GetLastTerminal();
1053                 }
1054             }
1055
1056             wxHtmlCell *selcell = cell;
1057             if (!selcell)
1058             {
1059                 if (goingDown)
1060                 {
1061                     selcell = m_Cell->FindCellByPos(x, y,
1062                                                  wxHTML_FIND_NEAREST_BEFORE);
1063                     if (!selcell)
1064                         selcell = m_Cell->GetLastTerminal();
1065                 }
1066                 else
1067                 {
1068                     selcell = m_Cell->FindCellByPos(x, y,
1069                                                  wxHTML_FIND_NEAREST_AFTER);
1070                     if (!selcell)
1071                         selcell = m_Cell->GetFirstTerminal();
1072                 }
1073             }
1074
1075             // NB: it may *rarely* happen that the code above didn't find one
1076             //     of the cells, e.g. if wxHtmlWindow doesn't contain any
1077             //     visible cells.
1078             if ( selcell && m_tmpSelFromCell )
1079             {
1080                 if ( !m_selection )
1081                 {
1082                     // start selecting only if mouse movement was big enough
1083                     // (otherwise it was meant as mouse click, not selection):
1084                     const int PRECISION = 2;
1085                     wxPoint diff = m_tmpSelFromPos - wxPoint(x,y);
1086                     if (abs(diff.x) > PRECISION || abs(diff.y) > PRECISION)
1087                     {
1088                         m_selection = new wxHtmlSelection();
1089                     }
1090                 }
1091                 if ( m_selection )
1092                 {
1093                     if ( m_tmpSelFromCell->IsBefore(selcell) )
1094                     {
1095                         m_selection->Set(m_tmpSelFromPos, m_tmpSelFromCell,
1096                                          wxPoint(x,y), selcell);                                    }
1097                     else
1098                     {
1099                         m_selection->Set(wxPoint(x,y), selcell,
1100                                          m_tmpSelFromPos, m_tmpSelFromCell);
1101                     }
1102                     m_selection->ClearPrivPos();
1103                     Refresh();
1104                 }
1105             }
1106         }
1107
1108         // handle cursor and status bar text changes:
1109         if ( cell != m_tmpLastCell )
1110         {
1111             wxHtmlLinkInfo *lnk = cell ? cell->GetLink(x, y) : NULL;
1112             wxCursor cur;
1113             if (cell)
1114                 cur = cell->GetCursor();
1115             else
1116                 cur = *wxSTANDARD_CURSOR;
1117             SetCursor(cur);
1118
1119             if (lnk != m_tmpLastLink)
1120             {
1121                 if (lnk == NULL)
1122                 {
1123                     if (m_RelatedStatusBar != -1)
1124                         m_RelatedFrame->SetStatusText(wxEmptyString,
1125                                                       m_RelatedStatusBar);
1126                 }
1127                 else
1128                 {
1129                     if (m_RelatedStatusBar != -1)
1130                         m_RelatedFrame->SetStatusText(lnk->GetHref(),
1131                                                       m_RelatedStatusBar);
1132                 }
1133                 m_tmpLastLink = lnk;
1134             }
1135
1136             m_tmpLastCell = cell;
1137         }
1138         else // mouse moved but stayed in the same cell
1139         {
1140             if ( cell )
1141                 OnCellMouseHover(cell, x, y);
1142         }
1143
1144         m_tmpMouseMoved = FALSE;
1145     }
1146 }
1147
1148 #if wxUSE_CLIPBOARD
1149 void wxHtmlWindow::StopAutoScrolling()
1150 {
1151     if ( m_timerAutoScroll )
1152     {
1153         wxDELETE(m_timerAutoScroll);
1154     }
1155 }
1156
1157 void wxHtmlWindow::OnMouseEnter(wxMouseEvent& event)
1158 {
1159     StopAutoScrolling();
1160     event.Skip();
1161 }
1162
1163 void wxHtmlWindow::OnMouseLeave(wxMouseEvent& event)
1164 {
1165     // don't prevent the usual processing of the event from taking place
1166     event.Skip();
1167
1168     // when a captured mouse leave a scrolled window we start generate
1169     // scrolling events to allow, for example, extending selection beyond the
1170     // visible area in some controls
1171     if ( wxWindow::GetCapture() == this )
1172     {
1173         // where is the mouse leaving?
1174         int pos, orient;
1175         wxPoint pt = event.GetPosition();
1176         if ( pt.x < 0 )
1177         {
1178             orient = wxHORIZONTAL;
1179             pos = 0;
1180         }
1181         else if ( pt.y < 0 )
1182         {
1183             orient = wxVERTICAL;
1184             pos = 0;
1185         }
1186         else // we're lower or to the right of the window
1187         {
1188             wxSize size = GetClientSize();
1189             if ( pt.x > size.x )
1190             {
1191                 orient = wxHORIZONTAL;
1192                 pos = GetVirtualSize().x / wxHTML_SCROLL_STEP;
1193             }
1194             else if ( pt.y > size.y )
1195             {
1196                 orient = wxVERTICAL;
1197                 pos = GetVirtualSize().y / wxHTML_SCROLL_STEP;
1198             }
1199             else // this should be impossible
1200             {
1201                 // but seems to happen sometimes under wxMSW - maybe it's a bug
1202                 // there but for now just ignore it
1203
1204                 //wxFAIL_MSG( _T("can't understand where has mouse gone") );
1205
1206                 return;
1207             }
1208         }
1209
1210         // only start the auto scroll timer if the window can be scrolled in
1211         // this direction
1212         if ( !HasScrollbar(orient) )
1213             return;
1214
1215         delete m_timerAutoScroll;
1216         m_timerAutoScroll = new wxHtmlWinAutoScrollTimer
1217                                 (
1218                                     this,
1219                                     pos == 0 ? wxEVT_SCROLLWIN_LINEUP
1220                                              : wxEVT_SCROLLWIN_LINEDOWN,
1221                                     pos,
1222                                     orient
1223                                 );
1224         m_timerAutoScroll->Start(50); // FIXME: make configurable
1225     }
1226 }
1227
1228 void wxHtmlWindow::OnKeyUp(wxKeyEvent& event)
1229 {
1230     if ( IsSelectionEnabled() &&
1231          event.GetKeyCode() == 'C' && event.ControlDown() )
1232     {
1233         (void) CopySelection();
1234     }
1235 }
1236
1237 void wxHtmlWindow::OnCopy(wxCommandEvent& WXUNUSED(event))
1238 {
1239     (void) CopySelection();
1240 }
1241
1242 void wxHtmlWindow::OnDoubleClick(wxMouseEvent& event)
1243 {
1244     // select word under cursor:
1245     if ( IsSelectionEnabled() )
1246     {
1247         SelectWord(CalcUnscrolledPosition(event.GetPosition()));
1248
1249         (void) CopySelection(Primary);
1250
1251         m_lastDoubleClick = wxGetLocalTimeMillis();
1252     }
1253     else
1254         event.Skip();
1255 }
1256
1257 void wxHtmlWindow::SelectWord(const wxPoint& pos)
1258 {
1259     if ( m_Cell )
1260     {
1261         wxHtmlCell *cell = m_Cell->FindCellByPos(pos.x, pos.y);
1262         if ( cell )
1263         {
1264             delete m_selection;
1265             m_selection = new wxHtmlSelection();
1266             m_selection->Set(cell, cell);
1267             RefreshRect(wxRect(CalcScrolledPosition(cell->GetAbsPos()),
1268                                wxSize(cell->GetWidth(), cell->GetHeight())));
1269         }
1270     }
1271 }
1272
1273 void wxHtmlWindow::SelectLine(const wxPoint& pos)
1274 {
1275     if ( m_Cell )
1276     {
1277         wxHtmlCell *cell = m_Cell->FindCellByPos(pos.x, pos.y);
1278         if ( cell )
1279         {
1280             // We use following heuristic to find a "line": let the line be all
1281             // cells in same container as the cell under mouse cursor that are
1282             // neither completely above nor completely bellow the clicked cell
1283             // (i.e. are likely to be words positioned on same line of text).
1284
1285             int y1 = cell->GetAbsPos().y;
1286             int y2 = y1 + cell->GetHeight();
1287             int y;
1288             const wxHtmlCell *c;
1289             const wxHtmlCell *before = NULL;
1290             const wxHtmlCell *after = NULL;
1291
1292             // find last cell of line:
1293             for ( c = cell->GetNext(); c; c = c->GetNext())
1294             {
1295                 y = c->GetAbsPos().y;
1296                 if ( y + c->GetHeight() > y1 && y < y2 )
1297                     after = c;
1298                 else
1299                     break;
1300             }
1301             if ( !after )
1302                 after = cell;
1303
1304             // find first cell of line:
1305             for ( c = cell->GetParent()->GetFirstChild();
1306                     c && c != cell; c = c->GetNext())
1307             {
1308                 y = c->GetAbsPos().y;
1309                 if ( y + c->GetHeight() > y1 && y < y2 )
1310                 {
1311                     if ( ! before )
1312                         before = c;
1313                 }
1314                 else
1315                     before = NULL;
1316             }
1317             if ( !before )
1318                 before = cell;
1319
1320             delete m_selection;
1321             m_selection = new wxHtmlSelection();
1322             m_selection->Set(before, after);
1323
1324             Refresh();
1325         }
1326     }
1327 }
1328
1329 void wxHtmlWindow::SelectAll()
1330 {
1331     if ( m_Cell )
1332     {
1333         delete m_selection;
1334         m_selection = new wxHtmlSelection();
1335         m_selection->Set(m_Cell->GetFirstTerminal(), m_Cell->GetLastTerminal());
1336         Refresh();
1337     }
1338 }
1339
1340 #endif // wxUSE_CLIPBOARD
1341
1342
1343
1344 IMPLEMENT_ABSTRACT_CLASS(wxHtmlProcessor,wxObject)
1345
1346 #if wxUSE_EXTENDED_RTTI
1347 IMPLEMENT_DYNAMIC_CLASS_XTI(wxHtmlWindow, wxScrolledWindow,"wx/html/htmlwin.h")
1348
1349 wxBEGIN_PROPERTIES_TABLE(wxHtmlWindow)
1350 /*
1351         TODO PROPERTIES
1352                 style , wxHW_SCROLLBAR_AUTO
1353                 borders , (dimension)
1354                 url , string
1355                 htmlcode , string
1356 */
1357 wxEND_PROPERTIES_TABLE()
1358
1359 wxBEGIN_HANDLERS_TABLE(wxHtmlWindow)
1360 wxEND_HANDLERS_TABLE()
1361
1362 wxCONSTRUCTOR_5( wxHtmlWindow , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle )
1363 #else
1364 IMPLEMENT_DYNAMIC_CLASS(wxHtmlWindow,wxScrolledWindow)
1365 #endif
1366
1367 BEGIN_EVENT_TABLE(wxHtmlWindow, wxScrolledWindow)
1368     EVT_SIZE(wxHtmlWindow::OnSize)
1369     EVT_LEFT_DOWN(wxHtmlWindow::OnMouseDown)
1370     EVT_LEFT_UP(wxHtmlWindow::OnMouseUp)
1371     EVT_RIGHT_UP(wxHtmlWindow::OnMouseUp)
1372     EVT_MOTION(wxHtmlWindow::OnMouseMove)
1373     EVT_ERASE_BACKGROUND(wxHtmlWindow::OnEraseBackground)
1374     EVT_PAINT(wxHtmlWindow::OnPaint)
1375 #if wxUSE_CLIPBOARD
1376     EVT_LEFT_DCLICK(wxHtmlWindow::OnDoubleClick)
1377     EVT_ENTER_WINDOW(wxHtmlWindow::OnMouseEnter)
1378     EVT_LEAVE_WINDOW(wxHtmlWindow::OnMouseLeave)
1379     EVT_KEY_UP(wxHtmlWindow::OnKeyUp)
1380     EVT_MENU(wxID_COPY, wxHtmlWindow::OnCopy)
1381 #endif // wxUSE_CLIPBOARD
1382 END_EVENT_TABLE()
1383
1384
1385
1386
1387
1388 // A module to allow initialization/cleanup
1389 // without calling these functions from app.cpp or from
1390 // the user's application.
1391
1392 class wxHtmlWinModule: public wxModule
1393 {
1394 DECLARE_DYNAMIC_CLASS(wxHtmlWinModule)
1395 public:
1396     wxHtmlWinModule() : wxModule() {}
1397     bool OnInit() { return TRUE; }
1398     void OnExit() { wxHtmlWindow::CleanUpStatics(); }
1399 };
1400
1401 IMPLEMENT_DYNAMIC_CLASS(wxHtmlWinModule, wxModule)
1402
1403
1404 // This hack forces the linker to always link in m_* files
1405 // (wxHTML doesn't work without handlers from these files)
1406 #include "wx/html/forcelnk.h"
1407 FORCE_WXHTML_MODULES()
1408
1409 #endif // wxUSE_HTML
1410