X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/2b5f62a0b2db198609b45dec622a018dae37008e..f6388667682be59eb1f8bbcb82fd489889358aad:/src/x11/evtloop.cpp?ds=inline

diff --git a/src/x11/evtloop.cpp b/src/x11/evtloop.cpp
index aaf03464a3..fa380fcc0d 100644
--- a/src/x11/evtloop.cpp
+++ b/src/x11/evtloop.cpp
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
-// Name:        x11/evtloop.cpp
+// Name:        src/x11/evtloop.cpp
 // Purpose:     implements wxEventLoop for X11
 // Author:      Julian Smart
 // Modified by:
@@ -17,23 +17,28 @@
 // headers
 // ----------------------------------------------------------------------------
 
-#ifdef __GNUG__
-    #pragma implementation "evtloop.h"
-#endif
+// for compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
 
-#include "wx/window.h"
-#include "wx/app.h"
 #include "wx/evtloop.h"
-#include "wx/tooltip.h"
-#if wxUSE_THREADS
-#include "wx/thread.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/hash.h"
+    #include "wx/app.h"
+    #include "wx/window.h"
+    #include "wx/timer.h"
 #endif
-#include "wx/timer.h"
-#include "wx/hash.h"
+
+#include "wx/tooltip.h"
 #include "wx/module.h"
+#include "wx/unix/private.h"
 #include "wx/x11/private.h"
 #include "X11/Xlib.h"
 
+#if wxUSE_THREADS
+    #include "wx/thread.h"
+#endif
+
 #include <sys/time.h>
 #include <unistd.h>
 
@@ -53,7 +58,7 @@ class wxSocketTableEntry: public wxObject
         m_callbackInput = NULL; m_callbackOutput = NULL;
         m_dataInput = NULL; m_dataOutput = NULL;
     }
-    
+
     int m_fdInput;
     int m_fdOutput;
     wxSocketCallback m_callbackInput;
@@ -73,7 +78,7 @@ class wxSocketTable: public wxHashTable
     }
     ~wxSocketTable()
     {
-        DeleteContents(TRUE);
+        WX_CLEAR_HASH_TABLE(*this)
     }
 
     wxSocketTableEntry* FindEntry(int fd);
@@ -162,30 +167,30 @@ bool wxSocketTable::CallCallback(int fd, wxSocketTableType socketType)
                 (entry->m_callbackOutput) (entry->m_fdOutput, entry->m_dataOutput);
             }
         }
-        return TRUE;
+        return true;
     }
     else
-        return FALSE;
+        return false;
 }
 
 void wxSocketTable::FillSets(fd_set* readset, fd_set* writeset, int* highest)
 {
     BeginFind();
-    wxNode* node = Next();
+    wxHashTable::compatibility_iterator node = Next();
     while (node)
     {
-        wxSocketTableEntry* entry = (wxSocketTableEntry*) node->Data();
-        
+        wxSocketTableEntry* entry = (wxSocketTableEntry*) node->GetData();
+
         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)
         {
-            FD_SET(entry->m_fdOutput, writeset);
+            wxFD_SET(entry->m_fdOutput, writeset);
             if (entry->m_fdOutput > *highest)
                 * highest = entry->m_fdOutput;
         }
@@ -197,17 +202,17 @@ void wxSocketTable::FillSets(fd_set* readset, fd_set* writeset, int* highest)
 void wxSocketTable::ProcessEvents(fd_set* readset, fd_set* writeset)
 {
     BeginFind();
-    wxNode* node = Next();
+    wxHashTable::compatibility_iterator node = Next();
     while (node)
     {
-        wxSocketTableEntry* entry = (wxSocketTableEntry*) node->Data();
-        
-        if (entry->m_fdInput != -1 && FD_ISSET(entry->m_fdInput, readset))
+        wxSocketTableEntry* entry = (wxSocketTableEntry*) node->GetData();
+
+        if (entry->m_fdInput != -1 && wxFD_ISSET(entry->m_fdInput, readset))
         {
             (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);
         }
@@ -223,7 +228,7 @@ class wxSocketTableModule: public wxModule
 DECLARE_DYNAMIC_CLASS(wxSocketTableModule)
 public:
     wxSocketTableModule() {}
-    bool OnInit() { wxTheSocketTable = new wxSocketTable; return TRUE; };
+    bool OnInit() { wxTheSocketTable = new wxSocketTable; return true; };
     void OnExit() { delete wxTheSocketTable; wxTheSocketTable = NULL; };
 };
 
@@ -257,12 +262,12 @@ class WXDLLEXPORT wxEventLoopImpl
 {
 public:
     // ctor
-    wxEventLoopImpl() { SetExitCode(0); m_keepGoing = FALSE; }
+    wxEventLoopImpl() { SetExitCode(0); m_keepGoing = false; }
 
-    // process an XEvent, return TRUE if it was processed
+    // process an XEvent, return true if it was processed
     bool ProcessEvent(XEvent* event);
 
-    // generate an idle message, return TRUE if more idle time requested
+    // generate an idle message, return true if more idle time requested
     bool SendIdleEvent();
 
     // set/get the exit code
@@ -270,7 +275,7 @@ public:
     int GetExitCode() const { return m_exitcode; }
 
 public:
-    // preprocess an event, return TRUE if processed (i.e. no further
+    // preprocess an event, return true if processed (i.e. no further
     // dispatching required)
     bool PreProcessEvent(XEvent* event);
 
@@ -292,13 +297,13 @@ bool wxEventLoopImpl::ProcessEvent(XEvent *event)
 {
     // give us the chance to preprocess the message first
     if ( PreProcessEvent(event) )
-        return TRUE;
-    
+        return true;
+
     // if it wasn't done, dispatch it to the corresponding window
     if (wxTheApp)
         return wxTheApp->ProcessXEvent((WXEvent*) event);
 
-    return FALSE;
+    return false;
 }
 
 bool wxEventLoopImpl::PreProcessEvent(XEvent *event)
@@ -315,18 +320,18 @@ bool wxEventLoopImpl::PreProcessEvent(XEvent *event)
     for ( wnd = wndThis; wnd; wnd = wnd->GetParent() )
     {
         if ( wnd->MSWTranslateMessage((WXMSG *)msg) )
-            return TRUE;
+            return true;
     }
 
     // Anyone for a non-translation message? Try youngest descendants first.
     for ( wnd = wndThis; wnd; wnd = wnd->GetParent() )
     {
         if ( wnd->MSWProcessMessage((WXMSG *)msg) )
-            return TRUE;
+            return true;
     }
 #endif
 
-    return FALSE;
+    return false;
 }
 
 // ----------------------------------------------------------------------------
@@ -335,18 +340,13 @@ bool wxEventLoopImpl::PreProcessEvent(XEvent *event)
 
 bool wxEventLoopImpl::SendIdleEvent()
 {
-    wxIdleEvent event;
-    event.SetEventObject(wxTheApp);
-
-    return wxTheApp->ProcessEvent(event) && event.MoreRequested();
+    return wxTheApp->ProcessIdle();
 }
 
 // ============================================================================
 // wxEventLoop implementation
 // ============================================================================
 
-wxEventLoop *wxEventLoop::ms_activeLoop = NULL;
-
 // ----------------------------------------------------------------------------
 // wxEventLoop running and exiting
 // ----------------------------------------------------------------------------
@@ -356,22 +356,16 @@ wxEventLoop::~wxEventLoop()
     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;
-    
-    wxEventLoop *oldLoop = ms_activeLoop;
-    ms_activeLoop = this;
 
-    m_impl->m_keepGoing = TRUE;
+    wxEventLoopActivator activate(this);
+
+    m_impl->m_keepGoing = true;
     while ( m_impl->m_keepGoing )
     {
 #if 0 // wxUSE_THREADS
@@ -411,8 +405,6 @@ int wxEventLoop::Run()
     delete m_impl;
     m_impl = NULL;
 
-    ms_activeLoop = oldLoop;
-
     return exitcode;
 }
 
@@ -421,7 +413,7 @@ void wxEventLoop::Exit(int rc)
     wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") );
 
     m_impl->SetExitCode(rc);
-    m_impl->m_keepGoing = FALSE;
+    m_impl->m_keepGoing = false;
 }
 
 // ----------------------------------------------------------------------------
@@ -438,6 +430,9 @@ bool wxEventLoop::Dispatch()
 {
     XEvent event;
 
+    // Start off by checking if any of our child processes have finished.
+    wxCheckForFinishedChildren();
+
     // TODO allowing for threads, as per e.g. wxMSW
 
     // This now waits until either an X event is received,
@@ -446,7 +441,7 @@ 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.
-    
+
     if (XPending( wxGlobalDisplay() ) == 0)
     {
 #if wxUSE_NANOX
@@ -457,35 +452,35 @@ 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.
-            
+
 #else
         struct timeval tv;
         tv.tv_sec=0;
         tv.tv_usec=10000; // TODO make this configurable
         int fd = ConnectionNumber( wxGlobalDisplay() );
-        
+
         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)
             wxTheSocketTable->FillSets( &readset, &writeset, &highest );
 #endif
-        
+
         if (select( highest+1, &readset, &writeset, NULL, &tv ) == 0)
         {
             // Timed out, so no event to process
-            return TRUE;
+            return true;
         }
         else
         {
             // An X11 event was pending, so get it
-            if (FD_ISSET( fd, &readset ))
+            if (wxFD_ISSET( fd, &readset ))
                 XNextEvent( wxGlobalDisplay(), &event );
 
 #if wxUSE_SOCKETS
@@ -496,14 +491,13 @@ bool wxEventLoop::Dispatch()
 #endif
         }
 #endif
-    } 
+    }
     else
     {
         XNextEvent( wxGlobalDisplay(), &event );
     }
-    
-    
+
+
     (void) m_impl->ProcessEvent( &event );
-    return TRUE;
+    return true;
 }
-