src/univ/listbox.cpp

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