don't compare invalid iterators/node pointers

[wxWidgets.git] / src / x11 / evtloop.cpp

diff --git a/src/x11/evtloop.cpp b/src/x11/evtloop.cpp
index f15fe0451608005b3ec46deb0e0f95642191adee..408d6fee3410ca7bc18ba1edbb7bfe62e024138a 100644 (file)
--- a/src/x11/evtloop.cpp
+++ b/src/x11/evtloop.cpp
@@ -17,10 +17,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
-    #pragma implementation "evtloop.h"
-#endif
-

 #include "wx/window.h"
 #include "wx/app.h"
 #include "wx/evtloop.h"
 #include "wx/window.h"
 #include "wx/app.h"
 #include "wx/evtloop.h"


@@ -31,6 +27,7 @@
 #include "wx/timer.h"
 #include "wx/hash.h"
 #include "wx/module.h"
 #include "wx/timer.h"
 #include "wx/hash.h"
 #include "wx/module.h"

+#include "wx/unix/private.h"

 #include "wx/x11/private.h"
 #include "X11/Xlib.h"
 
 #include "wx/x11/private.h"
 #include "X11/Xlib.h"
 


@@ -53,7 +50,7 @@ class wxSocketTableEntry: public wxObject
         m_callbackInput = NULL; m_callbackOutput = NULL;
         m_dataInput = NULL; m_dataOutput = NULL;
     }
         m_callbackInput = NULL; m_callbackOutput = NULL;
         m_dataInput = NULL; m_dataOutput = NULL;
     }

-    
+

     int m_fdInput;
     int m_fdOutput;
     wxSocketCallback m_callbackInput;
     int m_fdInput;
     int m_fdOutput;
     wxSocketCallback m_callbackInput;


@@ -73,7 +70,7 @@ class wxSocketTable: public wxHashTable
     }
     ~wxSocketTable()
     {
     }
     ~wxSocketTable()
     {

-        DeleteContents(TRUE);
+        WX_CLEAR_HASH_TABLE(*this)

     }
 
     wxSocketTableEntry* FindEntry(int fd);
     }
 
     wxSocketTableEntry* FindEntry(int fd);


@@ -171,21 +168,21 @@ bool wxSocketTable::CallCallback(int fd, wxSocketTableType socketType)
 void wxSocketTable::FillSets(fd_set* readset, fd_set* writeset, int* highest)
 {
     BeginFind();
 void wxSocketTable::FillSets(fd_set* readset, fd_set* writeset, int* highest)
 {
     BeginFind();

-    wxNode* node = Next();
+    wxHashTable::compatibility_iterator node = Next();

     while (node)
     {
     while (node)
     {

-        wxSocketTableEntry* entry = (wxSocketTableEntry*) node->Data();
+        wxSocketTableEntry* entry = (wxSocketTableEntry*) node->GetData();

 
         if (entry->m_fdInput != -1)
         {
 
         if (entry->m_fdInput != -1)
         {

-            FD_SET(entry->m_fdInput, readset);
+            wxFD_SET(entry->m_fdInput, readset);

             if (entry->m_fdInput > *highest)
                 * highest = entry->m_fdInput;
         }
 
         if (entry->m_fdOutput != -1)
         {
             if (entry->m_fdInput > *highest)
                 * highest = entry->m_fdInput;
         }
 
         if (entry->m_fdOutput != -1)
         {

-            FD_SET(entry->m_fdOutput, writeset);
+            wxFD_SET(entry->m_fdOutput, writeset);

             if (entry->m_fdOutput > *highest)
                 * highest = entry->m_fdOutput;
         }
             if (entry->m_fdOutput > *highest)
                 * highest = entry->m_fdOutput;
         }


@@ -197,17 +194,17 @@ void wxSocketTable::FillSets(fd_set* readset, fd_set* writeset, int* highest)
 void wxSocketTable::ProcessEvents(fd_set* readset, fd_set* writeset)
 {
     BeginFind();
 void wxSocketTable::ProcessEvents(fd_set* readset, fd_set* writeset)
 {
     BeginFind();

-    wxNode* node = Next();
+    wxHashTable::compatibility_iterator node = Next();

     while (node)
     {
     while (node)
     {

-        wxSocketTableEntry* entry = (wxSocketTableEntry*) node->Data();
+        wxSocketTableEntry* entry = (wxSocketTableEntry*) node->GetData();

 
 

-        if (entry->m_fdInput != -1 && FD_ISSET(entry->m_fdInput, readset))
+        if (entry->m_fdInput != -1 && wxFD_ISSET(entry->m_fdInput, readset))

         {
             (entry->m_callbackInput) (entry->m_fdInput, entry->m_dataInput);
         }
 
         {
             (entry->m_callbackInput) (entry->m_fdInput, entry->m_dataInput);
         }
 

-        if (entry->m_fdOutput != -1 && FD_ISSET(entry->m_fdOutput, writeset))
+        if (entry->m_fdOutput != -1 && wxFD_ISSET(entry->m_fdOutput, writeset))

         {
             (entry->m_callbackOutput) (entry->m_fdOutput, entry->m_dataOutput);
         }
         {
             (entry->m_callbackOutput) (entry->m_fdOutput, entry->m_dataOutput);
         }


@@ -293,7 +290,7 @@ bool wxEventLoopImpl::ProcessEvent(XEvent *event)
     // give us the chance to preprocess the message first
     if ( PreProcessEvent(event) )
         return TRUE;
     // give us the chance to preprocess the message first
     if ( PreProcessEvent(event) )
         return TRUE;

-    
+

     // if it wasn't done, dispatch it to the corresponding window
     if (wxTheApp)
         return wxTheApp->ProcessXEvent((WXEvent*) event);
     // if it wasn't done, dispatch it to the corresponding window
     if (wxTheApp)
         return wxTheApp->ProcessXEvent((WXEvent*) event);


@@ -335,18 +332,13 @@ bool wxEventLoopImpl::PreProcessEvent(XEvent *event)
 
 bool wxEventLoopImpl::SendIdleEvent()
 {
 
 bool wxEventLoopImpl::SendIdleEvent()
 {

-    wxIdleEvent event;
-    event.SetEventObject(wxTheApp);
-
-    return wxTheApp->ProcessEvent(event) && event.MoreRequested();
+    return wxTheApp->ProcessIdle();

 }
 
 // ============================================================================
 // wxEventLoop implementation
 // ============================================================================
 
 }
 
 // ============================================================================
 // wxEventLoop implementation
 // ============================================================================
 

-wxEventLoop *wxEventLoop::ms_activeLoop = NULL;
-

 // ----------------------------------------------------------------------------
 // wxEventLoop running and exiting
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxEventLoop running and exiting
 // ----------------------------------------------------------------------------


@@ -356,26 +348,20 @@ wxEventLoop::~wxEventLoop()
     wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
 }
 
     wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
 }
 

-bool wxEventLoop::IsRunning() const
-{
-    return m_impl != NULL;
-}
-

 int wxEventLoop::Run()
 {
     // event loops are not recursive, you need to create another loop!
     wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
 
     m_impl = new wxEventLoopImpl;
 int wxEventLoop::Run()
 {
     // event loops are not recursive, you need to create another loop!
     wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
 
     m_impl = new wxEventLoopImpl;

-    
-    wxEventLoop *oldLoop = ms_activeLoop;
-    ms_activeLoop = this;
+
+    wxEventLoopActivator activate(this);

 
     m_impl->m_keepGoing = TRUE;
     while ( m_impl->m_keepGoing )
     {
 #if 0 // wxUSE_THREADS
 
     m_impl->m_keepGoing = TRUE;
     while ( m_impl->m_keepGoing )
     {
 #if 0 // wxUSE_THREADS

-       wxMutexGuiLeaveOrEnter();
+        wxMutexGuiLeaveOrEnter();

 #endif // wxUSE_THREADS
 
         // generate and process idle events for as long as we don't have
 #endif // wxUSE_THREADS
 
         // generate and process idle events for as long as we don't have


@@ -387,7 +373,7 @@ int wxEventLoop::Run()
 #endif
             if (!m_impl->SendIdleEvent())
             {
 #endif
             if (!m_impl->SendIdleEvent())
             {

-#if wxUSE_THREADS
+#if 0 // wxUSE_THREADS

                 // leave the main loop to give other threads a chance to
                 // perform their GUI work
                 wxMutexGuiLeave();
                 // leave the main loop to give other threads a chance to
                 // perform their GUI work
                 wxMutexGuiLeave();


@@ -411,8 +397,6 @@ int wxEventLoop::Run()
     delete m_impl;
     m_impl = NULL;
 
     delete m_impl;
     m_impl = NULL;
 

-    ms_activeLoop = oldLoop;
-

     return exitcode;
 }
 
     return exitcode;
 }
 


@@ -430,8 +414,8 @@ void wxEventLoop::Exit(int rc)
 
 bool wxEventLoop::Pending() const
 {
 
 bool wxEventLoop::Pending() const
 {

-    XFlush((Display*) wxGetDisplay());
-    return (XPending((Display*) wxGetDisplay()) > 0);
+    XFlush( wxGlobalDisplay() );
+    return (XPending( wxGlobalDisplay() ) > 0);

 }
 
 bool wxEventLoop::Dispatch()
 }
 
 bool wxEventLoop::Dispatch()


@@ -446,8 +430,8 @@ bool wxEventLoop::Dispatch()
     // does also mean that idle processing will happen more
     // often, so we should probably limit idle processing to
     // not be repeated more than every N milliseconds.
     // does also mean that idle processing will happen more
     // often, so we should probably limit idle processing to
     // not be repeated more than every N milliseconds.

-    
-    if (XPending((Display*) wxGetDisplay()) == 0)
+
+    if (XPending( wxGlobalDisplay() ) == 0)

     {
 #if wxUSE_NANOX
         GR_TIMEOUT timeout = 10; // Milliseconds
     {
 #if wxUSE_NANOX
         GR_TIMEOUT timeout = 10; // Milliseconds


@@ -457,26 +441,27 @@ bool wxEventLoop::Dispatch()
         // Fall through to ProcessEvent.
         // we'll assume that ProcessEvent will just ignore
         // the event if there was a timeout and no event.
         // Fall through to ProcessEvent.
         // we'll assume that ProcessEvent will just ignore
         // the event if there was a timeout and no event.

-            
+

 #else
         struct timeval tv;
         tv.tv_sec=0;
         tv.tv_usec=10000; // TODO make this configurable
 #else
         struct timeval tv;
         tv.tv_sec=0;
         tv.tv_usec=10000; // TODO make this configurable

-        int fd = ConnectionNumber((Display*) wxGetDisplay());
+        int fd = ConnectionNumber( wxGlobalDisplay() );
+

         fd_set readset;
         fd_set writeset;
         int highest = fd;
         fd_set readset;
         fd_set writeset;
         int highest = fd;

-        FD_ZERO(&readset);
-        FD_ZERO(&writeset);
-        
-        FD_SET(fd, &readset);
+        wxFD_ZERO(&readset);
+        wxFD_ZERO(&writeset);
+
+        wxFD_SET(fd, &readset);

 
 #if wxUSE_SOCKETS
         if (wxTheSocketTable)
 
 #if wxUSE_SOCKETS
         if (wxTheSocketTable)

-            wxTheSocketTable->FillSets(& readset, & writeset, & highest);
+            wxTheSocketTable->FillSets( &readset, &writeset, &highest );

 #endif
 #endif

-        
-        if (select(highest+1, &readset, &writeset, NULL, & tv) == 0)
+
+        if (select( highest+1, &readset, &writeset, NULL, &tv ) == 0)

         {
             // Timed out, so no event to process
             return TRUE;
         {
             // Timed out, so no event to process
             return TRUE;


@@ -484,23 +469,25 @@ bool wxEventLoop::Dispatch()
         else
         {
             // An X11 event was pending, so get it
         else
         {
             // An X11 event was pending, so get it

-            if (FD_ISSET(fd, & readset))
-                XNextEvent((Display*) wxGetDisplay(), & event);
+            if (wxFD_ISSET( fd, &readset ))
+                XNextEvent( wxGlobalDisplay(), &event );

 
 #if wxUSE_SOCKETS
             // Check if any socket events were pending,
             // and if so, call their callbacks
             if (wxTheSocketTable)
 
 #if wxUSE_SOCKETS
             // Check if any socket events were pending,
             // and if so, call their callbacks
             if (wxTheSocketTable)

-                wxTheSocketTable->ProcessEvents(& readset, & writeset);
+                wxTheSocketTable->ProcessEvents( &readset, &writeset );

 #endif
         }
 #endif
 #endif
         }
 #endif

-    } else
+    }
+    else

     {
     {

-       XNextEvent((Display*) wxGetDisplay(), & event);
+        XNextEvent( wxGlobalDisplay(), &event );

     }
     }

-    
-    (void) m_impl->ProcessEvent(& event);
+
+
+    (void) m_impl->ProcessEvent( &event );

     return TRUE;
 }
 
     return TRUE;
 }