X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/3905012063ade424bf95283508da6507350cbe58..6695aca2e25ca3bf77b705cb745be86e4d486e3e:/src/cocoa/app.mm diff --git a/src/cocoa/app.mm b/src/cocoa/app.mm index 4ef6974b2f..bc8af99d71 100644 --- a/src/cocoa/app.mm +++ b/src/cocoa/app.mm @@ -1,128 +1,66 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: cocoa/app.mm +// Name: src/cocoa/app.mm // Purpose: wxApp // Author: David Elliott // Modified by: // Created: 2002/11/27 // RCS-ID: $Id$ // Copyright: (c) David Elliott -// Licence: wxWindows licence +// Software 2000 Ltd. +// Licence: wxWidgets licence ///////////////////////////////////////////////////////////////////////////// #include "wx/wxprec.h" + +#include "wx/app.h" + #ifndef WX_PRECOMP - #include "wx/defs.h" - #include "wx/app.h" - #include "wx/frame.h" - #include "wx/dialog.h" - #include "wx/dc.h" #include "wx/intl.h" #include "wx/log.h" + #include "wx/module.h" #endif -#include "wx/module.h" - -#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 -#import -#import #import #import +#import +#import +#import -// ======================================================================== -// wxPoseAsInitializer -// ======================================================================== -wxPoseAsInitializer *wxPoseAsInitializer::sm_first = NULL; - -// ======================================================================== -// wxPoserNSApplication -// ======================================================================== -@interface wxPoserNSApplication : NSApplication -{ -} - -- (void)sendEvent: (NSEvent*)anEvent; -@end // wxPoserNSApplication - -WX_IMPLEMENT_POSER(wxPoserNSApplication); - -@implementation wxPoserNSApplication : NSApplication +bool wxApp::sm_isEmbedded = false; // Normally we're not a plugin -- (void)sendEvent: (NSEvent*)anEvent -{ - wxLogDebug("SendEvent"); - wxTheApp->CocoaInstallRequestedIdleHandler(); - [super sendEvent: anEvent]; -} - -@end // wxPoserNSApplication +// wxNSApplicationObserver singleton. +static wxObjcAutoRefFromAlloc sg_cocoaAppObserver = [[WX_GET_OBJC_CLASS(wxNSApplicationObserver) alloc] init]; // ======================================================================== // wxNSApplicationDelegate // ======================================================================== -@interface wxNSApplicationDelegate : NSObject -{ -} - -- (void)doIdle: (id)data; -// Delegate methods -- (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication *)theApplication; -- (void)applicationWillBecomeActive:(NSNotification *)notification; -- (void)applicationDidBecomeActive:(NSNotification *)notification; -- (void)applicationWillResignActive:(NSNotification *)notification; -- (void)applicationDidResignActive:(NSNotification *)notification; -@end // interface wxNSApplicationDelegate : NSObject - @implementation wxNSApplicationDelegate : NSObject -- (void)doIdle: (id)data -{ - wxASSERT(wxTheApp); - wxASSERT(wxMenuBarManager::GetInstance()); - wxLogDebug("doIdle called"); -#ifdef __WXDEBUG__ - if(wxTheApp->IsInAssert()) - { - wxLogDebug("Idle events ignored durring assertion dialog"); - } - else -#endif - { - NSRunLoop *rl = [NSRunLoop currentRunLoop]; - // runMode: beforeDate returns YES if something was done - while(wxTheApp->ProcessIdle()) // FIXME: AND NO EVENTS ARE PENDING - { - wxLogDebug("Looping for idle events"); - #if 1 - if( [rl runMode:[rl currentMode] beforeDate:[NSDate distantPast]]) - { - wxLogDebug("Found actual work to do"); - break; - } - #endif - } - } - wxLogDebug("Idle processing complete, requesting next idle event"); - // Add ourself back into the run loop (on next event) if necessary - wxTheApp->CocoaRequestIdle(); -} - // NOTE: Terminate means that the event loop does NOT return and thus -// cleanup code doesn't properly execute. Furthermore, wxWindows has its +// cleanup code doesn't properly execute. Furthermore, wxWidgets has its // own exit on frame delete mechanism. - (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication *)theApplication { return NO; } +@end // implementation wxNSApplicationDelegate : NSObject +WX_IMPLEMENT_GET_OBJC_CLASS(wxNSApplicationDelegate,NSObject) + +// ======================================================================== +// wxNSApplicationObserver +// ======================================================================== +@implementation wxNSApplicationObserver : NSObject + - (void)applicationWillBecomeActive:(NSNotification *)notification { wxTheApp->CocoaDelegate_applicationWillBecomeActive(); @@ -143,7 +81,18 @@ WX_IMPLEMENT_POSER(wxPoserNSApplication); wxTheApp->CocoaDelegate_applicationDidResignActive(); } -@end // implementation wxNSApplicationDelegate : NSObject +- (void)applicationWillUpdate:(NSNotification *)notification; +{ + wxTheApp->CocoaDelegate_applicationWillUpdate(); +} + +- (void)controlTintChanged:(NSNotification *)notification +{ + wxLogDebug(wxT("TODO: send EVT_SYS_COLOUR_CHANGED as appropriate")); +} + +@end // implementation wxNSApplicationObserver : NSObject +WX_IMPLEMENT_GET_OBJC_CLASS(wxNSApplicationObserver,NSObject) // ======================================================================== // wxApp @@ -153,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 @@ -172,18 +116,45 @@ bool wxApp::Initialize(int& argc, wxChar **argv) // application (otherwise applications would need to handle it) if ( argc > 1 ) { - static const wxChar *ARG_PSN = _T("-psn_"); - if ( wxStrncmp(argv[1], ARG_PSN, strlen(ARG_PSN)) == 0 ) + static const wxChar *ARG_PSN = wxT("-psn_"); + if ( wxStrncmp(argv[1], ARG_PSN, wxStrlen(ARG_PSN)) == 0 ) { // remove this argument --argc; - memmove(argv + 1, argv + 2, argc * sizeof(char *)); + memmove(argv + 1, argv + 2, argc * sizeof(wxChar *)); } } - // 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); } @@ -192,12 +163,16 @@ void wxApp::CleanUp() { wxAutoNSAutoreleasePool pool; - wxDC::CocoaShutdownTextSystem(); + wxCocoaDCImpl::CocoaShutdownTextSystem(); wxMenuBarManager::DestroyInstance(); - [m_cocoaApp setDelegate: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(); } @@ -209,48 +184,14 @@ wxApp::wxApp() { m_topWindow = NULL; - m_isIdle = true; -#if WXWIN_COMPATIBILITY_2_2 - m_wantDebugOutput = TRUE; -#endif -#ifdef __WXDEBUG__ - m_isInAssert = FALSE; -#endif // __WXDEBUG__ - argc = 0; +#if !wxUSE_UNICODE argv = NULL; +#endif m_cocoaApp = NULL; m_cocoaAppDelegate = NULL; } -void wxApp::CocoaInstallIdleHandler() -{ - // If we're not the main thread, don't install the idle handler - if(m_cocoaMainThread != [NSThread currentThread]) - { - wxLogDebug("Attempt to install idle handler from secondary thread"); - return; - } - // If we're supposed to be stopping, don't add more idle events - if(![m_cocoaApp isRunning]) - return; - wxLogDebug("wxApp::CocoaInstallIdleHandler"); - m_isIdle = false; - // Call doIdle for EVERYTHING dammit -// We'd need Foundation/NSConnection.h for this next constant, do we need it? - [[ NSRunLoop currentRunLoop ] performSelector:@selector(doIdle:) target:m_cocoaAppDelegate argument:NULL order:0 modes:[NSArray arrayWithObjects:NSDefaultRunLoopMode, /* NSConnectionReplyRunLoopMode,*/ NSModalPanelRunLoopMode, /**/NSEventTrackingRunLoopMode,/**/ nil] ]; - /* Notes: - In the Mac OS X implementation of Cocoa, the above method schedules - doIdle: to be called from *within* [NSApplication - -nextEventMatchingMask:untilDate:inMode:dequeue:]. That is, no - NSEvent object is generated and control does not return from that - method. In fact, control will only return from that method for the - usual reasons (e.g. a real event is received or the untilDate is reached). - This has implications when trying to stop the event loop and return to - its caller. See wxEventLoop::Exit - */ -} - void wxApp::CocoaDelegate_applicationWillBecomeActive() { } @@ -272,23 +213,60 @@ bool wxApp::OnInitGui() { wxAutoNSAutoreleasePool pool; if(!wxAppBase::OnInitGui()) - return FALSE; + return false; // Create the app using the sharedApplication method m_cocoaApp = [NSApplication sharedApplication]; - m_cocoaAppDelegate = [[wxNSApplicationDelegate alloc] init]; - [m_cocoaApp setDelegate:m_cocoaAppDelegate]; - - wxMenuBarManager::CreateInstance(); - - wxDC::CocoaInitializeTextSystem(); -// [ m_cocoaApp setDelegate:m_cocoaApp ]; - #if 0 - wxLogDebug("Just for kicks"); - [ m_cocoaAppDelegate performSelector:@selector(doIdle:) withObject:NULL ]; - wxLogDebug("okay.. done now"); - #endif - return TRUE; + + 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]; + + if(!sm_isEmbedded) + wxMenuBarManager::CreateInstance(); + + 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() @@ -300,9 +278,9 @@ bool wxApp::CallOnInit() bool wxApp::OnInit() { if(!wxAppBase::OnInit()) - return FALSE; + return false; - return TRUE; + return true; } void wxApp::Exit() @@ -312,56 +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(NSEvent *event = [GetNSApplication() - nextEventMatchingMask:NSAnyEventMask - untilDate:[NSDate distantPast] - inMode:NSDefaultRunLoopMode - dequeue: YES]) + /* 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) { - [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; +static inline bool FakeNeedMoreIdle() +{ +#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. + */