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/log.h"
  34     #include "wx/brush.h"
  35     #include "wx/settings.h"
  36 #endif
  37
  38 #include "wx/msw/private.h"
  39
  40 #if wxUSE_EXTENDED_RTTI
  41 WX_DEFINE_FLAGS( wxChoiceStyle )
  42
  43 wxBEGIN_FLAGS( wxChoiceStyle )
  44     // new style border flags, we put them first to
  45     // use them for streaming out
  46     wxFLAGS_MEMBER(wxBORDER_SIMPLE)
  47     wxFLAGS_MEMBER(wxBORDER_SUNKEN)
  48     wxFLAGS_MEMBER(wxBORDER_DOUBLE)
  49     wxFLAGS_MEMBER(wxBORDER_RAISED)
  50     wxFLAGS_MEMBER(wxBORDER_STATIC)
  51     wxFLAGS_MEMBER(wxBORDER_NONE)
  52
  53     // old style border flags
  54     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
  55     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
  56     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
  57     wxFLAGS_MEMBER(wxRAISED_BORDER)
  58     wxFLAGS_MEMBER(wxSTATIC_BORDER)
  59     wxFLAGS_MEMBER(wxBORDER)
  60
  61     // standard window styles
  62     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
  63     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
  64     wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
  65     wxFLAGS_MEMBER(wxWANTS_CHARS)
  66     wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
  67     wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
  68     wxFLAGS_MEMBER(wxVSCROLL)
  69     wxFLAGS_MEMBER(wxHSCROLL)
  70
  71 wxEND_FLAGS( wxChoiceStyle )
  72
  73 IMPLEMENT_DYNAMIC_CLASS_XTI(wxChoice, wxControlWithItems,"wx/choice.h")
  74
  75 wxBEGIN_PROPERTIES_TABLE(wxChoice)
  76     wxEVENT_PROPERTY( Select , wxEVT_COMMAND_CHOICE_SELECTED , wxCommandEvent )
  77
  78     wxPROPERTY( Font , wxFont , SetFont , GetFont  , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
  79     wxPROPERTY_COLLECTION( Choices , wxArrayString , wxString , AppendString , GetStrings , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
  80     wxPROPERTY( Selection ,int, SetSelection, GetSelection, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
  81     wxPROPERTY_FLAGS( WindowStyle , wxChoiceStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
  82 wxEND_PROPERTIES_TABLE()
  83
  84 wxBEGIN_HANDLERS_TABLE(wxChoice)
  85 wxEND_HANDLERS_TABLE()
  86
  87 wxCONSTRUCTOR_4( wxChoice , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size )
  88 #else
  89 IMPLEMENT_DYNAMIC_CLASS(wxChoice, wxControlWithItems)
  90 #endif
  91 /*
  92     TODO PROPERTIES
  93         selection (long)
  94         content (list)
  95             item
  96 */
  97
  98 // ============================================================================
  99 // implementation
 100 // ============================================================================
 101
 102 // ----------------------------------------------------------------------------
 103 // creation
 104 // ----------------------------------------------------------------------------
 105
 106 bool wxChoice::Create(wxWindow *parent,
 107                       wxWindowID id,
 108                       const wxPoint& pos,
 109                       const wxSize& size,
 110                       int n, const wxString choices[],
 111                       long style,
 112                       const wxValidator& validator,
 113                       const wxString& name)
 114 {
 115     // Experience shows that wxChoice vs. wxComboBox distinction confuses
 116     // quite a few people - try to help them
 117     wxASSERT_MSG( !(style & wxCB_DROPDOWN) &&
 118                   !(style & wxCB_READONLY) &&
 119                   !(style & wxCB_SIMPLE),
 120                   _T("this style flag is ignored by wxChoice, you ")
 121                   _T("probably want to use a wxComboBox") );
 122
 123     return CreateAndInit(parent, id, pos, size, n, choices, style,
 124                          validator, name);
 125 }
 126
 127 bool wxChoice::CreateAndInit(wxWindow *parent,
 128                              wxWindowID id,
 129                              const wxPoint& pos,
 130                              const wxSize& size,
 131                              int n, const wxString choices[],
 132                              long style,
 133                              const wxValidator& validator,
 134                              const wxString& name)
 135 {
 136     // initialize wxControl
 137     if ( !CreateControl(parent, id, pos, size, style, validator, name) )
 138         return false;
 139
 140     // now create the real HWND
 141     if ( !MSWCreateControl(wxT("COMBOBOX"), wxEmptyString, pos, size) )
 142         return false;
 143
 144
 145     // choice/combobox normally has "white" (depends on colour scheme, of
 146     // course) background rather than inheriting the parent's background
 147     SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
 148
 149     // initialize the controls contents
 150     for ( int i = 0; i < n; i++ )
 151     {
 152         Append(choices[i]);
 153     }
 154
 155     // and now we may finally size the control properly (if needed)
 156     SetInitialSize(size);
 157
 158     return true;
 159 }
 160
 161 bool wxChoice::Create(wxWindow *parent,
 162                       wxWindowID id,
 163                       const wxPoint& pos,
 164                       const wxSize& size,
 165                       const wxArrayString& choices,
 166                       long style,
 167                       const wxValidator& validator,
 168                       const wxString& name)
 169 {
 170     wxCArrayString chs(choices);
 171     return Create(parent, id, pos, size, chs.GetCount(), chs.GetStrings(),
 172                   style, validator, name);
 173 }
 174
 175 bool wxChoice::MSWShouldPreProcessMessage(WXMSG *pMsg)
 176 {
 177     MSG *msg = (MSG *) pMsg;
 178
 179     // if the dropdown list is visible, don't preprocess certain keys
 180     if ( msg->message == WM_KEYDOWN
 181         && (msg->wParam == VK_ESCAPE || msg->wParam == VK_RETURN) )
 182     {
 183         if (::SendMessage(GetHwndOf(this), CB_GETDROPPEDSTATE, 0, 0))
 184         {
 185             return false;
 186         }
 187     }
 188
 189     return wxControl::MSWShouldPreProcessMessage(pMsg);
 190 }
 191
 192 WXDWORD wxChoice::MSWGetStyle(long style, WXDWORD *exstyle) const
 193 {
 194     // we never have an external border
 195     WXDWORD msStyle = wxControl::MSWGetStyle
 196                       (
 197                         (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
 198                       );
 199
 200     // WS_CLIPSIBLINGS is useful with wxChoice and doesn't seem to result in
 201     // any problems
 202     msStyle |= WS_CLIPSIBLINGS;
 203
 204     // wxChoice-specific styles
 205     msStyle |= CBS_DROPDOWNLIST | WS_HSCROLL | WS_VSCROLL;
 206     if ( style & wxCB_SORT )
 207         msStyle |= CBS_SORT;
 208
 209     return msStyle;
 210 }
 211
 212 wxChoice::~wxChoice()
 213 {
 214     Free();
 215 }
 216
 217 // ----------------------------------------------------------------------------
 218 // adding/deleting items to/from the list
 219 // ----------------------------------------------------------------------------
 220
 221 int wxChoice::DoAppend(const wxString& item)
 222 {
 223     int n = (int)SendMessage(GetHwnd(), CB_ADDSTRING, 0, (LPARAM)item.c_str());
 224     if ( n == CB_ERR )
 225     {
 226         wxLogLastError(wxT("SendMessage(CB_ADDSTRING)"));
 227     }
 228     else // ok
 229     {
 230         // we need to refresh our size in order to have enough space for the
 231         // newly added items
 232         if ( !IsFrozen() )
 233             UpdateVisibleHeight();
 234     }
 235
 236     InvalidateBestSize();
 237     return n;
 238 }
 239
 240 int wxChoice::DoInsert(const wxString& item, unsigned int pos)
 241 {
 242     wxCHECK_MSG(!(GetWindowStyle() & wxCB_SORT), -1, wxT("can't insert into sorted list"));
 243     wxCHECK_MSG(IsValidInsert(pos), -1, wxT("invalid index"));
 244
 245     int n = (int)SendMessage(GetHwnd(), CB_INSERTSTRING, pos, (LPARAM)item.c_str());
 246     if ( n == CB_ERR )
 247     {
 248         wxLogLastError(wxT("SendMessage(CB_INSERTSTRING)"));
 249     }
 250     else // ok
 251     {
 252         if ( !IsFrozen() )
 253             UpdateVisibleHeight();
 254     }
 255
 256     InvalidateBestSize();
 257     return n;
 258 }
 259
 260 void wxChoice::Delete(unsigned int n)
 261 {
 262     wxCHECK_RET( IsValid(n), wxT("invalid item index in wxChoice::Delete") );
 263
 264     if ( HasClientObjectData() )
 265     {
 266         delete GetClientObject(n);
 267     }
 268
 269     SendMessage(GetHwnd(), CB_DELETESTRING, n, 0);
 270
 271     if ( !IsFrozen() )
 272         UpdateVisibleHeight();
 273
 274     InvalidateBestSize();
 275 }
 276
 277 void wxChoice::Clear()
 278 {
 279     Free();
 280
 281     SendMessage(GetHwnd(), CB_RESETCONTENT, 0, 0);
 282
 283     if ( !IsFrozen() )
 284         UpdateVisibleHeight();
 285
 286     InvalidateBestSize();
 287 }
 288
 289 void wxChoice::Free()
 290 {
 291     if ( HasClientObjectData() )
 292     {
 293         unsigned int count = GetCount();
 294         for ( unsigned int n = 0; n < count; n++ )
 295         {
 296             delete GetClientObject(n);
 297         }
 298     }
 299 }
 300
 301 // ----------------------------------------------------------------------------
 302 // selection
 303 // ----------------------------------------------------------------------------
 304
 305 int wxChoice::GetSelection() const
 306 {
 307     // if m_lastAcceptedSelection is set, it means that the dropdown is
 308     // currently shown and that we want to use the last "permanent" selection
 309     // instead of whatever is under the mouse pointer currently
 310     //
 311     // otherwise, get the selection from the control
 312     return m_lastAcceptedSelection == wxID_NONE ? GetCurrentSelection()
 313                                                 : m_lastAcceptedSelection;
 314 }
 315
 316 int wxChoice::GetCurrentSelection() const
 317 {
 318     return (int)SendMessage(GetHwnd(), CB_GETCURSEL, 0, 0);
 319 }
 320
 321 void wxChoice::SetSelection(int n)
 322 {
 323     SendMessage(GetHwnd(), CB_SETCURSEL, n, 0);
 324 }
 325
 326 // ----------------------------------------------------------------------------
 327 // string list functions
 328 // ----------------------------------------------------------------------------
 329
 330 unsigned int wxChoice::GetCount() const
 331 {
 332     return (unsigned int)SendMessage(GetHwnd(), CB_GETCOUNT, 0, 0);
 333 }
 334
 335 int wxChoice::FindString(const wxString& s, bool bCase) const
 336 {
 337 #if defined(__WATCOMC__) && defined(__WIN386__)
 338     // For some reason, Watcom in WIN386 mode crashes in the CB_FINDSTRINGEXACT message.
 339     // wxChoice::Do it the long way instead.
 340     unsigned int count = GetCount();
 341     for ( unsigned int i = 0; i < count; i++ )
 342     {
 343         // as CB_FINDSTRINGEXACT is case insensitive, be case insensitive too
 344         if (GetString(i).IsSameAs(s, bCase))
 345             return i;
 346     }
 347
 348     return wxNOT_FOUND;
 349 #else // !Watcom
 350    //TODO:  Evidently some MSW versions (all?) don't like empty strings
 351    //passed to SendMessage, so we have to do it ourselves in that case
 352    if ( s.empty() )
 353    {
 354        unsigned int count = GetCount();
 355        for ( unsigned int i = 0; i < count; i++ )
 356        {
 357          if (GetString(i).empty())
 358              return i;
 359        }
 360
 361        return wxNOT_FOUND;
 362    }
 363    else if (bCase)
 364    {
 365        // back to base class search for not native search type
 366        return wxItemContainerImmutable::FindString( s, bCase );
 367    }
 368    else
 369    {
 370        int pos = (int)SendMessage(GetHwnd(), CB_FINDSTRINGEXACT,
 371                                   (WPARAM)-1, (LPARAM)s.c_str());
 372
 373        return pos == LB_ERR ? wxNOT_FOUND : pos;
 374    }
 375 #endif // Watcom/!Watcom
 376 }
 377
 378 void wxChoice::SetString(unsigned int n, const wxString& s)
 379 {
 380     wxCHECK_RET( IsValid(n), wxT("invalid item index in wxChoice::SetString") );
 381
 382     // we have to delete and add back the string as there is no way to change a
 383     // string in place
 384
 385     // we need to preserve the client data
 386     void *data;
 387     if ( m_clientDataItemsType != wxClientData_None )
 388     {
 389         data = DoGetItemClientData(n);
 390     }
 391     else // no client data
 392     {
 393         data = NULL;
 394     }
 395
 396     ::SendMessage(GetHwnd(), CB_DELETESTRING, n, 0);
 397     ::SendMessage(GetHwnd(), CB_INSERTSTRING, n, (LPARAM)s.c_str() );
 398
 399     if ( data )
 400     {
 401         DoSetItemClientData(n, data);
 402     }
 403     //else: it's already NULL by default
 404
 405     InvalidateBestSize();
 406 }
 407
 408 wxString wxChoice::GetString(unsigned int n) const
 409 {
 410     int len = (int)::SendMessage(GetHwnd(), CB_GETLBTEXTLEN, n, 0);
 411
 412     wxString str;
 413     if ( len != CB_ERR && len > 0 )
 414     {
 415         if ( ::SendMessage
 416                (
 417                 GetHwnd(),
 418                 CB_GETLBTEXT,
 419                 n,
 420                 (LPARAM)(wxChar *)wxStringBuffer(str, len)
 421                ) == CB_ERR )
 422         {
 423             wxLogLastError(wxT("SendMessage(CB_GETLBTEXT)"));
 424         }
 425     }
 426
 427     return str;
 428 }
 429
 430 // ----------------------------------------------------------------------------
 431 // client data
 432 // ----------------------------------------------------------------------------
 433
 434 void wxChoice::DoSetItemClientData(unsigned int n, void* clientData)
 435 {
 436     if ( ::SendMessage(GetHwnd(), CB_SETITEMDATA,
 437                        n, (LPARAM)clientData) == CB_ERR )
 438     {
 439         wxLogLastError(wxT("CB_SETITEMDATA"));
 440     }
 441 }
 442
 443 void* wxChoice::DoGetItemClientData(unsigned int n) const
 444 {
 445     LPARAM rc = SendMessage(GetHwnd(), CB_GETITEMDATA, n, 0);
 446     if ( rc == CB_ERR )
 447     {
 448         wxLogLastError(wxT("CB_GETITEMDATA"));
 449
 450         // unfortunately, there is no way to return an error code to the user
 451         rc = (LPARAM) NULL;
 452     }
 453
 454     return (void *)rc;
 455 }
 456
 457 void wxChoice::DoSetItemClientObject(unsigned int n, wxClientData* clientData)
 458 {
 459     DoSetItemClientData(n, clientData);
 460 }
 461
 462 wxClientData* wxChoice::DoGetItemClientObject(unsigned int n) const
 463 {
 464     return (wxClientData *)DoGetItemClientData(n);
 465 }
 466
 467 // ----------------------------------------------------------------------------
 468 // wxMSW specific helpers
 469 // ----------------------------------------------------------------------------
 470
 471 void wxChoice::UpdateVisibleHeight()
 472 {
 473     // be careful to not change the width here
 474     DoSetSize(wxDefaultCoord, wxDefaultCoord, wxDefaultCoord, GetSize().y, wxSIZE_USE_EXISTING);
 475 }
 476
 477 void wxChoice::DoMoveWindow(int x, int y, int width, int height)
 478 {
 479     // here is why this is necessary: if the width is negative, the combobox
 480     // window proc makes the window of the size width*height instead of
 481     // interpreting height in the usual manner (meaning the height of the drop
 482     // down list - usually the height specified in the call to MoveWindow()
 483     // will not change the height of combo box per se)
 484     //
 485     // this behaviour is not documented anywhere, but this is just how it is
 486     // here (NT 4.4) and, anyhow, the check shouldn't hurt - however without
 487     // the check, constraints/sizers using combos may break the height
 488     // constraint will have not at all the same value as expected
 489     if ( width < 0 )
 490         return;
 491
 492     wxControl::DoMoveWindow(x, y, width, height);
 493 }
 494
 495 void wxChoice::DoGetSize(int *w, int *h) const
 496 {
 497     // this is weird: sometimes, the height returned by Windows is clearly the
 498     // total height of the control including the drop down list -- but only
 499     // sometimes, and normally it isn't... I have no idea about what to do with
 500     // this
 501     wxControl::DoGetSize(w, h);
 502 }
 503
 504 void wxChoice::DoSetSize(int x, int y,
 505                          int width, int height,
 506                          int sizeFlags)
 507 {
 508     int heightOrig = height;
 509
 510     // the height which we must pass to Windows should be the total height of
 511     // the control including the drop down list while the height given to us
 512     // is, of course, just the height of the permanently visible part of it
 513     if ( height != wxDefaultCoord )
 514     {
 515         // don't make the drop down list too tall, arbitrarily limit it to 40
 516         // items max and also don't leave it empty
 517         size_t nItems = GetCount();
 518         if ( !nItems )
 519             nItems = 9;
 520         else if ( nItems > 24 )
 521             nItems = 24;
 522
 523         // add space for the drop down list
 524         const int hItem = SendMessage(GetHwnd(), CB_GETITEMHEIGHT, 0, 0);
 525         height += hItem*(nItems + 1);
 526     }
 527     else
 528     {
 529         // We cannot pass wxDefaultCoord as height to wxControl. wxControl uses
 530         // wxGetWindowRect() to determine the current height of the combobox,
 531         // and then again sets the combobox's height to that value. Unfortunately,
 532         // wxGetWindowRect doesn't include the dropdown list's height (at least
 533         // on Win2K), so this would result in a combobox with dropdown height of
 534         // 1 pixel. We have to determine the default height ourselves and call
 535         // wxControl with that value instead.
 536         int w, h;
 537         RECT r;
 538         DoGetSize(&w, &h);
 539         if (::SendMessage(GetHwnd(), CB_GETDROPPEDCONTROLRECT, 0, (LPARAM) &r) != 0)
 540         {
 541             height = h + r.bottom - r.top;
 542         }
 543     }
 544
 545     wxControl::DoSetSize(x, y, width, height, sizeFlags);
 546
 547     // If we're storing a pending size, make sure we store
 548     // the original size for reporting back to the app.
 549     if (m_pendingSize != wxDefaultSize)
 550         m_pendingSize = wxSize(width, heightOrig);
 551
 552     // This solution works on XP, but causes choice/combobox lists to be
 553     // too short on W2K and earlier.
 554 #if 0
 555     int widthCurrent, heightCurrent;
 556     DoGetSize(&widthCurrent, &heightCurrent);
 557
 558     // the height which we must pass to Windows should be the total height of
 559     // the control including the drop down list while the height given to us
 560     // is, of course, just the height of the permanently visible part of it
 561     if ( height != wxDefaultCoord && height != heightCurrent )
 562     {
 563         // don't make the drop down list too tall, arbitrarily limit it to 40
 564         // items max and also don't leave it empty
 565         unsigned int nItems = GetCount();
 566         if ( !nItems )
 567             nItems = 9;
 568         else if ( nItems > 24 )
 569             nItems = 24;
 570
 571         // add space for the drop down list
 572         const int hItem = SendMessage(GetHwnd(), CB_GETITEMHEIGHT, 0, 0);
 573         height += hItem*(nItems + 1);
 574     }
 575     else // keep the same height as now
 576     {
 577         // normally wxWindow::DoSetSize() checks if we set the same size as the
 578         // window already has and does nothing in this case, but for us the
 579         // check fails as the size we pass to it includes the dropdown while
 580         // the size returned by our GetSize() does not, so test if the size
 581         // didn't really change ourselves here
 582         if ( width == wxDefaultCoord || width == widthCurrent )
 583         {
 584             // size doesn't change, what about position?
 585             int xCurrent, yCurrent;
 586             DoGetPosition(&xCurrent, &yCurrent);
 587             const bool defMeansUnchanged = !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE);
 588             if ( ((x == wxDefaultCoord && defMeansUnchanged) || x == xCurrent)
 589                     &&
 590                  ((y == wxDefaultCoord && defMeansUnchanged) || y == yCurrent) )
 591             {
 592                 // nothing changes, nothing to do
 593                 return;
 594             }
 595         }
 596
 597         // We cannot pass wxDefaultCoord as height to wxControl. wxControl uses
 598         // wxGetWindowRect() to determine the current height of the combobox,
 599         // and then again sets the combobox's height to that value. Unfortunately,
 600         // wxGetWindowRect doesn't include the dropdown list's height (at least
 601         // on Win2K), so this would result in a combobox with dropdown height of
 602         // 1 pixel. We have to determine the default height ourselves and call
 603         // wxControl with that value instead.
 604         //
 605         // Also notice that sometimes CB_GETDROPPEDCONTROLRECT seems to return
 606         // wildly incorrect values (~32000) which looks like a bug in it, just
 607         // ignore them in this case
 608         RECT r;
 609         if ( ::SendMessage(GetHwnd(), CB_GETDROPPEDCONTROLRECT, 0, (LPARAM) &r)
 610                     && r.bottom < 30000 )
 611         {
 612             height = heightCurrent + r.bottom - r.top;
 613         }
 614     }
 615
 616     wxControl::DoSetSize(x, y, width, height, sizeFlags);
 617 #endif
 618 }
 619
 620 wxSize wxChoice::DoGetBestSize() const
 621 {
 622     // find the widest string
 623     int wChoice = 0;
 624     const unsigned int nItems = GetCount();
 625     for ( unsigned int i = 0; i < nItems; i++ )
 626     {
 627         int wLine;
 628         GetTextExtent(GetString(i), &wLine, NULL);
 629         if ( wLine > wChoice )
 630             wChoice = wLine;
 631     }
 632
 633     // give it some reasonable default value if there are no strings in the
 634     // list
 635     if ( wChoice == 0 )
 636         wChoice = 100;
 637
 638     // the combobox should be slightly larger than the widest string
 639     wChoice += 5*GetCharWidth();
 640
 641     wxSize best(wChoice, EDIT_HEIGHT_FROM_CHAR_HEIGHT(GetCharHeight()));
 642     CacheBestSize(best);
 643     return best;
 644 }
 645
 646 WXLRESULT wxChoice::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
 647 {
 648     switch ( nMsg )
 649     {
 650         case WM_LBUTTONUP:
 651             {
 652                 int x = (int)LOWORD(lParam);
 653                 int y = (int)HIWORD(lParam);
 654
 655                 // Ok, this is truly weird, but if a panel with a wxChoice
 656                 // loses the focus, then you get a *fake* WM_LBUTTONUP message
 657                 // with x = 65535 and y = 65535. Filter out this nonsense.
 658                 //
 659                 // VZ: I'd like to know how to reproduce this please...
 660                 if ( x == 65535 && y == 65535 )
 661                     return 0;
 662             }
 663             break;
 664
 665             // we have to handle both: one for the normal case and the other
 666             // for readonly
 667         case WM_CTLCOLOREDIT:
 668         case WM_CTLCOLORLISTBOX:
 669         case WM_CTLCOLORSTATIC:
 670             {
 671                 WXHDC hdc;
 672                 WXHWND hwnd;
 673                 UnpackCtlColor(wParam, lParam, &hdc, &hwnd);
 674
 675                 WXHBRUSH hbr = MSWControlColor((WXHDC)hdc, hwnd);
 676                 if ( hbr )
 677                     return (WXLRESULT)hbr;
 678                 //else: fall through to default window proc
 679             }
 680     }
 681
 682     return wxWindow::MSWWindowProc(nMsg, wParam, lParam);
 683 }
 684
 685 bool wxChoice::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
 686 {
 687     /*
 688         The native control provides a great variety in the events it sends in
 689         the different selection scenarios (undoubtedly for greater amusement of
 690         the programmers using it). For the reference, here are the cases when
 691         the final selection is accepted (things are quite interesting when it
 692         is cancelled too):
 693
 694         A. Selecting with just the arrows without opening the dropdown:
 695             1. CBN_SELENDOK
 696             2. CBN_SELCHANGE
 697
 698         B. Opening dropdown with F4 and selecting with arrows:
 699             1. CBN_DROPDOWN
 700             2. many CBN_SELCHANGE while changing selection in the list
 701             3. CBN_SELENDOK
 702             4. CBN_CLOSEUP
 703
 704         C. Selecting with the mouse:
 705             1. CBN_DROPDOWN
 706             -- no intermediate CBN_SELCHANGEs --
 707             2. CBN_SELENDOK
 708             3. CBN_CLOSEUP
 709             4. CBN_SELCHANGE
 710
 711         Admire the different order of messages in all of those cases, it must
 712         surely have taken a lot of effort to Microsoft developers to achieve
 713         such originality.
 714      */
 715     switch ( param )
 716     {
 717         case CBN_DROPDOWN:
 718             // we use this value both because we don't want to track selection
 719             // using CB_GETCURSEL while the dropdown is opened and because we
 720             // need to reset the selection back to it if it's eventually
 721             // cancelled by user
 722             m_lastAcceptedSelection = GetCurrentSelection();
 723             break;
 724
 725         case CBN_CLOSEUP:
 726             // if the selection was accepted by the user, it should have been
 727             // reset to wxID_NONE by CBN_SELENDOK, otherwise the selection was
 728             // cancelled and we must restore the old one
 729             if ( m_lastAcceptedSelection != wxID_NONE )
 730             {
 731                 SetSelection(m_lastAcceptedSelection);
 732                 m_lastAcceptedSelection = wxID_NONE;
 733             }
 734             break;
 735
 736         case CBN_SELENDOK:
 737             // reset it to prevent CBN_CLOSEUP from undoing the selection (it's
 738             // ok to reset it now as GetCurrentSelection() will now return the
 739             // same thing anyhow)
 740             m_lastAcceptedSelection = wxID_NONE;
 741
 742             {
 743                 const int n = GetSelection();
 744
 745                 wxCommandEvent event(wxEVT_COMMAND_CHOICE_SELECTED, m_windowId);
 746                 event.SetInt(n);
 747                 event.SetEventObject(this);
 748
 749                 if ( n > -1 )
 750                 {
 751                     event.SetString(GetStringSelection());
 752                     InitCommandEventWithItems(event, n);
 753                 }
 754
 755                 ProcessCommand(event);
 756             }
 757             break;
 758
 759         // don't handle CBN_SELENDCANCEL: just leave m_lastAcceptedSelection
 760         // valid and the selection will be undone in CBN_CLOSEUP above
 761
 762         // don't handle CBN_SELCHANGE neither, we don't want to generate events
 763         // while the dropdown is opened -- but do add it if we ever need this
 764
 765         default:
 766             return false;
 767     }
 768
 769     return true;
 770 }
 771
 772 WXHBRUSH wxChoice::MSWControlColor(WXHDC hDC, WXHWND hWnd)
 773 {
 774     if ( !IsEnabled() )
 775         return MSWControlColorDisabled(hDC);
 776
 777     return wxChoiceBase::MSWControlColor(hDC, hWnd);
 778 }
 779
 780 #endif // wxUSE_CHOICE && !(__SMARTPHONE__ && __WXWINCE__)