// Copyright (C) 2018 The Qt Company Ltd. // Copyright (c) 2007-2008, Apple, Inc. // SPDX-License-Identifier: BSD-3-Clause // Qt-Security score:significant reason:default #include #include "qcocoaapplicationdelegate.h" #include "qcocoaintegration.h" #include "qcocoamenubar.h" #include "qcocoamenu.h" #include "qcocoamenuloader.h" #include "qcocoamenuitem.h" #include "qcocoansmenu.h" #include "qcocoahelpers.h" #if QT_CONFIG(sessionmanager) # include "qcocoasessionmanager.h" #endif #include #include #include #include #include #include #include QT_USE_NAMESPACE @implementation QCocoaApplicationDelegate { NSObject *reflectionDelegate; bool inLaunch; } + (instancetype)sharedDelegate { static QCocoaApplicationDelegate *shared = nil; static dispatch_once_t onceToken; dispatch_once(&onceToken, ^{ shared = [[self alloc] init]; atexit_b(^{ [shared release]; shared = nil; }); }); return shared; } - (instancetype)init { self = [super init]; if (self) { inLaunch = true; } return self; } - (void)dealloc { [_dockMenu release]; if (reflectionDelegate) { [[NSApplication sharedApplication] setDelegate:reflectionDelegate]; [reflectionDelegate release]; } [[NSNotificationCenter defaultCenter] removeObserver:self]; [super dealloc]; } - (NSMenu *)applicationDockMenu:(NSApplication *)sender { Q_UNUSED(sender); // Manually invoke the delegate's -menuWillOpen: method. // See QTBUG-39604 (and its fix) for details. [self.dockMenu.delegate menuWillOpen:self.dockMenu]; return [[self.dockMenu retain] autorelease]; } // This function will only be called when NSApp is actually running. - (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender { if ([reflectionDelegate respondsToSelector:_cmd]) return [reflectionDelegate applicationShouldTerminate:sender]; if (QGuiApplicationPrivate::instance()->threadData.loadRelaxed()->eventLoops.isEmpty()) { // No event loop is executing. This probably means that Qt is used as a plugin, // or as a part of a native Cocoa application. In any case it should be fine to // terminate now. qCDebug(lcQpaApplication) << "No running event loops, terminating now"; return NSTerminateNow; } #if QT_CONFIG(sessionmanager) QCocoaSessionManager *cocoaSessionManager = QCocoaSessionManager::instance(); cocoaSessionManager->resetCancellation(); cocoaSessionManager->appCommitData(); if (cocoaSessionManager->wasCanceled()) { qCDebug(lcQpaApplication) << "Session management canceled application termination"; return NSTerminateCancel; } #endif if (!QWindowSystemInterface::handleApplicationTermination()) { qCDebug(lcQpaApplication) << "Application termination canceled"; return NSTerminateCancel; } // Even if the application termination was accepted by the application we can't // return NSTerminateNow, as that would trigger AppKit to ultimately call exit(). // We need to ensure that the runloop continues spinning so that we can return // from our own event loop back to main(), and exit from there. qCDebug(lcQpaApplication) << "Termination accepted, but returning to runloop for exit through main()"; return NSTerminateCancel; } - (void)applicationWillFinishLaunching:(NSNotification *)notification { if ([reflectionDelegate respondsToSelector:_cmd]) [reflectionDelegate applicationWillFinishLaunching:notification]; /* From the Cocoa documentation: "A good place to install event handlers is in the applicationWillFinishLaunching: method of the application delegate. At that point, the Application Kit has installed its default event handlers, so if you install a handler for one of the same events, it will replace the Application Kit version." */ /* If Qt is used as a plugin, we let the 3rd party application handle events like quit and open file events. Otherwise, if we install our own handlers, we easily end up breaking functionality the 3rd party application depends on. */ NSAppleEventManager *eventManager = [NSAppleEventManager sharedAppleEventManager]; [eventManager setEventHandler:self andSelector:@selector(getUrl:withReplyEvent:) forEventClass:kInternetEventClass andEventID:kAEGetURL]; } // called by QCocoaIntegration's destructor before resetting the application delegate to nil - (void)removeAppleEventHandlers { NSAppleEventManager *eventManager = [NSAppleEventManager sharedAppleEventManager]; [eventManager removeEventHandlerForEventClass:kInternetEventClass andEventID:kAEGetURL]; } - (bool)inLaunch { return inLaunch; } - (void)applicationDidFinishLaunching:(NSNotification *)aNotification { if ([reflectionDelegate respondsToSelector:_cmd]) [reflectionDelegate applicationDidFinishLaunching:aNotification]; inLaunch = false; if (qEnvironmentVariableIsEmpty("QT_MAC_DISABLE_FOREGROUND_APPLICATION_TRANSFORM")) { auto currentApplication = NSRunningApplication.currentApplication; if (!currentApplication.active) { // Move the application to front to avoid launching behind the terminal. // Ignoring other apps is necessary (we must ignore the terminal), but makes // Qt apps play slightly less nice with other apps when launching from Finder // (see the activateIgnoringOtherApps docs). FIXME: Try to distinguish between // being non-active here because another application stole activation in the // time it took us to launch from Finder, and being non-active because we were // launched from Terminal or something that doesn't activate us at all. auto frontmostApplication = NSWorkspace.sharedWorkspace.frontmostApplication; qCDebug(lcQpaApplication) << "Launched with" << frontmostApplication << "as frontmost application. Activating" << currentApplication << "instead."; [NSApplication.sharedApplication activateIgnoringOtherApps:YES]; } if (QOperatingSystemVersion::current() >= QOperatingSystemVersion::MacOSSonoma) { // Qt windows are typically shown in main(), at which point the application // is not active yet. When the application is activated, either externally // or via the override above, it will only bring the main and key windows // forward, which differs from the behavior if these windows had been shown // once the application was already active. To work around this, we explicitly // activate the current application again, bringing all windows to the front. // We only do this on Sonoma and up, as earlier macOS versions have a bug where // the app will deactivate as part of activating, even if it's active app, // which in turn results in losing key window status for the key window. // FIXME: Consider bringing our windows to the front via orderFront instead, // or deferring the orderFront during setVisible until the app is active. [currentApplication activateWithOptions:NSApplicationActivateAllWindows]; } } QCocoaMenuBar::insertWindowMenu(); } /*! Tells the delegate to open the specified files Sent by the system when the user drags a file to the app's icon in places like Finder or the Dock, or opens a file via the "Open With" menu in Finder. These actions can happen when the application is not running, in which case the call comes in between willFinishLaunching and didFinishLaunching. In this case we don't pass on the incoming file paths as file open events, as the paths are also part of the command line arguments, and Qt applications normally expect to handle file opening via those. \note The app must register itself as a handler for each file type via the CFBundleDocumentTypes key in the Info.plist. */ - (void)application:(NSApplication *)sender openFiles:(NSArray *)filenames { Q_UNUSED(filenames); Q_UNUSED(sender); for (NSString *fileName in filenames) { QString qtFileName = QString::fromNSString(fileName); if (inLaunch) { // We need to be careful because Cocoa will be nice enough to take // command line arguments and send them to us as events. Given the history // of Qt Applications, this will result in behavior people don't want, as // they might be doing the opening themselves with the command line parsing. if (qApp->arguments().contains(qtFileName)) continue; } QUrl url = qt_apple_urlFromPossiblySecurityScopedURL([NSURL fileURLWithPath:fileName]); QWindowSystemInterface::handleFileOpenEvent(url); // FIXME: We're supposed to call [NSApp replyToOpenOrPrint:] here, but we // don't know if the open operation succeeded, failed, or was cancelled. } if ([reflectionDelegate respondsToSelector:_cmd]) [reflectionDelegate application:sender openFiles:filenames]; } - (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication *)sender { if ([reflectionDelegate respondsToSelector:_cmd]) return [reflectionDelegate applicationShouldTerminateAfterLastWindowClosed:sender]; return NO; // Someday qApp->quitOnLastWindowClosed(); when QApp and NSApp work closer together. } - (void)applicationDidBecomeActive:(NSNotification *)notification { if (QCocoaWindow::s_applicationActivationObserver) { [[[NSWorkspace sharedWorkspace] notificationCenter] removeObserver:QCocoaWindow::s_applicationActivationObserver]; QCocoaWindow::s_applicationActivationObserver = nil; } if ([reflectionDelegate respondsToSelector:_cmd]) [reflectionDelegate applicationDidBecomeActive:notification]; QWindowSystemInterface::handleApplicationStateChanged(Qt::ApplicationActive); if (QCocoaWindow::s_windowUnderMouse) { QPointF windowPoint; QPointF screenPoint; QNSView *view = qnsview_cast(QCocoaWindow::s_windowUnderMouse->m_view); [view convertFromScreen:[NSEvent mouseLocation] toWindowPoint:&windowPoint andScreenPoint:&screenPoint]; QWindow *windowUnderMouse = QCocoaWindow::s_windowUnderMouse->window(); qCInfo(lcQpaMouse) << "Application activated with mouse at" << windowPoint << "; sending" << QEvent::Enter << "to" << windowUnderMouse; QWindowSystemInterface::handleEnterEvent(windowUnderMouse, windowPoint, screenPoint); } } - (void)applicationDidResignActive:(NSNotification *)notification { if ([reflectionDelegate respondsToSelector:_cmd]) [reflectionDelegate applicationDidResignActive:notification]; QWindowSystemInterface::handleApplicationStateChanged(Qt::ApplicationInactive); if (QCocoaWindow::s_windowUnderMouse) { QWindow *windowUnderMouse = QCocoaWindow::s_windowUnderMouse->window(); qCInfo(lcQpaMouse) << "Application deactivated; sending" << QEvent::Leave << "to" << windowUnderMouse; QWindowSystemInterface::handleLeaveEvent(windowUnderMouse); } } /*! Returns a Boolean value that indicates if the app responds to reopen AppleEvents. These events are sent whenever the Finder reactivates an already running application because someone double-clicked it again or used the dock to activate it. We pass the activation on to Qt, and return YES, to let AppKit follow its normal flow. */ - (BOOL)applicationShouldHandleReopen:(NSApplication *)theApplication hasVisibleWindows:(BOOL)flag { if ([reflectionDelegate respondsToSelector:_cmd]) return [reflectionDelegate applicationShouldHandleReopen:theApplication hasVisibleWindows:flag]; /* true to force delivery of the event even if the application state is already active, because rapp (handle reopen) events are sent each time the dock icon is clicked regardless of the active state of the application or number of visible windows. For example, a browser app that has no windows opened would need the event be to delivered even if it was already active in order to create a new window as per OS X conventions. */ QWindowSystemInterface::handleApplicationStateChanged(Qt::ApplicationActive, true /*forcePropagate*/); return YES; } - (void)setReflectionDelegate:(NSObject *)oldDelegate { [oldDelegate retain]; [reflectionDelegate release]; reflectionDelegate = oldDelegate; } - (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector { NSMethodSignature *result = [super methodSignatureForSelector:aSelector]; if (!result && reflectionDelegate) { result = [reflectionDelegate methodSignatureForSelector:aSelector]; } return result; } - (BOOL)respondsToSelector:(SEL)aSelector { return [super respondsToSelector:aSelector] || [reflectionDelegate respondsToSelector:aSelector]; } - (void)forwardInvocation:(NSInvocation *)invocation { SEL invocationSelector = [invocation selector]; if ([reflectionDelegate respondsToSelector:invocationSelector]) [invocation invokeWithTarget:reflectionDelegate]; else [self doesNotRecognizeSelector:invocationSelector]; } /*! Callback for when the application is asked to pick up a user activity from another app (also known as Handoff, which is part of the bigger Continuity story for Apple operating systems). This is normally managed by two apps by the same vendor explicitly initiating a custom NSUserActivity and picking it up in another app on the same or another device, which we don't have APIs for. This is also how the system supports Universal Links, where a web page can deep-link into an app. In this case the app needs to claim and validate an associated domain. The resulting link will be delivered as a special NSUserActivityTypeBrowsingWeb activity type, which we treat as QDesktopServices::handleUrl(). Finally, for NS/UIDocument based apps (which Qt is not), the system automatically handles document hand-off if the application includes the NSUbiquitousDocumentUserActivityType key in its Info.plist. */ - (BOOL)application:(NSApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void(^)(NSArray> *restorableObjects))restorationHandler { // Check if eg. user has installed an app delegate capable of handling this if ([reflectionDelegate respondsToSelector:_cmd] && [reflectionDelegate application:application continueUserActivity:userActivity restorationHandler:restorationHandler] == YES) { return YES; } if (!QGuiApplication::instance()) return NO; if ([userActivity.activityType isEqualToString:NSUserActivityTypeBrowsingWeb]) { QCocoaIntegration *cocoaIntegration = QCocoaIntegration::instance(); Q_ASSERT(cocoaIntegration); return cocoaIntegration->services()->handleUrl(QUrl::fromNSURL(userActivity.webpageURL)); } return NO; } /*! Callback for when the app is asked to open custom URL schemes. We register a handler for events of type kInternetEventClass with the NSAppleEventManager during application start. The application must include the schemes in the CFBundleURLTypes key of the Info.plist. \note This callback is not used for http/https URLs, see continueUserActivity above for how we handle that. */ - (void)getUrl:(NSAppleEventDescriptor *)event withReplyEvent:(NSAppleEventDescriptor *)replyEvent { Q_UNUSED(replyEvent); NSString *urlString = [[event paramDescriptorForKeyword:keyDirectObject] stringValue]; const QString qurlString = QString::fromNSString(urlString); if (event.eventClass == kInternetEventClass && event.eventID == kAEGetURL) { // 'GURL' (Get URL) event this application should handle if (!QGuiApplication::instance()) return; QCocoaIntegration *cocoaIntegration = QCocoaIntegration::instance(); Q_ASSERT(cocoaIntegration); if (cocoaIntegration->services()->handleUrl(QUrl(qurlString))) return; } // The string we get from the requesting application might not necessarily meet // QUrl's requirement for a IDN-compliant host. So if we can't parse into a QUrl, // then we pass the string on to the application as the name of a file (and // QFileOpenEvent::file is not guaranteed to be the path to a local, open'able // file anyway). if (const QUrl url(qurlString); url.isValid()) QWindowSystemInterface::handleFileOpenEvent(url); else QWindowSystemInterface::handleFileOpenEvent(qurlString); } - (BOOL)applicationSupportsSecureRestorableState:(NSApplication *)application { if (@available(macOS 12, *)) { if ([reflectionDelegate respondsToSelector:_cmd]) return [reflectionDelegate applicationSupportsSecureRestorableState:application]; } // We don't support or implement state restorations via the AppKit // state restoration APIs, but if we did, we would/should support // secure state restoration. This is the default for apps linked // against the macOS 14 SDK, but as we target versions below that // as well we need to return YES here explicitly to silence a runtime // warning. return YES; } @end @implementation QCocoaApplicationDelegate (Menus) - (BOOL)validateMenuItem:(NSMenuItem*)item { qCDebug(lcQpaMenus) << "Validating" << item << "for" << self; auto *nativeItem = qt_objc_cast(item); if (!nativeItem) return item.enabled; // FIXME Test with with Qt as plugin or embedded QWindow. auto *platformItem = nativeItem.platformMenuItem; if (!platformItem) // Try a bit harder with orphan menu items return item.hasSubmenu || (item.enabled && (item.action != @selector(qt_itemFired:))); // Menu-holding items are always enabled, as it's conventional in Cocoa if (platformItem->menu()) return YES; return platformItem->isEnabled(); } @end @implementation QCocoaApplicationDelegate (MenuAPI) - (void)qt_itemFired:(QCocoaNSMenuItem *)item { qCDebug(lcQpaMenus) << "Activating" << item; if (item.hasSubmenu) return; auto *nativeItem = qt_objc_cast(item); Q_ASSERT_X(nativeItem, qPrintable(__FUNCTION__), "Triggered menu item is not a QCocoaNSMenuItem."); auto *platformItem = nativeItem.platformMenuItem; // Menu-holding items also get a target to play nicely // with NSMenuValidation but should not trigger. if (!platformItem || platformItem->menu()) return; QGuiApplicationPrivate::modifier_buttons = QAppleKeyMapper::fromCocoaModifiers([NSEvent modifierFlags]); static QMetaMethod activatedSignal = QMetaMethod::fromSignal(&QCocoaMenuItem::activated); activatedSignal.invoke(platformItem, Qt::QueuedConnection); } @end