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