]> git.saurik.com Git - wxWidgets.git/blob - src/osx/core/evtloop_cf.cpp
Applied Blit system options optimization to StretchBlit
[wxWidgets.git] / src / osx / core / evtloop_cf.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/osx/core/evtloop_cf.cpp
3 // Purpose: wxEventLoop implementation common to both Carbon and Cocoa
4 // Author: Vadim Zeitlin
5 // Created: 2009-10-18
6 // RCS-ID: $Id$
7 // Copyright: (c) 2009 Vadim Zeitlin <vadim@wxwidgets.org>
8 // Licence: wxWindows licence
9 ///////////////////////////////////////////////////////////////////////////////
10
11 // ============================================================================
12 // declarations
13 // ============================================================================
14
15 // ----------------------------------------------------------------------------
16 // headers
17 // ----------------------------------------------------------------------------
18
19 // for compilers that support precompilation, includes "wx.h".
20 #include "wx/wxprec.h"
21
22 #ifdef __BORLANDC__
23 #pragma hdrstop
24 #endif
25
26 #include "wx/evtloop.h"
27
28 #if wxUSE_EVENTLOOP_SOURCE
29
30 #ifndef WX_PRECOMP
31 #include "wx/log.h"
32 #include "wx/app.h"
33 #endif
34
35 #include "wx/evtloopsrc.h"
36
37 #include "wx/scopedptr.h"
38
39 #include "wx/osx/private.h"
40 #include "wx/osx/core/cfref.h"
41 #include "wx/thread.h"
42
43 #if wxUSE_GUI
44 #include "wx/nonownedwnd.h"
45 #endif
46
47 // ============================================================================
48 // wxCFEventLoopSource and wxCFEventLoop implementation
49 // ============================================================================
50
51 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
52 namespace
53 {
54
55 void EnableDescriptorCallBacks(CFFileDescriptorRef cffd, int flags)
56 {
57 if ( flags & wxEVENT_SOURCE_INPUT )
58 CFFileDescriptorEnableCallBacks(cffd, kCFFileDescriptorReadCallBack);
59 if ( flags & wxEVENT_SOURCE_OUTPUT )
60 CFFileDescriptorEnableCallBacks(cffd, kCFFileDescriptorWriteCallBack);
61 }
62
63 void
64 wx_cffiledescriptor_callback(CFFileDescriptorRef cffd,
65 CFOptionFlags flags,
66 void *ctxData)
67 {
68 wxLogTrace(wxTRACE_EVT_SOURCE,
69 "CFFileDescriptor callback, flags=%d", flags);
70
71 wxCFEventLoopSource * const
72 source = static_cast<wxCFEventLoopSource *>(ctxData);
73
74 wxEventLoopSourceHandler * const
75 handler = source->GetHandler();
76 if ( flags & kCFFileDescriptorReadCallBack )
77 handler->OnReadWaiting();
78 if ( flags & kCFFileDescriptorWriteCallBack )
79 handler->OnWriteWaiting();
80
81 // we need to re-enable callbacks to be called again
82 EnableDescriptorCallBacks(cffd, source->GetFlags());
83 }
84
85 } // anonymous namespace
86
87 wxEventLoopSource *
88 wxCFEventLoop::AddSourceForFD(int fd,
89 wxEventLoopSourceHandler *handler,
90 int flags)
91 {
92 wxCHECK_MSG( fd != -1, NULL, "can't monitor invalid fd" );
93
94 wxScopedPtr<wxCFEventLoopSource>
95 source(new wxCFEventLoopSource(handler, flags));
96
97 CFFileDescriptorContext ctx = { 0, source.get(), NULL, NULL, NULL };
98 wxCFRef<CFFileDescriptorRef>
99 cffd(CFFileDescriptorCreate
100 (
101 kCFAllocatorDefault,
102 fd,
103 true, // close on invalidate
104 wx_cffiledescriptor_callback,
105 &ctx
106 ));
107 if ( !cffd )
108 return NULL;
109
110 wxCFRef<CFRunLoopSourceRef>
111 cfsrc(CFFileDescriptorCreateRunLoopSource(kCFAllocatorDefault, cffd, 0));
112 if ( !cfsrc )
113 return NULL;
114
115 CFRunLoopRef cfloop = CFGetCurrentRunLoop();
116 CFRunLoopAddSource(cfloop, cfsrc, kCFRunLoopDefaultMode);
117
118 source->SetFileDescriptor(cffd.release());
119
120 return source.release();
121 }
122
123 void wxCFEventLoopSource::SetFileDescriptor(CFFileDescriptorRef cffd)
124 {
125 wxASSERT_MSG( !m_cffd, "shouldn't be called more than once" );
126
127 m_cffd = cffd;
128 }
129
130 wxCFEventLoopSource::~wxCFEventLoopSource()
131 {
132 if ( m_cffd )
133 CFRelease(m_cffd);
134 }
135
136 #else // OS X < 10.5
137
138 wxEventLoopSource *
139 wxCFEventLoop::AddSourceForFD(int WXUNUSED(fd),
140 wxEventLoopSourceHandler * WXUNUSED(handler),
141 int WXUNUSED(flags))
142 {
143 return NULL;
144 }
145
146 #endif // MAC_OS_X_VERSION_MAX_ALLOWED
147
148 #endif // wxUSE_EVENTLOOP_SOURCE
149
150 void wxCFEventLoop::OSXCommonModeObserverCallBack(CFRunLoopObserverRef observer, int activity, void *info)
151 {
152 wxCFEventLoop * eventloop = static_cast<wxCFEventLoop *>(info);
153 if ( eventloop )
154 eventloop->CommonModeObserverCallBack(observer, activity);
155 }
156
157 void wxCFEventLoop::OSXDefaultModeObserverCallBack(CFRunLoopObserverRef observer, int activity, void *info)
158 {
159 wxCFEventLoop * eventloop = static_cast<wxCFEventLoop *>(info);
160 if ( eventloop )
161 eventloop->DefaultModeObserverCallBack(observer, activity);
162 }
163
164 void wxCFEventLoop::CommonModeObserverCallBack(CFRunLoopObserverRef WXUNUSED(observer), int activity)
165 {
166 if ( activity & kCFRunLoopBeforeTimers )
167 {
168 // process pending wx events first as they correspond to low-level events
169 // which happened before, i.e. typically pending events were queued by a
170 // previous call to Dispatch() and if we didn't process them now the next
171 // call to it might enqueue them again (as happens with e.g. socket events
172 // which would be generated as long as there is input available on socket
173 // and this input is only removed from it when pending event handlers are
174 // executed)
175
176 if ( wxTheApp )
177 wxTheApp->ProcessPendingEvents();
178 }
179
180 if ( activity & kCFRunLoopBeforeWaiting )
181 {
182 if ( ProcessIdle() )
183 {
184 WakeUp();
185 }
186 else
187 {
188 #if wxUSE_THREADS
189 wxMutexGuiLeaveOrEnter();
190 #endif
191 }
192 }
193 }
194
195 void
196 wxCFEventLoop::DefaultModeObserverCallBack(CFRunLoopObserverRef WXUNUSED(observer),
197 int WXUNUSED(activity))
198 {
199 /*
200 if ( activity & kCFRunLoopBeforeTimers )
201 {
202 }
203
204 if ( activity & kCFRunLoopBeforeWaiting )
205 {
206 }
207 */
208 }
209
210
211 wxCFEventLoop::wxCFEventLoop()
212 {
213 m_shouldExit = false;
214
215 m_runLoop = CFGetCurrentRunLoop();
216
217 CFRunLoopObserverContext ctxt;
218 bzero( &ctxt, sizeof(ctxt) );
219 ctxt.info = this;
220 m_commonModeRunLoopObserver = CFRunLoopObserverCreate( kCFAllocatorDefault, kCFRunLoopBeforeTimers | kCFRunLoopBeforeWaiting , true /* repeats */, 0,
221 (CFRunLoopObserverCallBack) wxCFEventLoop::OSXCommonModeObserverCallBack, &ctxt );
222 CFRunLoopAddObserver(m_runLoop, m_commonModeRunLoopObserver, kCFRunLoopCommonModes);
223 CFRelease(m_commonModeRunLoopObserver);
224
225 m_defaultModeRunLoopObserver = CFRunLoopObserverCreate( kCFAllocatorDefault, kCFRunLoopBeforeTimers | kCFRunLoopBeforeWaiting , true /* repeats */, 0,
226 (CFRunLoopObserverCallBack) wxCFEventLoop::OSXDefaultModeObserverCallBack, &ctxt );
227 CFRunLoopAddObserver(m_runLoop, m_defaultModeRunLoopObserver, kCFRunLoopDefaultMode);
228 CFRelease(m_defaultModeRunLoopObserver);
229 }
230
231 wxCFEventLoop::~wxCFEventLoop()
232 {
233 CFRunLoopRemoveObserver(m_runLoop, m_commonModeRunLoopObserver, kCFRunLoopCommonModes);
234 CFRunLoopRemoveObserver(m_runLoop, m_defaultModeRunLoopObserver, kCFRunLoopDefaultMode);
235 }
236
237
238 CFRunLoopRef wxCFEventLoop::CFGetCurrentRunLoop() const
239 {
240 return CFRunLoopGetCurrent();
241 }
242
243 void wxCFEventLoop::WakeUp()
244 {
245 CFRunLoopWakeUp(m_runLoop);
246 }
247
248 #if wxUSE_BASE
249
250 void wxMacWakeUp()
251 {
252 wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
253
254 if ( loop )
255 loop->WakeUp();
256 }
257
258 #endif
259
260 bool wxCFEventLoop::YieldFor(long eventsToProcess)
261 {
262 #if wxUSE_THREADS
263 // Yielding from a non-gui thread needs to bail out, otherwise we end up
264 // possibly sending events in the thread too.
265 if ( !wxThread::IsMain() )
266 {
267 return true;
268 }
269 #endif // wxUSE_THREADS
270
271 m_isInsideYield = true;
272 m_eventsToProcessInsideYield = eventsToProcess;
273
274 #if wxUSE_LOG
275 // disable log flushing from here because a call to wxYield() shouldn't
276 // normally result in message boxes popping up &c
277 wxLog::Suspend();
278 #endif // wxUSE_LOG
279
280 // process all pending events:
281 while ( DoProcessEvents() == 1 )
282 ;
283
284 // it's necessary to call ProcessIdle() to update the frames sizes which
285 // might have been changed (it also will update other things set from
286 // OnUpdateUI() which is a nice (and desired) side effect)
287 while ( ProcessIdle() ) {}
288
289 // if there are pending events, we must process them.
290 if (wxTheApp)
291 wxTheApp->ProcessPendingEvents();
292
293 #if wxUSE_LOG
294 wxLog::Resume();
295 #endif // wxUSE_LOG
296 m_isInsideYield = false;
297
298 return true;
299 }
300
301 // implement/override base class pure virtual
302 bool wxCFEventLoop::Pending() const
303 {
304 return true;
305 }
306
307 int wxCFEventLoop::DoProcessEvents()
308 {
309 return DispatchTimeout( 0 );
310 }
311
312 bool wxCFEventLoop::Dispatch()
313 {
314 return DoProcessEvents() != 0;
315 }
316
317 int wxCFEventLoop::DispatchTimeout(unsigned long timeout)
318 {
319 if ( !wxTheApp )
320 return 0;
321
322 int status = DoDispatchTimeout(timeout);
323
324 switch( status )
325 {
326 case 0:
327 break;
328 case -1:
329 if ( m_shouldExit )
330 return 0;
331
332 break;
333 case 1:
334 break;
335 }
336
337 return status;
338 }
339
340 int wxCFEventLoop::DoDispatchTimeout(unsigned long timeout)
341 {
342 SInt32 status = CFRunLoopRunInMode(kCFRunLoopDefaultMode, timeout / 1000.0 , true);
343 switch( status )
344 {
345 case kCFRunLoopRunFinished:
346 wxFAIL_MSG( "incorrect run loop state" );
347 break;
348 case kCFRunLoopRunStopped:
349 return 0;
350 break;
351 case kCFRunLoopRunTimedOut:
352 return -1;
353 break;
354 case kCFRunLoopRunHandledSource:
355 default:
356 break;
357 }
358 return 1;
359 }
360
361 void wxCFEventLoop::DoRun()
362 {
363 for ( ;; )
364 {
365 // generate and process idle events for as long as we don't
366 // have anything else to do
367 DoProcessEvents();
368
369 // if the "should exit" flag is set, the loop should terminate
370 // but not before processing any remaining messages so while
371 // Pending() returns true, do process them
372 if ( m_shouldExit )
373 {
374 while ( DoProcessEvents() == 1 )
375 ;
376
377 break;
378 }
379 }
380 }
381
382 void wxCFEventLoop::DoStop()
383 {
384 CFRunLoopStop(CFGetCurrentRunLoop());
385 }
386
387 // enters a loop calling OnNextIteration(), Pending() and Dispatch() and
388 // terminating when Exit() is called
389 int wxCFEventLoop::Run()
390 {
391 // event loops are not recursive, you need to create another loop!
392 wxCHECK_MSG( !IsRunning(), -1, wxT("can't reenter a message loop") );
393
394 // ProcessIdle() and ProcessEvents() below may throw so the code here should
395 // be exception-safe, hence we must use local objects for all actions we
396 // should undo
397 wxEventLoopActivator activate(this);
398
399 // we must ensure that OnExit() is called even if an exception is thrown
400 // from inside ProcessEvents() but we must call it from Exit() in normal
401 // situations because it is supposed to be called synchronously,
402 // wxModalEventLoop depends on this (so we can't just use ON_BLOCK_EXIT or
403 // something similar here)
404 #if wxUSE_EXCEPTIONS
405 for ( ;; )
406 {
407 try
408 {
409 #endif // wxUSE_EXCEPTIONS
410
411 DoRun();
412
413 #if wxUSE_EXCEPTIONS
414 // exit the outer loop as well
415 break;
416 }
417 catch ( ... )
418 {
419 try
420 {
421 if ( !wxTheApp || !wxTheApp->OnExceptionInMainLoop() )
422 {
423 OnExit();
424 break;
425 }
426 //else: continue running the event loop
427 }
428 catch ( ... )
429 {
430 // OnException() throwed, possibly rethrowing the same
431 // exception again: very good, but we still need OnExit() to
432 // be called
433 OnExit();
434 throw;
435 }
436 }
437 }
438 #endif // wxUSE_EXCEPTIONS
439
440 return m_exitcode;
441 }
442
443 // sets the "should exit" flag and wakes up the loop so that it terminates
444 // soon
445 void wxCFEventLoop::Exit(int rc)
446 {
447 m_exitcode = rc;
448 m_shouldExit = true;
449 DoStop();
450 }
451
452 // TODO Move to thread_osx.cpp
453
454 #if wxUSE_THREADS
455
456 // ----------------------------------------------------------------------------
457 // GUI Serialization copied from MSW implementation
458 // ----------------------------------------------------------------------------
459
460 // if it's false, some secondary thread is holding the GUI lock
461 static bool gs_bGuiOwnedByMainThread = true;
462
463 // critical section which controls access to all GUI functions: any secondary
464 // thread (i.e. except the main one) must enter this crit section before doing
465 // any GUI calls
466 static wxCriticalSection *gs_critsectGui = NULL;
467
468 // critical section which protects gs_nWaitingForGui variable
469 static wxCriticalSection *gs_critsectWaitingForGui = NULL;
470
471 // number of threads waiting for GUI in wxMutexGuiEnter()
472 static size_t gs_nWaitingForGui = 0;
473
474 void wxOSXThreadModuleOnInit()
475 {
476 gs_critsectWaitingForGui = new wxCriticalSection();
477 gs_critsectGui = new wxCriticalSection();
478 gs_critsectGui->Enter();
479 }
480
481
482 void wxOSXThreadModuleOnExit()
483 {
484 if ( gs_critsectGui )
485 {
486 if ( !wxGuiOwnedByMainThread() )
487 {
488 gs_critsectGui->Enter();
489 gs_bGuiOwnedByMainThread = true;
490 }
491
492 gs_critsectGui->Leave();
493 wxDELETE(gs_critsectGui);
494 }
495
496 wxDELETE(gs_critsectWaitingForGui);
497 }
498
499
500 // wake up the main thread
501 void WXDLLIMPEXP_BASE wxWakeUpMainThread()
502 {
503 wxMacWakeUp();
504 }
505
506 void wxMutexGuiEnterImpl()
507 {
508 // this would dead lock everything...
509 wxASSERT_MSG( !wxThread::IsMain(),
510 wxT("main thread doesn't want to block in wxMutexGuiEnter()!") );
511
512 // the order in which we enter the critical sections here is crucial!!
513
514 // set the flag telling to the main thread that we want to do some GUI
515 {
516 wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
517
518 gs_nWaitingForGui++;
519 }
520
521 wxWakeUpMainThread();
522
523 // now we may block here because the main thread will soon let us in
524 // (during the next iteration of OnIdle())
525 gs_critsectGui->Enter();
526 }
527
528 void wxMutexGuiLeaveImpl()
529 {
530 wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
531
532 if ( wxThread::IsMain() )
533 {
534 gs_bGuiOwnedByMainThread = false;
535 }
536 else
537 {
538 // decrement the number of threads waiting for GUI access now
539 wxASSERT_MSG( gs_nWaitingForGui > 0,
540 wxT("calling wxMutexGuiLeave() without entering it first?") );
541
542 gs_nWaitingForGui--;
543
544 wxWakeUpMainThread();
545 }
546
547 gs_critsectGui->Leave();
548 }
549
550 void WXDLLIMPEXP_BASE wxMutexGuiLeaveOrEnter()
551 {
552 wxASSERT_MSG( wxThread::IsMain(),
553 wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
554
555 if ( !gs_critsectWaitingForGui )
556 return;
557
558 wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
559
560 if ( gs_nWaitingForGui == 0 )
561 {
562 // no threads are waiting for GUI - so we may acquire the lock without
563 // any danger (but only if we don't already have it)
564 if ( !wxGuiOwnedByMainThread() )
565 {
566 gs_critsectGui->Enter();
567
568 gs_bGuiOwnedByMainThread = true;
569 }
570 //else: already have it, nothing to do
571 }
572 else
573 {
574 // some threads are waiting, release the GUI lock if we have it
575 if ( wxGuiOwnedByMainThread() )
576 wxMutexGuiLeave();
577 //else: some other worker thread is doing GUI
578 }
579 }
580
581 bool WXDLLIMPEXP_BASE wxGuiOwnedByMainThread()
582 {
583 return gs_bGuiOwnedByMainThread;
584 }
585
586 #endif