added InitCommandEventWithItems() and call it from wxChoice and wxComboBox code to...
[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/settings.h"
33 #include "wx/log.h"
34 // for wxEVT_COMMAND_TEXT_ENTER
35 #include "wx/textctrl.h"
36 #include "wx/app.h"
37 #endif
38
39 #include "wx/brush.h"
40 #include "wx/clipbrd.h"
41 #include "wx/msw/private.h"
42
43 #if wxUSE_TOOLTIPS
44 #if !defined(__GNUWIN32_OLD__) || defined(__CYGWIN10__)
45 #include <commctrl.h>
46 #endif
47 #include "wx/tooltip.h"
48 #endif // wxUSE_TOOLTIPS
49
50 // ----------------------------------------------------------------------------
51 // wxWin macros
52 // ----------------------------------------------------------------------------
53
54 #if wxUSE_EXTENDED_RTTI
55 WX_DEFINE_FLAGS( wxComboBoxStyle )
56
57 wxBEGIN_FLAGS( wxComboBoxStyle )
58 // new style border flags, we put them first to
59 // use them for streaming out
60 wxFLAGS_MEMBER(wxBORDER_SIMPLE)
61 wxFLAGS_MEMBER(wxBORDER_SUNKEN)
62 wxFLAGS_MEMBER(wxBORDER_DOUBLE)
63 wxFLAGS_MEMBER(wxBORDER_RAISED)
64 wxFLAGS_MEMBER(wxBORDER_STATIC)
65 wxFLAGS_MEMBER(wxBORDER_NONE)
66
67 // old style border flags
68 wxFLAGS_MEMBER(wxSIMPLE_BORDER)
69 wxFLAGS_MEMBER(wxSUNKEN_BORDER)
70 wxFLAGS_MEMBER(wxDOUBLE_BORDER)
71 wxFLAGS_MEMBER(wxRAISED_BORDER)
72 wxFLAGS_MEMBER(wxSTATIC_BORDER)
73 wxFLAGS_MEMBER(wxBORDER)
74
75 // standard window styles
76 wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
77 wxFLAGS_MEMBER(wxCLIP_CHILDREN)
78 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
79 wxFLAGS_MEMBER(wxWANTS_CHARS)
80 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
81 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
82 wxFLAGS_MEMBER(wxVSCROLL)
83 wxFLAGS_MEMBER(wxHSCROLL)
84
85 wxFLAGS_MEMBER(wxCB_SIMPLE)
86 wxFLAGS_MEMBER(wxCB_SORT)
87 wxFLAGS_MEMBER(wxCB_READONLY)
88 wxFLAGS_MEMBER(wxCB_DROPDOWN)
89
90 wxEND_FLAGS( wxComboBoxStyle )
91
92 IMPLEMENT_DYNAMIC_CLASS_XTI(wxComboBox, wxControl,"wx/combobox.h")
93
94 wxBEGIN_PROPERTIES_TABLE(wxComboBox)
95 wxEVENT_PROPERTY( Select , wxEVT_COMMAND_COMBOBOX_SELECTED , wxCommandEvent )
96 wxEVENT_PROPERTY( TextEnter , wxEVT_COMMAND_TEXT_ENTER , wxCommandEvent )
97
98 // TODO DELEGATES
99 wxPROPERTY( Font , wxFont , SetFont , GetFont , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
100 wxPROPERTY_COLLECTION( Choices , wxArrayString , wxString , AppendString , GetStrings , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
101 wxPROPERTY( Value ,wxString, SetValue, GetValue, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
102 wxPROPERTY( Selection ,int, SetSelection, GetSelection, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
103 wxPROPERTY_FLAGS( WindowStyle , wxComboBoxStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
104 wxEND_PROPERTIES_TABLE()
105
106 wxBEGIN_HANDLERS_TABLE(wxComboBox)
107 wxEND_HANDLERS_TABLE()
108
109 wxCONSTRUCTOR_5( wxComboBox , wxWindow* , Parent , wxWindowID , Id , wxString , Value , wxPoint , Position , wxSize , Size )
110
111 #else
112
113 IMPLEMENT_DYNAMIC_CLASS(wxComboBox, wxControl)
114
115 #endif
116
117 BEGIN_EVENT_TABLE(wxComboBox, wxControl)
118 EVT_MENU(wxID_CUT, wxComboBox::OnCut)
119 EVT_MENU(wxID_COPY, wxComboBox::OnCopy)
120 EVT_MENU(wxID_PASTE, wxComboBox::OnPaste)
121 EVT_MENU(wxID_UNDO, wxComboBox::OnUndo)
122 EVT_MENU(wxID_REDO, wxComboBox::OnRedo)
123 EVT_MENU(wxID_CLEAR, wxComboBox::OnDelete)
124 EVT_MENU(wxID_SELECTALL, wxComboBox::OnSelectAll)
125
126 EVT_UPDATE_UI(wxID_CUT, wxComboBox::OnUpdateCut)
127 EVT_UPDATE_UI(wxID_COPY, wxComboBox::OnUpdateCopy)
128 EVT_UPDATE_UI(wxID_PASTE, wxComboBox::OnUpdatePaste)
129 EVT_UPDATE_UI(wxID_UNDO, wxComboBox::OnUpdateUndo)
130 EVT_UPDATE_UI(wxID_REDO, wxComboBox::OnUpdateRedo)
131 EVT_UPDATE_UI(wxID_CLEAR, wxComboBox::OnUpdateDelete)
132 EVT_UPDATE_UI(wxID_SELECTALL, wxComboBox::OnUpdateSelectAll)
133 END_EVENT_TABLE()
134
135 // ----------------------------------------------------------------------------
136 // function prototypes
137 // ----------------------------------------------------------------------------
138
139 LRESULT APIENTRY _EXPORT wxComboEditWndProc(HWND hWnd,
140 UINT message,
141 WPARAM wParam,
142 LPARAM lParam);
143
144 // ---------------------------------------------------------------------------
145 // global vars
146 // ---------------------------------------------------------------------------
147
148 // the pointer to standard radio button wnd proc
149 static WNDPROC gs_wndprocEdit = (WNDPROC)NULL;
150
151 // ============================================================================
152 // implementation
153 // ============================================================================
154
155 // ----------------------------------------------------------------------------
156 // wnd proc for subclassed edit control
157 // ----------------------------------------------------------------------------
158
159 LRESULT APIENTRY _EXPORT wxComboEditWndProc(HWND hWnd,
160 UINT message,
161 WPARAM wParam,
162 LPARAM lParam)
163 {
164 HWND hwndCombo = ::GetParent(hWnd);
165 wxWindow *win = wxFindWinFromHandle((WXHWND)hwndCombo);
166
167 switch ( message )
168 {
169 // forward some messages to the combobox to generate the appropriate
170 // wxEvents from them
171 case WM_KEYUP:
172 case WM_KEYDOWN:
173 case WM_CHAR:
174 case WM_SYSCHAR:
175 case WM_SYSKEYDOWN:
176 case WM_SYSKEYUP:
177 case WM_SETFOCUS:
178 case WM_KILLFOCUS:
179 {
180 wxComboBox *combo = wxDynamicCast(win, wxComboBox);
181 if ( !combo )
182 {
183 // we can get WM_KILLFOCUS while our parent is already half
184 // destroyed and hence doesn't look like a combobx any
185 // longer, check for it to avoid bogus assert failures
186 if ( !win->IsBeingDeleted() )
187 {
188 wxFAIL_MSG( _T("should have combo as parent") );
189 }
190 }
191 else if ( combo->MSWProcessEditMsg(message, wParam, lParam) )
192 {
193 // handled by parent
194 return 0;
195 }
196 }
197 break;
198
199 case WM_GETDLGCODE:
200 {
201 wxCHECK_MSG( win, 0, _T("should have a parent") );
202
203 if ( win->GetWindowStyle() & wxTE_PROCESS_ENTER )
204 {
205 // need to return a custom dlg code or we'll never get it
206 return DLGC_WANTMESSAGE;
207 }
208 }
209 break;
210 }
211
212 return ::CallWindowProc(CASTWNDPROC gs_wndprocEdit, hWnd, message, wParam, lParam);
213 }
214
215 // ----------------------------------------------------------------------------
216 // wxComboBox callbacks
217 // ----------------------------------------------------------------------------
218
219 WXLRESULT wxComboBox::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
220 {
221 // TODO: handle WM_CTLCOLOR messages from our EDIT control to be able to
222 // set its colour correctly (to be the same as our own one)
223
224 switch ( nMsg )
225 {
226 case WM_SIZE:
227 // wxStaticBox can generate this message, when modifying the control's style.
228 // This causes the content of the combobox to be selected, for some reason.
229 case WM_STYLECHANGED:
230 {
231 // combobox selection sometimes spontaneously changes when its
232 // size changes, restore it to the old value if necessary
233 long fromOld, toOld;
234 GetSelection(&fromOld, &toOld);
235 WXLRESULT result = wxChoice::MSWWindowProc(nMsg, wParam, lParam);
236
237 long fromNew, toNew;
238 GetSelection(&fromNew, &toNew);
239
240 if ( fromOld != fromNew || toOld != toNew )
241 {
242 SetSelection(fromOld, toOld);
243 }
244
245 return result;
246 }
247 }
248
249 return wxChoice::MSWWindowProc(nMsg, wParam, lParam);
250 }
251
252 bool wxComboBox::MSWProcessEditMsg(WXUINT msg, WXWPARAM wParam, WXLPARAM lParam)
253 {
254 switch ( msg )
255 {
256 case WM_CHAR:
257 // for compatibility with wxTextCtrl, generate a special message
258 // when Enter is pressed
259 if ( wParam == VK_RETURN )
260 {
261 wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
262
263 const int sel = GetSelection();
264 event.SetInt(sel);
265 event.SetString(GetValue());
266 InitCommandEventWithItems(event, sel);
267
268 if ( ProcessCommand(event) )
269 {
270 // don't let the event through to the native control
271 // because it doesn't need it and may generate an annoying
272 // beep if it gets it
273 return true;
274 }
275 }
276 // fall through
277
278 case WM_SYSCHAR:
279 return HandleChar(wParam, lParam, true /* isASCII */);
280
281 case WM_SYSKEYDOWN:
282 case WM_KEYDOWN:
283 return HandleKeyDown(wParam, lParam);
284
285 case WM_SYSKEYUP:
286 case WM_KEYUP:
287 return HandleKeyUp(wParam, lParam);
288
289 case WM_SETFOCUS:
290 return HandleSetFocus((WXHWND)wParam);
291
292 case WM_KILLFOCUS:
293 return HandleKillFocus((WXHWND)wParam);
294 }
295
296 return false;
297 }
298
299 bool wxComboBox::MSWCommand(WXUINT param, WXWORD id)
300 {
301 int sel = -1;
302 wxString value;
303
304 switch ( param )
305 {
306 case CBN_SELENDOK:
307 #ifndef __SMARTPHONE__
308 // we need to reset this to prevent the selection from being undone
309 // by wxChoice, see wxChoice::MSWCommand() and comments there
310 m_lastAcceptedSelection = wxID_NONE;
311 #endif
312
313 // set these variables so that they could be also fixed in
314 // CBN_EDITCHANGE below
315 sel = GetSelection();
316 value = GetStringSelection();
317 {
318 wxCommandEvent event(wxEVT_COMMAND_COMBOBOX_SELECTED, GetId());
319 event.SetInt(sel);
320 event.SetString(value);
321 InitCommandEventWithItems(event, sel);
322
323 ProcessCommand(event);
324 }
325
326 // fall through: for compability with wxGTK, also send the text
327 // update event when the selection changes (this also seems more
328 // logical as the text does change)
329
330 case CBN_EDITCHANGE:
331 {
332 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, GetId());
333
334 // if sel != -1, value was already initialized above
335 if ( sel == -1 )
336 {
337 value = wxGetWindowText(GetHwnd());
338 }
339
340 event.SetString(value);
341 InitCommandEventWithItems(event, sel);
342
343 ProcessCommand(event);
344 }
345 break;
346
347 default:
348 return wxChoice::MSWCommand(param, id);
349 }
350
351 // skip wxChoice version as it would generate its own events for
352 // CBN_SELENDOK
353 return wxControl::MSWCommand(param, id);
354 }
355
356 WXHWND wxComboBox::GetEditHWND() const
357 {
358 // this function should not be called for wxCB_READONLY controls, it is
359 // the callers responsability to check this
360 wxASSERT_MSG( !(GetWindowStyle() & wxCB_READONLY),
361 _T("read-only combobox doesn't have any edit control") );
362
363 POINT pt;
364 pt.x = pt.y = 4;
365 HWND hwndEdit = ::ChildWindowFromPoint(GetHwnd(), pt);
366 if ( !hwndEdit || hwndEdit == GetHwnd() )
367 {
368 wxFAIL_MSG(_T("not read only combobox without edit control?"));
369 }
370
371 return (WXHWND)hwndEdit;
372 }
373
374 // ----------------------------------------------------------------------------
375 // wxComboBox creation
376 // ----------------------------------------------------------------------------
377
378 bool wxComboBox::Create(wxWindow *parent, wxWindowID id,
379 const wxString& value,
380 const wxPoint& pos,
381 const wxSize& size,
382 int n, const wxString choices[],
383 long style,
384 const wxValidator& validator,
385 const wxString& name)
386 {
387 // pretend that wxComboBox is hidden while it is positioned and resized and
388 // show it only right before leaving this method because otherwise there is
389 // some noticeable flicker while the control rearranges itself
390 m_isShown = false;
391
392 if ( !CreateAndInit(parent, id, pos, size, n, choices, style,
393 validator, name) )
394 return false;
395
396 // we shouldn't call SetValue() for an empty string because this would
397 // (correctly) result in an assert with a read only combobox and is useless
398 // for the other ones anyhow
399 if ( !value.empty() )
400 SetValue(value);
401
402 // a (not read only) combobox is, in fact, 2 controls: the combobox itself
403 // and an edit control inside it and if we want to catch events from this
404 // edit control, we must subclass it as well
405 if ( !(style & wxCB_READONLY) )
406 {
407 gs_wndprocEdit = wxSetWindowProc((HWND)GetEditHWND(),
408 wxComboEditWndProc);
409 }
410
411 // and finally, show the control
412 Show(true);
413
414 return true;
415 }
416
417 bool wxComboBox::Create(wxWindow *parent, wxWindowID id,
418 const wxString& value,
419 const wxPoint& pos,
420 const wxSize& size,
421 const wxArrayString& choices,
422 long style,
423 const wxValidator& validator,
424 const wxString& name)
425 {
426 wxCArrayString chs(choices);
427 return Create(parent, id, value, pos, size, chs.GetCount(),
428 chs.GetStrings(), style, validator, name);
429 }
430
431 WXDWORD wxComboBox::MSWGetStyle(long style, WXDWORD *exstyle) const
432 {
433 // we never have an external border
434 WXDWORD msStyle = wxChoice::MSWGetStyle
435 (
436 (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
437 );
438
439 // usually WS_TABSTOP is added by wxControl::MSWGetStyle() but as we're
440 // created hidden (see Create() above), it is not done for us but we still
441 // want to have this style
442 msStyle |= WS_TABSTOP;
443
444 // remove the style always added by wxChoice
445 msStyle &= ~CBS_DROPDOWNLIST;
446
447 if ( style & wxCB_READONLY )
448 msStyle |= CBS_DROPDOWNLIST;
449 #ifndef __WXWINCE__
450 else if ( style & wxCB_SIMPLE )
451 msStyle |= CBS_SIMPLE; // A list (shown always) and edit control
452 #endif
453 else
454 msStyle |= CBS_DROPDOWN;
455
456 // there is no reason to not always use CBS_AUTOHSCROLL, so do use it
457 msStyle |= CBS_AUTOHSCROLL;
458
459 // NB: we used to also add CBS_NOINTEGRALHEIGHT here but why?
460
461 return msStyle;
462 }
463
464 // ----------------------------------------------------------------------------
465 // wxComboBox text control-like methods
466 // ----------------------------------------------------------------------------
467
468 wxString wxComboBox::GetValue() const
469 {
470 return wxGetWindowText(m_hWnd);
471 }
472
473 void wxComboBox::SetValue(const wxString& value)
474 {
475 if ( HasFlag(wxCB_READONLY) )
476 SetStringSelection(value);
477 else
478 SetWindowText(GetHwnd(), value.c_str());
479 }
480
481 // Clipboard operations
482 void wxComboBox::Copy()
483 {
484 SendMessage(GetHwnd(), WM_COPY, 0, 0L);
485 }
486
487 void wxComboBox::Cut()
488 {
489 SendMessage(GetHwnd(), WM_CUT, 0, 0L);
490 }
491
492 void wxComboBox::Paste()
493 {
494 SendMessage(GetHwnd(), WM_PASTE, 0, 0L);
495 }
496
497 void wxComboBox::Undo()
498 {
499 if (CanUndo())
500 {
501 HWND hEditWnd = (HWND) GetEditHWND();
502 if ( hEditWnd )
503 ::SendMessage(hEditWnd, EM_UNDO, 0, 0);
504 }
505 }
506
507 void wxComboBox::Redo()
508 {
509 if (CanUndo())
510 {
511 // Same as Undo, since Undo undoes the undo, i.e. a redo.
512 HWND hEditWnd = (HWND) GetEditHWND();
513 if ( hEditWnd )
514 ::SendMessage(hEditWnd, EM_UNDO, 0, 0);
515 }
516 }
517
518 void wxComboBox::SelectAll()
519 {
520 SetSelection(0, GetLastPosition());
521 }
522
523 bool wxComboBox::CanUndo() const
524 {
525 if (!IsEditable())
526 return false;
527
528 HWND hEditWnd = (HWND) GetEditHWND();
529 if ( hEditWnd )
530 return ::SendMessage(hEditWnd, EM_CANUNDO, 0, 0) != 0;
531 else
532 return false;
533 }
534
535 bool wxComboBox::CanRedo() const
536 {
537 if (!IsEditable())
538 return false;
539
540 HWND hEditWnd = (HWND) GetEditHWND();
541 if ( hEditWnd )
542 return ::SendMessage(hEditWnd, EM_CANUNDO, 0, 0) != 0;
543 else
544 return false;
545 }
546
547 bool wxComboBox::HasSelection() const
548 {
549 long from, to;
550 GetSelection(&from, &to);
551 return from != to;
552 }
553
554 bool wxComboBox::CanCopy() const
555 {
556 // Can copy if there's a selection
557 return HasSelection();
558 }
559
560 bool wxComboBox::CanCut() const
561 {
562 return IsEditable() && CanCopy();
563 }
564
565 bool wxComboBox::CanPaste() const
566 {
567 if ( !IsEditable() )
568 return false;
569
570 // Standard edit control: check for straight text on clipboard
571 if ( !::OpenClipboard(GetHwndOf(wxTheApp->GetTopWindow())) )
572 return false;
573
574 bool isTextAvailable = ::IsClipboardFormatAvailable(CF_TEXT) != 0;
575 ::CloseClipboard();
576
577 return isTextAvailable;
578 }
579
580 bool wxComboBox::IsEditable() const
581 {
582 return !HasFlag(wxCB_READONLY);
583 }
584
585 void wxComboBox::SetEditable(bool WXUNUSED(editable))
586 {
587 // Can't implement in MSW?
588 // HWND hWnd = GetHwnd();
589 // SendMessage(hWnd, EM_SETREADONLY, (WPARAM)!editable, (LPARAM)0L);
590 }
591
592 void wxComboBox::SetInsertionPoint(long pos)
593 {
594 if ( GetWindowStyle() & wxCB_READONLY )
595 return;
596
597 #ifdef __WIN32__
598 HWND hWnd = GetHwnd();
599 ::SendMessage(hWnd, CB_SETEDITSEL, 0, MAKELPARAM(pos, pos));
600 HWND hEditWnd = (HWND) GetEditHWND();
601 if ( hEditWnd )
602 {
603 // Scroll insertion point into view
604 SendMessage(hEditWnd, EM_SCROLLCARET, (WPARAM)0, (LPARAM)0);
605 // Why is this necessary? (Copied from wxTextCtrl::SetInsertionPoint)
606 SendMessage(hEditWnd, EM_REPLACESEL, 0, (LPARAM) wxEmptyString);
607 }
608 #endif // __WIN32__
609 }
610
611 void wxComboBox::SetInsertionPointEnd()
612 {
613 // setting insertion point doesn't make sense for read only comboboxes
614 if ( !(GetWindowStyle() & wxCB_READONLY) )
615 {
616 wxTextPos pos = GetLastPosition();
617 SetInsertionPoint(pos);
618 }
619 }
620
621 long wxComboBox::GetInsertionPoint() const
622 {
623 // CB_GETEDITSEL returns the index of the first character of the selection in
624 // its low-order word
625 DWORD pos= (DWORD)::SendMessage(GetHwnd(), CB_GETEDITSEL, 0, 0L);
626 return LOWORD(pos);
627 }
628
629 wxTextPos wxComboBox::GetLastPosition() const
630 {
631 HWND hEditWnd = (HWND) GetEditHWND();
632
633 // Get number of characters in the last (only) line. We'll add this to the character
634 // index for the last line, 1st position.
635 wxTextPos lineLength = (wxTextPos)SendMessage(hEditWnd, EM_LINELENGTH, (WPARAM) 0, (LPARAM)0L);
636
637 return lineLength;
638 }
639
640 void wxComboBox::Replace(long from, long to, const wxString& value)
641 {
642 #if wxUSE_CLIPBOARD
643 Remove(from, to);
644
645 // Now replace with 'value', by pasting.
646 wxSetClipboardData(wxDF_TEXT, (wxObject *)(const wxChar *)value, 0, 0);
647
648 // Paste into edit control
649 SendMessage(GetHwnd(), WM_PASTE, (WPARAM)0, (LPARAM)0L);
650 #else
651 wxUnusedVar(from);
652 wxUnusedVar(to);
653 wxUnusedVar(value);
654 #endif
655 }
656
657 void wxComboBox::Remove(long from, long to)
658 {
659 // Set selection and remove it
660 SetSelection(from, to);
661 SendMessage(GetHwnd(), WM_CUT, (WPARAM)0, (LPARAM)0);
662 }
663
664 void wxComboBox::SetSelection(long from, long to)
665 {
666 // if from and to are both -1, it means (in wxWidgets) that all text should
667 // be selected, translate this into Windows convention
668 if ( (from == -1) && (to == -1) )
669 {
670 from = 0;
671 }
672
673 if ( SendMessage(GetHwnd(), CB_SETEDITSEL,
674 0, (LPARAM)MAKELONG(from, to)) == CB_ERR )
675 {
676 wxLogDebug(_T("CB_SETEDITSEL failed"));
677 }
678 }
679
680 void wxComboBox::GetSelection(long* from, long* to) const
681 {
682 DWORD dwStart, dwEnd;
683 if ( ::SendMessage(GetHwnd(), CB_GETEDITSEL,
684 (WPARAM)&dwStart, (LPARAM)&dwEnd) == CB_ERR )
685 {
686 *from =
687 *to = 0;
688 }
689 else
690 {
691 *from = dwStart;
692 *to = dwEnd;
693 }
694 }
695
696 // ----------------------------------------------------------------------------
697 // standard event handling
698 // ----------------------------------------------------------------------------
699
700 void wxComboBox::OnCut(wxCommandEvent& WXUNUSED(event))
701 {
702 Cut();
703 }
704
705 void wxComboBox::OnCopy(wxCommandEvent& WXUNUSED(event))
706 {
707 Copy();
708 }
709
710 void wxComboBox::OnPaste(wxCommandEvent& WXUNUSED(event))
711 {
712 Paste();
713 }
714
715 void wxComboBox::OnUndo(wxCommandEvent& WXUNUSED(event))
716 {
717 Undo();
718 }
719
720 void wxComboBox::OnRedo(wxCommandEvent& WXUNUSED(event))
721 {
722 Redo();
723 }
724
725 void wxComboBox::OnDelete(wxCommandEvent& WXUNUSED(event))
726 {
727 long from, to;
728 GetSelection(& from, & to);
729 if (from != -1 && to != -1)
730 Remove(from, to);
731 }
732
733 void wxComboBox::OnSelectAll(wxCommandEvent& WXUNUSED(event))
734 {
735 SetSelection(-1, -1);
736 }
737
738 void wxComboBox::OnUpdateCut(wxUpdateUIEvent& event)
739 {
740 event.Enable( CanCut() );
741 }
742
743 void wxComboBox::OnUpdateCopy(wxUpdateUIEvent& event)
744 {
745 event.Enable( CanCopy() );
746 }
747
748 void wxComboBox::OnUpdatePaste(wxUpdateUIEvent& event)
749 {
750 event.Enable( CanPaste() );
751 }
752
753 void wxComboBox::OnUpdateUndo(wxUpdateUIEvent& event)
754 {
755 event.Enable( CanUndo() );
756 }
757
758 void wxComboBox::OnUpdateRedo(wxUpdateUIEvent& event)
759 {
760 event.Enable( CanRedo() );
761 }
762
763 void wxComboBox::OnUpdateDelete(wxUpdateUIEvent& event)
764 {
765 event.Enable(HasSelection() && IsEditable());
766 }
767
768 void wxComboBox::OnUpdateSelectAll(wxUpdateUIEvent& event)
769 {
770 event.Enable(GetLastPosition() > 0);
771 }
772
773 #endif // wxUSE_COMBOBOX