add wxImage test units to test loading from both seekable and non-seekable streams

[wxWidgets.git] / src / unix / evtloopunix.cpp

diff --git a/src/unix/evtloopunix.cpp b/src/unix/evtloopunix.cpp
index d9e4100457525d1d272edd16cfd89b0aaa1d7909..4edf70e6969dbaed9077ecacd548510efe8bf811 100644 (file)
--- a/src/unix/evtloopunix.cpp
+++ b/src/unix/evtloopunix.cpp
@@ -19,6 +19,8 @@
 // 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_CONSOLE_EVENTLOOP
+

 #include "wx/evtloop.h"
 
 #ifndef WX_PRECOMP
 #include "wx/evtloop.h"
 
 #ifndef WX_PRECOMP


@@ -27,27 +29,53 @@
 #endif
 
 #include <errno.h>
 #endif
 
 #include <errno.h>

+#include "wx/apptrait.h"

 #include "wx/thread.h"
 #include "wx/module.h"
 #include "wx/thread.h"
 #include "wx/module.h"

-#include "wx/generic/private/timer.h"
+#include "wx/unix/pipe.h"
+#include "wx/unix/private/timer.h"

 #include "wx/unix/private/epolldispatcher.h"
 #include "wx/private/selectdispatcher.h"
 
 #define TRACE_EVENTS _T("events")
 
 #include "wx/unix/private/epolldispatcher.h"
 #include "wx/private/selectdispatcher.h"
 
 #define TRACE_EVENTS _T("events")
 

-//this code should not be compiled when GUI is defined
-//(monolithic build issue)
-#if !wxUSE_GUI
-

 // ===========================================================================
 // wxEventLoop::PipeIOHandler implementation
 // ===========================================================================
 
 // ===========================================================================
 // wxEventLoop::PipeIOHandler implementation
 // ===========================================================================
 

+namespace wxPrivate
+{
+
+// pipe used for wake up messages: when a child thread wants to wake up
+// the event loop in the main thread it writes to this pipe
+class PipeIOHandler : public wxFDIOHandler
+{
+public:
+    // default ctor does nothing, call Create() to really initialize the
+    // object
+    PipeIOHandler() { }
+
+    bool Create();
+
+    // this method can be, and normally is, called from another thread
+    void WakeUp();
+
+    int GetReadFd() { return m_pipe[wxPipe::Read]; }
+
+    // implement wxFDIOHandler pure virtual methods
+    virtual void OnReadWaiting();
+    virtual void OnWriteWaiting() { }
+    virtual void OnExceptionWaiting() { }
+
+private:
+    wxPipe m_pipe;
+};
+

 // ----------------------------------------------------------------------------
 // initialization
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // initialization
 // ----------------------------------------------------------------------------
 

-bool wxConsoleEventLoop::PipeIOHandler::Create()
+bool PipeIOHandler::Create()

 {
     if ( !m_pipe.Create() )
     {
 {
     if ( !m_pipe.Create() )
     {


@@ -74,7 +102,7 @@ bool wxConsoleEventLoop::PipeIOHandler::Create()
 // wakeup handling
 // ----------------------------------------------------------------------------
 
 // wakeup handling
 // ----------------------------------------------------------------------------
 

-void wxConsoleEventLoop::PipeIOHandler::WakeUp()
+void PipeIOHandler::WakeUp()

 {
     if ( write(m_pipe[wxPipe::Write], "s", 1) != 1 )
     {
 {
     if ( write(m_pipe[wxPipe::Write], "s", 1) != 1 )
     {


@@ -84,17 +112,17 @@ void wxConsoleEventLoop::PipeIOHandler::WakeUp()
     }
 }
 
     }
 }
 

-void wxConsoleEventLoop::PipeIOHandler::OnReadWaiting()
+void PipeIOHandler::OnReadWaiting()

 {
     // got wakeup from child thread: read all data available in pipe just to
 {
     // got wakeup from child thread: read all data available in pipe just to

-    // make it empty (evevn though we write one byte at a time from WakeUp(),
+    // make it empty (even though we write one byte at a time from WakeUp(),

     // it could have been called several times)
     char buf[4];
     for ( ;; )
     {
         const int size = read(GetReadFd(), buf, WXSIZEOF(buf));
 
     // it could have been called several times)
     char buf[4];
     for ( ;; )
     {
         const int size = read(GetReadFd(), buf, WXSIZEOF(buf));
 

-        if ( size == 0 || (size == -1 && errno == EAGAIN) )
+        if ( size == 0 || (size == -1 && (errno == EAGAIN || errno == EINTR)) )

         {
             // nothing left in the pipe (EAGAIN is expected for an FD with
             // O_NONBLOCK)
         {
             // nothing left in the pipe (EAGAIN is expected for an FD with
             // O_NONBLOCK)


@@ -109,9 +137,13 @@ void wxConsoleEventLoop::PipeIOHandler::OnReadWaiting()
         }
     }
 
         }
     }
 

-    wxTheApp->ProcessPendingEvents();
+    // writing to the wake up pipe will make wxConsoleEventLoop return from
+    // wxFDIODispatcher::Dispatch() it might be currently blocking in, nothing
+    // else needs to be done

 }
 
 }
 

+} // namespace wxPrivate
+

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


@@ -122,29 +154,30 @@ void wxConsoleEventLoop::PipeIOHandler::OnReadWaiting()
 
 wxConsoleEventLoop::wxConsoleEventLoop()
 {
 
 wxConsoleEventLoop::wxConsoleEventLoop()
 {

-    if ( !m_wakeupPipe.Create() )
+    m_wakeupPipe = new wxPrivate::PipeIOHandler();
+    if ( !m_wakeupPipe->Create() )

     {
     {

+        wxDELETE(m_wakeupPipe);

         m_dispatcher = NULL;
         return;
     }
 
         m_dispatcher = NULL;
         return;
     }
 

-#ifdef HAVE_SYS_EPOLL_H
-    m_dispatcher = wxEpollDispatcher::Get();
+    m_dispatcher = wxFDIODispatcher::Get();

     if ( !m_dispatcher )
     if ( !m_dispatcher )

-#endif // HAVE_SYS_EPOLL_H
-    {
-        m_dispatcher = wxSelectDispatcher::Get();
-    }
-
-    wxCHECK_RET( m_dispatcher, _T("failed to create IO dispatcher") );
+        return;

 
     m_dispatcher->RegisterFD
                   (
 
     m_dispatcher->RegisterFD
                   (

-                    m_wakeupPipe.GetReadFd(),
-                    &m_wakeupPipe,
+                    m_wakeupPipe->GetReadFd(),
+                    m_wakeupPipe,

                     wxFDIO_INPUT
                   );
                     wxFDIO_INPUT
                   );

-};
+}
+
+wxConsoleEventLoop::~wxConsoleEventLoop()
+{
+    delete m_wakeupPipe;
+}

 
 //-----------------------------------------------------------------------------
 // events dispatch and loop handling
 
 //-----------------------------------------------------------------------------
 // events dispatch and loop handling


@@ -152,46 +185,64 @@ wxConsoleEventLoop::wxConsoleEventLoop()
 
 bool wxConsoleEventLoop::Pending() const
 {
 
 bool wxConsoleEventLoop::Pending() const
 {

-    return wxTheApp->HasPendingEvents();
+    if ( m_dispatcher->HasPending() )
+        return true;
+
+#if wxUSE_TIMER
+    wxUsecClock_t nextTimer;
+    if ( wxTimerScheduler::Get().GetNext(&nextTimer) &&
+            !wxMilliClockToLong(nextTimer) )
+        return true;
+#endif // wxUSE_TIMER
+
+    return false;

 }
 
 bool wxConsoleEventLoop::Dispatch()
 {
 }
 
 bool wxConsoleEventLoop::Dispatch()
 {

-    wxTheApp->ProcessPendingEvents();
+    DispatchTimeout(wxFDIODispatcher::TIMEOUT_INFINITE);
+

     return true;
 }
 
     return true;
 }
 

-void wxConsoleEventLoop::WakeUp()
+int wxConsoleEventLoop::DispatchTimeout(unsigned long timeout)

 {
 {

-    m_wakeupPipe.WakeUp();
-}
-
-void wxConsoleEventLoop::OnNextIteration()
-{
-    // calculate the timeout until the next timer expiration
-    int timeout;
-

 #if wxUSE_TIMER
 #if wxUSE_TIMER

+    // check if we need to decrease the timeout to account for a timer

     wxUsecClock_t nextTimer;
     if ( wxTimerScheduler::Get().GetNext(&nextTimer) )
     {
     wxUsecClock_t nextTimer;
     if ( wxTimerScheduler::Get().GetNext(&nextTimer) )
     {

-        // timeout is in ms
-        timeout = (nextTimer / 1000).ToLong();
+        unsigned long timeUntilNextTimer = wxMilliClockToLong(nextTimer / 1000);
+        if ( timeUntilNextTimer < timeout )
+            timeout = timeUntilNextTimer;

     }
     }

-    else // no timers, we can block forever

 #endif // wxUSE_TIMER
 #endif // wxUSE_TIMER

-    {
-        timeout = wxFDIODispatcher::TIMEOUT_INFINITE;
-    }

 
 

-    m_dispatcher->RunLoop(timeout);
+    bool hadEvent = m_dispatcher->Dispatch(timeout) > 0;

 
 #if wxUSE_TIMER
 
 #if wxUSE_TIMER

-    wxTimerScheduler::Get().NotifyExpired();
-#endif
+    if ( wxTimerScheduler::Get().NotifyExpired() )
+        hadEvent = true;
+#endif // wxUSE_TIMER

 
 

+    return hadEvent ? 1 : -1;
+}
+
+void wxConsoleEventLoop::WakeUp()
+{
+    m_wakeupPipe->WakeUp();
+}
+
+void wxConsoleEventLoop::OnNextIteration()
+{

     // call the signal handlers for any signals we caught recently
     wxTheApp->CheckSignal();
 }
 
     // call the signal handlers for any signals we caught recently
     wxTheApp->CheckSignal();
 }
 

-#endif // !wxUSE_GUI
+
+wxEventLoopBase *wxConsoleAppTraits::CreateEventLoop()
+{
+    return new wxEventLoop();
+}
+
+#endif // wxUSE_CONSOLE_EVENTLOOP