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