using proper cmd constant

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

diff --git a/src/unix/evtloopunix.cpp b/src/unix/evtloopunix.cpp
index b439c4d4664b4f871973739e7187fdd2bf5d0699..b219d1b2dca30138516d60b68f9df0b3329b38ae 100644 (file)
--- a/src/unix/evtloopunix.cpp
+++ b/src/unix/evtloopunix.cpp
@@ -21,6 +21,8 @@
 
 #if wxUSE_CONSOLE_EVENTLOOP
 
+#include "wx/evtloop.h"
+
 #ifndef WX_PRECOMP
     #include "wx/app.h"
     #include "wx/log.h"
@@ -28,24 +30,57 @@
 
 #include <errno.h>
 #include "wx/apptrait.h"
-#include "wx/evtloop.h"
+#include "wx/scopedptr.h"
 #include "wx/thread.h"
 #include "wx/module.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")
+#if wxUSE_EVENTLOOP_SOURCE
+    #include "wx/evtloopsrc.h"
+#endif // wxUSE_EVENTLOOP_SOURCE
+
+#define TRACE_EVENTS wxT("events")
 
 // ===========================================================================
 // 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
 // ----------------------------------------------------------------------------
 
-bool wxConsoleEventLoop::PipeIOHandler::Create()
+bool PipeIOHandler::Create()
 {
     if ( !m_pipe.Create() )
     {
@@ -53,17 +88,14 @@ bool wxConsoleEventLoop::PipeIOHandler::Create()
         return false;
     }
 
-    const int fdRead = GetReadFd();
-
-    int flags = fcntl(fdRead, F_GETFL, 0);
-    if ( flags == -1 || fcntl(fdRead, F_SETFL, flags | O_NONBLOCK) == -1 )
+    if ( !m_pipe.MakeNonBlocking(wxPipe::Read) )
     {
         wxLogSysError(_("Failed to switch wake up pipe to non-blocking mode"));
         return false;
     }
 
     wxLogTrace(TRACE_EVENTS, wxT("Wake up pipe (%d, %d) created"),
-               fdRead, m_pipe[wxPipe::Write]);
+               m_pipe[wxPipe::Read], m_pipe[wxPipe::Write]);
 
     return true;
 }
@@ -72,7 +104,7 @@ bool wxConsoleEventLoop::PipeIOHandler::Create()
 // wakeup handling
 // ----------------------------------------------------------------------------
 
-void wxConsoleEventLoop::PipeIOHandler::WakeUp()
+void PipeIOHandler::WakeUp()
 {
     if ( write(m_pipe[wxPipe::Write], "s", 1) != 1 )
     {
@@ -82,7 +114,7 @@ void wxConsoleEventLoop::PipeIOHandler::WakeUp()
     }
 }
 
-void wxConsoleEventLoop::PipeIOHandler::OnReadWaiting()
+void PipeIOHandler::OnReadWaiting()
 {
     // got wakeup from child thread: read all data available in pipe just to
     // make it empty (even though we write one byte at a time from WakeUp(),
@@ -112,6 +144,8 @@ void wxConsoleEventLoop::PipeIOHandler::OnReadWaiting()
     // else needs to be done
 }
 
+} // namespace wxPrivate
+
 // ===========================================================================
 // wxEventLoop implementation
 // ===========================================================================
@@ -122,8 +156,10 @@ void wxConsoleEventLoop::PipeIOHandler::OnReadWaiting()
 
 wxConsoleEventLoop::wxConsoleEventLoop()
 {
-    if ( !m_wakeupPipe.Create() )
+    m_wakeupPipe = new wxPrivate::PipeIOHandler();
+    if ( !m_wakeupPipe->Create() )
     {
+        wxDELETE(m_wakeupPipe);
         m_dispatcher = NULL;
         return;
     }
@@ -134,12 +170,93 @@ wxConsoleEventLoop::wxConsoleEventLoop()
 
     m_dispatcher->RegisterFD
                   (
-                    m_wakeupPipe.GetReadFd(),
-                    &m_wakeupPipe,
+                    m_wakeupPipe->GetReadFd(),
+                    m_wakeupPipe,
                     wxFDIO_INPUT
                   );
 }
 
+wxConsoleEventLoop::~wxConsoleEventLoop()
+{
+    if ( m_wakeupPipe )
+    {
+        if ( m_dispatcher )
+        {
+            m_dispatcher->UnregisterFD(m_wakeupPipe->GetReadFd());
+        }
+
+        delete m_wakeupPipe;
+    }
+}
+
+//-----------------------------------------------------------------------------
+// adding & removing sources
+//-----------------------------------------------------------------------------
+
+#if wxUSE_EVENTLOOP_SOURCE
+
+// This class is a temporary bridge between event loop sources and
+// FDIODispatcher. It is going to be removed soon, when all subject interfaces
+// are modified
+class wxFDIOEventLoopSourceHandler : public wxFDIOHandler
+{
+public:
+    wxFDIOEventLoopSourceHandler(wxEventLoopSourceHandler* handler) :
+        m_impl(handler) { }
+
+    virtual void OnReadWaiting()
+    {
+        m_impl->OnReadWaiting();
+    }
+    virtual void OnWriteWaiting()
+    {
+        m_impl->OnWriteWaiting();
+    }
+
+    virtual void OnExceptionWaiting()
+    {
+        m_impl->OnExceptionWaiting();
+    }
+
+protected:
+    wxEventLoopSourceHandler* m_impl;
+};
+
+wxEventLoopSource *
+wxConsoleEventLoop::AddSourceForFD(int fd,
+                                   wxEventLoopSourceHandler *handler,
+                                   int flags)
+{
+    wxCHECK_MSG( fd != -1, NULL, "can't monitor invalid fd" );
+
+    wxLogTrace(wxTRACE_EVT_SOURCE,
+                "Adding event loop source for fd=%d", fd);
+
+    // we need a bridge to wxFDIODispatcher
+    //
+    // TODO: refactor the code so that only wxEventLoopSourceHandler is used
+    wxScopedPtr<wxFDIOHandler>
+        fdioHandler(new wxFDIOEventLoopSourceHandler(handler));
+
+    if ( !m_dispatcher->RegisterFD(fd, fdioHandler.get(), flags) )
+        return NULL;
+
+    return new wxUnixEventLoopSource(m_dispatcher, fdioHandler.release(),
+                                     fd, handler, flags);
+}
+
+wxUnixEventLoopSource::~wxUnixEventLoopSource()
+{
+    wxLogTrace(wxTRACE_EVT_SOURCE,
+               "Removing event loop source for fd=%d", m_fd);
+
+    m_dispatcher->UnregisterFD(m_fd);
+
+    delete m_fdioHandler;
+}
+
+#endif // wxUSE_EVENTLOOP_SOURCE
+
 //-----------------------------------------------------------------------------
 // events dispatch and loop handling
 //-----------------------------------------------------------------------------
@@ -161,7 +278,8 @@ bool wxConsoleEventLoop::Pending() const
 
 bool wxConsoleEventLoop::Dispatch()
 {
-    DispatchTimeout(wxFDIODispatcher::TIMEOUT_INFINITE);
+    DispatchTimeout(static_cast<unsigned long>(
+        wxFDIODispatcher::TIMEOUT_INFINITE));
 
     return true;
 }
@@ -191,7 +309,7 @@ int wxConsoleEventLoop::DispatchTimeout(unsigned long timeout)
 
 void wxConsoleEventLoop::WakeUp()
 {
-    m_wakeupPipe.WakeUp();
+    m_wakeupPipe->WakeUp();
 }
 
 void wxConsoleEventLoop::OnNextIteration()