src/generic/htmllbox.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        generic/htmllbox.cpp
   3 // Purpose:     implementation of wxHtmlListBox
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     31.05.03
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2003 Vadim Zeitlin <vadim@wxwindows.org>
   9 // License:     wxWindows license
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/dcclient.h"
  29 #endif //WX_PRECOMP
  30
  31 #if wxUSE_HTML
  32
  33 #include "wx/htmllbox.h"
  34
  35 #include "wx/html/htmlcell.h"
  36 #include "wx/html/winpars.h"
  37
  38 // this hack forces the linker to always link in m_* files
  39 #include "wx/html/forcelnk.h"
  40 FORCE_WXHTML_MODULES()
  41
  42 // ----------------------------------------------------------------------------
  43 // constants
  44 // ----------------------------------------------------------------------------
  45
  46 // small border always added to the cells:
  47 static const wxCoord CELL_BORDER = 2;
  48
  49 const wxChar wxHtmlListBoxNameStr[] = wxT("htmlListBox");
  50 const wxChar wxSimpleHtmlListBoxNameStr[] = wxT("simpleHtmlListBox");
  51
  52 // ============================================================================
  53 // private classes
  54 // ============================================================================
  55
  56 // ----------------------------------------------------------------------------
  57 // wxHtmlListBoxCache
  58 // ----------------------------------------------------------------------------
  59
  60 // this class is used by wxHtmlListBox to cache the parsed representation of
  61 // the items to avoid doing it anew each time an item must be drawn
  62 class wxHtmlListBoxCache
  63 {
  64 private:
  65     // invalidate a single item, used by Clear() and InvalidateRange()
  66     void InvalidateItem(size_t n)
  67     {
  68         m_items[n] = (size_t)-1;
  69         delete m_cells[n];
  70         m_cells[n] = NULL;
  71     }
  72
  73 public:
  74     wxHtmlListBoxCache()
  75     {
  76         for ( size_t n = 0; n < SIZE; n++ )
  77         {
  78             m_items[n] = (size_t)-1;
  79             m_cells[n] = NULL;
  80         }
  81
  82         m_next = 0;
  83     }
  84
  85     ~wxHtmlListBoxCache()
  86     {
  87         for ( size_t n = 0; n < SIZE; n++ )
  88         {
  89             delete m_cells[n];
  90         }
  91     }
  92
  93     // completely invalidate the cache
  94     void Clear()
  95     {
  96         for ( size_t n = 0; n < SIZE; n++ )
  97         {
  98             InvalidateItem(n);
  99         }
 100     }
 101
 102     // return the cached cell for this index or NULL if none
 103     wxHtmlCell *Get(size_t item) const
 104     {
 105         for ( size_t n = 0; n < SIZE; n++ )
 106         {
 107             if ( m_items[n] == item )
 108                 return m_cells[n];
 109         }
 110
 111         return NULL;
 112     }
 113
 114     // returns true if we already have this item cached
 115     bool Has(size_t item) const { return Get(item) != NULL; }
 116
 117     // ensure that the item is cached
 118     void Store(size_t item, wxHtmlCell *cell)
 119     {
 120         delete m_cells[m_next];
 121         m_cells[m_next] = cell;
 122         m_items[m_next] = item;
 123
 124         // advance to the next item wrapping around if there are no more
 125         if ( ++m_next == SIZE )
 126             m_next = 0;
 127     }
 128
 129     // forget the cached value of the item(s) between the given ones (inclusive)
 130     void InvalidateRange(size_t from, size_t to)
 131     {
 132         for ( size_t n = 0; n < SIZE; n++ )
 133         {
 134             if ( m_items[n] >= from && m_items[n] <= to )
 135             {
 136                 InvalidateItem(n);
 137             }
 138         }
 139     }
 140
 141 private:
 142     // the max number of the items we cache
 143     enum { SIZE = 50 };
 144
 145     // the index of the LRU (oldest) cell
 146     size_t m_next;
 147
 148     // the parsed representation of the cached item or NULL
 149     wxHtmlCell *m_cells[SIZE];
 150
 151     // the index of the currently cached item (only valid if m_cells != NULL)
 152     size_t m_items[SIZE];
 153 };
 154
 155 // ----------------------------------------------------------------------------
 156 // wxHtmlListBoxStyle
 157 // ----------------------------------------------------------------------------
 158
 159 // just forward wxDefaultHtmlRenderingStyle callbacks to the main class so that
 160 // they could be overridden by the user code
 161 class wxHtmlListBoxStyle : public wxDefaultHtmlRenderingStyle
 162 {
 163 public:
 164     wxHtmlListBoxStyle(const wxHtmlListBox& hlbox) : m_hlbox(hlbox) { }
 165
 166     virtual wxColour GetSelectedTextColour(const wxColour& colFg)
 167     {
 168         return m_hlbox.GetSelectedTextColour(colFg);
 169     }
 170
 171     virtual wxColour GetSelectedTextBgColour(const wxColour& colBg)
 172     {
 173         return m_hlbox.GetSelectedTextBgColour(colBg);
 174     }
 175
 176 private:
 177     const wxHtmlListBox& m_hlbox;
 178
 179     DECLARE_NO_COPY_CLASS(wxHtmlListBoxStyle)
 180 };
 181
 182 // ----------------------------------------------------------------------------
 183 // event tables
 184 // ----------------------------------------------------------------------------
 185
 186 BEGIN_EVENT_TABLE(wxHtmlListBox, wxVListBox)
 187     EVT_SIZE(wxHtmlListBox::OnSize)
 188     EVT_MOTION(wxHtmlListBox::OnMouseMove)
 189     EVT_LEFT_DOWN(wxHtmlListBox::OnLeftDown)
 190 END_EVENT_TABLE()
 191
 192 // ============================================================================
 193 // implementation
 194 // ============================================================================
 195
 196 IMPLEMENT_ABSTRACT_CLASS(wxHtmlListBox, wxVListBox)
 197
 198
 199 // ----------------------------------------------------------------------------
 200 // wxHtmlListBox creation
 201 // ----------------------------------------------------------------------------
 202
 203 wxHtmlListBox::wxHtmlListBox()
 204     : wxHtmlWindowMouseHelper(this)
 205 {
 206     Init();
 207 }
 208
 209 // normal constructor which calls Create() internally
 210 wxHtmlListBox::wxHtmlListBox(wxWindow *parent,
 211                              wxWindowID id,
 212                              const wxPoint& pos,
 213                              const wxSize& size,
 214                              long style,
 215                              const wxString& name)
 216     : wxHtmlWindowMouseHelper(this)
 217 {
 218     Init();
 219
 220     (void)Create(parent, id, pos, size, style, name);
 221 }
 222
 223 void wxHtmlListBox::Init()
 224 {
 225     m_htmlParser = NULL;
 226     m_htmlRendStyle = new wxHtmlListBoxStyle(*this);
 227     m_cache = new wxHtmlListBoxCache;
 228 }
 229
 230 bool wxHtmlListBox::Create(wxWindow *parent,
 231                            wxWindowID id,
 232                            const wxPoint& pos,
 233                            const wxSize& size,
 234                            long style,
 235                            const wxString& name)
 236 {
 237     return wxVListBox::Create(parent, id, pos, size, style, name);
 238 }
 239
 240 wxHtmlListBox::~wxHtmlListBox()
 241 {
 242     delete m_cache;
 243
 244     if ( m_htmlParser )
 245     {
 246         delete m_htmlParser->GetDC();
 247         delete m_htmlParser;
 248     }
 249
 250     delete m_htmlRendStyle;
 251 }
 252
 253 // ----------------------------------------------------------------------------
 254 // wxHtmlListBox appearance
 255 // ----------------------------------------------------------------------------
 256
 257 wxColour wxHtmlListBox::GetSelectedTextColour(const wxColour& colFg) const
 258 {
 259     return m_htmlRendStyle->
 260                 wxDefaultHtmlRenderingStyle::GetSelectedTextColour(colFg);
 261 }
 262
 263 wxColour
 264 wxHtmlListBox::GetSelectedTextBgColour(const wxColour& WXUNUSED(colBg)) const
 265 {
 266     return GetSelectionBackground();
 267 }
 268
 269 // ----------------------------------------------------------------------------
 270 // wxHtmlListBox items markup
 271 // ----------------------------------------------------------------------------
 272
 273 wxString wxHtmlListBox::OnGetItemMarkup(size_t n) const
 274 {
 275     // we don't even need to wrap the value returned by OnGetItem() inside
 276     // "<html><body>" and "</body></html>" because wxHTML can parse it even
 277     // without these tags
 278     return OnGetItem(n);
 279 }
 280
 281 // ----------------------------------------------------------------------------
 282 // wxHtmlListBox cache handling
 283 // ----------------------------------------------------------------------------
 284
 285 void wxHtmlListBox::CacheItem(size_t n) const
 286 {
 287     if ( !m_cache->Has(n) )
 288     {
 289         if ( !m_htmlParser )
 290         {
 291             wxHtmlListBox *self = wxConstCast(this, wxHtmlListBox);
 292
 293             self->m_htmlParser = new wxHtmlWinParser(self);
 294             m_htmlParser->SetDC(new wxClientDC(self));
 295             m_htmlParser->SetFS(&self->m_filesystem);
 296 #if !wxUSE_UNICODE
 297             if (GetFont().Ok())
 298                 m_htmlParser->SetInputEncoding(GetFont().GetEncoding());
 299 #endif
 300             // use system's default GUI font by default:
 301             m_htmlParser->SetStandardFonts();
 302         }
 303
 304         wxHtmlContainerCell *cell = (wxHtmlContainerCell *)m_htmlParser->
 305                 Parse(OnGetItemMarkup(n));
 306         wxCHECK_RET( cell, _T("wxHtmlParser::Parse() returned NULL?") );
 307
 308         // set the cell's ID to item's index so that CellCoordsToPhysical()
 309         // can quickly find the item:
 310         cell->SetId(wxString::Format(_T("%lu"), (unsigned long)n));
 311
 312         cell->Layout(GetClientSize().x - 2*GetMargins().x);
 313
 314         m_cache->Store(n, cell);
 315     }
 316 }
 317
 318 void wxHtmlListBox::OnSize(wxSizeEvent& event)
 319 {
 320     // we need to relayout all the cached cells
 321     m_cache->Clear();
 322
 323     event.Skip();
 324 }
 325
 326 void wxHtmlListBox::RefreshRow(size_t line)
 327 {
 328     m_cache->InvalidateRange(line, line);
 329
 330     wxVListBox::RefreshRow(line);
 331 }
 332
 333 void wxHtmlListBox::RefreshRows(size_t from, size_t to)
 334 {
 335     m_cache->InvalidateRange(from, to);
 336
 337     wxVListBox::RefreshRows(from, to);
 338 }
 339
 340 void wxHtmlListBox::RefreshAll()
 341 {
 342     m_cache->Clear();
 343
 344     wxVListBox::RefreshAll();
 345 }
 346
 347 void wxHtmlListBox::SetItemCount(size_t count)
 348 {
 349     // the items are going to change, forget the old ones
 350     m_cache->Clear();
 351
 352     wxVListBox::SetItemCount(count);
 353 }
 354
 355 // ----------------------------------------------------------------------------
 356 // wxHtmlListBox implementation of wxVListBox pure virtuals
 357 // ----------------------------------------------------------------------------
 358
 359 void wxHtmlListBox::OnDrawItem(wxDC& dc, const wxRect& rect, size_t n) const
 360 {
 361     CacheItem(n);
 362
 363     wxHtmlCell *cell = m_cache->Get(n);
 364     wxCHECK_RET( cell, _T("this cell should be cached!") );
 365
 366     wxHtmlRenderingInfo htmlRendInfo;
 367
 368     // note that we can't stop drawing exactly at the window boundary as then
 369     // even the visible cells part could be not drawn, so always draw the
 370     // entire cell
 371     cell->Draw(dc,
 372                rect.x + CELL_BORDER, rect.y + CELL_BORDER,
 373                0, INT_MAX, htmlRendInfo);
 374 }
 375
 376 wxCoord wxHtmlListBox::OnMeasureItem(size_t n) const
 377 {
 378     CacheItem(n);
 379
 380     wxHtmlCell *cell = m_cache->Get(n);
 381     wxCHECK_MSG( cell, 0, _T("this cell should be cached!") );
 382
 383     return cell->GetHeight() + cell->GetDescent() + 4;
 384 }
 385
 386 // ----------------------------------------------------------------------------
 387 // wxHtmlListBox implementation of wxHtmlListBoxWinInterface
 388 // ----------------------------------------------------------------------------
 389
 390 void wxHtmlListBox::SetHTMLWindowTitle(const wxString& WXUNUSED(title))
 391 {
 392     // nothing to do
 393 }
 394
 395 void wxHtmlListBox::OnHTMLLinkClicked(const wxHtmlLinkInfo& link)
 396 {
 397     OnLinkClicked(GetItemForCell(link.GetHtmlCell()), link);
 398 }
 399
 400 void wxHtmlListBox::OnLinkClicked(size_t WXUNUSED(n),
 401                                   const wxHtmlLinkInfo& link)
 402 {
 403     wxHtmlLinkEvent event(GetId(), link);
 404     GetEventHandler()->ProcessEvent(event);
 405 }
 406
 407 wxHtmlOpeningStatus
 408 wxHtmlListBox::OnHTMLOpeningURL(wxHtmlURLType WXUNUSED(type),
 409                                 const wxString& WXUNUSED(url),
 410                                 wxString *WXUNUSED(redirect)) const
 411 {
 412     return wxHTML_OPEN;
 413 }
 414
 415 wxPoint wxHtmlListBox::HTMLCoordsToWindow(wxHtmlCell *cell,
 416                                           const wxPoint& pos) const
 417 {
 418     return CellCoordsToPhysical(pos, cell);
 419 }
 420
 421 wxWindow* wxHtmlListBox::GetHTMLWindow() { return this; }
 422
 423 wxColour wxHtmlListBox::GetHTMLBackgroundColour() const
 424 {
 425     return GetBackgroundColour();
 426 }
 427
 428 void wxHtmlListBox::SetHTMLBackgroundColour(const wxColour& WXUNUSED(clr))
 429 {
 430     // nothing to do
 431 }
 432
 433 void wxHtmlListBox::SetHTMLBackgroundImage(const wxBitmap& WXUNUSED(bmpBg))
 434 {
 435     // nothing to do
 436 }
 437
 438 void wxHtmlListBox::SetHTMLStatusText(const wxString& WXUNUSED(text))
 439 {
 440     // nothing to do
 441 }
 442
 443 wxCursor wxHtmlListBox::GetHTMLCursor(HTMLCursor type) const
 444 {
 445     // we don't want to show text selection cursor in listboxes
 446     if (type == HTMLCursor_Text)
 447         return wxHtmlWindow::GetDefaultHTMLCursor(HTMLCursor_Default);
 448
 449     // in all other cases, use the same cursor as wxHtmlWindow:
 450     return wxHtmlWindow::GetDefaultHTMLCursor(type);
 451 }
 452
 453 // ----------------------------------------------------------------------------
 454 // wxHtmlListBox handling of HTML links
 455 // ----------------------------------------------------------------------------
 456
 457 wxPoint wxHtmlListBox::GetRootCellCoords(size_t n) const
 458 {
 459     wxPoint pos(CELL_BORDER, CELL_BORDER);
 460     pos += GetMargins();
 461     pos.y += GetRowsHeight(GetVisibleBegin(), n);
 462     return pos;
 463 }
 464
 465 bool wxHtmlListBox::PhysicalCoordsToCell(wxPoint& pos, wxHtmlCell*& cell) const
 466 {
 467     int n = HitTest(pos);
 468     if ( n == wxNOT_FOUND )
 469         return false;
 470
 471     // convert mouse coordinates to coords relative to item's wxHtmlCell:
 472     pos -= GetRootCellCoords(n);
 473
 474     CacheItem(n);
 475     cell = m_cache->Get(n);
 476
 477     return true;
 478 }
 479
 480 size_t wxHtmlListBox::GetItemForCell(const wxHtmlCell *cell) const
 481 {
 482     wxCHECK_MSG( cell, 0, _T("no cell") );
 483
 484     cell = cell->GetRootCell();
 485
 486     wxCHECK_MSG( cell, 0, _T("no root cell") );
 487
 488     // the cell's ID contains item index, see CacheItem():
 489     unsigned long n;
 490     if ( !cell->GetId().ToULong(&n) )
 491     {
 492         wxFAIL_MSG( _T("unexpected root cell's ID") );
 493         return 0;
 494     }
 495
 496     return n;
 497 }
 498
 499 wxPoint
 500 wxHtmlListBox::CellCoordsToPhysical(const wxPoint& pos, wxHtmlCell *cell) const
 501 {
 502     return pos + GetRootCellCoords(GetItemForCell(cell));
 503 }
 504
 505 void wxHtmlListBox::OnInternalIdle()
 506 {
 507     wxVListBox::OnInternalIdle();
 508
 509     if ( wxHtmlWindowMouseHelper::DidMouseMove() )
 510     {
 511         wxPoint pos = ScreenToClient(wxGetMousePosition());
 512         wxHtmlCell *cell;
 513
 514         if ( !PhysicalCoordsToCell(pos, cell) )
 515             return;
 516
 517         wxHtmlWindowMouseHelper::HandleIdle(cell, pos);
 518     }
 519 }
 520
 521 void wxHtmlListBox::OnMouseMove(wxMouseEvent& event)
 522 {
 523     wxHtmlWindowMouseHelper::HandleMouseMoved();
 524     event.Skip();
 525 }
 526
 527 void wxHtmlListBox::OnLeftDown(wxMouseEvent& event)
 528 {
 529     wxPoint pos = event.GetPosition();
 530     wxHtmlCell *cell;
 531
 532     if ( !PhysicalCoordsToCell(pos, cell) )
 533     {
 534         event.Skip();
 535         return;
 536     }
 537
 538     if ( !wxHtmlWindowMouseHelper::HandleMouseClick(cell, pos, event) )
 539     {
 540         // no link was clicked, so let the listbox code handle the click (e.g.
 541         // by selecting another item in the list):
 542         event.Skip();
 543     }
 544 }
 545
 546
 547 // ----------------------------------------------------------------------------
 548 // wxSimpleHtmlListBox
 549 // ----------------------------------------------------------------------------
 550
 551 bool wxSimpleHtmlListBox::Create(wxWindow *parent, wxWindowID id,
 552                                  const wxPoint& pos,
 553                                  const wxSize& size,
 554                                  int n, const wxString choices[],
 555                                  long style,
 556                                  const wxValidator& validator,
 557                                  const wxString& name)
 558 {
 559     if (!wxHtmlListBox::Create(parent, id, pos, size, style, name))
 560         return false;
 561
 562 #if wxUSE_VALIDATORS
 563     SetValidator(validator);
 564 #endif
 565
 566     Append(n, choices);
 567
 568     return true;
 569 }
 570
 571 bool wxSimpleHtmlListBox::Create(wxWindow *parent, wxWindowID id,
 572                                  const wxPoint& pos,
 573                                  const wxSize& size,
 574                                  const wxArrayString& choices,
 575                                  long style,
 576                                  const wxValidator& validator,
 577                                  const wxString& name)
 578 {
 579     if (!wxHtmlListBox::Create(parent, id, pos, size, style, name))
 580         return false;
 581
 582 #if wxUSE_VALIDATORS
 583     SetValidator(validator);
 584 #endif
 585
 586     Append(choices);
 587
 588     return true;
 589 }
 590
 591 wxSimpleHtmlListBox::~wxSimpleHtmlListBox()
 592 {
 593     wxItemContainer::Clear();
 594 }
 595
 596 void wxSimpleHtmlListBox::DoClear()
 597 {
 598     wxASSERT(m_items.GetCount() == m_HTMLclientData.GetCount());
 599
 600     m_items.Clear();
 601     m_HTMLclientData.Clear();
 602
 603     UpdateCount();
 604 }
 605
 606 void wxSimpleHtmlListBox::DoDeleteOneItem(unsigned int n)
 607 {
 608     m_items.RemoveAt(n);
 609
 610     m_HTMLclientData.RemoveAt(n);
 611
 612     UpdateCount();
 613 }
 614
 615 int wxSimpleHtmlListBox::DoInsertItems(const wxArrayStringsAdapter& items,
 616                                        unsigned int pos,
 617                                        void **clientData,
 618                                        wxClientDataType type)
 619 {
 620     const unsigned int count = items.GetCount();
 621
 622     m_items.Insert(wxEmptyString, pos, count);
 623     m_HTMLclientData.Insert(NULL, pos, count);
 624
 625     for ( unsigned int i = 0; i < count; ++i, ++pos )
 626     {
 627         m_items[pos] = items[i];
 628         AssignNewItemClientData(pos, clientData, i, type);
 629     }
 630
 631     UpdateCount();
 632
 633     return pos;
 634 }
 635
 636 void wxSimpleHtmlListBox::SetString(unsigned int n, const wxString& s)
 637 {
 638     wxCHECK_RET( IsValid(n),
 639                  wxT("invalid index in wxSimpleHtmlListBox::SetString") );
 640
 641     m_items[n]=s;
 642     RefreshRow(n);
 643 }
 644
 645 wxString wxSimpleHtmlListBox::GetString(unsigned int n) const
 646 {
 647     wxCHECK_MSG( IsValid(n), wxEmptyString,
 648                  wxT("invalid index in wxSimpleHtmlListBox::GetString") );
 649
 650     return m_items[n];
 651 }
 652
 653 void wxSimpleHtmlListBox::UpdateCount()
 654 {
 655     wxASSERT(m_items.GetCount() == m_HTMLclientData.GetCount());
 656     wxHtmlListBox::SetItemCount(m_items.GetCount());
 657
 658     // very small optimization: if you need to add lot of items to
 659     // a wxSimpleHtmlListBox be sure to use the
 660     // wxSimpleHtmlListBox::Append(const wxArrayString&) method instead!
 661     if (!this->IsFrozen())
 662         RefreshAll();
 663 }
 664
 665 #endif // wxUSE_HTML