src/generic/vlbox.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 #ifndef WX_PRECOMP
  28     #include "wx/settings.h"
  29     #include "wx/dcclient.h"
  30 #endif //WX_PRECOMP
  31
  32 #include "wx/vlbox.h"
  33 #include "wx/selstore.h"
  34
  35 // ----------------------------------------------------------------------------
  36 // event tables
  37 // ----------------------------------------------------------------------------
  38
  39 BEGIN_EVENT_TABLE(wxVListBox, wxVScrolledWindow)
  40     EVT_PAINT(wxVListBox::OnPaint)
  41
  42     EVT_KEY_DOWN(wxVListBox::OnKeyDown)
  43     EVT_LEFT_DOWN(wxVListBox::OnLeftDown)
  44     EVT_LEFT_DCLICK(wxVListBox::OnLeftDClick)
  45 END_EVENT_TABLE()
  46
  47 // ============================================================================
  48 // implementation
  49 // ============================================================================
  50
  51 // ----------------------------------------------------------------------------
  52 // wxVListBox creation
  53 // ----------------------------------------------------------------------------
  54
  55 void wxVListBox::Init()
  56 {
  57     m_current =
  58     m_anchor = wxNOT_FOUND;
  59     m_selStore = NULL;
  60 }
  61
  62 bool wxVListBox::Create(wxWindow *parent,
  63                         wxWindowID id,
  64                         const wxPoint& pos,
  65                         const wxSize& size,
  66                         long style,
  67                         const wxString& name)
  68 {
  69     if ( !wxVScrolledWindow::Create(parent, id, pos, size, style, name) )
  70         return false;
  71
  72     if ( style & wxLB_MULTIPLE )
  73         m_selStore = new wxSelectionStore;
  74
  75     SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOX));
  76     m_colBgSel = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
  77
  78     return true;
  79 }
  80
  81 wxVListBox::~wxVListBox()
  82 {
  83     delete m_selStore;
  84 }
  85
  86 void wxVListBox::SetItemCount(size_t count)
  87 {
  88     if ( m_selStore )
  89     {
  90         // tell the selection store that our number of items has changed
  91         m_selStore->SetItemCount(count);
  92     }
  93
  94     SetLineCount(count);
  95 }
  96
  97 // ----------------------------------------------------------------------------
  98 // selection handling
  99 // ----------------------------------------------------------------------------
 100
 101 bool wxVListBox::IsSelected(size_t line) const
 102 {
 103     return m_selStore ? m_selStore->IsSelected(line) : (int)line == m_current;
 104 }
 105
 106 bool wxVListBox::Select(size_t item, bool select)
 107 {
 108     wxCHECK_MSG( m_selStore, false,
 109                  _T("Select() may only be used with multiselection listbox") );
 110
 111     wxCHECK_MSG( item < GetItemCount(), false,
 112                  _T("Select(): invalid item index") );
 113
 114     bool changed = m_selStore->SelectItem(item, select);
 115     if ( changed )
 116     {
 117         // selection really changed
 118         RefreshLine(item);
 119     }
 120
 121     DoSetCurrent(item);
 122
 123     return changed;
 124 }
 125
 126 bool wxVListBox::SelectRange(size_t from, size_t to)
 127 {
 128     wxCHECK_MSG( m_selStore, false,
 129                  _T("SelectRange() may only be used with multiselection listbox") );
 130
 131     // make sure items are in correct order
 132     if ( from > to )
 133     {
 134         size_t tmp = from;
 135         from = to;
 136         to = tmp;
 137     }
 138
 139     wxCHECK_MSG( to < GetItemCount(), false,
 140                     _T("SelectRange(): invalid item index") );
 141
 142     wxArrayInt changed;
 143     if ( !m_selStore->SelectRange(from, to, true, &changed) )
 144     {
 145         // too many items have changed, we didn't record them in changed array
 146         // so we have no choice but to refresh everything between from and to
 147         RefreshLines(from, to);
 148     }
 149     else // we've got the indices of the changed items
 150     {
 151         const size_t count = changed.GetCount();
 152         if ( !count )
 153         {
 154             // nothing changed
 155             return false;
 156         }
 157
 158         // refresh just the lines which have really changed
 159         for ( size_t n = 0; n < count; n++ )
 160         {
 161             RefreshLine(changed[n]);
 162         }
 163     }
 164
 165     // something changed
 166     return true;
 167 }
 168
 169 bool wxVListBox::DoSelectAll(bool select)
 170 {
 171     wxCHECK_MSG( m_selStore, false,
 172                  _T("SelectAll may only be used with multiselection listbox") );
 173
 174     size_t count = GetItemCount();
 175     if ( count )
 176     {
 177         wxArrayInt changed;
 178         if ( !m_selStore->SelectRange(0, count - 1, select) ||
 179                 !changed.IsEmpty() )
 180         {
 181             Refresh();
 182
 183             // something changed
 184             return true;
 185         }
 186     }
 187
 188     return false;
 189 }
 190
 191 bool wxVListBox::DoSetCurrent(int current)
 192 {
 193     wxASSERT_MSG( current == wxNOT_FOUND ||
 194                     (current >= 0 && (size_t)current < GetItemCount()),
 195                   _T("wxVListBox::DoSetCurrent(): invalid item index") );
 196
 197     if ( current == m_current )
 198     {
 199         // nothing to do
 200         return false;
 201     }
 202
 203     if ( m_current != wxNOT_FOUND )
 204         RefreshLine(m_current);
 205
 206     m_current = current;
 207
 208     if ( m_current != wxNOT_FOUND )
 209     {
 210         // if the line is not visible at all, we scroll it into view but we
 211         // don't need to refresh it -- it will be redrawn anyhow
 212         if ( !IsVisible(m_current) )
 213         {
 214             ScrollToLine(m_current);
 215         }
 216         else // line is at least partly visible
 217         {
 218             // it is, indeed, only partly visible, so scroll it into view to
 219             // make it entirely visible
 220             if ( (size_t)m_current == GetLastVisibleLine() )
 221             {
 222                 ScrollToLine(m_current);
 223             }
 224
 225             // but in any case refresh it as even if it was only partly visible
 226             // before we need to redraw it entirely as its background changed
 227             RefreshLine(m_current);
 228         }
 229     }
 230
 231     return true;
 232 }
 233
 234 void wxVListBox::SendSelectedEvent()
 235 {
 236     wxASSERT_MSG( m_current != wxNOT_FOUND,
 237                     _T("SendSelectedEvent() shouldn't be called") );
 238
 239     wxCommandEvent event(wxEVT_COMMAND_LISTBOX_SELECTED, GetId());
 240     event.SetEventObject(this);
 241     event.m_commandInt = m_current;
 242
 243     (void)GetEventHandler()->ProcessEvent(event);
 244 }
 245
 246 void wxVListBox::SetSelection(int selection)
 247 {
 248     wxCHECK_RET( selection == wxNOT_FOUND ||
 249                   (selection >= 0 && (size_t)selection < GetItemCount()),
 250                   _T("wxVListBox::SetSelection(): invalid item index") );
 251
 252     if ( HasMultipleSelection() )
 253     {
 254         Select(selection);
 255         m_anchor = selection;
 256     }
 257
 258     DoSetCurrent(selection);
 259 }
 260
 261 size_t wxVListBox::GetSelectedCount() const
 262 {
 263     return m_selStore ? m_selStore->GetSelectedCount()
 264                       : m_current == wxNOT_FOUND ? 0 : 1;
 265 }
 266
 267 int wxVListBox::GetFirstSelected(unsigned long& cookie) const
 268 {
 269     cookie = 0;
 270
 271     return GetNextSelected(cookie);
 272 }
 273
 274 int wxVListBox::GetNextSelected(unsigned long& cookie) const
 275 {
 276     wxCHECK_MSG( m_selStore, wxNOT_FOUND,
 277                   _T("GetFirst/NextSelected() may only be used with multiselection listboxes") );
 278
 279     while ( cookie < GetItemCount() )
 280     {
 281         if ( IsSelected(cookie++) )
 282             return cookie - 1;
 283     }
 284
 285     return wxNOT_FOUND;
 286 }
 287
 288 // ----------------------------------------------------------------------------
 289 // wxVListBox appearance parameters
 290 // ----------------------------------------------------------------------------
 291
 292 void wxVListBox::SetMargins(const wxPoint& pt)
 293 {
 294     if ( pt != m_ptMargins )
 295     {
 296         m_ptMargins = pt;
 297
 298         Refresh();
 299     }
 300 }
 301
 302 void wxVListBox::SetSelectionBackground(const wxColour& col)
 303 {
 304     m_colBgSel = col;
 305 }
 306
 307 // ----------------------------------------------------------------------------
 308 // wxVListBox painting
 309 // ----------------------------------------------------------------------------
 310
 311 wxCoord wxVListBox::OnGetLineHeight(size_t line) const
 312 {
 313     return OnMeasureItem(line) + 2*m_ptMargins.y;
 314 }
 315
 316 void wxVListBox::OnDrawSeparator(wxDC& WXUNUSED(dc),
 317                                  wxRect& WXUNUSED(rect),
 318                                  size_t WXUNUSED(n)) const
 319 {
 320 }
 321
 322 void wxVListBox::OnDrawBackground(wxDC& dc, const wxRect& rect, size_t n) const
 323 {
 324     // we need to render selected and current items differently
 325     const bool isSelected = IsSelected(n),
 326                isCurrent = IsCurrent(n);
 327     if ( isSelected || isCurrent )
 328     {
 329         if ( isSelected )
 330         {
 331             dc.SetBrush(wxBrush(m_colBgSel, wxSOLID));
 332         }
 333         else // !selected
 334         {
 335             dc.SetBrush(*wxTRANSPARENT_BRUSH);
 336         }
 337
 338         dc.SetPen(*(isCurrent ? wxBLACK_PEN : wxTRANSPARENT_PEN));
 339
 340         dc.DrawRectangle(rect);
 341     }
 342     //else: do nothing for the normal items
 343 }
 344
 345 void wxVListBox::OnPaint(wxPaintEvent& WXUNUSED(event))
 346 {
 347     wxPaintDC dc(this);
 348
 349     // the update rectangle
 350     wxRect rectUpdate = GetUpdateClientRect();
 351
 352     // the bounding rectangle of the current line
 353     wxRect rectLine;
 354     rectLine.width = GetClientSize().x;
 355
 356     // iterate over all visible lines
 357     const size_t lineMax = GetLastVisibleLine();
 358     for ( size_t line = GetFirstVisibleLine(); line <= lineMax; line++ )
 359     {
 360         const wxCoord hLine = OnGetLineHeight(line);
 361
 362         rectLine.height = hLine;
 363
 364         // and draw the ones which intersect the update rect
 365         if ( rectLine.Intersects(rectUpdate) )
 366         {
 367             // don't allow drawing outside of the lines rectangle
 368             wxDCClipper clip(dc, rectLine);
 369
 370             wxRect rect = rectLine;
 371             OnDrawBackground(dc, rect, line);
 372
 373             OnDrawSeparator(dc, rect, line);
 374
 375             rect.Deflate(m_ptMargins.x, m_ptMargins.y);
 376             OnDrawItem(dc, rect, line);
 377         }
 378         else // no intersection
 379         {
 380             if ( rectLine.GetTop() > rectUpdate.GetBottom() )
 381             {
 382                 // we are already below the update rect, no need to continue
 383                 // further
 384                 break;
 385             }
 386             //else: the next line may intersect the update rect
 387         }
 388
 389         rectLine.y += hLine;
 390     }
 391 }
 392
 393 // ============================================================================
 394 // wxVListBox keyboard/mouse handling
 395 // ============================================================================
 396
 397 void wxVListBox::DoHandleItemClick(int item, int flags)
 398 {
 399     // has anything worth telling the client code about happened?
 400     bool notify = false;
 401
 402     if ( HasMultipleSelection() )
 403     {
 404         // select the iteem clicked?
 405         bool select = true;
 406
 407         // NB: the keyboard interface we implement here corresponds to
 408         //     wxLB_EXTENDED rather than wxLB_MULTIPLE but this one makes more
 409         //     sense IMHO
 410         if ( flags & ItemClick_Shift )
 411         {
 412             if ( m_current != wxNOT_FOUND )
 413             {
 414                 if ( m_anchor == wxNOT_FOUND )
 415                     m_anchor = m_current;
 416
 417                 select = false;
 418
 419                 // only the range from the selection anchor to new m_current
 420                 // must be selected
 421                 if ( DeselectAll() )
 422                     notify = true;
 423
 424                 if ( SelectRange(m_anchor, item) )
 425                     notify = true;
 426             }
 427             //else: treat it as ordinary click/keypress
 428         }
 429         else // Shift not pressed
 430         {
 431             m_anchor = item;
 432
 433             if ( flags & ItemClick_Ctrl )
 434             {
 435                 select = false;
 436
 437                 if ( !(flags & ItemClick_Kbd) )
 438                 {
 439                     Toggle(item);
 440
 441                     // the status of the item has definitely changed
 442                     notify = true;
 443                 }
 444                 //else: Ctrl-arrow pressed, don't change selection
 445             }
 446             //else: behave as in single selection case
 447         }
 448
 449         if ( select )
 450         {
 451             // make the clicked item the only selection
 452             if ( DeselectAll() )
 453                 notify = true;
 454
 455             if ( Select(item) )
 456                 notify = true;
 457         }
 458     }
 459
 460     // in any case the item should become the current one
 461     if ( DoSetCurrent(item) )
 462     {
 463         if ( !HasMultipleSelection() )
 464         {
 465             // this has also changed the selection for single selection case
 466             notify = true;
 467         }
 468     }
 469
 470     if ( notify )
 471     {
 472         // notify the user about the selection change
 473         SendSelectedEvent();
 474     }
 475     //else: nothing changed at all
 476 }
 477
 478 // ----------------------------------------------------------------------------
 479 // keyboard handling
 480 // ----------------------------------------------------------------------------
 481
 482 void wxVListBox::OnKeyDown(wxKeyEvent& event)
 483 {
 484     // flags for DoHandleItemClick()
 485     int flags = ItemClick_Kbd;
 486
 487     int current = 0; // just to silent the stupid compiler warnings
 488     switch ( event.GetKeyCode() )
 489     {
 490         case WXK_HOME:
 491             current = 0;
 492             break;
 493
 494         case WXK_END:
 495             current = GetLineCount() - 1;
 496             break;
 497
 498         case WXK_DOWN:
 499             if ( m_current == (int)GetLineCount() - 1 )
 500                 return;
 501
 502             current = m_current + 1;
 503             break;
 504
 505         case WXK_UP:
 506             if ( m_current == wxNOT_FOUND )
 507                 current = GetLineCount() - 1;
 508             else if ( m_current != 0 )
 509                 current = m_current - 1;
 510             else // m_current == 0
 511                 return;
 512             break;
 513
 514         case WXK_PAGEDOWN:
 515         case WXK_NEXT:
 516             PageDown();
 517             current = GetFirstVisibleLine();
 518             break;
 519
 520         case WXK_PAGEUP:
 521         case WXK_PRIOR:
 522             if ( m_current == (int)GetFirstVisibleLine() )
 523             {
 524                 PageUp();
 525             }
 526
 527             current = GetFirstVisibleLine();
 528             break;
 529
 530         case WXK_SPACE:
 531             // hack: pressing space should work like a mouse click rather than
 532             // like a keyboard arrow press, so trick DoHandleItemClick() in
 533             // thinking we were clicked
 534             flags &= ~ItemClick_Kbd;
 535             current = m_current;
 536             break;
 537
 538         default:
 539             event.Skip();
 540             return;
 541     }
 542
 543     if ( event.ShiftDown() )
 544        flags |= ItemClick_Shift;
 545     if ( event.ControlDown() )
 546         flags |= ItemClick_Ctrl;
 547
 548     DoHandleItemClick(current, flags);
 549 }
 550
 551 // ----------------------------------------------------------------------------
 552 // wxVListBox mouse handling
 553 // ----------------------------------------------------------------------------
 554
 555 void wxVListBox::OnLeftDown(wxMouseEvent& event)
 556 {
 557     int item = HitTest(event.GetPosition());
 558
 559     if ( item != wxNOT_FOUND )
 560     {
 561         int flags = 0;
 562         if ( event.ShiftDown() )
 563            flags |= ItemClick_Shift;
 564
 565         // under Mac Apple-click is used in the same way as Ctrl-click
 566         // elsewhere
 567 #ifdef __WXMAC__
 568         if ( event.MetaDown() )
 569 #else
 570         if ( event.ControlDown() )
 571 #endif
 572             flags |= ItemClick_Ctrl;
 573
 574         DoHandleItemClick(item, flags);
 575     }
 576 }
 577
 578 void wxVListBox::OnLeftDClick(wxMouseEvent& event)
 579 {
 580     int item = HitTest(event.GetPosition());
 581     if ( item != wxNOT_FOUND )
 582     {
 583         wxCommandEvent event(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, GetId());
 584         event.SetEventObject(this);
 585         event.m_commandInt = item;
 586
 587         (void)GetEventHandler()->ProcessEvent(event);
 588     }
 589 }
 590