]>
Commit | Line | Data |
---|---|---|
1 | /////////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/common/popupcmn.cpp | |
3 | // Purpose: implementation of wxPopupTransientWindow | |
4 | // Author: Vadim Zeitlin | |
5 | // Modified by: | |
6 | // Created: 06.01.01 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr> | |
9 | // License: wxWindows licence | |
10 | /////////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // ============================================================================ | |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
20 | // For compilers that support precompilation, includes "wx.h". | |
21 | #include "wx/wxprec.h" | |
22 | ||
23 | #ifdef __BORLANDC__ | |
24 | #pragma hdrstop | |
25 | #endif | |
26 | ||
27 | #if wxUSE_POPUPWIN | |
28 | ||
29 | #include "wx/popupwin.h" | |
30 | ||
31 | #ifndef WX_PRECOMP | |
32 | #include "wx/combobox.h" // wxComboCtrl | |
33 | #include "wx/app.h" // wxPostEvent | |
34 | #include "wx/log.h" | |
35 | #endif //WX_PRECOMP | |
36 | ||
37 | #include "wx/display.h" | |
38 | #include "wx/recguard.h" | |
39 | ||
40 | #ifdef __WXUNIVERSAL__ | |
41 | #include "wx/univ/renderer.h" | |
42 | #include "wx/scrolbar.h" | |
43 | #endif // __WXUNIVERSAL__ | |
44 | ||
45 | #ifdef __WXGTK__ | |
46 | #include <gtk/gtk.h> | |
47 | #elif defined(__WXMSW__) | |
48 | #include "wx/msw/private.h" | |
49 | #elif defined(__WXX11__) | |
50 | #include "wx/x11/private.h" | |
51 | #endif | |
52 | ||
53 | IMPLEMENT_DYNAMIC_CLASS(wxPopupWindow, wxWindow) | |
54 | IMPLEMENT_DYNAMIC_CLASS(wxPopupTransientWindow, wxPopupWindow) | |
55 | ||
56 | #if wxUSE_COMBOBOX && defined(__WXUNIVERSAL__) | |
57 | IMPLEMENT_DYNAMIC_CLASS(wxPopupComboWindow, wxPopupTransientWindow) | |
58 | #endif | |
59 | ||
60 | // ---------------------------------------------------------------------------- | |
61 | // private classes | |
62 | // ---------------------------------------------------------------------------- | |
63 | ||
64 | // event handlers which we use to intercept events which cause the popup to | |
65 | // disappear | |
66 | class wxPopupWindowHandler : public wxEvtHandler | |
67 | { | |
68 | public: | |
69 | wxPopupWindowHandler(wxPopupTransientWindow *popup) : m_popup(popup) {} | |
70 | ||
71 | protected: | |
72 | // event handlers | |
73 | void OnLeftDown(wxMouseEvent& event); | |
74 | ||
75 | private: | |
76 | wxPopupTransientWindow *m_popup; | |
77 | ||
78 | DECLARE_EVENT_TABLE() | |
79 | wxDECLARE_NO_COPY_CLASS(wxPopupWindowHandler); | |
80 | }; | |
81 | ||
82 | class wxPopupFocusHandler : public wxEvtHandler | |
83 | { | |
84 | public: | |
85 | wxPopupFocusHandler(wxPopupTransientWindow *popup) : m_popup(popup) {} | |
86 | ||
87 | protected: | |
88 | void OnKillFocus(wxFocusEvent& event); | |
89 | void OnKeyDown(wxKeyEvent& event); | |
90 | ||
91 | private: | |
92 | wxPopupTransientWindow *m_popup; | |
93 | ||
94 | DECLARE_EVENT_TABLE() | |
95 | wxDECLARE_NO_COPY_CLASS(wxPopupFocusHandler); | |
96 | }; | |
97 | ||
98 | // ---------------------------------------------------------------------------- | |
99 | // event tables | |
100 | // ---------------------------------------------------------------------------- | |
101 | ||
102 | BEGIN_EVENT_TABLE(wxPopupWindowHandler, wxEvtHandler) | |
103 | EVT_LEFT_DOWN(wxPopupWindowHandler::OnLeftDown) | |
104 | END_EVENT_TABLE() | |
105 | ||
106 | BEGIN_EVENT_TABLE(wxPopupFocusHandler, wxEvtHandler) | |
107 | EVT_KILL_FOCUS(wxPopupFocusHandler::OnKillFocus) | |
108 | EVT_KEY_DOWN(wxPopupFocusHandler::OnKeyDown) | |
109 | END_EVENT_TABLE() | |
110 | ||
111 | BEGIN_EVENT_TABLE(wxPopupTransientWindow, wxPopupWindow) | |
112 | #if defined( __WXMSW__ ) || defined( __WXMAC__) | |
113 | EVT_IDLE(wxPopupTransientWindow::OnIdle) | |
114 | #endif | |
115 | END_EVENT_TABLE() | |
116 | ||
117 | // ============================================================================ | |
118 | // implementation | |
119 | // ============================================================================ | |
120 | ||
121 | // ---------------------------------------------------------------------------- | |
122 | // wxPopupWindowBase | |
123 | // ---------------------------------------------------------------------------- | |
124 | ||
125 | wxPopupWindowBase::~wxPopupWindowBase() | |
126 | { | |
127 | // this destructor is required for Darwin | |
128 | } | |
129 | ||
130 | bool wxPopupWindowBase::Create(wxWindow* WXUNUSED(parent), int WXUNUSED(flags)) | |
131 | { | |
132 | return true; | |
133 | } | |
134 | ||
135 | void wxPopupWindowBase::Position(const wxPoint& ptOrigin, | |
136 | const wxSize& size) | |
137 | { | |
138 | // determine the position and size of the screen we clamp the popup to | |
139 | wxPoint posScreen; | |
140 | wxSize sizeScreen; | |
141 | ||
142 | const int displayNum = wxDisplay::GetFromPoint(ptOrigin); | |
143 | if ( displayNum != wxNOT_FOUND ) | |
144 | { | |
145 | const wxRect rectScreen = wxDisplay(displayNum).GetGeometry(); | |
146 | posScreen = rectScreen.GetPosition(); | |
147 | sizeScreen = rectScreen.GetSize(); | |
148 | } | |
149 | else // outside of any display? | |
150 | { | |
151 | // just use the primary one then | |
152 | posScreen = wxPoint(0, 0); | |
153 | sizeScreen = wxGetDisplaySize(); | |
154 | } | |
155 | ||
156 | ||
157 | const wxSize sizeSelf = GetSize(); | |
158 | ||
159 | // is there enough space to put the popup below the window (where we put it | |
160 | // by default)? | |
161 | wxCoord y = ptOrigin.y + size.y; | |
162 | if ( y + sizeSelf.y > posScreen.y + sizeScreen.y ) | |
163 | { | |
164 | // check if there is enough space above | |
165 | if ( ptOrigin.y > sizeSelf.y ) | |
166 | { | |
167 | // do position the control above the window | |
168 | y -= size.y + sizeSelf.y; | |
169 | } | |
170 | //else: not enough space below nor above, leave below | |
171 | } | |
172 | ||
173 | // now check left/right too | |
174 | wxCoord x = ptOrigin.x; | |
175 | ||
176 | if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft ) | |
177 | { | |
178 | // shift the window to the left instead of the right. | |
179 | x -= size.x; | |
180 | x -= sizeSelf.x; // also shift it by window width. | |
181 | } | |
182 | else | |
183 | x += size.x; | |
184 | ||
185 | ||
186 | if ( x + sizeSelf.x > posScreen.x + sizeScreen.x ) | |
187 | { | |
188 | // check if there is enough space to the left | |
189 | if ( ptOrigin.x > sizeSelf.x ) | |
190 | { | |
191 | // do position the control to the left | |
192 | x -= size.x + sizeSelf.x; | |
193 | } | |
194 | //else: not enough space there neither, leave in default position | |
195 | } | |
196 | ||
197 | Move(x, y, wxSIZE_NO_ADJUSTMENTS); | |
198 | } | |
199 | ||
200 | // ---------------------------------------------------------------------------- | |
201 | // wxPopupTransientWindow | |
202 | // ---------------------------------------------------------------------------- | |
203 | ||
204 | void wxPopupTransientWindow::Init() | |
205 | { | |
206 | m_child = | |
207 | m_focus = NULL; | |
208 | ||
209 | m_handlerFocus = NULL; | |
210 | m_handlerPopup = NULL; | |
211 | } | |
212 | ||
213 | wxPopupTransientWindow::wxPopupTransientWindow(wxWindow *parent, int style) | |
214 | { | |
215 | Init(); | |
216 | ||
217 | (void)Create(parent, style); | |
218 | } | |
219 | ||
220 | wxPopupTransientWindow::~wxPopupTransientWindow() | |
221 | { | |
222 | if (m_handlerPopup && m_handlerPopup->GetNextHandler()) | |
223 | PopHandlers(); | |
224 | ||
225 | wxASSERT(!m_handlerFocus || !m_handlerFocus->GetNextHandler()); | |
226 | wxASSERT(!m_handlerPopup || !m_handlerPopup->GetNextHandler()); | |
227 | ||
228 | delete m_handlerFocus; | |
229 | delete m_handlerPopup; | |
230 | } | |
231 | ||
232 | void wxPopupTransientWindow::PopHandlers() | |
233 | { | |
234 | if ( m_child ) | |
235 | { | |
236 | if ( !m_child->RemoveEventHandler(m_handlerPopup) ) | |
237 | { | |
238 | // something is very wrong and someone else probably deleted our | |
239 | // handler - so don't risk deleting it second time | |
240 | m_handlerPopup = NULL; | |
241 | } | |
242 | if (m_child->HasCapture()) | |
243 | { | |
244 | m_child->ReleaseMouse(); | |
245 | } | |
246 | m_child = NULL; | |
247 | } | |
248 | ||
249 | if ( m_focus ) | |
250 | { | |
251 | if ( !m_focus->RemoveEventHandler(m_handlerFocus) ) | |
252 | { | |
253 | // see above | |
254 | m_handlerFocus = NULL; | |
255 | } | |
256 | } | |
257 | m_focus = NULL; | |
258 | } | |
259 | ||
260 | void wxPopupTransientWindow::Popup(wxWindow *winFocus) | |
261 | { | |
262 | const wxWindowList& children = GetChildren(); | |
263 | if ( children.GetCount() ) | |
264 | { | |
265 | m_child = children.GetFirst()->GetData(); | |
266 | } | |
267 | else | |
268 | { | |
269 | m_child = this; | |
270 | } | |
271 | ||
272 | Show(); | |
273 | ||
274 | // There is a problem if these are still in use | |
275 | wxASSERT(!m_handlerFocus || !m_handlerFocus->GetNextHandler()); | |
276 | wxASSERT(!m_handlerPopup || !m_handlerPopup->GetNextHandler()); | |
277 | ||
278 | if (!m_handlerPopup) | |
279 | m_handlerPopup = new wxPopupWindowHandler(this); | |
280 | ||
281 | m_child->PushEventHandler(m_handlerPopup); | |
282 | ||
283 | #if defined(__WXMSW__) | |
284 | // Focusing on child of popup window does not work on MSW unless WS_POPUP | |
285 | // style is set. We do not even want to try to set the focus, as it may | |
286 | // provoke errors on some Windows versions (Vista and later). | |
287 | if ( ::GetWindowLong(GetHwnd(), GWL_STYLE) & WS_POPUP ) | |
288 | #endif | |
289 | { | |
290 | m_focus = winFocus ? winFocus : this; | |
291 | m_focus->SetFocus(); | |
292 | } | |
293 | ||
294 | #if defined( __WXMSW__ ) || (defined( __WXMAC__) && wxOSX_USE_CARBON) | |
295 | // MSW doesn't allow to set focus to the popup window, but we need to | |
296 | // subclass the window which has the focus, and not winFocus passed in or | |
297 | // otherwise everything else breaks down | |
298 | m_focus = FindFocus(); | |
299 | #elif defined(__WXGTK__) | |
300 | // GTK+ catches the activate events from the popup | |
301 | // window, not the focus events from the child window | |
302 | m_focus = this; | |
303 | #endif | |
304 | ||
305 | if ( m_focus ) | |
306 | { | |
307 | if (!m_handlerFocus) | |
308 | m_handlerFocus = new wxPopupFocusHandler(this); | |
309 | ||
310 | m_focus->PushEventHandler(m_handlerFocus); | |
311 | } | |
312 | } | |
313 | ||
314 | bool wxPopupTransientWindow::Show( bool show ) | |
315 | { | |
316 | #ifdef __WXGTK__ | |
317 | if (!show) | |
318 | { | |
319 | gdk_pointer_ungrab( (guint32)GDK_CURRENT_TIME ); | |
320 | ||
321 | gtk_grab_remove( m_widget ); | |
322 | } | |
323 | #endif | |
324 | ||
325 | #ifdef __WXX11__ | |
326 | if (!show) | |
327 | { | |
328 | XUngrabPointer( wxGlobalDisplay(), CurrentTime ); | |
329 | } | |
330 | #endif | |
331 | ||
332 | #if defined( __WXMSW__ ) || defined( __WXMAC__) | |
333 | if (!show && m_child && m_child->HasCapture()) | |
334 | { | |
335 | m_child->ReleaseMouse(); | |
336 | } | |
337 | #endif | |
338 | ||
339 | bool ret = wxPopupWindow::Show( show ); | |
340 | ||
341 | #ifdef __WXGTK__ | |
342 | if (show) | |
343 | { | |
344 | gtk_grab_add( m_widget ); | |
345 | ||
346 | gdk_pointer_grab( m_widget->window, TRUE, | |
347 | (GdkEventMask) | |
348 | (GDK_BUTTON_PRESS_MASK | | |
349 | GDK_BUTTON_RELEASE_MASK | | |
350 | GDK_POINTER_MOTION_HINT_MASK | | |
351 | GDK_POINTER_MOTION_MASK), | |
352 | NULL, | |
353 | NULL, | |
354 | (guint32)GDK_CURRENT_TIME ); | |
355 | } | |
356 | #endif | |
357 | ||
358 | #ifdef __WXX11__ | |
359 | if (show) | |
360 | { | |
361 | Window xwindow = (Window) m_clientWindow; | |
362 | ||
363 | /* int res =*/ XGrabPointer(wxGlobalDisplay(), xwindow, | |
364 | True, | |
365 | ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask, | |
366 | GrabModeAsync, | |
367 | GrabModeAsync, | |
368 | None, | |
369 | None, | |
370 | CurrentTime ); | |
371 | } | |
372 | #endif | |
373 | ||
374 | #if defined( __WXMSW__ ) || defined( __WXMAC__) | |
375 | if (show && m_child) | |
376 | { | |
377 | // Assume that the mouse is outside the popup to begin with | |
378 | m_child->CaptureMouse(); | |
379 | } | |
380 | #endif | |
381 | ||
382 | return ret; | |
383 | } | |
384 | ||
385 | void wxPopupTransientWindow::Dismiss() | |
386 | { | |
387 | Hide(); | |
388 | PopHandlers(); | |
389 | } | |
390 | ||
391 | void wxPopupTransientWindow::DismissAndNotify() | |
392 | { | |
393 | Dismiss(); | |
394 | OnDismiss(); | |
395 | } | |
396 | ||
397 | void wxPopupTransientWindow::OnDismiss() | |
398 | { | |
399 | // nothing to do here - but it may be interesting for derived class | |
400 | } | |
401 | ||
402 | bool wxPopupTransientWindow::ProcessLeftDown(wxMouseEvent& WXUNUSED(event)) | |
403 | { | |
404 | // no special processing here | |
405 | return false; | |
406 | } | |
407 | ||
408 | #if defined( __WXMSW__ ) || defined( __WXMAC__) | |
409 | void wxPopupTransientWindow::OnIdle(wxIdleEvent& event) | |
410 | { | |
411 | event.Skip(); | |
412 | ||
413 | if (IsShown() && m_child) | |
414 | { | |
415 | wxPoint pos = ScreenToClient(wxGetMousePosition()); | |
416 | wxRect rect(GetSize()); | |
417 | ||
418 | if ( rect.Contains(pos) ) | |
419 | { | |
420 | if ( m_child->HasCapture() ) | |
421 | { | |
422 | m_child->ReleaseMouse(); | |
423 | } | |
424 | } | |
425 | else | |
426 | { | |
427 | if ( !m_child->HasCapture() ) | |
428 | { | |
429 | m_child->CaptureMouse(); | |
430 | } | |
431 | } | |
432 | } | |
433 | } | |
434 | #endif // __WXMSW__ | |
435 | ||
436 | ||
437 | #if wxUSE_COMBOBOX && defined(__WXUNIVERSAL__) | |
438 | ||
439 | // ---------------------------------------------------------------------------- | |
440 | // wxPopupComboWindow | |
441 | // ---------------------------------------------------------------------------- | |
442 | ||
443 | BEGIN_EVENT_TABLE(wxPopupComboWindow, wxPopupTransientWindow) | |
444 | EVT_KEY_DOWN(wxPopupComboWindow::OnKeyDown) | |
445 | END_EVENT_TABLE() | |
446 | ||
447 | wxPopupComboWindow::wxPopupComboWindow(wxComboCtrl *parent) | |
448 | : wxPopupTransientWindow(parent) | |
449 | { | |
450 | m_combo = parent; | |
451 | } | |
452 | ||
453 | bool wxPopupComboWindow::Create(wxComboCtrl *parent) | |
454 | { | |
455 | m_combo = parent; | |
456 | ||
457 | return wxPopupWindow::Create(parent); | |
458 | } | |
459 | ||
460 | void wxPopupComboWindow::PositionNearCombo() | |
461 | { | |
462 | // the origin point must be in screen coords | |
463 | wxPoint ptOrigin = m_combo->ClientToScreen(wxPoint(0,0)); | |
464 | ||
465 | #if 0 //def __WXUNIVERSAL__ | |
466 | // account for the fact that (0, 0) is not the top left corner of the | |
467 | // window: there is also the border | |
468 | wxRect rectBorders = m_combo->GetRenderer()-> | |
469 | GetBorderDimensions(m_combo->GetBorder()); | |
470 | ptOrigin.x -= rectBorders.x; | |
471 | ptOrigin.y -= rectBorders.y; | |
472 | #endif // __WXUNIVERSAL__ | |
473 | ||
474 | // position below or above the combobox: the width is 0 to put it exactly | |
475 | // below us, not to the left or to the right | |
476 | Position(ptOrigin, wxSize(0, m_combo->GetSize().y)); | |
477 | } | |
478 | ||
479 | void wxPopupComboWindow::OnDismiss() | |
480 | { | |
481 | m_combo->OnPopupDismiss(); | |
482 | } | |
483 | ||
484 | void wxPopupComboWindow::OnKeyDown(wxKeyEvent& event) | |
485 | { | |
486 | m_combo->ProcessWindowEvent(event); | |
487 | } | |
488 | ||
489 | #endif // wxUSE_COMBOBOX && defined(__WXUNIVERSAL__) | |
490 | ||
491 | // ---------------------------------------------------------------------------- | |
492 | // wxPopupWindowHandler | |
493 | // ---------------------------------------------------------------------------- | |
494 | ||
495 | void wxPopupWindowHandler::OnLeftDown(wxMouseEvent& event) | |
496 | { | |
497 | // let the window have it first (we're the first event handler in the chain | |
498 | // of handlers for this window) | |
499 | if ( m_popup->ProcessLeftDown(event) ) | |
500 | { | |
501 | return; | |
502 | } | |
503 | ||
504 | wxPoint pos = event.GetPosition(); | |
505 | ||
506 | // in non-Univ ports the system manages scrollbars for us | |
507 | #if defined(__WXUNIVERSAL__) && wxUSE_SCROLLBAR | |
508 | // scrollbar on which the click occurred | |
509 | wxWindow *sbar = NULL; | |
510 | #endif // __WXUNIVERSAL__ && wxUSE_SCROLLBAR | |
511 | ||
512 | wxWindow *win = (wxWindow *)event.GetEventObject(); | |
513 | ||
514 | switch ( win->HitTest(pos.x, pos.y) ) | |
515 | { | |
516 | case wxHT_WINDOW_OUTSIDE: | |
517 | { | |
518 | // do the coords translation now as after DismissAndNotify() | |
519 | // m_popup may be destroyed | |
520 | wxMouseEvent event2(event); | |
521 | ||
522 | m_popup->ClientToScreen(&event2.m_x, &event2.m_y); | |
523 | ||
524 | // clicking outside a popup dismisses it | |
525 | m_popup->DismissAndNotify(); | |
526 | ||
527 | // dismissing a tooltip shouldn't waste a click, i.e. you | |
528 | // should be able to dismiss it and press the button with the | |
529 | // same click, so repost this event to the window beneath us | |
530 | wxWindow *winUnder = wxFindWindowAtPoint(event2.GetPosition()); | |
531 | if ( winUnder ) | |
532 | { | |
533 | // translate the event coords to the ones of the window | |
534 | // which is going to get the event | |
535 | winUnder->ScreenToClient(&event2.m_x, &event2.m_y); | |
536 | ||
537 | event2.SetEventObject(winUnder); | |
538 | wxPostEvent(winUnder->GetEventHandler(), event2); | |
539 | } | |
540 | } | |
541 | break; | |
542 | ||
543 | #if defined(__WXUNIVERSAL__) && wxUSE_SCROLLBAR | |
544 | case wxHT_WINDOW_HORZ_SCROLLBAR: | |
545 | sbar = win->GetScrollbar(wxHORIZONTAL); | |
546 | break; | |
547 | ||
548 | case wxHT_WINDOW_VERT_SCROLLBAR: | |
549 | sbar = win->GetScrollbar(wxVERTICAL); | |
550 | break; | |
551 | #endif // __WXUNIVERSAL__ && wxUSE_SCROLLBAR | |
552 | ||
553 | default: | |
554 | // forgot to update the switch after adding a new hit test code? | |
555 | wxFAIL_MSG( _T("unexpected HitTest() return value") ); | |
556 | // fall through | |
557 | ||
558 | case wxHT_WINDOW_CORNER: | |
559 | // don't actually know if this one is good for anything, but let it | |
560 | // pass just in case | |
561 | ||
562 | case wxHT_WINDOW_INSIDE: | |
563 | // let the normal processing take place | |
564 | event.Skip(); | |
565 | break; | |
566 | } | |
567 | ||
568 | #if defined(__WXUNIVERSAL__) && wxUSE_SCROLLBAR | |
569 | if ( sbar ) | |
570 | { | |
571 | // translate the event coordinates to the scrollbar ones | |
572 | pos = sbar->ScreenToClient(win->ClientToScreen(pos)); | |
573 | ||
574 | // and give the event to it | |
575 | wxMouseEvent event2 = event; | |
576 | event2.m_x = pos.x; | |
577 | event2.m_y = pos.y; | |
578 | ||
579 | (void)sbar->GetEventHandler()->ProcessEvent(event2); | |
580 | } | |
581 | #endif // __WXUNIVERSAL__ && wxUSE_SCROLLBAR | |
582 | } | |
583 | ||
584 | // ---------------------------------------------------------------------------- | |
585 | // wxPopupFocusHandler | |
586 | // ---------------------------------------------------------------------------- | |
587 | ||
588 | void wxPopupFocusHandler::OnKillFocus(wxFocusEvent& event) | |
589 | { | |
590 | // when we lose focus we always disappear - unless it goes to the popup (in | |
591 | // which case we don't really lose it) | |
592 | wxWindow *win = event.GetWindow(); | |
593 | while ( win ) | |
594 | { | |
595 | if ( win == m_popup ) | |
596 | return; | |
597 | win = win->GetParent(); | |
598 | } | |
599 | ||
600 | m_popup->DismissAndNotify(); | |
601 | } | |
602 | ||
603 | void wxPopupFocusHandler::OnKeyDown(wxKeyEvent& event) | |
604 | { | |
605 | // we can be associated with the popup itself in which case we should avoid | |
606 | // infinite recursion | |
607 | static int s_inside; | |
608 | wxRecursionGuard guard(s_inside); | |
609 | if ( guard.IsInside() ) | |
610 | { | |
611 | event.Skip(); | |
612 | return; | |
613 | } | |
614 | ||
615 | // let the window have it first, it might process the keys | |
616 | if ( !m_popup->GetEventHandler()->ProcessEvent(event) ) | |
617 | { | |
618 | // by default, dismiss the popup | |
619 | m_popup->DismissAndNotify(); | |
620 | } | |
621 | } | |
622 | ||
623 | #endif // wxUSE_POPUPWIN |