fix wxCHECK_MSG() return value

[wxWidgets.git] / src / osx / core / evtloop_cf.cpp

diff --git a/src/osx/core/evtloop_cf.cpp b/src/osx/core/evtloop_cf.cpp
index afe67a048c4a787f8495cde12cf2f3272b7a9638..ef70c2368edd43f508d986c17f67d122c768dc20 100644 (file)
--- a/src/osx/core/evtloop_cf.cpp
+++ b/src/osx/core/evtloop_cf.cpp
@@ -5,6 +5,7 @@
 // Created:     2009-10-18
 // RCS-ID:      $Id$
 // Copyright:   (c) 2009 Vadim Zeitlin <vadim@wxwidgets.org>
 // Created:     2009-10-18
 // RCS-ID:      $Id$
 // Copyright:   (c) 2009 Vadim Zeitlin <vadim@wxwidgets.org>

+//              (c) 2013 Rob Bresalier

 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 


@@ -25,8 +26,6 @@
 
 #include "wx/evtloop.h"
 
 
 #include "wx/evtloop.h"
 

-#if wxUSE_EVENTLOOP_SOURCE
-

 #ifndef WX_PRECOMP
     #include "wx/log.h"
     #include "wx/app.h"
 #ifndef WX_PRECOMP
     #include "wx/log.h"
     #include "wx/app.h"


@@ -44,107 +43,30 @@
     #include "wx/nonownedwnd.h"
 #endif
 
     #include "wx/nonownedwnd.h"
 #endif
 

+#include <CoreFoundation/CFSocket.h>
+

 // ============================================================================
 // wxCFEventLoopSource and wxCFEventLoop implementation
 // ============================================================================
 
 // ============================================================================
 // wxCFEventLoopSource and wxCFEventLoop implementation
 // ============================================================================
 

-#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
-namespace
-{
-
-void EnableDescriptorCallBacks(CFFileDescriptorRef cffd, int flags)
-{
-    if ( flags & wxEVENT_SOURCE_INPUT )
-        CFFileDescriptorEnableCallBacks(cffd, kCFFileDescriptorReadCallBack);
-    if ( flags & wxEVENT_SOURCE_OUTPUT )
-        CFFileDescriptorEnableCallBacks(cffd, kCFFileDescriptorWriteCallBack);
-}
-
-void
-wx_cffiledescriptor_callback(CFFileDescriptorRef cffd,
-                             CFOptionFlags flags,
-                             void *ctxData)
-{
-    wxLogTrace(wxTRACE_EVT_SOURCE,
-               "CFFileDescriptor callback, flags=%d", flags);
-
-    wxCFEventLoopSource * const
-        source = static_cast<wxCFEventLoopSource *>(ctxData);
-
-    wxEventLoopSourceHandler * const
-        handler = source->GetHandler();
-    if ( flags & kCFFileDescriptorReadCallBack )
-        handler->OnReadWaiting();
-    if ( flags & kCFFileDescriptorWriteCallBack )
-        handler->OnWriteWaiting();
-
-    // we need to re-enable callbacks to be called again
-    EnableDescriptorCallBacks(cffd, source->GetFlags());
-}
-
-} // anonymous namespace
-
-wxEventLoopSource *
-wxCFEventLoop::AddSourceForFD(int fd,
-                              wxEventLoopSourceHandler *handler,
-                              int flags)
-{
-    wxCHECK_MSG( fd != -1, NULL, "can't monitor invalid fd" );
-
-    wxScopedPtr<wxCFEventLoopSource>
-        source(new wxCFEventLoopSource(handler, flags));
-
-    CFFileDescriptorContext ctx = { 0, source.get(), NULL, NULL, NULL };
-    wxCFRef<CFFileDescriptorRef>
-        cffd(CFFileDescriptorCreate
-             (
-                  kCFAllocatorDefault,
-                  fd,
-                  true,   // close on invalidate
-                  wx_cffiledescriptor_callback,
-                  &ctx
-             ));
-    if ( !cffd )
-        return NULL;
-
-    wxCFRef<CFRunLoopSourceRef>
-        cfsrc(CFFileDescriptorCreateRunLoopSource(kCFAllocatorDefault, cffd, 0));
-    if ( !cfsrc )
-        return NULL;
-
-    CFRunLoopRef cfloop = CFGetCurrentRunLoop();
-    CFRunLoopAddSource(cfloop, cfsrc, kCFRunLoopDefaultMode);
-
-    source->SetFileDescriptor(cffd.release());
-
-    return source.release();
-}
+#if wxUSE_EVENTLOOP_SOURCE

 
 

-void wxCFEventLoopSource::SetFileDescriptor(CFFileDescriptorRef cffd)
+void wxCFEventLoopSource::InitSourceSocket(CFSocketRef cfSocket)

 {
 {

-    wxASSERT_MSG( !m_cffd, "shouldn't be called more than once" );
+    wxASSERT_MSG( !m_cfSocket, "shouldn't be called more than once" );

 
 

-    m_cffd = cffd;
+    m_cfSocket = cfSocket;

 }
 
 wxCFEventLoopSource::~wxCFEventLoopSource()
 {
 }
 
 wxCFEventLoopSource::~wxCFEventLoopSource()
 {

-    if ( m_cffd )
-        CFRelease(m_cffd);
-}
-
-#else // OS X < 10.5
-
-wxEventLoopSource *
-wxCFEventLoop::AddSourceForFD(int WXUNUSED(fd),
-                              wxEventLoopSourceHandler * WXUNUSED(handler),
-                              int WXUNUSED(flags))
-{
-    return NULL;
+    if ( m_cfSocket )
+    {
+        CFSocketInvalidate(m_cfSocket);
+        CFRelease(m_cfSocket);
+    }

 }
 
 }
 

-#endif // MAC_OS_X_VERSION_MAX_ALLOWED
-

 #endif // wxUSE_EVENTLOOP_SOURCE
 
 void wxCFEventLoop::OSXCommonModeObserverCallBack(CFRunLoopObserverRef observer, int activity, void *info)
 #endif // wxUSE_EVENTLOOP_SOURCE
 
 void wxCFEventLoop::OSXCommonModeObserverCallBack(CFRunLoopObserverRef observer, int activity, void *info)


@@ -173,13 +95,13 @@ void wxCFEventLoop::CommonModeObserverCallBack(CFRunLoopObserverRef WXUNUSED(obs
         // and this input is only removed from it when pending event handlers are
         // executed)
 
         // and this input is only removed from it when pending event handlers are
         // executed)
 

-        if ( wxTheApp )
+        if ( wxTheApp && ShouldProcessIdleEvents() )

             wxTheApp->ProcessPendingEvents();
     }
 
     if ( activity & kCFRunLoopBeforeWaiting )
     {
             wxTheApp->ProcessPendingEvents();
     }
 
     if ( activity & kCFRunLoopBeforeWaiting )
     {

-        if ( ProcessIdle() )
+        if ( ShouldProcessIdleEvents() && ProcessIdle() )

         {
             WakeUp();
         }
         {
             WakeUp();
         }


@@ -211,7 +133,12 @@ wxCFEventLoop::DefaultModeObserverCallBack(CFRunLoopObserverRef WXUNUSED(observe
 wxCFEventLoop::wxCFEventLoop()
 {
     m_shouldExit = false;
 wxCFEventLoop::wxCFEventLoop()
 {
     m_shouldExit = false;

+    m_processIdleEvents = true;

 
 

+#if wxUSE_UIACTIONSIMULATOR
+    m_shouldWaitForEvent = false;
+#endif
+    

     m_runLoop = CFGetCurrentRunLoop();
 
     CFRunLoopObserverContext ctxt;
     m_runLoop = CFGetCurrentRunLoop();
 
     CFRunLoopObserverContext ctxt;


@@ -220,18 +147,19 @@ wxCFEventLoop::wxCFEventLoop()
     m_commonModeRunLoopObserver = CFRunLoopObserverCreate( kCFAllocatorDefault, kCFRunLoopBeforeTimers | kCFRunLoopBeforeWaiting , true /* repeats */, 0,
                                                           (CFRunLoopObserverCallBack) wxCFEventLoop::OSXCommonModeObserverCallBack, &ctxt );
     CFRunLoopAddObserver(m_runLoop, m_commonModeRunLoopObserver, kCFRunLoopCommonModes);
     m_commonModeRunLoopObserver = CFRunLoopObserverCreate( kCFAllocatorDefault, kCFRunLoopBeforeTimers | kCFRunLoopBeforeWaiting , true /* repeats */, 0,
                                                           (CFRunLoopObserverCallBack) wxCFEventLoop::OSXCommonModeObserverCallBack, &ctxt );
     CFRunLoopAddObserver(m_runLoop, m_commonModeRunLoopObserver, kCFRunLoopCommonModes);

-    CFRelease(m_commonModeRunLoopObserver);

 
     m_defaultModeRunLoopObserver = CFRunLoopObserverCreate( kCFAllocatorDefault, kCFRunLoopBeforeTimers | kCFRunLoopBeforeWaiting , true /* repeats */, 0,
                                                            (CFRunLoopObserverCallBack) wxCFEventLoop::OSXDefaultModeObserverCallBack, &ctxt );
     CFRunLoopAddObserver(m_runLoop, m_defaultModeRunLoopObserver, kCFRunLoopDefaultMode);
 
     m_defaultModeRunLoopObserver = CFRunLoopObserverCreate( kCFAllocatorDefault, kCFRunLoopBeforeTimers | kCFRunLoopBeforeWaiting , true /* repeats */, 0,
                                                            (CFRunLoopObserverCallBack) wxCFEventLoop::OSXDefaultModeObserverCallBack, &ctxt );
     CFRunLoopAddObserver(m_runLoop, m_defaultModeRunLoopObserver, kCFRunLoopDefaultMode);

-    CFRelease(m_defaultModeRunLoopObserver);

 }
 
 wxCFEventLoop::~wxCFEventLoop()
 {
     CFRunLoopRemoveObserver(m_runLoop, m_commonModeRunLoopObserver, kCFRunLoopCommonModes);
     CFRunLoopRemoveObserver(m_runLoop, m_defaultModeRunLoopObserver, kCFRunLoopDefaultMode);
 }
 
 wxCFEventLoop::~wxCFEventLoop()
 {
     CFRunLoopRemoveObserver(m_runLoop, m_commonModeRunLoopObserver, kCFRunLoopCommonModes);
     CFRunLoopRemoveObserver(m_runLoop, m_defaultModeRunLoopObserver, kCFRunLoopDefaultMode);

+
+    CFRelease(m_defaultModeRunLoopObserver);
+    CFRelease(m_commonModeRunLoopObserver);

 }
 
 
 }
 
 


@@ -306,7 +234,17 @@ bool wxCFEventLoop::Pending() const
 
 int wxCFEventLoop::DoProcessEvents()
 {
 
 int wxCFEventLoop::DoProcessEvents()
 {

-    return DispatchTimeout( 0 );
+#if wxUSE_UIACTIONSIMULATOR
+    if ( m_shouldWaitForEvent )
+    {
+        int  handled = DispatchTimeout( 1000 );
+        wxASSERT_MSG( handled == 1, "No Event Available");
+        m_shouldWaitForEvent = false;
+        return handled;
+    }
+    else
+#endif
+        return DispatchTimeout( 0 );

 }
 
 bool wxCFEventLoop::Dispatch()
 }
 
 bool wxCFEventLoop::Dispatch()


@@ -358,7 +296,7 @@ int wxCFEventLoop::DoDispatchTimeout(unsigned long timeout)
     return 1;
 }
 
     return 1;
 }
 

-void wxCFEventLoop::DoRun()
+void wxCFEventLoop::OSXDoRun()

 {
     for ( ;; )
     {
 {
     for ( ;; )
     {


@@ -379,23 +317,15 @@ void wxCFEventLoop::DoRun()
     }
 }
 
     }
 }
 

-void wxCFEventLoop::DoStop()
+void wxCFEventLoop::OSXDoStop()

 {
     CFRunLoopStop(CFGetCurrentRunLoop());
 }
 
 // enters a loop calling OnNextIteration(), Pending() and Dispatch() and
 // terminating when Exit() is called
 {
     CFRunLoopStop(CFGetCurrentRunLoop());
 }
 
 // enters a loop calling OnNextIteration(), Pending() and Dispatch() and
 // terminating when Exit() is called

-int wxCFEventLoop::Run()
+int wxCFEventLoop::DoRun()

 {
 {

-    // event loops are not recursive, you need to create another loop!
-    wxCHECK_MSG( !IsRunning(), -1, wxT("can't reenter a message loop") );
-
-    // ProcessIdle() and ProcessEvents() below may throw so the code here should
-    // be exception-safe, hence we must use local objects for all actions we
-    // should undo
-    wxEventLoopActivator activate(this);
-

     // we must ensure that OnExit() is called even if an exception is thrown
     // from inside ProcessEvents() but we must call it from Exit() in normal
     // situations because it is supposed to be called synchronously,
     // we must ensure that OnExit() is called even if an exception is thrown
     // from inside ProcessEvents() but we must call it from Exit() in normal
     // situations because it is supposed to be called synchronously,


@@ -408,7 +338,7 @@ int wxCFEventLoop::Run()
         {
 #endif // wxUSE_EXCEPTIONS
 
         {
 #endif // wxUSE_EXCEPTIONS
 

-            DoRun();
+            OSXDoRun();

 
 #if wxUSE_EXCEPTIONS
             // exit the outer loop as well
 
 #if wxUSE_EXCEPTIONS
             // exit the outer loop as well


@@ -442,11 +372,30 @@ int wxCFEventLoop::Run()
 
 // sets the "should exit" flag and wakes up the loop so that it terminates
 // soon
 
 // sets the "should exit" flag and wakes up the loop so that it terminates
 // soon

-void wxCFEventLoop::Exit(int rc)
+void wxCFEventLoop::ScheduleExit(int rc)

 {
     m_exitcode = rc;
     m_shouldExit = true;
 {
     m_exitcode = rc;
     m_shouldExit = true;

-    DoStop();
+    OSXDoStop();
+}
+
+wxCFEventLoopPauseIdleEvents::wxCFEventLoopPauseIdleEvents()
+{
+    wxCFEventLoop* cfl = dynamic_cast<wxCFEventLoop*>(wxEventLoopBase::GetActive());
+    if ( cfl )
+    {
+        m_formerState = cfl->ShouldProcessIdleEvents();
+        cfl->SetProcessIdleEvents(false);
+    }
+    else
+        m_formerState = true;
+}
+
+wxCFEventLoopPauseIdleEvents::~wxCFEventLoopPauseIdleEvents()
+{
+    wxCFEventLoop* cfl = dynamic_cast<wxCFEventLoop*>(wxEventLoopBase::GetActive());
+    if ( cfl )
+        cfl->SetProcessIdleEvents(m_formerState);

 }
 
 // TODO Move to thread_osx.cpp
 }
 
 // TODO Move to thread_osx.cpp