]> git.saurik.com Git - wxWidgets.git/blob - src/msw/combobox.cpp
add support for alpha in color dialog on OSX, see #14127
[wxWidgets.git] / src / msw / combobox.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/combobox.cpp
3 // Purpose: wxComboBox class
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 01/02/97
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_COMBOBOX
28
29 #include "wx/combobox.h"
30
31 #ifndef WX_PRECOMP
32 #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
33 #include "wx/settings.h"
34 #include "wx/log.h"
35 // for wxEVT_COMMAND_TEXT_ENTER
36 #include "wx/textctrl.h"
37 #include "wx/app.h"
38 #include "wx/brush.h"
39 #endif
40
41 #include "wx/clipbrd.h"
42 #include "wx/wupdlock.h"
43 #include "wx/msw/private.h"
44
45 #if wxUSE_UXTHEME
46 #include "wx/msw/uxtheme.h"
47 #endif
48
49 #if wxUSE_TOOLTIPS
50 #include "wx/tooltip.h"
51 #endif // wxUSE_TOOLTIPS
52
53 // ----------------------------------------------------------------------------
54 // wxWin macros
55 // ----------------------------------------------------------------------------
56
57 BEGIN_EVENT_TABLE(wxComboBox, wxControl)
58 EVT_MENU(wxID_CUT, wxComboBox::OnCut)
59 EVT_MENU(wxID_COPY, wxComboBox::OnCopy)
60 EVT_MENU(wxID_PASTE, wxComboBox::OnPaste)
61 EVT_MENU(wxID_UNDO, wxComboBox::OnUndo)
62 EVT_MENU(wxID_REDO, wxComboBox::OnRedo)
63 EVT_MENU(wxID_CLEAR, wxComboBox::OnDelete)
64 EVT_MENU(wxID_SELECTALL, wxComboBox::OnSelectAll)
65
66 EVT_UPDATE_UI(wxID_CUT, wxComboBox::OnUpdateCut)
67 EVT_UPDATE_UI(wxID_COPY, wxComboBox::OnUpdateCopy)
68 EVT_UPDATE_UI(wxID_PASTE, wxComboBox::OnUpdatePaste)
69 EVT_UPDATE_UI(wxID_UNDO, wxComboBox::OnUpdateUndo)
70 EVT_UPDATE_UI(wxID_REDO, wxComboBox::OnUpdateRedo)
71 EVT_UPDATE_UI(wxID_CLEAR, wxComboBox::OnUpdateDelete)
72 EVT_UPDATE_UI(wxID_SELECTALL, wxComboBox::OnUpdateSelectAll)
73 END_EVENT_TABLE()
74
75 // ----------------------------------------------------------------------------
76 // function prototypes
77 // ----------------------------------------------------------------------------
78
79 LRESULT APIENTRY _EXPORT wxComboEditWndProc(HWND hWnd,
80 UINT message,
81 WPARAM wParam,
82 LPARAM lParam);
83
84 // ---------------------------------------------------------------------------
85 // global vars
86 // ---------------------------------------------------------------------------
87
88 // the pointer to standard radio button wnd proc
89 static WNDPROC gs_wndprocEdit = (WNDPROC)NULL;
90
91 // ============================================================================
92 // implementation
93 // ============================================================================
94
95 namespace
96 {
97
98 // Check if the given message should be forwarded from the edit control which
99 // is part of the combobox to wxComboBox itself. All messages generating the
100 // events that the code using wxComboBox could be interested in must be
101 // forwarded.
102 bool ShouldForwardFromEditToCombo(UINT message)
103 {
104 switch ( message )
105 {
106 case WM_KEYUP:
107 case WM_KEYDOWN:
108 case WM_CHAR:
109 case WM_SYSCHAR:
110 case WM_SYSKEYDOWN:
111 case WM_SYSKEYUP:
112 case WM_SETFOCUS:
113 case WM_KILLFOCUS:
114 case WM_CUT:
115 case WM_COPY:
116 case WM_PASTE:
117 return true;
118 }
119
120 return false;
121 }
122
123 } // anonymous namespace
124
125 // ----------------------------------------------------------------------------
126 // wnd proc for subclassed edit control
127 // ----------------------------------------------------------------------------
128
129 LRESULT APIENTRY _EXPORT wxComboEditWndProc(HWND hWnd,
130 UINT message,
131 WPARAM wParam,
132 LPARAM lParam)
133 {
134 HWND hwndCombo = ::GetParent(hWnd);
135 wxWindow *win = wxFindWinFromHandle((WXHWND)hwndCombo);
136
137 if ( ShouldForwardFromEditToCombo(message) )
138 {
139 wxComboBox *combo = wxDynamicCast(win, wxComboBox);
140 if ( !combo )
141 {
142 // we can get WM_KILLFOCUS while our parent is already half
143 // destroyed and hence doesn't look like a combobx any
144 // longer, check for it to avoid bogus assert failures
145 if ( !win->IsBeingDeleted() )
146 {
147 wxFAIL_MSG( wxT("should have combo as parent") );
148 }
149 }
150 else if ( combo->MSWProcessEditMsg(message, wParam, lParam) )
151 {
152 // handled by parent
153 return 0;
154 }
155 }
156 else if ( message == WM_GETDLGCODE )
157 {
158 wxCHECK_MSG( win, 0, wxT("should have a parent") );
159
160 if ( win->GetWindowStyle() & wxTE_PROCESS_ENTER )
161 {
162 // need to return a custom dlg code or we'll never get it
163 return DLGC_WANTMESSAGE;
164 }
165 }
166
167 return ::CallWindowProc(CASTWNDPROC gs_wndprocEdit, hWnd, message, wParam, lParam);
168 }
169
170 // ----------------------------------------------------------------------------
171 // wxComboBox callbacks
172 // ----------------------------------------------------------------------------
173
174 WXLRESULT wxComboBox::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
175 {
176 // TODO: handle WM_CTLCOLOR messages from our EDIT control to be able to
177 // set its colour correctly (to be the same as our own one)
178
179 switch ( nMsg )
180 {
181 case WM_SIZE:
182 // wxStaticBox can generate this message, when modifying the control's style.
183 // This causes the content of the combobox to be selected, for some reason.
184 case WM_STYLECHANGED:
185 {
186 // combobox selection sometimes spontaneously changes when its
187 // size changes, restore it to the old value if necessary
188 if ( !GetEditHWNDIfAvailable() )
189 break;
190
191 long fromOld, toOld;
192 GetSelection(&fromOld, &toOld);
193
194 // if an editable combobox has a not empty text not from the
195 // list, it tries to autocomplete it from the list when it is
196 // resized, but we don't want this to happen as it doesn't seem
197 // to make any sense, so we forcefully restore the old text
198 wxString textOld;
199 if ( !HasFlag(wxCB_READONLY) && GetCurrentSelection() == -1 )
200 textOld = GetValue();
201
202 // eliminate flickering during following hacks
203 wxWindowUpdateLocker lock(this);
204
205 WXLRESULT result = wxChoice::MSWWindowProc(nMsg, wParam, lParam);
206
207 if ( !textOld.empty() && GetValue() != textOld )
208 SetLabel(textOld);
209
210 long fromNew, toNew;
211 GetSelection(&fromNew, &toNew);
212
213 if ( fromOld != fromNew || toOld != toNew )
214 {
215 SetSelection(fromOld, toOld);
216 }
217
218 return result;
219 }
220 }
221
222 return wxChoice::MSWWindowProc(nMsg, wParam, lParam);
223 }
224
225 bool wxComboBox::MSWProcessEditMsg(WXUINT msg, WXWPARAM wParam, WXLPARAM lParam)
226 {
227 switch ( msg )
228 {
229 case WM_CHAR:
230 // for compatibility with wxTextCtrl, generate a special message
231 // when Enter is pressed
232 if ( wParam == VK_RETURN )
233 {
234 if (SendMessage(GetHwnd(), CB_GETDROPPEDSTATE, 0, 0))
235 return false;
236
237 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
238
239 const int sel = GetSelection();
240 event.SetInt(sel);
241 event.SetString(GetValue());
242 InitCommandEventWithItems(event, sel);
243
244 if ( ProcessCommand(event) )
245 {
246 // don't let the event through to the native control
247 // because it doesn't need it and may generate an annoying
248 // beep if it gets it
249 return true;
250 }
251 }
252 // fall through, WM_CHAR is one of the message we should forward.
253
254 default:
255 if ( ShouldForwardFromEditToCombo(msg) )
256 {
257 // For all the messages forward from the edit control the
258 // result is not used.
259 WXLRESULT result;
260 return MSWHandleMessage(&result, msg, wParam, lParam);
261 }
262 }
263
264 return false;
265 }
266
267 bool wxComboBox::MSWCommand(WXUINT param, WXWORD id)
268 {
269 int sel = -1;
270 wxString value;
271
272 switch ( param )
273 {
274 case CBN_DROPDOWN:
275 // remember the last selection, just as wxChoice does
276 m_lastAcceptedSelection = GetCurrentSelection();
277 {
278 wxCommandEvent event(wxEVT_COMMAND_COMBOBOX_DROPDOWN, GetId());
279 event.SetEventObject(this);
280 ProcessCommand(event);
281 }
282 break;
283
284 case CBN_CLOSEUP:
285 // Do the same thing as in wxChoice but using different event type.
286 if ( m_pendingSelection != wxID_NONE )
287 {
288 SendSelectionChangedEvent(wxEVT_COMMAND_COMBOBOX_SELECTED);
289 m_pendingSelection = wxID_NONE;
290 }
291 {
292 wxCommandEvent event(wxEVT_COMMAND_COMBOBOX_CLOSEUP, GetId());
293 event.SetEventObject(this);
294 ProcessCommand(event);
295 }
296 break;
297
298 case CBN_SELENDOK:
299 #ifndef __SMARTPHONE__
300 // we need to reset this to prevent the selection from being undone
301 // by wxChoice, see wxChoice::MSWCommand() and comments there
302 m_lastAcceptedSelection = wxID_NONE;
303 #endif
304
305 // set these variables so that they could be also fixed in
306 // CBN_EDITCHANGE below
307 sel = GetSelection();
308 value = GetStringSelection();
309
310 // this string is going to become the new combobox value soon but
311 // we need it to be done right now, otherwise the event handler
312 // could get a wrong value when it calls our GetValue()
313 ::SetWindowText(GetHwnd(), value.t_str());
314
315 SendSelectionChangedEvent(wxEVT_COMMAND_COMBOBOX_SELECTED);
316
317 // fall through: for compatibility with wxGTK, also send the text
318 // update event when the selection changes (this also seems more
319 // logical as the text does change)
320
321 case CBN_EDITCHANGE:
322 if ( m_allowTextEvents )
323 {
324 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, GetId());
325
326 // if sel != -1, value was already initialized above
327 if ( sel == -1 )
328 {
329 value = wxGetWindowText(GetHwnd());
330 }
331
332 event.SetString(value);
333 InitCommandEventWithItems(event, sel);
334
335 ProcessCommand(event);
336 }
337 break;
338
339 default:
340 return wxChoice::MSWCommand(param, id);
341 }
342
343 // skip wxChoice version as it would generate its own events for
344 // CBN_SELENDOK and also interfere with our handling of CBN_DROPDOWN
345 return true;
346 }
347
348 bool wxComboBox::MSWShouldPreProcessMessage(WXMSG *pMsg)
349 {
350 // prevent command accelerators from stealing editing
351 // hotkeys when we have the focus
352 if (wxIsCtrlDown())
353 {
354 WPARAM vkey = pMsg->wParam;
355
356 switch (vkey)
357 {
358 case 'C':
359 case 'V':
360 case 'X':
361 case VK_INSERT:
362 case VK_DELETE:
363 case VK_HOME:
364 case VK_END:
365 return false;
366 }
367 }
368
369 return wxChoice::MSWShouldPreProcessMessage(pMsg);
370 }
371
372 WXHWND wxComboBox::GetEditHWNDIfAvailable() const
373 {
374 // FIXME-VC6: Only VC6 needs this guard, see WINVER definition in
375 // include/wx/msw/wrapwin.h
376 #if defined(WINVER) && WINVER >= 0x0500
377 WinStruct<COMBOBOXINFO> info;
378 if ( MSWGetComboBoxInfo(&info) )
379 return info.hwndItem;
380 #endif // WINVER >= 0x0500
381
382 if (HasFlag(wxCB_SIMPLE))
383 {
384 POINT pt;
385 pt.x = pt.y = 4;
386 return (WXHWND) ::ChildWindowFromPoint(GetHwnd(), pt);
387 }
388
389 // notice that a slightly safer alternative could be to use FindWindowEx()
390 // but it's not available under WinCE so just take the first child for now
391 // to keep one version of the code for all platforms and fix it later if
392 // problems are discovered
393
394 // we assume that the only child of the combobox is the edit window
395 return (WXHWND)::GetWindow(GetHwnd(), GW_CHILD);
396 }
397
398 WXHWND wxComboBox::GetEditHWND() const
399 {
400 // this function should not be called for wxCB_READONLY controls, it is
401 // the callers responsibility to check this
402 wxASSERT_MSG( !HasFlag(wxCB_READONLY),
403 wxT("read-only combobox doesn't have any edit control") );
404
405 WXHWND hWndEdit = GetEditHWNDIfAvailable();
406 wxASSERT_MSG( hWndEdit, wxT("combobox without edit control?") );
407
408 return hWndEdit;
409 }
410
411 wxWindow *wxComboBox::GetEditableWindow()
412 {
413 wxASSERT_MSG( !HasFlag(wxCB_READONLY),
414 wxT("read-only combobox doesn't have any edit control") );
415
416 return this;
417 }
418
419 // ----------------------------------------------------------------------------
420 // wxComboBox creation
421 // ----------------------------------------------------------------------------
422
423 bool wxComboBox::Create(wxWindow *parent, wxWindowID id,
424 const wxString& value,
425 const wxPoint& pos,
426 const wxSize& size,
427 int n, const wxString choices[],
428 long style,
429 const wxValidator& validator,
430 const wxString& name)
431 {
432 // pretend that wxComboBox is hidden while it is positioned and resized and
433 // show it only right before leaving this method because otherwise there is
434 // some noticeable flicker while the control rearranges itself
435 m_isShown = false;
436
437 if ( !CreateAndInit(parent, id, pos, size, n, choices, style,
438 validator, name) )
439 return false;
440
441 // we shouldn't call SetValue() for an empty string because this would
442 // (correctly) result in an assert with a read only combobox and is useless
443 // for the other ones anyhow
444 if ( !value.empty() )
445 SetValue(value);
446
447 // a (not read only) combobox is, in fact, 2 controls: the combobox itself
448 // and an edit control inside it and if we want to catch events from this
449 // edit control, we must subclass it as well
450 if ( !(style & wxCB_READONLY) )
451 {
452 gs_wndprocEdit = wxSetWindowProc((HWND)GetEditHWND(), wxComboEditWndProc);
453 }
454
455 // and finally, show the control
456 Show(true);
457
458 return true;
459 }
460
461 bool wxComboBox::Create(wxWindow *parent, wxWindowID id,
462 const wxString& value,
463 const wxPoint& pos,
464 const wxSize& size,
465 const wxArrayString& choices,
466 long style,
467 const wxValidator& validator,
468 const wxString& name)
469 {
470 wxCArrayString chs(choices);
471 return Create(parent, id, value, pos, size, chs.GetCount(),
472 chs.GetStrings(), style, validator, name);
473 }
474
475 WXDWORD wxComboBox::MSWGetStyle(long style, WXDWORD *exstyle) const
476 {
477 // we never have an external border
478 WXDWORD msStyle = wxChoice::MSWGetStyle
479 (
480 (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
481 );
482
483 // usually WS_TABSTOP is added by wxControl::MSWGetStyle() but as we're
484 // created hidden (see Create() above), it is not done for us but we still
485 // want to have this style
486 msStyle |= WS_TABSTOP;
487
488 // remove the style always added by wxChoice
489 msStyle &= ~CBS_DROPDOWNLIST;
490
491 if ( style & wxCB_READONLY )
492 msStyle |= CBS_DROPDOWNLIST;
493 #ifndef __WXWINCE__
494 else if ( style & wxCB_SIMPLE )
495 msStyle |= CBS_SIMPLE; // A list (shown always) and edit control
496 #endif
497 else
498 msStyle |= CBS_DROPDOWN;
499
500 // there is no reason to not always use CBS_AUTOHSCROLL, so do use it
501 msStyle |= CBS_AUTOHSCROLL;
502
503 // NB: we used to also add CBS_NOINTEGRALHEIGHT here but why?
504
505 return msStyle;
506 }
507
508 // ----------------------------------------------------------------------------
509 // wxComboBox text control-like methods
510 // ----------------------------------------------------------------------------
511
512 wxString wxComboBox::GetValue() const
513 {
514 return HasFlag(wxCB_READONLY) ? GetStringSelection()
515 : wxTextEntry::GetValue();
516 }
517
518 void wxComboBox::SetValue(const wxString& value)
519 {
520 if ( HasFlag(wxCB_READONLY) )
521 SetStringSelection(value);
522 else
523 wxTextEntry::SetValue(value);
524 }
525
526 void wxComboBox::Clear()
527 {
528 wxChoice::Clear();
529 if ( !HasFlag(wxCB_READONLY) )
530 wxTextEntry::Clear();
531 }
532
533 bool wxComboBox::ContainsHWND(WXHWND hWnd) const
534 {
535 return hWnd == GetEditHWNDIfAvailable();
536 }
537
538 void wxComboBox::GetSelection(long *from, long *to) const
539 {
540 if ( !HasFlag(wxCB_READONLY) )
541 {
542 wxTextEntry::GetSelection(from, to);
543 }
544 else // text selection doesn't make sense for read only comboboxes
545 {
546 if ( from )
547 *from = -1;
548 if ( to )
549 *to = -1;
550 }
551 }
552
553 bool wxComboBox::IsEditable() const
554 {
555 return !HasFlag(wxCB_READONLY) && wxTextEntry::IsEditable();
556 }
557
558 // ----------------------------------------------------------------------------
559 // standard event handling
560 // ----------------------------------------------------------------------------
561
562 void wxComboBox::OnCut(wxCommandEvent& WXUNUSED(event))
563 {
564 Cut();
565 }
566
567 void wxComboBox::OnCopy(wxCommandEvent& WXUNUSED(event))
568 {
569 Copy();
570 }
571
572 void wxComboBox::OnPaste(wxCommandEvent& WXUNUSED(event))
573 {
574 Paste();
575 }
576
577 void wxComboBox::OnUndo(wxCommandEvent& WXUNUSED(event))
578 {
579 Undo();
580 }
581
582 void wxComboBox::OnRedo(wxCommandEvent& WXUNUSED(event))
583 {
584 Redo();
585 }
586
587 void wxComboBox::OnDelete(wxCommandEvent& WXUNUSED(event))
588 {
589 RemoveSelection();
590 }
591
592 void wxComboBox::OnSelectAll(wxCommandEvent& WXUNUSED(event))
593 {
594 SelectAll();
595 }
596
597 void wxComboBox::OnUpdateCut(wxUpdateUIEvent& event)
598 {
599 event.Enable( CanCut() );
600 }
601
602 void wxComboBox::OnUpdateCopy(wxUpdateUIEvent& event)
603 {
604 event.Enable( CanCopy() );
605 }
606
607 void wxComboBox::OnUpdatePaste(wxUpdateUIEvent& event)
608 {
609 event.Enable( CanPaste() );
610 }
611
612 void wxComboBox::OnUpdateUndo(wxUpdateUIEvent& event)
613 {
614 event.Enable( IsEditable() && CanUndo() );
615 }
616
617 void wxComboBox::OnUpdateRedo(wxUpdateUIEvent& event)
618 {
619 event.Enable( IsEditable() && CanRedo() );
620 }
621
622 void wxComboBox::OnUpdateDelete(wxUpdateUIEvent& event)
623 {
624 event.Enable(IsEditable() && HasSelection());
625 }
626
627 void wxComboBox::OnUpdateSelectAll(wxUpdateUIEvent& event)
628 {
629 event.Enable(IsEditable() && !wxTextEntry::IsEmpty());
630 }
631
632 #if wxUSE_TOOLTIPS
633
634 void wxComboBox::DoSetToolTip(wxToolTip *tip)
635 {
636 wxChoice::DoSetToolTip(tip);
637
638 if ( tip && !HasFlag(wxCB_READONLY) )
639 tip->AddOtherWindow(GetEditHWND());
640 }
641
642 #endif // wxUSE_TOOLTIPS
643
644 #if wxUSE_UXTHEME
645
646 bool wxComboBox::SetHint(const wxString& hintOrig)
647 {
648 wxString hint(hintOrig);
649 if ( wxUxThemeEngine::GetIfActive() )
650 {
651 // under XP (but not Vista) there is a bug in cue banners
652 // implementation for combobox edit control: the first character is
653 // partially chopped off, so prepend a space to make it fully visible
654 hint.insert(0, " ");
655 }
656
657 return wxTextEntry::SetHint(hint);
658 }
659
660 #endif // wxUSE_UXTHEME
661
662 wxSize wxComboBox::DoGetSizeFromTextSize(int xlen, int ylen) const
663 {
664 wxSize tsize( wxChoice::DoGetSizeFromTextSize(xlen, ylen) );
665
666 if ( !HasFlag(wxCB_READONLY) )
667 {
668 // Add the margins we have previously set
669 wxPoint marg( GetMargins() );
670 marg.x = wxMax(0, marg.x);
671 marg.y = wxMax(0, marg.y);
672 tsize.IncBy( marg );
673 }
674
675 return tsize;
676 }
677
678 #endif // wxUSE_COMBOBOX