1 files changed, 141 insertions, 80 deletions

diff --git a/src/plugins/platforms/cocoa/qnsview_drawing.mm b/src/plugins/platforms/cocoa/qnsview_drawing.mm
index d2e6f848a0..2fd63fad67 100644
--- a/src/plugins/platforms/cocoa/qnsview_drawing.mm
+++ b/src/plugins/platforms/cocoa/qnsview_drawing.mm
@@ -39,24 +39,11 @@
 
 // This file is included from qnsview.mm, and only used to organize the code
 
-@implementation QT_MANGLE_NAMESPACE(QNSView) (Drawing)
+@implementation QNSView (Drawing)
 
 - (void)initDrawing
 {
-    self.wantsLayer = [self layerExplicitlyRequested]
-        || [self shouldUseMetalLayer]
-        || [self layerEnabledByMacOS];
-
-    // Enable high-DPI OpenGL for retina displays. Enabling has the side
-    // effect that Cocoa will start calling glViewport(0, 0, width, height),
-    // overriding any glViewport calls in application code. This is usually not a
-    // problem, except if the application wants to have a "custom" viewport.
-    // (like the hellogl example)
-    if (m_platformWindow->window()->supportsOpenGL()) {
-        self.wantsBestResolutionOpenGLSurface = qt_mac_resolveOption(YES, m_platformWindow->window(),
-            "_q_mac_wantsBestResolutionOpenGLSurface", "QT_MAC_WANTS_BEST_RESOLUTION_OPENGL_SURFACE");
-        // See also QCocoaGLContext::makeCurrent for software renderer workarounds.
-    }
+    [self updateLayerBacking];
 }
 
 - (BOOL)isOpaque
@@ -71,22 +58,13 @@
     return YES;
 }
 
-- (void)drawRect:(NSRect)dirtyRect
-{
-    Q_UNUSED(dirtyRect);
-
-    if (!m_platformWindow)
-        return;
+// ----------------------- Layer setup -----------------------
 
-    QRegion exposedRegion;
-    const NSRect *dirtyRects;
-    NSInteger numDirtyRects;
-    [self getRectsBeingDrawn:&dirtyRects count:&numDirtyRects];
-    for (int i = 0; i < numDirtyRects; ++i)
-        exposedRegion += QRectF::fromCGRect(dirtyRects[i]).toRect();
-
-    qCDebug(lcQpaDrawing) << "[QNSView drawRect:]" << m_platformWindow->window() << exposedRegion;
-    m_platformWindow->handleExposeEvent(exposedRegion);
+- (void)updateLayerBacking
+{
+    self.wantsLayer = [self layerEnabledByMacOS]
+        || [self layerExplicitlyRequested]
+        || [self shouldUseMetalLayer];
 }
 
 - (BOOL)layerEnabledByMacOS
@@ -123,40 +101,81 @@
     return surfaceType == QWindow::MetalSurface || surfaceType == QWindow::VulkanSurface;
 }
 
+/*
+    This method is called by AppKit when layer-backing is requested by
+    setting wantsLayer too YES (via -[NSView _updateLayerBackedness]),
+    or in cases where AppKit itself decides that a view should be
+    layer-backed.
+
+    Note however that some code paths in AppKit will not go via this
+    method for creating the backing layer, and will instead create the
+    layer manually, and just call setLayer. An example of this is when
+    an NSOpenGLContext is attached to a view, in which case AppKit will
+    create a new layer in NSOpenGLContextSetLayerOnViewIfNecessary.
+
+    For this reason we leave the implementation of this override as
+    minimal as possible, only focusing on creating the appropriate
+    layer type, and then leave it up to setLayer to do the work of
+    making sure the layer is set up correctly.
+*/
 - (CALayer *)makeBackingLayer
 {
     if ([self shouldUseMetalLayer]) {
         // Check if Metal is supported. If it isn't then it's most likely
         // too late at this point and the QWindow will be non-functional,
         // but we can at least print a warning.
-        if (![MTLCreateSystemDefaultDevice() autorelease]) {
-            qWarning() << "QWindow initialization error: Metal is not supported";
-            return [super makeBackingLayer];
+        if ([MTLCreateSystemDefaultDevice() autorelease]) {
+            return [CAMetalLayer layer];
+        } else {
+            qCWarning(lcQpaDrawing) << "Failed to create QWindow::MetalSurface."
+                << "Metal is not supported by any of the GPUs in this system.";
         }
-
-        CAMetalLayer *layer = [CAMetalLayer layer];
-
-        // Set the contentsScale for the layer. This is normally done in
-        // viewDidChangeBackingProperties, however on startup that function
-        // is called before the layer is created here. The layer's drawableSize
-        // is updated from layoutSublayersOfLayer as usual.
-        layer.contentsScale = self.window.backingScaleFactor;
-
-        return layer;
     }
 
     return [super makeBackingLayer];
 }
 
+/*
+    This method is called by AppKit whenever the view is asked to change
+    its layer, which can happen both as a result of enabling layer-backing,
+    or when a layer is set explicitly. The latter can happen both when a
+    view is layer-hosting, or when AppKit internals are switching out the
+    layer-backed view, as described above for makeBackingLayer.
+*/
 - (void)setLayer:(CALayer *)layer
 {
-    qCDebug(lcQpaDrawing) << "Making" << self << "layer-backed with" << layer
-        << "due to being" << ([self layerExplicitlyRequested] ? "explicitly requested"
+    qCDebug(lcQpaDrawing) << "Making" << self
+        << (self.wantsLayer ? "layer-backed" : "layer-hosted")
+        << "with" << layer << "due to being" << ([self layerExplicitlyRequested] ? "explicitly requested"
             : [self shouldUseMetalLayer] ? "needed by surface type" : "enabled by macOS");
+
+    if (layer.delegate && layer.delegate != self) {
+        qCWarning(lcQpaDrawing) << "Layer already has delegate" << layer.delegate
+            << "This delegate is responsible for all view updates for" << self;
+    } else {
+        layer.delegate = self;
+    }
+
     [super setLayer:layer];
-    layer.delegate = self;
+
+    // When adding a view to a view hierarchy the backing properties will change
+    // which results in updating the contents scale, but in case of switching the
+    // layer on a view that's already in a view hierarchy we need to manually ensure
+    // the scale is up to date.
+    if (self.superview)
+        [self updateLayerContentsScale];
+
+    if (self.opaque && lcQpaDrawing().isDebugEnabled()) {
+        // If the view claims to be opaque we expect it to fill the entire
+        // layer with content, in which case we want to detect any areas
+        // where it doesn't.
+        layer.backgroundColor = NSColor.magentaColor.CGColor;
+    }
+
 }
 
+// ----------------------- Layer updates -----------------------
+
 - (NSViewLayerContentsRedrawPolicy)layerContentsRedrawPolicy
 {
     // We need to set this explicitly since the super implementation
@@ -164,64 +183,106 @@
     return NSViewLayerContentsRedrawDuringViewResize;
 }
 
-#if 0 // Disabled until we enable lazy backingstore resizing
 - (NSViewLayerContentsPlacement)layerContentsPlacement
 {
-    // Always place the layer at top left without any automatic scaling,
-    // so that we can re-use larger layers when resizing a window down.
+    // Always place the layer at top left without any automatic scaling.
+    // This will highlight situations where we're missing content for the
+    // layer by not responding to the displayLayer: request synchronously.
+    // It also allows us to re-use larger layers when resizing a window down.
     return NSViewLayerContentsPlacementTopLeft;
 }
-#endif
 
-- (void)updateMetalLayerDrawableSize:(CAMetalLayer *)layer
+- (void)viewDidChangeBackingProperties
 {
-    CGSize drawableSize = layer.bounds.size;
-    drawableSize.width *= layer.contentsScale;
-    drawableSize.height *= layer.contentsScale;
-    layer.drawableSize = drawableSize;
+    qCDebug(lcQpaDrawing) << "Backing properties changed for" << self;
+
+    if (self.layer)
+        [self updateLayerContentsScale];
+
+    // Ideally we would plumb this situation through QPA in a way that lets
+    // clients invalidate their own caches, recreate QBackingStore, etc.
+    // For now we trigger an expose, and let QCocoaBackingStore deal with
+    // buffer invalidation internally.
+    [self setNeedsDisplay:YES];
 }
 
-- (void)layoutSublayersOfLayer:(CALayer *)layer
+- (void)updateLayerContentsScale
 {
-    if ([layer isKindOfClass:CAMetalLayer.class])
-        [self updateMetalLayerDrawableSize:static_cast<CAMetalLayer* >(layer)];
+    // We expect clients to fill the layer with retina aware content,
+    // based on the devicePixelRatio of the QWindow, so we set the
+    // layer's content scale to match that. By going via devicePixelRatio
+    // instead of applying the NSWindow's backingScaleFactor, we also take
+    // into account OpenGL views with wantsBestResolutionOpenGLSurface set
+    // to NO. In this case the window will have a backingScaleFactor of 2,
+    // but the QWindow will have a devicePixelRatio of 1.
+    auto devicePixelRatio = m_platformWindow->devicePixelRatio();
+    qCDebug(lcQpaDrawing) << "Updating" << self.layer << "content scale to" << devicePixelRatio;
+    self.layer.contentsScale = devicePixelRatio;
 }
 
-- (void)displayLayer:(CALayer *)layer
+/*
+    This method is called by AppKit to determine whether it should update
+    the contentScale of the layer to match the window backing scale.
+
+    We always return NO since we're updating the contents scale manually.
+*/
+- (BOOL)layer:(CALayer *)layer shouldInheritContentsScale:(CGFloat)scale fromWindow:(NSWindow *)window
 {
-    if (!NSThread.isMainThread) {
-        // Qt is calling AppKit APIs such as -[NSOpenGLContext setView:] on secondary threads,
-        // which we shouldn't do. This may result in AppKit (wrongly) triggering a display on
-        // the thread where we made the call, so block it here and defer to the main thread.
-        qCWarning(lcQpaDrawing) << "Display non non-main thread! Deferring to main thread";
-        dispatch_async(dispatch_get_main_queue(), ^{ self.needsDisplay = YES; });
-        return;
-    }
+    Q_UNUSED(layer); Q_UNUSED(scale); Q_UNUSED(window);
+    return NO;
+}
 
-    Q_ASSERT(layer == self.layer);
+// ----------------------- Draw callbacks -----------------------
+
+/*
+    This method is called by AppKit for the non-layer case, where we are
+    drawing into the NSWindow's surface.
+*/
+- (void)drawRect:(NSRect)dirtyBoundingRect
+{
+    Q_ASSERT_X(!self.layer, "QNSView",
+        "The drawRect code path should not be hit when we are layer backed");
 
     if (!m_platformWindow)
         return;
 
-    qCDebug(lcQpaDrawing) << "[QNSView displayLayer]" << m_platformWindow->window();
+    QRegion exposedRegion;
+    const NSRect *dirtyRects;
+    NSInteger numDirtyRects;
+    [self getRectsBeingDrawn:&dirtyRects count:&numDirtyRects];
+    for (int i = 0; i < numDirtyRects; ++i)
+        exposedRegion += QRectF::fromCGRect(dirtyRects[i]).toRect();
 
-    // FIXME: Find out if there's a way to resolve the dirty rect like in drawRect:
-    m_platformWindow->handleExposeEvent(QRectF::fromCGRect(self.bounds).toRect());
+    if (exposedRegion.isEmpty())
+        exposedRegion = QRectF::fromCGRect(dirtyBoundingRect).toRect();
+
+    qCDebug(lcQpaDrawing) << "[QNSView drawRect:]" << m_platformWindow->window() << exposedRegion;
+    m_platformWindow->handleExposeEvent(exposedRegion);
 }
 
-- (void)viewDidChangeBackingProperties
+/*
+    This method is called by AppKit when we are layer-backed, where
+    we are drawing into the layer.
+*/
+- (void)displayLayer:(CALayer *)layer
 {
-    CALayer *layer = self.layer;
-    if (!layer)
-        return;
+    Q_ASSERT_X(self.layer && layer == self.layer, "QNSView",
+        "The displayLayer code path should only be hit for our own layer");
 
-    layer.contentsScale = self.window.backingScaleFactor;
+    if (!m_platformWindow)
+        return;
 
-    // Metal layers must be manually updated on e.g. screen change
-    if ([layer isKindOfClass:CAMetalLayer.class]) {
-        [self updateMetalLayerDrawableSize:static_cast<CAMetalLayer* >(layer)];
-        [self setNeedsDisplay:YES];
+    if (!NSThread.isMainThread) {
+        // Qt is calling AppKit APIs such as -[NSOpenGLContext setView:] on secondary threads,
+        // which we shouldn't do. This may result in AppKit (wrongly) triggering a display on
+        // the thread where we made the call, so block it here and defer to the main thread.
+        qCWarning(lcQpaDrawing) << "Display non non-main thread! Deferring to main thread";
+        dispatch_async(dispatch_get_main_queue(), ^{ self.needsDisplay = YES; });
+        return;
     }
+
+    qCDebug(lcQpaDrawing) << "[QNSView displayLayer]" << m_platformWindow->window();
+    m_platformWindow->handleExposeEvent(QRectF::fromCGRect(self.bounds).toRect());
 }
 
 @end