]> git.saurik.com Git - wxWidgets.git/blob - src/common/combocmn.cpp
minor tab height bug fix
[wxWidgets.git] / src / common / combocmn.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/combocmn.cpp
3 // Purpose: wxComboCtrlBase
4 // Author: Jaakko Salli
5 // Modified by:
6 // Created: Apr-30-2006
7 // RCS-ID: $Id$
8 // Copyright: (c) 2005 Jaakko Salli
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 #include "wx/wxprec.h"
21
22 #ifdef __BORLANDC__
23 #pragma hdrstop
24 #endif
25
26 #if wxUSE_COMBOCTRL
27
28 #include "wx/combobox.h"
29
30 #ifndef WX_PRECOMP
31 #include "wx/log.h"
32 #include "wx/dcclient.h"
33 #include "wx/settings.h"
34 #include "wx/dialog.h"
35 #include "wx/timer.h"
36 #endif
37
38 #include "wx/tooltip.h"
39
40 #include "wx/combo.h"
41
42
43
44 // constants
45 // ----------------------------------------------------------------------------
46
47 #define DEFAULT_DROPBUTTON_WIDTH 19
48
49 #define BMP_BUTTON_MARGIN 4
50
51 #define DEFAULT_POPUP_HEIGHT 400
52
53 #define DEFAULT_TEXT_INDENT 3
54
55 #define COMBO_MARGIN 2 // spacing right of wxTextCtrl
56
57
58 #if defined(__WXMSW__)
59
60 #define USE_TRANSIENT_POPUP 1 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
61 #define TRANSIENT_POPUPWIN_IS_PERFECT 0 // wxPopupTransientWindow works, its child can have focus, and common
62 // native controls work on it like normal.
63 #define POPUPWIN_IS_PERFECT 0 // Same, but for non-transient popup window.
64 #define TEXTCTRL_TEXT_CENTERED 0 // 1 if text in textctrl is vertically centered
65
66 //#undef wxUSE_POPUPWIN
67 //#define wxUSE_POPUPWIN 0
68
69 #elif defined(__WXGTK__)
70
71 // NB: It is not recommended to use wxDialog as popup on wxGTK, because of
72 // this bug: If wxDialog is hidden, its position becomes corrupt
73 // between hide and next show, but without internal coordinates being
74 // reflected (or something like that - atleast commenting out ->Hide()
75 // seemed to eliminate the position change).
76
77 #define USE_TRANSIENT_POPUP 1 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
78 #define TRANSIENT_POPUPWIN_IS_PERFECT 0 // wxPopupTransientWindow works, its child can have focus, and common
79 // native controls work on it like normal.
80 #define POPUPWIN_IS_PERFECT 1 // Same, but for non-transient popup window.
81 #define TEXTCTRL_TEXT_CENTERED 1 // 1 if text in textctrl is vertically centered
82
83 #elif defined(__WXMAC__)
84
85 #define USE_TRANSIENT_POPUP 0 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
86 #define TRANSIENT_POPUPWIN_IS_PERFECT 0 // wxPopupTransientWindow works, its child can have focus, and common
87 // native controls work on it like normal.
88 #define POPUPWIN_IS_PERFECT 0 // Same, but for non-transient popup window.
89 #define TEXTCTRL_TEXT_CENTERED 1 // 1 if text in textctrl is vertically centered
90
91 #else
92
93 #define USE_TRANSIENT_POPUP 0 // Use wxPopupWindowTransient (preferred, if it works properly on platform)
94 #define TRANSIENT_POPUPWIN_IS_PERFECT 0 // wxPopupTransientWindow works, its child can have focus, and common
95 // native controls work on it like normal.
96 #define POPUPWIN_IS_PERFECT 0 // Same, but for non-transient popup window.
97 #define TEXTCTRL_TEXT_CENTERED 1 // 1 if text in textctrl is vertically centered
98
99 #endif
100
101
102 // Popupwin is really only supported on wxMSW (not WINCE) and wxGTK, regardless
103 // what the wxUSE_POPUPWIN says.
104 // FIXME: Why isn't wxUSE_POPUPWIN reliable any longer? (it was in wxW2.6.2)
105 #if (!defined(__WXMSW__) && !defined(__WXGTK__)) || defined(__WXWINCE__)
106 #undef wxUSE_POPUPWIN
107 #define wxUSE_POPUPWIN 0
108 #endif
109
110
111 #if wxUSE_POPUPWIN
112 #include "wx/popupwin.h"
113 #else
114 #undef USE_TRANSIENT_POPUP
115 #define USE_TRANSIENT_POPUP 0
116 #endif
117
118
119 // Define different types of popup windows
120 enum
121 {
122 POPUPWIN_NONE = 0,
123 POPUPWIN_WXPOPUPTRANSIENTWINDOW = 1,
124 POPUPWIN_WXPOPUPWINDOW = 2,
125 POPUPWIN_WXDIALOG = 3
126 };
127
128
129 #if USE_TRANSIENT_POPUP
130 // wxPopupTransientWindow is implemented
131
132 #define wxComboPopupWindowBase wxPopupTransientWindow
133 #define PRIMARY_POPUP_TYPE POPUPWIN_WXPOPUPTRANSIENTWINDOW
134 #define USES_WXPOPUPTRANSIENTWINDOW 1
135
136 #if TRANSIENT_POPUPWIN_IS_PERFECT
137 //
138 #elif POPUPWIN_IS_PERFECT
139 #define wxComboPopupWindowBase2 wxPopupWindow
140 #define SECONDARY_POPUP_TYPE POPUPWIN_WXPOPUPWINDOW
141 #define USES_WXPOPUPWINDOW 1
142 #else
143 #define wxComboPopupWindowBase2 wxDialog
144 #define SECONDARY_POPUP_TYPE POPUPWIN_WXDIALOG
145 #define USES_WXDIALOG 1
146 #endif
147
148 #elif wxUSE_POPUPWIN
149 // wxPopupWindow (but not wxPopupTransientWindow) is properly implemented
150
151 #define wxComboPopupWindowBase wxPopupWindow
152 #define PRIMARY_POPUP_TYPE POPUPWIN_WXPOPUPWINDOW
153 #define USES_WXPOPUPWINDOW 1
154
155 #if !POPUPWIN_IS_PERFECT
156 #define wxComboPopupWindowBase2 wxDialog
157 #define SECONDARY_POPUP_TYPE POPUPWIN_WXDIALOG
158 #define USES_WXDIALOG 1
159 #endif
160
161 #else
162 // wxPopupWindow is not implemented
163
164 #define wxComboPopupWindowBase wxDialog
165 #define PRIMARY_POPUP_TYPE POPUPWIN_WXDIALOG
166 #define USES_WXDIALOG 1
167
168 #endif
169
170
171 #ifndef USES_WXPOPUPTRANSIENTWINDOW
172 #define USES_WXPOPUPTRANSIENTWINDOW 0
173 #endif
174
175 #ifndef USES_WXPOPUPWINDOW
176 #define USES_WXPOPUPWINDOW 0
177 #endif
178
179 #ifndef USES_WXDIALOG
180 #define USES_WXDIALOG 0
181 #endif
182
183
184 #if USES_WXPOPUPWINDOW
185 #define INSTALL_TOPLEV_HANDLER 1
186 #else
187 #define INSTALL_TOPLEV_HANDLER 0
188 #endif
189
190
191 //
192 // ** TODO **
193 // * wxComboPopupWindow for external use (ie. replace old wxUniv wxPopupComboWindow)
194 //
195
196
197 // ----------------------------------------------------------------------------
198 // wxComboFrameEventHandler takes care of hiding the popup when events happen
199 // in its top level parent.
200 // ----------------------------------------------------------------------------
201
202 #if INSTALL_TOPLEV_HANDLER
203
204 //
205 // This will no longer be necessary after wxTransientPopupWindow
206 // works well on all platforms.
207 //
208
209 class wxComboFrameEventHandler : public wxEvtHandler
210 {
211 public:
212 wxComboFrameEventHandler( wxComboCtrlBase* pCb );
213 virtual ~wxComboFrameEventHandler();
214
215 void OnPopup();
216
217 void OnIdle( wxIdleEvent& event );
218 void OnMouseEvent( wxMouseEvent& event );
219 void OnActivate( wxActivateEvent& event );
220 void OnResize( wxSizeEvent& event );
221 void OnMove( wxMoveEvent& event );
222 void OnMenuEvent( wxMenuEvent& event );
223 void OnClose( wxCloseEvent& event );
224
225 protected:
226 wxWindow* m_focusStart;
227 wxComboCtrlBase* m_combo;
228
229 private:
230 DECLARE_EVENT_TABLE()
231 };
232
233 BEGIN_EVENT_TABLE(wxComboFrameEventHandler, wxEvtHandler)
234 EVT_IDLE(wxComboFrameEventHandler::OnIdle)
235 EVT_LEFT_DOWN(wxComboFrameEventHandler::OnMouseEvent)
236 EVT_RIGHT_DOWN(wxComboFrameEventHandler::OnMouseEvent)
237 EVT_SIZE(wxComboFrameEventHandler::OnResize)
238 EVT_MOVE(wxComboFrameEventHandler::OnMove)
239 EVT_MENU_HIGHLIGHT(wxID_ANY,wxComboFrameEventHandler::OnMenuEvent)
240 EVT_MENU_OPEN(wxComboFrameEventHandler::OnMenuEvent)
241 EVT_ACTIVATE(wxComboFrameEventHandler::OnActivate)
242 EVT_CLOSE(wxComboFrameEventHandler::OnClose)
243 END_EVENT_TABLE()
244
245 wxComboFrameEventHandler::wxComboFrameEventHandler( wxComboCtrlBase* combo )
246 : wxEvtHandler()
247 {
248 m_combo = combo;
249 }
250
251 wxComboFrameEventHandler::~wxComboFrameEventHandler()
252 {
253 }
254
255 void wxComboFrameEventHandler::OnPopup()
256 {
257 m_focusStart = ::wxWindow::FindFocus();
258 }
259
260 void wxComboFrameEventHandler::OnIdle( wxIdleEvent& event )
261 {
262 wxWindow* winFocused = ::wxWindow::FindFocus();
263
264 wxWindow* popup = m_combo->GetPopupControl()->GetControl();
265 wxWindow* winpopup = m_combo->GetPopupWindow();
266
267 if (
268 winFocused != m_focusStart &&
269 winFocused != popup &&
270 winFocused->GetParent() != popup &&
271 winFocused != winpopup &&
272 winFocused->GetParent() != winpopup &&
273 winFocused != m_combo &&
274 winFocused != m_combo->GetButton() // GTK (atleast) requires this
275 )
276 {
277 m_combo->HidePopup();
278 }
279
280 event.Skip();
281 }
282
283 void wxComboFrameEventHandler::OnMenuEvent( wxMenuEvent& event )
284 {
285 m_combo->HidePopup();
286 event.Skip();
287 }
288
289 void wxComboFrameEventHandler::OnMouseEvent( wxMouseEvent& event )
290 {
291 m_combo->HidePopup();
292 event.Skip();
293 }
294
295 void wxComboFrameEventHandler::OnClose( wxCloseEvent& event )
296 {
297 m_combo->HidePopup();
298 event.Skip();
299 }
300
301 void wxComboFrameEventHandler::OnActivate( wxActivateEvent& event )
302 {
303 m_combo->HidePopup();
304 event.Skip();
305 }
306
307 void wxComboFrameEventHandler::OnResize( wxSizeEvent& event )
308 {
309 m_combo->HidePopup();
310 event.Skip();
311 }
312
313 void wxComboFrameEventHandler::OnMove( wxMoveEvent& event )
314 {
315 m_combo->HidePopup();
316 event.Skip();
317 }
318
319 #endif // INSTALL_TOPLEV_HANDLER
320
321 // ----------------------------------------------------------------------------
322 // wxComboPopupWindow is, in essence, wxPopupWindow customized for
323 // wxComboCtrl.
324 // ----------------------------------------------------------------------------
325
326 class wxComboPopupWindow : public wxComboPopupWindowBase
327 {
328 public:
329
330 wxComboPopupWindow( wxComboCtrlBase *parent,
331 int style )
332 #if USES_WXPOPUPWINDOW || USES_WXPOPUPTRANSIENTWINDOW
333 : wxComboPopupWindowBase(parent,style)
334 #else
335 : wxComboPopupWindowBase(parent,
336 wxID_ANY,
337 wxEmptyString,
338 wxPoint(-21,-21),
339 wxSize(20,20),
340 style)
341 #endif
342 {
343 m_inShow = 0;
344 }
345
346 #if USES_WXPOPUPTRANSIENTWINDOW
347 virtual bool Show( bool show );
348 virtual bool ProcessLeftDown(wxMouseEvent& event);
349 virtual void OnDismiss();
350 #endif
351
352 private:
353 wxByte m_inShow;
354 };
355
356
357 #if USES_WXPOPUPTRANSIENTWINDOW
358 bool wxComboPopupWindow::Show( bool show )
359 {
360 // Guard against recursion
361 if ( m_inShow )
362 return wxComboPopupWindowBase::Show(show);
363
364 m_inShow++;
365
366 wxASSERT( IsKindOf(CLASSINFO(wxPopupTransientWindow)) );
367
368 wxPopupTransientWindow* ptw = (wxPopupTransientWindow*) this;
369 wxComboCtrlBase* combo = (wxComboCtrlBase*) GetParent();
370
371 if ( show != ptw->IsShown() )
372 {
373 if ( show )
374 ptw->Popup(combo->GetPopupControl()->GetControl());
375 else
376 ptw->Dismiss();
377 }
378
379 m_inShow--;
380
381 return true;
382 }
383
384 bool wxComboPopupWindow::ProcessLeftDown(wxMouseEvent& event)
385 {
386 return wxPopupTransientWindow::ProcessLeftDown(event);
387 }
388
389 // First thing that happens when a transient popup closes is that this method gets called.
390 void wxComboPopupWindow::OnDismiss()
391 {
392 wxComboCtrlBase* combo = (wxComboCtrlBase*) GetParent();
393 wxASSERT_MSG( combo->IsKindOf(CLASSINFO(wxComboCtrlBase)),
394 wxT("parent might not be wxComboCtrl, but check IMPLEMENT_DYNAMIC_CLASS(2) macro for correctness") );
395
396 combo->OnPopupDismiss();
397 }
398 #endif // USES_WXPOPUPTRANSIENTWINDOW
399
400
401 // ----------------------------------------------------------------------------
402 // wxComboPopupWindowEvtHandler does bulk of the custom event handling
403 // of a popup window. It is separate so we can have different types
404 // of popup windows.
405 // ----------------------------------------------------------------------------
406
407 class wxComboPopupWindowEvtHandler : public wxEvtHandler
408 {
409 public:
410
411 wxComboPopupWindowEvtHandler( wxComboCtrlBase *parent )
412 {
413 m_combo = parent;
414 }
415
416 void OnSizeEvent( wxSizeEvent& event );
417 void OnKeyEvent(wxKeyEvent& event);
418 #if USES_WXDIALOG
419 void OnActivate( wxActivateEvent& event );
420 #endif
421
422 private:
423 wxComboCtrlBase* m_combo;
424
425 DECLARE_EVENT_TABLE()
426 };
427
428
429 BEGIN_EVENT_TABLE(wxComboPopupWindowEvtHandler, wxEvtHandler)
430 EVT_KEY_DOWN(wxComboPopupWindowEvtHandler::OnKeyEvent)
431 EVT_KEY_UP(wxComboPopupWindowEvtHandler::OnKeyEvent)
432 #if USES_WXDIALOG
433 EVT_ACTIVATE(wxComboPopupWindowEvtHandler::OnActivate)
434 #endif
435 EVT_SIZE(wxComboPopupWindowEvtHandler::OnSizeEvent)
436 END_EVENT_TABLE()
437
438
439 void wxComboPopupWindowEvtHandler::OnSizeEvent( wxSizeEvent& WXUNUSED(event) )
440 {
441 // Block the event so that the popup control does not get auto-resized.
442 }
443
444 void wxComboPopupWindowEvtHandler::OnKeyEvent( wxKeyEvent& event )
445 {
446 // Relay keyboard event to the main child controls
447 wxWindowList children = m_combo->GetPopupWindow()->GetChildren();
448 wxWindowList::iterator node = children.begin();
449 wxWindow* child = (wxWindow*)*node;
450 child->AddPendingEvent(event);
451 }
452
453 #if USES_WXDIALOG
454 void wxComboPopupWindowEvtHandler::OnActivate( wxActivateEvent& event )
455 {
456 if ( !event.GetActive() )
457 {
458 // Tell combo control that we are dismissed.
459 m_combo->HidePopup();
460
461 event.Skip();
462 }
463 }
464 #endif
465
466
467 // ----------------------------------------------------------------------------
468 // wxComboPopup
469 //
470 // ----------------------------------------------------------------------------
471
472 wxComboPopup::~wxComboPopup()
473 {
474 }
475
476 void wxComboPopup::OnPopup()
477 {
478 }
479
480 void wxComboPopup::OnDismiss()
481 {
482 }
483
484 wxSize wxComboPopup::GetAdjustedSize( int minWidth,
485 int prefHeight,
486 int WXUNUSED(maxHeight) )
487 {
488 return wxSize(minWidth,prefHeight);
489 }
490
491 void wxComboPopup::DefaultPaintComboControl( wxComboCtrlBase* combo,
492 wxDC& dc, const wxRect& rect )
493 {
494 if ( combo->GetWindowStyle() & wxCB_READONLY ) // ie. no textctrl
495 {
496 combo->PrepareBackground(dc,rect,0);
497
498 dc.DrawText( combo->GetValue(),
499 rect.x + combo->GetTextIndent(),
500 (rect.height-dc.GetCharHeight())/2 + rect.y );
501 }
502 }
503
504 void wxComboPopup::PaintComboControl( wxDC& dc, const wxRect& rect )
505 {
506 DefaultPaintComboControl(m_combo,dc,rect);
507 }
508
509 void wxComboPopup::OnComboKeyEvent( wxKeyEvent& event )
510 {
511 event.Skip();
512 }
513
514 void wxComboPopup::OnComboDoubleClick()
515 {
516 }
517
518 void wxComboPopup::SetStringValue( const wxString& WXUNUSED(value) )
519 {
520 }
521
522 bool wxComboPopup::LazyCreate()
523 {
524 return false;
525 }
526
527 void wxComboPopup::Dismiss()
528 {
529 m_combo->HidePopup();
530 }
531
532 // ----------------------------------------------------------------------------
533 // input handling
534 // ----------------------------------------------------------------------------
535
536 //
537 // This is pushed to the event handler queue of the child textctrl.
538 //
539 class wxComboBoxExtraInputHandler : public wxEvtHandler
540 {
541 public:
542
543 wxComboBoxExtraInputHandler( wxComboCtrlBase* combo )
544 : wxEvtHandler()
545 {
546 m_combo = combo;
547 }
548 virtual ~wxComboBoxExtraInputHandler() { }
549 void OnKey(wxKeyEvent& event);
550 void OnFocus(wxFocusEvent& event);
551
552 protected:
553 wxComboCtrlBase* m_combo;
554
555 private:
556 DECLARE_EVENT_TABLE()
557 };
558
559
560 BEGIN_EVENT_TABLE(wxComboBoxExtraInputHandler, wxEvtHandler)
561 EVT_KEY_DOWN(wxComboBoxExtraInputHandler::OnKey)
562 EVT_SET_FOCUS(wxComboBoxExtraInputHandler::OnFocus)
563 END_EVENT_TABLE()
564
565
566 void wxComboBoxExtraInputHandler::OnKey(wxKeyEvent& event)
567 {
568 // Let the wxComboCtrl event handler have a go first.
569 wxComboCtrlBase* combo = m_combo;
570 wxObject* prevObj = event.GetEventObject();
571
572 event.SetId(combo->GetId());
573 event.SetEventObject(combo);
574 combo->GetEventHandler()->ProcessEvent(event);
575
576 event.SetId(((wxWindow*)prevObj)->GetId());
577 event.SetEventObject(prevObj);
578 }
579
580 void wxComboBoxExtraInputHandler::OnFocus(wxFocusEvent& event)
581 {
582 // FIXME: This code does run when control is clicked,
583 // yet on Windows it doesn't select all the text.
584 if ( !(m_combo->GetInternalFlags() & wxCC_NO_TEXT_AUTO_SELECT) )
585 {
586 if ( m_combo->GetTextCtrl() )
587 m_combo->GetTextCtrl()->SelectAll();
588 else
589 m_combo->SetSelection(-1,-1);
590 }
591
592 // Send focus indication to parent.
593 // NB: This is needed for cases where the textctrl gets focus
594 // instead of its parent. While this may trigger multiple
595 // wxEVT_SET_FOCUSes (since m_text->SetFocus is called
596 // from combo's focus event handler), they should be quite
597 // harmless.
598 wxFocusEvent evt2(wxEVT_SET_FOCUS,m_combo->GetId());
599 evt2.SetEventObject(m_combo);
600 m_combo->GetEventHandler()->ProcessEvent(evt2);
601
602 event.Skip();
603 }
604
605
606 //
607 // This is pushed to the event handler queue of the control in popup.
608 //
609
610 class wxComboPopupExtraEventHandler : public wxEvtHandler
611 {
612 public:
613
614 wxComboPopupExtraEventHandler( wxComboCtrlBase* combo )
615 : wxEvtHandler()
616 {
617 m_combo = combo;
618 m_beenInside = false;
619 }
620 virtual ~wxComboPopupExtraEventHandler() { }
621
622 void OnMouseEvent( wxMouseEvent& event );
623
624 // Called from wxComboCtrlBase::OnPopupDismiss
625 void OnPopupDismiss()
626 {
627 m_beenInside = false;
628 }
629
630 protected:
631 wxComboCtrlBase* m_combo;
632
633 bool m_beenInside;
634
635 private:
636 DECLARE_EVENT_TABLE()
637 };
638
639
640 BEGIN_EVENT_TABLE(wxComboPopupExtraEventHandler, wxEvtHandler)
641 EVT_MOUSE_EVENTS(wxComboPopupExtraEventHandler::OnMouseEvent)
642 END_EVENT_TABLE()
643
644
645 void wxComboPopupExtraEventHandler::OnMouseEvent( wxMouseEvent& event )
646 {
647 wxPoint pt = event.GetPosition();
648 wxSize sz = m_combo->GetPopupControl()->GetControl()->GetClientSize();
649 int evtType = event.GetEventType();
650 bool isInside = pt.x >= 0 && pt.y >= 0 && pt.x < sz.x && pt.y < sz.y;
651
652 if ( evtType == wxEVT_MOTION ||
653 evtType == wxEVT_LEFT_DOWN ||
654 evtType == wxEVT_RIGHT_DOWN )
655 {
656 // Block motion and click events outside the popup
657 if ( !isInside || !m_combo->IsPopupShown() )
658 {
659 event.Skip(false);
660 return;
661 }
662 }
663 else if ( evtType == wxEVT_LEFT_UP )
664 {
665 if ( !m_combo->IsPopupShown() )
666 {
667 event.Skip(false);
668 return;
669 }
670
671 if ( !m_beenInside )
672 {
673 if ( isInside )
674 {
675 m_beenInside = true;
676 }
677 else
678 {
679 //
680 // Some mouse events to popup that happen outside it, before cursor
681 // has been inside the popu, need to be ignored by it but relayed to
682 // the dropbutton.
683 //
684 wxWindow* btn = m_combo->GetButton();
685 if ( btn )
686 btn->GetEventHandler()->AddPendingEvent(event);
687 else
688 m_combo->GetEventHandler()->AddPendingEvent(event);
689
690 return;
691 }
692
693 event.Skip();
694 }
695 }
696
697 event.Skip();
698 }
699
700 // ----------------------------------------------------------------------------
701 // wxComboCtrlBase
702 // ----------------------------------------------------------------------------
703
704
705 BEGIN_EVENT_TABLE(wxComboCtrlBase, wxControl)
706 EVT_TEXT(wxID_ANY,wxComboCtrlBase::OnTextCtrlEvent)
707 EVT_SIZE(wxComboCtrlBase::OnSizeEvent)
708 EVT_SET_FOCUS(wxComboCtrlBase::OnFocusEvent)
709 EVT_KILL_FOCUS(wxComboCtrlBase::OnFocusEvent)
710 //EVT_BUTTON(wxID_ANY,wxComboCtrlBase::OnButtonClickEvent)
711 EVT_KEY_DOWN(wxComboCtrlBase::OnKeyEvent)
712 EVT_TEXT_ENTER(wxID_ANY,wxComboCtrlBase::OnTextCtrlEvent)
713 EVT_SYS_COLOUR_CHANGED(wxComboCtrlBase::OnSysColourChanged)
714 END_EVENT_TABLE()
715
716
717 IMPLEMENT_ABSTRACT_CLASS(wxComboCtrlBase, wxControl)
718
719 void wxComboCtrlBase::Init()
720 {
721 m_winPopup = (wxWindow *)NULL;
722 m_popup = (wxWindow *)NULL;
723 m_popupWinState = Hidden;
724 m_btn = (wxWindow*) NULL;
725 m_text = (wxTextCtrl*) NULL;
726 m_popupInterface = (wxComboPopup*) NULL;
727
728 m_popupExtraHandler = (wxEvtHandler*) NULL;
729 m_textEvtHandler = (wxEvtHandler*) NULL;
730
731 #if INSTALL_TOPLEV_HANDLER
732 m_toplevEvtHandler = (wxEvtHandler*) NULL;
733 #endif
734
735 m_mainCtrlWnd = this;
736
737 m_heightPopup = -1;
738 m_widthMinPopup = -1;
739 m_anchorSide = 0;
740 m_widthCustomPaint = 0;
741 m_widthCustomBorder = 0;
742
743 m_btnState = 0;
744 m_btnWidDefault = 0;
745 m_blankButtonBg = false;
746 m_ignoreEvtText = 0;
747 m_popupWinType = POPUPWIN_NONE;
748 m_btnWid = m_btnHei = -1;
749 m_btnSide = wxRIGHT;
750 m_btnSpacingX = 0;
751
752 m_extLeft = 0;
753 m_extRight = 0;
754 m_absIndent = -1;
755 m_iFlags = 0;
756 m_timeCanAcceptClick = 0;
757 }
758
759 bool wxComboCtrlBase::Create(wxWindow *parent,
760 wxWindowID id,
761 const wxString& value,
762 const wxPoint& pos,
763 const wxSize& size,
764 long style,
765 const wxValidator& validator,
766 const wxString& name)
767 {
768 if ( !wxControl::Create(parent,
769 id,
770 pos,
771 size,
772 style | wxWANTS_CHARS,
773 validator,
774 name) )
775 return false;
776
777 m_valueString = value;
778
779 // Get colours
780 OnThemeChange();
781 m_absIndent = GetNativeTextIndent();
782
783 m_iFlags |= wxCC_IFLAG_CREATED;
784
785 // If x and y indicate valid size, wxSizeEvent won't be
786 // emitted automatically, so we need to add artifical one.
787 if ( size.x > 0 && size.y > 0 )
788 {
789 wxSizeEvent evt(size,GetId());
790 GetEventHandler()->AddPendingEvent(evt);
791 }
792
793 return true;
794 }
795
796 void wxComboCtrlBase::InstallInputHandlers()
797 {
798 if ( m_text )
799 {
800 m_textEvtHandler = new wxComboBoxExtraInputHandler(this);
801 m_text->PushEventHandler(m_textEvtHandler);
802 }
803 }
804
805 void
806 wxComboCtrlBase::CreateTextCtrl(int style, const wxValidator& validator)
807 {
808 if ( !(m_windowStyle & wxCB_READONLY) )
809 {
810 if ( m_text )
811 m_text->Destroy();
812
813 // wxTE_PROCESS_TAB is needed because on Windows, wxTAB_TRAVERSAL is
814 // not used by the wxPropertyGrid and therefore the tab is processed by
815 // looking at ancestors to see if they have wxTAB_TRAVERSAL. The
816 // navigation event is then sent to the wrong window.
817 style |= wxTE_PROCESS_TAB;
818
819 if ( HasFlag(wxTE_PROCESS_ENTER) )
820 style |= wxTE_PROCESS_ENTER;
821
822 // Ignore EVT_TEXT generated by the constructor (but only
823 // if the event redirector already exists)
824 // NB: This must be " = 1" instead of "++";
825 if ( m_textEvtHandler )
826 m_ignoreEvtText = 1;
827 else
828 m_ignoreEvtText = 0;
829
830 m_text = new wxTextCtrl(this, wxID_ANY, m_valueString,
831 wxDefaultPosition, wxSize(10,-1),
832 style, validator);
833 }
834 }
835
836 void wxComboCtrlBase::OnThemeChange()
837 {
838 SetOwnBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
839 }
840
841 wxComboCtrlBase::~wxComboCtrlBase()
842 {
843 if ( HasCapture() )
844 ReleaseMouse();
845
846 #if INSTALL_TOPLEV_HANDLER
847 delete ((wxComboFrameEventHandler*)m_toplevEvtHandler);
848 m_toplevEvtHandler = (wxEvtHandler*) NULL;
849 #endif
850
851 DestroyPopup();
852
853 if ( m_text )
854 m_text->RemoveEventHandler(m_textEvtHandler);
855
856 delete m_textEvtHandler;
857 }
858
859
860 // ----------------------------------------------------------------------------
861 // geometry stuff
862 // ----------------------------------------------------------------------------
863
864 // Recalculates button and textctrl areas
865 void wxComboCtrlBase::CalculateAreas( int btnWidth )
866 {
867 wxSize sz = GetClientSize();
868 int customBorder = m_widthCustomBorder;
869 int btnBorder; // border for button only
870
871 // check if button should really be outside the border: we'll do it it if
872 // its platform default or bitmap+pushbutton background is used, but not if
873 // there is vertical size adjustment or horizontal spacing.
874 if ( ( (m_iFlags & wxCC_BUTTON_OUTSIDE_BORDER) ||
875 (m_bmpNormal.Ok() && m_blankButtonBg) ) &&
876 m_btnSpacingX == 0 &&
877 m_btnHei <= 0 )
878 {
879 m_iFlags |= wxCC_IFLAG_BUTTON_OUTSIDE;
880 btnBorder = 0;
881 }
882 else
883 {
884 m_iFlags &= ~(wxCC_IFLAG_BUTTON_OUTSIDE);
885 btnBorder = customBorder;
886 }
887
888 // Defaul indentation
889 if ( m_absIndent < 0 )
890 m_absIndent = GetNativeTextIndent();
891
892 int butWidth = btnWidth;
893
894 if ( butWidth <= 0 )
895 butWidth = m_btnWidDefault;
896 else
897 m_btnWidDefault = butWidth;
898
899 if ( butWidth <= 0 )
900 return;
901
902 int butHeight = sz.y - btnBorder*2;
903
904 // Adjust button width
905 if ( m_btnWid > 0 )
906 butWidth = m_btnWid;
907 else
908 {
909 // Adjust button width to match aspect ratio
910 // (but only if control is smaller than best size).
911 int bestHeight = GetBestSize().y;
912 int height = GetSize().y;
913
914 if ( height < bestHeight )
915 {
916 // Make very small buttons square, as it makes
917 // them accommodate arrow image better and still
918 // looks decent.
919 if ( height > 18 )
920 butWidth = (height*butWidth)/bestHeight;
921 else
922 butWidth = butHeight;
923 }
924 }
925
926 // Adjust button height
927 if ( m_btnHei > 0 )
928 butHeight = m_btnHei;
929
930 // Use size of normal bitmap if...
931 // It is larger
932 // OR
933 // button width is set to default and blank button bg is not drawn
934 if ( m_bmpNormal.Ok() )
935 {
936 int bmpReqWidth = m_bmpNormal.GetWidth();
937 int bmpReqHeight = m_bmpNormal.GetHeight();
938
939 // If drawing blank button background, we need to add some margin.
940 if ( m_blankButtonBg )
941 {
942 bmpReqWidth += BMP_BUTTON_MARGIN*2;
943 bmpReqHeight += BMP_BUTTON_MARGIN*2;
944 }
945
946 if ( butWidth < bmpReqWidth || ( m_btnWid == 0 && !m_blankButtonBg ) )
947 butWidth = bmpReqWidth;
948 if ( butHeight < bmpReqHeight || ( m_btnHei == 0 && !m_blankButtonBg ) )
949 butHeight = bmpReqHeight;
950
951 // Need to fix height?
952 if ( (sz.y-(customBorder*2)) < butHeight && btnWidth == 0 )
953 {
954 int newY = butHeight+(customBorder*2);
955 SetClientSize(wxDefaultCoord,newY);
956 sz.y = newY;
957 }
958 }
959
960 int butAreaWid = butWidth + (m_btnSpacingX*2);
961
962 m_btnSize.x = butWidth;
963 m_btnSize.y = butHeight;
964
965 m_btnArea.x = ( m_btnSide==wxRIGHT ? sz.x - butAreaWid - btnBorder : btnBorder );
966 m_btnArea.y = btnBorder;
967 m_btnArea.width = butAreaWid;
968 m_btnArea.height = sz.y - (btnBorder*2);
969
970 m_tcArea.x = ( m_btnSide==wxRIGHT ? 0 : butAreaWid ) + customBorder;
971 m_tcArea.y = customBorder;
972 m_tcArea.width = sz.x - butAreaWid - (customBorder*2);
973 m_tcArea.height = sz.y - (customBorder*2);
974
975 /*
976 if ( m_text )
977 {
978 ::wxMessageBox(wxString::Format(wxT("ButtonArea (%i,%i,%i,%i)\n"),m_btnArea.x,m_btnArea.y,m_btnArea.width,m_btnArea.height) +
979 wxString::Format(wxT("TextCtrlArea (%i,%i,%i,%i)"),m_tcArea.x,m_tcArea.y,m_tcArea.width,m_tcArea.height));
980 }
981 */
982 }
983
984 void wxComboCtrlBase::PositionTextCtrl( int textCtrlXAdjust, int textCtrlYAdjust )
985 {
986 if ( !m_text )
987 return;
988
989 wxSize sz = GetClientSize();
990 int customBorder = m_widthCustomBorder;
991
992 #if !TEXTCTRL_TEXT_CENTERED
993 if ( (m_text->GetWindowStyleFlag() & wxBORDER_MASK) == wxNO_BORDER )
994 {
995 // Centre textctrl
996 int tcSizeY = m_text->GetBestSize().y;
997 int diff = sz.y - tcSizeY;
998 int y = textCtrlYAdjust + (diff/2);
999
1000 if ( y < customBorder )
1001 y = customBorder;
1002
1003 m_text->SetSize( m_tcArea.x + m_widthCustomPaint + m_absIndent + textCtrlXAdjust,
1004 y,
1005 m_tcArea.width - COMBO_MARGIN -
1006 (textCtrlXAdjust + m_widthCustomPaint + m_absIndent),
1007 -1 );
1008
1009 // Make sure textctrl doesn't exceed the bottom custom border
1010 wxSize tsz = m_text->GetSize();
1011 diff = (y + tsz.y) - (sz.y - customBorder);
1012 if ( diff >= 0 )
1013 {
1014 tsz.y = tsz.y - diff - 1;
1015 m_text->SetSize(tsz);
1016 }
1017 }
1018 else
1019 #else
1020 wxUnusedVar(textCtrlXAdjust);
1021 wxUnusedVar(textCtrlYAdjust);
1022 #endif
1023 {
1024 // If it has border, have textctrl will the entire text field.
1025 m_text->SetSize( m_tcArea.x + m_widthCustomPaint,
1026 customBorder,
1027 sz.x - m_btnArea.width - m_widthCustomPaint - customBorder,
1028 sz.y-(customBorder*2) );
1029 }
1030 }
1031
1032 wxSize wxComboCtrlBase::DoGetBestSize() const
1033 {
1034 wxSize sizeText(150,0);
1035
1036 if ( m_text )
1037 sizeText = m_text->GetBestSize();
1038
1039 // TODO: Better method to calculate close-to-native control height.
1040
1041 int fhei;
1042 if ( m_font.Ok() )
1043 fhei = (m_font.GetPointSize()*2) + 5;
1044 else if ( wxNORMAL_FONT->Ok() )
1045 fhei = (wxNORMAL_FONT->GetPointSize()*2) + 5;
1046 else
1047 fhei = sizeText.y + 4;
1048
1049 // Need to force height to accomodate bitmap?
1050 int btnSizeY = m_btnSize.y;
1051 if ( m_bmpNormal.Ok() && fhei < btnSizeY )
1052 fhei = btnSizeY;
1053
1054 // Control height doesn't depend on border
1055 /*
1056 // Add border
1057 int border = m_windowStyle & wxBORDER_MASK;
1058 if ( border == wxSIMPLE_BORDER )
1059 fhei += 2;
1060 else if ( border == wxNO_BORDER )
1061 fhei += (m_widthCustomBorder*2);
1062 else
1063 // Sunken etc.
1064 fhei += 4;
1065 */
1066
1067 // Final adjustments
1068 #ifdef __WXGTK__
1069 fhei += 1;
1070 #endif
1071
1072 wxSize ret(sizeText.x + COMBO_MARGIN + DEFAULT_DROPBUTTON_WIDTH,
1073 fhei);
1074
1075 CacheBestSize(ret);
1076 return ret;
1077 }
1078
1079 void wxComboCtrlBase::OnSizeEvent( wxSizeEvent& event )
1080 {
1081 if ( !IsCreated() )
1082 return;
1083
1084 // defined by actual wxComboCtrls
1085 OnResize();
1086
1087 event.Skip();
1088 }
1089
1090 // ----------------------------------------------------------------------------
1091 // standard operations
1092 // ----------------------------------------------------------------------------
1093
1094 bool wxComboCtrlBase::Enable(bool enable)
1095 {
1096 if ( !wxControl::Enable(enable) )
1097 return false;
1098
1099 if ( m_btn )
1100 m_btn->Enable(enable);
1101 if ( m_text )
1102 m_text->Enable(enable);
1103
1104 return true;
1105 }
1106
1107 bool wxComboCtrlBase::Show(bool show)
1108 {
1109 if ( !wxControl::Show(show) )
1110 return false;
1111
1112 if (m_btn)
1113 m_btn->Show(show);
1114
1115 if (m_text)
1116 m_text->Show(show);
1117
1118 return true;
1119 }
1120
1121 bool wxComboCtrlBase::SetFont ( const wxFont& font )
1122 {
1123 if ( !wxControl::SetFont(font) )
1124 return false;
1125
1126 if (m_text)
1127 m_text->SetFont(font);
1128
1129 return true;
1130 }
1131
1132 #if wxUSE_TOOLTIPS
1133 void wxComboCtrlBase::DoSetToolTip(wxToolTip *tooltip)
1134 {
1135 wxControl::DoSetToolTip(tooltip);
1136
1137 // Set tool tip for button and text box
1138 if ( tooltip )
1139 {
1140 const wxString &tip = tooltip->GetTip();
1141 if ( m_text ) m_text->SetToolTip(tip);
1142 if ( m_btn ) m_btn->SetToolTip(tip);
1143 }
1144 else
1145 {
1146 if ( m_text ) m_text->SetToolTip( (wxToolTip*) NULL );
1147 if ( m_btn ) m_btn->SetToolTip( (wxToolTip*) NULL );
1148 }
1149 }
1150 #endif // wxUSE_TOOLTIPS
1151
1152 // ----------------------------------------------------------------------------
1153 // painting
1154 // ----------------------------------------------------------------------------
1155
1156 #if (!defined(__WXMSW__)) || defined(__WXUNIVERSAL__)
1157 // prepare combo box background on area in a way typical on platform
1158 void wxComboCtrlBase::PrepareBackground( wxDC& dc, const wxRect& rect, int flags ) const
1159 {
1160 wxSize sz = GetClientSize();
1161 bool isEnabled;
1162 bool isFocused; // also selected
1163
1164 // For smaller size control (and for disabled background) use less spacing
1165 int focusSpacingX;
1166 int focusSpacingY;
1167
1168 if ( !(flags & wxCONTROL_ISSUBMENU) )
1169 {
1170 // Drawing control
1171 isEnabled = IsEnabled();
1172 isFocused = ShouldDrawFocus();
1173
1174 // Windows-style: for smaller size control (and for disabled background) use less spacing
1175 focusSpacingX = isEnabled ? 2 : 1;
1176 focusSpacingY = sz.y > (GetCharHeight()+2) && isEnabled ? 2 : 1;
1177 }
1178 else
1179 {
1180 // Drawing a list item
1181 isEnabled = true; // they are never disabled
1182 isFocused = flags & wxCONTROL_SELECTED ? true : false;
1183
1184 focusSpacingX = 0;
1185 focusSpacingY = 0;
1186 }
1187
1188 // Set the background sub-rectangle for selection, disabled etc
1189 wxRect selRect(rect);
1190 selRect.y += focusSpacingY;
1191 selRect.height -= (focusSpacingY*2);
1192
1193 int wcp = 0;
1194
1195 if ( !(flags & wxCONTROL_ISSUBMENU) )
1196 wcp += m_widthCustomPaint;
1197
1198 selRect.x += wcp + focusSpacingX;
1199 selRect.width -= wcp + (focusSpacingX*2);
1200
1201 wxColour bgCol;
1202
1203 if ( isEnabled )
1204 {
1205 // If popup is hidden and this control is focused,
1206 // then draw the focus-indicator (selbgcolor background etc.).
1207 if ( isFocused )
1208 {
1209 dc.SetTextForeground( wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT) );
1210 bgCol = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
1211 }
1212 else
1213 {
1214 dc.SetTextForeground( wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT) );
1215 bgCol = GetBackgroundColour();
1216 }
1217 }
1218 else
1219 {
1220 dc.SetTextForeground( wxSystemSettings::GetColour(wxSYS_COLOUR_GRAYTEXT) );
1221 bgCol = GetBackgroundColour();
1222 }
1223
1224 dc.SetBrush( bgCol );
1225 dc.SetPen( bgCol );
1226 dc.DrawRectangle( selRect );
1227
1228 // Don't clip exactly to the selection rectangle so we can draw
1229 // to the non-selected area in front of it.
1230 wxRect clipRect(rect.x,rect.y,
1231 (selRect.x+selRect.width)-rect.x,rect.height);
1232 dc.SetClippingRegion(clipRect);
1233 }
1234 #else
1235 // Save the library size a bit for platforms that re-implement this.
1236 void wxComboCtrlBase::PrepareBackground( wxDC&, const wxRect&, int ) const
1237 {
1238 }
1239 #endif
1240
1241 void wxComboCtrlBase::DrawButton( wxDC& dc, const wxRect& rect, int paintBg )
1242 {
1243 int drawState = m_btnState;
1244
1245 #ifdef __WXGTK__
1246 if ( GetPopupWindowState() >= Animating )
1247 drawState |= wxCONTROL_PRESSED;
1248 #endif
1249
1250 wxRect drawRect(rect.x+m_btnSpacingX,
1251 rect.y+((rect.height-m_btnSize.y)/2),
1252 m_btnSize.x,
1253 m_btnSize.y);
1254
1255 // Make sure area is not larger than the control
1256 if ( drawRect.y < rect.y )
1257 drawRect.y = rect.y;
1258 if ( drawRect.height > rect.height )
1259 drawRect.height = rect.height;
1260
1261 bool enabled = IsEnabled();
1262
1263 if ( !enabled )
1264 drawState |= wxCONTROL_DISABLED;
1265
1266 if ( !m_bmpNormal.Ok() )
1267 {
1268 // Need to clear button background even if m_btn is present
1269 if ( paintBg )
1270 {
1271 wxColour bgCol;
1272
1273 if ( m_iFlags & wxCC_IFLAG_BUTTON_OUTSIDE )
1274 bgCol = GetParent()->GetBackgroundColour();
1275 else
1276 bgCol = GetBackgroundColour();
1277
1278 dc.SetBrush(bgCol);
1279 dc.SetPen(bgCol);
1280 dc.DrawRectangle(rect);
1281 }
1282
1283 // Draw standard button
1284 wxRendererNative::Get().DrawComboBoxDropButton(this,
1285 dc,
1286 drawRect,
1287 drawState);
1288 }
1289 else
1290 {
1291 // Draw bitmap
1292
1293 wxBitmap* pBmp;
1294
1295 if ( !enabled )
1296 pBmp = &m_bmpDisabled;
1297 else if ( m_btnState & wxCONTROL_PRESSED )
1298 pBmp = &m_bmpPressed;
1299 else if ( m_btnState & wxCONTROL_CURRENT )
1300 pBmp = &m_bmpHover;
1301 else
1302 pBmp = &m_bmpNormal;
1303
1304 if ( m_blankButtonBg )
1305 {
1306 // If using blank button background, we need to clear its background
1307 // with button face colour instead of colour for rest of the control.
1308 if ( paintBg )
1309 {
1310 wxColour bgCol = GetParent()->GetBackgroundColour(); //wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
1311 //wxColour bgCol = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
1312 dc.SetPen(bgCol);
1313 dc.SetBrush(bgCol);
1314 dc.DrawRectangle(rect);
1315 }
1316
1317 wxRendererNative::Get().DrawPushButton(this,
1318 dc,
1319 drawRect,
1320 drawState);
1321
1322 }
1323 else
1324
1325 {
1326 // Need to clear button background even if m_btn is present
1327 // (assume non-button background was cleared just before this call so brushes are good)
1328 if ( paintBg )
1329 dc.DrawRectangle(rect);
1330 }
1331
1332 // Draw bitmap centered in drawRect
1333 dc.DrawBitmap(*pBmp,
1334 drawRect.x + (drawRect.width-pBmp->GetWidth())/2,
1335 drawRect.y + (drawRect.height-pBmp->GetHeight())/2,
1336 true);
1337 }
1338 }
1339
1340 void wxComboCtrlBase::RecalcAndRefresh()
1341 {
1342 if ( IsCreated() )
1343 {
1344 wxSizeEvent evt(GetSize(),GetId());
1345 GetEventHandler()->ProcessEvent(evt);
1346 Refresh();
1347 }
1348 }
1349
1350 // ----------------------------------------------------------------------------
1351 // miscellaneous event handlers
1352 // ----------------------------------------------------------------------------
1353
1354 void wxComboCtrlBase::OnTextCtrlEvent(wxCommandEvent& event)
1355 {
1356 if ( event.GetEventType() == wxEVT_COMMAND_TEXT_UPDATED )
1357 {
1358 if ( m_ignoreEvtText > 0 )
1359 {
1360 m_ignoreEvtText--;
1361 return;
1362 }
1363 }
1364
1365 // Change event id, object and string before relaying it forward
1366 event.SetId(GetId());
1367 wxString s = event.GetString();
1368 event.SetEventObject(this);
1369 event.SetString(s);
1370 event.Skip();
1371 }
1372
1373 // call if cursor is on button area or mouse is captured for the button
1374 bool wxComboCtrlBase::HandleButtonMouseEvent( wxMouseEvent& event,
1375 int flags )
1376 {
1377 int type = event.GetEventType();
1378
1379 if ( type == wxEVT_MOTION )
1380 {
1381 if ( flags & wxCC_MF_ON_BUTTON )
1382 {
1383 if ( !(m_btnState & wxCONTROL_CURRENT) )
1384 {
1385 // Mouse hover begins
1386 m_btnState |= wxCONTROL_CURRENT;
1387 if ( HasCapture() ) // Retain pressed state.
1388 m_btnState |= wxCONTROL_PRESSED;
1389 Refresh();
1390 }
1391 }
1392 else if ( (m_btnState & wxCONTROL_CURRENT) )
1393 {
1394 // Mouse hover ends
1395 m_btnState &= ~(wxCONTROL_CURRENT|wxCONTROL_PRESSED);
1396 Refresh();
1397 }
1398 }
1399 else if ( type == wxEVT_LEFT_DOWN || type == wxEVT_LEFT_DCLICK )
1400 {
1401 if ( flags & (wxCC_MF_ON_CLICK_AREA|wxCC_MF_ON_BUTTON) )
1402 {
1403 m_btnState |= wxCONTROL_PRESSED;
1404 Refresh();
1405
1406 if ( !(m_iFlags & wxCC_POPUP_ON_MOUSE_UP) )
1407 OnButtonClick();
1408 else
1409 // If showing popup now, do not capture mouse or there will be interference
1410 CaptureMouse();
1411 }
1412 }
1413 else if ( type == wxEVT_LEFT_UP )
1414 {
1415
1416 // Only accept event if mouse was left-press was previously accepted
1417 if ( HasCapture() )
1418 ReleaseMouse();
1419
1420 if ( m_btnState & wxCONTROL_PRESSED )
1421 {
1422 // If mouse was inside, fire the click event.
1423 if ( m_iFlags & wxCC_POPUP_ON_MOUSE_UP )
1424 {
1425 if ( flags & (wxCC_MF_ON_CLICK_AREA|wxCC_MF_ON_BUTTON) )
1426 OnButtonClick();
1427 }
1428
1429 m_btnState &= ~(wxCONTROL_PRESSED);
1430 Refresh();
1431 }
1432 }
1433 else if ( type == wxEVT_LEAVE_WINDOW )
1434 {
1435 if ( m_btnState & (wxCONTROL_CURRENT|wxCONTROL_PRESSED) )
1436 {
1437 m_btnState &= ~(wxCONTROL_CURRENT);
1438
1439 // Mouse hover ends
1440 if ( IsPopupWindowState(Hidden) )
1441 {
1442 m_btnState &= ~(wxCONTROL_PRESSED);
1443 Refresh();
1444 }
1445 }
1446 }
1447 else
1448 return false;
1449
1450 return true;
1451 }
1452
1453 // returns true if event was consumed or filtered
1454 bool wxComboCtrlBase::PreprocessMouseEvent( wxMouseEvent& event,
1455 int WXUNUSED(flags) )
1456 {
1457 wxLongLong t = ::wxGetLocalTimeMillis();
1458 int evtType = event.GetEventType();
1459
1460 #if USES_WXPOPUPWINDOW || USES_WXDIALOG
1461 if ( m_popupWinType != POPUPWIN_WXPOPUPTRANSIENTWINDOW )
1462 {
1463 if ( IsPopupWindowState(Visible) &&
1464 ( evtType == wxEVT_LEFT_DOWN || evtType == wxEVT_RIGHT_DOWN ) )
1465 {
1466 HidePopup();
1467 return true;
1468 }
1469 }
1470 #endif
1471
1472 // Filter out clicks on button immediately after popup dismiss (Windows like behaviour)
1473 if ( evtType == wxEVT_LEFT_DOWN && t < m_timeCanAcceptClick )
1474 {
1475 event.SetEventType(0);
1476 return true;
1477 }
1478
1479 return false;
1480 }
1481
1482 void wxComboCtrlBase::HandleNormalMouseEvent( wxMouseEvent& event )
1483 {
1484 int evtType = event.GetEventType();
1485
1486 if ( (evtType == wxEVT_LEFT_DOWN || evtType == wxEVT_LEFT_DCLICK) &&
1487 (m_windowStyle & wxCB_READONLY) )
1488 {
1489 if ( GetPopupWindowState() >= Animating )
1490 {
1491 #if USES_WXPOPUPWINDOW
1492 // Click here always hides the popup.
1493 if ( m_popupWinType == POPUPWIN_WXPOPUPWINDOW )
1494 HidePopup();
1495 #endif
1496 }
1497 else
1498 {
1499 if ( !(m_windowStyle & wxCC_SPECIAL_DCLICK) )
1500 {
1501 // In read-only mode, clicking the text is the
1502 // same as clicking the button.
1503 OnButtonClick();
1504 }
1505 else if ( /*evtType == wxEVT_LEFT_UP || */evtType == wxEVT_LEFT_DCLICK )
1506 {
1507 //if ( m_popupInterface->CycleValue() )
1508 // Refresh();
1509 if ( m_popupInterface )
1510 m_popupInterface->OnComboDoubleClick();
1511 }
1512 }
1513 }
1514 else
1515 if ( IsPopupShown() )
1516 {
1517 // relay (some) mouse events to the popup
1518 if ( evtType == wxEVT_MOUSEWHEEL )
1519 m_popup->AddPendingEvent(event);
1520 }
1521 else if ( evtType )
1522 event.Skip();
1523 }
1524
1525 void wxComboCtrlBase::OnKeyEvent(wxKeyEvent& event)
1526 {
1527 if ( IsPopupShown() )
1528 {
1529 // pass it to the popped up control
1530 GetPopupControl()->GetControl()->AddPendingEvent(event);
1531 }
1532 else // no popup
1533 {
1534 int keycode = event.GetKeyCode();
1535
1536 if ( keycode == WXK_TAB )
1537 {
1538 wxNavigationKeyEvent evt;
1539
1540 wxWindow* mainCtrl = GetMainWindowOfCompositeControl();
1541
1542 evt.SetFlags(wxNavigationKeyEvent::FromTab|
1543 (!event.ShiftDown() ? wxNavigationKeyEvent::IsForward
1544 : wxNavigationKeyEvent::IsBackward));
1545 evt.SetEventObject(mainCtrl);
1546 evt.SetCurrentFocus(mainCtrl);
1547 mainCtrl->GetParent()->GetEventHandler()->AddPendingEvent(evt);
1548 return;
1549 }
1550
1551 if ( IsKeyPopupToggle(event) )
1552 {
1553 OnButtonClick();
1554 return;
1555 }
1556
1557 int comboStyle = GetWindowStyle();
1558 wxComboPopup* popupInterface = GetPopupControl();
1559
1560 if ( !popupInterface )
1561 {
1562 event.Skip();
1563 return;
1564 }
1565
1566 if ( (comboStyle & wxCB_READONLY) ||
1567 (keycode != WXK_RIGHT && keycode != WXK_LEFT) )
1568 {
1569 popupInterface->OnComboKeyEvent(event);
1570 }
1571 else
1572 event.Skip();
1573 }
1574 }
1575
1576 void wxComboCtrlBase::OnFocusEvent( wxFocusEvent& event )
1577 {
1578 if ( event.GetEventType() == wxEVT_SET_FOCUS )
1579 {
1580 #ifndef __WXMAC__
1581 wxWindow* tc = GetTextCtrl();
1582 if ( tc && tc != DoFindFocus() )
1583 tc->SetFocus();
1584 #endif
1585 }
1586
1587 Refresh();
1588 }
1589
1590 void wxComboCtrlBase::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
1591 {
1592 OnThemeChange();
1593 // indentation may also have changed
1594 if ( !(m_iFlags & wxCC_IFLAG_INDENT_SET) )
1595 m_absIndent = GetNativeTextIndent();
1596 RecalcAndRefresh();
1597 }
1598
1599 // ----------------------------------------------------------------------------
1600 // popup handling
1601 // ----------------------------------------------------------------------------
1602
1603 // Create popup window and the child control
1604 void wxComboCtrlBase::CreatePopup()
1605 {
1606 wxComboPopup* popupInterface = m_popupInterface;
1607 wxWindow* popup;
1608
1609 if ( !m_winPopup )
1610 {
1611 #ifdef wxComboPopupWindowBase2
1612 if ( m_iFlags & wxCC_IFLAG_USE_ALT_POPUP )
1613 {
1614 #if !USES_WXDIALOG
1615 m_winPopup = new wxComboPopupWindowBase2( this, wxNO_BORDER );
1616 #else
1617 m_winPopup = new wxComboPopupWindowBase2( this, wxID_ANY, wxEmptyString,
1618 wxPoint(-21,-21), wxSize(20, 20),
1619 wxNO_BORDER );
1620 #endif
1621 m_popupWinType = SECONDARY_POPUP_TYPE;
1622 }
1623 else
1624 #endif
1625 {
1626 m_winPopup = new wxComboPopupWindow( this, wxNO_BORDER );
1627 m_popupWinType = PRIMARY_POPUP_TYPE;
1628 }
1629 m_popupWinEvtHandler = new wxComboPopupWindowEvtHandler(this);
1630 m_winPopup->PushEventHandler(m_popupWinEvtHandler);
1631 }
1632
1633 popupInterface->Create(m_winPopup);
1634 m_popup = popup = popupInterface->GetControl();
1635
1636 m_popupExtraHandler = new wxComboPopupExtraEventHandler(this);
1637 popup->PushEventHandler( m_popupExtraHandler );
1638
1639 // This may be helpful on some platforms
1640 // (eg. it bypasses a wxGTK popupwindow bug where
1641 // window is not initially hidden when it should be)
1642 m_winPopup->Hide();
1643
1644 popupInterface->m_iFlags |= wxCP_IFLAG_CREATED;
1645 }
1646
1647 // Destroy popup window and the child control
1648 void wxComboCtrlBase::DestroyPopup()
1649 {
1650 HidePopup();
1651
1652 if ( m_popup )
1653 m_popup->RemoveEventHandler(m_popupExtraHandler);
1654
1655 delete m_popupExtraHandler;
1656
1657 delete m_popupInterface;
1658
1659 if ( m_winPopup )
1660 {
1661 m_winPopup->RemoveEventHandler(m_popupWinEvtHandler);
1662 delete m_popupWinEvtHandler;
1663 m_popupWinEvtHandler = NULL;
1664 m_winPopup->Destroy();
1665 }
1666
1667 m_popupExtraHandler = (wxEvtHandler*) NULL;
1668 m_popupInterface = (wxComboPopup*) NULL;
1669 m_winPopup = (wxWindow*) NULL;
1670 m_popup = (wxWindow*) NULL;
1671 }
1672
1673 void wxComboCtrlBase::DoSetPopupControl(wxComboPopup* iface)
1674 {
1675 wxCHECK_RET( iface, wxT("no popup interface set for wxComboCtrl") );
1676
1677 DestroyPopup();
1678
1679 iface->InitBase(this);
1680 iface->Init();
1681
1682 m_popupInterface = iface;
1683
1684 if ( !iface->LazyCreate() )
1685 {
1686 CreatePopup();
1687 }
1688 else
1689 {
1690 m_popup = (wxWindow*) NULL;
1691 }
1692
1693 // This must be done after creation
1694 if ( m_valueString.length() )
1695 {
1696 iface->SetStringValue(m_valueString);
1697 //Refresh();
1698 }
1699 }
1700
1701 // Ensures there is atleast the default popup
1702 void wxComboCtrlBase::EnsurePopupControl()
1703 {
1704 if ( !m_popupInterface )
1705 SetPopupControl(NULL);
1706 }
1707
1708 void wxComboCtrlBase::OnButtonClick()
1709 {
1710 // Derived classes can override this method for totally custom
1711 // popup action
1712 ShowPopup();
1713 }
1714
1715 void wxComboCtrlBase::ShowPopup()
1716 {
1717 EnsurePopupControl();
1718 wxCHECK_RET( !IsPopupWindowState(Visible), wxT("popup window already shown") );
1719
1720 if ( IsPopupWindowState(Animating) )
1721 return;
1722
1723 SetFocus();
1724
1725 // Space above and below
1726 int screenHeight;
1727 wxPoint scrPos;
1728 int spaceAbove;
1729 int spaceBelow;
1730 int maxHeightPopup;
1731 wxSize ctrlSz = GetSize();
1732
1733 screenHeight = wxSystemSettings::GetMetric( wxSYS_SCREEN_Y );
1734 scrPos = GetParent()->ClientToScreen(GetPosition());
1735
1736 spaceAbove = scrPos.y;
1737 spaceBelow = screenHeight - spaceAbove - ctrlSz.y;
1738
1739 maxHeightPopup = spaceBelow;
1740 if ( spaceAbove > spaceBelow )
1741 maxHeightPopup = spaceAbove;
1742
1743 // Width
1744 int widthPopup = ctrlSz.x + m_extLeft + m_extRight;
1745
1746 if ( widthPopup < m_widthMinPopup )
1747 widthPopup = m_widthMinPopup;
1748
1749 wxWindow* winPopup = m_winPopup;
1750 wxWindow* popup;
1751
1752 // Need to disable tab traversal of parent
1753 //
1754 // NB: This is to fix a bug in wxMSW. In theory it could also be fixed
1755 // by, for instance, adding check to window.cpp:wxWindowMSW::MSWProcessMessage
1756 // that if transient popup is open, then tab traversal is to be ignored.
1757 // However, I think this code would still be needed for cases where
1758 // transient popup doesn't work yet (wxWinCE?).
1759 wxWindow* parent = GetParent();
1760 int parentFlags = parent->GetWindowStyle();
1761 if ( parentFlags & wxTAB_TRAVERSAL )
1762 {
1763 parent->SetWindowStyle( parentFlags & ~(wxTAB_TRAVERSAL) );
1764 m_iFlags |= wxCC_IFLAG_PARENT_TAB_TRAVERSAL;
1765 }
1766
1767 if ( !winPopup )
1768 {
1769 CreatePopup();
1770 winPopup = m_winPopup;
1771 popup = m_popup;
1772 }
1773 else
1774 {
1775 popup = m_popup;
1776 }
1777
1778 winPopup->Enable();
1779
1780 wxASSERT( !m_popup || m_popup == popup ); // Consistency check.
1781
1782 wxSize adjustedSize = m_popupInterface->GetAdjustedSize(widthPopup,
1783 m_heightPopup<=0?DEFAULT_POPUP_HEIGHT:m_heightPopup,
1784 maxHeightPopup);
1785
1786 popup->SetSize(adjustedSize);
1787 popup->Move(0,0);
1788 m_popupInterface->OnPopup();
1789
1790 //
1791 // Reposition and resize popup window
1792 //
1793
1794 wxSize szp = popup->GetSize();
1795
1796 int popupX;
1797 int popupY = scrPos.y + ctrlSz.y;
1798
1799 // Default anchor is wxLEFT
1800 int anchorSide = m_anchorSide;
1801 if ( !anchorSide )
1802 anchorSide = wxLEFT;
1803
1804 int rightX = scrPos.x + ctrlSz.x + m_extRight - szp.x;
1805 int leftX = scrPos.x - m_extLeft;
1806 int screenWidth = wxSystemSettings::GetMetric( wxSYS_SCREEN_X );
1807
1808 // If there is not enough horizontal space, anchor on the other side.
1809 // If there is no space even then, place the popup at x 0.
1810 if ( anchorSide == wxRIGHT )
1811 {
1812 if ( rightX < 0 )
1813 {
1814 if ( (leftX+szp.x) < screenWidth )
1815 anchorSide = wxLEFT;
1816 else
1817 anchorSide = 0;
1818 }
1819 }
1820 else
1821 {
1822 if ( (leftX+szp.x) >= screenWidth )
1823 {
1824 if ( rightX >= 0 )
1825 anchorSide = wxRIGHT;
1826 else
1827 anchorSide = 0;
1828 }
1829 }
1830
1831 // Select x coordinate according to the anchor side
1832 if ( anchorSide == wxRIGHT )
1833 popupX = rightX;
1834 else if ( anchorSide == wxLEFT )
1835 popupX = leftX;
1836 else
1837 popupX = 0;
1838
1839 int showFlags = CanDeferShow;
1840
1841 if ( spaceBelow < szp.y )
1842 {
1843 popupY = scrPos.y - szp.y;
1844 showFlags |= ShowAbove;
1845 }
1846
1847 #if INSTALL_TOPLEV_HANDLER
1848 // Put top level window event handler into place
1849 if ( m_popupWinType == POPUPWIN_WXPOPUPWINDOW )
1850 {
1851 if ( !m_toplevEvtHandler )
1852 m_toplevEvtHandler = new wxComboFrameEventHandler(this);
1853
1854 wxWindow* toplev = ::wxGetTopLevelParent( this );
1855 wxASSERT( toplev );
1856 ((wxComboFrameEventHandler*)m_toplevEvtHandler)->OnPopup();
1857 toplev->PushEventHandler( m_toplevEvtHandler );
1858 }
1859 #endif
1860
1861 // Set string selection (must be this way instead of SetStringSelection)
1862 if ( m_text )
1863 {
1864 if ( !(m_iFlags & wxCC_NO_TEXT_AUTO_SELECT) )
1865 m_text->SelectAll();
1866
1867 m_popupInterface->SetStringValue( m_text->GetValue() );
1868 }
1869 else
1870 {
1871 // This is neede since focus/selection indication may change when popup is shown
1872 Refresh();
1873 }
1874
1875 // This must be after SetStringValue
1876 m_popupWinState = Animating;
1877
1878 wxRect popupWinRect( popupX, popupY, szp.x, szp.y );
1879
1880 m_popup = popup;
1881 if ( (m_iFlags & wxCC_IFLAG_DISABLE_POPUP_ANIM) ||
1882 AnimateShow( popupWinRect, showFlags ) )
1883 {
1884 DoShowPopup( popupWinRect, showFlags );
1885 }
1886 }
1887
1888 bool wxComboCtrlBase::AnimateShow( const wxRect& WXUNUSED(rect), int WXUNUSED(flags) )
1889 {
1890 return true;
1891 }
1892
1893 void wxComboCtrlBase::DoShowPopup( const wxRect& rect, int WXUNUSED(flags) )
1894 {
1895 wxWindow* winPopup = m_winPopup;
1896
1897 if ( IsPopupWindowState(Animating) )
1898 {
1899 // Make sure the popup window is shown in the right position.
1900 // Should not matter even if animation already did this.
1901
1902 // Some platforms (GTK) may like SetSize and Move to be separate
1903 // (though the bug was probably fixed).
1904 winPopup->SetSize( rect );
1905
1906 winPopup->Show();
1907
1908 m_popupWinState = Visible;
1909 }
1910 else if ( IsPopupWindowState(Hidden) )
1911 {
1912 // Animation was aborted
1913
1914 wxASSERT( !winPopup->IsShown() );
1915
1916 m_popupWinState = Hidden;
1917 }
1918 }
1919
1920 void wxComboCtrlBase::OnPopupDismiss()
1921 {
1922 // Just in case, avoid double dismiss
1923 if ( IsPopupWindowState(Hidden) )
1924 return;
1925
1926 // This must be set before focus - otherwise there will be recursive
1927 // OnPopupDismisses.
1928 m_popupWinState = Hidden;
1929
1930 //SetFocus();
1931 m_winPopup->Disable();
1932
1933 // Inform popup control itself
1934 m_popupInterface->OnDismiss();
1935
1936 if ( m_popupExtraHandler )
1937 ((wxComboPopupExtraEventHandler*)m_popupExtraHandler)->OnPopupDismiss();
1938
1939 #if INSTALL_TOPLEV_HANDLER
1940 // Remove top level window event handler
1941 if ( m_toplevEvtHandler )
1942 {
1943 wxWindow* toplev = ::wxGetTopLevelParent( this );
1944 if ( toplev )
1945 toplev->RemoveEventHandler( m_toplevEvtHandler );
1946 }
1947 #endif
1948
1949 m_timeCanAcceptClick = ::wxGetLocalTimeMillis();
1950
1951 if ( m_popupWinType == POPUPWIN_WXPOPUPTRANSIENTWINDOW )
1952 m_timeCanAcceptClick += 150;
1953
1954 // If cursor not on dropdown button, then clear its state
1955 // (technically not required by all ports, but do it for all just in case)
1956 if ( !m_btnArea.Contains(ScreenToClient(::wxGetMousePosition())) )
1957 m_btnState = 0;
1958
1959 // Return parent's tab traversal flag.
1960 // See ShowPopup for notes.
1961 if ( m_iFlags & wxCC_IFLAG_PARENT_TAB_TRAVERSAL )
1962 {
1963 wxWindow* parent = GetParent();
1964 parent->SetWindowStyle( parent->GetWindowStyle() | wxTAB_TRAVERSAL );
1965 m_iFlags &= ~(wxCC_IFLAG_PARENT_TAB_TRAVERSAL);
1966 }
1967
1968 // refresh control (necessary even if m_text)
1969 Refresh();
1970
1971 SetFocus();
1972 }
1973
1974 void wxComboCtrlBase::HidePopup()
1975 {
1976 // Should be able to call this without popup interface
1977 if ( IsPopupWindowState(Hidden) )
1978 return;
1979
1980 // transfer value and show it in textctrl, if any
1981 if ( !IsPopupWindowState(Animating) )
1982 SetValue( m_popupInterface->GetStringValue() );
1983
1984 m_winPopup->Hide();
1985
1986 OnPopupDismiss();
1987 }
1988
1989 // ----------------------------------------------------------------------------
1990 // customization methods
1991 // ----------------------------------------------------------------------------
1992
1993 void wxComboCtrlBase::SetButtonPosition( int width, int height,
1994 int side, int spacingX )
1995 {
1996 m_btnWid = width;
1997 m_btnHei = height;
1998 m_btnSide = side;
1999 m_btnSpacingX = spacingX;
2000
2001 RecalcAndRefresh();
2002 }
2003
2004 wxSize wxComboCtrlBase::GetButtonSize()
2005 {
2006 if ( m_btnSize.x > 0 )
2007 return m_btnSize;
2008
2009 wxSize retSize(m_btnWid,m_btnHei);
2010
2011 // Need to call CalculateAreas now if button size is
2012 // is not explicitly specified.
2013 if ( retSize.x <= 0 || retSize.y <= 0)
2014 {
2015 OnResize();
2016
2017 retSize = m_btnSize;
2018 }
2019
2020 return retSize;
2021 }
2022
2023 void wxComboCtrlBase::SetButtonBitmaps( const wxBitmap& bmpNormal,
2024 bool blankButtonBg,
2025 const wxBitmap& bmpPressed,
2026 const wxBitmap& bmpHover,
2027 const wxBitmap& bmpDisabled )
2028 {
2029 m_bmpNormal = bmpNormal;
2030 m_blankButtonBg = blankButtonBg;
2031
2032 if ( bmpPressed.Ok() )
2033 m_bmpPressed = bmpPressed;
2034 else
2035 m_bmpPressed = bmpNormal;
2036
2037 if ( bmpHover.Ok() )
2038 m_bmpHover = bmpHover;
2039 else
2040 m_bmpHover = bmpNormal;
2041
2042 if ( bmpDisabled.Ok() )
2043 m_bmpDisabled = bmpDisabled;
2044 else
2045 m_bmpDisabled = bmpNormal;
2046
2047 RecalcAndRefresh();
2048 }
2049
2050 void wxComboCtrlBase::SetCustomPaintWidth( int width )
2051 {
2052 if ( m_text )
2053 {
2054 // move textctrl accordingly
2055 wxRect r = m_text->GetRect();
2056 int inc = width - m_widthCustomPaint;
2057 r.x += inc;
2058 r.width -= inc;
2059 m_text->SetSize( r );
2060 }
2061
2062 m_widthCustomPaint = width;
2063
2064 RecalcAndRefresh();
2065 }
2066
2067 void wxComboCtrlBase::SetTextIndent( int indent )
2068 {
2069 if ( indent < 0 )
2070 {
2071 m_absIndent = GetNativeTextIndent();
2072 m_iFlags &= ~(wxCC_IFLAG_INDENT_SET);
2073 }
2074 else
2075 {
2076 m_absIndent = indent;
2077 m_iFlags |= wxCC_IFLAG_INDENT_SET;
2078 }
2079
2080 RecalcAndRefresh();
2081 }
2082
2083 wxCoord wxComboCtrlBase::GetNativeTextIndent() const
2084 {
2085 return DEFAULT_TEXT_INDENT;
2086 }
2087
2088 // ----------------------------------------------------------------------------
2089 // methods forwarded to wxTextCtrl
2090 // ----------------------------------------------------------------------------
2091
2092 wxString wxComboCtrlBase::GetValue() const
2093 {
2094 if ( m_text )
2095 return m_text->GetValue();
2096 return m_valueString;
2097 }
2098
2099 void wxComboCtrlBase::SetValueWithEvent(const wxString& value, bool withEvent)
2100 {
2101 if ( m_text )
2102 {
2103 if ( !withEvent )
2104 m_ignoreEvtText++;
2105
2106 m_text->SetValue(value);
2107 if ( !(m_iFlags & wxCC_NO_TEXT_AUTO_SELECT) )
2108 m_text->SelectAll();
2109 }
2110
2111 m_valueString = value;
2112
2113 Refresh();
2114
2115 // Since wxComboPopup may want to paint the combo as well, we need
2116 // to set the string value here (as well as sometimes in ShowPopup).
2117 if ( m_valueString != value && m_popupInterface )
2118 {
2119 m_popupInterface->SetStringValue(value);
2120 }
2121 }
2122
2123 void wxComboCtrlBase::SetValue(const wxString& value)
2124 {
2125 SetValueWithEvent(value, false);
2126 }
2127
2128 // In this SetValue variant wxComboPopup::SetStringValue is not called
2129 void wxComboCtrlBase::SetText(const wxString& value)
2130 {
2131 // Unlike in SetValue(), this must be called here or
2132 // the behaviour will no be consistent in readonlys.
2133 EnsurePopupControl();
2134
2135 m_valueString = value;
2136
2137 if ( m_text )
2138 {
2139 m_ignoreEvtText++;
2140 m_text->SetValue( value );
2141 }
2142
2143 Refresh();
2144 }
2145
2146 void wxComboCtrlBase::Copy()
2147 {
2148 if ( m_text )
2149 m_text->Copy();
2150 }
2151
2152 void wxComboCtrlBase::Cut()
2153 {
2154 if ( m_text )
2155 m_text->Cut();
2156 }
2157
2158 void wxComboCtrlBase::Paste()
2159 {
2160 if ( m_text )
2161 m_text->Paste();
2162 }
2163
2164 void wxComboCtrlBase::SetInsertionPoint(long pos)
2165 {
2166 if ( m_text )
2167 m_text->SetInsertionPoint(pos);
2168 }
2169
2170 void wxComboCtrlBase::SetInsertionPointEnd()
2171 {
2172 if ( m_text )
2173 m_text->SetInsertionPointEnd();
2174 }
2175
2176 long wxComboCtrlBase::GetInsertionPoint() const
2177 {
2178 if ( m_text )
2179 return m_text->GetInsertionPoint();
2180
2181 return 0;
2182 }
2183
2184 long wxComboCtrlBase::GetLastPosition() const
2185 {
2186 if ( m_text )
2187 return m_text->GetLastPosition();
2188
2189 return 0;
2190 }
2191
2192 void wxComboCtrlBase::Replace(long from, long to, const wxString& value)
2193 {
2194 if ( m_text )
2195 m_text->Replace(from, to, value);
2196 }
2197
2198 void wxComboCtrlBase::Remove(long from, long to)
2199 {
2200 if ( m_text )
2201 m_text->Remove(from, to);
2202 }
2203
2204 void wxComboCtrlBase::SetSelection(long from, long to)
2205 {
2206 if ( m_text )
2207 m_text->SetSelection(from, to);
2208 }
2209
2210 void wxComboCtrlBase::Undo()
2211 {
2212 if ( m_text )
2213 m_text->Undo();
2214 }
2215
2216 #endif // wxUSE_COMBOCTRL