Use gdk_window_invalidate instead of gtk_widget_queue_draw as the latter doesn't...

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

diff --git a/src/common/selectdispatcher.cpp b/src/common/selectdispatcher.cpp
index 2a96b334535d11feb1aa9cd92bbe1da7fbdbf043..1365319347931940c1a4d09348e9d957cdf678b3 100644 (file)
--- a/src/common/selectdispatcher.cpp
+++ b/src/common/selectdispatcher.cpp
@@ -19,9 +19,9 @@
 // for compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // for compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 

+#if wxUSE_SELECT_DISPATCHER
+

 #include "wx/private/selectdispatcher.h"
 #include "wx/private/selectdispatcher.h"

-#include "wx/module.h"
-#include "wx/timer.h"

 #include "wx/unix/private.h"
 
 #ifndef WX_PRECOMP
 #include "wx/unix/private.h"
 
 #ifndef WX_PRECOMP


@@ -30,7 +30,8 @@
     #include "wx/intl.h"
 #endif
 
     #include "wx/intl.h"
 #endif
 

-#ifdef HAVE_SYS_SELECT_H
+#if defined(HAVE_SYS_SELECT_H) || defined(__WATCOMC__)
+    #include <sys/time.h>

     #include <sys/select.h>
 #endif
 
     #include <sys/select.h>
 #endif
 


@@ -95,14 +96,10 @@ bool wxSelectSets::SetFD(int fd, int flags)
         if ( flags & ms_flags[n] )
         {
             wxFD_SET(fd, &m_fds[n]);
         if ( flags & ms_flags[n] )
         {
             wxFD_SET(fd, &m_fds[n]);

-            wxLogTrace(wxSelectDispatcher_Trace,
-                       _T("Registered fd %d for %s events"), fd, ms_names[n]);

         }
         else if ( wxFD_ISSET(fd,  (fd_set*) &m_fds[n]) )
         {
             wxFD_CLR(fd, &m_fds[n]);
         }
         else if ( wxFD_ISSET(fd,  (fd_set*) &m_fds[n]) )
         {
             wxFD_CLR(fd, &m_fds[n]);

-            wxLogTrace(wxSelectDispatcher_Trace,
-                       _T("Unregistered fd %d from %s events"), fd, ms_names[n]);

         }
     }
 
         }
     }
 


@@ -114,7 +111,7 @@ int wxSelectSets::Select(int nfds, struct timeval *tv)
     return select(nfds, &m_fds[Read], &m_fds[Write], &m_fds[Except], tv);
 }
 
     return select(nfds, &m_fds[Read], &m_fds[Write], &m_fds[Except], tv);
 }
 

-void wxSelectSets::Handle(int fd, wxFDIOHandler& handler) const
+bool wxSelectSets::Handle(int fd, wxFDIOHandler& handler) const

 {
     for ( int n = 0; n < Max; n++ )
     {
 {
     for ( int n = 0; n < Max; n++ )
     {


@@ -123,41 +120,19 @@ void wxSelectSets::Handle(int fd, wxFDIOHandler& handler) const
             wxLogTrace(wxSelectDispatcher_Trace,
                        _T("Got %s event on fd %d"), ms_names[n], fd);
             (handler.*ms_handlers[n])();
             wxLogTrace(wxSelectDispatcher_Trace,
                        _T("Got %s event on fd %d"), ms_names[n], fd);
             (handler.*ms_handlers[n])();

+            // callback can modify sets and destroy handler
+            // this forces that one event can be processed at one time
+            return true;

         }
     }
         }
     }

+
+    return false;

 }
 
 // ----------------------------------------------------------------------------
 // wxSelectDispatcher
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // wxSelectDispatcher
 // ----------------------------------------------------------------------------
 

-static wxSelectDispatcher *gs_selectDispatcher = NULL;
-
-/* static */
-wxSelectDispatcher *wxSelectDispatcher::Get()
-{
-    if ( !gs_selectDispatcher )
-    {
-        // the dispatcher should be only created from one thread so it should
-        // be ok to use a global without any protection here
-        gs_selectDispatcher = new wxSelectDispatcher;
-    }
-
-    return gs_selectDispatcher;
-}
-
-/* static */
-void wxSelectDispatcher::DispatchPending()
-{
-    if ( gs_selectDispatcher )
-        gs_selectDispatcher->RunLoop(0);
-}
-
-wxSelectDispatcher::wxSelectDispatcher()
-{
-    m_maxFD = -1;
-}
-

 bool wxSelectDispatcher::RegisterFD(int fd, wxFDIOHandler *handler, int flags)
 {
     if ( !wxMappedFDIODispatcher::RegisterFD(fd, handler, flags) )
 bool wxSelectDispatcher::RegisterFD(int fd, wxFDIOHandler *handler, int flags)
 {
     if ( !wxMappedFDIODispatcher::RegisterFD(fd, handler, flags) )


@@ -169,6 +144,8 @@ bool wxSelectDispatcher::RegisterFD(int fd, wxFDIOHandler *handler, int flags)
     if ( fd > m_maxFD )
       m_maxFD = fd;
 
     if ( fd > m_maxFD )
       m_maxFD = fd;
 

+    wxLogTrace(wxSelectDispatcher_Trace,
+                _T("Registered fd %d: input:%d, output:%d, exceptional:%d"), fd, (flags & wxFDIO_INPUT) == wxFDIO_INPUT, (flags & wxFDIO_OUTPUT), (flags & wxFDIO_EXCEPTION) == wxFDIO_EXCEPTION);

     return true;
 }
 
     return true;
 }
 


@@ -179,12 +156,17 @@ bool wxSelectDispatcher::ModifyFD(int fd, wxFDIOHandler *handler, int flags)
 
     wxASSERT_MSG( fd <= m_maxFD, _T("logic error: registered fd > m_maxFD?") );
 
 
     wxASSERT_MSG( fd <= m_maxFD, _T("logic error: registered fd > m_maxFD?") );
 

+    wxLogTrace(wxSelectDispatcher_Trace,
+                _T("Modified fd %d: input:%d, output:%d, exceptional:%d"), fd, (flags & wxFDIO_INPUT) == wxFDIO_INPUT, (flags & wxFDIO_OUTPUT) == wxFDIO_OUTPUT, (flags & wxFDIO_EXCEPTION) == wxFDIO_EXCEPTION);

     return m_sets.SetFD(fd, flags);
 }
 
     return m_sets.SetFD(fd, flags);
 }
 

-bool wxSelectDispatcher::UnregisterFD(int fd, int flags)
+bool wxSelectDispatcher::UnregisterFD(int fd)

 {
 {

-    m_sets.ClearFD(fd, flags);
+    m_sets.ClearFD(fd);
+
+    if ( !wxMappedFDIODispatcher::UnregisterFD(fd) )
+        return false;

 
     // remove the handler if we don't need it any more
     if ( !m_sets.HasFD(fd) )
 
     // remove the handler if we don't need it any more
     if ( !m_sets.HasFD(fd) )


@@ -198,16 +180,21 @@ bool wxSelectDispatcher::UnregisterFD(int fd, int flags)
                   ++it )
             {
                 if ( it->first > m_maxFD )
                   ++it )
             {
                 if ( it->first > m_maxFD )

+                {

                     m_maxFD = it->first;
                     m_maxFD = it->first;

+                }

             }
         }
     }
 
             }
         }
     }
 

+    wxLogTrace(wxSelectDispatcher_Trace,
+                _T("Removed fd %d, current max: %d"), fd, m_maxFD);

     return true;
 }
 
     return true;
 }
 

-void wxSelectDispatcher::ProcessSets(const wxSelectSets& sets)
+int wxSelectDispatcher::ProcessSets(const wxSelectSets& sets)

 {
 {

+    int numEvents = 0;

     for ( int fd = 0; fd <= m_maxFD; fd++ )
     {
         if ( !sets.HasFD(fd) )
     for ( int fd = 0; fd <= m_maxFD; fd++ )
     {
         if ( !sets.HasFD(fd) )


@@ -220,73 +207,60 @@ void wxSelectDispatcher::ProcessSets(const wxSelectSets& sets)
             continue;
         }
 
             continue;
         }
 

-        sets.Handle(fd, *handler);
+        if ( sets.Handle(fd, *handler) )
+            numEvents++;

     }
     }

+
+    return numEvents;

 }
 
 }
 

-void wxSelectDispatcher::RunLoop(int timeout)
+int wxSelectDispatcher::DoSelect(wxSelectSets& sets, int timeout) const

 {
     struct timeval tv,
 {
     struct timeval tv,

-                  *ptv = NULL;
+                  *ptv;

     if ( timeout != TIMEOUT_INFINITE )
     {
         ptv = &tv;
         tv.tv_sec = 0;
         tv.tv_usec = timeout*1000;
     }
     if ( timeout != TIMEOUT_INFINITE )
     {
         ptv = &tv;
         tv.tv_sec = 0;
         tv.tv_usec = timeout*1000;
     }

-
-    for ( ;; )
+    else // no timeout

     {
     {

-        wxSelectSets sets = m_sets;
-
-        wxStopWatch sw;
-        if ( ptv && timeout )
-          sw.Start(ptv->tv_usec/10);
-
-        const int ret = sets.Select(m_maxFD + 1, ptv);
-        switch ( ret )
-        {
-            case -1:
-                // continue if we were interrupted by a signal, else bail out
-                if ( errno != EINTR )
-                {
-                    wxLogSysError(_("Failed to monitor I/O channels"));
-                    return;
-                }
-                break;
-
-            case 0:
-                // timeout expired without anything happening
-                return;
+        ptv = NULL;
+    }

 
 

-            default:
-                ProcessSets(sets);
-        }
+    int ret = sets.Select(m_maxFD + 1, ptv);

 
 

-        if ( ptv )
-        {
-            timeout -= sw.Time();
-            if ( timeout <= 0 )
-                break;
+    // TODO: we need to restart select() in this case but for now just return
+    //       as if timeout expired
+    if ( ret == -1 && errno == EINTR )
+        ret = 0;

 
 

-            ptv->tv_usec = timeout*1000;
-        }
-    }
+    return ret;

 }
 
 }
 

-// ----------------------------------------------------------------------------
-// wxSelectDispatcherModule
-// ----------------------------------------------------------------------------
+bool wxSelectDispatcher::HasPending() const
+{
+    wxSelectSets sets(m_sets);
+    return DoSelect(sets, 0) > 0;
+}

 
 

-class wxSelectDispatcherModule : public wxModule
+int wxSelectDispatcher::Dispatch(int timeout)

 {
 {

-public:
-    virtual bool OnInit() { return true; }
-    virtual void OnExit() { wxDELETE(gs_selectDispatcher); }
+    wxSelectSets sets(m_sets);
+    switch ( DoSelect(sets, timeout) )
+    {
+        case -1:
+            wxLogSysError(_("Failed to monitor I/O channels"));
+            return -1;

 
 

-private:
-    DECLARE_DYNAMIC_CLASS(wxSelectDispatcherModule)
-};
+        case 0:
+            // timeout expired without anything happening
+            return 0;

 
 

-IMPLEMENT_DYNAMIC_CLASS(wxSelectDispatcherModule, wxModule)
+        default:
+            return ProcessSets(sets);
+    }
+}

 
 

+#endif // wxUSE_SELECT_DISPATCHER