// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
+#if wxUSE_CONSOLE_EVENTLOOP
+
#include "wx/evtloop.h"
#ifndef WX_PRECOMP
#endif
#include <errno.h>
+#include "wx/apptrait.h"
+#include "wx/scopedptr.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")
+#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() : m_pipeIsEmpty(true) { }
+
+ 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;
+
+ // Protects access to m_pipeIsEmpty.
+ wxCriticalSection m_pipeLock;
+
+ // This flag is set to true after writing to the pipe and reset to false
+ // after reading from it in the main thread. Having it allows us to avoid
+ // overflowing the pipe with too many writes if the main thread can't keep
+ // up with reading from it.
+ bool m_pipeIsEmpty;
+};
+
// ----------------------------------------------------------------------------
// initialization
// ----------------------------------------------------------------------------
-bool wxConsoleEventLoop::PipeIOHandler::Create()
+bool PipeIOHandler::Create()
{
if ( !m_pipe.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;
}
// wakeup handling
// ----------------------------------------------------------------------------
-void wxConsoleEventLoop::PipeIOHandler::WakeUp()
+void PipeIOHandler::WakeUp()
{
+ wxCriticalSectionLocker lock(m_pipeLock);
+
+ // No need to do anything if the pipe already contains something.
+ if ( !m_pipeIsEmpty )
+ return;
+
if ( write(m_pipe[wxPipe::Write], "s", 1) != 1 )
{
// don't use wxLog here, we can be in another thread and this could
// result in dead locks
perror("write(wake up pipe)");
}
+ else
+ {
+ // We just wrote to it, so it's not empty any more.
+ m_pipeIsEmpty = false;
+ }
}
-void wxConsoleEventLoop::PipeIOHandler::OnReadWaiting()
+void PipeIOHandler::OnReadWaiting()
{
- // 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(),
- // it could have been called several times)
+ // got wakeup from child thread, remove the data that provoked it from the
+ // pipe
+
+ wxCriticalSectionLocker lock(m_pipeLock);
+
char buf[4];
for ( ;; )
{
const int size = read(GetReadFd(), buf, WXSIZEOF(buf));
- if ( size == 0 || (size == -1 && errno == EAGAIN) )
+ if ( size > 0 )
{
- // nothing left in the pipe (EAGAIN is expected for an FD with
- // O_NONBLOCK)
+ wxASSERT_MSG( size == 1, "Too many writes to wake-up pipe?" );
+
break;
}
- if ( size == -1 )
+ if ( size == 0 || (size == -1 && errno == EAGAIN) )
{
- wxLogSysError(_("Failed to read from wake-up pipe"));
-
+ // No data available, not an error (but still surprising,
+ // spurious wakeup?)
break;
}
+
+ if ( errno == EINTR )
+ {
+ // We were interrupted, try again.
+ continue;
+ }
+
+ wxLogSysError(_("Failed to read from wake-up pipe"));
+
+ return;
}
- wxTheApp->ProcessPendingEvents();
+ // The pipe is empty now, so future calls to WakeUp() would need to write
+ // to it again.
+ m_pipeIsEmpty = true;
+
+ // 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
// ===========================================================================
wxConsoleEventLoop::wxConsoleEventLoop()
{
- if ( !m_wakeupPipe.Create() )
+ m_wakeupPipe = new wxPrivate::PipeIOHandler();
+ if ( !m_wakeupPipe->Create() )
{
+ wxDELETE(m_wakeupPipe);
m_dispatcher = NULL;
return;
}
-#ifdef HAVE_SYS_EPOLL_H
- m_dispatcher = wxEpollDispatcher::Get();
+ m_dispatcher = wxFDIODispatcher::Get();
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_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
//-----------------------------------------------------------------------------
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()
{
- wxTheApp->ProcessPendingEvents();
+ DispatchTimeout(static_cast<unsigned long>(
+ wxFDIODispatcher::TIMEOUT_INFINITE));
+
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
+ // check if we need to decrease the timeout to account for a timer
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
- {
- timeout = wxFDIODispatcher::TIMEOUT_INFINITE;
- }
- m_dispatcher->RunLoop(timeout);
+ bool hadEvent = m_dispatcher->Dispatch(timeout) > 0;
#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();
}
+
+wxEventLoopBase *wxConsoleAppTraits::CreateEventLoop()
+{
+ return new wxEventLoop();
+}
+
+#endif // wxUSE_CONSOLE_EVENTLOOP
projects / wxWidgets.git / blobdiff