X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/a01ada0599acdc11497850c4c8e846d3f237bf91..3c01c5951189e13b8b4a5d7b288b54d4a57a30f8:/tests/events/evthandler.cpp

diff --git a/tests/events/evthandler.cpp b/tests/events/evthandler.cpp
index ea86660020..366fb8e775 100644
--- a/tests/events/evthandler.cpp
+++ b/tests/events/evthandler.cpp
@@ -26,7 +26,7 @@
 const wxEventType LegacyEventType = wxNewEventType();
 
 class MyEvent;
-wxDEFINE_EVENT( MyEventType, MyEvent )
+wxDEFINE_EVENT(MyEventType, MyEvent);
 
 class MyEvent : public wxEvent
 {
@@ -36,7 +36,14 @@ public:
     virtual wxEvent *Clone() const { return new MyEvent; }
 };
 
-#define EVT_MYEVENT(func) wx__DECLARE_EVT0(MyEventType, &func)
+typedef void (wxEvtHandler::*MyEventFunction)(MyEvent&);
+#ifndef wxHAS_EVENT_BIND
+    #define MyEventHandler(func) wxEVENT_HANDLER_CAST(MyEventFunction, func)
+#else
+    #define MyEventHandler(func) &func
+#endif
+#define EVT_MYEVENT(func) \
+    wx__DECLARE_EVT0(MyEventType, MyEventHandler(func))
 
 class AnotherEvent : public wxEvent
 {
@@ -68,6 +75,11 @@ void GlobalOnMyEvent(MyEvent&)
     g_called.function = true;
 }
 
+void GlobalOnEvent(wxEvent&)
+{
+    g_called.function = true;
+}
+
 void GlobalOnAnotherEvent(AnotherEvent&);
 
 void GlobalOnIdle(wxIdleEvent&)
@@ -123,7 +135,9 @@ BEGIN_EVENT_TABLE(MyClassWithEventTable, wxEvtHandler)
     EVT_IDLE(MyClassWithEventTable::OnIdle)
 
     EVT_MYEVENT(MyClassWithEventTable::OnMyEvent)
+#ifdef wxHAS_EVENT_BIND
     EVT_MYEVENT(MyClassWithEventTable::OnEvent)
+#endif
 
     // this shouldn't compile:
     //EVT_MYEVENT(MyClassWithEventTable::OnIdle)
@@ -146,32 +160,30 @@ private:
     CPPUNIT_TEST_SUITE( EvtHandlerTestCase );
         CPPUNIT_TEST( BuiltinConnect );
         CPPUNIT_TEST( LegacyConnect );
-#if !wxEVENTS_COMPATIBILITY_2_8
-        CPPUNIT_TEST( ConnectFunction );
-        CPPUNIT_TEST( ConnectStaticMethod );
-        CPPUNIT_TEST( ConnectFunctor );
-        CPPUNIT_TEST( ConnectMethod );
-        CPPUNIT_TEST( ConnectMethodUsingBaseEvent );
-        CPPUNIT_TEST( ConnectMethodWithSink );
-        CPPUNIT_TEST( ConnectNonHandler );
-        CPPUNIT_TEST( StaticConnect );
-        CPPUNIT_TEST( InvalidConnect );
-#endif // !wxEVENTS_COMPATIBILITY_2_8
+#ifdef wxHAS_EVENT_BIND
+        CPPUNIT_TEST( BindFunction );
+        CPPUNIT_TEST( BindStaticMethod );
+        CPPUNIT_TEST( BindFunctor );
+        CPPUNIT_TEST( BindMethod );
+        CPPUNIT_TEST( BindMethodUsingBaseEvent );
+        CPPUNIT_TEST( BindFunctionUsingBaseEvent );
+        CPPUNIT_TEST( BindNonHandler );
+        CPPUNIT_TEST( InvalidBind );
+#endif // wxHAS_EVENT_BIND
     CPPUNIT_TEST_SUITE_END();
 
     void BuiltinConnect();
     void LegacyConnect();
-#if !wxEVENTS_COMPATIBILITY_2_8
-    void ConnectFunction();
-    void ConnectStaticMethod();
-    void ConnectFunctor();
-    void ConnectMethod();
-    void ConnectMethodUsingBaseEvent();
-    void ConnectMethodWithSink();
-    void ConnectNonHandler();
-    void StaticConnect();
-    void InvalidConnect();
-#endif // !wxEVENTS_COMPATIBILITY_2_8
+#ifdef wxHAS_EVENT_BIND
+    void BindFunction();
+    void BindStaticMethod();
+    void BindFunctor();
+    void BindMethod();
+    void BindMethodUsingBaseEvent();
+    void BindFunctionUsingBaseEvent();
+    void BindNonHandler();
+    void InvalidBind();
+#endif // wxHAS_EVENT_BIND
 
 
     // these member variables exceptionally don't use "m_" prefix because
@@ -201,20 +213,20 @@ void EvtHandlerTestCase::BuiltinConnect()
     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);
+#ifdef wxHAS_EVENT_BIND
+    handler.Bind(wxEVT_IDLE, GlobalOnIdle);
+    handler.Unbind(wxEVT_IDLE, GlobalOnIdle);
 
     IdleFunctor f;
-    handler.Connect(wxEVT_IDLE, f);
-    handler.Disconnect(wxEVT_IDLE, f);
+    handler.Bind(wxEVT_IDLE, f);
+    handler.Unbind(wxEVT_IDLE, f);
 
-    handler.Connect(wxEVT_IDLE, &MyHandler::OnIdle);
-    handler.Disconnect(wxEVT_IDLE, &MyHandler::OnIdle);
+    handler.Bind(wxEVT_IDLE, &MyHandler::OnIdle, &handler);
+    handler.Unbind(wxEVT_IDLE, &MyHandler::OnIdle, &handler);
 
-    handler.Connect(wxEVT_IDLE, &MyHandler::StaticOnIdle);
-    handler.Disconnect(wxEVT_IDLE, &MyHandler::StaticOnIdle);
-#endif // !wxEVENTS_COMPATIBILITY_2_8
+    handler.Bind(wxEVT_IDLE, &MyHandler::StaticOnIdle);
+    handler.Unbind(wxEVT_IDLE, &MyHandler::StaticOnIdle);
+#endif // wxHAS_EVENT_BIND
 }
 
 void EvtHandlerTestCase::LegacyConnect()
@@ -237,154 +249,200 @@ void EvtHandlerTestCase::LegacyConnect()
     handler.Disconnect( 0, 0, LegacyEventType, (wxObjectEventFunction)&MyHandler::OnEvent, NULL, &handler );
 }
 
-#if !wxEVENTS_COMPATIBILITY_2_8
+#ifdef wxHAS_EVENT_BIND
 
-void EvtHandlerTestCase::ConnectFunction()
+void EvtHandlerTestCase::BindFunction()
 {
     // function tests
-    handler.Connect( MyEventType, GlobalOnMyEvent );
+    handler.Bind( MyEventType, GlobalOnMyEvent );
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( g_called.function );
-    handler.Disconnect( MyEventType, GlobalOnMyEvent );
+    handler.Unbind( MyEventType, GlobalOnMyEvent );
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( !g_called.function ); // check that it was disconnected
 
-    handler.Connect( 0, MyEventType, GlobalOnMyEvent );
-    handler.Disconnect( 0, MyEventType, GlobalOnMyEvent );
+    handler.Bind( MyEventType, GlobalOnMyEvent, 0 );
+    handler.Unbind( MyEventType, GlobalOnMyEvent, 0 );
 
-    handler.Connect( 0, 0, MyEventType, GlobalOnMyEvent );
-    handler.Disconnect( 0, 0, MyEventType, GlobalOnMyEvent );
+    handler.Bind( MyEventType, GlobalOnMyEvent, 0, 0 );
+    handler.Unbind( MyEventType, GlobalOnMyEvent, 0, 0 );
 }
 
-void EvtHandlerTestCase::ConnectStaticMethod()
+void EvtHandlerTestCase::BindStaticMethod()
 {
     // static method tests (this is same as functions but still test it just in
     // case we hit some strange compiler bugs)
-    handler.Connect( MyEventType, &MyHandler::StaticOnMyEvent );
+    handler.Bind( MyEventType, &MyHandler::StaticOnMyEvent );
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( g_called.smethod );
-    handler.Disconnect( MyEventType, &MyHandler::StaticOnMyEvent );
+    handler.Unbind( MyEventType, &MyHandler::StaticOnMyEvent );
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( !g_called.smethod );
 
-    handler.Connect( 0, MyEventType, &MyHandler::StaticOnMyEvent );
-    handler.Disconnect( 0, MyEventType, &MyHandler::StaticOnMyEvent );
+    handler.Bind( MyEventType, &MyHandler::StaticOnMyEvent, 0 );
+    handler.Unbind( MyEventType, &MyHandler::StaticOnMyEvent, 0 );
 
-    handler.Connect( 0, 0, MyEventType, &MyHandler::StaticOnMyEvent );
-    handler.Disconnect( 0, 0, MyEventType, &MyHandler::StaticOnMyEvent );
+    handler.Bind( MyEventType, &MyHandler::StaticOnMyEvent, 0, 0 );
+    handler.Unbind( MyEventType, &MyHandler::StaticOnMyEvent, 0, 0 );
 }
 
-void EvtHandlerTestCase::ConnectFunctor()
+void EvtHandlerTestCase::BindFunctor()
 {
     // generalized functor tests
     MyFunctor functor;
 
-    handler.Connect( MyEventType, functor );
+    handler.Bind( MyEventType, functor );
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( g_called.functor );
-    handler.Disconnect( MyEventType, functor );
+    handler.Unbind( MyEventType, functor );
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( !g_called.functor );
 
-    handler.Connect( 0, MyEventType, functor );
-    handler.Disconnect( 0, MyEventType, functor );
+    handler.Bind( MyEventType, functor, 0 );
+    handler.Unbind( MyEventType, functor, 0 );
+
+    handler.Bind( MyEventType, functor, 0, 0 );
+    handler.Unbind( MyEventType, functor, 0, 0 );
+
+    // test that a temporary functor is working as well and also test that
+    // unbinding a different (though equal) instance of the same functor does
+    // not work
+    MyFunctor func;
+    handler.Bind( MyEventType, MyFunctor() );
+    CPPUNIT_ASSERT( !handler.Unbind( MyEventType, func ));
+
+    handler.Bind( MyEventType, MyFunctor(), 0 );
+    CPPUNIT_ASSERT( !handler.Unbind( MyEventType, func, 0 ));
 
-    handler.Connect( 0, 0, MyEventType, functor );
-    handler.Disconnect( 0, 0, MyEventType, functor );
+    handler.Bind( MyEventType, MyFunctor(), 0, 0 );
+    CPPUNIT_ASSERT( !handler.Unbind( MyEventType, func, 0, 0 ));
 }
 
-void EvtHandlerTestCase::ConnectMethod()
+void EvtHandlerTestCase::BindMethod()
 {
     // class method tests
-    handler.Connect( MyEventType, &MyHandler::OnMyEvent );
+    handler.Bind( MyEventType, &MyHandler::OnMyEvent, &handler );
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( g_called.method );
-    handler.Disconnect( MyEventType, &MyHandler::OnMyEvent );
+    handler.Unbind( MyEventType, &MyHandler::OnMyEvent, &handler );
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( !g_called.method );
 
-    handler.Connect( 0, MyEventType, &MyHandler::OnMyEvent );
-    handler.Disconnect( 0, MyEventType, &MyHandler::OnMyEvent );
+    handler.Bind( MyEventType, &MyHandler::OnMyEvent, &handler, 0 );
+    handler.Unbind( MyEventType, &MyHandler::OnMyEvent, &handler, 0 );
 
-    handler.Connect( 0, 0, MyEventType, &MyHandler::OnMyEvent );
-    handler.Disconnect( 0, 0, MyEventType, &MyHandler::OnMyEvent );
+    handler.Bind( MyEventType, &MyHandler::OnMyEvent, &handler, 0, 0 );
+    handler.Unbind( MyEventType, &MyHandler::OnMyEvent, &handler, 0, 0 );
 }
 
-void EvtHandlerTestCase::ConnectMethodUsingBaseEvent()
+void EvtHandlerTestCase::BindMethodUsingBaseEvent()
 {
     // 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 );
+    handler.Bind( MyEventType, &MyHandler::OnEvent, &handler );
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( g_called.method );
-    handler.Disconnect( MyEventType, &MyHandler::OnEvent );
+    handler.Unbind( MyEventType, &MyHandler::OnEvent, &handler );
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( !g_called.method );
 
-    handler.Connect( 0, MyEventType, &MyHandler::OnEvent );
-    handler.Disconnect( 0, MyEventType, &MyHandler::OnEvent );
+    handler.Bind( MyEventType, &MyHandler::OnEvent, &handler, 0 );
+    handler.Unbind( MyEventType, &MyHandler::OnEvent, &handler, 0 );
 
-    handler.Connect( 0, 0, MyEventType, &MyHandler::OnEvent );
-    handler.Disconnect( 0, 0, MyEventType, &MyHandler::OnEvent );
+    handler.Bind( MyEventType, &MyHandler::OnEvent, &handler, 0, 0 );
+    handler.Unbind( MyEventType, &MyHandler::OnEvent, &handler, 0, 0 );
 }
 
-void EvtHandlerTestCase::ConnectMethodWithSink()
+
+void EvtHandlerTestCase::BindFunctionUsingBaseEvent()
 {
-    handler.Connect( MyEventType, &MyHandler::OnMyEvent, NULL, &handler );
-    handler.Connect( 0, MyEventType, &MyHandler::OnMyEvent, NULL, &handler );
-    handler.Connect( 0, 0, MyEventType, &MyHandler::OnMyEvent, NULL, &handler );
+    // test connecting a function taking just wxEvent and not MyEvent: this
+    // should work too if we don't need any MyEvent-specific information in the
+    // handler
+    handler.Bind( MyEventType, GlobalOnEvent );
+    g_called.Reset();
+    handler.ProcessEvent(e);
+    CPPUNIT_ASSERT( g_called.function );
+    handler.Unbind( MyEventType, GlobalOnEvent );
+    g_called.Reset();
+    handler.ProcessEvent(e);
+    CPPUNIT_ASSERT( !g_called.function );
+
+    handler.Bind( MyEventType, GlobalOnEvent, 0 );
+    handler.Unbind( MyEventType, GlobalOnEvent, 0 );
 
-    handler.Disconnect( MyEventType, &MyHandler::OnMyEvent, NULL, &handler );
-    handler.Disconnect( 0, MyEventType, &MyHandler::OnMyEvent, NULL, &handler );
-    handler.Disconnect( 0, 0, MyEventType, &MyHandler::OnMyEvent, NULL, &handler );
+    handler.Bind( MyEventType, GlobalOnEvent, 0, 0 );
+    handler.Unbind( MyEventType, GlobalOnEvent, 0, 0 );
 }
 
-void EvtHandlerTestCase::ConnectNonHandler()
+
+
+void EvtHandlerTestCase::BindNonHandler()
 {
     // class method tests for class not derived from wxEvtHandler
     MySink sink;
 
-    handler.Connect( MyEventType, &MySink::OnMyEvent, NULL, &sink );
+    handler.Bind( MyEventType, &MySink::OnMyEvent, &sink );
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( g_called.method );
-    handler.Disconnect( MyEventType, &MySink::OnMyEvent, NULL, &sink );
+    handler.Unbind( MyEventType, &MySink::OnMyEvent, &sink );
     g_called.Reset();
     handler.ProcessEvent(e);
     CPPUNIT_ASSERT( !g_called.method );
 }
 
-void EvtHandlerTestCase::StaticConnect()
-{
-    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, 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::InvalidBind()
 {
     // 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(MyEventType, GlobalOnAnotherEvent);
-    //IdleFunctor f; handler.Connect(MyEventType, f);
-    //handler.Connect(MyEventType, &MyHandler::StaticOnAnotherEvent);
-    //handler.Connect(MyEventType, &MyHandler::OnAnotherEvent);
+
+    // connecting a handler with incompatible signature shouldn't work
+#ifdef TEST_INVALID_BIND_GLOBAL
+    handler.Bind(MyEventType, GlobalOnAnotherEvent);
+#endif
+#ifdef TEST_INVALID_BIND_STATIC
+    handler.Bind(MyEventType, &MyHandler::StaticOnAnotherEvent);
+#endif
+#ifdef TEST_INVALID_BIND_METHOD
+    handler.Bind(MyEventType, &MyHandler::OnAnotherEvent, &handler);
+#endif
+#ifdef TEST_INVALID_BIND_FUNCTOR
+    IdleFunctor f;
+    handler.Bind(MyEventType, f);
+#endif
+
+    // the handler can't be omitted when calling Bind()
+#ifdef TEST_INVALID_BIND_NO_HANDLER
+    handler.Bind(MyEventType, &MyHandler::OnMyEvent);
+#endif
+
+    // calling a derived class method with a base class pointer must not work
+#ifdef TEST_INVALID_BIND_DERIVED
+    struct C1 : wxEvtHandler { };
+    struct C2 : wxEvtHandler { void OnWhatever(wxEvent&); };
+    C1 c1;
+    c1.Bind(&C2::OnWhatever);
+#endif
+
+    // using object pointer incompatible with the method must not work
+#ifdef TEST_INVALID_BIND_WRONG_CLASS
+    MySink mySink;
+    MyHandler myHandler;
+    myHandler.Bind(MyEventType, &MyHandler::OnMyEvent, &mySink);
+#endif
 }
 
-#endif // !wxEVENTS_COMPATIBILITY_2_8
+#endif // wxHAS_EVENT_BIND