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