#include "wx/osx/private.h"
#include "wx/osx/core/cfref.h"
+#include "wx/thread.h"
+
+#if wxUSE_GUI
+ #include "wx/nonownedwnd.h"
+#endif
// ============================================================================
// wxCFEventLoopSource and wxCFEventLoop implementation
if ( !cffd )
return NULL;
- source->SetFileDescriptor(cffd.release());
-
wxCFRef<CFRunLoopSourceRef>
cfsrc(CFFileDescriptorCreateRunLoopSource(kCFAllocatorDefault, cffd, 0));
if ( !cfsrc )
CFRunLoopRef cfloop = CFGetCurrentRunLoop();
CFRunLoopAddSource(cfloop, cfsrc, kCFRunLoopDefaultMode);
+ // Enable the callbacks initially.
+ EnableDescriptorCallBacks(cffd, source->GetFlags());
+
+ source->SetFileDescriptor(cffd.release());
+
return source.release();
}
#endif // wxUSE_EVENTLOOP_SOURCE
-void wxObserverCallBack(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info)
+void wxCFEventLoop::OSXCommonModeObserverCallBack(CFRunLoopObserverRef observer, int activity, void *info)
{
wxCFEventLoop * eventloop = static_cast<wxCFEventLoop *>(info);
if ( eventloop )
- eventloop->ObserverCallBack(observer, activity);
-}
+ 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::ObserverCallBack(CFRunLoopObserverRef observer, int activity)
+void wxCFEventLoop::CommonModeObserverCallBack(CFRunLoopObserverRef WXUNUSED(observer), int activity)
{
if ( activity & kCFRunLoopBeforeTimers )
{
if ( wxTheApp )
wxTheApp->ProcessPendingEvents();
}
-
+
if ( activity & kCFRunLoopBeforeWaiting )
{
if ( ProcessIdle() )
else
{
#if wxUSE_THREADS
- wxMutexGuiLeave();
- wxMilliSleep(20);
- wxMutexGuiEnter();
+ wxMutexGuiLeaveOrEnter();
#endif
}
}
}
+void
+wxCFEventLoop::DefaultModeObserverCallBack(CFRunLoopObserverRef WXUNUSED(observer),
+ int WXUNUSED(activity))
+{
+ /*
+ if ( activity & kCFRunLoopBeforeTimers )
+ {
+ }
+
+ if ( activity & kCFRunLoopBeforeWaiting )
+ {
+ }
+ */
+}
+
+
wxCFEventLoop::wxCFEventLoop()
{
m_shouldExit = false;
-
+
m_runLoop = CFGetCurrentRunLoop();
-
+
CFRunLoopObserverContext ctxt;
bzero( &ctxt, sizeof(ctxt) );
ctxt.info = this;
- m_runLoopObserver = CFRunLoopObserverCreate( kCFAllocatorDefault, kCFRunLoopBeforeTimers | kCFRunLoopBeforeWaiting , true /* repeats */, 0,
- wxObserverCallBack, &ctxt );
- CFRunLoopAddObserver(m_runLoop, m_runLoopObserver, kCFRunLoopDefaultMode);
+ m_commonModeRunLoopObserver = CFRunLoopObserverCreate( kCFAllocatorDefault, kCFRunLoopBeforeTimers | kCFRunLoopBeforeWaiting , true /* repeats */, 0,
+ (CFRunLoopObserverCallBack) wxCFEventLoop::OSXCommonModeObserverCallBack, &ctxt );
+ CFRunLoopAddObserver(m_runLoop, m_commonModeRunLoopObserver, kCFRunLoopCommonModes);
+ CFRelease(m_commonModeRunLoopObserver);
+
+ m_defaultModeRunLoopObserver = CFRunLoopObserverCreate( kCFAllocatorDefault, kCFRunLoopBeforeTimers | kCFRunLoopBeforeWaiting , true /* repeats */, 0,
+ (CFRunLoopObserverCallBack) wxCFEventLoop::OSXDefaultModeObserverCallBack, &ctxt );
+ CFRunLoopAddObserver(m_runLoop, m_defaultModeRunLoopObserver, kCFRunLoopDefaultMode);
+ CFRelease(m_defaultModeRunLoopObserver);
}
wxCFEventLoop::~wxCFEventLoop()
{
- CFRunLoopRemoveObserver(m_runLoop, m_runLoopObserver, kCFRunLoopDefaultMode);
+ CFRunLoopRemoveObserver(m_runLoop, m_commonModeRunLoopObserver, kCFRunLoopCommonModes);
+ CFRunLoopRemoveObserver(m_runLoop, m_defaultModeRunLoopObserver, kCFRunLoopDefaultMode);
}
-
+
CFRunLoopRef wxCFEventLoop::CFGetCurrentRunLoop() const
{
void wxCFEventLoop::WakeUp()
{
- extern void wxMacWakeUp();
-
- wxMacWakeUp();
+ CFRunLoopWakeUp(m_runLoop);
+}
+
+#if wxUSE_BASE
+
+void wxMacWakeUp()
+{
+ wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
+
+ if ( loop )
+ loop->WakeUp();
}
+#endif
+
bool wxCFEventLoop::YieldFor(long eventsToProcess)
{
#if wxUSE_THREADS
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;
}
int wxCFEventLoop::DoProcessEvents()
{
- return DispatchTimeout( 1000 );
+ return DispatchTimeout( 0 );
}
bool wxCFEventLoop::Dispatch()
return 0;
int status = DoDispatchTimeout(timeout);
-
+
switch( status )
{
case 0:
case -1:
if ( m_shouldExit )
return 0;
-
+
break;
case 1:
break;
}
-
+
return status;
}
int wxCFEventLoop::DoDispatchTimeout(unsigned long timeout)
-{
+{
SInt32 status = CFRunLoopRunInMode(kCFRunLoopDefaultMode, timeout / 1000.0 , true);
switch( status )
{
// 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
{
while ( DoProcessEvents() == 1 )
;
-
+
break;
}
}
{
// event loops are not recursive, you need to create another loop!
wxCHECK_MSG( !IsRunning(), -1, wxT("can't reenter a message loop") );
-
+
// ProcessIdle() and ProcessEvents() below may throw so the code here should
// be exception-safe, hence we must use local objects for all actions we
// should undo
wxEventLoopActivator activate(this);
-
+
// 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,
try
{
#endif // wxUSE_EXCEPTIONS
-
+
DoRun();
-
+
#if wxUSE_EXCEPTIONS
// exit the outer loop as well
break;
}
}
#endif // wxUSE_EXCEPTIONS
-
+
return m_exitcode;
}
DoStop();
}
-#if wxUSE_GUI
+// 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);
+}
-wxModalEventLoop::wxModalEventLoop(wxWindow *winModal)
+
+// wake up the main thread
+void WXDLLIMPEXP_BASE wxWakeUpMainThread()
{
- m_modalWindow = dynamic_cast<wxNonOwnedWindow*> (winModal);
- wxASSERT_MSG( m_modalWindow != NULL, "must pass in a toplevel window for modal event loop" );
+ wxMacWakeUp();
}
-#ifdef __WXOSX_IPHONE__
+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 wxModalEventLoop::DoRun()
+void wxMutexGuiLeaveImpl()
{
- // presentModalViewController:animated:
+ 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 wxModalEventLoop::DoStop()
+void WXDLLIMPEXP_BASE wxMutexGuiLeaveOrEnter()
{
- // (void)dismissModalViewControllerAnimated:(BOOL)animated
+ 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
+ }
}
-#endif // wxUSE_GUI
+bool WXDLLIMPEXP_BASE wxGuiOwnedByMainThread()
+{
+ return gs_bGuiOwnedByMainThread;
+}
#endif
projects / wxWidgets.git / blobdiff