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