src/html/htmlwin.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/html/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 #ifdef __BORLANDC__
  13     #pragma hdrstop
  14 #endif
  15
  16 #if wxUSE_HTML && wxUSE_STREAMS
  17
  18 #ifndef WX_PRECOMP
  19     #include "wx/list.h"
  20     #include "wx/log.h"
  21     #include "wx/intl.h"
  22     #include "wx/dcclient.h"
  23     #include "wx/frame.h"
  24     #include "wx/dcmemory.h"
  25     #include "wx/timer.h"
  26     #include "wx/settings.h"
  27     #include "wx/dataobj.h"
  28     #include "wx/statusbr.h"
  29 #endif
  30
  31 #include "wx/html/htmlwin.h"
  32 #include "wx/html/htmlproc.h"
  33 #include "wx/clipbrd.h"
  34 #include "wx/recguard.h"
  35
  36 #include "wx/arrimpl.cpp"
  37 #include "wx/listimpl.cpp"
  38
  39 // uncomment this line to visually show the extent of the selection
  40 //#define DEBUG_HTML_SELECTION
  41
  42 // HTML events:
  43 IMPLEMENT_DYNAMIC_CLASS(wxHtmlLinkEvent, wxCommandEvent)
  44 IMPLEMENT_DYNAMIC_CLASS(wxHtmlCellEvent, wxCommandEvent)
  45
  46 wxDEFINE_EVENT( wxEVT_COMMAND_HTML_CELL_CLICKED, wxHtmlCellEvent );
  47 wxDEFINE_EVENT( wxEVT_COMMAND_HTML_CELL_HOVER, wxHtmlCellEvent );
  48 wxDEFINE_EVENT( wxEVT_COMMAND_HTML_LINK_CLICKED, wxHtmlLinkEvent );
  49
  50
  51 #if wxUSE_CLIPBOARD
  52 // ----------------------------------------------------------------------------
  53 // wxHtmlWinAutoScrollTimer: the timer used to generate a stream of scroll
  54 // events when a captured mouse is held outside the window
  55 // ----------------------------------------------------------------------------
  56
  57 class wxHtmlWinAutoScrollTimer : public wxTimer
  58 {
  59 public:
  60     wxHtmlWinAutoScrollTimer(wxScrolledWindow *win,
  61                       wxEventType eventTypeToSend,
  62                       int pos, int orient)
  63     {
  64         m_win = win;
  65         m_eventType = eventTypeToSend;
  66         m_pos = pos;
  67         m_orient = orient;
  68     }
  69
  70     virtual void Notify();
  71
  72 private:
  73     wxScrolledWindow *m_win;
  74     wxEventType m_eventType;
  75     int m_pos,
  76         m_orient;
  77
  78     wxDECLARE_NO_COPY_CLASS(wxHtmlWinAutoScrollTimer);
  79 };
  80
  81 void wxHtmlWinAutoScrollTimer::Notify()
  82 {
  83     // only do all this as long as the window is capturing the mouse
  84     if ( wxWindow::GetCapture() != m_win )
  85     {
  86         Stop();
  87     }
  88     else // we still capture the mouse, continue generating events
  89     {
  90         // first scroll the window if we are allowed to do it
  91         wxScrollWinEvent event1(m_eventType, m_pos, m_orient);
  92         event1.SetEventObject(m_win);
  93         if ( m_win->GetEventHandler()->ProcessEvent(event1) )
  94         {
  95             // and then send a pseudo mouse-move event to refresh the selection
  96             wxMouseEvent event2(wxEVT_MOTION);
  97             wxGetMousePosition(&event2.m_x, &event2.m_y);
  98
  99             // the mouse event coordinates should be client, not screen as
 100             // returned by wxGetMousePosition
 101             wxWindow *parentTop = m_win;
 102             while ( parentTop->GetParent() )
 103                 parentTop = parentTop->GetParent();
 104             wxPoint ptOrig = parentTop->GetPosition();
 105             event2.m_x -= ptOrig.x;
 106             event2.m_y -= ptOrig.y;
 107
 108             event2.SetEventObject(m_win);
 109
 110             // FIXME: we don't fill in the other members - ok?
 111             m_win->GetEventHandler()->ProcessEvent(event2);
 112         }
 113         else // can't scroll further, stop
 114         {
 115             Stop();
 116         }
 117     }
 118 }
 119
 120 #endif // wxUSE_CLIPBOARD
 121
 122
 123
 124 //-----------------------------------------------------------------------------
 125 // wxHtmlHistoryItem
 126 //-----------------------------------------------------------------------------
 127
 128 // item of history list
 129 class WXDLLIMPEXP_HTML wxHtmlHistoryItem
 130 {
 131 public:
 132     wxHtmlHistoryItem(const wxString& p, const wxString& a) {m_Page = p, m_Anchor = a, m_Pos = 0;}
 133     int GetPos() const {return m_Pos;}
 134     void SetPos(int p) {m_Pos = p;}
 135     const wxString& GetPage() const {return m_Page;}
 136     const wxString& GetAnchor() const {return m_Anchor;}
 137
 138 private:
 139     wxString m_Page;
 140     wxString m_Anchor;
 141     int m_Pos;
 142 };
 143
 144
 145 //-----------------------------------------------------------------------------
 146 // our private arrays:
 147 //-----------------------------------------------------------------------------
 148
 149 WX_DECLARE_OBJARRAY(wxHtmlHistoryItem, wxHtmlHistoryArray);
 150 WX_DEFINE_OBJARRAY(wxHtmlHistoryArray)
 151
 152 WX_DECLARE_LIST(wxHtmlProcessor, wxHtmlProcessorList);
 153 WX_DEFINE_LIST(wxHtmlProcessorList)
 154
 155 //-----------------------------------------------------------------------------
 156 // wxHtmlWindowMouseHelper
 157 //-----------------------------------------------------------------------------
 158
 159 wxHtmlWindowMouseHelper::wxHtmlWindowMouseHelper(wxHtmlWindowInterface *iface)
 160     : m_tmpMouseMoved(false),
 161       m_tmpLastLink(NULL),
 162       m_tmpLastCell(NULL),
 163       m_interface(iface)
 164 {
 165 }
 166
 167 void wxHtmlWindowMouseHelper::HandleMouseMoved()
 168 {
 169     m_tmpMouseMoved = true;
 170 }
 171
 172 bool wxHtmlWindowMouseHelper::HandleMouseClick(wxHtmlCell *rootCell,
 173                                                const wxPoint& pos,
 174                                                const wxMouseEvent& event)
 175 {
 176     if (!rootCell)
 177         return false;
 178
 179     wxHtmlCell *cell = rootCell->FindCellByPos(pos.x, pos.y);
 180     // this check is needed because FindCellByPos returns terminal cell and
 181     // containers may have empty borders -- in this case NULL will be
 182     // returned
 183     if (!cell)
 184         return false;
 185
 186     // adjust the coordinates to be relative to this cell:
 187     wxPoint relpos = pos - cell->GetAbsPos(rootCell);
 188
 189     return OnCellClicked(cell, relpos.x, relpos.y, event);
 190 }
 191
 192 void wxHtmlWindowMouseHelper::HandleIdle(wxHtmlCell *rootCell,
 193                                          const wxPoint& pos)
 194 {
 195     wxHtmlCell *cell = rootCell ? rootCell->FindCellByPos(pos.x, pos.y) : NULL;
 196
 197     if (cell != m_tmpLastCell)
 198     {
 199         wxHtmlLinkInfo *lnk = NULL;
 200         if (cell)
 201         {
 202             // adjust the coordinates to be relative to this cell:
 203             wxPoint relpos = pos - cell->GetAbsPos(rootCell);
 204             lnk = cell->GetLink(relpos.x, relpos.y);
 205         }
 206
 207         wxCursor cur;
 208         if (cell)
 209             cur = cell->GetMouseCursor(m_interface);
 210         else
 211             cur = m_interface->GetHTMLCursor(
 212                         wxHtmlWindowInterface::HTMLCursor_Default);
 213
 214         m_interface->GetHTMLWindow()->SetCursor(cur);
 215
 216         if (lnk != m_tmpLastLink)
 217         {
 218             if (lnk)
 219                 m_interface->SetHTMLStatusText(lnk->GetHref());
 220             else
 221                 m_interface->SetHTMLStatusText(wxEmptyString);
 222
 223             m_tmpLastLink = lnk;
 224         }
 225
 226         m_tmpLastCell = cell;
 227     }
 228     else // mouse moved but stayed in the same cell
 229     {
 230         if ( cell )
 231         {
 232             OnCellMouseHover(cell, pos.x, pos.y);
 233         }
 234     }
 235
 236     m_tmpMouseMoved = false;
 237 }
 238
 239 bool wxHtmlWindowMouseHelper::OnCellClicked(wxHtmlCell *cell,
 240                                             wxCoord x, wxCoord y,
 241                                             const wxMouseEvent& event)
 242 {
 243     wxHtmlCellEvent ev(wxEVT_COMMAND_HTML_CELL_CLICKED,
 244                        m_interface->GetHTMLWindow()->GetId(),
 245                        cell, wxPoint(x,y), event);
 246
 247     if (!m_interface->GetHTMLWindow()->GetEventHandler()->ProcessEvent(ev))
 248     {
 249         // if the event wasn't handled, do the default processing here:
 250
 251         wxASSERT_MSG( cell, wxT("can't be called with NULL cell") );
 252
 253         cell->ProcessMouseClick(m_interface, ev.GetPoint(), ev.GetMouseEvent());
 254     }
 255
 256     // true if a link was clicked, false otherwise
 257     return ev.GetLinkClicked();
 258 }
 259
 260 void wxHtmlWindowMouseHelper::OnCellMouseHover(wxHtmlCell * cell,
 261                                                wxCoord x,
 262                                                wxCoord y)
 263 {
 264     wxHtmlCellEvent ev(wxEVT_COMMAND_HTML_CELL_HOVER,
 265                        m_interface->GetHTMLWindow()->GetId(),
 266                        cell, wxPoint(x,y), wxMouseEvent());
 267     m_interface->GetHTMLWindow()->GetEventHandler()->ProcessEvent(ev);
 268 }
 269
 270
 271
 272
 273 //-----------------------------------------------------------------------------
 274 // wxHtmlWindow
 275 //-----------------------------------------------------------------------------
 276
 277 wxList wxHtmlWindow::m_Filters;
 278 wxHtmlFilter *wxHtmlWindow::m_DefaultFilter = NULL;
 279 wxHtmlProcessorList *wxHtmlWindow::m_GlobalProcessors = NULL;
 280 wxCursor *wxHtmlWindow::ms_cursorLink = NULL;
 281 wxCursor *wxHtmlWindow::ms_cursorText = NULL;
 282
 283 void wxHtmlWindow::CleanUpStatics()
 284 {
 285     wxDELETE(m_DefaultFilter);
 286     WX_CLEAR_LIST(wxList, m_Filters);
 287     if (m_GlobalProcessors)
 288         WX_CLEAR_LIST(wxHtmlProcessorList, *m_GlobalProcessors);
 289     wxDELETE(m_GlobalProcessors);
 290     wxDELETE(ms_cursorLink);
 291     wxDELETE(ms_cursorText);
 292 }
 293
 294 void wxHtmlWindow::Init()
 295 {
 296     m_tmpCanDrawLocks = 0;
 297     m_FS = new wxFileSystem();
 298 #if wxUSE_STATUSBAR
 299     m_RelatedStatusBar = NULL;
 300     m_RelatedStatusBarIndex = -1;
 301 #endif // wxUSE_STATUSBAR
 302     m_RelatedFrame = NULL;
 303     m_TitleFormat = wxT("%s");
 304     m_OpenedPage = m_OpenedAnchor = m_OpenedPageTitle = wxEmptyString;
 305     m_Cell = NULL;
 306     m_Parser = new wxHtmlWinParser(this);
 307     m_Parser->SetFS(m_FS);
 308     m_HistoryPos = -1;
 309     m_HistoryOn = true;
 310     m_History = new wxHtmlHistoryArray;
 311     m_Processors = NULL;
 312     SetBorders(10);
 313     m_selection = NULL;
 314     m_makingSelection = false;
 315 #if wxUSE_CLIPBOARD
 316     m_timerAutoScroll = NULL;
 317     m_lastDoubleClick = 0;
 318 #endif // wxUSE_CLIPBOARD
 319     m_tmpSelFromCell = NULL;
 320 }
 321
 322 bool wxHtmlWindow::Create(wxWindow *parent, wxWindowID id,
 323                           const wxPoint& pos, const wxSize& size,
 324                           long style, const wxString& name)
 325 {
 326     if (!wxScrolledWindow::Create(parent, id, pos, size,
 327                                   style | wxVSCROLL | wxHSCROLL,
 328                                   name))
 329         return false;
 330
 331     // We can't erase our background in EVT_ERASE_BACKGROUND handler and use
 332     // double buffering in EVT_PAINT handler as this requires blitting back
 333     // something already drawn on the window to the backing store bitmap when
 334     // handling EVT_PAINT but blitting in this direction is simply not
 335     // supported by OS X.
 336     //
 337     // So instead we use a hack with artificial EVT_ERASE_BACKGROUND generation
 338     // from OnPaint() and this means that we never need the "real" erase event
 339     // at all so disable it to avoid executing any user-defined handlers twice
 340     // (and to avoid processing unnecessary event if no handlers are defined).
 341     SetBackgroundStyle(wxBG_STYLE_PAINT);
 342     SetPage(wxT("<html><body></body></html>"));
 343
 344     SetInitialSize(size);
 345     return true;
 346 }
 347
 348
 349 wxHtmlWindow::~wxHtmlWindow()
 350 {
 351 #if wxUSE_CLIPBOARD
 352     StopAutoScrolling();
 353 #endif // wxUSE_CLIPBOARD
 354     HistoryClear();
 355
 356     delete m_selection;
 357
 358     delete m_Cell;
 359
 360     if ( m_Processors )
 361     {
 362         WX_CLEAR_LIST(wxHtmlProcessorList, *m_Processors);
 363     }
 364
 365     delete m_Parser;
 366     delete m_FS;
 367     delete m_History;
 368     delete m_Processors;
 369 }
 370
 371
 372
 373 void wxHtmlWindow::SetRelatedFrame(wxFrame* frame, const wxString& format)
 374 {
 375     m_RelatedFrame = frame;
 376     m_TitleFormat = format;
 377 }
 378
 379
 380
 381 #if wxUSE_STATUSBAR
 382 void wxHtmlWindow::SetRelatedStatusBar(int index)
 383 {
 384     m_RelatedStatusBarIndex = index;
 385 }
 386
 387 void wxHtmlWindow::SetRelatedStatusBar(wxStatusBar* statusbar, int index)
 388 {
 389     m_RelatedStatusBar =  statusbar;
 390     m_RelatedStatusBarIndex = index;
 391 }
 392
 393 #endif // wxUSE_STATUSBAR
 394
 395
 396
 397 void wxHtmlWindow::SetFonts(const wxString& normal_face, const wxString& fixed_face, const int *sizes)
 398 {
 399     m_Parser->SetFonts(normal_face, fixed_face, sizes);
 400
 401     // re-layout the page after changing fonts:
 402     DoSetPage(*(m_Parser->GetSource()));
 403 }
 404
 405 void wxHtmlWindow::SetStandardFonts(int size,
 406                                     const wxString& normal_face,
 407                                     const wxString& fixed_face)
 408 {
 409     m_Parser->SetStandardFonts(size, normal_face, fixed_face);
 410
 411     // re-layout the page after changing fonts:
 412     DoSetPage(*(m_Parser->GetSource()));
 413 }
 414
 415 bool wxHtmlWindow::SetPage(const wxString& source)
 416 {
 417     m_OpenedPage = m_OpenedAnchor = m_OpenedPageTitle = wxEmptyString;
 418     return DoSetPage(source);
 419 }
 420
 421 bool wxHtmlWindow::DoSetPage(const wxString& source)
 422 {
 423     wxString newsrc(source);
 424
 425     wxDELETE(m_selection);
 426
 427     // we will soon delete all the cells, so clear pointers to them:
 428     m_tmpSelFromCell = NULL;
 429
 430     // pass HTML through registered processors:
 431     if (m_Processors || m_GlobalProcessors)
 432     {
 433         wxHtmlProcessorList::compatibility_iterator nodeL, nodeG;
 434         int prL, prG;
 435
 436         if ( m_Processors )
 437             nodeL = m_Processors->GetFirst();
 438         if ( m_GlobalProcessors )
 439             nodeG = m_GlobalProcessors->GetFirst();
 440
 441         // VS: there are two lists, global and local, both of them sorted by
 442         //     priority. Since we have to go through _both_ lists with
 443         //     decreasing priority, we "merge-sort" the lists on-line by
 444         //     processing that one of the two heads that has higher priority
 445         //     in every iteration
 446         while (nodeL || nodeG)
 447         {
 448             prL = (nodeL) ? nodeL->GetData()->GetPriority() : -1;
 449             prG = (nodeG) ? nodeG->GetData()->GetPriority() : -1;
 450             if (prL > prG)
 451             {
 452                 if (nodeL->GetData()->IsEnabled())
 453                     newsrc = nodeL->GetData()->Process(newsrc);
 454                 nodeL = nodeL->GetNext();
 455             }
 456             else // prL <= prG
 457             {
 458                 if (nodeG->GetData()->IsEnabled())
 459                     newsrc = nodeG->GetData()->Process(newsrc);
 460                 nodeG = nodeG->GetNext();
 461             }
 462         }
 463     }
 464
 465     // ...and run the parser on it:
 466     wxClientDC *dc = new wxClientDC(this);
 467     dc->SetMapMode(wxMM_TEXT);
 468     SetBackgroundColour(wxColour(0xFF, 0xFF, 0xFF));
 469     SetBackgroundImage(wxNullBitmap);
 470
 471     m_Parser->SetDC(dc);
 472     if (m_Cell)
 473     {
 474         delete m_Cell;
 475         // notice that it's important to set m_Cell to NULL here before calling
 476         // Parse() below, even if it will be overwritten by its return value:
 477         // without this we may crash if it's used from inside Parse()
 478         m_Cell = NULL;
 479     }
 480     m_Cell = (wxHtmlContainerCell*) m_Parser->Parse(newsrc);
 481     delete dc;
 482     m_Cell->SetIndent(m_Borders, wxHTML_INDENT_ALL, wxHTML_UNITS_PIXELS);
 483     m_Cell->SetAlignHor(wxHTML_ALIGN_CENTER);
 484     CreateLayout();
 485     if (m_tmpCanDrawLocks == 0)
 486         Refresh();
 487     return true;
 488 }
 489
 490 bool wxHtmlWindow::AppendToPage(const wxString& source)
 491 {
 492     return DoSetPage(*(GetParser()->GetSource()) + source);
 493 }
 494
 495 bool wxHtmlWindow::LoadPage(const wxString& location)
 496 {
 497     wxCHECK_MSG( !location.empty(), false, "location must be non-empty" );
 498
 499     wxBusyCursor busyCursor;
 500
 501     bool rt_val;
 502     bool needs_refresh = false;
 503
 504     m_tmpCanDrawLocks++;
 505     if (m_HistoryOn && (m_HistoryPos != -1))
 506     {
 507         // store scroll position into history item:
 508         int x, y;
 509         GetViewStart(&x, &y);
 510         (*m_History)[m_HistoryPos].SetPos(y);
 511     }
 512
 513     // first check if we're moving to an anchor in the same page
 514     size_t posLocalAnchor = location.Find('#');
 515     if ( posLocalAnchor != wxString::npos && posLocalAnchor != 0 )
 516     {
 517         // check if the part before the anchor is the same as the (either
 518         // relative or absolute) URI of the current page
 519         const wxString beforeAnchor = location.substr(0, posLocalAnchor);
 520         if ( beforeAnchor != m_OpenedPage &&
 521                 m_FS->GetPath() + beforeAnchor != m_OpenedPage )
 522         {
 523             // indicate that we're not moving to a local anchor
 524             posLocalAnchor = wxString::npos;
 525         }
 526     }
 527
 528     if ( posLocalAnchor != wxString::npos )
 529     {
 530         m_tmpCanDrawLocks--;
 531         rt_val = ScrollToAnchor(location.substr(posLocalAnchor + 1));
 532         m_tmpCanDrawLocks++;
 533     }
 534     else // moving to another page
 535     {
 536         needs_refresh = true;
 537 #if wxUSE_STATUSBAR
 538         // load&display it:
 539         if (m_RelatedStatusBarIndex != -1)
 540         {
 541             SetHTMLStatusText(_("Connecting..."));
 542             Refresh(false);
 543         }
 544 #endif // wxUSE_STATUSBAR
 545
 546         wxFSFile *f = m_Parser->OpenURL(wxHTML_URL_PAGE, location);
 547
 548         // try to interpret 'location' as filename instead of URL:
 549         if (f == NULL)
 550         {
 551             wxFileName fn(location);
 552             wxString location2 = wxFileSystem::FileNameToURL(fn);
 553             f = m_Parser->OpenURL(wxHTML_URL_PAGE, location2);
 554         }
 555
 556         if (f == NULL)
 557         {
 558             wxLogError(_("Unable to open requested HTML document: %s"), location.c_str());
 559             m_tmpCanDrawLocks--;
 560             SetHTMLStatusText(wxEmptyString);
 561             return false;
 562         }
 563
 564         else
 565         {
 566             wxList::compatibility_iterator node;
 567             wxString src = wxEmptyString;
 568
 569 #if wxUSE_STATUSBAR
 570             if (m_RelatedStatusBarIndex != -1)
 571             {
 572                 wxString msg = _("Loading : ") + location;
 573                 SetHTMLStatusText(msg);
 574                 Refresh(false);
 575             }
 576 #endif // wxUSE_STATUSBAR
 577
 578             node = m_Filters.GetFirst();
 579             while (node)
 580             {
 581                 wxHtmlFilter *h = (wxHtmlFilter*) node->GetData();
 582                 if (h->CanRead(*f))
 583                 {
 584                     src = h->ReadFile(*f);
 585                     break;
 586                 }
 587                 node = node->GetNext();
 588             }
 589             if (src == wxEmptyString)
 590             {
 591                 if (m_DefaultFilter == NULL) m_DefaultFilter = GetDefaultFilter();
 592                 src = m_DefaultFilter->ReadFile(*f);
 593             }
 594
 595             m_FS->ChangePathTo(f->GetLocation());
 596             rt_val = SetPage(src);
 597             m_OpenedPage = f->GetLocation();
 598             if (f->GetAnchor() != wxEmptyString)
 599             {
 600                 ScrollToAnchor(f->GetAnchor());
 601             }
 602
 603             delete f;
 604
 605 #if wxUSE_STATUSBAR
 606             if (m_RelatedStatusBarIndex != -1)
 607             {
 608                 SetHTMLStatusText(_("Done"));
 609             }
 610 #endif // wxUSE_STATUSBAR
 611         }
 612     }
 613
 614     if (m_HistoryOn) // add this page to history there:
 615     {
 616         int c = m_History->GetCount() - (m_HistoryPos + 1);
 617
 618         if (m_HistoryPos < 0 ||
 619             (*m_History)[m_HistoryPos].GetPage() != m_OpenedPage ||
 620             (*m_History)[m_HistoryPos].GetAnchor() != m_OpenedAnchor)
 621         {
 622             m_HistoryPos++;
 623             for (int i = 0; i < c; i++)
 624                 m_History->RemoveAt(m_HistoryPos);
 625             m_History->Add(new wxHtmlHistoryItem(m_OpenedPage, m_OpenedAnchor));
 626         }
 627     }
 628
 629     if (m_OpenedPageTitle == wxEmptyString)
 630         OnSetTitle(wxFileNameFromPath(m_OpenedPage));
 631
 632     if (needs_refresh)
 633     {
 634         m_tmpCanDrawLocks--;
 635         Refresh();
 636     }
 637     else
 638         m_tmpCanDrawLocks--;
 639
 640     return rt_val;
 641 }
 642
 643
 644 bool wxHtmlWindow::LoadFile(const wxFileName& filename)
 645 {
 646     wxString url = wxFileSystem::FileNameToURL(filename);
 647     return LoadPage(url);
 648 }
 649
 650
 651 bool wxHtmlWindow::ScrollToAnchor(const wxString& anchor)
 652 {
 653     const wxHtmlCell *c = m_Cell->Find(wxHTML_COND_ISANCHOR, &anchor);
 654     if (!c)
 655     {
 656         wxLogWarning(_("HTML anchor %s does not exist."), anchor.c_str());
 657         return false;
 658     }
 659     else
 660     {
 661         // Go to next visible cell in current container, if it exists. This
 662         // yields a bit better (even though still imperfect) results in that
 663         // there's better chance of using a suitable cell for upper Y
 664         // coordinate value. See bug #11406 for additional discussion.
 665         const wxHtmlCell *c_save = c;
 666         while ( c && c->IsFormattingCell() )
 667             c = c->GetNext();
 668         if ( !c )
 669             c = c_save;
 670
 671         int y;
 672
 673         for (y = 0; c != NULL; c = c->GetParent()) y += c->GetPosY();
 674         Scroll(-1, y / wxHTML_SCROLL_STEP);
 675         m_OpenedAnchor = anchor;
 676         return true;
 677     }
 678 }
 679
 680
 681 void wxHtmlWindow::OnSetTitle(const wxString& title)
 682 {
 683     if (m_RelatedFrame)
 684     {
 685         wxString tit;
 686         tit.Printf(m_TitleFormat, title.c_str());
 687         m_RelatedFrame->SetTitle(tit);
 688     }
 689     m_OpenedPageTitle = title;
 690 }
 691
 692
 693 // return scroll steps such that a) scrollbars aren't shown needlessly
 694 // and b) entire content is viewable (i.e. round up)
 695 static int ScrollSteps(int size, int available)
 696 {
 697     if ( size <= available )
 698         return 0;
 699     else
 700         return (size + wxHTML_SCROLL_STEP - 1) / wxHTML_SCROLL_STEP;
 701 }
 702
 703
 704 void wxHtmlWindow::CreateLayout()
 705 {
 706     // SetScrollbars() results in size change events -- and thus a nested
 707     // CreateLayout() call -- on some platforms. Ignore nested calls, toplevel
 708     // CreateLayout() will do the right thing eventually.
 709     static wxRecursionGuardFlag s_flagReentrancy;
 710     wxRecursionGuard guard(s_flagReentrancy);
 711     if ( guard.IsInside() )
 712         return;
 713
 714     if (!m_Cell)
 715         return;
 716
 717     int clientWidth, clientHeight;
 718     GetClientSize(&clientWidth, &clientHeight);
 719
 720     const int vscrollbar = wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
 721     const int hscrollbar = wxSystemSettings::GetMetric(wxSYS_HSCROLL_Y);
 722
 723     if ( HasScrollbar(wxHORIZONTAL) )
 724         clientHeight += hscrollbar;
 725
 726     if ( HasScrollbar(wxVERTICAL) )
 727         clientWidth += vscrollbar;
 728
 729     if ( HasFlag(wxHW_SCROLLBAR_NEVER) )
 730     {
 731         SetScrollbars(1, 1, 0, 0); // always off
 732         m_Cell->Layout(clientWidth);
 733     }
 734     else // !wxHW_SCROLLBAR_NEVER
 735     {
 736         // Lay the content out with the assumption that it's too large to fit
 737         // in the window (this is likely to be the case):
 738         m_Cell->Layout(clientWidth - vscrollbar);
 739
 740         // If the layout is wider than the window, horizontal scrollbar will
 741         // certainly be shown. Account for it here for subsequent computations.
 742         if ( m_Cell->GetWidth() > clientWidth )
 743             clientHeight -= hscrollbar;
 744
 745         if ( m_Cell->GetHeight() <= clientHeight )
 746         {
 747             // we fit into the window, hide vertical scrollbar:
 748             SetScrollbars
 749             (
 750                 wxHTML_SCROLL_STEP, wxHTML_SCROLL_STEP,
 751                 ScrollSteps(m_Cell->GetWidth(), clientWidth - vscrollbar),
 752                 0
 753             );
 754             // ...and redo the layout to use the extra space
 755             m_Cell->Layout(clientWidth);
 756         }
 757         else
 758         {
 759             // If the content doesn't fit into the window by only a small
 760             // margin, chances are that it may fit fully with scrollbar turned
 761             // off. It's something worth trying but on the other hand, we don't
 762             // want to waste too much time redoing the layout (twice!) for
 763             // long -- and thus expensive to layout -- pages. The cut-off value
 764             // is an arbitrary heuristics.
 765             static const int SMALL_OVERLAP = 60;
 766             if ( m_Cell->GetHeight() <= clientHeight + SMALL_OVERLAP )
 767             {
 768                 m_Cell->Layout(clientWidth);
 769
 770                 if ( m_Cell->GetHeight() <= clientHeight )
 771                 {
 772                     // Great, we fit in. Hide the scrollbar.
 773                     SetScrollbars
 774                     (
 775                         wxHTML_SCROLL_STEP, wxHTML_SCROLL_STEP,
 776                         ScrollSteps(m_Cell->GetWidth(), clientWidth),
 777                         0
 778                     );
 779                     return;
 780                 }
 781                 else
 782                 {
 783                     // That didn't work out, go back to previous layout. Note
 784                     // that redoing the layout once again here isn't as bad as
 785                     // it looks -- thanks to the small cut-off value, it's a
 786                     // reasonably small page.
 787                     m_Cell->Layout(clientWidth - vscrollbar);
 788                 }
 789             }
 790             // else: the page is very long, it will certainly need scrollbar
 791
 792             SetScrollbars
 793             (
 794                 wxHTML_SCROLL_STEP, wxHTML_SCROLL_STEP,
 795                 ScrollSteps(m_Cell->GetWidth(), clientWidth - vscrollbar),
 796                 ScrollSteps(m_Cell->GetHeight(), clientHeight)
 797             );
 798         }
 799     }
 800 }
 801
 802 #if wxUSE_CONFIG
 803 void wxHtmlWindow::ReadCustomization(wxConfigBase *cfg, wxString path)
 804 {
 805     wxString oldpath;
 806     wxString tmp;
 807     int p_fontsizes[7];
 808     wxString p_fff, p_ffn;
 809
 810     if (path != wxEmptyString)
 811     {
 812         oldpath = cfg->GetPath();
 813         cfg->SetPath(path);
 814     }
 815
 816     m_Borders = cfg->Read(wxT("wxHtmlWindow/Borders"), m_Borders);
 817     p_fff = cfg->Read(wxT("wxHtmlWindow/FontFaceFixed"), m_Parser->m_FontFaceFixed);
 818     p_ffn = cfg->Read(wxT("wxHtmlWindow/FontFaceNormal"), m_Parser->m_FontFaceNormal);
 819     for (int i = 0; i < 7; i++)
 820     {
 821         tmp.Printf(wxT("wxHtmlWindow/FontsSize%i"), i);
 822         p_fontsizes[i] = cfg->Read(tmp, m_Parser->m_FontsSizes[i]);
 823     }
 824     SetFonts(p_ffn, p_fff, p_fontsizes);
 825
 826     if (path != wxEmptyString)
 827         cfg->SetPath(oldpath);
 828 }
 829
 830
 831
 832 void wxHtmlWindow::WriteCustomization(wxConfigBase *cfg, wxString path)
 833 {
 834     wxString oldpath;
 835     wxString tmp;
 836
 837     if (path != wxEmptyString)
 838     {
 839         oldpath = cfg->GetPath();
 840         cfg->SetPath(path);
 841     }
 842
 843     cfg->Write(wxT("wxHtmlWindow/Borders"), (long) m_Borders);
 844     cfg->Write(wxT("wxHtmlWindow/FontFaceFixed"), m_Parser->m_FontFaceFixed);
 845     cfg->Write(wxT("wxHtmlWindow/FontFaceNormal"), m_Parser->m_FontFaceNormal);
 846     for (int i = 0; i < 7; i++)
 847     {
 848         tmp.Printf(wxT("wxHtmlWindow/FontsSize%i"), i);
 849         cfg->Write(tmp, (long) m_Parser->m_FontsSizes[i]);
 850     }
 851
 852     if (path != wxEmptyString)
 853         cfg->SetPath(oldpath);
 854 }
 855 #endif // wxUSE_CONFIG
 856
 857 bool wxHtmlWindow::HistoryBack()
 858 {
 859     wxString a, l;
 860
 861     if (m_HistoryPos < 1) return false;
 862
 863     // store scroll position into history item:
 864     int x, y;
 865     GetViewStart(&x, &y);
 866     (*m_History)[m_HistoryPos].SetPos(y);
 867
 868     // go to previous position:
 869     m_HistoryPos--;
 870
 871     l = (*m_History)[m_HistoryPos].GetPage();
 872     a = (*m_History)[m_HistoryPos].GetAnchor();
 873     m_HistoryOn = false;
 874     m_tmpCanDrawLocks++;
 875     if (a == wxEmptyString) LoadPage(l);
 876     else LoadPage(l + wxT("#") + a);
 877     m_HistoryOn = true;
 878     m_tmpCanDrawLocks--;
 879     Scroll(0, (*m_History)[m_HistoryPos].GetPos());
 880     Refresh();
 881     return true;
 882 }
 883
 884 bool wxHtmlWindow::HistoryCanBack()
 885 {
 886     if (m_HistoryPos < 1) return false;
 887     return true ;
 888 }
 889
 890
 891 bool wxHtmlWindow::HistoryForward()
 892 {
 893     wxString a, l;
 894
 895     if (m_HistoryPos == -1) return false;
 896     if (m_HistoryPos >= (int)m_History->GetCount() - 1)return false;
 897
 898     m_OpenedPage = wxEmptyString; // this will disable adding new entry into history in LoadPage()
 899
 900     m_HistoryPos++;
 901     l = (*m_History)[m_HistoryPos].GetPage();
 902     a = (*m_History)[m_HistoryPos].GetAnchor();
 903     m_HistoryOn = false;
 904     m_tmpCanDrawLocks++;
 905     if (a == wxEmptyString) LoadPage(l);
 906     else LoadPage(l + wxT("#") + a);
 907     m_HistoryOn = true;
 908     m_tmpCanDrawLocks--;
 909     Scroll(0, (*m_History)[m_HistoryPos].GetPos());
 910     Refresh();
 911     return true;
 912 }
 913
 914 bool wxHtmlWindow::HistoryCanForward()
 915 {
 916     if (m_HistoryPos == -1) return false;
 917     if (m_HistoryPos >= (int)m_History->GetCount() - 1)return false;
 918     return true ;
 919 }
 920
 921
 922 void wxHtmlWindow::HistoryClear()
 923 {
 924     m_History->Empty();
 925     m_HistoryPos = -1;
 926 }
 927
 928 void wxHtmlWindow::AddProcessor(wxHtmlProcessor *processor)
 929 {
 930     if (!m_Processors)
 931     {
 932         m_Processors = new wxHtmlProcessorList;
 933     }
 934     wxHtmlProcessorList::compatibility_iterator node;
 935
 936     for (node = m_Processors->GetFirst(); node; node = node->GetNext())
 937     {
 938         if (processor->GetPriority() > node->GetData()->GetPriority())
 939         {
 940             m_Processors->Insert(node, processor);
 941             return;
 942         }
 943     }
 944     m_Processors->Append(processor);
 945 }
 946
 947 /*static */ void wxHtmlWindow::AddGlobalProcessor(wxHtmlProcessor *processor)
 948 {
 949     if (!m_GlobalProcessors)
 950     {
 951         m_GlobalProcessors = new wxHtmlProcessorList;
 952     }
 953     wxHtmlProcessorList::compatibility_iterator node;
 954
 955     for (node = m_GlobalProcessors->GetFirst(); node; node = node->GetNext())
 956     {
 957         if (processor->GetPriority() > node->GetData()->GetPriority())
 958         {
 959             m_GlobalProcessors->Insert(node, processor);
 960             return;
 961         }
 962     }
 963     m_GlobalProcessors->Append(processor);
 964 }
 965
 966
 967
 968 void wxHtmlWindow::AddFilter(wxHtmlFilter *filter)
 969 {
 970     m_Filters.Append(filter);
 971 }
 972
 973
 974 bool wxHtmlWindow::IsSelectionEnabled() const
 975 {
 976 #if wxUSE_CLIPBOARD
 977     return !HasFlag(wxHW_NO_SELECTION);
 978 #else
 979     return false;
 980 #endif
 981 }
 982
 983
 984 #if wxUSE_CLIPBOARD
 985 wxString wxHtmlWindow::DoSelectionToText(wxHtmlSelection *sel)
 986 {
 987     if ( !sel )
 988         return wxEmptyString;
 989
 990     wxClientDC dc(this);
 991     wxString text;
 992
 993     wxHtmlTerminalCellsInterator i(sel->GetFromCell(), sel->GetToCell());
 994     const wxHtmlCell *prev = NULL;
 995
 996     while ( i )
 997     {
 998         // When converting HTML content to plain text, the entire paragraph
 999         // (container in wxHTML) goes on single line. A new paragraph (that
1000         // should go on its own line) has its own container. Therefore, the
1001         // simplest way of detecting where to insert newlines in plain text
1002         // is to check if the parent container changed -- if it did, we moved
1003         // to a new paragraph.
1004         if ( prev && prev->GetParent() != i->GetParent() )
1005             text << '\n';
1006
1007         // NB: we don't need to pass the selection to ConvertToText() in the
1008         //     middle of the selected text; it's only useful when only part of
1009         //     a cell is selected
1010         text << i->ConvertToText(sel);
1011
1012         prev = *i;
1013         ++i;
1014     }
1015     return text;
1016 }
1017
1018 wxString wxHtmlWindow::ToText()
1019 {
1020     if (m_Cell)
1021     {
1022         wxHtmlSelection sel;
1023         sel.Set(m_Cell->GetFirstTerminal(), m_Cell->GetLastTerminal());
1024         return DoSelectionToText(&sel);
1025     }
1026     else
1027         return wxEmptyString;
1028 }
1029
1030 #endif // wxUSE_CLIPBOARD
1031
1032 bool wxHtmlWindow::CopySelection(ClipboardType t)
1033 {
1034 #if wxUSE_CLIPBOARD
1035     if ( m_selection )
1036     {
1037 #if defined(__UNIX__) && !defined(__WXMAC__)
1038         wxTheClipboard->UsePrimarySelection(t == Primary);
1039 #else // !__UNIX__
1040         // Primary selection exists only under X11, so don't do anything under
1041         // the other platforms when we try to access it
1042         //
1043         // TODO: this should be abstracted at wxClipboard level!
1044         if ( t == Primary )
1045             return false;
1046 #endif // __UNIX__/!__UNIX__
1047
1048         if ( wxTheClipboard->Open() )
1049         {
1050             const wxString txt(SelectionToText());
1051             wxTheClipboard->SetData(new wxTextDataObject(txt));
1052             wxTheClipboard->Close();
1053             wxLogTrace(wxT("wxhtmlselection"),
1054                        _("Copied to clipboard:\"%s\""), txt.c_str());
1055
1056             return true;
1057         }
1058     }
1059 #else
1060     wxUnusedVar(t);
1061 #endif // wxUSE_CLIPBOARD
1062
1063     return false;
1064 }
1065
1066
1067 void wxHtmlWindow::OnLinkClicked(const wxHtmlLinkInfo& link)
1068 {
1069     wxHtmlLinkEvent event(GetId(), link);
1070     event.SetEventObject(this);
1071     if (!GetEventHandler()->ProcessEvent(event))
1072     {
1073         // the default behaviour is to load the URL in this window
1074         const wxMouseEvent *e = event.GetLinkInfo().GetEvent();
1075         if (e == NULL || e->LeftUp())
1076             LoadPage(event.GetLinkInfo().GetHref());
1077     }
1078 }
1079
1080 void wxHtmlWindow::DoEraseBackground(wxDC& dc)
1081 {
1082     // if we don't have any background bitmap we just fill it with background
1083     // colour and we also must do it if the background bitmap is not fully
1084     // opaque as otherwise junk could be left there
1085     if ( !m_bmpBg.IsOk() || m_bmpBg.GetMask() )
1086     {
1087         dc.SetBackground(GetBackgroundColour());
1088         dc.Clear();
1089     }
1090
1091     if ( m_bmpBg.IsOk() )
1092     {
1093         // draw the background bitmap tiling it over the entire window area
1094         const wxSize sz = GetClientSize();
1095         const wxSize sizeBmp(m_bmpBg.GetWidth(), m_bmpBg.GetHeight());
1096         for ( wxCoord x = 0; x < sz.x; x += sizeBmp.x )
1097         {
1098             for ( wxCoord y = 0; y < sz.y; y += sizeBmp.y )
1099             {
1100                 dc.DrawBitmap(m_bmpBg, x, y, true /* use mask */);
1101             }
1102         }
1103     }
1104 }
1105
1106 void wxHtmlWindow::OnPaint(wxPaintEvent& WXUNUSED(event))
1107 {
1108     wxPaintDC dcPaint(this);
1109
1110     if (m_tmpCanDrawLocks > 0 || m_Cell == NULL)
1111         return;
1112
1113     int x, y;
1114     GetViewStart(&x, &y);
1115     const wxRect rect = GetUpdateRegion().GetBox();
1116     const wxSize sz = GetClientSize();
1117
1118     // set up the DC we're drawing on: if the window is already double buffered
1119     // we do it directly on wxPaintDC, otherwise we allocate a backing store
1120     // buffer and compose the drawing there and then blit it to screen all at
1121     // once
1122     wxDC *dc;
1123     wxMemoryDC dcm;
1124     if ( IsDoubleBuffered() )
1125     {
1126         dc = &dcPaint;
1127     }
1128     else // window is not double buffered by the system, do it ourselves
1129     {
1130         if ( !m_backBuffer.IsOk() )
1131             m_backBuffer.Create(sz.x, sz.y);
1132         dcm.SelectObject(m_backBuffer);
1133         dc = &dcm;
1134     }
1135
1136     PrepareDC(*dc);
1137
1138     // erase the background: for compatibility, we must generate the event to
1139     // allow the user-defined handlers to do it
1140     wxEraseEvent eraseEvent(GetId(), dc);
1141     eraseEvent.SetEventObject(this);
1142     if ( !ProcessWindowEvent(eraseEvent) )
1143     {
1144         // erase background ourselves
1145         DoEraseBackground(*dc);
1146     }
1147     //else: background erased by the user-defined handler
1148
1149
1150     // draw the HTML window contents
1151     dc->SetMapMode(wxMM_TEXT);
1152     dc->SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
1153
1154     wxHtmlRenderingInfo rinfo;
1155     wxDefaultHtmlRenderingStyle rstyle;
1156     rinfo.SetSelection(m_selection);
1157     rinfo.SetStyle(&rstyle);
1158     m_Cell->Draw(*dc, 0, 0,
1159                  y * wxHTML_SCROLL_STEP + rect.GetTop(),
1160                  y * wxHTML_SCROLL_STEP + rect.GetBottom(),
1161                  rinfo);
1162
1163 #ifdef DEBUG_HTML_SELECTION
1164     {
1165     int xc, yc, x, y;
1166     wxGetMousePosition(&xc, &yc);
1167     ScreenToClient(&xc, &yc);
1168     CalcUnscrolledPosition(xc, yc, &x, &y);
1169     wxHtmlCell *at = m_Cell->FindCellByPos(x, y);
1170     wxHtmlCell *before =
1171         m_Cell->FindCellByPos(x, y, wxHTML_FIND_NEAREST_BEFORE);
1172     wxHtmlCell *after =
1173         m_Cell->FindCellByPos(x, y, wxHTML_FIND_NEAREST_AFTER);
1174
1175     dc->SetBrush(*wxTRANSPARENT_BRUSH);
1176     dc->SetPen(*wxBLACK_PEN);
1177     if (at)
1178         dc->DrawRectangle(at->GetAbsPos(),
1179                           wxSize(at->GetWidth(),at->GetHeight()));
1180     dc->SetPen(*wxGREEN_PEN);
1181     if (before)
1182         dc->DrawRectangle(before->GetAbsPos().x+1, before->GetAbsPos().y+1,
1183                           before->GetWidth()-2,before->GetHeight()-2);
1184     dc->SetPen(*wxRED_PEN);
1185     if (after)
1186         dc->DrawRectangle(after->GetAbsPos().x+2, after->GetAbsPos().y+2,
1187                           after->GetWidth()-4,after->GetHeight()-4);
1188     }
1189 #endif // DEBUG_HTML_SELECTION
1190
1191     if ( dc != &dcPaint )
1192     {
1193         dc->SetDeviceOrigin(0,0);
1194         dcPaint.Blit(0, rect.GetTop(),
1195                      sz.x, rect.GetBottom() - rect.GetTop() + 1,
1196                      dc,
1197                      0, rect.GetTop());
1198     }
1199 }
1200
1201
1202
1203
1204 void wxHtmlWindow::OnSize(wxSizeEvent& event)
1205 {
1206     event.Skip();
1207
1208     m_backBuffer = wxNullBitmap;
1209
1210     CreateLayout();
1211
1212     // Recompute selection if necessary:
1213     if ( m_selection )
1214     {
1215         m_selection->Set(m_selection->GetFromCell(),
1216                          m_selection->GetToCell());
1217         m_selection->ClearPrivPos();
1218     }
1219
1220     Refresh();
1221 }
1222
1223
1224 void wxHtmlWindow::OnMouseMove(wxMouseEvent& WXUNUSED(event))
1225 {
1226     wxHtmlWindowMouseHelper::HandleMouseMoved();
1227 }
1228
1229 void wxHtmlWindow::OnMouseDown(wxMouseEvent& event)
1230 {
1231 #if wxUSE_CLIPBOARD
1232     if ( event.LeftDown() && IsSelectionEnabled() )
1233     {
1234         const long TRIPLECLICK_LEN = 200; // 0.2 sec after doubleclick
1235         if ( wxGetLocalTimeMillis() - m_lastDoubleClick <= TRIPLECLICK_LEN )
1236         {
1237             SelectLine(CalcUnscrolledPosition(event.GetPosition()));
1238
1239             (void) CopySelection();
1240         }
1241         else
1242         {
1243             m_makingSelection = true;
1244
1245             if ( m_selection )
1246             {
1247                 wxDELETE(m_selection);
1248                 Refresh();
1249             }
1250             m_tmpSelFromPos = CalcUnscrolledPosition(event.GetPosition());
1251             m_tmpSelFromCell = NULL;
1252
1253             CaptureMouse();
1254         }
1255     }
1256 #endif // wxUSE_CLIPBOARD
1257
1258     // in any case, let the default handler set focus to this window
1259     event.Skip();
1260 }
1261
1262 void wxHtmlWindow::OnMouseUp(wxMouseEvent& event)
1263 {
1264 #if wxUSE_CLIPBOARD
1265     if ( m_makingSelection )
1266     {
1267         ReleaseMouse();
1268         m_makingSelection = false;
1269
1270         // if m_selection=NULL, the user didn't move the mouse far enough from
1271         // starting point and the mouse up event is part of a click, the user
1272         // is not selecting text:
1273         if ( m_selection )
1274         {
1275             CopySelection(Primary);
1276
1277             // we don't want mouse up event that ended selecting to be
1278             // handled as mouse click and e.g. follow hyperlink:
1279             return;
1280         }
1281     }
1282 #endif // wxUSE_CLIPBOARD
1283
1284     wxPoint pos = CalcUnscrolledPosition(event.GetPosition());
1285     wxHtmlWindowMouseHelper::HandleMouseClick(m_Cell, pos, event);
1286 }
1287
1288 #if wxUSE_CLIPBOARD
1289 void wxHtmlWindow::OnMouseCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
1290 {
1291     if ( !m_makingSelection )
1292         return;
1293
1294     // discard the selecting operation
1295     m_makingSelection = false;
1296     wxDELETE(m_selection);
1297     m_tmpSelFromCell = NULL;
1298     Refresh();
1299 }
1300 #endif // wxUSE_CLIPBOARD
1301
1302
1303 void wxHtmlWindow::OnInternalIdle()
1304 {
1305     wxWindow::OnInternalIdle();
1306
1307     if (m_Cell != NULL && DidMouseMove())
1308     {
1309 #ifdef DEBUG_HTML_SELECTION
1310         Refresh();
1311 #endif
1312         int xc, yc, x, y;
1313         wxGetMousePosition(&xc, &yc);
1314         ScreenToClient(&xc, &yc);
1315         CalcUnscrolledPosition(xc, yc, &x, &y);
1316
1317         wxHtmlCell *cell = m_Cell->FindCellByPos(x, y);
1318
1319         // handle selection update:
1320         if ( m_makingSelection )
1321         {
1322             if ( !m_tmpSelFromCell )
1323                 m_tmpSelFromCell = m_Cell->FindCellByPos(
1324                                          m_tmpSelFromPos.x,m_tmpSelFromPos.y);
1325
1326             // NB: a trick - we adjust selFromPos to be upper left or bottom
1327             //     right corner of the first cell of the selection depending
1328             //     on whether the mouse is moving to the right or to the left.
1329             //     This gives us more "natural" behaviour when selecting
1330             //     a line (specifically, first cell of the next line is not
1331             //     included if you drag selection from left to right over
1332             //     entire line):
1333             wxPoint dirFromPos;
1334             if ( !m_tmpSelFromCell )
1335             {
1336                 dirFromPos = m_tmpSelFromPos;
1337             }
1338             else
1339             {
1340                 dirFromPos = m_tmpSelFromCell->GetAbsPos();
1341                 if ( x < m_tmpSelFromPos.x )
1342                 {
1343                     dirFromPos.x += m_tmpSelFromCell->GetWidth();
1344                     dirFromPos.y += m_tmpSelFromCell->GetHeight();
1345                 }
1346             }
1347             bool goingDown = dirFromPos.y < y ||
1348                              (dirFromPos.y == y && dirFromPos.x < x);
1349
1350             // determine selection span:
1351             if ( /*still*/ !m_tmpSelFromCell )
1352             {
1353                 if (goingDown)
1354                 {
1355                     m_tmpSelFromCell = m_Cell->FindCellByPos(
1356                                          m_tmpSelFromPos.x,m_tmpSelFromPos.y,
1357                                          wxHTML_FIND_NEAREST_AFTER);
1358                     if (!m_tmpSelFromCell)
1359                         m_tmpSelFromCell = m_Cell->GetFirstTerminal();
1360                 }
1361                 else
1362                 {
1363                     m_tmpSelFromCell = m_Cell->FindCellByPos(
1364                                          m_tmpSelFromPos.x,m_tmpSelFromPos.y,
1365                                          wxHTML_FIND_NEAREST_BEFORE);
1366                     if (!m_tmpSelFromCell)
1367                         m_tmpSelFromCell = m_Cell->GetLastTerminal();
1368                 }
1369             }
1370
1371             wxHtmlCell *selcell = cell;
1372             if (!selcell)
1373             {
1374                 if (goingDown)
1375                 {
1376                     selcell = m_Cell->FindCellByPos(x, y,
1377                                                  wxHTML_FIND_NEAREST_BEFORE);
1378                     if (!selcell)
1379                         selcell = m_Cell->GetLastTerminal();
1380                 }
1381                 else
1382                 {
1383                     selcell = m_Cell->FindCellByPos(x, y,
1384                                                  wxHTML_FIND_NEAREST_AFTER);
1385                     if (!selcell)
1386                         selcell = m_Cell->GetFirstTerminal();
1387                 }
1388             }
1389
1390             // NB: it may *rarely* happen that the code above didn't find one
1391             //     of the cells, e.g. if wxHtmlWindow doesn't contain any
1392             //     visible cells.
1393             if ( selcell && m_tmpSelFromCell )
1394             {
1395                 if ( !m_selection )
1396                 {
1397                     // start selecting only if mouse movement was big enough
1398                     // (otherwise it was meant as mouse click, not selection):
1399                     const int PRECISION = 2;
1400                     wxPoint diff = m_tmpSelFromPos - wxPoint(x,y);
1401                     if (abs(diff.x) > PRECISION || abs(diff.y) > PRECISION)
1402                     {
1403                         m_selection = new wxHtmlSelection();
1404                     }
1405                 }
1406                 if ( m_selection )
1407                 {
1408                     if ( m_tmpSelFromCell->IsBefore(selcell) )
1409                     {
1410                         m_selection->Set(m_tmpSelFromPos, m_tmpSelFromCell,
1411                                          wxPoint(x,y), selcell);
1412                     }
1413                     else
1414                     {
1415                         m_selection->Set(wxPoint(x,y), selcell,
1416                                          m_tmpSelFromPos, m_tmpSelFromCell);
1417                     }
1418                     m_selection->ClearPrivPos();
1419                     Refresh();
1420                 }
1421             }
1422         }
1423
1424         // handle cursor and status bar text changes:
1425
1426         // NB: because we're passing in 'cell' and not 'm_Cell' (so that the
1427         //     leaf cell lookup isn't done twice), we need to adjust the
1428         //     position for the new root:
1429         wxPoint posInCell(x, y);
1430         if (cell)
1431             posInCell -= cell->GetAbsPos();
1432         wxHtmlWindowMouseHelper::HandleIdle(cell, posInCell);
1433     }
1434 }
1435
1436 #if wxUSE_CLIPBOARD
1437 void wxHtmlWindow::StopAutoScrolling()
1438 {
1439     if ( m_timerAutoScroll )
1440     {
1441         wxDELETE(m_timerAutoScroll);
1442     }
1443 }
1444
1445 void wxHtmlWindow::OnMouseEnter(wxMouseEvent& event)
1446 {
1447     StopAutoScrolling();
1448     event.Skip();
1449 }
1450
1451 void wxHtmlWindow::OnMouseLeave(wxMouseEvent& event)
1452 {
1453     // don't prevent the usual processing of the event from taking place
1454     event.Skip();
1455
1456     // when a captured mouse leave a scrolled window we start generate
1457     // scrolling events to allow, for example, extending selection beyond the
1458     // visible area in some controls
1459     if ( wxWindow::GetCapture() == this )
1460     {
1461         // where is the mouse leaving?
1462         int pos, orient;
1463         wxPoint pt = event.GetPosition();
1464         if ( pt.x < 0 )
1465         {
1466             orient = wxHORIZONTAL;
1467             pos = 0;
1468         }
1469         else if ( pt.y < 0 )
1470         {
1471             orient = wxVERTICAL;
1472             pos = 0;
1473         }
1474         else // we're lower or to the right of the window
1475         {
1476             wxSize size = GetClientSize();
1477             if ( pt.x > size.x )
1478             {
1479                 orient = wxHORIZONTAL;
1480                 pos = GetVirtualSize().x / wxHTML_SCROLL_STEP;
1481             }
1482             else if ( pt.y > size.y )
1483             {
1484                 orient = wxVERTICAL;
1485                 pos = GetVirtualSize().y / wxHTML_SCROLL_STEP;
1486             }
1487             else // this should be impossible
1488             {
1489                 // but seems to happen sometimes under wxMSW - maybe it's a bug
1490                 // there but for now just ignore it
1491
1492                 //wxFAIL_MSG( wxT("can't understand where has mouse gone") );
1493
1494                 return;
1495             }
1496         }
1497
1498         // only start the auto scroll timer if the window can be scrolled in
1499         // this direction
1500         if ( !HasScrollbar(orient) )
1501             return;
1502
1503         delete m_timerAutoScroll;
1504         m_timerAutoScroll = new wxHtmlWinAutoScrollTimer
1505                                 (
1506                                     this,
1507                                     pos == 0 ? wxEVT_SCROLLWIN_LINEUP
1508                                              : wxEVT_SCROLLWIN_LINEDOWN,
1509                                     pos,
1510                                     orient
1511                                 );
1512         m_timerAutoScroll->Start(50); // FIXME: make configurable
1513     }
1514 }
1515
1516 void wxHtmlWindow::OnKeyUp(wxKeyEvent& event)
1517 {
1518     if ( IsSelectionEnabled() &&
1519             (event.GetKeyCode() == 'C' && event.CmdDown()) )
1520     {
1521         wxClipboardTextEvent evt(wxEVT_COMMAND_TEXT_COPY, GetId());
1522
1523         evt.SetEventObject(this);
1524
1525         GetEventHandler()->ProcessEvent(evt);
1526     }
1527 }
1528
1529 void wxHtmlWindow::OnCopy(wxCommandEvent& WXUNUSED(event))
1530 {
1531     (void) CopySelection();
1532 }
1533
1534 void wxHtmlWindow::OnClipboardEvent(wxClipboardTextEvent& WXUNUSED(event))
1535 {
1536     (void) CopySelection();
1537 }
1538
1539 void wxHtmlWindow::OnDoubleClick(wxMouseEvent& event)
1540 {
1541     // select word under cursor:
1542     if ( IsSelectionEnabled() )
1543     {
1544         SelectWord(CalcUnscrolledPosition(event.GetPosition()));
1545
1546         (void) CopySelection(Primary);
1547
1548         m_lastDoubleClick = wxGetLocalTimeMillis();
1549     }
1550     else
1551         event.Skip();
1552 }
1553
1554 void wxHtmlWindow::SelectWord(const wxPoint& pos)
1555 {
1556     if ( m_Cell )
1557     {
1558         wxHtmlCell *cell = m_Cell->FindCellByPos(pos.x, pos.y);
1559         if ( cell )
1560         {
1561             delete m_selection;
1562             m_selection = new wxHtmlSelection();
1563             m_selection->Set(cell, cell);
1564             RefreshRect(wxRect(CalcScrolledPosition(cell->GetAbsPos()),
1565                                wxSize(cell->GetWidth(), cell->GetHeight())));
1566         }
1567     }
1568 }
1569
1570 void wxHtmlWindow::SelectLine(const wxPoint& pos)
1571 {
1572     if ( m_Cell )
1573     {
1574         wxHtmlCell *cell = m_Cell->FindCellByPos(pos.x, pos.y);
1575         if ( cell )
1576         {
1577             // We use following heuristic to find a "line": let the line be all
1578             // cells in same container as the cell under mouse cursor that are
1579             // neither completely above nor completely bellow the clicked cell
1580             // (i.e. are likely to be words positioned on same line of text).
1581
1582             int y1 = cell->GetAbsPos().y;
1583             int y2 = y1 + cell->GetHeight();
1584             int y;
1585             const wxHtmlCell *c;
1586             const wxHtmlCell *before = NULL;
1587             const wxHtmlCell *after = NULL;
1588
1589             // find last cell of line:
1590             for ( c = cell->GetNext(); c; c = c->GetNext())
1591             {
1592                 y = c->GetAbsPos().y;
1593                 if ( y + c->GetHeight() > y1 && y < y2 )
1594                     after = c;
1595                 else
1596                     break;
1597             }
1598             if ( !after )
1599                 after = cell;
1600
1601             // find first cell of line:
1602             for ( c = cell->GetParent()->GetFirstChild();
1603                     c && c != cell; c = c->GetNext())
1604             {
1605                 y = c->GetAbsPos().y;
1606                 if ( y + c->GetHeight() > y1 && y < y2 )
1607                 {
1608                     if ( ! before )
1609                         before = c;
1610                 }
1611                 else
1612                     before = NULL;
1613             }
1614             if ( !before )
1615                 before = cell;
1616
1617             delete m_selection;
1618             m_selection = new wxHtmlSelection();
1619             m_selection->Set(before, after);
1620
1621             Refresh();
1622         }
1623     }
1624 }
1625
1626 void wxHtmlWindow::SelectAll()
1627 {
1628     if ( m_Cell )
1629     {
1630         delete m_selection;
1631         m_selection = new wxHtmlSelection();
1632         m_selection->Set(m_Cell->GetFirstTerminal(), m_Cell->GetLastTerminal());
1633         Refresh();
1634     }
1635 }
1636
1637 #endif // wxUSE_CLIPBOARD
1638
1639
1640
1641 IMPLEMENT_ABSTRACT_CLASS(wxHtmlProcessor,wxObject)
1642
1643 #if wxUSE_EXTENDED_RTTI
1644 IMPLEMENT_DYNAMIC_CLASS_XTI(wxHtmlWindow, wxScrolledWindow,"wx/html/htmlwin.h")
1645
1646 wxBEGIN_PROPERTIES_TABLE(wxHtmlWindow)
1647 /*
1648     TODO PROPERTIES
1649         style , wxHW_SCROLLBAR_AUTO
1650         borders , (dimension)
1651         url , string
1652         htmlcode , string
1653 */
1654 wxEND_PROPERTIES_TABLE()
1655
1656 wxBEGIN_HANDLERS_TABLE(wxHtmlWindow)
1657 wxEND_HANDLERS_TABLE()
1658
1659 wxCONSTRUCTOR_5( wxHtmlWindow , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle )
1660 #else
1661 IMPLEMENT_DYNAMIC_CLASS(wxHtmlWindow,wxScrolledWindow)
1662 #endif
1663
1664 BEGIN_EVENT_TABLE(wxHtmlWindow, wxScrolledWindow)
1665     EVT_SIZE(wxHtmlWindow::OnSize)
1666     EVT_LEFT_DOWN(wxHtmlWindow::OnMouseDown)
1667     EVT_LEFT_UP(wxHtmlWindow::OnMouseUp)
1668     EVT_RIGHT_UP(wxHtmlWindow::OnMouseUp)
1669     EVT_MOTION(wxHtmlWindow::OnMouseMove)
1670     EVT_PAINT(wxHtmlWindow::OnPaint)
1671 #if wxUSE_CLIPBOARD
1672     EVT_LEFT_DCLICK(wxHtmlWindow::OnDoubleClick)
1673     EVT_ENTER_WINDOW(wxHtmlWindow::OnMouseEnter)
1674     EVT_LEAVE_WINDOW(wxHtmlWindow::OnMouseLeave)
1675     EVT_MOUSE_CAPTURE_LOST(wxHtmlWindow::OnMouseCaptureLost)
1676     EVT_KEY_UP(wxHtmlWindow::OnKeyUp)
1677     EVT_MENU(wxID_COPY, wxHtmlWindow::OnCopy)
1678     EVT_TEXT_COPY(wxID_ANY, wxHtmlWindow::OnClipboardEvent)
1679 #endif // wxUSE_CLIPBOARD
1680 END_EVENT_TABLE()
1681
1682 //-----------------------------------------------------------------------------
1683 // wxHtmlWindowInterface implementation in wxHtmlWindow
1684 //-----------------------------------------------------------------------------
1685
1686 void wxHtmlWindow::SetHTMLWindowTitle(const wxString& title)
1687 {
1688     OnSetTitle(title);
1689 }
1690
1691 void wxHtmlWindow::OnHTMLLinkClicked(const wxHtmlLinkInfo& link)
1692 {
1693     OnLinkClicked(link);
1694 }
1695
1696 wxHtmlOpeningStatus wxHtmlWindow::OnHTMLOpeningURL(wxHtmlURLType type,
1697                                                    const wxString& url,
1698                                                    wxString *redirect) const
1699 {
1700     return OnOpeningURL(type, url, redirect);
1701 }
1702
1703 wxPoint wxHtmlWindow::HTMLCoordsToWindow(wxHtmlCell *WXUNUSED(cell),
1704                                          const wxPoint& pos) const
1705 {
1706     return CalcScrolledPosition(pos);
1707 }
1708
1709 wxWindow* wxHtmlWindow::GetHTMLWindow()
1710 {
1711     return this;
1712 }
1713
1714 wxColour wxHtmlWindow::GetHTMLBackgroundColour() const
1715 {
1716     return GetBackgroundColour();
1717 }
1718
1719 void wxHtmlWindow::SetHTMLBackgroundColour(const wxColour& clr)
1720 {
1721     SetBackgroundColour(clr);
1722 }
1723
1724 void wxHtmlWindow::SetHTMLBackgroundImage(const wxBitmap& bmpBg)
1725 {
1726     SetBackgroundImage(bmpBg);
1727 }
1728
1729 void wxHtmlWindow::SetHTMLStatusText(const wxString& text)
1730 {
1731 #if wxUSE_STATUSBAR
1732     if (m_RelatedStatusBarIndex != -1)
1733     {
1734         if (m_RelatedStatusBar)
1735         {
1736             m_RelatedStatusBar->SetStatusText(text, m_RelatedStatusBarIndex);
1737         }
1738         else if (m_RelatedFrame)
1739         {
1740             m_RelatedFrame->SetStatusText(text, m_RelatedStatusBarIndex);
1741         }
1742     }
1743 #else
1744     wxUnusedVar(text);
1745 #endif // wxUSE_STATUSBAR
1746 }
1747
1748 /*static*/
1749 wxCursor wxHtmlWindow::GetDefaultHTMLCursor(HTMLCursor type)
1750 {
1751     switch (type)
1752     {
1753         case HTMLCursor_Link:
1754             if ( !ms_cursorLink )
1755                 ms_cursorLink = new wxCursor(wxCURSOR_HAND);
1756             return *ms_cursorLink;
1757
1758         case HTMLCursor_Text:
1759             if ( !ms_cursorText )
1760                 ms_cursorText = new wxCursor(wxCURSOR_IBEAM);
1761             return *ms_cursorText;
1762
1763         case HTMLCursor_Default:
1764         default:
1765             return *wxSTANDARD_CURSOR;
1766     }
1767 }
1768
1769 wxCursor wxHtmlWindow::GetHTMLCursor(HTMLCursor type) const
1770 {
1771     return GetDefaultHTMLCursor(type);
1772 }
1773
1774
1775 //-----------------------------------------------------------------------------
1776 // wxHtmlWinModule
1777 //-----------------------------------------------------------------------------
1778
1779 // A module to allow initialization/cleanup
1780 // without calling these functions from app.cpp or from
1781 // the user's application.
1782
1783 class wxHtmlWinModule: public wxModule
1784 {
1785 DECLARE_DYNAMIC_CLASS(wxHtmlWinModule)
1786 public:
1787     wxHtmlWinModule() : wxModule() {}
1788     bool OnInit() { return true; }
1789     void OnExit() { wxHtmlWindow::CleanUpStatics(); }
1790 };
1791
1792 IMPLEMENT_DYNAMIC_CLASS(wxHtmlWinModule, wxModule)
1793
1794
1795 // This hack forces the linker to always link in m_* files
1796 // (wxHTML doesn't work without handlers from these files)
1797 #include "wx/html/forcelnk.h"
1798 FORCE_WXHTML_MODULES()
1799
1800 #endif // wxUSE_HTML