src/univ/listbox.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/univ/listbox.cpp
   3 // Purpose:     wxListBox implementation
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     30.08.00
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #include "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23     #pragma hdrstop
  24 #endif
  25
  26 #if wxUSE_LISTBOX
  27
  28 #ifndef WX_PRECOMP
  29     #include "wx/log.h"
  30
  31     #include "wx/dcclient.h"
  32     #include "wx/listbox.h"
  33     #include "wx/validate.h"
  34 #endif
  35
  36 #include "wx/univ/renderer.h"
  37 #include "wx/univ/inphand.h"
  38 #include "wx/univ/theme.h"
  39
  40 // ----------------------------------------------------------------------------
  41 // wxStdListboxInputHandler: handles mouse and kbd in a single or multi
  42 // selection listbox
  43 // ----------------------------------------------------------------------------
  44
  45 class WXDLLEXPORT wxStdListboxInputHandler : public wxStdInputHandler
  46 {
  47 public:
  48     // if pressing the mouse button in a multiselection listbox should toggle
  49     // the item under mouse immediately, then specify true as the second
  50     // parameter (this is the standard behaviour, under GTK the item is toggled
  51     // only when the mouse is released in the multi selection listbox)
  52     wxStdListboxInputHandler(wxInputHandler *inphand,
  53                              bool toggleOnPressAlways = true);
  54
  55     // base class methods
  56     virtual bool HandleKey(wxInputConsumer *consumer,
  57                            const wxKeyEvent& event,
  58                            bool pressed);
  59     virtual bool HandleMouse(wxInputConsumer *consumer,
  60                              const wxMouseEvent& event);
  61     virtual bool HandleMouseMove(wxInputConsumer *consumer,
  62                                  const wxMouseEvent& event);
  63
  64 protected:
  65     // return the item under mouse, 0 if the mouse is above the listbox or
  66     // GetCount() if it is below it
  67     int HitTest(const wxListBox *listbox, const wxMouseEvent& event);
  68
  69     // parts of HitTest(): first finds the pseudo (because not in range) index
  70     // of the item and the second one adjusts it if necessary - that is if the
  71     // third one returns false
  72     int HitTestUnsafe(const wxListBox *listbox, const wxMouseEvent& event);
  73     int FixItemIndex(const wxListBox *listbox, int item);
  74     bool IsValidIndex(const wxListBox *listbox, int item);
  75
  76     // init m_btnCapture and m_actionMouse
  77     wxControlAction SetupCapture(wxListBox *lbox,
  78                                  const wxMouseEvent& event,
  79                                  int item);
  80
  81     wxRenderer *m_renderer;
  82
  83     // the button which initiated the mouse capture (currently 0 or 1)
  84     int m_btnCapture;
  85
  86     // the action to perform when the mouse moves while we capture it
  87     wxControlAction m_actionMouse;
  88
  89     // the ctor parameter toggleOnPressAlways (see comments near it)
  90     bool m_toggleOnPressAlways;
  91
  92     // do we track the mouse outside the window when it is captured?
  93     bool m_trackMouseOutside;
  94 };
  95
  96 // ============================================================================
  97 // implementation of wxListBox
  98 // ============================================================================
  99
 100 BEGIN_EVENT_TABLE(wxListBox, wxListBoxBase)
 101     EVT_SIZE(wxListBox::OnSize)
 102 END_EVENT_TABLE()
 103
 104 // ----------------------------------------------------------------------------
 105 // construction
 106 // ----------------------------------------------------------------------------
 107
 108 void wxListBox::Init()
 109 {
 110     // will be calculated later when needed
 111     m_lineHeight = 0;
 112     m_itemsPerPage = 0;
 113     m_maxWidth = 0;
 114     m_scrollRangeY = 0;
 115     m_maxWidthItem = -1;
 116     m_strings.unsorted = NULL;
 117
 118     // no items hence no current item
 119     m_current = -1;
 120     m_selAnchor = -1;
 121     m_currentChanged = false;
 122
 123     // no need to update anything initially
 124     m_updateCount = 0;
 125
 126     // no scrollbars to show nor update
 127     m_updateScrollbarX =
 128     m_showScrollbarX =
 129     m_updateScrollbarY =
 130     m_showScrollbarY = false;
 131 }
 132
 133 wxListBox::wxListBox(wxWindow *parent,
 134                      wxWindowID id,
 135                      const wxPoint &pos,
 136                      const wxSize &size,
 137                      const wxArrayString& choices,
 138                      long style,
 139                      const wxValidator& validator,
 140                      const wxString &name)
 141           :wxScrollHelper(this)
 142 {
 143     Init();
 144
 145     Create(parent, id, pos, size, choices, style, validator, name);
 146 }
 147
 148 bool wxListBox::Create(wxWindow *parent,
 149                        wxWindowID id,
 150                        const wxPoint &pos,
 151                        const wxSize &size,
 152                        const wxArrayString& choices,
 153                        long style,
 154                        const wxValidator& validator,
 155                        const wxString &name)
 156 {
 157     wxCArrayString chs(choices);
 158
 159     return Create(parent, id, pos, size, chs.GetCount(), chs.GetStrings(),
 160                   style, validator, name);
 161 }
 162
 163 bool wxListBox::Create(wxWindow *parent,
 164                        wxWindowID id,
 165                        const wxPoint &pos,
 166                        const wxSize &size,
 167                        int n,
 168                        const wxString choices[],
 169                        long style,
 170                        const wxValidator& validator,
 171                        const wxString &name)
 172 {
 173     // for compatibility accept both the new and old styles - they mean the
 174     // same thing for us
 175     if ( style & wxLB_ALWAYS_SB )
 176         style |= wxALWAYS_SHOW_SB;
 177
 178     // if we don't have neither multiple nor extended flag, we must have the
 179     // single selection listbox
 180     if ( !(style & (wxLB_MULTIPLE | wxLB_EXTENDED)) )
 181         style |= wxLB_SINGLE;
 182
 183 #if wxUSE_TWO_WINDOWS
 184     style |=  wxVSCROLL|wxHSCROLL;
 185     if ((style & wxBORDER_MASK) == 0)
 186         style |= wxBORDER_SUNKEN;
 187 #endif
 188
 189     if ( !wxControl::Create(parent, id, pos, size, style,
 190                             validator, name) )
 191         return false;
 192
 193     if ( IsSorted() )
 194         m_strings.sorted = new wxSortedArrayString;
 195     else
 196         m_strings.unsorted = new wxArrayString;
 197
 198     Set(n, choices);
 199
 200     SetInitialSize(size);
 201
 202     CreateInputHandler(wxINP_HANDLER_LISTBOX);
 203
 204     return true;
 205 }
 206
 207 wxListBox::~wxListBox()
 208 {
 209     // call this just to free the client data -- and avoid leaking memory
 210     DoClear();
 211
 212     if ( IsSorted() )
 213         delete m_strings.sorted;
 214     else
 215         delete m_strings.unsorted;
 216
 217     m_strings.sorted = NULL;
 218 }
 219
 220 // ----------------------------------------------------------------------------
 221 // accessing strings
 222 // ----------------------------------------------------------------------------
 223
 224 unsigned int wxListBox::GetCount() const
 225 {
 226     return IsSorted() ? m_strings.sorted->size()
 227                       : m_strings.unsorted->size();
 228 }
 229
 230 wxString wxListBox::GetString(unsigned int n) const
 231 {
 232     return IsSorted() ? m_strings.sorted->Item(n)
 233                       : m_strings.unsorted->Item(n);
 234 }
 235
 236 int wxListBox::FindString(const wxString& s, bool bCase) const
 237 {
 238     return IsSorted() ? m_strings.sorted->Index(s, bCase)
 239                       : m_strings.unsorted->Index(s, bCase);
 240 }
 241
 242 // ----------------------------------------------------------------------------
 243 // adding/inserting strings
 244 // ----------------------------------------------------------------------------
 245
 246 int wxListBox::DoInsertItems(const wxArrayStringsAdapter& items,
 247                              unsigned int pos,
 248                              void **clientData,
 249                              wxClientDataType type)
 250 {
 251     int idx = wxNOT_FOUND;
 252
 253     const unsigned int numItems = items.GetCount();
 254     for ( unsigned int i = 0; i < numItems; ++i )
 255     {
 256         const wxString& item = items[i];
 257         idx = IsSorted() ? m_strings.sorted->Add(item)
 258                          : (m_strings.unsorted->Insert(item, pos), pos++);
 259
 260         m_itemsClientData.Insert(NULL, idx);
 261         AssignNewItemClientData(idx, clientData, i, type);
 262
 263         // call the wxCheckListBox hook
 264         OnItemInserted(idx);
 265     }
 266
 267     // the number of items has changed so we might have to show the scrollbar
 268     m_updateScrollbarY = true;
 269
 270     // the max width also might have changed - just recalculate it instead of
 271     // keeping track of it here, this is probably more efficient for a typical
 272     // use pattern
 273     RefreshHorzScrollbar();
 274
 275     // note that we have to refresh all the items after the ones we inserted,
 276     // not just these items
 277     RefreshFromItemToEnd(pos);
 278
 279     return idx;
 280 }
 281
 282 void wxListBox::SetString(unsigned int n, const wxString& s)
 283 {
 284     wxCHECK_RET( !IsSorted(), wxT("can't set string in sorted listbox") );
 285
 286     if ( IsSorted() )
 287         (*m_strings.sorted)[n] = s;
 288     else
 289         (*m_strings.unsorted)[n] = s;
 290
 291     if ( HasHorzScrollbar() )
 292     {
 293         // we need to update m_maxWidth as changing the string may cause the
 294         // horz scrollbar [dis]appear
 295         wxCoord width;
 296
 297         GetTextExtent(s, &width, NULL);
 298
 299         // it might have increased if the new string is long
 300         if ( width > m_maxWidth )
 301         {
 302             m_maxWidth = width;
 303             m_maxWidthItem = n;
 304             m_updateScrollbarX = true;
 305         }
 306         // or also decreased if the old string was the longest one
 307         else if ( n == (unsigned int)m_maxWidthItem )
 308         {
 309             RefreshHorzScrollbar();
 310         }
 311     }
 312
 313     RefreshItem(n);
 314 }
 315
 316 // ----------------------------------------------------------------------------
 317 // removing strings
 318 // ----------------------------------------------------------------------------
 319
 320 void wxListBox::DoClear()
 321 {
 322     if ( IsSorted() )
 323         m_strings.sorted->Clear();
 324     else
 325         m_strings.unsorted->Clear();
 326
 327     m_itemsClientData.Clear();
 328     m_selections.Clear();
 329
 330     m_current = -1;
 331
 332     m_updateScrollbarY = true;
 333
 334     RefreshHorzScrollbar();
 335
 336     RefreshAll();
 337 }
 338
 339 void wxListBox::DoDeleteOneItem(unsigned int n)
 340 {
 341     wxCHECK_RET( IsValid(n),
 342                  wxT("invalid index in wxListBox::Delete") );
 343
 344     // do it before removing the index as otherwise the last item will not be
 345     // refreshed (as GetCount() will be decremented)
 346     RefreshFromItemToEnd(n);
 347
 348     if ( IsSorted() )
 349         m_strings.sorted->RemoveAt(n);
 350     else
 351         m_strings.unsorted->RemoveAt(n);
 352
 353     m_itemsClientData.RemoveAt(n);
 354
 355     // when the item disappears we must not keep using its index
 356     if ( (int)n == m_current )
 357     {
 358         m_current = -1;
 359     }
 360     else if ( (int)n < m_current )
 361     {
 362         m_current--;
 363     }
 364     //else: current item may stay
 365
 366     // update the selections array: the indices of all seletected items after
 367     // the one being deleted must change and the item itselfm ust be removed
 368     int index = wxNOT_FOUND;
 369     unsigned int count = m_selections.GetCount();
 370     for ( unsigned int item = 0; item < count; item++ )
 371     {
 372         if ( m_selections[item] == (int)n )
 373         {
 374             // remember to delete it later
 375             index = item;
 376         }
 377         else if ( m_selections[item] > (int)n )
 378         {
 379             // to account for the index shift
 380             m_selections[item]--;
 381         }
 382         //else: nothing changed for this one
 383     }
 384
 385     if ( index != wxNOT_FOUND )
 386     {
 387         m_selections.RemoveAt(index);
 388     }
 389
 390     // the number of items has changed, hence the scrollbar may disappear
 391     m_updateScrollbarY = true;
 392
 393     // finally, if the longest item was deleted the scrollbar may disappear
 394     if ( (int)n == m_maxWidthItem )
 395     {
 396         RefreshHorzScrollbar();
 397     }
 398 }
 399
 400 // ----------------------------------------------------------------------------
 401 // client data handling
 402 // ----------------------------------------------------------------------------
 403
 404 void wxListBox::DoSetItemClientData(unsigned int n, void* clientData)
 405 {
 406     m_itemsClientData[n] = clientData;
 407 }
 408
 409 void *wxListBox::DoGetItemClientData(unsigned int n) const
 410 {
 411     return m_itemsClientData[n];
 412 }
 413
 414 // ----------------------------------------------------------------------------
 415 // selection
 416 // ----------------------------------------------------------------------------
 417
 418 void wxListBox::DoSetSelection(int n, bool select)
 419 {
 420     if ( select )
 421     {
 422         if ( n == wxNOT_FOUND )
 423         {
 424             if ( !HasMultipleSelection() )
 425             {
 426                 // selecting wxNOT_FOUND is documented to deselect all items
 427                 DeselectAll();
 428                 return;
 429             }
 430         }
 431         else if ( m_selections.Index(n) == wxNOT_FOUND )
 432         {
 433             if ( !HasMultipleSelection() )
 434             {
 435                 // selecting an item in a single selection listbox deselects
 436                 // all the others
 437                 DeselectAll();
 438             }
 439
 440             m_selections.Add(n);
 441
 442             RefreshItem(n);
 443         }
 444         //else: already selected
 445     }
 446     else // unselect
 447     {
 448         int index = m_selections.Index(n);
 449         if ( index != wxNOT_FOUND )
 450         {
 451             m_selections.RemoveAt(index);
 452
 453             RefreshItem(n);
 454         }
 455         //else: not selected
 456     }
 457
 458     // sanity check: a single selection listbox can't have more than one item
 459     // selected
 460     wxASSERT_MSG( HasMultipleSelection() || (m_selections.GetCount() < 2),
 461                   wxT("multiple selected items in single selection lbox?") );
 462
 463     if ( select )
 464     {
 465         // the newly selected item becomes the current one
 466         SetCurrentItem(n);
 467     }
 468 }
 469
 470 int wxListBox::GetSelection() const
 471 {
 472     wxCHECK_MSG( !HasMultipleSelection(), wxNOT_FOUND,
 473                  wxT("use wxListBox::GetSelections for ths listbox") );
 474
 475     return m_selections.IsEmpty() ? wxNOT_FOUND : m_selections[0];
 476 }
 477
 478 static int wxCMPFUNC_CONV wxCompareInts(int *n, int *m)
 479 {
 480     return *n - *m;
 481 }
 482
 483 int wxListBox::GetSelections(wxArrayInt& selections) const
 484 {
 485     // always return sorted array to the user
 486     selections = m_selections;
 487     unsigned int count = m_selections.GetCount();
 488
 489     // don't call sort on an empty array
 490     if ( count )
 491     {
 492         selections.Sort(wxCompareInts);
 493     }
 494
 495     return count;
 496 }
 497
 498 // ----------------------------------------------------------------------------
 499 // refresh logic: we use delayed refreshing which allows to avoid multiple
 500 // refreshes (and hence flicker) in case when several listbox items are
 501 // added/deleted/changed subsequently
 502 // ----------------------------------------------------------------------------
 503
 504 void wxListBox::RefreshFromItemToEnd(int from)
 505 {
 506     RefreshItems(from, GetCount() - from);
 507 }
 508
 509 void wxListBox::RefreshItems(int from, int count)
 510 {
 511     switch ( m_updateCount )
 512     {
 513         case 0:
 514             m_updateFrom = from;
 515             m_updateCount = count;
 516             break;
 517
 518         case -1:
 519             // we refresh everything anyhow
 520             break;
 521
 522         default:
 523             // add these items to the others which we have to refresh
 524             if ( m_updateFrom < from )
 525             {
 526                 count += from - m_updateFrom;
 527                 if ( m_updateCount < count )
 528                     m_updateCount = count;
 529             }
 530             else // m_updateFrom >= from
 531             {
 532                 int updateLast = wxMax(m_updateFrom + m_updateCount,
 533                                        from + count);
 534                 m_updateFrom = from;
 535                 m_updateCount = updateLast - m_updateFrom;
 536             }
 537     }
 538 }
 539
 540 void wxListBox::RefreshItem(int n)
 541 {
 542     switch ( m_updateCount )
 543     {
 544         case 0:
 545             // refresh this item only
 546             m_updateFrom = n;
 547             m_updateCount = 1;
 548             break;
 549
 550         case -1:
 551             // we refresh everything anyhow
 552             break;
 553
 554         default:
 555             // add this item to the others which we have to refresh
 556             if ( m_updateFrom < n )
 557             {
 558                 if ( m_updateCount < n - m_updateFrom + 1 )
 559                     m_updateCount = n - m_updateFrom + 1;
 560             }
 561             else // n <= m_updateFrom
 562             {
 563                 m_updateCount += m_updateFrom - n;
 564                 m_updateFrom = n;
 565             }
 566     }
 567 }
 568
 569 void wxListBox::RefreshAll()
 570 {
 571     m_updateCount = -1;
 572 }
 573
 574 void wxListBox::RefreshHorzScrollbar()
 575 {
 576     m_maxWidth = 0; // recalculate it
 577     m_updateScrollbarX = true;
 578 }
 579
 580 void wxListBox::UpdateScrollbars()
 581 {
 582     wxSize size = GetClientSize();
 583
 584     // is our height enough to show all items?
 585     unsigned int nLines = GetCount();
 586     wxCoord lineHeight = GetLineHeight();
 587     bool showScrollbarY = (int)nLines*lineHeight > size.y;
 588
 589     // check the width too if required
 590     wxCoord charWidth, maxWidth;
 591     bool showScrollbarX;
 592     if ( HasHorzScrollbar() )
 593     {
 594         charWidth = GetCharWidth();
 595         maxWidth = GetMaxWidth();
 596         showScrollbarX = maxWidth > size.x;
 597     }
 598     else // never show it
 599     {
 600         charWidth = maxWidth = 0;
 601         showScrollbarX = false;
 602     }
 603
 604     // what should be the scrollbar range now?
 605     int scrollRangeX = showScrollbarX
 606                         ? (maxWidth + charWidth - 1) / charWidth + 2 // FIXME
 607                         : 0;
 608     int scrollRangeY = showScrollbarY
 609                         ? nLines +
 610                             (size.y % lineHeight + lineHeight - 1) / lineHeight
 611                         : 0;
 612
 613     // reset scrollbars if something changed: either the visibility status
 614     // or the range of a scrollbar which is shown
 615     if ( (showScrollbarY != m_showScrollbarY) ||
 616          (showScrollbarX != m_showScrollbarX) ||
 617          (showScrollbarY && (scrollRangeY != m_scrollRangeY)) ||
 618          (showScrollbarX && (scrollRangeX != m_scrollRangeX)) )
 619     {
 620         int x, y;
 621         GetViewStart(&x, &y);
 622         SetScrollbars(charWidth, lineHeight,
 623                       scrollRangeX, scrollRangeY,
 624                       x, y);
 625
 626         m_showScrollbarX = showScrollbarX;
 627         m_showScrollbarY = showScrollbarY;
 628
 629         m_scrollRangeX = scrollRangeX;
 630         m_scrollRangeY = scrollRangeY;
 631     }
 632 }
 633
 634 void wxListBox::UpdateItems()
 635 {
 636     // only refresh the items which must be refreshed
 637     if ( m_updateCount == -1 )
 638     {
 639         // refresh all
 640         wxLogTrace(wxT("listbox"), wxT("Refreshing all"));
 641
 642         Refresh();
 643     }
 644     else
 645     {
 646         wxSize size = GetClientSize();
 647         wxRect rect;
 648         rect.width = size.x;
 649         rect.height = size.y;
 650         rect.y += m_updateFrom*GetLineHeight();
 651         rect.height = m_updateCount*GetLineHeight();
 652
 653         // we don't need to calculate x position as we always refresh the
 654         // entire line(s)
 655         CalcScrolledPosition(0, rect.y, NULL, &rect.y);
 656
 657         wxLogTrace(wxT("listbox"), wxT("Refreshing items %d..%d (%d-%d)"),
 658                    m_updateFrom, m_updateFrom + m_updateCount - 1,
 659                    rect.GetTop(), rect.GetBottom());
 660
 661         Refresh(true, &rect);
 662     }
 663 }
 664
 665 void wxListBox::OnInternalIdle()
 666 {
 667     if ( m_updateScrollbarY || m_updateScrollbarX )
 668     {
 669         UpdateScrollbars();
 670
 671         m_updateScrollbarX =
 672         m_updateScrollbarY = false;
 673     }
 674
 675     if ( m_currentChanged )
 676     {
 677         DoEnsureVisible(m_current);
 678
 679         m_currentChanged = false;
 680     }
 681
 682     if ( m_updateCount )
 683     {
 684         UpdateItems();
 685
 686         m_updateCount = 0;
 687     }
 688     wxListBoxBase::OnInternalIdle();
 689 }
 690
 691 // ----------------------------------------------------------------------------
 692 // drawing
 693 // ----------------------------------------------------------------------------
 694
 695 wxBorder wxListBox::GetDefaultBorder() const
 696 {
 697     return wxBORDER_SUNKEN;
 698 }
 699
 700 void wxListBox::DoDraw(wxControlRenderer *renderer)
 701 {
 702     // adjust the DC to account for scrolling
 703     wxDC& dc = renderer->GetDC();
 704     PrepareDC(dc);
 705     dc.SetFont(GetFont());
 706
 707     // get the update rect
 708     wxRect rectUpdate = GetUpdateClientRect();
 709
 710     int yTop, yBottom;
 711     CalcUnscrolledPosition(0, rectUpdate.GetTop(), NULL, &yTop);
 712     CalcUnscrolledPosition(0, rectUpdate.GetBottom(), NULL, &yBottom);
 713
 714     // get the items which must be redrawn
 715     wxCoord lineHeight = GetLineHeight();
 716     unsigned int itemFirst = yTop / lineHeight,
 717                  itemLast = (yBottom + lineHeight - 1) / lineHeight,
 718                  itemMax = GetCount();
 719
 720     if ( itemFirst >= itemMax )
 721         return;
 722
 723     if ( itemLast > itemMax )
 724         itemLast = itemMax;
 725
 726     // do draw them
 727     wxLogTrace(wxT("listbox"), wxT("Repainting items %d..%d"),
 728                itemFirst, itemLast);
 729
 730     DoDrawRange(renderer, itemFirst, itemLast);
 731 }
 732
 733 void wxListBox::DoDrawRange(wxControlRenderer *renderer,
 734                             int itemFirst, int itemLast)
 735 {
 736     renderer->DrawItems(this, itemFirst, itemLast);
 737 }
 738
 739 // ----------------------------------------------------------------------------
 740 // size calculations
 741 // ----------------------------------------------------------------------------
 742
 743 bool wxListBox::SetFont(const wxFont& font)
 744 {
 745     if ( !wxControl::SetFont(font) )
 746         return false;
 747
 748     CalcItemsPerPage();
 749
 750     RefreshAll();
 751
 752     return true;
 753 }
 754
 755 void wxListBox::CalcItemsPerPage()
 756 {
 757     m_lineHeight = GetRenderer()->GetListboxItemHeight(GetCharHeight());
 758     m_itemsPerPage = GetClientSize().y / m_lineHeight;
 759 }
 760
 761 int wxListBox::GetItemsPerPage() const
 762 {
 763     if ( !m_itemsPerPage )
 764     {
 765         wxConstCast(this, wxListBox)->CalcItemsPerPage();
 766     }
 767
 768     return m_itemsPerPage;
 769 }
 770
 771 wxCoord wxListBox::GetLineHeight() const
 772 {
 773     if ( !m_lineHeight )
 774     {
 775         wxConstCast(this, wxListBox)->CalcItemsPerPage();
 776     }
 777
 778     return m_lineHeight;
 779 }
 780
 781 wxCoord wxListBox::GetMaxWidth() const
 782 {
 783     if ( m_maxWidth == 0 )
 784     {
 785         wxListBox *self = wxConstCast(this, wxListBox);
 786         wxCoord width;
 787         unsigned int count = GetCount();
 788         for ( unsigned int n = 0; n < count; n++ )
 789         {
 790             GetTextExtent(this->GetString(n), &width, NULL);
 791             if ( width > m_maxWidth )
 792             {
 793                 self->m_maxWidth = width;
 794                 self->m_maxWidthItem = n;
 795             }
 796         }
 797     }
 798
 799     return m_maxWidth;
 800 }
 801
 802 void wxListBox::OnSize(wxSizeEvent& event)
 803 {
 804     // recalculate the number of items per page
 805     CalcItemsPerPage();
 806
 807     // the scrollbars might [dis]appear
 808     m_updateScrollbarX =
 809     m_updateScrollbarY = true;
 810
 811     event.Skip();
 812 }
 813
 814 void wxListBox::DoSetFirstItem(int n)
 815 {
 816     SetCurrentItem(n);
 817 }
 818
 819 void wxListBox::DoSetSize(int x, int y,
 820                           int width, int height,
 821                           int sizeFlags)
 822 {
 823     if ( GetWindowStyle() & wxLB_INT_HEIGHT )
 824     {
 825         // we must round up the height to an entire number of rows
 826
 827         // the client area must contain an int number of rows, so take borders
 828         // into account
 829         wxRect rectBorders = GetRenderer()->GetBorderDimensions(GetBorder());
 830         wxCoord hBorders = rectBorders.y + rectBorders.height;
 831
 832         wxCoord hLine = GetLineHeight();
 833         height = ((height - hBorders + hLine - 1) / hLine)*hLine + hBorders;
 834     }
 835
 836     wxListBoxBase::DoSetSize(x, y, width, height, sizeFlags);
 837 }
 838
 839 wxSize wxListBox::DoGetBestClientSize() const
 840 {
 841     wxCoord width = 0,
 842             height = 0;
 843
 844     unsigned int count = GetCount();
 845     for ( unsigned int n = 0; n < count; n++ )
 846     {
 847         wxCoord w,h;
 848         GetTextExtent(this->GetString(n), &w, &h);
 849
 850         if ( w > width )
 851             width = w;
 852         if ( h > height )
 853             height = h;
 854     }
 855
 856     // if the listbox is empty, still give it some non zero (even if
 857     // arbitrary) size - otherwise, leave small margin around the strings
 858     if ( !width )
 859         width = 100;
 860     else
 861         width += 3*GetCharWidth();
 862
 863     if ( !height )
 864         height = GetCharHeight();
 865
 866     // we need the height of the entire listbox, not just of one line
 867     height *= wxMax(count, 7);
 868
 869     return wxSize(width, height);
 870 }
 871
 872 // ----------------------------------------------------------------------------
 873 // listbox actions
 874 // ----------------------------------------------------------------------------
 875
 876 bool wxListBox::SendEvent(wxEventType type, int item)
 877 {
 878     wxCommandEvent event(type, m_windowId);
 879     event.SetEventObject(this);
 880
 881     // use the current item by default
 882     if ( item == -1 )
 883     {
 884         item = m_current;
 885     }
 886
 887     // client data and string parameters only make sense if we have an item
 888     if ( item != -1 )
 889     {
 890         if ( HasClientObjectData() )
 891             event.SetClientObject(GetClientObject(item));
 892         else if ( HasClientUntypedData() )
 893             event.SetClientData(GetClientData(item));
 894
 895         event.SetString(GetString(item));
 896     }
 897
 898     event.SetInt(item);
 899
 900     return GetEventHandler()->ProcessEvent(event);
 901 }
 902
 903 void wxListBox::SetCurrentItem(int n)
 904 {
 905     if ( n != m_current )
 906     {
 907         if ( m_current != -1 )
 908             RefreshItem(m_current);
 909
 910         m_current = n;
 911
 912         if ( m_current != -1 )
 913         {
 914             m_currentChanged = true;
 915
 916             RefreshItem(m_current);
 917         }
 918     }
 919     //else: nothing to do
 920 }
 921
 922 bool wxListBox::FindItem(const wxString& prefix, bool strictlyAfter)
 923 {
 924     unsigned int count = GetCount();
 925     if ( count==0 )
 926     {
 927         // empty listbox, we can't find anything in it
 928         return false;
 929     }
 930
 931     // start either from the current item or from the next one if strictlyAfter
 932     // is true
 933     int first;
 934     if ( strictlyAfter )
 935     {
 936         // the following line will set first correctly to 0 if there is no
 937         // selection (m_current == -1)
 938         first = m_current == (int)(count - 1) ? 0 : m_current + 1;
 939     }
 940     else // start with the current
 941     {
 942         first = m_current == -1 ? 0 : m_current;
 943     }
 944
 945     int last = first == 0 ? count - 1 : first - 1;
 946
 947     // if this is not true we'd never exit from the loop below!
 948     wxASSERT_MSG( first < (int)count && last < (int)count, wxT("logic error") );
 949
 950     // precompute it outside the loop
 951     size_t len = prefix.length();
 952
 953     // loop over all items in the listbox
 954     for ( int item = first; item != (int)last; item < (int)(count - 1) ? item++ : item = 0 )
 955     {
 956         if ( wxStrnicmp(this->GetString(item).c_str(), prefix, len) == 0 )
 957         {
 958             SetCurrentItem(item);
 959
 960             if ( !(GetWindowStyle() & wxLB_MULTIPLE) )
 961             {
 962                 DeselectAll(item);
 963                 SelectAndNotify(item);
 964
 965                 if ( GetWindowStyle() & wxLB_EXTENDED )
 966                     AnchorSelection(item);
 967             }
 968
 969             return true;
 970         }
 971     }
 972
 973     // nothing found
 974     return false;
 975 }
 976
 977 void wxListBox::EnsureVisible(int n)
 978 {
 979     if ( m_updateScrollbarY )
 980     {
 981         UpdateScrollbars();
 982
 983         m_updateScrollbarX =
 984         m_updateScrollbarY = false;
 985     }
 986
 987     DoEnsureVisible(n);
 988 }
 989
 990 void wxListBox::DoEnsureVisible(int n)
 991 {
 992     if ( !m_showScrollbarY )
 993     {
 994         // nothing to do - everything is shown anyhow
 995         return;
 996     }
 997
 998     int first;
 999     GetViewStart(0, &first);
1000     if ( first > n )
1001     {
1002         // we need to scroll upwards, so make the current item appear on top
1003         // of the shown range
1004         Scroll(0, n);
1005     }
1006     else
1007     {
1008         int last = first + GetClientSize().y / GetLineHeight() - 1;
1009         if ( last < n )
1010         {
1011             // scroll down: the current item appears at the bottom of the
1012             // range
1013             Scroll(0, n - (last - first));
1014         }
1015     }
1016 }
1017
1018 void wxListBox::ChangeCurrent(int diff)
1019 {
1020     int current = m_current == -1 ? 0 : m_current;
1021
1022     current += diff;
1023
1024     int last = GetCount() - 1;
1025     if ( current < 0 )
1026         current = 0;
1027     else if ( current > last )
1028         current = last;
1029
1030     SetCurrentItem(current);
1031 }
1032
1033 void wxListBox::ExtendSelection(int itemTo)
1034 {
1035     // if we don't have the explicit values for selection start/end, make them
1036     // up
1037     if ( m_selAnchor == -1 )
1038         m_selAnchor = m_current;
1039
1040     if ( itemTo == -1 )
1041         itemTo = m_current;
1042
1043     // swap the start/end of selection range if necessary
1044     int itemFrom = m_selAnchor;
1045     if ( itemFrom > itemTo )
1046     {
1047         int itemTmp = itemFrom;
1048         itemFrom = itemTo;
1049         itemTo = itemTmp;
1050     }
1051
1052     // the selection should now include all items in the range between the
1053     // anchor and the specified item and only them
1054
1055     int n;
1056     for ( n = 0; n < itemFrom; n++ )
1057     {
1058         Deselect(n);
1059     }
1060
1061     for ( ; n <= itemTo; n++ )
1062     {
1063         SetSelection(n);
1064     }
1065
1066     unsigned int count = GetCount();
1067     for ( ; n < (int)count; n++ )
1068     {
1069         Deselect(n);
1070     }
1071 }
1072
1073 void wxListBox::DoSelect(int item, bool sel)
1074 {
1075     if ( item != -1 )
1076     {
1077         // go to this item first
1078         SetCurrentItem(item);
1079     }
1080
1081     // the current item is the one we want to change: either it was just
1082     // changed above to be the same as item or item == -1 in which we case we
1083     // are supposed to use the current one anyhow
1084     if ( m_current != -1 )
1085     {
1086         // [de]select it
1087         SetSelection(m_current, sel);
1088     }
1089 }
1090
1091 void wxListBox::SelectAndNotify(int item)
1092 {
1093     DoSelect(item);
1094
1095     SendEvent(wxEVT_COMMAND_LISTBOX_SELECTED);
1096 }
1097
1098 void wxListBox::Activate(int item)
1099 {
1100     if ( item != -1 )
1101         SetCurrentItem(item);
1102     else
1103         item = m_current;
1104
1105     if ( !(GetWindowStyle() & wxLB_MULTIPLE) )
1106     {
1107         DeselectAll(item);
1108     }
1109
1110     if ( item != -1 )
1111     {
1112         DoSelect(item);
1113
1114         SendEvent(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED);
1115     }
1116 }
1117
1118 // ----------------------------------------------------------------------------
1119 // input handling
1120 // ----------------------------------------------------------------------------
1121
1122 /*
1123    The numArg here is the listbox item index while the strArg is used
1124    differently for the different actions:
1125
1126    a) for wxACTION_LISTBOX_FIND it has the natural meaning: this is the string
1127       to find
1128
1129    b) for wxACTION_LISTBOX_SELECT and wxACTION_LISTBOX_EXTENDSEL it is used
1130       to decide if the listbox should send the notification event (it is empty)
1131       or not (it is not): this allows us to reuse the same action for when the
1132       user is dragging the mouse when it has been released although in the
1133       first case no notification is sent while in the second it is sent.
1134  */
1135 bool wxListBox::PerformAction(const wxControlAction& action,
1136                               long numArg,
1137                               const wxString& strArg)
1138 {
1139     int item = (int)numArg;
1140
1141     if ( action == wxACTION_LISTBOX_SETFOCUS )
1142     {
1143         SetCurrentItem(item);
1144     }
1145     else if ( action == wxACTION_LISTBOX_ACTIVATE )
1146     {
1147         Activate(item);
1148     }
1149     else if ( action == wxACTION_LISTBOX_TOGGLE )
1150     {
1151         if ( item == -1 )
1152             item = m_current;
1153
1154         if ( IsSelected(item) )
1155             DoUnselect(item);
1156         else
1157             SelectAndNotify(item);
1158     }
1159     else if ( action == wxACTION_LISTBOX_SELECT )
1160     {
1161         DeselectAll(item);
1162
1163         if ( strArg.empty() )
1164             SelectAndNotify(item);
1165         else
1166             DoSelect(item);
1167     }
1168     else if ( action == wxACTION_LISTBOX_SELECTADD )
1169         DoSelect(item);
1170     else if ( action == wxACTION_LISTBOX_UNSELECT )
1171         DoUnselect(item);
1172     else if ( action == wxACTION_LISTBOX_MOVEDOWN )
1173         ChangeCurrent(1);
1174     else if ( action == wxACTION_LISTBOX_MOVEUP )
1175         ChangeCurrent(-1);
1176     else if ( action == wxACTION_LISTBOX_PAGEDOWN )
1177         ChangeCurrent(GetItemsPerPage());
1178     else if ( action == wxACTION_LISTBOX_PAGEUP )
1179         ChangeCurrent(-GetItemsPerPage());
1180     else if ( action == wxACTION_LISTBOX_START )
1181         SetCurrentItem(0);
1182     else if ( action == wxACTION_LISTBOX_END )
1183         SetCurrentItem(GetCount() - 1);
1184     else if ( action == wxACTION_LISTBOX_UNSELECTALL )
1185         DeselectAll(item);
1186     else if ( action == wxACTION_LISTBOX_EXTENDSEL )
1187         ExtendSelection(item);
1188     else if ( action == wxACTION_LISTBOX_FIND )
1189         FindNextItem(strArg);
1190     else if ( action == wxACTION_LISTBOX_ANCHOR )
1191         AnchorSelection(item == -1 ? m_current : item);
1192     else if ( action == wxACTION_LISTBOX_SELECTALL ||
1193               action == wxACTION_LISTBOX_SELTOGGLE )
1194         wxFAIL_MSG(wxT("unimplemented yet"));
1195     else
1196         return wxControl::PerformAction(action, numArg, strArg);
1197
1198     return true;
1199 }
1200
1201 /* static */
1202 wxInputHandler *wxListBox::GetStdInputHandler(wxInputHandler *handlerDef)
1203 {
1204     static wxStdListboxInputHandler s_handler(handlerDef);
1205
1206     return &s_handler;
1207 }
1208
1209 // ============================================================================
1210 // implementation of wxStdListboxInputHandler
1211 // ============================================================================
1212
1213 wxStdListboxInputHandler::wxStdListboxInputHandler(wxInputHandler *handler,
1214                                                    bool toggleOnPressAlways)
1215                         : wxStdInputHandler(handler)
1216 {
1217     m_btnCapture = 0;
1218     m_toggleOnPressAlways = toggleOnPressAlways;
1219     m_actionMouse = wxACTION_NONE;
1220     m_trackMouseOutside = true;
1221 }
1222
1223 int wxStdListboxInputHandler::HitTest(const wxListBox *lbox,
1224                                       const wxMouseEvent& event)
1225 {
1226     int item = HitTestUnsafe(lbox, event);
1227
1228     return FixItemIndex(lbox, item);
1229 }
1230
1231 int wxStdListboxInputHandler::HitTestUnsafe(const wxListBox *lbox,
1232                                             const wxMouseEvent& event)
1233 {
1234     wxPoint pt = event.GetPosition();
1235     pt -= lbox->GetClientAreaOrigin();
1236     int y;
1237     lbox->CalcUnscrolledPosition(0, pt.y, NULL, &y);
1238     return y / lbox->GetLineHeight();
1239 }
1240
1241 int wxStdListboxInputHandler::FixItemIndex(const wxListBox *lbox,
1242                                            int item)
1243 {
1244     if ( item < 0 )
1245     {
1246         // mouse is above the first item
1247         item = 0;
1248     }
1249     else if ( (unsigned int)item >= lbox->GetCount() )
1250     {
1251         // mouse is below the last item
1252         item = lbox->GetCount() - 1;
1253     }
1254
1255     return item;
1256 }
1257
1258 bool wxStdListboxInputHandler::IsValidIndex(const wxListBox *lbox, int item)
1259 {
1260     return item >= 0 && (unsigned int)item < lbox->GetCount();
1261 }
1262
1263 wxControlAction
1264 wxStdListboxInputHandler::SetupCapture(wxListBox *lbox,
1265                                        const wxMouseEvent& event,
1266                                        int item)
1267 {
1268     // we currently only allow selecting with the left mouse button, if we
1269     // do need to allow using other buttons too we might use the code
1270     // inside #if 0
1271 #if 0
1272     m_btnCapture = event.LeftDown()
1273                     ? 1
1274                     : event.RightDown()
1275                         ? 3
1276                         : 2;
1277 #else
1278     m_btnCapture = 1;
1279 #endif // 0/1
1280
1281     wxControlAction action;
1282     if ( lbox->HasMultipleSelection() )
1283     {
1284         if ( lbox->GetWindowStyle() & wxLB_MULTIPLE )
1285         {
1286             if ( m_toggleOnPressAlways )
1287             {
1288                 // toggle the item right now
1289                 action = wxACTION_LISTBOX_TOGGLE;
1290             }
1291             //else: later
1292
1293             m_actionMouse = wxACTION_LISTBOX_SETFOCUS;
1294         }
1295         else // wxLB_EXTENDED listbox
1296         {
1297             // simple click in an extended sel listbox clears the old
1298             // selection and adds the clicked item to it then, ctrl-click
1299             // toggles an item to it and shift-click adds a range between
1300             // the old selection anchor and the clicked item
1301             if ( event.ControlDown() )
1302             {
1303                 lbox->PerformAction(wxACTION_LISTBOX_ANCHOR, item);
1304
1305                 action = wxACTION_LISTBOX_TOGGLE;
1306             }
1307             else if ( event.ShiftDown() )
1308             {
1309                 action = wxACTION_LISTBOX_EXTENDSEL;
1310             }
1311             else // simple click
1312             {
1313                 lbox->PerformAction(wxACTION_LISTBOX_ANCHOR, item);
1314
1315                 action = wxACTION_LISTBOX_SELECT;
1316             }
1317
1318             m_actionMouse = wxACTION_LISTBOX_EXTENDSEL;
1319         }
1320     }
1321     else // single selection
1322     {
1323         m_actionMouse =
1324         action = wxACTION_LISTBOX_SELECT;
1325     }
1326
1327     // by default we always do track it
1328     m_trackMouseOutside = true;
1329
1330     return action;
1331 }
1332
1333 bool wxStdListboxInputHandler::HandleKey(wxInputConsumer *consumer,
1334                                          const wxKeyEvent& event,
1335                                          bool pressed)
1336 {
1337     // we're only interested in the key press events
1338     if ( pressed && !event.AltDown() )
1339     {
1340         bool isMoveCmd = true;
1341         int style = consumer->GetInputWindow()->GetWindowStyle();
1342
1343         wxControlAction action;
1344         wxString strArg;
1345
1346         int keycode = event.GetKeyCode();
1347         switch ( keycode )
1348         {
1349             // movement
1350             case WXK_UP:
1351                 action = wxACTION_LISTBOX_MOVEUP;
1352                 break;
1353
1354             case WXK_DOWN:
1355                 action = wxACTION_LISTBOX_MOVEDOWN;
1356                 break;
1357
1358             case WXK_PAGEUP:
1359                 action = wxACTION_LISTBOX_PAGEUP;
1360                 break;
1361
1362             case WXK_PAGEDOWN:
1363                 action = wxACTION_LISTBOX_PAGEDOWN;
1364                 break;
1365
1366             case WXK_HOME:
1367                 action = wxACTION_LISTBOX_START;
1368                 break;
1369
1370             case WXK_END:
1371                 action = wxACTION_LISTBOX_END;
1372                 break;
1373
1374             // selection
1375             case WXK_SPACE:
1376                 if ( style & wxLB_MULTIPLE )
1377                 {
1378                     action = wxACTION_LISTBOX_TOGGLE;
1379                     isMoveCmd = false;
1380                 }
1381                 break;
1382
1383             case WXK_RETURN:
1384                 action = wxACTION_LISTBOX_ACTIVATE;
1385                 isMoveCmd = false;
1386                 break;
1387
1388             default:
1389                 if ( (keycode < 255) && wxIsalnum((wxChar)keycode) )
1390                 {
1391                     action = wxACTION_LISTBOX_FIND;
1392                     strArg = (wxChar)keycode;
1393                 }
1394         }
1395
1396         if ( !action.IsEmpty() )
1397         {
1398             consumer->PerformAction(action, -1, strArg);
1399
1400             if ( isMoveCmd )
1401             {
1402                 if ( style & wxLB_SINGLE )
1403                 {
1404                     // the current item is always the one selected
1405                     consumer->PerformAction(wxACTION_LISTBOX_SELECT);
1406                 }
1407                 else if ( style & wxLB_EXTENDED )
1408                 {
1409                     if ( event.ShiftDown() )
1410                         consumer->PerformAction(wxACTION_LISTBOX_EXTENDSEL);
1411                     else
1412                     {
1413                         // select the item and make it the new selection anchor
1414                         consumer->PerformAction(wxACTION_LISTBOX_SELECT);
1415                         consumer->PerformAction(wxACTION_LISTBOX_ANCHOR);
1416                     }
1417                 }
1418                 //else: nothing to do for multiple selection listboxes
1419             }
1420
1421             return true;
1422         }
1423     }
1424
1425     return wxStdInputHandler::HandleKey(consumer, event, pressed);
1426 }
1427
1428 bool wxStdListboxInputHandler::HandleMouse(wxInputConsumer *consumer,
1429                                            const wxMouseEvent& event)
1430 {
1431     wxListBox *lbox = wxStaticCast(consumer->GetInputWindow(), wxListBox);
1432     int item = HitTest(lbox, event);
1433     wxControlAction action;
1434
1435     // when the left mouse button is pressed, capture the mouse and track the
1436     // item under mouse (if the mouse leaves the window, we will still be
1437     // getting the mouse move messages generated by wxScrollWindow)
1438     if ( event.LeftDown() )
1439     {
1440         // capture the mouse to track the selected item
1441         lbox->CaptureMouse();
1442
1443         action = SetupCapture(lbox, event, item);
1444     }
1445     else if ( m_btnCapture && event.ButtonUp(m_btnCapture) )
1446     {
1447         // when the left mouse button is released, release the mouse too
1448         wxWindow *winCapture = wxWindow::GetCapture();
1449         if ( winCapture )
1450         {
1451             winCapture->ReleaseMouse();
1452             m_btnCapture = 0;
1453
1454             action = m_actionMouse;
1455         }
1456         //else: the mouse wasn't presed over the listbox, only released here
1457     }
1458     else if ( event.LeftDClick() )
1459     {
1460         action = wxACTION_LISTBOX_ACTIVATE;
1461     }
1462
1463     if ( !action.IsEmpty() )
1464     {
1465         lbox->PerformAction(action, item);
1466
1467         return true;
1468     }
1469
1470     return wxStdInputHandler::HandleMouse(consumer, event);
1471 }
1472
1473 bool wxStdListboxInputHandler::HandleMouseMove(wxInputConsumer *consumer,
1474                                                const wxMouseEvent& event)
1475 {
1476     wxWindow *winCapture = wxWindow::GetCapture();
1477     if ( winCapture && (event.GetEventObject() == winCapture) )
1478     {
1479         wxListBox *lbox = wxStaticCast(consumer->GetInputWindow(), wxListBox);
1480
1481         if ( !m_btnCapture || !m_trackMouseOutside )
1482         {
1483             // someone captured the mouse for us (we always set m_btnCapture
1484             // when we do it ourselves): in this case we only react to
1485             // the mouse messages when they happen inside the listbox
1486             if ( lbox->HitTest(event.GetPosition()) != wxHT_WINDOW_INSIDE )
1487                 return false;
1488         }
1489
1490         int item = HitTest(lbox, event);
1491         if ( !m_btnCapture )
1492         {
1493             // now that we have the mouse inside the listbox, do capture it
1494             // normally - but ensure that we will still ignore the outside
1495             // events
1496             SetupCapture(lbox, event, item);
1497
1498             m_trackMouseOutside = false;
1499         }
1500
1501         if ( IsValidIndex(lbox, item) )
1502         {
1503             // pass something into strArg to tell the listbox that it shouldn't
1504             // send the notification message: see PerformAction() above
1505             lbox->PerformAction(m_actionMouse, item, wxT("no"));
1506         }
1507         // else: don't pass invalid index to the listbox
1508     }
1509     else // we don't have capture any more
1510     {
1511         if ( m_btnCapture )
1512         {
1513             // if we lost capture unexpectedly (someone else took the capture
1514             // from us), return to a consistent state
1515             m_btnCapture = 0;
1516         }
1517     }
1518
1519     return wxStdInputHandler::HandleMouseMove(consumer, event);
1520 }
1521
1522 #endif // wxUSE_LISTBOX