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"
35 #include "wx/dialog.h"
37 #include "wx/textctrl.h"
40 #include "wx/tooltip.h"
47 // ----------------------------------------------------------------------------
49 #define DEFAULT_DROPBUTTON_WIDTH 19
51 #define BMP_BUTTON_MARGIN 4
53 #define DEFAULT_POPUP_HEIGHT 400
55 #define DEFAULT_TEXT_INDENT 3
57 #define COMBO_MARGIN 2 // spacing right of wxTextCtrl
60 #if defined(__WXMSW__)
62 #define USE_TRANSIENT_POPUP 1 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
63 #define TRANSIENT_POPUPWIN_IS_PERFECT 0 // wxPopupTransientWindow works, its child can have focus, and common
64 // native controls work on it like normal.
65 #define POPUPWIN_IS_PERFECT 0 // Same, but for non-transient popup window.
66 #define TEXTCTRL_TEXT_CENTERED 0 // 1 if text in textctrl is vertically centered
67 #define FOCUS_RING 0 // No focus ring on wxMSW
69 //#undef wxUSE_POPUPWIN
70 //#define wxUSE_POPUPWIN 0
72 #elif defined(__WXGTK__)
74 // NB: It is not recommended to use wxDialog as popup on wxGTK, because of
75 // this bug: If wxDialog is hidden, its position becomes corrupt
76 // between hide and next show, but without internal coordinates being
77 // reflected (or something like that - atleast commenting out ->Hide()
78 // seemed to eliminate the position change).
80 #define USE_TRANSIENT_POPUP 1 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
81 #define TRANSIENT_POPUPWIN_IS_PERFECT 0 // wxPopupTransientWindow works, its child can have focus, and common
82 // native controls work on it like normal.
83 #define POPUPWIN_IS_PERFECT 1 // Same, but for non-transient popup window.
84 #define TEXTCTRL_TEXT_CENTERED 1 // 1 if text in textctrl is vertically centered
85 #define FOCUS_RING 0 // No focus ring on wxGTK
87 #elif defined(__WXMAC__)
89 #define USE_TRANSIENT_POPUP 1 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
90 #define TRANSIENT_POPUPWIN_IS_PERFECT 1 // wxPopupTransientWindow works, its child can have focus, and common
91 // native controls work on it like normal.
92 #define POPUPWIN_IS_PERFECT 1 // Same, but for non-transient popup window.
93 #define TEXTCTRL_TEXT_CENTERED 1 // 1 if text in textctrl is vertically centered
94 #define FOCUS_RING 3 // Reserve room for the textctrl's focus ring to display
96 #undef DEFAULT_DROPBUTTON_WIDTH
97 #define DEFAULT_DROPBUTTON_WIDTH 22
99 #define COMBO_MARGIN FOCUS_RING
103 #define USE_TRANSIENT_POPUP 0 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
104 #define TRANSIENT_POPUPWIN_IS_PERFECT 0 // wxPopupTransientWindow works, its child can have focus, and common
105 // native controls work on it like normal.
106 #define POPUPWIN_IS_PERFECT 0 // Same, but for non-transient popup window.
107 #define TEXTCTRL_TEXT_CENTERED 1 // 1 if text in textctrl is vertically centered
113 // Popupwin is really only supported on wxMSW (not WINCE) and wxGTK, regardless
114 // what the wxUSE_POPUPWIN says.
115 // FIXME: Why isn't wxUSE_POPUPWIN reliable any longer? (it was in wxW2.6.2)
116 #if (!defined(__WXMSW__) && !defined(__WXGTK__) && !defined(__WXMAC__)) || defined(__WXWINCE__)
117 #undef wxUSE_POPUPWIN
118 #define wxUSE_POPUPWIN 0
123 #include "wx/popupwin.h"
125 #undef USE_TRANSIENT_POPUP
126 #define USE_TRANSIENT_POPUP 0
130 // Define different types of popup windows
134 POPUPWIN_WXPOPUPTRANSIENTWINDOW
= 1,
135 POPUPWIN_WXPOPUPWINDOW
= 2,
136 POPUPWIN_WXDIALOG
= 3
140 #if USE_TRANSIENT_POPUP
141 // wxPopupTransientWindow is implemented
143 #define wxComboPopupWindowBase wxPopupTransientWindow
144 #define PRIMARY_POPUP_TYPE POPUPWIN_WXPOPUPTRANSIENTWINDOW
145 #define USES_WXPOPUPTRANSIENTWINDOW 1
147 #if TRANSIENT_POPUPWIN_IS_PERFECT
149 #elif POPUPWIN_IS_PERFECT
150 #define wxComboPopupWindowBase2 wxPopupWindow
151 #define SECONDARY_POPUP_TYPE POPUPWIN_WXPOPUPWINDOW
152 #define USES_WXPOPUPWINDOW 1
154 #define wxComboPopupWindowBase2 wxDialog
155 #define SECONDARY_POPUP_TYPE POPUPWIN_WXDIALOG
156 #define USES_WXDIALOG 1
160 // wxPopupWindow (but not wxPopupTransientWindow) is properly implemented
162 #define wxComboPopupWindowBase wxPopupWindow
163 #define PRIMARY_POPUP_TYPE POPUPWIN_WXPOPUPWINDOW
164 #define USES_WXPOPUPWINDOW 1
166 #if !POPUPWIN_IS_PERFECT
167 #define wxComboPopupWindowBase2 wxDialog
168 #define SECONDARY_POPUP_TYPE POPUPWIN_WXDIALOG
169 #define USES_WXDIALOG 1
173 // wxPopupWindow is not implemented
175 #define wxComboPopupWindowBase wxDialog
176 #define PRIMARY_POPUP_TYPE POPUPWIN_WXDIALOG
177 #define USES_WXDIALOG 1
182 #ifndef USES_WXPOPUPTRANSIENTWINDOW
183 #define USES_WXPOPUPTRANSIENTWINDOW 0
186 #ifndef USES_WXPOPUPWINDOW
187 #define USES_WXPOPUPWINDOW 0
190 #ifndef USES_WXDIALOG
191 #define USES_WXDIALOG 0
195 #if USES_WXPOPUPWINDOW
196 #define INSTALL_TOPLEV_HANDLER 1
198 #define INSTALL_TOPLEV_HANDLER 0
204 // * wxComboPopupWindow for external use (ie. replace old wxUniv wxPopupComboWindow)
208 // ----------------------------------------------------------------------------
209 // wxComboFrameEventHandler takes care of hiding the popup when events happen
210 // in its top level parent.
211 // ----------------------------------------------------------------------------
213 #if INSTALL_TOPLEV_HANDLER
216 // This will no longer be necessary after wxTransientPopupWindow
217 // works well on all platforms.
220 class wxComboFrameEventHandler
: public wxEvtHandler
223 wxComboFrameEventHandler( wxComboCtrlBase
* pCb
);
224 virtual ~wxComboFrameEventHandler();
228 void OnIdle( wxIdleEvent
& event
);
229 void OnMouseEvent( wxMouseEvent
& event
);
230 void OnActivate( wxActivateEvent
& event
);
231 void OnResize( wxSizeEvent
& event
);
232 void OnMove( wxMoveEvent
& event
);
233 void OnMenuEvent( wxMenuEvent
& event
);
234 void OnClose( wxCloseEvent
& event
);
237 wxWindow
* m_focusStart
;
238 wxComboCtrlBase
* m_combo
;
241 DECLARE_EVENT_TABLE()
244 BEGIN_EVENT_TABLE(wxComboFrameEventHandler
, wxEvtHandler
)
245 EVT_IDLE(wxComboFrameEventHandler
::OnIdle
)
246 EVT_LEFT_DOWN(wxComboFrameEventHandler
::OnMouseEvent
)
247 EVT_RIGHT_DOWN(wxComboFrameEventHandler
::OnMouseEvent
)
248 EVT_SIZE(wxComboFrameEventHandler
::OnResize
)
249 EVT_MOVE(wxComboFrameEventHandler
::OnMove
)
250 EVT_MENU_HIGHLIGHT(wxID_ANY
,wxComboFrameEventHandler
::OnMenuEvent
)
251 EVT_MENU_OPEN(wxComboFrameEventHandler
::OnMenuEvent
)
252 EVT_ACTIVATE(wxComboFrameEventHandler
::OnActivate
)
253 EVT_CLOSE(wxComboFrameEventHandler
::OnClose
)
256 wxComboFrameEventHandler
::wxComboFrameEventHandler( wxComboCtrlBase
* combo
)
262 wxComboFrameEventHandler
::~wxComboFrameEventHandler()
266 void wxComboFrameEventHandler
::OnPopup()
268 m_focusStart
= ::wxWindow
::FindFocus();
271 void wxComboFrameEventHandler
::OnIdle( wxIdleEvent
& event
)
273 wxWindow
* winFocused
= ::wxWindow
::FindFocus();
275 wxWindow
* popup
= m_combo
->GetPopupControl()->GetControl();
276 wxWindow
* winpopup
= m_combo
->GetPopupWindow();
279 winFocused
!= m_focusStart
&&
280 winFocused
!= popup
&&
281 winFocused
->GetParent() != popup
&&
282 winFocused
!= winpopup
&&
283 winFocused
->GetParent() != winpopup
&&
284 winFocused
!= m_combo
&&
285 winFocused
!= m_combo
->GetButton() // GTK (atleast) requires this
288 m_combo
->HidePopup();
294 void wxComboFrameEventHandler
::OnMenuEvent( wxMenuEvent
& event
)
296 m_combo
->HidePopup();
300 void wxComboFrameEventHandler
::OnMouseEvent( wxMouseEvent
& event
)
302 m_combo
->HidePopup();
306 void wxComboFrameEventHandler
::OnClose( wxCloseEvent
& event
)
308 m_combo
->HidePopup();
312 void wxComboFrameEventHandler
::OnActivate( wxActivateEvent
& event
)
314 m_combo
->HidePopup();
318 void wxComboFrameEventHandler
::OnResize( wxSizeEvent
& event
)
320 m_combo
->HidePopup();
324 void wxComboFrameEventHandler
::OnMove( wxMoveEvent
& event
)
326 m_combo
->HidePopup();
330 #endif // INSTALL_TOPLEV_HANDLER
332 // ----------------------------------------------------------------------------
333 // wxComboPopupWindow is, in essence, wxPopupWindow customized for
335 // ----------------------------------------------------------------------------
337 class wxComboPopupWindow
: public wxComboPopupWindowBase
341 wxComboPopupWindow( wxComboCtrlBase
*parent
,
343 #if USES_WXPOPUPWINDOW || USES_WXPOPUPTRANSIENTWINDOW
344 : wxComboPopupWindowBase(parent
,style
)
346 : wxComboPopupWindowBase(parent
,
357 #if USES_WXPOPUPTRANSIENTWINDOW
358 virtual bool Show( bool show
);
359 virtual bool ProcessLeftDown(wxMouseEvent
& event
);
361 virtual void OnDismiss();
369 #if USES_WXPOPUPTRANSIENTWINDOW
370 bool wxComboPopupWindow
::Show( bool show
)
372 // Guard against recursion
374 return wxComboPopupWindowBase
::Show(show
);
378 wxASSERT( IsKindOf(CLASSINFO(wxPopupTransientWindow
)) );
380 wxPopupTransientWindow
* ptw
= (wxPopupTransientWindow
*) this;
382 if ( show
!= ptw
->IsShown() )
385 // We used to do wxPopupTransientWindow::Popup here,
386 // but this would hide normal Show, which we are
387 // also going to need.
398 bool wxComboPopupWindow
::ProcessLeftDown(wxMouseEvent
& event
)
400 return wxPopupTransientWindow
::ProcessLeftDown(event
);
403 // First thing that happens when a transient popup closes is that this method gets called.
404 void wxComboPopupWindow
::OnDismiss()
406 wxComboCtrlBase
* combo
= (wxComboCtrlBase
*) GetParent();
407 wxASSERT_MSG( combo
->IsKindOf(CLASSINFO(wxComboCtrlBase
)),
408 wxT("parent might not be wxComboCtrl, but check IMPLEMENT_DYNAMIC_CLASS(2) macro for correctness") );
410 combo
->OnPopupDismiss();
412 #endif // USES_WXPOPUPTRANSIENTWINDOW
415 // ----------------------------------------------------------------------------
416 // wxComboPopupWindowEvtHandler does bulk of the custom event handling
417 // of a popup window. It is separate so we can have different types
419 // ----------------------------------------------------------------------------
421 class wxComboPopupWindowEvtHandler
: public wxEvtHandler
425 wxComboPopupWindowEvtHandler( wxComboCtrlBase
*parent
)
430 void OnSizeEvent( wxSizeEvent
& event
);
431 void OnKeyEvent(wxKeyEvent
& event
);
433 void OnActivate( wxActivateEvent
& event
);
437 wxComboCtrlBase
* m_combo
;
439 DECLARE_EVENT_TABLE()
443 BEGIN_EVENT_TABLE(wxComboPopupWindowEvtHandler
, wxEvtHandler
)
444 EVT_KEY_DOWN(wxComboPopupWindowEvtHandler
::OnKeyEvent
)
445 EVT_KEY_UP(wxComboPopupWindowEvtHandler
::OnKeyEvent
)
447 EVT_ACTIVATE(wxComboPopupWindowEvtHandler
::OnActivate
)
449 EVT_SIZE(wxComboPopupWindowEvtHandler
::OnSizeEvent
)
453 void wxComboPopupWindowEvtHandler
::OnSizeEvent( wxSizeEvent
& WXUNUSED(event
) )
455 // Block the event so that the popup control does not get auto-resized.
458 void wxComboPopupWindowEvtHandler
::OnKeyEvent( wxKeyEvent
& event
)
460 // Relay keyboard event to the main child controls
461 wxWindowList children
= m_combo
->GetPopupWindow()->GetChildren();
462 wxWindowList
::iterator node
= children
.begin();
463 wxWindow
* child
= (wxWindow
*)*node
;
464 child
->GetEventHandler()->AddPendingEvent(event
);
468 void wxComboPopupWindowEvtHandler
::OnActivate( wxActivateEvent
& event
)
470 if ( !event
.GetActive() )
472 // Tell combo control that we are dismissed.
473 m_combo
->HidePopup();
481 // ----------------------------------------------------------------------------
484 // ----------------------------------------------------------------------------
486 wxComboPopup
::~wxComboPopup()
490 void wxComboPopup
::OnPopup()
494 void wxComboPopup
::OnDismiss()
498 wxSize wxComboPopup
::GetAdjustedSize( int minWidth
,
500 int WXUNUSED(maxHeight
) )
502 return wxSize(minWidth
,prefHeight
);
505 void wxComboPopup
::DefaultPaintComboControl( wxComboCtrlBase
* combo
,
506 wxDC
& dc
, const wxRect
& rect
)
508 if ( combo
->GetWindowStyle() & wxCB_READONLY
) // ie. no textctrl
510 combo
->PrepareBackground(dc
,rect
,0);
512 dc
.DrawText( combo
->GetValue(),
513 rect
.x
+ combo
->GetTextIndent(),
514 (rect
.height
-dc
.GetCharHeight())/2 + rect
.y
);
518 void wxComboPopup
::PaintComboControl( wxDC
& dc
, const wxRect
& rect
)
520 DefaultPaintComboControl(m_combo
,dc
,rect
);
523 void wxComboPopup
::OnComboKeyEvent( wxKeyEvent
& event
)
528 void wxComboPopup
::OnComboDoubleClick()
532 void wxComboPopup
::SetStringValue( const wxString
& WXUNUSED(value
) )
536 bool wxComboPopup
::LazyCreate()
541 void wxComboPopup
::Dismiss()
543 m_combo
->HidePopup();
546 // ----------------------------------------------------------------------------
548 // ----------------------------------------------------------------------------
551 // This is pushed to the event handler queue of the child textctrl.
553 class wxComboBoxExtraInputHandler
: public wxEvtHandler
557 wxComboBoxExtraInputHandler( wxComboCtrlBase
* combo
)
562 virtual ~wxComboBoxExtraInputHandler() { }
563 void OnKey(wxKeyEvent
& event
);
564 void OnFocus(wxFocusEvent
& event
);
567 wxComboCtrlBase
* m_combo
;
570 DECLARE_EVENT_TABLE()
574 BEGIN_EVENT_TABLE(wxComboBoxExtraInputHandler
, wxEvtHandler
)
575 EVT_KEY_DOWN(wxComboBoxExtraInputHandler
::OnKey
)
576 EVT_KEY_UP(wxComboBoxExtraInputHandler
::OnKey
)
577 EVT_CHAR(wxComboBoxExtraInputHandler
::OnKey
)
578 EVT_SET_FOCUS(wxComboBoxExtraInputHandler
::OnFocus
)
579 EVT_KILL_FOCUS(wxComboBoxExtraInputHandler
::OnFocus
)
583 void wxComboBoxExtraInputHandler
::OnKey(wxKeyEvent
& event
)
585 // Let the wxComboCtrl event handler have a go first.
586 wxComboCtrlBase
* combo
= m_combo
;
587 wxObject
* prevObj
= event
.GetEventObject();
589 event
.SetId(combo
->GetId());
590 event
.SetEventObject(combo
);
591 combo
->GetEventHandler()->ProcessEvent(event
);
593 event
.SetId(((wxWindow
*)prevObj
)->GetId());
594 event
.SetEventObject(prevObj
);
597 void wxComboBoxExtraInputHandler
::OnFocus(wxFocusEvent
& event
)
599 // FIXME: This code does run when control is clicked,
600 // yet on Windows it doesn't select all the text.
601 if ( event
.GetEventType() == wxEVT_SET_FOCUS
&&
602 !(m_combo
->GetInternalFlags() & wxCC_NO_TEXT_AUTO_SELECT
) )
604 if ( m_combo
->GetTextCtrl() )
605 m_combo
->GetTextCtrl()->SelectAll();
607 m_combo
->SetSelection(-1,-1);
610 // Send focus indication to parent.
611 // NB: This is needed for cases where the textctrl gets focus
612 // instead of its parent. While this may trigger multiple
613 // wxEVT_SET_FOCUSes (since m_text->SetFocus is called
614 // from combo's focus event handler), they should be quite
616 wxFocusEvent
evt2(event
.GetEventType(),m_combo
->GetId());
617 evt2
.SetEventObject(m_combo
);
618 m_combo
->GetEventHandler()->ProcessEvent(evt2
);
625 // This is pushed to the event handler queue of the control in popup.
628 class wxComboPopupExtraEventHandler
: public wxEvtHandler
632 wxComboPopupExtraEventHandler( wxComboCtrlBase
* combo
)
636 m_beenInside
= false;
638 virtual ~wxComboPopupExtraEventHandler() { }
640 void OnMouseEvent( wxMouseEvent
& event
);
642 // Called from wxComboCtrlBase::OnPopupDismiss
643 void OnPopupDismiss()
645 m_beenInside
= false;
649 wxComboCtrlBase
* m_combo
;
654 DECLARE_EVENT_TABLE()
658 BEGIN_EVENT_TABLE(wxComboPopupExtraEventHandler
, wxEvtHandler
)
659 EVT_MOUSE_EVENTS(wxComboPopupExtraEventHandler
::OnMouseEvent
)
663 void wxComboPopupExtraEventHandler
::OnMouseEvent( wxMouseEvent
& event
)
665 wxPoint pt
= event
.GetPosition();
666 wxSize sz
= m_combo
->GetPopupControl()->GetControl()->GetClientSize();
667 int evtType
= event
.GetEventType();
668 bool isInside
= pt
.x
>= 0 && pt
.y
>= 0 && pt
.x
< sz
.x
&& pt
.y
< sz
.y
;
669 bool relayToButton
= false;
673 if ( evtType
== wxEVT_MOTION
||
674 evtType
== wxEVT_LEFT_DOWN
||
675 evtType
== wxEVT_RIGHT_DOWN
)
677 // Block motion and click events outside the popup
678 if ( !isInside
|| !m_combo
->IsPopupShown() )
683 else if ( evtType
== wxEVT_LEFT_UP
)
685 if ( !m_combo
->IsPopupShown() )
688 relayToButton
= true;
690 else if ( !m_beenInside
)
698 relayToButton
= true;
706 // Some mouse events to popup that happen outside it, before cursor
707 // has been inside the popup, need to be ignored by it but relayed to
710 wxWindow
* eventSink
= m_combo
;
711 wxWindow
* btn
= m_combo
->GetButton();
715 eventSink
->GetEventHandler()->ProcessEvent(event
);
719 // ----------------------------------------------------------------------------
720 // wxComboCtrlTextCtrl
721 // ----------------------------------------------------------------------------
723 class wxComboCtrlTextCtrl
: public wxTextCtrl
726 wxComboCtrlTextCtrl() : wxTextCtrl() { }
727 virtual ~wxComboCtrlTextCtrl() { }
729 virtual wxWindow
*GetMainWindowOfCompositeControl()
731 wxComboCtrl
* combo
= (wxComboCtrl
*) GetParent();
733 // Returning this instead of just 'parent' lets FindFocus work
734 // correctly even when parent control is a child of a composite
735 // generic control (as is case with wxGenericDatePickerCtrl).
736 return combo
->GetMainWindowOfCompositeControl();
740 // ----------------------------------------------------------------------------
742 // ----------------------------------------------------------------------------
745 BEGIN_EVENT_TABLE(wxComboCtrlBase
, wxControl
)
746 EVT_TEXT(wxID_ANY
,wxComboCtrlBase
::OnTextCtrlEvent
)
747 EVT_SIZE(wxComboCtrlBase
::OnSizeEvent
)
748 EVT_SET_FOCUS(wxComboCtrlBase
::OnFocusEvent
)
749 EVT_KILL_FOCUS(wxComboCtrlBase
::OnFocusEvent
)
750 EVT_IDLE(wxComboCtrlBase
::OnIdleEvent
)
751 //EVT_BUTTON(wxID_ANY,wxComboCtrlBase::OnButtonClickEvent)
752 EVT_KEY_DOWN(wxComboCtrlBase
::OnKeyEvent
)
753 EVT_TEXT_ENTER(wxID_ANY
,wxComboCtrlBase
::OnTextCtrlEvent
)
754 EVT_SYS_COLOUR_CHANGED(wxComboCtrlBase
::OnSysColourChanged
)
758 IMPLEMENT_ABSTRACT_CLASS(wxComboCtrlBase
, wxControl
)
760 void wxComboCtrlBase
::Init()
764 m_popupWinState
= Hidden
;
767 m_popupInterface
= NULL
;
769 m_popupExtraHandler
= NULL
;
770 m_textEvtHandler
= NULL
;
772 #if INSTALL_TOPLEV_HANDLER
773 m_toplevEvtHandler
= NULL
;
776 m_mainCtrlWnd
= this;
779 m_widthMinPopup
= -1;
781 m_widthCustomPaint
= 0;
782 m_widthCustomBorder
= 0;
786 m_blankButtonBg
= false;
788 m_popupWinType
= POPUPWIN_NONE
;
789 m_btnWid
= m_btnHei
= -1;
797 m_timeCanAcceptClick
= 0;
799 m_resetFocus
= false;
802 bool wxComboCtrlBase
::Create(wxWindow
*parent
,
804 const wxString
& value
,
808 const wxValidator
& validator
,
809 const wxString
& name
)
811 if ( !wxControl
::Create(parent
,
815 style
| wxWANTS_CHARS
,
820 m_valueString
= value
;
824 m_absIndent
= GetNativeTextIndent();
826 m_iFlags
|= wxCC_IFLAG_CREATED
;
828 // If x and y indicate valid size, wxSizeEvent won't be
829 // emitted automatically, so we need to add artifical one.
830 if ( size
.x
> 0 && size
.y
> 0 )
832 wxSizeEvent
evt(size
,GetId());
833 GetEventHandler()->AddPendingEvent(evt
);
839 void wxComboCtrlBase
::InstallInputHandlers()
843 m_textEvtHandler
= new wxComboBoxExtraInputHandler(this);
844 m_text
->PushEventHandler(m_textEvtHandler
);
849 wxComboCtrlBase
::CreateTextCtrl(int style
, const wxValidator
& validator
)
851 if ( !(m_windowStyle
& wxCB_READONLY
) )
856 // wxTE_PROCESS_TAB is needed because on Windows, wxTAB_TRAVERSAL is
857 // not used by the wxPropertyGrid and therefore the tab is processed by
858 // looking at ancestors to see if they have wxTAB_TRAVERSAL. The
859 // navigation event is then sent to the wrong window.
860 style
|= wxTE_PROCESS_TAB
;
862 if ( HasFlag(wxTE_PROCESS_ENTER
) )
863 style
|= wxTE_PROCESS_ENTER
;
865 // Ignore EVT_TEXT generated by the constructor (but only
866 // if the event redirector already exists)
867 // NB: This must be " = 1" instead of "++";
868 if ( m_textEvtHandler
)
873 m_text
= new wxComboCtrlTextCtrl();
874 m_text
->Create(this, wxID_ANY
, m_valueString
,
875 wxDefaultPosition
, wxSize(10,-1),
880 void wxComboCtrlBase
::OnThemeChange()
882 // Leave the default bg on the Mac so the area used by the focus ring will
883 // be the correct colour and themed brush. Instead we'll use
884 // wxSYS_COLOUR_WINDOW in the EVT_PAINT handler as needed.
886 SetOwnBackgroundColour(wxSystemSettings
::GetColour(wxSYS_COLOUR_WINDOW
));
890 wxComboCtrlBase
::~wxComboCtrlBase()
895 #if INSTALL_TOPLEV_HANDLER
896 delete ((wxComboFrameEventHandler
*)m_toplevEvtHandler
);
897 m_toplevEvtHandler
= NULL
;
903 m_text
->RemoveEventHandler(m_textEvtHandler
);
905 delete m_textEvtHandler
;
909 // ----------------------------------------------------------------------------
911 // ----------------------------------------------------------------------------
913 // Recalculates button and textctrl areas
914 void wxComboCtrlBase
::CalculateAreas( int btnWidth
)
916 wxSize sz
= GetClientSize();
917 int customBorder
= m_widthCustomBorder
;
918 int btnBorder
; // border for button only
920 // check if button should really be outside the border: we'll do it it if
921 // its platform default or bitmap+pushbutton background is used, but not if
922 // there is vertical size adjustment or horizontal spacing.
923 if ( ( (m_iFlags
& wxCC_BUTTON_OUTSIDE_BORDER
) ||
924 (m_bmpNormal
.Ok() && m_blankButtonBg
) ) &&
925 m_btnSpacingX
== 0 &&
928 m_iFlags
|= wxCC_IFLAG_BUTTON_OUTSIDE
;
931 else if ( (m_iFlags
& wxCC_BUTTON_COVERS_BORDER
) &&
932 m_btnSpacingX
== 0 && !m_bmpNormal
.Ok() )
934 m_iFlags
&= ~(wxCC_IFLAG_BUTTON_OUTSIDE
);
939 m_iFlags
&= ~(wxCC_IFLAG_BUTTON_OUTSIDE
);
940 btnBorder
= customBorder
;
943 // Defaul indentation
944 if ( m_absIndent
< 0 )
945 m_absIndent
= GetNativeTextIndent();
947 int butWidth
= btnWidth
;
950 butWidth
= m_btnWidDefault
;
952 m_btnWidDefault
= butWidth
;
957 int butHeight
= sz
.y
- btnBorder
*2;
959 // Adjust button width
964 // Adjust button width to match aspect ratio
965 // (but only if control is smaller than best size).
966 int bestHeight
= GetBestSize().y
;
967 int height
= GetSize().y
;
969 if ( height
< bestHeight
)
971 // Make very small buttons square, as it makes
972 // them accommodate arrow image better and still
975 butWidth
= (height
*butWidth
)/bestHeight
;
977 butWidth
= butHeight
;
981 // Adjust button height
983 butHeight
= m_btnHei
;
985 // Use size of normal bitmap if...
988 // button width is set to default and blank button bg is not drawn
989 if ( m_bmpNormal
.Ok() )
991 int bmpReqWidth
= m_bmpNormal
.GetWidth();
992 int bmpReqHeight
= m_bmpNormal
.GetHeight();
994 // If drawing blank button background, we need to add some margin.
995 if ( m_blankButtonBg
)
997 bmpReqWidth
+= BMP_BUTTON_MARGIN
*2;
998 bmpReqHeight
+= BMP_BUTTON_MARGIN
*2;
1001 if ( butWidth
< bmpReqWidth
|| ( m_btnWid
== 0 && !m_blankButtonBg
) )
1002 butWidth
= bmpReqWidth
;
1003 if ( butHeight
< bmpReqHeight
|| ( m_btnHei
== 0 && !m_blankButtonBg
) )
1004 butHeight
= bmpReqHeight
;
1006 // Need to fix height?
1007 if ( (sz
.y
-(customBorder
*2)) < butHeight
&& btnWidth
== 0 )
1009 int newY
= butHeight
+(customBorder
*2);
1010 SetClientSize(wxDefaultCoord
,newY
);
1011 if ( m_bmpNormal
.Ok() || m_btnArea
.width
!= butWidth
|| m_btnArea
.height
!= butHeight
)
1012 m_iFlags
|= wxCC_IFLAG_HAS_NONSTANDARD_BUTTON
;
1014 m_iFlags
&= ~wxCC_IFLAG_HAS_NONSTANDARD_BUTTON
;
1020 int butAreaWid
= butWidth
+ (m_btnSpacingX
*2);
1022 m_btnSize
.x
= butWidth
;
1023 m_btnSize
.y
= butHeight
;
1025 m_btnArea
.x
= ( m_btnSide
==wxRIGHT ? sz
.x
- butAreaWid
- btnBorder
: btnBorder
);
1026 m_btnArea
.y
= btnBorder
+ FOCUS_RING
;
1027 m_btnArea
.width
= butAreaWid
;
1028 m_btnArea
.height
= sz
.y
- ((btnBorder
+FOCUS_RING
)*2);
1030 m_tcArea
.x
= ( m_btnSide
==wxRIGHT ?
0 : butAreaWid
) + customBorder
+ FOCUS_RING
;
1031 m_tcArea
.y
= customBorder
+ FOCUS_RING
;
1032 m_tcArea
.width
= sz
.x
- butAreaWid
- (customBorder
*2) - (FOCUS_RING
*2);
1033 m_tcArea
.height
= sz
.y
- ((customBorder
+FOCUS_RING
)*2);
1038 ::wxMessageBox(wxString::Format(wxT("ButtonArea (%i,%i,%i,%i)\n"),m_btnArea.x,m_btnArea.y,m_btnArea.width,m_btnArea.height) +
1039 wxString::Format(wxT("TextCtrlArea (%i,%i,%i,%i)"),m_tcArea.x,m_tcArea.y,m_tcArea.width,m_tcArea.height));
1044 void wxComboCtrlBase
::PositionTextCtrl( int textCtrlXAdjust
, int textCtrlYAdjust
)
1049 #if !TEXTCTRL_TEXT_CENTERED
1051 wxSize sz
= GetClientSize();
1053 int customBorder
= m_widthCustomBorder
;
1054 if ( (m_text
->GetWindowStyleFlag() & wxBORDER_MASK
) == wxNO_BORDER
)
1057 int tcSizeY
= m_text
->GetBestSize().y
;
1058 int diff
= sz
.y
- tcSizeY
;
1059 int y
= textCtrlYAdjust
+ (diff
/2);
1061 if ( y
< customBorder
)
1064 m_text
->SetSize( m_tcArea
.x
+ m_widthCustomPaint
+ m_absIndent
+ textCtrlXAdjust
,
1066 m_tcArea
.width
- COMBO_MARGIN
-
1067 (textCtrlXAdjust
+ m_widthCustomPaint
+ m_absIndent
),
1070 // Make sure textctrl doesn't exceed the bottom custom border
1071 wxSize tsz
= m_text
->GetSize();
1072 diff
= (y
+ tsz
.y
) - (sz
.y
- customBorder
);
1075 tsz
.y
= tsz
.y
- diff
- 1;
1076 m_text
->SetSize(tsz
);
1080 #else // TEXTCTRL_TEXT_CENTERED
1081 wxUnusedVar(textCtrlXAdjust
);
1082 wxUnusedVar(textCtrlYAdjust
);
1083 #endif // !TEXTCTRL_TEXT_CENTERED/TEXTCTRL_TEXT_CENTERED
1085 // If it has border, have textctrl will the entire text field.
1086 m_text
->SetSize( m_tcArea
.x
+ m_widthCustomPaint
,
1088 m_tcArea
.width
- m_widthCustomPaint
,
1093 wxSize wxComboCtrlBase
::DoGetBestSize() const
1095 wxSize
sizeText(150,0);
1098 sizeText
= m_text
->GetBestSize();
1100 // TODO: Better method to calculate close-to-native control height.
1104 fhei
= (m_font
.GetPointSize()*2) + 5;
1105 else if ( wxNORMAL_FONT
->Ok() )
1106 fhei
= (wxNORMAL_FONT
->GetPointSize()*2) + 5;
1108 fhei
= sizeText
.y
+ 4;
1110 // Need to force height to accomodate bitmap?
1111 int btnSizeY
= m_btnSize
.y
;
1112 if ( m_bmpNormal
.Ok() && fhei
< btnSizeY
)
1115 // Control height doesn't depend on border
1118 int border = m_windowStyle & wxBORDER_MASK;
1119 if ( border == wxSIMPLE_BORDER )
1121 else if ( border == wxNO_BORDER )
1122 fhei += (m_widthCustomBorder*2);
1128 // Final adjustments
1134 // these are the numbers from the HIG:
1135 switch ( m_windowVariant
)
1137 case wxWINDOW_VARIANT_NORMAL
:
1141 case wxWINDOW_VARIANT_SMALL
:
1144 case wxWINDOW_VARIANT_MINI
:
1150 fhei
+= 2 * FOCUS_RING
;
1151 int width
= sizeText
.x
+ FOCUS_RING
+ COMBO_MARGIN
+ DEFAULT_DROPBUTTON_WIDTH
;
1153 wxSize
ret(width
, fhei
);
1158 void wxComboCtrlBase
::OnSizeEvent( wxSizeEvent
& event
)
1163 // defined by actual wxComboCtrls
1169 // ----------------------------------------------------------------------------
1170 // standard operations
1171 // ----------------------------------------------------------------------------
1173 bool wxComboCtrlBase
::Enable(bool enable
)
1175 if ( !wxControl
::Enable(enable
) )
1179 m_btn
->Enable(enable
);
1181 m_text
->Enable(enable
);
1188 bool wxComboCtrlBase
::Show(bool show
)
1190 if ( !wxControl
::Show(show
) )
1202 bool wxComboCtrlBase
::SetFont ( const wxFont
& font
)
1204 if ( !wxControl
::SetFont(font
) )
1208 m_text
->SetFont(font
);
1214 void wxComboCtrlBase
::DoSetToolTip(wxToolTip
*tooltip
)
1216 wxControl
::DoSetToolTip(tooltip
);
1218 // Set tool tip for button and text box
1221 const wxString
&tip
= tooltip
->GetTip();
1222 if ( m_text
) m_text
->SetToolTip(tip
);
1223 if ( m_btn
) m_btn
->SetToolTip(tip
);
1227 if ( m_text
) m_text
->SetToolTip( NULL
);
1228 if ( m_btn
) m_btn
->SetToolTip( NULL
);
1231 #endif // wxUSE_TOOLTIPS
1233 #if wxUSE_VALIDATORS
1234 void wxComboCtrlBase
::SetValidator(const wxValidator
& validator
)
1236 wxTextCtrl
* textCtrl
= GetTextCtrl();
1239 textCtrl
->SetValidator( validator
);
1241 wxControl
::SetValidator( validator
);
1244 wxValidator
* wxComboCtrlBase
::GetValidator()
1246 wxTextCtrl
* textCtrl
= GetTextCtrl();
1248 return textCtrl ? textCtrl
->GetValidator() : wxControl
::GetValidator();
1250 #endif // wxUSE_VALIDATORS
1252 // ----------------------------------------------------------------------------
1254 // ----------------------------------------------------------------------------
1256 #if (!defined(__WXMSW__)) || defined(__WXUNIVERSAL__)
1257 // prepare combo box background on area in a way typical on platform
1258 void wxComboCtrlBase
::PrepareBackground( wxDC
& dc
, const wxRect
& rect
, int flags
) const
1260 wxSize sz
= GetClientSize();
1262 bool doDrawFocusRect
; // also selected
1264 // For smaller size control (and for disabled background) use less spacing
1268 if ( !(flags
& wxCONTROL_ISSUBMENU
) )
1271 isEnabled
= IsEnabled();
1272 doDrawFocusRect
= ShouldDrawFocus() && !(m_iFlags
& wxCC_FULL_BUTTON
);
1274 // Windows-style: for smaller size control (and for disabled background) use less spacing
1275 focusSpacingX
= isEnabled ?
2 : 1;
1276 focusSpacingY
= sz
.y
> (GetCharHeight()+2) && isEnabled ?
2 : 1;
1280 // Drawing a list item
1281 isEnabled
= true; // they are never disabled
1282 doDrawFocusRect
= (flags
& wxCONTROL_SELECTED
) != 0;
1288 // Set the background sub-rectangle for selection, disabled etc
1289 wxRect
selRect(rect
);
1290 selRect
.y
+= focusSpacingY
;
1291 selRect
.height
-= (focusSpacingY
*2);
1295 if ( !(flags
& wxCONTROL_ISSUBMENU
) )
1296 wcp
+= m_widthCustomPaint
;
1298 selRect
.x
+= wcp
+ focusSpacingX
;
1299 selRect
.width
-= wcp
+ (focusSpacingX
*2);
1302 bool doDrawSelRect
= true;
1306 // If popup is hidden and this control is focused,
1307 // then draw the focus-indicator (selbgcolor background etc.).
1308 if ( doDrawFocusRect
)
1310 dc
.SetTextForeground( wxSystemSettings
::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT
) );
1311 bgCol
= wxSystemSettings
::GetColour(wxSYS_COLOUR_HIGHLIGHT
);
1315 dc
.SetTextForeground( wxSystemSettings
::GetColour(wxSYS_COLOUR_WINDOWTEXT
) );
1316 #ifndef __WXMAC__ // see note in OnThemeChange
1317 doDrawSelRect
= false;
1318 bgCol
= GetBackgroundColour();
1320 bgCol
= wxSystemSettings
::GetColour(wxSYS_COLOUR_WINDOW
);
1326 dc
.SetTextForeground( wxSystemSettings
::GetColour(wxSYS_COLOUR_GRAYTEXT
) );
1327 #ifndef __WXMAC__ // see note in OnThemeChange
1328 bgCol
= GetBackgroundColour();
1330 bgCol
= wxSystemSettings
::GetColour(wxSYS_COLOUR_WINDOW
);
1334 dc
.SetBrush( bgCol
);
1335 if ( doDrawSelRect
)
1338 dc
.DrawRectangle( selRect
);
1341 // Don't clip exactly to the selection rectangle so we can draw
1342 // to the non-selected area in front of it.
1343 wxRect
clipRect(rect
.x
,rect
.y
,
1344 (selRect
.x
+selRect
.width
)-rect
.x
,rect
.height
);
1345 dc
.SetClippingRegion(clipRect
);
1348 // Save the library size a bit for platforms that re-implement this.
1349 void wxComboCtrlBase
::PrepareBackground( wxDC
&, const wxRect
&, int ) const
1354 void wxComboCtrlBase
::DrawButton( wxDC
& dc
, const wxRect
& rect
, int flags
)
1356 int drawState
= m_btnState
;
1358 if ( (m_iFlags
& wxCC_BUTTON_STAYS_DOWN
) &&
1359 GetPopupWindowState() >= Animating
)
1360 drawState
|= wxCONTROL_PRESSED
;
1362 wxRect
drawRect(rect
.x
+m_btnSpacingX
,
1363 rect
.y
+((rect
.height
-m_btnSize
.y
)/2),
1367 // Make sure area is not larger than the control
1368 if ( drawRect
.y
< rect
.y
)
1369 drawRect
.y
= rect
.y
;
1370 if ( drawRect
.height
> rect
.height
)
1371 drawRect
.height
= rect
.height
;
1373 bool enabled
= IsEnabled();
1376 drawState
|= wxCONTROL_DISABLED
;
1378 if ( !m_bmpNormal
.Ok() )
1380 if ( flags
& Button_BitmapOnly
)
1383 // Need to clear button background even if m_btn is present
1384 if ( flags
& Button_PaintBackground
)
1388 if ( m_iFlags
& wxCC_IFLAG_BUTTON_OUTSIDE
)
1389 bgCol
= GetParent()->GetBackgroundColour();
1391 bgCol
= GetBackgroundColour();
1395 dc
.DrawRectangle(rect
);
1398 // Draw standard button
1399 wxRendererNative
::Get().DrawComboBoxDropButton(this,
1411 pBmp
= &m_bmpDisabled
;
1412 else if ( m_btnState
& wxCONTROL_PRESSED
)
1413 pBmp
= &m_bmpPressed
;
1414 else if ( m_btnState
& wxCONTROL_CURRENT
)
1417 pBmp
= &m_bmpNormal
;
1419 if ( m_blankButtonBg
)
1421 // If using blank button background, we need to clear its background
1422 // with button face colour instead of colour for rest of the control.
1423 if ( flags
& Button_PaintBackground
)
1425 wxColour bgCol
= GetParent()->GetBackgroundColour(); //wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
1426 //wxColour bgCol = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
1429 dc
.DrawRectangle(rect
);
1432 if ( !(flags
& Button_BitmapOnly
) )
1434 wxRendererNative
::Get().DrawPushButton(this,
1443 // Need to clear button background even if m_btn is present
1444 // (assume non-button background was cleared just before this call so brushes are good)
1445 if ( flags
& Button_PaintBackground
)
1446 dc
.DrawRectangle(rect
);
1449 // Draw bitmap centered in drawRect
1450 dc
.DrawBitmap(*pBmp
,
1451 drawRect
.x
+ (drawRect
.width
-pBmp
->GetWidth())/2,
1452 drawRect
.y
+ (drawRect
.height
-pBmp
->GetHeight())/2,
1457 void wxComboCtrlBase
::RecalcAndRefresh()
1461 wxSizeEvent
evt(GetSize(),GetId());
1462 GetEventHandler()->ProcessEvent(evt
);
1467 // ----------------------------------------------------------------------------
1468 // miscellaneous event handlers
1469 // ----------------------------------------------------------------------------
1471 void wxComboCtrlBase
::OnTextCtrlEvent(wxCommandEvent
& event
)
1473 if ( event
.GetEventType() == wxEVT_COMMAND_TEXT_UPDATED
)
1475 if ( m_ignoreEvtText
> 0 )
1482 // Change event id, object and string before relaying it forward
1483 event
.SetId(GetId());
1484 wxString s
= event
.GetString();
1485 event
.SetEventObject(this);
1490 // call if cursor is on button area or mouse is captured for the button
1491 bool wxComboCtrlBase
::HandleButtonMouseEvent( wxMouseEvent
& event
,
1494 int type
= event
.GetEventType();
1496 if ( type
== wxEVT_MOTION
)
1498 if ( (flags
& wxCC_MF_ON_BUTTON
) &&
1499 IsPopupWindowState(Hidden
) )
1501 if ( !(m_btnState
& wxCONTROL_CURRENT
) )
1503 // Mouse hover begins
1504 m_btnState
|= wxCONTROL_CURRENT
;
1505 if ( HasCapture() ) // Retain pressed state.
1506 m_btnState
|= wxCONTROL_PRESSED
;
1510 else if ( (m_btnState
& wxCONTROL_CURRENT
) )
1513 m_btnState
&= ~(wxCONTROL_CURRENT
|wxCONTROL_PRESSED
);
1517 else if ( type
== wxEVT_LEFT_DOWN
|| type
== wxEVT_LEFT_DCLICK
)
1519 if ( flags
& (wxCC_MF_ON_CLICK_AREA
|wxCC_MF_ON_BUTTON
) )
1521 m_btnState
|= wxCONTROL_PRESSED
;
1524 if ( !(m_iFlags
& wxCC_POPUP_ON_MOUSE_UP
) )
1527 // If showing popup now, do not capture mouse or there will be interference
1531 else if ( type
== wxEVT_LEFT_UP
)
1534 // Only accept event if mouse was left-press was previously accepted
1538 if ( m_btnState
& wxCONTROL_PRESSED
)
1540 // If mouse was inside, fire the click event.
1541 if ( m_iFlags
& wxCC_POPUP_ON_MOUSE_UP
)
1543 if ( flags
& (wxCC_MF_ON_CLICK_AREA
|wxCC_MF_ON_BUTTON
) )
1547 m_btnState
&= ~(wxCONTROL_PRESSED
);
1551 else if ( type
== wxEVT_LEAVE_WINDOW
)
1553 if ( m_btnState
& (wxCONTROL_CURRENT
|wxCONTROL_PRESSED
) )
1555 m_btnState
&= ~(wxCONTROL_CURRENT
);
1558 if ( IsPopupWindowState(Hidden
) )
1560 m_btnState
&= ~(wxCONTROL_PRESSED
);
1568 // Never have 'hot' state when popup is being shown
1569 // (this is mostly needed because of the animation).
1570 if ( !IsPopupWindowState(Hidden
) )
1571 m_btnState
&= ~wxCONTROL_CURRENT
;
1576 // returns true if event was consumed or filtered
1577 bool wxComboCtrlBase
::PreprocessMouseEvent( wxMouseEvent
& event
,
1578 int WXUNUSED(flags
) )
1580 wxLongLong t
= ::wxGetLocalTimeMillis();
1581 int evtType
= event
.GetEventType();
1583 #if USES_WXPOPUPWINDOW || USES_WXDIALOG
1584 if ( m_popupWinType
!= POPUPWIN_WXPOPUPTRANSIENTWINDOW
)
1586 if ( IsPopupWindowState(Visible
) &&
1587 ( evtType
== wxEVT_LEFT_DOWN
|| evtType
== wxEVT_RIGHT_DOWN
) )
1595 // Filter out clicks on button immediately after popup dismiss
1596 if ( evtType
== wxEVT_LEFT_DOWN
&& t
< m_timeCanAcceptClick
)
1598 event
.SetEventType(0);
1605 void wxComboCtrlBase
::HandleNormalMouseEvent( wxMouseEvent
& event
)
1607 int evtType
= event
.GetEventType();
1609 if ( (evtType
== wxEVT_LEFT_DOWN
|| evtType
== wxEVT_LEFT_DCLICK
) &&
1610 (m_windowStyle
& wxCB_READONLY
) )
1612 if ( GetPopupWindowState() >= Animating
)
1614 #if USES_WXPOPUPWINDOW
1615 // Click here always hides the popup.
1616 if ( m_popupWinType
== POPUPWIN_WXPOPUPWINDOW
)
1622 if ( !(m_windowStyle
& wxCC_SPECIAL_DCLICK
) )
1624 // In read-only mode, clicking the text is the
1625 // same as clicking the button.
1628 else if ( /*evtType == wxEVT_LEFT_UP || */evtType
== wxEVT_LEFT_DCLICK
)
1630 //if ( m_popupInterface->CycleValue() )
1632 if ( m_popupInterface
)
1633 m_popupInterface
->OnComboDoubleClick();
1638 if ( IsPopupShown() )
1640 // relay (some) mouse events to the popup
1641 if ( evtType
== wxEVT_MOUSEWHEEL
)
1642 m_popup
->GetEventHandler()->AddPendingEvent(event
);
1648 void wxComboCtrlBase
::OnKeyEvent(wxKeyEvent
& event
)
1650 if ( IsPopupShown() )
1652 // pass it to the popped up control
1653 GetPopupControl()->GetControl()->GetEventHandler()->AddPendingEvent(event
);
1657 if ( HandleAsNavigationKey(event
) )
1660 if ( IsKeyPopupToggle(event
) )
1666 int comboStyle
= GetWindowStyle();
1667 wxComboPopup
* popupInterface
= GetPopupControl();
1669 if ( !popupInterface
)
1675 int keycode
= event
.GetKeyCode();
1677 if ( (comboStyle
& wxCB_READONLY
) ||
1678 (keycode
!= WXK_RIGHT
&& keycode
!= WXK_LEFT
) )
1680 popupInterface
->OnComboKeyEvent(event
);
1687 void wxComboCtrlBase
::OnFocusEvent( wxFocusEvent
& event
)
1689 if ( event
.GetEventType() == wxEVT_SET_FOCUS
)
1691 wxWindow
* tc
= GetTextCtrl();
1692 if ( tc
&& tc
!= DoFindFocus() )
1694 m_resetFocus
= true;
1705 void wxComboCtrlBase
::OnIdleEvent( wxIdleEvent
& WXUNUSED(event
) )
1709 m_resetFocus
= false;
1710 wxWindow
* tc
= GetTextCtrl();
1716 void wxComboCtrlBase
::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
1719 // indentation may also have changed
1720 if ( !(m_iFlags
& wxCC_IFLAG_INDENT_SET
) )
1721 m_absIndent
= GetNativeTextIndent();
1725 // ----------------------------------------------------------------------------
1727 // ----------------------------------------------------------------------------
1729 // Create popup window and the child control
1730 void wxComboCtrlBase
::CreatePopup()
1732 wxComboPopup
* popupInterface
= m_popupInterface
;
1737 #ifdef wxComboPopupWindowBase2
1738 if ( m_iFlags
& wxCC_IFLAG_USE_ALT_POPUP
)
1741 m_winPopup
= new wxComboPopupWindowBase2( this, wxNO_BORDER
);
1743 m_winPopup
= new wxComboPopupWindowBase2( this, wxID_ANY
, wxEmptyString
,
1744 wxPoint(-21,-21), wxSize(20, 20),
1747 m_popupWinType
= SECONDARY_POPUP_TYPE
;
1750 #endif // wxComboPopupWindowBase2
1752 m_winPopup
= new wxComboPopupWindow( this, wxNO_BORDER
);
1753 m_popupWinType
= PRIMARY_POPUP_TYPE
;
1755 m_popupWinEvtHandler
= new wxComboPopupWindowEvtHandler(this);
1756 m_winPopup
->PushEventHandler(m_popupWinEvtHandler
);
1759 popupInterface
->Create(m_winPopup
);
1760 m_popup
= popup
= popupInterface
->GetControl();
1762 m_popupExtraHandler
= new wxComboPopupExtraEventHandler(this);
1763 popup
->PushEventHandler( m_popupExtraHandler
);
1765 // This may be helpful on some platforms
1766 // (eg. it bypasses a wxGTK popupwindow bug where
1767 // window is not initially hidden when it should be)
1770 popupInterface
->m_iFlags
|= wxCP_IFLAG_CREATED
;
1773 // Destroy popup window and the child control
1774 void wxComboCtrlBase
::DestroyPopup()
1779 m_popup
->RemoveEventHandler(m_popupExtraHandler
);
1781 delete m_popupExtraHandler
;
1783 delete m_popupInterface
;
1787 m_winPopup
->RemoveEventHandler(m_popupWinEvtHandler
);
1788 delete m_popupWinEvtHandler
;
1789 m_popupWinEvtHandler
= NULL
;
1790 m_winPopup
->Destroy();
1793 m_popupExtraHandler
= NULL
;
1794 m_popupInterface
= NULL
;
1799 void wxComboCtrlBase
::DoSetPopupControl(wxComboPopup
* iface
)
1801 wxCHECK_RET( iface
, wxT("no popup interface set for wxComboCtrl") );
1805 iface
->InitBase(this);
1808 m_popupInterface
= iface
;
1810 if ( !iface
->LazyCreate() )
1819 // This must be done after creation
1820 if ( m_valueString
.length() )
1822 iface
->SetStringValue(m_valueString
);
1827 // Ensures there is atleast the default popup
1828 void wxComboCtrlBase
::EnsurePopupControl()
1830 if ( !m_popupInterface
)
1831 SetPopupControl(NULL
);
1834 void wxComboCtrlBase
::OnButtonClick()
1836 // Derived classes can override this method for totally custom
1838 if ( !IsPopupWindowState(Visible
) )
1844 void wxComboCtrlBase
::ShowPopup()
1846 EnsurePopupControl();
1847 wxCHECK_RET( !IsPopupWindowState(Visible
), wxT("popup window already shown") );
1849 if ( IsPopupWindowState(Animating
) )
1854 // Space above and below
1860 wxSize ctrlSz
= GetSize();
1862 screenHeight
= wxSystemSettings
::GetMetric( wxSYS_SCREEN_Y
);
1863 scrPos
= GetParent()->ClientToScreen(GetPosition());
1865 spaceAbove
= scrPos
.y
;
1866 spaceBelow
= screenHeight
- spaceAbove
- ctrlSz
.y
;
1868 maxHeightPopup
= spaceBelow
;
1869 if ( spaceAbove
> spaceBelow
)
1870 maxHeightPopup
= spaceAbove
;
1873 int widthPopup
= ctrlSz
.x
+ m_extLeft
+ m_extRight
;
1875 if ( widthPopup
< m_widthMinPopup
)
1876 widthPopup
= m_widthMinPopup
;
1878 wxWindow
* winPopup
= m_winPopup
;
1881 // Need to disable tab traversal of parent
1883 // NB: This is to fix a bug in wxMSW. In theory it could also be fixed
1884 // by, for instance, adding check to window.cpp:wxWindowMSW::MSWProcessMessage
1885 // that if transient popup is open, then tab traversal is to be ignored.
1886 // However, I think this code would still be needed for cases where
1887 // transient popup doesn't work yet (wxWinCE?).
1888 wxWindow
* parent
= GetParent();
1889 int parentFlags
= parent
->GetWindowStyle();
1890 if ( parentFlags
& wxTAB_TRAVERSAL
)
1892 parent
->SetWindowStyle( parentFlags
& ~(wxTAB_TRAVERSAL
) );
1893 m_iFlags
|= wxCC_IFLAG_PARENT_TAB_TRAVERSAL
;
1899 winPopup
= m_winPopup
;
1909 wxASSERT( !m_popup
|| m_popup
== popup
); // Consistency check.
1911 wxSize adjustedSize
= m_popupInterface
->GetAdjustedSize(widthPopup
,
1912 m_heightPopup
<=0?DEFAULT_POPUP_HEIGHT
:m_heightPopup
,
1915 popup
->SetSize(adjustedSize
);
1917 m_popupInterface
->OnPopup();
1920 // Reposition and resize popup window
1923 wxSize szp
= popup
->GetSize();
1926 int popupY
= scrPos
.y
+ ctrlSz
.y
;
1928 // Default anchor is wxLEFT
1929 int anchorSide
= m_anchorSide
;
1931 anchorSide
= wxLEFT
;
1933 int rightX
= scrPos
.x
+ ctrlSz
.x
+ m_extRight
- szp
.x
;
1934 int leftX
= scrPos
.x
- m_extLeft
;
1936 if ( wxTheApp
->GetLayoutDirection() == wxLayout_RightToLeft
)
1939 int screenWidth
= wxSystemSettings
::GetMetric( wxSYS_SCREEN_X
);
1941 // If there is not enough horizontal space, anchor on the other side.
1942 // If there is no space even then, place the popup at x 0.
1943 if ( anchorSide
== wxRIGHT
)
1947 if ( (leftX
+szp
.x
) < screenWidth
)
1948 anchorSide
= wxLEFT
;
1955 if ( (leftX
+szp
.x
) >= screenWidth
)
1958 anchorSide
= wxRIGHT
;
1964 // Select x coordinate according to the anchor side
1965 if ( anchorSide
== wxRIGHT
)
1967 else if ( anchorSide
== wxLEFT
)
1972 int showFlags
= CanDeferShow
;
1974 if ( spaceBelow
< szp
.y
)
1976 popupY
= scrPos
.y
- szp
.y
;
1977 showFlags
|= ShowAbove
;
1980 #if INSTALL_TOPLEV_HANDLER
1981 // Put top level window event handler into place
1982 if ( m_popupWinType
== POPUPWIN_WXPOPUPWINDOW
)
1984 if ( !m_toplevEvtHandler
)
1985 m_toplevEvtHandler
= new wxComboFrameEventHandler(this);
1987 wxWindow
* toplev
= ::wxGetTopLevelParent( this );
1989 ((wxComboFrameEventHandler
*)m_toplevEvtHandler
)->OnPopup();
1990 toplev
->PushEventHandler( m_toplevEvtHandler
);
1994 // Set string selection (must be this way instead of SetStringSelection)
1997 if ( !(m_iFlags
& wxCC_NO_TEXT_AUTO_SELECT
) )
1998 m_text
->SelectAll();
2000 m_popupInterface
->SetStringValue( m_text
->GetValue() );
2004 // This is neede since focus/selection indication may change when popup is shown
2008 // This must be after SetStringValue
2009 m_popupWinState
= Animating
;
2011 wxRect
popupWinRect( popupX
, popupY
, szp
.x
, szp
.y
);
2014 if ( (m_iFlags
& wxCC_IFLAG_DISABLE_POPUP_ANIM
) ||
2015 AnimateShow( popupWinRect
, showFlags
) )
2017 DoShowPopup( popupWinRect
, showFlags
);
2021 bool wxComboCtrlBase
::AnimateShow( const wxRect
& WXUNUSED(rect
), int WXUNUSED(flags
) )
2026 void wxComboCtrlBase
::DoShowPopup( const wxRect
& rect
, int WXUNUSED(flags
) )
2028 wxWindow
* winPopup
= m_winPopup
;
2030 if ( IsPopupWindowState(Animating
) )
2032 // Make sure the popup window is shown in the right position.
2033 // Should not matter even if animation already did this.
2035 // Some platforms (GTK) may like SetSize and Move to be separate
2036 // (though the bug was probably fixed).
2037 winPopup
->SetSize( rect
);
2039 #if USES_WXPOPUPTRANSIENTWINDOW
2040 if ( m_popupWinType
== POPUPWIN_WXPOPUPTRANSIENTWINDOW
)
2041 ((wxPopupTransientWindow
*)winPopup
)->Popup(m_popup
);
2046 m_popupWinState
= Visible
;
2048 else if ( IsPopupWindowState(Hidden
) )
2050 // Animation was aborted
2052 wxASSERT( !winPopup
->IsShown() );
2054 m_popupWinState
= Hidden
;
2060 void wxComboCtrlBase
::OnPopupDismiss()
2062 // Just in case, avoid double dismiss
2063 if ( IsPopupWindowState(Hidden
) )
2066 // This must be set before focus - otherwise there will be recursive
2067 // OnPopupDismisses.
2068 m_popupWinState
= Hidden
;
2071 m_winPopup
->Disable();
2073 // Inform popup control itself
2074 m_popupInterface
->OnDismiss();
2076 if ( m_popupExtraHandler
)
2077 ((wxComboPopupExtraEventHandler
*)m_popupExtraHandler
)->OnPopupDismiss();
2079 #if INSTALL_TOPLEV_HANDLER
2080 // Remove top level window event handler
2081 if ( m_toplevEvtHandler
)
2083 wxWindow
* toplev
= ::wxGetTopLevelParent( this );
2085 toplev
->RemoveEventHandler( m_toplevEvtHandler
);
2089 m_timeCanAcceptClick
= ::wxGetLocalTimeMillis();
2091 if ( m_popupWinType
== POPUPWIN_WXPOPUPTRANSIENTWINDOW
)
2092 m_timeCanAcceptClick
+= 150;
2094 // If cursor not on dropdown button, then clear its state
2095 // (technically not required by all ports, but do it for all just in case)
2096 if ( !m_btnArea
.Contains(ScreenToClient(::wxGetMousePosition())) )
2099 // Return parent's tab traversal flag.
2100 // See ShowPopup for notes.
2101 if ( m_iFlags
& wxCC_IFLAG_PARENT_TAB_TRAVERSAL
)
2103 wxWindow
* parent
= GetParent();
2104 parent
->SetWindowStyle( parent
->GetWindowStyle() | wxTAB_TRAVERSAL
);
2105 m_iFlags
&= ~(wxCC_IFLAG_PARENT_TAB_TRAVERSAL
);
2108 // refresh control (necessary even if m_text)
2114 void wxComboCtrlBase
::HidePopup()
2116 // Should be able to call this without popup interface
2117 if ( IsPopupWindowState(Hidden
) )
2120 // transfer value and show it in textctrl, if any
2121 if ( !IsPopupWindowState(Animating
) )
2122 SetValue( m_popupInterface
->GetStringValue() );
2129 // ----------------------------------------------------------------------------
2130 // customization methods
2131 // ----------------------------------------------------------------------------
2133 void wxComboCtrlBase
::SetButtonPosition( int width
, int height
,
2134 int side
, int spacingX
)
2139 m_btnSpacingX
= spacingX
;
2144 wxSize wxComboCtrlBase
::GetButtonSize()
2146 if ( m_btnSize
.x
> 0 )
2149 wxSize
retSize(m_btnWid
,m_btnHei
);
2151 // Need to call CalculateAreas now if button size is
2152 // is not explicitly specified.
2153 if ( retSize
.x
<= 0 || retSize
.y
<= 0)
2157 retSize
= m_btnSize
;
2163 void wxComboCtrlBase
::SetButtonBitmaps( const wxBitmap
& bmpNormal
,
2165 const wxBitmap
& bmpPressed
,
2166 const wxBitmap
& bmpHover
,
2167 const wxBitmap
& bmpDisabled
)
2169 m_bmpNormal
= bmpNormal
;
2170 m_blankButtonBg
= blankButtonBg
;
2172 if ( bmpPressed
.Ok() )
2173 m_bmpPressed
= bmpPressed
;
2175 m_bmpPressed
= bmpNormal
;
2177 if ( bmpHover
.Ok() )
2178 m_bmpHover
= bmpHover
;
2180 m_bmpHover
= bmpNormal
;
2182 if ( bmpDisabled
.Ok() )
2183 m_bmpDisabled
= bmpDisabled
;
2185 m_bmpDisabled
= bmpNormal
;
2190 void wxComboCtrlBase
::SetCustomPaintWidth( int width
)
2194 // move textctrl accordingly
2195 wxRect r
= m_text
->GetRect();
2196 int inc
= width
- m_widthCustomPaint
;
2199 m_text
->SetSize( r
);
2202 m_widthCustomPaint
= width
;
2207 void wxComboCtrlBase
::SetTextIndent( int indent
)
2211 m_absIndent
= GetNativeTextIndent();
2212 m_iFlags
&= ~(wxCC_IFLAG_INDENT_SET
);
2216 m_absIndent
= indent
;
2217 m_iFlags
|= wxCC_IFLAG_INDENT_SET
;
2223 wxCoord wxComboCtrlBase
::GetNativeTextIndent() const
2225 return DEFAULT_TEXT_INDENT
;
2228 // ----------------------------------------------------------------------------
2229 // methods forwarded to wxTextCtrl
2230 // ----------------------------------------------------------------------------
2232 wxString wxComboCtrlBase
::GetValue() const
2235 return m_text
->GetValue();
2236 return m_valueString
;
2239 void wxComboCtrlBase
::SetValueWithEvent(const wxString
& value
, bool withEvent
)
2246 m_text
->SetValue(value
);
2248 if ( !(m_iFlags
& wxCC_NO_TEXT_AUTO_SELECT
) )
2249 m_text
->SelectAll();
2252 // Since wxComboPopup may want to paint the combo as well, we need
2253 // to set the string value here (as well as sometimes in ShowPopup).
2254 if ( m_valueString
!= value
)
2256 m_valueString
= value
;
2258 EnsurePopupControl();
2260 if (m_popupInterface
)
2261 m_popupInterface
->SetStringValue(value
);
2267 void wxComboCtrlBase
::SetValue(const wxString
& value
)
2269 SetValueWithEvent(value
, false);
2272 // In this SetValue variant wxComboPopup::SetStringValue is not called
2273 void wxComboCtrlBase
::SetText(const wxString
& value
)
2275 // Unlike in SetValue(), this must be called here or
2276 // the behaviour will no be consistent in readonlys.
2277 EnsurePopupControl();
2279 m_valueString
= value
;
2284 m_text
->SetValue( value
);
2290 void wxComboCtrlBase
::Copy()
2296 void wxComboCtrlBase
::Cut()
2302 void wxComboCtrlBase
::Paste()
2308 void wxComboCtrlBase
::SetInsertionPoint(long pos
)
2311 m_text
->SetInsertionPoint(pos
);
2314 void wxComboCtrlBase
::SetInsertionPointEnd()
2317 m_text
->SetInsertionPointEnd();
2320 long wxComboCtrlBase
::GetInsertionPoint() const
2323 return m_text
->GetInsertionPoint();
2328 long wxComboCtrlBase
::GetLastPosition() const
2331 return m_text
->GetLastPosition();
2336 void wxComboCtrlBase
::Replace(long from
, long to
, const wxString
& value
)
2339 m_text
->Replace(from
, to
, value
);
2342 void wxComboCtrlBase
::Remove(long from
, long to
)
2345 m_text
->Remove(from
, to
);
2348 void wxComboCtrlBase
::SetSelection(long from
, long to
)
2351 m_text
->SetSelection(from
, to
);
2354 void wxComboCtrlBase
::Undo()
2360 #endif // wxUSE_COMBOCTRL