JBR-9515 Allow size of per-directory buffer used to retrieve events to be configurable to avoid OVERFLOW_EVENT

Providing support of the "text-input-unstable-v3" protocol, except its surrounding text API (zwp_text_input_v3::set_surrounding_text + zwp_text_input_v3::delete_surrounding_text).
A new system property "sun.awt.wl.im.enabled"[=true|false] is introduced to enable/disable all the integrations with Wayland's native input methods. Set to 'true' by default.

(cherry picked from commit 1c37490f00)

.github/README.md

@@ -161,7 +161,7 @@ Install the necessary tools, libraries, and headers with:
 ```
 $ sudo apt-get install autoconf make build-essential libx11-dev libxext-dev libxrender-dev libxtst-dev \
        libxt-dev libxrandr-dev libcups2-dev libfontconfig1-dev libasound2-dev libspeechd-dev libwayland-dev \
-       wayland-protocols libxkbcommon-x11-0
+       wayland-protocols libxkbcommon-x11-0 libdbus-1-dev
 ```
 Get Java 23 (for instance, [Azul Zulu Builds of OpenJDK 23](https://www.azul.com/downloads/?version=java-23&os=linux&package=jdk#zulu)).
 

make/JBRApi.gmk

@@ -40,13 +40,13 @@ else ifeq ($(call isBuildOsEnv, windows.wsl1 windows.wsl2), true)
 else
     M2_REPO := $(HOME)/.m2/repository
 endif
-M2_ARTIFACT := $(M2_REPO)/com/jetbrains/jbr-api/SNAPSHOT
+M2_ARTIFACT := $(M2_REPO)/org/jetbrains/runtime/jbr-api/SNAPSHOT
 M2_POM_CONTENT := \
     <?xml version="1.0" encoding="UTF-8"?> \
     <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" \
         xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> \
       <modelVersion>4.0.0</modelVersion> \
-      <groupId>com.jetbrains</groupId> \
+      <groupId>org.jetbrains.runtime</groupId> \
       <artifactId>jbr-api</artifactId> \
       <version>SNAPSHOT</version> \
     </project> \
@@ -65,7 +65,8 @@ jbr-api:
 	    $(MKDIR) -p $(M2_ARTIFACT); \
 	    $(ECHO) '$(M2_POM_CONTENT)' > $(M2_ARTIFACT)/$(ARTIFACT_NAME).pom; \
 	    $(CP) "$(JBR_API_DIR)/out/$(ARTIFACT_NAME).jar" "$(M2_ARTIFACT)"; \
-	    $(ECHO) "Installed into local Maven repository as com.jetbrains:jbr-api:SNAPSHOT"; \
+	    $(ECHO) "Installed into local Maven repository as org.jetbrains.runtime:jbr-api:SNAPSHOT"; \
+	    cd "$(M2_ARTIFACT)" && sha256sum --binary "$(ARTIFACT_NAME).jar"; \
 	else \
 	    $(ECHO) "No Maven repository found at $(M2_REPO) - skipping local installation"; \
 	fi

make/autoconf/lib-vulkan.m4

@@ -89,7 +89,7 @@ AC_DEFUN_ONCE([LIB_SETUP_VULKAN],
     if (test "x${with_vulkan_shader_compiler}" = x || test "x${with_vulkan_shader_compiler}" = xglslc); then
       UTIL_LOOKUP_PROGS(GLSLC, glslc)
       SHADER_COMPILER="$GLSLC"
-      VULKAN_SHADER_COMPILER="glslc --target-env=vulkan1.2 -mfmt=num -o"
+      VULKAN_SHADER_COMPILER="glslc --target-env=vulkan1.2 -mfmt=num"
     fi
 
     # Check glslangValidator
@@ -97,7 +97,8 @@ AC_DEFUN_ONCE([LIB_SETUP_VULKAN],
         test "x$SHADER_COMPILER" = x; then
       UTIL_LOOKUP_PROGS(GLSLANG, glslangValidator)
       SHADER_COMPILER="$GLSLANG"
-      VULKAN_SHADER_COMPILER="glslangValidator --target-env vulkan1.2 -x -o"
+      # Newer glslangValidator could use -P\"\#extension GL_GOOGLE_include_directive: require\"
+      VULKAN_SHADER_COMPILER="glslangValidator --target-env vulkan1.2 -x"
     fi
 
     if test "x$SHADER_COMPILER" = x; then

make/modules/java.desktop/gensrc/GensrcWayland.gmk

@@ -35,6 +35,8 @@ WAYLAND_BASIC_PROTOCOL_FILES := \
         $(WAYLAND_PROTOCOLS_ROOT)/staging/xdg-activation/xdg-activation-v1.xml \
         $(WAYLAND_PROTOCOLS_ROOT)/unstable/primary-selection/primary-selection-unstable-v1.xml \
         $(WAYLAND_PROTOCOLS_ROOT)/unstable/xdg-output/xdg-output-unstable-v1.xml \
+        $(WAYLAND_PROTOCOLS_ROOT)/unstable/relative-pointer/relative-pointer-unstable-v1.xml \
+        $(WAYLAND_PROTOCOLS_ROOT)/unstable/text-input/text-input-unstable-v3.xml \
         $(GTK_SHELL1_PROTOCOL_PATH) \
         #
 

make/modules/java.desktop/lib/AwtLibraries.gmk

@@ -199,7 +199,7 @@ $(eval $(call SetupJdkLibrary, BUILD_LIBAWT, \
         -framework OpenGL, \
     LIBS_windows := advapi32.lib comctl32.lib comdlg32.lib delayimp.lib \
         gdi32.lib gdiplus.lib imm32.lib kernel32.lib ole32.lib shell32.lib shlwapi.lib \
-        user32.lib uuid.lib winmm.lib winspool.lib dwmapi.lib $(A11Y_NVDA_ANNOUNCING_LIBS), \
+        user32.lib uuid.lib winmm.lib winspool.lib dwmapi.lib $(A11Y_NVDA_ANNOUNCING_LIBS) oleacc.lib, \
     VERSIONINFO_RESOURCE := $(LIBAWT_VERSIONINFO_RESOURCE), \
     EXTRA_RCFLAGS := $(LIBAWT_RCFLAGS), \
     STATIC_LIB_EXCLUDE_OBJS := $(LIBAWT_STATIC_EXCLUDE_OBJS), \
@@ -220,7 +220,7 @@ endif
 # Compile Vulkan shaders
 define compile-spirv
   $(call MakeTargetDir)
-  $(VULKAN_SHADER_COMPILER) '$(call DecodeSpace, $@)' '$(call DecodeSpace, $<)'
+  $(VULKAN_SHADER_COMPILER) -D$(call uppercase,$(patsubst .%,STAGE_%,$(suffix $<))) -o '$(call DecodeSpace, $@)' '$(call DecodeSpace, $<)'
 endef
 spirv-name = $(strip $1).h
 

src/hotspot/share/services/attachListener.cpp

@@ -172,8 +172,8 @@ volatile AttachListenerState AttachListener::_state = AL_NOT_INITIALIZED;
 
 AttachAPIVersion AttachListener::_supported_version = ATTACH_API_V1;
 
-// Default is true (if jdk.attach.vm.streaming property is not set).
-bool AttachListener::_default_streaming_output = true;
+// Default is false (if jdk.attach.vm.streaming property is not set).
+bool AttachListener::_default_streaming_output = false;
 
 static bool get_bool_sys_prop(const char* name, bool default_value, TRAPS) {
   ResourceMark rm(THREAD);

src/java.base/windows/classes/sun/nio/fs/WindowsWatchService.java

@@ -36,6 +36,7 @@ import java.util.Map;
 import java.util.Set;
 
 import jdk.internal.misc.Unsafe;
+import jdk.internal.util.ArraysSupport;
 
 import static sun.nio.fs.WindowsNativeDispatcher.*;
 import static sun.nio.fs.WindowsConstants.*;
@@ -284,9 +285,26 @@ class WindowsWatchService
         private static final short OFFSETOF_FILENAMELENGTH  = 8;
         private static final short OFFSETOF_FILENAME        = 12;
 
-        // size of per-directory buffer for events (FIXME - make this configurable)
-        // Need to be less than 4*16384 = 65536. DWORD align.
-        private static final int CHANGES_BUFFER_SIZE    = 16 * 1024;
+        // size of per-directory buffer for events
+        // Need to be less than 4*16384 = 65536 when monitoring a directory over the network. DWORD align.
+        private static final int DEFAULT_CHANGES_BUFFER_SIZE = 16 * 1024;
+        static final int CHANGES_BUFFER_SIZE;
+        static {
+            String rawValue = System.getProperty(
+                "jdk.nio.file.WatchService.bufferSizeToRetrieveEventsPerDirectory",
+                String.valueOf(DEFAULT_CHANGES_BUFFER_SIZE));
+            int intValue;
+            try {
+                // Clamp to size of per-directory buffer used to retrieve events.
+                intValue = Math.clamp(
+                    Long.decode(rawValue),
+                    1,
+                    ArraysSupport.SOFT_MAX_ARRAY_LENGTH);
+            } catch (NumberFormatException e) {
+                intValue = DEFAULT_CHANGES_BUFFER_SIZE;
+            }
+            CHANGES_BUFFER_SIZE = intValue;
+        }
 
         private final WindowsFileSystem fs;
         private final WindowsWatchService watcher;

src/java.desktop/macosx/classes/sun/java2d/metal/MTLLayer.java

@@ -33,7 +33,6 @@ import sun.lwawt.macosx.CFLayer;
 import sun.util.logging.PlatformLogger;
 
 import java.awt.Component;
-import java.awt.GraphicsConfiguration;
 import java.awt.Insets;
 import java.awt.Window;
 
@@ -51,12 +50,13 @@ public class MTLLayer extends CFLayer {
     private static native void nativeSetOpaque(long layerPtr, boolean opaque);
 
     private int scale = 1;
+    private final boolean perfCountersEnabled;
 
     public MTLLayer(LWWindowPeer peer) {
         super(0, true);
 
         Window target = (peer != null) ? peer.getTarget() : null;
-        boolean perfCountersEnabled = (target != null) && AWTAccessor.getWindowAccessor().countersEnabled(target);
+        this.perfCountersEnabled = (target != null) && AWTAccessor.getWindowAccessor().countersEnabled(target);
 
         setPtr(nativeCreateLayer(perfCountersEnabled));
         this.peer = peer;
@@ -150,11 +150,29 @@ public class MTLLayer extends CFLayer {
         }
     }
 
+    private final static String[] STAT_NAMES = new String[]{
+            "java2d.native.mtlLayer.drawInMTLContext",  // type = 0
+            "java2d.native.mtlLayer.nextDrawable"       // type = 1
+    };
+
+    private void addStat(int type, double value) {
+        // Called from the native code when this layer has been presented on screen
+        if (perfCountersEnabled && (peer != null)) {
+            final Component target = peer.getTarget();
+            if (target instanceof Window window) {
+                AWTAccessor.getWindowAccessor().addStat(window,
+                        ((type >= 0) && (type < STAT_NAMES.length)) ? STAT_NAMES[type] : "undefined", value);
+            }
+        }
+    }
+
     private void countNewFrame() {
         // Called from the native code when this layer has been presented on screen
-        Component target = peer.getTarget();
-        if (target instanceof Window window) {
-            AWTAccessor.getWindowAccessor().bumpCounter(window, "java2d.native.frames");
+        if (perfCountersEnabled && (peer != null)) {
+            final Component target = peer.getTarget();
+            if (target instanceof Window window) {
+                AWTAccessor.getWindowAccessor().incrementCounter(window, "java2d.native.frames");
+            }
         }
     }
 
@@ -162,9 +180,11 @@ public class MTLLayer extends CFLayer {
         // Called from the native code when an attempt was made to present this layer
         // on screen, but that attempt was not successful. This can happen, for example,
         // when those attempts are too frequent.
-        Component target = peer.getTarget();
-        if (target instanceof Window window) {
-            AWTAccessor.getWindowAccessor().bumpCounter(window, "java2d.native.framesDropped");
+        if (perfCountersEnabled && (peer != null)) {
+            final Component target = peer.getTarget();
+            if (target instanceof Window window) {
+                AWTAccessor.getWindowAccessor().incrementCounter(window, "java2d.native.framesDropped");
+            }
         }
     }
 }

src/java.desktop/macosx/native/libawt_lwawt/awt/AWTWindow.m

@@ -75,6 +75,19 @@ BOOL isColorMatchingEnabled() {
     return (BOOL)colorMatchingEnabled;
 }
 
+BOOL isWindowAnimationEnabled() {
+    static int windowAnimationEnabled = -1;
+    if (windowAnimationEnabled == -1) {
+        JNIEnv *env = [ThreadUtilities getJNIEnvUncached];
+        if (env == NULL) return NO;
+        NSString* windowAnimationEnabledProp = [PropertiesUtilities javaSystemPropertyForKey:@"apple.awt.window.animation"
+                                                                                     withEnv:env];
+        windowAnimationEnabled = [@"true" isCaseInsensitiveLike:windowAnimationEnabledProp] ? YES : NO;
+        J2dRlsTraceLn(J2D_TRACE_INFO, "AWTWindow_windowAnimationEnabled: %d", windowAnimationEnabled);
+    }
+    return (BOOL)windowAnimationEnabled;
+}
+
 @interface NSTitlebarAccessoryViewController (Private)
 - (void)_setHidden:(BOOL)h animated:(BOOL)a;
 @end
@@ -605,6 +618,10 @@ AWT_ASSERT_APPKIT_THREAD;
     if (self.nsWindow == nil) return nil; // no hope either
     [self.nsWindow release]; // the property retains the object already
 
+    if (!isWindowAnimationEnabled()
+        && (self.nsWindow.animationBehavior != NSWindowAnimationBehaviorNone)) {
+        self.nsWindow.animationBehavior = NSWindowAnimationBehaviorNone;
+    }
     if (isColorMatchingEnabled()) {
         // Supported by both OpenGL & Metal pipelines
         // Tell the system we have an sRGB backing store
@@ -3008,8 +3025,6 @@ JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeSetRoundedCor
 
     NSWindow *w = (NSWindow *)jlong_to_ptr(windowPtr);
     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
-        w.hasShadow = YES;
-        w.contentView.wantsLayer = YES;
         w.contentView.layer.cornerRadius = radius;
         w.contentView.layer.masksToBounds = YES;
         w.contentView.layer.opaque = NO;
@@ -3024,11 +3039,11 @@ JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeSetRoundedCor
             w.contentView.layer.borderWidth = borderWidth;
             w.contentView.layer.borderColor = color.CGColor;
         }
+        w.contentView.wantsLayer = YES;
 
         w.backgroundColor = NSColor.clearColor;
         w.opaque = NO;
-        // remove corner radius animation
-        [w.contentView.layer removeAllAnimations];
+        w.hasShadow = YES;
         [w invalidateShadow];
     }];
 

src/java.desktop/macosx/native/libawt_lwawt/java2d/metal/MTLLayer.h

@@ -71,6 +71,8 @@
 - (void) stopRedraw:(MTLContext*)mtlc displayID:(jint)displayID force:(BOOL)force;
 - (void) flushBuffer;
 - (void) commitCommandBuffer:(MTLContext*)mtlc wait:(BOOL)waitUntilCompleted display:(BOOL)updateDisplay;
+
+- (void) addStatCallback:(int)type value:(double)value;
 - (void) countFramePresentedCallback;
 - (void) countFrameDroppedCallback;
 @end

src/java.desktop/macosx/native/libawt_lwawt/java2d/metal/MTLLayer.m

@@ -129,6 +129,7 @@ BOOL MTLLayer_isExtraRedrawEnabled() {
                                     [NSNull null], @"anchorPoint",
                                     [NSNull null], @"bounds",
                                     [NSNull null], @"contents",
+                                    [NSNull null], @"cornerRadius",
                                     [NSNull null], @"contentsScale",
                                     [NSNull null], @"onOrderIn",
                                     [NSNull null], @"onOrderOut",
@@ -226,29 +227,33 @@ BOOL MTLLayer_isExtraRedrawEnabled() {
             }
 
             // Acquire CAMetalDrawable without blocking:
-            const CFTimeInterval beforeDrawableTime = (TRACE_DISPLAY) ? CACurrentMediaTime() : 0.0;
+            const CFTimeInterval beforeDrawableTime = CACurrentMediaTime();
             const id<CAMetalDrawable> mtlDrawable = [self nextDrawable];
             if (mtlDrawable == nil) {
                 J2dTraceLn(J2D_TRACE_VERBOSE, "MTLLayer.blitTexture: nextDrawable is null");
                 return;
             }
-            const CFTimeInterval nextDrawableTime = (TRACE_DISPLAY) ? CACurrentMediaTime() : 0.0;
+            const CFTimeInterval nextDrawableTime = CACurrentMediaTime();
+            const CFTimeInterval nextDrawableLatency = (nextDrawableTime - beforeDrawableTime);
 
             // rolling mean weight (lerp):
             static const NSTimeInterval a = 0.25;
 
-#if TRACE_DISPLAY_ON
-            const CFTimeInterval nextDrawableLatency = (nextDrawableTime - beforeDrawableTime);
             if (nextDrawableLatency > 0.0) {
+                if (self.perfCountersEnabled) {
+                    [self addStatCallback:1 value:1000.0 * nextDrawableLatency]; // See MTLLayer.STAT_NAMES[1]
+                }
+#if TRACE_DISPLAY_ON
                 self.avgNextDrawableTime = nextDrawableLatency * a + self.avgNextDrawableTime * (1.0 - a);
-            }
-            J2dRlsTraceLn(J2D_TRACE_VERBOSE,
-                          "[%.6lf] MTLLayer_blitTexture: drawable(%d) presented"
-                          " - nextDrawableLatency = %.3lf ms - average = %.3lf ms",
-                          CACurrentMediaTime(), mtlDrawable.drawableID,
-                          1000.0 * nextDrawableLatency, 1000.0 * self.avgNextDrawableTime
-            );
+
+                J2dRlsTraceLn(J2D_TRACE_VERBOSE,
+                              "[%.6lf] MTLLayer_blitTexture: drawable(%d) presented"
+                              " - nextDrawableLatency = %.3lf ms - average = %.3lf ms",
+                              CACurrentMediaTime(), mtlDrawable.drawableID,
+                              1000.0 * nextDrawableLatency, 1000.0 * self.avgNextDrawableTime
+                );
 #endif
+            }
             // Keep Fence from now:
             releaseFence = NO;
 
@@ -389,8 +394,17 @@ BOOL MTLLayer_isExtraRedrawEnabled() {
         return;
     }
 
+    const CFTimeInterval beforeMethod = CACurrentMediaTime();
+
     (*env)->CallVoidMethod(env, javaLayerLocalRef, jm_drawInMTLContext);
     CHECK_EXCEPTION();
+
+    const CFTimeInterval drawInMTLContextLatency = (CACurrentMediaTime() - beforeMethod);
+    if (drawInMTLContextLatency > 0.0) {
+        if (self.perfCountersEnabled) {
+            [self addStatCallback:0 value:1000.0 * drawInMTLContextLatency]; // See MTLLayer.STAT_NAMES[0]
+        }
+    }
     (*env)->DeleteLocalRef(env, javaLayerLocalRef);
 }
 
@@ -516,6 +530,20 @@ BOOL MTLLayer_isExtraRedrawEnabled() {
     }
 }
 
+- (void) addStatCallback:(int)type value:(double)value {
+    // attach the current thread to the JVM if necessary, and get an env
+    JNIEnv* env = [ThreadUtilities getJNIEnvUncached];
+    GET_MTL_LAYER_CLASS();
+    DECLARE_METHOD(jm_addStatFrame, jc_JavaLayer, "addStat", "(ID)V");
+
+    jobject javaLayerLocalRef = (*env)->NewLocalRef(env, self.javaLayer);
+    if (javaLayerLocalRef != NULL) {
+        (*env)->CallVoidMethod(env, javaLayerLocalRef, jm_addStatFrame, (jint)type, (jdouble)value);
+        CHECK_EXCEPTION();
+        (*env)->DeleteLocalRef(env, javaLayerLocalRef);
+    }
+}
+
 - (void) countFrameDroppedCallback {
     // attach the current thread to the JVM if necessary, and get an env
     JNIEnv* env = [ThreadUtilities getJNIEnvUncached];

src/java.desktop/macosx/native/libawt_lwawt/java2d/opengl/CGLLayer.m

@@ -63,6 +63,7 @@ AWT_ASSERT_APPKIT_THREAD;
                                     [NSNull null], @"anchorPoint",
                                     [NSNull null], @"bounds",
                                     [NSNull null], @"contents",
+                                    [NSNull null], @"cornerRadius",
                                     [NSNull null], @"contentsScale",
                                     [NSNull null], @"onOrderIn",
                                     [NSNull null], @"onOrderOut",

src/java.desktop/share/classes/com/jetbrains/desktop/Vulkan.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2025 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.jetbrains.desktop;
+
+import com.jetbrains.exported.JBRApi;
+import sun.java2d.vulkan.VKEnv;
+import sun.java2d.vulkan.VKGPU;
+
+@JBRApi.Service
+@JBRApi.Provides("Vulkan")
+public class Vulkan {
+
+    Vulkan() {
+        if (!VKEnv.isVulkanEnabled()) throw new JBRApi.ServiceNotAvailableException("Vulkan is not enabled");
+    }
+
+    boolean isPresentationEnabled() {
+        return VKEnv.isPresentationEnabled();
+    }
+
+    Device[] getDevices() {
+        return VKEnv.getDevices().map(Device::new).toArray(Device[]::new);
+    }
+
+    @JBRApi.Provides("Vulkan.Device")
+    static class Device {
+        private final VKGPU device;
+
+        Device(VKGPU device) {
+            this.device = device;
+        }
+
+        String getName() {
+            return device.getName();
+        }
+
+        String getTypeString() {
+            return device.getType().toString();
+        }
+
+        int getCapabilities() {
+            return device.getCaps();
+        }
+    }
+}

src/java.desktop/share/classes/java/awt/Component.java

@@ -53,10 +53,14 @@ import java.awt.event.TextEvent;
 import java.awt.im.InputContext;
 import java.awt.im.InputMethodRequests;
 import java.awt.image.BufferStrategy;
+import java.awt.image.BufferedImage;
 import java.awt.image.ColorModel;
 import java.awt.image.ImageObserver;
 import java.awt.image.ImageProducer;
+import java.awt.image.Raster;
+import java.awt.image.SampleModel;
 import java.awt.image.VolatileImage;
+import java.awt.image.WritableRaster;
 import java.awt.peer.ComponentPeer;
 import java.awt.peer.ContainerPeer;
 import java.awt.peer.LightweightPeer;
@@ -89,6 +93,7 @@ import javax.accessibility.AccessibleStateSet;
 import javax.swing.JComponent;
 import javax.swing.JRootPane;
 
+import com.jetbrains.exported.JBRApi;
 import sun.awt.AWTAccessor;
 import sun.awt.AppContext;
 import sun.awt.ComponentFactory;
@@ -99,6 +104,7 @@ import sun.awt.EmbeddedFrame;
 import sun.awt.RequestFocusController;
 import sun.awt.SubRegionShowable;
 import sun.awt.SunToolkit;
+import sun.awt.SurfacePixelGrabber;
 import sun.awt.dnd.SunDropTargetEvent;
 import sun.awt.im.CompositionArea;
 import sun.awt.image.VSyncedBSManager;
@@ -10559,4 +10565,79 @@ public abstract class Component implements ImageObserver, MenuContainer,
         }
         return p.updateCustomTitleBarHitTest(allowNativeActions);
     }
+
+    @JBRApi.Provides("Screenshoter#getWindowBackbufferArea")
+    private static BufferedImage getWindowBackbufferArea(Window window, int x, int y, int width, int height) {
+        Objects.requireNonNull(window);
+
+        if (x < 0 || y < 0) {
+            throw new IllegalArgumentException("Negative coordinates are not allowed");
+        }
+
+        if (width <= 0 || height <= 0) {
+            throw new IllegalArgumentException("The size must be positive");
+        }
+
+        Image fullBackbuffer = window.getBackBuffer();
+        if (fullBackbuffer == null) {
+            return null;
+        }
+
+        var bufferWidth = fullBackbuffer.getWidth(null);
+        var bufferHeight = fullBackbuffer.getHeight(null);
+        if (x >= width) {
+            throw new IllegalArgumentException(String.format("x coordinate (%d) is out of bounds (%d)", x, bufferWidth));
+        }
+
+        if (y >= height) {
+            throw new IllegalArgumentException(String.format("y coordinate (%d) is out of bounds (%d)", y, bufferHeight));
+        }
+
+        if ((long) x + width > bufferWidth) {
+            width = bufferWidth - x;
+        }
+
+        if ((long) y + height > bufferHeight) {
+            height  = bufferHeight - y;
+        }
+
+        if (fullBackbuffer instanceof BufferedImage bufferedImage) {
+            return bufferedImage.getSubimage(x, y, width, height);
+        } else {
+            ColorModel colorModel = window.getGraphicsConfiguration().getColorModel();
+            SampleModel sampleModel = colorModel.createCompatibleSampleModel(width, height);
+            WritableRaster raster = Raster.createWritableRaster(sampleModel, null);
+            BufferedImage image = new BufferedImage(colorModel, raster, colorModel.isAlphaPremultiplied(), null);
+            image.getGraphics().drawImage(fullBackbuffer,
+                    0, 0, width, height,
+                    x, y, x + width, y + height,
+                    null);
+            return image;
+        }
+    }
+
+    @JBRApi.Provides("Screenshoter#getWindowSurfaceArea")
+    private static BufferedImage getWindowSurfaceArea(Window window, int x, int y, int width, int height) {
+        Objects.requireNonNull(window);
+
+        if (x < 0 || y < 0) {
+            throw new IllegalArgumentException("Negative coordinates are not allowed");
+        }
+
+        if (width <= 0 || height <= 0) {
+            throw new IllegalArgumentException("The size must be positive");
+        }
+
+        ComponentPeer peer = window.peer;
+        if (peer == null || !window.isVisible()) {
+            return null;
+        }
+
+        if (peer instanceof SurfacePixelGrabber spg) {
+            // TODO: translate coordinates, maybe?
+            return spg.getClientAreaSnapshot(x, y, width, height);
+        }
+
+        return null;
+    }
 }

src/java.desktop/share/classes/java/awt/Window.java

@@ -34,7 +34,6 @@ import java.awt.event.WindowFocusListener;
 import java.awt.event.WindowListener;
 import java.awt.event.WindowStateListener;
 import java.awt.geom.Path2D;
-import java.awt.geom.Point2D;
 import java.awt.im.InputContext;
 import java.awt.image.BufferStrategy;
 import java.awt.peer.ComponentPeer;
@@ -44,6 +43,7 @@ import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.OptionalDataException;
+import java.io.PrintStream;
 import java.io.Serial;
 import java.io.Serializable;
 import java.lang.annotation.Native;
@@ -53,12 +53,15 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.EventListener;
+import java.util.LinkedHashMap;
 import java.util.Locale;
 import java.util.Map;
 import java.util.HashMap;
 import java.util.Objects;
 import java.util.ResourceBundle;
 import java.util.Set;
+import java.util.Timer;
+import java.util.TimerTask;
 import java.util.Vector;
 import java.util.concurrent.atomic.AtomicBoolean;
 
@@ -69,11 +72,14 @@ import javax.accessibility.AccessibleState;
 import javax.accessibility.AccessibleStateSet;
 
 import com.jetbrains.exported.JBRApi;
+import jdk.internal.misc.InnocuousThread;
 import sun.awt.AWTAccessor;
 import sun.awt.AppContext;
 import sun.awt.DebugSettings;
 import sun.awt.SunToolkit;
 import sun.awt.util.IdentityArrayList;
+import sun.awt.util.ThreadGroupUtils;
+import sun.java2d.marlin.stats.StatDouble;
 import sun.java2d.pipe.Region;
 import sun.util.logging.PlatformLogger;
 
@@ -1153,45 +1159,51 @@ public class Window extends Container implements Accessible {
     }
 
     void doDispose() {
-    class DisposeAction implements Runnable {
-        public void run() {
-            disposing = true;
-            try {
-                // Check if this window is the fullscreen window for the
-                // device. Exit the fullscreen mode prior to disposing
-                // of the window if that's the case.
-                GraphicsDevice gd = getGraphicsConfiguration().getDevice();
-                if (gd.getFullScreenWindow() == Window.this) {
-                    gd.setFullScreenWindow(null);
-                }
+        final class DisposeAction implements Runnable {
+            public void run() {
+                final Window window = Window.this;
 
-                Object[] ownedWindowArray;
-                synchronized(ownedWindowList) {
-                    ownedWindowArray = new Object[ownedWindowList.size()];
-                    ownedWindowList.copyInto(ownedWindowArray);
-                }
-                for (int i = 0; i < ownedWindowArray.length; i++) {
-                    Window child = (Window) (((WeakReference)
-                                   (ownedWindowArray[i])).get());
-                    if (child != null) {
-                        child.disposeImpl();
+                // dump stats if needed:
+                AWTAccessor.getWindowAccessor().dumpStats(window, true, null);
+
+                disposing = true;
+                try {
+                    // Check if this window is the fullscreen window for the
+                    // device. Exit the fullscreen mode prior to disposing
+                    // of the window if that's the case.
+                    GraphicsDevice gd = getGraphicsConfiguration().getDevice();
+                    if (gd.getFullScreenWindow() == window) {
+                        gd.setFullScreenWindow(null);
                     }
-                }
-                hide();
-                beforeFirstShow = true;
-                removeNotify();
-                synchronized (inputContextLock) {
-                    if (inputContext != null) {
-                        inputContext.dispose();
-                        inputContext = null;
+
+                    Object[] ownedWindowArray;
+                    synchronized(ownedWindowList) {
+                        ownedWindowArray = new Object[ownedWindowList.size()];
+                        ownedWindowList.copyInto(ownedWindowArray);
                     }
+                    for (int i = 0; i < ownedWindowArray.length; i++) {
+                        Window child = (Window) (((WeakReference)
+                                       (ownedWindowArray[i])).get());
+                        if (child != null) {
+                            child.disposeImpl();
+                        }
+                    }
+                    hide();
+                    beforeFirstShow = true;
+                    removeNotify();
+                    synchronized (inputContextLock) {
+                        if (inputContext != null) {
+                            inputContext.dispose();
+                            inputContext = null;
+                        }
+                    }
+                    clearCurrentFocusCycleRootOnHide();
+                } finally {
+                    disposing = false;
                 }
-                clearCurrentFocusCycleRootOnHide();
-            } finally {
-                disposing = false;
             }
         }
-    }
+
         boolean fireWindowClosedEvent = isDisplayable();
         DisposeAction action = new DisposeAction();
         if (EventQueue.isDispatchThread()) {
@@ -3950,6 +3962,7 @@ public class Window extends Container implements Accessible {
         private float getHeight() { return height; }
         private void setHeight(float height) {
             if (height <= 0.0f) throw new IllegalArgumentException("TitleBar height must be positive");
+            if (this.height == height) return;
             this.height = height;
             notifyUpdate();
         }
@@ -3958,13 +3971,17 @@ public class Window extends Container implements Accessible {
         }
         private void putProperties(Map<String, ?> m) {
             if (properties == null) properties = new HashMap<>();
-            properties.putAll(m);
-            notifyUpdate();
+            boolean needsUpdate = false;
+            for (Map.Entry<String, ?> e : m.entrySet()) {
+                Object old = properties.put(e.getKey(), e.getValue());
+                if (!needsUpdate && !Objects.equals(old, e.getValue())) needsUpdate = true;
+            }
+            if (needsUpdate) notifyUpdate();
         }
         private void putProperty(String key, Object value) {
             if (properties == null) properties = new HashMap<>();
-            properties.put(key, value);
-            notifyUpdate();
+            Object old = properties.put(key, value);
+            if (!Objects.equals(old, value)) notifyUpdate();
         }
         private float getLeftInset() { return insets[0]; }
         private float getRightInset() { return insets[1]; }
@@ -4159,8 +4176,36 @@ public class Window extends Container implements Accessible {
         return value;
     }
 
+    private final static String STATS_ALL_SUFFIX = ".all";
+    private final static String SYSTEM_PROPERTY_COUNTERS;
+
+    private final static boolean USE_COUNTERS;
+    private final static boolean TRACE_ALL_COUNTERS;
+    private final static boolean TRACE_STD_ERR;
+
+    private final static int TRACE_CAPACITY;
+
+    private final static boolean TRACE_COUNTERS = true;
+    private final static boolean DUMP_STATS = true;
+
+    // thread dump interval (ms)
+    static final long DUMP_INTERVAL = 10 * 1000L;
+
+    private static PrintStream getTraceStdStream() {
+        // get live std stream:
+        return TRACE_STD_ERR ? System.err : System.out;
+    }
+
     static {
-        String counters = System.getProperty("awt.window.counters");
+        SYSTEM_PROPERTY_COUNTERS = System.getProperty("awt.window.counters");
+        USE_COUNTERS = (SYSTEM_PROPERTY_COUNTERS != null);
+
+        TRACE_ALL_COUNTERS = USE_COUNTERS && (Objects.equals(SYSTEM_PROPERTY_COUNTERS, "")
+                                            || Objects.equals(SYSTEM_PROPERTY_COUNTERS, "stderr")
+                                            || Objects.equals(SYSTEM_PROPERTY_COUNTERS, "stdout"));
+
+        TRACE_STD_ERR = USE_COUNTERS && SYSTEM_PROPERTY_COUNTERS.contains("stderr");
+        TRACE_CAPACITY = USE_COUNTERS ? 8 : 0;
 
         AWTAccessor.setWindowAccessor(new AWTAccessor.WindowAccessor() {
             public void updateWindow(Window window) {
@@ -4197,100 +4242,206 @@ public class Window extends Container implements Accessible {
 
             public boolean countersEnabled(Window w) {
                 // May want to selectively enable or disable counters per window
-                return counters != null;
+                return USE_COUNTERS;
             }
 
-            public void bumpCounter(Window w, String counterName) {
-                Objects.requireNonNull(w);
-                Objects.requireNonNull(counterName);
+            private final static long NANO_IN_SEC = java.util.concurrent.TimeUnit.SECONDS.toNanos(1);
 
-                PerfCounter newCounter;
-                long curTimeNanos = System.nanoTime();
-                synchronized (w.perfCounters) {
-                    newCounter = w.perfCounters.compute(counterName, (k, v) ->
-                            v == null
-                            ? new PerfCounter(curTimeNanos, 1L)
-                            : new PerfCounter(curTimeNanos, v.value + 1));
-                }
-                PerfCounter prevCounter;
-                synchronized (w.perfCountersPrev) {
-                    prevCounter = w.perfCountersPrev.putIfAbsent(counterName, newCounter);
-                }
-                if (prevCounter != null) {
-                    long nanosInSecond = java.util.concurrent.TimeUnit.SECONDS.toNanos(1);
-                    long timeDeltaNanos = curTimeNanos - prevCounter.updateTimeNanos;
-                    if (timeDeltaNanos > nanosInSecond) {
-                        long valPerSecond = (long) ((double) (newCounter.value - prevCounter.value)
-                                * nanosInSecond / timeDeltaNanos);
-                        boolean traceAllCounters = Objects.equals(counters, "")
-                                || Objects.equals(counters, "stdout")
-                                || Objects.equals(counters, "stderr");
-                        boolean traceEnabled = traceAllCounters || (counters != null && counters.contains(counterName));
-                        if (traceEnabled) {
-                            if (counters.contains("stderr")) {
-                                System.err.println(counterName + " per second: " + valPerSecond);
-                            } else {
-                                System.out.println(counterName + " per second: " + valPerSecond);
-                            }
-                        }
-                        if (perfLog.isLoggable(PlatformLogger.Level.FINE)) {
-                            perfLog.fine(counterName + " per second: " + valPerSecond);
+            public void incrementCounter(final Window w, final String counterName) {
+                if (USE_COUNTERS) {
+                    Objects.requireNonNull(w);
+                    Objects.requireNonNull(counterName);
+
+                    final long curTimeNanos = System.nanoTime();
+                    // use try-catch to avoid throwing runtime exception to native JNI callers!
+                    try {
+                        PerfCounter newCounter, prevCounter;
+                        synchronized (w.perfCounters) {
+                            newCounter = w.perfCounters.compute(counterName, (_, v) ->
+                                    v == null
+                                            ? new PerfCounter(curTimeNanos, 1L)
+                                            : new PerfCounter(curTimeNanos, v.value + 1));
                         }
                         synchronized (w.perfCountersPrev) {
-                            w.perfCountersPrev.put(counterName, newCounter);
+                            prevCounter = w.perfCountersPrev.putIfAbsent(counterName, newCounter);
+                        }
+                        if (prevCounter != null) {
+                            final long timeDeltaNanos = curTimeNanos - prevCounter.updateTimeNanos;
+                            if (timeDeltaNanos > NANO_IN_SEC) {
+                                final double valPerSecond = (double) (newCounter.value - prevCounter.value)
+                                        * NANO_IN_SEC / timeDeltaNanos;
+
+                                synchronized (w.perfCountersPrev) {
+                                    w.perfCountersPrev.put(counterName, newCounter);
+                                }
+                                addStat(w, counterName, valPerSecond);
+                                if (TRACE_COUNTERS) {
+                                    dumpCounter(counterName, valPerSecond);
+                                }
+                            }
+                        }
+                    } catch (RuntimeException re) {
+                        perfLog.severe("incrementCounter: failed", re);
+                    }
+                }
+            }
+
+            public void addStat(final Window w, final String statName, final double value) {
+                if (USE_COUNTERS && Double.isFinite(value)) {
+                    Objects.requireNonNull(w);
+                    Objects.requireNonNull(statName);
+
+                    // use try-catch to avoid throwing runtime exception to native JNI callers!
+                    try {
+                        synchronized (w.perfStats) {
+                            StatDouble stat = w.perfStats.computeIfAbsent(statName, StatDouble::new);
+                            stat.add(value);
+                            stat = w.perfStats.computeIfAbsent(statName + STATS_ALL_SUFFIX, StatDouble::new);
+                            stat.add(value);
+                        }
+                    } catch (RuntimeException re) {
+                        perfLog.severe("addStat: failed", re);
+                    }
+                }
+            }
+
+            public long getCounter(final Window w, final String counterName) {
+                if (USE_COUNTERS) {
+                    Objects.requireNonNull(w);
+                    Objects.requireNonNull(counterName);
+
+                    synchronized (w.perfCounters) {
+                        PerfCounter counter = w.perfCounters.get(counterName);
+                        return counter != null ? counter.value : -1L;
+                    }
+                }
+                return -1L;
+            }
+
+            public double getCounterPerSecond(final Window w, final String counterName) {
+                if (USE_COUNTERS) {
+                    Objects.requireNonNull(w);
+                    Objects.requireNonNull(counterName);
+
+                    PerfCounter newCounter, prevCounter;
+                    synchronized (w.perfCounters) {
+                        newCounter = w.perfCounters.get(counterName);
+                    }
+                    synchronized (w.perfCountersPrev) {
+                        prevCounter = w.perfCountersPrev.get(counterName);
+                    }
+
+                    if (newCounter != null && prevCounter != null) {
+                        final long timeDeltaNanos = newCounter.updateTimeNanos - prevCounter.updateTimeNanos;
+                        // Note that this time delta will usually be above one second.
+                        if (timeDeltaNanos > 0L) {
+                            return (double) (newCounter.value - prevCounter.value) * NANO_IN_SEC / timeDeltaNanos;
+                        }
+                    }
+                }
+                return Double.NaN;
+            }
+
+            public void dumpStats(final Window w, final boolean reset, StringBuilder sb) {
+                if (USE_COUNTERS) {
+                    synchronized (w.perfStats) {
+                        boolean header = false;
+
+                        for (final StatDouble stat : w.perfStats.values()) {
+                            if (stat.shouldLog()) {
+                                final boolean traceEnabled = TRACE_ALL_COUNTERS || SYSTEM_PROPERTY_COUNTERS.contains(stat.name);
+                                if (!header) {
+                                    header = true;
+                                    doLog(String.format("* Window['%s'@%s]:",
+                                            (w instanceof Frame ? ((Frame) w).getTitle() : ""),
+                                            Integer.toHexString(System.identityHashCode(w))),
+                                            traceEnabled);
+                                }
+                                // format:
+                                if (sb == null) {
+                                    sb = new StringBuilder(128);
+                                }
+                                sb.setLength(0);
+                                sb.append("  - ");
+                                stat.toString(sb);
+                                doLog(sb.toString(), traceEnabled);
+
+                                if (reset && !stat.name.endsWith(STATS_ALL_SUFFIX)) {
+                                    stat.reset();
+                                } else {
+                                    stat.updateLastLogCount();
+                                }
+                            }
                         }
                     }
                 }
             }
 
-            public long getCounter(Window w, String counterName) {
-                Objects.requireNonNull(w);
-                Objects.requireNonNull(counterName);
+            @Override
+            public void addWindowListener(Window w, WindowListener listener) {
+                w.addWindowListener(listener);
+            }
 
-                synchronized (w.perfCounters) {
-                    PerfCounter counter = w.perfCounters.get(counterName);
-                    return counter != null ? counter.value : -1L;
+            private static void dumpCounter(final String counterName, final double valPerSecond) {
+                if (USE_COUNTERS) {
+                    doLog(String.format("%s per second: %.2f", counterName, valPerSecond),
+                            TRACE_ALL_COUNTERS || SYSTEM_PROPERTY_COUNTERS.contains(counterName));
                 }
             }
 
-            public long getCounterPerSecond(Window w, String counterName) {
-                Objects.requireNonNull(w);
-                Objects.requireNonNull(counterName);
-
-                PerfCounter newCounter;
-                PerfCounter prevCounter;
-
-                synchronized (w.perfCounters) {
-                    newCounter = w.perfCounters.get(counterName);
+            private static void doLog(final String msg, final boolean traceEnabled) {
+                if (traceEnabled) {
+                    getTraceStdStream().println(msg);
                 }
-
-                synchronized (w.perfCountersPrev) {
-                    prevCounter = w.perfCountersPrev.get(counterName);
+                if (perfLog.isLoggable(PlatformLogger.Level.FINE)) {
+                    perfLog.fine(msg);
                 }
-
-                if (newCounter != null && prevCounter != null) {
-                    long timeDeltaNanos = newCounter.updateTimeNanos - prevCounter.updateTimeNanos;
-                    // Note that this time delta will usually be above one second.
-                    if (timeDeltaNanos > 0) {
-                        long nanosInSecond = java.util.concurrent.TimeUnit.SECONDS.toNanos(1);
-                        long valPerSecond = (long) ((double) (newCounter.value - prevCounter.value)
-                                * nanosInSecond / timeDeltaNanos);
-                        return valPerSecond;
-                    }
-                }
-                return -1;
             }
         }); // WindowAccessor
+
+        if (USE_COUNTERS) {
+            final Runnable dumper = new Runnable() {
+                private final static StringBuilder sb = new StringBuilder(128);
+
+                @Override
+                public void run() {
+                    getTraceStdStream().printf("--- WindowStats dump at: %s ---\n", new java.util.Date());
+
+                    final AWTAccessor.WindowAccessor windowAccessor = AWTAccessor.getWindowAccessor();
+
+                    for (Window window : Window.getWindows()) {
+                        // dump stats if needed:
+                        windowAccessor.dumpStats(window, true, sb);
+                    }
+                    getTraceStdStream().println("-----");
+                }
+            };
+            final Thread hook = InnocuousThread.newSystemThread("WindowStatsHook", dumper);
+            hook.setDaemon(true);
+            hook.setContextClassLoader(null);
+            Runtime.getRuntime().addShutdownHook(hook);
+
+            if (DUMP_STATS) {
+                final Timer statTimer = new Timer("WindowStats", true);
+                statTimer.scheduleAtFixedRate(new TimerTask() {
+                    @Override
+                    public void run() {
+                        dumper.run();
+                    }
+                }, DUMP_INTERVAL, DUMP_INTERVAL);
+            }
+        }
     } // static
 
     // a window doesn't need to be updated in the Z-order.
     @Override
     void updateZOrder() {}
 
-    private record PerfCounter(Long updateTimeNanos, Long value) {}
+    private record PerfCounter(long updateTimeNanos, long value) {}
 
-    private transient final Map<String, PerfCounter> perfCounters = new HashMap<>(4);
-    private transient final Map<String, PerfCounter> perfCountersPrev = new HashMap<>(4);
+    private transient final HashMap<String, PerfCounter> perfCounters = (USE_COUNTERS) ? new HashMap<>(TRACE_CAPACITY) : null;
+    private transient final HashMap<String, PerfCounter> perfCountersPrev = (USE_COUNTERS) ? new HashMap<>(TRACE_CAPACITY) : null;
+    private transient final LinkedHashMap<String, StatDouble> perfStats = (USE_COUNTERS) ? new LinkedHashMap<>(TRACE_CAPACITY) : null;
 
 } // class Window
 

src/java.desktop/share/classes/javax/swing/RepaintManager.java

@@ -27,10 +27,7 @@ package javax.swing;
 
 import java.awt.*;
 import java.awt.event.*;
-import java.awt.geom.Point2D;
-import java.awt.geom.Rectangle2D;
 import java.awt.image.VolatileImage;
-import java.awt.peer.WindowPeer;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.applet.*;
@@ -43,14 +40,12 @@ import sun.java2d.SunGraphicsEnvironment;
 
 import com.sun.java.swing.SwingUtilities3;
 import java.awt.geom.AffineTransform;
-import java.util.stream.Collectors;
 
 import sun.java2d.SunGraphics2D;
 import sun.java2d.pipe.Region;
 import sun.swing.SwingAccessor;
 import sun.swing.SwingUtilities2;
 import sun.swing.SwingUtilities2.RepaintListener;
-import java.util.stream.Collectors;
 
 /**
  * This class manages repaint requests, allowing the number
@@ -755,7 +750,7 @@ public class RepaintManager
                     .filter(Objects::nonNull)
                     .distinct()
                     .forEach(w -> AWTAccessor.getWindowAccessor()
-                            .bumpCounter(w, "swing.RepaintManager.updateWindows"));
+                            .incrementCounter(w, "swing.RepaintManager.updateWindows"));
 
         if (Toolkit.getDefaultToolkit() instanceof SunToolkit sunToolkit &&
             sunToolkit.needUpdateWindow()) {
@@ -774,14 +769,14 @@ public class RepaintManager
 
             for (Window window : windows) {
                 AWTAccessor.getWindowAccessor().updateWindow(window);
-                AWTAccessor.getWindowAccessor().bumpCounter(window, "swing.RepaintManager.updateWindows");
+                AWTAccessor.getWindowAccessor().incrementCounter(window, "swing.RepaintManager.updateWindows");
             }
         } else {
             dirtyComponents.keySet().stream()
                     .map(c -> c instanceof Window w ? w : SwingUtilities.getWindowAncestor(c))
                     .filter(Objects::nonNull)
                     .forEach(w -> AWTAccessor.getWindowAccessor()
-                            .bumpCounter(w, "swing.RepaintManager.updateWindows"));
+                            .incrementCounter(w, "swing.RepaintManager.updateWindows"));
         }
     }
 

src/java.desktop/share/classes/javax/swing/plaf/basic/BasicTreeUI.java

@@ -748,6 +748,27 @@ public class BasicTreeUI extends TreeUI
         return bounds;
     }
 
+    /**
+     * A potentially faster version of {@link #getPathBounds(JTree, TreePath)}
+     * which calculates only {@code y} and {@code height}
+     * of the bounding {@code Rectangle}
+     */
+    private Rectangle getVerticalPathBounds(TreePath path) {
+        if (tree == null || treeState == null) {
+            return null;
+        }
+        int rowHeight = treeState.getRowHeight();
+        if (rowHeight <= 0) {
+            return getPathBounds(tree, path);
+        }
+        int row = treeState.getRowForPath(path);
+        if (row < 0) {
+            return null;
+        }
+        return new Rectangle(0, tree.getInsets().top + row * rowHeight,
+                0, rowHeight);
+    }
+
     /**
       * Returns the path for passed in row.  If row is not visible
       * null is returned.
@@ -4381,17 +4402,21 @@ public class BasicTreeUI extends TreeUI
                     updateSize();
                 }
                 else if (treeState.isExpanded(parentPath)) {
-                    // Changed nodes are visible
-                    // Find the minimum index, we only need paint from there
-                    // down.
-                    int minIndex = indices[0];
-                    for (int i = indices.length - 1; i > 0; i--) {
-                        minIndex = Math.min(indices[i], minIndex);
+                    TreePath minPath = null;
+                    Rectangle minBounds = null;
+                    if (tree.isShowing()) {
+                        // Changed nodes are visible
+                        // Find the minimum index, we only need paint from there
+                        // down.
+                        int minIndex = indices[0];
+                        for (int i = indices.length - 1; i > 0; i--) {
+                            minIndex = Math.min(indices[i], minIndex);
+                        }
+                        Object minChild = treeModel.getChild(
+                                parentPath.getLastPathComponent(), minIndex);
+                        minPath = parentPath.pathByAddingChild(minChild);
+                        minBounds = getVerticalPathBounds(minPath);
                     }
-                    Object minChild = treeModel.getChild(
-                            parentPath.getLastPathComponent(), minIndex);
-                    TreePath minPath = parentPath.pathByAddingChild(minChild);
-                    Rectangle minBounds = getPathBounds(tree, minPath);
 
                     // Forward to the treestate
                     treeState.treeNodesChanged(e);
@@ -4399,20 +4424,19 @@ public class BasicTreeUI extends TreeUI
                     // Mark preferred size as bogus.
                     updateSize0();
 
-                    // And repaint
-                    Rectangle newMinBounds = getPathBounds(tree, minPath);
-                    if (minBounds == null || newMinBounds == null) {
-                        return;
-                    }
-
-                    if (indices.length == 1 &&
-                            newMinBounds.height == minBounds.height) {
-                        tree.repaint(0, minBounds.y, tree.getWidth(),
-                                     minBounds.height);
-                    }
-                    else {
-                        tree.repaint(0, minBounds.y, tree.getWidth(),
-                                     tree.getHeight() - minBounds.y);
+                    if (minBounds != null) {
+                        // And repaint
+                        Rectangle newMinBounds = getVerticalPathBounds(minPath);
+                        if (newMinBounds != null) {
+                            if (indices.length == 1 &&
+                                    newMinBounds.height == minBounds.height) {
+                                tree.repaint(0, minBounds.y, tree.getWidth(),
+                                        minBounds.height);
+                            } else {
+                                tree.repaint(0, minBounds.y, tree.getWidth(),
+                                        tree.getHeight() - minBounds.y);
+                            }
+                        }
                     }
                 }
                 else {

src/java.desktop/share/classes/sun/awt/AWTAccessor.java

@@ -37,7 +37,7 @@ import java.awt.event.InputEvent;
 import java.awt.event.InvocationEvent;
 import java.awt.event.KeyEvent;
 import java.awt.event.MouseEvent;
-import java.awt.geom.Point2D;
+import java.awt.event.WindowListener;
 import java.awt.image.BufferStrategy;
 import java.awt.peer.ComponentPeer;
 
@@ -329,10 +329,17 @@ public final class AWTAccessor {
          */
         Window[] getOwnedWindows(Window w);
 
+        /* JBR Window counters API */
         boolean countersEnabled(Window w);
-        void bumpCounter(Window w, String counterName);
+        void incrementCounter(Window w, String counterName);
+        void addStat(Window w, String statName, double value);
+
         long getCounter(Window w, String counterName);
-        long getCounterPerSecond(Window w, String counterName);
+        double getCounterPerSecond(Window w, String counterName);
+
+        void dumpStats(Window w, boolean reset, StringBuilder sb);
+
+        void addWindowListener(Window w, WindowListener listener);
     }
 
     /**

src/java.desktop/share/classes/sun/awt/SunToolkit.java

@@ -50,6 +50,7 @@ import java.awt.KeyboardFocusManager;
 import java.awt.Label;
 import java.awt.MenuComponent;
 import java.awt.Panel;
+import java.awt.Point;
 import java.awt.RenderingHints;
 import java.awt.ScrollPane;
 import java.awt.Scrollbar;
@@ -90,6 +91,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.ReentrantLock;
 
+import com.jetbrains.exported.JBRApi;
 import sun.awt.im.InputContext;
 import sun.awt.image.ByteArrayImageSource;
 import sun.awt.image.FileImageSource;
@@ -2084,6 +2086,23 @@ public abstract class SunToolkit extends Toolkit
         return AWTAccessor.getAWTEventAccessor().isSystemGenerated(e);
     }
 
+    @JBRApi.Service
+    @JBRApi.Provides("RelativePointerMovement")
+    public interface RelativePointerMovementInfoProvider {
+        private static RelativePointerMovementInfoProvider create() {
+            var tk = Toolkit.getDefaultToolkit();
+            if (tk instanceof ComponentFactory cf) {
+                var mouseInfoPeer = cf.getMouseInfoPeer();
+                if (mouseInfoPeer instanceof RelativePointerMovementInfoProvider p){
+                    return p;
+                }
+            }
+
+            throw new JBRApi.ServiceNotAvailableException("Service not supported for toolkit " + tk.getClass().getName());
+        }
+
+        Point getAccumulatedMouseDeltaAndReset();
+    }
 } // class SunToolkit
 
 

src/java.desktop/share/classes/sun/awt/SurfacePixelGrabber.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2025 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+package sun.awt;
+
+import java.awt.image.BufferedImage;
+
+public interface SurfacePixelGrabber {
+    BufferedImage getClientAreaSnapshot(int x, int y, int width, int height);
+}

src/java.desktop/share/classes/sun/java2d/marlin/Curve.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2007, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -144,7 +144,9 @@ final class Curve {
     // finds points where the first and second derivative are
     // perpendicular. This happens when g(t) = f'(t)*f''(t) == 0 (where
     // * is a dot product). Unfortunately, we have to solve a cubic.
-    private int perpendiculardfddf(final double[] pts, final int off) {
+    private int perpendiculardfddf(final double[] pts, final int off,
+                                   final double A, final double B)
+    {
         assert pts.length >= off + 4;
 
         // these are the coefficients of some multiple of g(t) (not g(t),
@@ -155,7 +157,7 @@ final class Curve {
         final double c = 2.0d * (dax * cx + day * cy) + dbx * dbx + dby * dby;
         final double d = dbx * cx + dby * cy;
 
-        return Helpers.cubicRootsInAB(a, b, c, d, pts, off, 0.0d, 1.0d);
+        return Helpers.cubicRootsInAB(a, b, c, d, pts, off, A, B);
     }
 
     // Tries to find the roots of the function ROC(t)-w in [0, 1). It uses
@@ -171,35 +173,43 @@ final class Curve {
     // at most 4 sub-intervals of (0,1). ROC has asymptotes at inflection
     // points, so roc-w can have at least 6 roots. This shouldn't be a
     // problem for what we're trying to do (draw a nice looking curve).
-    int rootsOfROCMinusW(final double[] roots, final int off, final double w2, final double err) {
+    int rootsOfROCMinusW(final double[] roots, final int off, final double w2,
+                         final double A, final double B)
+    {
         // no OOB exception, because by now off<=6, and roots.length >= 10
         assert off <= 6 && roots.length >= 10;
 
         int ret = off;
-        final int end = off + perpendiculardfddf(roots, off);
+        final int end = off + perpendiculardfddf(roots, off, A, B);
+        Helpers.isort(roots, off, end);
         roots[end] = 1.0d; // always check interval end points
 
-        double t0 = 0.0d, ft0 = ROCsq(t0) - w2;
+        double t0 = 0.0d;
+        double ft0 = eliminateInf(ROCsq(t0) - w2);
+        double t1, ft1;
 
         for (int i = off; i <= end; i++) {
-            double t1 = roots[i], ft1 = ROCsq(t1) - w2;
+            t1 = roots[i];
+            ft1 = eliminateInf(ROCsq(t1) - w2);
             if (ft0 == 0.0d) {
                 roots[ret++] = t0;
             } else if (ft1 * ft0 < 0.0d) { // have opposite signs
                 // (ROC(t)^2 == w^2) == (ROC(t) == w) is true because
                 // ROC(t) >= 0 for all t.
-                roots[ret++] = falsePositionROCsqMinusX(t0, t1, w2, err);
+                roots[ret++] = falsePositionROCsqMinusX(t0, t1, ft0, ft1, w2, A); // A = err
             }
             t0 = t1;
             ft0 = ft1;
         }
-
         return ret - off;
     }
 
-    private static double eliminateInf(final double x) {
-        return (x == Double.POSITIVE_INFINITY ? Double.MAX_VALUE :
-               (x == Double.NEGATIVE_INFINITY ? Double.MIN_VALUE : x));
+    private final static double MAX_ROC_SQ = 1e20;
+
+    private static double eliminateInf(final double x2) {
+        // limit the value of x to avoid numerical problems (smaller step):
+        // must handle NaN and +Infinity:
+        return (x2 <= MAX_ROC_SQ) ? x2 : MAX_ROC_SQ;
     }
 
     // A slight modification of the false position algorithm on wikipedia.
@@ -210,17 +220,18 @@ final class Curve {
     // and turn out. Same goes for the newton's method
     // algorithm in Helpers.java
     private double falsePositionROCsqMinusX(final double t0, final double t1,
+                                            final double ft0, final double ft1,
                                             final double w2, final double err)
     {
         final int iterLimit = 100;
         int side = 0;
-        double t = t1, ft = eliminateInf(ROCsq(t) - w2);
-        double s = t0, fs = eliminateInf(ROCsq(s) - w2);
+        double s = t0, fs = eliminateInf(ft0);
+        double t = t1, ft = eliminateInf(ft1);
         double r = s, fr;
 
-        for (int i = 0; i < iterLimit && Math.abs(t - s) > err * Math.abs(t + s); i++) {
+        for (int i = 0; i < iterLimit && Math.abs(t - s) > err; i++) {
             r = (fs * t - ft * s) / (fs - ft);
-            fr = ROCsq(r) - w2;
+            fr = eliminateInf(ROCsq(r) - w2);
             if (sameSign(fr, ft)) {
                 ft = fr; t = r;
                 if (side < 0) {
@@ -241,7 +252,7 @@ final class Curve {
                 break;
             }
         }
-        return r;
+        return (Math.abs(ft) <= Math.abs(fs)) ? t : s;
     }
 
     private static boolean sameSign(final double x, final double y) {
@@ -256,9 +267,9 @@ final class Curve {
         final double dy = t * (t * day + dby) + cy;
         final double ddx = 2.0d * dax * t + dbx;
         final double ddy = 2.0d * day * t + dby;
-        final double dx2dy2 = dx * dx + dy * dy;
-        final double ddx2ddy2 = ddx * ddx + ddy * ddy;
-        final double ddxdxddydy = ddx * dx + ddy * dy;
-        return dx2dy2 * ((dx2dy2 * dx2dy2) / (dx2dy2 * ddx2ddy2 - ddxdxddydy * ddxdxddydy));
+        final double dx2dy2 = dx * dx + dy * dy; // positive
+        final double dxddyddxdy = dx * ddy - dy * ddx;
+        // may return +Infinity if dxddyddxdy = 0 or NaN if 0/0:
+        return (dx2dy2 * dx2dy2 * dx2dy2) / (dxddyddxdy * dxddyddxdy); // both positive
     }
 }

src/java.desktop/share/classes/sun/java2d/marlin/DMarlinRenderingEngine.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2007, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -564,7 +564,7 @@ public final class DMarlinRenderingEngine extends RenderingEngine
     }
 
     private static boolean nearZero(final double num) {
-        return Math.abs(num) < 2.0d * Math.ulp(num);
+        return Math.abs(num) < 2.0d * Helpers.ulp(num);
     }
 
     abstract static class NormalizingPathIterator implements PathIterator {

src/java.desktop/share/classes/sun/java2d/marlin/Helpers.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2007, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -31,12 +31,19 @@ import sun.java2d.marlin.stats.StatLong;
 
 final class Helpers implements MarlinConst {
 
+    private final static double T_ERR = 1e-4;
+    private final static double T_A = T_ERR;
+    private final static double T_B = 1.0 - T_ERR;
+
     private static final double EPS = 1e-9d;
 
     private Helpers() {
         throw new Error("This is a non instantiable class");
     }
 
+    /** use lower precision like former Pisces and Marlin (float-precision) */
+    static double ulp(final double value) { return Math.ulp((float)value); }
+
     static boolean within(final double x, final double y) {
         return within(x, y, EPS);
     }
@@ -322,10 +329,10 @@ final class Helpers implements MarlinConst {
 
         // now we must subdivide at points where one of the offset curves will have
         // a cusp. This happens at ts where the radius of curvature is equal to w.
-        ret += c.rootsOfROCMinusW(ts, ret, w2, 0.0001d);
+        ret += c.rootsOfROCMinusW(ts, ret, w2, T_A, T_B);
 
-        ret = filterOutNotInAB(ts, 0, ret, 0.0001d, 0.9999d);
-        isort(ts, ret);
+        ret = filterOutNotInAB(ts, 0, ret, T_A, T_B);
+        isort(ts, 0, ret);
         return ret;
     }
 
@@ -354,7 +361,7 @@ final class Helpers implements MarlinConst {
         if ((outCodeOR & OUTCODE_BOTTOM) != 0) {
             ret += curve.yPoints(ts, ret, clipRect[1]);
         }
-        isort(ts, ret);
+        isort(ts, 0, ret);
         return ret;
     }
 
@@ -374,11 +381,11 @@ final class Helpers implements MarlinConst {
         }
     }
 
-    static void isort(final double[] a, final int len) {
-        for (int i = 1, j; i < len; i++) {
+    static void isort(final double[] a, final int off, final int len) {
+        for (int i = off + 1, j; i < len; i++) {
             final double ai = a[i];
             j = i - 1;
-            for (; j >= 0 && a[j] > ai; j--) {
+            for (; j >= off && a[j] > ai; j--) {
                 a[j + 1] = a[j];
             }
             a[j + 1] = ai;

src/java.desktop/share/classes/sun/java2d/marlin/RendererStats.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -28,6 +28,8 @@ package sun.java2d.marlin;
 import java.util.Timer;
 import java.util.TimerTask;
 import java.util.concurrent.ConcurrentLinkedQueue;
+
+import jdk.internal.misc.InnocuousThread;
 import jdk.internal.ref.CleanerFactory;
 import sun.java2d.marlin.ArrayCacheConst.CacheStats;
 import static sun.java2d.marlin.MarlinUtils.logInfo;
@@ -383,21 +385,13 @@ public final class RendererStats implements MarlinConst {
             = new ConcurrentLinkedQueue<>();
 
         private RendererStatsHolder() {
-            final Thread hook = new Thread(
-                    MarlinUtils.getRootThreadGroup(),
-                    new Runnable() {
-                        @Override
-                        public void run() {
-                            dump();
-                        }
-                    },
-                    "MarlinStatsHook"
-                    );
+            final Thread hook = InnocuousThread.newSystemThread("MarlinStatsHook", () -> dump());
+            hook.setDaemon(true);
             hook.setContextClassLoader(null);
             Runtime.getRuntime().addShutdownHook(hook);
 
             if (USE_DUMP_THREAD) {
-                final Timer statTimer = new Timer("RendererStats");
+                final Timer statTimer = new Timer("RendererStats", true);
                 statTimer.scheduleAtFixedRate(new TimerTask() {
                     @Override
                     public void run() {

src/java.desktop/share/classes/sun/java2d/marlin/Stroker.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2007, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -886,8 +886,8 @@ final class Stroker implements StartFlagPathConsumer2D, MarlinConst {
 
         // if p1 == p2 && p3 == p4: draw line from p1->p4, unless p1 == p4,
         // in which case ignore if p1 == p2
-        final boolean p1eqp2 = Helpers.withinD(dx1, dy1, 6.0d * Math.ulp(y2));
-        final boolean p3eqp4 = Helpers.withinD(dx4, dy4, 6.0d * Math.ulp(y4));
+        final boolean p1eqp2 = Helpers.withinD(dx1, dy1, 6.0d * Helpers.ulp(y2));
+        final boolean p3eqp4 = Helpers.withinD(dx4, dy4, 6.0d * Helpers.ulp(y4));
 
         if (p1eqp2 && p3eqp4) {
             return getLineOffsets(x1, y1, x4, y4, leftOff, rightOff);
@@ -905,7 +905,7 @@ final class Stroker implements StartFlagPathConsumer2D, MarlinConst {
         final double l1sq = dx1 * dx1 + dy1 * dy1;
         final double l4sq = dx4 * dx4 + dy4 * dy4;
 
-        if (Helpers.within(dotsq, l1sq * l4sq, 4.0d * Math.ulp(dotsq))) {
+        if (Helpers.within(dotsq, l1sq * l4sq, 4.0d * Helpers.ulp(dotsq))) {
             return getLineOffsets(x1, y1, x4, y4, leftOff, rightOff);
         }
 
@@ -1078,8 +1078,8 @@ final class Stroker implements StartFlagPathConsumer2D, MarlinConst {
         // equal if they're very close to each other.
 
         // if p1 == p2 or p2 == p3: draw line from p1->p3
-        final boolean p1eqp2 = Helpers.withinD(dx12, dy12, 6.0d * Math.ulp(y2));
-        final boolean p2eqp3 = Helpers.withinD(dx23, dy23, 6.0d * Math.ulp(y3));
+        final boolean p1eqp2 = Helpers.withinD(dx12, dy12, 6.0d * Helpers.ulp(y2));
+        final boolean p2eqp3 = Helpers.withinD(dx23, dy23, 6.0d * Helpers.ulp(y3));
 
         if (p1eqp2 || p2eqp3) {
             return getLineOffsets(x1, y1, x3, y3, leftOff, rightOff);
@@ -1091,7 +1091,7 @@ final class Stroker implements StartFlagPathConsumer2D, MarlinConst {
         final double l1sq = dx12 * dx12 + dy12 * dy12;
         final double l3sq = dx23 * dx23 + dy23 * dy23;
 
-        if (Helpers.within(dotsq, l1sq * l3sq, 4.0d * Math.ulp(dotsq))) {
+        if (Helpers.within(dotsq, l1sq * l3sq, 4.0d * Helpers.ulp(dotsq))) {
             return getLineOffsets(x1, y1, x3, y3, leftOff, rightOff);
         }
 

src/java.desktop/share/classes/sun/java2d/marlin/Version.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -27,7 +27,7 @@ package sun.java2d.marlin;
 
 public final class Version {
 
-    private static final String VERSION = "marlin-0.9.4.7-Unsafe-OpenJDK";
+    private static final String VERSION = "marlin-0.9.4.9-Unsafe-OpenJDK";
 
     public static String getVersion() {
         return VERSION;

src/java.desktop/share/classes/sun/java2d/marlin/stats/StatDouble.java

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright 2025 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.java2d.marlin.stats;
+
+import static sun.java2d.marlin.stats.StatLong.trimTo3Digits;
+
+/**
+ * Statistics on double values
+ */
+public final class StatDouble {
+    // rolling mean weight (lerp):
+    private final static double EMA_ALPHA = 0.25;
+    private final static double EMA_ONE_MINUS_ALPHA = 1.0 - EMA_ALPHA;
+
+    public final String name;
+    private long count, lastLogCount;
+    private double min, max, mean, ema_mean = 0.0, squaredError;
+
+    public StatDouble(final String name) {
+        this.name = name;
+        reset();
+    }
+
+    public void reset() {
+        count = 0L;
+        lastLogCount = 0L;
+        min = Double.POSITIVE_INFINITY;
+        max = Double.NEGATIVE_INFINITY;
+        mean = 0.0;
+        // skip ema_mean = 0.0;
+        squaredError = 0.0;
+    }
+
+    public void add(final double val) {
+        count++;
+        if (val < min) {
+            min = val;
+        }
+        if (val > max) {
+            max = val;
+        }
+        // Exponential smoothing (EMA):
+        ema_mean = EMA_ALPHA * val + EMA_ONE_MINUS_ALPHA * ema_mean;
+        // Welford's algorithm:
+        final double oldMean = mean;
+        mean += (val - mean) / count;
+        squaredError += (val - mean) * (val - oldMean);
+    }
+
+    public boolean shouldLog() {
+        return (count > lastLogCount);
+    }
+
+    public void updateLastLogCount() {
+        this.lastLogCount = this.count;
+    }
+
+    public long count() {
+        return count;
+    }
+
+    public double min() {
+        return (count != 0L) ? min : Double.NaN;
+    }
+
+    public double max() {
+        return (count != 0L) ? max : Double.NaN;
+    }
+
+    public double mean() {
+        return (count != 0L) ? mean : Double.NaN;
+    }
+
+    public double ema() {
+        return (count != 0L) ? ema_mean : Double.NaN;
+    }
+
+    public double variance() {
+        return (count != 0L) ? (squaredError / (count - 1L)) : Double.NaN;
+    }
+
+    public double stddev() {
+        return (count != 0L) ? Math.sqrt(variance()) : Double.NaN;
+    }
+
+    public double total() {
+        return (count != 0L) ? (mean() * count) : Double.NaN;
+    }
+
+    @Override
+    public String toString() {
+        return toString(new StringBuilder(128)).toString();
+    }
+
+    public StringBuilder toString(final StringBuilder sb) {
+        sb.append(name).append('[').append(count);
+        sb.append("] sum: ").append(trimTo3Digits(total()));
+        sb.append(" avg: ").append(trimTo3Digits(mean()));
+        sb.append(" stddev: ").append(trimTo3Digits(stddev()));
+        sb.append(" ema: ").append(trimTo3Digits(ema()));
+        sb.append(" [").append(trimTo3Digits(min())).append(" - ").append(trimTo3Digits(max())).append("]");
+        return sb;
+    }
+}

src/java.desktop/share/classes/sun/java2d/vulkan/VKEnv.java

@@ -31,7 +31,6 @@ import sun.util.logging.PlatformLogger;
 import java.awt.Toolkit;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 public final class VKEnv {
@@ -49,7 +48,7 @@ public final class VKEnv {
 
         @SuppressWarnings("removal")
         private static final boolean accelsd = vulkan && "true".equalsIgnoreCase(AccessController.doPrivileged(
-                (PrivilegedAction<String>) () -> System.getProperty("sun.java2d.vulkan.accelsd", "")));
+                (PrivilegedAction<String>) () -> System.getProperty("sun.java2d.vulkan.accelsd", "true")));
 
         @SuppressWarnings("removal")
         private static final int deviceNumber = !vulkan ? 0 : AccessController.doPrivileged(
@@ -109,16 +108,20 @@ public final class VKEnv {
         state = newState;
 
         if (Options.verbose || log.isLoggable(PlatformLogger.Level.FINE)) {
-            String message;
+            StringBuilder msg = new StringBuilder("Vulkan rendering enabled: ");
             if (isVulkanEnabled()) {
-                message = "Vulkan rendering enabled: YES" +
-                          "\n  presentation enabled: " + (isPresentationEnabled() ? "YES" : "NO") +
-                          "\n  accelerated surface data enabled: " + (isSurfaceDataAccelerated() ? "YES" : "NO") +
-                          "\n  devices:" + Stream.of(devices).map(d -> (d == defaultDevice ?
-                          "\n    *" : "\n     ") + d.getName()).collect(Collectors.joining());
+                msg.append("YES")
+                        .append("\n  Presentation enabled: ").append(isPresentationEnabled() ? "YES" : "NO")
+                        .append("\n  Accelerated surface data enabled: ").append(isSurfaceDataAccelerated() ? "YES" : "NO")
+                        .append("\n  Devices:");
+                for (int i = 0; i < devices.length; i++) {
+                    VKGPU d = devices[i];
+                    msg.append(d == defaultDevice ? "\n    *" : "\n     ").append(i).append(": ").append(d.getName());
+                }
             } else {
-                message = "Vulkan rendering enabled: NO";
+                msg.append("NO");
             }
+            String message = msg.toString();
             if (Options.verbose) {
                 System.err.println(message);
             }

src/java.desktop/share/classes/sun/java2d/vulkan/VKSurfaceData.java

@@ -36,6 +36,7 @@ import sun.java2d.loops.CompositeType;
 import sun.java2d.loops.GraphicsPrimitive;
 import sun.java2d.loops.SurfaceType;
 import static sun.java2d.pipe.BufferedOpCodes.CONFIGURE_SURFACE;
+import static sun.java2d.pipe.BufferedOpCodes.DISPOSE_SURFACE;
 import sun.java2d.pipe.BufferedContext;
 import sun.java2d.pipe.ParallelogramPipe;
 import sun.java2d.pipe.PixelToParallelogramConverter;
@@ -43,7 +44,6 @@ import sun.java2d.pipe.RenderBuffer;
 import sun.java2d.pipe.TextPipe;
 import sun.java2d.pipe.hw.AccelSurface;
 import java.awt.GraphicsConfiguration;
-import java.awt.GraphicsEnvironment;
 import java.awt.Rectangle;
 import java.awt.image.BufferedImage;
 import java.awt.image.Raster;
@@ -137,7 +137,29 @@ public abstract class VKSurfaceData extends SurfaceData
         }
     }
 
-    protected BufferedImage getSnapshot(int x, int y, int width, int height) {
+    /**
+     * Disposes the native resources associated with the given VKSurfaceData
+     * (referenced by the pData parameter).  This method is invoked from
+     * the native Dispose() method from the Disposer thread when the
+     * Java-level VKSurfaceData object is about to go away.
+     */
+    static void dispose(long pData) {
+        VKRenderQueue rq = VKRenderQueue.getInstance();
+        rq.lock();
+        try {
+            RenderBuffer buf = rq.getBuffer();
+            rq.ensureCapacityAndAlignment(12, 4);
+            buf.putInt(DISPOSE_SURFACE);
+            buf.putLong(pData);
+
+            // this call is expected to complete synchronously, so flush now
+            rq.flushNow();
+        } finally {
+            rq.unlock();
+        }
+    }
+
+    public BufferedImage getSnapshot(int x, int y, int width, int height) {
         BufferedImage image = getFormat().createCompatibleImage(width, height, getTransparency());
         SurfaceData sd = SurfaceData.getPrimarySurfaceData(image);
         Blit blit = Blit.getFromCache(getSurfaceType(), CompositeType.SrcNoEa, sd.getSurfaceType());

src/java.desktop/share/glsl/vulkan/alpha_type.glsl

@@ -1,20 +0,0 @@
-
-#define ALPHA_TYPE_PRE_MULTIPLIED 0U
-#define ALPHA_TYPE_STRAIGHT       1U
-
-vec4 convertAlpha(vec4 color, uint inType, uint outType) {
-    if (inType == ALPHA_TYPE_STRAIGHT && outType == ALPHA_TYPE_PRE_MULTIPLIED) {
-        return vec4(color.rgb * color.a, color.a);
-    } else if (inType == ALPHA_TYPE_PRE_MULTIPLIED && outType == ALPHA_TYPE_STRAIGHT && color.a > 0.0) {
-        return vec4(color.rgb / color.a, color.a);
-    } else return color;
-}
-
-#ifdef ALPHA_TYPE_SPEC_INDEX
-layout (constant_id = ALPHA_TYPE_SPEC_INDEX  ) const uint const_InAlphaType  = ALPHA_TYPE_PRE_MULTIPLIED;
-layout (constant_id = ALPHA_TYPE_SPEC_INDEX+1) const uint const_OutAlphaType = ALPHA_TYPE_PRE_MULTIPLIED;
-
-vec4 convertAlpha(vec4 color) {
-    return convertAlpha(color, const_InAlphaType, const_OutAlphaType);
-}
-#endif

src/java.desktop/share/glsl/vulkan/blit.frag

@@ -1,7 +1,7 @@
 #version 450
 #extension GL_GOOGLE_include_directive: require
-#define ALPHA_TYPE_SPEC_INDEX 0
-#include "alpha_type.glsl"
+#include "common.glsl"
+DEFAULT_PUSH_CONSTANTS();
 
 layout(set = 0, binding = 0) uniform texture2D u_Texture;
 layout(set = 1, binding = 0) uniform sampler u_Sampler;
@@ -9,5 +9,5 @@ layout(location = 0) in  vec2 in_TexCoord;
 layout(location = 0) out vec4 out_Color;
 
 void main() {
-    out_Color = convertAlpha(texture(sampler2D(u_Texture, u_Sampler), in_TexCoord));
+    out_Color = APPLY_COMPOSITE(convertAlpha(texture(sampler2D(u_Texture, u_Sampler), in_TexCoord)));
 }

src/java.desktop/share/glsl/vulkan/blit.vert

@@ -1,14 +1,12 @@
 #version 450
-
-layout(push_constant) uniform PushConstants {
-    mat2x3 transform;
-} push;
+#extension GL_GOOGLE_include_directive: require
+#include "common.glsl"
 
 layout(location = 0) in  vec2 in_Position;
 layout(location = 1) in  vec2 in_TexCoord;
 layout(location = 0) out vec2 out_TexCoord;
 
 void main() {
-    gl_Position = vec4(vec3(in_Position, 1.0)*push.transform, 0.0, 1.0);
+    gl_Position = transformToDeviceSpace(in_Position);
     out_TexCoord = in_TexCoord;
 }

src/java.desktop/share/glsl/vulkan/clip.vert

@@ -1,11 +1,9 @@
 #version 450
-
-layout(push_constant) uniform PushConstants {
-    mat2x3 transform;
-} push;
+#extension GL_GOOGLE_include_directive: require
+#include "common.glsl"
 
 layout(location = 0) in ivec2 in_Position;
 
 void main() {
-    gl_Position = vec4(vec3(in_Position, 1)*push.transform, 0.0, 1.0);
+    gl_Position = transformToDeviceSpace(in_Position);
 }

src/java.desktop/share/glsl/vulkan/color.vert

@@ -1,14 +1,12 @@
 #version 450
-
-layout(push_constant) uniform PushConstants {
-    mat2x3 transform;
-} push;
+#extension GL_GOOGLE_include_directive: require
+#include "common.glsl"
 
 layout(location = 0) in vec2 in_Position;
-layout(location = 1) in vec4 in_Color;
+layout(location = 1) in uint in_Color;
 layout(location = 0) out flat vec4 out_Color;
 
 void main() {
-    gl_Position = vec4(vec3(in_Position, 1)*push.transform, 0.0, 1.0);
-    out_Color = in_Color;
+    gl_Position = transformToDeviceSpace(in_Position);
+    out_Color = convertAlpha(decodeColor(in_Color)); // No need to APPLY_COMPOSITE - it was already done on the host.
 }

src/java.desktop/share/glsl/vulkan/common.glsl

@@ -0,0 +1,103 @@
+
+// Shader specialization.
+#define SHADER_MOD_XOR  1U // Xor composite mode
+#define SHADER_MOD_MASK 2U // MASK_FILL / MASK_BLIT
+
+layout (constant_id = 0) const uint const_InAlphaType    = 0;
+layout (constant_id = 1) const uint const_OutAlphaType   = 0;
+layout (constant_id = 2) const uint const_ShaderVariant  = 0;
+layout (constant_id = 3) const uint const_ShaderModifier = 0;
+
+// Host structs.
+struct VKTransform {
+    float m00, m01, m02;
+    float m10, m11, m12;
+};
+struct VKCompositeConstants {
+    uint xorColor;
+    float extraAlpha;
+};
+
+// Vertex shader transformation support.
+#ifdef STAGE_VERT
+layout(push_constant) uniform PushConstants { VKTransform transform; } push;
+
+vec4 transformToDeviceSpace(vec2 v) {
+    return vec4(vec3(v, 1.0) * mat2x3(push.transform.m00, push.transform.m01, push.transform.m02, push.transform.m10, push.transform.m11, push.transform.m12), 0.0, 1.0);
+}
+#endif
+
+// Fragment shader push constant support.
+#ifdef STAGE_FRAG
+#define PUSH_CONSTANTS_IMPL(STATEMENT) \
+    layout(push_constant) uniform PushConstants { VKTransform _; VKCompositeConstants push_composite; STATEMENT }
+#define DEFAULT_PUSH_CONSTANTS() PUSH_CONSTANTS_IMPL(STAGE_FRAG)
+#define PUSH_CONSTANTS(TYPE) PUSH_CONSTANTS_IMPL(TYPE push;)
+#endif
+
+// Color conversion support.
+#define ALPHA_TYPE_PRE_MULTIPLIED 0U
+#define ALPHA_TYPE_STRAIGHT       1U
+
+vec4 convertAlpha(vec4 color, uint inType, uint outType) {
+    if (inType == ALPHA_TYPE_STRAIGHT && outType == ALPHA_TYPE_PRE_MULTIPLIED) {
+        return vec4(color.rgb * color.a, color.a);
+    } else if (inType == ALPHA_TYPE_PRE_MULTIPLIED && outType == ALPHA_TYPE_STRAIGHT && color.a > 0.0) {
+        return vec4(color.rgb / color.a, color.a);
+    } else return color;
+}
+
+vec4 convertAlpha(vec4 color) {
+    return convertAlpha(color, const_InAlphaType, const_OutAlphaType);
+}
+
+// When applying alpha to a color, straight alpha only multiplies alpha,
+// and pre-multiplied multiplies the whole color. Use this for convenience.
+vec4 alphaMask(float alpha, uint alphaType) {
+    return alphaType == ALPHA_TYPE_PRE_MULTIPLIED ? vec4(alpha) : vec4(1.0, 1.0, 1.0, alpha);
+}
+
+// Decode color from uint-packed ARGB components.
+vec4 decodeColor(uint srgb) {
+    return vec4((uvec4(srgb) >> uvec4(16, 8, 0, 24)) & 0xFFU) / 255.0;
+}
+
+#ifdef STAGE_FRAG
+// Before outputting the color, some post-processing is needed:
+// - For alpha composite, apply extra alpha.
+// - For XOR composite, apply xor.
+vec4 applyComposite(vec4 color, VKCompositeConstants composite) {
+    if ((const_ShaderModifier & SHADER_MOD_XOR) != 0) {
+        uvec4 xor = uvec4(composite.xorColor) >> uvec4(16, 8, 0, 24);
+        xor = (uvec4(color * 255.0) ^ xor) & 0xFFU;
+        return vec4(xor) / 255.0;
+    } else return color * alphaMask(composite.extraAlpha, const_OutAlphaType);
+}
+#define APPLY_COMPOSITE(COLOR) applyComposite(COLOR, push_composite)
+
+// MASK_FILL / MASK_BLIT support.
+int calculateMaskIndex(vec2 localCoord, ivec4 originOffsetAndScanline) {
+    ivec2 maskPos = ivec2(localCoord - vec2(originOffsetAndScanline.xy));
+    int offset = originOffsetAndScanline.z;
+    int scanline = originOffsetAndScanline.w;
+    return offset + scanline * maskPos.y + min(scanline, maskPos.x);
+}
+vec4 applyMaskOp(vec4 color, float mask) {
+    if ((const_ShaderModifier & SHADER_MOD_XOR) != 0) return color * float(mask > 0.0);
+    else return color * alphaMask(mask, const_OutAlphaType);
+}
+#define APPLY_MASK(COLOR) applyMaskOp(COLOR, imageLoad(u_Mask, calculateMaskIndex(gl_FragCoord.xy, in_OriginOffsetAndScanline)).r)
+
+// Generic shader support.
+#define GENERIC_INOUT()                                            \
+    layout(location = 0) out      vec4 out_Color;                  \
+    layout(location = 0) in       vec2 in_Position;                \
+    layout(location = 1) in flat  uint in_Data;                    \
+    layout(location = 2) in flat ivec4 in_OriginOffsetAndScanline; \
+    layout(origin_upper_left) in  vec4 gl_FragCoord;               \
+    layout(set = 0, binding = 0, r8) uniform readonly restrict imageBuffer u_Mask
+
+// Generic color output - handles composite and mask automatically.
+#define OUTPUT(COLOR) out_Color = COLOR; out_Color = APPLY_COMPOSITE(out_Color); \
+    if ((const_ShaderModifier & SHADER_MOD_MASK) != 0) out_Color = APPLY_MASK(out_Color)
+#endif

src/java.desktop/share/glsl/vulkan/gradient.frag

@@ -0,0 +1,21 @@
+#version 450
+#extension GL_GOOGLE_include_directive: require
+#include "common.glsl"
+
+#define SHADER_VARIANT_GRADIENT_CLAMP 0
+#define SHADER_VARIANT_GRADIENT_CYCLE 1
+
+struct VKGradientPaintConstants {
+    vec4 c0, c1;
+    vec3 p;
+};
+PUSH_CONSTANTS(VKGradientPaintConstants);
+GENERIC_INOUT();
+
+void main() {
+    float t = dot(vec3(in_Position, 1.0), push.p);
+    t = const_ShaderVariant == SHADER_VARIANT_GRADIENT_CYCLE ?
+        abs(mod(t + 1.0, 2.0) - 1.0) : // Cycle
+        clamp(t, 0.0, 1.0);            // Clamp
+    OUTPUT(convertAlpha(mix(push.c0, push.c1, t)));
+}

src/java.desktop/share/glsl/vulkan/mask_fill.vert

@@ -0,0 +1,21 @@
+#version 450
+#extension GL_GOOGLE_include_directive: require
+#include "common.glsl"
+
+layout(location = 0) in ivec4 in_PositionOffsetAndScanline;
+layout(location = 1) in  uint in_Data;
+
+layout(location = 0) out vec2 out_Position;
+layout(location = 1) out uint out_Data;
+
+// This starts with "Origin" and not "Position" intentionally.
+// When drawing, vertices are ordered in a such way, that provoking vertex is always the top-left one.
+// This gives us an easy way to calculate offset within the rectangle without additional inputs.
+layout(location = 2) out flat ivec4 out_OriginOffsetAndScanline;
+
+void main() {
+    out_Position = in_PositionOffsetAndScanline.xy;
+    out_Data = in_Data;
+    out_OriginOffsetAndScanline = in_PositionOffsetAndScanline;
+    gl_Position = transformToDeviceSpace(in_PositionOffsetAndScanline.xy);
+}

src/java.desktop/share/glsl/vulkan/mask_fill_color.frag

@@ -1,4 +1,6 @@
 #version 450
+#extension GL_GOOGLE_include_directive: require
+#include "common.glsl"
 
 layout(set = 0, binding = 0, r8) uniform readonly restrict imageBuffer u_Mask;
 
@@ -10,9 +12,5 @@ layout(location = 1) in flat  vec4 in_Color;
 layout(location = 0) out vec4 out_Color;
 
 void main() {
-    ivec2 maskPos = ivec2(gl_FragCoord.xy - vec2(in_OriginOffsetAndScanline.xy));
-    int offset = in_OriginOffsetAndScanline.z;
-    int scanline = in_OriginOffsetAndScanline.w;
-    int maskIndex = offset + scanline * maskPos.y + min(scanline, maskPos.x);
-    out_Color = in_Color * imageLoad(u_Mask, maskIndex).r;
+    out_Color = APPLY_MASK(in_Color);
 }

src/java.desktop/share/glsl/vulkan/mask_fill_color.vert

@@ -1,11 +1,9 @@
 #version 450
-
-layout(push_constant) uniform PushConstants {
-    mat2x3 transform;
-} push;
+#extension GL_GOOGLE_include_directive: require
+#include "common.glsl"
 
 layout(location = 0) in ivec4 in_PositionOffsetAndScanline;
-layout(location = 1) in  vec4 in_Color;
+layout(location = 1) in  uint in_Color;
 
 // This starts with "Origin" and not "Position" intentionally.
 // When drawing, vertices are ordered in a such way, that provoking vertex is always the top-left one.
@@ -14,7 +12,7 @@ layout(location = 0) out flat ivec4 out_OriginOffsetAndScanline;
 layout(location = 1) out flat  vec4 out_Color;
 
 void main() {
-    gl_Position = vec4(vec3(in_PositionOffsetAndScanline.xy, 1)*push.transform, 0.0, 1.0);
+    gl_Position = transformToDeviceSpace(in_PositionOffsetAndScanline.xy);
     out_OriginOffsetAndScanline = in_PositionOffsetAndScanline;
-    out_Color = in_Color;
+    out_Color = convertAlpha(decodeColor(in_Color));
 }

src/java.desktop/share/glsl/vulkan/primitive.vert

@@ -0,0 +1,15 @@
+#version 450
+#extension GL_GOOGLE_include_directive: require
+#include "common.glsl"
+
+layout(location = 0) in  vec2 in_Position;
+layout(location = 1) in  uint in_Data;
+layout(location = 0) out vec2 out_Position;
+layout(location = 1) out uint out_Data;
+layout(location = 2) out flat ivec4 _; // Unused output
+
+void main() {
+    out_Position = in_Position;
+    out_Data = in_Data;
+    gl_Position = transformToDeviceSpace(in_Position);
+}

src/java.desktop/share/native/common/java2d/AccelTexturePool.c

@@ -63,7 +63,7 @@
 #define TRACE_USE_API               0
 #define TRACE_REUSE                 0
 
-#define INIT_TEST                   1
+#define INIT_TEST                   0
 #define INIT_TEST_STEP              1
 #define INIT_TEST_MAX               1024
 

src/java.desktop/share/native/common/java2d/vulkan/VKBlitLoops.c

@@ -113,7 +113,7 @@ void VKBlitLoops_IsoBlit(VKSDOps* srcOps, jint filter,
                                                                   VK_COMPONENT_SWIZZLE_ONE);
     VKPackedSwizzle swizzle = srcOpaque ? OPAQUE_SWIZZLE : 0;
 
-    if (!VKRenderer_Validate(SHADER_BLIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, alphaType)) return;
+    if (!VKRenderer_Validate(SHADER_BLIT, NO_SHADER_VARIANT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, alphaType)) return;
     VKRenderer_DrawImage(srcOps->image, srcOps->image->format, swizzle, filter, SAMPLER_WRAP_BORDER,
                          (float)sx1, (float)sy1, (float)sx2, (float)sy2, (float)dx1, (float)dy1, (float)dx2, (float)dy2);
     VKRenderer_AddSurfaceDependency(srcOps, context->surface);
@@ -154,7 +154,7 @@ void VKBlitLoops_Blit(JNIEnv *env, SurfaceDataOps* src, jshort srctype, jint fil
     }
     if (srcInfo.bounds.x2 > srcInfo.bounds.x1 && srcInfo.bounds.y2 > srcInfo.bounds.y1) {
         src->GetRasInfo(env, src, &srcInfo);
-        if (srcInfo.rasBase) {
+        while (srcInfo.rasBase) {
             if (srcInfo.bounds.x1 != sx1) dx1 += (srcInfo.bounds.x1 - sx1) * (dx2 - dx1) / (sx2 - sx1);
             if (srcInfo.bounds.y1 != sy1) dy1 += (srcInfo.bounds.y1 - sy1) * (dy2 - dy1) / (sy2 - sy1);
             if (srcInfo.bounds.x2 != sx2) dx2 += (srcInfo.bounds.x2 - sx2) * (dx2 - dx1) / (sx2 - sx1);
@@ -165,12 +165,17 @@ void VKBlitLoops_Blit(JNIEnv *env, SurfaceDataOps* src, jshort srctype, jint fil
 
             // Need to validate render pass early, as image may not yet be configured.
             AlphaType alphaType = getSrcAlphaType(srctype);
-            if (!VKRenderer_Validate(SHADER_BLIT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, alphaType)) return;
+            if (!VKRenderer_Validate(SHADER_BLIT, NO_SHADER_VARIANT, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, alphaType)) break;
 
             VKDevice* device = context->surface->device;
             BlitSrcType type = decodeSrcType(device, srctype);
-            VKTexturePoolHandle* imageHandle = VKTexturePool_GetTexture(device->texturePool, sw, sh, type.format);
+            VKTexturePoolHandle* imageHandle =
+                    VKTexturePool_GetTexture(VKRenderer_GetTexturePool(device->renderer), sw, sh, type.format);
             VKImage* image = VKTexturePoolHandle_GetTexture(imageHandle);
+            if (!image) {
+                J2dRlsTraceLn(J2D_TRACE_ERROR, "VKBlitLoops_Blit: could not get texture from the pool");
+                break;
+            }
 
             VkDeviceSize dataSize = sh * sw * srcInfo.pixelStride;
             VKBuffer buffer;
@@ -231,7 +236,9 @@ void VKBlitLoops_Blit(JNIEnv *env, SurfaceDataOps* src, jshort srctype, jint fil
             VKRenderer_ExecOnCleanup(context->surface, VKBlitLoops_DisposeTexture, imageHandle);
             VKRenderer_ExecOnCleanup(context->surface, VKBlitLoops_DisposeBuffer, buffer.handle);
             VKRenderer_ExecOnCleanup(context->surface, VKBlitLoops_DisposeMemory, page);
-        } else {
+            break;
+        }
+        if (!srcInfo.rasBase) {
             J2dRlsTraceLn(J2D_TRACE_ERROR, "VKBlitLoops_Blit: could not get raster info");
         }
         SurfaceData_InvokeRelease(env, src, &srcInfo);

src/java.desktop/share/native/common/java2d/vulkan/VKComposites.c

@@ -56,7 +56,7 @@ VKComposites VKComposites_Create() {
             .colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
                               VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT },
         {   .logicOpEnable = VK_TRUE,
-            .logicOp = VK_LOGIC_OP_XOR }, ALPHA_TYPE_PRE_MULTIPLIED });
+            .logicOp = VK_LOGIC_OP_XOR }, ALPHA_TYPE_STRAIGHT });
 
     //                NAME |      SRC_COLOR       |       DST_COLOR      |      SRC_ALPHA       |       DST_ALPHA     ||
     ALPHA_BLEND(     CLEAR , ZERO                 , ZERO                 , ZERO                 , ZERO                );
@@ -138,7 +138,6 @@ void VKComposites_AddState(VKComposites* composites, VKCompositeMode mode, VKCom
     state.blendState.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
     state.blendState.pNext = NULL;
     state.blendState.attachmentCount = 1;
-    state.outAlphaType = ALPHA_TYPE_PRE_MULTIPLIED;
     MAP_AT(composites->map, (VKCompositeDescriptor) { mode, VK_FALSE }) = state;
 
     // Using pre-multiplied alpha is necessary for correct blending,

src/java.desktop/share/native/common/java2d/vulkan/VKDevice.c

@@ -272,7 +272,6 @@ void VKDevice_CheckAndAdd(VKEnv* vk, VkPhysicalDevice physicalDevice) {
 void VKDevice_Reset(VKDevice* device) {
     if (device == NULL) return;
     VKRenderer_Destroy(device->renderer);
-    VKTexturePool_Dispose(device->texturePool);
     VKAllocator_Destroy(device->allocator);
     ARRAY_FREE(device->enabledExtensions);
     ARRAY_FREE(device->enabledLayers);
@@ -392,11 +391,4 @@ Java_sun_java2d_vulkan_VKGPU_init(JNIEnv *env, jclass jClass, jlong jDevice) {
         JNU_ThrowByName(env, "java/lang/RuntimeException", "Vulkan: Cannot create renderer");
         return;
     }
-
-    device->texturePool = VKTexturePool_InitWithDevice(device);
-    if (!device->texturePool) {
-        VKDevice_Reset(device);
-        JNU_ThrowByName(env, "java/lang/RuntimeException", "Vulkan: Cannot create texture pool");
-        return;
-    }
 }

src/java.desktop/share/native/common/java2d/vulkan/VKDevice.h

@@ -59,7 +59,6 @@ struct VKDevice {
 
     VKAllocator*     allocator;
     VKRenderer*      renderer;
-    VKTexturePool*   texturePool;
 
     DEVICE_FUNCTION_TABLE(DECL_PFN)
     SWAPCHAIN_DEVICE_FUNCTION_TABLE(DECL_PFN)

src/java.desktop/share/native/common/java2d/vulkan/VKPipelines.c

@@ -49,6 +49,7 @@ static size_t pipelineDescriptorHash(const void* ptr) {
     hash(&h, d->inAlphaType);
     hash(&h, d->composite);
     hash(&h, d->shader);
+    hash(&h, d->shaderVariant);
     hash(&h, d->topology);
     return (size_t) h;
 }
@@ -59,6 +60,7 @@ static bool pipelineDescriptorEquals(const void* ap, const void* bp) {
            a->inAlphaType == b->inAlphaType &&
              a->composite == b->composite &&
                 a->shader == b->shader &&
+         a->shaderVariant == b->shaderVariant &&
               a->topology == b->topology;
 }
 
@@ -144,12 +146,20 @@ static VKPipelineInfo VKPipelines_CreatePipelines(VKRenderPassContext* renderPas
         VkPipelineShaderStageCreateInfo createInfos[2]; // vert + frag
     } ShaderStages;
     ShaderStages stages[count];
+    typedef struct {
+        uint32_t inAlphaType, outAlphaType, shaderVariant, shaderModifier;
+    } SpecializationData;
+    const VkSpecializationMapEntry SPECIALIZATION_ENTRIES[] = {
+        { 0,  0, 4 },
+        { 1,  4, 4 },
+        { 2,  8, 4 },
+        { 3, 12, 4 }
+    };
     typedef struct {
         VkSpecializationInfo info;
-        VkSpecializationMapEntry entries[2];
-        uint64_t data[1];
+        SpecializationData data;
     } Specialization;
-    Specialization specializations[count][2];
+    Specialization specializations[count];
     VkPipelineInputAssemblyStateCreateInfo inputAssemblyStates[count];
     VkPipelineDepthStencilStateCreateInfo depthStencilStates[count];
     VkPipelineDynamicStateCreateInfo dynamicStates[count];
@@ -163,14 +173,19 @@ static VKPipelineInfo VKPipelines_CreatePipelines(VKRenderPassContext* renderPas
         // - pStages (but stageCount is set to 2)
         // - pVertexInputState
         // - createInfo.layout
-        for (uint32_t j = 0; j < SARRAY_COUNT_OF(specializations[i]); j++) {
-            specializations[i][j].info = (VkSpecializationInfo) {
-                .mapEntryCount = 0,
-                .pMapEntries = specializations[i][j].entries,
-                .dataSize = 0,
-                .pData = specializations[i][j].data
-            };
-        }
+        specializations[i] = (Specialization) {
+            .info = {
+                .mapEntryCount = SARRAY_COUNT_OF(SPECIALIZATION_ENTRIES),
+                .pMapEntries = SPECIALIZATION_ENTRIES,
+                .dataSize = sizeof(SpecializationData),
+                .pData = &specializations[i].data
+            },
+            .data = {
+                descriptors[i].inAlphaType, pipelineInfos[i].outAlphaType, (uint32_t) descriptors[i].shaderVariant,
+                (descriptors[i].composite == LOGIC_COMPOSITE_XOR ? 1 : 0) |
+                (descriptors[i].shader & SHADER_MASK ? 2 : 0)
+            }
+        };
         inputAssemblyStates[i] = (VkPipelineInputAssemblyStateCreateInfo) {
             .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
             .topology = descriptors[i].topology
@@ -234,37 +249,38 @@ static VKPipelineInfo VKPipelines_CreatePipelines(VKRenderPassContext* renderPas
     }
 
     // Setup input states.
-    MAKE_INPUT_STATE(COLOR, VKColorVertex, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R32G32B32A32_SFLOAT);
-    MAKE_INPUT_STATE(MASK_FILL_COLOR, VKMaskFillColorVertex, VK_FORMAT_R32G32B32A32_SINT, VK_FORMAT_R32G32B32A32_SFLOAT);
+    MAKE_INPUT_STATE(PRIMITIVE, VKVertex, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R32_UINT);
+    MAKE_INPUT_STATE(MASK_FILL, VKMaskFillVertex, VK_FORMAT_R32G32B32A32_SINT, VK_FORMAT_R32_UINT);
     MAKE_INPUT_STATE(BLIT, VKTxVertex, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R32G32_SFLOAT);
     MAKE_INPUT_STATE(CLIP, VKIntVertex, VK_FORMAT_R32G32_SINT);
 
     for (uint32_t i = 0; i < count; i++) {
         // Setup shader-specific pipeline parameters.
-        switch (descriptors[i].shader) {
+        switch ((int) descriptors[i].shader) {
         case SHADER_COLOR:
-            createInfos[i].pVertexInputState = &INPUT_STATE_COLOR;
-            createInfos[i].layout = pipelineContext->colorPipelineLayout;
+            createInfos[i].pVertexInputState = &INPUT_STATE_PRIMITIVE;
+            createInfos[i].layout = pipelineContext->commonPipelineLayout;
             stages[i] = (ShaderStages) {{ shaders->color_vert, shaders->color_frag }};
             break;
-        case SHADER_MASK_FILL_COLOR:
-            createInfos[i].pVertexInputState = &INPUT_STATE_MASK_FILL_COLOR;
+        case SHADER_COLOR | SHADER_MASK:
+            createInfos[i].pVertexInputState = &INPUT_STATE_MASK_FILL;
             createInfos[i].layout = pipelineContext->maskFillPipelineLayout;
             stages[i] = (ShaderStages) {{ shaders->mask_fill_color_vert, shaders->mask_fill_color_frag }};
             break;
+        case SHADER_GRADIENT:
+            createInfos[i].pVertexInputState = &INPUT_STATE_PRIMITIVE;
+            createInfos[i].layout = pipelineContext->maskFillPipelineLayout;
+            stages[i] = (ShaderStages) {{ shaders->primitive_vert, shaders->gradient_frag }};
+            break;
+        case SHADER_GRADIENT | SHADER_MASK:
+            createInfos[i].pVertexInputState = &INPUT_STATE_MASK_FILL;
+            createInfos[i].layout = pipelineContext->maskFillPipelineLayout;
+            stages[i] = (ShaderStages) {{ shaders->mask_fill_vert, shaders->gradient_frag }};
+            break;
         case SHADER_BLIT:
             createInfos[i].pVertexInputState = &INPUT_STATE_BLIT;
             createInfos[i].layout = pipelineContext->texturePipelineLayout;
             stages[i] = (ShaderStages) {{ shaders->blit_vert, shaders->blit_frag }};
-            // Alpha conversion specialization.
-            uint32_t* spec = (uint32_t*) specializations[i][1].data;
-            spec[0] = descriptors[i].inAlphaType;
-            spec[1] = pipelineInfos[i].outAlphaType;
-            specializations[i][1].info.dataSize = 8;
-            specializations[i][1].entries[0] = (VkSpecializationMapEntry) { 0, 0, 4 };
-            specializations[i][1].entries[1] = (VkSpecializationMapEntry) { 1, 4, 4 };
-            specializations[i][1].info.mapEntryCount = 2;
-            stages[i].createInfos[1].pSpecializationInfo = &specializations[i][1].info;
             break;
         case SHADER_CLIP:
             createInfos[i].pVertexInputState = &INPUT_STATE_CLIP;
@@ -290,6 +306,9 @@ static VKPipelineInfo VKPipelines_CreatePipelines(VKRenderPassContext* renderPas
         default:
             VK_FATAL_ERROR("Cannot create pipeline, unknown shader requested!");
         }
+        for (uint32_t j = 0; j < createInfos[i].stageCount; j++) {
+            stages[i].createInfos[j].pSpecializationInfo = &specializations[i].info;
+        }
         assert(createInfos[i].pDynamicState->dynamicStateCount <= MAX_DYNAMIC_STATES);
         J2dRlsTraceLn(J2D_TRACE_INFO, "VKPipelines_CreatePipelines: stencilMode=%d, dstOpaque=%d, composite=%d, shader=%d, topology=%d",
                 descriptors[i].stencilMode, descriptors[i].dstOpaque, descriptors[i].composite, descriptors[i].shader, descriptors[i].topology);
@@ -303,6 +322,7 @@ static VKPipelineInfo VKPipelines_CreatePipelines(VKRenderPassContext* renderPas
     J2dRlsTraceLn(J2D_TRACE_INFO, "VKPipelines_CreatePipelines: created %d pipelines", count);
     for (uint32_t i = 0; i < count; i++) {
         pipelineInfos[i].pipeline = pipelines[i];
+        pipelineInfos[i].layout = createInfos[i].layout;
         MAP_AT(renderPassContext->pipelines, descriptors[i]) = pipelineInfos[i];
     }
     return pipelineInfos[0];
@@ -403,21 +423,49 @@ static VkResult VKPipelines_InitPipelineLayouts(VKDevice* device, VKPipelineCont
     assert(device != NULL && pipelines != NULL);
     VkResult result;
 
-    // We want all our pipelines to have same push constant range to ensure common state is compatible between pipelines.
-    VkPushConstantRange pushConstantRange = {
+    // We want all our pipelines to have the same push constant ranges to ensure a common state is compatible between pipelines.
+    VkPushConstantRange pushConstantRanges[] = {{
             .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
             .offset = 0,
             .size = sizeof(VKTransform)
-    };
+    }, {
+            .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
+            .offset = PUSH_CONSTANTS_OFFSET,
+            .size = PUSH_CONSTANTS_SIZE
+    }};
+
+    // Common pipeline.
     VkPipelineLayoutCreateInfo createInfo = {
             .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
             .setLayoutCount = 0,
-            .pushConstantRangeCount = 1,
-            .pPushConstantRanges = &pushConstantRange
+            .pushConstantRangeCount = SARRAY_COUNT_OF(pushConstantRanges),
+            .pPushConstantRanges = pushConstantRanges
     };
-    result = device->vkCreatePipelineLayout(device->handle, &createInfo, NULL, &pipelines->colorPipelineLayout);
+    result = device->vkCreatePipelineLayout(device->handle, &createInfo, NULL, &pipelines->commonPipelineLayout);
     VK_IF_ERROR(result) return result;
 
+    // Mask fill pipeline.
+    VkDescriptorSetLayoutBinding maskBufferLayoutBinding = {
+            .binding = 0,
+            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
+            .descriptorCount = 1,
+            .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
+            .pImmutableSamplers = NULL
+    };
+    VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo = {
+            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
+            .bindingCount = 1,
+            .pBindings = &maskBufferLayoutBinding
+    };
+    result = device->vkCreateDescriptorSetLayout(device->handle, &descriptorSetLayoutCreateInfo, NULL, &pipelines->maskFillDescriptorSetLayout);
+    VK_IF_ERROR(result) return result;
+
+    createInfo.setLayoutCount = 1;
+    createInfo.pSetLayouts = &pipelines->maskFillDescriptorSetLayout;
+    result = device->vkCreatePipelineLayout(device->handle, &createInfo, NULL, &pipelines->maskFillPipelineLayout);
+    VK_IF_ERROR(result) return result;
+
+    // Texture pipeline.
     VkDescriptorSetLayoutBinding textureLayoutBinding = {
             .binding = 0,
             .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
@@ -437,31 +485,11 @@ static VkResult VKPipelines_InitPipelineLayouts(VKDevice* device, VKPipelineCont
         pipelines->textureDescriptorSetLayout,
         pipelines->samplers.descriptorSetLayout
     };
-    createInfo.setLayoutCount = 2;
+    createInfo.setLayoutCount = SARRAY_COUNT_OF(textureDescriptorSetLayouts);
     createInfo.pSetLayouts = textureDescriptorSetLayouts;
     result = device->vkCreatePipelineLayout(device->handle, &createInfo, NULL, &pipelines->texturePipelineLayout);
     VK_IF_ERROR(result) return result;
 
-    VkDescriptorSetLayoutBinding maskBufferLayoutBinding = {
-            .binding = 0,
-            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
-            .descriptorCount = 1,
-            .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
-            .pImmutableSamplers = NULL
-    };
-    VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo = {
-            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
-            .bindingCount = 1,
-            .pBindings = &maskBufferLayoutBinding
-    };
-    result = device->vkCreateDescriptorSetLayout(device->handle, &descriptorSetLayoutCreateInfo, NULL, &pipelines->maskFillDescriptorSetLayout);
-    VK_IF_ERROR(result) return result;
-
-    createInfo.setLayoutCount = 1;
-    createInfo.pSetLayouts = &pipelines->maskFillDescriptorSetLayout;
-    result = device->vkCreatePipelineLayout(device->handle, &createInfo, NULL, &pipelines->maskFillPipelineLayout);
-    VK_IF_ERROR(result) return result;
-
     return VK_SUCCESS;
 }
 
@@ -504,7 +532,7 @@ void VKPipelines_DestroyContext(VKPipelineContext* pipelineContext) {
 
     VKPipelines_DestroyShaders(device, pipelineContext->shaders);
 
-    device->vkDestroyPipelineLayout(device->handle, pipelineContext->colorPipelineLayout, NULL);
+    device->vkDestroyPipelineLayout(device->handle, pipelineContext->commonPipelineLayout, NULL);
     device->vkDestroyPipelineLayout(device->handle, pipelineContext->texturePipelineLayout, NULL);
     device->vkDestroyDescriptorSetLayout(device->handle, pipelineContext->textureDescriptorSetLayout, NULL);
     device->vkDestroyPipelineLayout(device->handle, pipelineContext->maskFillPipelineLayout, NULL);

src/java.desktop/share/native/common/java2d/vulkan/VKPipelines.h

@@ -36,13 +36,26 @@
  * Shader programs.
  */
 typedef enum {
+    // Base shaders.
     SHADER_COLOR,
-    SHADER_MASK_FILL_COLOR,
+    SHADER_GRADIENT,
     SHADER_BLIT,
     SHADER_CLIP,
-    NO_SHADER = 0x7FFFFFFF
+    NO_SHADER = 0x7FFFFFFF,
+    // Mask modifier bit (MASK_FILL & MASK_BLIT).
+    SHADER_MASK = ~NO_SHADER
 } VKShader;
 
+/**
+ * Shader variant.
+ * It is used to specialize shader behavior, and its meaning varies with each particular shader.
+ */
+typedef enum {
+    SHADER_VARIANT_GRADIENT_CLAMP = 0,
+    SHADER_VARIANT_GRADIENT_CYCLE = 1,
+    NO_SHADER_VARIANT = 0x7FFFFFFF
+} VKShaderVariant;
+
 typedef enum {
     STENCIL_MODE_NONE = 0, // No stencil attachment.
     STENCIL_MODE_OFF  = 1, // Has stencil attachment, stencil test disabled.
@@ -59,12 +72,14 @@ typedef struct {
     AlphaType           inAlphaType : 1;
     VKCompositeMode     composite;
     VKShader            shader;
+    VKShaderVariant     shaderVariant;
     VkPrimitiveTopology topology;
 } VKPipelineDescriptor;
 
 typedef struct {
-    VkPipeline pipeline;
-    AlphaType  outAlphaType;
+    VkPipeline       pipeline;
+    VkPipelineLayout layout;
+    AlphaType        outAlphaType;
 } VKPipelineInfo;
 
 /**
@@ -72,7 +87,7 @@ typedef struct {
  */
 struct VKPipelineContext {
     VKDevice*                   device;
-    VkPipelineLayout            colorPipelineLayout;
+    VkPipelineLayout            commonPipelineLayout;
     VkDescriptorSetLayout       textureDescriptorSetLayout;
     VkPipelineLayout            texturePipelineLayout;
     VkDescriptorSetLayout       maskFillDescriptorSetLayout;
@@ -93,14 +108,42 @@ struct VKRenderPassContext {
     MAP(VKPipelineDescriptor, VKPipelineInfo) pipelines;
 };
 
+typedef struct {
+    unsigned int xorColor;
+    float extraAlpha;
+} VKCompositeConstants;
+
+typedef struct {
+    RGBA c0, c1;
+    float p0, p1, p3;
+} VKGradientPaintConstants;
+
+typedef union {
+    // The minimum guaranteed size of push constants is 128 bytes.
+    alignas(32) // The maximum alignment for built-in glsl types is 32 bytes (dvec4).
+    char data[(128 - sizeof(VKTransform) - sizeof(VKCompositeConstants)) / 32 * 32];
+    VKGradientPaintConstants gradientPaint;
+} VKShaderConstants;
+#define MAX_SHADER_CONSTANTS_SIZE 96 // We expect 96 bytes
+typedef char VKShaderConstantsCheckOffset[sizeof(VKShaderConstants) == MAX_SHADER_CONSTANTS_SIZE ? 1 : -1]; // Verify.
+
+typedef struct {
+    VKTransform transform;
+    VKCompositeConstants composite;
+    VKShaderConstants shader;
+} VKPushConstants;
+typedef char VKPushConstantsCheckSize[sizeof(VKPushConstants) <= 128 ? 1 : -1]; // We should not exceed 128 bytes.
+static const uint32_t PUSH_CONSTANTS_OFFSET = (uintptr_t) &((VKPushConstants*) NULL)->composite;
+static const uint32_t PUSH_CONSTANTS_SIZE = sizeof(VKPushConstants) - PUSH_CONSTANTS_OFFSET;
+
 typedef struct {
     int x, y;
 } VKIntVertex;
 
 typedef struct {
     float x, y;
-    RGBA color;
-} VKColorVertex;
+    unsigned int data;
+} VKVertex;
 
 typedef struct {
     float px, py;
@@ -109,8 +152,8 @@ typedef struct {
 
 typedef struct {
     int x, y, maskOffset, maskScanline;
-    RGBA color;
-} VKMaskFillColorVertex;
+    unsigned int data;
+} VKMaskFillVertex;
 
 VKPipelineContext* VKPipelines_CreateContext(VKDevice* device);
 void VKPipelines_DestroyContext(VKPipelineContext* pipelines);

src/java.desktop/share/native/common/java2d/vulkan/VKRenderQueue.c

@@ -93,6 +93,21 @@
 #define OFFSET_XFORM   sun_java2d_vulkan_VKBlitLoops_OFFSET_XFORM
 #define OFFSET_ISOBLIT sun_java2d_vulkan_VKBlitLoops_OFFSET_ISOBLIT
 
+static void applyXor() {
+    if (VKRenderer_GetContext()->shader == SHADER_COLOR) {
+        VKRenderer_GetContext()->vertexData ^= VKRenderer_GetContext()->constants.composite.xorColor;
+    }
+}
+
+static void setComposite(VKCompositeMode comp, unsigned int xorColor, float extraAlpha) {
+    VKRenderer_GetContext()->composite = comp;
+    if (VKRenderer_GetContext()->constants.composite.xorColor != xorColor ||
+        VKRenderer_GetContext()->constants.composite.extraAlpha != extraAlpha) {
+        VKRenderer_GetContext()->constants.composite = (VKCompositeConstants) { xorColor, extraAlpha };
+        VKRenderer_GetContext()->constantsModCount++;
+    }
+}
+
 JNIEXPORT void JNICALL Java_sun_java2d_vulkan_VKRenderQueue_flushBuffer
     (JNIEnv *env, jobject oglrq, jlong buf, jint limit)
 {
@@ -476,30 +491,26 @@ JNIEXPORT void JNICALL Java_sun_java2d_vulkan_VKRenderQueue_flushBuffer
                 jint   flags      = NEXT_INT(b);
                 J2dRlsTraceLn(J2D_TRACE_VERBOSE,
                     "VKRenderQueue_flushBuffer: SET_ALPHA_COMPOSITE(%d, %f, %d)", rule, extraAlpha, flags);
-                VKRenderer_GetContext()->renderColor      = VKRenderer_GetContext()->color;
-                VKRenderer_GetContext()->composite  = (VKCompositeMode) rule;
-                VKRenderer_GetContext()->extraAlpha = extraAlpha;
+                applyXor();
+                setComposite((VKCompositeMode) rule, 0, extraAlpha);
             }
             break;
         case sun_java2d_pipe_BufferedOpCodes_SET_XOR_COMPOSITE:
             {
                 jint xorPixel = NEXT_INT(b);
                 J2dRlsTraceLn(J2D_TRACE_VERBOSE,
-                    "VKRenderQueue_flushBuffer: SET_XOR_COMPOSITE");
-                VKRenderer_GetContext()->renderColor = VKUtil_DecodeJavaColor(xorPixel, ALPHA_TYPE_STRAIGHT);
-                // TODO Fix XOR mode!
-                // VKRenderer_GetContext()->renderColor.a = 0.0f; // Alpha is left unchanged in XOR mode.
-                VKRenderer_GetContext()->composite  = LOGIC_COMPOSITE_XOR;
-                VKRenderer_GetContext()->extraAlpha = 1.0f;
+                    "VKRenderQueue_flushBuffer: SET_XOR_COMPOSITE(0x%08x)", xorPixel);
+                applyXor();
+                setComposite(LOGIC_COMPOSITE_XOR, xorPixel, -1.0f);
+                applyXor();
             }
             break;
         case sun_java2d_pipe_BufferedOpCodes_RESET_COMPOSITE:
             {
                 J2dRlsTraceLn(J2D_TRACE_VERBOSE,
                     "VKRenderQueue_flushBuffer: RESET_COMPOSITE");
-                VKRenderer_GetContext()->renderColor = VKRenderer_GetContext()->color;
-                VKRenderer_GetContext()->composite  = ALPHA_COMPOSITE_SRC;
-                VKRenderer_GetContext()->extraAlpha = 1.0f;
+                applyXor();
+                setComposite(ALPHA_COMPOSITE_SRC, 0, 1.0f);
             }
             break;
         case sun_java2d_pipe_BufferedOpCodes_SET_TRANSFORM:
@@ -522,8 +533,8 @@ JNIEXPORT void JNICALL Java_sun_java2d_vulkan_VKRenderQueue_flushBuffer
                 };
 
                 VKRenderingContext* context = VKRenderer_GetContext();
-                if (VK_IS_NEQ_TRANSFORM(&context->transform, &transform)) {
-                    context->transform = transform;
+                if (VK_IS_NEQ_TRANSFORM(&context->constants.transform, &transform)) {
+                    context->constants.transform = transform;
                     context->transformModCount++;
                 }
             }
@@ -533,8 +544,8 @@ JNIEXPORT void JNICALL Java_sun_java2d_vulkan_VKRenderQueue_flushBuffer
                 J2dRlsTraceLn(J2D_TRACE_VERBOSE,
                     "VKRenderQueue_flushBuffer: RESET_TRANSFORM");
                 VKRenderingContext* context = VKRenderer_GetContext();
-                if (VK_IS_NEQ_TRANSFORM(&context->transform, &VK_ID_TRANSFORM)) {
-                    context->transform = VK_ID_TRANSFORM;
+                if (VK_IS_NEQ_TRANSFORM(&context->constants.transform, &VK_ID_TRANSFORM)) {
+                    context->constants.transform = VK_ID_TRANSFORM;
                     context->transformModCount++;
                 }
             }
@@ -568,9 +579,10 @@ JNIEXPORT void JNICALL Java_sun_java2d_vulkan_VKRenderQueue_flushBuffer
             break;
         case sun_java2d_pipe_BufferedOpCodes_DISPOSE_SURFACE:
             {
-                jlong pData = NEXT_LONG(b);
+                VKSDOps* surface = NEXT_VK_SURFACE(b);
                 J2dRlsTraceLn(J2D_TRACE_VERBOSE,
                     "VKRenderQueue_flushBuffer: DISPOSE_SURFACE");
+                VKSD_ResetSurface(surface);
             }
             break;
         case sun_java2d_pipe_BufferedOpCodes_DISPOSE_CONFIG:
@@ -643,31 +655,34 @@ JNIEXPORT void JNICALL Java_sun_java2d_vulkan_VKRenderQueue_flushBuffer
             break;
         case sun_java2d_pipe_BufferedOpCodes_SET_COLOR:
             {
-                jint javaColor = NEXT_INT(b);
-                VKRenderer_GetContext()->color = VKUtil_DecodeJavaColor(javaColor, ALPHA_TYPE_STRAIGHT);
-                if (COMPOSITE_GROUP(VKRenderer_GetContext()->composite) == ALPHA_COMPOSITE_GROUP) {
-                    VKRenderer_GetContext()->renderColor = VKRenderer_GetContext()->color;
-                }
-                J2dRlsTraceLn(J2D_TRACE_VERBOSE, "VKRenderQueue_flushBuffer: SET_COLOR(0x%08x)", javaColor);
-                J2dTraceLn(J2D_TRACE_VERBOSE, // Print color values with straight alpha for convenience.
-                    "    srgb={%.3f, %.3f, %.3f, %.3f}",
-                    VKUtil_GetRGBA(VKRenderer_GetContext()->color, ALPHA_TYPE_STRAIGHT).r,
-                    VKUtil_GetRGBA(VKRenderer_GetContext()->color, ALPHA_TYPE_STRAIGHT).g,
-                    VKUtil_GetRGBA(VKRenderer_GetContext()->color, ALPHA_TYPE_STRAIGHT).b,
-                    VKUtil_GetRGBA(VKRenderer_GetContext()->color, ALPHA_TYPE_STRAIGHT).a);
+                VKRenderer_GetContext()->inAlphaType = ALPHA_TYPE_STRAIGHT;
+                VKRenderer_GetContext()->shader = SHADER_COLOR;
+                VKRenderer_GetContext()->shaderVariant = NO_SHADER_VARIANT;
+                VKRenderer_GetContext()->vertexData = NEXT_INT(b);
+                applyXor();
+                J2dRlsTraceLn(J2D_TRACE_VERBOSE, "VKRenderQueue_flushBuffer: SET_COLOR(0x%08x)", VKRenderer_GetContext()->vertexData);
             }
             break;
         case sun_java2d_pipe_BufferedOpCodes_SET_GRADIENT_PAINT:
             {
-                jboolean useMask= NEXT_BOOLEAN(b);
-                jboolean cyclic = NEXT_BOOLEAN(b);
-                jdouble p0      = NEXT_DOUBLE(b);
-                jdouble p1      = NEXT_DOUBLE(b);
-                jdouble p3      = NEXT_DOUBLE(b);
-                jint pixel1     = NEXT_INT(b);
-                jint pixel2     = NEXT_INT(b);
+                jboolean useMask = NEXT_BOOLEAN(b); // Unused.
+                jboolean cyclic  = NEXT_BOOLEAN(b);
+                jdouble p0       = NEXT_DOUBLE(b);
+                jdouble p1       = NEXT_DOUBLE(b);
+                jdouble p3       = NEXT_DOUBLE(b);
+                jint pixel1      = NEXT_INT(b);
+                jint pixel2      = NEXT_INT(b);
                 J2dRlsTraceLn(J2D_TRACE_VERBOSE,
                     "VKRenderQueue_flushBuffer: SET_GRADIENT_PAINT");
+                VKRenderer_GetContext()->inAlphaType = ALPHA_TYPE_PRE_MULTIPLIED;
+                VKRenderer_GetContext()->shader = SHADER_GRADIENT;
+                VKRenderer_GetContext()->shaderVariant = cyclic ? SHADER_VARIANT_GRADIENT_CYCLE : SHADER_VARIANT_GRADIENT_CLAMP;
+                VKRenderer_GetContext()->constants.shader.gradientPaint = (VKGradientPaintConstants) {
+                    VKUtil_GetRGBA(VKUtil_DecodeJavaColor(pixel1, ALPHA_TYPE_PRE_MULTIPLIED), ALPHA_TYPE_PRE_MULTIPLIED),
+                    VKUtil_GetRGBA(VKUtil_DecodeJavaColor(pixel2, ALPHA_TYPE_PRE_MULTIPLIED), ALPHA_TYPE_PRE_MULTIPLIED),
+                    p0*2.0, p1*2.0, p3*2.0-0.5
+                };
+                VKRenderer_GetContext()->constantsModCount++;
             }
             break;
         case sun_java2d_pipe_BufferedOpCodes_SET_LINEAR_GRADIENT_PAINT:

src/java.desktop/share/native/common/java2d/vulkan/VKRenderer.c

@@ -94,6 +94,7 @@ typedef struct {
 struct VKRenderer {
     VKDevice*          device;
     VKPipelineContext* pipelineContext;
+    VKTexturePool*     texturePool;
 
     POOL(VkCommandBuffer,   commandBufferPool);
     POOL(VkCommandBuffer,   secondaryCommandBufferPool);
@@ -163,6 +164,7 @@ struct VKRenderPass {
     BufferWritingState maskFillBufferWriting;
 
     VKPipelineDescriptor state;
+    uint64_t             constantsModCount; // Just a tag to detect when constants were changed.
     uint64_t             transformModCount; // Just a tag to detect when transform was changed.
     uint64_t             clipModCount; // Just a tag to detect when clip was changed.
     VkBool32             pendingFlush    : 1;
@@ -175,12 +177,17 @@ struct VKRenderPass {
 // which is only called from queue flusher thread, no need for synchronization.
 static VKRenderingContext context = {
         .surface = NULL,
-        .transform = VK_ID_TRANSFORM,
-        .transformModCount = 1,
-        .color = {},
-        .renderColor = {},
         .composite = ALPHA_COMPOSITE_SRC_OVER,
-        .extraAlpha = 1.0f,
+        .inAlphaType = ALPHA_TYPE_UNKNOWN,
+        .shader = NO_SHADER,
+        .shaderVariant = NO_SHADER_VARIANT,
+        .vertexData = 0,
+        .constantsModCount = 1,
+        .transformModCount = 1,
+        .constants = {
+            .transform = VK_ID_TRANSFORM,
+            .composite = { 0, 1.0f }
+        },
         .clipModCount = 1,
         .clipRect = NO_CLIP,
         .clipSpanVertices = NULL
@@ -193,6 +200,9 @@ VKRenderingContext *VKRenderer_GetContext() {
     return &context;
 }
 
+VKTexturePool *VKRenderer_GetTexturePool(VKRenderer* renderer) {
+    return renderer->texturePool;
+}
 /**
  * Helper function for POOL_TAKE macro.
  */
@@ -217,7 +227,7 @@ static VkBool32 VKRenderer_CheckPoolDrain(void* pool, void* entry) {
     return VK_FALSE;
 }
 
-#define VERTEX_BUFFER_SIZE (128 * 1024) // 128KiB - enough to draw 910 quads (6 verts) with VKColorVertex.
+#define VERTEX_BUFFER_SIZE (128 * 1024) // 128KiB - enough to draw 1820 quads (6 verts) with VKVertex.
 #define VERTEX_BUFFER_PAGE_SIZE (1 * 1024 * 1024) // 1MiB - fits 8 buffers.
 static void VKRenderer_FindVertexBufferMemoryType(VKMemoryRequirements* requirements) {
     VKAllocator_FindMemoryType(requirements, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
@@ -368,6 +378,12 @@ VKRenderer* VKRenderer_Create(VKDevice* device) {
         return NULL;
     }
 
+    renderer->texturePool = VKTexturePool_InitWithDevice(device);
+    if (!renderer->texturePool) {
+        VKRenderer_Destroy(renderer);
+        return NULL;
+    }
+
     // Create command pool
     // TODO we currently have single command pool with VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
     //      we may need to consider having multiple pools to avoid resetting buffers one-by-one
@@ -438,6 +454,9 @@ void VKRenderer_Destroy(VKRenderer* renderer) {
         device->vkDestroyDescriptorPool(device->handle, renderer->descriptorPools[i], NULL);
     }
     ARRAY_FREE(renderer->descriptorPools);
+
+    VKTexturePool_Dispose(renderer->texturePool);
+
     for (uint32_t i = 0; i < ARRAY_SIZE(renderer->imageDescriptorPools); i++) {
         device->vkDestroyDescriptorPool(device->handle, renderer->imageDescriptorPools[i], NULL);
     }
@@ -584,33 +603,47 @@ inline void VKRenderer_FlushDraw(VKSDOps* surface) {
 static void VKRenderer_ResetDrawing(VKSDOps* surface) {
     assert(surface != NULL && surface->renderPass != NULL);
     VKRenderer* renderer = surface->device->renderer;
-    surface->renderPass->state.composite = NO_COMPOSITE;
-    surface->renderPass->state.shader = NO_SHADER;
-    surface->renderPass->transformModCount = 0;
-    surface->renderPass->firstVertex = 0;
-    surface->renderPass->vertexCount = 0;
-    surface->renderPass->vertexBufferWriting = (BufferWritingState) {NULL, 0, VK_FALSE};
-    surface->renderPass->maskFillBufferWriting = (BufferWritingState) {NULL, 0, VK_FALSE};
-    if (ARRAY_SIZE(surface->renderPass->flushRanges) > 0) {
+    VKRenderPass* renderPass = surface->renderPass;
+    renderPass->state.composite = NO_COMPOSITE;
+    renderPass->state.shader = NO_SHADER;
+    renderPass->constantsModCount = 0;
+    renderPass->transformModCount = 0;
+    renderPass->firstVertex = 0;
+    renderPass->vertexCount = 0;
+    renderPass->vertexBufferWriting = (BufferWritingState) { NULL, 0, VK_FALSE };
+    renderPass->maskFillBufferWriting = (BufferWritingState) { NULL, 0, VK_FALSE };
+    if (ARRAY_SIZE(renderPass->flushRanges) > 0) {
         VK_IF_ERROR(surface->device->vkFlushMappedMemoryRanges(surface->device->handle,
-            ARRAY_SIZE(surface->renderPass->flushRanges), surface->renderPass->flushRanges)) {}
-        ARRAY_RESIZE(surface->renderPass->flushRanges, 0);
+            ARRAY_SIZE(renderPass->flushRanges), renderPass->flushRanges)) {}
+        ARRAY_RESIZE(renderPass->flushRanges, 0);
     }
-    size_t vertexBufferCount = ARRAY_SIZE(surface->renderPass->vertexBuffers);
-    size_t maskFillBufferCount = ARRAY_SIZE(surface->renderPass->maskFillBuffers);
-    size_t cleanupQueueCount = ARRAY_SIZE(surface->renderPass->cleanupQueue);
+    size_t vertexBufferCount = ARRAY_SIZE(renderPass->vertexBuffers);
+    size_t maskFillBufferCount = ARRAY_SIZE(renderPass->maskFillBuffers);
+    size_t cleanupQueueCount = ARRAY_SIZE(renderPass->cleanupQueue);
     for (uint32_t i = 0; i < vertexBufferCount; i++) {
-        POOL_RETURN(surface->device->renderer, vertexBufferPool, surface->renderPass->vertexBuffers[i]);
+        POOL_RETURN(renderer, vertexBufferPool, renderPass->vertexBuffers[i]);
     }
     for (uint32_t i = 0; i < maskFillBufferCount; i++) {
-        POOL_RETURN(surface->device->renderer, maskFillBufferPool, surface->renderPass->maskFillBuffers[i]);
+        POOL_RETURN(renderer, maskFillBufferPool, renderPass->maskFillBuffers[i]);
     }
     for (uint32_t i = 0; i < cleanupQueueCount; i++) {
-        POOL_RETURN(surface->device->renderer, cleanupQueue, surface->renderPass->cleanupQueue[i]);
+        POOL_RETURN(renderer, cleanupQueue, renderPass->cleanupQueue[i]);
     }
-    ARRAY_RESIZE(surface->renderPass->vertexBuffers, 0);
-    ARRAY_RESIZE(surface->renderPass->maskFillBuffers, 0);
-    ARRAY_RESIZE(surface->renderPass->cleanupQueue, 0);
+    ARRAY_RESIZE(renderPass->vertexBuffers, 0);
+    ARRAY_RESIZE(renderPass->maskFillBuffers, 0);
+    ARRAY_RESIZE(renderPass->cleanupQueue, 0);
+
+    // Update dependencies on used surfaces.
+    for (uint32_t i = 0, surfaces = (uint32_t) ARRAY_SIZE(renderPass->usedSurfaces); i < surfaces; i++) {
+        VKSDOps* usedSurface = renderPass->usedSurfaces[i];
+        uint32_t newSize = 0, oldSize = (uint32_t) ARRAY_SIZE(usedSurface->dependentSurfaces);
+        for (uint32_t j = 0; j < oldSize; j++) {
+            VKSDOps* s = usedSurface->dependentSurfaces[j];
+            if (s != surface) usedSurface->dependentSurfaces[newSize++] = s;
+        }
+        if (newSize != oldSize) ARRAY_RESIZE(usedSurface->dependentSurfaces, newSize);
+    }
+    ARRAY_RESIZE(renderPass->usedSurfaces, 0);
 }
 
 /**
@@ -698,6 +731,7 @@ static VkBool32 VKRenderer_InitRenderPass(VKSDOps* surface) {
                 .composite = NO_COMPOSITE,
                 .shader = NO_SHADER
             },
+            .constantsModCount = 0,
             .transformModCount = 0,
             .clipModCount = 0,
             .pendingFlush = VK_FALSE,
@@ -864,19 +898,11 @@ VkBool32 VKRenderer_FlushRenderPass(VKSDOps* surface) {
     VKRenderer* renderer = device->renderer;
     VkCommandBuffer cb = VKRenderer_Record(renderer);
 
-    // Update dependencies on used surfaces.
+    // Update timestamps on used surfaces.
     surface->lastTimestamp = renderer->writeTimestamp;
     for (uint32_t i = 0, surfaces = (uint32_t) ARRAY_SIZE(surface->renderPass->usedSurfaces); i < surfaces; i++) {
-        VKSDOps* usedSurface = surface->renderPass->usedSurfaces[i];
-        usedSurface->lastTimestamp = renderer->writeTimestamp;
-        uint32_t newSize = 0, oldSize = (uint32_t) ARRAY_SIZE(usedSurface->dependentSurfaces);
-        for (uint32_t j = 0; j < oldSize; j++) {
-            VKSDOps* s = usedSurface->dependentSurfaces[j];
-            if (s != surface) usedSurface->dependentSurfaces[newSize++] = s;
-        }
-        if (newSize != oldSize) ARRAY_RESIZE(usedSurface->dependentSurfaces, newSize);
+        surface->renderPass->usedSurfaces[i]->lastTimestamp = renderer->writeTimestamp;
     }
-    ARRAY_RESIZE(surface->renderPass->usedSurfaces, 0);
 
     // Insert barriers to prepare surface for rendering.
     VkImageMemoryBarrier barriers[2];
@@ -950,9 +976,12 @@ void VKRenderer_FlushSurface(VKSDOps* surface) {
         uint32_t imageIndex;
         VkResult acquireImageResult = device->vkAcquireNextImageKHR(device->handle, win->swapchain, UINT64_MAX,
                                                                     acquireSemaphore, VK_NULL_HANDLE, &imageIndex);
-        if (acquireImageResult != VK_SUCCESS) {
-            // TODO possible suboptimal conditions
-            VK_IF_ERROR(acquireImageResult) {}
+        if (acquireImageResult != VK_SUCCESS && acquireImageResult != VK_SUBOPTIMAL_KHR) {
+            VK_IF_ERROR(acquireImageResult) {
+                // Failed, try again later.
+                surface->renderPass->pendingFlush = VK_TRUE;
+                return;
+            }
         }
 
         // Insert barriers to prepare both main (src) and swapchain (dst) images for blit.
@@ -1109,7 +1138,7 @@ static uint32_t VKRenderer_AllocateVertices(uint32_t primitives, uint32_t vertic
  * This function can invalidate drawing state, always call it before VK_DRAW.
  */
 static BufferWritingState VKRenderer_AllocateMaskFillBytes(uint32_t size) {
-    assert(size > 0);
+    // assert(size > 0); // size can be 0 when binding the buffer without allocating any data.
     assert(size <= MASK_FILL_BUFFER_SIZE);
     VKSDOps* surface = VKRenderer_GetContext()->surface;
     BufferWritingState state = VKRenderer_AllocateBufferData(
@@ -1145,16 +1174,35 @@ static void VKRenderer_ValidateTransform() {
                 0.0f, 2.0f / (float) surface->image->extent.height, -1.0f
         };
         // Combine it with user transform.
-        VKUtil_ConcatenateTransform(&transform, &context->transform);
+        VKUtil_ConcatenateTransform(&transform, &context->constants.transform);
         // Push the transform into shader.
         surface->device->vkCmdPushConstants(
                 renderPass->commandBuffer,
-                surface->device->renderer->pipelineContext->colorPipelineLayout, // TODO what if our pipeline layout differs?
+                surface->device->renderer->pipelineContext->commonPipelineLayout,
                 VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(VKTransform), &transform
         );
     }
 }
 
+static void VKRenderer_ValidateConstants() {
+    VKRenderingContext* context = VKRenderer_GetContext();
+    assert(context->surface != NULL);
+    VKSDOps* surface = context->surface;
+    VKRenderPass* renderPass = surface->renderPass;
+    // Update constants, ignoring clip and color shaders.
+    if (renderPass->constantsModCount != context->constantsModCount &&
+        renderPass->state.shader != SHADER_CLIP && renderPass->state.shader != SHADER_COLOR) {
+        J2dTraceLn(J2D_TRACE_VERBOSE, "VKRenderer_ValidateConstants: updating constants");
+        VKRenderer_FlushDraw(surface);
+        renderPass->constantsModCount = context->constantsModCount;
+        surface->device->vkCmdPushConstants(
+                renderPass->commandBuffer,
+                surface->device->renderer->pipelineContext->commonPipelineLayout,
+                VK_SHADER_STAGE_FRAGMENT_BIT, PUSH_CONSTANTS_OFFSET, PUSH_CONSTANTS_SIZE, &context->constants.composite
+        );
+    }
+}
+
 /**
  * Setup stencil attachment according to the context clip state.
  * If there is a clip shape, attachment is cleared with "fail" value and then
@@ -1191,6 +1239,7 @@ static void VKRenderer_SetupStencil() {
             .inAlphaType = ALPHA_TYPE_UNKNOWN,
             .composite = NO_COMPOSITE,
             .shader = SHADER_CLIP,
+            .shaderVariant = NO_SHADER_VARIANT,
             .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST
         }).pipeline);
     // Reset vertex buffer binding.
@@ -1235,7 +1284,7 @@ void VKRenderer_RecordBarriers(VKRenderer* renderer,
 /**
  * Setup pipeline for drawing. Returns FALSE if surface is not yet ready for drawing.
  */
-VkBool32 VKRenderer_Validate(VKShader shader, VkPrimitiveTopology topology, AlphaType inAlphaType) {
+VkBool32 VKRenderer_Validate(VKShader shader, VKShaderVariant shaderVariant, VkPrimitiveTopology topology, AlphaType inAlphaType) {
     assert(context.surface != NULL);
     VKSDOps* surface = context.surface;
 
@@ -1277,10 +1326,18 @@ VkBool32 VKRenderer_Validate(VKShader shader, VkPrimitiveTopology topology, Alph
             J2dTraceLn(J2D_TRACE_VERBOSE, "VKRenderer_Validate: updating clip");
             surface->device->vkCmdSetScissor(renderPass->commandBuffer, 0, 1, &context.clipRect);
             if (clipChanged) {
+                VKStencilMode stencilMode = STENCIL_MODE_NONE;
                 if (ARRAY_SIZE(context.clipSpanVertices) > 0) {
                     VKRenderer_SetupStencil();
-                    renderPass->state.stencilMode = STENCIL_MODE_ON;
-                } else renderPass->state.stencilMode = surface->stencil != NULL ? STENCIL_MODE_OFF : STENCIL_MODE_NONE;
+                    stencilMode = STENCIL_MODE_ON;
+                } else if (surface->stencil != NULL) {
+                    stencilMode = STENCIL_MODE_OFF;
+                }
+                // Reset the pipeline when changing stencil mode.
+                if (renderPass->state.stencilMode != stencilMode) {
+                    renderPass->state.shader = NO_SHADER;
+                }
+                renderPass->state.stencilMode = stencilMode;
             }
         }
         // Validate current composite.
@@ -1296,6 +1353,7 @@ VkBool32 VKRenderer_Validate(VKShader shader, VkPrimitiveTopology topology, Alph
 
     // Validate current pipeline.
     if (renderPass->state.shader != shader ||
+        renderPass->state.shaderVariant != shaderVariant ||
         renderPass->state.topology != topology ||
         renderPass->state.inAlphaType != inAlphaType) {
         J2dTraceLn(J2D_TRACE_VERBOSE, "VKRenderer_Validate: updating pipeline, old=%d, new=%d",
@@ -1303,6 +1361,7 @@ VkBool32 VKRenderer_Validate(VKShader shader, VkPrimitiveTopology topology, Alph
         VKRenderer_FlushDraw(surface);
         VkCommandBuffer cb = renderPass->commandBuffer;
         renderPass->state.shader = shader;
+        renderPass->state.shaderVariant = shaderVariant;
         renderPass->state.topology = topology;
         renderPass->state.inAlphaType = inAlphaType;
         VKPipelineInfo pipelineInfo = VKPipelines_GetPipelineInfo(renderPass->context, renderPass->state);
@@ -1310,10 +1369,26 @@ VkBool32 VKRenderer_Validate(VKShader shader, VkPrimitiveTopology topology, Alph
         surface->device->vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineInfo.pipeline);
         renderPass->vertexBufferWriting.bound = VK_FALSE;
         renderPass->maskFillBufferWriting.bound = VK_FALSE;
+
+        // If pipeline uses mask fill layout, but the shader is not actually a MASK one, that must be a generic-layout pipeline.
+        // In that case, we need to bind a mask buffer, even if we won't ever use it.
+        // We could use VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT or nullDescriptor, but those require
+        // optional features or extensions, so don't bother for now...
+        // TODO this is ugly, do something with it.
+        if (pipelineInfo.layout == surface->device->renderer->pipelineContext->maskFillPipelineLayout && !(shader & SHADER_MASK)) {
+            VKRenderer_AllocateMaskFillBytes(0);
+        }
     }
+
+    VKRenderer_ValidateConstants();
     return VK_TRUE;
 }
 
+static VkBool32 VKRenderer_ValidatePaint(VKShader shaderModifier, VkBool32 fill) {
+    return VKRenderer_Validate(context.shader | shaderModifier, context.shaderVariant,
+        fill ? VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST : VK_PRIMITIVE_TOPOLOGY_LINE_LIST, context.inAlphaType);
+}
+
 // Drawing operations.
 
 void VKRenderer_RenderRect(VkBool32 fill, jint x, jint y, jint w, jint h) {
@@ -1324,12 +1399,9 @@ void VKRenderer_RenderRect(VkBool32 fill, jint x, jint y, jint w, jint h) {
 void VKRenderer_RenderParallelogram(VkBool32 fill,
                                     jfloat x11, jfloat y11,
                                     jfloat dx21, jfloat dy21,
-                                    jfloat dx12, jfloat dy12)
-{
-    if (!VKRenderer_Validate(SHADER_COLOR,
-                             fill ? VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST
-                                  : VK_PRIMITIVE_TOPOLOGY_LINE_LIST, ALPHA_TYPE_UNKNOWN)) return; // Not ready.
-    RGBA c = VKRenderer_GetRGBA(context.surface, context.renderColor);
+                                    jfloat dx12, jfloat dy12) {
+    if (!VKRenderer_ValidatePaint(0, fill)) return; // Not ready.
+
     /*                   dx21
      *    (p1)---------(p2) |          (p1)------
      *     |\            \  |            |  \    dy21
@@ -1340,12 +1412,12 @@ void VKRenderer_RenderParallelogram(VkBool32 fill,
      *                              dy21    \ |
      *                                  -----(p3)
      */
-    VKColorVertex p1 = {x11, y11, c};
-    VKColorVertex p2 = {x11 + dx21, y11 + dy21, c};
-    VKColorVertex p3 = {x11 + dx21 + dx12, y11 + dy21 + dy12, c};
-    VKColorVertex p4 = {x11 + dx12, y11 + dy12, c};
+    VKVertex p1 = {x11, y11, context.vertexData};
+    VKVertex p2 = {x11 + dx21, y11 + dy21, context.vertexData};
+    VKVertex p3 = {x11 + dx21 + dx12, y11 + dy21 + dy12, context.vertexData};
+    VKVertex p4 = {x11 + dx12, y11 + dy12, context.vertexData};
 
-    VKColorVertex* vs;
+    VKVertex* vs;
     VK_DRAW(vs, 1, fill ? 6 : 8);
     uint32_t i = 0;
     vs[i++] = p1;
@@ -1362,19 +1434,18 @@ void VKRenderer_RenderParallelogram(VkBool32 fill,
 
 void VKRenderer_FillSpans(jint spanCount, jint *spans) {
     if (spanCount == 0) return;
-    if (!VKRenderer_Validate(SHADER_COLOR, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, ALPHA_TYPE_UNKNOWN)) return; // Not ready.
-    RGBA c = VKRenderer_GetRGBA(context.surface, context.renderColor);
+    if (!VKRenderer_ValidatePaint(0, VK_TRUE)) return; // Not ready.
 
     jfloat x1 = (float)*(spans++);
     jfloat y1 = (float)*(spans++);
     jfloat x2 = (float)*(spans++);
     jfloat y2 = (float)*(spans++);
-    VKColorVertex p1 = {x1, y1, c};
-    VKColorVertex p2 = {x2, y1, c};
-    VKColorVertex p3 = {x2, y2, c};
-    VKColorVertex p4 = {x1, y2, c};
+    VKVertex p1 = {x1, y1, context.vertexData};
+    VKVertex p2 = {x2, y1, context.vertexData};
+    VKVertex p3 = {x2, y2, context.vertexData};
+    VKVertex p4 = {x1, y2, context.vertexData};
 
-    VKColorVertex* vs;
+    VKVertex* vs;
     VK_DRAW(vs, 1, 6);
     vs[0] = p1; vs[1] = p2; vs[2] = p3; vs[3] = p3; vs[4] = p4; vs[5] = p1;
 
@@ -1391,8 +1462,8 @@ void VKRenderer_FillSpans(jint spanCount, jint *spans) {
 
 void VKRenderer_MaskFill(jint x, jint y, jint w, jint h,
                          jint maskoff, jint maskscan, jint masklen, uint8_t *mask) {
-    if (!VKRenderer_Validate(SHADER_MASK_FILL_COLOR,
-                             VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, ALPHA_TYPE_UNKNOWN)) return; // Not ready.
+    if (!VKRenderer_ValidatePaint(SHADER_MASK, VK_TRUE)) return; // Not ready.
+
     // maskoff is the offset from the beginning of mask,
     // it's the same as x and y offset within a tile (maskoff % maskscan, maskoff / maskscan).
     // maskscan is the number of bytes in a row/
@@ -1410,14 +1481,13 @@ void VKRenderer_MaskFill(jint x, jint y, jint w, jint h,
         *((char *)maskState.data) = (char)0xFF;
     }
 
-    VKMaskFillColorVertex* vs;
+    VKMaskFillVertex* vs;
     VK_DRAW(vs, 1, 6);
-    RGBA c = VKRenderer_GetRGBA(context.surface, context.renderColor);
     int offset = (int) maskState.offset;
-    VKMaskFillColorVertex p1 = {x, y, offset, maskscan, c};
-    VKMaskFillColorVertex p2 = {x + w, y, offset, maskscan, c};
-    VKMaskFillColorVertex p3 = {x + w, y + h, offset, maskscan, c};
-    VKMaskFillColorVertex p4 = {x, y + h, offset, maskscan, c};
+    VKMaskFillVertex p1 = {x, y, offset, maskscan, context.vertexData};
+    VKMaskFillVertex p2 = {x + w, y, offset, maskscan, context.vertexData};
+    VKMaskFillVertex p3 = {x + w, y + h, offset, maskscan, context.vertexData};
+    VKMaskFillVertex p4 = {x, y + h, offset, maskscan, context.vertexData};
     // Always keep p1 as provoking vertex for correct origin calculation in vertex shader.
     vs[0] = p1; vs[1] = p3; vs[2] = p2;
     vs[3] = p1; vs[4] = p3; vs[5] = p4;

src/java.desktop/share/native/common/java2d/vulkan/VKRenderer.h

@@ -29,27 +29,22 @@
 
 #include "VKTypes.h"
 #include "VKPipelines.h"
+#include "VKTexturePool.h"
 
 #define NO_CLIP ((VkRect2D) {{0, 0}, {0x7FFFFFFFU, 0x7FFFFFFFU}})
 
 struct VKRenderingContext {
     VKSDOps*        surface;
 
-    VKTransform     transform;
+    VKCompositeMode composite;
+    AlphaType       inAlphaType;
+    VKShader        shader;
+    VKShaderVariant shaderVariant;
+    unsigned int    vertexData;
+    VKPushConstants constants;
+    uint64_t        constantsModCount;
     uint64_t        transformModCount;
 
-    // We keep this color separately from renderColor,
-    // because we need consistent state when switching between XOR and alpha
-    // composite modes. This variable holds last value set by SET_COLOR, while
-    // renderColor holds color, currently used for drawing, which may have
-    // also been provided by SET_XOR_COMPOSITE.
-    Color           color;
-    Color           renderColor;
-    VKCompositeMode composite;
-
-    // Extra alpha is not used when painting with plain color,
-    // in this case color.a already includes it.
-    float extraAlpha;
     uint64_t           clipModCount; // Used to track changes to the clip.
     VkRect2D           clipRect;
     ARRAY(VKIntVertex) clipSpanVertices;
@@ -62,7 +57,7 @@ VKRenderer* VKRenderer_Create(VKDevice* device);
 /**
  * Setup pipeline for drawing. Returns FALSE if the surface is not yet ready for drawing.
  */
-VkBool32 VKRenderer_Validate(VKShader shader, VkPrimitiveTopology topology, AlphaType inAlphaType);
+VkBool32 VKRenderer_Validate(VKShader shader, VKShaderVariant shaderVariant, VkPrimitiveTopology topology, AlphaType inAlphaType);
 
 /**
  * Record commands into the primary command buffer (outside of a render pass).
@@ -147,5 +142,6 @@ void VKRenderer_DrawImage(VKImage* image, VkFormat format,
                           float dx1, float dy1, float dx2, float dy2);
 
 VKRenderingContext* VKRenderer_GetContext();
+VKTexturePool* VKRenderer_GetTexturePool(VKRenderer* );
 
 #endif //VKRenderer_h_Included

src/java.desktop/share/native/common/java2d/vulkan/VKSurfaceData.c

@@ -292,7 +292,7 @@ VkBool32 VKSD_ConfigureWindowSurface(VKWinSDOps* vkwinsdo) {
 }
 
 static void VKSD_OnDispose(JNIEnv* env, SurfaceDataOps* ops) {
-    VKSD_ResetSurface((VKSDOps*) ops);
+    JNU_CallStaticMethodByName(env, NULL, "sun/java2d/vulkan/VKSurfaceData", "dispose", "(J)V", ptr_to_jlong(ops));
 }
 
 JNIEXPORT VKSDOps* VKSD_CreateSurface(JNIEnv* env, jobject vksd, jint type, jint format, jint backgroundRGB,

src/java.desktop/share/native/common/java2d/vulkan/VKTypes.h

@@ -62,7 +62,7 @@ typedef uint16_t VKPackedSwizzle;
  */
 typedef struct {
     float m00, m01, m02;
-    float m10 __attribute__((aligned(16))), m11, m12;
+    float m10, m11, m12;
 } VKTransform;
 
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VKMemory);

src/java.desktop/unix/classes/sun/awt/wl/DefaultFrameDecoration.java

@@ -40,35 +40,44 @@ import java.awt.RenderingHints;
 import java.awt.geom.Ellipse2D;
 
 public class DefaultFrameDecoration extends FullFrameDecorationHelper {
-    private static final int HEIGHT = 30;
+    private static final int BORDER_SIZE = 1;
+    private static final int HEIGHT = 28 + BORDER_SIZE;
     private static final int BUTTON_ICON_SIZE = 4;
-    private static final int BUTTON_CIRCLE_RADIUS = 10;
+    private static final int BUTTON_SIZE = 16;
+    private static final int BUTTONS_RIGHT_PADDING = 7;
+    private static final int BUTTONS_PADDING = 8;
     private static final Font FONT = new Font(Font.DIALOG, Font.BOLD, 12);
-    private static final Color ACTIVE_BACKGROUND = new Color(0xebebeb);
-    private static final Color ACTIVE_BACKGROUND_DARK = new Color(0x222222);
-    private static final Color INACTIVE_BACKGROUND = new Color(0xfafafa);
-    private static final Color INACTIVE_BACKGROUND_DARK = new Color(0x2c2c2c);
+    private static final Color ACTIVE_BACKGROUND = new Color(0xedeeef);
+    private static final Color ACTIVE_BACKGROUND_DARK = new Color(0x31363b);
+    private static final Color INACTIVE_BACKGROUND = new Color(0xdcddde);
+    private static final Color INACTIVE_BACKGROUND_DARK = new Color(0x292d31);
     private static final Color ICON_BACKGROUND = ACTIVE_BACKGROUND;
     private static final Color ICON_BACKGROUND_DARK = ACTIVE_BACKGROUND_DARK;
-    private static final Color ICON_HOVERED_BACKGROUND = new Color(0xd1d1d1);
-    private static final Color ICON_HOVERED_BACKGROUND_DARK = new Color(0x373737);
-    private static final Color ICON_PRESSED_BACKGROUND = new Color(0xc0c0c0);
-    private static final Color ICON_PRESSED_BACKGROUND_DARK = new Color(0x565656);
-    private static final Color ACTIVE_FOREGROUND = Color.darkGray;
-    private static final Color ACTIVE_FOREGROUND_DARK = new Color(0xf7f7f7);
-    private static final Color INACTIVE_FOREGROUND = Color.gray;
-    private static final Color INACTIVE_FOREGROUND_DARK = new Color(0xb5b5b5);
+    private static final Color ICON_HOVERED_BACKGROUND = new Color(0x232629);
+    private static final Color ICON_HOVERED_BACKGROUND_DARK = new Color(0xfcfcfc);
+    private static final Color ICON_HOVERED_FOREGROUND = new Color(0xcacdcf);
+    private static final Color ICON_HOVERED_FOREGROUND_DARK = new Color(0x43484c);
+    private static final Color ICON_PRESSED_BACKGROUND = new Color(0xa6a8ab);
+    private static final Color ICON_PRESSED_BACKGROUND_DARK = new Color(0x6e7175);
+    private static final Color CLOSE_ICON_PRESSED_BACKGROUND = new Color(0x6d2229);
+    private static final Color CLOSE_ICON_PRESSED_BACKGROUND_DARK = new Color(0x6d2229);
+    private static final Color CLOSE_ICON_HOVERED_BACKGROUND = new Color(0xff98a2);
+    private static final Color CLOSE_ICON_HOVERED_INACTIVE_BACKGROUND = new Color(0xda4453);
+    private static final Color CLOSE_ICON_HOVERED_INACTIVE_BACKGROUND_DARK = new Color(0xda4453);
+    private static final Color CLOSE_ICON_HOVERED_BACKGROUND_DARK = new Color(0xff98a2);
+    private static final Color ACTIVE_FOREGROUND = new Color(0x2d3033);
+    private static final Color ACTIVE_FOREGROUND_DARK = new Color(0xf1f1f1);
+    private static final Color INACTIVE_FOREGROUND = ACTIVE_FOREGROUND;
+    private static final Color INACTIVE_FOREGROUND_DARK = ACTIVE_FOREGROUND_DARK;
 
-    private static final Color ACTIVE_BACKGROUND_TOP = new Color(0xfbfbfb);
-    private static final Color ACTIVE_BACKGROUND_TOP_DARK = new Color(0x313131);
-    private static final Color INACTIVE_BACKGROUND_TOP = new Color(0xfefefe);
-    private static final Color INACTIVE_BACKGROUND_TOP_DARK = new Color(0x3a3a3a);
-    private static final Color ACTIVE_BORDER = new Color(0x9e9e9e);
-    private static final Color ACTIVE_BORDER_DARK = new Color(0x080808);
-    private static final Color INACTIVE_BORDER = new Color(0xbcbcbc);
-    private static final Color INACTIVE_BORDER_DARK = new Color(0x121212);
-
-    private static final int BORDER_SIZE = 1;
+    private static final Color ACTIVE_BACKGROUND_TOP = new Color(0xa9abac);
+    private static final Color ACTIVE_BACKGROUND_TOP_DARK = new Color(0x4c565f);
+    private static final Color INACTIVE_BACKGROUND_TOP = new Color(0xb7b8b9);
+    private static final Color INACTIVE_BACKGROUND_TOP_DARK = new Color(0x424952);
+    private static final Color ACTIVE_BORDER = ACTIVE_BACKGROUND_TOP;
+    private static final Color ACTIVE_BORDER_DARK = ACTIVE_BACKGROUND_TOP_DARK;
+    private static final Color INACTIVE_BORDER = INACTIVE_BACKGROUND_TOP;
+    private static final Color INACTIVE_BORDER_DARK = INACTIVE_BACKGROUND_TOP_DARK;
     private static final int SIGNIFICANT_DRAG_DISTANCE = 4;
 
     public DefaultFrameDecoration(WLDecoratedPeer peer, boolean showMinimize, boolean showMaximize) {
@@ -96,64 +105,31 @@ public class DefaultFrameDecoration extends FullFrameDecorationHelper {
         return new Dimension(getButtonSpaceWidth(), HEIGHT);
     }
 
-    private Point getCloseButtonCenter() {
-        int width = peer.getWidth();
-        return width >= HEIGHT ? new Point(width - HEIGHT / 2, HEIGHT / 2) : null;
-    }
-
-    private Point getMaximizeButtonCenter() {
-        if (!hasMaximizeButton()) return null;
-        int width = peer.getWidth();
-        return width >= 2 * HEIGHT ? new Point(width - HEIGHT * 3 / 2, HEIGHT / 2) : null;
-    }
-
-    private Point getMinimizeButtonCenter() {
-        if (!hasMinimizeButton()) return null;
-        int width = peer.getWidth();
-        int buttonSpaceWidth = getButtonSpaceWidth();
-        return width >= buttonSpaceWidth ? new Point(width - buttonSpaceWidth + HEIGHT / 2, HEIGHT / 2) : null;
-    }
-
     @Override
     protected Rectangle getCloseButtonBounds() {
-        int width = peer.getWidth();
-        if (width >= HEIGHT) {
-            return new Rectangle(width - HEIGHT / 2 - BUTTON_CIRCLE_RADIUS,
-                    HEIGHT / 2 - BUTTON_CIRCLE_RADIUS,
-                    BUTTON_CIRCLE_RADIUS * 2,
-                    BUTTON_CIRCLE_RADIUS * 2);
-        } else {
-            return null;
-        }
+        int x = peer.getWidth() - BUTTON_SIZE - BUTTONS_RIGHT_PADDING - BORDER_SIZE;
+        int y = (int) Math.floor((HEIGHT - BUTTON_SIZE + 1f) / 2);
+        return new Rectangle(x, y, BUTTON_SIZE, BUTTON_SIZE);
     }
 
     @Override
     protected Rectangle getMaximizeButtonBounds() {
         if (!hasMaximizeButton()) return null;
-        int width = peer.getWidth();
-        if (width >= 2 * HEIGHT) {
-            return new Rectangle(width - HEIGHT * 3 / 2 - BUTTON_CIRCLE_RADIUS,
-                    HEIGHT / 2 - BUTTON_CIRCLE_RADIUS,
-                    BUTTON_CIRCLE_RADIUS * 2,
-                    BUTTON_CIRCLE_RADIUS * 2);
-        } else {
-            return null;
-        }
+
+        int x = peer.getWidth() - BUTTON_SIZE * 2 - BUTTONS_RIGHT_PADDING
+                - BUTTONS_PADDING - BORDER_SIZE;
+        int y = (int) Math.floor((HEIGHT - BUTTON_SIZE + 1f) / 2);
+        return x > 0 ? new Rectangle(x, y, BUTTON_SIZE, BUTTON_SIZE) : null;
     }
 
     @Override
     protected Rectangle getMinimizeButtonBounds() {
         if (!hasMinimizeButton()) return null;
-        int width = peer.getWidth();
-        int buttonSpaceWidth = getButtonSpaceWidth();
-        if (width >= buttonSpaceWidth) {
-            return new Rectangle(width - buttonSpaceWidth + HEIGHT / 2 - BUTTON_CIRCLE_RADIUS,
-                    HEIGHT / 2 - BUTTON_CIRCLE_RADIUS,
-                    BUTTON_CIRCLE_RADIUS * 2,
-                    BUTTON_CIRCLE_RADIUS * 2);
-        } else {
-            return null;
-        }
+
+        int x = peer.getWidth() - BUTTON_SIZE * 3 - BUTTONS_RIGHT_PADDING
+                - BUTTONS_PADDING * 2 - BORDER_SIZE;
+        int y = (int) Math.floor((HEIGHT - BUTTON_SIZE + 1f) / 2);
+        return x > 0 ? new Rectangle(x, y, BUTTON_SIZE, BUTTON_SIZE) : null;
     }
 
     @Override
@@ -170,7 +146,7 @@ public class DefaultFrameDecoration extends FullFrameDecorationHelper {
         final int numButtons = 1
                 + (hasMaximizeButton() ? 1 : 0)
                 + (hasMinimizeButton() ? 1 : 0);
-        return numButtons * HEIGHT;
+        return numButtons * BUTTON_SIZE + (numButtons - 1) * BUTTONS_PADDING + BUTTONS_RIGHT_PADDING;
     }
 
     private Color getBackgroundColor(boolean isActive) {
@@ -217,13 +193,33 @@ public class DefaultFrameDecoration extends FullFrameDecorationHelper {
         }
     }
 
+    private Color getButtonForeground(boolean isHovered) {
+        if (isHovered) {
+            return isDarkTheme() ? ICON_HOVERED_FOREGROUND_DARK : ICON_HOVERED_FOREGROUND;
+        } else {
+            return isDarkTheme() ? ACTIVE_FOREGROUND_DARK : ACTIVE_FOREGROUND;
+        }
+    }
+
+    private Color getClosePressedBackground() {
+        return isDarkTheme() ? CLOSE_ICON_PRESSED_BACKGROUND_DARK : CLOSE_ICON_PRESSED_BACKGROUND;
+    }
+
+    private Color getCloseHoveredBackground(boolean isActive) {
+        if (isActive) {
+            return isDarkTheme() ? CLOSE_ICON_HOVERED_BACKGROUND_DARK : CLOSE_ICON_HOVERED_BACKGROUND;
+        } else {
+            return isDarkTheme() ? CLOSE_ICON_HOVERED_INACTIVE_BACKGROUND_DARK : CLOSE_ICON_HOVERED_INACTIVE_BACKGROUND;
+        }
+    }
+
     @Override
     protected void paintBorder(Graphics2D g2d) {
         int width = peer.getWidth();
         int height = peer.getHeight();
         g2d.setColor(getBorderColor(isActive()));
         g2d.setStroke(new BasicStroke(BORDER_SIZE));
-        g2d.drawRect(0, 0, width - BORDER_SIZE, height - BORDER_SIZE);
+        g2d.drawRect(0, 0, width, height);
     }
 
     @Override
@@ -250,17 +246,11 @@ public class DefaultFrameDecoration extends FullFrameDecorationHelper {
             // The title bar
             g.fillRoundRect(0, 0, width, HEIGHT + radius + 1, radius, radius);
 
-            // The top bevel of the title bar
-            g.setColor(getBackgroundTopColor(active));
-            g.drawLine(radius / 2, 1, width - radius / 2, 1);
-            g.drawArc(1, 1, (radius - 1), (radius - 1), 90, 60);
-            g.drawArc(width - radius, 1, (radius - 1), (radius - 1), 45, 45);
-
             // The border
             var oldStroke = g.getStroke();
             g.setColor(getBorderColor(active));
             g.setStroke(new BasicStroke(BORDER_SIZE));
-            g.drawRoundRect(0, 0, width - BORDER_SIZE, HEIGHT + radius + 1, radius, radius);
+            g.drawRoundRect(0, 0, width, HEIGHT + radius + 1, radius, radius);
             g.setStroke(oldStroke);
             g.drawLine(0, HEIGHT - 1, width, HEIGHT - 1);
         } else {
@@ -270,32 +260,35 @@ public class DefaultFrameDecoration extends FullFrameDecorationHelper {
 
             // The top bevel of the title bar
             g.setColor(getBackgroundTopColor(active));
-            g.drawLine(BORDER_SIZE, BORDER_SIZE, width - BORDER_SIZE, BORDER_SIZE);
-            g.drawLine(BORDER_SIZE, BORDER_SIZE, BORDER_SIZE, HEIGHT - BORDER_SIZE);
+            g.drawLine(BORDER_SIZE, BORDER_SIZE, width, BORDER_SIZE);
+            g.drawLine(BORDER_SIZE, BORDER_SIZE, BORDER_SIZE, HEIGHT);
 
             // The border
             var oldStroke = g.getStroke();
             g.setColor(getBorderColor(active));
             g.setStroke(new BasicStroke(BORDER_SIZE));
-            g.drawRect(0, 0, width - BORDER_SIZE, HEIGHT - BORDER_SIZE);
+            g.drawRect(0, 0, width, HEIGHT);
             g.setStroke(oldStroke);
         }
         paintTitle(g, title, foregroundColor, width);
 
-        Point closeButtonCenter = getCloseButtonCenter();
-        if (closeButtonCenter != null) {
-            paintButtonBackground(g, closeButtonCenter, closeButton);
-            paintCloseButton(g, closeButtonCenter, foregroundColor);
+        Rectangle closeButtonBounds = getCloseButtonBounds();
+        if (closeButtonBounds != null) {
+            paintCloseButtonBackground(g, closeButtonBounds, closeButton);
+            Color buttonColor = getButtonForeground(closeButton.hovered);
+            paintCloseButton(g, closeButtonBounds, buttonColor);
         }
-        Point maximizedButtonCenter = getMaximizeButtonCenter();
-        if (maximizedButtonCenter != null) {
-            paintButtonBackground(g, maximizedButtonCenter, maximizeButton);
-            paintMaximizeButton(g, maximizedButtonCenter, foregroundColor);
+        Rectangle maximizedButtonBounds = getMaximizeButtonBounds();
+        if (maximizedButtonBounds != null) {
+            paintButtonBackground(g, maximizedButtonBounds, maximizeButton);
+            Color buttonColor = getButtonForeground(maximizeButton.hovered);
+            paintMaximizeButton(g, maximizedButtonBounds, buttonColor);
         }
-        Point minimizedButtonCenter = getMinimizeButtonCenter();
-        if (minimizedButtonCenter != null) {
-            paintButtonBackground(g, minimizedButtonCenter, minimizeButton);
-            paintMinimizeButton(g, minimizedButtonCenter, foregroundColor);
+        Rectangle minimizedButtonBounds = getMinimizeButtonBounds();
+        if (minimizedButtonBounds != null) {
+            paintButtonBackground(g, minimizedButtonBounds, minimizeButton);
+            Color buttonColor = getButtonForeground(minimizeButton.hovered);
+            paintMinimizeButton(g, minimizedButtonBounds, buttonColor);
         }
         g.setClip(null);
     }
@@ -304,7 +297,7 @@ public class DefaultFrameDecoration extends FullFrameDecorationHelper {
         g.setColor(foregroundColor);
         g.setFont(FONT);
         FontMetrics fm = g.getFontMetrics();
-        int leftMargin = HEIGHT / 2 - BUTTON_CIRCLE_RADIUS; // same as space between close button and right window edge
+        int leftMargin = HEIGHT / 2 - BUTTON_SIZE; // same as space between close button and right window edge
         int availableWidth = width - getButtonSpaceWidth() - leftMargin;
         String text = SwingUtilities2.clipStringIfNecessary(null, fm, title, availableWidth);
         int textWidth = fm.stringWidth(text);
@@ -313,48 +306,60 @@ public class DefaultFrameDecoration extends FullFrameDecorationHelper {
                 (HEIGHT - fm.getHeight()) / 2 + fm.getAscent());
     }
 
-    private void paintButtonBackground(Graphics2D g, Point center, ButtonState state) {
-        if (isActive()) {
+    private void paintCloseButtonBackground(Graphics2D g, Rectangle bounds, ButtonState state) {
+        if (!isActive() && !state.hovered && !state.pressed) return;
+
+        g.setColor(state.pressed ? getClosePressedBackground() :
+                   state.hovered ? getCloseHoveredBackground(isActive()) : getIconBackground());
+        g.fill(new Ellipse2D.Float(bounds.x, bounds.y, bounds.width, bounds.height));
+    }
+
+    private void paintButtonBackground(Graphics2D g, Rectangle bounds, ButtonState state) {
+        if (state.hovered || state.pressed) {
             g.setColor(state.pressed ? getIconPressedBackground() :
                     state.hovered ? getIconHoveredBackground() : getIconBackground());
-            g.fill(new Ellipse2D.Float(center.x - BUTTON_CIRCLE_RADIUS + .5f,
-                    center.y - BUTTON_CIRCLE_RADIUS + .5f,
-                    2 * BUTTON_CIRCLE_RADIUS, 2 * BUTTON_CIRCLE_RADIUS));
+            g.fill(new Ellipse2D.Float(bounds.x, bounds.y, bounds.width, bounds.height));
         }
     }
 
-    private void paintCloseButton(Graphics2D g, Point center, Color foregroundColor) {
+    private static Point centerOf(Rectangle rect) {
+        return new Point((int) Math.floor(rect.x + rect.width / 2f),
+                (int) Math.floor(rect.y + rect.height / 2f));
+    }
+
+    private void paintCloseButton(Graphics2D g, Rectangle bounds, Color foregroundColor) {
         g.setColor(foregroundColor);
+        Point center = centerOf(bounds);
         g.drawLine(center.x - BUTTON_ICON_SIZE, center.y - BUTTON_ICON_SIZE,
                 center.x + BUTTON_ICON_SIZE, center.y + BUTTON_ICON_SIZE);
         g.drawLine(center.x - BUTTON_ICON_SIZE, center.y + BUTTON_ICON_SIZE,
                 center.x + BUTTON_ICON_SIZE, center.y - BUTTON_ICON_SIZE);
     }
 
-    private void paintMaximizeButton(Graphics2D g, Point center, Color foregroundColor) {
+    private void paintMaximizeButton(Graphics2D g, Rectangle bounds, Color foregroundColor) {
         g.setColor(foregroundColor);
+        Point center = centerOf(bounds);
+        int size = BUTTON_ICON_SIZE + 1;
         if (peer.getState() == Frame.MAXIMIZED_BOTH) {
-            g.drawLine(center.x - BUTTON_ICON_SIZE, center.y,
-                    center.x, center.y - BUTTON_ICON_SIZE);
-            g.drawLine(center.x, center.y - BUTTON_ICON_SIZE,
-                    center.x + BUTTON_ICON_SIZE, center.y);
-            g.drawLine(center.x - BUTTON_ICON_SIZE, center.y,
-                    center.x, center.y + BUTTON_ICON_SIZE);
-            g.drawLine(center.x, center.y + BUTTON_ICON_SIZE,
-                    center.x + BUTTON_ICON_SIZE, center.y);
+            g.drawLine(center.x - size, center.y, center.x, center.y - size);
+            g.drawLine(center.x, center.y - size, center.x + size, center.y);
+            g.drawLine(center.x - size, center.y, center.x, center.y + size);
+            g.drawLine(center.x, center.y + size, center.x + size, center.y);
         } else {
-            g.drawLine(center.x - BUTTON_ICON_SIZE, center.y + BUTTON_ICON_SIZE / 2,
-                    center.x, center.y - BUTTON_ICON_SIZE / 2);
-            g.drawLine(center.x, center.y - BUTTON_ICON_SIZE / 2,
-                    center.x + BUTTON_ICON_SIZE, center.y + BUTTON_ICON_SIZE / 2);
+            g.drawLine(center.x - size, (int) (center.y + size / 2f),
+                    center.x, (int) (center.y - size / 2f));
+            g.drawLine(center.x, (int) (center.y - size / 2f),
+                    center.x + size, (int) (center.y + size / 2f));
         }
     }
 
-    private void paintMinimizeButton(Graphics2D g, Point center, Color foregroundColor) {
+    private void paintMinimizeButton(Graphics2D g, Rectangle bounds, Color foregroundColor) {
         g.setColor(foregroundColor);
-        g.drawLine(center.x - BUTTON_ICON_SIZE, center.y - BUTTON_ICON_SIZE / 2,
-                center.x, center.y + BUTTON_ICON_SIZE / 2);
-        g.drawLine(center.x, center.y + BUTTON_ICON_SIZE / 2,
-                center.x + BUTTON_ICON_SIZE, center.y -  BUTTON_ICON_SIZE / 2);
+        Point center = centerOf(bounds);
+        int size = BUTTON_ICON_SIZE + 1;
+        g.drawLine(center.x - size, (int) (center.y - size / 2f),
+                center.x, (int) (center.y + size / 2f));
+        g.drawLine(center.x, (int) (center.y + size / 2f),
+                center.x + size, (int) (center.y - size / 2f));
     }
 }

src/java.desktop/unix/classes/sun/awt/wl/GtkFrameDecoration.java

@@ -76,8 +76,10 @@ public class GtkFrameDecoration extends FullFrameDecorationHelper {
     @Override
     public void paint(Graphics g) {
         // Determine buttons' bounds, etc.
-        nativePrePaint(nativePtr, peer.getWidth());
-        super.paint(g);
+        nativePrePaint(nativePtr, peer.getWidth(), peer.getHeight());
+        if (peer.getWidth() >= titleBarMinWidth && peer.getHeight() >= titleBarHeight) {
+            super.paint(g);
+        }
     }
 
     @Override
@@ -85,6 +87,9 @@ public class GtkFrameDecoration extends FullFrameDecorationHelper {
         int width = peer.getWidth();
         int height = titleBarHeight;
 
+        assert width >= titleBarMinWidth;
+        assert peer.getHeight() >= titleBarHeight;
+
         double scale = ((WLGraphicsConfig) peer.getGraphicsConfiguration()).getEffectiveScale();
         g2d.setBackground(new Color(0, true));
         g2d.clearRect(0, 0, width, height);
@@ -217,5 +222,5 @@ public class GtkFrameDecoration extends FullFrameDecorationHelper {
                                             String title, int buttonsState);
     private native int nativeGetIntProperty(long nativePtr, String name);
     private native void nativeNotifyConfigured(long nativePtr, boolean active, boolean maximized, boolean fullscreen);
-    private native void nativePrePaint(long nativePtr, int width);
+    private native void nativePrePaint(long nativePtr, int width, int height);
 }

src/java.desktop/unix/classes/sun/awt/wl/WLComponentPeer.java

@@ -88,8 +88,8 @@ public class WLComponentPeer implements ComponentPeer, WLSurfaceSizeListener {
     private static final PlatformLogger focusLog = PlatformLogger.getLogger("sun.awt.wl.focus.WLComponentPeer");
     private static final PlatformLogger popupLog = PlatformLogger.getLogger("sun.awt.wl.popup.WLComponentPeer");
 
-    private static final int MINIMUM_WIDTH = 1;
-    private static final int MINIMUM_HEIGHT = 1;
+    protected static final int MINIMUM_WIDTH = 1;
+    protected static final int MINIMUM_HEIGHT = 1;
 
     private final Object stateLock = new Object();
 
@@ -135,7 +135,12 @@ public class WLComponentPeer implements ComponentPeer, WLSurfaceSizeListener {
             log.fine("WLComponentPeer: target=" + target + " with size=" + wlSize);
         }
 
-        shadow = new Shadow(targetIsWlPopup() ? ShadowImage.POPUP_SHADOW_SIZE : ShadowImage.WINDOW_SHADOW_SIZE);
+        boolean shadowEnabled = Boolean.parseBoolean(System.getProperty("sun.awt.wl.Shadow", "true"));
+        if (shadowEnabled) {
+            shadow = new ShadowImpl(targetIsWlPopup() ? ShadowImage.POPUP_SHADOW_SIZE : ShadowImage.WINDOW_SHADOW_SIZE);
+        } else {
+            shadow = new NilShadow();
+        }
         // TODO
         // setup parent window for target
     }
@@ -263,7 +268,7 @@ public class WLComponentPeer implements ComponentPeer, WLSurfaceSizeListener {
         return false;
     }
 
-    private static Window getToplevelFor(Component component) {
+    public static Window getToplevelFor(Component component) {
         Container container = component instanceof Container c ? c : component.getParent();
         for (Container p = container; p != null; p = p.getParent()) {
             if (p instanceof Window window && !isWlPopup(window)) {
@@ -280,7 +285,7 @@ public class WLComponentPeer implements ComponentPeer, WLSurfaceSizeListener {
                 : c.getParent();
     }
 
-    static Point getRelativeLocation(Component c, Window toplevel) {
+    public static Point getRelativeLocation(Component c, Window toplevel) {
         Objects.requireNonNull(c);
 
         if (toplevel == null) {
@@ -852,8 +857,10 @@ public class WLComponentPeer implements ComponentPeer, WLSurfaceSizeListener {
     }
 
     public Dimension getMinimumSize() {
-        int shadowSize = (int) Math.ceil(shadow.getSize() * 4);
-        return new Dimension(shadowSize, shadowSize);
+        int shadowSize = shadow != null ? (int) Math.ceil(shadow.getSize() * 4) : 0;
+        return shadowSize == 0
+                ? new Dimension(MINIMUM_WIDTH, MINIMUM_HEIGHT)
+                : new Dimension(shadowSize, shadowSize);
     }
 
     void showWindowMenu(long serial, int x, int y) {
@@ -1583,7 +1590,7 @@ public class WLComponentPeer implements ComponentPeer, WLSurfaceSizeListener {
      * Converts a value in the Java coordinate system into the Wayland
      * surface-local coordinate system.
      */
-    int javaUnitsToSurfaceUnits(int value) {
+    public final int javaUnitsToSurfaceUnits(int value) {
         if (!WLGraphicsEnvironment.isDebugScaleEnabled()) {
             return value;
         } else {
@@ -1593,7 +1600,7 @@ public class WLComponentPeer implements ComponentPeer, WLSurfaceSizeListener {
         }
     }
 
-    int javaUnitsToSurfaceSize(int value) {
+    public final int javaUnitsToSurfaceSize(int value) {
         if (!WLGraphicsEnvironment.isDebugScaleEnabled()) {
             return value;
         } else {
@@ -1611,6 +1618,14 @@ public class WLComponentPeer implements ComponentPeer, WLSurfaceSizeListener {
         return new Dimension(javaUnitsToSurfaceSize(d.width), javaUnitsToSurfaceSize(d.height));
     }
 
+    int javaUnitsToBufferUnits(int value) {
+        return (int) Math.floor(value * effectiveScale);
+    }
+
+    int javaSizeToBufferSize(int value) {
+        return (int) Math.ceil(value * effectiveScale);
+    }
+
     /**
      * Converts a point in the device (screen) space into coordinates on this surface
      */
@@ -1741,9 +1756,12 @@ public class WLComponentPeer implements ComponentPeer, WLSurfaceSizeListener {
 
     private Dimension constrainSize(int width, int height) {
         Dimension maxBounds = getMaxBufferBounds();
+        Dimension minSize = getMinimumSize();
+        minSize.width = Math.max(MINIMUM_WIDTH, minSize.width);
+        minSize.height = Math.max(MINIMUM_HEIGHT, minSize.height);
         return new Dimension(
-                Math.max(Math.min(width, maxBounds.width), MINIMUM_WIDTH),
-                Math.max(Math.min(height, maxBounds.height), MINIMUM_HEIGHT));
+                Math.max(Math.min(width, maxBounds.width), minSize.width),
+                Math.max(Math.min(height, maxBounds.height), minSize.height));
     }
 
     private Dimension constrainSize(Dimension bounds) {
@@ -1812,6 +1830,20 @@ public class WLComponentPeer implements ComponentPeer, WLSurfaceSizeListener {
         return result;
     }
 
+    private interface Shadow {
+        int getSize();
+        void updateSurfaceSize();
+        void resizeToParentWindow();
+        void createSurface();
+        void commitSurface();
+        void dispose();
+        void hide();
+        void updateSurfaceData();
+        void paint();
+        void commitSurfaceData();
+        void notifyConfigured(boolean active, boolean maximized, boolean fullscreen);
+    }
+
     private static class ShadowImage {
         private static final Color activeColor = new Color(0, 0, 0, 0xA0);
         private static final Color inactiveColor = new Color(0, 0, 0, 0x40);
@@ -1916,7 +1948,7 @@ public class WLComponentPeer implements ComponentPeer, WLSurfaceSizeListener {
         }
     }
 
-    private class Shadow implements WLSurfaceSizeListener {
+    private class ShadowImpl implements WLSurfaceSizeListener, Shadow {
         private WLSubSurface shadowSurface; // protected by AWT lock
         private SurfaceData shadowSurfaceData;  // protected by AWT lock
         private boolean needsRepaint = true;  // protected by AWT lock
@@ -1924,7 +1956,7 @@ public class WLComponentPeer implements ComponentPeer, WLSurfaceSizeListener {
         private final WLSize shadowWlSize = new WLSize(); // protected by stateLock
         private boolean isActive;  // protected by AWT lock
 
-        public Shadow(int shadowSize) {
+        public ShadowImpl(int shadowSize) {
             this.shadowSize = shadowSize;
             shadowWlSize.deriveFromJavaSize(wlSize.getJavaWidth() + shadowSize * 2, wlSize.getJavaHeight() + shadowSize * 2);
             shadowSurfaceData = ((WLGraphicsConfig) getGraphicsConfiguration()).createSurfaceData(this, shadowWlSize.getPixelWidth(), shadowWlSize.getPixelHeight());
@@ -2039,6 +2071,20 @@ public class WLComponentPeer implements ComponentPeer, WLSurfaceSizeListener {
         }
     }
 
+    private static class NilShadow implements Shadow {
+        @Override public int getSize() { return 0; }
+        @Override public void updateSurfaceSize() { }
+        @Override public void resizeToParentWindow() { }
+        @Override public void createSurface() { }
+        @Override public void commitSurface() { }
+        @Override public void dispose() { }
+        @Override public void hide() { }
+        @Override public void updateSurfaceData() { }
+        @Override public void paint() { }
+        @Override public void commitSurfaceData() { }
+        @Override public void notifyConfigured(boolean active, boolean maximized, boolean fullscreen) { }
+    }
+
     private class WLSize {
         /**
          * Represents the full size of the component in "client" units as returned by Component.getSize().

src/java.desktop/unix/classes/sun/awt/wl/WLDataDevice.java

@@ -88,7 +88,8 @@ public class WLDataDevice {
     private static native void dispatchDataSourceQueueImpl(long nativePtr);
     private static native void setSelectionImpl(int protocol, long nativePtr, long dataOfferNativePtr, long serial);
     private static native void startDragImpl(long nativePtr, long dataOfferNativePtr,
-                                             long originSurfaceNativePtr, long iconNativePtr, long serial);
+                                             long originSurfaceNativePtr, long serial);
+    private static native void performDeletionsOnEDTImpl(long nativePtr);
 
     public boolean isProtocolSupported(int protocol) {
         return isProtocolSupportedImpl(nativePtr, protocol);
@@ -98,8 +99,8 @@ public class WLDataDevice {
         setSelectionImpl(protocol, nativePtr, (source == null) ? 0 : source.getNativePtr(), serial);
     }
 
-    public void startDrag(WLDataSource source, long originSurfaceNativePtr, long iconNativePtr, long serial) {
-        startDragImpl(nativePtr, source.getNativePtr(), originSurfaceNativePtr, iconNativePtr, serial);
+    public void startDrag(WLDataSource source, long originSurfaceNativePtr, long serial) {
+        startDragImpl(nativePtr, source.getNativePtr(), originSurfaceNativePtr, serial);
     }
 
     public WLClipboard getSystemClipboard() {
@@ -246,6 +247,10 @@ public class WLDataDevice {
         return result;
     }
 
+    public void performDeletionsOnEDT() {
+        performDeletionsOnEDTImpl(nativePtr);
+    }
+
     // Event handlers, called from native on the EDT
     private void handleDnDEnter(WLDataOffer offer, long serial, long surfacePtr, double x, double y) {
         WLDropTargetContextPeer.getInstance().handleEnter(offer, serial, surfacePtr, x, y);

src/java.desktop/unix/classes/sun/awt/wl/WLDataOffer.java

@@ -61,7 +61,7 @@ public class WLDataOffer {
     }
 
     // after calling destroy(), this object enters an invalid state and needs to be deleted
-    public void destroy() {
+    public synchronized void destroy() {
         if (nativePtr != 0) {
             destroyImpl(nativePtr);
             nativePtr = 0;

src/java.desktop/unix/classes/sun/awt/wl/WLDataSource.java

@@ -25,7 +25,10 @@
 
 package sun.awt.wl;
 
+import java.awt.Graphics2D;
+import java.awt.Image;
 import java.awt.datatransfer.Transferable;
+import java.awt.image.BufferedImage;
 import java.util.HashSet;
 
 public class WLDataSource {
@@ -44,6 +47,8 @@ public class WLDataSource {
 
     private static native void setDnDActionsImpl(long nativePtr, int actions);
 
+    private static native void setDnDIconImpl(long nativePtr, int scale, int width, int height, int offsetX, int offsetY, int[] pixels);
+
     WLDataSource(WLDataDevice dataDevice, int protocol, Transferable data) {
         var wlDataTransferer = (WLDataTransferer) WLDataTransferer.getInstance();
 
@@ -91,6 +96,31 @@ public class WLDataSource {
         setDnDActionsImpl(nativePtr, actions);
     }
 
+    public void setDnDIcon(Image image, int scale, int offsetX, int offsetY) {
+        if (nativePtr == 0) {
+            throw new IllegalStateException("Native pointer is null");
+        }
+
+        int width = image.getWidth(null);
+        int height = image.getHeight(null);
+        int[] pixels = new int[width * height];
+
+        if (image instanceof BufferedImage) {
+            // NOTE: no need to ensure that the BufferedImage is TYPE_INT_ARGB,
+            // getRGB() does pixel format conversion automatically
+            ((BufferedImage) image).getRGB(0, 0, width, height, pixels, 0, width);
+        } else {
+            BufferedImage bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
+            Graphics2D g = bufferedImage.createGraphics();
+            g.drawImage(image, 0, 0, null);
+            g.dispose();
+
+            bufferedImage.getRGB(0, 0, width, height, pixels, 0, width);
+        }
+
+        setDnDIconImpl(nativePtr, scale, width, height, offsetX, offsetY, pixels);
+    }
+
     public synchronized void destroy() {
         if (nativePtr != 0) {
             destroyImpl(nativePtr);

src/java.desktop/unix/classes/sun/awt/wl/WLDecoratedPeer.java

@@ -63,7 +63,7 @@ public abstract class WLDecoratedPeer extends WLWindowPeer {
                 d = new DefaultFrameDecoration(this, showMinimize, showMaximize);
             }
         } else {
-            if (isGTKAvailable()) {
+            if (!WLToolkit.isKDE() && isGTKAvailable()) {
                 d = new GtkFrameDecoration(this, showMinimize, showMaximize);
             } else {
                 d = new DefaultFrameDecoration(this, showMinimize, showMaximize);
@@ -134,10 +134,11 @@ public abstract class WLDecoratedPeer extends WLWindowPeer {
     @Override
     public Dimension getMinimumSize() {
         final Dimension parentMinimumSize = super.getMinimumSize();
-        final Dimension decorMinimumSize = getDecoration().getMinimumSize();
+        var d = getDecoration();
+        final Dimension decorMinimumSize = d != null ? d.getMinimumSize() : new Dimension(0, 0);
         final Dimension frameMinimumSize
                 = (decorMinimumSize.getWidth() == 0 && decorMinimumSize.getHeight() == 0)
-                ? new Dimension(1, 1)
+                ? new Dimension(MINIMUM_WIDTH, MINIMUM_HEIGHT)
                 : decorMinimumSize;
         return new Rectangle(parentMinimumSize)
                 .union(new Rectangle(frameMinimumSize))

src/java.desktop/unix/classes/sun/awt/wl/WLDragSourceContextPeer.java

@@ -92,21 +92,33 @@ public class WLDragSourceContextPeer extends SunDragSourceContextPeer {
         this.dataDevice = dataDevice;
     }
 
-    private long getComponentWlSurfacePtr() {
+    private WLComponentPeer getPeer() {
         var comp = getComponent();
         while (comp != null) {
             var peer = AWTAccessor.getComponentAccessor().getPeer(comp);
             if (peer instanceof WLComponentPeer wlPeer) {
-                return wlPeer.getSurface().getWlSurfacePtr();
+                return wlPeer;
             }
             comp = comp.getParent();
         }
+        return null;
+    }
 
-        return 0;
+    private WLMainSurface getSurface() {
+        WLComponentPeer peer = getPeer();
+        if (peer != null) {
+            return peer.getSurface();
+        }
+        return null;
     }
 
     @Override
     protected void startDrag(Transferable trans, long[] formats, Map<Long, DataFlavor> formatMap) {
+        var mainSurface = getSurface();
+        if (mainSurface == null) {
+            return;
+        }
+
         // formats and formatMap are unused, because WLDataSource already references the same DataTransferer singleton
         var source = new WLDragSource(trans);
 
@@ -115,10 +127,17 @@ public class WLDragSourceContextPeer extends SunDragSourceContextPeer {
 
         source.setDnDActions(waylandActions);
 
+        var dragImage = getDragImage();
+        if (dragImage != null) {
+            var dragImageOffset = getDragImageOffset();
+            source.setDnDIcon(dragImage,
+                    mainSurface.getGraphicsDevice().getDisplayScale(),
+                    dragImageOffset.x, dragImageOffset.y);
+        }
+
         long eventSerial = WLToolkit.getInputState().pointerButtonSerial();
 
-        var wlSurface = getComponentWlSurfacePtr();
-        dataDevice.startDrag(source, wlSurface, 0, eventSerial);
+        dataDevice.startDrag(source, mainSurface.getWlSurfacePtr(), eventSerial);
     }
 
     @Override

src/java.desktop/unix/classes/sun/awt/wl/WLFramePeer.java

@@ -26,6 +26,7 @@
 package sun.awt.wl;
 
 import java.awt.*;
+import java.awt.event.WindowAdapter;
 import java.awt.event.WindowEvent;
 import java.awt.peer.FramePeer;
 import sun.awt.AWTAccessor;
@@ -42,6 +43,12 @@ public class WLFramePeer extends WLDecoratedPeer implements FramePeer {
         super(target, target.isUndecorated(),
                 Toolkit.getDefaultToolkit().isFrameStateSupported(Frame.ICONIFIED),
                 Toolkit.getDefaultToolkit().isFrameStateSupported(Frame.MAXIMIZED_BOTH));
+        AWTAccessor.getWindowAccessor().addWindowListener(target, new WindowAdapter() {
+            @Override
+            public void windowClosing(WindowEvent e) {
+                getFrame().removeNotify();
+            }
+        });
     }
 
     @Override

src/java.desktop/unix/classes/sun/awt/wl/WLGraphicsConfig.java

@@ -38,35 +38,9 @@ import sun.java2d.wl.WLSurfaceSizeListener;
 
 public abstract class WLGraphicsConfig extends GraphicsConfiguration {
     private final WLGraphicsDevice device;
-    private final int x;
-    private final int y;
-    private final int xLogical; // logical (scaled) horizontal location; optional, could be zero
-    private final int yLogical; // logical (scaled) vertical location; optional, could be zero
-    private final int width;
-    private final int height;
-    private final int widthLogical; // logical (scaled) width; optional, could be zero
-    private final int heightLogical;// logical (scaled) height; optional, could be zero
-    private final int displayScale; // as reported by Wayland
-    private final double effectiveScale; // as enforced by Java
 
-    protected WLGraphicsConfig(WLGraphicsDevice device, int x, int y, int xLogical, int yLogical,
-                               int width, int height, int widthLogical, int heightLogical,
-                               int displayScale) {
+    protected WLGraphicsConfig(WLGraphicsDevice device) {
         this.device = device;
-        this.x = x;
-        this.y = y;
-        this.xLogical = xLogical;
-        this.yLogical = yLogical;
-        this.width = width;
-        this.height = height;
-        this.widthLogical = widthLogical;
-        this.heightLogical = heightLogical;
-        this.displayScale = displayScale;
-        this.effectiveScale = WLGraphicsEnvironment.effectiveScaleFrom(displayScale);
-    }
-
-    boolean differsFrom(int width, int height, int scale) {
-        return width != this.width || height != this.height || scale != this.displayScale;
     }
 
     @Override
@@ -84,7 +58,7 @@ public abstract class WLGraphicsConfig extends GraphicsConfiguration {
 
     @Override
     public AffineTransform getDefaultTransform() {
-        double scale = effectiveScale;
+        double scale = device.getEffectiveScale();
         return AffineTransform.getScaleInstance(scale, scale);
     }
 
@@ -97,20 +71,18 @@ public abstract class WLGraphicsConfig extends GraphicsConfiguration {
 
     @Override
     public Rectangle getBounds() {
-        return (widthLogical > 0 && heightLogical > 0)
-                ? new Rectangle(xLogical, yLogical, widthLogical, heightLogical)
-                : new Rectangle(x, y, width, height);
+        return device.getBounds();
     }
 
     public Rectangle getRealBounds() {
-        return new Rectangle(x, y, width, height);
+        return device.getRealBounds();
     }
 
     /**
      * Returns the preferred Wayland buffer scale for this display configuration.
      */
     public int getDisplayScale() {
-        return displayScale;
+        return device.getDisplayScale();
     }
 
     /**
@@ -118,7 +90,7 @@ public abstract class WLGraphicsConfig extends GraphicsConfiguration {
      * if overridden with the sun.java2d.uiScale system property.
      */
     public double getEffectiveScale() {
-       return effectiveScale;
+       return device.getEffectiveScale();
     }
 
     public abstract SurfaceType getSurfaceType();
@@ -127,6 +99,7 @@ public abstract class WLGraphicsConfig extends GraphicsConfiguration {
 
     @Override
     public String toString() {
-        return String.format("%dx%d@(%d, %d) %dx scale", width, height, x, y, displayScale);
+        Rectangle bounds = getBounds();
+        return String.format("%dx%d@(%d, %d) %dx scale", bounds.width, bounds.height, bounds.x, bounds.y, getDisplayScale());
     }
 }

src/java.desktop/unix/classes/sun/awt/wl/WLGraphicsDevice.java

@@ -39,15 +39,21 @@ import java.util.HashSet;
 import java.util.Set;
 
 /**
- * Corresponds to Wayland's output and is identified by its wlID and x, y coordinates
- * in the multi-monitor setup. Whenever those change, this device is re-created.
+ * Corresponds to a Wayland output and is identified by its wlID.
+ * Owns all graphics configurations associated with this device.
+ * Encapsulates all the other properties of the output, such as its size
+ * and location in a multi-monitor configuration.
+ * Whenever any of these properties change, they are updated and
+ * the GraphicsConfiguration objects get re-created to let referents know of the change.
  */
 public class WLGraphicsDevice extends GraphicsDevice {
     private static final double MM_IN_INCH = 25.4;
+
     /**
      *  ID of the corresponding wl_output object received from Wayland.
+     *  Only changes when the device gets invalidated.
      */
-    private volatile int wlID; // only changes when the device gets invalidated
+    private volatile int wlID;
 
     /**
      * Some human-readable name of the device that came from Wayland.
@@ -58,75 +64,142 @@ public class WLGraphicsDevice extends GraphicsDevice {
     /**
      * The horizontal location of this device in the multi-monitor configuration.
      */
-    private volatile int x; // only changes when the device gets invalidated
+    private volatile int x;
 
     /**
      * The vertical location of this device in the multi-monitor configuration.
      */
-    private volatile int y; // only changes when the device gets invalidated
+    private volatile int y;
 
-    private volatile int xLogical; // logical (scaled) horizontal location; optional, could be zero
-    private volatile int yLogical; // logical (scaled) vertical location; optional, could be zero
+    /**
+     * Pixel width, mostly for accounting and reporting.
+     */
+    private volatile int width;
 
-    private final int widthMm;
-    private final int heightMm;
+    /**
+     * Pixel height, mostly for accounting and reporting.
+     */
+    private volatile int height;
 
-    // Configs are always the same in size and scale
-    private volatile GraphicsConfiguration[] configs = null;
+    /**
+     * Logical (scaled) width in Java units.
+     */
+    private volatile int widthLogical;
 
-    // The default config is an object from the configs array
-    private volatile WLGraphicsConfig defaultConfig = null;
+    /**
+     * Logical (scaled) height in Java units.
+     */
+    private volatile int heightLogical;
 
-    // Top-level window peers that consider this device as their primary one
-    // and get their graphics configuration from it
+    /**
+     * Width in millimeters.
+     */
+    private volatile int widthMm;
+
+    /**
+     * Height in millimeters.
+     */
+    private volatile int heightMm;
+
+    /**
+     * The device's scale factor as reported by Wayland.
+     * Since it is an integer, it's usually higher than the real fraction scale.
+     */
+    private volatile int displayScale;
+
+    /**
+     * The effective scale factor as determined by Java.
+     */
+    private volatile double effectiveScale;
+
+    private volatile GraphicsConfiguration[] configs;
+    private volatile WLGraphicsConfig defaultConfig; // A reference to the configs array
+
+    /**
+     * Top-level window peers that consider this device as their primary one
+     * and get their graphics configuration from it
+     */
     private final Set<WLComponentPeer> toplevels = new HashSet<>(); // guarded by 'this'
 
-    private WLGraphicsDevice(int id, int x, int y, int xLogical, int yLogical, int widthMm, int heightMm) {
+    private WLGraphicsDevice(int id,
+                             String name,
+                             int x, int y,
+                             int width, int height,
+                             int widthLogical, int heightLogical,
+                             int widthMm, int heightMm,
+                             int displayScale) {
+        assert width > 0 && height > 0;
+        assert widthLogical > 0 && heightLogical > 0;
+        assert widthMm > 0 && heightMm > 0;
+        assert displayScale > 0;
+
         this.wlID = id;
+        this.name = name;
         this.x = x;
         this.y = y;
-        this.xLogical = xLogical;
-        this.yLogical = yLogical;
+        this.width = width;
+        this.height = height;
+        this.widthLogical = widthLogical;
+        this.heightLogical = heightLogical;
         this.widthMm = widthMm;
         this.heightMm = heightMm;
+        this.displayScale = displayScale;
+        this.effectiveScale = WLGraphicsEnvironment.effectiveScaleFrom(displayScale);
+
+        makeGC();
     }
 
-    int getID() {
-        return wlID;
-    }
-
-    void updateConfiguration(String name, int width, int height, int widthLogical, int heightLogical, int scale) {
-        this.name = name;
-
-        WLGraphicsConfig config = defaultConfig;
-        // Note that all configs are of equal size and scale
-        if (config == null || config.differsFrom(width, height, scale)) {
-            GraphicsConfiguration[] newConfigs;
-            WLGraphicsConfig newDefaultConfig;
-            // It is necessary to create a new object whenever config changes as its
-            // identity is used to detect changes in scale, among other things.
-            if (VKEnv.isPresentationEnabled()) {
-                newConfigs = VKEnv.getDevices().flatMap(d -> d.getPresentableGraphicsConfigs().map(
-                        gc -> WLVKGraphicsConfig.getConfig(
-                                gc, this, x, y, xLogical, yLogical, width, height, widthLogical, heightLogical, scale)))
-                        .toArray(WLGraphicsConfig[]::new);
-                newDefaultConfig = (WLGraphicsConfig) newConfigs[0];
-            } else {
-                // TODO: Actually, Wayland may support a lot more shared memory buffer configurations, need to
-                //   subscribe to the wl_shm:format event and get the list from there.
-                newDefaultConfig = WLSMGraphicsConfig.getConfig(this, x, y, xLogical, yLogical, width, height, widthLogical, heightLogical, scale, true);
-                newConfigs = new GraphicsConfiguration[2];
-                newConfigs[0] = newDefaultConfig;
-                newConfigs[1] = WLSMGraphicsConfig.getConfig(this, x, y, xLogical, yLogical, width, height, widthLogical, heightLogical, scale, false);
-            }
-
-            configs = newConfigs;
-            defaultConfig = newDefaultConfig;
+    private void makeGC() {
+        GraphicsConfiguration[] newConfigs;
+        WLGraphicsConfig newDefaultConfig;
+        if (VKEnv.isPresentationEnabled()) {
+            newConfigs = VKEnv.getDevices().flatMap(d -> d.getPresentableGraphicsConfigs().map(
+                            gc -> WLVKGraphicsConfig.getConfig(gc, this)))
+                    .toArray(WLGraphicsConfig[]::new);
+            newDefaultConfig = (WLGraphicsConfig) newConfigs[0];
+        } else {
+            // TODO: Actually, Wayland may support a lot more shared memory buffer configurations, need to
+            //   subscribe to the wl_shm:format event and get the list from there.
+            newDefaultConfig = WLSMGraphicsConfig.getConfig(this, true);
+            newConfigs = new GraphicsConfiguration[2];
+            newConfigs[0] = newDefaultConfig;
+            newConfigs[1] = WLSMGraphicsConfig.getConfig(this, false);
         }
 
+        configs = newConfigs;
+        defaultConfig = newDefaultConfig;
+    }
+
+    void updateConfiguration(String name,
+                             int x, int y,
+                             int width, int height,
+                             int widthLogical, int heightLogical,
+                             int widthMm, int heightMm,
+                             int scale) {
+        assert width > 0 && height > 0;
+        assert widthLogical > 0 && heightLogical > 0;
+        assert widthMm > 0 && heightMm > 0;
+        assert scale > 0;
+
+        this.name = name;
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+        this.widthLogical = widthLogical;
+        this.heightLogical = heightLogical;
+        this.widthMm = widthMm;
+        this.heightMm = heightMm;
+        this.displayScale = scale;
+        this.effectiveScale =  WLGraphicsEnvironment.effectiveScaleFrom(scale);
+
+        // It is necessary to create new config objects whenever this device changes
+        // as GraphicsConfiguration identity is used to detect changes in scale, among other things.
+        makeGC();
+
         // It is important that by the time displayChanged() events are delivered,
         // all the peers on this device had their graphics configuration updated
-        // to refer to the new ones with, perhaps, different scale or resolution.
+        // to refer to the new ones with, perhaps, a different scale or resolution.
         // This affects various BufferStrategy that use volatile images as their buffers.
         notifyToplevels();
     }
@@ -136,47 +209,36 @@ public class WLGraphicsDevice extends GraphicsDevice {
         synchronized (this) {
             toplevelsCopy.addAll(toplevels);
         }
-        int wlOutputID = this.wlID;
-        // NB: each of those peers will likely receive another such notification
-        // from Wayland when it gets the wl_surface::enter event, but the second one
-        // will effectively be a no-op.
-        toplevelsCopy.forEach((peer) -> peer.notifyEnteredOutput(wlOutputID));
+        toplevelsCopy.forEach(WLComponentPeer::checkIfOnNewScreen);
     }
 
     /**
-     * Changes all aspects of this device including its identity to be that of the given
+     * Changes all aspects of this device, including its identity to be that of the given
      * device. Only used for devices that are no longer physically present, but references
      * to which may still exist in the program.
      */
     void invalidate(WLGraphicsDevice similarDevice) {
+        // Note: It is expected that all the surface this device used to host have already received
+        // the 'leave' event and updated their device/graphics configurations accordingly.
         this.wlID = similarDevice.wlID;
-        this.x = similarDevice.x;
-        this.y = similarDevice.y;
-        this.xLogical = similarDevice.xLogical;
-        this.yLogical = similarDevice.yLogical;
-
-        int newScale = similarDevice.getDisplayScale();
-        Rectangle newBounds = similarDevice.defaultConfig.getBounds();
-        Rectangle newRealBounds = similarDevice.defaultConfig.getRealBounds();
-        updateConfiguration(similarDevice.name, newRealBounds.width, newRealBounds.height, newBounds.width, newBounds.height, newScale);
+        updateConfiguration(similarDevice.name,
+                similarDevice.x,
+                similarDevice.y,
+                similarDevice.width,
+                similarDevice.height,
+                similarDevice.widthLogical,
+                similarDevice.heightLogical,
+                similarDevice.widthMm,
+                similarDevice.heightMm,
+                similarDevice.displayScale);
     }
 
     public static WLGraphicsDevice createWithConfiguration(int id, String name,
-                                                           int x, int y, int xLogical, int yLogical,
+                                                           int x, int y,
                                                            int width, int height, int widthLogical, int heightLogical,
                                                            int widthMm, int heightMm,
                                                            int scale) {
-        WLGraphicsDevice device = new WLGraphicsDevice(id, x, y, xLogical, yLogical, widthMm, heightMm);
-        device.updateConfiguration(name, width, height, widthLogical, heightLogical, scale);
-        return device;
-    }
-
-    /**
-     * Compares the identity of this device with the given attributes
-     * and returns true iff the attributes identify the same device.
-     */
-    boolean isSameDeviceAs(int wlID, int x, int y, int xLogical, int yLogical) {
-        return this.wlID == wlID && this.x == x && this.y == y && this.xLogical == xLogical && this.yLogical == yLogical;
+        return new WLGraphicsDevice(id, name, x, y, width, height, widthLogical, heightLogical, widthMm, heightMm, scale);
     }
 
     boolean hasSameNameAs(WLGraphicsDevice otherDevice) {
@@ -207,8 +269,8 @@ public class WLGraphicsDevice extends GraphicsDevice {
     public GraphicsConfiguration[] getConfigurations() {
         // From wayland.xml, wl_output.mode event:
         // "Non-current modes are deprecated. A compositor can decide to only
-        //	advertise the current mode and never send other modes. Clients
-        //	should not rely on non-current modes."
+        // advertise the current mode and never send other modes. Clients
+        // should not rely on non-current modes."
         // So there's always the same set of configs.
         return configs.clone();
     }
@@ -218,8 +280,24 @@ public class WLGraphicsDevice extends GraphicsDevice {
         return defaultConfig;
     }
 
+    int getID() {
+        return wlID;
+    }
+
+    Rectangle getBounds() {
+        return new Rectangle(x, y, widthLogical, heightLogical);
+    }
+
+    Rectangle getRealBounds() {
+        return new Rectangle(x, y, width, height);
+    }
+
     int getDisplayScale() {
-        return defaultConfig.getDisplayScale();
+        return displayScale;
+    }
+
+    double getEffectiveScale() {
+        return effectiveScale;
     }
 
     int getResolution() {
@@ -227,13 +305,6 @@ public class WLGraphicsDevice extends GraphicsDevice {
         return getResolutionX(defaultConfig);
     }
 
-    double getPhysicalResolution() {
-        Rectangle bounds = defaultConfig.getRealBounds();
-        double daigInPixels = Math.sqrt(bounds.width * bounds.width + bounds.height * bounds.height);
-        double diagInMm = Math.sqrt(widthMm * widthMm + heightMm * heightMm);
-        return daigInPixels * MM_IN_INCH / diagInMm;
-    }
-
     double getPhysicalScale() {
         Rectangle bounds = defaultConfig.getRealBounds();
         double daigInPixels = Math.sqrt(bounds.width * bounds.width + bounds.height * bounds.height);
@@ -267,7 +338,7 @@ public class WLGraphicsDevice extends GraphicsDevice {
 
         boolean fsSupported = isFullScreenSupported();
         if (fsSupported && old != null) {
-            // enter windowed mode and restore original display mode
+            // enter windowed mode and restore the original display mode
             exitFullScreenExclusive(old);
         }
 
@@ -311,9 +382,8 @@ public class WLGraphicsDevice extends GraphicsDevice {
     @Override
     public String toString() {
         var config = defaultConfig;
-        return String.format("WLGraphicsDevice: '%s' id=%d at (%d, %d) ((%d, %d) logical) with %s",
-                name, wlID, x, y, xLogical, yLogical,
-                config != null ? config : "<no configs>");
+        return String.format("WLGraphicsDevice: '%s' id=%d at (%d, %d) with %s",
+                name, wlID, x, y, config != null ? config : "<no configs>");
     }
 
     public Insets getInsets() {

src/java.desktop/unix/classes/sun/awt/wl/WLGraphicsEnvironment.java

@@ -26,6 +26,7 @@
 
 package sun.awt.wl;
 
+import java.awt.AWTError;
 import java.awt.Dimension;
 import java.awt.GraphicsConfiguration;
 import java.awt.GraphicsDevice;
@@ -54,6 +55,8 @@ public class WLGraphicsEnvironment extends SunGraphicsEnvironment implements HiD
     private static final boolean debugScaleEnabled;
     private final Dimension totalDisplayBounds = new Dimension();
 
+    private final List<WLGraphicsDevice> devices = new ArrayList<>(5);
+
     @SuppressWarnings("restricted")
     private static void loadAwt() {
         System.loadLibrary("awt");
@@ -94,15 +97,30 @@ public class WLGraphicsEnvironment extends SunGraphicsEnvironment implements HiD
         }
     }
 
+    @Override
+    public GraphicsDevice getDefaultScreenDevice() {
+        synchronized (devices) {
+            if (devices.isEmpty()) {
+                throw new AWTError("no screen devices");
+            }
+            return devices.getFirst();
+        }
+    }
+
+    @Override
+    public synchronized GraphicsDevice[] getScreenDevices() {
+        synchronized (devices) {
+            return devices.toArray(new GraphicsDevice[0]);
+        }
+    }
+
     @Override
     public boolean isDisplayLocal() {
         return true;
     }
 
-    private final List<WLGraphicsDevice> devices = new ArrayList<>(5);
-
     private void notifyOutputConfigured(String name, String make, String model, int wlID,
-                                        int x, int y, int xLogical, int yLogical,
+                                        int x, int y,
                                         int width, int height,
                                         int widthLogical, int heightLogical,
                                         int widthMm, int heightMm,
@@ -110,46 +128,35 @@ public class WLGraphicsEnvironment extends SunGraphicsEnvironment implements HiD
         // Called from native code whenever a new output appears or an existing one changes its properties
         // NB: initially called during WLToolkit.initIDs() on the main thread; later on EDT.
         if (log.isLoggable(Level.FINE)) {
-            log.fine(String.format("Output configured id=%d at (%d, %d) (%d, %d logical) %dx%d (%dx%d logical) %dx scale",
-                    wlID, x, y, xLogical, yLogical, width, height, widthLogical, heightLogical, scale));
+            log.fine(String.format("Output configured id=%d at (%d, %d) %dx%d (%dx%d logical) %dx scale",
+                    wlID, x, y, width, height, widthLogical, heightLogical, scale));
         }
 
-        String humanID =
-                (name != null ? name + " " : "")
-                + (make != null ? make + " " : "")
-                + (model != null ? model : "");
-        synchronized (devices) {
-            boolean newOutput = true;
-            for (int i = 0; i < devices.size(); i++) {
-                final WLGraphicsDevice gd = devices.get(i);
-                if (gd.getID() == wlID) {
-                    newOutput = false;
-                    if (gd.isSameDeviceAs(wlID, x, y, xLogical, yLogical)) {
-                        // These coordinates and the size are not scaled.
-                        gd.updateConfiguration(humanID, width, height, widthLogical, heightLogical, scale);
-                    } else {
-                        final WLGraphicsDevice updatedDevice = WLGraphicsDevice.createWithConfiguration(wlID, humanID,
-                                x, y, xLogical, yLogical, width, height, widthLogical, heightLogical,
-                                widthMm, heightMm, scale);
-                        devices.set(i, updatedDevice);
-                        gd.invalidate(updatedDevice);
-                    }
-                    break;
-                }
-            }
-            if (newOutput) {
-                final WLGraphicsDevice gd = WLGraphicsDevice.createWithConfiguration(wlID, humanID,
-                        x, y, xLogical, yLogical, width, height, widthLogical, heightLogical,
-                        widthMm, heightMm, scale);
-                devices.add(gd);
-            }
-            if (LogDisplay.ENABLED) {
-                double effectiveScale = effectiveScaleFrom(scale);
-                LogDisplay log = newOutput ? LogDisplay.ADDED : LogDisplay.CHANGED;
-                log.log(wlID, (int) (width / effectiveScale) + "x" +  (int) (height / effectiveScale), effectiveScale);
+        // Logical size comes from an optional protocol, so take the data from the main one, if absent
+        if (widthLogical == 0) widthLogical = width;
+        if (heightLogical == 0) heightLogical = height;
+        String humanID = deviceNameFrom(name, make, model);
+
+        WLGraphicsDevice gd = deviceWithID(wlID);
+        if (gd != null) {
+            // Some properties of an existing device have changed; update the existing device and
+            // let all the windows it hosts know about the change.
+            gd.updateConfiguration(humanID, x, y, width, height, widthLogical, heightLogical, widthMm, heightMm, scale);
+        } else {
+            WLGraphicsDevice newGD = WLGraphicsDevice.createWithConfiguration(wlID, humanID,
+                    x, y, width, height, widthLogical, heightLogical,
+                    widthMm, heightMm, scale);
+            synchronized (devices) {
+                devices.add(newGD);
             }
         }
 
+        if (LogDisplay.ENABLED) {
+            double effectiveScale = effectiveScaleFrom(scale);
+            LogDisplay log = (gd == null) ? LogDisplay.ADDED : LogDisplay.CHANGED;
+            log.log(wlID, (int) (width / effectiveScale) + "x" + (int) (height / effectiveScale), effectiveScale);
+        }
+
         updateTotalDisplayBounds();
 
         // Skip notification during the initial configuration events
@@ -158,6 +165,12 @@ public class WLGraphicsEnvironment extends SunGraphicsEnvironment implements HiD
         }
     }
 
+    private static String deviceNameFrom(String name, String make, String model) {
+        return (name != null ? name + " " : "")
+                + (make != null ? make + " " : "")
+                + (model != null ? model : "");
+    }
+
     private WLGraphicsDevice getSimilarDevice(WLGraphicsDevice modelDevice) {
         WLGraphicsDevice similarDevice = devices.isEmpty() ? null : devices.getFirst();
         for (WLGraphicsDevice device : devices) {
@@ -181,47 +194,33 @@ public class WLGraphicsEnvironment extends SunGraphicsEnvironment implements HiD
             log.fine(String.format("Output destroyed id=%d", wlID));
         }
         // NB: id may *not* be that of any output; if so, just ignore this event.
-        synchronized (devices) {
-            final Optional<WLGraphicsDevice> deviceOptional = devices.stream()
-                    .filter(device -> device.getID() == wlID)
-                    .findFirst();
-            if (deviceOptional.isPresent()) {
-                final WLGraphicsDevice destroyedDevice = deviceOptional.get();
-                if (LogDisplay.ENABLED) {
-                    WLGraphicsConfig config = (WLGraphicsConfig) destroyedDevice.getDefaultConfiguration();
-                    Rectangle bounds = config.getBounds();
-                    LogDisplay.REMOVED.log(wlID, bounds.width + "x" +  bounds.height, config.getEffectiveScale());
-                }
-                devices.remove(destroyedDevice);
-                final WLGraphicsDevice similarDevice = getSimilarDevice(destroyedDevice);
-                if (similarDevice != null) destroyedDevice.invalidate(similarDevice);
+        WLGraphicsDevice gd = deviceWithID(wlID);
+        if (gd != null) {
+            if (LogDisplay.ENABLED) {
+                WLGraphicsConfig config = (WLGraphicsConfig) gd.getDefaultConfiguration();
+                Rectangle bounds = config.getBounds();
+                LogDisplay.REMOVED.log(wlID, bounds.width + "x" + bounds.height, config.getEffectiveScale());
             }
+            synchronized (devices) {
+                devices.remove(gd);
+            }
+            final WLGraphicsDevice similarDevice = getSimilarDevice(gd);
+            if (similarDevice != null) gd.invalidate(similarDevice);
         }
 
         updateTotalDisplayBounds();
         displayChanged();
     }
 
-    WLGraphicsDevice notifySurfaceEnteredOutput(WLComponentPeer wlComponentPeer, int wlOutputID) {
+    WLGraphicsDevice deviceWithID(int wlOutputID) {
         synchronized (devices) {
             for (WLGraphicsDevice gd : devices) {
                 if (gd.getID() == wlOutputID) {
                     return gd;
                 }
             }
-            return null;
-        }
-    }
-
-    WLGraphicsDevice notifySurfaceLeftOutput(WLComponentPeer wlComponentPeer, int wlOutputID) {
-        synchronized (devices) {
-            for (WLGraphicsDevice gd : devices) {
-                if (gd.getID() == wlOutputID) {
-                    return gd;
-                }
-            }
-            return null;
         }
+        return null;
     }
 
     public Dimension getTotalDisplayBounds() {
@@ -231,17 +230,15 @@ public class WLGraphicsEnvironment extends SunGraphicsEnvironment implements HiD
     }
 
     private void updateTotalDisplayBounds() {
+        Rectangle virtualBounds = new Rectangle();
         synchronized (devices) {
-            Rectangle virtualBounds = new Rectangle();
-            for (GraphicsDevice gd : devices) {
-                for (GraphicsConfiguration gc : gd.getConfigurations()) {
-                    virtualBounds = virtualBounds.union(gc.getBounds());
-                }
-            }
-            synchronized (totalDisplayBounds) {
-                totalDisplayBounds.setSize(virtualBounds.getSize());
+            for (var gd : devices) {
+                virtualBounds = virtualBounds.union(gd.getBounds());
             }
         }
+        synchronized (totalDisplayBounds) {
+            totalDisplayBounds.setSize(virtualBounds.getSize());
+        }
     }
 
     static double effectiveScaleFrom(int displayScale) {

src/java.desktop/unix/classes/sun/awt/wl/WLMainSurface.java

@@ -67,7 +67,7 @@ public class WLMainSurface extends WLSurface {
         // Called from native code whenever the corresponding wl_surface enters an output (monitor)
         synchronized (devices) {
             final WLGraphicsEnvironment ge = (WLGraphicsEnvironment)WLGraphicsEnvironment.getLocalGraphicsEnvironment();
-            final WLGraphicsDevice gd = ge.notifySurfaceEnteredOutput(peer, wlOutputID);
+            final WLGraphicsDevice gd = ge.deviceWithID(wlOutputID);
             if (gd != null) {
                 devices.add(gd);
             }
@@ -81,7 +81,7 @@ public class WLMainSurface extends WLSurface {
         // Called from native code whenever the corresponding wl_surface leaves an output (monitor)
         synchronized (devices) {
             final WLGraphicsEnvironment ge = (WLGraphicsEnvironment)WLGraphicsEnvironment.getLocalGraphicsEnvironment();
-            final WLGraphicsDevice gd = ge.notifySurfaceLeftOutput(peer, wlOutputID);
+            final WLGraphicsDevice gd = ge.deviceWithID(wlOutputID);
             if (gd != null) {
                 devices.remove(gd);
             }

src/java.desktop/unix/classes/sun/awt/wl/WLMouseInfoPeer.java

@@ -24,11 +24,16 @@
  */
 package sun.awt.wl;
 
+import sun.awt.SunToolkit;
+
 import java.awt.Point;
 import java.awt.Window;
 import java.awt.peer.MouseInfoPeer;
 
-public class WLMouseInfoPeer implements MouseInfoPeer  {
+public class WLMouseInfoPeer implements MouseInfoPeer, SunToolkit.RelativePointerMovementInfoProvider {
+    private final Object mouseDeltaLock = new Object();
+    private double mouseDeltaX = 0.0;
+    private double mouseDeltaY = 0.0;
 
     @Override
     public int fillPointWithCoords(Point point) {
@@ -55,4 +60,23 @@ public class WLMouseInfoPeer implements MouseInfoPeer  {
         return HOLDER.instance;
     }
 
+    void accumulatePointerDelta(double dx, double dy) {
+        synchronized (mouseDeltaLock) {
+            mouseDeltaX += dx;
+            mouseDeltaY += dy;
+        }
+    }
+
+    @Override
+    public Point getAccumulatedMouseDeltaAndReset() {
+        var p = new Point();
+        synchronized (mouseDeltaLock) {
+            int idx = (int) mouseDeltaX;
+            int idy = (int) mouseDeltaY;
+            p.setLocation(idx, idy);
+            mouseDeltaX = mouseDeltaX - idx;
+            mouseDeltaY = mouseDeltaY - idy;
+        }
+        return p;
+    }
 }

src/java.desktop/unix/classes/sun/awt/wl/WLRoundedCornersManager.java

@@ -52,7 +52,8 @@ public class WLRoundedCornersManager implements RoundedCornersManager {
 
     public static int roundCornerRadiusFor(RoundedCornerKind kind) {
         return switch (kind) {
-            case DEFAULT, FULL -> 24;
+            case DEFAULT -> 12;
+            case FULL -> 24;
             case NONE -> 0;
             case SMALL -> 8;
         };

src/java.desktop/unix/classes/sun/awt/wl/WLSMGraphicsConfig.java

@@ -58,36 +58,16 @@ public class WLSMGraphicsConfig extends WLGraphicsConfig
     private final ColorModel colorModel;
     private final SurfaceType surfaceType;
 
-    private WLSMGraphicsConfig(WLGraphicsDevice device,
-                               int x,
-                               int y,
-                               int xLogical,
-                               int yLogical,
-                               int width,
-                               int height,
-                               int widthLogical,
-                               int heightLogical,
-                               int scale,
-                               boolean translucencyCapable) {
-        super(device, x, y, xLogical, yLogical, width, height, widthLogical, heightLogical, scale);
+    private WLSMGraphicsConfig(WLGraphicsDevice device, boolean translucencyCapable) {
+        super(device);
         this.translucencyCapable = translucencyCapable;
         this.colorModel = colorModelFor(translucencyCapable ? Transparency.TRANSLUCENT : Transparency.OPAQUE);
         // Note: GNOME Shell definitely expects alpha values to be pre-multiplied
         this.surfaceType = translucencyCapable ? SurfaceType.IntArgbPre : SurfaceType.IntRgb;
     }
 
-    public static WLSMGraphicsConfig getConfig(WLGraphicsDevice device,
-                                               int x,
-                                               int y,
-                                               int xLogical,
-                                               int yLogical,
-                                               int width,
-                                               int height,
-                                               int widthLogical,
-                                               int heightLogical,
-                                               int scale,
-                                               boolean translucencyCapable) {
-        var newConfig = new WLSMGraphicsConfig(device, x, y, xLogical, yLogical, width, height, widthLogical, heightLogical, scale, translucencyCapable);
+    public static WLSMGraphicsConfig getConfig(WLGraphicsDevice device, boolean translucencyCapable) {
+        var newConfig = new WLSMGraphicsConfig(device, translucencyCapable);
         if (log.isLoggable(PlatformLogger.Level.FINE)) {
             log.fine("New shared memory config " + newConfig);
         }

src/java.desktop/unix/classes/sun/awt/wl/WLToolkit.java

@@ -35,6 +35,7 @@ import sun.awt.PeerEvent;
 import sun.awt.SunToolkit;
 import sun.awt.UNIXToolkit;
 import sun.awt.datatransfer.DataTransferer;
+import sun.awt.wl.im.WLInputMethodMetaDescriptor;
 import sun.java2d.vulkan.VKEnv;
 import sun.java2d.vulkan.VKRenderQueue;
 import sun.util.logging.PlatformLogger;
@@ -86,6 +87,7 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Properties;
 import java.util.concurrent.Semaphore;
 
@@ -138,6 +140,8 @@ public class WLToolkit extends UNIXToolkit implements Runnable {
 
     private static Boolean sunAwtDisableGtkFileDialogs = null;
 
+    private static final boolean isKDE;
+
     private static native void initIDs(long displayPtr);
 
     static {
@@ -147,6 +151,8 @@ public class WLToolkit extends UNIXToolkit implements Runnable {
             VKEnv.init(display);
             initIDs(display);
         }
+        String desktop = System.getenv("XDG_CURRENT_DESKTOP");
+        isKDE = desktop != null && desktop.toLowerCase().contains("kde");
         initialized = true;
     }
 
@@ -249,6 +255,9 @@ public class WLToolkit extends UNIXToolkit implements Runnable {
                     WLToolkit.awtLock();
                     try {
                         dispatchEventsOnEDT();
+                        if (dataDevice != null) {
+                            dataDevice.performDeletionsOnEDT();
+                        }
                     } finally {
                         eventsQueued.release();
                         WLToolkit.awtUnlock();
@@ -290,6 +299,10 @@ public class WLToolkit extends UNIXToolkit implements Runnable {
     private static WLInputState inputState = WLInputState.initialState();
     private static WLKeyboard keyboard;
 
+    private static void dispatchRelativePointerEvent(double dx, double dy) {
+        WLMouseInfoPeer.getInstance().accumulatePointerDelta(dx, dy);
+    }
+
     private static void dispatchPointerEvent(WLPointerEvent e) {
         // Invoked from the native code
         assert EventQueue.isDispatchThread();
@@ -768,13 +781,27 @@ public class WLToolkit extends UNIXToolkit implements Runnable {
         return 16777216; // 24 bits per pixel, 8 bits per channel
     }
 
+    /**
+     * {@link java.awt.event.InputMethodEvent#getText()} can contain attributes which provide AWT/Swing with additional useful information
+     *   (e.g. a language of the text).
+     *
+     * One kind of the possible attributes is {@link InputMethodHighlight}. It informs AWT/Swing that some parts of
+     *   the text are in different states of the text composing process, hence they should look differently from the others.
+     *   However, it doesn't tell how exactly they should look; this choice is left to Toolkit's implementations,
+     *   or more precisely implementations of this method.
+     *
+     * @param highlight a state of a part of InputMethodEvent's text
+     *
+     * @return a collection of {@link TextAttribute}s (with their corresponding values as documented) informing how exactly
+     *         such text should look or {@code null} if a mapping can't be provided.
+     *
+     * @see Toolkit#mapInputMethodHighlight(InputMethodHighlight)
+     */
     @Override
-    public Map<TextAttribute, ?> mapInputMethodHighlight( InputMethodHighlight highlight) {
-        if (log.isLoggable(PlatformLogger.Level.FINE)) {
-            log.fine("Not implemented: WLToolkit.mapInputMethodHighlight()");
-        }
-        return null;
+    public Map<TextAttribute, ?> mapInputMethodHighlight(InputMethodHighlight highlight) {
+        return WLInputMethodMetaDescriptor.mapInputMethodHighlight(highlight);
     }
+
     @Override
     public boolean getLockingKeyState(int key) {
         return switch (key) {
@@ -834,10 +861,7 @@ public class WLToolkit extends UNIXToolkit implements Runnable {
      */
     @Override
     public InputMethodDescriptor getInputMethodAdapterDescriptor() {
-        if (log.isLoggable(PlatformLogger.Level.FINE)) {
-            log.fine("Not implemented: WLToolkit.getInputMethodAdapterDescriptor()");
-        }
-        return null;
+        return WLInputMethodMetaDescriptor.getInstanceIfAvailableOnPlatform();
     }
 
     /**
@@ -846,9 +870,6 @@ public class WLToolkit extends UNIXToolkit implements Runnable {
      */
     @Override
     public boolean enableInputMethodsForTextComponent() {
-        if (log.isLoggable(PlatformLogger.Level.FINE)) {
-            log.fine("Not implemented: WLToolkit.enableInputMethodsForTextComponent()");
-        }
         return true;
     }
 
@@ -945,17 +966,28 @@ public class WLToolkit extends UNIXToolkit implements Runnable {
 
     @Override
     public void grab(Window w) {
-        if (log.isLoggable(PlatformLogger.Level.FINE)) {
-            log.fine("Not implemented: WLToolkit.grab()");
+        // There is no input grab in Wayland for client applications, only
+        // the compositor can control grabs. But we need UngrabEvent
+        // for popup/tooltip management, so we do input grab accounting here
+        // and in ungrab() below.
+        Objects.requireNonNull(w);
+
+        var peer = AWTAccessor.getComponentAccessor().getPeer(w);
+        if (peer instanceof WLWindowPeer windowPeer) {
+            windowPeer.grab();
         }
     }
 
     @Override
     public void ungrab(Window w) {
-        if (log.isLoggable(PlatformLogger.Level.FINE)) {
-            log.fine("Not implemented: WLToolkit.ungrab()");
+        Objects.requireNonNull(w);
+
+        var peer = AWTAccessor.getComponentAccessor().getPeer(w);
+        if (peer instanceof WLWindowPeer windowPeer) {
+            windowPeer.ungrab(false);
         }
     }
+
     /**
      * Returns if the java.awt.Desktop class is supported on the current
      * desktop.
@@ -1076,4 +1108,7 @@ public class WLToolkit extends UNIXToolkit implements Runnable {
         return WLCursorManager.getInstance();
     }
 
+    public static boolean isKDE() {
+        return isKDE;
+    }
 }

src/java.desktop/unix/classes/sun/awt/wl/WLWindowPeer.java

@@ -25,10 +25,15 @@
 package sun.awt.wl;
 
 import sun.awt.AWTAccessor;
+import sun.awt.SurfacePixelGrabber;
+import sun.awt.UngrabEvent;
 import sun.java2d.SunGraphics2D;
+import sun.java2d.vulkan.VKSurfaceData;
+import sun.java2d.wl.WLSMSurfaceData;
 
 import javax.swing.JRootPane;
 import javax.swing.RootPaneContainer;
+import java.awt.AWTEvent;
 import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Component;
@@ -36,18 +41,21 @@ import java.awt.Dialog;
 import java.awt.Font;
 import java.awt.GraphicsConfiguration;
 import java.awt.Insets;
+import java.awt.Rectangle;
 import java.awt.RenderingHints;
 import java.awt.SystemColor;
 import java.awt.Window;
 import java.awt.event.WindowEvent;
 import java.awt.geom.Path2D;
+import java.awt.image.BufferedImage;
 import java.awt.peer.ComponentPeer;
 import java.awt.peer.WindowPeer;
 import java.lang.ref.WeakReference;
 
-public class WLWindowPeer extends WLComponentPeer implements WindowPeer {
+public class WLWindowPeer extends WLComponentPeer implements WindowPeer, SurfacePixelGrabber {
     private static Font defaultFont;
     private Dialog blocker;
+    private static WLWindowPeer grabbingWindow; // fake, kept for UngrabEvent only
 
     // If this window gets focus from Wayland, we need to transfer focus synthFocusOwner, if any
     private WeakReference<Component> synthFocusOwner = new WeakReference<>(null);
@@ -94,6 +102,8 @@ public class WLWindowPeer extends WLComponentPeer implements WindowPeer {
 
     @Override
     protected void wlSetVisible(boolean v) {
+        if (!v) ungrab(true);
+
         if (v && targetIsWlPopup() && shouldBeFocusedOnShowing()) {
             requestWindowFocus();
         }
@@ -197,6 +207,7 @@ public class WLWindowPeer extends WLComponentPeer implements WindowPeer {
 
     @Override
     public void dispose() {
+        ungrab(true);
         resetCornerMasks();
         super.dispose();
     }
@@ -236,6 +247,91 @@ public class WLWindowPeer extends WLComponentPeer implements WindowPeer {
         synthFocusOwner = new WeakReference<>(c);
     }
 
+    public void grab() {
+        if (grabbingWindow != null && !isGrabbing()) {
+            grabbingWindow.ungrab(false);
+        }
+        grabbingWindow = this;
+    }
+
+    public void ungrab(boolean externalUngrab) {
+        if (isGrabbing()) {
+            grabbingWindow = null;
+            if (externalUngrab) {
+                WLToolkit.postEvent(new UngrabEvent(getTarget()));
+            }
+        }
+    }
+
+    private boolean isGrabbing() {
+        return this == grabbingWindow;
+    }
+
+    @Override
+    void handleJavaWindowFocusEvent(AWTEvent e) {
+        if (e.getID() == WindowEvent.WINDOW_LOST_FOCUS) {
+            ungrab(true);
+        }
+    }
+
+    @Override
+    public BufferedImage getClientAreaSnapshot(int x, int y, int width, int height) {
+        // Move the coordinate system to the client area
+        Insets insets = getInsets();
+        x += insets.left;
+        y += insets.top;
+
+        if (width <= 0 || height <= 0) {
+            return null;
+        }
+        if (x < 0 || y < 0) {
+            // Shouldn't happen, but better avoid accessing surface data outside the range
+            throw new IllegalArgumentException("Negative coordinates are not allowed");
+        }
+        if (x >= getWidth()) {
+            throw new IllegalArgumentException(String.format("x coordinate (%d) is out of bounds (%d)", x, getWidth()));
+        }
+        if (y >= getHeight()) {
+            throw new IllegalArgumentException(String.format("y coordinate (%d) is out of bounds (%d)", y, getHeight()));
+        }
+        if ((long) x + width > getWidth()) {
+            width = getWidth() - x;
+        }
+        if ((long) y + height > getHeight()) {
+            height = getHeight() - y;
+        }
+
+        // At this point the coordinates and size are in Java units;
+        // need to convert them into pixels.
+        Rectangle bounds = new Rectangle(
+                javaUnitsToBufferUnits(x),
+                javaUnitsToBufferUnits(y),
+                javaSizeToBufferSize(width),
+                javaSizeToBufferSize(height)
+        );
+        Rectangle bufferBounds = getBufferBounds();
+        if (bounds.x >= bufferBounds.width) {
+            bounds.x = bufferBounds.width - 1;
+        }
+        if (bounds.y >= bufferBounds.height) {
+            bounds.y = bufferBounds.height - 1;
+        }
+        if (bounds.x + bounds.width > bufferBounds.width) {
+            bounds.width = bufferBounds.width - bounds.x;
+        }
+        if (bounds.y + bounds.height > bufferBounds.height) {
+            bounds.height = bufferBounds.height - bounds.y;
+        }
+
+        if (surfaceData instanceof VKSurfaceData vksd) {
+            return vksd.getSnapshot(bounds.x, bounds.y, bounds.width, bounds.height);
+        } else if (surfaceData instanceof WLSMSurfaceData smsd) {
+            return smsd.getSnapshot(bounds.x, bounds.y, bounds.width, bounds.height);
+        }
+
+        return null;
+    }
+
     private boolean canPaintRoundedCorners() {
         int roundedCornerSize = WLRoundedCornersManager.roundCornerRadiusFor(roundedCornerKind);
         // Note: You would normally get a transparency-capable color model when using

src/java.desktop/unix/classes/sun/awt/wl/im/WLInputMethodMetaDescriptor.java

@@ -0,0 +1,214 @@
+/*
+ * Copyright 2025 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.awt.wl.im;
+
+import sun.awt.wl.im.text_input_unstable_v3.WLInputMethodDescriptorZwpTextInputV3;
+import sun.util.logging.PlatformLogger;
+
+import java.awt.AWTException;
+import java.awt.Image;
+import java.awt.font.TextAttribute;
+import java.awt.im.InputMethodHighlight;
+import java.awt.im.spi.InputMethod;
+import java.awt.im.spi.InputMethodDescriptor;
+import java.util.Arrays;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+
+
+/**
+ * Since Wayland compositors may support multiple IM protocols,
+ *   this class is responsible for choosing one specific among them,
+ *   and the corresponding "real" implementation of {@code InputMethodDescriptor} from a subpackage.
+ */
+public final class WLInputMethodMetaDescriptor implements InputMethodDescriptor {
+    // NB: the class loading routine has to be as fast and not demanding on resources as possible.
+    //     Also, it has to succeed in any practically possible situation.
+    //     E.g. if the Wayland compositor doesn't support any known IM protocol,
+    //     it mustn't prevent this class from being loaded successfully.
+    //     Ideally, nothing additional should happen at the loading time.
+    //
+    //     This class is directly used by WLToolkit to find and instantiate an InputMethod implementation.
+
+    // See java.text.MessageFormat for the formatting syntax
+    private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.wl.im.WLInputMethodMetaDescriptor");
+
+
+    /** @see sun.awt.wl.WLToolkit#mapInputMethodHighlight(InputMethodHighlight) */
+    public static Map<TextAttribute, ?> mapInputMethodHighlight(final InputMethodHighlight highlight) {
+        // NB: The implementation is supposed to produce results exactly equal to XToolkit's implementation
+        //     for better visual consistency.
+
+        if (highlight == null)
+            return null;
+
+        switch (highlight.getState()) {
+            case InputMethodHighlight.RAW_TEXT -> {
+                if (highlight.isSelected())
+                    return imHighlightMapSelectedRawText;
+                else
+                    return imHighlightMapUnselectedRawText;
+            }
+
+            case InputMethodHighlight.CONVERTED_TEXT -> {
+                if (highlight.isSelected())
+                    return imHighlightMapSelectedConvertedText;
+                else
+                    return imHighlightMapUnselectedConvertedText;
+            }
+        }
+
+        return null;
+    }
+
+
+    public static WLInputMethodMetaDescriptor getInstanceIfAvailableOnPlatform() {
+        final WLInputMethodMetaDescriptor result;
+
+        if (!ENABLE_NATIVE_IM_SUPPORT) {
+            result = null;
+        } else {
+            // For now there's only 1 possible implementation of IM,
+            //   but if/when there are more, this method will have to choose one of them.
+            //   It'll be good if the preferable engine can be chosen via a system property.
+
+            final InputMethodDescriptor realImDescriptor = WLInputMethodDescriptorZwpTextInputV3.getInstanceIfAvailableOnPlatform();
+            if (realImDescriptor != null) {
+                result = new WLInputMethodMetaDescriptor(realImDescriptor);
+            } else {
+                result = null;
+            }
+        }
+
+        if (log.isLoggable(PlatformLogger.Level.FINE)) {
+            log.fine("getInstanceIfAvailableOnPlatform(): result={0}, ENABLE_NATIVE_IM_SUPPORT={1}.", result, ENABLE_NATIVE_IM_SUPPORT);
+        }
+
+        return result;
+    }
+
+    /* java.awt.im.spi.InputMethodDescriptor methods section */
+
+    @Override
+    public Locale[] getAvailableLocales() throws AWTException {
+        final Locale[] result = realImDescriptor.getAvailableLocales();
+
+        if (log.isLoggable(PlatformLogger.Level.FINE)) {
+            log.fine("getAvailableLocales(): result={0}, this={1}.", Arrays.toString(result), this);
+        }
+
+        return result;
+    }
+
+    @Override
+    public boolean hasDynamicLocaleList() {
+        final boolean result = realImDescriptor.hasDynamicLocaleList();
+
+        if (log.isLoggable(PlatformLogger.Level.FINE)) {
+            log.fine("hasDynamicLocaleList(): result={0}, this={1}.", result, this);
+        }
+
+        return result;
+    }
+
+    @Override
+    public String getInputMethodDisplayName(Locale inputLocale, Locale displayLanguage) {
+        return realImDescriptor.getInputMethodDisplayName(inputLocale, displayLanguage);
+    }
+
+    @Override
+    public Image getInputMethodIcon(Locale inputLocale) {
+        return realImDescriptor.getInputMethodIcon(inputLocale);
+    }
+
+    @Override
+    public InputMethod createInputMethod() throws Exception {
+        final InputMethod result = realImDescriptor.createInputMethod();
+
+        if (log.isLoggable(PlatformLogger.Level.FINE)) {
+            log.fine("createInputMethod(): result={0}, this={1}.", result, this);
+        }
+
+        return result;
+    }
+
+
+    /* java.lang.Object methods section */
+
+    @Override
+    public String toString() {
+        return String.format("WLInputMethodMetaDescriptor@%d[realImDescriptor=%s]", System.identityHashCode(this), realImDescriptor);
+    }
+
+
+    /* Implementation details section */
+
+    /**
+     * The values are copied from XToolkit's implementation for better visual consistency with AWT on X11.
+     *
+     * @see #mapInputMethodHighlight(InputMethodHighlight)
+     * @see sun.awt.X11InputMethodBase
+     */
+    private final static Map<TextAttribute, ?> imHighlightMapUnselectedRawText = Map.of(
+        TextAttribute.WEIGHT, TextAttribute.WEIGHT_BOLD
+    );
+    private final static Map<TextAttribute, ?> imHighlightMapUnselectedConvertedText = Map.of(
+        TextAttribute.INPUT_METHOD_UNDERLINE, TextAttribute.UNDERLINE_LOW_ONE_PIXEL
+    );
+    private final static Map<TextAttribute, ?> imHighlightMapSelectedRawText = Map.of(
+        TextAttribute.SWAP_COLORS, TextAttribute.SWAP_COLORS_ON
+    );
+    private final static Map<TextAttribute, ?> imHighlightMapSelectedConvertedText = Map.of(
+        TextAttribute.SWAP_COLORS, TextAttribute.SWAP_COLORS_ON
+    );
+
+    /**
+     * This flag allows disabling ALL integrations with native IMs. The idea is to allow users to disable
+     *   unnecessary for them functionality if they face any problems because of it.
+     * Therefore, if it's {@code false}, the Toolkit code shouldn't use (directly or indirectly)
+     *   any of Wayland's input methods-related APIs (e.g. the "text-input" protocol).
+     */
+    private final static boolean ENABLE_NATIVE_IM_SUPPORT;
+
+    static {
+        boolean enableNativeImSupportInitializer = true;
+        try {
+            enableNativeImSupportInitializer = Boolean.parseBoolean(System.getProperty("sun.awt.wl.im.enabled", "true"));
+        } catch (Exception err) {
+            log.severe("Failed to read the value of the system property \"sun.awt.wl.im.enabled\". Assuming the default value(=true).", err);
+        }
+
+        ENABLE_NATIVE_IM_SUPPORT = enableNativeImSupportInitializer;
+    }
+
+
+    private final InputMethodDescriptor realImDescriptor;
+
+    private WLInputMethodMetaDescriptor(InputMethodDescriptor realImDescriptor) {
+        this.realImDescriptor = Objects.requireNonNull(realImDescriptor, "realImDescriptor");
+    }
+}

src/java.desktop/unix/classes/sun/awt/wl/im/text_input_unstable_v3/ChangeCause.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2025 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.awt.wl.im.text_input_unstable_v3;
+
+
+/** Reason for the change of surrounding text or cursor position */
+enum ChangeCause {
+    /** input method caused the change */
+    INPUT_METHOD(0),
+    /** something else than the input method caused the change */
+    OTHER       (1);
+
+    public final int intValue;
+    ChangeCause(int intValue) {
+        this.intValue = intValue;
+    }
+}

src/java.desktop/unix/classes/sun/awt/wl/im/text_input_unstable_v3/ClientComponentCaretPositionTracker.java

@@ -0,0 +1,371 @@
+/*
+ * Copyright 2025 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.awt.wl.im.text_input_unstable_v3;
+
+import sun.util.logging.PlatformLogger;
+
+import javax.swing.event.CaretEvent;
+import javax.swing.event.CaretListener;
+import javax.swing.text.JTextComponent;
+import java.awt.AWTEvent;
+import java.awt.Component;
+import java.awt.EventQueue;
+import java.awt.Rectangle;
+import java.awt.TextComponent;
+import java.awt.event.ComponentEvent;
+import java.awt.event.ComponentListener;
+import java.awt.event.KeyEvent;
+import java.awt.event.MouseEvent;
+import java.awt.event.TextEvent;
+import java.awt.event.TextListener;
+import java.lang.ref.WeakReference;
+import java.util.Objects;
+
+
+/**
+ * This class is intended to track all the cases when a new {@code zwp_text_input_v3::set_cursor_rectangle} request
+ * may have to be issued. Here are the examples of such cases:
+ * <ul>
+ * <li>The caret position has changed ;
+ * <li>The component has been moved/resized ;
+ * <li>The component's window has been moved/resized ;
+ * <li>The component's text has been changed ;
+ * </ul>
+ */
+class ClientComponentCaretPositionTracker implements ComponentListener, CaretListener, TextListener
+{
+    // See java.text.MessageFormat for the formatting syntax
+    private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.wl.im.text_input_unstable_v3.ClientComponentCaretPositionTracker");
+
+
+    public ClientComponentCaretPositionTracker(WLInputMethodZwpTextInputV3 im) {
+        this.im = new WeakReference<>(Objects.requireNonNull(im, "im"));
+    }
+
+
+    public void startTracking(final Component component) {
+        assert(EventQueue.isDispatchThread());
+
+        if (log.isLoggable(PlatformLogger.Level.FINER)) {
+            log.finer(
+                String.format("startTracking(component=%s): im=%s, this=%s.", component, getOwnerIm(), this),
+                new Throwable("Stacktrace")
+            );
+        }
+
+        stopTrackingCurrentComponent();
+
+        if (component == null) {
+            return;
+        }
+
+        trackedComponent = new WeakReference<>(component);
+
+        lastKnownClientWindowBounds = null;
+
+        try {
+            // Moving and changing the size causes a possible change of caret position
+            component.addComponentListener(this);
+
+            if (component instanceof JTextComponent jtc) {
+                jtc.addCaretListener(this);
+                isCaretListenerInstalled = true;
+            } else if (component instanceof TextComponent tc) {
+                tc.addTextListener(this);
+                isTextListenerInstalled = true;
+            }
+
+            if (log.isLoggable(PlatformLogger.Level.FINEST)) {
+                log.finest("startTracking(...): updated this={0}.", this);
+            }
+        } catch (Exception err) {
+            stopTrackingCurrentComponent();
+            throw err;
+        }
+    }
+
+    public void stopTrackingCurrentComponent() {
+        assert(EventQueue.isDispatchThread());
+
+        if (log.isLoggable(PlatformLogger.Level.FINER)) {
+            log.finer(String.format("stopTrackingCurrentComponent(): this=%s.", this), new Throwable("Stacktrace"));
+        }
+
+        final Component trackedComponentStrong = getTrackedComponentIfTracking();
+        if (trackedComponentStrong == null) {
+            return;
+        }
+
+        if (isTextListenerInstalled) {
+            isTextListenerInstalled = false;
+            try {
+                ((TextComponent)trackedComponentStrong).removeTextListener(this);
+            } catch (Exception err) {
+                if (log.isLoggable(PlatformLogger.Level.WARNING)) {
+                    log.warning(String.format("stopTrackingCurrentComponent(): exception occurred while removing the text listener from %s.", trackedComponentStrong), err);
+                }
+            }
+        }
+
+        if (isCaretListenerInstalled) {
+            isCaretListenerInstalled = false;
+            try {
+                ((JTextComponent)trackedComponentStrong).removeCaretListener(this);
+            } catch (Exception err) {
+                if (log.isLoggable(PlatformLogger.Level.WARNING)) {
+                    log.warning(String.format("stopTrackingCurrentComponent(): exception occurred while removing the caret listener from %s.", trackedComponentStrong), err);
+                }
+            }
+        }
+
+        try {
+            trackedComponentStrong.removeComponentListener(this);
+        } catch (Exception err) {
+            if (log.isLoggable(PlatformLogger.Level.WARNING)) {
+                log.warning(String.format("stopTrackingCurrentComponent(): exception occurred while removing the component listener from %s.", trackedComponentStrong), err);
+            }
+        }
+
+        lastKnownClientWindowBounds = null;
+
+        updatesAreDeferred = false;
+
+        if (trackedComponent != null) {
+            trackedComponent.clear();
+            trackedComponent = null;
+        }
+    }
+
+    public Component getTrackedComponentIfTracking() {
+        assert(EventQueue.isDispatchThread());
+
+        final Component trackedComponentStrong;
+        if (trackedComponent == null) {
+            trackedComponentStrong = null;
+        } else {
+            trackedComponentStrong = trackedComponent.get();
+        }
+
+        if (trackedComponentStrong == null) {
+            isTextListenerInstalled = false;
+            isCaretListenerInstalled = false;
+
+            lastKnownClientWindowBounds = null;
+
+            updatesAreDeferred = false;
+
+            if (trackedComponent != null) {
+                trackedComponent.clear();
+                trackedComponent = null;
+            }
+        }
+
+        return trackedComponentStrong;
+    }
+
+
+    public void deferUpdates() {
+        assert(EventQueue.isDispatchThread());
+
+        if (log.isLoggable(PlatformLogger.Level.FINER)) {
+            log.finer(String.format("deferUpdates(): this=%s.", this), new Throwable("Stacktrace"));
+        }
+
+        updatesAreDeferred = true;
+    }
+
+    public void resumeUpdates(final boolean discardDeferredUpdates) {
+        assert(EventQueue.isDispatchThread());
+
+        if (log.isLoggable(PlatformLogger.Level.FINER)) {
+            log.finer(String.format("resumeUpdates(%b): this=%s.", discardDeferredUpdates, this), new Throwable("Stacktrace"));
+        }
+
+        if (getTrackedComponentIfTracking() == null) return;
+
+        updatesAreDeferred = false;
+        hasDeferredUpdates = hasDeferredUpdates && !discardDeferredUpdates;
+
+        if (hasDeferredUpdates) {
+            updateNotify();
+        }
+    }
+
+    public boolean areUpdatesDeferred() {
+        assert(EventQueue.isDispatchThread());
+
+        return updatesAreDeferred;
+    }
+
+
+    /* Listening callbacks */
+
+    /** This method is intended to be called from the owning IM's {@link java.awt.im.spi.InputMethod#dispatchEvent(AWTEvent)}. */
+    public void onIMDispatchEvent(AWTEvent event) {
+        assert(EventQueue.isDispatchThread());
+
+        if (log.isLoggable(PlatformLogger.Level.FINER)) {
+            log.finer("onIMDispatchEvent(event={0}): this={1}.", event, this);
+        }
+
+        final int eventId = event.getID();
+
+        if (eventId >= MouseEvent.MOUSE_FIRST && eventId <= MouseEvent.MOUSE_LAST) {
+            // MouseEvent or MouseWheelEvent
+            if (!isCaretListenerInstalled || eventId == MouseEvent.MOUSE_WHEEL) {
+                // We expect no mouse events except MouseWheelEvent can change the physical position of the caret
+                //   without changing its logical position inside the document. The logical position is handled by caretUpdate.
+
+                // The event hasn't been handled by the component yet, so the caret position couldn't have been changed yet.
+                // Hence, we have to postpone the updating request.
+                EventQueue.invokeLater(this::updateNotify);
+            }
+        }
+
+        if (eventId >= KeyEvent.KEY_FIRST && eventId <= KeyEvent.KEY_LAST) {
+            if ( !isCaretListenerInstalled && (!isTextListenerInstalled || eventId != KeyEvent.KEY_TYPED) ) {
+                EventQueue.invokeLater(this::updateNotify);
+            }
+        }
+    }
+
+    /** This method is intended to be called from the owning IM's {@link java.awt.im.spi.InputMethod#notifyClientWindowChange(Rectangle)}. */
+    public void onIMNotifyClientWindowChange(Rectangle location) {
+        assert(EventQueue.isDispatchThread());
+
+        if (log.isLoggable(PlatformLogger.Level.FINER)) {
+            log.finer("onIMNotifyClientWindowChange(location={0}): this={1}.", location, this);
+        }
+
+        if (location != null) {
+            // null means the window has become iconified or invisible, so no need to try to update the caret position.
+
+            lastKnownClientWindowBounds = location;
+
+            updateNotify();
+        }
+    }
+
+    // ComponentListener
+
+    @Override
+    public void componentHidden(ComponentEvent e) {}
+
+    @Override
+    public void componentMoved(ComponentEvent e) {
+        updateNotify();
+    }
+
+    @Override
+    public void componentResized(ComponentEvent e) {
+        updateNotify();
+    }
+
+    @Override
+    public void componentShown(ComponentEvent e) {
+        updateNotify();
+    }
+
+    // CaretListener
+
+    @Override
+    public void caretUpdate(CaretEvent e) {
+        updateNotify();
+    }
+
+    // TextListener
+
+    @Override
+    public void textValueChanged(TextEvent e) {
+        updateNotify();
+    }
+
+
+    /* java.lang.Object methods section */
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder(1024);
+        sb.append("ClientComponentCaretPositionTracker@").append(System.identityHashCode(this));
+        sb.append('{');
+        sb.append("isCaretListenerInstalled=").append(isCaretListenerInstalled);
+        sb.append(", isTextListenerInstalled=").append(isTextListenerInstalled);
+        sb.append(", lastKnownClientWindowBounds=").append(lastKnownClientWindowBounds);
+        sb.append(", updatesAreDeferred=").append(updatesAreDeferred);
+        sb.append(", hasDeferredUpdates=").append(hasDeferredUpdates);
+        sb.append(", trackedComponent=").append(trackedComponent == null ? "null" : trackedComponent.get());
+        sb.append('}');
+        return sb.toString();
+    }
+
+
+    /* Implementation details */
+
+    private final WeakReference<WLInputMethodZwpTextInputV3> im;
+    private WeakReference<Component> trackedComponent = null;
+    private boolean isCaretListenerInstalled = false;
+    private boolean isTextListenerInstalled = false;
+    private Rectangle lastKnownClientWindowBounds = null;
+    private boolean updatesAreDeferred = false;
+    private boolean hasDeferredUpdates = false;
+
+
+    private WLInputMethodZwpTextInputV3 getOwnerIm() {
+        assert(EventQueue.isDispatchThread());
+
+        final WLInputMethodZwpTextInputV3 thisImStrong;
+        if (this.im == null) {
+            thisImStrong = null;
+        } else {
+            thisImStrong = this.im.get();
+        }
+
+        if (thisImStrong == null) {
+            stopTrackingCurrentComponent();
+        }
+
+        return thisImStrong;
+    }
+
+    private void updateNotify() {
+        if (log.isLoggable(PlatformLogger.Level.FINEST)) {
+            log.finest(String.format("updateNotify(): this=%s.", this), new Throwable("Stacktrace"));
+        }
+
+        if (getTrackedComponentIfTracking() == null) return;
+
+        if (updatesAreDeferred) {
+            hasDeferredUpdates = true;
+            return;
+        }
+        hasDeferredUpdates = false;
+
+        final var imToNotify = getOwnerIm();
+        if (imToNotify != null) {
+            imToNotify.wlUpdateCursorRectangle(false);
+        }
+    }
+}
+

src/java.desktop/unix/classes/sun/awt/wl/im/text_input_unstable_v3/ContentHint.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2025 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.awt.wl.im.text_input_unstable_v3;
+
+
+/** Content hint is a bitmask to allow to modify the behavior of the text input */
+enum ContentHint {
+    /** no special behavior */
+    NONE               (0x0),
+    /** suggest word completions */
+    COMPLETION         (0x1),
+    /** suggest word corrections */
+    SPELLCHECK         (0x2),
+    /** switch to uppercase letters at the start of a sentence */
+    AUTO_CAPITALIZATION(0x4),
+    /** prefer lowercase letters */
+    LOWERCASE          (0x8),
+    /** prefer uppercase letters */
+    UPPERCASE          (0x10),
+    /** prefer casing for titles and headings (can be language dependent) */
+    TITLECASE          (0x20),
+    /** characters should be hidden */
+    HIDDEN_TEXT        (0x40),
+    /** typed text should not be stored */
+    SENSITIVE_DATA     (0x80),
+    /** just Latin characters should be entered */
+    LATIN              (0x100),
+    /** the text input is multiline */
+    MULTILINE          (0x200);
+
+    public final int intMask;
+    ContentHint(int intMask) {
+        this.intMask = intMask;
+    }
+}

src/java.desktop/unix/classes/sun/awt/wl/im/text_input_unstable_v3/ContentPurpose.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2025 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.awt.wl.im.text_input_unstable_v3;
+
+
+/**
+ * The content purpose allows to specify the primary purpose of a text input.
+ * This allows an input method to show special purpose input panels with extra characters or to disallow some characters.
+ */
+enum ContentPurpose {
+    /** default input, allowing all characters */
+    NORMAL  (0),
+    /** allow only alphabetic characters */
+    ALPHA   (1),
+    /** allow only digits */
+    DIGITS  (2),
+    /** input a number (including decimal separator and sign) */
+    NUMBER  (3),
+    /** input a phone number */
+    PHONE   (4),
+    /** input an URL */
+    URL     (5),
+    /** input an email address */
+    EMAIL   (6),
+    /** input a name of a person */
+    NAME    (7),
+    /** input a password (combine with sensitive_data hint) */
+    PASSWORD(8),
+    /** input is a numeric password (combine with sensitive_data hint) */
+    PIN     (9),
+    /** input a date */
+    DATE    (10),
+    /** input a time */
+    TIME    (11),
+    /** input a date and time */
+    DATETIME(12),
+    /** input for a terminal */
+    TERMINAL(13);
+
+    public final int intValue;
+    ContentPurpose(int intValue) {
+        this.intValue = intValue;
+    }
+}

src/java.desktop/unix/classes/sun/awt/wl/im/text_input_unstable_v3/IncomingChanges.java

@@ -0,0 +1,131 @@
+/*
+ * Copyright 2025 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.awt.wl.im.text_input_unstable_v3;
+
+import java.util.Arrays;
+import java.util.Objects;
+
+
+/**
+ * This class accumulates changes received as
+ * {@code zwp_text_input_v3::preedit_string}, {@code zwp_text_input_v3::commit_string} events until
+ * a {@code zwp_text_input_v3::done} event is received.
+ */
+final class IncomingChanges
+{
+    public IncomingChanges updatePreeditString(byte[] newPreeditStringUtf8, int newPreeditStringCursorBeginUtf8Byte, int newPreeditStringCursorEndUtf8Byte) {
+        this.doUpdatePreeditString = true;
+        this.newPreeditStringUtf8 = newPreeditStringUtf8;
+        this.newPreeditStringCursorBeginUtf8Byte = newPreeditStringCursorBeginUtf8Byte;
+        this.newPreeditStringCursorEndUtf8Byte = newPreeditStringCursorEndUtf8Byte;
+        this.cachedResultPreeditString = null;
+
+        return this;
+    }
+
+    /**
+     * @return {@code null} if there are no changes in the preedit string
+     *                      (i.e. {@link #updatePreeditString(byte[], int, int)} hasn't been called);
+     *         an instance of JavaPreeditString otherwise.
+     * @see JavaPreeditString
+     */
+    public JavaPreeditString getPreeditString() {
+        if (cachedResultPreeditString != null) {
+            return cachedResultPreeditString;
+        }
+
+        cachedResultPreeditString = doUpdatePreeditString
+            ? JavaPreeditString.fromWaylandPreeditString(newPreeditStringUtf8, newPreeditStringCursorBeginUtf8Byte, newPreeditStringCursorEndUtf8Byte)
+            : null;
+
+        return cachedResultPreeditString;
+    }
+
+
+    public IncomingChanges updateCommitString(byte[] newCommitStringUtf8) {
+        this.doUpdateCommitString = true;
+        this.newCommitStringUtf8 = newCommitStringUtf8;
+        this.cachedResultCommitString = null;
+
+        return this;
+    }
+
+    /**
+     * @return {@code null} if there are no changes in the commit string
+     *                     (i.e. {@link #updateCommitString(byte[])}  hasn't been called);
+     *         an instance of JavaCommitString otherwise.
+     * @see JavaCommitString
+     */
+    public JavaCommitString getCommitString() {
+        if (cachedResultCommitString != null) {
+            return cachedResultCommitString;
+        }
+
+        cachedResultCommitString = doUpdateCommitString
+            ? JavaCommitString.fromWaylandCommitString(newCommitStringUtf8)
+            : null;
+
+        return cachedResultCommitString;
+    }
+
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == null || getClass() != o.getClass()) return false;
+        IncomingChanges that = (IncomingChanges) o;
+        return doUpdatePreeditString == that.doUpdatePreeditString &&
+               newPreeditStringCursorBeginUtf8Byte == that.newPreeditStringCursorBeginUtf8Byte &&
+               newPreeditStringCursorEndUtf8Byte == that.newPreeditStringCursorEndUtf8Byte &&
+               doUpdateCommitString == that.doUpdateCommitString &&
+               Arrays.equals(newPreeditStringUtf8, that.newPreeditStringUtf8) &&
+               Arrays.equals(newCommitStringUtf8, that.newCommitStringUtf8);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(
+            doUpdatePreeditString,
+            Arrays.hashCode(newPreeditStringUtf8),
+            newPreeditStringCursorBeginUtf8Byte,
+            newPreeditStringCursorEndUtf8Byte,
+            doUpdateCommitString,
+            Arrays.hashCode(newCommitStringUtf8)
+        );
+    }
+
+
+    // zwp_text_input_v3::preedit_string
+    private boolean doUpdatePreeditString = false;
+    private byte[] newPreeditStringUtf8 = null;
+    private int newPreeditStringCursorBeginUtf8Byte = 0;
+    private int newPreeditStringCursorEndUtf8Byte = 0;
+    private JavaPreeditString cachedResultPreeditString = null;
+
+    // zwp_text_input_v3::commit_string
+    private boolean doUpdateCommitString = false;
+    private byte[] newCommitStringUtf8 = null;
+    private JavaCommitString cachedResultCommitString = null;
+}

src/java.desktop/unix/classes/sun/awt/wl/im/text_input_unstable_v3/InputContextState.java

@@ -0,0 +1,199 @@
+/*
+ * Copyright 2025 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.awt.wl.im.text_input_unstable_v3;
+
+import java.awt.Rectangle;
+import java.util.Objects;
+
+
+/**
+ * This class encapsulates the entire state of an input context represented by an instance of {@code zwp_text_input_v3}.
+ *
+ * @see StateOfEnabled
+ */
+final class InputContextState {
+    /** pointer to a native context {@code zwp_text_input_v3} */
+    public final long nativeContextPtr;
+
+
+    public InputContextState(long nativeContextPtr) {
+        assert(nativeContextPtr != 0);
+
+        this.nativeContextPtr = nativeContextPtr;
+    }
+
+
+    /** @return 0 if the input context hasn't entered a surface yet. Otherwise, the native pointer to the surface. */
+    public long getCurrentWlSurfacePtr() {
+        return currentWlSurfacePtr;
+    }
+
+    public void setCurrentWlSurfacePtr(long currentWlSurfacePtr) {
+        this.currentWlSurfacePtr = currentWlSurfacePtr;
+    }
+
+
+    /**
+     * Notifies the InputContext that a set of changes has been sent and committed to the compositor
+     *   via a {@code zwp_text_input_v3::commit} request. The InputContext reacts by incrementing its commit counter.
+     *
+     * @param changes represents the set of changes that have been sent and followed by a 'commit' request.
+     *                Must not be {@code null} (but can be empty, which means only the 'commit' request has been issued).
+     *
+     * @return a new instance of {@link OutgoingBeingCommittedChanges} consisting of
+     *         the passed changes and the new value of the commit counter.
+     *
+     * @throws NullPointerException if {@code changes} is {@code null}.
+     *
+     * @see OutgoingChanges
+     */
+    public OutgoingBeingCommittedChanges syncWithCommittedOutgoingChanges(final OutgoingChanges changes) {
+        Objects.requireNonNull(changes, "changes");
+
+        // zwp_text_input_v3::done natively uses uint32_t for the serial,
+        //   so it can't get greater than 0xFFFFFFFF.
+        this.commitCounter = (this.commitCounter + 1) % 0x100000000L;
+
+        return new OutgoingBeingCommittedChanges(changes, this.commitCounter);
+    }
+
+    public long getCommitCounter() {
+        return commitCounter;
+    }
+
+
+    /**
+     * This class represents the extended state of an {@code InputContextState} that only exists when the context
+     *   is enabled.
+     *
+     * @param textChangeCause the property set via a {@code zwp_text_input_v3::set_text_change_cause} request. Must not be {@code null}.
+     * @param contentHint the property set via a {@code zwp_text_input_v3::set_content_type} request.
+     * @param contentPurpose the property set via a {@code zwp_text_input_v3::set_content_type} request. Must not be {@code null}.
+     * @param cursorRectangle the property set via a {@code zwp_text_input_v3::set_cursor_rectangle} request.
+     *                        {@code null} means "the text input does not support describing the cursor area".
+     */
+    public record StateOfEnabled(
+        // zwp_text_input_v3::set_text_change_cause
+        ChangeCause textChangeCause,
+        // zwp_text_input_v3::set_content_type.hint
+        int contentHint,
+        // zwp_text_input_v3::set_content_type.purpose
+        ContentPurpose contentPurpose,
+        // zwp_text_input_v3::set_cursor_rectangle
+        Rectangle cursorRectangle
+    ) {
+        public StateOfEnabled {
+            Objects.requireNonNull(textChangeCause, "textChangeCause");
+            Objects.requireNonNull(contentPurpose, "contentPurpose");
+        }
+    }
+
+    public StateOfEnabled getCurrentStateOfEnabled() {
+        return stateOfEnabled;
+    }
+
+    public boolean isEnabled() {
+        return getCurrentStateOfEnabled() != null;
+    }
+
+    /**
+     * NB: if you want to call setEnabledState(null), consider using {@code wlHandleContextGotDisabled()} of
+     *     the owning {@link WLInputMethodZwpTextInputV3}.
+     *
+     * @param newState {@code null} to mark the InputContext as disabled,
+     *                 otherwise the InputContext will be marked as enabled and having the state as
+     *                 specified in the parameter.
+     */
+    public void setEnabledState(StateOfEnabled newState) {
+        this.stateOfEnabled = newState;
+    }
+
+
+    public void syncWithAppliedIncomingChanges(final JavaPreeditString appliedPreeditString, final JavaCommitString appliedCommitString, final long doneSerial) {
+        this.latestAppliedPreeditString = Objects.requireNonNull(appliedPreeditString, "appliedPreeditString");
+        this.latestAppliedCommitString = Objects.requireNonNull(appliedCommitString, "appliedCommitString");
+        this.latestDoneSerial = doneSerial;
+    }
+
+    public JavaPreeditString getLatestAppliedPreeditString() {
+        return latestAppliedPreeditString;
+    }
+
+    public JavaCommitString getLatestAppliedCommitString() {
+        return latestAppliedCommitString;
+    }
+
+    public long getLatestDoneSerial() {
+        return latestDoneSerial;
+    }
+
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder(512);
+        sb.append("InputContextState@").append(System.identityHashCode(this));
+        sb.append('{');
+        sb.append("nativeContextPtr=0x").append(Long.toHexString(nativeContextPtr));
+        sb.append(", currentWlSurfacePtr=0x").append(Long.toHexString(currentWlSurfacePtr));
+        sb.append(", commitCounter=").append(commitCounter);
+        sb.append(", latestDoneSerial=").append(latestDoneSerial);
+        sb.append(", stateOfEnabled=").append(stateOfEnabled);
+        sb.append(", latestAppliedPreeditString=").append(latestAppliedPreeditString);
+        sb.append(", latestAppliedCommitString=").append(latestAppliedCommitString);
+        sb.append('}');
+        return sb.toString();
+    }
+
+
+    // zwp_text_input_v3::enter.surface / zwp_text_input_v3::leave.surface
+    private long currentWlSurfacePtr = 0;
+    // zwp_text_input_v3::commit
+    /**
+     * How many times changes to this context have been committed (through {@code zwp_text_input_v3::commit}).
+     * Essentially, it means the most actual version of the context's state.
+     */
+    private long commitCounter = 0;
+    // zwp_text_input_v3::done.serial
+    /**
+     * The {@code serial} parameter of the latest {@code zwp_text_input_v3::done} event received.
+     * Essentially, it means the latest version of the context's state known/confirmed by the compositor.
+     */
+    private long latestDoneSerial = 0;
+    /** {@code null} if the InputContextState is disabled. */
+    private StateOfEnabled stateOfEnabled = null;
+    /**
+     * The latest preedit string applied as a result of the latest {@code zwp_text_input_v3::done} event received.
+     * Must never be {@code null} ; if a {@code zwp_text_input_v3::done} event wasn't preceded by a
+     * {@code zwp_text_input_v3::preedit_string} event, the field should be set to {@link PropertiesInitials#PREEDIT_STRING}.
+     */
+    private JavaPreeditString latestAppliedPreeditString = PropertiesInitials.PREEDIT_STRING;
+    /**
+     * The latest commit string applied as a result of the latest {@code zwp_text_input_v3::done} event received.
+     * Must never be {@code null} ; if a {@code zwp_text_input_v3::done} event wasn't preceded by a
+     * {@code zwp_text_input_v3::commit_string} event, the field should be set to {@link PropertiesInitials#COMMIT_STRING}.
+     */
+    private JavaCommitString latestAppliedCommitString = PropertiesInitials.COMMIT_STRING;
+}

src/java.desktop/unix/classes/sun/awt/wl/im/text_input_unstable_v3/JavaCommitString.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2025 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.awt.wl.im.text_input_unstable_v3;
+
+import java.util.Objects;
+
+record JavaCommitString(String text) {
+    public JavaCommitString {
+        Objects.requireNonNull(text, "text");
+    }
+
+    public static final JavaCommitString EMPTY = new JavaCommitString("");
+
+    /** Never returns {@code null}. */
+    public static JavaCommitString fromWaylandCommitString(byte[] utf8Bytes) {
+        return new JavaCommitString(Utilities.utf8BytesToJavaString(utf8Bytes));
+    }
+}

src/java.desktop/unix/classes/sun/awt/wl/im/text_input_unstable_v3/JavaPreeditString.java

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2025 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.awt.wl.im.text_input_unstable_v3;
+
+import java.util.Objects;
+
+/**
+ * This class represents the result of a conversion of a UTF-8 preedit string received in a
+ * {@code zwp_text_input_v3::preedit_string} event to a Java UTF-16 string.
+ * If {@link #cursorBeginCodeUnit} and/or {@link #cursorEndCodeUnit} point at UTF-16 surrogate pairs,
+ *   they're guaranteed to point at the very beginning of them as long as {@link #fromWaylandPreeditString} is
+ *   used to perform the conversion.
+ * <p>
+ * {@link #fromWaylandPreeditString} never returns {@code null}.
+ * <p>
+ * See the specification of {@code zwp_text_input_v3::preedit_string} event for more info about
+ * cursor_begin, cursor_end values.
+ *
+ * @param text The preedit text string. Mustn't be {@code null} (use an empty string instead).
+ * @param cursorBeginCodeUnit UTF-16 equivalent of {@code preedit_string.cursor_begin}.
+ * @param cursorEndCodeUnit UTF-16 equivalent of {@code preedit_string.cursor_end}.
+ *                          It's not explicitly stated in the protocol specification, but it seems to be a valid
+ *                          situation when cursor_end < cursor_begin, which means
+ *                          the highlight extends to the right from the caret
+ *                          (e.g., when the text gets selected with Shift + Left Arrow).
+ */
+record JavaPreeditString(String text, int cursorBeginCodeUnit, int cursorEndCodeUnit) {
+    public JavaPreeditString {
+        Objects.requireNonNull(text, "text");
+    }
+
+    public static final JavaPreeditString EMPTY = new JavaPreeditString("", 0, 0);
+    public static final JavaPreeditString EMPTY_NO_CARET = new JavaPreeditString("", -1, -1);
+
+    public static JavaPreeditString fromWaylandPreeditString(
+        final byte[] utf8Bytes,
+        final int cursorBeginUtf8Byte,
+        final int cursorEndUtf8Byte
+    ) {
+        // Java's UTF-8 -> UTF-16 conversion doesn't like trailing NUL codepoints, so let's trim them
+        final int utf8BytesWithoutNulLength = Utilities.getLengthOfUtf8BytesWithoutTrailingNULs(utf8Bytes);
+
+        // cursorBeginUtf8Byte, cursorEndUtf8Byte normalized relatively to the valid values range.
+        final int fixedCursorBeginUtf8Byte;
+        final int fixedCursorEndUtf8Byte;
+        if (cursorBeginUtf8Byte < 0 || cursorEndUtf8Byte < 0) {
+            fixedCursorBeginUtf8Byte = fixedCursorEndUtf8Byte = -1;
+        } else {
+            // 0 <= cursorBeginUtf8Byte <= fixedCursorBeginUtf8Byte <= utf8BytesWithoutNulLength
+            fixedCursorBeginUtf8Byte = Math.min(cursorBeginUtf8Byte, utf8BytesWithoutNulLength);
+            // 0 <= cursorEndUtf8Byte <= fixedCursorEndUtf8Byte <= utf8BytesWithoutNulLength
+            fixedCursorEndUtf8Byte = Math.min(cursorEndUtf8Byte, utf8BytesWithoutNulLength);
+        }
+
+        final var resultText = Utilities.utf8BytesToJavaString(utf8Bytes, 0, utf8BytesWithoutNulLength);
+
+        if (fixedCursorBeginUtf8Byte < 0 || fixedCursorEndUtf8Byte < 0) {
+            return new JavaPreeditString(resultText, -1, -1);
+        }
+
+        if (resultText == null) {
+            assert(fixedCursorBeginUtf8Byte == 0);
+            assert(fixedCursorEndUtf8Byte == 0);
+
+            return JavaPreeditString.EMPTY;
+        }
+
+        final String javaPrefixBeforeCursorBegin = (fixedCursorBeginUtf8Byte == 0)
+            ? ""
+            : Utilities.utf8BytesToJavaString(utf8Bytes, 0, fixedCursorBeginUtf8Byte);
+
+        final String javaPrefixBeforeCursorEnd = (fixedCursorEndUtf8Byte == 0)
+            ? ""
+            : Utilities.utf8BytesToJavaString(utf8Bytes, 0, fixedCursorEndUtf8Byte);
+
+        return new JavaPreeditString(
+            resultText,
+            javaPrefixBeforeCursorBegin.length(),
+            javaPrefixBeforeCursorEnd.length()
+        );
+    }
+}

src/java.desktop/unix/classes/sun/awt/wl/im/text_input_unstable_v3/OutgoingBeingCommittedChanges.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2025 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.awt.wl.im.text_input_unstable_v3;
+
+import java.util.Objects;
+
+
+/**
+ * This class is intended to keep changes after they get committed and until they actually get applied.
+ *
+ * @param changeSet changes that have been sent and committed to the compositor,
+ *                  but not yet confirmed by it (via a {@code zwp_text_input_v3::done} event).
+ *                  Must not be {@code null}.
+ * @param commitCounter the number of times a {@code zwp_text_input_v3::commit} request has been issued to
+ *                      the corresponding {@link InputContextState}.
+ *
+ * @see OutgoingChanges
+ */
+record OutgoingBeingCommittedChanges(OutgoingChanges changeSet, long commitCounter) {
+    public OutgoingBeingCommittedChanges {
+        Objects.requireNonNull(changeSet, "changeSet");
+    }
+}

src/java.desktop/unix/classes/sun/awt/wl/im/text_input_unstable_v3/OutgoingChanges.java

@@ -0,0 +1,166 @@
+/*
+ * Copyright 2025 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.awt.wl.im.text_input_unstable_v3;
+
+import java.awt.Rectangle;
+import java.util.Objects;
+
+
+/**
+ * This class is intended to accumulate changes for an {@link InputContextState} until
+ *   they're sent via the set of requests
+ *   {@code zwp_text_input_v3::enable}, {@code zwp_text_input_v3::disable}, {@code zwp_text_input_v3::set_*}
+ *   and commited via {@code zwp_text_input_v3::commit}.
+ * <p>
+ * The reason of having to accumulate changes instead of applying them as soon as they appear is the following
+ * part of the {@code zpw_text_input_v3::done(serial)} event specification:
+ * {@code
+ * When the client receives a done event with a serial different than the number of past commit requests,
+ * it must proceed with evaluating and applying the changes as normal, except it should not change the
+ * current state of the zwp_text_input_v3 object. All pending state requests [...]
+ * on the zwp_text_input_v3 object should be sent and committed after receiving a
+ * zwp_text_input_v3.done event with a matching serial.
+ * }
+ *<p>
+ * All the properties this class includes are nullable where {@code null} means absence of this property change.
+ * In other words, if a property is null, the corresponding {@code zwp_text_input_v3::set_...} shouldn't be
+ * called when processing this instance of OutgoingChanges.
+ * <p>
+ * The modifier methods return {@code this} for method chaining.
+ */
+final class OutgoingChanges
+{
+    // zwp_text_input_v3::enable / zwp_text_input_v3::disable
+    private Boolean newEnabled = null;
+
+    // zwp_text_input_v3::set_text_change_cause
+    private ChangeCause newTextChangeCause = null;
+
+    // zwp_text_input_v3::set_content_type
+    private Integer newContentTypeHint = null;
+    private ContentPurpose newContentTypePurpose = null;
+
+    // zwp_text_input_v3::set_cursor_rectangle
+    private Rectangle newCursorRectangle = null;
+
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder(256);
+        sb.append("OutgoingChanges@").append(System.identityHashCode(this));
+        sb.append('[');
+        sb.append("newEnabled=").append(newEnabled);
+        sb.append(", newTextChangeCause=").append(newTextChangeCause);
+        sb.append(", newContentTypeHint=").append(newContentTypeHint);
+        sb.append(", newContentTypePurpose=").append(newContentTypePurpose);
+        sb.append(", newCursorRectangle=").append(newCursorRectangle);
+        sb.append(']');
+        return sb.toString();
+    }
+
+
+    public OutgoingChanges setEnabledState(Boolean newEnabled) {
+        this.newEnabled = newEnabled;
+        return this;
+    }
+
+    public Boolean getEnabledState() { return newEnabled; }
+
+
+    public OutgoingChanges setTextChangeCause(ChangeCause newTextChangeCause) {
+        this.newTextChangeCause = newTextChangeCause;
+        return this;
+    }
+
+    public ChangeCause getTextChangeCause() { return newTextChangeCause; }
+
+
+    /**
+     * Both parameters have to be {@code null} or not null simultaneously.
+     *
+     * @throws NullPointerException if one of the parameters is {@code null} while the other one is not.
+     */
+    public OutgoingChanges setContentType(Integer newContentTypeHint, ContentPurpose newContentTypePurpose) {
+        if (newContentTypeHint == null && newContentTypePurpose == null) {
+            this.newContentTypeHint = null;
+            this.newContentTypePurpose = null;
+        } else {
+            final var contentHintAllMask =
+                    ContentHint.NONE.intMask |
+                            ContentHint.COMPLETION.intMask |
+                            ContentHint.SPELLCHECK.intMask |
+                            ContentHint.AUTO_CAPITALIZATION.intMask |
+                            ContentHint.LOWERCASE.intMask |
+                            ContentHint.UPPERCASE.intMask |
+                            ContentHint.TITLECASE.intMask |
+                            ContentHint.HIDDEN_TEXT.intMask |
+                            ContentHint.SENSITIVE_DATA.intMask |
+                            ContentHint.LATIN.intMask |
+                            ContentHint.MULTILINE.intMask;
+
+            if ( (Objects.requireNonNull(newContentTypeHint, "newContentTypeHint") & ~contentHintAllMask) != 0 ) {
+                throw new IllegalArgumentException(String.format("newContentTypeHint=%d has invalid bits set", newContentTypeHint));
+            }
+
+            this.newContentTypeHint = newContentTypeHint;
+            this.newContentTypePurpose = Objects.requireNonNull(newContentTypePurpose, "newContentTypePurpose");
+        }
+        return this;
+    }
+
+    public Integer getContentTypeHint() { return newContentTypeHint; }
+    public ContentPurpose getContentTypePurpose() { return newContentTypePurpose; }
+
+
+    public OutgoingChanges setCursorRectangle(Rectangle newCursorRectangle) {
+        this.newCursorRectangle = newCursorRectangle;
+        return this;
+    }
+
+    public Rectangle getCursorRectangle() { return newCursorRectangle; }
+
+
+    public OutgoingChanges appendChangesFrom(OutgoingChanges src) {
+        if (src == null) return this;
+
+        if (getTextChangeCause() == null) {
+            setTextChangeCause(src.getTextChangeCause());
+        }
+        if (getContentTypeHint() == null) {
+            setContentType(src.getContentTypeHint(), src.getContentTypePurpose());
+        }
+        if (getCursorRectangle() == null) {
+            setCursorRectangle(src.getCursorRectangle());
+        }
+
+        return this;
+    }
+
+
+    public boolean isEmpty() {
+        return (getEnabledState() == null && getTextChangeCause() == null && getContentTypeHint() == null && getCursorRectangle() == null);
+    }
+}

src/java.desktop/unix/classes/sun/awt/wl/im/text_input_unstable_v3/PropertiesInitials.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2025 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.awt.wl.im.text_input_unstable_v3;
+
+import java.awt.Rectangle;
+
+
+interface PropertiesInitials {
+    /** {@code zwp_text_input_v3::set_text_change_cause} */
+    ChangeCause       TEXT_CHANGE_CAUSE = ChangeCause.INPUT_METHOD;
+    /** {@code zwp_text_input_v3::set_content_type} (hint) */
+    int               CONTENT_HINT      = ContentHint.NONE.intMask;
+    /** {@code zwp_text_input_v3::set_content_type} (purpose) */
+    ContentPurpose    CONTENT_PURPOSE   = ContentPurpose.NORMAL;
+    /**
+     * {@code zwp_text_input_v3::set_cursor_rectangle}.
+     * <p>
+     * The initial values describing a cursor rectangle are empty.
+     * That means the text input does not support describing the cursor area.
+     * If the empty values get applied, subsequent attempts to change them may have no effect.
+     */
+    Rectangle         CURSOR_RECTANGLE  = null;
+    /** {@code zwp_text_input_v3::preedit_string} */
+    JavaPreeditString PREEDIT_STRING    = new JavaPreeditString("", 0, 0);
+    /** {@code zwp_text_input_v3::commit_string} */
+    JavaCommitString  COMMIT_STRING     = new JavaCommitString("");
+}

src/java.desktop/unix/classes/sun/awt/wl/im/text_input_unstable_v3/Utilities.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2025 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.awt.wl.im.text_input_unstable_v3;
+
+import java.nio.charset.StandardCharsets;
+
+
+interface Utilities {
+    static int getLengthOfUtf8BytesWithoutTrailingNULs(final byte[] utf8Bytes) {
+        int lastNonNulIndex = (utf8Bytes == null) ? -1 : utf8Bytes.length - 1;
+        for (; lastNonNulIndex >= 0; --lastNonNulIndex) {
+            if (utf8Bytes[lastNonNulIndex] != 0) {
+                break;
+            }
+        }
+
+        return (lastNonNulIndex < 0) ? 0 : lastNonNulIndex + 1;
+    }
+
+    static String utf8BytesToJavaString(final byte[] utf8Bytes) {
+        if (utf8Bytes == null) {
+            return "";
+        }
+
+        return utf8BytesToJavaString(
+            utf8Bytes,
+            0,
+            // Java's UTF-8 -> UTF-16 conversion doesn't like trailing NUL codepoints, so let's trim them
+            getLengthOfUtf8BytesWithoutTrailingNULs(utf8Bytes)
+        );
+    }
+
+    static String utf8BytesToJavaString(final byte[] utf8Bytes, final int offset, final int length) {
+        return utf8Bytes == null ? "" : new String(utf8Bytes, offset, length, StandardCharsets.UTF_8);
+    }
+}

src/java.desktop/unix/classes/sun/awt/wl/im/text_input_unstable_v3/WLInputMethodDescriptorZwpTextInputV3.java

@@ -0,0 +1,203 @@
+/*
+ * Copyright 2025 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.awt.wl.im.text_input_unstable_v3;
+
+import sun.awt.wl.WLToolkit;
+import sun.util.logging.PlatformLogger;
+
+import java.awt.AWTException;
+import java.awt.Image;
+import java.awt.Toolkit;
+import java.awt.im.spi.InputMethod;
+import java.awt.im.spi.InputMethodDescriptor;
+import java.util.Locale;
+
+
+public final class WLInputMethodDescriptorZwpTextInputV3 implements InputMethodDescriptor {
+
+    // See java.text.MessageFormat for the formatting syntax
+    private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.wl.im.text_input_unstable_v3.WLInputMethodDescriptorZwpTextInputV3");
+
+
+    public static boolean isAvailableOnPlatform() {
+        return initAndGetIsAvailableOnPlatform();
+    }
+
+    public static WLInputMethodDescriptorZwpTextInputV3 getInstanceIfAvailableOnPlatform() {
+        if (!isAvailableOnPlatform()) {
+            return null;
+        }
+        return new WLInputMethodDescriptorZwpTextInputV3();
+    }
+
+
+    /* java.awt.im.spi.InputMethodDescriptor methods section */
+
+    @Override
+    public Locale[] getAvailableLocales() throws AWTException {
+        ensureIsAvailableOnPlatform();
+        return getAvailableLocalesInternal();
+    }
+
+    @Override
+    public boolean hasDynamicLocaleList() {
+        // Since the return value of {@link #getAvailableLocales()} doesn't currently change over time,
+        //   it doesn't make sense to return true here.
+        return false;
+    }
+
+    @Override
+    public String getInputMethodDisplayName(Locale inputLocale, Locale displayLanguage) {
+        assert isAvailableOnPlatform();
+
+        // This is how it's implemented in all other Toolkits.
+        //
+        // We ignore the input locale.
+        // When displaying for the default locale, rely on the localized AWT properties;
+        //   for any other locale, fall back to English.
+        String name = "System Input Methods";
+        if (Locale.getDefault().equals(displayLanguage)) {
+            name = Toolkit.getProperty("AWT.HostInputMethodDisplayName", name);
+        }
+        return name;
+    }
+
+    @Override
+    public Image getInputMethodIcon(Locale inputLocale) {
+        return null;
+    }
+
+    @Override
+    public InputMethod createInputMethod() throws Exception {
+        // NB: we should avoid returning null from this method because the calling code isn't really ready to get null
+
+        ensureIsAvailableOnPlatform();
+
+        final var result = new WLInputMethodZwpTextInputV3();
+
+        if (log.isLoggable(PlatformLogger.Level.FINE)) {
+            log.fine("createInputMethod(): result={0}.", result);
+        }
+
+        return result;
+    }
+
+
+    /* java.lang.Object methods section */
+
+    @Override
+    public String toString() {
+        return String.format("WLInputMethodDescriptorZwpTextInputV3@%d", System.identityHashCode(this));
+    }
+
+
+    /* Implementation details section */
+
+    /** Used as the return value for {@link #getAvailableLocales()}. */
+    private volatile static Locale toolkitStartupLocale = null;
+
+    private volatile static Boolean isAvailableOnPlatform = null;
+
+
+    static Locale[] getAvailableLocalesInternal() {
+        // This is how it's implemented in XToolkit.
+        //
+        // A better implementation would be obtaining all currently installed and enabled input sources
+        //   (like on GNOME Settings -> Keyboard -> Input Sources) and mapping them to locales.
+        // However, there seem no universal Wayland API for that, so it seems can't be implemented reliably.
+        //
+        // So leaving as is at the moment.
+        //
+        // TODO: research how to implement this better along with {@link #hasDynamicLocaleList}
+
+        return new Locale[]{ (Locale)initAndGetToolkitStartupLocale().clone() };
+    }
+
+    private static Locale initAndGetToolkitStartupLocale() {
+        if (toolkitStartupLocale == null) {
+            synchronized (WLInputMethodDescriptorZwpTextInputV3.class) {
+                if (toolkitStartupLocale == null) {
+                    toolkitStartupLocale = WLToolkit.getStartupLocale();
+                }
+            }
+        }
+
+        if (log.isLoggable(PlatformLogger.Level.CONFIG)) {
+            log.config("initAndGetToolkitStartupLocale(): toolkitStartupLocale={0}.", toolkitStartupLocale);
+        }
+
+        return toolkitStartupLocale;
+    }
+
+    private static boolean initAndGetIsAvailableOnPlatform() {
+        if (isAvailableOnPlatform == null) {
+            synchronized (WLInputMethodDescriptorZwpTextInputV3.class) {
+                try {
+                    if (isAvailableOnPlatform == null) {
+                        isAvailableOnPlatform = checkIfAvailableOnPlatform();
+                    }
+                } catch (Exception err) {
+                    if (log.isLoggable(PlatformLogger.Level.WARNING)) {
+                        log.warning("Failed to check whether the IM protocol is supported on the system", err);
+                    }
+                    isAvailableOnPlatform = false;
+                }
+            }
+        }
+
+        if (log.isLoggable(PlatformLogger.Level.CONFIG)) {
+            log.config("initAndGetIsAvailableOnPlatform(): isAvailableOnPlatform={0}.", isAvailableOnPlatform);
+        }
+
+        return isAvailableOnPlatform;
+    }
+
+    private static void ensureIsAvailableOnPlatform() throws AWTException {
+        if (!isAvailableOnPlatform()) {
+            throw new AWTException("sun.awt.wl.im.text_input_unstable_v3.WLInputMethodZwpTextInputV3 is not supported on this system");
+        }
+    }
+
+
+    private WLInputMethodDescriptorZwpTextInputV3() {
+        assert isAvailableOnPlatform();
+
+        initAndGetToolkitStartupLocale();
+    }
+
+
+    /* JNI downcalls section */
+
+    /**
+     * This method checks if {@link WLInputMethodZwpTextInputV3} can function on this system.
+     * Basically, it means the Wayland compositor supports a minimal sufficient subset of the required protocols
+     *   (currently the set only includes the "text-input-unstable-v3" protocol).
+     *
+     * @return true if {@link WLInputMethodZwpTextInputV3} can function on this system, false otherwise.
+     * @see <a href="https://wayland.app/protocols/text-input-unstable-v3">text-input-unstable-v3</a>
+     */
+    private static native boolean checkIfAvailableOnPlatform();
+}

src/java.desktop/unix/classes/sun/java2d/vulkan/WLVKGraphicsConfig.java

@@ -47,11 +47,8 @@ public final class WLVKGraphicsConfig extends WLGraphicsConfig
 
     private final VKGraphicsConfig offscreenConfig;
 
-    public WLVKGraphicsConfig(VKGraphicsConfig offscreenConfig, WLGraphicsDevice device,
-                              int x, int y, int xLogical, int yLogical,
-                              int width, int height, int widthLogical, int heightLogical,
-                              int scale) {
-        super(device, x, y, xLogical, yLogical, width, height, widthLogical, heightLogical, scale);
+    public WLVKGraphicsConfig(VKGraphicsConfig offscreenConfig, WLGraphicsDevice device) {
+        super(device);
         this.offscreenConfig = offscreenConfig;
     }
 
@@ -65,11 +62,8 @@ public final class WLVKGraphicsConfig extends WLGraphicsConfig
         return getEffectiveScale();
     }
 
-    public static WLVKGraphicsConfig getConfig(VKGraphicsConfig offscreenConfig, WLGraphicsDevice device,
-                                               int x, int y, int xLogical, int yLogical,
-                                               int width, int height, int widthLogical, int heightLogical,
-                                               int scale) {
-        return new WLVKGraphicsConfig(offscreenConfig, device, x, y, xLogical, yLogical, width, height, widthLogical, heightLogical, scale);
+    public static WLVKGraphicsConfig getConfig(VKGraphicsConfig offscreenConfig, WLGraphicsDevice device) {
+        return new WLVKGraphicsConfig(offscreenConfig, device);
     }
 
     @Override

src/java.desktop/unix/classes/sun/java2d/wl/WLSMSurfaceData.java

@@ -26,19 +26,25 @@
 
 package sun.java2d.wl;
 
+import java.awt.AlphaComposite;
 import java.awt.Color;
 import java.awt.Component;
 import java.awt.Window;
 import java.awt.GraphicsConfiguration;
 import java.awt.Rectangle;
+import java.awt.image.BufferedImage;
+import java.awt.image.ColorModel;
 import java.awt.image.Raster;
+import java.awt.image.SampleModel;
+import java.awt.image.WritableRaster;
 import java.util.Objects;
 
 import sun.awt.AWTAccessor;
 import sun.awt.wl.WLComponentPeer;
-import sun.awt.wl.WLGraphicsConfig;
 import sun.awt.wl.WLSMGraphicsConfig;
 import sun.java2d.SurfaceData;
+import sun.java2d.loops.Blit;
+import sun.java2d.loops.CompositeType;
 import sun.java2d.loops.SurfaceType;
 import sun.util.logging.PlatformLogger;
 
@@ -124,16 +130,20 @@ public class WLSMSurfaceData extends SurfaceData implements WLSurfaceDataExt, WL
         return gc;
     }
 
+    public BufferedImage getSnapshot(int x, int y, int width, int height) {
+        ColorModel colorModel = getColorModel();
+        SampleModel sampleModel = colorModel.createCompatibleSampleModel(width, height);
+        WritableRaster raster = Raster.createWritableRaster(sampleModel, null);
+        BufferedImage image = new BufferedImage(colorModel, raster, colorModel.isAlphaPremultiplied(), null);
+        SurfaceData sd = SurfaceData.getPrimarySurfaceData(image);
+        Blit blit = Blit.getFromCache(getSurfaceType(), CompositeType.SrcNoEa, sd.getSurfaceType());
+        blit.Blit(this, sd, AlphaComposite.Src, null, x, y, 0, 0, width, height);
+        return image;
+    }
+
     @Override
     public Raster getRaster(int x, int y, int w, int h) {
-        // Can do something like the following:
-        // Raster r = getColorModel().createCompatibleWritableRaster(w, h);
-        // copy surface data to this raster
-        // save a reference to this raster
-        // return r;
-        // then in flush() check if raster was modified and take pixels from there
-        // This is obviously suboptimal and shouldn't be used in performance-critical situations.
-        throw new UnsupportedOperationException("Not implemented yet");
+        return getSnapshot(x, y, w, h).getRaster().createTranslatedChild(x, y);
     }
 
     @Override
@@ -189,7 +199,7 @@ public class WLSMSurfaceData extends SurfaceData implements WLSurfaceDataExt, WL
     private void countNewFrame() {
         // Called from the native code when this surface data has been sent to the Wayland server
         if (target instanceof Window window) {
-            AWTAccessor.getWindowAccessor().bumpCounter(window, "java2d.native.frames");
+            AWTAccessor.getWindowAccessor().incrementCounter(window, "java2d.native.frames");
         }
     }
 
@@ -198,7 +208,7 @@ public class WLSMSurfaceData extends SurfaceData implements WLSurfaceDataExt, WL
         // the Wayland server, but that attempt was not successful. This can happen, for example,
         // when those attempts are too frequent.
         if (target instanceof Window window) {
-            AWTAccessor.getWindowAccessor().bumpCounter(window, "java2d.native.framesDropped");
+            AWTAccessor.getWindowAccessor().incrementCounter(window, "java2d.native.framesDropped");
         }
     }
 

src/java.desktop/unix/native/libawt_wlawt/GtkFrameDecoration.c

@@ -643,8 +643,19 @@ JNIEXPORT void JNICALL Java_sun_awt_wl_GtkFrameDecoration_nativePaintTitleBar
     jint pixel_width = ceil(width * scale);
     jint pixel_height = ceil(height * scale);
 
+    jboolean is_copy = JNI_FALSE;
+    const char *title_c_str = "";
+    if (title) {
+        title_c_str = JNU_GetStringPlatformChars(env, title, &is_copy);
+        if (!title_c_str)
+            return;
+    }
+
     unsigned char *buffer = (*env)->GetPrimitiveArrayCritical(env, dest, 0);
     if (!buffer) {
+        if (is_copy) {
+            JNU_ReleaseStringPlatformChars(env, title, title_c_str);
+        }
         JNU_ThrowOutOfMemoryError(env, "Could not get image buffer");
         return;
     }
@@ -660,31 +671,25 @@ JNIEXPORT void JNICALL Java_sun_awt_wl_GtkFrameDecoration_nativePaintTitleBar
 
     cairo_t *cr = p_cairo_create(surface);
 
-    jboolean is_copy = JNI_FALSE;
-    const char *title_c_str = "";
-    if (title) {
-        title_c_str = JNU_GetStringPlatformChars(env, title, &is_copy);
-        if (!title_c_str)
-            return;
-    }
     draw_title_bar(decor, surface, cr, width, height, scale, title_c_str, buttonsState);
 
-    if (is_copy) {
-        JNU_ReleaseStringPlatformChars(env, title, title_c_str);
-    }
-
     // Make sure pixels have been flush into the underlying buffer
     p_cairo_surface_flush(surface);
 
     p_gdk_threads_leave();
 
     (*env)->ReleasePrimitiveArrayCritical(env, dest, buffer, 0);
+
+    if (is_copy) {
+        JNU_ReleaseStringPlatformChars(env, title, title_c_str);
+    }
+
     p_cairo_destroy(cr);
     p_cairo_surface_destroy(surface);
 }
 
 JNIEXPORT void JNICALL Java_sun_awt_wl_GtkFrameDecoration_nativePrePaint(JNIEnv *env, jobject obj,
-                                                                         jlong ptr, jint width) {
+                                                                         jlong ptr, jint width, jint height) {
     assert (ptr != 0);
     GtkFrameDecorationDescr* decor = jlong_to_ptr(ptr);
 
@@ -714,6 +719,12 @@ JNIEXPORT void JNICALL Java_sun_awt_wl_GtkFrameDecoration_nativePrePaint(JNIEnv
     (*env)->SetIntField(env, obj, TitleBarHeightFID, pref_height);
     (*env)->SetIntField(env, obj, TitleBarMinWidthFID, min_width);
 
+    if (width < min_width || height < pref_height) {
+        // Avoid gtk warnings in case of insufficient space
+        p_gdk_threads_leave();
+        return;
+    }
+
     GtkAllocation ha = {0, 0, width, pref_height};
     p_gtk_widget_size_allocate(decor->titlebar, &ha);
 

src/java.desktop/unix/native/libawt_wlawt/WLDataDevice.c

@@ -26,6 +26,7 @@
 #include <assert.h>
 #include <stdbool.h>
 #include <stdlib.h>
+#include <pthread.h>
 
 #include "JNIUtilities.h"
 #include "WLToolkit.h"
@@ -34,7 +35,6 @@
 #include "sun_awt_wl_WLDataOffer.h"
 #include "wayland-client-protocol.h"
 
-
 // Types
 
 enum DataTransferProtocol
@@ -43,6 +43,9 @@ enum DataTransferProtocol
     DATA_TRANSFER_PROTOCOL_PRIMARY_SELECTION = sun_awt_wl_WLDataDevice_DATA_TRANSFER_PROTOCOL_PRIMARY_SELECTION,
 };
 
+struct DataSource;
+struct DataOffer;
+
 // native part of WLDataDevice, one instance per seat
 // seat's wl_data_device and zwp_primary_selection_device_v1 have user pointers to this struct
 struct DataDevice
@@ -54,12 +57,20 @@ struct DataDevice
     struct wl_event_queue *dataSourceQueue;
     struct wl_data_device *wlDataDevice;
     struct zwp_primary_selection_device_v1 *zwpPrimarySelectionDevice;
+
+    pthread_mutex_t sourceDelMutex;
+    struct DataSource* sourceDelQueue;
+
+    pthread_mutex_t offerDelMutex;
+    struct DataOffer* offerDelQueue;
 };
 
 // native part of WLDataSource, remains alive until WLDataSource.destroy() is called
 // pointer to this structure is the wl_data_source's (zwp_primary_selection_source_v1's) user pointer
 struct DataSource
 {
+    struct DataDevice* dataDevice;
+
     enum DataTransferProtocol protocol;
     // global reference to the corresponding WLDataSource object
     // destroyed in WLDataSource.destroy()
@@ -72,12 +83,19 @@ struct DataSource
         struct wl_data_source *wlDataSource;
         struct zwp_primary_selection_source_v1 *zwpPrimarySelectionSource;
     };
+
+    struct wl_surface* dragIcon;
+    struct wl_buffer* dragIconBuffer;
+
+    struct DataSource* nextDel;
 };
 
 // native part of WLDataOffer, remains alive until WLDataOffer.destroy() is called
 // pointer to this structure is the wl_data_offer's (zwp_primary_selection_offer_v1's) user pointer
 struct DataOffer
 {
+    struct DataDevice* dataDevice;
+
     enum DataTransferProtocol protocol;
     // global reference to the corresponding WLDataOffer object
     // destroyed in WLDataOffer.destroy()
@@ -90,6 +108,8 @@ struct DataOffer
         struct wl_data_offer *wlDataOffer;
         struct zwp_primary_selection_offer_v1 *zwpPrimarySelectionOffer;
     };
+
+    struct DataOffer* nextDel;
 };
 
 // Java refs
@@ -268,9 +288,6 @@ DataSource_setDnDActions(const struct DataSource *source, uint32_t actions);
 static struct DataOffer *
 DataOffer_create(struct DataDevice *dataDevice, enum DataTransferProtocol protocol, void *waylandObject);
 
-static void
-DataOffer_destroy(struct DataOffer *offer);
-
 static void
 DataOffer_receive(struct DataOffer *offer, const char *mime, int fd);
 
@@ -314,10 +331,13 @@ static struct DataOffer *
 DataOffer_create(struct DataDevice *dataDevice, enum DataTransferProtocol protocol, void *waylandObject)
 {
     struct DataOffer *offer = calloc(1, sizeof(struct DataOffer));
+
     if (offer == NULL) {
         return NULL;
     }
 
+    offer->dataDevice = dataDevice;
+
     JNIEnv *env = getEnv();
     assert(env != NULL);
 
@@ -331,7 +351,7 @@ DataOffer_create(struct DataDevice *dataDevice, enum DataTransferProtocol protoc
         return NULL;
     }
 
-    // Cleared in DataOffer_destroy
+    // Cleared in DataOffer.destroy()
     jobject globalRef = (*env)->NewGlobalRef(env, obj);
 
     EXCEPTION_CLEAR(env);
@@ -342,50 +362,23 @@ DataOffer_create(struct DataDevice *dataDevice, enum DataTransferProtocol protoc
     }
 
     offer->javaObject = globalRef;
+    offer->protocol = protocol;
 
     if (protocol == DATA_TRANSFER_PROTOCOL_WAYLAND) {
         struct wl_data_offer *wlDataOffer = waylandObject;
-
-        wl_data_offer_add_listener(wlDataOffer, &wlDataOfferListener, offer);
-
         offer->wlDataOffer = wlDataOffer;
-        offer->protocol = DATA_TRANSFER_PROTOCOL_WAYLAND;
+        wl_data_offer_add_listener(wlDataOffer, &wlDataOfferListener, offer);
     }
 
     if (protocol == DATA_TRANSFER_PROTOCOL_PRIMARY_SELECTION) {
         struct zwp_primary_selection_offer_v1 *zwpPrimarySelectionOffer = waylandObject;
-
-        zwp_primary_selection_offer_v1_add_listener(zwpPrimarySelectionOffer, &zwpPrimarySelectionOfferListener, offer);
         offer->zwpPrimarySelectionOffer = zwpPrimarySelectionOffer;
-        offer->protocol = DATA_TRANSFER_PROTOCOL_PRIMARY_SELECTION;
+        zwp_primary_selection_offer_v1_add_listener(zwpPrimarySelectionOffer, &zwpPrimarySelectionOfferListener, offer);
     }
 
     return offer;
 }
 
-static void
-DataOffer_destroy(struct DataOffer *offer)
-{
-    if (offer == NULL) {
-        return;
-    }
-
-    if (offer->javaObject != NULL) {
-        JNIEnv *env = getEnv();
-        assert(env != NULL);
-        (*env)->DeleteGlobalRef(env, offer->javaObject);
-        offer->javaObject = NULL;
-    }
-
-    if (offer->protocol == DATA_TRANSFER_PROTOCOL_WAYLAND) {
-        wl_data_offer_destroy(offer->wlDataOffer);
-    } else if (offer->protocol == DATA_TRANSFER_PROTOCOL_PRIMARY_SELECTION) {
-        zwp_primary_selection_offer_v1_destroy(offer->zwpPrimarySelectionOffer);
-    }
-
-    free(offer);
-}
-
 static void
 DataOffer_receive(struct DataOffer *offer, const char *mime, int fd)
 {
@@ -459,6 +452,68 @@ DataOffer_callSelectionHandler(struct DataDevice *dataDevice, struct DataOffer *
     EXCEPTION_CLEAR(env);
 }
 
+static void
+DataDevice_drainSourceDeletionQueue(struct DataDevice *dataDevice, JNIEnv* env) {
+    pthread_mutex_lock(&dataDevice->sourceDelMutex);
+
+    struct DataSource* source = dataDevice->sourceDelQueue;
+
+    while (source != NULL) {
+        if (source->protocol == DATA_TRANSFER_PROTOCOL_WAYLAND) {
+            wl_data_source_destroy(source->wlDataSource);
+        } else if (source->protocol == DATA_TRANSFER_PROTOCOL_PRIMARY_SELECTION) {
+            zwp_primary_selection_source_v1_destroy(source->zwpPrimarySelectionSource);
+        }
+
+        if (source->dragIconBuffer) {
+            wl_buffer_destroy(source->dragIconBuffer);
+        }
+
+        if (source->dragIcon) {
+            wl_surface_destroy(source->dragIcon);
+        }
+
+        if (source->javaObject != NULL) {
+            (*env)->DeleteGlobalRef(env, source->javaObject);
+        }
+
+        struct DataSource* next = source->nextDel;
+        free(source);
+        source = next;
+    }
+
+    dataDevice->sourceDelQueue = NULL;
+
+    pthread_mutex_unlock(&dataDevice->sourceDelMutex);
+}
+
+static void
+DataDevice_drainOfferDeletionQueue(struct DataDevice *dataDevice, JNIEnv* env) {
+    pthread_mutex_lock(&dataDevice->offerDelMutex);
+
+    struct DataOffer* offer = dataDevice->offerDelQueue;
+
+    while (offer != NULL) {
+        if (offer->protocol == DATA_TRANSFER_PROTOCOL_WAYLAND) {
+            wl_data_offer_destroy(offer->wlDataOffer);
+        } else if (offer->protocol == DATA_TRANSFER_PROTOCOL_PRIMARY_SELECTION) {
+            zwp_primary_selection_offer_v1_destroy(offer->zwpPrimarySelectionOffer);
+        }
+
+        if (offer->javaObject != NULL) {
+            (*env)->DeleteGlobalRef(env, offer->javaObject);
+        }
+
+        struct DataOffer* next = offer->nextDel;
+        free(offer);
+        offer = next;
+    }
+
+    dataDevice->offerDelQueue = NULL;
+
+    pthread_mutex_unlock(&dataDevice->offerDelMutex);
+}
+
 // Event handlers
 
 static void
@@ -821,6 +876,9 @@ Java_sun_awt_wl_WLDataDevice_initNative(JNIEnv *env, jobject obj, jlong wlSeatPt
         return 0;
     }
 
+    pthread_mutex_init(&dataDevice->sourceDelMutex, NULL);
+    pthread_mutex_init(&dataDevice->offerDelMutex, NULL);
+
     dataDevice->javaObject = (*env)->NewGlobalRef(env, obj);
     if ((*env)->ExceptionCheck(env)) {
         goto error_cleanup;
@@ -862,7 +920,10 @@ Java_sun_awt_wl_WLDataDevice_initNative(JNIEnv *env, jobject obj, jlong wlSeatPt
 
     return ptr_to_jlong(dataDevice);
 
-    error_cleanup:
+error_cleanup:
+    pthread_mutex_destroy(&dataDevice->sourceDelMutex);
+    pthread_mutex_destroy(&dataDevice->offerDelMutex);
+
     if (dataDevice->dataSourceQueue != NULL) {
         wl_event_queue_destroy(dataDevice->dataSourceQueue);
     }
@@ -909,6 +970,7 @@ Java_sun_awt_wl_WLDataDevice_dispatchDataSourceQueueImpl(JNIEnv *env, jclass cla
     assert(dataDevice != NULL);
 
     while (wl_display_dispatch_queue(wl_display, dataDevice->dataSourceQueue) != -1) {
+        DataDevice_drainSourceDeletionQueue(dataDevice, env);
     }
 }
 
@@ -937,7 +999,7 @@ Java_sun_awt_wl_WLDataDevice_setSelectionImpl(JNIEnv *env,
 JNIEXPORT void JNICALL
 Java_sun_awt_wl_WLDataDevice_startDragImpl(JNIEnv *env, jclass clazz, jlong dataDeviceNativePtr,
                                            jlong dataSourceNativePtr, jlong wlSurfacePtr,
-                                           jlong iconPtr, jlong serial)
+                                           jlong serial)
 {
     struct DataDevice *dataDevice = jlong_to_ptr(dataDeviceNativePtr);
     assert(dataDevice != NULL);
@@ -946,7 +1008,17 @@ Java_sun_awt_wl_WLDataDevice_startDragImpl(JNIEnv *env, jclass clazz, jlong data
     assert(source != NULL);
 
     wl_data_device_start_drag(dataDevice->wlDataDevice, source->wlDataSource, jlong_to_ptr(wlSurfacePtr),
-                              jlong_to_ptr(iconPtr), serial);
+                              source->dragIcon, serial);
+    if (source->dragIcon != NULL) {
+        wl_surface_commit(source->dragIcon);
+    }
+}
+
+JNIEXPORT void JNICALL
+Java_sun_awt_wl_WLDataDevice_performDeletionsOnEDTImpl(JNIEnv *env, jclass clazz, jlong dataDeviceNativePtr) {
+    struct DataDevice *dataDevice = jlong_to_ptr(dataDeviceNativePtr);
+    assert(dataDevice != NULL);
+    DataDevice_drainOfferDeletionQueue(dataDevice, env);
 }
 
 JNIEXPORT jlong JNICALL
@@ -955,21 +1027,23 @@ Java_sun_awt_wl_WLDataSource_initNative(JNIEnv *env, jobject javaObject, jlong d
     struct DataDevice *dataDevice = jlong_to_ptr(dataDeviceNativePtr);
     assert(dataDevice != NULL);
 
-    struct DataSource *dataSource = calloc(1, sizeof(struct DataSource));
+    struct DataSource *source = calloc(1, sizeof(struct DataSource));
 
-    if (dataSource == NULL) {
+    if (source == NULL) {
         JNU_ThrowOutOfMemoryError(env, "Failed to allocate DataSource");
         return 0;
     }
 
+    source->dataDevice = dataDevice;
+
     // cleaned up in WLDataSource.destroy()
-    dataSource->javaObject = (*env)->NewGlobalRef(env, javaObject);
+    source->javaObject = (*env)->NewGlobalRef(env, javaObject);
     if ((*env)->ExceptionCheck(env)) {
-        free(dataSource);
+        free(source);
         return 0;
     }
-    if (dataSource->javaObject == NULL) {
-        free(dataSource);
+    if (source->javaObject == NULL) {
+        free(source);
         JNU_ThrowInternalError(env, "Failed to create a reference to WLDataSource");
         return 0;
     }
@@ -978,39 +1052,56 @@ Java_sun_awt_wl_WLDataSource_initNative(JNIEnv *env, jobject javaObject, jlong d
         protocol = DATA_TRANSFER_PROTOCOL_WAYLAND;
     }
 
+    source->protocol = protocol;
+
     if (protocol == DATA_TRANSFER_PROTOCOL_WAYLAND) {
-        struct wl_data_source *wlDataSource = wl_data_device_manager_create_data_source(wl_ddm);
+        // To avoid race conditions when setting the dispatch queue,
+        // it's necessary to do this dance with wl_proxy_create_wrapper.
+        // See the docs for wl_proxy_create_wrapper for more details
+
+        struct wl_data_device_manager* dmWrapper = wl_proxy_create_wrapper(wl_ddm);
+        struct wl_data_source *wlDataSource = NULL;
+
+        if (dmWrapper != NULL) {
+            wl_proxy_set_queue((struct wl_proxy *) dmWrapper, dataDevice->dataSourceQueue);
+            wlDataSource = wl_data_device_manager_create_data_source(dmWrapper);
+            wl_proxy_wrapper_destroy(dmWrapper);
+        }
+
         if (wlDataSource == NULL) {
-            free(dataSource);
+            free(source);
             JNU_ThrowByName(env, "java/awt/AWTError", "Wayland error creating wl_data_source proxy");
             return 0;
         }
 
-        wl_proxy_set_queue((struct wl_proxy *) wlDataSource, dataDevice->dataSourceQueue);
-        wl_data_source_add_listener(wlDataSource, &wl_data_source_listener, dataSource);
+        source->wlDataSource = wlDataSource;
 
-        dataSource->protocol = DATA_TRANSFER_PROTOCOL_WAYLAND;
-        dataSource->wlDataSource = wlDataSource;
+        wl_data_source_add_listener(wlDataSource, &wl_data_source_listener, source);
     }
 
     if (protocol == DATA_TRANSFER_PROTOCOL_PRIMARY_SELECTION) {
-        struct zwp_primary_selection_source_v1 *zwpPrimarySelectionSource =
-                zwp_primary_selection_device_manager_v1_create_source(zwp_selection_dm);
+        struct zwp_primary_selection_device_manager_v1 *dmWrapper = wl_proxy_create_wrapper(zwp_selection_dm);
+        struct zwp_primary_selection_source_v1 *zwpPrimarySelectionSource = NULL;
+
+        if (dmWrapper != NULL) {
+            wl_proxy_set_queue((struct wl_proxy *) dmWrapper, dataDevice->dataSourceQueue);
+            zwpPrimarySelectionSource = zwp_primary_selection_device_manager_v1_create_source(dmWrapper);
+            wl_proxy_wrapper_destroy(dmWrapper);
+        }
+
         if (zwpPrimarySelectionSource == NULL) {
-            free(dataSource);
+            free(source);
             JNU_ThrowByName(env, "java/awt/AWTError", "Wayland error creating zwp_primary_selection_source_v1 proxy");
             return 0;
         }
 
-        wl_proxy_set_queue((struct wl_proxy *) zwpPrimarySelectionSource, dataDevice->dataSourceQueue);
-        zwp_primary_selection_source_v1_add_listener(zwpPrimarySelectionSource,
-                                                     &zwp_primary_selection_source_v1_listener, dataSource);
+        source->zwpPrimarySelectionSource = zwpPrimarySelectionSource;
 
-        dataSource->protocol = DATA_TRANSFER_PROTOCOL_PRIMARY_SELECTION;
-        dataSource->zwpPrimarySelectionSource = zwpPrimarySelectionSource;
+        zwp_primary_selection_source_v1_add_listener(zwpPrimarySelectionSource,
+                                                     &zwp_primary_selection_source_v1_listener, source);
     }
 
-    return ptr_to_jlong(dataSource);
+    return ptr_to_jlong(source);
 }
 
 JNIEXPORT void JNICALL
@@ -1034,18 +1125,13 @@ Java_sun_awt_wl_WLDataSource_destroyImpl(JNIEnv *env, jclass clazz, jlong native
         return;
     }
 
-    if (source->javaObject != NULL) {
-        (*env)->DeleteGlobalRef(env, source->javaObject);
-        source->javaObject = NULL;
-    }
+    assert(source->dataDevice != NULL);
+    struct DataDevice* dataDevice = source->dataDevice;
 
-    if (source->protocol == DATA_TRANSFER_PROTOCOL_WAYLAND) {
-        wl_data_source_destroy(source->wlDataSource);
-    } else if (source->protocol == DATA_TRANSFER_PROTOCOL_PRIMARY_SELECTION) {
-        zwp_primary_selection_source_v1_destroy(source->zwpPrimarySelectionSource);
-    }
-
-    free(source);
+    pthread_mutex_lock(&dataDevice->sourceDelMutex);
+    source->nextDel = dataDevice->sourceDelQueue;
+    dataDevice->sourceDelQueue = source;
+    pthread_mutex_unlock(&dataDevice->sourceDelMutex);
 }
 
 JNIEXPORT void JNICALL
@@ -1058,11 +1144,87 @@ Java_sun_awt_wl_WLDataSource_setDnDActionsImpl(JNIEnv *env,
     DataSource_setDnDActions(source, actions);
 }
 
+JNIEXPORT void JNICALL Java_sun_awt_wl_WLDataSource_setDnDIconImpl
+  (JNIEnv * env, jclass clazz, jlong nativePtr, jint scale,
+   jint width, jint height, jint offsetX, jint offsetY, jintArray pixels)
+{
+    struct DataSource *source = jlong_to_ptr(nativePtr);
+
+    size_t pixelCount = (size_t)((*env)->GetArrayLength(env, pixels));
+    size_t byteSize = pixelCount * 4U;
+    if (byteSize >= INT32_MAX) {
+        return;
+    }
+
+    jint *shmPixels = NULL;
+    struct wl_shm_pool *pool = CreateShmPool(byteSize, "WLDataSource_DragIcon", (void**)&shmPixels, NULL);
+    if (!pool) {
+        return;
+    }
+
+    (*env)->GetIntArrayRegion(env, pixels, 0, pixelCount, shmPixels);
+#if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+    // Wayland requires little-endian data
+    for (size_t i = 0; i < pixelCount; i++) {
+        uint32_t value = (uint32_t)shmPixels[i];
+        shmPixels[i] = (jint)((value & 0xFFU) << 24 |
+                              (value & 0xFF00U) << 8 |
+                              (value & 0xFF0000U) >> 8 |
+                              (value & 0xFF000000U) >> 24 & 0xFFU);
+    }
+#endif
+
+    source->dragIconBuffer = wl_shm_pool_create_buffer(pool, 0, width, height, width * 4, WL_SHM_FORMAT_ARGB8888);
+    wl_shm_pool_destroy(pool);
+    if (!source->dragIconBuffer) {
+        return;
+    }
+
+    source->dragIcon = wl_compositor_create_surface(wl_compositor);
+    if (!source->dragIcon) {
+        wl_buffer_destroy(source->dragIconBuffer);
+        source->dragIconBuffer = NULL;
+        return;
+    }
+
+#if WL_SURFACE_OFFSET_SINCE_VERSION >= 5
+    int wl_compositor_version = wl_compositor_get_version(wl_compositor);
+    if (wl_compositor_version >= 5) {
+        wl_surface_attach(source->dragIcon, source->dragIconBuffer, 0, 0);
+        wl_surface_offset(source->dragIcon, offsetX, offsetY);
+    } else {
+        wl_surface_attach(source->dragIcon, source->dragIconBuffer, offsetX, offsetY);
+    }
+#else
+    wl_surface_attach(source->dragIcon, source->dragIconBuffer, offsetX, offsetY);
+#endif
+
+    if (scale >= 1) {
+        wl_surface_set_buffer_scale(source->dragIcon, scale);
+    }
+
+    wl_surface_damage_buffer(source->dragIcon, 0, 0, width, height);
+
+    // NOTE: we still need to commit the surface, this is done immediately after start_drag
+}
+
 JNIEXPORT void JNICALL
 Java_sun_awt_wl_WLDataOffer_destroyImpl(JNIEnv *env, jclass clazz, jlong nativePtr)
 {
+    assert(env != NULL);
     struct DataOffer *offer = jlong_to_ptr(nativePtr);
-    DataOffer_destroy(offer);
+
+    if (offer == NULL) {
+        return;
+    }
+
+    assert(offer->dataDevice != NULL);
+    struct DataDevice* dataDevice = offer->dataDevice;
+
+    pthread_mutex_lock(&dataDevice->offerDelMutex);
+    offer->nextDel = dataDevice->offerDelQueue;
+    dataDevice->offerDelQueue = offer;
+    pthread_mutex_unlock(&dataDevice->offerDelMutex);
 }
 
 JNIEXPORT void JNICALL

src/java.desktop/unix/native/libawt_wlawt/WLGraphicsEnvironment.c

@@ -43,8 +43,6 @@ typedef struct WLOutput {
 
     int32_t x;
     int32_t y;
-    int32_t x_logical;
-    int32_t y_logical;
     int32_t width;
     int32_t height;
     int32_t width_logical;
@@ -59,6 +57,8 @@ typedef struct WLOutput {
     char *   make;
     char *   model;
     char *   name;
+
+    bool     offset_known; // whether x and y were set by xdg_output
 } WLOutput;
 
 static jclass geClass;
@@ -83,10 +83,13 @@ wl_output_geometry(
 {
     WLOutput *output = data;
 
-    // TODO: there's also a recommended, but unstable interface xdg_output;
-    //  we may want to switch to that one day.
-    output->x = x;
-    output->y = y;
+    if (!output->offset_known) {
+        // Ubuntu 22.04 has a bug that prevent Mutter from sending out updates to (x, y) in this
+        // geometry event. So we prefer to learn offset from xdg_output that will override
+        // (x, y) from this event.
+        output->x = x;
+        output->y = y;
+    }
     output->subpixel = subpixel;
     output->transform = transform;
     output->width_mm = physical_width;
@@ -161,8 +164,6 @@ NotifyOutputConfigured(WLOutput* output)
                            output->id,
                            output->x,
                            output->y,
-                           output->x_logical,
-                           output->y_logical,
                            output->width,
                            output->height,
                            output->width_logical,
@@ -173,6 +174,8 @@ NotifyOutputConfigured(WLOutput* output)
                            (jint)output->transform,
                            (jint)output->scale);
     JNU_CHECK_EXCEPTION(env);
+
+    output->offset_known = false;
 }
 
 static void
@@ -218,8 +221,12 @@ static void
 zxdg_output_logical_position(void *data, struct zxdg_output_v1 *zxdg_output_v1, int32_t x, int32_t y)
 {
     WLOutput * output = data;
-    output->x_logical = x;
-    output->y_logical = y;
+    output->x = x;
+    output->y = y;
+
+    // Prevent the geometry event from overriding these values with potentially incorrect ones;
+    // see wl_output_geometry().
+    output->offset_known = true;
 }
 
 static void
@@ -257,7 +264,7 @@ WLGraphicsEnvironment_initIDs
     CHECK_NULL_RETURN(
                     notifyOutputConfiguredMID = (*env)->GetMethodID(env, clazz,
                                                                     "notifyOutputConfigured",
-                                                                    "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;IIIIIIIIIIIIII)V"),
+                                                                    "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;IIIIIIIIIIII)V"),
                     JNI_FALSE);
     CHECK_NULL_RETURN(
                     notifyOutputDestroyedMID = (*env)->GetMethodID(env, clazz,

src/java.desktop/unix/native/libawt_wlawt/WLToolkit.c

@@ -24,6 +24,7 @@
  * questions.
  */
 
+#include "relative-pointer-unstable-v1.h"
 #ifdef HEADLESS
     #error This file should not be included in headless library
 #endif
@@ -80,6 +81,7 @@ struct gtk_shell1* gtk_shell1 = NULL;
 #endif
 struct wl_keyboard *wl_keyboard; // optional, check for NULL before use
 struct wl_pointer  *wl_pointer; // optional, check for NULL before use
+struct zwp_relative_pointer_manager_v1* relative_pointer_manager; // optional, check for NULL before use
 
 #define MAX_CURSOR_SCALE 100
 struct wl_cursor_theme *cursor_themes[MAX_CURSOR_SCALE] = {NULL};
@@ -88,6 +90,8 @@ struct wl_data_device_manager *wl_ddm = NULL;
 struct zwp_primary_selection_device_manager_v1 *zwp_selection_dm = NULL; // optional, check for NULL before use
 struct zxdg_output_manager_v1 *zxdg_output_manager_v1 = NULL; // optional, check for NULL before use
 
+struct zwp_text_input_manager_v3 *zwp_text_input_manager = NULL; // optional, check for NULL before use
+
 static uint32_t num_of_outstanding_sync = 0;
 
 // This group of definitions corresponds to declarations from awt.h
@@ -128,6 +132,7 @@ static jmethodID dispatchKeyboardKeyEventMID;
 static jmethodID dispatchKeyboardModifiersEventMID;
 static jmethodID dispatchKeyboardEnterEventMID;
 static jmethodID dispatchKeyboardLeaveEventMID;
+static jmethodID dispatchRelativePointerEventMID;
 
 JNIEnv *getEnv() {
     JNIEnv *env;
@@ -464,6 +469,31 @@ static const struct wl_keyboard_listener wl_keyboard_listener = {
         .key         = wl_keyboard_key
 };
 
+static void
+wl_relative_motion(void *data,
+                   struct zwp_relative_pointer_v1 *zwp_relative_pointer_v1,
+                   uint32_t utime_hi,
+                   uint32_t utime_lo,
+                   wl_fixed_t dx,
+                   wl_fixed_t dy,
+                   wl_fixed_t dx_unaccel,
+                   wl_fixed_t dy_unaccel)
+{
+    double ddx = wl_fixed_to_double(dx);
+    double ddy = wl_fixed_to_double(dy);
+    JNIEnv* env = getEnv();
+
+    (*env)->CallStaticVoidMethod(env,
+                                 tkClass,
+                                 dispatchRelativePointerEventMID,
+                                 ddx, ddy);
+    JNU_CHECK_EXCEPTION(env);
+}
+
+static const struct zwp_relative_pointer_v1_listener relative_pointer_listener = {
+    .relative_motion = wl_relative_motion
+};
+
 static void
 wl_seat_capabilities(void *data, struct wl_seat *wl_seat, uint32_t capabilities)
 {
@@ -474,6 +504,14 @@ wl_seat_capabilities(void *data, struct wl_seat *wl_seat, uint32_t capabilities)
         wl_pointer = wl_seat_get_pointer(wl_seat);
         if (wl_pointer != NULL) {
             wl_pointer_add_listener(wl_pointer, &wl_pointer_listener, NULL);
+            if (relative_pointer_manager != NULL) {
+                struct zwp_relative_pointer_v1* rptr
+                    = zwp_relative_pointer_manager_v1_get_relative_pointer(relative_pointer_manager,
+                                                                           wl_pointer);
+                if (rptr != NULL) {
+                    zwp_relative_pointer_v1_add_listener(rptr, &relative_pointer_listener, NULL);
+                }
+            }
         }
     } else if (!has_pointer && wl_pointer != NULL) {
         wl_pointer_release(wl_pointer);
@@ -536,7 +574,12 @@ registry_global(void *data, struct wl_registry *wl_registry,
     if (strcmp(interface, wl_shm_interface.name) == 0) {
         wl_shm = wl_registry_bind( wl_registry, name, &wl_shm_interface, 1);
     } else if (strcmp(interface, wl_compositor_interface.name) == 0) {
-        wl_compositor = wl_registry_bind(wl_registry, name, &wl_compositor_interface, 4);
+#if WL_SURFACE_OFFSET_SINCE_VERSION >= 5
+        uint32_t chosen_version = (version >= 5) ? 5 : 4;
+#else
+        uint32_t chosen_version = 4;
+#endif
+        wl_compositor = wl_registry_bind(wl_registry, name, &wl_compositor_interface, chosen_version);
     } else if (strcmp(interface, wl_subcompositor_interface.name) == 0) {
         wl_subcompositor = wl_registry_bind(wl_registry, name, &wl_subcompositor_interface, 1);
     } else if (strcmp(interface, xdg_wm_base_interface.name) == 0) {
@@ -560,6 +603,9 @@ registry_global(void *data, struct wl_registry *wl_registry,
     } else if (strcmp(interface, xdg_activation_v1_interface.name) == 0) {
         xdg_activation_v1 = wl_registry_bind(wl_registry, name, &xdg_activation_v1_interface, 1);
     }
+    else if (strcmp(interface, zwp_relative_pointer_manager_v1_interface.name) == 0) {
+        relative_pointer_manager = wl_registry_bind(wl_registry, name, &zwp_relative_pointer_manager_v1_interface, 1);
+    }
 #ifdef HAVE_GTK_SHELL1
     else if (strcmp(interface, gtk_shell1_interface.name) == 0) {
         gtk_shell1 = wl_registry_bind(wl_registry, name, &gtk_shell1_interface, 1);
@@ -577,6 +623,14 @@ registry_global(void *data, struct wl_registry *wl_registry,
             WLOutputXdgOutputManagerBecameAvailable();
             process_new_listener_before_end_of_init();
         }
+    } else if (strcmp(interface, zwp_text_input_manager_v3_interface.name) == 0) {
+        // If the requested version is higher than the provided one by the compositor,
+        //   the event loop may shut down as soon as it gets launched (wl_display_dispatch will return -1),
+        //   so let's protect from this since the component being obtained is not vital for work.
+        const uint32_t versionToBind = 1;
+        if (versionToBind <= version) {
+            zwp_text_input_manager = wl_registry_bind(wl_registry, name, &zwp_text_input_manager_v3_interface, versionToBind);
+        }
     }
 
 #ifdef WAKEFIELD_ROBOT
@@ -710,6 +764,10 @@ initJavaRefs(JNIEnv *env, jclass clazz)
                                                                                     "dispatchKeyboardModifiersEvent",
                                                                                     "(J)V"),
                       JNI_FALSE);
+    CHECK_NULL_RETURN(dispatchRelativePointerEventMID = (*env)->GetStaticMethodID(env, tkClass,
+                                                                          "dispatchRelativePointerEvent",
+                                                                          "(DD)V"),
+                      JNI_FALSE);
 
     jclass wlgeClass = (*env)->FindClass(env, "sun/awt/wl/WLGraphicsEnvironment");
     CHECK_NULL_RETURN(wlgeClass, JNI_FALSE);

src/java.desktop/unix/native/libawt_wlawt/WLToolkit.h

@@ -30,6 +30,8 @@
 #include "xdg-output-unstable-v1.h"
 #include "primary-selection-unstable-v1.h"
 #include "viewporter.h"
+#include "relative-pointer-unstable-v1.h"
+#include "text-input-unstable-v3.h"
 #include "jvm_md.h"
 #include "jni_util.h"
 
@@ -66,6 +68,8 @@ extern struct wl_cursor_theme *wl_cursor_theme;
 extern struct wl_data_device_manager *wl_ddm;
 extern struct zwp_primary_selection_device_manager_v1 *zwp_selection_dm; // optional, check for NULL before use
 extern struct zxdg_output_manager_v1 *zxdg_output_manager_v1; // optional, check for NULL before use
+extern struct zwp_relative_pointer_manager_v1* relative_pointer_manager;
+extern struct zwp_text_input_manager_v3 *zwp_text_input_manager; // optional, check for NULL before use
 
 JNIEnv *getEnv();
 

src/java.desktop/unix/native/libawt_wlawt/im/text-input-unstable-v3/WLInputMethod.c

@@ -0,0 +1,687 @@
+/*
+ * Copyright 2025 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include "sun_awt_wl_im_text_input_unstable_v3_WLInputMethodDescriptorZwpTextInputV3.h"
+#include "sun_awt_wl_im_text_input_unstable_v3_WLInputMethodZwpTextInputV3.h"
+#include "WLToolkit.h"      // wl_seat, zwp_text_input_*, uint[...]_t, int[...]_t
+#include "JNIUtilities.h"
+
+#include <stdbool.h>        // bool, true, false
+#include <string.h>         // memset, strlen
+#include <stdlib.h>         // malloc, free
+#include <assert.h>         // assert
+
+
+static bool checkIfTheImplementationIsAvailable() {
+    return (zwp_text_input_manager == NULL) ? false : true;
+}
+
+static struct {
+    jclass wlInputMethodClass;
+
+    /// `sun.awt.wl.im.text_input_unstable_v3.WLInputMethodZwpTextInputV3#zwp_text_input_v3_onEnter`
+    jmethodID mID_tiOnEnter;
+    /// `sun.awt.wl.im.text_input_unstable_v3.WLInputMethodZwpTextInputV3#zwp_text_input_v3_onLeave`
+    jmethodID mID_tiOnLeave;
+    /// `sun.awt.wl.im.text_input_unstable_v3.WLInputMethodZwpTextInputV3#zwp_text_input_v3_onPreeditString`
+    jmethodID mID_tiOnPreeditString;
+    /// `sun.awt.wl.im.text_input_unstable_v3.WLInputMethodZwpTextInputV3#zwp_text_input_v3_onCommitString`
+    jmethodID mID_tiOnCommitString;
+    /// `sun.awt.wl.im.text_input_unstable_v3.WLInputMethodZwpTextInputV3#zwp_text_input_v3_onDeleteSurroundingText`
+    jmethodID mID_tiOnDeleteSurroundingText;
+    /// `sun.awt.wl.im.text_input_unstable_v3.WLInputMethodZwpTextInputV3#zwp_text_input_v3_onDone`
+    jmethodID mID_tiOnDone;
+} jniIDs = {0};
+
+
+// ================================================= IMContext section ================================================
+static void IMContext_zwp_text_input_v3_onEnter(void*, struct zwp_text_input_v3*, struct wl_surface*);
+static void IMContext_zwp_text_input_v3_onLeave(void*, struct zwp_text_input_v3*, struct wl_surface*);
+static void IMContext_zwp_text_input_v3_onPreeditString(void*, struct zwp_text_input_v3*, const char*, int32_t, int32_t);
+static void IMContext_zwp_text_input_v3_onCommitString(void*, struct zwp_text_input_v3*, const char*);
+static void IMContext_zwp_text_input_v3_onDeleteSurroundingText(void*, struct zwp_text_input_v3*, uint32_t, uint32_t);
+static void IMContext_zwp_text_input_v3_onDone(void*, struct zwp_text_input_v3*, uint32_t);
+
+static const struct zwp_text_input_v3_listener IMContext_zwp_text_input_v3_listener = {
+    .enter = &IMContext_zwp_text_input_v3_onEnter,
+    .leave = &IMContext_zwp_text_input_v3_onLeave,
+    .preedit_string = &IMContext_zwp_text_input_v3_onPreeditString,
+    .commit_string = &IMContext_zwp_text_input_v3_onCommitString,
+    .delete_surrounding_text = &IMContext_zwp_text_input_v3_onDeleteSurroundingText,
+    .done = &IMContext_zwp_text_input_v3_onDone,
+};
+
+/**
+ * The native-side counterpart of `sun.awt.wl.im.text_input_unstable_v3.WLInputMethodZwpTextInputV3`.
+ * On Java side these contexts are created and destroyed through
+ * `WLInputMethod#createNativeContext` and `WLInputMethod#destroyNativeContext` respectively.
+ *
+ * `IMContext` and `WLInputMethodZwpTextInputV3` are related in a 1:1 ratio - an instance of `WLInputMethodZwpTextInputV3` holds no more than 1
+ * instance of `IMContext` and an instance of `IMContext` only belongs to 1 instance of `WLInputMethodZwpTextInputV3`.
+ */
+struct IMContext {
+    /// A global reference to the instance of `sun.awt.wl.im.text_input_unstable_v3.WLInputMethodZwpTextInputV3` owning this instance of `IMContext`.
+    jobject wlInputMethodOwner;
+
+    /// Represents an input context for the entire `text-input-unstable-v3` protocol.
+    struct zwp_text_input_v3 *textInput;
+};
+
+/**
+ * Creates and fully initializes an instance of `struct IMContext`.
+ *
+ * @param wlInputMethodOwnerRefToCopy a reference to the owning instance of `sun.awt.wl.im.text_input_unstable_v3.WLInputMethodZwpTextInputV3`.
+ *                                    NB: the reference will be copied via `NewGlobalRef` and no longer used.
+ * @return `null` if it has failed to create or completely initialize a new instance.
+ *         In this case a corresponding exception of class `java.awt.AWTException` or of an unchecked exception class
+ *         will be raised in @p env
+ */
+static struct IMContext* IMContext_Create(JNIEnv * const env, jobject wlInputMethodOwnerRefToCopy) {
+    struct wl_seat * const wlSeat = wl_seat;
+    struct zwp_text_input_manager_v3 * const textInputManager = zwp_text_input_manager;
+
+    struct IMContext *result = NULL;
+    jobject wlInputMethodOwner = NULL;
+    struct zwp_text_input_v3 *textInput = NULL;
+
+    if (wlSeat == NULL) {
+        JNU_ThrowByName(env, "java/awt/AWTException", "IMContext_Create: no wl_seat is available");
+        goto failure;
+    }
+
+    if (textInputManager == NULL) {
+        JNU_ThrowNullPointerException(env, "IMContext_Create: textInputManager is NULL");
+        goto failure;
+    }
+
+    wlInputMethodOwner = (*env)->NewGlobalRef(env, wlInputMethodOwnerRefToCopy);
+    if (wlInputMethodOwner == NULL) {
+        if ((*env)->ExceptionCheck(env) == JNI_FALSE) {
+            JNU_ThrowOutOfMemoryError(env, "IMContext_Create: NewGlobalRef(wlInputMethodOwnerRefToCopy) failed");
+        }
+        goto failure;
+    }
+
+    wlInputMethodOwnerRefToCopy = NULL; // To avoid misusages
+
+    result = malloc(sizeof(struct IMContext));
+    if (result == NULL) {
+        JNU_ThrowOutOfMemoryError(env, "IMContext_Create: malloc(sizeof(struct IMContext)) failed");
+        goto failure;
+    }
+
+    textInput = zwp_text_input_manager_v3_get_text_input(textInputManager, wlSeat);
+    if (textInput == NULL) {
+        JNU_ThrowByName(env, "java/awt/AWTException", "IMContext_Create: failed to obtain a new instance of zwp_text_input_v3");
+        goto failure;
+    }
+
+    // WLToolkit dispatches (almost) all native Wayland events on EDT, not on its thread.
+    // If it didn't, the callbacks being set here might be called even before this function finishes, hence even before
+    //   the constructor of `sun.awt.wl.im.text_input_unstable_v3.WLInputMethodZwpTextInputV3` finishes (because the constructor gets called on the
+    //   EDT rather than on the toolkit thread).
+    // In that case we would have to take it into account while implementing the callbacks and
+    //   `WLInputMethodZwpTextInputV3` class in general.
+    zwp_text_input_v3_add_listener(textInput, &IMContext_zwp_text_input_v3_listener, result);
+
+    (void)memset(result, 0, sizeof(struct IMContext));
+
+    result->wlInputMethodOwner = wlInputMethodOwner;
+    result->textInput = textInput;
+
+    return result;
+
+failure:
+    if (textInput != NULL) {
+        zwp_text_input_v3_destroy(textInput);
+        textInput = NULL;
+    }
+
+    if (result != NULL) {
+        free(result);
+        result = NULL;
+    }
+
+    if (wlInputMethodOwner != NULL) {
+        (*env)->DeleteGlobalRef(env, wlInputMethodOwner);
+        wlInputMethodOwner = NULL;
+    }
+
+    return NULL;
+}
+
+/// Destroys the context previously created by IMContext_Create
+static void IMContext_Destroy(JNIEnv * const env, struct IMContext * const imContext) {
+    assert(env != NULL);
+    assert(imContext != NULL);
+
+    if (imContext->textInput != NULL) {
+        zwp_text_input_v3_destroy(imContext->textInput);
+        imContext->textInput = NULL;
+    }
+
+    if (imContext->wlInputMethodOwner != NULL) {
+        (*env)->DeleteGlobalRef(env, imContext->wlInputMethodOwner);
+        imContext->wlInputMethodOwner = NULL;
+    }
+
+    free(imContext);
+}
+
+
+// The IMContext_zwp_text_input_v3_on* callbacks are supposed to be as a thin bridge to
+// `WLInputMethodZwpTextInputV3`'s JNI upcalls as possible in terms of contained logic.
+// Generally they should only invoke the corresponding upcalls with the received parameters.
+//
+// Exceptions after making JNI upcalls to WLInputMethodZwpTextInputV3 are checked (via JNU_CHECK_EXCEPTION),
+//   but not suppressed on a purpose: all the corresponding Java methods already handles any java.lang.Exception.
+//   So if an exception leaves any of those methods, it's something really strange and it's better to let WLToolkit
+//   get to know about it rather than log and try to continue the normal path.
+//   The checks are just made to suppress -Xcheck:jni warnings.
+
+static void IMContext_zwp_text_input_v3_onEnter(
+    void * const ctx,
+    struct zwp_text_input_v3 * const textInput,
+    struct wl_surface * const surface
+) {
+    const struct IMContext * const imContext = ctx;
+    JNIEnv *env = NULL;
+
+    if (imContext == NULL) {
+        return;
+    }
+
+    env = getEnv();
+    if (env == NULL) {
+        return;
+    }
+
+    (*env)->CallVoidMethod(env, imContext->wlInputMethodOwner, jniIDs.mID_tiOnEnter, ptr_to_jlong(surface));
+    JNU_CHECK_EXCEPTION(env);
+}
+
+static void IMContext_zwp_text_input_v3_onLeave(
+    void * const ctx,
+    struct zwp_text_input_v3 * const textInput,
+    struct wl_surface * const surface
+) {
+    const struct IMContext * const imContext = ctx;
+    JNIEnv *env = NULL;
+
+    if (imContext == NULL) {
+        return;
+    }
+
+    env = getEnv();
+    if (env == NULL) {
+        return;
+    }
+
+    (*env)->CallVoidMethod(env, imContext->wlInputMethodOwner, jniIDs.mID_tiOnLeave, ptr_to_jlong(surface));
+    JNU_CHECK_EXCEPTION(env);
+}
+
+
+/**
+ * Converts a UTF-8 string to a Java byte array, throwing an OutOfMemoryError if the allocation fails. Another kind
+ * of exceptions may also appear, according to the implementation of 'NewByteArray' and 'SetByteArrayRegion'.
+ * Regardless of the returned value, always check 'env->ExceptionCheck()' after each call of this function.
+ *
+ * @param utf8Str UTF-8 string to convert.
+ * @param utf8StrSizeInBytes size of the UTF-8 string in bytes, or a negative value to ask the function to
+ *                           calculate it manually.
+ * @param env JNI environment. Mustn't be NULL.
+ * @param oomMessage message to use in the OutOfMemoryError exception if it appears. Mustn't be NULL.
+ *
+ * @return a local JNI reference to a Java byte array or NULL if 'utf8Str' is NULL,
+ *                                                            an exception occurred,
+ *                                                            or 'NewByteArray' returned NULL for some other reason.
+ */
+static jbyteArray utf8StrToJByteArrayOrThrowOOM(
+    const char * const utf8Str,
+    ssize_t utf8StrSizeInBytes,
+    JNIEnv * const env,
+    const char * const oomMessage
+) {
+    jbyteArray result = NULL;
+
+    assert(env != NULL);
+    assert(oomMessage != NULL);
+
+    if (utf8Str == NULL) {
+        return NULL;
+    }
+
+    if (utf8StrSizeInBytes < 0) {
+        // Let's believe there's a trailing NUL codepoint (otherwise we can't calculate the string's size), and
+        //   there are no NUL codepoints in the middle, though it's possible in general for UTF-8.
+        utf8StrSizeInBytes = (ssize_t)(strlen(utf8Str) + 1);
+    }
+
+    result = (*env)->NewByteArray(env, (jsize)utf8StrSizeInBytes);
+    if (result == NULL) {
+        if ((*env)->ExceptionCheck(env) == JNI_FALSE) {
+            JNU_ThrowOutOfMemoryError(env, oomMessage);
+        }
+    } else {
+        (*env)->SetByteArrayRegion(
+            env,
+            result,
+            0,
+            (jsize)utf8StrSizeInBytes,
+            (const jbyte*)utf8Str
+        );
+    }
+
+    return result;
+}
+
+
+static void IMContext_zwp_text_input_v3_onPreeditString(
+    void * const ctx,
+    struct zwp_text_input_v3 * const textInput,
+    const char * const preeditStringUtf8,
+    const int32_t cursorBeginUtf8Byte,
+    const int32_t cursorEndUtf8Byte
+) {
+    const struct IMContext * const imContext = ctx;
+    JNIEnv *env = NULL;
+    jbyteArray preeditStringUtf8Bytes = NULL;
+
+    if (imContext == NULL) {
+        return;
+    }
+
+    env = getEnv();
+    if (env == NULL) {
+        return;
+    }
+
+    // may still be NULL
+    preeditStringUtf8Bytes = utf8StrToJByteArrayOrThrowOOM(
+        preeditStringUtf8,
+        // the zwp_text_input_v3::preedit_string event doesn't provide the length or size of the string separately,
+        //   asking the function to manually calculate it.
+        -1,
+        env,
+        "IMContext_zwp_text_input_v3_onPreeditString: failed to allocate a new Java byte array"
+    );
+
+    if ((*env)->ExceptionCheck(env) == JNI_TRUE) {
+        return;
+    }
+
+    (*env)->CallVoidMethod(
+        env,
+        imContext->wlInputMethodOwner,
+        jniIDs.mID_tiOnPreeditString,
+        preeditStringUtf8Bytes,
+        (jint)cursorBeginUtf8Byte,
+        (jint)cursorEndUtf8Byte
+    );
+    JNU_CHECK_EXCEPTION(env);
+}
+
+static void IMContext_zwp_text_input_v3_onCommitString(
+    void * const ctx,
+    struct zwp_text_input_v3 * const textInput,
+    const char * const commitStringUtf8
+) {
+    const struct IMContext * const imContext = ctx;
+    JNIEnv *env = NULL;
+    jbyteArray commitStringUtf8Bytes = NULL;
+
+    if (imContext == NULL) {
+        return;
+    }
+
+    env = getEnv();
+    if (env == NULL) {
+        return;
+    }
+
+    // may still be NULL
+    commitStringUtf8Bytes = utf8StrToJByteArrayOrThrowOOM(
+        commitStringUtf8,
+        // the zwp_text_input_v3::commit_string event doesn't provide the length or size of the string separately,
+        //   asking the function to manually calculate it.
+        -1,
+        env,
+        "IMContext_zwp_text_input_v3_onCommitString: failed to allocate a new Java byte array"
+    );
+
+    if ((*env)->ExceptionCheck(env) == JNI_TRUE) {
+        return;
+    }
+
+    (*env)->CallVoidMethod(env, imContext->wlInputMethodOwner, jniIDs.mID_tiOnCommitString, commitStringUtf8Bytes);
+    JNU_CHECK_EXCEPTION(env);
+}
+
+static void IMContext_zwp_text_input_v3_onDeleteSurroundingText(
+    void * const ctx,
+    struct zwp_text_input_v3 * const textInput,
+    const uint32_t numberOfUtf8BytesBeforeToDelete,
+    const uint32_t numberOfUtf8BytesAfterToDelete
+) {
+    const struct IMContext * const imContext = ctx;
+    JNIEnv *env = NULL;
+
+    if (imContext == NULL) {
+        return;
+    }
+
+    env = getEnv();
+    if (env == NULL) {
+        return;
+    }
+
+    if ((*env)->ExceptionCheck(env) == JNI_TRUE) {
+        return;
+    }
+
+    (*env)->CallVoidMethod(
+       env,
+       imContext->wlInputMethodOwner,
+       jniIDs.mID_tiOnDeleteSurroundingText,
+       (jlong)numberOfUtf8BytesBeforeToDelete,
+       (jlong)numberOfUtf8BytesAfterToDelete
+    );
+    JNU_CHECK_EXCEPTION(env);
+}
+
+static void IMContext_zwp_text_input_v3_onDone(
+    void *const ctx,
+    struct zwp_text_input_v3 * const textInput,
+    const uint32_t serial
+) {
+    const struct IMContext * const imContext = ctx;
+    JNIEnv *env = NULL;
+
+    if (imContext == NULL) {
+        return;
+    }
+
+    env = getEnv();
+    if (env == NULL) {
+        return;
+    }
+
+    (*env)->CallVoidMethod(env, imContext->wlInputMethodOwner, jniIDs.mID_tiOnDone, (jlong)serial);
+    JNU_CHECK_EXCEPTION(env);
+}
+// ============================================= END of IMContext section =============================================
+
+
+// =============================================== JNI downcalls section ==============================================
+
+JNIEXPORT jboolean JNICALL
+Java_sun_awt_wl_im_text_1input_1unstable_1v3_WLInputMethodDescriptorZwpTextInputV3_checkIfAvailableOnPlatform(JNIEnv * const env, const jclass clazz) {
+    return checkIfTheImplementationIsAvailable() ? JNI_TRUE : JNI_FALSE;
+}
+
+
+JNIEXPORT void JNICALL
+Java_sun_awt_wl_im_text_1input_1unstable_1v3_WLInputMethodZwpTextInputV3_initIDs(JNIEnv * const env, const jclass clazz) {
+    CHECK_NULL_THROW_OOME(
+        env,
+        jniIDs.wlInputMethodClass = (*env)->NewGlobalRef(env, clazz),
+        "Allocation of a global reference to sun.awt.wl.im.text_input_unstable_v3.WLInputMethodZwpTextInputV3 class failed"
+    );
+
+    jniIDs.mID_tiOnEnter =
+        (*env)->GetMethodID(env, jniIDs.wlInputMethodClass, "zwp_text_input_v3_onEnter", "(J)V");
+    if (jniIDs.mID_tiOnEnter == NULL) {
+        // DeleteGlobalRef is one of the few JNI functions that are safe to call while there's a pending exception
+        (*env)->DeleteGlobalRef(env, jniIDs.wlInputMethodClass);
+        (void)memset(&jniIDs, 0, sizeof(jniIDs));
+        return;
+    }
+
+    jniIDs.mID_tiOnLeave =
+        (*env)->GetMethodID(env, jniIDs.wlInputMethodClass, "zwp_text_input_v3_onLeave", "(J)V");
+    if (jniIDs.mID_tiOnLeave == NULL) {
+        (*env)->DeleteGlobalRef(env, jniIDs.wlInputMethodClass);
+        (void)memset(&jniIDs, 0, sizeof(jniIDs));
+        return;
+    }
+
+    jniIDs.mID_tiOnPreeditString =
+        (*env)->GetMethodID(env, jniIDs.wlInputMethodClass, "zwp_text_input_v3_onPreeditString", "([BII)V");
+    if (jniIDs.mID_tiOnPreeditString == NULL) {
+        (*env)->DeleteGlobalRef(env, jniIDs.wlInputMethodClass);
+        (void)memset(&jniIDs, 0, sizeof(jniIDs));
+        return;
+    }
+
+    jniIDs.mID_tiOnCommitString =
+        (*env)->GetMethodID(env, jniIDs.wlInputMethodClass, "zwp_text_input_v3_onCommitString", "([B)V");
+    if (jniIDs.mID_tiOnCommitString == NULL) {
+        (*env)->DeleteGlobalRef(env, jniIDs.wlInputMethodClass);
+        (void)memset(&jniIDs, 0, sizeof(jniIDs));
+        return;
+    }
+
+    jniIDs.mID_tiOnDeleteSurroundingText =
+        (*env)->GetMethodID(env, jniIDs.wlInputMethodClass, "zwp_text_input_v3_onDeleteSurroundingText", "(JJ)V");
+    if (jniIDs.mID_tiOnDeleteSurroundingText == NULL) {
+        (*env)->DeleteGlobalRef(env, jniIDs.wlInputMethodClass);
+        (void)memset(&jniIDs, 0, sizeof(jniIDs));
+        return;
+    }
+
+    jniIDs.mID_tiOnDone =
+        (*env)->GetMethodID(env, jniIDs.wlInputMethodClass, "zwp_text_input_v3_onDone", "(J)V");
+    if (jniIDs.mID_tiOnDone == NULL) {
+        (*env)->DeleteGlobalRef(env, jniIDs.wlInputMethodClass);
+        (void)memset(&jniIDs, 0, sizeof(jniIDs));
+        return;
+    }
+}
+
+
+JNIEXPORT jlong JNICALL
+Java_sun_awt_wl_im_text_1input_1unstable_1v3_WLInputMethodZwpTextInputV3_createNativeContext(JNIEnv * const env, const jobject self) {
+    struct IMContext *result = NULL;
+
+    if (!checkIfTheImplementationIsAvailable()) {
+        JNU_ThrowByName(env, "java/awt/AWTException", "sun.awt.wl.im.text_input_unstable_v3.WLInputMethodZwpTextInputV3 is not supported on this system");
+        return 0;
+    }
+
+    result = IMContext_Create(env, self);
+
+    return ptr_to_jlong(result);
+}
+
+JNIEXPORT void JNICALL
+Java_sun_awt_wl_im_text_1input_1unstable_1v3_WLInputMethodZwpTextInputV3_disposeNativeContext(
+    JNIEnv * const env,
+    const jclass clazz,
+    const jlong contextPtr
+) {
+    struct IMContext *imContext = jlong_to_ptr(contextPtr);
+
+    if (imContext == NULL) {
+        JNU_ThrowNullPointerException(env, "contextPtr");
+        return;
+    }
+
+    IMContext_Destroy(env, imContext);
+    imContext = NULL;
+}
+
+JNIEXPORT void JNICALL
+Java_sun_awt_wl_im_text_1input_1unstable_1v3_WLInputMethodZwpTextInputV3_zwp_1text_1input_1v3_1enable(
+    JNIEnv * const env,
+    const jobject self,
+    const jlong contextPtr
+) {
+    const struct IMContext * const imContext = jlong_to_ptr(contextPtr);
+    struct zwp_text_input_v3 *textInput = NULL;
+
+    if (imContext == NULL) {
+        JNU_ThrowNullPointerException(env, "contextPtr");
+        return;
+    }
+
+    textInput = imContext->textInput;
+    if (textInput == NULL) {
+        JNU_ThrowByName(env, "java/lang/IllegalStateException", "textInput == NULL");
+        return;
+    }
+
+    zwp_text_input_v3_enable(textInput);
+}
+
+JNIEXPORT void JNICALL
+Java_sun_awt_wl_im_text_1input_1unstable_1v3_WLInputMethodZwpTextInputV3_zwp_1text_1input_1v3_1disable(
+    JNIEnv * const env,
+    const jobject self,
+    const jlong contextPtr
+) {
+    const struct IMContext * const imContext = jlong_to_ptr(contextPtr);
+    struct zwp_text_input_v3 *textInput = NULL;
+
+    if (imContext == NULL) {
+        JNU_ThrowNullPointerException(env, "contextPtr");
+        return;
+    }
+
+    textInput = imContext->textInput;
+    if (textInput == NULL) {
+        JNU_ThrowByName(env, "java/lang/IllegalStateException", "textInput == NULL");
+        return;
+    }
+
+    zwp_text_input_v3_disable(textInput);
+}
+
+JNIEXPORT void JNICALL
+Java_sun_awt_wl_im_text_1input_1unstable_1v3_WLInputMethodZwpTextInputV3_zwp_1text_1input_1v3_1set_1cursor_1rectangle(
+    JNIEnv * const env,
+    const jobject self,
+    const jlong contextPtr,
+    const jint surfaceLocalX,
+    const jint surfaceLocalY,
+    const jint width,
+    const jint height
+) {
+    const struct IMContext * const imContext = jlong_to_ptr(contextPtr);
+    struct zwp_text_input_v3 *textInput = NULL;
+
+    if (imContext == NULL) {
+        JNU_ThrowNullPointerException(env, "contextPtr");
+        return;
+    }
+
+    textInput = imContext->textInput;
+    if (textInput == NULL) {
+        JNU_ThrowByName(env, "java/lang/IllegalStateException", "textInput == NULL");
+        return;
+    }
+
+    zwp_text_input_v3_set_cursor_rectangle(
+        textInput,
+        (int32_t)surfaceLocalX,
+        (int32_t)surfaceLocalY,
+        (int32_t)width,
+        (int32_t)height
+    );
+}
+
+JNIEXPORT void JNICALL
+Java_sun_awt_wl_im_text_1input_1unstable_1v3_WLInputMethodZwpTextInputV3_zwp_1text_1input_1v3_1set_1content_1type(
+    JNIEnv * const env,
+    const jobject self,
+    const jlong contextPtr,
+    const jint hint,
+    const jint purpose
+) {
+    const struct IMContext * const imContext = jlong_to_ptr(contextPtr);
+    struct zwp_text_input_v3 *textInput = NULL;
+
+    if (imContext == NULL) {
+        JNU_ThrowNullPointerException(env, "contextPtr");
+        return;
+    }
+
+    textInput = imContext->textInput;
+    if (textInput == NULL) {
+        JNU_ThrowByName(env, "java/lang/IllegalStateException", "textInput == NULL");
+        return;
+    }
+
+    zwp_text_input_v3_set_content_type(textInput, (uint32_t)hint, (uint32_t)purpose);
+}
+
+JNIEXPORT void JNICALL
+Java_sun_awt_wl_im_text_1input_1unstable_1v3_WLInputMethodZwpTextInputV3_zwp_1text_1input_1v3_1set_1text_1change_1cause(
+    JNIEnv * const env,
+    const jobject self,
+    const jlong contextPtr,
+    const jint changeCause
+) {
+    const struct IMContext * const imContext = jlong_to_ptr(contextPtr);
+    struct zwp_text_input_v3 *textInput = NULL;
+
+    if (imContext == NULL) {
+        JNU_ThrowNullPointerException(env, "contextPtr");
+        return;
+    }
+
+    textInput = imContext->textInput;
+    if (textInput == NULL) {
+        JNU_ThrowByName(env, "java/lang/IllegalStateException", "textInput == NULL");
+        return;
+    }
+
+    zwp_text_input_v3_set_text_change_cause(textInput, (uint32_t)changeCause);
+}
+
+JNIEXPORT void JNICALL
+Java_sun_awt_wl_im_text_1input_1unstable_1v3_WLInputMethodZwpTextInputV3_zwp_1text_1input_1v3_1commit(
+    JNIEnv * const env,
+    const jobject self,
+    const jlong contextPtr
+) {
+    const struct IMContext * const imContext = jlong_to_ptr(contextPtr);
+    struct zwp_text_input_v3 *textInput = NULL;
+
+    if (imContext == NULL) {
+        JNU_ThrowNullPointerException(env, "contextPtr");
+        return;
+    }
+
+    textInput = imContext->textInput;
+    if (textInput == NULL) {
+        JNU_ThrowByName(env, "java/lang/IllegalStateException", "textInput == NULL");
+        return;
+    }
+
+    zwp_text_input_v3_commit(textInput);
+}
+
+// =========================================== END of JNI downcalls section ===========================================

src/java.desktop/windows/classes/sun/awt/windows/AccessibleCaretLocationNotifier.java

@@ -0,0 +1,173 @@
+/*
+ * Copyright 2024 JetBrains s.r.o.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.awt.windows;
+
+import sun.awt.AWTAccessor;
+import sun.java2d.SunGraphicsEnvironment;
+
+import javax.swing.*;
+import javax.swing.event.CaretEvent;
+import javax.swing.event.CaretListener;
+import javax.swing.text.JTextComponent;
+import java.awt.*;
+import java.awt.im.InputMethodRequests;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.lang.ref.WeakReference;
+
+/**
+ * Provides caret tracking support for assistive tools that don't work with Java Access Bridge.
+ * Specifically, it's targeted for the built-in Windows Magnifier.
+ * This class listens to caret change events of the currently focused JTextComponent
+ * and forwards them to the native code, which then sends them as Win32 IAccessible events.
+ * <p>
+ * A typical high-level scenario of the interaction with the magnifier:
+ * <ol>
+ * <li>Magnifier sends a WM_GETOBJECT window message to get accessible content of the window.</li>
+ * <li>The message is handled in AwtComponent native class (awt_Component.cpp),
+ *     which calls {@link #startCaretNotifier}.</li>
+ * <li>We start listening for keyboard focus change events.</li>
+ * <li>If at some point focus gets to a {@link JTextComponent}, we subscribe to its caret events.</li>
+ * <li>When the caret changes, we need to move the magnifier viewport to the new caret location.
+ *     To achieve this, we create a Win32 IAccessible object for the caret (see AccessibleCaret.cpp)
+ *     and send an event that its location was changed (EVENT_OBJECT_LOCATIONCHANGE).</li>
+ * <li>Magnifier receives this event and sends the WM_GETOBJECT message with the OBJID_CARET argument
+ *     to get the caret object and its location property. After that, it moves the viewport to the returned location.
+ * </li>
+ * <li>When the {@link JTextComponent} loses focus, we stop listening to caret events
+ *     and release the IAccessible caret object.</li>
+ * </ol>
+ * </p>
+ * <p>
+ * The feature is enabled by default
+ * and can be toggled by setting the sun.awt.windows.use.native.caret.accessibility.events property.
+ * </p>
+ */
+@SuppressWarnings("unused") // Used from the native side through JNI.
+class AccessibleCaretLocationNotifier implements PropertyChangeListener, CaretListener {
+    private volatile static AccessibleCaretLocationNotifier caretNotifier;
+    private static final boolean nativeCaretEventsEnabled =
+            Boolean.parseBoolean(System.getProperty("sun.awt.windows.use.native.caret.accessibility.events", "true"));
+
+    private WeakReference<JTextComponent> currentFocusedComponent;
+    private long currentHwnd;
+
+    @SuppressWarnings("unused") // Called from the native through JNI.
+    public static void startCaretNotifier(long hwnd) {
+        if (nativeCaretEventsEnabled && caretNotifier == null) {
+            SwingUtilities.invokeLater(() -> {
+                if (caretNotifier == null) {
+                    caretNotifier = new AccessibleCaretLocationNotifier(hwnd);
+                    KeyboardFocusManager cfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
+                    cfm.addPropertyChangeListener("focusOwner", caretNotifier);
+                    if (cfm.getFocusOwner() instanceof JTextComponent textComponent) {
+                        caretNotifier.propertyChange(new PropertyChangeEvent(caretNotifier, "focusOwner", null, textComponent));
+                    }
+                }
+            });
+        }
+    }
+
+    public AccessibleCaretLocationNotifier(long hwnd) {
+        currentHwnd = hwnd;
+    }
+
+    private static native void updateNativeCaretLocation(long hwnd, int x, int y, int width, int height);
+    private static native void releaseNativeCaret(long hwnd);
+
+    @Override
+    public void propertyChange(PropertyChangeEvent e) {
+        Window w = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusedWindow();
+        if (w != null) {
+            WWindowPeer wp = AWTAccessor.getComponentAccessor().getPeer(w);
+            if (wp != null) {
+                long hwnd = wp.getHWnd();
+                if (currentHwnd != hwnd) {
+                    currentHwnd = hwnd;
+                }
+            }
+        }
+
+        Object newFocusedComponent = e.getNewValue();
+        if (currentFocusedComponent != null) {
+            JTextComponent currentComponentStrong = currentFocusedComponent.get();
+            if (currentComponentStrong != null && newFocusedComponent != currentComponentStrong) {
+                currentComponentStrong.removeCaretListener(this);
+                currentFocusedComponent.clear();
+                currentFocusedComponent = null;
+                releaseNativeCaret(currentHwnd);
+            }
+        }
+
+        if (newFocusedComponent instanceof JTextComponent textComponent) {
+            currentFocusedComponent = new WeakReference<>(textComponent);
+            textComponent.addCaretListener(this);
+            // Trigger the caret event when the text component receives focus to notify about the initial caret location
+            caretUpdate(new CaretEvent(textComponent) {
+                // Dot and mark won't be used, so we can set any values.
+                @Override
+                public int getDot() { return 0; }
+
+                @Override
+                public int getMark() { return 0; }
+            });
+        }
+    }
+
+    @Override
+    public void caretUpdate(CaretEvent e) {
+        if (!(e.getSource() instanceof JTextComponent textComponent)) {
+            return;
+        }
+
+        SwingUtilities.invokeLater(() -> {
+            if (!textComponent.isShowing()) return;
+            InputMethodRequests imr = textComponent.getInputMethodRequests();
+            if (imr == null) return;
+            Rectangle caretRectangle = imr.getTextLocation(null);
+            if (caretRectangle == null) return;
+            caretRectangle.width = 1;
+
+            Container parent = textComponent.getParent();
+            if (parent != null && parent.isShowing()) {
+                // Make sure we don't go outside of parent bounds, which can happen in the case of scrollable components.
+                Rectangle parentBounds = parent.getBounds();
+                parentBounds.setLocation(parent.getLocationOnScreen());
+
+                if (!parentBounds.contains(caretRectangle)) {
+                    caretRectangle = parentBounds.intersection(caretRectangle);
+                    if (caretRectangle.isEmpty()) return;
+                }
+            }
+
+            caretRectangle = SunGraphicsEnvironment.toDeviceSpaceAbs(caretRectangle);
+
+            updateNativeCaretLocation(AccessibleCaretLocationNotifier.this.currentHwnd,
+                    (int) caretRectangle.getX(), (int) caretRectangle.getY(),
+                    (int) caretRectangle.getWidth(), (int) caretRectangle.getHeight());
+        });
+    }
+}

src/java.desktop/windows/classes/sun/java2d/d3d/D3DSurfaceData.java

@@ -831,11 +831,11 @@ public class D3DSurfaceData extends SurfaceData implements AccelSurface {
             if (sd.getPeer().getTarget() instanceof Window window) {
                 switch (D3DRenderQueue.getFramePresentedStatus()) {
                     case 1:
-                        AWTAccessor.getWindowAccessor().bumpCounter(window, "java2d.native.framesPresentRequested");
+                        AWTAccessor.getWindowAccessor().incrementCounter(window, "java2d.native.framesPresentRequested");
                         break;
                     case 0:
                     default:
-                        AWTAccessor.getWindowAccessor().bumpCounter(window, "java2d.native.framesPresentFailed");
+                        AWTAccessor.getWindowAccessor().incrementCounter(window, "java2d.native.framesPresentFailed");
                 }
             }
         }

src/java.desktop/windows/native/libawt/windows/AccessibleCaret.cpp

@@ -0,0 +1,317 @@
+/*
+ * Copyright (c) 2024, JetBrains s.r.o.. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include "AccessibleCaret.h"
+#include "debug_assert.h"       // DASSERT
+#include "sun_awt_windows_AccessibleCaretLocationNotifier.h"
+
+#include <atomic>               // std::atomic
+
+
+/**
+ * This class implements Win32 IAccessible interface in a similar way to the system text caret.
+ */
+
+static std::atomic<AccessibleCaret *> GLOBAL_INSTANCE{nullptr};
+
+AccessibleCaret* AccessibleCaret::getInstanceIfPresent() noexcept {
+    return GLOBAL_INSTANCE.load();
+}
+
+AccessibleCaret* AccessibleCaret::getOrCreateInstance() {
+    bool unused;
+    return AccessibleCaret::getOrCreateInstance(unused);
+}
+
+AccessibleCaret* AccessibleCaret::getOrCreateInstance(bool& instanceIsNew) {
+    instanceIsNew = false;
+
+    AccessibleCaret* result = GLOBAL_INSTANCE.load();
+
+    if (result == nullptr) {
+        AccessibleCaret* newInstance = new AccessibleCaret();
+
+        if (GLOBAL_INSTANCE.compare_exchange_strong(result, newInstance)) {
+            result = newInstance;
+            instanceIsNew = true;
+        } else {
+            DASSERT(result != nullptr);
+            delete newInstance;
+        }
+    }
+
+    DASSERT(result != nullptr);
+    return result;
+}
+
+bool AccessibleCaret::releaseInstanceIfPresent() {
+    AccessibleCaret* instance = GLOBAL_INSTANCE.exchange(nullptr);
+    if (instance != nullptr) {
+        instance->Release();
+        return true;
+    }
+    return false;
+}
+
+
+AccessibleCaret::AccessibleCaret()
+    : m_refCount(1), m_x(0), m_y(0), m_width(0), m_height(0) {
+    InitializeCriticalSection(&m_caretLocationLock);
+}
+
+AccessibleCaret::~AccessibleCaret() {
+    DeleteCriticalSection(&m_caretLocationLock);
+
+    // If the destroyed object is being referred by the singleton variable, the latter should be cleared.
+    // This case should never happen, but if it does, it's better not to leave a dangling pointer.
+    AccessibleCaret* self = this;
+    (void)GLOBAL_INSTANCE.compare_exchange_strong(self, nullptr);
+}
+
+
+// IUnknown methods
+IFACEMETHODIMP_(ULONG) AccessibleCaret::AddRef() {
+    return InterlockedIncrement(&m_refCount);
+}
+
+IFACEMETHODIMP_(ULONG) AccessibleCaret::Release() {
+    ULONG count = InterlockedDecrement(&m_refCount);
+    if (count == 0) {
+        delete this;
+    }
+    return count;
+}
+
+IFACEMETHODIMP AccessibleCaret::QueryInterface(REFIID riid, void **ppInterface) {
+    if (ppInterface == nullptr) {
+        return E_POINTER;
+    }
+
+    if (riid == IID_IUnknown || riid == IID_IDispatch || riid == IID_IAccessible) {
+        *ppInterface = static_cast<IAccessible *>(this);
+        AddRef();
+        return S_OK;
+    }
+
+    *ppInterface = nullptr;
+    return E_NOINTERFACE;
+}
+
+// IDispatch methods
+IFACEMETHODIMP AccessibleCaret::GetTypeInfoCount(UINT *pctinfo) {
+    return E_NOTIMPL;
+}
+
+IFACEMETHODIMP AccessibleCaret::GetTypeInfo(UINT itinfo, LCID lcid, ITypeInfo **pptinfo) {
+    return E_NOTIMPL;
+}
+
+IFACEMETHODIMP AccessibleCaret::GetIDsOfNames(REFIID riid, OLECHAR **rgszNames, UINT cNames, LCID lcid,
+                                              DISPID *rgdispid) {
+    return E_NOTIMPL;
+}
+
+IFACEMETHODIMP AccessibleCaret::Invoke(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags,
+                                       DISPPARAMS *pdispparams, VARIANT *pvarResult, EXCEPINFO *pexcepinfo,
+                                       UINT *puArgErr) {
+    return E_NOTIMPL;
+}
+
+// IAccessible methods
+IFACEMETHODIMP AccessibleCaret::get_accParent(IDispatch **ppdispParent) {
+    if (ppdispParent == nullptr) {
+        return E_POINTER;
+    }
+    *ppdispParent = nullptr;
+    return S_FALSE;
+}
+
+IFACEMETHODIMP AccessibleCaret::get_accChildCount(long *pcountChildren) {
+    if (pcountChildren == nullptr) {
+        return E_POINTER;
+    }
+    *pcountChildren = 0;
+    return S_OK;
+}
+
+IFACEMETHODIMP AccessibleCaret::get_accChild(VARIANT varChild, IDispatch **ppdispChild) {
+    if (ppdispChild == nullptr) {
+        return E_POINTER;
+    }
+    *ppdispChild = nullptr;
+    return S_FALSE;
+}
+
+IFACEMETHODIMP AccessibleCaret::get_accName(VARIANT varChild, BSTR *pszName) {
+    if (pszName == nullptr) {
+        return E_POINTER;
+    }
+    *pszName = SysAllocString(L"Edit"); // Same name as the system caret.
+    return S_OK;
+}
+
+IFACEMETHODIMP AccessibleCaret::get_accValue(VARIANT varChild, BSTR *pszValue) {
+    return DISP_E_MEMBERNOTFOUND;
+}
+
+IFACEMETHODIMP AccessibleCaret::get_accDescription(VARIANT varChild, BSTR *pszDescription) {
+    return S_FALSE;
+}
+
+IFACEMETHODIMP AccessibleCaret::get_accRole(VARIANT varChild, VARIANT *pvarRole) {
+    if (pvarRole == nullptr) {
+        return E_POINTER;
+    }
+
+    pvarRole->vt = VT_I4;
+    pvarRole->lVal = ROLE_SYSTEM_CARET;
+    return S_OK;
+}
+
+IFACEMETHODIMP AccessibleCaret::get_accState(VARIANT varChild, VARIANT *pvarState) {
+    if (pvarState == nullptr) {
+        return E_POINTER;
+    }
+
+    pvarState->vt = VT_I4;
+    pvarState->lVal = 0; // The state without any flags, corresponds to "normal".
+    return S_OK;
+}
+
+IFACEMETHODIMP AccessibleCaret::get_accHelp(VARIANT varChild, BSTR *pszHelp) {
+    return S_FALSE;
+}
+
+IFACEMETHODIMP AccessibleCaret::get_accHelpTopic(BSTR *pszHelpFile, VARIANT varChild, long *pidTopic) {
+    return S_FALSE;
+}
+
+IFACEMETHODIMP AccessibleCaret::get_accKeyboardShortcut(VARIANT varChild, BSTR *pszKeyboardShortcut) {
+    return S_FALSE;
+}
+
+IFACEMETHODIMP AccessibleCaret::get_accFocus(VARIANT *pvarChild) {
+    if (pvarChild == nullptr) {
+        return E_POINTER;
+    }
+
+    pvarChild->vt = VT_EMPTY;
+    return S_OK;
+}
+
+IFACEMETHODIMP AccessibleCaret::get_accSelection(VARIANT *pvarChildren) {
+    return DISP_E_MEMBERNOTFOUND;
+}
+
+IFACEMETHODIMP AccessibleCaret::get_accDefaultAction(VARIANT varChild, BSTR *pszDefaultAction) {
+    return S_FALSE;
+}
+
+IFACEMETHODIMP AccessibleCaret::accSelect(long flagsSelect, VARIANT varChild) {
+    return DISP_E_MEMBERNOTFOUND;
+}
+
+IFACEMETHODIMP AccessibleCaret::accLocation(long *pxLeft, long *pyTop, long *pcxWidth, long *pcyHeight,
+                                            VARIANT varChild) {
+    if (pxLeft == nullptr || pyTop == nullptr || pcxWidth == nullptr || pcyHeight == nullptr) {
+        return E_POINTER;
+    }
+
+    EnterCriticalSection(&m_caretLocationLock);
+    *pxLeft = m_x;
+    *pyTop = m_y;
+    *pcxWidth = m_width;
+    *pcyHeight = m_height;
+    LeaveCriticalSection(&m_caretLocationLock);
+
+    return S_OK;
+}
+
+IFACEMETHODIMP AccessibleCaret::accNavigate(long navDir, VARIANT varStart, VARIANT *pvarEndUpAt) {
+    return DISP_E_MEMBERNOTFOUND;
+}
+
+IFACEMETHODIMP AccessibleCaret::accHitTest(long xLeft, long yTop, VARIANT *pvarChild) {
+    return DISP_E_MEMBERNOTFOUND;
+}
+
+IFACEMETHODIMP AccessibleCaret::accDoDefaultAction(VARIANT varChild) {
+    return DISP_E_MEMBERNOTFOUND;
+}
+
+IFACEMETHODIMP AccessibleCaret::put_accName(VARIANT varChild, BSTR szName) {
+    return E_NOTIMPL;
+}
+
+IFACEMETHODIMP AccessibleCaret::put_accValue(VARIANT varChild, BSTR szValue) {
+    return DISP_E_MEMBERNOTFOUND;
+}
+
+void AccessibleCaret::setLocation(long x, long y, long width, long height) {
+    EnterCriticalSection(&m_caretLocationLock);
+    m_x = x;
+    m_y = y;
+    m_width = width;
+    m_height = height;
+    LeaveCriticalSection(&m_caretLocationLock);
+}
+
+
+extern "C" {
+/*
+ * Class:     sun_awt_windows_AccessibleCaretLocationNotifier
+ * Method:    updateNativeCaretLocation
+ * Signature: (JIIII)V
+ */
+JNIEXPORT void JNICALL Java_sun_awt_windows_AccessibleCaretLocationNotifier_updateNativeCaretLocation(
+    JNIEnv *env, jclass jClass,
+    jlong jHwnd, jint x, jint y, jint width, jint height) {
+    HWND hwnd = reinterpret_cast<HWND>(jHwnd);
+
+    bool caretIsNew = false;
+    AccessibleCaret* caret = AccessibleCaret::getOrCreateInstance(caretIsNew);
+    if (caretIsNew) {
+        // Notify with Object ID "OBJID_CARET".
+        // After that, an assistive tool will send a WM_GETOBJECT message with this ID,
+        // and we can return the caret instance.
+        NotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_CARET, CHILDID_SELF);
+        NotifyWinEvent(EVENT_OBJECT_SHOW, hwnd, OBJID_CARET, CHILDID_SELF);
+    }
+    caret->setLocation(x, y, width, height);
+    NotifyWinEvent(EVENT_OBJECT_LOCATIONCHANGE, hwnd, OBJID_CARET, CHILDID_SELF);
+}
+
+/*
+ * Class:     sun_awt_windows_AccessibleCaretLocationNotifier
+ * Method:    releaseNativeCaret
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_sun_awt_windows_AccessibleCaretLocationNotifier_releaseNativeCaret(
+    JNIEnv *env, jclass jClass, jlong jHwnd) {
+    if (AccessibleCaret::releaseInstanceIfPresent()) {
+        HWND hwnd = reinterpret_cast<HWND>(jHwnd);
+        NotifyWinEvent(EVENT_OBJECT_HIDE, hwnd, OBJID_CARET, CHILDID_SELF);
+        NotifyWinEvent(EVENT_OBJECT_DESTROY, hwnd, OBJID_CARET, CHILDID_SELF);
+    }
+}
+} /* extern "C" */

src/java.desktop/windows/native/libawt/windows/AccessibleCaret.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2024, JetBrains s.r.o.. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#ifndef ACCESSIBLECARET_H
+#define ACCESSIBLECARET_H
+
+#include <oleacc.h>
+#include <windows.h> // ULONG, CRITICAL_SECTION
+
+class AccessibleCaret : public IAccessible {
+public:
+    static AccessibleCaret* getInstanceIfPresent() noexcept;
+    static AccessibleCaret* getOrCreateInstance();
+    static AccessibleCaret* getOrCreateInstance(bool& instanceIsNew);
+    static bool releaseInstanceIfPresent();
+
+    // IUnknown methods.
+    IFACEMETHODIMP_(ULONG) AddRef();
+    IFACEMETHODIMP_(ULONG) Release();
+    IFACEMETHODIMP QueryInterface(REFIID riid, void **ppInterface);
+
+    // IDispatch methods.
+    IFACEMETHODIMP GetTypeInfoCount(UINT *pctinfo);
+    IFACEMETHODIMP GetTypeInfo(UINT itinfo, LCID lcid, ITypeInfo **pptinfo);
+    IFACEMETHODIMP GetIDsOfNames(REFIID riid, __in_ecount(cNames)
+                                 OLECHAR **rgszNames, UINT cNames, LCID lcid, DISPID *rgdispid);
+    IFACEMETHODIMP Invoke(DISPID dispidMember, REFIID riid, LCID lcid,
+                          WORD wFlags, DISPPARAMS *pdispparams, VARIANT *pvarResult,
+                          EXCEPINFO *pexcepinfo, UINT *puArgErr);
+
+    // IAccessible methods
+    IFACEMETHODIMP get_accParent(IDispatch **ppdispParent);
+    IFACEMETHODIMP get_accChildCount(long *pcountChildren);
+    IFACEMETHODIMP get_accChild(VARIANT varChild, IDispatch **ppdispChild);
+    IFACEMETHODIMP get_accName(VARIANT varChild, BSTR *pszName);
+    IFACEMETHODIMP get_accValue(VARIANT varChild, BSTR *pszValue);
+    IFACEMETHODIMP get_accDescription(VARIANT varChild, BSTR *pszDescription);
+    IFACEMETHODIMP get_accRole(VARIANT varChild, VARIANT *pvarRole);
+    IFACEMETHODIMP get_accState(VARIANT varChild, VARIANT *pvarState);
+    IFACEMETHODIMP get_accHelp(VARIANT varChild, BSTR *pszHelp);
+    IFACEMETHODIMP get_accHelpTopic(BSTR *pszHelpFile, VARIANT varChild, long *pidTopic);
+    IFACEMETHODIMP get_accKeyboardShortcut(VARIANT varChild, BSTR *pszKeyboardShortcut);
+    IFACEMETHODIMP get_accFocus(VARIANT *pvarChild);
+    IFACEMETHODIMP get_accSelection(VARIANT *pvarChildren);
+    IFACEMETHODIMP get_accDefaultAction(VARIANT varChild, BSTR *pszDefaultAction);
+    IFACEMETHODIMP accSelect(long flagsSelect, VARIANT varChild);
+    IFACEMETHODIMP accLocation(long *pxLeft, long *pyTop, long *pcxWidth, long *pcyHeight, VARIANT varChild);
+    IFACEMETHODIMP accNavigate(long navDir, VARIANT varStart, VARIANT *pvarEndUpAt);
+    IFACEMETHODIMP accHitTest(long xLeft, long yTop, VARIANT *pvarChild);
+    IFACEMETHODIMP accDoDefaultAction(VARIANT varChild);
+    IFACEMETHODIMP put_accName(VARIANT varChild, BSTR szName);
+    IFACEMETHODIMP put_accValue(VARIANT varChild, BSTR szValue);
+
+    void setLocation(long x, long y, long width, long height);
+
+private:
+    AccessibleCaret();
+    ~AccessibleCaret();
+
+    ULONG m_refCount;
+    int m_x, m_y, m_width, m_height;
+    CRITICAL_SECTION m_caretLocationLock;
+};
+
+#endif //ACCESSIBLECARET_H

src/java.desktop/windows/native/libawt/windows/awt_Component.cpp

@@ -50,6 +50,7 @@
 #include "awt_Win32GraphicsDevice.h"
 #include "Hashtable.h"
 #include "ComCtl32Util.h"
+#include "AccessibleCaret.h"
 
 #include <Region.h>
 
@@ -2037,6 +2038,32 @@ LRESULT AwtComponent::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
           if (::IsWindow(AwtWindow::GetModalBlocker(GetHWnd()))) {
               mr = mrConsume;
           }
+          break;
+      }
+      case WM_GETOBJECT:
+      {
+          // We've got a WM_GETOBJECT message which was likely sent by an assistive tool.
+          // Therefore, we can start generating native caret accessibility events.
+          DWORD objId = static_cast<DWORD>(static_cast<DWORD_PTR>(lParam));
+          if (objId == OBJID_CLIENT) {
+              JNIEnv *env = (JNIEnv *) JNU_GetEnv(jvm, JNI_VERSION_1_2);
+              if (env != nullptr) {
+                  jclass cls = env->FindClass("sun/awt/windows/AccessibleCaretLocationNotifier");
+                  if (cls != nullptr) {
+                      jmethodID mid = env->GetStaticMethodID(cls, "startCaretNotifier", "(J)V");
+                      if (mid != nullptr) {
+                          env->CallStaticVoidMethod(cls, mid, reinterpret_cast<jlong>(GetHWnd()));
+                      }
+                  }
+              }
+          } else if (objId == OBJID_CARET) {
+              AccessibleCaret *caret = AccessibleCaret::getInstanceIfPresent();
+              if (caret != nullptr) {
+                  retValue = LresultFromObject(IID_IAccessible, wParam, caret);
+                  mr = mrConsume;
+              }
+          }
+          break;
       }
     }
 
@@ -2450,7 +2477,7 @@ void AwtComponent::WmTouchHandler(const TOUCHINPUT& touchInput)
             const jint scrollModifiers = modifiers & ~java_awt_event_InputEvent_SHIFT_DOWN_MASK;
             SendMouseWheelEventFromTouch(p, scrollModifiers, sun_awt_event_TouchEvent_TOUCH_UPDATE, deltaY);
         }
-        
+
         const jint deltaX = ScaleDownX(static_cast<int>(m_lastTouchPoint.x - p.x));
         if (deltaX != 0) {
             const jint scrollModifiers = modifiers | java_awt_event_InputEvent_SHIFT_DOWN_MASK;

src/jdk.attach/share/classes/sun/tools/attach/HotSpotVirtualMachine.java

@@ -63,8 +63,10 @@ public abstract class HotSpotVirtualMachine extends VirtualMachine {
     static {
         String s = VM.getSavedProperty("jdk.attach.allowAttachSelf");
         ALLOW_ATTACH_SELF = "".equals(s) || Boolean.parseBoolean(s);
+        // For now the default is false because it makes jstack hang with
+        // buffer overflow on lengthy outputs, which occur often in automatic tests.
         String s2 = VM.getSavedProperty("jdk.attach.allowStreamingOutput");
-        ALLOW_STREAMING_OUTPUT = !("false".equals(s2));
+        ALLOW_STREAMING_OUTPUT = "".equals(s2) || Boolean.parseBoolean(s2);
     }
 
     private final boolean selfAttach;

test/hotspot/jtreg/jbFdProblemList.txt

@@ -58,7 +58,7 @@ gc/stress/gcold/TestGCOldWithShenandoah.java#aggressive JBR-8563 windows-aarch64
 
 # :hotspot_runtime
 
-runtime/ErrorHandling/AccessZeroNKlassHitsProtectionZone.java#coh_no_cds JBR-6616 windows-aarch64
+runtime/ErrorHandling/AccessZeroNKlassHitsProtectionZone.java#coh_no_cds JBR-6616,JBR-9488 windows-aarch64,macosx-26.0
 runtime/ErrorHandling/AccessZeroNKlassHitsProtectionZone.java#no_coh_cds JBR-6616 windows-aarch64
 runtime/ErrorHandling/AccessZeroNKlassHitsProtectionZone.java#no_coh_no_cds JBR-6616 windows-aarch64
 runtime/ErrorHandling/ErrorFileOverwriteTest.java JBR-8524 windows-aarch64
@@ -89,9 +89,12 @@ vmTestbase/jit/misctests/JitBug1/JitBug1.java JBR-8801 linux-aarch64,windows-all
 vmTestbase/jit/misctests/Pi/Pi.java JBR-8854 linux-aarch64
 vmTestbase/jit/misctests/t5/t5.java JBR-8854 linux-aarch64
 vmTestbase/jit/misctests/putfield00802/putfield00802.java JBR-8801 linux-aarch64,windows-all
-vmTestbase/nsk/monitoring/ThreadMXBean/ThreadInfo/Multi/Multi002/TestDescription.java JBR-8743 windows-all
-vmTestbase/nsk/monitoring/ThreadMXBean/ThreadInfo/Multi/Multi003/TestDescription.java JBR-8743 windows-all
-vmTestbase/nsk/monitoring/ThreadMXBean/ThreadInfo/Multi/Multi004/TestDescription.java JBR-8743,JBR-8744 windows-all
+
+vmTestbase/nsk/monitoring/ThreadMXBean/ThreadInfo/Multi/Multi001/Multi001.java JBR-8545 windows-aarch64,windows-x64
+vmTestbase/nsk/monitoring/ThreadMXBean/ThreadInfo/Multi/Multi002/TestDescription.java JBR-8927,JBR-8545 windows-all,windows-x64
+vmTestbase/nsk/monitoring/ThreadMXBean/ThreadInfo/Multi/Multi003/TestDescription.java JBR-8927,JBR-8545 windows-all,windows-x64
+vmTestbase/nsk/monitoring/ThreadMXBean/ThreadInfo/Multi/Multi004/TestDescription.java JBR-8927,JBR-8545 windows-all,windows-x64
+vmTestbase/nsk/monitoring/ThreadMXBean/ThreadInfo/Multi/Multi005/TestDescription.java JBR-8927,JBR-8545 windows-all,windows-x64
 
 #############################################################################