1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/combocmn.cpp
3 // Purpose: wxComboCtrlBase
4 // Author: Jaakko Salli
6 // Created: Apr-30-2006
8 // Copyright: (c) 2005 Jaakko Salli
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 #include "wx/wxprec.h"
28 #include "wx/combobox.h"
33 #include "wx/dcclient.h"
34 #include "wx/settings.h"
36 #include "wx/textctrl.h"
39 #include "wx/tooltip.h"
46 // ----------------------------------------------------------------------------
48 #define DEFAULT_DROPBUTTON_WIDTH 19
50 #define BMP_BUTTON_MARGIN 4
52 #define DEFAULT_POPUP_HEIGHT 400
54 #define DEFAULT_TEXT_INDENT 3
56 #define COMBO_MARGIN 2 // spacing right of wxTextCtrl
59 #if defined(__WXMSW__)
61 // Let's use wxFrame as a fall-back solution until wxMSW gets wxNonOwnedWindow
63 #define wxCC_GENERIC_TLW_IS_FRAME
64 #define wxComboCtrlGenericTLW wxFrame
66 #define USE_TRANSIENT_POPUP 1 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
67 #define TRANSIENT_POPUPWIN_IS_PERFECT 0 // wxPopupTransientWindow works, its child can have focus, and common
68 // native controls work on it like normal.
69 #define POPUPWIN_IS_PERFECT 0 // Same, but for non-transient popup window.
70 #define TEXTCTRL_TEXT_CENTERED 0 // 1 if text in textctrl is vertically centered
71 #define FOCUS_RING 0 // No focus ring on wxMSW
73 //#undef wxUSE_POPUPWIN
74 //#define wxUSE_POPUPWIN 0
76 #elif defined(__WXGTK__)
78 // NB: It is not recommended to use wxDialog as popup on wxGTK, because of
79 // this bug: If wxDialog is hidden, its position becomes corrupt
80 // between hide and next show, but without internal coordinates being
81 // reflected (or something like that - atleast commenting out ->Hide()
82 // seemed to eliminate the position change).
84 #include "wx/dialog.h"
85 #define wxCC_GENERIC_TLW_IS_DIALOG
86 #define wxComboCtrlGenericTLW wxDialog
88 #include "wx/gtk/private.h"
90 // NB: Let's not be afraid to use wxGTK's wxPopupTransientWindow as a
91 // 'perfect' popup, as it can succesfully host child controls even in
92 // popups that are shown in modal dialogs.
94 #define USE_TRANSIENT_POPUP 1 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
95 #define TRANSIENT_POPUPWIN_IS_PERFECT 1 // wxPopupTransientWindow works, its child can have focus, and common
96 // native controls work on it like normal.
97 #define POPUPWIN_IS_PERFECT 1 // Same, but for non-transient popup window.
98 #define TEXTCTRL_TEXT_CENTERED 1 // 1 if text in textctrl is vertically centered
99 #define FOCUS_RING 0 // No focus ring on wxGTK
101 #elif defined(__WXMAC__)
103 #include "wx/nonownedwnd.h"
104 #define wxCC_GENERIC_TLW_IS_NONOWNEDWINDOW
105 #define wxComboCtrlGenericTLW wxNonOwnedWindow
107 #define USE_TRANSIENT_POPUP 1 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
108 #define TRANSIENT_POPUPWIN_IS_PERFECT 1 // wxPopupTransientWindow works, its child can have focus, and common
109 // native controls work on it like normal.
110 #define POPUPWIN_IS_PERFECT 1 // Same, but for non-transient popup window.
111 #define TEXTCTRL_TEXT_CENTERED 1 // 1 if text in textctrl is vertically centered
112 #define FOCUS_RING 3 // Reserve room for the textctrl's focus ring to display
114 #undef DEFAULT_DROPBUTTON_WIDTH
115 #define DEFAULT_DROPBUTTON_WIDTH 22
117 #define COMBO_MARGIN FOCUS_RING
121 #include "wx/dialog.h"
122 #define wxCC_GENERIC_TLW_IS_DIALOG
123 #define wxComboCtrlGenericTLW wxDialog
125 #define USE_TRANSIENT_POPUP 0 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
126 #define TRANSIENT_POPUPWIN_IS_PERFECT 0 // wxPopupTransientWindow works, its child can have focus, and common
127 // native controls work on it like normal.
128 #define POPUPWIN_IS_PERFECT 0 // Same, but for non-transient popup window.
129 #define TEXTCTRL_TEXT_CENTERED 1 // 1 if text in textctrl is vertically centered
135 // Popupwin is really only supported on wxMSW (not WINCE) and wxGTK, regardless
136 // what the wxUSE_POPUPWIN says.
137 // FIXME: Why isn't wxUSE_POPUPWIN reliable any longer? (it was in wxW2.6.2)
138 #if (!defined(__WXMSW__) && !defined(__WXGTK__) && !defined(__WXMAC__)) || defined(__WXWINCE__)
139 #undef wxUSE_POPUPWIN
140 #define wxUSE_POPUPWIN 0
145 #include "wx/popupwin.h"
147 #undef USE_TRANSIENT_POPUP
148 #define USE_TRANSIENT_POPUP 0
152 // Define different types of popup windows
156 POPUPWIN_WXPOPUPTRANSIENTWINDOW
= 1,
157 POPUPWIN_WXPOPUPWINDOW
= 2,
158 POPUPWIN_GENERICTLW
= 3
162 #if USE_TRANSIENT_POPUP
163 // wxPopupTransientWindow is implemented
165 #define wxComboPopupWindowBase wxPopupTransientWindow
166 #define PRIMARY_POPUP_TYPE POPUPWIN_WXPOPUPTRANSIENTWINDOW
167 #define USES_WXPOPUPTRANSIENTWINDOW 1
169 #if TRANSIENT_POPUPWIN_IS_PERFECT
171 #elif POPUPWIN_IS_PERFECT
172 #define wxComboPopupWindowBase2 wxPopupWindow
173 #define SECONDARY_POPUP_TYPE POPUPWIN_WXPOPUPWINDOW
174 #define USES_WXPOPUPWINDOW 1
176 #define wxComboPopupWindowBase2 wxComboCtrlGenericTLW
177 #define SECONDARY_POPUP_TYPE POPUPWIN_GENERICTLW
178 #define USES_GENERICTLW 1
182 // wxPopupWindow (but not wxPopupTransientWindow) is properly implemented
184 #define wxComboPopupWindowBase wxPopupWindow
185 #define PRIMARY_POPUP_TYPE POPUPWIN_WXPOPUPWINDOW
186 #define USES_WXPOPUPWINDOW 1
188 #if !POPUPWIN_IS_PERFECT
189 #define wxComboPopupWindowBase2 wxComboCtrlGenericTLW
190 #define SECONDARY_POPUP_TYPE POPUPWIN_GENERICTLW
191 #define USES_GENERICTLW 1
195 // wxPopupWindow is not implemented
197 #define wxComboPopupWindowBase wxComboCtrlGenericTLW
198 #define PRIMARY_POPUP_TYPE POPUPWIN_GENERICTLW
199 #define USES_GENERICTLW 1
204 #ifndef USES_WXPOPUPTRANSIENTWINDOW
205 #define USES_WXPOPUPTRANSIENTWINDOW 0
208 #ifndef USES_WXPOPUPWINDOW
209 #define USES_WXPOPUPWINDOW 0
212 #ifndef USES_GENERICTLW
213 #define USES_GENERICTLW 0
217 #if USES_WXPOPUPWINDOW
218 #define INSTALL_TOPLEV_HANDLER 1
220 #define INSTALL_TOPLEV_HANDLER 0
226 // * wxComboPopupWindow for external use (ie. replace old wxUniv wxPopupComboWindow)
230 // ----------------------------------------------------------------------------
231 // wxComboFrameEventHandler takes care of hiding the popup when events happen
232 // in its top level parent.
233 // ----------------------------------------------------------------------------
235 #if INSTALL_TOPLEV_HANDLER
238 // This will no longer be necessary after wxTransientPopupWindow
239 // works well on all platforms.
242 class wxComboFrameEventHandler
: public wxEvtHandler
245 wxComboFrameEventHandler( wxComboCtrlBase
* pCb
);
246 virtual ~wxComboFrameEventHandler();
250 void OnIdle( wxIdleEvent
& event
);
251 void OnMouseEvent( wxMouseEvent
& event
);
252 void OnActivate( wxActivateEvent
& event
);
253 void OnResize( wxSizeEvent
& event
);
254 void OnMove( wxMoveEvent
& event
);
255 void OnMenuEvent( wxMenuEvent
& event
);
256 void OnClose( wxCloseEvent
& event
);
259 wxWindow
* m_focusStart
;
260 wxComboCtrlBase
* m_combo
;
263 DECLARE_EVENT_TABLE()
266 BEGIN_EVENT_TABLE(wxComboFrameEventHandler
, wxEvtHandler
)
267 EVT_IDLE(wxComboFrameEventHandler
::OnIdle
)
268 EVT_LEFT_DOWN(wxComboFrameEventHandler
::OnMouseEvent
)
269 EVT_RIGHT_DOWN(wxComboFrameEventHandler
::OnMouseEvent
)
270 EVT_SIZE(wxComboFrameEventHandler
::OnResize
)
271 EVT_MOVE(wxComboFrameEventHandler
::OnMove
)
272 EVT_MENU_HIGHLIGHT(wxID_ANY
,wxComboFrameEventHandler
::OnMenuEvent
)
273 EVT_MENU_OPEN(wxComboFrameEventHandler
::OnMenuEvent
)
274 EVT_ACTIVATE(wxComboFrameEventHandler
::OnActivate
)
275 EVT_CLOSE(wxComboFrameEventHandler
::OnClose
)
278 wxComboFrameEventHandler
::wxComboFrameEventHandler( wxComboCtrlBase
* combo
)
284 wxComboFrameEventHandler
::~wxComboFrameEventHandler()
288 void wxComboFrameEventHandler
::OnPopup()
290 m_focusStart
= ::wxWindow
::FindFocus();
293 void wxComboFrameEventHandler
::OnIdle( wxIdleEvent
& event
)
295 wxWindow
* winFocused
= ::wxWindow
::FindFocus();
297 wxWindow
* popup
= m_combo
->GetPopupControl()->GetControl();
298 wxWindow
* winpopup
= m_combo
->GetPopupWindow();
301 winFocused
!= m_focusStart
&&
302 winFocused
!= popup
&&
303 winFocused
->GetParent() != popup
&&
304 winFocused
!= winpopup
&&
305 winFocused
->GetParent() != winpopup
&&
306 winFocused
!= m_combo
&&
307 winFocused
!= m_combo
->GetButton() // GTK (atleast) requires this
310 m_combo
->HidePopup(true);
316 void wxComboFrameEventHandler
::OnMenuEvent( wxMenuEvent
& event
)
318 m_combo
->HidePopup(true);
322 void wxComboFrameEventHandler
::OnMouseEvent( wxMouseEvent
& event
)
324 m_combo
->HidePopup(true);
328 void wxComboFrameEventHandler
::OnClose( wxCloseEvent
& event
)
330 m_combo
->HidePopup(true);
334 void wxComboFrameEventHandler
::OnActivate( wxActivateEvent
& event
)
336 m_combo
->HidePopup(true);
340 void wxComboFrameEventHandler
::OnResize( wxSizeEvent
& event
)
342 m_combo
->HidePopup(true);
346 void wxComboFrameEventHandler
::OnMove( wxMoveEvent
& event
)
348 m_combo
->HidePopup(true);
352 #endif // INSTALL_TOPLEV_HANDLER
354 // ----------------------------------------------------------------------------
355 // wxComboPopupWindow is, in essence, wxPopupWindow customized for
357 // ----------------------------------------------------------------------------
359 class wxComboPopupWindow
: public wxComboPopupWindowBase
363 wxComboPopupWindow( wxComboCtrlBase
*parent
,
365 #if USES_WXPOPUPWINDOW || USES_WXPOPUPTRANSIENTWINDOW
366 : wxComboPopupWindowBase(parent
,style
)
368 : wxComboPopupWindowBase(parent
,
379 #if USES_WXPOPUPTRANSIENTWINDOW
380 virtual bool Show( bool show
);
381 virtual bool ProcessLeftDown(wxMouseEvent
& event
);
383 virtual void OnDismiss();
391 #if USES_WXPOPUPTRANSIENTWINDOW
392 bool wxComboPopupWindow
::Show( bool show
)
394 // Guard against recursion
396 return wxComboPopupWindowBase
::Show(show
);
400 wxASSERT( IsKindOf(CLASSINFO(wxPopupTransientWindow
)) );
402 wxPopupTransientWindow
* ptw
= (wxPopupTransientWindow
*) this;
404 if ( show
!= ptw
->IsShown() )
407 // We used to do wxPopupTransientWindow::Popup here,
408 // but this would hide normal Show, which we are
409 // also going to need.
420 bool wxComboPopupWindow
::ProcessLeftDown(wxMouseEvent
& event
)
422 return wxPopupTransientWindow
::ProcessLeftDown(event
);
425 // First thing that happens when a transient popup closes is that this method gets called.
426 void wxComboPopupWindow
::OnDismiss()
428 wxComboCtrlBase
* combo
= (wxComboCtrlBase
*) GetParent();
429 wxASSERT_MSG( combo
->IsKindOf(CLASSINFO(wxComboCtrlBase
)),
430 wxT("parent might not be wxComboCtrl, but check IMPLEMENT_DYNAMIC_CLASS(2) macro for correctness") );
432 combo
->OnPopupDismiss(true);
434 #endif // USES_WXPOPUPTRANSIENTWINDOW
437 // ----------------------------------------------------------------------------
438 // wxComboPopupWindowEvtHandler does bulk of the custom event handling
439 // of a popup window. It is separate so we can have different types
441 // ----------------------------------------------------------------------------
443 class wxComboPopupWindowEvtHandler
: public wxEvtHandler
447 wxComboPopupWindowEvtHandler( wxComboCtrlBase
*parent
)
452 void OnSizeEvent( wxSizeEvent
& event
);
453 void OnKeyEvent(wxKeyEvent
& event
);
455 void OnActivate( wxActivateEvent
& event
);
459 wxComboCtrlBase
* m_combo
;
461 DECLARE_EVENT_TABLE()
465 BEGIN_EVENT_TABLE(wxComboPopupWindowEvtHandler
, wxEvtHandler
)
466 EVT_KEY_DOWN(wxComboPopupWindowEvtHandler
::OnKeyEvent
)
467 EVT_KEY_UP(wxComboPopupWindowEvtHandler
::OnKeyEvent
)
468 EVT_CHAR(wxComboPopupWindowEvtHandler
::OnKeyEvent
)
470 EVT_ACTIVATE(wxComboPopupWindowEvtHandler
::OnActivate
)
472 EVT_SIZE(wxComboPopupWindowEvtHandler
::OnSizeEvent
)
476 void wxComboPopupWindowEvtHandler
::OnSizeEvent( wxSizeEvent
& WXUNUSED(event
) )
478 // Block the event so that the popup control does not get auto-resized.
481 void wxComboPopupWindowEvtHandler
::OnKeyEvent( wxKeyEvent
& event
)
483 // Relay keyboard event to the main child controls
484 wxWindowList children
= m_combo
->GetPopupWindow()->GetChildren();
485 wxWindowList
::iterator node
= children
.begin();
486 wxWindow
* child
= (wxWindow
*)*node
;
487 child
->GetEventHandler()->ProcessEvent(event
);
491 void wxComboPopupWindowEvtHandler
::OnActivate( wxActivateEvent
& event
)
493 if ( !event
.GetActive() )
495 // Tell combo control that we are dismissed.
496 m_combo
->HidePopup(true);
504 // ----------------------------------------------------------------------------
507 // ----------------------------------------------------------------------------
509 wxComboPopup
::~wxComboPopup()
513 void wxComboPopup
::OnPopup()
517 void wxComboPopup
::OnDismiss()
521 wxComboCtrl
* wxComboPopup
::GetComboCtrl() const
523 return wxStaticCast(m_combo
, wxComboCtrl
);
526 wxSize wxComboPopup
::GetAdjustedSize( int minWidth
,
528 int WXUNUSED(maxHeight
) )
530 return wxSize(minWidth
,prefHeight
);
533 void wxComboPopup
::DefaultPaintComboControl( wxComboCtrlBase
* combo
,
534 wxDC
& dc
, const wxRect
& rect
)
536 if ( combo
->GetWindowStyle() & wxCB_READONLY
) // ie. no textctrl
538 combo
->PrepareBackground(dc
,rect
,0);
540 dc
.DrawText( combo
->GetValue(),
541 rect
.x
+ combo
->m_marginLeft
,
542 (rect
.height
-dc
.GetCharHeight())/2 + rect
.y
);
546 void wxComboPopup
::PaintComboControl( wxDC
& dc
, const wxRect
& rect
)
548 DefaultPaintComboControl(m_combo
,dc
,rect
);
551 void wxComboPopup
::OnComboKeyEvent( wxKeyEvent
& event
)
556 void wxComboPopup
::OnComboCharEvent( wxKeyEvent
& event
)
561 void wxComboPopup
::OnComboDoubleClick()
565 void wxComboPopup
::SetStringValue( const wxString
& WXUNUSED(value
) )
569 bool wxComboPopup
::LazyCreate()
574 void wxComboPopup
::Dismiss()
576 m_combo
->HidePopup(true);
579 // ----------------------------------------------------------------------------
581 // ----------------------------------------------------------------------------
584 // This is pushed to the event handler queue of the child textctrl.
586 class wxComboBoxExtraInputHandler
: public wxEvtHandler
590 wxComboBoxExtraInputHandler( wxComboCtrlBase
* combo
)
595 virtual ~wxComboBoxExtraInputHandler() { }
596 void OnKey(wxKeyEvent
& event
);
597 void OnFocus(wxFocusEvent
& event
);
600 wxComboCtrlBase
* m_combo
;
603 DECLARE_EVENT_TABLE()
607 BEGIN_EVENT_TABLE(wxComboBoxExtraInputHandler
, wxEvtHandler
)
608 EVT_KEY_DOWN(wxComboBoxExtraInputHandler
::OnKey
)
609 EVT_KEY_UP(wxComboBoxExtraInputHandler
::OnKey
)
610 EVT_CHAR(wxComboBoxExtraInputHandler
::OnKey
)
611 EVT_SET_FOCUS(wxComboBoxExtraInputHandler
::OnFocus
)
612 EVT_KILL_FOCUS(wxComboBoxExtraInputHandler
::OnFocus
)
616 void wxComboBoxExtraInputHandler
::OnKey(wxKeyEvent
& event
)
618 // Let the wxComboCtrl event handler have a go first.
619 wxComboCtrlBase
* combo
= m_combo
;
621 wxKeyEvent
redirectedEvent(event
);
622 redirectedEvent
.SetId(combo
->GetId());
623 redirectedEvent
.SetEventObject(combo
);
625 if ( !combo
->GetEventHandler()->ProcessEvent(redirectedEvent
) )
627 // Don't let TAB through to the text ctrl - looks ugly
628 if ( event
.GetKeyCode() != WXK_TAB
)
633 void wxComboBoxExtraInputHandler
::OnFocus(wxFocusEvent
& event
)
635 // FIXME: This code does run when control is clicked,
636 // yet on Windows it doesn't select all the text.
637 if ( event
.GetEventType() == wxEVT_SET_FOCUS
&&
638 !(m_combo
->GetInternalFlags() & wxCC_NO_TEXT_AUTO_SELECT
) )
640 if ( m_combo
->GetTextCtrl() )
641 m_combo
->GetTextCtrl()->SelectAll();
643 m_combo
->SetSelection(-1,-1);
646 // Send focus indication to parent.
647 // NB: This is needed for cases where the textctrl gets focus
648 // instead of its parent. While this may trigger multiple
649 // wxEVT_SET_FOCUSes (since m_text->SetFocus is called
650 // from combo's focus event handler), they should be quite
652 wxFocusEvent
evt2(event
.GetEventType(),m_combo
->GetId());
653 evt2
.SetEventObject(m_combo
);
654 m_combo
->GetEventHandler()->ProcessEvent(evt2
);
661 // This is pushed to the event handler queue of the control in popup.
664 class wxComboPopupExtraEventHandler
: public wxEvtHandler
668 wxComboPopupExtraEventHandler( wxComboCtrlBase
* combo
)
672 m_beenInside
= false;
674 // Let's make it so that the popup control will not receive mouse
675 // events until mouse left button has been up.
676 m_blockEventsToPopup
= true;
678 virtual ~wxComboPopupExtraEventHandler() { }
680 void OnMouseEvent( wxMouseEvent
& event
);
682 // Called from wxComboCtrlBase::OnPopupDismiss
683 void OnPopupDismiss()
685 m_beenInside
= false;
686 m_blockEventsToPopup
= true;
690 wxComboCtrlBase
* m_combo
;
693 bool m_blockEventsToPopup
;
696 DECLARE_EVENT_TABLE()
700 BEGIN_EVENT_TABLE(wxComboPopupExtraEventHandler
, wxEvtHandler
)
701 EVT_MOUSE_EVENTS(wxComboPopupExtraEventHandler
::OnMouseEvent
)
705 void wxComboPopupExtraEventHandler
::OnMouseEvent( wxMouseEvent
& event
)
707 wxPoint pt
= event
.GetPosition();
708 wxSize sz
= m_combo
->GetPopupControl()->GetControl()->GetClientSize();
709 int evtType
= event
.GetEventType();
710 bool isInside
= pt
.x
>= 0 && pt
.y
>= 0 && pt
.x
< sz
.x
&& pt
.y
< sz
.y
;
711 bool relayToButton
= false;
715 if ( !isInside
|| !m_combo
->IsPopupShown() )
717 // Mouse is outside the popup or popup is not actually shown (yet)
719 if ( evtType
== wxEVT_MOTION
||
720 evtType
== wxEVT_LEFT_DOWN
||
721 evtType
== wxEVT_LEFT_UP
||
722 evtType
== wxEVT_RIGHT_DOWN
)
724 // Block motion and click events outside the popup
730 // Mouse is inside the popup, which is fully shown
734 // Do not let the popup control respond to mouse events until
735 // mouse press used to display the popup has been lifted. This
736 // is important for users with slower mouse fingers or mouse
737 // drivers. Note that we have some redundancy here, just in
738 // case the popup is some native control that does not emit all
739 // mouse event types.
740 if ( evtType
== wxEVT_MOTION
)
742 if ( m_blockEventsToPopup
)
744 if ( event
.LeftIsDown() )
747 m_blockEventsToPopup
= false;
750 else if ( evtType
== wxEVT_LEFT_DOWN
)
752 if ( m_blockEventsToPopup
)
753 m_blockEventsToPopup
= false;
755 else if ( evtType
== wxEVT_LEFT_UP
)
757 if ( m_blockEventsToPopup
)
759 // On first left up, stop blocking mouse events (but still
761 m_blockEventsToPopup
= false;
765 else if ( m_blockEventsToPopup
)
772 // Some mouse events to popup that happen outside it, before cursor
773 // has been inside the popup, need to be ignored by it but relayed to
776 if ( evtType
== wxEVT_LEFT_UP
)
778 if ( !m_combo
->IsPopupShown() )
781 relayToButton
= true;
783 else if ( !isInside
&& !m_beenInside
)
785 // Popup is shown but the cursor is not inside, nor it has been
786 relayToButton
= true;
792 wxWindow
* eventSink
= m_combo
;
793 wxWindow
* btn
= m_combo
->GetButton();
797 eventSink
->GetEventHandler()->ProcessEvent(event
);
801 // ----------------------------------------------------------------------------
802 // wxComboCtrlTextCtrl
803 // ----------------------------------------------------------------------------
805 class wxComboCtrlTextCtrl
: public wxTextCtrl
808 wxComboCtrlTextCtrl() : wxTextCtrl() { }
809 virtual ~wxComboCtrlTextCtrl() { }
811 virtual wxWindow
*GetMainWindowOfCompositeControl()
813 wxComboCtrl
* combo
= (wxComboCtrl
*) GetParent();
815 // Returning this instead of just 'parent' lets FindFocus work
816 // correctly even when parent control is a child of a composite
817 // generic control (as is case with wxGenericDatePickerCtrl).
818 return combo
->GetMainWindowOfCompositeControl();
822 // ----------------------------------------------------------------------------
824 // ----------------------------------------------------------------------------
827 BEGIN_EVENT_TABLE(wxComboCtrlBase
, wxControl
)
828 EVT_TEXT(wxID_ANY
,wxComboCtrlBase
::OnTextCtrlEvent
)
829 EVT_SIZE(wxComboCtrlBase
::OnSizeEvent
)
830 EVT_SET_FOCUS(wxComboCtrlBase
::OnFocusEvent
)
831 EVT_KILL_FOCUS(wxComboCtrlBase
::OnFocusEvent
)
832 EVT_IDLE(wxComboCtrlBase
::OnIdleEvent
)
833 //EVT_BUTTON(wxID_ANY,wxComboCtrlBase::OnButtonClickEvent)
834 EVT_KEY_DOWN(wxComboCtrlBase
::OnKeyEvent
)
835 EVT_CHAR(wxComboCtrlBase
::OnCharEvent
)
836 EVT_TEXT_ENTER(wxID_ANY
,wxComboCtrlBase
::OnTextCtrlEvent
)
837 EVT_SYS_COLOUR_CHANGED(wxComboCtrlBase
::OnSysColourChanged
)
841 IMPLEMENT_ABSTRACT_CLASS(wxComboCtrlBase
, wxControl
)
843 void wxComboCtrlBase
::Init()
847 m_popupWinState
= Hidden
;
850 m_popupInterface
= NULL
;
852 m_popupExtraHandler
= NULL
;
853 m_textEvtHandler
= NULL
;
855 #if INSTALL_TOPLEV_HANDLER
856 m_toplevEvtHandler
= NULL
;
859 m_mainCtrlWnd
= this;
862 m_widthMinPopup
= -1;
864 m_widthCustomPaint
= 0;
865 m_widthCustomBorder
= 0;
869 m_blankButtonBg
= false;
871 m_popupWinType
= POPUPWIN_NONE
;
872 m_btnWid
= m_btnHei
= -1;
880 m_timeCanAcceptClick
= 0;
882 m_resetFocus
= false;
885 bool wxComboCtrlBase
::Create(wxWindow
*parent
,
887 const wxString
& value
,
891 const wxValidator
& validator
,
892 const wxString
& name
)
894 if ( !wxControl
::Create(parent
,
898 style
| wxWANTS_CHARS
,
903 m_valueString
= value
;
907 m_marginLeft
= GetNativeTextIndent();
909 m_iFlags
|= wxCC_IFLAG_CREATED
;
911 // If x and y indicate valid size, wxSizeEvent won't be
912 // emitted automatically, so we need to add artifical one.
913 if ( size
.x
> 0 && size
.y
> 0 )
915 wxSizeEvent
evt(size
,GetId());
916 GetEventHandler()->AddPendingEvent(evt
);
922 void wxComboCtrlBase
::InstallInputHandlers()
926 m_textEvtHandler
= new wxComboBoxExtraInputHandler(this);
927 m_text
->PushEventHandler(m_textEvtHandler
);
932 wxComboCtrlBase
::CreateTextCtrl(int style
, const wxValidator
& validator
)
934 if ( !(m_windowStyle
& wxCB_READONLY
) )
939 // wxTE_PROCESS_TAB is needed because on Windows, wxTAB_TRAVERSAL is
940 // not used by the wxPropertyGrid and therefore the tab is processed by
941 // looking at ancestors to see if they have wxTAB_TRAVERSAL. The
942 // navigation event is then sent to the wrong window.
943 style
|= wxTE_PROCESS_TAB
;
945 if ( HasFlag(wxTE_PROCESS_ENTER
) )
946 style
|= wxTE_PROCESS_ENTER
;
948 // Ignore EVT_TEXT generated by the constructor (but only
949 // if the event redirector already exists)
950 // NB: This must be " = 1" instead of "++";
951 if ( m_textEvtHandler
)
956 m_text
= new wxComboCtrlTextCtrl();
957 m_text
->Create(this, wxID_ANY
, m_valueString
,
958 wxDefaultPosition
, wxSize(10,-1),
960 m_text
->SetHint(m_hintText
);
964 void wxComboCtrlBase
::OnThemeChange()
966 // Leave the default bg on the Mac so the area used by the focus ring will
967 // be the correct colour and themed brush. Instead we'll use
968 // wxSYS_COLOUR_WINDOW in the EVT_PAINT handler as needed.
970 #if defined(__WXMSW__) || defined(__WXGTK__)
971 wxVisualAttributes vattrs
= wxComboBox
::GetClassDefaultAttributes();
973 wxVisualAttributes vattrs
;
974 vattrs
.colFg
= wxSystemSettings
::GetColour(wxSYS_COLOUR_WINDOWTEXT
);
975 vattrs
.colBg
= wxSystemSettings
::GetColour(wxSYS_COLOUR_WINDOW
);
978 // Only change the colours if application has not specified
982 SetOwnForegroundColour(vattrs
.colFg
);
987 SetOwnBackgroundColour(vattrs
.colBg
);
993 wxComboCtrlBase
::~wxComboCtrlBase()
998 #if INSTALL_TOPLEV_HANDLER
999 delete ((wxComboFrameEventHandler
*)m_toplevEvtHandler
);
1000 m_toplevEvtHandler
= NULL
;
1006 m_text
->RemoveEventHandler(m_textEvtHandler
);
1008 delete m_textEvtHandler
;
1012 // ----------------------------------------------------------------------------
1014 // ----------------------------------------------------------------------------
1016 // Recalculates button and textctrl areas
1017 void wxComboCtrlBase
::CalculateAreas( int btnWidth
)
1019 wxSize sz
= GetClientSize();
1020 int customBorder
= m_widthCustomBorder
;
1021 int btnBorder
; // border for button only
1023 // check if button should really be outside the border: we'll do it it if
1024 // its platform default or bitmap+pushbutton background is used, but not if
1025 // there is vertical size adjustment or horizontal spacing.
1026 if ( ( (m_iFlags
& wxCC_BUTTON_OUTSIDE_BORDER
) ||
1027 (m_bmpNormal
.Ok() && m_blankButtonBg
) ) &&
1028 m_btnSpacingX
== 0 &&
1031 m_iFlags
|= wxCC_IFLAG_BUTTON_OUTSIDE
;
1034 else if ( (m_iFlags
& wxCC_BUTTON_COVERS_BORDER
) &&
1035 m_btnSpacingX
== 0 && !m_bmpNormal
.Ok() )
1037 m_iFlags
&= ~(wxCC_IFLAG_BUTTON_OUTSIDE
);
1042 m_iFlags
&= ~(wxCC_IFLAG_BUTTON_OUTSIDE
);
1043 btnBorder
= customBorder
;
1046 // Defaul indentation
1047 if ( m_marginLeft
< 0 )
1048 m_marginLeft
= GetNativeTextIndent();
1050 int butWidth
= btnWidth
;
1052 if ( butWidth
<= 0 )
1053 butWidth
= m_btnWidDefault
;
1055 m_btnWidDefault
= butWidth
;
1057 if ( butWidth
<= 0 )
1060 int butHeight
= sz
.y
- btnBorder
*2;
1062 // Adjust button width
1064 butWidth
= m_btnWid
;
1067 // Adjust button width to match aspect ratio
1068 // (but only if control is smaller than best size).
1069 int bestHeight
= GetBestSize().y
;
1070 int height
= GetSize().y
;
1072 if ( height
< bestHeight
)
1074 // Make very small buttons square, as it makes
1075 // them accommodate arrow image better and still
1078 butWidth
= (height
*butWidth
)/bestHeight
;
1080 butWidth
= butHeight
;
1084 // Adjust button height
1086 butHeight
= m_btnHei
;
1088 // Use size of normal bitmap if...
1091 // button width is set to default and blank button bg is not drawn
1092 if ( m_bmpNormal
.Ok() )
1094 int bmpReqWidth
= m_bmpNormal
.GetWidth();
1095 int bmpReqHeight
= m_bmpNormal
.GetHeight();
1097 // If drawing blank button background, we need to add some margin.
1098 if ( m_blankButtonBg
)
1100 bmpReqWidth
+= BMP_BUTTON_MARGIN
*2;
1101 bmpReqHeight
+= BMP_BUTTON_MARGIN
*2;
1104 if ( butWidth
< bmpReqWidth
|| ( m_btnWid
== 0 && !m_blankButtonBg
) )
1105 butWidth
= bmpReqWidth
;
1106 if ( butHeight
< bmpReqHeight
|| ( m_btnHei
== 0 && !m_blankButtonBg
) )
1107 butHeight
= bmpReqHeight
;
1109 // Need to fix height?
1110 if ( (sz
.y
-(customBorder
*2)) < butHeight
&& btnWidth
== 0 )
1112 int newY
= butHeight
+(customBorder
*2);
1113 SetClientSize(wxDefaultCoord
,newY
);
1114 if ( m_bmpNormal
.Ok() || m_btnArea
.width
!= butWidth
|| m_btnArea
.height
!= butHeight
)
1115 m_iFlags
|= wxCC_IFLAG_HAS_NONSTANDARD_BUTTON
;
1117 m_iFlags
&= ~wxCC_IFLAG_HAS_NONSTANDARD_BUTTON
;
1123 int butAreaWid
= butWidth
+ (m_btnSpacingX
*2);
1125 m_btnSize
.x
= butWidth
;
1126 m_btnSize
.y
= butHeight
;
1128 m_btnArea
.x
= ( m_btnSide
==wxRIGHT ? sz
.x
- butAreaWid
- btnBorder
: btnBorder
);
1129 m_btnArea
.y
= btnBorder
+ FOCUS_RING
;
1130 m_btnArea
.width
= butAreaWid
;
1131 m_btnArea
.height
= sz
.y
- ((btnBorder
+FOCUS_RING
)*2);
1133 m_tcArea
.x
= ( m_btnSide
==wxRIGHT ?
0 : butAreaWid
) + customBorder
+ FOCUS_RING
;
1134 m_tcArea
.y
= customBorder
+ FOCUS_RING
;
1135 m_tcArea
.width
= sz
.x
- butAreaWid
- (customBorder
*2) - (FOCUS_RING
*2);
1136 m_tcArea
.height
= sz
.y
- ((customBorder
+FOCUS_RING
)*2);
1141 ::wxMessageBox(wxString::Format(wxT("ButtonArea (%i,%i,%i,%i)\n"),m_btnArea.x,m_btnArea.y,m_btnArea.width,m_btnArea.height) +
1142 wxString::Format(wxT("TextCtrlArea (%i,%i,%i,%i)"),m_tcArea.x,m_tcArea.y,m_tcArea.width,m_tcArea.height));
1147 void wxComboCtrlBase
::PositionTextCtrl( int textCtrlXAdjust
, int textCtrlYAdjust
)
1152 wxSize sz
= GetClientSize();
1154 int customBorder
= m_widthCustomBorder
;
1155 if ( (m_text
->GetWindowStyleFlag() & wxBORDER_MASK
) == wxNO_BORDER
)
1159 if ( !m_widthCustomPaint
)
1161 // No special custom paint area - we can use 0 left margin
1163 if ( m_text
->SetMargins(0) )
1164 textCtrlXAdjust
= 0;
1165 x
= m_tcArea
.x
+ m_marginLeft
+ textCtrlXAdjust
;
1169 // There is special custom paint area - it is better to
1170 // use some margin with the wxTextCtrl.
1171 m_text
->SetMargins(m_marginLeft
);
1172 x
= m_tcArea
.x
+ m_widthCustomPaint
+
1173 m_marginLeft
+ textCtrlXAdjust
;
1176 // Centre textctrl vertically, if needed
1177 #if !TEXTCTRL_TEXT_CENTERED
1178 int tcSizeY
= m_text
->GetBestSize().y
;
1179 int diff0
= sz
.y
- tcSizeY
;
1180 int y
= textCtrlYAdjust
+ (diff0
/2);
1182 wxUnusedVar(textCtrlYAdjust
);
1186 if ( y
< customBorder
)
1191 m_tcArea
.width
- m_tcArea
.x
- x
,
1194 // Make sure textctrl doesn't exceed the bottom custom border
1195 wxSize tsz
= m_text
->GetSize();
1196 int diff1
= (y
+ tsz
.y
) - (sz
.y
- customBorder
);
1199 tsz
.y
= tsz
.y
- diff1
- 1;
1200 m_text
->SetSize(tsz
);
1205 // If it has border, have textctrl fill the entire text field.
1206 m_text
->SetSize( m_tcArea
.x
+ m_widthCustomPaint
,
1208 m_tcArea
.width
- m_widthCustomPaint
,
1213 wxSize wxComboCtrlBase
::DoGetBestSize() const
1215 wxSize
sizeText(150,0);
1218 sizeText
= m_text
->GetBestSize();
1220 // TODO: Better method to calculate close-to-native control height.
1224 fhei
= (m_font
.GetPointSize()*2) + 5;
1225 else if ( wxNORMAL_FONT
->Ok() )
1226 fhei
= (wxNORMAL_FONT
->GetPointSize()*2) + 5;
1228 fhei
= sizeText
.y
+ 4;
1230 // Need to force height to accomodate bitmap?
1231 int btnSizeY
= m_btnSize
.y
;
1232 if ( m_bmpNormal
.Ok() && fhei
< btnSizeY
)
1235 // Control height doesn't depend on border
1238 int border = m_windowStyle & wxBORDER_MASK;
1239 if ( border == wxSIMPLE_BORDER )
1241 else if ( border == wxNO_BORDER )
1242 fhei += (m_widthCustomBorder*2);
1248 // Final adjustments
1254 // these are the numbers from the HIG:
1255 switch ( m_windowVariant
)
1257 case wxWINDOW_VARIANT_NORMAL
:
1261 case wxWINDOW_VARIANT_SMALL
:
1264 case wxWINDOW_VARIANT_MINI
:
1270 fhei
+= 2 * FOCUS_RING
;
1271 int width
= sizeText
.x
+ FOCUS_RING
+ COMBO_MARGIN
+ DEFAULT_DROPBUTTON_WIDTH
;
1273 wxSize
ret(width
, fhei
);
1278 void wxComboCtrlBase
::OnSizeEvent( wxSizeEvent
& event
)
1283 // defined by actual wxComboCtrls
1289 // ----------------------------------------------------------------------------
1290 // standard operations
1291 // ----------------------------------------------------------------------------
1293 bool wxComboCtrlBase
::Enable(bool enable
)
1295 if ( !wxControl
::Enable(enable
) )
1299 m_btn
->Enable(enable
);
1301 m_text
->Enable(enable
);
1308 bool wxComboCtrlBase
::Show(bool show
)
1310 if ( !wxControl
::Show(show
) )
1322 bool wxComboCtrlBase
::SetFont ( const wxFont
& font
)
1324 if ( !wxControl
::SetFont(font
) )
1329 // Without hiding the wxTextCtrl there would be some
1330 // visible 'flicker' (at least on Windows XP).
1332 m_text
->SetFont(font
);
1341 void wxComboCtrlBase
::DoSetToolTip(wxToolTip
*tooltip
)
1343 wxControl
::DoSetToolTip(tooltip
);
1345 // Set tool tip for button and text box
1348 const wxString
&tip
= tooltip
->GetTip();
1349 if ( m_text
) m_text
->SetToolTip(tip
);
1350 if ( m_btn
) m_btn
->SetToolTip(tip
);
1354 if ( m_text
) m_text
->SetToolTip( NULL
);
1355 if ( m_btn
) m_btn
->SetToolTip( NULL
);
1358 #endif // wxUSE_TOOLTIPS
1360 #if wxUSE_VALIDATORS
1361 void wxComboCtrlBase
::SetValidator(const wxValidator
& validator
)
1363 wxTextCtrl
* textCtrl
= GetTextCtrl();
1366 textCtrl
->SetValidator( validator
);
1368 wxControl
::SetValidator( validator
);
1371 wxValidator
* wxComboCtrlBase
::GetValidator()
1373 wxTextCtrl
* textCtrl
= GetTextCtrl();
1375 return textCtrl ? textCtrl
->GetValidator() : wxControl
::GetValidator();
1377 #endif // wxUSE_VALIDATORS
1379 bool wxComboCtrlBase
::SetForegroundColour(const wxColour
& colour
)
1381 if ( wxControl
::SetForegroundColour(colour
) )
1384 m_text
->SetForegroundColour(colour
);
1390 bool wxComboCtrlBase
::SetBackgroundColour(const wxColour
& colour
)
1392 if ( wxControl
::SetBackgroundColour(colour
) )
1395 m_text
->SetBackgroundColour(colour
);
1400 // ----------------------------------------------------------------------------
1402 // ----------------------------------------------------------------------------
1404 #if (!defined(__WXMSW__)) || defined(__WXUNIVERSAL__)
1405 // prepare combo box background on area in a way typical on platform
1406 void wxComboCtrlBase
::PrepareBackground( wxDC
& dc
, const wxRect
& rect
, int flags
) const
1408 wxSize sz
= GetClientSize();
1410 bool doDrawFocusRect
; // also selected
1412 // For smaller size control (and for disabled background) use less spacing
1416 if ( !(flags
& wxCONTROL_ISSUBMENU
) )
1419 isEnabled
= IsEnabled();
1420 doDrawFocusRect
= ShouldDrawFocus() && !(m_iFlags
& wxCC_FULL_BUTTON
);
1422 // Windows-style: for smaller size control (and for disabled background) use less spacing
1423 focusSpacingX
= isEnabled ?
2 : 1;
1424 focusSpacingY
= sz
.y
> (GetCharHeight()+2) && isEnabled ?
2 : 1;
1428 // Drawing a list item
1429 isEnabled
= true; // they are never disabled
1430 doDrawFocusRect
= (flags
& wxCONTROL_SELECTED
) != 0;
1436 // Set the background sub-rectangle for selection, disabled etc
1437 wxRect
selRect(rect
);
1438 selRect
.y
+= focusSpacingY
;
1439 selRect
.height
-= (focusSpacingY
*2);
1443 if ( !(flags
& wxCONTROL_ISSUBMENU
) )
1444 wcp
+= m_widthCustomPaint
;
1446 selRect
.x
+= wcp
+ focusSpacingX
;
1447 selRect
.width
-= wcp
+ (focusSpacingX
*2);
1452 bool doDrawSelRect
= true;
1454 // Determine foreground colour
1457 if ( doDrawFocusRect
)
1459 fgCol
= wxSystemSettings
::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT
);
1461 else if ( m_hasFgCol
)
1463 // Honour the custom foreground colour
1464 fgCol
= GetForegroundColour();
1468 fgCol
= wxSystemSettings
::GetColour(wxSYS_COLOUR_WINDOWTEXT
);
1473 fgCol
= wxSystemSettings
::GetColour(wxSYS_COLOUR_GRAYTEXT
);
1476 // Determine background colour
1479 if ( doDrawFocusRect
)
1481 bgCol
= wxSystemSettings
::GetColour(wxSYS_COLOUR_HIGHLIGHT
);
1483 else if ( m_hasBgCol
)
1485 // Honour the custom background colour
1486 bgCol
= GetBackgroundColour();
1490 #ifndef __WXMAC__ // see note in OnThemeChange
1491 doDrawSelRect
= false;
1492 bgCol
= GetBackgroundColour();
1494 bgCol
= wxSystemSettings
::GetColour(wxSYS_COLOUR_WINDOW
);
1500 #ifndef __WXMAC__ // see note in OnThemeChange
1501 bgCol
= GetBackgroundColour();
1503 bgCol
= wxSystemSettings
::GetColour(wxSYS_COLOUR_WINDOW
);
1507 dc
.SetTextForeground( fgCol
);
1508 dc
.SetBrush( bgCol
);
1509 if ( doDrawSelRect
)
1512 dc
.DrawRectangle( selRect
);
1515 // Don't clip exactly to the selection rectangle so we can draw
1516 // to the non-selected area in front of it.
1517 wxRect
clipRect(rect
.x
,rect
.y
,
1518 (selRect
.x
+selRect
.width
)-rect
.x
,rect
.height
);
1519 dc
.SetClippingRegion(clipRect
);
1522 // Save the library size a bit for platforms that re-implement this.
1523 void wxComboCtrlBase
::PrepareBackground( wxDC
&, const wxRect
&, int ) const
1528 void wxComboCtrlBase
::DrawButton( wxDC
& dc
, const wxRect
& rect
, int flags
)
1530 int drawState
= m_btnState
;
1532 if ( (m_iFlags
& wxCC_BUTTON_STAYS_DOWN
) &&
1533 GetPopupWindowState() >= Animating
)
1534 drawState
|= wxCONTROL_PRESSED
;
1536 wxRect
drawRect(rect
.x
+m_btnSpacingX
,
1537 rect
.y
+((rect
.height
-m_btnSize
.y
)/2),
1541 // Make sure area is not larger than the control
1542 if ( drawRect
.y
< rect
.y
)
1543 drawRect
.y
= rect
.y
;
1544 if ( drawRect
.height
> rect
.height
)
1545 drawRect
.height
= rect
.height
;
1547 bool enabled
= IsEnabled();
1550 drawState
|= wxCONTROL_DISABLED
;
1552 if ( !m_bmpNormal
.Ok() )
1554 if ( flags
& Button_BitmapOnly
)
1557 // Need to clear button background even if m_btn is present
1558 if ( flags
& Button_PaintBackground
)
1562 if ( m_iFlags
& wxCC_IFLAG_BUTTON_OUTSIDE
)
1563 bgCol
= GetParent()->GetBackgroundColour();
1565 bgCol
= GetBackgroundColour();
1569 dc
.DrawRectangle(rect
);
1572 // Draw standard button
1573 wxRendererNative
::Get().DrawComboBoxDropButton(this,
1585 pBmp
= &m_bmpDisabled
;
1586 else if ( m_btnState
& wxCONTROL_PRESSED
)
1587 pBmp
= &m_bmpPressed
;
1588 else if ( m_btnState
& wxCONTROL_CURRENT
)
1591 pBmp
= &m_bmpNormal
;
1593 if ( m_blankButtonBg
)
1595 // If using blank button background, we need to clear its background
1596 // with button face colour instead of colour for rest of the control.
1597 if ( flags
& Button_PaintBackground
)
1599 wxColour bgCol
= GetParent()->GetBackgroundColour(); //wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
1600 //wxColour bgCol = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
1603 dc
.DrawRectangle(rect
);
1606 if ( !(flags
& Button_BitmapOnly
) )
1608 wxRendererNative
::Get().DrawPushButton(this,
1617 // Need to clear button background even if m_btn is present
1618 // (assume non-button background was cleared just before this call so brushes are good)
1619 if ( flags
& Button_PaintBackground
)
1620 dc
.DrawRectangle(rect
);
1623 // Draw bitmap centered in drawRect
1624 dc
.DrawBitmap(*pBmp
,
1625 drawRect
.x
+ (drawRect
.width
-pBmp
->GetWidth())/2,
1626 drawRect
.y
+ (drawRect
.height
-pBmp
->GetHeight())/2,
1631 void wxComboCtrlBase
::RecalcAndRefresh()
1635 wxSizeEvent
evt(GetSize(),GetId());
1636 GetEventHandler()->ProcessEvent(evt
);
1641 // ----------------------------------------------------------------------------
1642 // miscellaneous event handlers
1643 // ----------------------------------------------------------------------------
1645 void wxComboCtrlBase
::OnTextCtrlEvent(wxCommandEvent
& event
)
1647 if ( event
.GetEventType() == wxEVT_COMMAND_TEXT_UPDATED
)
1649 if ( m_ignoreEvtText
> 0 )
1656 // Change event id, object and string before relaying it forward
1657 event
.SetId(GetId());
1658 wxString s
= event
.GetString();
1659 event
.SetEventObject(this);
1664 // call if cursor is on button area or mouse is captured for the button
1665 bool wxComboCtrlBase
::HandleButtonMouseEvent( wxMouseEvent
& event
,
1668 int type
= event
.GetEventType();
1670 if ( type
== wxEVT_MOTION
)
1672 if ( (flags
& wxCC_MF_ON_BUTTON
) &&
1673 IsPopupWindowState(Hidden
) )
1675 if ( !(m_btnState
& wxCONTROL_CURRENT
) )
1677 // Mouse hover begins
1678 m_btnState
|= wxCONTROL_CURRENT
;
1679 if ( HasCapture() ) // Retain pressed state.
1680 m_btnState
|= wxCONTROL_PRESSED
;
1684 else if ( (m_btnState
& wxCONTROL_CURRENT
) )
1687 m_btnState
&= ~(wxCONTROL_CURRENT
|wxCONTROL_PRESSED
);
1691 else if ( type
== wxEVT_LEFT_DOWN
|| type
== wxEVT_LEFT_DCLICK
)
1693 if ( flags
& (wxCC_MF_ON_CLICK_AREA
|wxCC_MF_ON_BUTTON
) )
1695 m_btnState
|= wxCONTROL_PRESSED
;
1698 if ( !(m_iFlags
& wxCC_POPUP_ON_MOUSE_UP
) )
1701 // If showing popup now, do not capture mouse or there will be interference
1705 else if ( type
== wxEVT_LEFT_UP
)
1708 // Only accept event if mouse was left-press was previously accepted
1712 if ( m_btnState
& wxCONTROL_PRESSED
)
1714 // If mouse was inside, fire the click event.
1715 if ( m_iFlags
& wxCC_POPUP_ON_MOUSE_UP
)
1717 if ( flags
& (wxCC_MF_ON_CLICK_AREA
|wxCC_MF_ON_BUTTON
) )
1721 m_btnState
&= ~(wxCONTROL_PRESSED
);
1725 else if ( type
== wxEVT_LEAVE_WINDOW
)
1727 if ( m_btnState
& (wxCONTROL_CURRENT
|wxCONTROL_PRESSED
) )
1729 m_btnState
&= ~(wxCONTROL_CURRENT
);
1732 if ( IsPopupWindowState(Hidden
) )
1734 m_btnState
&= ~(wxCONTROL_PRESSED
);
1742 // Never have 'hot' state when popup is being shown
1743 // (this is mostly needed because of the animation).
1744 if ( !IsPopupWindowState(Hidden
) )
1745 m_btnState
&= ~wxCONTROL_CURRENT
;
1750 // returns true if event was consumed or filtered
1751 bool wxComboCtrlBase
::PreprocessMouseEvent( wxMouseEvent
& event
,
1752 int WXUNUSED(flags
) )
1754 wxLongLong t
= ::wxGetLocalTimeMillis();
1755 int evtType
= event
.GetEventType();
1757 #if USES_WXPOPUPWINDOW || USES_GENERICTLW
1758 if ( m_popupWinType
!= POPUPWIN_WXPOPUPTRANSIENTWINDOW
)
1760 if ( IsPopupWindowState(Visible
) &&
1761 ( evtType
== wxEVT_LEFT_DOWN
|| evtType
== wxEVT_RIGHT_DOWN
) )
1769 // Filter out clicks on button immediately after popup dismiss
1770 if ( evtType
== wxEVT_LEFT_DOWN
&& t
< m_timeCanAcceptClick
)
1772 event
.SetEventType(0);
1779 void wxComboCtrlBase
::HandleNormalMouseEvent( wxMouseEvent
& event
)
1781 int evtType
= event
.GetEventType();
1783 if ( (evtType
== wxEVT_LEFT_DOWN
|| evtType
== wxEVT_LEFT_DCLICK
) &&
1784 (m_windowStyle
& wxCB_READONLY
) )
1786 if ( GetPopupWindowState() >= Animating
)
1788 #if USES_WXPOPUPWINDOW
1789 // Click here always hides the popup.
1790 if ( m_popupWinType
== POPUPWIN_WXPOPUPWINDOW
)
1796 if ( !(m_windowStyle
& wxCC_SPECIAL_DCLICK
) )
1798 // In read-only mode, clicking the text is the
1799 // same as clicking the button.
1802 else if ( /*evtType == wxEVT_LEFT_UP || */evtType
== wxEVT_LEFT_DCLICK
)
1804 //if ( m_popupInterface->CycleValue() )
1806 if ( m_popupInterface
)
1807 m_popupInterface
->OnComboDoubleClick();
1811 else if ( evtType
== wxEVT_MOUSEWHEEL
)
1813 if ( IsPopupShown() )
1815 // relay (some) mouse events to the popup
1816 m_popup
->GetEventHandler()->ProcessEvent(event
);
1818 else if ( event
.GetWheelAxis() == 0 &&
1819 event
.GetWheelRotation() != 0 &&
1820 event
.GetModifiers() == 0 )
1822 // Translate mousewheel actions into key up/down. This is
1823 // the simplest way of getting native behaviour: scrolling the
1824 // wheel moves selection up/down by one item.
1825 wxKeyEvent
kevent(wxEVT_KEY_DOWN
);
1826 kevent
.m_keyCode
= event
.GetWheelRotation() > 0
1829 GetEventHandler()->ProcessEvent(kevent
);
1842 void wxComboCtrlBase
::OnKeyEvent(wxKeyEvent
& event
)
1844 if ( IsPopupShown() )
1846 // pass it to the popped up control
1847 GetPopupControl()->GetControl()->GetEventHandler()->ProcessEvent(event
);
1851 wxWindow
* mainCtrl
= GetMainWindowOfCompositeControl();
1853 if ( mainCtrl
->GetParent()->HasFlag(wxTAB_TRAVERSAL
) )
1855 if ( mainCtrl
->HandleAsNavigationKey(event
) )
1859 if ( IsKeyPopupToggle(event
) )
1865 int comboStyle
= GetWindowStyle();
1866 wxComboPopup
* popupInterface
= GetPopupControl();
1868 if ( !popupInterface
)
1874 int keycode
= event
.GetKeyCode();
1876 if ( (comboStyle
& wxCB_READONLY
) ||
1877 (keycode
!= WXK_RIGHT
&& keycode
!= WXK_LEFT
) )
1879 popupInterface
->OnComboKeyEvent(event
);
1886 void wxComboCtrlBase
::OnCharEvent(wxKeyEvent
& event
)
1888 if ( IsPopupShown() )
1890 // pass it to the popped up control
1891 GetPopupControl()->GetControl()->GetEventHandler()->ProcessEvent(event
);
1895 wxComboPopup
* popupInterface
= GetPopupControl();
1896 if ( popupInterface
)
1898 popupInterface
->OnComboCharEvent(event
);
1907 void wxComboCtrlBase
::OnFocusEvent( wxFocusEvent
& event
)
1909 if ( event
.GetEventType() == wxEVT_SET_FOCUS
)
1911 wxWindow
* tc
= GetTextCtrl();
1912 if ( tc
&& tc
!= DoFindFocus() )
1921 void wxComboCtrlBase
::OnIdleEvent( wxIdleEvent
& WXUNUSED(event
) )
1925 m_resetFocus
= false;
1926 wxWindow
* tc
= GetTextCtrl();
1932 void wxComboCtrlBase
::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
1935 // left margin may also have changed
1936 if ( !(m_iFlags
& wxCC_IFLAG_LEFT_MARGIN_SET
) )
1937 m_marginLeft
= GetNativeTextIndent();
1941 // ----------------------------------------------------------------------------
1943 // ----------------------------------------------------------------------------
1945 // Create popup window and the child control
1946 void wxComboCtrlBase
::CreatePopup()
1948 wxComboPopup
* popupInterface
= m_popupInterface
;
1953 #ifdef wxComboPopupWindowBase2
1954 if ( m_iFlags
& wxCC_IFLAG_USE_ALT_POPUP
)
1956 #if !USES_GENERICTLW
1957 m_winPopup
= new wxComboPopupWindowBase2( this, wxNO_BORDER
);
1959 int tlwFlags
= wxNO_BORDER
;
1960 #ifdef wxCC_GENERIC_TLW_IS_FRAME
1961 tlwFlags
|= wxFRAME_NO_TASKBAR
;
1964 #ifdef wxCC_GENERIC_TLW_IS_NONOWNEDWINDOW
1965 m_winPopup
= new wxComboPopupWindowBase2( this, wxID_ANY
,
1966 wxPoint(-21,-21), wxSize(20, 20),
1969 m_winPopup
= new wxComboPopupWindowBase2( this, wxID_ANY
, wxEmptyString
,
1970 wxPoint(-21,-21), wxSize(20, 20),
1974 m_popupWinType
= SECONDARY_POPUP_TYPE
;
1977 #endif // wxComboPopupWindowBase2
1979 m_winPopup
= new wxComboPopupWindow( this, wxNO_BORDER
);
1980 m_popupWinType
= PRIMARY_POPUP_TYPE
;
1982 m_popupWinEvtHandler
= new wxComboPopupWindowEvtHandler(this);
1983 m_winPopup
->PushEventHandler(m_popupWinEvtHandler
);
1986 popupInterface
->Create(m_winPopup
);
1987 m_popup
= popup
= popupInterface
->GetControl();
1989 m_popupExtraHandler
= new wxComboPopupExtraEventHandler(this);
1990 popup
->PushEventHandler( m_popupExtraHandler
);
1992 // This may be helpful on some platforms
1993 // (eg. it bypasses a wxGTK popupwindow bug where
1994 // window is not initially hidden when it should be)
1997 popupInterface
->m_iFlags
|= wxCP_IFLAG_CREATED
;
2000 // Destroy popup window and the child control
2001 void wxComboCtrlBase
::DestroyPopup()
2006 m_popup
->RemoveEventHandler(m_popupExtraHandler
);
2008 delete m_popupExtraHandler
;
2010 delete m_popupInterface
;
2014 m_winPopup
->RemoveEventHandler(m_popupWinEvtHandler
);
2015 delete m_popupWinEvtHandler
;
2016 m_popupWinEvtHandler
= NULL
;
2017 m_winPopup
->Destroy();
2020 m_popupExtraHandler
= NULL
;
2021 m_popupInterface
= NULL
;
2026 void wxComboCtrlBase
::DoSetPopupControl(wxComboPopup
* iface
)
2028 wxCHECK_RET( iface
, wxT("no popup interface set for wxComboCtrl") );
2032 iface
->InitBase(this);
2035 m_popupInterface
= iface
;
2037 if ( !iface
->LazyCreate() )
2046 // This must be done after creation
2047 if ( m_valueString
.length() )
2049 iface
->SetStringValue(m_valueString
);
2054 // Ensures there is atleast the default popup
2055 void wxComboCtrlBase
::EnsurePopupControl()
2057 if ( !m_popupInterface
)
2058 SetPopupControl(NULL
);
2061 void wxComboCtrlBase
::OnButtonClick()
2063 // Derived classes can override this method for totally custom
2065 if ( !IsPopupWindowState(Visible
) )
2067 wxCommandEvent
event(wxEVT_COMMAND_COMBOBOX_DROPDOWN
, GetId());
2068 event
.SetEventObject(this);
2069 HandleWindowEvent(event
);
2079 void wxComboCtrlBase
::ShowPopup()
2081 EnsurePopupControl();
2082 wxCHECK_RET( !IsPopupWindowState(Visible
), wxT("popup window already shown") );
2084 if ( IsPopupWindowState(Animating
) )
2089 // Space above and below
2095 wxSize ctrlSz
= GetSize();
2097 screenHeight
= wxSystemSettings
::GetMetric( wxSYS_SCREEN_Y
);
2098 scrPos
= GetParent()->ClientToScreen(GetPosition());
2100 spaceAbove
= scrPos
.y
;
2101 spaceBelow
= screenHeight
- spaceAbove
- ctrlSz
.y
;
2103 maxHeightPopup
= spaceBelow
;
2104 if ( spaceAbove
> spaceBelow
)
2105 maxHeightPopup
= spaceAbove
;
2108 int widthPopup
= ctrlSz
.x
+ m_extLeft
+ m_extRight
;
2110 if ( widthPopup
< m_widthMinPopup
)
2111 widthPopup
= m_widthMinPopup
;
2113 wxWindow
* winPopup
= m_winPopup
;
2116 // Need to disable tab traversal of parent
2118 // NB: This is to fix a bug in wxMSW. In theory it could also be fixed
2119 // by, for instance, adding check to window.cpp:wxWindowMSW::MSWProcessMessage
2120 // that if transient popup is open, then tab traversal is to be ignored.
2121 // However, I think this code would still be needed for cases where
2122 // transient popup doesn't work yet (wxWinCE?).
2123 wxWindow
* mainCtrl
= GetMainWindowOfCompositeControl();
2124 wxWindow
* parent
= mainCtrl
->GetParent();
2125 int parentFlags
= parent
->GetWindowStyle();
2126 if ( parentFlags
& wxTAB_TRAVERSAL
)
2128 parent
->SetWindowStyle( parentFlags
& ~(wxTAB_TRAVERSAL
) );
2129 m_iFlags
|= wxCC_IFLAG_PARENT_TAB_TRAVERSAL
;
2135 winPopup
= m_winPopup
;
2145 wxASSERT( !m_popup
|| m_popup
== popup
); // Consistency check.
2147 wxSize adjustedSize
= m_popupInterface
->GetAdjustedSize(widthPopup
,
2148 m_heightPopup
<=0?DEFAULT_POPUP_HEIGHT
:m_heightPopup
,
2151 popup
->SetSize(adjustedSize
);
2153 m_popupInterface
->OnPopup();
2156 // Reposition and resize popup window
2159 wxSize szp
= popup
->GetSize();
2162 int popupY
= scrPos
.y
+ ctrlSz
.y
;
2164 // Default anchor is wxLEFT
2165 int anchorSide
= m_anchorSide
;
2167 anchorSide
= wxLEFT
;
2169 int rightX
= scrPos
.x
+ ctrlSz
.x
+ m_extRight
- szp
.x
;
2170 int leftX
= scrPos
.x
- m_extLeft
;
2172 if ( wxTheApp
->GetLayoutDirection() == wxLayout_RightToLeft
)
2175 int screenWidth
= wxSystemSettings
::GetMetric( wxSYS_SCREEN_X
);
2177 // If there is not enough horizontal space, anchor on the other side.
2178 // If there is no space even then, place the popup at x 0.
2179 if ( anchorSide
== wxRIGHT
)
2183 if ( (leftX
+szp
.x
) < screenWidth
)
2184 anchorSide
= wxLEFT
;
2191 if ( (leftX
+szp
.x
) >= screenWidth
)
2194 anchorSide
= wxRIGHT
;
2200 // Select x coordinate according to the anchor side
2201 if ( anchorSide
== wxRIGHT
)
2203 else if ( anchorSide
== wxLEFT
)
2208 int showFlags
= CanDeferShow
;
2210 if ( spaceBelow
< szp
.y
)
2212 popupY
= scrPos
.y
- szp
.y
;
2213 showFlags
|= ShowAbove
;
2216 #if INSTALL_TOPLEV_HANDLER
2217 // Put top level window event handler into place
2218 if ( m_popupWinType
== POPUPWIN_WXPOPUPWINDOW
)
2220 if ( !m_toplevEvtHandler
)
2221 m_toplevEvtHandler
= new wxComboFrameEventHandler(this);
2223 wxWindow
* toplev
= ::wxGetTopLevelParent( this );
2225 ((wxComboFrameEventHandler
*)m_toplevEvtHandler
)->OnPopup();
2226 toplev
->PushEventHandler( m_toplevEvtHandler
);
2230 // Set string selection (must be this way instead of SetStringSelection)
2233 if ( !(m_iFlags
& wxCC_NO_TEXT_AUTO_SELECT
) )
2234 m_text
->SelectAll();
2236 m_popupInterface
->SetStringValue( m_text
->GetValue() );
2240 // This is neede since focus/selection indication may change when popup is shown
2244 // This must be after SetStringValue
2245 m_popupWinState
= Animating
;
2247 wxRect
popupWinRect( popupX
, popupY
, szp
.x
, szp
.y
);
2250 if ( (m_iFlags
& wxCC_IFLAG_DISABLE_POPUP_ANIM
) ||
2251 AnimateShow( popupWinRect
, showFlags
) )
2253 DoShowPopup( popupWinRect
, showFlags
);
2257 bool wxComboCtrlBase
::AnimateShow( const wxRect
& WXUNUSED(rect
), int WXUNUSED(flags
) )
2262 void wxComboCtrlBase
::DoShowPopup( const wxRect
& rect
, int WXUNUSED(flags
) )
2264 wxWindow
* winPopup
= m_winPopup
;
2266 if ( IsPopupWindowState(Animating
) )
2268 // Make sure the popup window is shown in the right position.
2269 // Should not matter even if animation already did this.
2271 // Some platforms (GTK) may like SetSize and Move to be separate
2272 // (though the bug was probably fixed).
2273 winPopup
->SetSize( rect
);
2275 #if USES_WXPOPUPTRANSIENTWINDOW
2276 if ( m_popupWinType
== POPUPWIN_WXPOPUPTRANSIENTWINDOW
)
2277 ((wxPopupTransientWindow
*)winPopup
)->Popup(m_popup
);
2282 m_popupWinState
= Visible
;
2284 else if ( IsPopupWindowState(Hidden
) )
2286 // Animation was aborted
2288 wxASSERT( !winPopup
->IsShown() );
2290 m_popupWinState
= Hidden
;
2296 void wxComboCtrlBase
::OnPopupDismiss(bool generateEvent
)
2298 // Just in case, avoid double dismiss
2299 if ( IsPopupWindowState(Hidden
) )
2302 // This must be set before focus - otherwise there will be recursive
2303 // OnPopupDismisses.
2304 m_popupWinState
= Hidden
;
2307 m_winPopup
->Disable();
2309 // Inform popup control itself
2310 m_popupInterface
->OnDismiss();
2312 if ( m_popupExtraHandler
)
2313 ((wxComboPopupExtraEventHandler
*)m_popupExtraHandler
)->OnPopupDismiss();
2315 #if INSTALL_TOPLEV_HANDLER
2316 // Remove top level window event handler
2317 if ( m_toplevEvtHandler
)
2319 wxWindow
* toplev
= ::wxGetTopLevelParent( this );
2321 toplev
->RemoveEventHandler( m_toplevEvtHandler
);
2325 m_timeCanAcceptClick
= ::wxGetLocalTimeMillis();
2327 if ( m_popupWinType
== POPUPWIN_WXPOPUPTRANSIENTWINDOW
)
2328 m_timeCanAcceptClick
+= 150;
2330 // If cursor not on dropdown button, then clear its state
2331 // (technically not required by all ports, but do it for all just in case)
2332 if ( !m_btnArea
.Contains(ScreenToClient(::wxGetMousePosition())) )
2335 // Return parent's tab traversal flag.
2336 // See ShowPopup for notes.
2337 if ( m_iFlags
& wxCC_IFLAG_PARENT_TAB_TRAVERSAL
)
2339 wxWindow
* parent
= GetParent();
2340 parent
->SetWindowStyle( parent
->GetWindowStyle() | wxTAB_TRAVERSAL
);
2341 m_iFlags
&= ~(wxCC_IFLAG_PARENT_TAB_TRAVERSAL
);
2344 // refresh control (necessary even if m_text)
2349 if ( generateEvent
)
2351 wxCommandEvent
event(wxEVT_COMMAND_COMBOBOX_CLOSEUP
, GetId());
2352 event
.SetEventObject(this);
2353 HandleWindowEvent(event
);
2357 void wxComboCtrlBase
::HidePopup(bool generateEvent
)
2359 // Should be able to call this without popup interface
2360 if ( IsPopupWindowState(Hidden
) )
2363 // transfer value and show it in textctrl, if any
2364 if ( !IsPopupWindowState(Animating
) )
2365 SetValue( m_popupInterface
->GetStringValue() );
2369 OnPopupDismiss(generateEvent
);
2372 // ----------------------------------------------------------------------------
2373 // customization methods
2374 // ----------------------------------------------------------------------------
2376 void wxComboCtrlBase
::SetButtonPosition( int width
, int height
,
2377 int side
, int spacingX
)
2382 m_btnSpacingX
= spacingX
;
2384 if ( width
> 0 || height
> 0 || spacingX
)
2385 m_iFlags
|= wxCC_IFLAG_HAS_NONSTANDARD_BUTTON
;
2390 wxSize wxComboCtrlBase
::GetButtonSize()
2392 if ( m_btnSize
.x
> 0 )
2395 wxSize
retSize(m_btnWid
,m_btnHei
);
2397 // Need to call CalculateAreas now if button size is
2398 // is not explicitly specified.
2399 if ( retSize
.x
<= 0 || retSize
.y
<= 0)
2403 retSize
= m_btnSize
;
2409 void wxComboCtrlBase
::SetButtonBitmaps( const wxBitmap
& bmpNormal
,
2411 const wxBitmap
& bmpPressed
,
2412 const wxBitmap
& bmpHover
,
2413 const wxBitmap
& bmpDisabled
)
2415 m_bmpNormal
= bmpNormal
;
2416 m_blankButtonBg
= blankButtonBg
;
2418 if ( bmpPressed
.Ok() )
2419 m_bmpPressed
= bmpPressed
;
2421 m_bmpPressed
= bmpNormal
;
2423 if ( bmpHover
.Ok() )
2424 m_bmpHover
= bmpHover
;
2426 m_bmpHover
= bmpNormal
;
2428 if ( bmpDisabled
.Ok() )
2429 m_bmpDisabled
= bmpDisabled
;
2431 m_bmpDisabled
= bmpNormal
;
2436 void wxComboCtrlBase
::SetCustomPaintWidth( int width
)
2440 // move textctrl accordingly
2441 wxRect r
= m_text
->GetRect();
2442 int inc
= width
- m_widthCustomPaint
;
2445 m_text
->SetSize( r
);
2448 m_widthCustomPaint
= width
;
2453 bool wxComboCtrlBase
::DoSetMargins(const wxPoint
& margins
)
2455 // For general sanity's sake, we ignore top margin. Instead
2456 // we will always try to center the text vertically.
2459 if ( margins
.x
!= -1 )
2461 m_marginLeft
= margins
.x
;
2462 m_iFlags
|= wxCC_IFLAG_LEFT_MARGIN_SET
;
2466 m_marginLeft
= GetNativeTextIndent();
2467 m_iFlags
&= ~(wxCC_IFLAG_LEFT_MARGIN_SET
);
2470 if ( margins
.y
!= -1 )
2480 wxPoint wxComboCtrlBase
::DoGetMargins() const
2482 return wxPoint(m_marginLeft
, -1);
2485 #if WXWIN_COMPATIBILITY_2_8
2486 void wxComboCtrlBase
::SetTextIndent( int indent
)
2490 m_marginLeft
= GetNativeTextIndent();
2491 m_iFlags
&= ~(wxCC_IFLAG_LEFT_MARGIN_SET
);
2495 m_marginLeft
= indent
;
2496 m_iFlags
|= wxCC_IFLAG_LEFT_MARGIN_SET
;
2502 wxCoord wxComboCtrlBase
::GetTextIndent() const
2504 return m_marginLeft
;
2508 wxCoord wxComboCtrlBase
::GetNativeTextIndent() const
2510 return DEFAULT_TEXT_INDENT
;
2513 // ----------------------------------------------------------------------------
2514 // methods forwarded to wxTextCtrl
2515 // ----------------------------------------------------------------------------
2517 wxString wxComboCtrlBase
::GetValue() const
2520 return m_text
->GetValue();
2521 return m_valueString
;
2524 void wxComboCtrlBase
::SetValueWithEvent(const wxString
& value
, bool withEvent
)
2531 m_text
->SetValue(value
);
2533 if ( !(m_iFlags
& wxCC_NO_TEXT_AUTO_SELECT
) )
2534 m_text
->SelectAll();
2537 // Since wxComboPopup may want to paint the combo as well, we need
2538 // to set the string value here (as well as sometimes in ShowPopup).
2539 if ( m_valueString
!= value
)
2541 m_valueString
= value
;
2543 EnsurePopupControl();
2545 if (m_popupInterface
)
2546 m_popupInterface
->SetStringValue(value
);
2552 void wxComboCtrlBase
::SetValue(const wxString
& value
)
2554 SetValueWithEvent(value
, false);
2557 // In this SetValue variant wxComboPopup::SetStringValue is not called
2558 void wxComboCtrlBase
::SetText(const wxString
& value
)
2560 // Unlike in SetValue(), this must be called here or
2561 // the behaviour will no be consistent in readonlys.
2562 EnsurePopupControl();
2564 m_valueString
= value
;
2569 m_text
->SetValue( value
);
2575 void wxComboCtrlBase
::Copy()
2581 void wxComboCtrlBase
::Cut()
2587 void wxComboCtrlBase
::Paste()
2593 void wxComboCtrlBase
::SetInsertionPoint(long pos
)
2596 m_text
->SetInsertionPoint(pos
);
2599 void wxComboCtrlBase
::SetInsertionPointEnd()
2602 m_text
->SetInsertionPointEnd();
2605 long wxComboCtrlBase
::GetInsertionPoint() const
2608 return m_text
->GetInsertionPoint();
2613 long wxComboCtrlBase
::GetLastPosition() const
2616 return m_text
->GetLastPosition();
2621 void wxComboCtrlBase
::Replace(long from
, long to
, const wxString
& value
)
2624 m_text
->Replace(from
, to
, value
);
2627 void wxComboCtrlBase
::Remove(long from
, long to
)
2630 m_text
->Remove(from
, to
);
2633 void wxComboCtrlBase
::SetSelection(long from
, long to
)
2636 m_text
->SetSelection(from
, to
);
2639 void wxComboCtrlBase
::Undo()
2645 bool wxComboCtrlBase
::SetHint(const wxString
& hint
)
2650 res
= m_text
->SetHint(hint
);
2655 wxString wxComboCtrlBase
::GetHint() const
2660 #endif // wxUSE_COMBOCTRL