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