Fix (correct) warning about potentially uninitialized variables.

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

diff --git a/src/common/event.cpp b/src/common/event.cpp
index 0c3b44ea099e0b004e98dbfcc25ecd172f3b0820..5c40ecf1c803a24174018f2d7d906ebe02c7a2d2 100644 (file)
--- a/src/common/event.cpp
+++ b/src/common/event.cpp
@@ -17,7 +17,14 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) && !defined(__EMX__)
+// Some older compilers (such as EMX) cannot handle
+// #pragma interface/implementation correctly, iff
+// #pragma implementation is used in _two_ translation
+// units (as created by e.g. event.cpp compiled for
+// libwx_base and event.cpp compiled for libwx_gui_core).
+// So we must not use those pragmas for those compilers in
+// such files.

     #pragma implementation "event.h"
 #endif
 
     #pragma implementation "event.h"
 #endif
 


@@ -41,6 +48,7 @@
 #endif
 
 #include "wx/event.h"
 #endif
 
 #include "wx/event.h"

+#include "wx/module.h"

 
 #if wxUSE_GUI
     #include "wx/validate.h"
 
 #if wxUSE_GUI
     #include "wx/validate.h"


@@ -86,7 +94,7 @@
     IMPLEMENT_DYNAMIC_CLASS(wxSysColourChangedEvent, wxEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxDisplayChangedEvent, wxEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxUpdateUIEvent, wxCommandEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxSysColourChangedEvent, wxEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxDisplayChangedEvent, wxEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxUpdateUIEvent, wxCommandEvent)

-    IMPLEMENT_DYNAMIC_CLASS(wxNavigationKeyEvent, wxCommandEvent)
+    IMPLEMENT_DYNAMIC_CLASS(wxNavigationKeyEvent, wxEvent)

     IMPLEMENT_DYNAMIC_CLASS(wxPaletteChangedEvent, wxEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxQueryNewPaletteEvent, wxEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxWindowCreateEvent, wxEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxPaletteChangedEvent, wxEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxQueryNewPaletteEvent, wxEvent)
     IMPLEMENT_DYNAMIC_CLASS(wxWindowCreateEvent, wxEvent)


@@ -112,6 +120,24 @@ wxEventHashTable wxEvtHandler::sm_eventHashTable(wxEvtHandler::sm_eventTable);
 const wxEventTableEntry wxEvtHandler::sm_eventTableEntries[] =
     { DECLARE_EVENT_TABLE_ENTRY(wxEVT_NULL, 0, 0, (wxObjectEventFunction)NULL, NULL) };
 
 const wxEventTableEntry wxEvtHandler::sm_eventTableEntries[] =
     { DECLARE_EVENT_TABLE_ENTRY(wxEVT_NULL, 0, 0, (wxObjectEventFunction)NULL, NULL) };
 

+    
+#ifdef __WXDEBUG__
+// Clear up event hash table contents or we can get problems
+// when C++ is cleaning up the static object
+class wxEventTableEntryModule: public wxModule
+{
+DECLARE_DYNAMIC_CLASS(wxEventTableEntryModule)
+public:
+    wxEventTableEntryModule() {}
+    bool OnInit() { return true; }
+    void OnExit()
+    {
+        wxEventHashTable::ClearAll();
+    }
+};
+IMPLEMENT_DYNAMIC_CLASS(wxEventTableEntryModule, wxModule)
+#endif
+    

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


@@ -304,16 +330,6 @@ int wxNewEventType()
     // MT-FIXME
     static int s_lastUsedEventType = wxEVT_FIRST;
 
     // MT-FIXME
     static int s_lastUsedEventType = wxEVT_FIRST;
 

-#if WXWIN_COMPATIBILITY_2
-    // check that we don't overlap with the user-defined types: if it does
-    // happen, the best solution is probably to update the existing code to
-    // use wxNewEventType() instead of wxEVT_USER_FIRST
-    //
-    // due to the uncertainty
-    wxASSERT_MSG( s_lastUsedEventType < wxEVT_USER_FIRST - 1,
-                  _T("possible event type conflict") );
-#endif // WXWIN_COMPATIBILITY_2
-

     return s_lastUsedEventType++;
 }
 
     return s_lastUsedEventType++;
 }
 


@@ -336,9 +352,9 @@ wxEvent::wxEvent(int theId, wxEventType commandType )
     m_eventObject = (wxObject *) NULL;
     m_timeStamp = 0;
     m_id = theId;
     m_eventObject = (wxObject *) NULL;
     m_timeStamp = 0;
     m_id = theId;

-    m_skipped = FALSE;
+    m_skipped = false;

     m_callbackUserData = (wxObject *) NULL;
     m_callbackUserData = (wxObject *) NULL;

-    m_isCommandEvent = FALSE;
+    m_isCommandEvent = false;

     m_propagationLevel = wxEVENT_PROPAGATE_NONE;
 }
 
     m_propagationLevel = wxEVENT_PROPAGATE_NONE;
 }
 


@@ -371,7 +387,7 @@ wxCommandEvent::wxCommandEvent(wxEventType commandType, int theId)
     m_clientObject = (wxClientData *) NULL;
     m_extraLong = 0;
     m_commandInt = 0;
     m_clientObject = (wxClientData *) NULL;
     m_extraLong = 0;
     m_commandInt = 0;

-    m_isCommandEvent = TRUE;
+    m_isCommandEvent = true;

 
     // the command events are propagated upwards by default
     m_propagationLevel = wxEVENT_PROPAGATE_MAX;
 
     // the command events are propagated upwards by default
     m_propagationLevel = wxEVENT_PROPAGATE_MAX;


@@ -390,34 +406,34 @@ long wxUpdateUIEvent::sm_updateInterval = 0;
 wxUpdateUIMode wxUpdateUIEvent::sm_updateMode = wxUPDATE_UI_PROCESS_ALL;
 
 // Can we update?
 wxUpdateUIMode wxUpdateUIEvent::sm_updateMode = wxUPDATE_UI_PROCESS_ALL;
 
 // Can we update?

-bool wxUpdateUIEvent::CanUpdate(wxWindow* win)
+bool wxUpdateUIEvent::CanUpdate(wxWindowBase *win)

 {
     // Don't update if we've switched global updating off
     // and this window doesn't support updates.
     if (win &&
        (GetMode() == wxUPDATE_UI_PROCESS_SPECIFIED &&
        ((win->GetExtraStyle() & wxWS_EX_PROCESS_UI_UPDATES) == 0)))
 {
     // Don't update if we've switched global updating off
     // and this window doesn't support updates.
     if (win &&
        (GetMode() == wxUPDATE_UI_PROCESS_SPECIFIED &&
        ((win->GetExtraStyle() & wxWS_EX_PROCESS_UI_UPDATES) == 0)))

-        return FALSE;
+        return false;

 
     if (sm_updateInterval == -1)
 
     if (sm_updateInterval == -1)

-        return FALSE;
+        return false;

     else if (sm_updateInterval == 0)
     else if (sm_updateInterval == 0)

-        return TRUE;
+        return true;

     else
     {
 #if wxUSE_STOPWATCH && wxUSE_LONGLONG
         wxLongLong now = wxGetLocalTimeMillis();
         if (now > (sm_lastUpdate + sm_updateInterval))
         {
     else
     {
 #if wxUSE_STOPWATCH && wxUSE_LONGLONG
         wxLongLong now = wxGetLocalTimeMillis();
         if (now > (sm_lastUpdate + sm_updateInterval))
         {

-            return TRUE;
+            return true;

         }
 #else
         // If we don't have wxStopWatch or wxLongLong, we
         // should err on the safe side and update now anyway.
         }
 #else
         // If we don't have wxStopWatch or wxLongLong, we
         // should err on the safe side and update now anyway.

-        return TRUE;
+        return true;

 #endif
     }
 #endif
     }

-    return FALSE;
+    return false;

 }
 
 // Reset the update time to provide a delay until the next
 }
 
 // Reset the update time to provide a delay until the next


@@ -450,9 +466,9 @@ bool wxIdleEvent::CanSend(wxWindow* win)
     if (win &&
        (GetMode() == wxIDLE_PROCESS_SPECIFIED &&
        ((win->GetExtraStyle() & wxWS_EX_PROCESS_IDLE) == 0)))
     if (win &&
        (GetMode() == wxIDLE_PROCESS_SPECIFIED &&
        ((win->GetExtraStyle() & wxWS_EX_PROCESS_IDLE) == 0)))

-        return FALSE;
+        return false;

 
 

-    return TRUE;
+    return true;

 }
 
 /*
 }
 
 /*


@@ -490,13 +506,13 @@ wxScrollWinEvent::wxScrollWinEvent(wxEventType commandType,
 wxMouseEvent::wxMouseEvent(wxEventType commandType)
 {
     m_eventType = commandType;
 wxMouseEvent::wxMouseEvent(wxEventType commandType)
 {
     m_eventType = commandType;

-    m_metaDown = FALSE;
-    m_altDown = FALSE;
-    m_controlDown = FALSE;
-    m_shiftDown = FALSE;
-    m_leftDown = FALSE;
-    m_rightDown = FALSE;
-    m_middleDown = FALSE;
+    m_metaDown = false;
+    m_altDown = false;
+    m_controlDown = false;
+    m_shiftDown = false;
+    m_leftDown = false;
+    m_rightDown = false;
+    m_middleDown = false;

     m_x = 0;
     m_y = 0;
     m_wheelRotation = 0;
     m_x = 0;
     m_y = 0;
     m_wheelRotation = 0;


@@ -525,106 +541,120 @@ void wxMouseEvent::Assign(const wxMouseEvent& event)
     m_linesPerAction = event.m_linesPerAction;
 }
 
     m_linesPerAction = event.m_linesPerAction;
 }
 

-// True if was a button dclick event (1 = left, 2 = middle, 3 = right)
-// or any button dclick event (but = -1)
+// return true if was a button dclick event

 bool wxMouseEvent::ButtonDClick(int but) const
 {
     switch (but)
     {
 bool wxMouseEvent::ButtonDClick(int but) const
 {
     switch (but)
     {

-        case -1:
+        default:
+            wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonDClick"));
+            // fall through
+
+        case wxMOUSE_BTN_ANY:

             return (LeftDClick() || MiddleDClick() || RightDClick());
             return (LeftDClick() || MiddleDClick() || RightDClick());

-        case 1:
+
+        case wxMOUSE_BTN_LEFT:

             return LeftDClick();
             return LeftDClick();

-        case 2:
+
+        case wxMOUSE_BTN_MIDDLE:

             return MiddleDClick();
             return MiddleDClick();

-        case 3:
+
+        case wxMOUSE_BTN_RIGHT:

             return RightDClick();
             return RightDClick();

-        default:
-            wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonDClick"));

     }
     }

-
-    return FALSE;

 }
 
 }
 

-// True if was a button down event (1 = left, 2 = middle, 3 = right)
-// or any button down event (but = -1)
+// return true if was a button down event

 bool wxMouseEvent::ButtonDown(int but) const
 {
     switch (but)
     {
 bool wxMouseEvent::ButtonDown(int but) const
 {
     switch (but)
     {

-        case -1:
+        default:
+            wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonDown"));
+            // fall through
+
+        case wxMOUSE_BTN_ANY:

             return (LeftDown() || MiddleDown() || RightDown());
             return (LeftDown() || MiddleDown() || RightDown());

-        case 1:
+
+        case wxMOUSE_BTN_LEFT:

             return LeftDown();
             return LeftDown();

-        case 2:
+
+        case wxMOUSE_BTN_MIDDLE:

             return MiddleDown();
             return MiddleDown();

-        case 3:
+
+        case wxMOUSE_BTN_RIGHT:

             return RightDown();
             return RightDown();

-        default:
-            wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonDown"));

     }
     }

-
-    return FALSE;

 }
 
 }
 

-// True if was a button up event (1 = left, 2 = middle, 3 = right)
-// or any button up event (but = -1)
+// return true if was a button up event

 bool wxMouseEvent::ButtonUp(int but) const
 {
     switch (but)
     {
 bool wxMouseEvent::ButtonUp(int but) const
 {
     switch (but)
     {

-        case -1:
+        default:
+            wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonUp"));
+            // fall through
+
+        case wxMOUSE_BTN_ANY:

             return (LeftUp() || MiddleUp() || RightUp());
             return (LeftUp() || MiddleUp() || RightUp());

-        case 1:
+
+        case wxMOUSE_BTN_LEFT:

             return LeftUp();
             return LeftUp();

-        case 2:
+
+        case wxMOUSE_BTN_MIDDLE:

             return MiddleUp();
             return MiddleUp();

-        case 3:
+
+        case wxMOUSE_BTN_RIGHT:

             return RightUp();
             return RightUp();

-        default:
-            wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonUp"));

     }
     }

-
-    return FALSE;

 }
 
 }
 

-// True if the given button is currently changing state
+// return true if the given button is currently changing state

 bool wxMouseEvent::Button(int but) const
 {
     switch (but)
     {
 bool wxMouseEvent::Button(int but) const
 {
     switch (but)
     {

-        case -1:
-            return (ButtonUp(-1) || ButtonDown(-1) || ButtonDClick(-1));
-        case 1:
-            return (LeftDown() || LeftUp() || LeftDClick());
-        case 2:
-            return (MiddleDown() || MiddleUp() || MiddleDClick());
-        case 3:
-            return (RightDown() || RightUp() || RightDClick());

         default:
             wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::Button"));
         default:
             wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::Button"));

-    }
+            // fall through
+
+        case wxMOUSE_BTN_ANY:
+            return ButtonUp(wxMOUSE_BTN_ANY) ||
+                    ButtonDown(wxMOUSE_BTN_ANY) ||
+                        ButtonDClick(wxMOUSE_BTN_ANY);
+
+        case wxMOUSE_BTN_LEFT:
+            return LeftDown() || LeftUp() || LeftDClick();
+
+        case wxMOUSE_BTN_MIDDLE:
+            return MiddleDown() || MiddleUp() || MiddleDClick();

 
 

-    return FALSE;
+        case wxMOUSE_BTN_RIGHT:
+            return RightDown() || RightUp() || RightDClick();
+    }

 }
 
 bool wxMouseEvent::ButtonIsDown(int but) const
 {
     switch (but)
     {
 }
 
 bool wxMouseEvent::ButtonIsDown(int but) const
 {
     switch (but)
     {

-        case -1:
-            return (LeftIsDown() || MiddleIsDown() || RightIsDown());
-        case 1:
+        default:
+            wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonIsDown"));
+            // fall through
+
+        case wxMOUSE_BTN_ANY:
+            return LeftIsDown() || MiddleIsDown() || RightIsDown();
+
+        case wxMOUSE_BTN_LEFT:

             return LeftIsDown();
             return LeftIsDown();

-        case 2:
+
+        case wxMOUSE_BTN_MIDDLE:

             return MiddleIsDown();
             return MiddleIsDown();

-        case 3:
+
+        case wxMOUSE_BTN_RIGHT:

             return RightIsDown();
             return RightIsDown();

-        default:
-            wxFAIL_MSG(wxT("invalid parameter in wxMouseEvent::ButtonIsDown"));

     }
     }

-
-    return FALSE;

 }
 
 int wxMouseEvent::GetButton() const
 }
 
 int wxMouseEvent::GetButton() const


@@ -637,7 +667,7 @@ int wxMouseEvent::GetButton() const
         }
     }
 
         }
     }
 

-    return -1;
+    return wxMOUSE_BTN_NONE;

 }
 
 // Find the logical position of the event given the DC
 }
 
 // Find the logical position of the event given the DC


@@ -656,10 +686,10 @@ wxPoint wxMouseEvent::GetLogicalPosition(const wxDC& dc) const
 wxKeyEvent::wxKeyEvent(wxEventType type)
 {
     m_eventType = type;
 wxKeyEvent::wxKeyEvent(wxEventType type)
 {
     m_eventType = type;

-    m_shiftDown = FALSE;
-    m_controlDown = FALSE;
-    m_metaDown = FALSE;
-    m_altDown = FALSE;
+    m_shiftDown = false;
+    m_controlDown = false;
+    m_metaDown = false;
+    m_altDown = false;

     m_keyCode = 0;
     m_scanCode = 0;
 #if wxUSE_UNICODE
     m_keyCode = 0;
     m_scanCode = 0;
 #if wxUSE_UNICODE


@@ -713,20 +743,42 @@ wxChildFocusEvent::wxChildFocusEvent(wxWindow *win)
 
 #endif // wxUSE_GUI
 
 
 #endif // wxUSE_GUI
 

+
+#if wxUSE_BASE
+

 // ----------------------------------------------------------------------------
 // wxEventHashTable
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // wxEventHashTable
 // ----------------------------------------------------------------------------
 

-static const int EVENT_TYPE_TABLE_INIT_SIZE = 31; // Not to big not to small...
+static const int EVENT_TYPE_TABLE_INIT_SIZE = 31; // Not too big not too small...
+
+wxEventHashTable* wxEventHashTable::sm_first = NULL;

 
 wxEventHashTable::wxEventHashTable(const wxEventTable &table)
                 : m_table(table),
 
 wxEventHashTable::wxEventHashTable(const wxEventTable &table)
                 : m_table(table),

-                  m_rebuildHash(TRUE)
+                  m_rebuildHash(true)

 {
     AllocEventTypeTable(EVENT_TYPE_TABLE_INIT_SIZE);
 {
     AllocEventTypeTable(EVENT_TYPE_TABLE_INIT_SIZE);

+    
+    m_next = sm_first;
+    if (m_next)
+        m_next->m_previous = this;
+    sm_first = this;

 }
 
 wxEventHashTable::~wxEventHashTable()
 }
 
 wxEventHashTable::~wxEventHashTable()

+{
+    if (m_next)
+        m_next->m_previous = m_previous;
+    if (m_previous)
+        m_previous->m_next = m_next;
+    if (sm_first == this)
+        sm_first = m_next;
+    
+    Clear();
+}
+
+void wxEventHashTable::Clear()

 {
     size_t i;
     for(i = 0; i < m_size; i++)
 {
     size_t i;
     for(i = 0; i < m_size; i++)


@@ -738,7 +790,24 @@ wxEventHashTable::~wxEventHashTable()
         }
     }
 
         }
     }
 

-    delete[] m_eventTypeTable;
+    // Necessary in order to not invoke the
+    // overloaded delete operator when statics are cleaned up
+    if (m_eventTypeTable)
+        delete[] m_eventTypeTable;
+
+    m_eventTypeTable = NULL;
+    m_size = 0;
+}
+
+// Clear all tables
+void wxEventHashTable::ClearAll()
+{
+    wxEventHashTable* table = sm_first;
+    while (table)
+    {
+        table->Clear();
+        table = table->m_next;
+    }

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


@@ -746,8 +815,11 @@ bool wxEventHashTable::HandleEvent(wxEvent &event, wxEvtHandler *self)
     if (m_rebuildHash)
     {
         InitHashTable();
     if (m_rebuildHash)
     {
         InitHashTable();

-        m_rebuildHash = FALSE;
+        m_rebuildHash = false;

     }
     }

+    
+    if (!m_eventTypeTable)
+        return FALSE;

 
     // Find all entries for the given event type.
     wxEventType eventType = event.GetEventType();
 
     // Find all entries for the given event type.
     wxEventType eventType = event.GetEventType();


@@ -756,36 +828,21 @@ bool wxEventHashTable::HandleEvent(wxEvent &event, wxEvtHandler *self)
     {
         // Now start the search for an event handler
         // that can handle an event with the given ID.
     {
         // Now start the search for an event handler
         // that can handle an event with the given ID.

-        int eventId = event.GetId();
-        const wxEventTableEntryPointerArray &eventEntryTable = eTTnode->eventEntryTable;
+        const wxEventTableEntryPointerArray&
+            eventEntryTable = eTTnode->eventEntryTable;

 
 

-        size_t n;
-        size_t count = eventEntryTable.GetCount();
-        for (n = 0; n < count; n++)
+        const size_t count = eventEntryTable.GetCount();
+        for (size_t n = 0; n < count; n++)

         {
         {

-            const wxEventTableEntry* entry = eventEntryTable[n];
-            int tableId1 = entry->m_id,
-                tableId2 = entry->m_lastId;
-
-            if ((tableId1 == -1) ||
-                (tableId2 == -1 && tableId1 == eventId) ||
-                (tableId2 != -1 &&
-                 (eventId >= tableId1 && eventId <= tableId2)))
+            if ( wxEvtHandler::
+                    ProcessEventIfMatches(*eventEntryTable[n], self, event) )

             {
             {

-                event.Skip(FALSE);
-                event.m_callbackUserData = entry->m_callbackUserData;
-
-                (self->*((wxEventFunction) (entry->m_fn)))(event);
-
-                if (!event.GetSkipped())
-                    return TRUE;
+                return true;

             }
         }
             }
         }

-
-        return FALSE;

     }
 
     }
 

-    return FALSE;
+    return false;

 }
 
 void wxEventHashTable::InitHashTable()
 }
 
 void wxEventHashTable::InitHashTable()


@@ -821,6 +878,10 @@ void wxEventHashTable::InitHashTable()
 
 void wxEventHashTable::AddEntry(const wxEventTableEntry &entry)
 {
 
 void wxEventHashTable::AddEntry(const wxEventTableEntry &entry)
 {

+    // This might happen 'accidentally' as the app is exiting
+    if (!m_eventTypeTable)
+        return;
+    

     EventTypeTablePointer *peTTnode = &m_eventTypeTable[entry.m_eventType % m_size];
     EventTypeTablePointer  eTTnode = *peTTnode;
 
     EventTypeTablePointer *peTTnode = &m_eventTypeTable[entry.m_eventType % m_size];
     EventTypeTablePointer  eTTnode = *peTTnode;
 


@@ -889,12 +950,11 @@ void wxEventHashTable::GrowEventTypeTable()
     delete[] oldEventTypeTable;
 }
 
     delete[] oldEventTypeTable;
 }
 

+

 // ----------------------------------------------------------------------------
 // wxEvtHandler
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // wxEvtHandler
 // ----------------------------------------------------------------------------
 

-#if wxUSE_BASE
-

 /*
  * Event handler
  */
 /*
  * Event handler
  */


@@ -903,7 +963,7 @@ wxEvtHandler::wxEvtHandler()
 {
     m_nextHandler = (wxEvtHandler *) NULL;
     m_previousHandler = (wxEvtHandler *) NULL;
 {
     m_nextHandler = (wxEvtHandler *) NULL;
     m_previousHandler = (wxEvtHandler *) NULL;

-    m_enabled = TRUE;
+    m_enabled = true;

     m_dynamicEvents = (wxList *) NULL;
     m_pendingEvents = (wxList *) NULL;
 #if wxUSE_THREADS
     m_dynamicEvents = (wxList *) NULL;
     m_pendingEvents = (wxList *) NULL;
 #if wxUSE_THREADS


@@ -976,9 +1036,17 @@ bool wxEvtHandler::ProcessThreadEvent(wxEvent& event)
 
     AddPendingEvent(event);
 
 
     AddPendingEvent(event);
 

-    return TRUE;
+    return true;

 }
 
 }
 

+void wxEvtHandler::ClearEventLocker()
+{
+#if !defined(__VISAGECPP__)
+    delete m_eventsLocker;
+    m_eventsLocker = NULL;
+#endif
+};
+

 #endif // wxUSE_THREADS
 
 void wxEvtHandler::AddPendingEvent(wxEvent& event)
 #endif // wxUSE_THREADS
 
 void wxEvtHandler::AddPendingEvent(wxEvent& event)


@@ -1067,6 +1135,47 @@ void wxEvtHandler::ProcessPendingEvents()
 /*
  * Event table stuff
  */
 /*
  * Event table stuff
  */

+/* static */ bool
+wxEvtHandler::ProcessEventIfMatches(const wxEventTableEntryBase& entry,
+                                    wxEvtHandler *handler,
+                                    wxEvent& event)
+{
+    int tableId1 = entry.m_id,
+        tableId2 = entry.m_lastId;
+
+    // match only if the event type is the same and the id is either -1 in
+    // the event table (meaning "any") or the event id matches the id
+    // specified in the event table either exactly or by falling into
+    // range between first and last
+    if ((tableId1 == -1) ||
+        (tableId2 == -1 && tableId1 == event.GetId()) ||
+        (tableId2 != -1 &&
+         (event.GetId() >= tableId1 && event.GetId() <= tableId2)))
+    {
+        event.Skip(false);
+        event.m_callbackUserData = entry.m_callbackUserData;
+
+#if wxUSE_EXCEPTIONS
+        if ( wxTheApp )
+        {
+            // call the handler via wxApp method which allows the user to catch
+            // any exceptions which may be thrown by any handler in the program
+            // in one place
+            wxTheApp->HandleEvent(handler, (wxEventFunction)entry.m_fn, event);
+        }
+        else
+#endif // wxUSE_EXCEPTIONS
+        {
+            // no need for an extra virtual function call
+            (handler->*((wxEventFunction) (entry.m_fn)))(event);
+        }
+
+        if (!event.GetSkipped())
+            return true;
+    }
+
+    return false;
+}

 
 bool wxEvtHandler::TryParent(wxEvent& event)
 {
 
 bool wxEvtHandler::TryParent(wxEvent& event)
 {


@@ -1078,11 +1187,11 @@ bool wxEvtHandler::TryParent(wxEvent& event)
         if ( event.GetEventType() != wxEVT_IDLE )
         {
             if ( wxTheApp->ProcessEvent(event) )
         if ( event.GetEventType() != wxEVT_IDLE )
         {
             if ( wxTheApp->ProcessEvent(event) )

-                return TRUE;
+                return true;

         }
     }
 
         }
     }
 

-    return FALSE;
+    return false;

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


@@ -1106,25 +1215,23 @@ bool wxEvtHandler::ProcessEvent(wxEvent& event)
     {
         // if we have a validator, it has higher priority than our own event
         // table
     {
         // if we have a validator, it has higher priority than our own event
         // table

-#if wxUSE_VALIDATORS

         if ( TryValidator(event) )
         if ( TryValidator(event) )

-            return TRUE;
-#endif // wxUSE_VALIDATORS
+            return true;

 
         // Handle per-instance dynamic event tables first
         if ( m_dynamicEvents && SearchDynamicEventTable(event) )
 
         // Handle per-instance dynamic event tables first
         if ( m_dynamicEvents && SearchDynamicEventTable(event) )

-            return TRUE;
+            return true;

 
         // Then static per-class event tables
         if ( GetEventHashTable().HandleEvent(event, this) )
 
         // Then static per-class event tables
         if ( GetEventHashTable().HandleEvent(event, this) )

-            return TRUE;
+            return true;

     }
 
     // Try going down the event handler chain
     if ( GetNextHandler() )
     {
         if ( GetNextHandler()->ProcessEvent(event) )
     }
 
     // Try going down the event handler chain
     if ( GetNextHandler() )
     {
         if ( GetNextHandler()->ProcessEvent(event) )

-            return TRUE;
+            return true;

     }
 
     // Finally propagate the event upwards the window chain and/or to the
     }
 
     // Finally propagate the event upwards the window chain and/or to the


@@ -1135,46 +1242,18 @@ bool wxEvtHandler::ProcessEvent(wxEvent& event)
 
 bool wxEvtHandler::SearchEventTable(wxEventTable& table, wxEvent& event)
 {
 
 bool wxEvtHandler::SearchEventTable(wxEventTable& table, wxEvent& event)
 {

-    wxEventType eventType = event.GetEventType();
-    int eventId = event.GetId();
-
-    // BC++ doesn't like testing for m_fn without != 0
+    const wxEventType eventType = event.GetEventType();

     for ( int i = 0; table.entries[i].m_fn != 0; i++ )
     {
     for ( int i = 0; table.entries[i].m_fn != 0; i++ )
     {

-        // the line using reference exposes a bug in gcc: although it _seems_
-        // to work, it leads to weird crashes later on during program
-        // execution
-#ifdef __GNUG__
-        wxEventTableEntry entry = table.entries[i];
-#else

         const wxEventTableEntry& entry = table.entries[i];
         const wxEventTableEntry& entry = table.entries[i];

-#endif
-
-        // match only if the event type is the same and the id is either -1 in
-        // the event table (meaning "any") or the event id matches the id
-        // specified in the event table either exactly or by falling into
-        // range between first and last

         if ( eventType == entry.m_eventType )
         {
         if ( eventType == entry.m_eventType )
         {

-            int tableId1 = entry.m_id,
-                tableId2 = entry.m_lastId;
-
-            if ( (tableId1 == -1) ||
-                 (tableId2 == -1 && eventId == tableId1) ||
-                 (tableId2 != -1 &&
-                    (eventId >= tableId1 && eventId <= tableId2)) )
-            {
-                event.Skip(FALSE);
-                event.m_callbackUserData = entry.m_callbackUserData;
-
-                (this->*((wxEventFunction) (entry.m_fn)))(event);
-
-                return !event.GetSkipped();
-            }
+            if ( ProcessEventIfMatches(entry, this, event) )
+                return true;

         }
     }
 
         }
     }
 

-    return FALSE;
+    return false;

 }
 
 void wxEvtHandler::Connect( int id, int lastId,
 }
 
 void wxEvtHandler::Connect( int id, int lastId,


@@ -1208,7 +1287,7 @@ bool wxEvtHandler::Disconnect( int id, int lastId, wxEventType eventType,
                   wxEvtHandler* eventSink )
 {
     if (!m_dynamicEvents)
                   wxEvtHandler* eventSink )
 {
     if (!m_dynamicEvents)

-        return FALSE;
+        return false;

 
     wxList::compatibility_iterator node = m_dynamicEvents->GetFirst();
     while (node)
 
     wxList::compatibility_iterator node = m_dynamicEvents->GetFirst();
     while (node)


@@ -1230,55 +1309,46 @@ bool wxEvtHandler::Disconnect( int id, int lastId, wxEventType eventType,
                 delete entry->m_callbackUserData;
             m_dynamicEvents->Erase( node );
             delete entry;
                 delete entry->m_callbackUserData;
             m_dynamicEvents->Erase( node );
             delete entry;

-            return TRUE;
+            return true;

         }
         node = node->GetNext();
     }
         }
         node = node->GetNext();
     }

-    return FALSE;
+    return false;

 }
 
 bool wxEvtHandler::SearchDynamicEventTable( wxEvent& event )
 {
 }
 
 bool wxEvtHandler::SearchDynamicEventTable( wxEvent& event )
 {

-    wxCHECK_MSG( m_dynamicEvents, FALSE,
+    wxCHECK_MSG( m_dynamicEvents, false,

                  wxT("caller should check that we have dynamic events") );
 
                  wxT("caller should check that we have dynamic events") );
 

-    int commandId = event.GetId();
-

     wxList::compatibility_iterator node = m_dynamicEvents->GetFirst();
     while (node)
     {
 #if WXWIN_COMPATIBILITY_EVENT_TYPES
     wxList::compatibility_iterator node = m_dynamicEvents->GetFirst();
     while (node)
     {
 #if WXWIN_COMPATIBILITY_EVENT_TYPES

-            wxEventTableEntry *entry = (wxEventTableEntry*)node->GetData();
+        wxEventTableEntry *entry = (wxEventTableEntry*)node->GetData();

 #else // !WXWIN_COMPATIBILITY_EVENT_TYPES
 #else // !WXWIN_COMPATIBILITY_EVENT_TYPES

-            wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();
+        wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();

 #endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES
 
 #endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES
 

-        if (entry->m_fn)
+        if ((event.m_eventType == entry->m_eventType) && (entry->m_fn != 0))

         {
         {

-            // Match, if event spec says any id will do (id == -1)
-            if ( (event.GetEventType() == entry->m_eventType) &&
-                 (entry->m_id == -1 ||
-                  (entry->m_lastId == -1 && commandId == entry->m_id) ||
-                  (entry->m_lastId != -1 &&
-                  (commandId >= entry->m_id && commandId <= entry->m_lastId))) )
-            {
-                event.Skip(FALSE);
-                event.m_callbackUserData = entry->m_callbackUserData;
-
+            wxEvtHandler *handler =

 #if !WXWIN_COMPATIBILITY_EVENT_TYPES
 #if !WXWIN_COMPATIBILITY_EVENT_TYPES

-                if (entry->m_eventSink)
-                    ((entry->m_eventSink)->*((wxEventFunction) (entry->m_fn)))(event);
-                else
+                                    entry->m_eventSink ? entry->m_eventSink
+                                                       :

 #endif
 #endif

-                    (this->*((wxEventFunction) (entry->m_fn)))(event);
+                                                         this;

 
 

-                if ( ! event.GetSkipped() )
-                    return TRUE;
+            if ( ProcessEventIfMatches(*entry, handler, event) )
+            {
+                return true;

             }
         }
             }
         }

+

         node = node->GetNext();
     }
         node = node->GetNext();
     }

-    return FALSE;
+
+    return false;

 };
 
 void wxEvtHandler::DoSetClientObject( wxClientData *data )
 };
 
 void wxEvtHandler::DoSetClientObject( wxClientData *data )


@@ -1322,17 +1392,6 @@ void *wxEvtHandler::DoGetClientData() const
     return m_clientData;
 }
 
     return m_clientData;
 }
 

-
-#if WXWIN_COMPATIBILITY
-bool wxEvtHandler::OnClose()
-{
-    if (GetNextHandler())
-        return GetNextHandler()->OnClose();
-    else
-        return FALSE;
-}
-#endif // WXWIN_COMPATIBILITY
-

 #endif // wxUSE_BASE
 
 #if wxUSE_GUI
 #endif // wxUSE_BASE
 
 #if wxUSE_GUI