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