allow handling events in a function taking the base class of the event class correspo...

[wxWidgets.git] / tests / events / evthandler.cpp

diff --git a/tests/events/evthandler.cpp b/tests/events/evthandler.cpp
index 137fe3e6e2996f2a7cd259a46925a1c5b229efc5..ea866600201362f5bce3d3008b22c65cba1839ee 100644 (file)
--- a/tests/events/evthandler.cpp
+++ b/tests/events/evthandler.cpp
@@ -23,19 +23,21 @@
 // test events and their handlers
 // ----------------------------------------------------------------------------
 
 // test events and their handlers
 // ----------------------------------------------------------------------------
 

-const wxEventType EVT_LEGACY = wxNewEventType();
+const wxEventType LegacyEventType = wxNewEventType();

 
 class MyEvent;
 
 class MyEvent;

-wxDEFINE_EVENT( EVT_MYEVENT, MyEvent )
+wxDEFINE_EVENT( MyEventType, MyEvent )

 
 class MyEvent : public wxEvent
 {
 public:
 
 class MyEvent : public wxEvent
 {
 public:

-    MyEvent() : wxEvent(0, EVT_MYEVENT) { }
+    MyEvent() : wxEvent(0, MyEventType) { }

 
     virtual wxEvent *Clone() const { return new MyEvent; }
 };
 
 
     virtual wxEvent *Clone() const { return new MyEvent; }
 };
 

+#define EVT_MYEVENT(func) wx__DECLARE_EVT0(MyEventType, &func)
+

 class AnotherEvent : public wxEvent
 {
 };
 class AnotherEvent : public wxEvent
 {
 };


@@ -100,6 +102,7 @@ public:
 struct MySink
 {
     void OnMyEvent(MyEvent&) { g_called.method = true; }
 struct MySink
 {
     void OnMyEvent(MyEvent&) { g_called.method = true; }

+    void OnEvent(wxEvent&) { g_called.method = true; }

     void OnIdle(wxIdleEvent&) { g_called.method = true; }
 };
 
     void OnIdle(wxIdleEvent&) { g_called.method = true; }
 };
 


@@ -119,7 +122,11 @@ private:
 BEGIN_EVENT_TABLE(MyClassWithEventTable, wxEvtHandler)
     EVT_IDLE(MyClassWithEventTable::OnIdle)
 
 BEGIN_EVENT_TABLE(MyClassWithEventTable, wxEvtHandler)
     EVT_IDLE(MyClassWithEventTable::OnIdle)
 

+    EVT_MYEVENT(MyClassWithEventTable::OnMyEvent)
+    EVT_MYEVENT(MyClassWithEventTable::OnEvent)
+

     // this shouldn't compile:
     // this shouldn't compile:

+    //EVT_MYEVENT(MyClassWithEventTable::OnIdle)

     //EVT_IDLE(MyClassWithEventTable::OnAnotherEvent)
 END_EVENT_TABLE()
 
     //EVT_IDLE(MyClassWithEventTable::OnAnotherEvent)
 END_EVENT_TABLE()
 


@@ -144,6 +151,7 @@ private:
         CPPUNIT_TEST( ConnectStaticMethod );
         CPPUNIT_TEST( ConnectFunctor );
         CPPUNIT_TEST( ConnectMethod );
         CPPUNIT_TEST( ConnectStaticMethod );
         CPPUNIT_TEST( ConnectFunctor );
         CPPUNIT_TEST( ConnectMethod );

+        CPPUNIT_TEST( ConnectMethodUsingBaseEvent );

         CPPUNIT_TEST( ConnectMethodWithSink );
         CPPUNIT_TEST( ConnectNonHandler );
         CPPUNIT_TEST( StaticConnect );
         CPPUNIT_TEST( ConnectMethodWithSink );
         CPPUNIT_TEST( ConnectNonHandler );
         CPPUNIT_TEST( StaticConnect );


@@ -158,6 +166,7 @@ private:
     void ConnectStaticMethod();
     void ConnectFunctor();
     void ConnectMethod();
     void ConnectStaticMethod();
     void ConnectFunctor();
     void ConnectMethod();

+    void ConnectMethodUsingBaseEvent();

     void ConnectMethodWithSink();
     void ConnectNonHandler();
     void StaticConnect();
     void ConnectMethodWithSink();
     void ConnectNonHandler();
     void StaticConnect();


@@ -187,6 +196,11 @@ void EvtHandlerTestCase::BuiltinConnect()
     handler.Connect(wxEVT_IDLE, wxIdleEventHandler(MyHandler::OnIdle), NULL, &handler);
     handler.Disconnect(wxEVT_IDLE, wxIdleEventHandler(MyHandler::OnIdle), NULL, &handler);
 
     handler.Connect(wxEVT_IDLE, wxIdleEventHandler(MyHandler::OnIdle), NULL, &handler);
     handler.Disconnect(wxEVT_IDLE, wxIdleEventHandler(MyHandler::OnIdle), NULL, &handler);
 

+    // using casts like this is even uglier than using wxIdleEventHandler but
+    // it should still continue to work for compatibility
+    handler.Connect(wxEVT_IDLE, (wxObjectEventFunction)(wxEventFunction)&MyHandler::OnIdle);
+    handler.Disconnect(wxEVT_IDLE, (wxObjectEventFunction)(wxEventFunction)&MyHandler::OnIdle);
+

 #if !wxEVENTS_COMPATIBILITY_2_8
     handler.Connect(wxEVT_IDLE, GlobalOnIdle);
     handler.Disconnect(wxEVT_IDLE, GlobalOnIdle);
 #if !wxEVENTS_COMPATIBILITY_2_8
     handler.Connect(wxEVT_IDLE, GlobalOnIdle);
     handler.Disconnect(wxEVT_IDLE, GlobalOnIdle);


@@ -205,22 +219,22 @@ void EvtHandlerTestCase::BuiltinConnect()
 
 void EvtHandlerTestCase::LegacyConnect()
 {
 
 void EvtHandlerTestCase::LegacyConnect()
 {

-    handler.Connect( EVT_LEGACY, (wxObjectEventFunction)&MyHandler::OnEvent );
-    handler.Connect( 0, EVT_LEGACY, (wxObjectEventFunction)&MyHandler::OnEvent );
-    handler.Connect( 0, 0, EVT_LEGACY, (wxObjectEventFunction)&MyHandler::OnEvent );
+    handler.Connect( LegacyEventType, (wxObjectEventFunction)&MyHandler::OnEvent );
+    handler.Connect( 0, LegacyEventType, (wxObjectEventFunction)&MyHandler::OnEvent );
+    handler.Connect( 0, 0, LegacyEventType, (wxObjectEventFunction)&MyHandler::OnEvent );

 
 

-    handler.Disconnect( EVT_LEGACY, (wxObjectEventFunction)&MyHandler::OnEvent );
-    handler.Disconnect( 0, EVT_LEGACY, (wxObjectEventFunction)&MyHandler::OnEvent );
-    handler.Disconnect( 0, 0, EVT_LEGACY, (wxObjectEventFunction)&MyHandler::OnEvent );
+    handler.Disconnect( LegacyEventType, (wxObjectEventFunction)&MyHandler::OnEvent );
+    handler.Disconnect( 0, LegacyEventType, (wxObjectEventFunction)&MyHandler::OnEvent );
+    handler.Disconnect( 0, 0, LegacyEventType, (wxObjectEventFunction)&MyHandler::OnEvent );

 
 
 
 

-    handler.Connect( EVT_LEGACY, (wxObjectEventFunction)&MyHandler::OnEvent, NULL, &handler );
-    handler.Connect( 0, EVT_LEGACY, (wxObjectEventFunction)&MyHandler::OnEvent, NULL, &handler );
-    handler.Connect( 0, 0, EVT_LEGACY, (wxObjectEventFunction)&MyHandler::OnEvent, NULL, &handler );
+    handler.Connect( LegacyEventType, (wxObjectEventFunction)&MyHandler::OnEvent, NULL, &handler );
+    handler.Connect( 0, LegacyEventType, (wxObjectEventFunction)&MyHandler::OnEvent, NULL, &handler );
+    handler.Connect( 0, 0, LegacyEventType, (wxObjectEventFunction)&MyHandler::OnEvent, NULL, &handler );

 
 

-    handler.Disconnect( EVT_LEGACY, (wxObjectEventFunction)&MyHandler::OnEvent, NULL, &handler );
-    handler.Disconnect( 0, EVT_LEGACY, (wxObjectEventFunction)&MyHandler::OnEvent, NULL, &handler );
-    handler.Disconnect( 0, 0, EVT_LEGACY, (wxObjectEventFunction)&MyHandler::OnEvent, NULL, &handler );
+    handler.Disconnect( LegacyEventType, (wxObjectEventFunction)&MyHandler::OnEvent, NULL, &handler );
+    handler.Disconnect( 0, LegacyEventType, (wxObjectEventFunction)&MyHandler::OnEvent, NULL, &handler );
+    handler.Disconnect( 0, 0, LegacyEventType, (wxObjectEventFunction)&MyHandler::OnEvent, NULL, &handler );

 }
 
 #if !wxEVENTS_COMPATIBILITY_2_8
 }
 
 #if !wxEVENTS_COMPATIBILITY_2_8


@@ -228,40 +242,40 @@ void EvtHandlerTestCase::LegacyConnect()
 void EvtHandlerTestCase::ConnectFunction()
 {
     // function tests
 void EvtHandlerTestCase::ConnectFunction()
 {
     // function tests

-    handler.Connect( EVT_MYEVENT, GlobalOnMyEvent );
+    handler.Connect( MyEventType, GlobalOnMyEvent );

     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( g_called.function );
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( g_called.function );

-    handler.Disconnect( EVT_MYEVENT, GlobalOnMyEvent );
+    handler.Disconnect( MyEventType, GlobalOnMyEvent );

     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( !g_called.function ); // check that it was disconnected
 
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( !g_called.function ); // check that it was disconnected
 

-    handler.Connect( 0, EVT_MYEVENT, GlobalOnMyEvent );
-    handler.Disconnect( 0, EVT_MYEVENT, GlobalOnMyEvent );
+    handler.Connect( 0, MyEventType, GlobalOnMyEvent );
+    handler.Disconnect( 0, MyEventType, GlobalOnMyEvent );

 
 

-    handler.Connect( 0, 0, EVT_MYEVENT, GlobalOnMyEvent );
-    handler.Disconnect( 0, 0, EVT_MYEVENT, GlobalOnMyEvent );
+    handler.Connect( 0, 0, MyEventType, GlobalOnMyEvent );
+    handler.Disconnect( 0, 0, MyEventType, GlobalOnMyEvent );

 }
 
 void EvtHandlerTestCase::ConnectStaticMethod()
 {
     // static method tests (this is same as functions but still test it just in
     // case we hit some strange compiler bugs)
 }
 
 void EvtHandlerTestCase::ConnectStaticMethod()
 {
     // static method tests (this is same as functions but still test it just in
     // case we hit some strange compiler bugs)

-    handler.Connect( EVT_MYEVENT, &MyHandler::StaticOnMyEvent );
+    handler.Connect( MyEventType, &MyHandler::StaticOnMyEvent );

     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( g_called.smethod );
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( g_called.smethod );

-    handler.Disconnect( EVT_MYEVENT, &MyHandler::StaticOnMyEvent );
+    handler.Disconnect( MyEventType, &MyHandler::StaticOnMyEvent );

     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( !g_called.smethod );
 
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( !g_called.smethod );
 

-    handler.Connect( 0, EVT_MYEVENT, &MyHandler::StaticOnMyEvent );
-    handler.Disconnect( 0, EVT_MYEVENT, &MyHandler::StaticOnMyEvent );
+    handler.Connect( 0, MyEventType, &MyHandler::StaticOnMyEvent );
+    handler.Disconnect( 0, MyEventType, &MyHandler::StaticOnMyEvent );

 
 

-    handler.Connect( 0, 0, EVT_MYEVENT, &MyHandler::StaticOnMyEvent );
-    handler.Disconnect( 0, 0, EVT_MYEVENT, &MyHandler::StaticOnMyEvent );
+    handler.Connect( 0, 0, MyEventType, &MyHandler::StaticOnMyEvent );
+    handler.Disconnect( 0, 0, MyEventType, &MyHandler::StaticOnMyEvent );

 }
 
 void EvtHandlerTestCase::ConnectFunctor()
 }
 
 void EvtHandlerTestCase::ConnectFunctor()


@@ -269,50 +283,71 @@ void EvtHandlerTestCase::ConnectFunctor()
     // generalized functor tests
     MyFunctor functor;
 
     // generalized functor tests
     MyFunctor functor;
 

-    handler.Connect( EVT_MYEVENT, functor );
+    handler.Connect( MyEventType, functor );

     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( g_called.functor );
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( g_called.functor );

-    handler.Disconnect( EVT_MYEVENT, functor );
+    handler.Disconnect( MyEventType, functor );

     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( !g_called.functor );
 
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( !g_called.functor );
 

-    handler.Connect( 0, EVT_MYEVENT, functor );
-    handler.Disconnect( 0, EVT_MYEVENT, functor );
+    handler.Connect( 0, MyEventType, functor );
+    handler.Disconnect( 0, MyEventType, functor );

 
 

-    handler.Connect( 0, 0, EVT_MYEVENT, functor );
-    handler.Disconnect( 0, 0, EVT_MYEVENT, functor );
+    handler.Connect( 0, 0, MyEventType, functor );
+    handler.Disconnect( 0, 0, MyEventType, functor );

 }
 
 void EvtHandlerTestCase::ConnectMethod()
 {
     // class method tests
 }
 
 void EvtHandlerTestCase::ConnectMethod()
 {
     // class method tests

-    handler.Connect( EVT_MYEVENT, &MyHandler::OnMyEvent );
+    handler.Connect( MyEventType, &MyHandler::OnMyEvent );
+    g_called.Reset();
+    handler.ProcessEvent(e);
+    CPPUNIT_ASSERT( g_called.method );
+    handler.Disconnect( MyEventType, &MyHandler::OnMyEvent );
+    g_called.Reset();
+    handler.ProcessEvent(e);
+    CPPUNIT_ASSERT( !g_called.method );
+
+    handler.Connect( 0, MyEventType, &MyHandler::OnMyEvent );
+    handler.Disconnect( 0, MyEventType, &MyHandler::OnMyEvent );
+
+    handler.Connect( 0, 0, MyEventType, &MyHandler::OnMyEvent );
+    handler.Disconnect( 0, 0, MyEventType, &MyHandler::OnMyEvent );
+}
+
+void EvtHandlerTestCase::ConnectMethodUsingBaseEvent()
+{
+    // test connecting a method taking just wxEvent and not MyEvent: this
+    // should work too if we don't need any MyEvent-specific information in the
+    // handler
+    handler.Connect( MyEventType, &MyHandler::OnEvent );

     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( g_called.method );
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( g_called.method );

-    handler.Disconnect( EVT_MYEVENT, &MyHandler::OnMyEvent );
+    handler.Disconnect( MyEventType, &MyHandler::OnEvent );

     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( !g_called.method );
 
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( !g_called.method );
 

-    handler.Connect( 0, EVT_MYEVENT, &MyHandler::OnMyEvent );
-    handler.Disconnect( 0, EVT_MYEVENT, &MyHandler::OnMyEvent );
+    handler.Connect( 0, MyEventType, &MyHandler::OnEvent );
+    handler.Disconnect( 0, MyEventType, &MyHandler::OnEvent );

 
 

-    handler.Connect( 0, 0, EVT_MYEVENT, &MyHandler::OnMyEvent );
-    handler.Disconnect( 0, 0, EVT_MYEVENT, &MyHandler::OnMyEvent );
+    handler.Connect( 0, 0, MyEventType, &MyHandler::OnEvent );
+    handler.Disconnect( 0, 0, MyEventType, &MyHandler::OnEvent );

 }
 
 void EvtHandlerTestCase::ConnectMethodWithSink()
 {
 }
 
 void EvtHandlerTestCase::ConnectMethodWithSink()
 {

-    handler.Connect( EVT_MYEVENT, &MyHandler::OnMyEvent, NULL, &handler );
-    handler.Connect( 0, EVT_MYEVENT, &MyHandler::OnMyEvent, NULL, &handler );
-    handler.Connect( 0, 0, EVT_MYEVENT, &MyHandler::OnMyEvent, NULL, &handler );
+    handler.Connect( MyEventType, &MyHandler::OnMyEvent, NULL, &handler );
+    handler.Connect( 0, MyEventType, &MyHandler::OnMyEvent, NULL, &handler );
+    handler.Connect( 0, 0, MyEventType, &MyHandler::OnMyEvent, NULL, &handler );

 
 

-    handler.Disconnect( EVT_MYEVENT, &MyHandler::OnMyEvent, NULL, &handler );
-    handler.Disconnect( 0, EVT_MYEVENT, &MyHandler::OnMyEvent, NULL, &handler );
-    handler.Disconnect( 0, 0, EVT_MYEVENT, &MyHandler::OnMyEvent, NULL, &handler );
+    handler.Disconnect( MyEventType, &MyHandler::OnMyEvent, NULL, &handler );
+    handler.Disconnect( 0, MyEventType, &MyHandler::OnMyEvent, NULL, &handler );
+    handler.Disconnect( 0, 0, MyEventType, &MyHandler::OnMyEvent, NULL, &handler );

 }
 
 void EvtHandlerTestCase::ConnectNonHandler()
 }
 
 void EvtHandlerTestCase::ConnectNonHandler()


@@ -320,11 +355,11 @@ void EvtHandlerTestCase::ConnectNonHandler()
     // class method tests for class not derived from wxEvtHandler
     MySink sink;
 
     // class method tests for class not derived from wxEvtHandler
     MySink sink;
 

-    handler.Connect( EVT_MYEVENT, &MySink::OnMyEvent, NULL, &sink );
+    handler.Connect( MyEventType, &MySink::OnMyEvent, NULL, &sink );

     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( g_called.method );
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( g_called.method );

-    handler.Disconnect( EVT_MYEVENT, &MySink::OnMyEvent, NULL, &sink );
+    handler.Disconnect( MyEventType, &MySink::OnMyEvent, NULL, &sink );

     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( !g_called.method );
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( !g_called.method );


@@ -332,13 +367,13 @@ void EvtHandlerTestCase::ConnectNonHandler()
 
 void EvtHandlerTestCase::StaticConnect()
 {
 
 void EvtHandlerTestCase::StaticConnect()
 {

-    wxEvtHandler::Connect( &handler, EVT_MYEVENT, &MyHandler::OnMyEvent, NULL, &handler );
-    wxEvtHandler::Connect( &handler, 0, EVT_MYEVENT, &MyHandler::OnMyEvent, NULL, &handler );
-    wxEvtHandler::Connect( &handler, 0, 0, EVT_MYEVENT, &MyHandler::OnMyEvent, NULL, &handler );
+    wxEvtHandler::Connect( &handler, MyEventType, &MyHandler::OnMyEvent, NULL, &handler );
+    wxEvtHandler::Connect( &handler, 0, MyEventType, &MyHandler::OnMyEvent, NULL, &handler );
+    wxEvtHandler::Connect( &handler, 0, 0, MyEventType, &MyHandler::OnMyEvent, NULL, &handler );

 
 

-    wxEvtHandler::Disconnect( &handler, EVT_MYEVENT, &MyHandler::OnMyEvent, NULL, &handler );
-    wxEvtHandler::Disconnect( &handler, 0, EVT_MYEVENT, &MyHandler::OnMyEvent, NULL, &handler );
-    wxEvtHandler::Disconnect( &handler, 0, 0, EVT_MYEVENT, &MyHandler::OnMyEvent, NULL, &handler );
+    wxEvtHandler::Disconnect( &handler, MyEventType, &MyHandler::OnMyEvent, NULL, &handler );
+    wxEvtHandler::Disconnect( &handler, 0, MyEventType, &MyHandler::OnMyEvent, NULL, &handler );
+    wxEvtHandler::Disconnect( &handler, 0, 0, MyEventType, &MyHandler::OnMyEvent, NULL, &handler );

 }
 
 void EvtHandlerTestCase::InvalidConnect()
 }
 
 void EvtHandlerTestCase::InvalidConnect()


@@ -346,10 +381,10 @@ void EvtHandlerTestCase::InvalidConnect()
     // these calls shouldn't compile but we unfortunately can't check this
     // automatically, you need to uncomment them manually and test that
     // compilation does indeed fail
     // these calls shouldn't compile but we unfortunately can't check this
     // automatically, you need to uncomment them manually and test that
     // compilation does indeed fail

-    //handler.Connect(EVT_MYEVENT, GlobalOnAnotherEvent);
-    //IdleFunctor f; handler.Connect(EVT_MYEVENT, f);
-    //handler.Connect(EVT_MYEVENT, &MyHandler::StaticOnAnotherEvent);
-    //handler.Connect(EVT_MYEVENT, &MyHandler::OnAnotherEvent);
+    //handler.Connect(MyEventType, GlobalOnAnotherEvent);
+    //IdleFunctor f; handler.Connect(MyEventType, f);
+    //handler.Connect(MyEventType, &MyHandler::StaticOnAnotherEvent);
+    //handler.Connect(MyEventType, &MyHandler::OnAnotherEvent);

 }
 
 #endif // !wxEVENTS_COMPATIBILITY_2_8
 }
 
 #endif // !wxEVENTS_COMPATIBILITY_2_8