Add blockPointerInputOutside flag

Author: MatkovIvan

compose/mpp/demo/src/commonMain/kotlin/androidx/compose/mpp/demo/components/popup/ConfigurablePopup.kt

@@ -148,13 +148,15 @@ private fun EditPopupProperties(): PopupProperties {
         val clippingEnabled = EditBooleanSetting("clippingEnabled", true)
         val usePlatformDefaultWidth = EditBooleanSetting("usePlatformDefaultWidth", false)
         val usePlatformInsets = EditBooleanSetting("usePlatformInsets", true)
+        val blockPointerInputOutside = EditBooleanSetting("blockPointerInputOutside", false)
         popupProperties = PopupProperties(
             focusable = focusable,
             dismissOnBackPress = dismissOnBackPress,
             dismissOnClickOutside = dismissOnClickOutside,
             clippingEnabled = clippingEnabled,
             usePlatformDefaultWidth = usePlatformDefaultWidth,
-            usePlatformInsets = usePlatformInsets
+            usePlatformInsets = usePlatformInsets,
+            blockPointerInputOutside = blockPointerInputOutside,
         )
     }
     return popupProperties

compose/ui/ui/api/desktop/ui.api

@@ -4611,7 +4611,6 @@ public abstract interface class androidx/compose/ui/window/PopupPositionProvider
 
 public final class androidx/compose/ui/window/PopupProperties {
 	public static final field $stable I
-	public fun <init> ()V
 	public synthetic fun <init> (ZZZZ)V
 	public synthetic fun <init> (ZZZZILkotlin/jvm/internal/DefaultConstructorMarker;)V
 	public fun <init> (ZZZZZ)V

compose/ui/ui/src/desktopMain/kotlin/androidx/compose/ui/scene/ComposeContainer.desktop.kt

@@ -32,7 +32,6 @@ import androidx.compose.ui.scene.skia.SkiaLayerComponent
 import androidx.compose.ui.skiko.OverlayRenderDecorator
 import androidx.compose.ui.unit.Density
 import androidx.compose.ui.unit.LayoutDirection
-import androidx.compose.ui.util.fastAll
 import androidx.compose.ui.util.fastForEach
 import androidx.compose.ui.util.fastForEachReversed
 import androidx.compose.ui.window.Dialog
@@ -138,7 +137,7 @@ internal class ComposeContainer(
         },
         eventListener = AwtEventListeners(
             DetectEventOutsideLayer(),
-            FocusableLayerEventFilter()
+            BlockingInputLayerEventFilter()
         ),
         architectureComponentsOwner = architectureComponentsOwner,
         coroutineContext = coroutineContext + MainUIDispatcher + DesktopCoroutineExceptionHandler(),
@@ -402,29 +401,32 @@ internal class ComposeContainer(
     }
 
     private fun createPlatformLayer(
+        compositionContext: CompositionContext,
         density: Density,
         layoutDirection: LayoutDirection,
         focusable: Boolean,
-        compositionContext: CompositionContext
+        blockPointerInputOutside: Boolean,
     ): ComposeSceneLayer {
         return when (layerType) {
             LayerType.OnWindow -> WindowComposeSceneLayer(
                 composeContainer = this,
                 skiaLayerAnalytics = skiaLayerAnalytics,
                 transparent = true, // TODO: Consider allowing opaque window layers
+                compositionContext = compositionContext,
                 density = density,
                 layoutDirection = layoutDirection,
                 focusable = focusable,
-                compositionContext = compositionContext,
-                renderSettings = renderSettings
+                blockPointerInputOutside = blockPointerInputOutside,
+                renderSettings = renderSettings,
             )
             LayerType.OnComponent -> SwingComposeSceneLayer(
                 composeContainer = this,
                 skiaLayerAnalytics = skiaLayerAnalytics,
+                compositionContext = compositionContext,
                 density = density,
                 layoutDirection = layoutDirection,
                 focusable = focusable,
-                compositionContext = compositionContext
+                blockPointerInputOutside = blockPointerInputOutside,
             )
             else -> error("Unexpected LayerType")
         }
@@ -447,6 +449,23 @@ internal class ComposeContainer(
         }
     }
 
+    /**
+     * Generates a sequence of layers that are positioned below the given layer in the layers list.
+     *
+     * @param layer the layer to find layers below
+     * @return a sequence of layers positioned below the given layer
+     */
+    fun layersBelow(layer: DesktopComposeSceneLayer) = sequence {
+        var isBelow = true
+        layers.fastForEach { i ->
+            if (i == layer) {
+                isBelow = false
+            } else if (isBelow) {
+                yield(i)
+            }
+        }
+    }
+
     /**
      * Notify layers about change in layers list. Required for additional invalidation and
      * re-drawing if needed.
@@ -499,15 +518,17 @@ internal class ComposeContainer(
         override val platformContext: PlatformContext,
     ) : ComposeSceneContext {
         override fun createLayer(
+            compositionContext: CompositionContext,
             density: Density,
             layoutDirection: LayoutDirection,
             focusable: Boolean,
-            compositionContext: CompositionContext
+            blockPointerInputOutside: Boolean,
         ): ComposeSceneLayer = createPlatformLayer(
+            compositionContext = compositionContext,
             density = density,
             layoutDirection = layoutDirection,
             focusable = focusable,
-            compositionContext = compositionContext
+            blockPointerInputOutside = blockPointerInputOutside,
         )
     }
 
@@ -520,24 +541,24 @@ internal class ComposeContainer(
 
     /**
      * Detect and trigger [DesktopComposeSceneLayer.onMouseEventOutside] if event happened below
-     * focused layer.
+     * a layer that blocks pointer input outside of its bounds.
      */
     private inner class DetectEventOutsideLayer : AwtEventListener {
         override fun onMouseEvent(event: AwtMouseEvent): Boolean {
             layers.fastForEachReversed {
                 it.onMouseEventOutside(event)
-                if (it.focusable) {
+                if (it.blockPointerInputOutside) {
                     return false
                 }
             }
             return false
         }
     }
 
-    private inner class FocusableLayerEventFilter : AwtEventFilter() {
-        private val noFocusableLayers get() = layers.fastAll { !it.focusable }
+    private inner class BlockingInputLayerEventFilter : AwtEventFilter() {
+        private val noBlockingInputLayers get() = layers.all { !it.blockPointerInputOutside }
 
-        override fun shouldSendMouseEvent(event: AwtMouseEvent): Boolean = noFocusableLayers
-        override fun shouldSendKeyEvent(event: AwtKeyEvent): Boolean = noFocusableLayers
+        override fun shouldSendMouseEvent(event: AwtMouseEvent): Boolean = noBlockingInputLayers
+        override fun shouldSendKeyEvent(event: AwtKeyEvent): Boolean = noBlockingInputLayers
     }
 }

compose/ui/ui/src/desktopMain/kotlin/androidx/compose/ui/scene/ComposeSceneMediator.desktop.kt

@@ -504,7 +504,7 @@ internal class ComposeSceneMediator(
             val processingResult = scene.onMouseWheelEvent(event.position, event)
             if (!processingResult.anyChangeConsumed) {
                 if (redispatchUnconsumedMouseWheelEvents) {
-                    redispatchUnconsumedMouseEvent(event)
+                    redispatchMouseEvent(event)
                 }
             }
         }
@@ -531,7 +531,7 @@ internal class ComposeSceneMediator(
      * AWT/Swing, however, interprets listening to mouse events as "interest" in them and sends them
      * only to the "interested" component "under" the mouse pointer.
      */
-    private fun redispatchUnconsumedMouseEvent(event: MouseEvent) {
+    fun redispatchMouseEvent(event: MouseEvent, target: Component? = null) {
         // Redispatch the event to the heavyweight ancestor, which in turn will try to find the
         // correct target component and send the event to it. Unregistering from mouse events
         // during this call allows the event to be sent to the component it would've been sent to
@@ -543,11 +543,11 @@ internal class ComposeSceneMediator(
         // With that approach, there would probably also be a need to add a flag (or multiple flags)
         // to ComposePanel that would control which types of events should be listened to.
         val source = event.component ?: return  // Should be contentComponent
-        val target = source.heavyWeightAncestorOrNull() ?: return
+        val resolvedTarget = target ?: source.heavyWeightAncestorOrNull() ?: return
         try {
             unsubscribeFromInputEvents()
-            val retargetedEvent = SwingUtilities.convertMouseEvent(source, event, target)
-            target.dispatchEvent(retargetedEvent)
+            val retargetedEvent = SwingUtilities.convertMouseEvent(source, event, resolvedTarget)
+            resolvedTarget.dispatchEvent(retargetedEvent)
         } finally {
             subscribeToInputEvents()
         }

compose/ui/ui/src/desktopMain/kotlin/androidx/compose/ui/scene/DesktopComposeSceneLayer.desktop.kt

@@ -56,7 +56,7 @@ internal abstract class DesktopComposeSceneLayer(
     protected val eventListener get() = AwtEventListeners(
         DetectEventOutsideLayer(),
         boundsEventFilter,
-        FocusableLayerEventFilter()
+        BlockingInputLayerEventFilter()
     )
     private val boundsEventFilter = BoundsEventFilter(
         bounds = Rectangle(windowContainer.size)
@@ -217,6 +217,10 @@ internal abstract class DesktopComposeSceneLayer(
         outsidePointerCallback?.invoke(eventType, event.composePointerButton)
     }
 
+    protected open fun redispatchMouseEvent(event: MouseEvent) {
+        mediator?.redispatchMouseEvent(event)
+    }
+
     private fun inBounds(event: MouseEvent): Boolean {
         val point = if (event.component != windowContainer) {
             SwingUtilities.convertPoint(event.component, event.point, windowContainer)
@@ -228,28 +232,28 @@ internal abstract class DesktopComposeSceneLayer(
 
     /**
      * Detect and trigger [DesktopComposeSceneLayer.onMouseEventOutside] if event happened below
-     * focused layer.
+     * a layer that blocks pointer input outside of its bounds.
      */
     private inner class DetectEventOutsideLayer : AwtEventListener {
         override fun onMouseEvent(event: MouseEvent): Boolean {
             layersAbove.toList().fastForEachReversed {
                 if (!inBounds(event)) {
                     it.onMouseEventOutside(event)
                 }
-                if (it.focusable) {
+                if (it.blockPointerInputOutside) {
                     return false
                 }
             }
             return false
         }
     }
 
-    private inner class FocusableLayerEventFilter : AwtEventFilter() {
-        private val noFocusableLayersAbove: Boolean
-            get() = layersAbove.all { !it.focusable }
+    private inner class BlockingInputLayerEventFilter : AwtEventFilter() {
+        private val noBlockingInputLayers: Boolean
+            get() = layersAbove.all { !it.blockPointerInputOutside }
 
-        override fun shouldSendMouseEvent(event: MouseEvent): Boolean = noFocusableLayersAbove
-        override fun shouldSendKeyEvent(event: KeyEvent): Boolean = focusable && noFocusableLayersAbove
+        override fun shouldSendMouseEvent(event: MouseEvent): Boolean = noBlockingInputLayers
+        override fun shouldSendKeyEvent(event: KeyEvent): Boolean = focusable && noBlockingInputLayers
     }
 
     private inner class BoundsEventFilter(
@@ -277,6 +281,9 @@ internal abstract class DesktopComposeSceneLayer(
                 true
             } else {
                 onMouseEventOutside(event)
+                if (!blockPointerInputOutside) {
+                    redispatchMouseEvent(event)
+                }
                 false
             }
         }

compose/ui/ui/src/desktopMain/kotlin/androidx/compose/ui/scene/SwingComposeSceneLayer.desktop.kt

@@ -40,14 +40,25 @@ import org.jetbrains.skiko.SkiaLayerAnalytics
 internal class SwingComposeSceneLayer(
     composeContainer: ComposeContainer,
     private val skiaLayerAnalytics: SkiaLayerAnalytics,
+    compositionContext: CompositionContext,
     density: Density,
     layoutDirection: LayoutDirection,
     focusable: Boolean,
-    compositionContext: CompositionContext
+    blockPointerInputOutside: Boolean = focusable,
 ) : DesktopComposeSceneLayer(composeContainer, density, layoutDirection) {
+    private fun onBackgroundMouseEvent(event: MouseEvent) {
+        onMouseEventOutside(event)
+        if (!blockPointerInputOutside) {
+            // [redispatchMouseEvent] requires a hack with unregistering from mouse events
+            container.removeMouseListener(backgroundMouseListener)
+            mediator?.redispatchMouseEvent(event)
+            container.addMouseListener(backgroundMouseListener)
+        }
+    }
+
     private val backgroundMouseListener = object : MouseAdapter() {
-        override fun mousePressed(event: MouseEvent) = onMouseEventOutside(event)
-        override fun mouseReleased(event: MouseEvent) = onMouseEventOutside(event)
+        override fun mousePressed(event: MouseEvent) = onBackgroundMouseEvent(event)
+        override fun mouseReleased(event: MouseEvent) = onBackgroundMouseEvent(event)
     }
 
     private val container = object : JLayeredPane() {
@@ -94,6 +105,11 @@ internal class SwingComposeSceneLayer(
             updateBounds()
         }
 
+    override var blockPointerInputOutside: Boolean = blockPointerInputOutside
+        set(value) {
+            field = value
+        }
+
     override var scrimColor: Color? = null
 
     init {

compose/ui/ui/src/desktopMain/kotlin/androidx/compose/ui/scene/WindowComposeSceneLayer.desktop.kt

@@ -37,10 +37,13 @@ import androidx.compose.ui.window.density
 import androidx.compose.ui.window.getDialogScrimBlendMode
 import androidx.compose.ui.window.layoutDirectionFor
 import androidx.compose.ui.window.sizeInPx
+import java.awt.Component
 import java.awt.Point
 import java.awt.event.ComponentAdapter
 import java.awt.event.ComponentEvent
+import java.awt.event.MouseEvent
 import javax.swing.JDialog
+import javax.swing.SwingUtilities
 import org.jetbrains.skia.Canvas
 import org.jetbrains.skiko.DelicateSkikoApi
 import org.jetbrains.skiko.SkiaLayerAnalytics
@@ -50,10 +53,11 @@ internal class WindowComposeSceneLayer(
     composeContainer: ComposeContainer,
     private val skiaLayerAnalytics: SkiaLayerAnalytics,
     private val transparent: Boolean,
+    compositionContext: CompositionContext,
     density: Density,
     layoutDirection: LayoutDirection,
     focusable: Boolean,
-    compositionContext: CompositionContext,
+    override var blockPointerInputOutside: Boolean,
     private val renderSettings: RenderSettings
 ) : DesktopComposeSceneLayer(composeContainer, density, layoutDirection) {
     // WindowComposeSceneLayer is tied to the window it was created with
@@ -198,6 +202,12 @@ internal class WindowComposeSceneLayer(
         canvas.drawRect(0f, 0f, width.toFloat(), height.toFloat(), paint)
     }
 
+    override fun redispatchMouseEvent(event: MouseEvent) {
+        val source = event.component ?: return
+        val target = findRedispatchTarget(source, event.point) ?: return
+        mediator?.redispatchMouseEvent(event = event, target = target)
+    }
+
     private fun createSkiaLayerComponent(mediator: ComposeSceneMediator): SkiaLayerComponent {
         val renderDelegate = OverlayRenderDecorator(
             recordDrawBounds(mediator)
@@ -239,4 +249,27 @@ internal class WindowComposeSceneLayer(
             locationOnScreen.y + y
         )
     }
+
+    private fun findRedispatchTarget(source: Component, point: Point): Component? {
+        val screenPoint = Point(point)
+        val sourceLocation = source.locationOnScreen
+        screenPoint.translate(sourceLocation.x, sourceLocation.y)
+
+        composeContainer.layersBelow(this).toList().asReversed().forEach { layer ->
+            val targetWindow = (layer as? WindowComposeSceneLayer)?.layerWindow ?: return@forEach
+            val pointInTargetWindow = Point(screenPoint)
+            SwingUtilities.convertPointFromScreen(pointInTargetWindow, targetWindow)
+            if (targetWindow.isShowing && targetWindow.contains(pointInTargetWindow)) {
+                return targetWindow.findComponentAt(pointInTargetWindow) ?: targetWindow
+            }
+        }
+
+        val pointInParentWindow = Point(screenPoint)
+        SwingUtilities.convertPointFromScreen(pointInParentWindow, parentWindow)
+        if (parentWindow.isShowing && parentWindow.contains(pointInParentWindow)) {
+            return parentWindow.findComponentAt(pointInParentWindow) ?: parentWindow
+        }
+
+        return null
+    }
 }