]> git.saurik.com Git - wxWidgets.git/blob - tests/events/propagation.cpp
Somehow, setting a tint color makes gauge work :/.
[wxWidgets.git] / tests / events / propagation.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: tests/events/propagation.cpp
3 // Purpose: Test events propagation
4 // Author: Vadim Zeitlin
5 // Created: 2009-01-16
6 // Copyright: (c) 2009 Vadim Zeitlin <vadim@wxwidgets.org>
7 ///////////////////////////////////////////////////////////////////////////////
8
9 // ----------------------------------------------------------------------------
10 // headers
11 // ----------------------------------------------------------------------------
12
13 #include "testprec.h"
14
15 #ifdef __BORLANDC__
16 #pragma hdrstop
17 #endif
18
19 #ifndef WX_PRECOMP
20 #include "wx/app.h"
21 #include "wx/event.h"
22 #include "wx/scrolwin.h"
23 #include "wx/window.h"
24 #endif // WX_PRECOMP
25
26 #include "wx/docmdi.h"
27 #include "wx/frame.h"
28 #include "wx/menu.h"
29 #include "wx/scopedptr.h"
30 #include "wx/scopeguard.h"
31 #include "wx/toolbar.h"
32 #include "wx/uiaction.h"
33
34 // FIXME: Currently under OS X testing paint event doesn't work because neither
35 // calling Refresh()+Update() nor even sending wxPaintEvent directly to
36 // the window doesn't result in calls to its event handlers, so disable
37 // some tests there. But this should be fixed and the tests reenabled
38 // because wxPaintEvent propagation in wxScrolledWindow is a perfect
39 // example of fragile code that could be broken under OS X.
40 #ifndef __WXOSX__
41 #define CAN_TEST_PAINT_EVENTS
42 #endif
43
44 namespace
45 {
46
47 // this string will record the execution of all handlers
48 wxString g_str;
49
50 // a custom event
51 wxDEFINE_EVENT(TEST_EVT, wxCommandEvent);
52
53 // a custom event handler tracing the propagation of the events of the
54 // specified types
55 template <class Event>
56 class TestEvtHandlerBase : public wxEvtHandler
57 {
58 public:
59 TestEvtHandlerBase(wxEventType evtType, char tag)
60 : m_evtType(evtType),
61 m_tag(tag)
62 {
63 Connect(evtType,
64 static_cast<wxEventFunction>(&TestEvtHandlerBase::OnTest));
65 }
66
67 // override ProcessEvent() to confirm that it is called for all event
68 // handlers in the chain
69 virtual bool ProcessEvent(wxEvent& event)
70 {
71 if ( event.GetEventType() == m_evtType )
72 g_str += 'o'; // "o" == "overridden"
73
74 return wxEvtHandler::ProcessEvent(event);
75 }
76
77 private:
78 void OnTest(wxEvent& event)
79 {
80 g_str += m_tag;
81
82 event.Skip();
83 }
84
85 const wxEventType m_evtType;
86 const char m_tag;
87
88 wxDECLARE_NO_COPY_TEMPLATE_CLASS(TestEvtHandlerBase, Event);
89 };
90
91 struct TestEvtHandler : TestEvtHandlerBase<wxCommandEvent>
92 {
93 TestEvtHandler(char tag)
94 : TestEvtHandlerBase<wxCommandEvent>(TEST_EVT, tag)
95 {
96 }
97 };
98
99 struct TestMenuEvtHandler : TestEvtHandlerBase<wxCommandEvent>
100 {
101 TestMenuEvtHandler(char tag)
102 : TestEvtHandlerBase<wxCommandEvent>(wxEVT_MENU, tag)
103 {
104 }
105 };
106
107 struct TestPaintEvtHandler : TestEvtHandlerBase<wxPaintEvent>
108 {
109 TestPaintEvtHandler(char tag)
110 : TestEvtHandlerBase<wxPaintEvent>(wxEVT_PAINT, tag)
111 {
112 }
113 };
114
115 // Another custom event handler, suitable for use with Connect().
116 struct TestEvtSink : wxEvtHandler
117 {
118 TestEvtSink(char tag)
119 : m_tag(tag)
120 {
121 }
122
123 void Handle(wxEvent& event)
124 {
125 g_str += m_tag;
126
127 event.Skip();
128 }
129
130 const char m_tag;
131
132 wxDECLARE_NO_COPY_CLASS(TestEvtSink);
133 };
134
135 // a window handling the test event
136 class TestWindow : public wxWindow
137 {
138 public:
139 TestWindow(wxWindow *parent, char tag)
140 : wxWindow(parent, wxID_ANY),
141 m_tag(tag)
142 {
143 Connect(TEST_EVT, wxCommandEventHandler(TestWindow::OnTest));
144 }
145
146 private:
147 void OnTest(wxCommandEvent& event)
148 {
149 g_str += m_tag;
150
151 event.Skip();
152 }
153
154 const char m_tag;
155
156 DECLARE_NO_COPY_CLASS(TestWindow)
157 };
158
159 // a scroll window handling paint event: we want to have a special test case
160 // for this because the event propagation is complicated even further than
161 // usual here by the presence of wxScrollHelperEvtHandler in the event handlers
162 // chain and the fact that OnDraw() virtual method must be called if EVT_PAINT
163 // is not handled
164 class TestScrollWindow : public wxScrolledWindow
165 {
166 public:
167 TestScrollWindow(wxWindow *parent)
168 : wxScrolledWindow(parent, wxID_ANY)
169 {
170 Connect(wxEVT_PAINT, wxPaintEventHandler(TestScrollWindow::OnPaint));
171 }
172
173 void GeneratePaintEvent()
174 {
175 #ifdef __WXGTK__
176 // We need to map the window, otherwise we're not going to get any
177 // paint events for it.
178 wxYield();
179
180 // Ignore events generated during the initial mapping.
181 g_str.clear();
182 #endif // __WXGTK__
183
184 Refresh();
185 Update();
186 }
187
188 virtual void OnDraw(wxDC& WXUNUSED(dc))
189 {
190 g_str += 'D'; // draw
191 }
192
193 private:
194 void OnPaint(wxPaintEvent& event)
195 {
196 g_str += 'P'; // paint
197 event.Skip();
198 }
199
200 wxDECLARE_NO_COPY_CLASS(TestScrollWindow);
201 };
202
203 int DoFilterEvent(wxEvent& event)
204 {
205 if ( event.GetEventType() == TEST_EVT ||
206 event.GetEventType() == wxEVT_MENU )
207 g_str += 'a';
208
209 return -1;
210 }
211
212 bool DoProcessEvent(wxEvent& event)
213 {
214 if ( event.GetEventType() == TEST_EVT ||
215 event.GetEventType() == wxEVT_MENU )
216 g_str += 'A';
217
218 return false;
219 }
220
221 } // anonymous namespace
222
223 // --------------------------------------------------------------------------
224 // test class
225 // --------------------------------------------------------------------------
226
227 class EventPropagationTestCase : public CppUnit::TestCase
228 {
229 public:
230 EventPropagationTestCase() {}
231
232 virtual void setUp();
233 virtual void tearDown();
234
235 private:
236 CPPUNIT_TEST_SUITE( EventPropagationTestCase );
237 CPPUNIT_TEST( OneHandler );
238 CPPUNIT_TEST( TwoHandlers );
239 CPPUNIT_TEST( WindowWithoutHandler );
240 CPPUNIT_TEST( WindowWithHandler );
241 CPPUNIT_TEST( ForwardEvent );
242 CPPUNIT_TEST( ScrollWindowWithoutHandler );
243 CPPUNIT_TEST( ScrollWindowWithHandler );
244 CPPUNIT_TEST( MenuEvent );
245 CPPUNIT_TEST( DocView );
246 WXUISIM_TEST( ContextMenuEvent );
247 CPPUNIT_TEST_SUITE_END();
248
249 void OneHandler();
250 void TwoHandlers();
251 void WindowWithoutHandler();
252 void WindowWithHandler();
253 void ForwardEvent();
254 void ScrollWindowWithoutHandler();
255 void ScrollWindowWithHandler();
256 void MenuEvent();
257 void DocView();
258 void ContextMenuEvent();
259
260 DECLARE_NO_COPY_CLASS(EventPropagationTestCase)
261 };
262
263 // register in the unnamed registry so that these tests are run by default
264 CPPUNIT_TEST_SUITE_REGISTRATION( EventPropagationTestCase );
265
266 // also include in its own registry so that these tests can be run alone
267 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( EventPropagationTestCase, "EventPropagationTestCase" );
268
269 void EventPropagationTestCase::setUp()
270 {
271 SetFilterEventFunc(DoFilterEvent);
272 SetProcessEventFunc(DoProcessEvent);
273
274 g_str.clear();
275 }
276
277 void EventPropagationTestCase::tearDown()
278 {
279 SetFilterEventFunc(NULL);
280 SetProcessEventFunc(NULL);
281 }
282
283 void EventPropagationTestCase::OneHandler()
284 {
285 wxCommandEvent event(TEST_EVT);
286 TestEvtHandler h1('1');
287 h1.ProcessEvent(event);
288 CPPUNIT_ASSERT_EQUAL( "oa1A", g_str );
289 }
290
291 void EventPropagationTestCase::TwoHandlers()
292 {
293 wxCommandEvent event(TEST_EVT);
294 TestEvtHandler h1('1');
295 TestEvtHandler h2('2');
296 h1.SetNextHandler(&h2);
297 h2.SetPreviousHandler(&h1);
298 h1.ProcessEvent(event);
299 CPPUNIT_ASSERT_EQUAL( "oa1o2A", g_str );
300 }
301
302 void EventPropagationTestCase::WindowWithoutHandler()
303 {
304 wxCommandEvent event(TEST_EVT);
305 TestWindow * const parent = new TestWindow(wxTheApp->GetTopWindow(), 'p');
306 wxON_BLOCK_EXIT_OBJ0( *parent, wxWindow::Destroy );
307
308 TestWindow * const child = new TestWindow(parent, 'c');
309
310 child->GetEventHandler()->ProcessEvent(event);
311 CPPUNIT_ASSERT_EQUAL( "acpA", g_str );
312 }
313
314 void EventPropagationTestCase::WindowWithHandler()
315 {
316 wxCommandEvent event(TEST_EVT);
317 TestWindow * const parent = new TestWindow(wxTheApp->GetTopWindow(), 'p');
318 wxON_BLOCK_EXIT_OBJ0( *parent, wxWindow::Destroy );
319
320 TestWindow * const child = new TestWindow(parent, 'c');
321
322 TestEvtHandler h1('1');
323 child->PushEventHandler(&h1);
324 wxON_BLOCK_EXIT_OBJ1( *child, wxWindow::PopEventHandler, false );
325 TestEvtHandler h2('2');
326 child->PushEventHandler(&h2);
327 wxON_BLOCK_EXIT_OBJ1( *child, wxWindow::PopEventHandler, false );
328
329 child->HandleWindowEvent(event);
330 CPPUNIT_ASSERT_EQUAL( "oa2o1cpA", g_str );
331 }
332
333 void EventPropagationTestCase::ForwardEvent()
334 {
335 // The idea of this test is to check that the events explicitly forwarded
336 // to another event handler still get pre/post-processed as usual as this
337 // used to be broken by the fixes trying to avoid duplicate processing.
338 TestWindow * const win = new TestWindow(wxTheApp->GetTopWindow(), 'w');
339 wxON_BLOCK_EXIT_OBJ0( *win, wxWindow::Destroy );
340
341 TestEvtHandler h1('1');
342 win->PushEventHandler(&h1);
343 wxON_BLOCK_EXIT_OBJ1( *win, wxWindow::PopEventHandler, false );
344
345 class ForwardEvtHandler : public wxEvtHandler
346 {
347 public:
348 ForwardEvtHandler(wxEvtHandler& h) : m_h(&h) { }
349
350 virtual bool ProcessEvent(wxEvent& event)
351 {
352 g_str += 'f';
353
354 return m_h->ProcessEvent(event);
355 }
356
357 private:
358 wxEvtHandler *m_h;
359 } f(h1);
360
361 // First send the event directly to f.
362 wxCommandEvent event1(TEST_EVT);
363 f.ProcessEvent(event1);
364 CPPUNIT_ASSERT_EQUAL( "foa1wA", g_str );
365 g_str.clear();
366
367 // And then also test sending it to f indirectly.
368 wxCommandEvent event2(TEST_EVT);
369 TestEvtHandler h2('2');
370 h2.SetNextHandler(&f);
371 h2.ProcessEvent(event2);
372 CPPUNIT_ASSERT_EQUAL( "oa2fo1wAA", g_str );
373 }
374
375 void EventPropagationTestCase::ScrollWindowWithoutHandler()
376 {
377 TestWindow * const parent = new TestWindow(wxTheApp->GetTopWindow(), 'p');
378 wxON_BLOCK_EXIT_OBJ0( *parent, wxWindow::Destroy );
379
380 TestScrollWindow * const win = new TestScrollWindow(parent);
381
382 #ifdef CAN_TEST_PAINT_EVENTS
383 win->GeneratePaintEvent();
384 CPPUNIT_ASSERT_EQUAL( "PD", g_str );
385 #endif
386
387 g_str.clear();
388 wxCommandEvent eventCmd(TEST_EVT);
389 win->HandleWindowEvent(eventCmd);
390 CPPUNIT_ASSERT_EQUAL( "apA", g_str );
391 }
392
393 void EventPropagationTestCase::ScrollWindowWithHandler()
394 {
395 TestWindow * const parent = new TestWindow(wxTheApp->GetTopWindow(), 'p');
396 wxON_BLOCK_EXIT_OBJ0( *parent, wxWindow::Destroy );
397
398 TestScrollWindow * const win = new TestScrollWindow(parent);
399
400 #ifdef CAN_TEST_PAINT_EVENTS
401 TestPaintEvtHandler h('h');
402 win->PushEventHandler(&h);
403 wxON_BLOCK_EXIT_OBJ1( *win, wxWindow::PopEventHandler, false );
404
405 win->GeneratePaintEvent();
406 CPPUNIT_ASSERT_EQUAL( "ohPD", g_str );
407 #endif
408
409 g_str.clear();
410 wxCommandEvent eventCmd(TEST_EVT);
411 win->HandleWindowEvent(eventCmd);
412 CPPUNIT_ASSERT_EQUAL( "apA", g_str );
413 }
414
415 // Create a menu bar with a single menu containing wxID_APPLY menu item and
416 // attach it to the specified frame.
417 wxMenu* CreateTestMenu(wxFrame* frame)
418 {
419 wxMenu* const menu = new wxMenu;
420 menu->Append(wxID_APPLY);
421 wxMenuBar* const mb = new wxMenuBar;
422 mb->Append(menu, "&Menu");
423 frame->SetMenuBar(mb);
424
425 return menu;
426 }
427
428 // Helper for checking that the menu event processing resulted in the expected
429 // output from the handlers.
430 //
431 // Notice that this is supposed to be used with ASSERT_MENU_EVENT_RESULT()
432 // macro to make the file name and line number of the caller appear in the
433 // failure messages.
434 void
435 CheckMenuEvent(wxMenu* menu, const char* result, CppUnit::SourceLine sourceLine)
436 {
437 g_str.clear();
438
439 // Trigger the menu event: this is more reliable than using
440 // wxUIActionSimulator and currently works in all ports as they all call
441 // wxMenuBase::SendEvent() from their respective menu event handlers.
442 menu->SendEvent(wxID_APPLY);
443
444 CPPUNIT_NS::assertEquals( result, g_str, sourceLine, "" );
445 }
446
447 #define ASSERT_MENU_EVENT_RESULT(menu, result) \
448 CheckMenuEvent((menu), (result), CPPUNIT_SOURCELINE())
449
450 void EventPropagationTestCase::MenuEvent()
451 {
452 wxFrame* const frame = static_cast<wxFrame*>(wxTheApp->GetTopWindow());
453
454 // Create a minimal menu bar.
455 wxMenu* const menu = CreateTestMenu(frame);
456 wxMenuBar* const mb = menu->GetMenuBar();
457 wxScopedPtr<wxMenuBar> ensureMenuBarDestruction(mb);
458 wxON_BLOCK_EXIT_OBJ1( *frame, wxFrame::SetMenuBar, (wxMenuBar*)NULL );
459
460 // Check that wxApp gets the event exactly once.
461 ASSERT_MENU_EVENT_RESULT( menu, "aA" );
462
463
464 // Check that the menu event handler is called.
465 TestMenuEvtHandler hm('m'); // 'm' for "menu"
466 menu->SetNextHandler(&hm);
467 wxON_BLOCK_EXIT_OBJ1( *menu,
468 wxEvtHandler::SetNextHandler, (wxEvtHandler*)NULL );
469 ASSERT_MENU_EVENT_RESULT( menu, "aomA" );
470
471
472 // Test that the event handler associated with the menu bar gets the event.
473 TestMenuEvtHandler hb('b'); // 'b' for "menu Bar"
474 mb->PushEventHandler(&hb);
475 wxON_BLOCK_EXIT_OBJ1( *mb, wxWindow::PopEventHandler, false );
476
477 ASSERT_MENU_EVENT_RESULT( menu, "aomobA" );
478
479
480 // Also test that the window to which the menu belongs gets the event.
481 TestMenuEvtHandler hw('w'); // 'w' for "Window"
482 frame->PushEventHandler(&hw);
483 wxON_BLOCK_EXIT_OBJ1( *frame, wxWindow::PopEventHandler, false );
484
485 ASSERT_MENU_EVENT_RESULT( menu, "aomobowA" );
486 }
487
488 // Minimal viable implementations of wxDocument and wxView.
489 class EventTestDocument : public wxDocument
490 {
491 public:
492 EventTestDocument() { }
493
494 wxDECLARE_DYNAMIC_CLASS(EventTestDocument);
495 };
496
497 class EventTestView : public wxView
498 {
499 public:
500 EventTestView() { }
501
502 virtual void OnDraw(wxDC*) { }
503
504 wxDECLARE_DYNAMIC_CLASS(EventTestView);
505 };
506
507 wxIMPLEMENT_DYNAMIC_CLASS(EventTestDocument, wxDocument);
508 wxIMPLEMENT_DYNAMIC_CLASS(EventTestView, wxView);
509
510 void EventPropagationTestCase::DocView()
511 {
512 // Set up the parent frame and its menu bar.
513 wxDocManager docManager;
514
515 wxScopedPtr<wxDocMDIParentFrame>
516 parent(new wxDocMDIParentFrame(&docManager, NULL, wxID_ANY, "Parent"));
517
518 wxMenu* const menu = CreateTestMenu(parent.get());
519
520
521 // Set up the event handlers.
522 TestEvtSink sinkDM('m');
523 docManager.Connect(wxEVT_MENU,
524 wxEventHandler(TestEvtSink::Handle), NULL, &sinkDM);
525
526 TestEvtSink sinkParent('p');
527 parent->Connect(wxEVT_MENU,
528 wxEventHandler(TestEvtSink::Handle), NULL, &sinkParent);
529
530
531 // Check that wxDocManager and wxFrame get the event in order.
532 ASSERT_MENU_EVENT_RESULT( menu, "ampA" );
533
534
535 // Now check what happens if we have an active document.
536 wxDocTemplate docTemplate(&docManager, "Test", "", "", "",
537 "Test Document", "Test View",
538 wxCLASSINFO(EventTestDocument),
539 wxCLASSINFO(EventTestView));
540 wxDocument* const doc = docTemplate.CreateDocument("");
541 wxView* const view = doc->GetFirstView();
542
543 wxScopedPtr<wxMDIChildFrame>
544 child(new wxDocMDIChildFrame(doc, view, parent.get(), wxID_ANY, "Child"));
545
546 wxMenu* const menuChild = CreateTestMenu(child.get());
547
548 // Ensure that the child that we've just created is the active one.
549 child->Activate();
550
551 #ifdef __WXGTK__
552 // There are a lot of hacks related to child frame menu bar handling in
553 // wxGTK and, in particular, the code in src/gtk/mdi.cpp relies on getting
554 // idle events to really put everything in place. Moreover, as wxGTK uses
555 // GtkNotebook as its MDI pages container, the frame must be shown for all
556 // this to work as gtk_notebook_set_current_page() doesn't do anything if
557 // called for a hidden window (this incredible fact cost me quite some time
558 // to find empirically -- only to notice its confirmation in GTK+
559 // documentation immediately afterwards). So just do whatever it takes to
560 // make things work "as usual".
561 child->Show();
562 parent->Show();
563 wxYield();
564 #endif // __WXGTK__
565
566 TestEvtSink sinkDoc('d');
567 doc->Connect(wxEVT_MENU,
568 wxEventHandler(TestEvtSink::Handle), NULL, &sinkDoc);
569
570 TestEvtSink sinkView('v');
571 view->Connect(wxEVT_MENU,
572 wxEventHandler(TestEvtSink::Handle), NULL, &sinkView);
573
574 TestEvtSink sinkChild('c');
575 child->Connect(wxEVT_MENU,
576 wxEventHandler(TestEvtSink::Handle), NULL, &sinkChild);
577
578 // Check that wxDocument, wxView, wxDocManager, child frame and the parent
579 // get the event in order.
580 ASSERT_MENU_EVENT_RESULT( menuChild, "advmcpA" );
581
582
583 #if wxUSE_TOOLBAR
584 // Also check that toolbar events get forwarded to the active child.
585 wxToolBar* const tb = parent->CreateToolBar(wxTB_NOICONS);
586 tb->AddTool(wxID_APPLY, "Apply", wxNullBitmap);
587 tb->Realize();
588
589 // As in CheckMenuEvent(), use toolbar method actually sending the event
590 // instead of bothering with wxUIActionSimulator which would have been
591 // trickier.
592 g_str.clear();
593 tb->OnLeftClick(wxID_APPLY, true /* doesn't matter */);
594
595 CPPUNIT_ASSERT_EQUAL( "advmcpA", g_str );
596 #endif // wxUSE_TOOLBAR
597 }
598
599 #if wxUSE_UIACTIONSIMULATOR
600
601 class ContextMenuTestWindow : public wxWindow
602 {
603 public:
604 ContextMenuTestWindow(wxWindow *parent, char tag)
605 : wxWindow(parent, wxID_ANY),
606 m_tag(tag)
607 {
608 Connect(wxEVT_CONTEXT_MENU,
609 wxContextMenuEventHandler(ContextMenuTestWindow::OnMenu));
610 }
611
612 private:
613 void OnMenu(wxContextMenuEvent& event)
614 {
615 g_str += m_tag;
616
617 event.Skip();
618 }
619
620 const char m_tag;
621
622 wxDECLARE_NO_COPY_CLASS(ContextMenuTestWindow);
623 };
624
625 void EventPropagationTestCase::ContextMenuEvent()
626 {
627 ContextMenuTestWindow * const
628 parent = new ContextMenuTestWindow(wxTheApp->GetTopWindow(), 'p');
629 wxON_BLOCK_EXIT_OBJ0( *parent, wxWindow::Destroy );
630
631 ContextMenuTestWindow * const
632 child = new ContextMenuTestWindow(parent, 'c');
633 parent->SetSize(100, 100);
634 child->SetSize(0, 0, 50, 50);
635 child->SetFocus();
636
637 wxUIActionSimulator sim;
638 const wxPoint origin = parent->ClientToScreen(wxPoint(0, 0));
639
640 // Right clicking in the child should generate an event for it and the
641 // parent.
642 g_str.clear();
643 sim.MouseMove(origin + wxPoint(10, 10));
644 sim.MouseClick(wxMOUSE_BTN_RIGHT);
645
646 // At least with MSW, for WM_CONTEXTMENU to be synthesized by the system
647 // from the right mouse click event, we must dispatch the mouse messages.
648 wxYield();
649
650 CPPUNIT_ASSERT_EQUAL( "cp", g_str );
651
652 // Right clicking outside the child should generate the event just in the
653 // parent.
654 g_str.clear();
655 sim.MouseMove(origin + wxPoint(60, 60));
656 sim.MouseClick(wxMOUSE_BTN_RIGHT);
657 wxYield();
658 CPPUNIT_ASSERT_EQUAL( "p", g_str );
659 }
660
661 #endif // wxUSE_UIACTIONSIMULATOR