]>
Commit | Line | Data |
---|---|---|
e0c6027b | 1 | /////////////////////////////////////////////////////////////////////////////// |
e19ac18a | 2 | // Name: src/generic/vlbox.cpp |
e0c6027b VZ |
3 | // Purpose: implementation of wxVListBox |
4 | // Author: Vadim Zeitlin | |
5 | // Modified by: | |
6 | // Created: 31.05.03 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 2003 Vadim Zeitlin <vadim@wxwindows.org> | |
0a53b9b8 | 9 | // License: wxWindows license |
e0c6027b VZ |
10 | /////////////////////////////////////////////////////////////////////////////// |
11 | ||
12 | // ============================================================================ | |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
20 | // For compilers that support precompilation, includes "wx.h". | |
21 | #include "wx/wxprec.h" | |
22 | ||
23 | #ifdef __BORLANDC__ | |
24 | #pragma hdrstop | |
25 | #endif | |
26 | ||
179e085f RN |
27 | #if wxUSE_LISTBOX |
28 | ||
2a673eb1 WS |
29 | #include "wx/vlbox.h" |
30 | ||
e0c6027b VZ |
31 | #ifndef WX_PRECOMP |
32 | #include "wx/settings.h" | |
bb178b29 | 33 | #include "wx/dcclient.h" |
2a673eb1 | 34 | #include "wx/listbox.h" |
e0c6027b VZ |
35 | #endif //WX_PRECOMP |
36 | ||
0975a8a0 | 37 | #include "wx/dcbuffer.h" |
be465555 | 38 | #include "wx/selstore.h" |
04125489 | 39 | #include "wx/renderer.h" |
e0c6027b VZ |
40 | |
41 | // ---------------------------------------------------------------------------- | |
42 | // event tables | |
43 | // ---------------------------------------------------------------------------- | |
44 | ||
45 | BEGIN_EVENT_TABLE(wxVListBox, wxVScrolledWindow) | |
46 | EVT_PAINT(wxVListBox::OnPaint) | |
47 | ||
48 | EVT_KEY_DOWN(wxVListBox::OnKeyDown) | |
49 | EVT_LEFT_DOWN(wxVListBox::OnLeftDown) | |
50 | EVT_LEFT_DCLICK(wxVListBox::OnLeftDClick) | |
04125489 VZ |
51 | |
52 | EVT_SET_FOCUS(wxVListBox::OnSetOrKillFocus) | |
53 | EVT_KILL_FOCUS(wxVListBox::OnSetOrKillFocus) | |
e0c6027b VZ |
54 | END_EVENT_TABLE() |
55 | ||
56 | // ============================================================================ | |
57 | // implementation | |
58 | // ============================================================================ | |
59 | ||
0c8392ca RD |
60 | IMPLEMENT_ABSTRACT_CLASS(wxVListBox, wxVScrolledWindow) |
61 | ||
e0c6027b VZ |
62 | // ---------------------------------------------------------------------------- |
63 | // wxVListBox creation | |
64 | // ---------------------------------------------------------------------------- | |
65 | ||
66 | void wxVListBox::Init() | |
67 | { | |
970b97a2 VZ |
68 | m_current = |
69 | m_anchor = wxNOT_FOUND; | |
be465555 | 70 | m_selStore = NULL; |
e0c6027b VZ |
71 | } |
72 | ||
73 | bool wxVListBox::Create(wxWindow *parent, | |
74 | wxWindowID id, | |
75 | const wxPoint& pos, | |
76 | const wxSize& size, | |
e0c6027b VZ |
77 | long style, |
78 | const wxString& name) | |
79 | { | |
a047aff2 JS |
80 | #ifdef __WXMSW__ |
81 | if ((style & wxBORDER_MASK) == wxDEFAULT) | |
82 | style |= wxBORDER_THEME; | |
83 | #endif | |
84 | ||
fef7400f | 85 | style |= wxWANTS_CHARS | wxFULL_REPAINT_ON_RESIZE; |
e0c6027b VZ |
86 | if ( !wxVScrolledWindow::Create(parent, id, pos, size, style, name) ) |
87 | return false; | |
88 | ||
be465555 VZ |
89 | if ( style & wxLB_MULTIPLE ) |
90 | m_selStore = new wxSelectionStore; | |
e0c6027b | 91 | |
dc596072 RD |
92 | // make sure the native widget has the right colour since we do |
93 | // transparent drawing by default | |
94 | SetBackgroundColour(GetBackgroundColour()); | |
04125489 VZ |
95 | |
96 | // leave m_colBgSel in an invalid state: it means for OnDrawBackground() | |
97 | // to use wxRendererNative instead of painting selection bg ourselves | |
98 | m_colBgSel = wxNullColour; | |
9a9b4940 | 99 | |
0975a8a0 JS |
100 | // flicker-free drawing requires this |
101 | SetBackgroundStyle(wxBG_STYLE_CUSTOM); | |
102 | ||
e0c6027b VZ |
103 | return true; |
104 | } | |
105 | ||
be465555 VZ |
106 | wxVListBox::~wxVListBox() |
107 | { | |
108 | delete m_selStore; | |
109 | } | |
110 | ||
111 | void wxVListBox::SetItemCount(size_t count) | |
112 | { | |
113 | if ( m_selStore ) | |
114 | { | |
115 | // tell the selection store that our number of items has changed | |
116 | m_selStore->SetItemCount(count); | |
117 | } | |
118 | ||
f18eaf26 | 119 | SetRowCount(count); |
be465555 VZ |
120 | } |
121 | ||
e0c6027b VZ |
122 | // ---------------------------------------------------------------------------- |
123 | // selection handling | |
124 | // ---------------------------------------------------------------------------- | |
125 | ||
be465555 VZ |
126 | bool wxVListBox::IsSelected(size_t line) const |
127 | { | |
128 | return m_selStore ? m_selStore->IsSelected(line) : (int)line == m_current; | |
129 | } | |
130 | ||
131 | bool wxVListBox::Select(size_t item, bool select) | |
132 | { | |
133 | wxCHECK_MSG( m_selStore, false, | |
134 | _T("Select() may only be used with multiselection listbox") ); | |
135 | ||
136 | wxCHECK_MSG( item < GetItemCount(), false, | |
137 | _T("Select(): invalid item index") ); | |
138 | ||
139 | bool changed = m_selStore->SelectItem(item, select); | |
140 | if ( changed ) | |
141 | { | |
142 | // selection really changed | |
e02c72fa | 143 | RefreshRow(item); |
be465555 VZ |
144 | } |
145 | ||
146 | DoSetCurrent(item); | |
147 | ||
148 | return changed; | |
149 | } | |
150 | ||
151 | bool wxVListBox::SelectRange(size_t from, size_t to) | |
e0c6027b | 152 | { |
be465555 VZ |
153 | wxCHECK_MSG( m_selStore, false, |
154 | _T("SelectRange() may only be used with multiselection listbox") ); | |
155 | ||
156 | // make sure items are in correct order | |
157 | if ( from > to ) | |
158 | { | |
159 | size_t tmp = from; | |
160 | from = to; | |
161 | to = tmp; | |
162 | } | |
163 | ||
164 | wxCHECK_MSG( to < GetItemCount(), false, | |
165 | _T("SelectRange(): invalid item index") ); | |
166 | ||
167 | wxArrayInt changed; | |
168 | if ( !m_selStore->SelectRange(from, to, true, &changed) ) | |
169 | { | |
170 | // too many items have changed, we didn't record them in changed array | |
171 | // so we have no choice but to refresh everything between from and to | |
e02c72fa | 172 | RefreshRows(from, to); |
be465555 VZ |
173 | } |
174 | else // we've got the indices of the changed items | |
175 | { | |
176 | const size_t count = changed.GetCount(); | |
177 | if ( !count ) | |
178 | { | |
179 | // nothing changed | |
180 | return false; | |
181 | } | |
182 | ||
183 | // refresh just the lines which have really changed | |
184 | for ( size_t n = 0; n < count; n++ ) | |
185 | { | |
e02c72fa | 186 | RefreshRow(changed[n]); |
be465555 VZ |
187 | } |
188 | } | |
189 | ||
190 | // something changed | |
191 | return true; | |
192 | } | |
193 | ||
194 | bool wxVListBox::DoSelectAll(bool select) | |
195 | { | |
196 | wxCHECK_MSG( m_selStore, false, | |
197 | _T("SelectAll may only be used with multiselection listbox") ); | |
198 | ||
199 | size_t count = GetItemCount(); | |
200 | if ( count ) | |
201 | { | |
202 | wxArrayInt changed; | |
203 | if ( !m_selStore->SelectRange(0, count - 1, select) || | |
204 | !changed.IsEmpty() ) | |
205 | { | |
206 | Refresh(); | |
207 | ||
208 | // something changed | |
209 | return true; | |
210 | } | |
211 | } | |
212 | ||
213 | return false; | |
214 | } | |
215 | ||
216 | bool wxVListBox::DoSetCurrent(int current) | |
217 | { | |
6c9210a7 VZ |
218 | wxASSERT_MSG( current == wxNOT_FOUND || |
219 | (current >= 0 && (size_t)current < GetItemCount()), | |
220 | _T("wxVListBox::DoSetCurrent(): invalid item index") ); | |
221 | ||
be465555 | 222 | if ( current == m_current ) |
e0c6027b VZ |
223 | { |
224 | // nothing to do | |
be465555 | 225 | return false; |
e0c6027b VZ |
226 | } |
227 | ||
be465555 | 228 | if ( m_current != wxNOT_FOUND ) |
e02c72fa | 229 | RefreshRow(m_current); |
e0c6027b | 230 | |
be465555 | 231 | m_current = current; |
e0c6027b | 232 | |
be465555 | 233 | if ( m_current != wxNOT_FOUND ) |
e0c6027b VZ |
234 | { |
235 | // if the line is not visible at all, we scroll it into view but we | |
236 | // don't need to refresh it -- it will be redrawn anyhow | |
be465555 | 237 | if ( !IsVisible(m_current) ) |
e0c6027b | 238 | { |
e02c72fa | 239 | ScrollToRow(m_current); |
e0c6027b VZ |
240 | } |
241 | else // line is at least partly visible | |
242 | { | |
243 | // it is, indeed, only partly visible, so scroll it into view to | |
244 | // make it entirely visible | |
e02c72fa VZ |
245 | while ( (size_t)m_current + 1 == GetVisibleRowsEnd() && |
246 | ScrollToRow(GetVisibleBegin() + 1) ) ; | |
e0c6027b VZ |
247 | |
248 | // but in any case refresh it as even if it was only partly visible | |
249 | // before we need to redraw it entirely as its background changed | |
e02c72fa | 250 | RefreshRow(m_current); |
e0c6027b | 251 | } |
be465555 | 252 | } |
e0c6027b | 253 | |
be465555 VZ |
254 | return true; |
255 | } | |
e0c6027b | 256 | |
be465555 VZ |
257 | void wxVListBox::SendSelectedEvent() |
258 | { | |
259 | wxASSERT_MSG( m_current != wxNOT_FOUND, | |
260 | _T("SendSelectedEvent() shouldn't be called") ); | |
261 | ||
262 | wxCommandEvent event(wxEVT_COMMAND_LISTBOX_SELECTED, GetId()); | |
263 | event.SetEventObject(this); | |
687706f5 | 264 | event.SetInt(m_current); |
be465555 VZ |
265 | |
266 | (void)GetEventHandler()->ProcessEvent(event); | |
267 | } | |
268 | ||
269 | void wxVListBox::SetSelection(int selection) | |
270 | { | |
6c9210a7 VZ |
271 | wxCHECK_RET( selection == wxNOT_FOUND || |
272 | (selection >= 0 && (size_t)selection < GetItemCount()), | |
273 | _T("wxVListBox::SetSelection(): invalid item index") ); | |
274 | ||
de5d3a20 VZ |
275 | if ( HasMultipleSelection() ) |
276 | { | |
ad679137 VZ |
277 | if (selection != wxNOT_FOUND) |
278 | Select(selection); | |
279 | else | |
280 | DeselectAll(); | |
de5d3a20 VZ |
281 | m_anchor = selection; |
282 | } | |
be465555 VZ |
283 | |
284 | DoSetCurrent(selection); | |
285 | } | |
286 | ||
287 | size_t wxVListBox::GetSelectedCount() const | |
288 | { | |
289 | return m_selStore ? m_selStore->GetSelectedCount() | |
290 | : m_current == wxNOT_FOUND ? 0 : 1; | |
291 | } | |
292 | ||
293 | int wxVListBox::GetFirstSelected(unsigned long& cookie) const | |
294 | { | |
295 | cookie = 0; | |
296 | ||
297 | return GetNextSelected(cookie); | |
298 | } | |
299 | ||
300 | int wxVListBox::GetNextSelected(unsigned long& cookie) const | |
301 | { | |
302 | wxCHECK_MSG( m_selStore, wxNOT_FOUND, | |
303 | _T("GetFirst/NextSelected() may only be used with multiselection listboxes") ); | |
304 | ||
305 | while ( cookie < GetItemCount() ) | |
306 | { | |
307 | if ( IsSelected(cookie++) ) | |
308 | return cookie - 1; | |
e0c6027b | 309 | } |
be465555 VZ |
310 | |
311 | return wxNOT_FOUND; | |
e0c6027b VZ |
312 | } |
313 | ||
04125489 VZ |
314 | void wxVListBox::RefreshSelected() |
315 | { | |
316 | // only refresh those items which are currently visible and selected: | |
317 | for ( size_t n = GetVisibleBegin(), end = GetVisibleEnd(); n < end; n++ ) | |
318 | { | |
319 | if ( IsSelected(n) ) | |
f18eaf26 | 320 | RefreshRow(n); |
04125489 VZ |
321 | } |
322 | } | |
323 | ||
e0c6027b | 324 | // ---------------------------------------------------------------------------- |
9a9b4940 | 325 | // wxVListBox appearance parameters |
e0c6027b VZ |
326 | // ---------------------------------------------------------------------------- |
327 | ||
328 | void wxVListBox::SetMargins(const wxPoint& pt) | |
329 | { | |
330 | if ( pt != m_ptMargins ) | |
331 | { | |
332 | m_ptMargins = pt; | |
333 | ||
334 | Refresh(); | |
335 | } | |
336 | } | |
337 | ||
9a9b4940 VZ |
338 | void wxVListBox::SetSelectionBackground(const wxColour& col) |
339 | { | |
340 | m_colBgSel = col; | |
341 | } | |
342 | ||
343 | // ---------------------------------------------------------------------------- | |
344 | // wxVListBox painting | |
345 | // ---------------------------------------------------------------------------- | |
346 | ||
e02c72fa | 347 | wxCoord wxVListBox::OnGetRowHeight(size_t line) const |
e0c6027b VZ |
348 | { |
349 | return OnMeasureItem(line) + 2*m_ptMargins.y; | |
350 | } | |
351 | ||
352 | void wxVListBox::OnDrawSeparator(wxDC& WXUNUSED(dc), | |
353 | wxRect& WXUNUSED(rect), | |
354 | size_t WXUNUSED(n)) const | |
355 | { | |
356 | } | |
357 | ||
27d0dcd0 VZ |
358 | void wxVListBox::OnDrawBackground(wxDC& dc, const wxRect& rect, size_t n) const |
359 | { | |
04125489 | 360 | if ( m_colBgSel.IsOk() ) |
27d0dcd0 | 361 | { |
04125489 VZ |
362 | // we need to render selected and current items differently |
363 | const bool isSelected = IsSelected(n), | |
364 | isCurrent = IsCurrent(n); | |
365 | if ( isSelected || isCurrent ) | |
27d0dcd0 | 366 | { |
04125489 VZ |
367 | if ( isSelected ) |
368 | { | |
369 | dc.SetBrush(wxBrush(m_colBgSel, wxSOLID)); | |
370 | } | |
371 | else // !selected | |
372 | { | |
373 | dc.SetBrush(*wxTRANSPARENT_BRUSH); | |
374 | } | |
375 | dc.SetPen(*(isCurrent ? wxBLACK_PEN : wxTRANSPARENT_PEN)); | |
376 | dc.DrawRectangle(rect); | |
27d0dcd0 | 377 | } |
04125489 VZ |
378 | //else: do nothing for the normal items |
379 | } | |
380 | else // use wxRendererNative for a more native look&feel: | |
381 | { | |
382 | int flags = 0; | |
383 | if ( IsSelected(n) ) | |
384 | flags |= wxCONTROL_SELECTED; | |
385 | if ( IsCurrent(n) ) | |
386 | flags |= wxCONTROL_CURRENT; | |
d836b8bc | 387 | if ( wxWindow::FindFocus() == wx_const_cast(wxVListBox*, this) ) |
04125489 VZ |
388 | flags |= wxCONTROL_FOCUSED; |
389 | ||
390 | wxRendererNative::Get().DrawItemSelectionRect( | |
391 | wx_const_cast(wxVListBox *, this), dc, rect, flags); | |
27d0dcd0 | 392 | } |
27d0dcd0 VZ |
393 | } |
394 | ||
395 | void wxVListBox::OnPaint(wxPaintEvent& WXUNUSED(event)) | |
e0c6027b | 396 | { |
0975a8a0 JS |
397 | wxSize clientSize = GetClientSize(); |
398 | ||
2e992e06 | 399 | wxAutoBufferedPaintDC dc(this); |
e0c6027b VZ |
400 | |
401 | // the update rectangle | |
402 | wxRect rectUpdate = GetUpdateClientRect(); | |
403 | ||
959b1a33 VZ |
404 | // fill it with background colour |
405 | dc.SetBackground(GetBackgroundColour()); | |
0975a8a0 JS |
406 | dc.Clear(); |
407 | ||
e0c6027b | 408 | // the bounding rectangle of the current line |
e02c72fa VZ |
409 | wxRect rectRow; |
410 | rectRow.width = clientSize.x; | |
e0c6027b VZ |
411 | |
412 | // iterate over all visible lines | |
b1b408af | 413 | const size_t lineMax = GetVisibleEnd(); |
e02c72fa | 414 | for ( size_t line = GetVisibleBegin(); line < lineMax; line++ ) |
e0c6027b | 415 | { |
e02c72fa | 416 | const wxCoord hRow = OnGetRowHeight(line); |
e0c6027b | 417 | |
e02c72fa | 418 | rectRow.height = hRow; |
e0c6027b VZ |
419 | |
420 | // and draw the ones which intersect the update rect | |
e02c72fa | 421 | if ( rectRow.Intersects(rectUpdate) ) |
e0c6027b VZ |
422 | { |
423 | // don't allow drawing outside of the lines rectangle | |
e02c72fa | 424 | wxDCClipper clip(dc, rectRow); |
e0c6027b | 425 | |
e02c72fa | 426 | wxRect rect = rectRow; |
27d0dcd0 VZ |
427 | OnDrawBackground(dc, rect, line); |
428 | ||
e0c6027b VZ |
429 | OnDrawSeparator(dc, rect, line); |
430 | ||
431 | rect.Deflate(m_ptMargins.x, m_ptMargins.y); | |
432 | OnDrawItem(dc, rect, line); | |
433 | } | |
434 | else // no intersection | |
435 | { | |
e02c72fa | 436 | if ( rectRow.GetTop() > rectUpdate.GetBottom() ) |
e0c6027b VZ |
437 | { |
438 | // we are already below the update rect, no need to continue | |
439 | // further | |
440 | break; | |
441 | } | |
442 | //else: the next line may intersect the update rect | |
443 | } | |
444 | ||
e02c72fa | 445 | rectRow.y += hRow; |
e0c6027b VZ |
446 | } |
447 | } | |
448 | ||
04125489 VZ |
449 | void wxVListBox::OnSetOrKillFocus(wxFocusEvent& WXUNUSED(event)) |
450 | { | |
451 | // we need to repaint the selection when we get the focus since | |
452 | // wxRendererNative in general draws the focused selection differently | |
453 | // from the unfocused selection (see OnDrawItem): | |
454 | RefreshSelected(); | |
455 | } | |
456 | ||
457 | ||
be465555 VZ |
458 | // ============================================================================ |
459 | // wxVListBox keyboard/mouse handling | |
460 | // ============================================================================ | |
461 | ||
970b97a2 | 462 | void wxVListBox::DoHandleItemClick(int item, int flags) |
be465555 VZ |
463 | { |
464 | // has anything worth telling the client code about happened? | |
465 | bool notify = false; | |
466 | ||
467 | if ( HasMultipleSelection() ) | |
468 | { | |
469 | // select the iteem clicked? | |
470 | bool select = true; | |
471 | ||
472 | // NB: the keyboard interface we implement here corresponds to | |
473 | // wxLB_EXTENDED rather than wxLB_MULTIPLE but this one makes more | |
474 | // sense IMHO | |
970b97a2 | 475 | if ( flags & ItemClick_Shift ) |
be465555 VZ |
476 | { |
477 | if ( m_current != wxNOT_FOUND ) | |
478 | { | |
970b97a2 VZ |
479 | if ( m_anchor == wxNOT_FOUND ) |
480 | m_anchor = m_current; | |
481 | ||
be465555 VZ |
482 | select = false; |
483 | ||
970b97a2 VZ |
484 | // only the range from the selection anchor to new m_current |
485 | // must be selected | |
be465555 VZ |
486 | if ( DeselectAll() ) |
487 | notify = true; | |
488 | ||
970b97a2 | 489 | if ( SelectRange(m_anchor, item) ) |
be465555 VZ |
490 | notify = true; |
491 | } | |
492 | //else: treat it as ordinary click/keypress | |
493 | } | |
970b97a2 | 494 | else // Shift not pressed |
be465555 | 495 | { |
970b97a2 | 496 | m_anchor = item; |
be465555 | 497 | |
970b97a2 VZ |
498 | if ( flags & ItemClick_Ctrl ) |
499 | { | |
500 | select = false; | |
be465555 | 501 | |
970b97a2 VZ |
502 | if ( !(flags & ItemClick_Kbd) ) |
503 | { | |
504 | Toggle(item); | |
505 | ||
506 | // the status of the item has definitely changed | |
507 | notify = true; | |
508 | } | |
509 | //else: Ctrl-arrow pressed, don't change selection | |
510 | } | |
511 | //else: behave as in single selection case | |
be465555 | 512 | } |
be465555 VZ |
513 | |
514 | if ( select ) | |
515 | { | |
516 | // make the clicked item the only selection | |
517 | if ( DeselectAll() ) | |
518 | notify = true; | |
519 | ||
520 | if ( Select(item) ) | |
521 | notify = true; | |
522 | } | |
523 | } | |
524 | ||
525 | // in any case the item should become the current one | |
526 | if ( DoSetCurrent(item) ) | |
527 | { | |
528 | if ( !HasMultipleSelection() ) | |
529 | { | |
530 | // this has also changed the selection for single selection case | |
531 | notify = true; | |
532 | } | |
533 | } | |
534 | ||
535 | if ( notify ) | |
536 | { | |
537 | // notify the user about the selection change | |
538 | SendSelectedEvent(); | |
539 | } | |
540 | //else: nothing changed at all | |
541 | } | |
542 | ||
e0c6027b | 543 | // ---------------------------------------------------------------------------- |
be465555 | 544 | // keyboard handling |
e0c6027b VZ |
545 | // ---------------------------------------------------------------------------- |
546 | ||
547 | void wxVListBox::OnKeyDown(wxKeyEvent& event) | |
548 | { | |
970b97a2 VZ |
549 | // flags for DoHandleItemClick() |
550 | int flags = ItemClick_Kbd; | |
551 | ||
999836aa | 552 | int current; |
e0c6027b VZ |
553 | switch ( event.GetKeyCode() ) |
554 | { | |
555 | case WXK_HOME: | |
be465555 | 556 | current = 0; |
e0c6027b VZ |
557 | break; |
558 | ||
559 | case WXK_END: | |
e02c72fa | 560 | current = GetRowCount() - 1; |
e0c6027b VZ |
561 | break; |
562 | ||
563 | case WXK_DOWN: | |
e02c72fa | 564 | if ( m_current == (int)GetRowCount() - 1 ) |
e0c6027b VZ |
565 | return; |
566 | ||
be465555 | 567 | current = m_current + 1; |
e0c6027b VZ |
568 | break; |
569 | ||
570 | case WXK_UP: | |
be465555 | 571 | if ( m_current == wxNOT_FOUND ) |
e02c72fa | 572 | current = GetRowCount() - 1; |
be465555 VZ |
573 | else if ( m_current != 0 ) |
574 | current = m_current - 1; | |
575 | else // m_current == 0 | |
e0c6027b VZ |
576 | return; |
577 | break; | |
578 | ||
579 | case WXK_PAGEDOWN: | |
e0c6027b | 580 | PageDown(); |
e02c72fa | 581 | current = GetVisibleBegin(); |
e0c6027b VZ |
582 | break; |
583 | ||
584 | case WXK_PAGEUP: | |
e02c72fa | 585 | if ( m_current == (int)GetVisibleBegin() ) |
e0c6027b VZ |
586 | { |
587 | PageUp(); | |
588 | } | |
589 | ||
e02c72fa | 590 | current = GetVisibleBegin(); |
e0c6027b VZ |
591 | break; |
592 | ||
970b97a2 VZ |
593 | case WXK_SPACE: |
594 | // hack: pressing space should work like a mouse click rather than | |
595 | // like a keyboard arrow press, so trick DoHandleItemClick() in | |
596 | // thinking we were clicked | |
597 | flags &= ~ItemClick_Kbd; | |
598 | current = m_current; | |
599 | break; | |
600 | ||
80c700cb RD |
601 | #ifdef __WXMSW__ |
602 | case WXK_TAB: | |
603 | // Since we are using wxWANTS_CHARS we need to send navigation | |
604 | // events for the tabs on MSW | |
f029f1d1 | 605 | HandleAsNavigationKey(event); |
80c700cb RD |
606 | // fall through to default |
607 | #endif | |
e0c6027b VZ |
608 | default: |
609 | event.Skip(); | |
999836aa | 610 | current = 0; // just to silent the stupid compiler warnings |
8703bc01 | 611 | wxUnusedVar(current); |
e0c6027b VZ |
612 | return; |
613 | } | |
614 | ||
970b97a2 VZ |
615 | if ( event.ShiftDown() ) |
616 | flags |= ItemClick_Shift; | |
617 | if ( event.ControlDown() ) | |
618 | flags |= ItemClick_Ctrl; | |
619 | ||
620 | DoHandleItemClick(current, flags); | |
e0c6027b VZ |
621 | } |
622 | ||
623 | // ---------------------------------------------------------------------------- | |
624 | // wxVListBox mouse handling | |
625 | // ---------------------------------------------------------------------------- | |
626 | ||
627 | void wxVListBox::OnLeftDown(wxMouseEvent& event) | |
628 | { | |
c7778877 | 629 | SetFocus(); |
4e115ed2 | 630 | |
10368bff | 631 | int item = VirtualHitTest(event.GetPosition().y); |
e0c6027b | 632 | |
6c9210a7 VZ |
633 | if ( item != wxNOT_FOUND ) |
634 | { | |
970b97a2 VZ |
635 | int flags = 0; |
636 | if ( event.ShiftDown() ) | |
637 | flags |= ItemClick_Shift; | |
638 | ||
6c9210a7 VZ |
639 | // under Mac Apple-click is used in the same way as Ctrl-click |
640 | // elsewhere | |
be465555 | 641 | #ifdef __WXMAC__ |
970b97a2 | 642 | if ( event.MetaDown() ) |
be465555 | 643 | #else |
970b97a2 | 644 | if ( event.ControlDown() ) |
be465555 | 645 | #endif |
970b97a2 VZ |
646 | flags |= ItemClick_Ctrl; |
647 | ||
648 | DoHandleItemClick(item, flags); | |
6c9210a7 | 649 | } |
e0c6027b VZ |
650 | } |
651 | ||
4e115ed2 | 652 | void wxVListBox::OnLeftDClick(wxMouseEvent& eventMouse) |
e0c6027b | 653 | { |
10368bff | 654 | int item = VirtualHitTest(eventMouse.GetPosition().y); |
be465555 | 655 | if ( item != wxNOT_FOUND ) |
e0c6027b | 656 | { |
e0c6027b | 657 | |
0975a8a0 JS |
658 | // if item double-clicked was not yet selected, then treat |
659 | // this event as a left-click instead | |
660 | if ( item == m_current ) | |
661 | { | |
662 | wxCommandEvent event(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, GetId()); | |
663 | event.SetEventObject(this); | |
664 | event.SetInt(item); | |
665 | ||
666 | (void)GetEventHandler()->ProcessEvent(event); | |
667 | } | |
668 | else | |
669 | { | |
670 | OnLeftDown(eventMouse); | |
671 | } | |
e19ac18a | 672 | |
e0c6027b VZ |
673 | } |
674 | } | |
675 | ||
dc596072 RD |
676 | |
677 | // ---------------------------------------------------------------------------- | |
678 | // use the same default attributes as wxListBox | |
679 | // ---------------------------------------------------------------------------- | |
680 | ||
dc596072 RD |
681 | //static |
682 | wxVisualAttributes | |
683 | wxVListBox::GetClassDefaultAttributes(wxWindowVariant variant) | |
684 | { | |
685 | return wxListBox::GetClassDefaultAttributes(variant); | |
686 | } | |
179e085f | 687 | |
8b939bc0 | 688 | #endif |