correct GetBestSize() to return correct best size, i.e. the same size as AutoSize...

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

diff --git a/src/x11/evtloop.cpp b/src/x11/evtloop.cpp
index 701d4cd9735714192d824d323e8da06182414bce..ed86512596819a275182d464c56c875ed27b7f40 100644 (file)
--- 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:
 // Purpose:     implements wxEventLoop for X11
 // Author:      Julian Smart
 // Modified by:


@@ -17,236 +17,33 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // 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/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"
+    #include "wx/module.h"

 #endif
 #endif

-#include "wx/timer.h"
-#include "wx/hash.h"
-#include "wx/module.h"
+
+#include "wx/private/socketevtdispatch.h"
+#include "wx/unix/private.h"

 #include "wx/x11/private.h"
 #include "X11/Xlib.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>
 
 #include <sys/time.h>
 #include <unistd.h>
 

-#if wxUSE_SOCKETS
-// ----------------------------------------------------------------------------
-// wxSocketTable
-// ----------------------------------------------------------------------------
-
-typedef void (*wxSocketCallback) (int fd, void* data);
-
-class wxSocketTableEntry: public wxObject
-{
-  public:
-    wxSocketTableEntry()
-    {
-        m_fdInput = -1; m_fdOutput = -1;
-        m_callbackInput = NULL; m_callbackOutput = NULL;
-        m_dataInput = NULL; m_dataOutput = NULL;
-    }
-    
-    int m_fdInput;
-    int m_fdOutput;
-    wxSocketCallback m_callbackInput;
-    wxSocketCallback m_callbackOutput;
-    void* m_dataInput;
-    void* m_dataOutput;
-};
-
-typedef enum
-{ wxSocketTableInput, wxSocketTableOutput } wxSocketTableType ;
-
-class wxSocketTable: public wxHashTable
-{
-  public:
-    wxSocketTable(): wxHashTable(wxKEY_INTEGER)
-    {
-    }
-    ~wxSocketTable()
-    {
-        WX_CLEAR_HASH_TABLE(*this)
-    }
-
-    wxSocketTableEntry* FindEntry(int fd);
-
-    void RegisterCallback(int fd, wxSocketTableType socketType, wxSocketCallback callback, void* data);
-
-    void UnregisterCallback(int fd, wxSocketTableType socketType);
-
-    bool CallCallback(int fd, wxSocketTableType socketType);
-
-    void FillSets(fd_set* readset, fd_set* writeset, int* highest);
-
-    void ProcessEvents(fd_set* readset, fd_set* writeset);
-};
-
-wxSocketTableEntry* wxSocketTable::FindEntry(int fd)
-{
-    wxSocketTableEntry* entry = (wxSocketTableEntry*) Get(fd);
-    return entry;
-}
-
-void wxSocketTable::RegisterCallback(int fd, wxSocketTableType socketType, wxSocketCallback callback, void* data)
-{
-    wxSocketTableEntry* entry = FindEntry(fd);
-    if (!entry)
-    {
-        entry = new wxSocketTableEntry();
-        Put(fd, entry);
-    }
-
-    if (socketType == wxSocketTableInput)
-    {
-        entry->m_fdInput = fd;
-        entry->m_dataInput = data;
-        entry->m_callbackInput = callback;
-    }
-    else
-    {
-        entry->m_fdOutput = fd;
-        entry->m_dataOutput = data;
-        entry->m_callbackOutput = callback;
-    }
-}
-
-void wxSocketTable::UnregisterCallback(int fd, wxSocketTableType socketType)
-{
-    wxSocketTableEntry* entry = FindEntry(fd);
-    if (entry)
-    {
-        if (socketType == wxSocketTableInput)
-        {
-            entry->m_fdInput = -1;
-            entry->m_dataInput = NULL;
-            entry->m_callbackInput = NULL;
-        }
-        else
-        {
-            entry->m_fdOutput = -1;
-            entry->m_dataOutput = NULL;
-            entry->m_callbackOutput = NULL;
-        }
-        if (entry->m_fdInput == -1 && entry->m_fdOutput == -1)
-        {
-            Delete(fd);
-            delete entry;
-        }
-    }
-}
-
-bool wxSocketTable::CallCallback(int fd, wxSocketTableType socketType)
-{
-    wxSocketTableEntry* entry = FindEntry(fd);
-    if (entry)
-    {
-        if (socketType == wxSocketTableInput)
-        {
-            if (entry->m_fdInput != -1 && entry->m_callbackInput)
-            {
-                (entry->m_callbackInput) (entry->m_fdInput, entry->m_dataInput);
-            }
-        }
-        else
-        {
-            if (entry->m_fdOutput != -1 && entry->m_callbackOutput)
-            {
-                (entry->m_callbackOutput) (entry->m_fdOutput, entry->m_dataOutput);
-            }
-        }
-        return TRUE;
-    }
-    else
-        return FALSE;
-}
-
-void wxSocketTable::FillSets(fd_set* readset, fd_set* writeset, int* highest)
-{
-    BeginFind();
-    wxHashTable::compatibility_iterator node = Next();
-    while (node)
-    {
-        wxSocketTableEntry* entry = (wxSocketTableEntry*) node->GetData();
-        
-        if (entry->m_fdInput != -1)
-        {
-            FD_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);
-            if (entry->m_fdOutput > *highest)
-                * highest = entry->m_fdOutput;
-        }
-
-        node = Next();
-    }
-}
-
-void wxSocketTable::ProcessEvents(fd_set* readset, fd_set* writeset)
-{
-    BeginFind();
-    wxHashTable::compatibility_iterator node = Next();
-    while (node)
-    {
-        wxSocketTableEntry* entry = (wxSocketTableEntry*) node->GetData();
-        
-        if (entry->m_fdInput != -1 && FD_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))
-        {
-            (entry->m_callbackOutput) (entry->m_fdOutput, entry->m_dataOutput);
-        }
-
-        node = Next();
-    }
-}
-
-wxSocketTable* wxTheSocketTable = NULL;
-
-class wxSocketTableModule: public wxModule
-{
-DECLARE_DYNAMIC_CLASS(wxSocketTableModule)
-public:
-    wxSocketTableModule() {}
-    bool OnInit() { wxTheSocketTable = new wxSocketTable; return TRUE; };
-    void OnExit() { delete wxTheSocketTable; wxTheSocketTable = NULL; };
-};
-
-IMPLEMENT_DYNAMIC_CLASS(wxSocketTableModule, wxModule)
-
-// Implement registration functions as C functions so they
-// can be called from gsock11.c
-
-extern "C" void wxRegisterSocketCallback(int fd, wxSocketTableType socketType, wxSocketCallback callback, void* data)
-{
-    if (wxTheSocketTable)
-    {
-        wxTheSocketTable->RegisterCallback(fd, socketType, callback, data);
-    }
-}
-
-extern "C" void wxUnregisterSocketCallback(int fd, wxSocketTableType socketType)
-{
-    if (wxTheSocketTable)
-    {
-        wxTheSocketTable->UnregisterCallback(fd, socketType);
-    }
-}
+#ifdef HAVE_SYS_SELECT_H
+#   include <sys/select.h>

 #endif
 
 // ----------------------------------------------------------------------------
 #endif
 
 // ----------------------------------------------------------------------------


@@ -257,12 +54,12 @@ class WXDLLEXPORT wxEventLoopImpl
 {
 public:
     // ctor
 {
 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);
 
     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
     bool SendIdleEvent();
 
     // set/get the exit code


@@ -270,7 +67,7 @@ public:
     int GetExitCode() const { return m_exitcode; }
 
 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);
 
     // dispatching required)
     bool PreProcessEvent(XEvent* event);
 


@@ -292,13 +89,13 @@ bool wxEventLoopImpl::ProcessEvent(XEvent *event)
 {
     // give us the chance to preprocess the message first
     if ( PreProcessEvent(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);
 
     // 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)
 }
 
 bool wxEventLoopImpl::PreProcessEvent(XEvent *event)


@@ -315,18 +112,18 @@ bool wxEventLoopImpl::PreProcessEvent(XEvent *event)
     for ( wnd = wndThis; wnd; wnd = wnd->GetParent() )
     {
         if ( wnd->MSWTranslateMessage((WXMSG *)msg) )
     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) )
     }
 
     // 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
 
     }
 #endif
 

-    return FALSE;
+    return false;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -342,8 +139,6 @@ bool wxEventLoopImpl::SendIdleEvent()
 // wxEventLoop implementation
 // ============================================================================
 
 // wxEventLoop implementation
 // ============================================================================
 

-wxEventLoop *wxEventLoop::ms_activeLoop = NULL;
-

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


@@ -353,28 +148,18 @@ 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;

 
 

-    m_impl->m_keepGoing = TRUE;
+    wxEventLoopActivator activate(this);
+
+    m_impl->m_keepGoing = true;

     while ( m_impl->m_keepGoing )
     {
     while ( m_impl->m_keepGoing )
     {

-#if 0 // wxUSE_THREADS
-        wxMutexGuiLeaveOrEnter();
-#endif // wxUSE_THREADS
-

         // generate and process idle events for as long as we don't have
         // anything else to do
         while ( ! Pending() )
         // generate and process idle events for as long as we don't have
         // anything else to do
         while ( ! Pending() )


@@ -384,13 +169,6 @@ int wxEventLoop::Run()
 #endif
             if (!m_impl->SendIdleEvent())
             {
 #endif
             if (!m_impl->SendIdleEvent())
             {

-#if 0 // wxUSE_THREADS
-                // leave the main loop to give other threads a chance to
-                // perform their GUI work
-                wxMutexGuiLeave();
-                wxUsleep(20);
-                wxMutexGuiEnter();
-#endif

                 // Break out of while loop
                 break;
             }
                 // Break out of while loop
                 break;
             }


@@ -404,12 +182,12 @@ int wxEventLoop::Run()
         }
     }
 
         }
     }
 

+    OnExit();
+

     int exitcode = m_impl->GetExitCode();
     delete m_impl;
     m_impl = NULL;
 
     int exitcode = m_impl->GetExitCode();
     delete m_impl;
     m_impl = NULL;
 

-    ms_activeLoop = oldLoop;
-

     return exitcode;
 }
 
     return exitcode;
 }
 


@@ -418,7 +196,7 @@ void wxEventLoop::Exit(int rc)
     wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") );
 
     m_impl->SetExitCode(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;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -435,6 +213,9 @@ bool wxEventLoop::Dispatch()
 {
     XEvent event;
 
 {
     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,
     // TODO allowing for threads, as per e.g. wxMSW
 
     // This now waits until either an X event is received,


@@ -443,7 +224,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.
     // 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
     if (XPending( wxGlobalDisplay() ) == 0)
     {
 #if wxUSE_NANOX


@@ -454,53 +235,37 @@ 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
         int fd = ConnectionNumber( wxGlobalDisplay() );
 #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;
         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)
+        if (select( fd+1, &readset, &writeset, NULL, &tv ) != 0)

         {
         {

-            // Timed out, so no event to process
-            return TRUE;
-        }
-        else
-        {
-            // An X11 event was pending, so get it
-            if (FD_ISSET( fd, &readset ))
+            // An X11 event was pending, get it
+            if (wxFD_ISSET( fd, &readset ))

                 XNextEvent( wxGlobalDisplay(), &event );
                 XNextEvent( wxGlobalDisplay(), &event );

-
-#if wxUSE_SOCKETS
-            // Check if any socket events were pending,
-            // and if so, call their callbacks
-            if (wxTheSocketTable)
-                wxTheSocketTable->ProcessEvents( &readset, &writeset );
+        }    

 #endif
 #endif

-        }
-#endif
-    } 
+    }

     else
     {
         XNextEvent( wxGlobalDisplay(), &event );
     }
     else
     {
         XNextEvent( wxGlobalDisplay(), &event );
     }

-    
-    
+
+#if wxUSE_SOCKETS
+    // handle any pending socket events:
+    wxSocketEventDispatcher::Get().RunLoop();
+#endif
+

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

-    return TRUE;
+    return true;

 }
 }

-