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