src/msw/choice.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/choice.cpp
   3 // Purpose:     wxChoice
   4 // Author:      Julian Smart
   5 // Modified by: Vadim Zeitlin to derive from wxChoiceBase
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   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_CHOICE && !(defined(__SMARTPHONE__) && defined(__WXWINCE__))
  28
  29 #include "wx/choice.h"
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/utils.h"
  33     #include "wx/app.h"
  34     #include "wx/log.h"
  35     #include "wx/brush.h"
  36     #include "wx/settings.h"
  37 #endif
  38
  39 #include "wx/msw/private.h"
  40
  41 // ============================================================================
  42 // implementation
  43 // ============================================================================
  44
  45 // ----------------------------------------------------------------------------
  46 // creation
  47 // ----------------------------------------------------------------------------
  48
  49 bool wxChoice::Create(wxWindow *parent,
  50                       wxWindowID id,
  51                       const wxPoint& pos,
  52                       const wxSize& size,
  53                       int n, const wxString choices[],
  54                       long style,
  55                       const wxValidator& validator,
  56                       const wxString& name)
  57 {
  58     // Experience shows that wxChoice vs. wxComboBox distinction confuses
  59     // quite a few people - try to help them
  60     wxASSERT_MSG( !(style & wxCB_DROPDOWN) &&
  61                   !(style & wxCB_READONLY) &&
  62                   !(style & wxCB_SIMPLE),
  63                   wxT("this style flag is ignored by wxChoice, you ")
  64                   wxT("probably want to use a wxComboBox") );
  65
  66     return CreateAndInit(parent, id, pos, size, n, choices, style,
  67                          validator, name);
  68 }
  69
  70 bool wxChoice::CreateAndInit(wxWindow *parent,
  71                              wxWindowID id,
  72                              const wxPoint& pos,
  73                              const wxSize& size,
  74                              int n, const wxString choices[],
  75                              long style,
  76                              const wxValidator& validator,
  77                              const wxString& name)
  78 {
  79     // initialize wxControl
  80     if ( !CreateControl(parent, id, pos, size, style, validator, name) )
  81         return false;
  82
  83     // now create the real HWND
  84     if ( !MSWCreateControl(wxT("COMBOBOX"), wxEmptyString, pos, size) )
  85         return false;
  86
  87
  88     // initialize the controls contents
  89     for ( int i = 0; i < n; i++ )
  90     {
  91         Append(choices[i]);
  92     }
  93
  94     // and now we may finally size the control properly (if needed)
  95     SetInitialSize(size);
  96
  97     return true;
  98 }
  99
 100 void wxChoice::SetLabel(const wxString& label)
 101 {
 102     if ( FindString(label) == wxNOT_FOUND )
 103     {
 104         // unless we explicitly do this here, CB_GETCURSEL will continue to
 105         // return the index of the previously selected item which will result
 106         // in wrongly replacing the value being set now with the previously
 107         // value if the user simply opens and closes (without selecting
 108         // anything) the combobox popup
 109         SetSelection(-1);
 110     }
 111
 112     wxChoiceBase::SetLabel(label);
 113 }
 114
 115 bool wxChoice::Create(wxWindow *parent,
 116                       wxWindowID id,
 117                       const wxPoint& pos,
 118                       const wxSize& size,
 119                       const wxArrayString& choices,
 120                       long style,
 121                       const wxValidator& validator,
 122                       const wxString& name)
 123 {
 124     wxCArrayString chs(choices);
 125     return Create(parent, id, pos, size, chs.GetCount(), chs.GetStrings(),
 126                   style, validator, name);
 127 }
 128
 129 bool wxChoice::MSWShouldPreProcessMessage(WXMSG *pMsg)
 130 {
 131     MSG *msg = (MSG *) pMsg;
 132
 133     // if the dropdown list is visible, don't preprocess certain keys
 134     if ( msg->message == WM_KEYDOWN
 135         && (msg->wParam == VK_ESCAPE || msg->wParam == VK_RETURN) )
 136     {
 137         if (::SendMessage(GetHwndOf(this), CB_GETDROPPEDSTATE, 0, 0))
 138         {
 139             return false;
 140         }
 141     }
 142
 143     return wxControl::MSWShouldPreProcessMessage(pMsg);
 144 }
 145
 146 WXDWORD wxChoice::MSWGetStyle(long style, WXDWORD *exstyle) const
 147 {
 148     // we never have an external border
 149     WXDWORD msStyle = wxControl::MSWGetStyle
 150                       (
 151                         (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
 152                       );
 153
 154     // WS_CLIPSIBLINGS is useful with wxChoice and doesn't seem to result in
 155     // any problems
 156     msStyle |= WS_CLIPSIBLINGS;
 157
 158     // wxChoice-specific styles
 159     msStyle |= CBS_DROPDOWNLIST | WS_HSCROLL | WS_VSCROLL;
 160     if ( style & wxCB_SORT )
 161         msStyle |= CBS_SORT;
 162
 163     return msStyle;
 164 }
 165
 166 #ifndef EP_EDITTEXT
 167     #define EP_EDITTEXT         1
 168     #define ETS_NORMAL          1
 169 #endif
 170
 171 wxVisualAttributes
 172 wxChoice::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
 173 {
 174     // it is important to return valid values for all attributes from here,
 175     // GetXXX() below rely on this
 176     wxVisualAttributes attrs;
 177
 178     // FIXME: Use better dummy window?
 179     wxWindow* wnd = wxTheApp->GetTopWindow();
 180     if (!wnd)
 181         return attrs;
 182
 183     attrs.font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
 184
 185     // there doesn't seem to be any way to get the text colour using themes
 186     // API: TMT_TEXTCOLOR doesn't work neither for EDIT nor COMBOBOX
 187     attrs.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
 188
 189     // NB: use EDIT, not COMBOBOX (the latter works in XP but not Vista)
 190     attrs.colBg = wnd->MSWGetThemeColour(L"EDIT",
 191                                          EP_EDITTEXT,
 192                                          ETS_NORMAL,
 193                                          ThemeColourBackground,
 194                                          wxSYS_COLOUR_WINDOW);
 195
 196     return attrs;
 197 }
 198
 199 wxChoice::~wxChoice()
 200 {
 201     Clear();
 202 }
 203
 204 // ----------------------------------------------------------------------------
 205 // adding/deleting items to/from the list
 206 // ----------------------------------------------------------------------------
 207
 208 int wxChoice::DoInsertItems(const wxArrayStringsAdapter& items,
 209                             unsigned int pos,
 210                             void **clientData, wxClientDataType type)
 211 {
 212     MSWAllocStorage(items, CB_INITSTORAGE);
 213
 214     const bool append = pos == GetCount();
 215
 216     // use CB_ADDSTRING when appending at the end to make sure the control is
 217     // resorted if it has wxCB_SORT style
 218     const unsigned msg = append ? CB_ADDSTRING : CB_INSERTSTRING;
 219
 220     if ( append )
 221         pos = 0;
 222
 223     int n = wxNOT_FOUND;
 224     const unsigned numItems = items.GetCount();
 225     for ( unsigned i = 0; i < numItems; ++i )
 226     {
 227         n = MSWInsertOrAppendItem(pos, items[i], msg);
 228         if ( n == wxNOT_FOUND )
 229             return n;
 230
 231         if ( !append )
 232             pos++;
 233
 234         AssignNewItemClientData(n, clientData, i, type);
 235     }
 236
 237     // we need to refresh our size in order to have enough space for the
 238     // newly added items
 239     if ( !IsFrozen() )
 240         MSWUpdateDropDownHeight();
 241
 242     InvalidateBestSize();
 243
 244     return n;
 245 }
 246
 247 void wxChoice::DoDeleteOneItem(unsigned int n)
 248 {
 249     wxCHECK_RET( IsValid(n), wxT("invalid item index in wxChoice::Delete") );
 250
 251     SendMessage(GetHwnd(), CB_DELETESTRING, n, 0);
 252
 253     if ( !IsFrozen() )
 254         MSWUpdateDropDownHeight();
 255
 256     InvalidateBestSize();
 257 }
 258
 259 void wxChoice::DoClear()
 260 {
 261     SendMessage(GetHwnd(), CB_RESETCONTENT, 0, 0);
 262
 263     if ( !IsFrozen() )
 264         MSWUpdateDropDownHeight();
 265
 266     InvalidateBestSize();
 267 }
 268
 269 // ----------------------------------------------------------------------------
 270 // selection
 271 // ----------------------------------------------------------------------------
 272
 273 int wxChoice::GetSelection() const
 274 {
 275     // if m_lastAcceptedSelection is set, it means that the dropdown is
 276     // currently shown and that we want to use the last "permanent" selection
 277     // instead of whatever is under the mouse pointer currently
 278     //
 279     // otherwise, get the selection from the control
 280     return m_lastAcceptedSelection == wxID_NONE ? GetCurrentSelection()
 281                                                 : m_lastAcceptedSelection;
 282 }
 283
 284 int wxChoice::GetCurrentSelection() const
 285 {
 286     return (int)SendMessage(GetHwnd(), CB_GETCURSEL, 0, 0);
 287 }
 288
 289 void wxChoice::SetSelection(int n)
 290 {
 291     SendMessage(GetHwnd(), CB_SETCURSEL, n, 0);
 292 }
 293
 294 // ----------------------------------------------------------------------------
 295 // string list functions
 296 // ----------------------------------------------------------------------------
 297
 298 unsigned int wxChoice::GetCount() const
 299 {
 300     return (unsigned int)SendMessage(GetHwnd(), CB_GETCOUNT, 0, 0);
 301 }
 302
 303 int wxChoice::FindString(const wxString& s, bool bCase) const
 304 {
 305 #if defined(__WATCOMC__) && defined(__WIN386__)
 306     // For some reason, Watcom in WIN386 mode crashes in the CB_FINDSTRINGEXACT message.
 307     // wxChoice::Do it the long way instead.
 308     unsigned int count = GetCount();
 309     for ( unsigned int i = 0; i < count; i++ )
 310     {
 311         // as CB_FINDSTRINGEXACT is case insensitive, be case insensitive too
 312         if (GetString(i).IsSameAs(s, bCase))
 313             return i;
 314     }
 315
 316     return wxNOT_FOUND;
 317 #else // !Watcom
 318    //TODO:  Evidently some MSW versions (all?) don't like empty strings
 319    //passed to SendMessage, so we have to do it ourselves in that case
 320    if ( s.empty() )
 321    {
 322        unsigned int count = GetCount();
 323        for ( unsigned int i = 0; i < count; i++ )
 324        {
 325          if (GetString(i).empty())
 326              return i;
 327        }
 328
 329        return wxNOT_FOUND;
 330    }
 331    else if (bCase)
 332    {
 333        // back to base class search for not native search type
 334        return wxItemContainerImmutable::FindString( s, bCase );
 335    }
 336    else
 337    {
 338        int pos = (int)SendMessage(GetHwnd(), CB_FINDSTRINGEXACT,
 339                                   (WPARAM)-1, (LPARAM)s.wx_str());
 340
 341        return pos == LB_ERR ? wxNOT_FOUND : pos;
 342    }
 343 #endif // Watcom/!Watcom
 344 }
 345
 346 void wxChoice::SetString(unsigned int n, const wxString& s)
 347 {
 348     wxCHECK_RET( IsValid(n), wxT("invalid item index in wxChoice::SetString") );
 349
 350     // we have to delete and add back the string as there is no way to change a
 351     // string in place
 352
 353     // we need to preserve the client data manually
 354     void *oldData = NULL;
 355     wxClientData *oldObjData = NULL;
 356     if ( HasClientUntypedData() )
 357         oldData = GetClientData(n);
 358     else if ( HasClientObjectData() )
 359         oldObjData = GetClientObject(n);
 360
 361     ::SendMessage(GetHwnd(), CB_DELETESTRING, n, 0);
 362     ::SendMessage(GetHwnd(), CB_INSERTSTRING, n, (LPARAM)s.wx_str() );
 363
 364     // restore the client data
 365     if ( oldData )
 366         SetClientData(n, oldData);
 367     else if ( oldObjData )
 368         SetClientObject(n, oldObjData);
 369
 370     InvalidateBestSize();
 371 }
 372
 373 wxString wxChoice::GetString(unsigned int n) const
 374 {
 375     int len = (int)::SendMessage(GetHwnd(), CB_GETLBTEXTLEN, n, 0);
 376
 377     wxString str;
 378     if ( len != CB_ERR && len > 0 )
 379     {
 380         if ( ::SendMessage
 381                (
 382                 GetHwnd(),
 383                 CB_GETLBTEXT,
 384                 n,
 385                 (LPARAM)(wxChar *)wxStringBuffer(str, len)
 386                ) == CB_ERR )
 387         {
 388             wxLogLastError(wxT("SendMessage(CB_GETLBTEXT)"));
 389         }
 390     }
 391
 392     return str;
 393 }
 394
 395 // ----------------------------------------------------------------------------
 396 // client data
 397 // ----------------------------------------------------------------------------
 398
 399 void wxChoice::DoSetItemClientData(unsigned int n, void* clientData)
 400 {
 401     if ( ::SendMessage(GetHwnd(), CB_SETITEMDATA,
 402                        n, (LPARAM)clientData) == CB_ERR )
 403     {
 404         wxLogLastError(wxT("CB_SETITEMDATA"));
 405     }
 406 }
 407
 408 void* wxChoice::DoGetItemClientData(unsigned int n) const
 409 {
 410     LPARAM rc = SendMessage(GetHwnd(), CB_GETITEMDATA, n, 0);
 411     if ( rc == CB_ERR )
 412     {
 413         wxLogLastError(wxT("CB_GETITEMDATA"));
 414
 415         // unfortunately, there is no way to return an error code to the user
 416         rc = (LPARAM) NULL;
 417     }
 418
 419     return (void *)rc;
 420 }
 421
 422 // ----------------------------------------------------------------------------
 423 // wxMSW-specific geometry management
 424 // ----------------------------------------------------------------------------
 425
 426 namespace
 427 {
 428
 429 // there is a difference between the height passed to CB_SETITEMHEIGHT and the
 430 // real height of the combobox; it is probably not constant for all Windows
 431 // versions/settings but right now I don't know how to find what it is so it is
 432 // temporarily hardcoded to its value under XP systems with normal fonts sizes
 433 const int COMBO_HEIGHT_ADJ = 6;
 434
 435 } // anonymous namespace
 436
 437 void wxChoice::MSWUpdateVisibleHeight()
 438 {
 439     if ( m_heightOwn != wxDefaultCoord )
 440     {
 441         ::SendMessage(GetHwnd(), CB_SETITEMHEIGHT,
 442                       (WPARAM)-1, m_heightOwn - COMBO_HEIGHT_ADJ);
 443     }
 444 }
 445
 446 #if wxUSE_DEFERRED_SIZING
 447 void wxChoice::MSWEndDeferWindowPos()
 448 {
 449     // we can only set the height of the choice itself now as it is reset to
 450     // default every time the control is resized
 451     MSWUpdateVisibleHeight();
 452
 453     wxChoiceBase::MSWEndDeferWindowPos();
 454 }
 455 #endif // wxUSE_DEFERRED_SIZING
 456
 457 void wxChoice::MSWUpdateDropDownHeight()
 458 {
 459     // be careful to not change the width here
 460     DoSetSize(wxDefaultCoord, wxDefaultCoord, wxDefaultCoord, GetSize().y,
 461               wxSIZE_USE_EXISTING);
 462 }
 463
 464 void wxChoice::DoMoveWindow(int x, int y, int width, int height)
 465 {
 466     // here is why this is necessary: if the width is negative, the combobox
 467     // window proc makes the window of the size width*height instead of
 468     // interpreting height in the usual manner (meaning the height of the drop
 469     // down list - usually the height specified in the call to MoveWindow()
 470     // will not change the height of combo box per se)
 471     //
 472     // this behaviour is not documented anywhere, but this is just how it is
 473     // here (NT 4.4) and, anyhow, the check shouldn't hurt - however without
 474     // the check, constraints/sizers using combos may break the height
 475     // constraint will have not at all the same value as expected
 476     if ( width < 0 )
 477         return;
 478
 479     wxControl::DoMoveWindow(x, y, width, height);
 480 }
 481
 482 void wxChoice::DoGetSize(int *w, int *h) const
 483 {
 484     wxControl::DoGetSize(w, h);
 485
 486     // this is weird: sometimes, the height returned by Windows is clearly the
 487     // total height of the control including the drop down list -- but only
 488     // sometimes, and sometimes it isn't so work around this here by using our
 489     // own stored value if we have it
 490     if ( h && m_heightOwn != wxDefaultCoord )
 491         *h = m_heightOwn;
 492 }
 493
 494 void wxChoice::DoSetSize(int x, int y,
 495                          int width, int height,
 496                          int sizeFlags)
 497 {
 498     const int heightBest = GetBestSize().y;
 499
 500     // we need the real height below so get the current one if it's not given
 501     if ( height == wxDefaultCoord )
 502     {
 503         // height not specified, use the same as before
 504         DoGetSize(NULL, &height);
 505     }
 506     else if ( height == heightBest )
 507     {
 508         // we don't need to manually manage our height, let the system use the
 509         // default one
 510         m_heightOwn = wxDefaultCoord;
 511     }
 512     else // non-default height specified
 513     {
 514         // set our new own height but be careful not to make it too big: the
 515         // native control apparently stores it as a single byte and so setting
 516         // own height to 256 pixels results in default height being used (255
 517         // is still ok)
 518         m_heightOwn = height;
 519
 520         if ( m_heightOwn > UCHAR_MAX )
 521             m_heightOwn = UCHAR_MAX;
 522         // nor too small: see MSWUpdateVisibleHeight()
 523         else if ( m_heightOwn < COMBO_HEIGHT_ADJ )
 524             m_heightOwn = COMBO_HEIGHT_ADJ;
 525     }
 526
 527
 528     // the height which we must pass to Windows should be the total height of
 529     // the control including the drop down list while the height given to us
 530     // is, of course, just the height of the permanently visible part of it so
 531     // add the drop down height to it
 532
 533     // don't make the drop down list too tall, arbitrarily limit it to 30
 534     // items max and also don't make it too small if it's currently empty
 535     size_t nItems = GetCount();
 536     if (!HasFlag(wxCB_SIMPLE))
 537     {
 538         if ( !nItems )
 539             nItems = 9;
 540         else if ( nItems > 30 )
 541             nItems = 30;
 542     }
 543
 544     const int hItem = SendMessage(GetHwnd(), CB_GETITEMHEIGHT, 0, 0);
 545     int heightWithItems = 0;
 546     if (!HasFlag(wxCB_SIMPLE))
 547         heightWithItems = height + hItem*nItems;
 548     else
 549         heightWithItems = SetHeightSimpleComboBox(nItems);
 550
 551
 552     // do resize the native control
 553     wxControl::DoSetSize(x, y, width, heightWithItems, sizeFlags);
 554
 555
 556     // make the control itself of the requested height: notice that this
 557     // must be done after changing its size or it has no effect (apparently
 558     // the height is reset to default during the control layout) and that it's
 559     // useless to to do it when using the deferred sizing -- in this case it
 560     // will be done from MSWEndDeferWindowPos()
 561 #if wxUSE_DEFERRED_SIZING
 562     if ( m_pendingSize == wxDefaultSize )
 563     {
 564         // not using deferred sizing, update it immediately
 565         MSWUpdateVisibleHeight();
 566     }
 567     else // in the middle of deferred sizing
 568     {
 569         // we need to report the size of the visible part of the control back
 570         // in GetSize() and not height stored by DoSetSize() in m_pendingSize
 571         m_pendingSize = wxSize(width, height);
 572     }
 573 #else // !wxUSE_DEFERRED_SIZING
 574     // always update the visible height immediately
 575     MSWUpdateVisibleHeight();
 576 #endif // wxUSE_DEFERRED_SIZING
 577 }
 578
 579 wxSize wxChoice::DoGetBestSize() const
 580 {
 581     // find the widest string
 582     int wChoice = 0;
 583     int hChoice;
 584     const unsigned int nItems = GetCount();
 585     for ( unsigned int i = 0; i < nItems; i++ )
 586     {
 587         int wLine;
 588         GetTextExtent(GetString(i), &wLine, NULL);
 589         if ( wLine > wChoice )
 590             wChoice = wLine;
 591     }
 592
 593     // give it some reasonable default value if there are no strings in the
 594     // list
 595     if ( wChoice == 0 )
 596         wChoice = 100;
 597
 598     // the combobox should be slightly larger than the widest string
 599     wChoice += 5*GetCharWidth();
 600     if( HasFlag( wxCB_SIMPLE ) )
 601     {
 602         hChoice = SetHeightSimpleComboBox( nItems );
 603     }
 604     else
 605         hChoice = EDIT_HEIGHT_FROM_CHAR_HEIGHT(GetCharHeight());
 606
 607     wxSize best(wChoice, hChoice);
 608     CacheBestSize(best);
 609     return best;
 610 }
 611
 612 int wxChoice::SetHeightSimpleComboBox(int nItems) const
 613 {
 614     int cx, cy;
 615     wxGetCharSize( GetHWND(), &cx, &cy, GetFont() );
 616     int hItem = SendMessage(GetHwnd(), CB_GETITEMHEIGHT, (WPARAM)-1, 0);
 617     return EDIT_HEIGHT_FROM_CHAR_HEIGHT( cy ) * wxMin( wxMax( nItems, 3 ), 6 ) + hItem - 1;
 618 }
 619
 620 // ----------------------------------------------------------------------------
 621 // MSW message handlers
 622 // ----------------------------------------------------------------------------
 623
 624 WXLRESULT wxChoice::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
 625 {
 626     switch ( nMsg )
 627     {
 628         case WM_LBUTTONUP:
 629             {
 630                 int x = (int)LOWORD(lParam);
 631                 int y = (int)HIWORD(lParam);
 632
 633                 // Ok, this is truly weird, but if a panel with a wxChoice
 634                 // loses the focus, then you get a *fake* WM_LBUTTONUP message
 635                 // with x = 65535 and y = 65535. Filter out this nonsense.
 636                 //
 637                 // VZ: I'd like to know how to reproduce this please...
 638                 if ( x == 65535 && y == 65535 )
 639                     return 0;
 640             }
 641             break;
 642
 643             // we have to handle both: one for the normal case and the other
 644             // for readonly
 645         case WM_CTLCOLOREDIT:
 646         case WM_CTLCOLORLISTBOX:
 647         case WM_CTLCOLORSTATIC:
 648             {
 649                 WXHDC hdc;
 650                 WXHWND hwnd;
 651                 UnpackCtlColor(wParam, lParam, &hdc, &hwnd);
 652
 653                 WXHBRUSH hbr = MSWControlColor((WXHDC)hdc, hwnd);
 654                 if ( hbr )
 655                     return (WXLRESULT)hbr;
 656                 //else: fall through to default window proc
 657             }
 658     }
 659
 660     return wxWindow::MSWWindowProc(nMsg, wParam, lParam);
 661 }
 662
 663 bool wxChoice::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
 664 {
 665     /*
 666         The native control provides a great variety in the events it sends in
 667         the different selection scenarios (undoubtedly for greater amusement of
 668         the programmers using it). For the reference, here are the cases when
 669         the final selection is accepted (things are quite interesting when it
 670         is cancelled too):
 671
 672         A. Selecting with just the arrows without opening the dropdown:
 673             1. CBN_SELENDOK
 674             2. CBN_SELCHANGE
 675
 676         B. Opening dropdown with F4 and selecting with arrows:
 677             1. CBN_DROPDOWN
 678             2. many CBN_SELCHANGE while changing selection in the list
 679             3. CBN_SELENDOK
 680             4. CBN_CLOSEUP
 681
 682         C. Selecting with the mouse:
 683             1. CBN_DROPDOWN
 684             -- no intermediate CBN_SELCHANGEs --
 685             2. CBN_SELENDOK
 686             3. CBN_CLOSEUP
 687             4. CBN_SELCHANGE
 688
 689         Admire the different order of messages in all of those cases, it must
 690         surely have taken a lot of effort to Microsoft developers to achieve
 691         such originality.
 692      */
 693     switch ( param )
 694     {
 695         case CBN_DROPDOWN:
 696             // we use this value both because we don't want to track selection
 697             // using CB_GETCURSEL while the dropdown is opened and because we
 698             // need to reset the selection back to it if it's eventually
 699             // cancelled by user
 700             m_lastAcceptedSelection = GetCurrentSelection();
 701             break;
 702
 703         case CBN_CLOSEUP:
 704             // if the selection was accepted by the user, it should have been
 705             // reset to wxID_NONE by CBN_SELENDOK, otherwise the selection was
 706             // cancelled and we must restore the old one
 707             if ( m_lastAcceptedSelection != wxID_NONE )
 708             {
 709                 SetSelection(m_lastAcceptedSelection);
 710                 m_lastAcceptedSelection = wxID_NONE;
 711             }
 712             break;
 713
 714         case CBN_SELENDOK:
 715             // reset it to prevent CBN_CLOSEUP from undoing the selection (it's
 716             // ok to reset it now as GetCurrentSelection() will now return the
 717             // same thing anyhow)
 718             m_lastAcceptedSelection = wxID_NONE;
 719
 720             {
 721                 const int n = GetSelection();
 722
 723                 wxCommandEvent event(wxEVT_COMMAND_CHOICE_SELECTED, m_windowId);
 724                 event.SetInt(n);
 725                 event.SetEventObject(this);
 726
 727                 if ( n > -1 )
 728                 {
 729                     event.SetString(GetStringSelection());
 730                     InitCommandEventWithItems(event, n);
 731                 }
 732
 733                 ProcessCommand(event);
 734             }
 735             break;
 736
 737         // don't handle CBN_SELENDCANCEL: just leave m_lastAcceptedSelection
 738         // valid and the selection will be undone in CBN_CLOSEUP above
 739
 740         // don't handle CBN_SELCHANGE neither, we don't want to generate events
 741         // while the dropdown is opened -- but do add it if we ever need this
 742
 743         default:
 744             return false;
 745     }
 746
 747     return true;
 748 }
 749
 750 WXHBRUSH wxChoice::MSWControlColor(WXHDC hDC, WXHWND hWnd)
 751 {
 752     if ( !IsEnabled() )
 753         return MSWControlColorDisabled(hDC);
 754
 755     return wxChoiceBase::MSWControlColor(hDC, hWnd);
 756 }
 757
 758 #endif // wxUSE_CHOICE && !(__SMARTPHONE__ && __WXWINCE__)