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
 297             // use system's default GUI font by default:
 298             m_htmlParser->SetStandardFonts();
 299         }
 300
 301         wxHtmlContainerCell *cell = (wxHtmlContainerCell *)m_htmlParser->
 302                 Parse(OnGetItemMarkup(n));
 303         wxCHECK_RET( cell, _T("wxHtmlParser::Parse() returned NULL?") );
 304
 305         // set the cell's ID to item's index so that CellCoordsToPhysical()
 306         // can quickly find the item:
 307         cell->SetId(wxString::Format(_T("%lu"), (unsigned long)n));
 308
 309         cell->Layout(GetClientSize().x - 2*GetMargins().x);
 310
 311         m_cache->Store(n, cell);
 312     }
 313 }
 314
 315 void wxHtmlListBox::OnSize(wxSizeEvent& event)
 316 {
 317     // we need to relayout all the cached cells
 318     m_cache->Clear();
 319
 320     event.Skip();
 321 }
 322
 323 void wxHtmlListBox::RefreshLine(size_t line)
 324 {
 325     m_cache->InvalidateRange(line, line);
 326
 327     wxVListBox::RefreshLine(line);
 328 }
 329
 330 void wxHtmlListBox::RefreshLines(size_t from, size_t to)
 331 {
 332     m_cache->InvalidateRange(from, to);
 333
 334     wxVListBox::RefreshLines(from, to);
 335 }
 336
 337 void wxHtmlListBox::RefreshAll()
 338 {
 339     m_cache->Clear();
 340
 341     wxVListBox::RefreshAll();
 342 }
 343
 344 void wxHtmlListBox::SetItemCount(size_t count)
 345 {
 346     // the items are going to change, forget the old ones
 347     m_cache->Clear();
 348
 349     wxVListBox::SetItemCount(count);
 350 }
 351
 352 // ----------------------------------------------------------------------------
 353 // wxHtmlListBox implementation of wxVListBox pure virtuals
 354 // ----------------------------------------------------------------------------
 355
 356 void wxHtmlListBox::OnDrawItem(wxDC& dc, const wxRect& rect, size_t n) const
 357 {
 358     CacheItem(n);
 359
 360     wxHtmlCell *cell = m_cache->Get(n);
 361     wxCHECK_RET( cell, _T("this cell should be cached!") );
 362
 363     wxHtmlRenderingInfo htmlRendInfo;
 364
 365     // draw the selected cell in selected state
 366     if ( IsSelected(n) )
 367     {
 368         wxHtmlSelection htmlSel;
 369         htmlSel.Set(wxPoint(0,0), cell, wxPoint(INT_MAX, INT_MAX), cell);
 370         htmlRendInfo.SetSelection(&htmlSel);
 371         if ( m_htmlRendStyle )
 372             htmlRendInfo.SetStyle(m_htmlRendStyle);
 373         htmlRendInfo.GetState().SetSelectionState(wxHTML_SEL_IN);
 374     }
 375
 376     // note that we can't stop drawing exactly at the window boundary as then
 377     // even the visible cells part could be not drawn, so always draw the
 378     // entire cell
 379     cell->Draw(dc,
 380                rect.x + CELL_BORDER, rect.y + CELL_BORDER,
 381                0, INT_MAX, htmlRendInfo);
 382 }
 383
 384 wxCoord wxHtmlListBox::OnMeasureItem(size_t n) const
 385 {
 386     CacheItem(n);
 387
 388     wxHtmlCell *cell = m_cache->Get(n);
 389     wxCHECK_MSG( cell, 0, _T("this cell should be cached!") );
 390
 391     return cell->GetHeight() + cell->GetDescent() + 4;
 392 }
 393
 394 // ----------------------------------------------------------------------------
 395 // wxHtmlListBox implementation of wxHtmlListBoxWinInterface
 396 // ----------------------------------------------------------------------------
 397
 398 void wxHtmlListBox::SetHTMLWindowTitle(const wxString& WXUNUSED(title))
 399 {
 400     // nothing to do
 401 }
 402
 403 void wxHtmlListBox::OnHTMLLinkClicked(const wxHtmlLinkInfo& link)
 404 {
 405     OnLinkClicked(GetItemForCell(link.GetHtmlCell()), link);
 406 }
 407
 408 wxHtmlOpeningStatus
 409 wxHtmlListBox::OnHTMLOpeningURL(wxHtmlURLType WXUNUSED(type),
 410                                 const wxString& WXUNUSED(url),
 411                                 wxString *WXUNUSED(redirect)) const
 412 {
 413     return wxHTML_OPEN;
 414 }
 415
 416 wxPoint wxHtmlListBox::HTMLCoordsToWindow(wxHtmlCell *cell,
 417                                           const wxPoint& pos) const
 418 {
 419     return CellCoordsToPhysical(pos, cell);
 420 }
 421
 422 wxWindow* wxHtmlListBox::GetHTMLWindow() { return this; }
 423
 424 wxColour wxHtmlListBox::GetHTMLBackgroundColour() const
 425 {
 426     return GetBackgroundColour();
 427 }
 428
 429 void wxHtmlListBox::SetHTMLBackgroundColour(const wxColour& WXUNUSED(clr))
 430 {
 431     // nothing to do
 432 }
 433
 434 void wxHtmlListBox::SetHTMLBackgroundImage(const wxBitmap& WXUNUSED(bmpBg))
 435 {
 436     // nothing to do
 437 }
 438
 439 void wxHtmlListBox::SetHTMLStatusText(const wxString& WXUNUSED(text))
 440 {
 441     // nothing to do
 442 }
 443
 444 wxCursor wxHtmlListBox::GetHTMLCursor(HTMLCursor type) const
 445 {
 446     // we don't want to show text selection cursor in listboxes
 447     if (type == HTMLCursor_Text)
 448         return wxHtmlWindow::GetDefaultHTMLCursor(HTMLCursor_Default);
 449
 450     // in all other cases, use the same cursor as wxHtmlWindow:
 451     return wxHtmlWindow::GetDefaultHTMLCursor(type);
 452 }
 453
 454 // ----------------------------------------------------------------------------
 455 // wxHtmlListBox handling of HTML links
 456 // ----------------------------------------------------------------------------
 457
 458 wxPoint wxHtmlListBox::GetRootCellCoords(size_t n) const
 459 {
 460     wxPoint pos(CELL_BORDER, CELL_BORDER);
 461     pos += GetMargins();
 462     pos.y += GetLinesHeight(GetFirstVisibleLine(), n);
 463     return pos;
 464 }
 465
 466 bool wxHtmlListBox::PhysicalCoordsToCell(wxPoint& pos, wxHtmlCell*& cell) const
 467 {
 468     int n = HitTest(pos);
 469     if ( n == wxNOT_FOUND )
 470         return false;
 471
 472     // convert mouse coordinates to coords relative to item's wxHtmlCell:
 473     pos -= GetRootCellCoords(n);
 474
 475     CacheItem(n);
 476     cell = m_cache->Get(n);
 477
 478     return true;
 479 }
 480
 481 size_t wxHtmlListBox::GetItemForCell(const wxHtmlCell *cell) const
 482 {
 483     wxCHECK_MSG( cell, 0, _T("no cell") );
 484
 485     cell = cell->GetRootCell();
 486
 487     wxCHECK_MSG( cell, 0, _T("no root cell") );
 488
 489     // the cell's ID contains item index, see CacheItem():
 490     unsigned long n;
 491     if ( !cell->GetId().ToULong(&n) )
 492     {
 493         wxFAIL_MSG( _T("unexpected root cell's ID") );
 494         return 0;
 495     }
 496
 497     return n;
 498 }
 499
 500 wxPoint
 501 wxHtmlListBox::CellCoordsToPhysical(const wxPoint& pos, wxHtmlCell *cell) const
 502 {
 503     return pos + GetRootCellCoords(GetItemForCell(cell));
 504 }
 505
 506 void wxHtmlListBox::OnInternalIdle()
 507 {
 508     wxVListBox::OnInternalIdle();
 509
 510     if ( wxHtmlWindowMouseHelper::DidMouseMove() )
 511     {
 512         wxPoint pos = ScreenToClient(wxGetMousePosition());
 513         wxHtmlCell *cell;
 514
 515         if ( !PhysicalCoordsToCell(pos, cell) )
 516             return;
 517
 518         wxHtmlWindowMouseHelper::HandleIdle(cell, pos);
 519     }
 520 }
 521
 522 void wxHtmlListBox::OnMouseMove(wxMouseEvent& event)
 523 {
 524     wxHtmlWindowMouseHelper::HandleMouseMoved();
 525     event.Skip();
 526 }
 527
 528 void wxHtmlListBox::OnLeftDown(wxMouseEvent& event)
 529 {
 530     wxPoint pos = event.GetPosition();
 531     wxHtmlCell *cell;
 532
 533     if ( !PhysicalCoordsToCell(pos, cell) )
 534     {
 535         event.Skip();
 536         return;
 537     }
 538
 539     if ( !wxHtmlWindowMouseHelper::HandleMouseClick(cell, pos, event) )
 540     {
 541         // no link was clicked, so let the listbox code handle the click (e.g.
 542         // by selecting another item in the list):
 543         event.Skip();
 544     }
 545 }
 546
 547
 548 // ----------------------------------------------------------------------------
 549 // wxSimpleHtmlListBox
 550 // ----------------------------------------------------------------------------
 551
 552 bool wxSimpleHtmlListBox::Create(wxWindow *parent, wxWindowID id,
 553                                  const wxPoint& pos,
 554                                  const wxSize& size,
 555                                  int n, const wxString choices[],
 556                                  long style,
 557                                  const wxValidator& validator,
 558                                  const wxString& name)
 559 {
 560     if (!wxHtmlListBox::Create(parent, id, pos, size, style, name))
 561         return false;
 562
 563     SetValidator(validator);
 564     for (int i=0; i<n; i++)
 565         Append(choices[i]);
 566
 567     return true;
 568 }
 569
 570 bool wxSimpleHtmlListBox::Create(wxWindow *parent, wxWindowID id,
 571                                     const wxPoint& pos,
 572                                     const wxSize& size,
 573                                     const wxArrayString& choices,
 574                                     long style,
 575                                     const wxValidator& validator,
 576                                     const wxString& name)
 577 {
 578     if (!wxHtmlListBox::Create(parent, id, pos, size, style, name))
 579         return false;
 580
 581     SetValidator(validator);
 582     Append(choices);
 583
 584     return true;
 585 }
 586
 587 wxSimpleHtmlListBox::~wxSimpleHtmlListBox()
 588 {
 589     wxASSERT(m_items.GetCount() == m_clientData.GetCount());
 590     if (HasClientObjectData())
 591     {
 592         // clear the array of client data objects
 593         for (size_t i=0; i<m_items.GetCount(); i++)
 594             delete DoGetItemClientObject(i);
 595     }
 596
 597     m_items.Clear();
 598     m_clientData.Clear();
 599 }
 600
 601 void wxSimpleHtmlListBox::Clear()
 602 {
 603     m_items.Clear();
 604     m_clientData.Clear();
 605     UpdateCount();
 606 }
 607
 608 void wxSimpleHtmlListBox::Delete(unsigned int n)
 609 {
 610     m_items.RemoveAt(n);
 611     m_clientData.RemoveAt(n);
 612     UpdateCount();
 613 }
 614
 615 void wxSimpleHtmlListBox::Append(const wxArrayString& strings)
 616 {
 617     // we know how many items are going to be added - avoid too many reallocs
 618     // m_items.Alloc(strings.GetCount());
 619     // FIXME: Alloc() will clear all the old contents.
 620     //        Suggested fix = make Grow() public and make WX_APPEND_ARRAY take
 621     //        care of calling it automatically
 622
 623     // append all given items at once
 624     WX_APPEND_ARRAY(m_items, strings);
 625     m_clientData.Add(NULL, strings.GetCount());
 626     UpdateCount();
 627 }
 628
 629 int wxSimpleHtmlListBox::DoAppend(const wxString& item)
 630 {
 631     m_items.Add(item);
 632     m_clientData.Add(NULL);
 633     UpdateCount();
 634     return GetCount()-1;
 635 }
 636
 637 int wxSimpleHtmlListBox::DoInsert(const wxString& item, unsigned int pos)
 638 {
 639     m_items.Insert(item, pos);
 640     m_clientData.Insert(NULL, pos);
 641     UpdateCount();
 642     return pos;
 643 }
 644
 645 void wxSimpleHtmlListBox::SetString(unsigned int n, const wxString& s)
 646 {
 647     wxCHECK_RET( IsValid(n),
 648                  wxT("invalid index in wxSimpleHtmlListBox::SetString") );
 649
 650     m_items[n]=s;
 651     RefreshLine(n);
 652 }
 653
 654 wxString wxSimpleHtmlListBox::GetString(unsigned int n) const
 655 {
 656     wxCHECK_MSG( IsValid(n), wxEmptyString,
 657                  wxT("invalid index in wxSimpleHtmlListBox::GetString") );
 658
 659     return m_items[n];
 660 }
 661
 662 void wxSimpleHtmlListBox::UpdateCount()
 663 {
 664     wxASSERT(m_items.GetCount() == m_clientData.GetCount());
 665     wxHtmlListBox::SetItemCount(m_items.GetCount());
 666
 667     // very small optimization: if you need to add lot of items to
 668     // a wxSimpleHtmlListBox be sure to use the
 669     // wxSimpleHtmlListBox::Append(const wxArrayString&) method instead!
 670     if (!this->IsFrozen())
 671         RefreshAll();
 672 }
 673
 674 #endif // wxUSE_HTML