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