src/msw/listbox.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/listbox.cpp
   3 // Purpose:     wxListBox
   4 // Author:      Julian Smart
   5 // Modified by: Vadim Zeitlin (owner drawn stuff)
   6 // Created:
   7 // Copyright:   (c) Julian Smart
   8 // Licence:     wxWindows licence
   9 ///////////////////////////////////////////////////////////////////////////////
  10
  11 // For compilers that support precompilation, includes "wx.h".
  12 #include "wx/wxprec.h"
  13
  14 #ifdef __BORLANDC__
  15     #pragma hdrstop
  16 #endif
  17
  18 #if wxUSE_LISTBOX
  19
  20 #include "wx/listbox.h"
  21
  22 #ifndef WX_PRECOMP
  23     #include "wx/dynarray.h"
  24     #include "wx/settings.h"
  25     #include "wx/brush.h"
  26     #include "wx/font.h"
  27     #include "wx/dc.h"
  28     #include "wx/utils.h"
  29     #include "wx/log.h"
  30     #include "wx/window.h"
  31 #endif
  32
  33 #include "wx/msw/private.h"
  34 #include "wx/msw/dc.h"
  35
  36 #include <windowsx.h>
  37
  38 #if wxUSE_OWNER_DRAWN
  39     #include  "wx/ownerdrw.h"
  40 #endif
  41
  42 // ============================================================================
  43 // list box item declaration and implementation
  44 // ============================================================================
  45
  46 #if wxUSE_OWNER_DRAWN
  47
  48 class wxListBoxItem : public wxOwnerDrawn
  49 {
  50 public:
  51     wxListBoxItem(wxListBox *parent)
  52         { m_parent = parent; }
  53
  54     wxListBox *GetParent() const
  55         { return m_parent; }
  56
  57     int GetIndex() const
  58         { return m_parent->GetItemIndex(const_cast<wxListBoxItem*>(this)); }
  59
  60     wxString GetName() const
  61         { return m_parent->GetString(GetIndex()); }
  62
  63 private:
  64     wxListBox *m_parent;
  65 };
  66
  67 wxOwnerDrawn *wxListBox::CreateLboxItem(size_t WXUNUSED(n))
  68 {
  69     return new wxListBoxItem(this);
  70 }
  71
  72 #endif  //USE_OWNER_DRAWN
  73
  74 // ============================================================================
  75 // list box control implementation
  76 // ============================================================================
  77
  78 // ----------------------------------------------------------------------------
  79 // creation
  80 // ----------------------------------------------------------------------------
  81
  82 void wxListBox::Init()
  83 {
  84     m_noItems = 0;
  85     m_updateHorizontalExtent = false;
  86 }
  87
  88 bool wxListBox::Create(wxWindow *parent,
  89                        wxWindowID id,
  90                        const wxPoint& pos,
  91                        const wxSize& size,
  92                        int n, const wxString choices[],
  93                        long style,
  94                        const wxValidator& validator,
  95                        const wxString& name)
  96 {
  97     // initialize base class fields
  98     if ( !CreateControl(parent, id, pos, size, style, validator, name) )
  99         return false;
 100
 101     // create the native control
 102     if ( !MSWCreateControl(wxT("LISTBOX"), wxEmptyString, pos, size) )
 103     {
 104         // control creation failed
 105         return false;
 106     }
 107
 108     // initialize the contents
 109     for ( int i = 0; i < n; i++ )
 110     {
 111         Append(choices[i]);
 112     }
 113
 114     // now we can compute our best size correctly, so do it again
 115     SetInitialSize(size);
 116
 117     return true;
 118 }
 119
 120 bool wxListBox::Create(wxWindow *parent,
 121                        wxWindowID id,
 122                        const wxPoint& pos,
 123                        const wxSize& size,
 124                        const wxArrayString& choices,
 125                        long style,
 126                        const wxValidator& validator,
 127                        const wxString& name)
 128 {
 129     wxCArrayString chs(choices);
 130     return Create(parent, id, pos, size, chs.GetCount(), chs.GetStrings(),
 131                   style, validator, name);
 132 }
 133
 134 wxListBox::~wxListBox()
 135 {
 136     Clear();
 137 }
 138
 139 WXDWORD wxListBox::MSWGetStyle(long style, WXDWORD *exstyle) const
 140 {
 141     WXDWORD msStyle = wxControl::MSWGetStyle(style, exstyle);
 142
 143     // we always want to get the notifications
 144     msStyle |= LBS_NOTIFY;
 145
 146     // without this style, you get unexpected heights, so e.g. constraint
 147     // layout doesn't work properly
 148     msStyle |= LBS_NOINTEGRALHEIGHT;
 149
 150     wxASSERT_MSG( !(style & wxLB_MULTIPLE) || !(style & wxLB_EXTENDED),
 151                   wxT("only one of listbox selection modes can be specified") );
 152
 153     if ( style & wxLB_MULTIPLE )
 154         msStyle |= LBS_MULTIPLESEL;
 155     else if ( style & wxLB_EXTENDED )
 156         msStyle |= LBS_EXTENDEDSEL;
 157
 158     wxASSERT_MSG( !(style & wxLB_ALWAYS_SB) || !(style & wxLB_NO_SB),
 159                   wxT( "Conflicting styles wxLB_ALWAYS_SB and wxLB_NO_SB." ) );
 160
 161     if ( !(style & wxLB_NO_SB) )
 162     {
 163         msStyle |= WS_VSCROLL;
 164         if ( style & wxLB_ALWAYS_SB )
 165             msStyle |= LBS_DISABLENOSCROLL;
 166     }
 167
 168     if ( m_windowStyle & wxLB_HSCROLL )
 169         msStyle |= WS_HSCROLL;
 170     if ( m_windowStyle & wxLB_SORT )
 171         msStyle |= LBS_SORT;
 172
 173 #if wxUSE_OWNER_DRAWN && !defined(__WXWINCE__)
 174     if ( m_windowStyle & wxLB_OWNERDRAW )
 175     {
 176         // we don't support LBS_OWNERDRAWVARIABLE yet and we also always put
 177         // the strings in the listbox for simplicity even though we could have
 178         // avoided it in this case
 179         msStyle |= LBS_OWNERDRAWFIXED | LBS_HASSTRINGS;
 180     }
 181 #endif // wxUSE_OWNER_DRAWN
 182
 183     return msStyle;
 184 }
 185
 186 void wxListBox::OnInternalIdle()
 187 {
 188     wxWindow::OnInternalIdle();
 189
 190     if (m_updateHorizontalExtent)
 191     {
 192         SetHorizontalExtent(wxEmptyString);
 193         m_updateHorizontalExtent = false;
 194     }
 195 }
 196
 197 void wxListBox::MSWOnItemsChanged()
 198 {
 199     // we need to do two things when items change: update their max horizontal
 200     // extent so that horizontal scrollbar could be shown or hidden as
 201     // appropriate and also invlaidate the best size
 202     //
 203     // updating the max extent is slow (it's an O(N) operation) and so we defer
 204     // it until the idle time but the best size should be invalidated
 205     // immediately doing it in idle time is too late -- layout using incorrect
 206     // old best size will have been already done by then
 207
 208     m_updateHorizontalExtent = true;
 209
 210     InvalidateBestSize();
 211 }
 212
 213 // ----------------------------------------------------------------------------
 214 // implementation of wxListBoxBase methods
 215 // ----------------------------------------------------------------------------
 216
 217 void wxListBox::DoSetFirstItem(int N)
 218 {
 219     wxCHECK_RET( IsValid(N),
 220                  wxT("invalid index in wxListBox::SetFirstItem") );
 221
 222     SendMessage(GetHwnd(), LB_SETTOPINDEX, (WPARAM)N, (LPARAM)0);
 223 }
 224
 225 void wxListBox::DoDeleteOneItem(unsigned int n)
 226 {
 227     wxCHECK_RET( IsValid(n),
 228                  wxT("invalid index in wxListBox::Delete") );
 229
 230 #if wxUSE_OWNER_DRAWN
 231     if ( HasFlag(wxLB_OWNERDRAW) )
 232     {
 233         delete m_aItems[n];
 234         m_aItems.RemoveAt(n);
 235     }
 236 #endif // wxUSE_OWNER_DRAWN
 237
 238     SendMessage(GetHwnd(), LB_DELETESTRING, n, 0);
 239     m_noItems--;
 240
 241     MSWOnItemsChanged();
 242
 243     UpdateOldSelections();
 244 }
 245
 246 int wxListBox::FindString(const wxString& s, bool bCase) const
 247 {
 248     // back to base class search for not native search type
 249     if (bCase)
 250        return wxItemContainerImmutable::FindString( s, bCase );
 251
 252     int pos = ListBox_FindStringExact(GetHwnd(), -1, s.t_str());
 253     if (pos == LB_ERR)
 254         return wxNOT_FOUND;
 255     else
 256         return pos;
 257 }
 258
 259 void wxListBox::DoClear()
 260 {
 261 #if wxUSE_OWNER_DRAWN
 262     if ( HasFlag(wxLB_OWNERDRAW) )
 263     {
 264         WX_CLEAR_ARRAY(m_aItems);
 265     }
 266 #endif // wxUSE_OWNER_DRAWN
 267
 268     ListBox_ResetContent(GetHwnd());
 269
 270     m_noItems = 0;
 271     MSWOnItemsChanged();
 272
 273     UpdateOldSelections();
 274 }
 275
 276 void wxListBox::DoSetSelection(int N, bool select)
 277 {
 278     wxCHECK_RET( N == wxNOT_FOUND || IsValid(N),
 279                  wxT("invalid index in wxListBox::SetSelection") );
 280
 281     if ( HasMultipleSelection() )
 282     {
 283         // Setting selection to -1 should deselect everything.
 284         const bool deselectAll = N == wxNOT_FOUND;
 285         SendMessage(GetHwnd(), LB_SETSEL,
 286                     deselectAll ? FALSE : select,
 287                     deselectAll ? -1 : N);
 288     }
 289     else
 290     {
 291         SendMessage(GetHwnd(), LB_SETCURSEL, select ? N : -1, 0);
 292     }
 293
 294     UpdateOldSelections();
 295 }
 296
 297 bool wxListBox::IsSelected(int N) const
 298 {
 299     wxCHECK_MSG( IsValid(N), false,
 300                  wxT("invalid index in wxListBox::Selected") );
 301
 302     return SendMessage(GetHwnd(), LB_GETSEL, N, 0) == 0 ? false : true;
 303 }
 304
 305 void *wxListBox::DoGetItemClientData(unsigned int n) const
 306 {
 307     LPARAM rc = SendMessage(GetHwnd(), LB_GETITEMDATA, n, 0);
 308     if ( rc == LB_ERR && GetLastError() != ERROR_SUCCESS )
 309     {
 310         wxLogLastError(wxT("LB_GETITEMDATA"));
 311
 312         return NULL;
 313     }
 314
 315     return (void *)rc;
 316 }
 317
 318 void wxListBox::DoSetItemClientData(unsigned int n, void *clientData)
 319 {
 320     if ( ListBox_SetItemData(GetHwnd(), n, clientData) == LB_ERR )
 321     {
 322         wxLogDebug(wxT("LB_SETITEMDATA failed"));
 323     }
 324 }
 325
 326 // Return number of selections and an array of selected integers
 327 int wxListBox::GetSelections(wxArrayInt& aSelections) const
 328 {
 329     aSelections.Empty();
 330
 331     if ( HasMultipleSelection() )
 332     {
 333         int countSel = ListBox_GetSelCount(GetHwnd());
 334         if ( countSel == LB_ERR )
 335         {
 336             wxLogDebug(wxT("ListBox_GetSelCount failed"));
 337         }
 338         else if ( countSel != 0 )
 339         {
 340             int *selections = new int[countSel];
 341
 342             if ( ListBox_GetSelItems(GetHwnd(),
 343                                      countSel, selections) == LB_ERR )
 344             {
 345                 wxLogDebug(wxT("ListBox_GetSelItems failed"));
 346                 countSel = -1;
 347             }
 348             else
 349             {
 350                 aSelections.Alloc(countSel);
 351                 for ( int n = 0; n < countSel; n++ )
 352                     aSelections.Add(selections[n]);
 353             }
 354
 355             delete [] selections;
 356         }
 357
 358         return countSel;
 359     }
 360     else  // single-selection listbox
 361     {
 362         if (ListBox_GetCurSel(GetHwnd()) > -1)
 363             aSelections.Add(ListBox_GetCurSel(GetHwnd()));
 364
 365         return aSelections.Count();
 366     }
 367 }
 368
 369 // Get single selection, for single choice list items
 370 int wxListBox::GetSelection() const
 371 {
 372     wxCHECK_MSG( !HasMultipleSelection(),
 373                  -1,
 374                  wxT("GetSelection() can't be used with multiple-selection listboxes, use GetSelections() instead.") );
 375
 376     return ListBox_GetCurSel(GetHwnd());
 377 }
 378
 379 // Find string for position
 380 wxString wxListBox::GetString(unsigned int n) const
 381 {
 382     wxCHECK_MSG( IsValid(n), wxEmptyString,
 383                  wxT("invalid index in wxListBox::GetString") );
 384
 385     int len = ListBox_GetTextLen(GetHwnd(), n);
 386
 387     // +1 for terminating NUL
 388     wxString result;
 389     ListBox_GetText(GetHwnd(), n, (wxChar*)wxStringBuffer(result, len + 1));
 390
 391     return result;
 392 }
 393
 394 int wxListBox::DoInsertItems(const wxArrayStringsAdapter & items,
 395                              unsigned int pos,
 396                              void **clientData,
 397                              wxClientDataType type)
 398 {
 399     MSWAllocStorage(items, LB_INITSTORAGE);
 400
 401     const bool append = pos == GetCount();
 402
 403     // we must use CB_ADDSTRING when appending as only it works correctly for
 404     // the sorted controls
 405     const unsigned msg = append ? LB_ADDSTRING : LB_INSERTSTRING;
 406
 407     if ( append )
 408         pos = 0;
 409
 410     int n = wxNOT_FOUND;
 411
 412     const unsigned int numItems = items.GetCount();
 413     for ( unsigned int i = 0; i < numItems; i++ )
 414     {
 415         n = MSWInsertOrAppendItem(pos, items[i], msg);
 416         if ( n == wxNOT_FOUND )
 417             return n;
 418
 419         if ( !append )
 420             pos++;
 421
 422         ++m_noItems;
 423
 424 #if wxUSE_OWNER_DRAWN
 425         if ( HasFlag(wxLB_OWNERDRAW) )
 426         {
 427             wxOwnerDrawn *pNewItem = CreateLboxItem(n);
 428             pNewItem->SetFont(GetFont());
 429             m_aItems.Insert(pNewItem, n);
 430         }
 431 #endif // wxUSE_OWNER_DRAWN
 432         AssignNewItemClientData(n, clientData, i, type);
 433     }
 434
 435     MSWOnItemsChanged();
 436
 437     UpdateOldSelections();
 438
 439     return n;
 440 }
 441
 442 int wxListBox::DoHitTestList(const wxPoint& point) const
 443 {
 444     LRESULT lRes = ::SendMessage(GetHwnd(), LB_ITEMFROMPOINT,
 445                                  0, MAKELPARAM(point.x, point.y));
 446
 447     // non zero high-order word means that this item is outside of the client
 448     // area, IOW the point is outside of the listbox
 449     return HIWORD(lRes) ? wxNOT_FOUND : LOWORD(lRes);
 450 }
 451
 452 void wxListBox::SetString(unsigned int n, const wxString& s)
 453 {
 454     wxCHECK_RET( IsValid(n),
 455                  wxT("invalid index in wxListBox::SetString") );
 456
 457     // remember the state of the item
 458     bool wasSelected = IsSelected(n);
 459
 460     void *oldData = NULL;
 461     wxClientData *oldObjData = NULL;
 462     if ( HasClientUntypedData() )
 463         oldData = GetClientData(n);
 464     else if ( HasClientObjectData() )
 465         oldObjData = GetClientObject(n);
 466
 467     // delete and recreate it
 468     SendMessage(GetHwnd(), LB_DELETESTRING, n, 0);
 469
 470     int newN = n;
 471     if ( n == (m_noItems - 1) )
 472         newN = -1;
 473
 474     ListBox_InsertString(GetHwnd(), newN, s.t_str());
 475
 476     // restore the client data
 477     if ( oldData )
 478         SetClientData(n, oldData);
 479     else if ( oldObjData )
 480         SetClientObject(n, oldObjData);
 481
 482     // we may have lost the selection
 483     if ( wasSelected )
 484         Select(n);
 485
 486     MSWOnItemsChanged();
 487 }
 488
 489 unsigned int wxListBox::GetCount() const
 490 {
 491     return m_noItems;
 492 }
 493
 494 // ----------------------------------------------------------------------------
 495 // size-related stuff
 496 // ----------------------------------------------------------------------------
 497
 498 void wxListBox::SetHorizontalExtent(const wxString& s)
 499 {
 500     // the rest is only necessary if we want a horizontal scrollbar
 501     if ( !HasFlag(wxHSCROLL) )
 502         return;
 503
 504
 505     WindowHDC dc(GetHwnd());
 506     SelectInHDC selFont(dc, GetHfontOf(GetFont()));
 507
 508     TEXTMETRIC lpTextMetric;
 509     ::GetTextMetrics(dc, &lpTextMetric);
 510
 511     int largestExtent = 0;
 512     SIZE extentXY;
 513
 514     if ( s.empty() )
 515     {
 516         // set extent to the max length of all strings
 517         for ( unsigned int i = 0; i < m_noItems; i++ )
 518         {
 519             const wxString str = GetString(i);
 520             ::GetTextExtentPoint32(dc, str.c_str(), str.length(), &extentXY);
 521
 522             int extentX = (int)(extentXY.cx + lpTextMetric.tmAveCharWidth);
 523             if ( extentX > largestExtent )
 524                 largestExtent = extentX;
 525         }
 526     }
 527     else // just increase the extent to the length of this string
 528     {
 529         int existingExtent = (int)SendMessage(GetHwnd(),
 530                                               LB_GETHORIZONTALEXTENT, 0, 0L);
 531
 532         ::GetTextExtentPoint32(dc, s.c_str(), s.length(), &extentXY);
 533
 534         int extentX = (int)(extentXY.cx + lpTextMetric.tmAveCharWidth);
 535         if ( extentX > existingExtent )
 536             largestExtent = extentX;
 537     }
 538
 539     if ( largestExtent )
 540         SendMessage(GetHwnd(), LB_SETHORIZONTALEXTENT, LOWORD(largestExtent), 0L);
 541     //else: it shouldn't change
 542 }
 543
 544 wxSize wxListBox::DoGetBestClientSize() const
 545 {
 546     // find the widest string
 547     int wLine;
 548     int wListbox = 0;
 549     for (unsigned int i = 0; i < m_noItems; i++)
 550     {
 551         wxString str(GetString(i));
 552         GetTextExtent(str, &wLine, NULL);
 553         if ( wLine > wListbox )
 554             wListbox = wLine;
 555     }
 556
 557     // give it some reasonable default value if there are no strings in the
 558     // list
 559     if ( wListbox == 0 )
 560         wListbox = 100;
 561
 562     // the listbox should be slightly larger than the widest string
 563     wListbox += 3*GetCharWidth();
 564
 565     // add room for the scrollbar
 566     wListbox += wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
 567
 568     // don't make the listbox too tall (limit height to 10 items) but don't
 569     // make it too small neither
 570     int hListbox = SendMessage(GetHwnd(), LB_GETITEMHEIGHT, 0, 0)*
 571                     wxMin(wxMax(m_noItems, 3), 10);
 572
 573     return wxSize(wListbox, hListbox);
 574 }
 575
 576 // ----------------------------------------------------------------------------
 577 // callbacks
 578 // ----------------------------------------------------------------------------
 579
 580 bool wxListBox::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
 581 {
 582     wxEventType evtType;
 583     if ( param == LBN_SELCHANGE )
 584     {
 585         if ( HasMultipleSelection() )
 586             return CalcAndSendEvent();
 587
 588         evtType = wxEVT_LISTBOX;
 589     }
 590     else if ( param == LBN_DBLCLK )
 591     {
 592         // Clicking under the last item in the listbox generates double click
 593         // event for the currently selected item which is rather surprising.
 594         // Avoid the surprise by checking that we do have an item under mouse.
 595         const DWORD pos = ::GetMessagePos();
 596         const wxPoint pt(GET_X_LPARAM(pos), GET_Y_LPARAM(pos));
 597         if ( HitTest(ScreenToClient(pt)) == wxNOT_FOUND )
 598             return false;
 599
 600         evtType = wxEVT_LISTBOX_DCLICK;
 601     }
 602     else
 603     {
 604         // some event we're not interested in
 605         return false;
 606     }
 607
 608     const int n = ListBox_GetCurSel(GetHwnd());
 609
 610     // We get events even when mouse is clicked outside of any valid item from
 611     // Windows, just ignore them.
 612     if ( n == wxNOT_FOUND )
 613        return false;
 614
 615     if ( param == LBN_SELCHANGE )
 616     {
 617         if ( !DoChangeSingleSelection(n) )
 618             return false;
 619     }
 620
 621     // Do generate an event otherwise.
 622     return SendEvent(evtType, n, true /* selection */);
 623 }
 624
 625 // ----------------------------------------------------------------------------
 626 // owner-drawn list boxes support
 627 // ----------------------------------------------------------------------------
 628
 629 #if wxUSE_OWNER_DRAWN
 630
 631 // misc overloaded methods
 632 // -----------------------
 633
 634 bool wxListBox::SetFont(const wxFont &font)
 635 {
 636     if ( HasFlag(wxLB_OWNERDRAW) )
 637     {
 638         const unsigned count = m_aItems.GetCount();
 639         for ( unsigned i = 0; i < count; i++ )
 640             m_aItems[i]->SetFont(font);
 641     }
 642
 643     wxListBoxBase::SetFont(font);
 644
 645     return true;
 646 }
 647
 648 bool wxListBox::GetItemRect(size_t n, wxRect& rect) const
 649 {
 650     wxCHECK_MSG( IsValid(n), false,
 651                  wxT("invalid index in wxListBox::GetItemRect") );
 652
 653     RECT rc;
 654
 655     if ( ListBox_GetItemRect(GetHwnd(), n, &rc) != LB_ERR )
 656     {
 657         rect = wxRectFromRECT(rc);
 658         return true;
 659     }
 660     else
 661     {
 662         // couldn't retrieve rect: for example, item isn't visible
 663         return false;
 664     }
 665 }
 666
 667 bool wxListBox::RefreshItem(size_t n)
 668 {
 669     wxRect rect;
 670     if ( !GetItemRect(n, rect) )
 671         return false;
 672
 673     RECT rc;
 674     wxCopyRectToRECT(rect, rc);
 675
 676     return ::InvalidateRect((HWND)GetHWND(), &rc, FALSE) == TRUE;
 677 }
 678
 679
 680 // drawing
 681 // -------
 682
 683 namespace
 684 {
 685     // space beneath/above each row in pixels
 686     static const int LISTBOX_EXTRA_SPACE = 1;
 687
 688 } // anonymous namespace
 689
 690 // the height is the same for all items
 691 // TODO should be changed for LBS_OWNERDRAWVARIABLE style listboxes
 692
 693 // NB: can't forward this to wxListBoxItem because LB_SETITEMDATA
 694 //     message is not yet sent when we get here!
 695 bool wxListBox::MSWOnMeasure(WXMEASUREITEMSTRUCT *item)
 696 {
 697     // only owner-drawn control should receive this message
 698     wxCHECK( HasFlag(wxLB_OWNERDRAW), false );
 699
 700     MEASUREITEMSTRUCT *pStruct = (MEASUREITEMSTRUCT *)item;
 701
 702 #ifdef __WXWINCE__
 703     HDC hdc = GetDC(NULL);
 704 #else
 705     HDC hdc = CreateIC(wxT("DISPLAY"), NULL, NULL, 0);
 706 #endif
 707
 708     {
 709         wxDCTemp dc((WXHDC)hdc);
 710         dc.SetFont(GetFont());
 711
 712         pStruct->itemHeight = dc.GetCharHeight() + 2 * LISTBOX_EXTRA_SPACE;
 713         pStruct->itemWidth  = dc.GetCharWidth();
 714     }
 715
 716 #ifdef __WXWINCE__
 717     ReleaseDC(NULL, hdc);
 718 #else
 719     DeleteDC(hdc);
 720 #endif
 721
 722     return true;
 723 }
 724
 725 // forward the message to the appropriate item
 726 bool wxListBox::MSWOnDraw(WXDRAWITEMSTRUCT *item)
 727 {
 728     // only owner-drawn control should receive this message
 729     wxCHECK( HasFlag(wxLB_OWNERDRAW), false );
 730
 731     DRAWITEMSTRUCT *pStruct = (DRAWITEMSTRUCT *)item;
 732
 733     // the item may be -1 for an empty listbox
 734     if ( pStruct->itemID == (UINT)-1 )
 735         return false;
 736
 737     wxListBoxItem *pItem = (wxListBoxItem *)m_aItems[pStruct->itemID];
 738
 739     wxDCTemp dc((WXHDC)pStruct->hDC);
 740
 741     return pItem->OnDrawItem(dc, wxRectFromRECT(pStruct->rcItem),
 742                              (wxOwnerDrawn::wxODAction)pStruct->itemAction,
 743                              (wxOwnerDrawn::wxODStatus)(pStruct->itemState | wxOwnerDrawn::wxODHidePrefix));
 744 }
 745
 746 #endif // wxUSE_OWNER_DRAWN
 747
 748 #endif // wxUSE_LISTBOX