]>
Commit | Line | Data |
---|---|---|
2bda0e17 | 1 | ///////////////////////////////////////////////////////////////////////////// |
11e62fe6 | 2 | // Name: src/msw/choice.cpp |
2bda0e17 KB |
3 | // Purpose: wxChoice |
4 | // Author: Julian Smart | |
8d99be5f | 5 | // Modified by: Vadim Zeitlin to derive from wxChoiceBase |
2bda0e17 KB |
6 | // Created: 04/01/98 |
7 | // RCS-ID: $Id$ | |
6c9a19aa | 8 | // Copyright: (c) Julian Smart |
65571936 | 9 | // Licence: wxWindows licence |
2bda0e17 KB |
10 | ///////////////////////////////////////////////////////////////////////////// |
11 | ||
8d99be5f VZ |
12 | // ============================================================================ |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
2bda0e17 KB |
20 | // For compilers that support precompilation, includes "wx.h". |
21 | #include "wx/wxprec.h" | |
22 | ||
23 | #ifdef __BORLANDC__ | |
8d99be5f | 24 | #pragma hdrstop |
2bda0e17 KB |
25 | #endif |
26 | ||
3180bc0e | 27 | #if wxUSE_CHOICE && !(defined(__SMARTPHONE__) && defined(__WXWINCE__)) |
1e6feb95 | 28 | |
b36e08d0 WS |
29 | #include "wx/choice.h" |
30 | ||
2bda0e17 | 31 | #ifndef WX_PRECOMP |
8d99be5f VZ |
32 | #include "wx/utils.h" |
33 | #include "wx/log.h" | |
f6bcfd97 | 34 | #include "wx/brush.h" |
c7401637 | 35 | #include "wx/settings.h" |
2bda0e17 KB |
36 | #endif |
37 | ||
38 | #include "wx/msw/private.h" | |
39 | ||
6a89f9ee | 40 | #if wxUSE_EXTENDED_RTTI |
bc9fb572 JS |
41 | WX_DEFINE_FLAGS( wxChoiceStyle ) |
42 | ||
3ff066a4 | 43 | wxBEGIN_FLAGS( wxChoiceStyle ) |
bc9fb572 JS |
44 | // new style border flags, we put them first to |
45 | // use them for streaming out | |
3ff066a4 SC |
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) | |
3dfb79a6 | 52 | |
bc9fb572 | 53 | // old style border flags |
3ff066a4 SC |
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) | |
cb0afb26 | 59 | wxFLAGS_MEMBER(wxBORDER) |
bc9fb572 JS |
60 | |
61 | // standard window styles | |
3ff066a4 SC |
62 | wxFLAGS_MEMBER(wxTAB_TRAVERSAL) |
63 | wxFLAGS_MEMBER(wxCLIP_CHILDREN) | |
64 | wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW) | |
65 | wxFLAGS_MEMBER(wxWANTS_CHARS) | |
cb0afb26 | 66 | wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE) |
3ff066a4 SC |
67 | wxFLAGS_MEMBER(wxALWAYS_SHOW_SB ) |
68 | wxFLAGS_MEMBER(wxVSCROLL) | |
69 | wxFLAGS_MEMBER(wxHSCROLL) | |
bc9fb572 | 70 | |
3ff066a4 | 71 | wxEND_FLAGS( wxChoiceStyle ) |
bc9fb572 | 72 | |
0ad2a19e | 73 | IMPLEMENT_DYNAMIC_CLASS_XTI(wxChoice, wxControlWithItems,"wx/choice.h") |
6a89f9ee | 74 | |
3ff066a4 | 75 | wxBEGIN_PROPERTIES_TABLE(wxChoice) |
3dfb79a6 | 76 | wxEVENT_PROPERTY( Select , wxEVT_COMMAND_CHOICE_SELECTED , wxCommandEvent ) |
c5ca409b | 77 | |
af498247 | 78 | wxPROPERTY( Font , wxFont , SetFont , GetFont , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) |
3ff066a4 | 79 | wxPROPERTY_COLLECTION( Choices , wxArrayString , wxString , AppendString , GetStrings , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) |
3dfb79a6 | 80 | wxPROPERTY( Selection ,int, SetSelection, GetSelection, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) |
af498247 | 81 | wxPROPERTY_FLAGS( WindowStyle , wxChoiceStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style |
3ff066a4 | 82 | wxEND_PROPERTIES_TABLE() |
6a89f9ee | 83 | |
3ff066a4 SC |
84 | wxBEGIN_HANDLERS_TABLE(wxChoice) |
85 | wxEND_HANDLERS_TABLE() | |
2bda0e17 | 86 | |
3dfb79a6 | 87 | wxCONSTRUCTOR_4( wxChoice , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size ) |
6a89f9ee | 88 | #else |
0ad2a19e | 89 | IMPLEMENT_DYNAMIC_CLASS(wxChoice, wxControlWithItems) |
6a89f9ee | 90 | #endif |
066f1b7a | 91 | /* |
3dfb79a6 VZ |
92 | TODO PROPERTIES |
93 | selection (long) | |
94 | content (list) | |
95 | item | |
066f1b7a SC |
96 | */ |
97 | ||
8d99be5f VZ |
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) | |
2bda0e17 | 114 | { |
f6bcfd97 | 115 | // Experience shows that wxChoice vs. wxComboBox distinction confuses |
8d99be5f VZ |
116 | // quite a few people - try to help them |
117 | wxASSERT_MSG( !(style & wxCB_DROPDOWN) && | |
118 | !(style & wxCB_READONLY) && | |
119 | !(style & wxCB_SIMPLE), | |
f6bcfd97 BP |
120 | _T("this style flag is ignored by wxChoice, you ") |
121 | _T("probably want to use a wxComboBox") ); | |
2bda0e17 | 122 | |
71e57cd6 VZ |
123 | return CreateAndInit(parent, id, pos, size, n, choices, style, |
124 | validator, name); | |
125 | } | |
126 | ||
cc61d2eb VZ |
127 | bool wxChoice::CreateAndInit(wxWindow *parent, |
128 | wxWindowID id, | |
71e57cd6 | 129 | const wxPoint& pos, |
3dfb79a6 | 130 | const wxSize& size, |
71e57cd6 VZ |
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) ) | |
02b7b6b0 | 138 | return false; |
2bda0e17 | 139 | |
71e57cd6 | 140 | // now create the real HWND |
f31a4098 | 141 | if ( !MSWCreateControl(wxT("COMBOBOX"), wxEmptyString, pos, size) ) |
02b7b6b0 | 142 | return false; |
71e57cd6 VZ |
143 | |
144 | ||
145 | // choice/combobox normally has "white" (depends on colour scheme, of | |
146 | // course) background rather than inheriting the parent's background | |
a756f210 | 147 | SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW)); |
c92d798f | 148 | |
cc61d2eb | 149 | // initialize the controls contents |
8d99be5f VZ |
150 | for ( int i = 0; i < n; i++ ) |
151 | { | |
152 | Append(choices[i]); | |
153 | } | |
2bda0e17 | 154 | |
cc61d2eb | 155 | // and now we may finally size the control properly (if needed) |
170acdc9 | 156 | SetInitialSize(size); |
cc61d2eb | 157 | |
02b7b6b0 | 158 | return true; |
2bda0e17 KB |
159 | } |
160 | ||
584ad2a3 MB |
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 | ||
4b17d2e3 DS |
175 | bool wxChoice::MSWShouldPreProcessMessage(WXMSG *pMsg) |
176 | { | |
177 | MSG *msg = (MSG *) pMsg; | |
178 | ||
dc302518 DS |
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) ) | |
4b17d2e3 DS |
182 | { |
183 | if (::SendMessage(GetHwndOf(this), CB_GETDROPPEDSTATE, 0, 0)) | |
184 | { | |
185 | return false; | |
186 | } | |
187 | } | |
188 | ||
189 | return wxControl::MSWShouldPreProcessMessage(pMsg); | |
190 | } | |
191 | ||
71e57cd6 VZ |
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 | ||
8ee9d618 VZ |
212 | wxChoice::~wxChoice() |
213 | { | |
214 | Free(); | |
215 | } | |
216 | ||
8d99be5f VZ |
217 | // ---------------------------------------------------------------------------- |
218 | // adding/deleting items to/from the list | |
219 | // ---------------------------------------------------------------------------- | |
2bda0e17 | 220 | |
def6fb9b | 221 | int wxChoice::DoAppend(const wxString& item) |
8d99be5f | 222 | { |
c140b7e7 | 223 | int n = (int)SendMessage(GetHwnd(), CB_ADDSTRING, 0, (LPARAM)item.c_str()); |
def6fb9b VZ |
224 | if ( n == CB_ERR ) |
225 | { | |
f6bcfd97 | 226 | wxLogLastError(wxT("SendMessage(CB_ADDSTRING)")); |
def6fb9b | 227 | } |
71e57cd6 VZ |
228 | else // ok |
229 | { | |
230 | // we need to refresh our size in order to have enough space for the | |
231 | // newly added items | |
e0e3a32d VZ |
232 | if ( !IsFrozen() ) |
233 | UpdateVisibleHeight(); | |
71e57cd6 | 234 | } |
def6fb9b | 235 | |
31582e4e | 236 | InvalidateBestSize(); |
def6fb9b | 237 | return n; |
2bda0e17 KB |
238 | } |
239 | ||
aa61d352 | 240 | int wxChoice::DoInsert(const wxString& item, unsigned int pos) |
243dbf1a VZ |
241 | { |
242 | wxCHECK_MSG(!(GetWindowStyle() & wxCB_SORT), -1, wxT("can't insert into sorted list")); | |
8228b893 | 243 | wxCHECK_MSG(IsValidInsert(pos), -1, wxT("invalid index")); |
243dbf1a | 244 | |
c140b7e7 | 245 | int n = (int)SendMessage(GetHwnd(), CB_INSERTSTRING, pos, (LPARAM)item.c_str()); |
243dbf1a VZ |
246 | if ( n == CB_ERR ) |
247 | { | |
248 | wxLogLastError(wxT("SendMessage(CB_INSERTSTRING)")); | |
249 | } | |
71e57cd6 VZ |
250 | else // ok |
251 | { | |
e0e3a32d VZ |
252 | if ( !IsFrozen() ) |
253 | UpdateVisibleHeight(); | |
71e57cd6 | 254 | } |
243dbf1a | 255 | |
31582e4e | 256 | InvalidateBestSize(); |
243dbf1a VZ |
257 | return n; |
258 | } | |
259 | ||
aa61d352 | 260 | void wxChoice::Delete(unsigned int n) |
2bda0e17 | 261 | { |
8228b893 | 262 | wxCHECK_RET( IsValid(n), wxT("invalid item index in wxChoice::Delete") ); |
8d99be5f | 263 | |
6c8a980f VZ |
264 | if ( HasClientObjectData() ) |
265 | { | |
266 | delete GetClientObject(n); | |
267 | } | |
268 | ||
8d99be5f | 269 | SendMessage(GetHwnd(), CB_DELETESTRING, n, 0); |
71e57cd6 | 270 | |
e0e3a32d VZ |
271 | if ( !IsFrozen() ) |
272 | UpdateVisibleHeight(); | |
31582e4e RD |
273 | |
274 | InvalidateBestSize(); | |
2bda0e17 KB |
275 | } |
276 | ||
8d99be5f | 277 | void wxChoice::Clear() |
8ee9d618 | 278 | { |
92d2389e | 279 | Free(); |
8ee9d618 VZ |
280 | |
281 | SendMessage(GetHwnd(), CB_RESETCONTENT, 0, 0); | |
71e57cd6 | 282 | |
e0e3a32d VZ |
283 | if ( !IsFrozen() ) |
284 | UpdateVisibleHeight(); | |
31582e4e RD |
285 | |
286 | InvalidateBestSize(); | |
8ee9d618 VZ |
287 | } |
288 | ||
289 | void wxChoice::Free() | |
2bda0e17 | 290 | { |
6c8a980f VZ |
291 | if ( HasClientObjectData() ) |
292 | { | |
aa61d352 VZ |
293 | unsigned int count = GetCount(); |
294 | for ( unsigned int n = 0; n < count; n++ ) | |
6c8a980f VZ |
295 | { |
296 | delete GetClientObject(n); | |
297 | } | |
298 | } | |
2bda0e17 KB |
299 | } |
300 | ||
8d99be5f VZ |
301 | // ---------------------------------------------------------------------------- |
302 | // selection | |
303 | // ---------------------------------------------------------------------------- | |
2bda0e17 | 304 | |
8d99be5f | 305 | int wxChoice::GetSelection() const |
6ba93d23 VZ |
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 | |
2bda0e17 | 317 | { |
8d99be5f | 318 | return (int)SendMessage(GetHwnd(), CB_GETCURSEL, 0, 0); |
2bda0e17 KB |
319 | } |
320 | ||
debe6624 | 321 | void wxChoice::SetSelection(int n) |
2bda0e17 | 322 | { |
8d99be5f VZ |
323 | SendMessage(GetHwnd(), CB_SETCURSEL, n, 0); |
324 | } | |
325 | ||
326 | // ---------------------------------------------------------------------------- | |
327 | // string list functions | |
328 | // ---------------------------------------------------------------------------- | |
329 | ||
aa61d352 | 330 | unsigned int wxChoice::GetCount() const |
8d99be5f | 331 | { |
aa61d352 | 332 | return (unsigned int)SendMessage(GetHwnd(), CB_GETCOUNT, 0, 0); |
2bda0e17 KB |
333 | } |
334 | ||
11e62fe6 | 335 | int wxChoice::FindString(const wxString& s, bool bCase) const |
2bda0e17 KB |
336 | { |
337 | #if defined(__WATCOMC__) && defined(__WIN386__) | |
8d99be5f VZ |
338 | // For some reason, Watcom in WIN386 mode crashes in the CB_FINDSTRINGEXACT message. |
339 | // wxChoice::Do it the long way instead. | |
aa61d352 VZ |
340 | unsigned int count = GetCount(); |
341 | for ( unsigned int i = 0; i < count; i++ ) | |
8d99be5f VZ |
342 | { |
343 | // as CB_FINDSTRINGEXACT is case insensitive, be case insensitive too | |
aa61d352 | 344 | if (GetString(i).IsSameAs(s, bCase)) |
8d99be5f VZ |
345 | return i; |
346 | } | |
347 | ||
348 | return wxNOT_FOUND; | |
349 | #else // !Watcom | |
4cd1ed99 RN |
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 | |
beedefb9 | 352 | if ( s.empty() ) |
4cd1ed99 | 353 | { |
aa61d352 VZ |
354 | unsigned int count = GetCount(); |
355 | for ( unsigned int i = 0; i < count; i++ ) | |
11e62fe6 | 356 | { |
aa61d352 | 357 | if (GetString(i).empty()) |
11e62fe6 WS |
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 ); | |
4cd1ed99 RN |
367 | } |
368 | else | |
369 | { | |
11e62fe6 WS |
370 | int pos = (int)SendMessage(GetHwnd(), CB_FINDSTRINGEXACT, |
371 | (WPARAM)-1, (LPARAM)s.c_str()); | |
f31a4098 | 372 | |
11e62fe6 | 373 | return pos == LB_ERR ? wxNOT_FOUND : pos; |
4cd1ed99 | 374 | } |
8d99be5f | 375 | #endif // Watcom/!Watcom |
2bda0e17 KB |
376 | } |
377 | ||
aa61d352 | 378 | void wxChoice::SetString(unsigned int n, const wxString& s) |
6c8a980f | 379 | { |
8228b893 | 380 | wxCHECK_RET( IsValid(n), wxT("invalid item index in wxChoice::SetString") ); |
2b5f62a0 VZ |
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 | |
31582e4e RD |
404 | |
405 | InvalidateBestSize(); | |
6c8a980f VZ |
406 | } |
407 | ||
aa61d352 | 408 | wxString wxChoice::GetString(unsigned int n) const |
2bda0e17 | 409 | { |
478cabab VZ |
410 | int len = (int)::SendMessage(GetHwnd(), CB_GETLBTEXTLEN, n, 0); |
411 | ||
6c8a980f | 412 | wxString str; |
478cabab VZ |
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 | { | |
f6bcfd97 | 423 | wxLogLastError(wxT("SendMessage(CB_GETLBTEXT)")); |
21d72d17 | 424 | } |
4438caf4 | 425 | } |
2bda0e17 | 426 | |
4438caf4 VZ |
427 | return str; |
428 | } | |
2bda0e17 | 429 | |
8d99be5f VZ |
430 | // ---------------------------------------------------------------------------- |
431 | // client data | |
432 | // ---------------------------------------------------------------------------- | |
433 | ||
aa61d352 | 434 | void wxChoice::DoSetItemClientData(unsigned int n, void* clientData) |
8d99be5f | 435 | { |
2b5f62a0 VZ |
436 | if ( ::SendMessage(GetHwnd(), CB_SETITEMDATA, |
437 | n, (LPARAM)clientData) == CB_ERR ) | |
8d99be5f | 438 | { |
223d09f6 | 439 | wxLogLastError(wxT("CB_SETITEMDATA")); |
8d99be5f VZ |
440 | } |
441 | } | |
442 | ||
aa61d352 | 443 | void* wxChoice::DoGetItemClientData(unsigned int n) const |
8d99be5f VZ |
444 | { |
445 | LPARAM rc = SendMessage(GetHwnd(), CB_GETITEMDATA, n, 0); | |
446 | if ( rc == CB_ERR ) | |
447 | { | |
223d09f6 | 448 | wxLogLastError(wxT("CB_GETITEMDATA")); |
8d99be5f VZ |
449 | |
450 | // unfortunately, there is no way to return an error code to the user | |
8ee9d618 | 451 | rc = (LPARAM) NULL; |
8d99be5f VZ |
452 | } |
453 | ||
454 | return (void *)rc; | |
455 | } | |
456 | ||
aa61d352 | 457 | void wxChoice::DoSetItemClientObject(unsigned int n, wxClientData* clientData) |
8d99be5f | 458 | { |
6c8a980f | 459 | DoSetItemClientData(n, clientData); |
8d99be5f VZ |
460 | } |
461 | ||
aa61d352 | 462 | wxClientData* wxChoice::DoGetItemClientObject(unsigned int n) const |
8d99be5f | 463 | { |
6c8a980f | 464 | return (wxClientData *)DoGetItemClientData(n); |
8d99be5f VZ |
465 | } |
466 | ||
467 | // ---------------------------------------------------------------------------- | |
468 | // wxMSW specific helpers | |
469 | // ---------------------------------------------------------------------------- | |
470 | ||
71e57cd6 VZ |
471 | void wxChoice::UpdateVisibleHeight() |
472 | { | |
e6968367 | 473 | // be careful to not change the width here |
02b7b6b0 | 474 | DoSetSize(wxDefaultCoord, wxDefaultCoord, wxDefaultCoord, GetSize().y, wxSIZE_USE_EXISTING); |
71e57cd6 VZ |
475 | } |
476 | ||
18c50997 VZ |
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 | ||
d99957b6 VZ |
495 | void wxChoice::DoGetSize(int *w, int *h) const |
496 | { | |
94a77ff7 VZ |
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 | |
02b7b6b0 | 501 | wxControl::DoGetSize(w, h); |
d99957b6 VZ |
502 | } |
503 | ||
4438caf4 | 504 | void wxChoice::DoSetSize(int x, int y, |
d99957b6 | 505 | int width, int height, |
4438caf4 VZ |
506 | int sizeFlags) |
507 | { | |
36043052 JS |
508 | int heightOrig = height; |
509 | ||
d4445d24 JS |
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; | |
a8e65eee | 522 | |
d4445d24 JS |
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 | ||
5637cc35 JS |
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 | ||
d4445d24 JS |
552 | // This solution works on XP, but causes choice/combobox lists to be |
553 | // too short on W2K and earlier. | |
554 | #if 0 | |
e3e78de1 VZ |
555 | int widthCurrent, heightCurrent; |
556 | DoGetSize(&widthCurrent, &heightCurrent); | |
557 | ||
d99957b6 VZ |
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 | |
e3e78de1 | 561 | if ( height != wxDefaultCoord && height != heightCurrent ) |
d99957b6 | 562 | { |
e3e78de1 VZ |
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 | |
aa61d352 | 565 | unsigned int nItems = GetCount(); |
e3e78de1 VZ |
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); | |
d99957b6 | 574 | } |
e3e78de1 | 575 | else // keep the same height as now |
d6959d6f | 576 | { |
e3e78de1 VZ |
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 | ||
d6959d6f | 597 | // We cannot pass wxDefaultCoord as height to wxControl. wxControl uses |
f31a4098 WS |
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 | |
d6959d6f DS |
602 | // 1 pixel. We have to determine the default height ourselves and call |
603 | // wxControl with that value instead. | |
e3e78de1 VZ |
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 | |
d6959d6f | 608 | RECT r; |
e3e78de1 VZ |
609 | if ( ::SendMessage(GetHwnd(), CB_GETDROPPEDCONTROLRECT, 0, (LPARAM) &r) |
610 | && r.bottom < 30000 ) | |
d6959d6f | 611 | { |
e3e78de1 | 612 | height = heightCurrent + r.bottom - r.top; |
d6959d6f DS |
613 | } |
614 | } | |
d99957b6 VZ |
615 | |
616 | wxControl::DoSetSize(x, y, width, height, sizeFlags); | |
ef036883 | 617 | #endif |
4438caf4 | 618 | } |
2bda0e17 | 619 | |
882a8f40 | 620 | wxSize wxChoice::DoGetBestSize() const |
4438caf4 VZ |
621 | { |
622 | // find the widest string | |
4438caf4 | 623 | int wChoice = 0; |
aa61d352 VZ |
624 | const unsigned int nItems = GetCount(); |
625 | for ( unsigned int i = 0; i < nItems; i++ ) | |
2bda0e17 | 626 | { |
d99957b6 VZ |
627 | int wLine; |
628 | GetTextExtent(GetString(i), &wLine, NULL); | |
4438caf4 VZ |
629 | if ( wLine > wChoice ) |
630 | wChoice = wLine; | |
2bda0e17 | 631 | } |
fd3f686c | 632 | |
4438caf4 VZ |
633 | // give it some reasonable default value if there are no strings in the |
634 | // list | |
635 | if ( wChoice == 0 ) | |
636 | wChoice = 100; | |
2bda0e17 | 637 | |
d99957b6 VZ |
638 | // the combobox should be slightly larger than the widest string |
639 | wChoice += 5*GetCharWidth(); | |
2bda0e17 | 640 | |
1d13cc5d RD |
641 | wxSize best(wChoice, EDIT_HEIGHT_FROM_CHAR_HEIGHT(GetCharHeight())); |
642 | CacheBestSize(best); | |
643 | return best; | |
2bda0e17 KB |
644 | } |
645 | ||
c140b7e7 | 646 | WXLRESULT wxChoice::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) |
2bda0e17 | 647 | { |
f499e614 | 648 | switch ( nMsg ) |
2bda0e17 | 649 | { |
f499e614 VZ |
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 | { | |
f499e614 VZ |
671 | WXHDC hdc; |
672 | WXHWND hwnd; | |
9f368d0d | 673 | UnpackCtlColor(wParam, lParam, &hdc, &hwnd); |
f499e614 | 674 | |
2bae4332 | 675 | WXHBRUSH hbr = MSWControlColor((WXHDC)hdc, hwnd); |
48fa6bd3 VZ |
676 | if ( hbr ) |
677 | return (WXLRESULT)hbr; | |
678 | //else: fall through to default window proc | |
f499e614 | 679 | } |
2bda0e17 KB |
680 | } |
681 | ||
8d99be5f | 682 | return wxWindow::MSWWindowProc(nMsg, wParam, lParam); |
2bda0e17 KB |
683 | } |
684 | ||
8d99be5f | 685 | bool wxChoice::MSWCommand(WXUINT param, WXWORD WXUNUSED(id)) |
2bda0e17 | 686 | { |
c11f0412 VZ |
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 | */ | |
6ba93d23 | 715 | switch ( param ) |
2bda0e17 | 716 | { |
6ba93d23 | 717 | case CBN_DROPDOWN: |
c11f0412 VZ |
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 | |
6ba93d23 VZ |
722 | m_lastAcceptedSelection = GetCurrentSelection(); |
723 | break; | |
2bda0e17 | 724 | |
6ba93d23 | 725 | case CBN_CLOSEUP: |
c11f0412 VZ |
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 | } | |
6ba93d23 VZ |
734 | break; |
735 | ||
c11f0412 VZ |
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 | ||
6ba93d23 VZ |
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()); | |
593ac33e | 752 | InitCommandEventWithItems(event, n); |
6ba93d23 VZ |
753 | } |
754 | ||
755 | ProcessCommand(event); | |
756 | } | |
c11f0412 VZ |
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; | |
8c1c5302 | 767 | } |
2bda0e17 | 768 | |
c11f0412 | 769 | return true; |
8d99be5f | 770 | } |
2bda0e17 | 771 | |
2bae4332 | 772 | WXHBRUSH wxChoice::MSWControlColor(WXHDC hDC, WXHWND hWnd) |
f6bcfd97 | 773 | { |
48fa6bd3 VZ |
774 | if ( !IsEnabled() ) |
775 | return MSWControlColorDisabled(hDC); | |
f6bcfd97 | 776 | |
2bae4332 | 777 | return wxChoiceBase::MSWControlColor(hDC, hWnd); |
f6bcfd97 BP |
778 | } |
779 | ||
3180bc0e | 780 | #endif // wxUSE_CHOICE && !(__SMARTPHONE__ && __WXWINCE__) |