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