conversion warning gcc 3.3 mac

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

diff --git a/src/common/event.cpp b/src/common/event.cpp
index 187dbf5fcdab090af2c57216b219362ca1b6af3e..8b0fb73f573af0229d1506ee87013c60c75b1ed9 100644 (file)
--- a/src/common/event.cpp
+++ b/src/common/event.cpp
@@ -48,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"


@@ -119,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
 // ----------------------------------------------------------------------------


@@ -522,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

 
 

-    return false;
+        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();
+
+        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


@@ -634,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


@@ -717,16 +750,35 @@ wxChildFocusEvent::wxChildFocusEvent(wxWindow *win)
 // 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),
                   m_rebuildHash(true)
 {
     AllocEventTypeTable(EVENT_TYPE_TABLE_INIT_SIZE);
 
 wxEventHashTable::wxEventHashTable(const wxEventTable &table)
                 : m_table(table),
                   m_rebuildHash(true)
 {
     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)


@@ -748,6 +817,9 @@ bool wxEventHashTable::HandleEvent(wxEvent &event, wxEvtHandler *self)
         InitHashTable();
         m_rebuildHash = false;
     }
         InitHashTable();
         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();


@@ -806,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;
 


@@ -874,6 +950,7 @@ void wxEventHashTable::GrowEventTypeTable()
     delete[] oldEventTypeTable;
 }
 
     delete[] oldEventTypeTable;
 }
 

+

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


@@ -1018,6 +1095,11 @@ void wxEvtHandler::AddPendingEvent(wxEvent& event)
 
 void wxEvtHandler::ProcessPendingEvents()
 {
 
 void wxEvtHandler::ProcessPendingEvents()
 {

+    // this method is only called by wxApp if this handler does have pending
+    // events
+    wxCHECK_RET( m_pendingEvents,
+                 wxT("Please call wxApp::ProcessPendingEvents() instead") );
+

 #if defined(__VISAGECPP__)
     wxENTER_CRIT_SECT( m_eventsLocker);
 #else
 #if defined(__VISAGECPP__)
     wxENTER_CRIT_SECT( m_eventsLocker);
 #else


@@ -1253,7 +1335,7 @@ bool wxEvtHandler::SearchDynamicEventTable( wxEvent& event )
         wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();
 #endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES
 
         wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();
 #endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES
 

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

         {
             wxEvtHandler *handler =
 #if !WXWIN_COMPATIBILITY_EVENT_TYPES
         {
             wxEvtHandler *handler =
 #if !WXWIN_COMPATIBILITY_EVENT_TYPES