1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: wxComboControlBase
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"
26 #if wxUSE_COMBOCONTROL
31 #include "wx/combobox.h"
32 #include "wx/dcclient.h"
33 #include "wx/settings.h"
34 #include "wx/dialog.h"
37 #include "wx/dcbuffer.h"
38 #include "wx/tooltip.h"
46 // ----------------------------------------------------------------------------
48 // Milliseconds to wait for two mouse-ups after focus inorder
49 // to trigger a double-click.
50 #define DOUBLE_CLICK_CONVERSION_TRESHOLD 500
52 #define DEFAULT_DROPBUTTON_WIDTH 19
54 #define BMP_BUTTON_MARGIN 4
56 #define DEFAULT_POPUP_HEIGHT 200
58 #define DEFAULT_TEXT_INDENT 3
60 #define COMBO_MARGIN 2 // spacing right of wxTextCtrl
63 #if defined(__WXMSW__)
65 #define USE_TRANSIENT_POPUP 1 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
67 //#undef wxUSE_POPUPWIN
68 //#define wxUSE_POPUPWIN 0
70 #elif defined(__WXGTK__)
72 #define USE_TRANSIENT_POPUP 1 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
74 #elif defined(__WXMAC__)
76 #define USE_TRANSIENT_POPUP 0 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
80 #define USE_TRANSIENT_POPUP 0 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
85 // Popupwin is really only supported on wxMSW (not WINCE) and wxGTK, regardless
86 // what the wxUSE_POPUPWIN says.
87 // FIXME: Why isn't wxUSE_POPUPWIN reliable any longer? (it was in wxW2.6.2)
88 #if (!defined(__WXMSW__) && !defined(__WXGTK__)) || defined(__WXWINCE__)
90 #define wxUSE_POPUPWIN 0
95 #include "wx/popupwin.h"
97 #undef USE_TRANSIENT_POPUP
98 #define USE_TRANSIENT_POPUP 0
102 #if USE_TRANSIENT_POPUP
104 #define wxComboPopupWindowBase wxPopupTransientWindow
105 #define INSTALL_TOPLEV_HANDLER 0
109 #define wxComboPopupWindowBase wxPopupWindow
110 #define INSTALL_TOPLEV_HANDLER 1
114 #define wxComboPopupWindowBase wxDialog
115 #define INSTALL_TOPLEV_HANDLER 0 // Doesn't need since can monitor active event
123 // * wxComboPopupWindow for external use (ie. replace old wxUniv wxPopupComboWindow)
127 // ----------------------------------------------------------------------------
128 // wxComboFrameEventHandler takes care of hiding the popup when events happen
129 // in its top level parent.
130 // ----------------------------------------------------------------------------
132 #if INSTALL_TOPLEV_HANDLER
135 // This will no longer be necessary after wxTransientPopupWindow
136 // works well on all platforms.
139 class wxComboFrameEventHandler
: public wxEvtHandler
142 wxComboFrameEventHandler( wxComboControlBase
* pCb
);
143 ~wxComboFrameEventHandler();
147 void OnIdle( wxIdleEvent
& event
);
148 void OnMouseEvent( wxMouseEvent
& event
);
149 void OnActivate( wxActivateEvent
& event
);
150 void OnResize( wxSizeEvent
& event
);
151 void OnMove( wxMoveEvent
& event
);
152 void OnMenuEvent( wxMenuEvent
& event
);
153 void OnClose( wxCloseEvent
& event
);
156 wxWindow
* m_focusStart
;
157 wxComboControlBase
* m_combo
;
160 DECLARE_EVENT_TABLE()
163 BEGIN_EVENT_TABLE(wxComboFrameEventHandler
, wxEvtHandler
)
164 EVT_IDLE(wxComboFrameEventHandler::OnIdle
)
165 EVT_LEFT_DOWN(wxComboFrameEventHandler::OnMouseEvent
)
166 EVT_RIGHT_DOWN(wxComboFrameEventHandler::OnMouseEvent
)
167 EVT_SIZE(wxComboFrameEventHandler::OnResize
)
168 EVT_MOVE(wxComboFrameEventHandler::OnMove
)
169 EVT_MENU_HIGHLIGHT(wxID_ANY
,wxComboFrameEventHandler::OnMenuEvent
)
170 EVT_MENU_OPEN(wxComboFrameEventHandler::OnMenuEvent
)
171 EVT_ACTIVATE(wxComboFrameEventHandler::OnActivate
)
172 EVT_CLOSE(wxComboFrameEventHandler::OnClose
)
175 wxComboFrameEventHandler::wxComboFrameEventHandler( wxComboControlBase
* combo
)
181 wxComboFrameEventHandler::~wxComboFrameEventHandler()
185 void wxComboFrameEventHandler::OnPopup()
187 m_focusStart
= ::wxWindow::FindFocus();
190 void wxComboFrameEventHandler::OnIdle( wxIdleEvent
& event
)
192 wxWindow
* winFocused
= ::wxWindow::FindFocus();
194 wxWindow
* popup
= m_combo
->GetPopupControl();
195 wxWindow
* winpopup
= m_combo
->GetPopupWindow();
198 winFocused
!= m_focusStart
&&
199 winFocused
!= popup
&&
200 winFocused
->GetParent() != popup
&&
201 winFocused
!= winpopup
&&
202 winFocused
->GetParent() != winpopup
&&
203 winFocused
!= m_combo
&&
204 winFocused
!= m_combo
->GetButton() // GTK (atleast) requires this
207 m_combo
->HidePopup();
213 void wxComboFrameEventHandler::OnMenuEvent( wxMenuEvent
& event
)
215 m_combo
->HidePopup();
219 void wxComboFrameEventHandler::OnMouseEvent( wxMouseEvent
& event
)
221 m_combo
->HidePopup();
225 void wxComboFrameEventHandler::OnClose( wxCloseEvent
& event
)
227 m_combo
->HidePopup();
231 void wxComboFrameEventHandler::OnActivate( wxActivateEvent
& event
)
233 m_combo
->HidePopup();
237 void wxComboFrameEventHandler::OnResize( wxSizeEvent
& event
)
239 m_combo
->HidePopup();
243 void wxComboFrameEventHandler::OnMove( wxMoveEvent
& event
)
245 m_combo
->HidePopup();
249 #endif // INSTALL_TOPLEV_HANDLER
251 // ----------------------------------------------------------------------------
252 // wxComboPopupWindow is wxPopupWindow customized for
254 // ----------------------------------------------------------------------------
256 class wxComboPopupWindow
: public wxComboPopupWindowBase
260 wxComboPopupWindow( wxComboControlBase
*parent
, int style
= wxBORDER_NONE
);
262 #if USE_TRANSIENT_POPUP
263 virtual bool ProcessLeftDown(wxMouseEvent
& event
);
266 void OnKeyEvent(wxKeyEvent
& event
);
268 void OnMouseEvent( wxMouseEvent
& event
);
270 void OnActivate( wxActivateEvent
& event
);
275 #if USE_TRANSIENT_POPUP
276 virtual void OnDismiss();
280 DECLARE_EVENT_TABLE()
284 BEGIN_EVENT_TABLE(wxComboPopupWindow
, wxComboPopupWindowBase
)
285 EVT_MOUSE_EVENTS(wxComboPopupWindow::OnMouseEvent
)
287 EVT_ACTIVATE(wxComboPopupWindow::OnActivate
)
289 EVT_KEY_DOWN(wxComboPopupWindow::OnKeyEvent
)
290 EVT_KEY_UP(wxComboPopupWindow::OnKeyEvent
)
294 wxComboPopupWindow::wxComboPopupWindow( wxComboControlBase
*parent
,
297 : wxComboPopupWindowBase(parent
,style
)
299 : wxComboPopupWindowBase(parent
,
309 void wxComboPopupWindow::OnKeyEvent( wxKeyEvent
& event
)
311 // Relay keyboard event to the main child controls
312 // (just skipping may just cause the popup to close)
313 wxWindowList children
= GetChildren();
314 wxWindowList::iterator node
= children
.begin();
315 wxWindow
* child
= (wxWindow
*)*node
;
316 child
->AddPendingEvent(event
);
319 void wxComboPopupWindow::OnMouseEvent( wxMouseEvent
& event
)
325 void wxComboPopupWindow::OnActivate( wxActivateEvent
& event
)
327 if ( !event
.GetActive() )
329 // Tell combo control that we are dismissed.
330 wxComboControl
* combo
= (wxComboControl
*) GetParent();
332 wxASSERT( combo
->IsKindOf(CLASSINFO(wxComboControl
)) );
341 #if USE_TRANSIENT_POPUP
342 bool wxComboPopupWindow::ProcessLeftDown(wxMouseEvent
& event
)
344 return wxComboPopupWindowBase::ProcessLeftDown(event
);
348 #if USE_TRANSIENT_POPUP
349 // First thing that happens when a transient popup closes is that this method gets called.
350 void wxComboPopupWindow::OnDismiss()
352 wxComboControlBase
* combo
= (wxComboControlBase
*) GetParent();
353 wxASSERT_MSG( combo
->IsKindOf(CLASSINFO(wxComboControlBase
)),
354 wxT("parent might not be wxComboControl, but check IMPLEMENT_DYNAMIC_CLASS(2) macro for correctness") );
356 combo
->OnPopupDismiss();
360 // ----------------------------------------------------------------------------
363 // ----------------------------------------------------------------------------
365 wxComboPopup::~wxComboPopup()
369 void wxComboPopup::OnPopup()
373 void wxComboPopup::OnDismiss()
377 wxSize
wxComboPopup::GetAdjustedSize( int minWidth
,
379 int WXUNUSED(maxHeight
) )
381 return wxSize(minWidth
,prefHeight
);
384 void wxComboPopup::DefaultPaintComboControl( wxComboControlBase
* combo
,
385 wxDC
& dc
, const wxRect
& rect
)
387 if ( combo
->GetWindowStyle() & wxCB_READONLY
) // ie. no textctrl
389 combo
->DrawFocusBackground(dc
,rect
,0);
391 dc
.DrawText( combo
->GetValue(),
392 rect
.x
+ combo
->GetTextIndent(),
393 (rect
.height
-dc
.GetCharHeight())/2 + rect
.y
);
397 void wxComboPopup::PaintComboControl( wxDC
& dc
, const wxRect
& rect
)
399 DefaultPaintComboControl(m_combo
,dc
,rect
);
402 void wxComboPopup::OnComboKeyEvent( wxKeyEvent
& event
)
407 void wxComboPopup::OnComboDoubleClick()
411 void wxComboPopup::SetStringValue( const wxString
& WXUNUSED(value
) )
415 bool wxComboPopup::LazyCreate()
420 void wxComboPopup::Dismiss()
422 m_combo
->HidePopup();
425 // ----------------------------------------------------------------------------
427 // ----------------------------------------------------------------------------
430 // This is pushed to the event handler queue of either combo box
431 // or its textctrl (latter if not readonly combo).
433 class wxComboBoxExtraInputHandler
: public wxEvtHandler
437 wxComboBoxExtraInputHandler( wxComboControlBase
* combo
)
442 ~wxComboBoxExtraInputHandler() { }
443 void OnKey(wxKeyEvent
& event
);
444 void OnFocus(wxFocusEvent
& event
);
447 wxComboControlBase
* m_combo
;
450 DECLARE_EVENT_TABLE()
454 BEGIN_EVENT_TABLE(wxComboBoxExtraInputHandler
, wxEvtHandler
)
455 EVT_KEY_DOWN(wxComboBoxExtraInputHandler::OnKey
)
456 EVT_SET_FOCUS(wxComboBoxExtraInputHandler::OnFocus
)
460 void wxComboBoxExtraInputHandler::OnKey(wxKeyEvent
& event
)
462 int keycode
= event
.GetKeyCode();
464 if ( keycode
== WXK_TAB
)
466 wxNavigationKeyEvent evt
;
467 evt
.SetFlags(wxNavigationKeyEvent::FromTab
|
468 (!event
.ShiftDown()?wxNavigationKeyEvent::IsForward
:
469 wxNavigationKeyEvent::IsBackward
));
470 evt
.SetEventObject(m_combo
);
471 m_combo
->GetParent()->GetEventHandler()->AddPendingEvent(evt
);
475 if ( m_combo
->IsPopupShown() )
477 // pass it to the popped up control
478 m_combo
->GetPopupControl()->GetControl()->AddPendingEvent(event
);
482 int comboStyle
= m_combo
->GetWindowStyle();
483 wxComboPopup
* popupInterface
= m_combo
->GetPopupControl();
485 if ( !popupInterface
)
491 if ( (comboStyle
& wxCB_READONLY
) ||
492 ( keycode
!= WXK_RIGHT
&& keycode
!= WXK_LEFT
)
495 // Alternate keys: UP and DOWN show the popup instead of cycling
496 if ( (comboStyle
& wxCC_ALT_KEYS
) )
498 if ( keycode
== WXK_UP
|| keycode
== WXK_DOWN
)
500 m_combo
->OnButtonClick();
507 popupInterface
->OnComboKeyEvent(event
);
514 void wxComboBoxExtraInputHandler::OnFocus(wxFocusEvent
& event
)
516 // FIXME: This code does run when control is clicked,
517 // yet on Windows it doesn't select all the text.
518 if ( !(m_combo
->GetInternalFlags() & wxCC_NO_TEXT_AUTO_SELECT
) )
520 if ( m_combo
->GetTextCtrl() )
521 m_combo
->GetTextCtrl()->SelectAll();
523 m_combo
->SetSelection(-1,-1);
526 if ( event
.GetId() != m_combo
->GetId() )
528 // Add textctrl set focus events as combo set focus events
529 // NOTE: Simply changing the event and skipping didn't seem
531 wxFocusEvent
evt2(wxEVT_SET_FOCUS
,m_combo
->GetId());
532 evt2
.SetEventObject(m_combo
);
533 m_combo
->GetEventHandler()->ProcessEvent(evt2
);
543 // This is pushed to the event handler queue of the control in popup.
546 class wxComboPopupExtraEventHandler
: public wxEvtHandler
550 wxComboPopupExtraEventHandler( wxComboControlBase
* combo
)
554 m_beenInside
= false;
556 ~wxComboPopupExtraEventHandler() { }
558 void OnMouseEvent( wxMouseEvent
& event
);
560 // Called from wxComboControlBase::OnPopupDismiss
561 void OnPopupDismiss()
563 m_beenInside
= false;
567 wxComboControlBase
* m_combo
;
572 DECLARE_EVENT_TABLE()
576 BEGIN_EVENT_TABLE(wxComboPopupExtraEventHandler
, wxEvtHandler
)
577 EVT_MOUSE_EVENTS(wxComboPopupExtraEventHandler::OnMouseEvent
)
581 void wxComboPopupExtraEventHandler::OnMouseEvent( wxMouseEvent
& event
)
583 wxPoint pt
= event
.GetPosition();
584 wxSize sz
= m_combo
->GetPopupControl()->GetControl()->GetClientSize();
585 int evtType
= event
.GetEventType();
586 bool isInside
= pt
.x
>= 0 && pt
.y
>= 0 && pt
.x
< sz
.x
&& pt
.y
< sz
.y
;
588 if ( evtType
== wxEVT_MOTION
||
589 evtType
== wxEVT_LEFT_DOWN
||
590 evtType
== wxEVT_RIGHT_DOWN
)
592 // Block motion and click events outside the popup
599 else if ( evtType
== wxEVT_LEFT_UP
)
601 // Don't let left-down events in if outside
602 if ( evtType
== wxEVT_LEFT_DOWN
)
617 // Some mouse events to popup that happen outside it, before cursor
618 // has been inside the popu, need to be ignored by it but relayed to
621 wxWindow
* btn
= m_combo
->GetButton();
623 btn
->GetEventHandler()->AddPendingEvent(event
);
625 m_combo
->GetEventHandler()->AddPendingEvent(event
);
637 // ----------------------------------------------------------------------------
638 // wxComboControlBase
639 // ----------------------------------------------------------------------------
642 BEGIN_EVENT_TABLE(wxComboControlBase
, wxControl
)
643 EVT_TEXT(wxID_ANY
,wxComboControlBase::OnTextCtrlEvent
)
644 EVT_SIZE(wxComboControlBase::OnSizeEvent
)
645 EVT_SET_FOCUS(wxComboControlBase::OnFocusEvent
)
646 EVT_KILL_FOCUS(wxComboControlBase::OnFocusEvent
)
647 //EVT_BUTTON(wxID_ANY,wxComboControlBase::OnButtonClickEvent)
648 EVT_TEXT_ENTER(wxID_ANY
,wxComboControlBase::OnTextCtrlEvent
)
649 EVT_SYS_COLOUR_CHANGED(wxComboControlBase::OnSysColourChanged
)
653 IMPLEMENT_ABSTRACT_CLASS(wxComboControlBase
, wxControl
)
655 // Have global double buffer - should be enough for multiple combos
656 static wxBitmap
* gs_doubleBuffer
= (wxBitmap
*) NULL
;
658 void wxComboControlBase::Init()
660 m_winPopup
= (wxWindow
*)NULL
;
661 m_popup
= (wxWindow
*)NULL
;
662 m_isPopupShown
= false;
663 m_btn
= (wxWindow
*) NULL
;
664 m_text
= (wxTextCtrl
*) NULL
;
665 m_popupInterface
= (wxComboPopup
*) NULL
;
667 m_extraEvtHandler
= (wxEvtHandler
*) NULL
;
668 m_popupExtraHandler
= (wxEvtHandler
*) NULL
;
669 m_textEvtHandler
= (wxEvtHandler
*) NULL
;
671 #if INSTALL_TOPLEV_HANDLER
672 m_toplevEvtHandler
= (wxEvtHandler
*) NULL
;
676 m_widthMinPopup
= -1;
678 m_widthCustomPaint
= 0;
679 m_widthCustomBorder
= 0;
683 m_blankButtonBg
= false;
684 m_btnWid
= m_btnHei
= 0;
692 m_downReceived
= false;
693 m_timeCanAcceptClick
= 0;
696 bool wxComboControlBase::Create(wxWindow
*parent
,
698 const wxString
& value
,
702 const wxValidator
& validator
,
703 const wxString
& name
)
705 if ( !wxControl::Create(parent
,
709 style
| wxWANTS_CHARS
,
714 m_valueString
= value
;
718 m_absIndent
= GetNativeTextIndent();
723 void wxComboControlBase::InstallInputHandlers( bool alsoTextCtrl
)
725 if ( m_text
&& alsoTextCtrl
)
727 m_textEvtHandler
= new wxComboBoxExtraInputHandler(this);
728 m_text
->PushEventHandler(m_textEvtHandler
);
731 wxComboBoxExtraInputHandler
* inputHandler
= new wxComboBoxExtraInputHandler(this);
732 PushEventHandler(inputHandler
);
733 m_extraEvtHandler
= inputHandler
;
736 void wxComboControlBase::CreateTextCtrl( int extraStyle
, const wxValidator
& validator
)
738 if ( !(m_windowStyle
& wxCB_READONLY
) )
740 m_text
= new wxTextCtrl(this,
745 // wxTE_PROCESS_TAB is needed because on Windows, wxTAB_TRAVERSAL is
746 // not used by the wxPropertyGrid and therefore the tab is
747 // processed by looking at ancestors to see if they have
748 // wxTAB_TRAVERSAL. The navigation event is then sent to
755 // This is required for some platforms (GTK+ atleast)
756 m_text
->SetSizeHints(2,4);
760 void wxComboControlBase::OnThemeChange()
762 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
));
765 wxComboControlBase::~wxComboControlBase()
770 delete gs_doubleBuffer
;
771 gs_doubleBuffer
= (wxBitmap
*) NULL
;
773 #if INSTALL_TOPLEV_HANDLER
774 delete ((wxComboFrameEventHandler
*)m_toplevEvtHandler
);
775 m_toplevEvtHandler
= (wxEvtHandler
*) NULL
;
779 m_popup
->RemoveEventHandler(m_popupExtraHandler
);
781 delete m_popupExtraHandler
;
785 delete m_popupInterface
;
788 RemoveEventHandler(m_extraEvtHandler
);
791 m_text
->RemoveEventHandler(m_textEvtHandler
);
793 delete m_textEvtHandler
;
794 delete m_extraEvtHandler
;
798 // ----------------------------------------------------------------------------
800 // ----------------------------------------------------------------------------
802 // Recalculates button and textctrl areas
803 void wxComboControlBase::CalculateAreas( int btnWidth
)
805 wxSize sz
= GetClientSize();
806 int customBorder
= m_widthCustomBorder
;
808 int btnBorder
; // border for button only
810 if ( ( (m_iFlags
& wxCC_BUTTON_OUTSIDE_BORDER
) || m_blankButtonBg
) &&
811 m_btnSpacingX
== 0 && m_btnWid
== 0 && m_btnHei
== 0 &&
812 (!m_bmpNormal
.Ok() || m_blankButtonBg
) )
814 buttonOutside
= true;
815 m_iFlags
|= wxCC_IFLAG_BUTTON_OUTSIDE
;
820 buttonOutside
= false;
821 m_iFlags
&= ~(wxCC_IFLAG_BUTTON_OUTSIDE
);
822 btnBorder
= customBorder
;
825 // Defaul indentation
826 if ( m_absIndent
< 0 )
827 m_absIndent
= GetNativeTextIndent();
829 int butWidth
= btnWidth
;
832 butWidth
= m_btnWidDefault
;
834 m_btnWidDefault
= butWidth
;
839 // Adjust button width
841 butWidth
+= m_btnWid
;
842 else if ( m_btnWid
> 0 )
845 int butHeight
= sz
.y
;
847 butHeight
-= btnBorder
*2;
849 // Adjust button height
851 butHeight
+= m_btnHei
;
852 else if ( m_btnHei
> 0 )
853 butHeight
= m_btnHei
;
855 // Use size of normal bitmap if...
858 // button width is set to default and blank button bg is not drawn
859 if ( m_bmpNormal
.Ok() )
861 int bmpReqWidth
= m_bmpNormal
.GetWidth();
862 int bmpReqHeight
= m_bmpNormal
.GetHeight();
864 // If drawing blank button background, we need to add some margin.
865 if ( m_blankButtonBg
)
867 bmpReqWidth
+= BMP_BUTTON_MARGIN
*2;
868 bmpReqHeight
+= BMP_BUTTON_MARGIN
*2;
871 if ( butWidth
< bmpReqWidth
|| ( m_btnWid
== 0 && !m_blankButtonBg
) )
872 butWidth
= bmpReqWidth
;
873 if ( butHeight
< bmpReqHeight
|| ( m_btnHei
== 0 && !m_blankButtonBg
) )
874 butHeight
= bmpReqHeight
;
876 // Need to fix height?
877 if ( (sz
.y
-(customBorder
*2)) < butHeight
&& btnWidth
== 0 )
879 int newY
= butHeight
+(customBorder
*2);
880 SetClientSize(-1,newY
);
885 int butAreaWid
= butWidth
+ (m_btnSpacingX
*2);
887 m_btnSize
.x
= butWidth
;
888 m_btnSize
.y
= butHeight
;
890 m_btnArea
.x
= ( m_btnSide
==wxRIGHT
? sz
.x
- butAreaWid
- btnBorder
: btnBorder
);
891 m_btnArea
.y
= btnBorder
;
892 m_btnArea
.width
= butAreaWid
;
893 m_btnArea
.height
= sz
.y
- (btnBorder
*2);
895 m_tcArea
.x
= ( m_btnSide
==wxRIGHT
? 0 : butAreaWid
) + customBorder
;
896 m_tcArea
.y
= customBorder
;
897 m_tcArea
.width
= sz
.x
- butAreaWid
- (customBorder
*2);
898 m_tcArea
.height
= sz
.y
- (customBorder
*2);
903 ::wxMessageBox(wxString::Format(wxT("ButtonArea (%i,%i,%i,%i)\n"),m_btnArea.x,m_btnArea.y,m_btnArea.width,m_btnArea.height) +
904 wxString::Format(wxT("TextCtrlArea (%i,%i,%i,%i)"),m_tcArea.x,m_tcArea.y,m_tcArea.width,m_tcArea.height));
909 void wxComboControlBase::PositionTextCtrl( int textCtrlXAdjust
, int textCtrlYAdjust
)
914 wxSize sz
= GetClientSize();
915 int customBorder
= m_widthCustomBorder
;
917 if ( (m_text
->GetWindowStyleFlag() & wxBORDER_MASK
) == wxNO_BORDER
)
920 int tcSizeY
= m_text
->GetBestSize().y
;
921 int diff
= sz
.y
- tcSizeY
;
922 int y
= textCtrlYAdjust
+ (diff
/2);
924 if ( y
< customBorder
)
927 m_text
->SetSize( m_tcArea
.x
+ m_widthCustomPaint
+ m_absIndent
+ textCtrlXAdjust
,
929 m_tcArea
.width
- COMBO_MARGIN
-
930 (textCtrlXAdjust
+ m_widthCustomPaint
+ m_absIndent
),
933 // Make sure textctrl doesn't exceed the bottom custom border
934 wxSize tsz
= m_text
->GetSize();
935 diff
= (y
+ tsz
.y
) - (sz
.y
- customBorder
);
938 tsz
.y
= tsz
.y
- diff
- 1;
939 m_text
->SetSize(tsz
);
944 m_text
->SetSize( m_tcArea
.x
,
946 sz
.x
- m_btnArea
.x
- m_widthCustomPaint
- customBorder
,
951 wxSize
wxComboControlBase::DoGetBestSize() const
953 wxSize
sizeText(150,0);
956 sizeText
= m_text
->GetBestSize();
958 // TODO: Better method to calculate close-to-native control height.
962 fhei
= (m_font
.GetPointSize()*2) + 5;
963 else if ( wxNORMAL_FONT
->Ok() )
964 fhei
= (wxNORMAL_FONT
->GetPointSize()*2) + 5;
966 fhei
= sizeText
.y
+ 4;
968 // Need to force height to accomodate bitmap?
969 int btnSizeY
= m_btnSize
.y
;
970 if ( m_bmpNormal
.Ok() && fhei
< btnSizeY
)
973 // Control height doesn't depend on border
976 int border = m_windowStyle & wxBORDER_MASK;
977 if ( border == wxSIMPLE_BORDER )
979 else if ( border == wxNO_BORDER )
980 fhei += (m_widthCustomBorder*2);
991 wxSize
ret(sizeText
.x
+ COMBO_MARGIN
+ DEFAULT_DROPBUTTON_WIDTH
,
998 void wxComboControlBase::DoMoveWindow(int x
, int y
, int width
, int height
)
1000 // SetSize is called last in create, so it marks the end of creation
1001 m_iFlags
|= wxCC_IFLAG_CREATED
;
1003 wxControl::DoMoveWindow(x
, y
, width
, height
);
1006 void wxComboControlBase::OnSizeEvent( wxSizeEvent
& event
)
1011 // defined by actual wxComboControls
1017 // ----------------------------------------------------------------------------
1018 // standard operations
1019 // ----------------------------------------------------------------------------
1021 bool wxComboControlBase::Enable(bool enable
)
1023 if ( !wxControl::Enable(enable
) )
1027 m_btn
->Enable(enable
);
1029 m_text
->Enable(enable
);
1034 bool wxComboControlBase::Show(bool show
)
1036 if ( !wxControl::Show(show
) )
1048 bool wxComboControlBase::SetFont ( const wxFont
& font
)
1050 if ( !wxControl::SetFont(font
) )
1054 m_text
->SetFont(font
);
1060 void wxComboControlBase::DoSetToolTip(wxToolTip
*tooltip
)
1062 wxControl::DoSetToolTip(tooltip
);
1064 // Set tool tip for button and text box
1067 const wxString
&tip
= tooltip
->GetTip();
1068 if ( m_text
) m_text
->SetToolTip(tip
);
1069 if ( m_btn
) m_btn
->SetToolTip(tip
);
1073 if ( m_text
) m_text
->SetToolTip( (wxToolTip
*) NULL
);
1074 if ( m_btn
) m_btn
->SetToolTip( (wxToolTip
*) NULL
);
1077 #endif // wxUSE_TOOLTIPS
1079 // ----------------------------------------------------------------------------
1081 // ----------------------------------------------------------------------------
1083 // draw focus background on area in a way typical on platform
1084 void wxComboControlBase::DrawFocusBackground( wxDC
& dc
, const wxRect
& rect
, int flags
)
1086 wxSize sz
= GetClientSize();
1088 bool isFocused
; // also selected
1090 // For smaller size control (and for disabled background) use less spacing
1094 if ( !(flags
& wxCONTROL_ISSUBMENU
) )
1097 isEnabled
= IsEnabled();
1098 isFocused
= ShouldDrawFocus();
1100 // Windows-style: for smaller size control (and for disabled background) use less spacing
1101 focusSpacingX
= isEnabled
? 2 : 1;
1102 focusSpacingY
= sz
.y
> (GetCharHeight()+2) && isEnabled
? 2 : 1;
1106 // Drawing a list item
1107 isEnabled
= true; // they are never disabled
1108 isFocused
= flags
& wxCONTROL_SELECTED
? true : false;
1114 // Set the background sub-rectangle for selection, disabled etc
1115 wxRect
selRect(rect
);
1116 selRect
.y
+= focusSpacingY
;
1117 selRect
.height
-= (focusSpacingY
*2);
1118 selRect
.x
+= m_widthCustomPaint
+ focusSpacingX
;
1119 selRect
.width
-= m_widthCustomPaint
+ (focusSpacingX
*2);
1125 // If popup is hidden and this control is focused,
1126 // then draw the focus-indicator (selbgcolor background etc.).
1129 dc
.SetTextForeground( wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT
) );
1130 bgCol
= wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT
);
1134 dc
.SetTextForeground( wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
) );
1135 bgCol
= GetBackgroundColour();
1140 dc
.SetTextForeground( wxSystemSettings::GetColour(wxSYS_COLOUR_GRAYTEXT
) );
1141 bgCol
= GetBackgroundColour();
1144 dc
.SetBrush( bgCol
);
1146 dc
.DrawRectangle( selRect
);
1149 void wxComboControlBase::DrawButton( wxDC
& dc
, const wxRect
& rect
, bool paintBg
)
1151 int drawState
= m_btnState
;
1154 if ( m_isPopupShown
)
1155 drawState
|= wxCONTROL_PRESSED
;
1158 wxRect
drawRect(rect
.x
+m_btnSpacingX
,
1159 rect
.y
+((rect
.height
-m_btnSize
.y
)/2),
1163 // Make sure area is not larger than the control
1164 if ( drawRect
.y
< rect
.y
)
1165 drawRect
.y
= rect
.y
;
1166 if ( drawRect
.height
> rect
.height
)
1167 drawRect
.height
= rect
.height
;
1169 bool enabled
= IsEnabled();
1172 drawState
|= wxCONTROL_DISABLED
;
1174 if ( !m_bmpNormal
.Ok() )
1176 // Need to clear button background even if m_btn is present
1177 // (assume non-button background was cleared just before this call so brushes are good)
1179 dc
.DrawRectangle(rect
);
1181 // Draw standard button
1182 wxRendererNative::Get().DrawComboBoxDropButton(this,
1194 pBmp
= &m_bmpDisabled
;
1195 else if ( m_btnState
& wxCONTROL_PRESSED
)
1196 pBmp
= &m_bmpPressed
;
1197 else if ( m_btnState
& wxCONTROL_CURRENT
)
1200 pBmp
= &m_bmpNormal
;
1202 if ( m_blankButtonBg
)
1204 // If using blank button background, we need to clear its background
1205 // with button face colour instead of colour for rest of the control.
1208 wxColour bgCol
= GetParent()->GetBackgroundColour(); //wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
1209 //wxColour bgCol = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
1212 dc
.DrawRectangle(rect
);
1215 wxRendererNative::Get().DrawPushButton(this,
1224 // Need to clear button background even if m_btn is present
1225 // (assume non-button background was cleared just before this call so brushes are good)
1227 dc
.DrawRectangle(rect
);
1230 // Draw bitmap centered in drawRect
1231 dc
.DrawBitmap(*pBmp
,
1232 drawRect
.x
+ (drawRect
.width
-pBmp
->GetWidth())/2,
1233 drawRect
.y
+ (drawRect
.height
-pBmp
->GetHeight())/2,
1238 void wxComboControlBase::RecalcAndRefresh()
1242 wxSizeEvent
evt(GetSize(),GetId());
1243 GetEventHandler()->ProcessEvent(evt
);
1248 wxBitmap
& wxComboControlBase::GetBufferBitmap( const wxSize
& sz
) const
1250 // If size is larger, recalculate double buffer bitmap
1251 if ( !gs_doubleBuffer
||
1252 sz
.x
> gs_doubleBuffer
->GetWidth() ||
1253 sz
.y
> gs_doubleBuffer
->GetHeight() )
1255 delete gs_doubleBuffer
;
1256 gs_doubleBuffer
= new wxBitmap(sz
.x
+25,sz
.y
);
1258 return *gs_doubleBuffer
;
1261 // ----------------------------------------------------------------------------
1262 // miscellaneous event handlers
1263 // ----------------------------------------------------------------------------
1265 void wxComboControlBase::OnTextCtrlEvent(wxCommandEvent
& event
)
1267 // Change event id and relay it forward
1268 event
.SetId(GetId());
1272 // call if cursor is on button area or mouse is captured for the button
1273 bool wxComboControlBase::HandleButtonMouseEvent( wxMouseEvent
& event
,
1276 int type
= event
.GetEventType();
1278 if ( type
== wxEVT_MOTION
)
1280 if ( flags
& wxCC_MF_ON_BUTTON
)
1282 if ( !(m_btnState
& wxCONTROL_CURRENT
) )
1284 // Mouse hover begins
1285 m_btnState
|= wxCONTROL_CURRENT
;
1286 if ( HasCapture() ) // Retain pressed state.
1287 m_btnState
|= wxCONTROL_PRESSED
;
1291 else if ( (m_btnState
& wxCONTROL_CURRENT
) )
1294 m_btnState
&= ~(wxCONTROL_CURRENT
|wxCONTROL_PRESSED
);
1298 else if ( type
== wxEVT_LEFT_DOWN
)
1300 // Only accept event if it wasn't right after popup dismiss
1301 //if ( ::wxGetLocalTimeMillis() > m_timeCanClick )
1303 // Need to test this, because it might be outside.
1304 if ( flags
& wxCC_MF_ON_BUTTON
)
1306 m_btnState
|= wxCONTROL_PRESSED
;
1309 if ( !(m_iFlags
& wxCC_POPUP_ON_MOUSE_UP
) )
1312 // If showing popup now, do not capture mouse or there will be interference
1321 else if ( type
== wxEVT_LEFT_UP
)
1324 // Only accept event if mouse was left-press was previously accepted
1328 if ( m_btnState
& wxCONTROL_PRESSED
)
1330 // If mouse was inside, fire the click event.
1331 if ( m_iFlags
& wxCC_POPUP_ON_MOUSE_UP
)
1333 if ( flags
& wxCC_MF_ON_BUTTON
)
1337 m_btnState
&= ~(wxCONTROL_PRESSED
);
1341 else if ( type
== wxEVT_LEAVE_WINDOW
)
1343 if ( m_btnState
& (wxCONTROL_CURRENT
|wxCONTROL_PRESSED
) )
1345 m_btnState
&= ~(wxCONTROL_CURRENT
);
1348 if ( !m_isPopupShown
)
1350 m_btnState
&= ~(wxCONTROL_PRESSED
);
1361 // Conversion to double-clicks and some basic filtering
1362 // returns true if event was consumed or filtered
1363 //bool wxComboControlBase::PreprocessMouseEvent( wxMouseEvent& event, bool isOnButtonArea )
1364 bool wxComboControlBase::PreprocessMouseEvent( wxMouseEvent
& event
,
1367 wxLongLong t
= ::wxGetLocalTimeMillis();
1368 int evtType
= event
.GetEventType();
1371 // Generate our own double-clicks
1372 // (to allow on-focus dc-event on double-clicks instead of triple-clicks)
1373 if ( (m_windowStyle
& wxCC_SPECIAL_DCLICK
) &&
1375 //!(handlerFlags & wxCC_MF_ON_BUTTON) )
1376 !(flags
& wxCC_MF_ON_BUTTON
) )
1378 if ( evtType
== wxEVT_LEFT_DOWN
)
1380 // Set value to avoid up-events without corresponding downs
1381 m_downReceived
= true;
1383 else if ( evtType
== wxEVT_LEFT_DCLICK
)
1385 // We'll make our own double-clicks
1387 event
.SetEventType(0);
1390 else if ( evtType
== wxEVT_LEFT_UP
)
1392 if ( m_downReceived
|| m_timeLastMouseUp
== 1 )
1394 wxLongLong timeFromLastUp
= (t
-m_timeLastMouseUp
);
1396 if ( timeFromLastUp
< DOUBLE_CLICK_CONVERSION_TRESHOLD
)
1398 //type = wxEVT_LEFT_DCLICK;
1399 event
.SetEventType(wxEVT_LEFT_DCLICK
);
1400 m_timeLastMouseUp
= 1;
1404 m_timeLastMouseUp
= t
;
1407 //m_downReceived = false;
1412 // Filter out clicks on button immediately after popup dismiss (Windows like behaviour)
1413 if ( evtType
== wxEVT_LEFT_DOWN
&& t
< m_timeCanAcceptClick
)
1415 event
.SetEventType(0);
1422 void wxComboControlBase::HandleNormalMouseEvent( wxMouseEvent
& event
)
1424 int evtType
= event
.GetEventType();
1426 if ( (evtType
== wxEVT_LEFT_DOWN
|| evtType
== wxEVT_LEFT_DCLICK
) &&
1427 (m_windowStyle
& wxCB_READONLY
) )
1429 if ( m_isPopupShown
)
1432 // Normally do nothing - evt handler should close it for us
1433 #elif !USE_TRANSIENT_POPUP
1434 // Click here always hides the popup.
1440 if ( !(m_windowStyle
& wxCC_SPECIAL_DCLICK
) )
1442 // In read-only mode, clicking the text is the
1443 // same as clicking the button.
1446 else if ( /*evtType == wxEVT_LEFT_UP || */evtType
== wxEVT_LEFT_DCLICK
)
1448 //if ( m_popupInterface->CycleValue() )
1450 if ( m_popupInterface
)
1451 m_popupInterface
->OnComboDoubleClick();
1456 if ( m_isPopupShown
)
1458 // relay (some) mouse events to the popup
1459 if ( evtType
== wxEVT_MOUSEWHEEL
)
1460 m_popup
->AddPendingEvent(event
);
1466 void wxComboControlBase::OnFocusEvent( wxFocusEvent
& )
1468 // First click is the first part of double-click
1469 // Some platforms don't generate down-less mouse up-event
1470 // (Windows does, GTK+2 doesn't), so that's why we have
1472 m_timeLastMouseUp
= ::wxGetLocalTimeMillis();
1479 // no need to check for m_widthCustomPaint - that
1480 // area never gets special handling when selected
1481 // (in writable mode, that is)
1485 void wxComboControlBase::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
1488 // indentation may also have changed
1489 if ( !(m_iFlags
& wxCC_IFLAG_INDENT_SET
) )
1490 m_absIndent
= GetNativeTextIndent();
1494 // ----------------------------------------------------------------------------
1496 // ----------------------------------------------------------------------------
1498 // Create popup window and the child control
1499 void wxComboControlBase::CreatePopup()
1501 wxComboPopup
* popupInterface
= m_popupInterface
;
1505 m_winPopup
= new wxComboPopupWindow( this, wxNO_BORDER
);
1507 popupInterface
->Create(m_winPopup
);
1508 m_popup
= popup
= popupInterface
->GetControl();
1510 m_popupExtraHandler
= new wxComboPopupExtraEventHandler(this);
1511 popup
->PushEventHandler( m_popupExtraHandler
);
1513 // This may be helpful on some platforms
1514 // (eg. it bypasses a wxGTK popupwindow bug where
1515 // window is not initially hidden when it should be)
1518 popupInterface
->m_iFlags
|= wxCP_IFLAG_CREATED
;
1521 void wxComboControlBase::SetPopupControl( wxComboPopup
* iface
)
1523 wxCHECK_RET( iface
, wxT("no popup interface set for wxComboControl") );
1525 delete m_popupInterface
;
1528 iface
->InitBase(this);
1531 m_popupInterface
= iface
;
1533 if ( !iface
->LazyCreate() || m_winPopup
)
1539 m_popup
= (wxWindow
*) NULL
;
1542 // This must be done after creation
1543 if ( m_valueString
.length() )
1545 iface
->SetStringValue(m_valueString
);
1550 // Ensures there is atleast the default popup
1551 void wxComboControlBase::EnsurePopupControl()
1553 if ( !m_popupInterface
)
1554 SetPopupControl(NULL
);
1557 void wxComboControlBase::OnButtonClick()
1559 // Derived classes can override this method for totally custom
1564 void wxComboControlBase::ShowPopup()
1566 EnsurePopupControl();
1567 wxCHECK_RET( !IsPopupShown(), wxT("popup window already shown") );
1571 // Space above and below
1577 wxSize ctrlSz
= GetSize();
1579 screenHeight
= wxSystemSettings::GetMetric( wxSYS_SCREEN_Y
);
1580 scrPos
= GetParent()->ClientToScreen(GetPosition());
1582 spaceAbove
= scrPos
.y
;
1583 spaceBelow
= screenHeight
- spaceAbove
- ctrlSz
.y
;
1585 maxHeightPopup
= spaceBelow
;
1586 if ( spaceAbove
> spaceBelow
)
1587 maxHeightPopup
= spaceAbove
;
1590 int widthPopup
= ctrlSz
.x
+ m_extLeft
+ m_extRight
;
1592 if ( widthPopup
< m_widthMinPopup
)
1593 widthPopup
= m_widthMinPopup
;
1595 wxWindow
* winPopup
= m_winPopup
;
1598 // Need to disable tab traversal of parent
1600 // NB: This is to fix a bug in wxMSW. In theory it could also be fixed
1601 // by, for instance, adding check to window.cpp:wxWindowMSW::MSWProcessMessage
1602 // that if transient popup is open, then tab traversal is to be ignored.
1603 // However, I think this code would still be needed for cases where
1604 // transient popup doesn't work yet (wxWinCE?).
1605 wxWindow
* parent
= GetParent();
1606 int parentFlags
= parent
->GetWindowStyle();
1607 if ( parentFlags
& wxTAB_TRAVERSAL
)
1609 parent
->SetWindowStyle( parentFlags
& ~(wxTAB_TRAVERSAL
) );
1610 m_iFlags
|= wxCC_IFLAG_PARENT_TAB_TRAVERSAL
;
1616 winPopup
= m_winPopup
;
1624 wxASSERT( !m_popup
|| m_popup
== popup
); // Consistency check.
1626 wxSize adjustedSize
= m_popupInterface
->GetAdjustedSize(widthPopup
,
1627 m_heightPopup
<=0?DEFAULT_POPUP_HEIGHT
:m_heightPopup
,
1630 popup
->SetSize(adjustedSize
);
1632 m_popupInterface
->OnPopup();
1635 // Reposition and resize popup window
1638 wxSize szp
= popup
->GetSize();
1641 int popupY
= scrPos
.y
+ ctrlSz
.y
;
1643 int anchorSide
= m_anchorSide
;
1645 anchorSide
= m_btnSide
;
1647 // Anchor popup to the side the dropbutton is on
1648 if ( anchorSide
== wxRIGHT
)
1649 popupX
= scrPos
.x
+ ctrlSz
.x
+ m_extRight
- szp
.x
;
1651 popupX
= scrPos
.x
- m_extLeft
;
1653 if ( spaceBelow
< szp
.y
)
1655 popupY
= scrPos
.y
- szp
.y
;
1659 //wxLogDebug(wxT("popup scheduled position1: %i,%i"),ptp.x,ptp.y);
1660 //wxLogDebug(wxT("popup position1: %i,%i"),winPopup->GetPosition().x,winPopup->GetPosition().y);
1662 // Some platforms (GTK) may need these two to be separate
1663 winPopup
->SetSize( szp
.x
, szp
.y
);
1664 winPopup
->Move( popupX
, popupY
);
1666 //wxLogDebug(wxT("popup position2: %i,%i"),winPopup->GetPosition().x,winPopup->GetPosition().y);
1670 // Set string selection (must be this way instead of SetStringSelection)
1673 if ( !(m_iFlags
& wxCC_NO_TEXT_AUTO_SELECT
) )
1674 m_text
->SelectAll();
1676 m_popupInterface
->SetStringValue( m_text
->GetValue() );
1680 // This is neede since focus/selection indication may change when popup is shown
1684 // This must be after SetStringValue
1685 m_isPopupShown
= true;
1688 #if USE_TRANSIENT_POPUP
1689 ((wxPopupTransientWindow
*)winPopup
)->Popup(popup
);
1694 #if INSTALL_TOPLEV_HANDLER
1695 // Put top level window event handler into place
1696 if ( !m_toplevEvtHandler
)
1697 m_toplevEvtHandler
= new wxComboFrameEventHandler(this);
1699 wxWindow
* toplev
= ::wxGetTopLevelParent( this );
1701 ((wxComboFrameEventHandler
*)m_toplevEvtHandler
)->OnPopup();
1702 toplev
->PushEventHandler( m_toplevEvtHandler
);
1707 void wxComboControlBase::OnPopupDismiss()
1709 // Just in case, avoid double dismiss
1710 if ( !m_isPopupShown
)
1713 // *Must* set this before focus etc.
1714 m_isPopupShown
= false;
1716 // Inform popup control itself
1717 m_popupInterface
->OnDismiss();
1719 if ( m_popupExtraHandler
)
1720 ((wxComboPopupExtraEventHandler
*)m_popupExtraHandler
)->OnPopupDismiss();
1722 #if INSTALL_TOPLEV_HANDLER
1723 // Remove top level window event handler
1724 if ( m_toplevEvtHandler
)
1726 wxWindow
* toplev
= ::wxGetTopLevelParent( this );
1728 toplev
->RemoveEventHandler( m_toplevEvtHandler
);
1732 m_timeCanAcceptClick
= ::wxGetLocalTimeMillis() + 150;
1734 // If cursor not on dropdown button, then clear its state
1735 // (technically not required by all ports, but do it for all just in case)
1736 if ( !m_btnArea
.Inside(ScreenToClient(::wxGetMousePosition())) )
1739 // Return parent's tab traversal flag.
1740 // See ShowPopup for notes.
1741 if ( m_iFlags
& wxCC_IFLAG_PARENT_TAB_TRAVERSAL
)
1743 wxWindow
* parent
= GetParent();
1744 parent
->SetWindowStyle( parent
->GetWindowStyle() | wxTAB_TRAVERSAL
);
1745 m_iFlags
&= ~(wxCC_IFLAG_PARENT_TAB_TRAVERSAL
);
1748 // refresh control (necessary even if m_text)
1757 void wxComboControlBase::HidePopup()
1759 // Should be able to call this without popup interface
1760 //wxCHECK_RET( m_popupInterface, _T("no popup interface") );
1761 if ( !m_isPopupShown
)
1764 // transfer value and show it in textctrl, if any
1765 SetValue( m_popupInterface
->GetStringValue() );
1767 #if USE_TRANSIENT_POPUP
1768 ((wxPopupTransientWindow
*)m_winPopup
)->Dismiss();
1776 // ----------------------------------------------------------------------------
1777 // customization methods
1778 // ----------------------------------------------------------------------------
1780 void wxComboControlBase::SetButtonPosition( int width
, int height
,
1781 int side
, int spacingX
)
1786 m_btnSpacingX
= spacingX
;
1791 void wxComboControlBase::SetButtonBitmaps( const wxBitmap
& bmpNormal
,
1793 const wxBitmap
& bmpPressed
,
1794 const wxBitmap
& bmpHover
,
1795 const wxBitmap
& bmpDisabled
)
1797 m_bmpNormal
= bmpNormal
;
1798 m_blankButtonBg
= blankButtonBg
;
1800 if ( bmpPressed
.Ok() )
1801 m_bmpPressed
= bmpPressed
;
1803 m_bmpPressed
= bmpNormal
;
1805 if ( bmpHover
.Ok() )
1806 m_bmpHover
= bmpHover
;
1808 m_bmpHover
= bmpNormal
;
1810 if ( bmpDisabled
.Ok() )
1811 m_bmpDisabled
= bmpDisabled
;
1813 m_bmpDisabled
= bmpNormal
;
1818 void wxComboControlBase::SetCustomPaintWidth( int width
)
1822 // move textctrl accordingly
1823 wxRect r
= m_text
->GetRect();
1824 int inc
= width
- m_widthCustomPaint
;
1827 m_text
->SetSize( r
);
1830 m_widthCustomPaint
= width
;
1835 void wxComboControlBase::SetTextIndent( int indent
)
1839 m_absIndent
= GetNativeTextIndent();
1840 m_iFlags
&= ~(wxCC_IFLAG_INDENT_SET
);
1844 m_absIndent
= indent
;
1845 m_iFlags
|= wxCC_IFLAG_INDENT_SET
;
1851 wxCoord
wxComboControlBase::GetNativeTextIndent() const
1853 return DEFAULT_TEXT_INDENT
;
1856 // ----------------------------------------------------------------------------
1857 // methods forwarded to wxTextCtrl
1858 // ----------------------------------------------------------------------------
1860 wxString
wxComboControlBase::GetValue() const
1863 return m_text
->GetValue();
1864 return m_valueString
;
1867 void wxComboControlBase::SetValue(const wxString
& value
)
1871 m_text
->SetValue(value
);
1872 if ( !(m_iFlags
& wxCC_NO_TEXT_AUTO_SELECT
) )
1873 m_text
->SelectAll();
1876 m_valueString
= value
;
1880 // Since wxComboPopup may want to paint the combo as well, we need
1881 // to set the string value here (as well as sometimes in ShowPopup).
1882 if ( m_valueString
!= value
&& m_popupInterface
)
1884 m_popupInterface
->SetStringValue(value
);
1888 // In this SetValue variant wxComboPopup::SetStringValue is not called
1889 void wxComboControlBase::SetText(const wxString
& value
)
1891 // Unlike in SetValue(), this must be called here or
1892 // the behaviour will no be consistent in readonlys.
1893 EnsurePopupControl();
1895 m_valueString
= value
;
1900 void wxComboControlBase::Copy()
1906 void wxComboControlBase::Cut()
1912 void wxComboControlBase::Paste()
1918 void wxComboControlBase::SetInsertionPoint(long pos
)
1921 m_text
->SetInsertionPoint(pos
);
1924 void wxComboControlBase::SetInsertionPointEnd()
1927 m_text
->SetInsertionPointEnd();
1930 long wxComboControlBase::GetInsertionPoint() const
1933 return m_text
->GetInsertionPoint();
1938 long wxComboControlBase::GetLastPosition() const
1941 return m_text
->GetLastPosition();
1946 void wxComboControlBase::Replace(long from
, long to
, const wxString
& value
)
1949 m_text
->Replace(from
, to
, value
);
1952 void wxComboControlBase::Remove(long from
, long to
)
1955 m_text
->Remove(from
, to
);
1958 void wxComboControlBase::SetSelection(long from
, long to
)
1961 m_text
->SetSelection(from
, to
);
1964 void wxComboControlBase::Undo()
1970 #endif // wxUSE_COMBOCONTROL