Allow to not create wxPaintDC in EVT_PAINT handler in wxMSW.

[wxWidgets.git] / src / common / event.cpp

diff --git a/src/common/event.cpp b/src/common/event.cpp
index 4f9c74adc3a2b926c079ca1404d7b265a4b5483d..4dd9eaeaa4f8e6fdaa952b0f31a61a5717e0e1ed 100644 (file)
--- a/src/common/event.cpp
+++ b/src/common/event.cpp
@@ -126,7 +126,7 @@ const wxEventTableEntry wxEvtHandler::sm_eventTableEntries[] =
 // the memory leaks when using it, however this breaks re-initializing the
 // library (i.e. repeated calls to wxInitialize/wxUninitialize) because the
 // event tables won't be rebuilt the next time, so disable this by default
 // the memory leaks when using it, however this breaks re-initializing the
 // library (i.e. repeated calls to wxInitialize/wxUninitialize) because the
 // event tables won't be rebuilt the next time, so disable this by default

-#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING
+#if wxUSE_MEMORY_TRACING

 
 class wxEventTableEntryModule: public wxModule
 {
 
 class wxEventTableEntryModule: public wxModule
 {


@@ -140,7 +140,7 @@ public:
 
 IMPLEMENT_DYNAMIC_CLASS(wxEventTableEntryModule, wxModule)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxEventTableEntryModule, wxModule)
 

-#endif // __WXDEBUG__ && wxUSE_MEMORY_TRACING
+#endif // wxUSE_MEMORY_TRACING

 
 // ----------------------------------------------------------------------------
 // global variables
 
 // ----------------------------------------------------------------------------
 // global variables


@@ -177,6 +177,8 @@ wxDEFINE_EVENT( wxEVT_COMMAND_TOOL_ENTER, wxCommandEvent );
 wxDEFINE_EVENT( wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEvent );
 wxDEFINE_EVENT( wxEVT_COMMAND_SPINCTRLDOUBLE_UPDATED, wxCommandEvent );
 wxDEFINE_EVENT( wxEVT_COMMAND_TOOL_DROPDOWN_CLICKED, wxCommandEvent );
 wxDEFINE_EVENT( wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEvent );
 wxDEFINE_EVENT( wxEVT_COMMAND_SPINCTRLDOUBLE_UPDATED, wxCommandEvent );
 wxDEFINE_EVENT( wxEVT_COMMAND_TOOL_DROPDOWN_CLICKED, wxCommandEvent );

+wxDEFINE_EVENT( wxEVT_COMMAND_COMBOBOX_DROPDOWN, wxCommandEvent);
+wxDEFINE_EVENT( wxEVT_COMMAND_COMBOBOX_CLOSEUP, wxCommandEvent);

 
 // Mouse event types
 wxDEFINE_EVENT( wxEVT_LEFT_DOWN, wxMouseEvent );
 
 // Mouse event types
 wxDEFINE_EVENT( wxEVT_LEFT_DOWN, wxMouseEvent );


@@ -402,10 +404,9 @@ wxEvent& wxEvent::operator=(const wxEvent& src)
 
 #if wxUSE_GUI
 
 
 #if wxUSE_GUI
 

-/*
- * Command events
- *
- */
+// ----------------------------------------------------------------------------
+// wxCommandEvent
+// ----------------------------------------------------------------------------

 
 #ifdef __VISUALC__
     // 'this' : used in base member initializer list (for m_commandString)
 
 #ifdef __VISUALC__
     // 'this' : used in base member initializer list (for m_commandString)


@@ -447,9 +448,9 @@ wxString wxCommandEvent::GetString() const
     }
 }
 
     }
 }
 

-/*
- * UI update events
- */
+// ----------------------------------------------------------------------------
+// wxUpdateUIEvent
+// ----------------------------------------------------------------------------

 
 #if wxUSE_LONGLONG
 wxLongLong wxUpdateUIEvent::sm_lastUpdate = 0;
 
 #if wxUSE_LONGLONG
 wxLongLong wxUpdateUIEvent::sm_lastUpdate = 0;


@@ -506,9 +507,9 @@ void wxUpdateUIEvent::ResetUpdateTime()
 #endif
 }
 
 #endif
 }
 

-/*
- * Scroll events
- */
+// ----------------------------------------------------------------------------
+// wxScrollEvent
+// ----------------------------------------------------------------------------

 
 wxScrollEvent::wxScrollEvent(wxEventType commandType,
                              int id,
 
 wxScrollEvent::wxScrollEvent(wxEventType commandType,
                              int id,


@@ -520,9 +521,9 @@ wxScrollEvent::wxScrollEvent(wxEventType commandType,
     m_commandInt = pos;
 }
 
     m_commandInt = pos;
 }
 

-/*
- * ScrollWin events
- */
+// ----------------------------------------------------------------------------
+// wxScrollWinEvent
+// ----------------------------------------------------------------------------

 
 wxScrollWinEvent::wxScrollWinEvent(wxEventType commandType,
                                    int pos,
 
 wxScrollWinEvent::wxScrollWinEvent(wxEventType commandType,
                                    int pos,


@@ -533,10 +534,9 @@ wxScrollWinEvent::wxScrollWinEvent(wxEventType commandType,
     m_commandInt = pos;
 }
 
     m_commandInt = pos;
 }
 

-/*
- * Mouse events
- *
- */
+// ----------------------------------------------------------------------------
+// wxMouseEvent
+// ----------------------------------------------------------------------------

 
 wxMouseEvent::wxMouseEvent(wxEventType commandType)
 {
 
 wxMouseEvent::wxMouseEvent(wxEventType commandType)
 {


@@ -703,34 +703,6 @@ bool wxMouseEvent::Button(int but) const
     }
 }
 
     }
 }
 

-bool wxMouseEvent::ButtonIsDown(int but) const
-{
-    switch (but)
-    {
-        default:
-            wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonIsDown"));
-            // fall through
-
-        case wxMOUSE_BTN_ANY:
-            return LeftIsDown() || MiddleIsDown() || RightIsDown() || Aux1Down() || Aux2Down();
-
-        case wxMOUSE_BTN_LEFT:
-            return LeftIsDown();
-
-        case wxMOUSE_BTN_MIDDLE:
-            return MiddleIsDown();
-
-        case wxMOUSE_BTN_RIGHT:
-            return RightIsDown();
-
-        case wxMOUSE_BTN_AUX1:
-            return Aux1IsDown();
-
-        case wxMOUSE_BTN_AUX2:
-            return Aux2IsDown();
-    }
-}
-

 int wxMouseEvent::GetButton() const
 {
     for ( int i = 1; i < wxMOUSE_BTN_MAX; i++ )
 int wxMouseEvent::GetButton() const
 {
     for ( int i = 1; i < wxMOUSE_BTN_MAX; i++ )


@@ -751,17 +723,14 @@ wxPoint wxMouseEvent::GetLogicalPosition(const wxDC& dc) const
     return pt;
 }
 
     return pt;
 }
 

-
-/*
- * Keyboard event
- *
- */
+// ----------------------------------------------------------------------------
+// wxKeyEvent
+// ----------------------------------------------------------------------------

 
 wxKeyEvent::wxKeyEvent(wxEventType type)
 {
     m_eventType = type;
     m_keyCode = 0;
 
 wxKeyEvent::wxKeyEvent(wxEventType type)
 {
     m_eventType = type;
     m_keyCode = 0;

-    m_scanCode = 0;

 #if wxUSE_UNICODE
     m_uniChar = 0;
 #endif
 #if wxUSE_UNICODE
     m_uniChar = 0;
 #endif


@@ -775,8 +744,6 @@ wxKeyEvent::wxKeyEvent(const wxKeyEvent& evt)
     m_y = evt.m_y;
 
     m_keyCode = evt.m_keyCode;
     m_y = evt.m_y;
 
     m_keyCode = evt.m_keyCode;

-
-    m_scanCode = evt.m_scanCode;

     m_rawCode = evt.m_rawCode;
     m_rawFlags = evt.m_rawFlags;
 
     m_rawCode = evt.m_rawCode;
     m_rawFlags = evt.m_rawFlags;
 


@@ -785,18 +752,70 @@ wxKeyEvent::wxKeyEvent(const wxKeyEvent& evt)
 #endif
 }
 
 #endif
 }
 

+bool wxKeyEvent::IsKeyInCategory(int category) const
+{
+    switch ( GetKeyCode() )
+    {
+        case WXK_LEFT:
+        case WXK_RIGHT:
+        case WXK_UP:
+        case WXK_DOWN:
+        case WXK_NUMPAD_LEFT:
+        case WXK_NUMPAD_RIGHT:
+        case WXK_NUMPAD_UP:
+        case WXK_NUMPAD_DOWN:
+            return (category & WXK_CATEGORY_ARROW) != 0;
+
+        case WXK_PAGEDOWN:
+        case WXK_END:
+        case WXK_NUMPAD_PAGEUP:
+        case WXK_NUMPAD_PAGEDOWN:
+            return (category & WXK_CATEGORY_PAGING) != 0;
+
+        case WXK_HOME:
+        case WXK_PAGEUP:
+        case WXK_NUMPAD_HOME:
+        case WXK_NUMPAD_END:
+            return (category & WXK_CATEGORY_JUMP) != 0;
+
+        case WXK_TAB:
+        case WXK_NUMPAD_TAB:
+            return (category & WXK_CATEGORY_TAB) != 0;
+
+        case WXK_BACK:
+        case WXK_DELETE:
+        case WXK_NUMPAD_DELETE:
+            return (category & WXK_CATEGORY_CUT) != 0;
+
+        default:
+            return false;
+    }
+}
+
+// ----------------------------------------------------------------------------
+// wxWindowCreateEvent
+// ----------------------------------------------------------------------------
+

 wxWindowCreateEvent::wxWindowCreateEvent(wxWindow *win)
 {
     SetEventType(wxEVT_CREATE);
     SetEventObject(win);
 }
 
 wxWindowCreateEvent::wxWindowCreateEvent(wxWindow *win)
 {
     SetEventType(wxEVT_CREATE);
     SetEventObject(win);
 }
 

+// ----------------------------------------------------------------------------
+// wxWindowDestroyEvent
+// ----------------------------------------------------------------------------
+

 wxWindowDestroyEvent::wxWindowDestroyEvent(wxWindow *win)
 {
     SetEventType(wxEVT_DESTROY);
     SetEventObject(win);
 }
 
 wxWindowDestroyEvent::wxWindowDestroyEvent(wxWindow *win)
 {
     SetEventType(wxEVT_DESTROY);
     SetEventObject(win);
 }
 

+// ----------------------------------------------------------------------------
+// wxChildFocusEvent
+// ----------------------------------------------------------------------------
+

 wxChildFocusEvent::wxChildFocusEvent(wxWindow *win)
                  : wxCommandEvent(wxEVT_CHILD_FOCUS)
 {
 wxChildFocusEvent::wxChildFocusEvent(wxWindow *win)
                  : wxCommandEvent(wxEVT_CHILD_FOCUS)
 {


@@ -871,7 +890,7 @@ void wxEventHashTable::Clear()
     m_size = 0;
 }
 
     m_size = 0;
 }
 

-#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING
+#if wxUSE_MEMORY_TRACING

 
 // Clear all tables
 void wxEventHashTable::ClearAll()
 
 // Clear all tables
 void wxEventHashTable::ClearAll()


@@ -884,7 +903,7 @@ void wxEventHashTable::ClearAll()
     }
 }
 
     }
 }
 

-#endif // __WXDEBUG__ && wxUSE_MEMORY_TRACING
+#endif // wxUSE_MEMORY_TRACING

 
 bool wxEventHashTable::HandleEvent(wxEvent &event, wxEvtHandler *self)
 {
 
 bool wxEventHashTable::HandleEvent(wxEvent &event, wxEvtHandler *self)
 {


@@ -1074,14 +1093,11 @@ wxEvtHandler::~wxEvtHandler()
         delete m_dynamicEvents;
     }
 
         delete m_dynamicEvents;
     }
 

-    if (m_pendingEvents)
-        m_pendingEvents->DeleteContents(true);
-    delete m_pendingEvents;
-

     // Remove us from the list of the pending events if necessary.
     // Remove us from the list of the pending events if necessary.

-    wxEventLoopBase *loop = wxEventLoopBase::GetActive();
-    if (loop)
-        loop->RemovePendingEventHandler(this);
+    if (wxTheApp)
+        wxTheApp->RemovePendingEventHandler(this);
+
+    DeletePendingEvents();

 
     // we only delete object data, not untyped
     if ( m_clientDataType == wxClientData_Object )
 
     // we only delete object data, not untyped
     if ( m_clientDataType == wxClientData_Object )


@@ -1127,12 +1143,15 @@ void wxEvtHandler::QueueEvent(wxEvent *event)
 {
     wxCHECK_RET( event, "NULL event can't be posted" );
 
 {
     wxCHECK_RET( event, "NULL event can't be posted" );
 

-    wxEventLoopBase* loop = wxEventLoopBase::GetActive();
-    if (!loop)
+    if (!wxTheApp)

     {
         // we need an event loop which manages the list of event handlers with
         // pending events... cannot proceed without it!
     {
         // we need an event loop which manages the list of event handlers with
         // pending events... cannot proceed without it!

-        wxLogDebug("No event loop is running!");
+        wxLogDebug("No application object! Cannot queue this event!");
+
+        // anyway delete the given event to avoid memory leaks
+        delete event;
+

         return;
     }
 
         return;
     }
 


@@ -1140,14 +1159,14 @@ void wxEvtHandler::QueueEvent(wxEvent *event)
     wxENTER_CRIT_SECT( m_pendingEventsLock );
 
     if ( !m_pendingEvents )
     wxENTER_CRIT_SECT( m_pendingEventsLock );
 
     if ( !m_pendingEvents )

-      m_pendingEvents = new wxList;
+        m_pendingEvents = new wxList;

 
     m_pendingEvents->Append(event);
 
     // 2) Add this event handler to list of event handlers that
     //    have pending events.
 
 
     m_pendingEvents->Append(event);
 
     // 2) Add this event handler to list of event handlers that
     //    have pending events.
 

-    loop->AppendPendingEventHandler(this);
+    wxTheApp->AppendPendingEventHandler(this);

 
     // only release m_pendingEventsLock now because otherwise there is a race
     // condition as described in the ticket #9093: we could process the event
 
     // only release m_pendingEventsLock now because otherwise there is a race
     // condition as described in the ticket #9093: we could process the event


@@ -1162,14 +1181,20 @@ void wxEvtHandler::QueueEvent(wxEvent *event)
     wxWakeUpIdle();
 }
 
     wxWakeUpIdle();
 }
 

+void wxEvtHandler::DeletePendingEvents()
+{
+    if (m_pendingEvents)
+        m_pendingEvents->DeleteContents(true);
+    wxDELETE(m_pendingEvents);
+}
+

 void wxEvtHandler::ProcessPendingEvents()
 {
 void wxEvtHandler::ProcessPendingEvents()
 {

-    wxEventLoopBase* loop = wxEventLoopBase::GetActive();
-    if (!loop)
+    if (!wxTheApp)

     {
         // we need an event loop which manages the list of event handlers with
         // pending events... cannot proceed without it!
     {
         // we need an event loop which manages the list of event handlers with
         // pending events... cannot proceed without it!

-        wxLogDebug("No event loop is running!");
+        wxLogDebug("No application object! Cannot process pending events!");

         return;
     }
 
         return;
     }
 


@@ -1200,7 +1225,7 @@ void wxEvtHandler::ProcessPendingEvents()
         if (!node)
         {
             // all our events are NOT processable now... signal this:
         if (!node)
         {
             // all our events are NOT processable now... signal this:

-            loop->DelayPendingEventHandler(this);
+            wxTheApp->DelayPendingEventHandler(this);

 
             // see the comment at the beginning of evtloop.h header for the
             // logic behind YieldFor() and behind DelayPendingEventHandler()
 
             // see the comment at the beginning of evtloop.h header for the
             // logic behind YieldFor() and behind DelayPendingEventHandler()


@@ -1222,7 +1247,7 @@ void wxEvtHandler::ProcessPendingEvents()
     {
         // if there are no more pending events left, we don't need to
         // stay in this list
     {
         // if there are no more pending events left, we don't need to
         // stay in this list

-        loop->RemovePendingEventHandler(this);
+        wxTheApp->RemovePendingEventHandler(this);

     }
 
     wxLEAVE_CRIT_SECT( m_pendingEventsLock );
     }
 
     wxLEAVE_CRIT_SECT( m_pendingEventsLock );


@@ -1234,13 +1259,10 @@ void wxEvtHandler::ProcessPendingEvents()
     // of this object any more
 }
 
     // of this object any more
 }
 

-/*
- * Event table stuff
- */
-/* static */ bool
-wxEvtHandler::ProcessEventIfMatchesId(const wxEventTableEntryBase& entry,
-                                      wxEvtHandler *handler,
-                                      wxEvent& event)
+/* static */
+bool wxEvtHandler::ProcessEventIfMatchesId(const wxEventTableEntryBase& entry,
+                                           wxEvtHandler *handler,
+                                           wxEvent& event)

 {
     int tableId1 = entry.m_id,
         tableId2 = entry.m_lastId;
 {
     int tableId1 = entry.m_id,
         tableId2 = entry.m_lastId;


@@ -1278,15 +1300,8 @@ wxEvtHandler::ProcessEventIfMatchesId(const wxEventTableEntryBase& entry,
     return false;
 }
 
     return false;
 }
 

-bool wxEvtHandler::TryParent(wxEvent& event)
+bool wxEvtHandler::DoTryApp(wxEvent& event)

 {
 {

-    if ( GetNextHandler() )
-    {
-        // the next handler will pass it to wxTheApp if it doesn't process it,
-        // so return from here to avoid doing it again
-        return GetNextHandler()->TryParent(event);
-    }
-

     if ( wxTheApp && (this != wxTheApp) )
     {
         // Special case: don't pass wxEVT_IDLE to wxApp, since it'll always
     if ( wxTheApp && (this != wxTheApp) )
     {
         // Special case: don't pass wxEVT_IDLE to wxApp, since it'll always


@@ -1302,6 +1317,27 @@ bool wxEvtHandler::TryParent(wxEvent& event)
     return false;
 }
 
     return false;
 }
 

+bool wxEvtHandler::TryBefore(wxEvent& event)
+{
+#if WXWIN_COMPATIBILITY_2_8
+    // call the old virtual function to keep the code overriding it working
+    return TryValidator(event);
+#else
+    wxUnusedVar(event);
+    return false;
+#endif
+}
+
+bool wxEvtHandler::TryAfter(wxEvent& event)
+{
+#if WXWIN_COMPATIBILITY_2_8
+    // as above, call the old virtual function for compatibility
+    return TryParent(event);
+#else
+    return DoTryApp(event);
+#endif
+}
+

 bool wxEvtHandler::ProcessEvent(wxEvent& event)
 {
     // allow the application to hook into event processing
 bool wxEvtHandler::ProcessEvent(wxEvent& event)
 {
     // allow the application to hook into event processing


@@ -1313,27 +1349,6 @@ bool wxEvtHandler::ProcessEvent(wxEvent& event)
     {
         if ( wxTheApp )
         {
     {
         if ( wxTheApp )
         {

-/*
-    CANNOT ENABLE: ProcessEvent() must always immediately process the event!
-
-            if (wxTheApp->IsYielding() &&
-                !wxTheApp->IsEventAllowedInsideYield(event.GetEventCategory()))
-            {
-                wxEvent* queuedEv = event.Clone();
-
-                // queue this event rather than processing it now
-                QueueEvent(queuedEv);
-                    // the wxWakeUpIdle call shouldn't probably be done
-                    // in this context (there's wxYield in the call stack)
-
-                return true;
-                    // it's not completely true that the event was processed;
-                    // but we cannot even say it was skipped or discarded...
-            }
-            //else: either we're not inside a wxYield() call or if we are,
-            //      we can process this event immediately.
-*/
-

             int rc = wxTheApp->FilterEvent(event);
             if ( rc != -1 )
             {
             int rc = wxTheApp->FilterEvent(event);
             if ( rc != -1 )
             {


@@ -1350,14 +1365,14 @@ bool wxEvtHandler::ProcessEvent(wxEvent& event)
         return true;
 
     // pass the event to the next handler, notice that we shouldn't call
         return true;
 
     // pass the event to the next handler, notice that we shouldn't call

-    // TryParent() even if it doesn't handle the event as the last handler in
+    // TryAfter() even if it doesn't handle the event as the last handler in

     // the chain will do it
     if ( GetNextHandler() )
         return GetNextHandler()->ProcessEvent(event);
 
     // propagate the event upwards the window chain and/or to the application
     // object if it wasn't processed at this level
     // the chain will do it
     if ( GetNextHandler() )
         return GetNextHandler()->ProcessEvent(event);
 
     // propagate the event upwards the window chain and/or to the application
     // object if it wasn't processed at this level

-    return TryParent(event);
+    return TryAfter(event);

 }
 
 bool wxEvtHandler::ProcessEventHere(wxEvent& event)
 }
 
 bool wxEvtHandler::ProcessEventHere(wxEvent& event)


@@ -1366,9 +1381,8 @@ bool wxEvtHandler::ProcessEventHere(wxEvent& event)
     if ( !GetEvtHandlerEnabled() )
         return false;
 
     if ( !GetEvtHandlerEnabled() )
         return false;
 

-    // If we have a validator, it has higher priority than our own event
-    // handlers
-    if ( TryValidator(event) )
+    // Try the hooks which should be called before our own handlers
+    if ( TryBefore(event) )

         return true;
 
     // Handle per-instance dynamic event tables first
         return true;
 
     // Handle per-instance dynamic event tables first


@@ -1394,9 +1408,15 @@ bool wxEvtHandler::SafelyProcessEvent(wxEvent& event)
     }
     catch ( ... )
     {
     }
     catch ( ... )
     {

-        wxEventLoopBase *loop = wxEventLoopBase::GetActive();
+        // notice that we do it in 2 steps to avoid warnings about possibly
+        // uninitialized loop variable from some versions of g++ which are not
+        // smart enough to figure out that GetActive() doesn't throw and so
+        // that loop will always be initialized
+        wxEventLoopBase *loop = NULL;

         try
         {
         try
         {

+            loop = wxEventLoopBase::GetActive();
+

             if ( !wxTheApp || !wxTheApp->OnExceptionInMainLoop() )
             {
                 if ( loop )
             if ( !wxTheApp || !wxTheApp->OnExceptionInMainLoop() )
             {
                 if ( loop )


@@ -1419,7 +1439,6 @@ bool wxEvtHandler::SafelyProcessEvent(wxEvent& event)
 #endif // wxUSE_EXCEPTIONS
 }
 
 #endif // wxUSE_EXCEPTIONS
 }
 

-

 bool wxEvtHandler::SearchEventTable(wxEventTable& table, wxEvent& event)
 {
     const wxEventType eventType = event.GetEventType();
 bool wxEvtHandler::SearchEventTable(wxEventTable& table, wxEvent& event)
 {
     const wxEventType eventType = event.GetEventType();


@@ -1436,11 +1455,11 @@ bool wxEvtHandler::SearchEventTable(wxEventTable& table, wxEvent& event)
     return false;
 }
 
     return false;
 }
 

-void wxEvtHandler::DoConnect(int id,
-                             int lastId,
-                             wxEventType eventType,
-                             wxEventFunctor *func,
-                             wxObject *userData)
+void wxEvtHandler::DoBind(int id,
+                          int lastId,
+                          wxEventType eventType,
+                          wxEventFunctor *func,
+                          wxObject *userData)

 {
     wxDynamicEventTableEntry *entry =
         new wxDynamicEventTableEntry(eventType, id, lastId, func, userData);
 {
     wxDynamicEventTableEntry *entry =
         new wxDynamicEventTableEntry(eventType, id, lastId, func, userData);


@@ -1464,11 +1483,11 @@ void wxEvtHandler::DoConnect(int id,
 }
 
 bool
 }
 
 bool

-wxEvtHandler::DoDisconnect(int id,
-                           int lastId,
-                           wxEventType eventType,
-                           const wxEventFunctor& func,
-                           wxObject *userData)
+wxEvtHandler::DoUnbind(int id,
+                       int lastId,
+                       wxEventType eventType,
+                       const wxEventFunctor& func,
+                       wxObject *userData)

 {
     if (!m_dynamicEvents)
         return false;
 {
     if (!m_dynamicEvents)
         return false;


@@ -1490,7 +1509,7 @@ wxEvtHandler::DoDisconnect(int id,
         if ((entry->m_id == id) &&
             ((entry->m_lastId == lastId) || (lastId == wxID_ANY)) &&
             ((entry->m_eventType == eventType) || (eventType == wxEVT_NULL)) &&
         if ((entry->m_id == id) &&
             ((entry->m_lastId == lastId) || (lastId == wxID_ANY)) &&
             ((entry->m_eventType == eventType) || (eventType == wxEVT_NULL)) &&

-            entry->m_fn->Matches(func) &&
+            entry->m_fn->IsMatching(func) &&

             ((entry->m_callbackUserData == userData) || !userData))
         {
             delete entry->m_callbackUserData;
             ((entry->m_callbackUserData == userData) || !userData))
         {
             delete entry->m_callbackUserData;