]> git.saurik.com Git - wxWidgets.git/blobdiff - src/x11/evtloop.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
missing commit
[wxWidgets.git] / src / x11 / evtloop.cpp
diff --git a/src/x11/evtloop.cpp b/src/x11/evtloop.cpp
index b62ce72440522179e793cc076ff5a9b3fa3d1ebf..146fabde1495ee8ff7e83f2f27e7060643011c48 100644 (file)
--- a/src/x11/evtloop.cpp
+++ b/src/x11/evtloop.cpp
@@ -6,7 +6,7 @@
 // Created:     01.06.01
 // RCS-ID:      $Id$
 // Copyright:   (c) 2002 Julian Smart
 // Created:     01.06.01
 // RCS-ID:      $Id$
 // Copyright:   (c) 2002 Julian Smart
-// License:     wxWindows licence
+// Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
@@ -26,19 +26,19 @@
     #include "wx/hash.h"
     #include "wx/app.h"
     #include "wx/window.h"
     #include "wx/hash.h"
     #include "wx/app.h"
     #include "wx/window.h"
-    #include "wx/timer.h"
     #include "wx/module.h"
 #endif
 
     #include "wx/module.h"
 #endif
 
-#include "wx/tooltip.h"
+#include "wx/private/fdiodispatcher.h"
 #include "wx/unix/private.h"
 #include "wx/x11/private.h"
 #include "wx/unix/private.h"
 #include "wx/x11/private.h"
-#include "X11/Xlib.h"
+#include "wx/generic/private/timer.h"
 
 #if wxUSE_THREADS
     #include "wx/thread.h"
 #endif
 
 
 #if wxUSE_THREADS
     #include "wx/thread.h"
 #endif
 
+#include <X11/Xlib.h>
 #include <sys/time.h>
 #include <unistd.h>
 
 #include <sys/time.h>
 #include <unistd.h>
 
@@ -46,218 +46,6 @@
 #   include <sys/select.h>
 #endif
 
 #   include <sys/select.h>
 #endif
 
-#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)
-    {
-    }
-    virtual ~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)
-        {
-            wxFD_SET(entry->m_fdInput, readset);
-            if (entry->m_fdInput > *highest)
-                * highest = entry->m_fdInput;
-        }
-
-        if (entry->m_fdOutput != -1)
-        {
-            wxFD_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 && wxFD_ISSET(entry->m_fdInput, readset))
-        {
-            (entry->m_callbackInput) (entry->m_fdInput, entry->m_dataInput);
-        }
-
-        if (entry->m_fdOutput != -1 && wxFD_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);
-    }
-}
-#endif
-
 // ----------------------------------------------------------------------------
 // wxEventLoopImpl
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxEventLoopImpl
 // ----------------------------------------------------------------------------
@@ -310,31 +98,8 @@ bool wxEventLoopImpl::ProcessEvent(XEvent *event)
     return false;
 }
 
     return false;
 }
 
-bool wxEventLoopImpl::PreProcessEvent(XEvent *event)
+bool wxEventLoopImpl::PreProcessEvent(XEvent *WXUNUSED(event))
 {
 {
-    // TODO
-#if 0
-    HWND hWnd = msg->hwnd;
-    wxWindow *wndThis = wxGetWindowFromHWND((WXHWND)hWnd);
-
-
-    // try translations first; find the youngest window with a translation
-    // table.
-    wxWindow *wnd;
-    for ( wnd = wndThis; wnd; wnd = wnd->GetParent() )
-    {
-        if ( wnd->MSWTranslateMessage((WXMSG *)msg) )
-            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;
-    }
-#endif
-
     return false;
 }
 
     return false;
 }
 
@@ -355,15 +120,15 @@ bool wxEventLoopImpl::SendIdleEvent()
 // wxEventLoop running and exiting
 // ----------------------------------------------------------------------------
 
 // wxEventLoop running and exiting
 // ----------------------------------------------------------------------------
 
-wxEventLoop::~wxEventLoop()
+wxGUIEventLoop::~wxGUIEventLoop()
 {
 {
-    wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
+    wxASSERT_MSG( !m_impl, wxT("should have been deleted in Run()") );
 }
 
 }
 
-int wxEventLoop::Run()
+int wxGUIEventLoop::Run()
 {
     // event loops are not recursive, you need to create another loop!
 {
     // event loops are not recursive, you need to create another loop!
-    wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
+    wxCHECK_MSG( !m_impl, -1, wxT("can't reenter a message loop") );
 
     m_impl = new wxEventLoopImpl;
 
 
     m_impl = new wxEventLoopImpl;
 
@@ -372,26 +137,15 @@ int wxEventLoop::Run()
     m_impl->m_keepGoing = true;
     while ( m_impl->m_keepGoing )
     {
     m_impl->m_keepGoing = true;
     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() )
         {
 #if wxUSE_TIMER
         // generate and process idle events for as long as we don't have
         // anything else to do
         while ( ! Pending() )
         {
 #if wxUSE_TIMER
-            wxTimer::NotifyTimers(); // TODO: is this the correct place for it?
+            wxGenericTimerImpl::NotifyTimers(); // TODO: is this the correct place for it?
 #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;
             }
@@ -405,37 +159,40 @@ int wxEventLoop::Run()
         }
     }
 
         }
     }
 
+    OnExit();
+
     int exitcode = m_impl->GetExitCode();
     int exitcode = m_impl->GetExitCode();
-    delete m_impl;
-    m_impl = NULL;
+    wxDELETE(m_impl);
 
     return exitcode;
 }
 
 
     return exitcode;
 }
 
-void wxEventLoop::Exit(int rc)
+void wxGUIEventLoop::Exit(int rc)
 {
 {
-    wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") );
-
-    m_impl->SetExitCode(rc);
-    m_impl->m_keepGoing = false;
+    if ( m_impl )
+    {
+        m_impl->SetExitCode(rc);
+        m_impl->m_keepGoing = false;
+    }
 }
 
 // ----------------------------------------------------------------------------
 // wxEventLoop message processing dispatching
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // wxEventLoop message processing dispatching
 // ----------------------------------------------------------------------------
 
-bool wxEventLoop::Pending() const
+bool wxGUIEventLoop::Pending() const
 {
     XFlush( wxGlobalDisplay() );
     return (XPending( wxGlobalDisplay() ) > 0);
 }
 
 {
     XFlush( wxGlobalDisplay() );
     return (XPending( wxGlobalDisplay() ) > 0);
 }
 
-bool wxEventLoop::Dispatch()
+bool wxGUIEventLoop::Dispatch()
 {
 {
-    XEvent event;
+    // see comment in wxEventLoopManual::ProcessEvents()
+    if ( wxTheApp )
+        wxTheApp->ProcessPendingEvents();
 
 
-    // Start off by checking if any of our child processes have finished.
-    wxCheckForFinishedChildren();
+    XEvent event;
 
     // TODO allowing for threads, as per e.g. wxMSW
 
 
     // TODO allowing for threads, as per e.g. wxMSW
 
@@ -465,34 +222,15 @@ bool wxEventLoop::Dispatch()
 
         fd_set readset;
         fd_set writeset;
 
         fd_set readset;
         fd_set writeset;
-        int highest = fd;
         wxFD_ZERO(&readset);
         wxFD_ZERO(&writeset);
         wxFD_ZERO(&readset);
         wxFD_ZERO(&writeset);
-
         wxFD_SET(fd, &readset);
 
         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;
-        }
-        else
+        if (select( fd+1, &readset, &writeset, NULL, &tv ) != 0)
         {
         {
-            // An X11 event was pending, so get it
+            // An X11 event was pending, get it
             if (wxFD_ISSET( fd, &readset ))
                 XNextEvent( wxGlobalDisplay(), &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)
-                wxTheSocketTable->ProcessEvents( &readset, &writeset );
-#endif
         }
 #endif
     }
         }
 #endif
     }
@@ -501,7 +239,41 @@ bool wxEventLoop::Dispatch()
         XNextEvent( wxGlobalDisplay(), &event );
     }
 
         XNextEvent( wxGlobalDisplay(), &event );
     }
 
+#if wxUSE_SOCKETS
+    // handle any pending socket events:
+    wxFDIODispatcher::DispatchPending();
+#endif
 
     (void) m_impl->ProcessEvent( &event );
     return true;
 }
 
     (void) m_impl->ProcessEvent( &event );
     return true;
 }
+
+bool wxGUIEventLoop::YieldFor(long eventsToProcess)
+{
+    // Sometimes only 2 yields seem
+    // to do the trick, e.g. in the
+    // progress dialog
+    int i;
+    for (i = 0; i < 2; i++)
+    {
+        m_isInsideYield = true;
+        m_eventsToProcessInsideYield = eventsToProcess;
+
+        // Call dispatch at least once so that sockets
+        // can be tested
+        wxTheApp->Dispatch();
+
+        // TODO: implement event filtering using the eventsToProcess mask
+        while (wxTheApp && wxTheApp->Pending())
+            wxTheApp->Dispatch();
+
+#if wxUSE_TIMER
+        wxGenericTimerImpl::NotifyTimers();
+#endif
+        ProcessIdle();
+
+        m_isInsideYield = false;
+    }
+
+    return true;
+}
wxWidgets (Impactor)