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