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