1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/osx/core/evtloop_cf.cpp
3 // Purpose: wxEventLoop implementation common to both Carbon and Cocoa
4 // Author: Vadim Zeitlin
7 // Copyright: (c) 2009 Vadim Zeitlin <vadim@wxwidgets.org>
8 // Licence: wxWindows licence
9 ///////////////////////////////////////////////////////////////////////////////
11 // ============================================================================
13 // ============================================================================
15 // ----------------------------------------------------------------------------
17 // ----------------------------------------------------------------------------
19 // for compilers that support precompilation, includes "wx.h".
20 #include "wx/wxprec.h"
26 #include "wx/evtloop.h"
28 #if wxUSE_EVENTLOOP_SOURCE
35 #include "wx/evtloopsrc.h"
37 #include "wx/scopedptr.h"
39 #include "wx/osx/private.h"
40 #include "wx/osx/core/cfref.h"
41 #include "wx/thread.h"
44 #include "wx/nonownedwnd.h"
47 // ============================================================================
48 // wxCFEventLoopSource and wxCFEventLoop implementation
49 // ============================================================================
54 void EnableDescriptorCallBacks(CFFileDescriptorRef cffd
, int flags
)
56 if ( flags
& wxEVENT_SOURCE_INPUT
)
57 CFFileDescriptorEnableCallBacks(cffd
, kCFFileDescriptorReadCallBack
);
58 if ( flags
& wxEVENT_SOURCE_OUTPUT
)
59 CFFileDescriptorEnableCallBacks(cffd
, kCFFileDescriptorWriteCallBack
);
63 wx_cffiledescriptor_callback(CFFileDescriptorRef cffd
,
67 wxLogTrace(wxTRACE_EVT_SOURCE
,
68 "CFFileDescriptor callback, flags=%d", flags
);
70 wxCFEventLoopSource
* const
71 source
= static_cast<wxCFEventLoopSource
*>(ctxData
);
73 wxEventLoopSourceHandler
* const
74 handler
= source
->GetHandler();
75 if ( flags
& kCFFileDescriptorReadCallBack
)
76 handler
->OnReadWaiting();
77 if ( flags
& kCFFileDescriptorWriteCallBack
)
78 handler
->OnWriteWaiting();
80 // we need to re-enable callbacks to be called again
81 EnableDescriptorCallBacks(cffd
, source
->GetFlags());
84 } // anonymous namespace
87 wxCFEventLoop
::AddSourceForFD(int fd
,
88 wxEventLoopSourceHandler
*handler
,
91 wxCHECK_MSG( fd
!= -1, NULL
, "can't monitor invalid fd" );
93 wxScopedPtr
<wxCFEventLoopSource
>
94 source(new wxCFEventLoopSource(handler
, flags
));
96 CFFileDescriptorContext ctx
= { 0, source
.get(), NULL
, NULL
, NULL
};
97 wxCFRef
<CFFileDescriptorRef
>
98 cffd(CFFileDescriptorCreate
102 true, // close on invalidate
103 wx_cffiledescriptor_callback
,
109 wxCFRef
<CFRunLoopSourceRef
>
110 cfsrc(CFFileDescriptorCreateRunLoopSource(kCFAllocatorDefault
, cffd
, 0));
114 CFRunLoopRef cfloop
= CFGetCurrentRunLoop();
115 CFRunLoopAddSource(cfloop
, cfsrc
, kCFRunLoopDefaultMode
);
117 // Enable the callbacks initially.
118 EnableDescriptorCallBacks(cffd
, source
->GetFlags());
120 source
->SetFileDescriptor(cffd
.release());
122 return source
.release();
125 void wxCFEventLoopSource
::SetFileDescriptor(CFFileDescriptorRef cffd
)
127 wxASSERT_MSG( !m_cffd
, "shouldn't be called more than once" );
132 wxCFEventLoopSource
::~wxCFEventLoopSource()
138 #endif // wxUSE_EVENTLOOP_SOURCE
140 void wxCFEventLoop
::OSXCommonModeObserverCallBack(CFRunLoopObserverRef observer
, int activity
, void *info
)
142 wxCFEventLoop
* eventloop
= static_cast<wxCFEventLoop
*>(info
);
144 eventloop
->CommonModeObserverCallBack(observer
, activity
);
147 void wxCFEventLoop
::OSXDefaultModeObserverCallBack(CFRunLoopObserverRef observer
, int activity
, void *info
)
149 wxCFEventLoop
* eventloop
= static_cast<wxCFEventLoop
*>(info
);
151 eventloop
->DefaultModeObserverCallBack(observer
, activity
);
154 void wxCFEventLoop
::CommonModeObserverCallBack(CFRunLoopObserverRef
WXUNUSED(observer
), int activity
)
156 if ( activity
& kCFRunLoopBeforeTimers
)
158 // process pending wx events first as they correspond to low-level events
159 // which happened before, i.e. typically pending events were queued by a
160 // previous call to Dispatch() and if we didn't process them now the next
161 // call to it might enqueue them again (as happens with e.g. socket events
162 // which would be generated as long as there is input available on socket
163 // and this input is only removed from it when pending event handlers are
167 wxTheApp
->ProcessPendingEvents();
170 if ( activity
& kCFRunLoopBeforeWaiting
)
179 wxMutexGuiLeaveOrEnter();
186 wxCFEventLoop
::DefaultModeObserverCallBack(CFRunLoopObserverRef
WXUNUSED(observer
),
187 int WXUNUSED(activity
))
190 if ( activity & kCFRunLoopBeforeTimers )
194 if ( activity & kCFRunLoopBeforeWaiting )
201 wxCFEventLoop
::wxCFEventLoop()
203 m_shouldExit
= false;
205 m_runLoop
= CFGetCurrentRunLoop();
207 CFRunLoopObserverContext ctxt
;
208 bzero( &ctxt
, sizeof(ctxt
) );
210 m_commonModeRunLoopObserver
= CFRunLoopObserverCreate( kCFAllocatorDefault
, kCFRunLoopBeforeTimers
| kCFRunLoopBeforeWaiting
, true /* repeats */, 0,
211 (CFRunLoopObserverCallBack
) wxCFEventLoop
::OSXCommonModeObserverCallBack
, &ctxt
);
212 CFRunLoopAddObserver(m_runLoop
, m_commonModeRunLoopObserver
, kCFRunLoopCommonModes
);
213 CFRelease(m_commonModeRunLoopObserver
);
215 m_defaultModeRunLoopObserver
= CFRunLoopObserverCreate( kCFAllocatorDefault
, kCFRunLoopBeforeTimers
| kCFRunLoopBeforeWaiting
, true /* repeats */, 0,
216 (CFRunLoopObserverCallBack
) wxCFEventLoop
::OSXDefaultModeObserverCallBack
, &ctxt
);
217 CFRunLoopAddObserver(m_runLoop
, m_defaultModeRunLoopObserver
, kCFRunLoopDefaultMode
);
218 CFRelease(m_defaultModeRunLoopObserver
);
221 wxCFEventLoop
::~wxCFEventLoop()
223 CFRunLoopRemoveObserver(m_runLoop
, m_commonModeRunLoopObserver
, kCFRunLoopCommonModes
);
224 CFRunLoopRemoveObserver(m_runLoop
, m_defaultModeRunLoopObserver
, kCFRunLoopDefaultMode
);
228 CFRunLoopRef wxCFEventLoop
::CFGetCurrentRunLoop() const
230 return CFRunLoopGetCurrent();
233 void wxCFEventLoop
::WakeUp()
235 CFRunLoopWakeUp(m_runLoop
);
242 wxEventLoopBase
* const loop
= wxEventLoopBase
::GetActive();
250 bool wxCFEventLoop
::YieldFor(long eventsToProcess
)
253 // Yielding from a non-gui thread needs to bail out, otherwise we end up
254 // possibly sending events in the thread too.
255 if ( !wxThread
::IsMain() )
259 #endif // wxUSE_THREADS
261 m_isInsideYield
= true;
262 m_eventsToProcessInsideYield
= eventsToProcess
;
265 // disable log flushing from here because a call to wxYield() shouldn't
266 // normally result in message boxes popping up &c
270 // process all pending events:
271 while ( DoProcessEvents() == 1 )
274 // it's necessary to call ProcessIdle() to update the frames sizes which
275 // might have been changed (it also will update other things set from
276 // OnUpdateUI() which is a nice (and desired) side effect)
277 while ( ProcessIdle() ) {}
279 // if there are pending events, we must process them.
281 wxTheApp
->ProcessPendingEvents();
286 m_isInsideYield
= false;
291 // implement/override base class pure virtual
292 bool wxCFEventLoop
::Pending() const
297 int wxCFEventLoop
::DoProcessEvents()
299 return DispatchTimeout( 0 );
302 bool wxCFEventLoop
::Dispatch()
304 return DoProcessEvents() != 0;
307 int wxCFEventLoop
::DispatchTimeout(unsigned long timeout
)
312 int status
= DoDispatchTimeout(timeout
);
330 int wxCFEventLoop
::DoDispatchTimeout(unsigned long timeout
)
332 SInt32 status
= CFRunLoopRunInMode(kCFRunLoopDefaultMode
, timeout
/ 1000.0 , true);
335 case kCFRunLoopRunFinished
:
336 wxFAIL_MSG( "incorrect run loop state" );
338 case kCFRunLoopRunStopped
:
341 case kCFRunLoopRunTimedOut
:
344 case kCFRunLoopRunHandledSource
:
351 void wxCFEventLoop
::DoRun()
355 // generate and process idle events for as long as we don't
356 // have anything else to do
359 // if the "should exit" flag is set, the loop should terminate
360 // but not before processing any remaining messages so while
361 // Pending() returns true, do process them
364 while ( DoProcessEvents() == 1 )
372 void wxCFEventLoop
::DoStop()
374 CFRunLoopStop(CFGetCurrentRunLoop());
377 // enters a loop calling OnNextIteration(), Pending() and Dispatch() and
378 // terminating when Exit() is called
379 int wxCFEventLoop
::Run()
381 // event loops are not recursive, you need to create another loop!
382 wxCHECK_MSG( !IsRunning(), -1, wxT("can't reenter a message loop") );
384 // ProcessIdle() and ProcessEvents() below may throw so the code here should
385 // be exception-safe, hence we must use local objects for all actions we
387 wxEventLoopActivator
activate(this);
389 // we must ensure that OnExit() is called even if an exception is thrown
390 // from inside ProcessEvents() but we must call it from Exit() in normal
391 // situations because it is supposed to be called synchronously,
392 // wxModalEventLoop depends on this (so we can't just use ON_BLOCK_EXIT or
393 // something similar here)
399 #endif // wxUSE_EXCEPTIONS
404 // exit the outer loop as well
411 if ( !wxTheApp
|| !wxTheApp
->OnExceptionInMainLoop() )
416 //else: continue running the event loop
420 // OnException() throwed, possibly rethrowing the same
421 // exception again: very good, but we still need OnExit() to
428 #endif // wxUSE_EXCEPTIONS
433 // sets the "should exit" flag and wakes up the loop so that it terminates
435 void wxCFEventLoop
::Exit(int rc
)
442 // TODO Move to thread_osx.cpp
446 // ----------------------------------------------------------------------------
447 // GUI Serialization copied from MSW implementation
448 // ----------------------------------------------------------------------------
450 // if it's false, some secondary thread is holding the GUI lock
451 static bool gs_bGuiOwnedByMainThread
= true;
453 // critical section which controls access to all GUI functions: any secondary
454 // thread (i.e. except the main one) must enter this crit section before doing
456 static wxCriticalSection
*gs_critsectGui
= NULL
;
458 // critical section which protects gs_nWaitingForGui variable
459 static wxCriticalSection
*gs_critsectWaitingForGui
= NULL
;
461 // number of threads waiting for GUI in wxMutexGuiEnter()
462 static size_t gs_nWaitingForGui
= 0;
464 void wxOSXThreadModuleOnInit()
466 gs_critsectWaitingForGui
= new wxCriticalSection();
467 gs_critsectGui
= new wxCriticalSection();
468 gs_critsectGui
->Enter();
472 void wxOSXThreadModuleOnExit()
474 if ( gs_critsectGui
)
476 if ( !wxGuiOwnedByMainThread() )
478 gs_critsectGui
->Enter();
479 gs_bGuiOwnedByMainThread
= true;
482 gs_critsectGui
->Leave();
483 wxDELETE(gs_critsectGui
);
486 wxDELETE(gs_critsectWaitingForGui
);
490 // wake up the main thread
491 void WXDLLIMPEXP_BASE
wxWakeUpMainThread()
496 void wxMutexGuiEnterImpl()
498 // this would dead lock everything...
499 wxASSERT_MSG( !wxThread
::IsMain(),
500 wxT("main thread doesn't want to block in wxMutexGuiEnter()!") );
502 // the order in which we enter the critical sections here is crucial!!
504 // set the flag telling to the main thread that we want to do some GUI
506 wxCriticalSectionLocker
enter(*gs_critsectWaitingForGui
);
511 wxWakeUpMainThread();
513 // now we may block here because the main thread will soon let us in
514 // (during the next iteration of OnIdle())
515 gs_critsectGui
->Enter();
518 void wxMutexGuiLeaveImpl()
520 wxCriticalSectionLocker
enter(*gs_critsectWaitingForGui
);
522 if ( wxThread
::IsMain() )
524 gs_bGuiOwnedByMainThread
= false;
528 // decrement the number of threads waiting for GUI access now
529 wxASSERT_MSG( gs_nWaitingForGui
> 0,
530 wxT("calling wxMutexGuiLeave() without entering it first?") );
534 wxWakeUpMainThread();
537 gs_critsectGui
->Leave();
540 void WXDLLIMPEXP_BASE
wxMutexGuiLeaveOrEnter()
542 wxASSERT_MSG( wxThread
::IsMain(),
543 wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
545 if ( !gs_critsectWaitingForGui
)
548 wxCriticalSectionLocker
enter(*gs_critsectWaitingForGui
);
550 if ( gs_nWaitingForGui
== 0 )
552 // no threads are waiting for GUI - so we may acquire the lock without
553 // any danger (but only if we don't already have it)
554 if ( !wxGuiOwnedByMainThread() )
556 gs_critsectGui
->Enter();
558 gs_bGuiOwnedByMainThread
= true;
560 //else: already have it, nothing to do
564 // some threads are waiting, release the GUI lock if we have it
565 if ( wxGuiOwnedByMainThread() )
567 //else: some other worker thread is doing GUI
571 bool WXDLLIMPEXP_BASE
wxGuiOwnedByMainThread()
573 return gs_bGuiOwnedByMainThread
;