#160: Auto size sections in the KL-driven concept card based on volume of content

Author: dukke

kview/src/main/java/dev/ikm/komet/kview/controls/ContentSizedSplitPane.java

@@ -0,0 +1,136 @@
+package dev.ikm.komet.kview.controls;
+
+import dev.ikm.komet.kview.fxutils.FXUtils;
+import javafx.event.EventTarget;
+import javafx.geometry.Orientation;
+import javafx.scene.Node;
+import javafx.scene.control.SplitPane;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.Region;
+
+import java.util.List;
+
+/**
+ * A {@link SplitPane} that gives each of its items the size its content asks for, instead of
+ * splitting its length evenly between them. An item holding a couple of rows takes the height
+ * those rows need and no more; the space it doesn't use goes to the last item, which is also the
+ * one the pane's own resizing grows and shrinks.
+ *
+ * <p>When the items' combined preferred size doesn't fit, each is capped at its fair share of what
+ * there is (see {@link FXUtils#capAtFairShare(double[], double)}): the small items keep their full
+ * preferred size, and what they leave over raises the share of the larger ones.
+ *
+ * <p>The sizing is re-applied on every layout pass, so an item that gains or loses content resizes
+ * with it — until the user drags a divider. From that first drag on, this behaves as an ordinary
+ * SplitPane and the items keep the sizes the user gives them.
+ */
+public class ContentSizedSplitPane extends SplitPane {
+
+    /** Style class the skin puts on its divider nodes. */
+    private static final String DIVIDER_STYLE_CLASS = "split-pane-divider";
+
+    /**
+     * Divider positions are fractions of the pane's length, so this is well under a pixel for any
+     * realistic pane. Positions closer than this to the ones already set are left alone: setting a
+     * position asks for another layout pass, which a rounding difference alone shouldn't do.
+     */
+    private static final double POSITION_TOLERANCE = 0.0001;
+
+    private boolean sizeToContent = true;
+
+    public ContentSizedSplitPane() {
+        // Grabbing a divider hands the sizing over to the user, for good.
+        addEventFilter(MouseEvent.MOUSE_PRESSED, mouseEvent -> {
+            if (isDivider(mouseEvent.getTarget())) {
+                sizeToContent = false;
+            }
+        });
+    }
+
+    @Override
+    protected void layoutChildren() {
+        if (sizeToContent) {
+            sizeItemsToContent();
+        }
+        super.layoutChildren();
+    }
+
+    /**
+     * Places the dividers so every item gets its preferred size, with the last item taking whatever
+     * the others didn't need.
+     */
+    private void sizeItemsToContent() {
+        List<Node> items = getItems();
+        List<Divider> dividers = getDividers();
+        if (dividers.isEmpty() || items.size() != dividers.size() + 1) {
+            // The skin creates a divider per gap between items; until it has, there is nothing to
+            // place (and nothing shown either).
+            return;
+        }
+
+        boolean vertical = getOrientation() == Orientation.VERTICAL;
+        double length = vertical
+                ? getHeight() - snappedTopInset() - snappedBottomInset()
+                : getWidth() - snappedLeftInset() - snappedRightInset();
+        double breadth = vertical
+                ? getWidth() - snappedLeftInset() - snappedRightInset()
+                : getHeight() - snappedTopInset() - snappedBottomInset();
+        double dividerThickness = dividerThickness();
+        double availableLength = length - dividerThickness * dividers.size();
+        if (availableLength <= 0 || breadth <= 0) {
+            return;
+        }
+
+        double[] prefSizes = new double[items.size()];
+        for (int i = 0; i < items.size(); i++) {
+            Node item = items.get(i);
+            prefSizes[i] = vertical ? item.prefHeight(breadth) : item.prefWidth(breadth);
+        }
+
+        double[] sizes = FXUtils.capAtFairShare(prefSizes, availableLength);
+        double allotted = 0;
+        for (double size : sizes) {
+            allotted += size;
+        }
+        sizes[sizes.length - 1] += availableLength - allotted;
+
+        // A divider's position is where its centre sits, as a fraction of the pane's length (see
+        // SplitPaneSkin), so walk the items adding each one's size and the divider that follows it.
+        double edge = 0;
+        for (int i = 0; i < dividers.size(); i++) {
+            edge += sizes[i];
+            double position = (edge + dividerThickness / 2) / length;
+            Divider divider = dividers.get(i);
+            if (Math.abs(divider.getPosition() - position) > POSITION_TOLERANCE) {
+                divider.setPosition(position);
+            }
+            edge += dividerThickness;
+        }
+    }
+
+    /**
+     * How much of the pane's length a divider takes up. The skin sizes its dividers by their
+     * preferred width whichever way the pane is oriented, so this reads the same measure.
+     */
+    private double dividerThickness() {
+        for (Node child : getChildrenUnmodifiable()) {
+            if (child instanceof Region divider && divider.getStyleClass().contains(DIVIDER_STYLE_CLASS)) {
+                return divider.prefWidth(-1);
+            }
+        }
+        return 0;
+    }
+
+    /** Whether the passed in event target is a divider, or a part of one (its grabber). */
+    private boolean isDivider(EventTarget target) {
+        for (Node node = target instanceof Node hit ? hit : null; node != null; node = node.getParent()) {
+            if (node.getStyleClass().contains(DIVIDER_STYLE_CLASS)) {
+                return true;
+            }
+            if (node == this) {
+                return false;
+            }
+        }
+        return false;
+    }
+}

kview/src/main/java/dev/ikm/komet/kview/controls/skin/SectionTitledPaneSkin.java

@@ -1,6 +1,7 @@
 package dev.ikm.komet.kview.controls.skin;
 
 import dev.ikm.komet.kview.controls.SectionTitledPane;
+import dev.ikm.komet.kview.fxutils.FXUtils;
 import javafx.beans.binding.Bindings;
 import javafx.collections.ObservableList;
 import javafx.css.PseudoClass;
@@ -203,18 +204,32 @@ protected void layoutChildren() {
             super.layoutChildren();
         }
 
+        /**
+         * The height the content wants, which is every row's preferred height stacked up. Measured
+         * from the children rather than from the row constraints: those hold the heights the grid's
+         * current height allowed (see {@link #applyRowConstraints()}), so a grid that was once
+         * squeezed would go on asking for the squeezed height and never get its room back.
+         */
+        @Override
+        protected double computePrefHeight(double width) {
+            double contentWidth = width < 0 ? -1 : width - snappedLeftInset() - snappedRightInset();
+            double[] rowPrefHeights = rowPrefHeights(contentWidth);
+            double prefHeight = Math.max(0, rowPrefHeights.length - 1) * getVgap();
+            for (double rowPrefHeight : rowPrefHeights) {
+                prefHeight += rowPrefHeight;
+            }
+            return snappedTopInset() + prefHeight + snappedBottomInset();
+        }
+
         /**
          * Recomputes the fixed per-row heights for the current size and content and installs them
          * as this grid's row constraints. Guarded so constraints are only touched when the heights
          * actually change — installing them re-requests layout, and the guard is what lets that
          * follow-up pass settle.
          */
         private void applyRowConstraints() {
-            List<Node> children = getManagedChildren();
-            int rowCount = 0;
-            for (Node child : children) {
-                rowCount = Math.max(rowCount, rowIndexOf(child) + 1);
-            }
+            double[] rowPrefHeights = rowPrefHeights(getWidth() - snappedLeftInset() - snappedRightInset());
+            int rowCount = rowPrefHeights.length;
             if (rowCount == 0) {
                 if (appliedRowHeights.length > 0) {
                     appliedRowHeights = new double[0];
@@ -223,25 +238,9 @@ private void applyRowConstraints() {
                 return;
             }
 
-            // Column widths are uniform (see numberColumnsProperty subscription: every column
-            // gets the same percentWidth), so each child's width — which its preferred height
-            // may depend on — follows from its column span alone.
-            int columnCount = Math.max(1, getColumnConstraints().size());
-            double contentWidth = getWidth() - snappedLeftInset() - snappedRightInset();
-            double columnWidth = (contentWidth - getHgap() * (columnCount - 1)) / columnCount;
-
-            double[] rowPrefHeights = new double[rowCount];
-            for (Node child : children) {
-                Integer span = GridPane.getColumnSpan(child);
-                int columnSpan = span == null ? 1 : span;
-                double cellWidth = columnWidth * columnSpan + getHgap() * (columnSpan - 1);
-                int row = rowIndexOf(child);
-                rowPrefHeights[row] = Math.max(rowPrefHeights[row], child.prefHeight(cellWidth));
-            }
-
             double availableHeight = getHeight() - snappedTopInset() - snappedBottomInset()
                     - getVgap() * (rowCount - 1);
-            double[] rowHeights = capAtFairShare(rowPrefHeights, availableHeight);
+            double[] rowHeights = FXUtils.capAtFairShare(rowPrefHeights, availableHeight);
             for (int i = 0; i < rowHeights.length; i++) {
                 rowHeights[i] = snapSizeY(rowHeights[i]);
             }
@@ -264,48 +263,46 @@ private void applyRowConstraints() {
             getRowConstraints().setAll(constraints);
         }
 
-        private static int rowIndexOf(Node child) {
-            Integer rowIndex = GridPane.getRowIndex(child);
-            return rowIndex == null ? 0 : rowIndex;
-        }
-
         /**
-         * Allocates the available height among the rows: every row gets at most its preferred
-         * height, and a row only gets less when the rows that need more than an equal split
-         * cannot be satisfied — those tall rows then share what the short rows left over.
+         * The preferred height of each row — the tallest preferred height among the children in it
+         * — measured at the width the passed in content width leaves each cell. A negative content
+         * width (the grid is being measured without one) leaves the children to their own
+         * unconstrained preferred height.
          */
-        private static double[] capAtFairShare(double[] prefHeights, double availableHeight) {
-            int rowCount = prefHeights.length;
-            double[] heights = new double[rowCount];
-            boolean[] keepsPref = new boolean[rowCount];
-            double remaining = Math.max(0, availableHeight);
-            int uncapped = rowCount;
-
-            // Settle the rows that fit within the current fair share; every row settled frees
-            // up share for the rest, so iterate until a full pass settles nothing.
-            boolean settledAny = true;
-            while (settledAny && uncapped > 0) {
-                settledAny = false;
-                double fairShare = remaining / uncapped;
-                for (int i = 0; i < rowCount; i++) {
-                    if (!keepsPref[i] && prefHeights[i] <= fairShare) {
-                        keepsPref[i] = true;
-                        heights[i] = prefHeights[i];
-                        remaining -= prefHeights[i];
-                        uncapped--;
-                        settledAny = true;
-                    }
-                }
+        private double[] rowPrefHeights(double contentWidth) {
+            List<Node> children = getManagedChildren();
+            int rowCount = 0;
+            for (Node child : children) {
+                rowCount = Math.max(rowCount, rowIndexOf(child) + 1);
             }
-            if (uncapped > 0) {
-                double fairShare = remaining / uncapped;
-                for (int i = 0; i < rowCount; i++) {
-                    if (!keepsPref[i]) {
-                        heights[i] = fairShare;
-                    }
-                }
+            if (rowCount == 0) {
+                return new double[0];
             }
-            return heights;
+
+            // Column widths are uniform (see numberColumnsProperty subscription: every column
+            // gets the same percentWidth), so each child's width — which its preferred height
+            // may depend on — follows from its column span alone.
+            int columnCount = Math.max(1, getColumnConstraints().size());
+            double columnWidth = contentWidth < 0
+                    ? -1
+                    : (contentWidth - getHgap() * (columnCount - 1)) / columnCount;
+
+            double[] rowPrefHeights = new double[rowCount];
+            for (Node child : children) {
+                Integer span = GridPane.getColumnSpan(child);
+                int columnSpan = span == null ? 1 : span;
+                double cellWidth = columnWidth < 0
+                        ? -1
+                        : columnWidth * columnSpan + getHgap() * (columnSpan - 1);
+                int row = rowIndexOf(child);
+                rowPrefHeights[row] = Math.max(rowPrefHeights[row], child.prefHeight(cellWidth));
+            }
+            return rowPrefHeights;
+        }
+
+        private static int rowIndexOf(Node child) {
+            Integer rowIndex = GridPane.getRowIndex(child);
+            return rowIndex == null ? 0 : rowIndex;
         }
 
         private boolean heightsChanged(double[] rowHeights) {

kview/src/main/java/dev/ikm/komet/kview/fxutils/FXUtils.java

@@ -310,4 +310,47 @@ private static void getTopmostPaneHierarchy(List<Pane> paneHierarchy, Node node)
         }
     }
 
+    /**
+     * Distributes {@code availableSize} among items that ask for {@code prefSizes}: every item gets
+     * at most the size it prefers, and an item only gets less than that when the items asking for
+     * more than an equal share cannot all be satisfied — those tall items then share whatever the
+     * shorter ones left over.
+     *
+     * @param prefSizes     the size each item prefers, in item order
+     * @param availableSize the size to distribute between them
+     * @return the size allotted to each item, in the same order
+     */
+    public static double[] capAtFairShare(double[] prefSizes, double availableSize) {
+        int itemCount = prefSizes.length;
+        double[] sizes = new double[itemCount];
+        boolean[] keepsPref = new boolean[itemCount];
+        double remaining = Math.max(0, availableSize);
+        int uncapped = itemCount;
+
+        // Settle the items that fit within the current fair share; every item settled frees up
+        // share for the rest, so iterate until a full pass settles nothing.
+        boolean settledAny = true;
+        while (settledAny && uncapped > 0) {
+            settledAny = false;
+            double fairShare = remaining / uncapped;
+            for (int i = 0; i < itemCount; i++) {
+                if (!keepsPref[i] && prefSizes[i] <= fairShare) {
+                    keepsPref[i] = true;
+                    sizes[i] = prefSizes[i];
+                    remaining -= prefSizes[i];
+                    uncapped--;
+                    settledAny = true;
+                }
+            }
+        }
+        if (uncapped > 0) {
+            double fairShare = remaining / uncapped;
+            for (int i = 0; i < itemCount; i++) {
+                if (!keepsPref[i]) {
+                    sizes[i] = fairShare;
+                }
+            }
+        }
+        return sizes;
+    }
 }

kview/src/main/java/dev/ikm/komet/kview/mvvm/view/genpurpose/GenPurposeDetailsController.java

@@ -43,6 +43,7 @@
 import dev.ikm.komet.framework.observable.ObservableSemanticVersion;
 import dev.ikm.komet.framework.view.ViewProperties;
 import dev.ikm.komet.kview.common.ViewCalculatorUtils;
+import dev.ikm.komet.kview.controls.ContentSizedSplitPane;
 import dev.ikm.komet.kview.controls.ComponentItem;
 import dev.ikm.komet.kview.controls.KLWorkspace;
 import dev.ikm.komet.kview.controls.KlWindowControlToolbar;
@@ -201,7 +202,7 @@ public class GenPurposeDetailsController {
     @FXML
     StampViewControl stampViewControl;
     @FXML
-    private SplitPane mainContent;
+    private ContentSizedSplitPane mainContent;
     @FXML
     private BorderPane detailsOuterBorderPane;
     @FXML
@@ -269,7 +270,9 @@ private void initialize() {
 
         // When the window resizes vertically only the bottom section should grow or shrink; the
         // SplitPane's default is to spread the delta across every section proportionally, so pin
-        // all items except the last one.
+        // all items except the last one. This takes over once the user has claimed the sections'
+        // sizing by dragging a divider — until then ContentSizedSplitPane sizes every section to
+        // its content and hands the leftover height to that same last section.
         mainContent.getItems().subscribe(() -> {
             List<Node> items = mainContent.getItems();
             items.forEach(item -> SplitPane.setResizableWithParent(item, item == items.getLast()));

kview/src/main/resources/dev/ikm/komet/kview/mvvm/view/genpurpose/genpurpose-details.fxml

@@ -17,7 +17,7 @@
 <?import javafx.scene.layout.VBox?>
 <?import javafx.scene.shape.SVGPath?>
 
-<?import javafx.scene.control.SplitPane?>
+<?import dev.ikm.komet.kview.controls.ContentSizedSplitPane?>
 <?import dev.ikm.komet.kview.controls.ComponentItemNode?>
 <BorderPane fx:id="detailsOuterBorderPane" maxHeight="Infinity" maxWidth="Infinity" prefWidth="727.0"
             stylesheets="@../kview.css" xmlns="http://javafx.com/javafx/24.0.1" xmlns:fx="http://javafx.com/fxml/1"
@@ -58,7 +58,7 @@
                         <VBox focusTraversable="true" maxHeight="1.7976931348623157E308" prefWidth="762.0">
                             <children>
                                 <HBox layoutX="14.0" layoutY="135.0" prefWidth="711.0" VBox.vgrow="ALWAYS">
-                                        <SplitPane fx:id="mainContent" orientation="VERTICAL" HBox.hgrow="ALWAYS"/>
+                                        <ContentSizedSplitPane fx:id="mainContent" orientation="VERTICAL" HBox.hgrow="ALWAYS"/>
                                 </HBox>
                             </children>
                         </VBox>