src/generic/vlbox.cpp

   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 // License:     wxWindows license
  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 END_EVENT_TABLE()
  55
  56 // ============================================================================
  57 // implementation
  58 // ============================================================================
  59
  60 IMPLEMENT_ABSTRACT_CLASS(wxVListBox, wxVScrolledWindow)
  61
  62 // ----------------------------------------------------------------------------
  63 // wxVListBox creation
  64 // ----------------------------------------------------------------------------
  65
  66 void wxVListBox::Init()
  67 {
  68     m_current =
  69     m_anchor = wxNOT_FOUND;
  70     m_selStore = NULL;
  71 }
  72
  73 bool wxVListBox::Create(wxWindow *parent,
  74                         wxWindowID id,
  75                         const wxPoint& pos,
  76                         const wxSize& size,
  77                         long style,
  78                         const wxString& name)
  79 {
  80 #ifdef __WXMSW__
  81         if ((style & wxBORDER_MASK) == wxDEFAULT)
  82                 style |= wxBORDER_THEME;
  83 #endif
  84
  85     style |= wxWANTS_CHARS | wxFULL_REPAINT_ON_RESIZE;
  86     if ( !wxVScrolledWindow::Create(parent, id, pos, size, style, name) )
  87         return false;
  88
  89     if ( style & wxLB_MULTIPLE )
  90         m_selStore = new wxSelectionStore;
  91
  92     // make sure the native widget has the right colour since we do
  93     // transparent drawing by default
  94     SetBackgroundColour(GetBackgroundColour());
  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;
  99
 100     // flicker-free drawing requires this
 101     SetBackgroundStyle(wxBG_STYLE_CUSTOM);
 102
 103     return true;
 104 }
 105
 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
 119     SetRowCount(count);
 120 }
 121
 122 // ----------------------------------------------------------------------------
 123 // selection handling
 124 // ----------------------------------------------------------------------------
 125
 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
 143         RefreshRow(item);
 144     }
 145
 146     DoSetCurrent(item);
 147
 148     return changed;
 149 }
 150
 151 bool wxVListBox::SelectRange(size_t from, size_t to)
 152 {
 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
 172         RefreshRows(from, to);
 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         {
 186             RefreshRow(changed[n]);
 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 {
 218     wxASSERT_MSG( current == wxNOT_FOUND ||
 219                     (current >= 0 && (size_t)current < GetItemCount()),
 220                   _T("wxVListBox::DoSetCurrent(): invalid item index") );
 221
 222     if ( current == m_current )
 223     {
 224         // nothing to do
 225         return false;
 226     }
 227
 228     if ( m_current != wxNOT_FOUND )
 229         RefreshRow(m_current);
 230
 231     m_current = current;
 232
 233     if ( m_current != wxNOT_FOUND )
 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
 237         if ( !IsVisible(m_current) )
 238         {
 239             ScrollToRow(m_current);
 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
 245             while ( (size_t)m_current + 1 == GetVisibleRowsEnd() &&
 246                     ScrollToRow(GetVisibleBegin() + 1) ) ;
 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
 250             RefreshRow(m_current);
 251         }
 252     }
 253
 254     return true;
 255 }
 256
 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);
 264     event.SetInt(m_current);
 265
 266     (void)GetEventHandler()->ProcessEvent(event);
 267 }
 268
 269 void wxVListBox::SetSelection(int selection)
 270 {
 271     wxCHECK_RET( selection == wxNOT_FOUND ||
 272                   (selection >= 0 && (size_t)selection < GetItemCount()),
 273                   _T("wxVListBox::SetSelection(): invalid item index") );
 274
 275     if ( HasMultipleSelection() )
 276     {
 277         if (selection != wxNOT_FOUND)
 278             Select(selection);
 279         else
 280             DeselectAll();
 281         m_anchor = selection;
 282     }
 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;
 309     }
 310
 311     return wxNOT_FOUND;
 312 }
 313
 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) )
 320             RefreshRow(n);
 321     }
 322 }
 323
 324 // ----------------------------------------------------------------------------
 325 // wxVListBox appearance parameters
 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
 338 void wxVListBox::SetSelectionBackground(const wxColour& col)
 339 {
 340     m_colBgSel = col;
 341 }
 342
 343 // ----------------------------------------------------------------------------
 344 // wxVListBox painting
 345 // ----------------------------------------------------------------------------
 346
 347 wxCoord wxVListBox::OnGetRowHeight(size_t line) const
 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
 358 bool
 359 wxVListBox::DoDrawSolidBackground(const wxColour& col,
 360                                   wxDC& dc,
 361                                   const wxRect& rect,
 362                                   size_t n) const
 363 {
 364     if ( !col.IsOk() )
 365         return false;
 366
 367     // we need to render selected and current items differently
 368     const bool isSelected = IsSelected(n),
 369                isCurrent = IsCurrent(n);
 370     if ( isSelected || isCurrent )
 371     {
 372         if ( isSelected )
 373         {
 374             dc.SetBrush(wxBrush(col, wxBRUSHSTYLE_SOLID));
 375         }
 376         else // !selected
 377         {
 378             dc.SetBrush(*wxTRANSPARENT_BRUSH);
 379         }
 380         dc.SetPen(*(isCurrent ? wxBLACK_PEN : wxTRANSPARENT_PEN));
 381         dc.DrawRectangle(rect);
 382     }
 383     //else: do nothing for the normal items
 384
 385     return true;
 386 }
 387
 388 void wxVListBox::OnDrawBackground(wxDC& dc, const wxRect& rect, size_t n) const
 389 {
 390     // use wxRendererNative for more native look unless we use custom bg colour
 391     if ( !DoDrawSolidBackground(m_colBgSel, dc, rect, n) )
 392     {
 393         int flags = 0;
 394         if ( IsSelected(n) )
 395             flags |= wxCONTROL_SELECTED;
 396         if ( IsCurrent(n) )
 397             flags |= wxCONTROL_CURRENT;
 398         if ( wxWindow::FindFocus() == wx_const_cast(wxVListBox*, this) )
 399             flags |= wxCONTROL_FOCUSED;
 400
 401         wxRendererNative::Get().DrawItemSelectionRect(
 402             wx_const_cast(wxVListBox *, this), dc, rect, flags);
 403     }
 404 }
 405
 406 void wxVListBox::OnPaint(wxPaintEvent& WXUNUSED(event))
 407 {
 408     wxSize clientSize = GetClientSize();
 409
 410     wxAutoBufferedPaintDC dc(this);
 411
 412     // the update rectangle
 413     wxRect rectUpdate = GetUpdateClientRect();
 414
 415     // fill it with background colour
 416     dc.SetBackground(GetBackgroundColour());
 417     dc.Clear();
 418
 419     // the bounding rectangle of the current line
 420     wxRect rectRow;
 421     rectRow.width = clientSize.x;
 422
 423     // iterate over all visible lines
 424     const size_t lineMax = GetVisibleEnd();
 425     for ( size_t line = GetVisibleBegin(); line < lineMax; line++ )
 426     {
 427         const wxCoord hRow = OnGetRowHeight(line);
 428
 429         rectRow.height = hRow;
 430
 431         // and draw the ones which intersect the update rect
 432         if ( rectRow.Intersects(rectUpdate) )
 433         {
 434             // don't allow drawing outside of the lines rectangle
 435             wxDCClipper clip(dc, rectRow);
 436
 437             wxRect rect = rectRow;
 438             OnDrawBackground(dc, rect, line);
 439
 440             OnDrawSeparator(dc, rect, line);
 441
 442             rect.Deflate(m_ptMargins.x, m_ptMargins.y);
 443             OnDrawItem(dc, rect, line);
 444         }
 445         else // no intersection
 446         {
 447             if ( rectRow.GetTop() > rectUpdate.GetBottom() )
 448             {
 449                 // we are already below the update rect, no need to continue
 450                 // further
 451                 break;
 452             }
 453             //else: the next line may intersect the update rect
 454         }
 455
 456         rectRow.y += hRow;
 457     }
 458 }
 459
 460 void wxVListBox::OnSetOrKillFocus(wxFocusEvent& WXUNUSED(event))
 461 {
 462     // we need to repaint the selection when we get the focus since
 463     // wxRendererNative in general draws the focused selection differently
 464     // from the unfocused selection (see OnDrawItem):
 465     RefreshSelected();
 466 }
 467
 468
 469 // ============================================================================
 470 // wxVListBox keyboard/mouse handling
 471 // ============================================================================
 472
 473 void wxVListBox::DoHandleItemClick(int item, int flags)
 474 {
 475     // has anything worth telling the client code about happened?
 476     bool notify = false;
 477
 478     if ( HasMultipleSelection() )
 479     {
 480         // select the iteem clicked?
 481         bool select = true;
 482
 483         // NB: the keyboard interface we implement here corresponds to
 484         //     wxLB_EXTENDED rather than wxLB_MULTIPLE but this one makes more
 485         //     sense IMHO
 486         if ( flags & ItemClick_Shift )
 487         {
 488             if ( m_current != wxNOT_FOUND )
 489             {
 490                 if ( m_anchor == wxNOT_FOUND )
 491                     m_anchor = m_current;
 492
 493                 select = false;
 494
 495                 // only the range from the selection anchor to new m_current
 496                 // must be selected
 497                 if ( DeselectAll() )
 498                     notify = true;
 499
 500                 if ( SelectRange(m_anchor, item) )
 501                     notify = true;
 502             }
 503             //else: treat it as ordinary click/keypress
 504         }
 505         else // Shift not pressed
 506         {
 507             m_anchor = item;
 508
 509             if ( flags & ItemClick_Ctrl )
 510             {
 511                 select = false;
 512
 513                 if ( !(flags & ItemClick_Kbd) )
 514                 {
 515                     Toggle(item);
 516
 517                     // the status of the item has definitely changed
 518                     notify = true;
 519                 }
 520                 //else: Ctrl-arrow pressed, don't change selection
 521             }
 522             //else: behave as in single selection case
 523         }
 524
 525         if ( select )
 526         {
 527             // make the clicked item the only selection
 528             if ( DeselectAll() )
 529                 notify = true;
 530
 531             if ( Select(item) )
 532                 notify = true;
 533         }
 534     }
 535
 536     // in any case the item should become the current one
 537     if ( DoSetCurrent(item) )
 538     {
 539         if ( !HasMultipleSelection() )
 540         {
 541             // this has also changed the selection for single selection case
 542             notify = true;
 543         }
 544     }
 545
 546     if ( notify )
 547     {
 548         // notify the user about the selection change
 549         SendSelectedEvent();
 550     }
 551     //else: nothing changed at all
 552 }
 553
 554 // ----------------------------------------------------------------------------
 555 // keyboard handling
 556 // ----------------------------------------------------------------------------
 557
 558 void wxVListBox::OnKeyDown(wxKeyEvent& event)
 559 {
 560     // flags for DoHandleItemClick()
 561     int flags = ItemClick_Kbd;
 562
 563     int current;
 564     switch ( event.GetKeyCode() )
 565     {
 566         case WXK_HOME:
 567             current = 0;
 568             break;
 569
 570         case WXK_END:
 571             current = GetRowCount() - 1;
 572             break;
 573
 574         case WXK_DOWN:
 575             if ( m_current == (int)GetRowCount() - 1 )
 576                 return;
 577
 578             current = m_current + 1;
 579             break;
 580
 581         case WXK_UP:
 582             if ( m_current == wxNOT_FOUND )
 583                 current = GetRowCount() - 1;
 584             else if ( m_current != 0 )
 585                 current = m_current - 1;
 586             else // m_current == 0
 587                 return;
 588             break;
 589
 590         case WXK_PAGEDOWN:
 591             PageDown();
 592             current = GetVisibleBegin();
 593             break;
 594
 595         case WXK_PAGEUP:
 596             if ( m_current == (int)GetVisibleBegin() )
 597             {
 598                 PageUp();
 599             }
 600
 601             current = GetVisibleBegin();
 602             break;
 603
 604         case WXK_SPACE:
 605             // hack: pressing space should work like a mouse click rather than
 606             // like a keyboard arrow press, so trick DoHandleItemClick() in
 607             // thinking we were clicked
 608             flags &= ~ItemClick_Kbd;
 609             current = m_current;
 610             break;
 611
 612 #ifdef __WXMSW__
 613         case WXK_TAB:
 614             // Since we are using wxWANTS_CHARS we need to send navigation
 615             // events for the tabs on MSW
 616             HandleAsNavigationKey(event);
 617             // fall through to default
 618 #endif
 619         default:
 620             event.Skip();
 621             current = 0; // just to silent the stupid compiler warnings
 622             wxUnusedVar(current);
 623             return;
 624     }
 625
 626     if ( event.ShiftDown() )
 627        flags |= ItemClick_Shift;
 628     if ( event.ControlDown() )
 629         flags |= ItemClick_Ctrl;
 630
 631     DoHandleItemClick(current, flags);
 632 }
 633
 634 // ----------------------------------------------------------------------------
 635 // wxVListBox mouse handling
 636 // ----------------------------------------------------------------------------
 637
 638 void wxVListBox::OnLeftDown(wxMouseEvent& event)
 639 {
 640     SetFocus();
 641
 642     int item = VirtualHitTest(event.GetPosition().y);
 643
 644     if ( item != wxNOT_FOUND )
 645     {
 646         int flags = 0;
 647         if ( event.ShiftDown() )
 648            flags |= ItemClick_Shift;
 649
 650         // under Mac Apple-click is used in the same way as Ctrl-click
 651         // elsewhere
 652 #ifdef __WXMAC__
 653         if ( event.MetaDown() )
 654 #else
 655         if ( event.ControlDown() )
 656 #endif
 657             flags |= ItemClick_Ctrl;
 658
 659         DoHandleItemClick(item, flags);
 660     }
 661 }
 662
 663 void wxVListBox::OnLeftDClick(wxMouseEvent& eventMouse)
 664 {
 665     int item = VirtualHitTest(eventMouse.GetPosition().y);
 666     if ( item != wxNOT_FOUND )
 667     {
 668
 669         // if item double-clicked was not yet selected, then treat
 670         // this event as a left-click instead
 671         if ( item == m_current )
 672         {
 673             wxCommandEvent event(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, GetId());
 674             event.SetEventObject(this);
 675             event.SetInt(item);
 676
 677             (void)GetEventHandler()->ProcessEvent(event);
 678         }
 679         else
 680         {
 681             OnLeftDown(eventMouse);
 682         }
 683
 684     }
 685 }
 686
 687
 688 // ----------------------------------------------------------------------------
 689 // use the same default attributes as wxListBox
 690 // ----------------------------------------------------------------------------
 691
 692 //static
 693 wxVisualAttributes
 694 wxVListBox::GetClassDefaultAttributes(wxWindowVariant variant)
 695 {
 696     return wxListBox::GetClassDefaultAttributes(variant);
 697 }
 698
 699 #endif