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
  42 // ============================================================================
  43 // wxCFEventLoopSource and wxCFEventLoop implementation
  44 // ============================================================================
  45
  46 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
  47 namespace
  48 {
  49
  50 void EnableDescriptorCallBacks(CFFileDescriptorRef cffd, int flags)
  51 {
  52     if ( flags & wxEVENT_SOURCE_INPUT )
  53         CFFileDescriptorEnableCallBacks(cffd, kCFFileDescriptorReadCallBack);
  54     if ( flags & wxEVENT_SOURCE_OUTPUT )
  55         CFFileDescriptorEnableCallBacks(cffd, kCFFileDescriptorWriteCallBack);
  56 }
  57
  58 void
  59 wx_cffiledescriptor_callback(CFFileDescriptorRef cffd,
  60                              CFOptionFlags flags,
  61                              void *ctxData)
  62 {
  63     wxLogTrace(wxTRACE_EVT_SOURCE,
  64                "CFFileDescriptor callback, flags=%d", flags);
  65
  66     wxCFEventLoopSource * const
  67         source = static_cast<wxCFEventLoopSource *>(ctxData);
  68
  69     wxEventLoopSourceHandler * const
  70         handler = source->GetHandler();
  71     if ( flags & kCFFileDescriptorReadCallBack )
  72         handler->OnReadWaiting();
  73     if ( flags & kCFFileDescriptorWriteCallBack )
  74         handler->OnWriteWaiting();
  75
  76     // we need to re-enable callbacks to be called again
  77     EnableDescriptorCallBacks(cffd, source->GetFlags());
  78 }
  79
  80 } // anonymous namespace
  81
  82 wxEventLoopSource *
  83 wxCFEventLoop::AddSourceForFD(int fd,
  84                               wxEventLoopSourceHandler *handler,
  85                               int flags)
  86 {
  87     wxCHECK_MSG( fd != -1, NULL, "can't monitor invalid fd" );
  88
  89     wxScopedPtr<wxCFEventLoopSource>
  90         source(new wxCFEventLoopSource(handler, flags));
  91
  92     CFFileDescriptorContext ctx = { 0, source.get(), NULL, NULL, NULL };
  93     wxCFRef<CFFileDescriptorRef>
  94         cffd(CFFileDescriptorCreate
  95              (
  96                   kCFAllocatorDefault,
  97                   fd,
  98                   true,   // close on invalidate
  99                   wx_cffiledescriptor_callback,
 100                   &ctx
 101              ));
 102     if ( !cffd )
 103         return NULL;
 104
 105     source->SetFileDescriptor(cffd.release());
 106
 107     wxCFRef<CFRunLoopSourceRef>
 108         cfsrc(CFFileDescriptorCreateRunLoopSource(kCFAllocatorDefault, cffd, 0));
 109     if ( !cfsrc )
 110         return NULL;
 111
 112     CFRunLoopRef cfloop = CFGetCurrentRunLoop();
 113     CFRunLoopAddSource(cfloop, cfsrc, kCFRunLoopDefaultMode);
 114
 115     return source.release();
 116 }
 117
 118 void wxCFEventLoopSource::SetFileDescriptor(CFFileDescriptorRef cffd)
 119 {
 120     wxASSERT_MSG( !m_cffd, "shouldn't be called more than once" );
 121
 122     m_cffd = cffd;
 123 }
 124
 125 wxCFEventLoopSource::~wxCFEventLoopSource()
 126 {
 127     if ( m_cffd )
 128         CFRelease(m_cffd);
 129 }
 130
 131 #else // OS X < 10.5
 132
 133 wxEventLoopSource *
 134 wxCFEventLoop::AddSourceForFD(int WXUNUSED(fd),
 135                               wxEventLoopSourceHandler * WXUNUSED(handler),
 136                               int WXUNUSED(flags))
 137 {
 138     return NULL;
 139 }
 140
 141 #endif // MAC_OS_X_VERSION_MAX_ALLOWED
 142
 143 #endif // wxUSE_EVENTLOOP_SOURCE
 144
 145 void wxObserverCallBack(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info)
 146 {
 147     wxCFEventLoop * eventloop = static_cast<wxCFEventLoop *>(info);
 148     if ( eventloop )
 149         eventloop->ObserverCallBack(observer, activity);
 150 }
 151
 152 void wxCFEventLoop::ObserverCallBack(CFRunLoopObserverRef observer, int activity)
 153 {
 154     if ( activity & kCFRunLoopBeforeTimers )
 155     {
 156         // process pending wx events first as they correspond to low-level events
 157         // which happened before, i.e. typically pending events were queued by a
 158         // previous call to Dispatch() and if we didn't process them now the next
 159         // call to it might enqueue them again (as happens with e.g. socket events
 160         // which would be generated as long as there is input available on socket
 161         // and this input is only removed from it when pending event handlers are
 162         // executed)
 163
 164         if ( wxTheApp )
 165             wxTheApp->ProcessPendingEvents();
 166     }
 167
 168     if ( activity & kCFRunLoopBeforeWaiting )
 169     {
 170         if ( ProcessIdle() )
 171         {
 172             WakeUp();
 173         }
 174         else
 175         {
 176 #if wxUSE_THREADS
 177             wxMutexGuiLeave();
 178             wxMilliSleep(20);
 179             wxMutexGuiEnter();
 180 #endif
 181         }
 182     }
 183 }
 184
 185 wxCFEventLoop::wxCFEventLoop()
 186 {
 187     m_shouldExit = false;
 188     CFRunLoopObserverContext ctxt;
 189     bzero( &ctxt, sizeof(ctxt) );
 190     ctxt.info = this;
 191     m_runLoopObserver = CFRunLoopObserverCreate( kCFAllocatorDefault, kCFRunLoopBeforeTimers | kCFRunLoopBeforeWaiting , true /* repeats */, 0,
 192                                                 wxObserverCallBack, &ctxt );
 193     CFRunLoopAddObserver(CFGetCurrentRunLoop(), m_runLoopObserver, kCFRunLoopDefaultMode);
 194 }
 195
 196 wxCFEventLoop::~wxCFEventLoop()
 197 {
 198 }
 199
 200
 201 CFRunLoopRef wxCFEventLoop::CFGetCurrentRunLoop() const
 202 {
 203     return CFRunLoopGetCurrent();
 204 }
 205
 206 void wxCFEventLoop::WakeUp()
 207 {
 208     extern void wxMacWakeUp();
 209
 210     wxMacWakeUp();
 211 }
 212
 213 bool wxCFEventLoop::YieldFor(long eventsToProcess)
 214 {
 215 #if wxUSE_THREADS
 216     // Yielding from a non-gui thread needs to bail out, otherwise we end up
 217     // possibly sending events in the thread too.
 218     if ( !wxThread::IsMain() )
 219     {
 220         return true;
 221     }
 222 #endif // wxUSE_THREADS
 223
 224     m_isInsideYield = true;
 225     m_eventsToProcessInsideYield = eventsToProcess;
 226
 227 #if wxUSE_LOG
 228     // disable log flushing from here because a call to wxYield() shouldn't
 229     // normally result in message boxes popping up &c
 230     wxLog::Suspend();
 231 #endif // wxUSE_LOG
 232
 233     // process all pending events:
 234     while ( DoProcessEvents() == 1 )
 235         ;
 236
 237     // it's necessary to call ProcessIdle() to update the frames sizes which
 238     // might have been changed (it also will update other things set from
 239     // OnUpdateUI() which is a nice (and desired) side effect)
 240     while ( ProcessIdle() ) {}
 241
 242     // if there are pending events, we must process them.
 243     if (wxTheApp)
 244         wxTheApp->ProcessPendingEvents();
 245
 246 #if wxUSE_LOG
 247     wxLog::Resume();
 248 #endif // wxUSE_LOG
 249     m_isInsideYield = false;
 250
 251     return true;
 252 }
 253
 254 // implement/override base class pure virtual
 255 bool wxCFEventLoop::Pending() const
 256 {
 257     return true;
 258 }
 259
 260 int wxCFEventLoop::DoProcessEvents()
 261 {
 262     return DispatchTimeout( 1000 );
 263 }
 264
 265 bool wxCFEventLoop::Dispatch()
 266 {
 267     return DoProcessEvents() != 0;
 268 }
 269
 270 int wxCFEventLoop::DispatchTimeout(unsigned long timeout)
 271 {
 272     if ( !wxTheApp )
 273         return 0;
 274
 275     wxMacAutoreleasePool autoreleasepool;
 276
 277     int status = DoDispatchTimeout(timeout);
 278
 279     switch( status )
 280     {
 281         case 0:
 282             break;
 283         case -1:
 284             if ( m_shouldExit )
 285                 return 0;
 286
 287             break;
 288         case 1:
 289             break;
 290     }
 291
 292     return status;
 293 }
 294
 295 int wxCFEventLoop::DoDispatchTimeout(unsigned long timeout)
 296 {
 297     SInt32 status = CFRunLoopRunInMode(kCFRunLoopDefaultMode, timeout / 1000.0 , true);
 298     switch( status )
 299     {
 300         case kCFRunLoopRunFinished:
 301             wxFAIL_MSG( "incorrect run loop state" );
 302             break;
 303         case kCFRunLoopRunStopped:
 304             return 0;
 305             break;
 306         case kCFRunLoopRunTimedOut:
 307             return -1;
 308             break;
 309         case kCFRunLoopRunHandledSource:
 310         default:
 311             break;
 312     }
 313     return 1;
 314 }
 315
 316 // enters a loop calling OnNextIteration(), Pending() and Dispatch() and
 317 // terminating when Exit() is called
 318 int wxCFEventLoop::Run()
 319 {
 320     // event loops are not recursive, you need to create another loop!
 321     wxCHECK_MSG( !IsRunning(), -1, wxT("can't reenter a message loop") );
 322
 323     // ProcessIdle() and ProcessEvents() below may throw so the code here should
 324     // be exception-safe, hence we must use local objects for all actions we
 325     // should undo
 326     wxEventLoopActivator activate(this);
 327
 328     // we must ensure that OnExit() is called even if an exception is thrown
 329     // from inside ProcessEvents() but we must call it from Exit() in normal
 330     // situations because it is supposed to be called synchronously,
 331     // wxModalEventLoop depends on this (so we can't just use ON_BLOCK_EXIT or
 332     // something similar here)
 333 #if wxUSE_EXCEPTIONS
 334     for ( ;; )
 335     {
 336         try
 337         {
 338 #endif // wxUSE_EXCEPTIONS
 339             for ( ;; )
 340             {
 341                 // generate and process idle events for as long as we don't
 342                 // have anything else to do
 343                 DoProcessEvents();
 344
 345                 // if the "should exit" flag is set, the loop should terminate
 346                 // but not before processing any remaining messages so while
 347                 // Pending() returns true, do process them
 348                 if ( m_shouldExit )
 349                 {
 350                     while ( DoProcessEvents() == 1 )
 351                         ;
 352
 353                     break;
 354                 }
 355             }
 356
 357 #if wxUSE_EXCEPTIONS
 358             // exit the outer loop as well
 359             break;
 360         }
 361         catch ( ... )
 362         {
 363             try
 364             {
 365                 if ( !wxTheApp || !wxTheApp->OnExceptionInMainLoop() )
 366                 {
 367                     OnExit();
 368                     break;
 369                 }
 370                 //else: continue running the event loop
 371             }
 372             catch ( ... )
 373             {
 374                 // OnException() throwed, possibly rethrowing the same
 375                 // exception again: very good, but we still need OnExit() to
 376                 // be called
 377                 OnExit();
 378                 throw;
 379             }
 380         }
 381     }
 382 #endif // wxUSE_EXCEPTIONS
 383
 384     return m_exitcode;
 385 }
 386
 387 // sets the "should exit" flag and wakes up the loop so that it terminates
 388 // soon
 389 void wxCFEventLoop::Exit(int rc)
 390 {
 391     m_exitcode = rc;
 392     m_shouldExit = true;
 393 }
 394
 395