Applied Blit system options optimization to StretchBlit

[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 3bd0c3c73371514cfa48397a6117983e66fa75aa..afe67a048c4a787f8495cde12cf2f3272b7a9638 100644 (file)
--- a/src/osx/core/evtloop_cf.cpp
+++ b/src/osx/core/evtloop_cf.cpp
@@ -38,6 +38,11 @@
 
 #include "wx/osx/private.h"
 #include "wx/osx/core/cfref.h"
 
 #include "wx/osx/private.h"
 #include "wx/osx/core/cfref.h"

+#include "wx/thread.h"
+
+#if wxUSE_GUI
+    #include "wx/nonownedwnd.h"
+#endif

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


@@ -102,8 +107,6 @@ wxCFEventLoop::AddSourceForFD(int fd,
     if ( !cffd )
         return NULL;
 
     if ( !cffd )
         return NULL;
 

-    source->SetFileDescriptor(cffd.release());
-

     wxCFRef<CFRunLoopSourceRef>
         cfsrc(CFFileDescriptorCreateRunLoopSource(kCFAllocatorDefault, cffd, 0));
     if ( !cfsrc )
     wxCFRef<CFRunLoopSourceRef>
         cfsrc(CFFileDescriptorCreateRunLoopSource(kCFAllocatorDefault, cffd, 0));
     if ( !cfsrc )


@@ -112,6 +115,8 @@ wxCFEventLoop::AddSourceForFD(int fd,
     CFRunLoopRef cfloop = CFGetCurrentRunLoop();
     CFRunLoopAddSource(cfloop, cfsrc, kCFRunLoopDefaultMode);
 
     CFRunLoopRef cfloop = CFGetCurrentRunLoop();
     CFRunLoopAddSource(cfloop, cfsrc, kCFRunLoopDefaultMode);
 

+    source->SetFileDescriptor(cffd.release());
+

     return source.release();
 }
 
     return source.release();
 }
 


@@ -142,29 +147,116 @@ wxCFEventLoop::AddSourceForFD(int WXUNUSED(fd),
 
 #endif // wxUSE_EVENTLOOP_SOURCE
 
 
 #endif // wxUSE_EVENTLOOP_SOURCE
 

+void wxCFEventLoop::OSXCommonModeObserverCallBack(CFRunLoopObserverRef observer, int activity, void *info)
+{
+    wxCFEventLoop * eventloop = static_cast<wxCFEventLoop *>(info);
+    if ( eventloop )
+        eventloop->CommonModeObserverCallBack(observer, activity);
+}
+
+void wxCFEventLoop::OSXDefaultModeObserverCallBack(CFRunLoopObserverRef observer, int activity, void *info)
+{
+    wxCFEventLoop * eventloop = static_cast<wxCFEventLoop *>(info);
+    if ( eventloop )
+        eventloop->DefaultModeObserverCallBack(observer, activity);
+}
+
+void wxCFEventLoop::CommonModeObserverCallBack(CFRunLoopObserverRef WXUNUSED(observer), int activity)
+{
+    if ( activity & kCFRunLoopBeforeTimers )
+    {
+        // process pending wx events first as they correspond to low-level events
+        // which happened before, i.e. typically pending events were queued by a
+        // previous call to Dispatch() and if we didn't process them now the next
+        // call to it might enqueue them again (as happens with e.g. socket events
+        // which would be generated as long as there is input available on socket
+        // and this input is only removed from it when pending event handlers are
+        // executed)
+
+        if ( wxTheApp )
+            wxTheApp->ProcessPendingEvents();
+    }
+
+    if ( activity & kCFRunLoopBeforeWaiting )
+    {
+        if ( ProcessIdle() )
+        {
+            WakeUp();
+        }
+        else
+        {
+#if wxUSE_THREADS
+            wxMutexGuiLeaveOrEnter();
+#endif
+        }
+    }
+}
+
+void
+wxCFEventLoop::DefaultModeObserverCallBack(CFRunLoopObserverRef WXUNUSED(observer),
+                                           int WXUNUSED(activity))
+{
+    /*
+    if ( activity & kCFRunLoopBeforeTimers )
+    {
+    }
+    
+    if ( activity & kCFRunLoopBeforeWaiting )
+    {
+    }
+    */
+}
+
+

 wxCFEventLoop::wxCFEventLoop()
 {
     m_shouldExit = false;
 wxCFEventLoop::wxCFEventLoop()
 {
     m_shouldExit = false;

-    m_sleepTime = 0.0;
+
+    m_runLoop = CFGetCurrentRunLoop();
+
+    CFRunLoopObserverContext ctxt;
+    bzero( &ctxt, sizeof(ctxt) );
+    ctxt.info = this;
+    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);
+    CFRelease(m_defaultModeRunLoopObserver);

 }
 
 wxCFEventLoop::~wxCFEventLoop()
 {
 }
 
 wxCFEventLoop::~wxCFEventLoop()
 {

+    CFRunLoopRemoveObserver(m_runLoop, m_commonModeRunLoopObserver, kCFRunLoopCommonModes);
+    CFRunLoopRemoveObserver(m_runLoop, m_defaultModeRunLoopObserver, kCFRunLoopDefaultMode);

 }
 }

-                        
+

 
 CFRunLoopRef wxCFEventLoop::CFGetCurrentRunLoop() const
 {
 
 CFRunLoopRef wxCFEventLoop::CFGetCurrentRunLoop() const
 {

-    return CFGetCurrentRunLoop();
+    return CFRunLoopGetCurrent();

 }
 
 void wxCFEventLoop::WakeUp()
 {
 }
 
 void wxCFEventLoop::WakeUp()
 {

-    extern void wxMacWakeUp();
-    
-    wxMacWakeUp();
+    CFRunLoopWakeUp(m_runLoop);

 }
 
 }
 

+#if wxUSE_BASE
+
+void wxMacWakeUp()
+{
+    wxEventLoopBase * const loop = wxEventLoopBase::GetActive();
+
+    if ( loop )
+        loop->WakeUp();
+}
+
+#endif
+

 bool wxCFEventLoop::YieldFor(long eventsToProcess)
 {
 #if wxUSE_THREADS
 bool wxCFEventLoop::YieldFor(long eventsToProcess)
 {
 #if wxUSE_THREADS


@@ -175,34 +267,34 @@ bool wxCFEventLoop::YieldFor(long eventsToProcess)
         return true;
     }
 #endif // wxUSE_THREADS
         return true;
     }
 #endif // wxUSE_THREADS

-    
+

     m_isInsideYield = true;
     m_eventsToProcessInsideYield = eventsToProcess;
     m_isInsideYield = true;
     m_eventsToProcessInsideYield = eventsToProcess;

-    
+

 #if wxUSE_LOG
     // disable log flushing from here because a call to wxYield() shouldn't
     // normally result in message boxes popping up &c
     wxLog::Suspend();
 #endif // wxUSE_LOG
 #if wxUSE_LOG
     // disable log flushing from here because a call to wxYield() shouldn't
     // normally result in message boxes popping up &c
     wxLog::Suspend();
 #endif // wxUSE_LOG

-    
+

     // process all pending events:
     while ( DoProcessEvents() == 1 )
         ;
     // process all pending events:
     while ( DoProcessEvents() == 1 )
         ;

-    
+

     // it's necessary to call ProcessIdle() to update the frames sizes which
     // might have been changed (it also will update other things set from
     // OnUpdateUI() which is a nice (and desired) side effect)
     while ( ProcessIdle() ) {}
     // it's necessary to call ProcessIdle() to update the frames sizes which
     // might have been changed (it also will update other things set from
     // OnUpdateUI() which is a nice (and desired) side effect)
     while ( ProcessIdle() ) {}

-    
+

     // if there are pending events, we must process them.
     if (wxTheApp)
         wxTheApp->ProcessPendingEvents();
     // if there are pending events, we must process them.
     if (wxTheApp)
         wxTheApp->ProcessPendingEvents();

-    
+

 #if wxUSE_LOG
     wxLog::Resume();
 #endif // wxUSE_LOG
     m_isInsideYield = false;
 #if wxUSE_LOG
     wxLog::Resume();
 #endif // wxUSE_LOG
     m_isInsideYield = false;

-    
+

     return true;
 }
 
     return true;
 }
 


@@ -214,22 +306,12 @@ bool wxCFEventLoop::Pending() const
 
 int wxCFEventLoop::DoProcessEvents()
 {
 
 int wxCFEventLoop::DoProcessEvents()
 {

-    // process pending wx events first as they correspond to low-level events
-    // which happened before, i.e. typically pending events were queued by a
-    // previous call to Dispatch() and if we didn't process them now the next
-    // call to it might enqueue them again (as happens with e.g. socket events
-    // which would be generated as long as there is input available on socket
-    // and this input is only removed from it when pending event handlers are
-    // executed)
-    if ( wxTheApp )
-        wxTheApp->ProcessPendingEvents();
-    
-    return DispatchTimeout( (unsigned long)(m_sleepTime * 1000.0) );
+    return DispatchTimeout( 0 );

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

-    return DispatchTimeout( (unsigned long)(m_sleepTime * 1000.0) ) != 0;
+    return DoProcessEvents() != 0;

 }
 
 int wxCFEventLoop::DispatchTimeout(unsigned long timeout)
 }
 
 int wxCFEventLoop::DispatchTimeout(unsigned long timeout)


@@ -237,10 +319,8 @@ int wxCFEventLoop::DispatchTimeout(unsigned long timeout)
     if ( !wxTheApp )
         return 0;
 
     if ( !wxTheApp )
         return 0;
 

-    wxMacAutoreleasePool autoreleasepool;
-    

     int status = DoDispatchTimeout(timeout);
     int status = DoDispatchTimeout(timeout);

-    
+

     switch( status )
     {
         case 0:
     switch( status )
     {
         case 0:


@@ -248,29 +328,17 @@ int wxCFEventLoop::DispatchTimeout(unsigned long timeout)
         case -1:
             if ( m_shouldExit )
                 return 0;
         case -1:
             if ( m_shouldExit )
                 return 0;

-            
-            if ( ProcessIdle() )
-                m_sleepTime = 0.0 ;
-            else
-            {
-                m_sleepTime = 1.0;
-#if wxUSE_THREADS
-                wxMutexGuiLeave();
-                wxMilliSleep(20);
-                wxMutexGuiEnter();
-#endif
-            }
+

             break;
         case 1:
             break;
         case 1:

-            m_sleepTime = 0;

             break;
     }
             break;
     }

-    
+

     return status;
 }
 
 int wxCFEventLoop::DoDispatchTimeout(unsigned long timeout)
     return status;
 }
 
 int wxCFEventLoop::DoDispatchTimeout(unsigned long timeout)

-{    
+{

     SInt32 status = CFRunLoopRunInMode(kCFRunLoopDefaultMode, timeout / 1000.0 , true);
     switch( status )
     {
     SInt32 status = CFRunLoopRunInMode(kCFRunLoopDefaultMode, timeout / 1000.0 , true);
     switch( status )
     {


@@ -290,18 +358,44 @@ int wxCFEventLoop::DoDispatchTimeout(unsigned long timeout)
     return 1;
 }
 
     return 1;
 }
 

+void wxCFEventLoop::DoRun()
+{
+    for ( ;; )
+    {
+        // generate and process idle events for as long as we don't
+        // have anything else to do
+        DoProcessEvents();
+
+        // if the "should exit" flag is set, the loop should terminate
+        // but not before processing any remaining messages so while
+        // Pending() returns true, do process them
+        if ( m_shouldExit )
+        {
+            while ( DoProcessEvents() == 1 )
+                ;
+
+            break;
+        }
+    }
+}
+
+void wxCFEventLoop::DoStop()
+{
+    CFRunLoopStop(CFGetCurrentRunLoop());
+}
+

 // enters a loop calling OnNextIteration(), Pending() and Dispatch() and
 // terminating when Exit() is called
 int wxCFEventLoop::Run()
 {
     // event loops are not recursive, you need to create another loop!
     wxCHECK_MSG( !IsRunning(), -1, wxT("can't reenter a message loop") );
 // enters a loop calling OnNextIteration(), Pending() and Dispatch() and
 // terminating when Exit() is called
 int wxCFEventLoop::Run()
 {
     // 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);
     // 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,


@@ -313,24 +407,9 @@ int wxCFEventLoop::Run()
         try
         {
 #endif // wxUSE_EXCEPTIONS
         try
         {
 #endif // wxUSE_EXCEPTIONS

-            for ( ;; )
-            {
-                // generate and process idle events for as long as we don't
-                // have anything else to do
-                DoProcessEvents();
-            
-                // if the "should exit" flag is set, the loop should terminate
-                // but not before processing any remaining messages so while
-                // Pending() returns true, do process them
-                if ( m_shouldExit )
-                {
-                    while ( DoProcessEvents() == 1 )
-                        ;
-                    
-                    break;
-                }
-            }
-            
+
+            DoRun();
+

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


@@ -357,7 +436,7 @@ int wxCFEventLoop::Run()
         }
     }
 #endif // wxUSE_EXCEPTIONS
         }
     }
 #endif // wxUSE_EXCEPTIONS

-    
+

     return m_exitcode;
 }
 
     return m_exitcode;
 }
 


@@ -367,7 +446,141 @@ void wxCFEventLoop::Exit(int rc)
 {
     m_exitcode = rc;
     m_shouldExit = true;
 {
     m_exitcode = rc;
     m_shouldExit = true;

-    m_sleepTime = 0;
+    DoStop();
+}
+
+// TODO Move to thread_osx.cpp
+
+#if wxUSE_THREADS
+
+// ----------------------------------------------------------------------------
+// GUI Serialization copied from MSW implementation
+// ----------------------------------------------------------------------------
+
+// if it's false, some secondary thread is holding the GUI lock
+static bool gs_bGuiOwnedByMainThread = true;
+
+// critical section which controls access to all GUI functions: any secondary
+// thread (i.e. except the main one) must enter this crit section before doing
+// any GUI calls
+static wxCriticalSection *gs_critsectGui = NULL;
+
+// critical section which protects gs_nWaitingForGui variable
+static wxCriticalSection *gs_critsectWaitingForGui = NULL;
+
+// number of threads waiting for GUI in wxMutexGuiEnter()
+static size_t gs_nWaitingForGui = 0;
+
+void wxOSXThreadModuleOnInit()
+{
+    gs_critsectWaitingForGui = new wxCriticalSection();
+    gs_critsectGui = new wxCriticalSection();
+    gs_critsectGui->Enter();

 }
 
 
 }
 
 

+void wxOSXThreadModuleOnExit()
+{
+    if ( gs_critsectGui )
+    {
+        if ( !wxGuiOwnedByMainThread() )
+        {
+            gs_critsectGui->Enter();
+            gs_bGuiOwnedByMainThread = true;
+        }
+
+        gs_critsectGui->Leave();
+        wxDELETE(gs_critsectGui);
+    }
+
+    wxDELETE(gs_critsectWaitingForGui);
+}
+
+
+// wake up the main thread
+void WXDLLIMPEXP_BASE wxWakeUpMainThread()
+{
+    wxMacWakeUp();
+}
+
+void wxMutexGuiEnterImpl()
+{
+    // this would dead lock everything...
+    wxASSERT_MSG( !wxThread::IsMain(),
+                 wxT("main thread doesn't want to block in wxMutexGuiEnter()!") );
+
+    // the order in which we enter the critical sections here is crucial!!
+
+    // set the flag telling to the main thread that we want to do some GUI
+    {
+        wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
+
+        gs_nWaitingForGui++;
+    }
+
+    wxWakeUpMainThread();
+
+    // now we may block here because the main thread will soon let us in
+    // (during the next iteration of OnIdle())
+    gs_critsectGui->Enter();
+}
+
+void wxMutexGuiLeaveImpl()
+{
+    wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
+
+    if ( wxThread::IsMain() )
+    {
+        gs_bGuiOwnedByMainThread = false;
+    }
+    else
+    {
+        // decrement the number of threads waiting for GUI access now
+        wxASSERT_MSG( gs_nWaitingForGui > 0,
+                     wxT("calling wxMutexGuiLeave() without entering it first?") );
+
+        gs_nWaitingForGui--;
+
+        wxWakeUpMainThread();
+    }
+
+    gs_critsectGui->Leave();
+}
+
+void WXDLLIMPEXP_BASE wxMutexGuiLeaveOrEnter()
+{
+    wxASSERT_MSG( wxThread::IsMain(),
+                 wxT("only main thread may call wxMutexGuiLeaveOrEnter()!") );
+
+    if ( !gs_critsectWaitingForGui )
+        return;
+
+    wxCriticalSectionLocker enter(*gs_critsectWaitingForGui);
+
+    if ( gs_nWaitingForGui == 0 )
+    {
+        // no threads are waiting for GUI - so we may acquire the lock without
+        // any danger (but only if we don't already have it)
+        if ( !wxGuiOwnedByMainThread() )
+        {
+            gs_critsectGui->Enter();
+
+            gs_bGuiOwnedByMainThread = true;
+        }
+        //else: already have it, nothing to do
+    }
+    else
+    {
+        // some threads are waiting, release the GUI lock if we have it
+        if ( wxGuiOwnedByMainThread() )
+            wxMutexGuiLeave();
+        //else: some other worker thread is doing GUI
+    }
+}
+
+bool WXDLLIMPEXP_BASE wxGuiOwnedByMainThread()
+{
+    return gs_bGuiOwnedByMainThread;
+}
+
+#endif