adding magnification API into the wxWindow classes for best retina support

[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 f151cb5684405c6c01444a48872fd48f2a964a19..9eefc0d22bf1da8d19c9f59401f93924ed930b0b 100644 (file)
--- a/src/osx/core/evtloop_cf.cpp
+++ b/src/osx/core/evtloop_cf.cpp
@@ -25,8 +25,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"


@@ -48,7 +46,8 @@
 // wxCFEventLoopSource and wxCFEventLoop implementation
 // ============================================================================
 
 // wxCFEventLoopSource and wxCFEventLoop implementation
 // ============================================================================
 

-#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
+#if wxUSE_EVENTLOOP_SOURCE
+

 namespace
 {
 
 namespace
 {
 


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

+    // Enable the callbacks initially.
+    EnableDescriptorCallBacks(cffd, source->GetFlags());
+

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


@@ -133,28 +135,23 @@ wxCFEventLoopSource::~wxCFEventLoopSource()
         CFRelease(m_cffd);
 }
 
         CFRelease(m_cffd);
 }
 

-#else // OS X < 10.5
+#endif // wxUSE_EVENTLOOP_SOURCE

 
 

-wxEventLoopSource *
-wxCFEventLoop::AddSourceForFD(int WXUNUSED(fd),
-                              wxEventLoopSourceHandler * WXUNUSED(handler),
-                              int WXUNUSED(flags))
+void wxCFEventLoop::OSXCommonModeObserverCallBack(CFRunLoopObserverRef observer, int activity, void *info)

 {
 {

-    return NULL;
+    wxCFEventLoop * eventloop = static_cast<wxCFEventLoop *>(info);
+    if ( eventloop )
+        eventloop->CommonModeObserverCallBack(observer, activity);

 }
 
 }
 

-#endif // MAC_OS_X_VERSION_MAX_ALLOWED
-
-#endif // wxUSE_EVENTLOOP_SOURCE
-
-extern "C" void wxObserverCallBack(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info)
+void wxCFEventLoop::OSXDefaultModeObserverCallBack(CFRunLoopObserverRef observer, int activity, void *info)

 {
     wxCFEventLoop * eventloop = static_cast<wxCFEventLoop *>(info);
     if ( eventloop )
 {
     wxCFEventLoop * eventloop = static_cast<wxCFEventLoop *>(info);
     if ( eventloop )

-        eventloop->ObserverCallBack(observer, activity);
+        eventloop->DefaultModeObserverCallBack(observer, activity);

 }
 
 }
 

-void wxCFEventLoop::ObserverCallBack(CFRunLoopObserverRef WXUNUSED(observer), int activity)
+void wxCFEventLoop::CommonModeObserverCallBack(CFRunLoopObserverRef WXUNUSED(observer), int activity)

 {
     if ( activity & kCFRunLoopBeforeTimers )
     {
 {
     if ( activity & kCFRunLoopBeforeTimers )
     {


@@ -166,13 +163,13 @@ void wxCFEventLoop::ObserverCallBack(CFRunLoopObserverRef WXUNUSED(observer), in
         // 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();
         }


@@ -185,24 +182,52 @@ void wxCFEventLoop::ObserverCallBack(CFRunLoopObserverRef WXUNUSED(observer), in
     }
 }
 
     }
 }
 

+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_processIdleEvents = true;

 
 

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

     m_runLoop = CFGetCurrentRunLoop();
 
     CFRunLoopObserverContext ctxt;
     bzero( &ctxt, sizeof(ctxt) );
     ctxt.info = this;
     m_runLoop = CFGetCurrentRunLoop();
 
     CFRunLoopObserverContext ctxt;
     bzero( &ctxt, sizeof(ctxt) );
     ctxt.info = this;

-    m_runLoopObserver = CFRunLoopObserverCreate( kCFAllocatorDefault, kCFRunLoopBeforeTimers | kCFRunLoopBeforeWaiting , true /* repeats */, 0,
-                                            wxObserverCallBack, &ctxt );
-    CFRunLoopAddObserver(m_runLoop, m_runLoopObserver, kCFRunLoopCommonModes);
-    CFRelease(m_runLoopObserver);
+    m_commonModeRunLoopObserver = CFRunLoopObserverCreate( kCFAllocatorDefault, kCFRunLoopBeforeTimers | kCFRunLoopBeforeWaiting , true /* repeats */, 0,
+                                                          (CFRunLoopObserverCallBack) wxCFEventLoop::OSXCommonModeObserverCallBack, &ctxt );
+    CFRunLoopAddObserver(m_runLoop, m_commonModeRunLoopObserver, kCFRunLoopCommonModes);
+
+    m_defaultModeRunLoopObserver = CFRunLoopObserverCreate( kCFAllocatorDefault, kCFRunLoopBeforeTimers | kCFRunLoopBeforeWaiting , true /* repeats */, 0,
+                                                           (CFRunLoopObserverCallBack) wxCFEventLoop::OSXDefaultModeObserverCallBack, &ctxt );
+    CFRunLoopAddObserver(m_runLoop, m_defaultModeRunLoopObserver, kCFRunLoopDefaultMode);

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

-    CFRunLoopRemoveObserver(m_runLoop, m_runLoopObserver, kCFRunLoopCommonModes);
+    CFRunLoopRemoveObserver(m_runLoop, m_commonModeRunLoopObserver, kCFRunLoopCommonModes);
+    CFRunLoopRemoveObserver(m_runLoop, m_defaultModeRunLoopObserver, kCFRunLoopDefaultMode);
+
+    CFRelease(m_defaultModeRunLoopObserver);
+    CFRelease(m_commonModeRunLoopObserver);

 }
 
 
 }
 
 


@@ -277,7 +302,15 @@ bool wxCFEventLoop::Pending() const
 
 int wxCFEventLoop::DoProcessEvents()
 {
 
 int wxCFEventLoop::DoProcessEvents()
 {

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

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


@@ -420,6 +453,25 @@ void wxCFEventLoop::Exit(int rc)
     DoStop();
 }
 
     DoStop();
 }
 

+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
 
 #if wxUSE_THREADS
 // TODO Move to thread_osx.cpp
 
 #if wxUSE_THREADS