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