Revert "fix glyph-overhang artifacts in partial row repaint"

This reverts commit 57103bb98b.

.ignore

@@ -0,0 +1,3 @@
+.gradle
+result
+bin

README.md

@@ -106,7 +106,6 @@ navigate_up = "ALT+K"
 navigate_right = "ALT+L"
 toggle_floating = "ALT+F"
 new_pane = "ALT+N"
-next_floating = "ALT+F12"
 close_pane = "ALT+X"
 new_tab = "ALT+A"
 previous_tab = "ALT+SHIFT+H"
@@ -121,7 +120,6 @@ open_scrollback = "ALT+S"
 - `Alt+n`: new pane — a floating pane when floating panes are shown, otherwise a new tiled
   pane (tiled panes are split equally across the width)
 - `Alt+f`: show or hide all floating panes
-- `Alt+F12`: cycle floating panes
 - `Alt+x`: close the active pane; closing a tab's last pane closes the tab, and closing the
   last pane of the last tab quits
 - `Alt+a`: new tab

config.example.toml

@@ -25,8 +25,7 @@ navigate_down = "ALT+J"
 navigate_up = "ALT+K"
 navigate_right = "ALT+L"
 toggle_floating = "ALT+F"
-new_floating = "ALT+SHIFT+F"
+new_pane = "ALT+N"
-next_floating = "ALT+F12"
 close_pane = "ALT+X"
 open_font_selector = "ALT+T"
 open_scrollback = "ALT+S"

flake.lock

@@ -70,11 +70,11 @@
         "nixpkgs": "nixpkgs"
       },
       "locked": {
-        "lastModified": 1780079529,
+        "lastModified": 1780256181,
-        "narHash": "sha256-AxlGTL8c5xSLcQHvWlm994IdOqxsN8iKrA02Cpv7vso=",
+        "narHash": "sha256-/saXdnYMbAMfP7u6USSqtNkBIgqZhU+CPr3F8tUQhHU=",
         "ref": "refs/heads/main",
-        "rev": "68121d50b52fb56038871c97c97e7a12ffe987c2",
+        "rev": "db5ee5d20daf8855de3a3b2fa9349eced70946f0",
-        "revCount": 20,
+        "revCount": 21,
         "type": "git",
         "url": "https://gitea.gregorlohaus.com/gregor/jlibghostty.git"
       },

src/main/java/com/gregor/jprototerm/AppConfig.java

@@ -37,7 +37,6 @@ public record AppConfig(
             "navigate_right",
             "toggle_floating",
             "new_pane",
-            "next_floating",
             "close_pane",
             "new_tab",
             "previous_tab",
@@ -96,7 +95,6 @@ public record AppConfig(
                         Map.entry("navigate_right", KeyBinding.parse("ALT+L")),
                         Map.entry("toggle_floating", KeyBinding.parse("ALT+F")),
                         Map.entry("new_pane", KeyBinding.parse("ALT+N")),
-                        Map.entry("next_floating", KeyBinding.parse("ALT+F12")),
                         Map.entry("close_pane", KeyBinding.parse("ALT+X")),
                         Map.entry("new_tab", KeyBinding.parse("ALT+A")),
                         Map.entry("previous_tab", KeyBinding.parse("ALT+SHIFT+H")),

src/main/java/com/gregor/jprototerm/Compositor.java

@@ -4,57 +4,52 @@ import dev.jlibghostty.KeyModifiers;
 import dev.jlibghostty.MouseButton;
 import dev.jlibghostty.MouseEncoderSize;
 import dev.jlibghostty.MouseInput;
-import javafx.geometry.VPos;
+import javafx.geometry.Pos;
-import javafx.scene.canvas.Canvas;
+import javafx.scene.Parent;
-import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.control.Label;
 import javafx.scene.input.InputEvent;
 import javafx.scene.input.MouseEvent;
 import javafx.scene.input.ScrollEvent;
 import javafx.scene.input.ScrollEvent.VerticalTextScrollUnits;
+import javafx.scene.layout.Background;
+import javafx.scene.layout.BackgroundFill;
+import javafx.scene.layout.CornerRadii;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Pane;
 import javafx.scene.paint.Color;
-import javafx.scene.text.Font;
-import javafx.scene.text.FontSmoothingType;
-import javafx.scene.text.TextAlignment;
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
+import java.util.Set;
 
 /**
- * Owns the window's tabs and drives rendering and input. It composites only the current tab:
+ * Owns the window's tabs and exposes the terminal surface as a JavaFX scene graph. Each
- * each frame it lays that tab out, paints the panes bottom-to-top (so the active floating pane
+ * terminal pane is mounted as its own node, so JavaFX child order handles stacking and clipping
- * lands on top) and lets each pane paint its own content, clipped to the region the layout gave
+ * between panes. The pane model still owns terminals, ptys, cell geometry, and snapshots; this
- * it. The cross-pane concerns live here — the dirty-frame bookkeeping, the tab strip, routing
+ * class handles tab/pane lifecycle, layout, focus, mouse routing, and frame scheduling.
- * mouse/scroll to the pane under the pointer, and the tab/pane lifecycle that {@link Main}'s key
- * bindings invoke.
  */
 public final class Compositor {
-    // Canvas background shown wherever no pane covers (gaps). Painted on a full recomposite.
     private static final Color GAP_BACKGROUND = Color.rgb(16, 16, 18);
     private static final Color TAB_TEXT = Color.rgb(225, 229, 235);
-    // Thin tab strip shown at the top when more than one tab is open.
+    private static final Color TAB_INACTIVE_TEXT = Color.rgb(128, 136, 148);
+    private static final Color TAB_ACTIVE_BACKGROUND = Color.rgb(45, 55, 72);
+    private static final Color TAB_INACTIVE_BACKGROUND = Color.rgb(22, 24, 28);
     private static final double TAB_BAR_HEIGHT = 22.0;
 
-    private final Canvas canvas = new Canvas();
+    private final Pane root = new Pane();
+    private final Pane paneLayer = new Pane();
+    private final HBox tabBar = new HBox(1.0);
     private final AppConfig config;
     private final TerminalMetrics metrics;
     private final List<Tab> tabs = new ArrayList<>();
+    private final Map<TerminalPane, TerminalPaneNode> nodes = new HashMap<>();
     private int currentTabIndex;
-    // Bumped on any structural change (tab switch, pane add/close/focus/move) so render()
+    private boolean sceneDirty = true;
-    // knows to recomposite. Terminal *content* changes are tracked separately through each
-    // tab's content version.
-    private long layoutVersion;
-    // Last content version drawn to the canvas per pane, so a content frame repaints only
-    // the panes that actually changed.
-    private final Map<TerminalPane, Long> paneContentVersion = new HashMap<>();
-    // Cheap per-frame dirty signal: skip the whole render when none of these changed.
     private double lastWidth = -1.0;
     private double lastHeight = -1.0;
-    private String lastFontFamily;
-    private double lastFontSize = -1.0;
-    private long lastLayoutVersion = Long.MIN_VALUE;
     private long lastContentVersion = Long.MIN_VALUE;
     private boolean mouseButtonPressed;
     private MouseButton pressedButton = MouseButton.UNKNOWN;
@@ -63,22 +58,25 @@ public final class Compositor {
         this.config = config;
         this.metrics = metrics;
         tabs.add(new Tab(config, metrics));
-        canvas.setFocusTraversable(true);
+
-        canvas.setOnMousePressed(this::handleMousePressed);
+        root.setFocusTraversable(true);
-        canvas.setOnMouseReleased(this::handleMouseReleased);
+        root.setBackground(new Background(new BackgroundFill(GAP_BACKGROUND, CornerRadii.EMPTY, null)));
-        canvas.setOnMouseDragged(this::handleMouseDragged);
+        root.getChildren().setAll(paneLayer, tabBar);
-        canvas.setOnMouseMoved(this::handleMouseMoved);
+        root.setOnMousePressed(event -> root.requestFocus());
-        canvas.setOnScroll(this::handleScroll);
     }
 
-    public Canvas canvas() {
+    public Parent node() {
-        return canvas;
+        return root;
+    }
+
+    public void requestFocus() {
+        root.requestFocus();
     }
 
     public void setFont(String family, double size) {
         metrics.setFont(family, size);
-        paneContentVersion.clear();
+        nodes.values().forEach(TerminalPaneNode::discard);
-        lastWidth = -1.0; // force a redraw on the next frame
+        markSceneDirty();
     }
 
     // ---- Tabs and panes -------------------------------------------------------------
@@ -93,7 +91,7 @@ public final class Compositor {
 
     public void navigate(Direction direction) {
         if (!isEmpty() && currentTab().navigate(direction)) {
-            layoutVersion++;
+            markSceneDirty();
         }
     }
 
@@ -102,7 +100,7 @@ public final class Compositor {
             return;
         }
         currentTab().toggleFloating();
-        layoutVersion++;
+        markSceneDirty();
     }
 
     public void createPane() {
@@ -110,15 +108,7 @@ public final class Compositor {
             return;
         }
         currentTab().createPane();
-        layoutVersion++;
+        markSceneDirty();
-    }
-
-    public void nextFloatingPane() {
-        if (isEmpty()) {
-            return;
-        }
-        currentTab().nextFloatingPane();
-        layoutVersion++;
     }
 
     public void closeActivePane() {
@@ -127,33 +117,31 @@ public final class Compositor {
         }
         currentTab().closeActivePane();
         if (currentTab().isEmpty()) {
-            // Closing a tab's last pane closes the tab. When no tabs remain the surface is
-            // empty and Main quits.
             tabs.remove(currentTabIndex);
             if (currentTabIndex >= tabs.size()) {
                 currentTabIndex = Math.max(0, tabs.size() - 1);
             }
         }
-        layoutVersion++;
+        markSceneDirty();
     }
 
     public void newTab() {
         tabs.add(new Tab(config, metrics));
         currentTabIndex = tabs.size() - 1;
-        layoutVersion++;
+        markSceneDirty();
     }
 
     public void nextTab() {
         if (tabs.size() > 1) {
             currentTabIndex = (currentTabIndex + 1) % tabs.size();
-            layoutVersion++;
+            markSceneDirty();
         }
     }
 
     public void previousTab() {
         if (tabs.size() > 1) {
             currentTabIndex = (currentTabIndex - 1 + tabs.size()) % tabs.size();
-            layoutVersion++;
+            markSceneDirty();
         }
     }
 
@@ -162,6 +150,8 @@ public final class Compositor {
             tab.close();
         }
         tabs.clear();
+        nodes.clear();
+        paneLayer.getChildren().clear();
     }
 
     private Tab currentTab() {
@@ -172,143 +162,140 @@ public final class Compositor {
         return tabs.isEmpty() ? List.of() : currentTab().panes();
     }
 
+    private List<TerminalPane> allOpenPanes() {
+        List<TerminalPane> panes = new ArrayList<>();
+        for (Tab tab : tabs) {
+            panes.addAll(tab.allPanes());
+        }
+        return panes;
+    }
+
     private boolean isActive(TerminalPane pane) {
         return !tabs.isEmpty() && currentTab().isActive(pane);
     }
 
     private void focus(TerminalPane pane) {
         if (!tabs.isEmpty() && currentTab().focus(pane)) {
-            layoutVersion++;
+            markSceneDirty();
         }
     }
 
     // ---- Rendering ------------------------------------------------------------------
 
     public void render() {
-        switch (nextFrameType()) {
+        double width = root.getWidth();
-            case IDLE -> { }
+        double height = root.getHeight();
-            case LAYOUT -> renderLayoutFrame();
-            case CONTENT -> renderContentFrame();
-        }
-    }
-
-    // Classify this frame and commit the change trackers. A layout change (size, font,
-    // tab/pane set, z-order, active pane) needs a full recomposite; otherwise a change to the
-    // current tab's content version repaints only the panes that changed; otherwise nothing
-    // changed and the frame is idle.
-    private FrameType nextFrameType() {
-        double width = canvas.getWidth();
-        double height = canvas.getHeight();
         long contentVersion = tabs.isEmpty() ? 0 : currentTab().contentVersion();
-
+        boolean geometryChanged = width != lastWidth || height != lastHeight;
-        boolean layoutChanged = width != lastWidth || height != lastHeight
-                || metrics.fontSize() != lastFontSize || !Objects.equals(metrics.fontFamily(), lastFontFamily)
-                || layoutVersion != lastLayoutVersion;
         boolean contentChanged = contentVersion != lastContentVersion;
+        boolean syncScene = sceneDirty || geometryChanged;
+
+        if (!syncScene && !contentChanged) {
+            return;
+        }
 
         lastWidth = width;
         lastHeight = height;
-        lastFontFamily = metrics.fontFamily();
-        lastFontSize = metrics.fontSize();
-        lastLayoutVersion = layoutVersion;
         lastContentVersion = contentVersion;
-
+        sceneDirty = false;
-        if (layoutChanged) {
+        if (syncScene) {
-            return FrameType.LAYOUT;
+            syncSceneGraph(width, height);
         }
-        if (contentChanged) {
+        renderVisiblePanes();
-            return FrameType.CONTENT;
-        }
-        return FrameType.IDLE;
     }
 
-    // Full recomposite onto the retained canvas: lay the tab out, clear to the gap colour,
+    private void markSceneDirty() {
-    // draw the tab strip, then paint every pane bottom-to-top (panes() puts the active
+        sceneDirty = true;
-    // floating pane last == on top).
+    }
-    private void renderLayoutFrame() {
+
+    private void syncSceneGraph(double width, double height) {
         double topInset = tabs.size() > 1 ? TAB_BAR_HEIGHT : 0.0;
+
+        paneLayer.resizeRelocate(0.0, 0.0, width, height);
+        updateTabBar(width, topInset);
+
         if (!tabs.isEmpty()) {
-            currentTab().layout(canvas.getWidth(), canvas.getHeight(), topInset);
+            currentTab().layout(width, height, topInset);
         }
+
         List<TerminalPane> panes = currentPanes();
-        // Sync each pane's ghostty grid to its (possibly new) bounds; a no-op when unchanged.
+        retainNodes(allOpenPanes());
+        List<TerminalPaneNode> orderedNodes = new ArrayList<>(panes.size());
         for (TerminalPane pane : panes) {
             pane.fitToBounds();
+            TerminalPaneNode node = nodeFor(pane);
+            node.resizeRelocate(Math.round(pane.x()), Math.round(pane.y()), pane.width(), pane.height());
+            orderedNodes.add(node);
+        }
+        paneLayer.getChildren().setAll(orderedNodes);
     }
 
-        GraphicsContext gc = beginFrame();
+    private void renderVisiblePanes() {
-        paneContentVersion.keySet().retainAll(panes);
+        for (TerminalPane pane : currentPanes()) {
-        gc.setFill(GAP_BACKGROUND);
+            TerminalPaneNode node = nodes.get(pane);
-        gc.fillRect(0, 0, canvas.getWidth(), canvas.getHeight());
+            if (node != null) {
-        if (topInset > 0.0) {
+                node.renderIncremental(isActive(pane));
-            drawTabBar(gc, canvas.getWidth(), topInset);
             }
-        for (TerminalPane pane : panes) {
-            pane.paintFull(gc, isActive(pane));
-            paneContentVersion.put(pane, pane.contentVersion());
         }
     }
 
-    // Repaint just the panes whose content changed, directly on the retained canvas. Each pane
+    private TerminalPaneNode nodeFor(TerminalPane pane) {
-    // clips itself to its rect minus the panes above it, so a lower pane's repaint can't bleed
+        return nodes.computeIfAbsent(pane, this::createNode);
-    // over one stacked on top — no restore pass needed. Bounds and grids can't have changed
-    // without a layout frame, so a content frame reuses the existing layout untouched.
-    private void renderContentFrame() {
-        List<TerminalPane> panes = currentPanes();
-        GraphicsContext gc = beginFrame();
-
-        for (TerminalPane pane : panes) {
-            Long drawn = paneContentVersion.get(pane);
-            if (drawn != null && drawn == pane.contentVersion()) {
-                continue;
-            }
-            pane.paintIncremental(gc, isActive(pane));
-            paneContentVersion.put(pane, pane.contentVersion());
-        }
     }
 
-    private GraphicsContext beginFrame() {
+    private TerminalPaneNode createNode(TerminalPane pane) {
-        GraphicsContext gc = canvas.getGraphicsContext2D();
+        TerminalPaneNode node = new TerminalPaneNode(pane, metrics);
-        gc.setFontSmoothingType(FontSmoothingType.LCD); // the per-cell renderer relies on LCD
+        node.setOnMousePressed(event -> handleMousePressed(pane, event));
-        return gc;
+        node.setOnMouseReleased(event -> handleMouseReleased(pane, event));
+        node.setOnMouseDragged(event -> handleMouseDragged(pane, event));
+        node.setOnMouseMoved(event -> handleMouseMoved(pane, event));
+        node.setOnScroll(event -> handleScroll(pane, event));
+        return node;
     }
 
-    // Thin tab strip: one equal-width segment per tab, the current one highlighted, with a
+    private void retainNodes(List<TerminalPane> openPanes) {
-    // small 1-based number centred in each segment.
+        Set<TerminalPane> open = new HashSet<>(openPanes);
-    private void drawTabBar(GraphicsContext gc, double width, double barHeight) {
+        nodes.keySet().removeIf(pane -> !open.contains(pane));
-        int count = tabs.size();
+    }
-        Font barFont = Font.font(metrics.fontFamily(), Math.max(9.0, Math.min(13.0, barHeight * 0.62)));
-        gc.setFont(barFont);
-        gc.setFontSmoothingType(FontSmoothingType.GRAY);
-        gc.setTextAlign(TextAlignment.CENTER);
-        gc.setTextBaseline(VPos.CENTER);
 
-        double gap = 1.0;
+    private void updateTabBar(double width, double barHeight) {
-        double segmentWidth = width / count;
+        tabBar.setVisible(barHeight > 0.0);
-        for (int i = 0; i < count; i++) {
+        tabBar.setManaged(false);
-            double x = i * segmentWidth;
+        tabBar.resizeRelocate(0.0, 0.0, width, barHeight);
+        tabBar.getChildren().clear();
+        if (barHeight <= 0.0) {
+            return;
+        }
+
+        double segmentWidth = width / tabs.size();
+        for (int i = 0; i < tabs.size(); i++) {
+            Label label = new Label(Integer.toString(i + 1));
             boolean current = i == currentTabIndex;
-            gc.setFill(current ? Color.rgb(45, 55, 72) : Color.rgb(22, 24, 28));
+            label.setAlignment(Pos.CENTER);
-            gc.fillRect(x, 0.0, segmentWidth - gap, barHeight);
+            label.setTextFill(current ? TAB_TEXT : TAB_INACTIVE_TEXT);
-            gc.setFill(current ? TAB_TEXT : Color.rgb(128, 136, 148));
+            label.setBackground(new Background(new BackgroundFill(
-            gc.fillText(Integer.toString(i + 1), x + (segmentWidth - gap) / 2.0, barHeight / 2.0);
+                    current ? TAB_ACTIVE_BACKGROUND : TAB_INACTIVE_BACKGROUND,
+                    CornerRadii.EMPTY,
+                    null)));
+            label.setFont(javafx.scene.text.Font.font(metrics.fontFamily(), Math.max(9.0, Math.min(13.0, barHeight * 0.62))));
+            label.setMinSize(0.0, barHeight);
+            label.setPrefSize(Math.max(0.0, segmentWidth - 1.0), barHeight);
+            label.setMaxSize(Double.MAX_VALUE, barHeight);
+            final int index = i;
+            label.setOnMousePressed(event -> {
+                currentTabIndex = index;
+                markSceneDirty();
+                root.requestFocus();
+                event.consume();
+            });
+            tabBar.getChildren().add(label);
         }
-
-        // Restore the defaults the cell renderer relies on (left-aligned, baseline, LCD).
-        gc.setTextAlign(TextAlignment.LEFT);
-        gc.setTextBaseline(VPos.BASELINE);
-        gc.setFontSmoothingType(FontSmoothingType.LCD);
     }
 
     // ---- Input ----------------------------------------------------------------------
 
-    private void handleMousePressed(MouseEvent event) {
+    private void handleMousePressed(TerminalPane pane, MouseEvent event) {
-        canvas.requestFocus();
+        root.requestFocus();
-        TerminalPane pane = paneAt(event.getX(), event.getY());
-        if (pane == null) {
-            return;
-        }
-
         focus(pane);
         pressedButton = mouseButton(event);
         mouseButtonPressed = true;
@@ -316,58 +303,38 @@ public final class Compositor {
         if (target == null) {
             return;
         }
-        send(pane, target, MouseInput.press(pressedButton, localX(event.getX(), pane, target), localY(event.getY(), pane, target), modifiers(event)), true, event);
+        send(pane, target, MouseInput.press(pressedButton, localX(event.getX(), target), localY(event.getY(), target), modifiers(event)), true, event);
-    }
-
-    private void handleMouseReleased(MouseEvent event) {
-        TerminalPane pane = paneAt(event.getX(), event.getY());
-        if (pane == null) {
-            pane = activePane();
     }
 
+    private void handleMouseReleased(TerminalPane pane, MouseEvent event) {
         MouseButton button = pressedButton == MouseButton.UNKNOWN ? mouseButton(event) : pressedButton;
         MouseTarget target = mouseTarget(pane);
         if (target != null) {
-            send(pane, target, MouseInput.release(button, localX(event.getX(), pane, target), localY(event.getY(), pane, target), modifiers(event)), false, event);
+            send(pane, target, MouseInput.release(button, localX(event.getX(), target), localY(event.getY(), target), modifiers(event)), false, event);
         }
         mouseButtonPressed = false;
         pressedButton = MouseButton.UNKNOWN;
     }
 
-    private void handleMouseDragged(MouseEvent event) {
+    private void handleMouseDragged(TerminalPane pane, MouseEvent event) {
-        TerminalPane pane = paneAt(event.getX(), event.getY());
-        if (pane == null) {
-            pane = activePane();
-        }
-
         MouseButton button = pressedButton == MouseButton.UNKNOWN ? mouseButton(event) : pressedButton;
         MouseTarget target = mouseTarget(pane);
         if (target == null) {
             return;
         }
-        send(pane, target, MouseInput.drag(button, localX(event.getX(), pane, target), localY(event.getY(), pane, target), modifiers(event)), true, event);
+        send(pane, target, MouseInput.drag(button, localX(event.getX(), target), localY(event.getY(), target), modifiers(event)), true, event);
-    }
-
-    private void handleMouseMoved(MouseEvent event) {
-        TerminalPane pane = paneAt(event.getX(), event.getY());
-        if (pane == null) {
-            return;
     }
 
+    private void handleMouseMoved(TerminalPane pane, MouseEvent event) {
         MouseTarget target = mouseTarget(pane);
         if (target == null) {
             return;
         }
-        send(pane, target, MouseInput.motion(localX(event.getX(), pane, target), localY(event.getY(), pane, target), modifiers(event)), mouseButtonPressed, event);
+        send(pane, target, MouseInput.motion(localX(event.getX(), target), localY(event.getY(), target), modifiers(event)), mouseButtonPressed, event);
     }
 
-    private void handleScroll(ScrollEvent event) {
+    private void handleScroll(TerminalPane pane, ScrollEvent event) {
-        TerminalPane pane = paneAt(event.getX(), event.getY());
+        root.requestFocus();
-        if (pane == null) {
-            return;
-        }
-
-        canvas.requestFocus();
         focus(pane);
         int direction = scrollDirection(event);
         if (direction == 0) {
@@ -379,23 +346,22 @@ public final class Compositor {
         MouseTarget target = mouseTarget(pane);
         boolean sent = false;
         if (target != null) {
-            // The wheel sends one button press per scrolled row; resolve the position once.
+            double ex = localX(event.getX(), target);
-            double ex = localX(event.getX(), pane, target);
+            double ey = localY(event.getY(), target);
-            double ey = localY(event.getY(), pane, target);
             KeyModifiers modifiers = modifiers(event);
             for (int i = 0; i < rows; i++) {
-                sent |= send(pane, target, MouseInput.press(wheelButton, ex, ey, modifiers), mouseButtonPressed, event);
+                if (!send(pane, target, MouseInput.press(wheelButton, ex, ey, modifiers), mouseButtonPressed, event)) {
+                    break;
+                }
+                sent = true;
             }
         }
         if (!sent) {
-            // Not consumed by the app (e.g. mouse reporting off): scroll the local viewport.
             pane.scrollViewport(direction > 0 ? -rows : rows);
             event.consume();
         }
     }
 
-    // Forward an already-positioned mouse event to the pane, consuming it if the pane (i.e.
-    // the app running in it) acted on it. Returns whether it was sent.
     private boolean send(TerminalPane pane, MouseTarget target, MouseInput input, boolean anyButtonPressed, InputEvent event) {
         boolean sent = pane.sendMouse(input, target.size(), anyButtonPressed);
         if (sent) {
@@ -404,17 +370,6 @@ public final class Compositor {
         return sent;
     }
 
-    private TerminalPane paneAt(double x, double y) {
-        List<TerminalPane> panes = currentPanes();
-        for (int i = panes.size() - 1; i >= 0; i--) {
-            TerminalPane pane = panes.get(i);
-            if (x >= pane.x() && x < pane.x() + pane.width() && y >= pane.y() && y < pane.y() + pane.height()) {
-                return pane;
-            }
-        }
-        return null;
-    }
-
     private MouseTarget mouseTarget(TerminalPane pane) {
         if (pane.width() <= 2 * TerminalMetrics.PADDING || pane.height() <= 2 * TerminalMetrics.PADDING) {
             return null;
@@ -429,14 +384,12 @@ public final class Compositor {
         return new MouseTarget(MouseEncoderSize.of(screenWidth, screenHeight, cellWidth, cellHeight), screenWidth, screenHeight);
     }
 
-    // Resolve a canvas-space pointer position to a pane-local pixel coordinate, clamped to
+    private static double localX(double nodeX, MouseTarget target) {
-    // the pane's reported screen size (what ghostty's mouse encoder expects).
+        return clamp(nodeX - TerminalMetrics.PADDING, 0.0, target.screenWidth() - 1.0);
-    private static double localX(double canvasX, TerminalPane pane, MouseTarget target) {
-        return clamp(canvasX - pane.x() - TerminalMetrics.PADDING, 0.0, target.screenWidth() - 1.0);
     }
 
-    private static double localY(double canvasY, TerminalPane pane, MouseTarget target) {
+    private static double localY(double nodeY, MouseTarget target) {
-        return clamp(canvasY - pane.y() - TerminalMetrics.PADDING, 0.0, target.screenHeight() - 1.0);
+        return clamp(nodeY - TerminalMetrics.PADDING, 0.0, target.screenHeight() - 1.0);
     }
 
     private static double clamp(double value, double min, double max) {
@@ -484,13 +437,6 @@ public final class Compositor {
         };
     }
 
-    // What one render() pass should do, decided from the change trackers in nextFrame().
-    private enum FrameType {
-        IDLE,     // nothing changed since the last frame
-        LAYOUT,   // geometry/font/tab/pane set changed: clear and repaint everything
-        CONTENT   // only terminal content changed: repaint the panes that changed
-    }
-
     private record MouseTarget(MouseEncoderSize size, long screenWidth, long screenHeight) {
     }
 }

src/main/java/com/gregor/jprototerm/GhosttyTerminalRenderer.java

@@ -1,631 +0,0 @@
-package com.gregor.jprototerm;
-
-import dev.jlibghostty.KittyImageCompression;
-import dev.jlibghostty.KittyImageFormat;
-import dev.jlibghostty.KittyImageSnapshot;
-import dev.jlibghostty.KittyPlacement;
-import dev.jlibghostty.KittyPlacementLayer;
-import dev.jlibghostty.KittyPlaceholder;
-import dev.jlibghostty.KittyRenderInfo;
-import dev.jlibghostty.RenderCell;
-import dev.jlibghostty.RenderColor;
-import dev.jlibghostty.RenderCursorStyle;
-import dev.jlibghostty.RenderRow;
-import dev.jlibghostty.RenderStateSnapshot;
-import javafx.scene.canvas.GraphicsContext;
-import javafx.scene.image.Image;
-import javafx.scene.image.PixelFormat;
-import javafx.scene.image.WritableImage;
-import javafx.scene.paint.Color;
-import javafx.scene.text.FontSmoothingType;
-
-import java.io.ByteArrayInputStream;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * The real terminal renderer: paints a pane's background, cell rows, cursor, border, padding
- * and (when enabled) kitty graphics. One instance per pane, since it caches that pane's
- * decoded kitty images.
- */
-final class GhosttyTerminalRenderer extends TerminalRenderer {
-    // GhosttyRenderStateDirty values (stable C ABI; see ghostty/vt/render.h).
-    private static final int DIRTY_PARTIAL = 1;
-    private static final int DIRTY_FULL = 2;
-
-    private static final Color DEFAULT_FOREGROUND = Color.rgb(225, 229, 235);
-    private static final Color SELECTED_BACKGROUND = Color.rgb(52, 92, 140);
-    // The default cell background (used for cells with no explicit bg, and as the foreground
-    // for reverse-video cells whose background is the terminal default).
-    private static final Color PANE_BACKGROUND = Color.rgb(9, 10, 12);
-
-    // A full-screen redraw asks for one Color per cell; most cells share a handful of colors,
-    // so cache them by packed RGB instead of allocating a Color each time. Bounded so a
-    // truecolor gradient can't grow it without limit.
-    private static final Map<Integer, Color> COLOR_CACHE = new HashMap<>();
-
-    private final TerminalMetrics metrics;
-    // Decoded kitty images for this renderer's pane (kitty graphics state is per-terminal).
-    private final Map<KittyImageKey, Image> kittyImageCache = new HashMap<>();
-
-    GhosttyTerminalRenderer(TerminalMetrics metrics) {
-        this.metrics = metrics;
-    }
-
-    @Override
-    void paintFull(GraphicsContext gc, RenderTarget target, boolean active) {
-        double px = Math.round(target.x());
-        double py = Math.round(target.y());
-        double width = target.width();
-        double height = target.height();
-        gc.save();
-        clip(gc, px, py, width, height, target.clip());
-        drawContent(gc, target, target.snapshotFull(), px, py, width, height, active,
-                target.kittyEnabled() && hasKittyGraphics(target));
-        gc.restore();
-    }
-
-    @Override
-    void paintIncremental(GraphicsContext gc, RenderTarget target, boolean active) {
-        double px = Math.round(target.x());
-        double py = Math.round(target.y());
-        double width = target.width();
-        double height = target.height();
-        gc.save();
-        clip(gc, px, py, width, height, target.clip());
-        if (target.kittyEnabled() && hasKittyGraphics(target)) {
-            // Kitty placements can move without a per-row dirty flag, so always redraw whole.
-            drawContent(gc, target, target.snapshotFull(), px, py, width, height, active, true);
-        } else {
-            RenderStateSnapshot snapshot = target.snapshot();
-            int dirty = snapshot == null ? DIRTY_FULL : snapshot.dirty();
-            if (dirty == DIRTY_FULL) {
-                drawContent(gc, target, snapshot, px, py, width, height, active, false);
-            } else if (dirty == DIRTY_PARTIAL) {
-                drawDirtyRows(gc, snapshot, px, py, width, height, active);
-            }
-            // dirty == FALSE: nothing visible changed.
-        }
-        gc.restore();
-    }
-
-    // Full content render: background, border, all rows, cursor, and (when enabled) kitty
-    // graphics. Used by the kitty direct path and by full redraws.
-    private void drawContent(
-            GraphicsContext gc,
-            RenderTarget target,
-            RenderStateSnapshot snapshot,
-            double x,
-            double y,
-            double width,
-            double height,
-            boolean active,
-            boolean withKitty
-    ) {
-        double cellWidth = metrics.cellWidth();
-        double lineHeight = metrics.lineHeight();
-        gc.setFontSmoothingType(FontSmoothingType.LCD);
-        gc.setFill(PANE_BACKGROUND);
-        gc.fillRect(x, y, width, height);
-        gc.setFont(metrics.font());
-
-        double left = x + TerminalMetrics.PADDING;
-        double top = y + TerminalMetrics.PADDING;
-        double baseline = top + metrics.baselineOffset();
-
-        Map<KittyPlaceholderKey, KittyPlaceholderBounds> placeholderBounds = withKitty
-                ? kittyPlaceholderBounds(snapshot)
-                : Map.of();
-
-        if (withKitty) {
-            drawKittyGraphics(gc, target, KittyPlacementLayer.BELOW_TEXT, placeholderBounds, left, top, cellWidth, lineHeight);
-        }
-
-        if (snapshot != null) {
-            double contentBottom = top + snapshot.rows() * lineHeight;
-            fillVerticalPadding(gc, snapshot, x, y, width, height, top, contentBottom);
-            for (RenderRow row : snapshot.renderRows()) {
-                double y0 = Math.floor(top + (row.row() * lineHeight));
-                double y1 = Math.ceil(top + ((row.row() + 1) * lineHeight));
-                paintSidePadding(gc, row, x, width, left, cellWidth, y0, y1 - y0);
-                drawRow(gc, row, left, top, baseline, cellWidth, lineHeight);
-            }
-            drawCursor(gc, snapshot, left, top, cellWidth, lineHeight);
-        }
-
-        if (withKitty) {
-            drawKittyGraphics(gc, target, KittyPlacementLayer.ABOVE_TEXT, placeholderBounds, left, top, cellWidth, lineHeight);
-        }
-
-        drawBorder(gc, x, y, width, height, active);
-    }
-
-    // Incremental render: repaint only the rows ghostty flagged dirty, then restore the
-    // cursor and border. The local band tracks the repainted span only so the border redraw
-    // can be limited to it.
-    private void drawDirtyRows(
-            GraphicsContext gc,
-            RenderStateSnapshot snapshot,
-            double px,
-            double py,
-            double pw,
-            double ph,
-            boolean active
-    ) {
-        double cellWidth = metrics.cellWidth();
-        double lineHeight = metrics.lineHeight();
-        gc.setFontSmoothingType(FontSmoothingType.LCD);
-        gc.setFont(metrics.font());
-        double left = px + TerminalMetrics.PADDING;
-        double top = py + TerminalMetrics.PADDING;
-        double baseline = top + metrics.baselineOffset();
-
-        double contentBottom = top + snapshot.rows() * lineHeight;
-        int lastRow = snapshot.rows() - 1;
-        boolean cursorRowDirty = false;
-        double bandMin = Double.POSITIVE_INFINITY;
-        double bandMax = Double.NEGATIVE_INFINITY;
-        for (RenderRow row : snapshot.renderRows()) {
-            if (!row.dirty()) {
-                continue;
-            }
-            // Snap the row band to integer pixels and paint opaque: a fractional-height fill
-            // would leave sub-pixel seams between rows.
-            double y0 = Math.floor(top + (row.row() * lineHeight));
-            double y1 = Math.ceil(top + ((row.row() + 1) * lineHeight));
-            gc.setFill(PANE_BACKGROUND);
-            gc.fillRect(px, y0, pw, y1 - y0);
-            paintSidePadding(gc, row, px, pw, left, cellWidth, y0, y1 - y0);
-            drawRow(gc, row, left, top, baseline, cellWidth, lineHeight);
-            bandMin = Math.min(bandMin, y0);
-            bandMax = Math.max(bandMax, y1);
-            // Edge rows also own the top/bottom padding strip; repaint it and extend the
-            // band so panes stacked above get restored over it too.
-            if (row.row() == 0) {
-                gc.setFill(rowEdgeBackground(row, true));
-                gc.fillRect(px, py, pw, top - py);
-                bandMin = Math.min(bandMin, py);
-            }
-            if (row.row() == lastRow) {
-                gc.setFill(rowEdgeBackground(row, true));
-                gc.fillRect(px, contentBottom, pw, py + ph - contentBottom);
-                bandMax = Math.max(bandMax, py + ph);
-            }
-            if (snapshot.cursorViewportHasValue() && row.row() == snapshot.cursorViewportY()) {
-                cursorRowDirty = true;
-            }
-        }
-        if (bandMin > bandMax) {
-            return;
-        }
-
-        // The cursor overlays its cell; redraw it only when its row was repainted, so we
-        // neither leave a stale cursor nor stack the translucent overlay on itself.
-        if (cursorRowDirty) {
-            drawCursor(gc, snapshot, left, top, cellWidth, lineHeight);
-        }
-        // Repainting rows clears the side borders within the band; restore just those
-        // segments, clipped to the band so we don't redraw the whole outline.
-        gc.save();
-        clipRect(gc, px, bandMin, pw, bandMax - bandMin);
-        drawBorder(gc, px, py, pw, ph, active);
-        gc.restore();
-    }
-
-    private void drawBorder(GraphicsContext gc, double x, double y, double width, double height, boolean active) {
-        gc.setStroke(active ? Color.rgb(87, 166, 255) : Color.rgb(52, 57, 65));
-        gc.setLineWidth(active ? 2.0 : 1.0);
-        gc.strokeRect(x + 0.5, y + 0.5, width - 1.0, height - 1.0);
-    }
-
-    // Effective background colour of a cell as it is drawn (reverse video swaps fg/bg, an
-    // unset colour falls back to the defaults).
-    private static Color cellBackgroundColor(RenderCell cell) {
-        if (cell.inverse()) {
-            var fg = cell.foreground();
-            return fg.isPresent() ? toFxColor(fg.get()) : DEFAULT_FOREGROUND;
-        }
-        var bg = cell.background();
-        return bg.isPresent() ? toFxColor(bg.get()) : PANE_BACKGROUND;
-    }
-
-    private static Color rowEdgeBackground(RenderRow row, boolean firstCell) {
-        List<RenderCell> cells = row.cells();
-        if (cells.isEmpty()) {
-            return PANE_BACKGROUND;
-        }
-        return cellBackgroundColor(firstCell ? cells.get(0) : cells.get(cells.size() - 1));
-    }
-
-    // Extend the row's edge-cell backgrounds into the left/right padding (the margin and the
-    // right-edge rounding sliver), so the unused space matches the rendered content.
-    private void paintSidePadding(GraphicsContext gc, RenderRow row, double paneX, double paneWidth,
-            double contentLeft, double cellWidth, double yTop, double bandHeight) {
-        int columns = row.cells().size();
-        if (columns == 0) {
-            return;
-        }
-        double contentRight = contentLeft + (columns * cellWidth);
-        gc.setFill(rowEdgeBackground(row, true));
-        gc.fillRect(paneX, yTop, contentLeft - paneX, bandHeight);
-        gc.setFill(rowEdgeBackground(row, false));
-        gc.fillRect(contentRight, yTop, paneX + paneWidth - contentRight, bandHeight);
-    }
-
-    // Fill the top/bottom padding strips with the top/bottom row's edge colour.
-    private void fillVerticalPadding(GraphicsContext gc, RenderStateSnapshot snapshot,
-            double paneX, double paneY, double paneWidth, double paneHeight, double contentTop, double contentBottom) {
-        List<RenderRow> rows = snapshot.renderRows();
-        if (rows.isEmpty()) {
-            return;
-        }
-        gc.setFill(rowEdgeBackground(rows.get(0), true));
-        gc.fillRect(paneX, paneY, paneWidth, contentTop - paneY);
-        gc.setFill(rowEdgeBackground(rows.get(rows.size() - 1), true));
-        gc.fillRect(paneX, contentBottom, paneWidth, paneY + paneHeight - contentBottom);
-    }
-
-    private static void drawRow(
-            GraphicsContext gc,
-            RenderRow row,
-            double left,
-            double top,
-            double baseline,
-            double cellWidth,
-            double lineHeight
-    ) {
-        for (RenderCell cell : row.cells()) {
-            if (cell.kittyPlaceholder().isPresent()) {
-                continue;
-            }
-
-            double x = left + (cell.column() * cellWidth);
-            double cellTop = top + (row.row() * lineHeight);
-
-            // Resolve fg/bg (null bg = terminal default, painted by the pane background).
-            // Avoid Optional.map's allocation on this hot path.
-            var fgOpt = cell.foreground();
-            var bgOpt = cell.background();
-            Color fg = fgOpt.isPresent() ? toFxColor(fgOpt.get()) : DEFAULT_FOREGROUND;
-            Color bg = bgOpt.isPresent() ? toFxColor(bgOpt.get()) : null;
-
-            // Reverse video: ghostty does not bake inverse into the resolved colours, so we
-            // swap them here, falling back to the terminal defaults for whichever is unset.
-            if (cell.inverse()) {
-                Color swappedBg = fg;
-                fg = (bg != null) ? bg : PANE_BACKGROUND;
-                bg = swappedBg;
-            }
-
-            if (bg != null) {
-                gc.setFill(bg);
-                gc.fillRect(x, cellTop, cellWidth, lineHeight);
-            }
-            if (cell.selected()) {
-                gc.setFill(SELECTED_BACKGROUND);
-                gc.fillRect(x, cellTop, cellWidth, lineHeight);
-            }
-            if (cell.codepoints().length == 0) {
-                continue;
-            }
-
-            double y = baseline + (row.row() * lineHeight);
-            gc.setFill(fg);
-            gc.fillText(cell.text(), x, y);
-        }
-    }
-
-    private static Color toFxColor(RenderColor color) {
-        int key = (color.red() << 16) | (color.green() << 8) | color.blue();
-        Color cached = COLOR_CACHE.get(key);
-        if (cached != null) {
-            return cached;
-        }
-        if (COLOR_CACHE.size() >= 4096) {
-            COLOR_CACHE.clear();
-        }
-        Color created = Color.rgb(color.red(), color.green(), color.blue());
-        COLOR_CACHE.put(key, created);
-        return created;
-    }
-
-    private static void drawCursor(GraphicsContext gc, RenderStateSnapshot snapshot, double left, double top, double cellWidth, double lineHeight) {
-        if (!snapshot.cursorVisible() || !snapshot.cursorViewportHasValue()) {
-            return;
-        }
-
-        double x = left + (snapshot.cursorViewportX() * cellWidth);
-        double y = top + (snapshot.cursorViewportY() * lineHeight);
-        gc.setStroke(Color.rgb(225, 229, 235));
-        gc.setFill(Color.rgb(225, 229, 235, 0.28));
-        gc.setLineWidth(1.5);
-
-        RenderCursorStyle style = snapshot.cursorStyle();
-        if (style == RenderCursorStyle.BAR) {
-            gc.strokeLine(x + 0.5, y + 2.0, x + 0.5, y + lineHeight - 2.0);
-        } else if (style == RenderCursorStyle.UNDERLINE) {
-            gc.strokeLine(x + 1.0, y + lineHeight - 2.0, x + cellWidth - 1.0, y + lineHeight - 2.0);
-        } else if (style == RenderCursorStyle.BLOCK) {
-            gc.fillRect(x + 0.5, y + 1.0, Math.max(1.0, cellWidth - 1.0), Math.max(1.0, lineHeight - 2.0));
-        } else {
-            gc.strokeRect(x + 0.5, y + 1.0, Math.max(1.0, cellWidth - 1.0), Math.max(1.0, lineHeight - 2.0));
-        }
-    }
-
-    // ---- Kitty graphics --------------------------------------------------------------
-
-    private static boolean hasKittyGraphics(RenderTarget target) {
-        return target.kittyGraphics()
-                .map(graphics -> !graphics.placements().isEmpty())
-                .orElse(false);
-    }
-
-    private void drawKittyGraphics(
-            GraphicsContext gc,
-            RenderTarget target,
-            KittyPlacementLayer layer,
-            Map<KittyPlaceholderKey, KittyPlaceholderBounds> placeholderBounds,
-            double originX,
-            double originY,
-            double cellWidth,
-            double lineHeight
-    ) {
-        target.kittyGraphics().ifPresent(graphics -> {
-            for (KittyPlacement placement : graphics.placements(layer)) {
-                Image image = imageFor(placement);
-                if (image == null) {
-                    continue;
-                }
-
-                if (placement.virtual()) {
-                    drawVirtualKittyPlacement(gc, placement, image, placeholderBounds, originX, originY, cellWidth, lineHeight);
-                } else {
-                    drawPinnedKittyPlacement(gc, placement, image, originX, originY, cellWidth, lineHeight);
-                }
-            }
-        });
-    }
-
-    private static void drawPinnedKittyPlacement(
-            GraphicsContext gc,
-            KittyPlacement placement,
-            Image image,
-            double originX,
-            double originY,
-            double cellWidth,
-            double lineHeight
-    ) {
-        KittyRenderInfo renderInfo = placement.renderInfo().orElse(null);
-        if (renderInfo == null || !renderInfo.viewportVisible()) {
-            return;
-        }
-
-        double sourceX = renderInfo.sourceX();
-        double sourceY = renderInfo.sourceY();
-        double sourceWidth = renderInfo.sourceWidth();
-        double sourceHeight = renderInfo.sourceHeight();
-        if (sourceWidth <= 0.0 || sourceHeight <= 0.0) {
-            return;
-        }
-
-        double x = originX + (renderInfo.viewportColumn() * cellWidth) + placement.xOffset();
-        double y = originY + (renderInfo.viewportRow() * lineHeight) + placement.yOffset();
-        double width = renderInfo.pixelWidth() > 0 ? renderInfo.pixelWidth() : renderInfo.gridColumns() * cellWidth;
-        double height = renderInfo.pixelHeight() > 0 ? renderInfo.pixelHeight() : renderInfo.gridRows() * lineHeight;
-        if (width <= 0.0 || height <= 0.0) {
-            return;
-        }
-
-        gc.drawImage(image, sourceX, sourceY, sourceWidth, sourceHeight, x, y, width, height);
-    }
-
-    private static void drawVirtualKittyPlacement(
-            GraphicsContext gc,
-            KittyPlacement placement,
-            Image image,
-            Map<KittyPlaceholderKey, KittyPlaceholderBounds> placeholderBounds,
-            double originX,
-            double originY,
-            double cellWidth,
-            double lineHeight
-    ) {
-        KittyPlaceholderBounds bounds = placeholderBounds.get(new KittyPlaceholderKey(placement.imageId(), placement.placementId()));
-        if (bounds == null) {
-            bounds = placeholderBounds.get(new KittyPlaceholderKey(placement.imageId(), 0));
-        }
-        if (bounds == null && placement.placementId() == 0) {
-            bounds = placeholderBounds.entrySet().stream()
-                    .filter(entry -> entry.getKey().imageId() == placement.imageId())
-                    .map(Map.Entry::getValue)
-                    .findFirst()
-                    .orElse(null);
-        }
-        if (bounds == null || bounds.isEmpty()) {
-            return;
-        }
-
-        SourceRect source = sourceRect(placement, image);
-        if (source.width() <= 0.0 || source.height() <= 0.0) {
-            return;
-        }
-
-        long gridColumns = gridColumns(placement, bounds);
-        long gridRows = gridRows(placement, bounds);
-        double sourceCellWidth = source.width() / Math.max(1L, gridColumns);
-        double sourceCellHeight = source.height() / Math.max(1L, gridRows);
-
-        double sourceX = source.x() + (bounds.minSourceColumn * sourceCellWidth);
-        double sourceY = source.y() + (bounds.minSourceRow * sourceCellHeight);
-        double sourceWidth = bounds.sourceColumns() * sourceCellWidth;
-        double sourceHeight = bounds.sourceRows() * sourceCellHeight;
-        double x = originX + (bounds.minColumn * cellWidth);
-        double y = originY + (bounds.minRow * lineHeight);
-        double availableWidth = bounds.columns() * cellWidth;
-        double availableHeight = bounds.rows() * lineHeight;
-
-        if (sourceWidth <= 0.0 || sourceHeight <= 0.0 || availableWidth <= 0.0 || availableHeight <= 0.0) {
-            return;
-        }
-
-        double scale = Math.min(availableWidth / sourceWidth, availableHeight / sourceHeight);
-        double width = sourceWidth * scale;
-        double height = sourceHeight * scale;
-        gc.drawImage(image, sourceX, sourceY, sourceWidth, sourceHeight, x, y, width, height);
-    }
-
-    private static long gridColumns(KittyPlacement placement, KittyPlaceholderBounds bounds) {
-        if (placement.columns() > 0) {
-            return placement.columns();
-        }
-        return Math.max(bounds.maxSourceColumn + 1, bounds.sourceColumns());
-    }
-
-    private static long gridRows(KittyPlacement placement, KittyPlaceholderBounds bounds) {
-        if (placement.rows() > 0) {
-            return placement.rows();
-        }
-        return Math.max(bounds.maxSourceRow + 1, bounds.sourceRows());
-    }
-
-    private static SourceRect sourceRect(KittyPlacement placement, Image image) {
-        double sourceX = placement.sourceX();
-        double sourceY = placement.sourceY();
-        double sourceWidth = placement.sourceWidth() > 0 ? placement.sourceWidth() : image.getWidth() - sourceX;
-        double sourceHeight = placement.sourceHeight() > 0 ? placement.sourceHeight() : image.getHeight() - sourceY;
-        return new SourceRect(sourceX, sourceY, Math.min(sourceWidth, image.getWidth() - sourceX), Math.min(sourceHeight, image.getHeight() - sourceY));
-    }
-
-    private Image imageFor(KittyPlacement placement) {
-        return placement.image().map(snapshot -> {
-            byte[] data = snapshot.data();
-            KittyImageKey key = KittyImageKey.of(snapshot, data);
-            Image cached = kittyImageCache.get(key);
-            if (cached != null) {
-                return cached;
-            }
-
-            kittyImageCache.keySet().removeIf(existing -> existing.id() == snapshot.id());
-            Image decoded = decodeImage(snapshot, data);
-            if (decoded != null) {
-                kittyImageCache.put(key, decoded);
-            }
-            return decoded;
-        }).orElse(null);
-    }
-
-    private Image decodeImage(KittyImageSnapshot snapshot, byte[] data) {
-        if (snapshot.compression() != KittyImageCompression.NONE) {
-            return null;
-        }
-
-        if (snapshot.format() == KittyImageFormat.PNG) {
-            return new Image(new ByteArrayInputStream(data));
-        }
-
-        int width = Math.toIntExact(snapshot.width());
-        int height = Math.toIntExact(snapshot.height());
-        WritableImage image = new WritableImage(width, height);
-
-        if (snapshot.format() == KittyImageFormat.RGBA) {
-            image.getPixelWriter().setPixels(0, 0, width, height, PixelFormat.getByteBgraInstance(), rgbaToBgra(data), 0, width * 4);
-        } else if (snapshot.format() == KittyImageFormat.RGB) {
-            image.getPixelWriter().setPixels(0, 0, width, height, PixelFormat.getByteRgbInstance(), data, 0, width * 3);
-        }
-        return image;
-    }
-
-    private static byte[] rgbaToBgra(byte[] rgba) {
-        byte[] bgra = new byte[rgba.length];
-        for (int i = 0; i + 3 < rgba.length; i += 4) {
-            bgra[i] = rgba[i + 2];
-            bgra[i + 1] = rgba[i + 1];
-            bgra[i + 2] = rgba[i];
-            bgra[i + 3] = rgba[i + 3];
-        }
-        return bgra;
-    }
-
-    private static Map<KittyPlaceholderKey, KittyPlaceholderBounds> kittyPlaceholderBounds(RenderStateSnapshot snapshot) {
-        if (snapshot == null) {
-            return Map.of();
-        }
-
-        Map<KittyPlaceholderKey, KittyPlaceholderBounds> result = new HashMap<>();
-        for (RenderRow row : snapshot.renderRows()) {
-            for (RenderCell cell : row.cells()) {
-                cell.kittyPlaceholder().ifPresent(placeholder -> {
-                    KittyPlaceholderKey key = new KittyPlaceholderKey(placeholder.imageId(), placeholder.placementId());
-                    result.computeIfAbsent(key, ignored -> new KittyPlaceholderBounds()).include(row.row(), cell.column(), placeholder);
-                });
-            }
-        }
-        return result;
-    }
-
-    // A kitty image is immutable for a given (id, number); re-transmitting under the same id
-    // changes the number (and the snapshot below evicts stale entries by id anyway). So the
-    // identity + dimensions + payload length are enough to key the decoded-image cache, and
-    // we avoid fingerprinting the whole payload — which previously ran once per frame per
-    // placement (O(image size)) just to look the image up.
-    private record KittyImageKey(long id, long number, long width, long height, KittyImageFormat format, int dataLength) {
-        private static KittyImageKey of(KittyImageSnapshot snapshot, byte[] data) {
-            return new KittyImageKey(
-                    snapshot.id(),
-                    snapshot.number(),
-                    snapshot.width(),
-                    snapshot.height(),
-                    snapshot.format(),
-                    data.length
-            );
-        }
-    }
-
-    private record KittyPlaceholderKey(long imageId, long placementId) {
-    }
-
-    private record SourceRect(double x, double y, double width, double height) {
-    }
-
-    private static final class KittyPlaceholderBounds {
-        private int minRow = Integer.MAX_VALUE;
-        private int maxRow = Integer.MIN_VALUE;
-        private int minColumn = Integer.MAX_VALUE;
-        private int maxColumn = Integer.MIN_VALUE;
-        private long minSourceRow = Long.MAX_VALUE;
-        private long maxSourceRow = Long.MIN_VALUE;
-        private long minSourceColumn = Long.MAX_VALUE;
-        private long maxSourceColumn = Long.MIN_VALUE;
-
-        private void include(int row, int column, KittyPlaceholder placeholder) {
-            minRow = Math.min(minRow, row);
-            maxRow = Math.max(maxRow, row);
-            minColumn = Math.min(minColumn, column);
-            maxColumn = Math.max(maxColumn, column);
-            minSourceRow = Math.min(minSourceRow, placeholder.sourceRow());
-            maxSourceRow = Math.max(maxSourceRow, placeholder.sourceRow());
-            minSourceColumn = Math.min(minSourceColumn, placeholder.sourceColumn());
-            maxSourceColumn = Math.max(maxSourceColumn, placeholder.sourceColumn());
-        }
-
-        private boolean isEmpty() {
-            return minRow == Integer.MAX_VALUE;
-        }
-
-        private int rows() {
-            return maxRow - minRow + 1;
-        }
-
-        private int columns() {
-            return maxColumn - minColumn + 1;
-        }
-
-        private long sourceRows() {
-            return maxSourceRow - minSourceRow + 1;
-        }
-
-        private long sourceColumns() {
-            return maxSourceColumn - minSourceColumn + 1;
-        }
-    }
-}

src/main/java/com/gregor/jprototerm/Main.java

@@ -12,7 +12,6 @@ import javafx.scene.control.Spinner;
 import javafx.scene.control.SpinnerValueFactory;
 import javafx.scene.input.KeyEvent;
 import javafx.scene.layout.GridPane;
-import javafx.scene.layout.StackPane;
 import javafx.scene.text.Font;
 import javafx.stage.Stage;
 
@@ -32,11 +31,7 @@ public final class Main extends Application {
         metrics = new TerminalMetrics(config.fontFamily(), config.fontSize());
         compositor = new Compositor(config, metrics);
 
-        StackPane root = new StackPane(compositor.canvas());
+        Scene scene = new Scene(compositor.node(), config.windowWidth(), config.windowHeight());
-        compositor.canvas().widthProperty().bind(root.widthProperty());
-        compositor.canvas().heightProperty().bind(root.heightProperty());
-
-        Scene scene = new Scene(root, config.windowWidth(), config.windowHeight());
         scene.addEventFilter(KeyEvent.KEY_PRESSED, this::handlePressed);
         scene.addEventFilter(KeyEvent.KEY_TYPED, event -> handleTyped(event));
 
@@ -53,7 +48,7 @@ public final class Main extends Application {
             compositor.close();
         });
         stage.show();
-        compositor.canvas().requestFocus();
+        compositor.requestFocus();
     }
 
     private void handlePressed(KeyEvent event) {
@@ -75,9 +70,6 @@ public final class Main extends Application {
         } else if (config.keybindings().get("new_pane").matches(event)) {
             compositor.createPane();
             event.consume();
-        } else if (config.keybindings().get("next_floating").matches(event)) {
-            compositor.nextFloatingPane();
-            event.consume();
         } else if (config.keybindings().get("close_pane").matches(event)) {
             compositor.closeActivePane();
             event.consume();
@@ -161,7 +153,7 @@ public final class Main extends Application {
                     config = config.withFont(selectedFamily.trim(), selectedSize);
                     config.save();
                     compositor.setFont(config.fontFamily(), config.fontSize());
-                    compositor.canvas().requestFocus();
+                    compositor.requestFocus();
                 });
     }
 

src/main/java/com/gregor/jprototerm/RenderProfiler.java

@@ -0,0 +1,79 @@
+package com.gregor.jprototerm;
+
+/**
+ * Lightweight render profiler, disabled unless {@code -Djprototerm.profile=true} (or the
+ * {@code JPROTOTERM_PROFILE=1} environment variable) is set. It accumulates wall-clock nanos
+ * into a handful of buckets and prints aggregate per-frame stats to stderr every
+ * {@code jprototerm.profile.frames} render invocations (default 120).
+ *
+ * <p>All render work runs on the JavaFX application thread, so the accumulators are plain
+ * fields with no synchronization.
+ *
+ * <p>Caveat: JavaFX canvas drawing is deferred to the QuantumRenderer thread, so the
+ * {@link #DRAW} bucket measures only the cost of <em>recording</em> draw commands, not the
+ * GPU paint. Pair this with {@code -Djavafx.pulseLogger=true} to see the render-thread side.
+ */
+final class RenderProfiler {
+    static final int SNAPSHOT = 0;
+    static final int FINGERPRINT = 1;
+    static final int DRAW = 2;
+    static final int FRAME = 3;
+    static final int UPDATE = 4;
+    static final int MARSHAL = 5;
+    private static final int BUCKETS = 6;
+    private static final String[] NAMES =
+            {"snapshot", "fingerprint", "draw", "frame-total", "update", "marshal"};
+
+    private static final boolean ENABLED =
+            Boolean.getBoolean("jprototerm.profile") || "1".equals(System.getenv("JPROTOTERM_PROFILE"));
+    private static final int DUMP_FRAMES = Integer.getInteger("jprototerm.profile.frames", 120);
+
+    private static final long[] totalNanos = new long[BUCKETS];
+    private static final long[] counts = new long[BUCKETS];
+    private static int frames;
+
+    private RenderProfiler() {
+    }
+
+    static boolean enabled() {
+        return ENABLED;
+    }
+
+    /** Returns a start timestamp, or 0 when profiling is disabled. */
+    static long start() {
+        return ENABLED ? System.nanoTime() : 0L;
+    }
+
+    /** Records the time elapsed since {@code startNanos} into {@code bucket}. */
+    static void stop(int bucket, long startNanos) {
+        if (!ENABLED) {
+            return;
+        }
+        totalNanos[bucket] += System.nanoTime() - startNanos;
+        counts[bucket]++;
+    }
+
+    /** Marks the end of one render invocation; dumps and resets every {@code DUMP_FRAMES}. */
+    static void frame() {
+        if (!ENABLED) {
+            return;
+        }
+        if (++frames < DUMP_FRAMES) {
+            return;
+        }
+        dump();
+    }
+
+    private static void dump() {
+        StringBuilder sb = new StringBuilder(192);
+        sb.append("[render-profile] ").append(frames).append(" renders");
+        for (int i = 0; i < BUCKETS; i++) {
+            double totalMs = totalNanos[i] / 1_000_000.0;
+            sb.append(String.format(" | %s %.3fms/f (n=%d)", NAMES[i], totalMs / frames, counts[i]));
+            totalNanos[i] = 0;
+            counts[i] = 0;
+        }
+        System.err.println(sb);
+        frames = 0;
+    }
+}

src/main/java/com/gregor/jprototerm/RenderTarget.java

@@ -1,45 +0,0 @@
-package com.gregor.jprototerm;
-
-import dev.jlibghostty.KittyGraphics;
-import dev.jlibghostty.RenderStateSnapshot;
-import javafx.scene.shape.Shape;
-
-import java.util.Optional;
-
-/**
- * The read-only view of a pane that a {@link TerminalRenderer} draws: its on-screen rect, its
- * current render snapshot, and its kitty-graphics state. Decoupling the renderer from
- * {@link TerminalPane} through this interface lets the renderer be swapped (e.g. a debug
- * renderer that just outlines bounds and clip bands) and unit-tested against a synthetic
- * target without a real terminal.
- */
-interface RenderTarget {
-    double x();
-
-    double y();
-
-    double width();
-
-    double height();
-
-    /** Whether kitty graphics should be drawn for this target at all. */
-    boolean kittyEnabled();
-
-    Optional<KittyGraphics> kittyGraphics();
-
-    /**
-     * Incremental snapshot: only rows that changed since the last frame are populated. May be
-     * {@code null} before the first snapshot exists.
-     */
-    RenderStateSnapshot snapshot();
-
-    /** Full snapshot with every row populated, regardless of dirty state. */
-    RenderStateSnapshot snapshotFull();
-
-    /**
-     * The region this target may draw into, or {@code null} to clip to its plain rect. Set at
-     * layout time (a tiled pane gets its rect minus the floating panes that cover it), so the
-     * renderer can clip its own output and never paint over a pane on top.
-     */
-    Shape clip();
-}

src/main/java/com/gregor/jprototerm/Tab.java

@@ -1,8 +1,5 @@
 package com.gregor.jprototerm;
 
-import javafx.scene.shape.Rectangle;
-import javafx.scene.shape.Shape;
-
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
@@ -78,6 +75,13 @@ final class Tab implements AutoCloseable {
         return List.copyOf(ordered);
     }
 
+    List<TerminalPane> allPanes() {
+        List<TerminalPane> all = new ArrayList<>(tiled.size() + floating.size());
+        all.addAll(tiled);
+        all.addAll(floating);
+        return List.copyOf(all);
+    }
+
     boolean isActive(TerminalPane pane) {
         return pane != null && pane == active;
     }
@@ -111,51 +115,6 @@ final class Tab implements AutoCloseable {
                     floatingWidth,
                     floatingHeight);
         }
-
-        assignClips();
-    }
-
-    // Give each pane its clip region for the next paints, so repainting a pane on a content
-    // frame can never bleed over one stacked on top of it. Each pane is clipped to its rect
-    // minus the union of the panes above it: floating panes are clipped by the floating panes
-    // higher in the stack, and tiled panes by the whole floating group. When nothing floats,
-    // every pane clips to its plain bounds.
-    private void assignClips() {
-        if (!floatingVisible || floating.isEmpty()) {
-            tiled.forEach(pane -> pane.setClip(null));
-            floating.forEach(pane -> pane.setClip(null));
-            return;
-        }
-
-        // Floating panes bottom-to-top, matching panes(): insertion order, active pane on top.
-        List<TerminalPane> order = new ArrayList<>(floating.size());
-        for (TerminalPane pane : floating) {
-            if (pane != active) {
-                order.add(pane);
-            }
-        }
-        if (floating.contains(active)) {
-            order.add(active);
-        }
-
-        // Walk top-to-bottom, accumulating the union of the panes above each one.
-        Shape above = null;
-        for (int i = order.size() - 1; i >= 0; i--) {
-            Rectangle rect = rectOf(order.get(i));
-            order.get(i).setClip(above == null ? null : Shape.subtract(rect, above));
-            above = (above == null) ? rect : Shape.union(above, rect);
-        }
-
-        // `above` is now the union of every floating pane; tiled panes sit under all of them.
-        for (TerminalPane pane : tiled) {
-            pane.setClip(Shape.subtract(rectOf(pane), above));
-        }
-    }
-
-    // Match the renderer's pixel snapping (round the origin, keep width/height) so the clip
-    // lines up exactly with where the floating panes are drawn.
-    private static Rectangle rectOf(TerminalPane pane) {
-        return new Rectangle(Math.round(pane.x()), Math.round(pane.y()), pane.width(), pane.height());
     }
 
     boolean navigate(Direction direction) {
@@ -201,16 +160,6 @@ final class Tab implements AutoCloseable {
         }
     }
 
-    void nextFloatingPane() {
-        if (floating.isEmpty()) {
-            createFloatingPane();
-            return;
-        }
-        floatingVisible = true;
-        int current = floating.indexOf(active); // -1 when the active pane is tiled
-        setActive(floating.get((current + 1 + floating.size()) % floating.size()));
-    }
-
     void closeActivePane() {
         TerminalPane closing = active;
         boolean wasFloating = floating.remove(closing);

src/main/java/com/gregor/jprototerm/TerminalPane.java

@@ -12,35 +12,28 @@ import dev.jlibghostty.RenderStateSnapshot;
 import dev.jlibghostty.ScrollViewport;
 import dev.jlibghostty.Terminal;
 import dev.jlibghostty.TerminalOptions;
-import javafx.scene.canvas.GraphicsContext;
-import javafx.scene.shape.Shape;
 
 import java.util.Optional;
+import java.util.concurrent.atomic.AtomicLong;
 
 /**
  * One terminal: owns its ghostty {@link Terminal}, the {@link ShellSession}/pty driving it,
- * and its on-screen geometry and grid. It does not draw itself — it is a {@link RenderTarget}
+ * and its on-screen geometry and grid. It does not draw itself; {@link TerminalPaneNode}
- * that a {@link TerminalRenderer} paints. {@link #paintFull}/{@link #paintIncremental} are the
+ * reads snapshots from it and represents the visible rows and kitty graphics as JavaFX nodes.
- * only rendering API exposed to the {@link Compositor}, and they just delegate to that
- * renderer; the compositor decides z-order and which rect each pane occupies.
  */
-public final class TerminalPane implements AutoCloseable, RenderTarget {
+public final class TerminalPane implements AutoCloseable {
     private final Terminal terminal;
     private final TerminalMetrics metrics;
     private final boolean kittyEnabled;
     // Run on every content change so the owning tab can bump its content version — the
     // compositor's O(1) "did the current tab change?" gate.
     private final Runnable onContentChange;
-    private final TerminalRenderer renderer;
     private final MouseEncoder mouseEncoder = new MouseEncoder();
     // A persistent render state (reused across frames) is what makes ghostty's per-row dirty
     // tracking meaningful: update() accumulates dirty since the last resetDirty().
     private final RenderState renderState = new RenderState();
     private RenderStateSnapshot cachedSnapshot;
     private ShellSession session;
-    // Clip region for rendering (rect minus the panes covering this one), set at layout time;
-    // null means clip to the plain bounds. See RenderTarget#clip().
-    private Shape clip;
     private double x;
     private double y;
     private double width;
@@ -49,16 +42,15 @@ public final class TerminalPane implements AutoCloseable, RenderTarget {
     private int rows;
     private int pixelWidth;
     private int pixelHeight;
-    private long contentVersion;
+    private final AtomicLong contentVersion = new AtomicLong();
-    private long snapshotVersion = -1;
+    private volatile long snapshotVersion = -1;
 
     private TerminalPane(Terminal terminal, TerminalMetrics metrics, boolean kittyEnabled,
-            Runnable onContentChange, TerminalRenderer renderer, int columns, int rows) {
+            Runnable onContentChange, int columns, int rows) {
         this.terminal = terminal;
         this.metrics = metrics;
         this.kittyEnabled = kittyEnabled;
         this.onContentChange = onContentChange;
-        this.renderer = renderer;
         this.columns = columns;
         this.rows = rows;
     }
@@ -75,8 +67,7 @@ public final class TerminalPane implements AutoCloseable, RenderTarget {
         int rows = heightPx > 0 ? metrics.rowsFor(heightPx) : config.rows();
         Terminal terminal = Ghostty.open(new TerminalOptions(columns, rows, config.maxScrollback()));
         terminal.setDeviceAttributesProvider(DeviceAttributes::xtermCompatible);
-        TerminalPane pane = new TerminalPane(terminal, metrics, config.kittyGraphics(), onContentChange,
+        TerminalPane pane = new TerminalPane(terminal, metrics, config.kittyGraphics(), onContentChange, columns, rows);
-                new GhosttyTerminalRenderer(metrics), columns, rows);
         pane.refresh();
         pane.attach(ShellSession.start(config.shell(), config.envOverride(), pane, columns, rows));
         return pane;
@@ -153,7 +144,6 @@ public final class TerminalPane implements AutoCloseable, RenderTarget {
      * Snapshotting is deferred here rather than done in refresh(), so a burst of writes
      * between two frames collapses into a single snapshot.
      */
-    @Override
     public RenderStateSnapshot snapshot() {
         return takeSnapshot(false);
     }
@@ -162,23 +152,31 @@ public final class TerminalPane implements AutoCloseable, RenderTarget {
      * Full snapshot with every row's cells populated. Used where the whole pane is redrawn
      * regardless of dirty state (the kitty-graphics path).
      */
-    @Override
     public RenderStateSnapshot snapshotFull() {
         return takeSnapshot(true);
     }
 
     private RenderStateSnapshot takeSnapshot(boolean full) {
         synchronized (terminal) {
+            long version = contentVersion.get();
             if (full) {
+                long updateStart = RenderProfiler.start();
                 renderState.update(terminal);
+                RenderProfiler.stop(RenderProfiler.UPDATE, updateStart);
+                long marshalStart = RenderProfiler.start();
                 cachedSnapshot = renderState.snapshot();
+                RenderProfiler.stop(RenderProfiler.MARSHAL, marshalStart);
                 renderState.resetDirty();
-                snapshotVersion = contentVersion;
+                snapshotVersion = version;
-            } else if (snapshotVersion != contentVersion) {
+            } else if (snapshotVersion != version) {
+                long updateStart = RenderProfiler.start();
                 renderState.update(terminal);
+                RenderProfiler.stop(RenderProfiler.UPDATE, updateStart);
+                long marshalStart = RenderProfiler.start();
                 cachedSnapshot = renderState.snapshotIncremental();
+                RenderProfiler.stop(RenderProfiler.MARSHAL, marshalStart);
                 renderState.resetDirty();
-                snapshotVersion = contentVersion;
+                snapshotVersion = version;
             }
             return cachedSnapshot;
         }
@@ -192,37 +190,35 @@ public final class TerminalPane implements AutoCloseable, RenderTarget {
 
     /** This pane's own content revision, bumped on every change (see {@link #refresh()}). */
     public long contentVersion() {
-        return contentVersion;
+        return contentVersion.get();
+    }
+
+    long snapshotVersion() {
+        return snapshotVersion;
     }
 
-    @Override
     public boolean kittyEnabled() {
         return kittyEnabled;
     }
 
-    @Override
     public Optional<KittyGraphics> kittyGraphics() {
         synchronized (terminal) {
             return terminal.kittyGraphics();
         }
     }
 
-    @Override
     public double x() {
         return x;
     }
 
-    @Override
     public double y() {
         return y;
     }
 
-    @Override
     public double width() {
         return width;
     }
 
-    @Override
     public double height() {
         return height;
     }
@@ -234,16 +230,6 @@ public final class TerminalPane implements AutoCloseable, RenderTarget {
         this.height = height;
     }
 
-    /** Set the clip region applied on the next paints (see {@link RenderTarget#clip()}). */
-    public void setClip(Shape clip) {
-        this.clip = clip;
-    }
-
-    @Override
-    public Shape clip() {
-        return clip;
-    }
-
     /** Recompute the ghostty grid from the current bounds and the shared cell metrics. */
     public void fitToBounds() {
         int columns = metrics.columnsFor(width);
@@ -276,20 +262,10 @@ public final class TerminalPane implements AutoCloseable, RenderTarget {
         // Mark this pane's content dirty (the snapshot is computed lazily in the paint path,
         // so a burst of writes collapses into one snapshot per frame) and tell the owning tab
         // one of its panes changed.
-        contentVersion++;
+        contentVersion.incrementAndGet();
         onContentChange.run();
     }
 
-    /** Paint the whole pane; see {@link TerminalRenderer#paintFull}. */
-    public void paintFull(GraphicsContext gc, boolean active) {
-        renderer.paintFull(gc, this, active);
-    }
-
-    /** Repaint what changed; see {@link TerminalRenderer#paintIncremental}. */
-    public void paintIncremental(GraphicsContext gc, boolean active) {
-        renderer.paintIncremental(gc, this, active);
-    }
-
     @Override
     public void close() {
         if (session != null) {

src/main/java/com/gregor/jprototerm/TerminalRenderer.java

@@ -1,60 +0,0 @@
-package com.gregor.jprototerm;
-
-import javafx.scene.canvas.GraphicsContext;
-import javafx.scene.shape.ClosePath;
-import javafx.scene.shape.LineTo;
-import javafx.scene.shape.MoveTo;
-import javafx.scene.shape.Path;
-import javafx.scene.shape.PathElement;
-import javafx.scene.shape.Shape;
-
-/**
- * Draws a {@link RenderTarget} onto a JavaFX canvas. The {@link Compositor} owns positioning
- * and z-order; a renderer only fills the target's rect, clipped to the target's {@link
- * RenderTarget#clip() clip region} so a repaint can never bleed over a pane on top.
- * Implementations can change the look entirely — {@link GhosttyTerminalRenderer} is the real
- * terminal renderer; a debug renderer could outline pane bounds instead.
- *
- * <p>A renderer may hold per-target state (e.g. a decoded-image cache), so an instance belongs
- * to a single {@link TerminalPane}.
- */
-abstract class TerminalRenderer {
-    /** Paint the whole target into its rect, clipped to its clip region. */
-    abstract void paintFull(GraphicsContext gc, RenderTarget target, boolean active);
-
-    /** Repaint only what changed since the last frame, clipped to the target's clip region. */
-    abstract void paintIncremental(GraphicsContext gc, RenderTarget target, boolean active);
-
-    protected static void clipRect(GraphicsContext gc, double x, double y, double width, double height) {
-        gc.beginPath();
-        gc.rect(x, y, width, height);
-        gc.clip();
-    }
-
-    /**
-     * Clip to {@code region} if given (the pane's rect minus the panes covering it, computed by
-     * {@code Shape.subtract} at layout), otherwise to the plain rect. The region is a rectilinear
-     * path, so it replays onto the canvas as move/line/close segments.
-     */
-    protected static void clip(GraphicsContext gc, double x, double y, double width, double height, Shape region) {
-        if (region == null) {
-            clipRect(gc, x, y, width, height);
-            return;
-        }
-        var elements = ((Path) region).getElements();
-        gc.beginPath();
-        if (elements.isEmpty()) {
-            gc.rect(x, y, 0.0, 0.0); // fully covered: clip to nothing
-        }
-        for (PathElement element : elements) {
-            if (element instanceof MoveTo moveTo) {
-                gc.moveTo(moveTo.getX(), moveTo.getY());
-            } else if (element instanceof LineTo lineTo) {
-                gc.lineTo(lineTo.getX(), lineTo.getY());
-            } else if (element instanceof ClosePath) {
-                gc.closePath();
-            }
-        }
-        gc.clip();
-    }
-}