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