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 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2009 Vadim Zeitlin <vadim@wxwidgets.org>
   8 ///////////////////////////////////////////////////////////////////////////////
   9
  10 // ----------------------------------------------------------------------------
  11 // headers
  12 // ----------------------------------------------------------------------------
  13
  14 #include "testprec.h"
  15
  16 #ifdef __BORLANDC__
  17     #pragma hdrstop
  18 #endif
  19
  20 #ifndef WX_PRECOMP
  21     #include "wx/app.h"
  22     #include "wx/event.h"
  23     #include "wx/scrolwin.h"
  24     #include "wx/window.h"
  25 #endif // WX_PRECOMP
  26
  27 #include "wx/scopeguard.h"
  28
  29 namespace
  30 {
  31
  32 // this string will record the execution of all handlers
  33 wxString g_str;
  34
  35 // a custom event
  36 wxDEFINE_EVENT(TEST_EVT, wxCommandEvent);
  37
  38 // a custom event handler tracing the propagation of the events of the
  39 // specified types
  40 template <class Event>
  41 class TestEvtHandlerBase : public wxEvtHandler
  42 {
  43 public:
  44     TestEvtHandlerBase(wxEventType evtType, char tag)
  45         : m_evtType(evtType),
  46           m_tag(tag)
  47     {
  48         Connect(evtType,
  49                 static_cast<wxEventFunction>(&TestEvtHandlerBase::OnTest));
  50     }
  51
  52     // override ProcessEvent() to confirm that it is called for all event
  53     // handlers in the chain
  54     virtual bool ProcessEvent(wxEvent& event)
  55     {
  56         if ( event.GetEventType() == m_evtType )
  57             g_str += 'o'; // "o" == "overridden"
  58
  59         return wxEvtHandler::ProcessEvent(event);
  60     }
  61
  62 private:
  63     void OnTest(wxEvent& event)
  64     {
  65         g_str += m_tag;
  66
  67         event.Skip();
  68     }
  69
  70     const wxEventType m_evtType;
  71     const char m_tag;
  72
  73     wxDECLARE_NO_COPY_TEMPLATE_CLASS(TestEvtHandlerBase, Event);
  74 };
  75
  76 struct TestEvtHandler : TestEvtHandlerBase<wxCommandEvent>
  77 {
  78     TestEvtHandler(char tag)
  79         : TestEvtHandlerBase<wxCommandEvent>(TEST_EVT, tag)
  80     {
  81     }
  82 };
  83
  84 struct TestPaintEvtHandler : TestEvtHandlerBase<wxPaintEvent>
  85 {
  86     TestPaintEvtHandler(char tag)
  87         : TestEvtHandlerBase<wxPaintEvent>(wxEVT_PAINT, tag)
  88     {
  89     }
  90 };
  91
  92 // a window handling the test event
  93 class TestWindow : public wxWindow
  94 {
  95 public:
  96     TestWindow(wxWindow *parent, char tag)
  97         : wxWindow(parent, wxID_ANY),
  98           m_tag(tag)
  99     {
 100         Connect(TEST_EVT, wxCommandEventHandler(TestWindow::OnTest));
 101     }
 102
 103 private:
 104     void OnTest(wxCommandEvent& event)
 105     {
 106         g_str += m_tag;
 107
 108         event.Skip();
 109     }
 110
 111     const char m_tag;
 112
 113     DECLARE_NO_COPY_CLASS(TestWindow)
 114 };
 115
 116 // a scroll window handling paint event: we want to have a special test case
 117 // for this because the event propagation is complicated even further than
 118 // usual here by the presence of wxScrollHelperEvtHandler in the event handlers
 119 // chain and the fact that OnDraw() virtual method must be called if EVT_PAINT
 120 // is not handled
 121 class TestScrollWindow : public wxScrolledWindow
 122 {
 123 public:
 124     TestScrollWindow(wxWindow *parent)
 125         : wxScrolledWindow(parent, wxID_ANY)
 126     {
 127         Connect(wxEVT_PAINT, wxPaintEventHandler(TestScrollWindow::OnPaint));
 128     }
 129
 130     virtual void OnDraw(wxDC& WXUNUSED(dc))
 131     {
 132         g_str += 'D';   // draw
 133     }
 134
 135 private:
 136     void OnPaint(wxPaintEvent& event)
 137     {
 138         g_str += 'P';   // paint
 139         event.Skip();
 140     }
 141
 142     wxDECLARE_NO_COPY_CLASS(TestScrollWindow);
 143 };
 144
 145 int DoFilterEvent(wxEvent& event)
 146 {
 147     if ( event.GetEventType() == TEST_EVT )
 148         g_str += 'a';
 149
 150     return -1;
 151 }
 152
 153 bool DoProcessEvent(wxEvent& event)
 154 {
 155     if ( event.GetEventType() == TEST_EVT )
 156         g_str += 'A';
 157
 158     return false;
 159 }
 160
 161 } // anonymous namespace
 162
 163 // --------------------------------------------------------------------------
 164 // test class
 165 // --------------------------------------------------------------------------
 166
 167 class EventPropagationTestCase : public CppUnit::TestCase
 168 {
 169 public:
 170     EventPropagationTestCase() {}
 171
 172     virtual void setUp();
 173     virtual void tearDown();
 174
 175 private:
 176     CPPUNIT_TEST_SUITE( EventPropagationTestCase );
 177         CPPUNIT_TEST( OneHandler );
 178         CPPUNIT_TEST( TwoHandlers );
 179         CPPUNIT_TEST( WindowWithoutHandler );
 180         CPPUNIT_TEST( WindowWithHandler );
 181         CPPUNIT_TEST( ForwardEvent );
 182         CPPUNIT_TEST( ScrollWindowWithoutHandler );
 183         CPPUNIT_TEST( ScrollWindowWithHandler );
 184     CPPUNIT_TEST_SUITE_END();
 185
 186     void OneHandler();
 187     void TwoHandlers();
 188     void WindowWithoutHandler();
 189     void WindowWithHandler();
 190     void ForwardEvent();
 191     void ScrollWindowWithoutHandler();
 192     void ScrollWindowWithHandler();
 193
 194     DECLARE_NO_COPY_CLASS(EventPropagationTestCase)
 195 };
 196
 197 // register in the unnamed registry so that these tests are run by default
 198 CPPUNIT_TEST_SUITE_REGISTRATION( EventPropagationTestCase );
 199
 200 // also include in its own registry so that these tests can be run alone
 201 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( EventPropagationTestCase, "EventPropagationTestCase" );
 202
 203 void EventPropagationTestCase::setUp()
 204 {
 205     SetFilterEventFunc(DoFilterEvent);
 206     SetProcessEventFunc(DoProcessEvent);
 207
 208     g_str.clear();
 209 }
 210
 211 void EventPropagationTestCase::tearDown()
 212 {
 213     SetFilterEventFunc(NULL);
 214     SetProcessEventFunc(NULL);
 215 }
 216
 217 void EventPropagationTestCase::OneHandler()
 218 {
 219     wxCommandEvent event(TEST_EVT);
 220     TestEvtHandler h1('1');
 221     h1.ProcessEvent(event);
 222     CPPUNIT_ASSERT_EQUAL( "oa1A", g_str );
 223 }
 224
 225 void EventPropagationTestCase::TwoHandlers()
 226 {
 227     wxCommandEvent event(TEST_EVT);
 228     TestEvtHandler h1('1');
 229     TestEvtHandler h2('2');
 230     h1.SetNextHandler(&h2);
 231     h2.SetPreviousHandler(&h1);
 232     h1.ProcessEvent(event);
 233     CPPUNIT_ASSERT_EQUAL( "oa1o2A", g_str );
 234 }
 235
 236 void EventPropagationTestCase::WindowWithoutHandler()
 237 {
 238     wxCommandEvent event(TEST_EVT);
 239     TestWindow * const parent = new TestWindow(wxTheApp->GetTopWindow(), 'p');
 240     wxON_BLOCK_EXIT_OBJ0( *parent, wxWindow::Destroy );
 241
 242     TestWindow * const child = new TestWindow(parent, 'c');
 243
 244     child->GetEventHandler()->ProcessEvent(event);
 245     CPPUNIT_ASSERT_EQUAL( "acpA", g_str );
 246 }
 247
 248 void EventPropagationTestCase::WindowWithHandler()
 249 {
 250     wxCommandEvent event(TEST_EVT);
 251     TestWindow * const parent = new TestWindow(wxTheApp->GetTopWindow(), 'p');
 252     wxON_BLOCK_EXIT_OBJ0( *parent, wxWindow::Destroy );
 253
 254     TestWindow * const child = new TestWindow(parent, 'c');
 255
 256     TestEvtHandler h1('1');
 257     child->PushEventHandler(&h1);
 258     wxON_BLOCK_EXIT_OBJ1( *child, wxWindow::PopEventHandler, false );
 259     TestEvtHandler h2('2');
 260     child->PushEventHandler(&h2);
 261     wxON_BLOCK_EXIT_OBJ1( *child, wxWindow::PopEventHandler, false );
 262
 263     child->HandleWindowEvent(event);
 264     CPPUNIT_ASSERT_EQUAL( "oa2o1cpA", g_str );
 265 }
 266
 267 void EventPropagationTestCase::ForwardEvent()
 268 {
 269     // The idea of this test is to check that the events explicitly forwarded
 270     // to another event handler still get pre/post-processed as usual as this
 271     // used to be broken by the fixes trying to avoid duplicate processing.
 272     TestWindow * const win = new TestWindow(wxTheApp->GetTopWindow(), 'w');
 273     wxON_BLOCK_EXIT_OBJ0( *win, wxWindow::Destroy );
 274
 275     TestEvtHandler h1('1');
 276     win->PushEventHandler(&h1);
 277     wxON_BLOCK_EXIT_OBJ1( *win, wxWindow::PopEventHandler, false );
 278
 279     class ForwardEvtHandler : public wxEvtHandler
 280     {
 281     public:
 282         ForwardEvtHandler(wxEvtHandler& h) : m_h(&h) { }
 283
 284         virtual bool ProcessEvent(wxEvent& event)
 285         {
 286             g_str += 'f';
 287
 288             return m_h->ProcessEvent(event);
 289         }
 290
 291     private:
 292         wxEvtHandler *m_h;
 293     } f(h1);
 294
 295     // First send the event directly to f.
 296     wxCommandEvent event1(TEST_EVT);
 297     f.ProcessEvent(event1);
 298     CPPUNIT_ASSERT_EQUAL( "foa1wA", g_str );
 299     g_str.clear();
 300
 301     // And then also test sending it to f indirectly.
 302     wxCommandEvent event2(TEST_EVT);
 303     TestEvtHandler h2('2');
 304     h2.SetNextHandler(&f);
 305     h2.ProcessEvent(event2);
 306     CPPUNIT_ASSERT_EQUAL( "oa2fo1wAA", g_str );
 307 }
 308
 309 void EventPropagationTestCase::ScrollWindowWithoutHandler()
 310 {
 311     TestWindow * const parent = new TestWindow(wxTheApp->GetTopWindow(), 'p');
 312     wxON_BLOCK_EXIT_OBJ0( *parent, wxWindow::Destroy );
 313
 314     TestScrollWindow * const win = new TestScrollWindow(parent);
 315
 316 #if !defined(__WXOSX__) && !defined(__WXGTK3__)
 317     wxPaintEvent event(win->GetId());
 318     win->ProcessWindowEvent(event);
 319     CPPUNIT_ASSERT_EQUAL( "PD", g_str );
 320 #endif
 321     g_str.clear();
 322     wxCommandEvent eventCmd(TEST_EVT);
 323     win->HandleWindowEvent(eventCmd);
 324     CPPUNIT_ASSERT_EQUAL( "apA", g_str );
 325 }
 326
 327 void EventPropagationTestCase::ScrollWindowWithHandler()
 328 {
 329     TestWindow * const parent = new TestWindow(wxTheApp->GetTopWindow(), 'p');
 330     wxON_BLOCK_EXIT_OBJ0( *parent, wxWindow::Destroy );
 331
 332     TestScrollWindow * const win = new TestScrollWindow(parent);
 333
 334 #if !defined(__WXOSX__) && !defined(__WXGTK3__)
 335     TestPaintEvtHandler h('h');
 336     win->PushEventHandler(&h);
 337     wxON_BLOCK_EXIT_OBJ1( *win, wxWindow::PopEventHandler, false );
 338
 339     wxPaintEvent event(win->GetId());
 340     win->ProcessWindowEvent(event);
 341     CPPUNIT_ASSERT_EQUAL( "ohPD", g_str );
 342 #endif
 343
 344     g_str.clear();
 345     wxCommandEvent eventCmd(TEST_EVT);
 346     win->HandleWindowEvent(eventCmd);
 347     CPPUNIT_ASSERT_EQUAL( "apA", g_str );
 348 }
 349