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