X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/02761f6cd478e3c2c97cf6f93442747f7b029833..6de7047076f388adc95b2eb5c95d5860d65f2f7d:/src/cocoa/app.mm diff --git a/src/cocoa/app.mm b/src/cocoa/app.mm index a246c4c211..0f30885ea9 100644 --- a/src/cocoa/app.mm +++ b/src/cocoa/app.mm @@ -6,6 +6,7 @@ // Created: 2002/11/27 // RCS-ID: $Id$ // Copyright: (c) David Elliott +// Software 2000 Ltd. // Licence: wxWidgets licence ///////////////////////////////////////////////////////////////////////////// @@ -14,20 +15,17 @@ #include "wx/app.h" #ifndef WX_PRECOMP - #include "wx/dc.h" #include "wx/intl.h" #include "wx/log.h" #include "wx/module.h" #endif -#include "wx/cocoa/ObjcPose.h" +#include "wx/cocoa/ObjcRef.h" #include "wx/cocoa/autorelease.h" #include "wx/cocoa/mbarman.h" #include "wx/cocoa/NSApplication.h" -#if wxUSE_WX_RESOURCES -# include "wx/resource.h" -#endif +#include "wx/cocoa/dc.h" #import #import @@ -37,94 +35,10 @@ #import #import -// ======================================================================== -// wxPoseAsInitializer -// ======================================================================== -wxPoseAsInitializer *wxPoseAsInitializer::sm_first = NULL; +bool wxApp::sm_isEmbedded = false; // Normally we're not a plugin -static bool sg_needIdle = true; - -// ======================================================================== -// wxPoserNSApplication -// ======================================================================== -@interface wxPoserNSApplication : NSApplication -{ -} - -- (NSEvent *)nextEventMatchingMask:(unsigned int)mask untilDate:(NSDate *)expiration inMode:(NSString *)mode dequeue:(BOOL)flag; -- (void)sendEvent: (NSEvent*)anEvent; -@end // wxPoserNSApplication - -WX_IMPLEMENT_POSER(wxPoserNSApplication); - -@implementation wxPoserNSApplication : NSApplication - -/* NOTE: The old method of idle event handling added the handler using the - [NSRunLoop -performSelector:target:argument:order:modes] which caused - the invocation to occur at the begining of [NSApplication - -nextEventMatchingMask:untilDate:expiration:inMode:dequeue:]. However, - the code would be scheduled for invocation with every iteration of - the event loop. This new method simply overrides the method. The - same caveats apply. In particular, by the time the event loop has - called this method, it usually expects to receive an event. If you - plan on stopping the event loop, it is wise to send an event through - the queue to ensure this method will return. - See wxEventLoop::Exit() for more information. - - This overridden method calls the superclass method with an untilDate - parameter that indicates nil should be returned if there are no pending - events. That is, nextEventMatchingMask: should not wait for an event. - If nil is returned then idle event processing occurs until the user - does not request anymore idle events or until a real event comes through. - - RN: Even though Apple documentation states that nil can be passed in place - of [NSDate distantPast] in the untilDate parameter, this causes Jaguar (10.2) - to get stuck in some kind of loop deep within nextEventMatchingMask:, thus we - need to explicitly pass [NSDate distantPast] instead. -*/ - -- (NSEvent *)nextEventMatchingMask:(unsigned int)mask untilDate:(NSDate *)expiration inMode:(NSString *)mode dequeue:(BOOL)flag -{ - // Get the same events except don't block - NSEvent *event = [super nextEventMatchingMask:mask untilDate:[NSDate distantPast] inMode:mode dequeue:flag]; - // If we got one, simply return it - if(event) - return event; - // No events, try doing some idle stuff - if(sg_needIdle -#ifdef __WXDEBUG__ - && !wxTheApp->IsInAssert() -#endif - && ([NSDefaultRunLoopMode isEqualToString:mode] || [NSModalPanelRunLoopMode isEqualToString:mode])) - { - sg_needIdle = false; - wxLogTrace(wxTRACE_COCOA,wxT("Processing idle events")); - while(wxTheApp->ProcessIdle()) - { - // Get the same events except don't block - NSEvent *event = [super nextEventMatchingMask:mask untilDate:[NSDate distantPast] inMode:mode dequeue:flag]; - // If we got one, simply return it - if(event) - return event; - // we didn't get one, do some idle work - wxLogTrace(wxTRACE_COCOA,wxT("Looping idle events")); - } - // No more idle work requested, block - wxLogTrace(wxTRACE_COCOA,wxT("Finished idle processing")); - } - else - wxLogTrace(wxTRACE_COCOA,wxT("Avoiding idle processing sg_needIdle=%d"),sg_needIdle); - return [super nextEventMatchingMask:mask untilDate:expiration inMode:mode dequeue:flag]; -} - -- (void)sendEvent: (NSEvent*)anEvent -{ - wxLogTrace(wxTRACE_COCOA,wxT("SendEvent")); - sg_needIdle = true; - [super sendEvent: anEvent]; -} - -@end // wxPoserNSApplication +// wxNSApplicationObserver singleton. +static wxObjcAutoRefFromAlloc sg_cocoaAppObserver = [[WX_GET_OBJC_CLASS(wxNSApplicationObserver) alloc] init]; // ======================================================================== // wxNSApplicationDelegate @@ -139,6 +53,14 @@ WX_IMPLEMENT_POSER(wxPoserNSApplication); return NO; } +@end // implementation wxNSApplicationDelegate : NSObject +WX_IMPLEMENT_GET_OBJC_CLASS(wxNSApplicationDelegate,NSObject) + +// ======================================================================== +// wxNSApplicationObserver +// ======================================================================== +@implementation wxNSApplicationObserver : NSObject + - (void)applicationWillBecomeActive:(NSNotification *)notification { wxTheApp->CocoaDelegate_applicationWillBecomeActive(); @@ -159,12 +81,18 @@ WX_IMPLEMENT_POSER(wxPoserNSApplication); wxTheApp->CocoaDelegate_applicationDidResignActive(); } +- (void)applicationWillUpdate:(NSNotification *)notification; +{ + wxTheApp->CocoaDelegate_applicationWillUpdate(); +} + - (void)controlTintChanged:(NSNotification *)notification { wxLogDebug(wxT("TODO: send EVT_SYS_COLOUR_CHANGED as appropriate")); } -@end // implementation wxNSApplicationDelegate : NSObject +@end // implementation wxNSApplicationObserver : NSObject +WX_IMPLEMENT_GET_OBJC_CLASS(wxNSApplicationObserver,NSObject) // ======================================================================== // wxApp @@ -174,11 +102,6 @@ WX_IMPLEMENT_POSER(wxPoserNSApplication); // wxApp Static member initialization // ---------------------------------------------------------------------------- IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler) -BEGIN_EVENT_TABLE(wxApp, wxEvtHandler) - EVT_IDLE(wxAppBase::OnIdle) -// EVT_END_SESSION(wxApp::OnEndSession) -// EVT_QUERY_END_SESSION(wxApp::OnQueryEndSession) -END_EVENT_TABLE() // ---------------------------------------------------------------------------- // wxApp initialization/cleanup @@ -202,9 +125,36 @@ bool wxApp::Initialize(int& argc, wxChar **argv) } } - // Posing must be completed before any instances of the Objective-C - // classes being posed as are created. - wxPoseAsInitializer::InitializePosers(); + /* + Cocoa supports -Key value options which set the user defaults key "Key" + to the value "value" Some of them are very handy for debugging like + -NSShowAllViews YES. Cocoa picks these up from the real argv so + our removal of them from the wx copy of it does not affect Cocoa's + ability to see them. + + We basically just assume that any "-NS" option and its following + argument needs to be removed from argv. We hope that user code does + not expect to see -NS options and indeed it's probably a safe bet + since most user code accepting options is probably using the + double-dash GNU-style syntax. + */ + for(int i=1; i < argc; ++i) + { + static const wxChar *ARG_NS = wxT("-NS"); + static const int ARG_NS_LEN = wxStrlen(ARG_NS); + if( wxStrncmp(argv[i], ARG_NS, ARG_NS_LEN) == 0 ) + { + // Only eat this option if it has an argument + if( (i + 1) < argc ) + { + argc -= 2; + memmove(argv + i, argv + i + 2, argc * sizeof(wxChar*)); + // drop back one position so the next run through the loop + // reprocesses the argument at our current index. + --i; + } + } + } return wxAppBase::Initialize(argc, argv); } @@ -213,14 +163,16 @@ void wxApp::CleanUp() { wxAutoNSAutoreleasePool pool; - wxDC::CocoaShutdownTextSystem(); + wxCocoaDCImpl::CocoaShutdownTextSystem(); wxMenuBarManager::DestroyInstance(); - [m_cocoaApp setDelegate:nil]; - [[NSNotificationCenter defaultCenter] removeObserver:m_cocoaAppDelegate - name:NSControlTintDidChangeNotification object:nil]; - [m_cocoaAppDelegate release]; - m_cocoaAppDelegate = NULL; + [[NSNotificationCenter defaultCenter] removeObserver:sg_cocoaAppObserver]; + if(!sm_isEmbedded) + { + [m_cocoaApp setDelegate:nil]; + [m_cocoaAppDelegate release]; + m_cocoaAppDelegate = NULL; + } wxAppBase::CleanUp(); } @@ -232,12 +184,10 @@ wxApp::wxApp() { m_topWindow = NULL; -#ifdef __WXDEBUG__ - m_isInAssert = false; -#endif // __WXDEBUG__ - argc = 0; +#if !wxUSE_UNICODE argv = NULL; +#endif m_cocoaApp = NULL; m_cocoaAppDelegate = NULL; } @@ -267,18 +217,58 @@ bool wxApp::OnInitGui() // Create the app using the sharedApplication method m_cocoaApp = [NSApplication sharedApplication]; - m_cocoaAppDelegate = [[wxNSApplicationDelegate alloc] init]; - [m_cocoaApp setDelegate:m_cocoaAppDelegate]; - [[NSNotificationCenter defaultCenter] addObserver:m_cocoaAppDelegate + + if(!sm_isEmbedded) + { + // Enable response to application delegate messages + m_cocoaAppDelegate = [[WX_GET_OBJC_CLASS(wxNSApplicationDelegate) alloc] init]; + [m_cocoaApp setDelegate:m_cocoaAppDelegate]; + } + + // Enable response to "delegate" messages on the notification observer + [[NSNotificationCenter defaultCenter] addObserver:sg_cocoaAppObserver + selector:@selector(applicationWillBecomeActive:) + name:NSApplicationWillBecomeActiveNotification object:nil]; + + [[NSNotificationCenter defaultCenter] addObserver:sg_cocoaAppObserver + selector:@selector(applicationDidBecomeActive:) + name:NSApplicationDidBecomeActiveNotification object:nil]; + + [[NSNotificationCenter defaultCenter] addObserver:sg_cocoaAppObserver + selector:@selector(applicationWillResignActive:) + name:NSApplicationWillResignActiveNotification object:nil]; + + [[NSNotificationCenter defaultCenter] addObserver:sg_cocoaAppObserver + selector:@selector(applicationDidResignActive:) + name:NSApplicationDidResignActiveNotification object:nil]; + + [[NSNotificationCenter defaultCenter] addObserver:sg_cocoaAppObserver + selector:@selector(applicationWillUpdate:) + name:NSApplicationWillUpdateNotification object:nil]; + + // Enable response to system notifications + [[NSNotificationCenter defaultCenter] addObserver:sg_cocoaAppObserver selector:@selector(controlTintChanged:) name:NSControlTintDidChangeNotification object:nil]; - wxMenuBarManager::CreateInstance(); + if(!sm_isEmbedded) + wxMenuBarManager::CreateInstance(); - wxDC::CocoaInitializeTextSystem(); + wxCocoaDCImpl::CocoaInitializeTextSystem(); return true; } +wxApp::~wxApp() +{ + if(m_cfRunLoopIdleObserver != NULL) + { + // Invalidate the observer which also removes it from the run loop. + CFRunLoopObserverInvalidate(m_cfRunLoopIdleObserver); + // Release the ref as we don't need it anymore. + m_cfRunLoopIdleObserver.reset(); + } +} + bool wxApp::CallOnInit() { // wxAutoNSAutoreleasePool pool; @@ -300,67 +290,223 @@ void wxApp::Exit() wxAppConsole::Exit(); } -// Yield to other processes -bool wxApp::Yield(bool onlyIfNeeded) +void wxApp::WakeUpIdle() { - // MT-FIXME - static bool s_inYield = false; + /* When called from the main thread the NSAutoreleasePool managed by + the [NSApplication run] method would ordinarily be in place and so + one would think a pool here would be unnecessary. + + However, when called from a different thread there is usually no + NSAutoreleasePool in place because wxThread has no knowledge of + wxCocoa. The pool here is generally only ever going to contain + the NSEvent we create with the factory method. As soon as we add + it to the main event queue with postEvent:atStart: it is retained + and so safe for our pool to release. + */ + wxAutoNSAutoreleasePool pool; + /* NOTE: This is a little heavy handed. What this does is cause an + AppKit NSEvent to be added to NSApplication's queue (which is always + on the main thread). This will cause the main thread runloop to + exit which returns control to nextEventMatchingMask which returns + the event which is then sent with sendEvent: and essentially dropped + since it's not for a window (windowNumber 0) and NSApplication + certainly doesn't understand it. + + With the exception of wxEventLoop::Exit which uses us to cause the + runloop to exit and return to the NSApplication event loop, most + callers only need wx idle to happen, or more specifically only really + need to ensure that ProcessPendingEvents is called which is currently + done without exiting the runloop. + + Be careful if you decide to change the implementation of this method + as wxEventLoop::Exit depends on the current behavior. + */ + [m_cocoaApp postEvent:[NSEvent otherEventWithType:NSApplicationDefined + location:NSZeroPoint modifierFlags:NSAnyEventMask + timestamp:0 windowNumber:0 context:nil + subtype:0 data1:0 data2:0] atStart:NO]; +} -#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 +extern "C" static void ObserveMainRunLoopBeforeWaiting(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info); +extern "C" static void ObserveMainRunLoopBeforeWaiting(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void *info) +{ + static_cast(info)->CF_ObserveMainRunLoopBeforeWaiting(observer, activity); +} - if (s_inYield) - { - if ( !onlyIfNeeded ) - { - wxFAIL_MSG( wxT("wxYield called recursively" ) ); - } +#if 0 +static int sg_cApplicationWillUpdate = 0; +#endif - return false; - } +/*! + Invoked from the applicationWillUpdate notification observer. See the + NSApplication documentation for the official statement on when this + will be called. Since it can be hard to understand for a Cocoa newbie + I'll try to explain it here as it relates to wxCocoa. + + Basically, we get called from within nextEventMatchingMask if and only + if any user code told the application to send the update notification + (sort of like a request for idle events). However, unlike wx idle events, + this notification is sent quite often, nearly every time through the loop + because nearly every control tells the application to send it. + + Because wx idle events are only supposed to be sent when the event loop + is about to block we instead schedule a function to be called just + before the run loop waits and send the idle events from there. + + It also has the desirable effect of only sending the wx idle events when + the event loop is actualy going to block. If the event loop is being + pumped manualy (e.g. like a PeekMessage) then the kCFRunLoopBeforeWaiting + observer never fires. Our Yield() method depends on this because sending + idle events from within Yield would be bad. + + Normally you might think that we could just set the observer up once and + leave it attached. However, this is problematic because our run loop + observer calls user code (the idle handlers) which can actually display + modal dialogs. Displaying a modal dialog causes reentry of the event + loop, usually in a different run loop mode than the main loop (e.g. in + modal-dialog mode instead of default mode). Because we only register the + observer with the run loop mode at the time of this call, it won't be + called from a modal loop. + + We want it to be called and thus we need a new observer. + */ +void wxApp::CocoaDelegate_applicationWillUpdate() +{ + wxLogTrace(wxTRACE_COCOA,wxT("applicationWillUpdate")); - s_inYield = true; +// CFRunLoopRef cfRunLoop = [[NSRunLoop currentRunLoop] getCFRunLoop]; + CFRunLoopRef cfRunLoop = CFRunLoopGetCurrent(); + wxCFRef cfRunLoopMode(CFRunLoopCopyCurrentMode(cfRunLoop)); - // Run the event loop until it is out of events - while(1) + /* If we have an observer and that observer is for the wrong run loop + mode then invalidate it and release it. + */ + if(m_cfRunLoopIdleObserver != NULL && m_cfObservedRunLoopMode != cfRunLoopMode) { - wxAutoNSAutoreleasePool pool; - NSEvent *event = [GetNSApplication() - nextEventMatchingMask:NSAnyEventMask - untilDate:[NSDate distantPast] - inMode:NSDefaultRunLoopMode - dequeue: YES]; - if(!event) - break; - [GetNSApplication() sendEvent: event]; + CFRunLoopObserverInvalidate(m_cfRunLoopIdleObserver); + m_cfRunLoopIdleObserver.reset(); + } +#if 0 + ++sg_cApplicationWillUpdate; +#endif + /* This will be true either on the first call or when the above code has + invalidated and released the exisiting observer. + */ + if(m_cfRunLoopIdleObserver == NULL) + { + // Enable idle event handling + CFRunLoopObserverContext observerContext = + { 0 + , this + , NULL + , NULL + , NULL + }; + /* NOTE: I can't recall why we don't just let the observer repeat + instead of invalidating itself each time it fires thus requiring + it to be recreated for each shot but there was if I remember + some good (but very obscure) reason for it. + + On the other hand, I could be wrong so don't take that as gospel. + */ + m_cfRunLoopIdleObserver.reset(CFRunLoopObserverCreate(kCFAllocatorDefault, kCFRunLoopBeforeWaiting, /*repeats*/FALSE, /*priority*/0, ObserveMainRunLoopBeforeWaiting, &observerContext)); + m_cfObservedRunLoopMode = cfRunLoopMode; + CFRunLoopAddObserver(cfRunLoop, m_cfRunLoopIdleObserver, m_cfObservedRunLoopMode); } - -#if wxUSE_LOG - // let the logs be flashed again - wxLog::Resume(); -#endif // wxUSE_LOG - - s_inYield = false; - - return true; } -void wxApp::WakeUpIdle() +static inline bool FakeNeedMoreIdle() { - [m_cocoaApp postEvent:[NSEvent otherEventWithType:NSApplicationDefined - location:NSZeroPoint modifierFlags:NSAnyEventMask - timestamp:0 windowNumber:0 context:nil - subtype:0 data1:0 data2:0] atStart:NO]; +#if 0 +// Return true on every 10th call. + static int idleCount = 0; + return ++idleCount % 10; +#else + return false; +#endif } -#ifdef __WXDEBUG__ -void wxApp::OnAssert(const wxChar *file, int line, const wxChar* cond, const wxChar *msg) +/*! + Called by CFRunLoop just before waiting. This is the appropriate time to + send idle events. Unlike other ports, we don't peek the queue for events + and stop idling if there is one. Instead, if the user requests more idle + events we tell Cocoa to send us an applicationWillUpdate notification + which will cause our observer of that notification to tell CFRunLoop to + call us before waiting which will cause us to be fired again but only + after exhausting the event queue. + + The reason we do it this way is that peeking for an event causes CFRunLoop + to reenter and fire off its timers, observers, and sources which we're + better off avoiding. Doing it this way, we basically let CFRunLoop do the + work of peeking for the next event which is much nicer. + */ +void wxApp::CF_ObserveMainRunLoopBeforeWaiting(CFRunLoopObserverRef observer, int activity) { - m_isInAssert = true; - wxAppBase::OnAssert(file, line, cond, msg); - m_isInAssert = false; + // Ensure that CocoaDelegate_applicationWillUpdate will recreate us. + // We've already been invalidated by CFRunLoop because we are one-shot. + m_cfRunLoopIdleObserver.reset(); +#if 0 + wxLogTrace(wxTRACE_COCOA,wxT("Idle BEGIN (%d)"), sg_cApplicationWillUpdate); + sg_cApplicationWillUpdate = 0; +#else + wxLogTrace(wxTRACE_COCOA,wxT("Idle BEGIN")); +#endif + if( ProcessIdle() || FakeNeedMoreIdle() ) + { + wxLogTrace(wxTRACE_COCOA, wxT("Idle REQUEST MORE")); + [NSApp setWindowsNeedUpdate:YES]; + } + else + { + wxLogTrace(wxTRACE_COCOA, wxT("Idle END")); + } } -#endif // __WXDEBUG__ + +/* A note about Cocoa's event loops vs. run loops: + + It's important to understand that Cocoa has a two-level event loop. The + outer level is run by NSApplication and can only ever happen on the main + thread. The nextEventMatchingMask:untilDate:inMode:dequeue: method returns + the next event which is then given to sendEvent: to send it. These + methods are defined in NSApplication and are thus part of AppKit. + + Events (NSEvent) are only sent due to actual user actions like clicking + the mouse or moving the mouse or pressing a key and so on. There are no + paint events; there are no timer events; there are no socket events; there + are no idle events. + + All of those types of "events" have nothing to do with the GUI at all. + That is why Cocoa's AppKit doesn't implement them. Instead, they are + implemented in Foundation's NSRunLoop which on OS X uses CFRunLoop + to do the actual work. + + How NSApplication uses NSRunLoop is rather interesting. Basically, it + interacts with NSRunLoop only from within the nextEventMatchingMask + method. It passes its inMode: argument almost directly to NSRunLoop + and thus CFRunLoop. The run loop then runs (e.g. loops) until it + is told to exit. The run loop calls the callout functions directly. + From within those callout functions the run loop is considered to + be running. Presumably, the AppKit installs a run loop source to + receive messages from the window server over the mach port (like a + socket). For some messages (e.g. need to paint) the AppKit will + call application code like drawRect: without exiting the run loop. + For other messages (ones that can be encapsulated in an NSEvent) + the AppKit tells the run loop to exit which returns control to + the nextEventMatchingMask method which then returns the NSEvent + object. It's important to note that once the runloop has exited + it is no longer considered running and thus if you ask it which + mode it is running in it will return nil. + + When manually pumping the event loop care should be taken to + tell it to run in the correct mode. For instance, if you are + using it to run a modal dialog then you want to run it in + the modal panel run loop mode. AppKit presumably has sources + or timers or observers that specifically don't listen on this + mode. Another interesting mode is the connection reply mode. + This allows Cocoa to wait for a response from a distributed + objects message without firing off user code that may result + in a DO call being made thus recursing. So basically, the + mode is a way for Cocoa to attempt to avoid run loop recursion + but to allow it under certain circumstances. + */ +