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