1 files changed, 114 insertions, 112 deletions

diff --git a/src/plugins/platforms/cocoa/qnswindow.mm b/src/plugins/platforms/cocoa/qnswindow.mm
index 1b9dd95cbc..52f765eb31 100644
--- a/src/plugins/platforms/cocoa/qnswindow.mm
+++ b/src/plugins/platforms/cocoa/qnswindow.mm
@@ -37,6 +37,8 @@
 **
 ****************************************************************************/
 
+#if !defined(QNSWINDOW_PROTOCOL_IMPLMENTATION)
+
 #include "qnswindow.h"
 #include "qcocoawindow.h"
 #include "qcocoahelpers.h"
@@ -89,44 +91,104 @@ static bool isMouseEvent(NSEvent *ev)
 }
 @end
 
-#define super USE_qt_objcDynamicSuper_INSTEAD
-
 @implementation QNSWindow
+#define QNSWINDOW_PROTOCOL_IMPLMENTATION 1
+#include "qnswindow.mm"
+#undef QNSWINDOW_PROTOCOL_IMPLMENTATION
 
-+ (void)load
++ (void)applicationActivationChanged:(NSNotification*)notification
 {
-    const Class windowClass = [self class];
-    const Class panelClass = [QNSPanel class];
-
-    unsigned int protocolCount;
-    Protocol **protocols = class_copyProtocolList(windowClass, &protocolCount);
-    for (unsigned int i = 0; i < protocolCount; ++i) {
-        Protocol *protocol = protocols[i];
-
-        unsigned int methodDescriptionsCount;
-        objc_method_description *methods = protocol_copyMethodDescriptionList(
-            protocol, NO, YES, &methodDescriptionsCount);
-
-        for (unsigned int j = 0; j < methodDescriptionsCount; ++j) {
-            objc_method_description method = methods[j];
-            class_addMethod(panelClass, method.name,
-                class_getMethodImplementation(windowClass, method.name),
-                method.types);
+    const id sender = self;
+    NSEnumerator<NSWindow*> *windowEnumerator = nullptr;
+    NSApplication *application = [NSApplication sharedApplication];
+
+    // Unfortunately there's no NSWindowListOrderedBackToFront,
+    // so we have to manually reverse the order using an array.
+    NSMutableArray<NSWindow *> *windows = [NSMutableArray<NSWindow *> new];
+    [application enumerateWindowsWithOptions:NSWindowListOrderedFrontToBack
+        usingBlock:^(NSWindow *window, BOOL *) {
+            // For some reason AppKit will give us nil-windows, skip those
+            if (!window)
+                return;
+
+            [windows addObject:window];
         }
-        free(methods);
+    ];
+
+    windowEnumerator = windows.reverseObjectEnumerator;
+
+    for (NSWindow *window in windowEnumerator) {
+        // We're meddling with normal and floating windows, so leave others alone
+        if (!(window.level == NSNormalWindowLevel || window.level == NSFloatingWindowLevel))
+            continue;
+
+        // Windows that hide automatically will keep their NSFloatingWindowLevel,
+        // and hence be on top of the window stack. We don't want to affect these
+        // windows, as otherwise we might end up with key windows being ordered
+        // behind these auto-hidden windows when activating the application by
+        // clicking on a new tool window.
+        if (window.hidesOnDeactivate)
+            continue;
+
+        if ([window conformsToProtocol:@protocol(QNSWindowProtocol)]) {
+            QCocoaWindow *cocoaWindow = static_cast<QCocoaNSWindow *>(window).platformWindow;
+            window.level = notification.name == NSApplicationWillResignActiveNotification ?
+                NSNormalWindowLevel : cocoaWindow->windowLevel(cocoaWindow->window()->flags());
+        }
+
+        // The documentation says that "when a window enters a new level, it’s ordered
+        // in front of all its peers in that level", but that doesn't seem to be the
+        // case in practice. To keep the order correct after meddling with the window
+        // levels, we explicitly order each window to the front. Since we are iterating
+        // the windows in back-to-front order, this is okey. The call also triggers AppKit
+        // to re-evaluate the level in relation to windows from other applications,
+        // working around an issue where our tool windows would stay on top of other
+        // application windows if activation was transferred to another application by
+        // clicking on it instead of via the application switcher or Dock. Finally, we
+        // do this re-ordering for all windows (except auto-hiding ones), otherwise we would
+        // end up triggering a bug in AppKit where the tool windows would disappear behind
+        // the application window.
+        [window orderFront:sender];
     }
+}
+
+@end
+
+@implementation QNSPanel
+#define QNSWINDOW_PROTOCOL_IMPLMENTATION 1
+#include "qnswindow.mm"
+#undef QNSWINDOW_PROTOCOL_IMPLMENTATION
+@end
+
+#else // QNSWINDOW_PROTOCOL_IMPLMENTATION
 
-    free(protocols);
+// The following content is mixed in to the QNSWindow and QNSPanel classes via includes
+
+{
+    // Member variables
+    QPointer<QCocoaWindow> m_platformWindow;
+}
+
+- (instancetype)initWithContentRect:(NSRect)contentRect styleMask:(NSWindowStyleMask)style
+    backing:(NSBackingStoreType)backingStoreType defer:(BOOL)defer screen:(NSScreen *)screen
+    platformWindow:(QCocoaWindow*)window
+{
+    // Initializing the window will end up in [NSWindow _commonAwake], which calls many
+    // of the getters below. We need to set up the platform window reference first, so
+    // we can properly reflect the window's state during initialization.
+    m_platformWindow = window;
+
+    return [super initWithContentRect:contentRect styleMask:style backing:backingStoreType defer:defer screen:screen];
 }
 
 - (QCocoaWindow *)platformWindow
 {
-    return qnsview_cast(self.contentView).platformWindow;
+    return m_platformWindow;
 }
 
 - (NSString *)description
 {
-    NSMutableString *description = [NSMutableString stringWithString:qt_objcDynamicSuper()];
+    NSMutableString *description = [NSMutableString stringWithString:[super description]];
 
 #ifndef QT_NO_DEBUG_STREAM
     QString contentViewDescription;
@@ -142,16 +204,15 @@ static bool isMouseEvent(NSEvent *ev)
 
 - (BOOL)canBecomeKeyWindow
 {
-    QCocoaWindow *pw = self.platformWindow;
-    if (!pw)
+    if (!m_platformWindow)
         return NO;
 
-    if (pw->shouldRefuseKeyWindowAndFirstResponder())
+    if (m_platformWindow->shouldRefuseKeyWindowAndFirstResponder())
         return NO;
 
     if ([self isKindOfClass:[QNSPanel class]]) {
         // Only tool or dialog windows should become key:
-        Qt::WindowType type = pw->window()->type();
+        Qt::WindowType type = m_platformWindow->window()->type();
         if (type == Qt::Tool || type == Qt::Dialog)
             return YES;
 
@@ -170,17 +231,26 @@ static bool isMouseEvent(NSEvent *ev)
 
     // Windows with a transient parent (such as combobox popup windows)
     // cannot become the main window:
-    QCocoaWindow *pw = self.platformWindow;
-    if (!pw || pw->window()->transientParent())
+    if (!m_platformWindow || m_platformWindow->window()->transientParent())
         canBecomeMain = NO;
 
     return canBecomeMain;
 }
 
+- (BOOL)worksWhenModal
+{
+    if (m_platformWindow && [self isKindOfClass:[QNSPanel class]]) {
+        Qt::WindowType type = m_platformWindow->window()->type();
+        if (type == Qt::Popup || type == Qt::Dialog || type == Qt::Tool)
+            return YES;
+    }
+
+    return [super worksWhenModal];
+}
+
 - (BOOL)isOpaque
 {
-    return self.platformWindow ?
-        self.platformWindow->isOpaque() : qt_objcDynamicSuper();
+    return m_platformWindow ? m_platformWindow->isOpaque() : [super isOpaque];
 }
 
 /*!
@@ -196,7 +266,7 @@ static bool isMouseEvent(NSEvent *ev)
 - (NSColor *)backgroundColor
 {
     return self.styleMask == NSWindowStyleMaskBorderless
-        ? [NSColor clearColor] : qt_objcDynamicSuper();
+        ? [NSColor clearColor] : [super backgroundColor];
 }
 
 - (void)sendEvent:(NSEvent*)theEvent
@@ -208,7 +278,7 @@ static bool isMouseEvent(NSEvent *ev)
     // e.g. if being retained by other parts of AppKit, or in an auto-release
     // pool. We guard against this in QNSView as well, as not all callbacks
     // come via events, but if they do there's no point in propagating them.
-    if (!self.platformWindow)
+    if (!m_platformWindow)
         return;
 
     // Prevent deallocation of this NSWindow during event delivery, as we
@@ -216,106 +286,38 @@ static bool isMouseEvent(NSEvent *ev)
     [[self retain] autorelease];
 
     const char *eventType = object_getClassName(theEvent);
-    if (QWindowSystemInterface::handleNativeEvent(self.platformWindow->window(),
+    if (QWindowSystemInterface::handleNativeEvent(m_platformWindow->window(),
         QByteArray::fromRawData(eventType, qstrlen(eventType)), theEvent, nullptr)) {
         return;
     }
 
-    qt_objcDynamicSuper(theEvent);
+    [super sendEvent:theEvent];
 
-    if (!self.platformWindow)
+    if (!m_platformWindow)
         return; // Platform window went away while processing event
 
-    QCocoaWindow *pw = self.platformWindow;
-    if (pw->frameStrutEventsEnabled() && isMouseEvent(theEvent)) {
+    if (m_platformWindow->frameStrutEventsEnabled() && isMouseEvent(theEvent)) {
         NSPoint loc = [theEvent locationInWindow];
         NSRect windowFrame = [self convertRectFromScreen:self.frame];
         NSRect contentFrame = self.contentView.frame;
         if (NSMouseInRect(loc, windowFrame, NO) && !NSMouseInRect(loc, contentFrame, NO))
-            [qnsview_cast(pw->view()) handleFrameStrutMouseEvent:theEvent];
+            [qnsview_cast(m_platformWindow->view()) handleFrameStrutMouseEvent:theEvent];
     }
 }
 
 - (void)closeAndRelease
 {
-    qCDebug(lcQpaWindow) << "closeAndRelease" << self;
-
-    [self.delegate release];
-    self.delegate = nil;
-
+    qCDebug(lcQpaWindow) << "Closing and releasing" << self;
     [self close];
     [self release];
 }
 
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wobjc-missing-super-calls"
 - (void)dealloc
 {
-    qCDebug(lcQpaWindow) << "dealloc" << self;
-    qt_objcDynamicSuper();
-}
-#pragma clang diagnostic pop
-
-+ (void)applicationActivationChanged:(NSNotification*)notification
-{
-    const id sender = self;
-    NSEnumerator<NSWindow*> *windowEnumerator = nullptr;
-    NSApplication *application = [NSApplication sharedApplication];
-
-    // Unfortunately there's no NSWindowListOrderedBackToFront,
-    // so we have to manually reverse the order using an array.
-    NSMutableArray<NSWindow *> *windows = [NSMutableArray<NSWindow *> new];
-    [application enumerateWindowsWithOptions:NSWindowListOrderedFrontToBack
-        usingBlock:^(NSWindow *window, BOOL *) {
-            // For some reason AppKit will give us nil-windows, skip those
-            if (!window)
-                return;
-
-            [windows addObject:window];
-        }
-    ];
-
-    windowEnumerator = windows.reverseObjectEnumerator;
-
-    for (NSWindow *window in windowEnumerator) {
-        // We're meddling with normal and floating windows, so leave others alone
-        if (!(window.level == NSNormalWindowLevel || window.level == NSFloatingWindowLevel))
-            continue;
-
-        // Windows that hide automatically will keep their NSFloatingWindowLevel,
-        // and hence be on top of the window stack. We don't want to affect these
-        // windows, as otherwise we might end up with key windows being ordered
-        // behind these auto-hidden windows when activating the application by
-        // clicking on a new tool window.
-        if (window.hidesOnDeactivate)
-            continue;
-
-        if ([window conformsToProtocol:@protocol(QNSWindowProtocol)]) {
-            QCocoaWindow *cocoaWindow = static_cast<QCocoaNSWindow *>(window).platformWindow;
-            window.level = notification.name == NSApplicationWillResignActiveNotification ?
-                NSNormalWindowLevel : cocoaWindow->windowLevel(cocoaWindow->window()->flags());
-        }
+    qCDebug(lcQpaWindow) << "Deallocating" << self;
+    self.delegate = nil;
 
-        // The documentation says that "when a window enters a new level, it’s ordered
-        // in front of all its peers in that level", but that doesn't seem to be the
-        // case in practice. To keep the order correct after meddling with the window
-        // levels, we explicitly order each window to the front. Since we are iterating
-        // the windows in back-to-front order, this is okey. The call also triggers AppKit
-        // to re-evaluate the level in relation to windows from other applications,
-        // working around an issue where our tool windows would stay on top of other
-        // application windows if activation was transferred to another application by
-        // clicking on it instead of via the application switcher or Dock. Finally, we
-        // do this re-ordering for all windows (except auto-hiding ones), otherwise we would
-        // end up triggering a bug in AppKit where the tool windows would disappear behind
-        // the application window.
-        [window orderFront:sender];
-    }
+    [super dealloc];
 }
 
-@end
-
-@implementation QNSPanel
-// Implementation shared with QNSWindow, see +[QNSWindow load] above
-@end
-
-#undef super
+#endif