// Purpose: wxEventLoop implementation common to both Carbon and Cocoa
// Author: Vadim Zeitlin
// Created: 2009-10-18
-// RCS-ID: $Id: wxhead.cpp,v 1.10 2009-06-29 10:23:04 zeitlin Exp $
+// RCS-ID: $Id$
// Copyright: (c) 2009 Vadim Zeitlin <vadim@wxwidgets.org>
+// (c) 2013 Rob Bresalier
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#include "wx/evtloop.h"
-#if wxUSE_EVENTLOOP_SOURCE
-
#ifndef WX_PRECOMP
#include "wx/log.h"
+ #include "wx/app.h"
#endif
#include "wx/evtloopsrc.h"
#include "wx/osx/private.h"
#include "wx/osx/core/cfref.h"
+#include "wx/thread.h"
+
+#if wxUSE_GUI
+ #include "wx/nonownedwnd.h"
+#endif
+
+#include <CoreFoundation/CFSocket.h>
// ============================================================================
// wxCFEventLoopSource and wxCFEventLoop implementation
// ============================================================================
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
-namespace
+#if wxUSE_EVENTLOOP_SOURCE
+
+void wxCFEventLoopSource::InitSourceSocket(CFSocketRef cfSocket)
{
+ wxASSERT_MSG( !m_cfSocket, "shouldn't be called more than once" );
-void EnableDescriptorCallBacks(CFFileDescriptorRef cffd, int flags)
+ m_cfSocket = cfSocket;
+}
+
+wxCFEventLoopSource::~wxCFEventLoopSource()
{
- if ( flags & wxEVENT_SOURCE_INPUT )
- CFFileDescriptorEnableCallBacks(cffd, kCFFileDescriptorReadCallBack);
- if ( flags & wxEVENT_SOURCE_OUTPUT )
- CFFileDescriptorEnableCallBacks(cffd, kCFFileDescriptorWriteCallBack);
+ if ( m_cfSocket )
+ {
+ CFSocketInvalidate(m_cfSocket);
+ CFRelease(m_cfSocket);
+ }
+}
+
+#endif // wxUSE_EVENTLOOP_SOURCE
+
+void wxCFEventLoop::OSXCommonModeObserverCallBack(CFRunLoopObserverRef observer, int activity, void *info)
+{
+ wxCFEventLoop * eventloop = static_cast<wxCFEventLoop *>(info);
+ if ( eventloop )
+ eventloop->CommonModeObserverCallBack(observer, activity);
+}
+
+void wxCFEventLoop::OSXDefaultModeObserverCallBack(CFRunLoopObserverRef observer, int activity, void *info)
+{
+ wxCFEventLoop * eventloop = static_cast<wxCFEventLoop *>(info);
+ if ( eventloop )
+ eventloop->DefaultModeObserverCallBack(observer, activity);
+}
+
+void wxCFEventLoop::CommonModeObserverCallBack(CFRunLoopObserverRef WXUNUSED(observer), int activity)
+{
+ if ( activity & kCFRunLoopBeforeTimers )
+ {
+ // process pending wx events first as they correspond to low-level events
+ // which happened before, i.e. typically pending events were queued by a
+ // previous call to Dispatch() and if we didn't process them now the next
+ // call to it might enqueue them again (as happens with e.g. socket events
+ // which would be generated as long as there is input available on socket
+ // and this input is only removed from it when pending event handlers are
+ // executed)
+
+ if ( wxTheApp && ShouldProcessIdleEvents() )
+ wxTheApp->ProcessPendingEvents();
+ }
+
+ if ( activity & kCFRunLoopBeforeWaiting )
+ {
+ if ( ShouldProcessIdleEvents() && ProcessIdle() )
+ {
+ WakeUp();
+ }
+ else
+ {
+#if wxUSE_THREADS
+ wxMutexGuiLeaveOrEnter();
+#endif
+ }
+ }
}
void
-wx_cffiledescriptor_callback(CFFileDescriptorRef cffd,
- CFOptionFlags flags,
- void *ctxData)
+wxCFEventLoop::DefaultModeObserverCallBack(CFRunLoopObserverRef WXUNUSED(observer),
+ int WXUNUSED(activity))
{
- wxLogTrace(wxTRACE_EVT_SOURCE,
- "CFFileDescriptor callback, flags=%d", flags);
+ /*
+ if ( activity & kCFRunLoopBeforeTimers )
+ {
+ }
+
+ if ( activity & kCFRunLoopBeforeWaiting )
+ {
+ }
+ */
+}
- wxCFEventLoopSource * const
- source = static_cast<wxCFEventLoopSource *>(ctxData);
- wxEventLoopSourceHandler * const
- handler = source->GetHandler();
- if ( flags & kCFFileDescriptorReadCallBack )
- handler->OnReadWaiting();
- if ( flags & kCFFileDescriptorWriteCallBack )
- handler->OnWriteWaiting();
+wxCFEventLoop::wxCFEventLoop()
+{
+ m_shouldExit = false;
+ m_processIdleEvents = true;
- // we need to re-enable callbacks to be called again
- EnableDescriptorCallBacks(cffd, source->GetFlags());
+#if wxUSE_UIACTIONSIMULATOR
+ m_shouldWaitForEvent = false;
+#endif
+
+ m_runLoop = CFGetCurrentRunLoop();
+
+ CFRunLoopObserverContext ctxt;
+ bzero( &ctxt, sizeof(ctxt) );
+ ctxt.info = this;
+ m_commonModeRunLoopObserver = CFRunLoopObserverCreate( kCFAllocatorDefault, kCFRunLoopBeforeTimers | kCFRunLoopBeforeWaiting , true /* repeats */, 0,
+ (CFRunLoopObserverCallBack) wxCFEventLoop::OSXCommonModeObserverCallBack, &ctxt );
+ CFRunLoopAddObserver(m_runLoop, m_commonModeRunLoopObserver, kCFRunLoopCommonModes);
+
+ m_defaultModeRunLoopObserver = CFRunLoopObserverCreate( kCFAllocatorDefault, kCFRunLoopBeforeTimers | kCFRunLoopBeforeWaiting , true /* repeats */, 0,
+ (CFRunLoopObserverCallBack) wxCFEventLoop::OSXDefaultModeObserverCallBack, &ctxt );
+ CFRunLoopAddObserver(m_runLoop, m_defaultModeRunLoopObserver, kCFRunLoopDefaultMode);
}
-} // anonymous namespace
+wxCFEventLoop::~wxCFEventLoop()
+{
+ CFRunLoopRemoveObserver(m_runLoop, m_commonModeRunLoopObserver, kCFRunLoopCommonModes);
+ CFRunLoopRemoveObserver(m_runLoop, m_defaultModeRunLoopObserver, kCFRunLoopDefaultMode);
-wxEventLoopSource *
-wxCFEventLoop::AddSourceForFD(int fd,
- wxEventLoopSourceHandler *handler,
- int flags)
+ CFRelease(m_defaultModeRunLoopObserver);
+ CFRelease(m_commonModeRunLoopObserver);
+}
+
+
+CFRunLoopRef wxCFEventLoop::CFGetCurrentRunLoop() const
{
- wxCHECK_MSG( fd != -1, NULL, "can't monitor invalid fd" );
+ return CFRunLoopGetCurrent();
+}
- wxScopedPtr<wxCFEventLoopSource>
- source(new wxCFEventLoopSource(handler, flags));
+void wxCFEventLoop::WakeUp()
+{
+ CFRunLoopWakeUp(m_runLoop);
+}
- CFFileDescriptorContext ctx = { 0, source.get(), NULL, NULL, NULL };
- wxCFRef<CFFileDescriptorRef>
- cffd(CFFileDescriptorCreate
- (
- kCFAllocatorDefault,
- fd,
- true, // close on invalidate
- wx_cffiledescriptor_callback,
- &ctx
- ));
- if ( !cffd )
- return NULL;
+#if wxUSE_BASE
- source->SetFileDescriptor(cffd.release());
+void wxMacWakeUp()
+{
+ wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
- wxCFRef<CFRunLoopSourceRef>
- cfsrc(CFFileDescriptorCreateRunLoopSource(kCFAllocatorDefault, cffd, 0));
- if ( !cfsrc )
- return NULL;
+ if ( loop )
+ loop->WakeUp();
+}
- CFRunLoopRef cfloop = CFGetCurrentRunLoop();
- CFRunLoopAddSource(cfloop, cfsrc, kCFRunLoopDefaultMode);
+#endif
- return source.release();
+bool wxCFEventLoop::YieldFor(long eventsToProcess)
+{
+#if wxUSE_THREADS
+ // Yielding from a non-gui thread needs to bail out, otherwise we end up
+ // possibly sending events in the thread too.
+ if ( !wxThread::IsMain() )
+ {
+ return true;
+ }
+#endif // wxUSE_THREADS
+
+ m_isInsideYield = true;
+ m_eventsToProcessInsideYield = eventsToProcess;
+
+#if wxUSE_LOG
+ // disable log flushing from here because a call to wxYield() shouldn't
+ // normally result in message boxes popping up &c
+ wxLog::Suspend();
+#endif // wxUSE_LOG
+
+ // process all pending events:
+ while ( DoProcessEvents() == 1 )
+ ;
+
+ // it's necessary to call ProcessIdle() to update the frames sizes which
+ // might have been changed (it also will update other things set from
+ // OnUpdateUI() which is a nice (and desired) side effect)
+ while ( ProcessIdle() ) {}
+
+ // if there are pending events, we must process them.
+ if (wxTheApp)
+ wxTheApp->ProcessPendingEvents();
+
+#if wxUSE_LOG
+ wxLog::Resume();
+#endif // wxUSE_LOG
+ m_isInsideYield = false;
+
+ return true;
}
-void wxCFEventLoopSource::SetFileDescriptor(CFFileDescriptorRef cffd)
+// implement/override base class pure virtual
+bool wxCFEventLoop::Pending() const
{
- wxASSERT_MSG( !m_cffd, "shouldn't be called more than once" );
+ return true;
+}
- m_cffd = cffd;
+int wxCFEventLoop::DoProcessEvents()
+{
+#if wxUSE_UIACTIONSIMULATOR
+ if ( m_shouldWaitForEvent )
+ {
+ int handled = DispatchTimeout( 1000 );
+ wxASSERT_MSG( handled == 1, "No Event Available");
+ m_shouldWaitForEvent = false;
+ return handled;
+ }
+ else
+#endif
+ return DispatchTimeout( 0 );
}
-wxCFEventLoopSource::~wxCFEventLoopSource()
+bool wxCFEventLoop::Dispatch()
{
- if ( m_cffd )
- CFRelease(m_cffd);
+ return DoProcessEvents() != 0;
}
-#else // OS X < 10.5
+int wxCFEventLoop::DispatchTimeout(unsigned long timeout)
+{
+ if ( !wxTheApp )
+ return 0;
+
+ int status = DoDispatchTimeout(timeout);
+
+ switch( status )
+ {
+ case 0:
+ break;
+ case -1:
+ if ( m_shouldExit )
+ return 0;
+
+ break;
+ case 1:
+ break;
+ }
-wxEventLoopSource *
-wxCFEventLoop::AddSourceForFD(int WXUNUSED(fd),
- wxEventLoopSourceHandler * WXUNUSED(handler),
- int WXUNUSED(flags))
+ return status;
+}
+
+int wxCFEventLoop::DoDispatchTimeout(unsigned long timeout)
{
- return NULL;
+ SInt32 status = CFRunLoopRunInMode(kCFRunLoopDefaultMode, timeout / 1000.0 , true);
+ switch( status )
+ {
+ case kCFRunLoopRunFinished:
+ wxFAIL_MSG( "incorrect run loop state" );
+ break;
+ case kCFRunLoopRunStopped:
+ return 0;
+ break;
+ case kCFRunLoopRunTimedOut:
+ return -1;
+ break;
+ case kCFRunLoopRunHandledSource:
+ default:
+ break;
+ }
+ return 1;
}
-#endif // MAC_OS_X_VERSION_MAX_ALLOWED
+void wxCFEventLoop::OSXDoRun()
+{
+ for ( ;; )
+ {
+ // generate and process idle events for as long as we don't
+ // have anything else to do
+ DoProcessEvents();
+
+ // if the "should exit" flag is set, the loop should terminate
+ // but not before processing any remaining messages so while
+ // Pending() returns true, do process them
+ if ( m_shouldExit )
+ {
+ while ( DoProcessEvents() == 1 )
+ ;
+
+ break;
+ }
+ }
+}
-#endif // wxUSE_EVENTLOOP_SOURCE
+void wxCFEventLoop::OSXDoStop()
+{
+ CFRunLoopStop(CFGetCurrentRunLoop());
+}
+
+// enters a loop calling OnNextIteration(), Pending() and Dispatch() and
+// terminating when Exit() is called
+int wxCFEventLoop::DoRun()
+{
+ // we must ensure that OnExit() is called even if an exception is thrown
+ // from inside ProcessEvents() but we must call it from Exit() in normal
+ // situations because it is supposed to be called synchronously,
+ // wxModalEventLoop depends on this (so we can't just use ON_BLOCK_EXIT or
+ // something similar here)
+#if wxUSE_EXCEPTIONS
+ for ( ;; )
+ {
+ try
+ {
+#endif // wxUSE_EXCEPTIONS
+
+ OSXDoRun();
+
+#if wxUSE_EXCEPTIONS
+ // exit the outer loop as well
+ break;
+ }
+ catch ( ... )
+ {
+ try
+ {
+ if ( !wxTheApp || !wxTheApp->OnExceptionInMainLoop() )
+ {
+ OnExit();
+ break;
+ }
+ //else: continue running the event loop
+ }
+ catch ( ... )
+ {
+ // OnException() throwed, possibly rethrowing the same
+ // exception again: very good, but we still need OnExit() to
+ // be called
+ OnExit();
+ throw;
+ }
+ }
+ }
+#endif // wxUSE_EXCEPTIONS
+
+ return m_exitcode;
+}
+
+// sets the "should exit" flag and wakes up the loop so that it terminates
+// soon
+void wxCFEventLoop::ScheduleExit(int rc)
+{
+ m_exitcode = rc;
+ m_shouldExit = true;
+ OSXDoStop();
+}
+
+wxCFEventLoopPauseIdleEvents::wxCFEventLoopPauseIdleEvents()
+{
+ wxCFEventLoop* cfl = dynamic_cast<wxCFEventLoop*>(wxEventLoopBase::GetActive());
+ if ( cfl )
+ {
+ m_formerState = cfl->ShouldProcessIdleEvents();
+ cfl->SetProcessIdleEvents(false);
+ }
+ else
+ m_formerState = true;
+}
+
+wxCFEventLoopPauseIdleEvents::~wxCFEventLoopPauseIdleEvents()
+{
+ wxCFEventLoop* cfl = dynamic_cast<wxCFEventLoop*>(wxEventLoopBase::GetActive());
+ if ( cfl )
+ cfl->SetProcessIdleEvents(m_formerState);
+}
+
+// TODO Move to thread_osx.cpp
+
+#if wxUSE_THREADS
+
+// ----------------------------------------------------------------------------
+// GUI Serialization copied from MSW implementation
+// ----------------------------------------------------------------------------
+
+// if it's false, some secondary thread is holding the GUI lock
+static bool gs_bGuiOwnedByMainThread = true;
+
+// critical section which controls access to all GUI functions: any secondary
+// thread (i.e. except the main one) must enter this crit section before doing
+// any GUI calls
+static wxCriticalSection *gs_critsectGui = NULL;
+
+// critical section which protects gs_nWaitingForGui variable
+static wxCriticalSection *gs_critsectWaitingForGui = NULL;
+
+// number of threads waiting for GUI in wxMutexGuiEnter()
+static size_t gs_nWaitingForGui = 0;
+
+void wxOSXThreadModuleOnInit()
+{
+ gs_critsectWaitingForGui = new wxCriticalSection();
+ gs_critsectGui = new wxCriticalSection();
+ gs_critsectGui->Enter();
+}
+
+
+void wxOSXThreadModuleOnExit()
+{
+ if ( gs_critsectGui )
+ {
+ if ( !wxGuiOwnedByMainThread() )
+ {
+ gs_critsectGui->Enter();
+ gs_bGuiOwnedByMainThread = true;
+ }
+
+ gs_critsectGui->Leave();
+ wxDELETE(gs_critsectGui);
+ }
+
+ wxDELETE(gs_critsectWaitingForGui);
+}
+
+
+// wake up the main thread
+void WXDLLIMPEXP_BASE wxWakeUpMainThread()
+{
+ wxMacWakeUp();
+}
+
+void wxMutexGuiEnterImpl()
+{
+ // this would dead lock everything...
+ wxASSERT_MSG( !wxThread::IsMain(),
+ wxT("main thread doesn't want to block in wxMutexGuiEnter()!") );
+
+ // the order in which we enter the critical sections here is crucial!!
+
+ // set the flag telling to the main thread that we want to do some GUI
+ {
+ wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
+
+ gs_nWaitingForGui++;
+ }
+
+ wxWakeUpMainThread();
+
+ // now we may block here because the main thread will soon let us in
+ // (during the next iteration of OnIdle())
+ gs_critsectGui->Enter();
+}
+
+void wxMutexGuiLeaveImpl()
+{
+ wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
+
+ if ( wxThread::IsMain() )
+ {
+ gs_bGuiOwnedByMainThread = false;
+ }
+ else
+ {
+ // decrement the number of threads waiting for GUI access now
+ wxASSERT_MSG( gs_nWaitingForGui > 0,
+ wxT("calling wxMutexGuiLeave() without entering it first?") );
+
+ gs_nWaitingForGui--;
+
+ wxWakeUpMainThread();
+ }
+
+ gs_critsectGui->Leave();
+}
+
+void WXDLLIMPEXP_BASE wxMutexGuiLeaveOrEnter()
+{
+ wxASSERT_MSG( wxThread::IsMain(),
+ wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
+
+ if ( !gs_critsectWaitingForGui )
+ return;
+
+ wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
+
+ if ( gs_nWaitingForGui == 0 )
+ {
+ // no threads are waiting for GUI - so we may acquire the lock without
+ // any danger (but only if we don't already have it)
+ if ( !wxGuiOwnedByMainThread() )
+ {
+ gs_critsectGui->Enter();
+
+ gs_bGuiOwnedByMainThread = true;
+ }
+ //else: already have it, nothing to do
+ }
+ else
+ {
+ // some threads are waiting, release the GUI lock if we have it
+ if ( wxGuiOwnedByMainThread() )
+ wxMutexGuiLeave();
+ //else: some other worker thread is doing GUI
+ }
+}
+
+bool WXDLLIMPEXP_BASE wxGuiOwnedByMainThread()
+{
+ return gs_bGuiOwnedByMainThread;
+}
+
+#endif
projects / wxWidgets.git / blobdiff