Ticket #13198: patch-fix-flow-layout-wrap.patch

src/org/openstreetmap/josm/gui/io/UploadDialog.java

@@ -5 +5 @@
 import static org.openstreetmap.josm.tools.I18n.tr;
 import static org.openstreetmap.josm.tools.I18n.trn;
 
-import java.awt.BorderLayout;
 import java.awt.Component;
 import java.awt.Dimension;
 import java.awt.FlowLayout;
@@ -59 +58 @@
 import org.openstreetmap.josm.tools.InputMapUtils;
 import org.openstreetmap.josm.tools.Utils;
 import org.openstreetmap.josm.tools.WindowGeometry;
+import org.openstreetmap.josm.tools.MultiLineFlowLayout;
 
 /**
  * This is a dialog for entering upload options like the parameters for
@@ -165 +165 @@
         tpConfigPanels.setToolTipTextAt(3, tr("Configure advanced settings"));
 
         pnl.add(tpConfigPanels, GBC.eol().fill(GBC.HORIZONTAL));
+
+        pnl.add(buildActionPanel(), GBC.eol().fill(GBC.HORIZONTAL));
         return pnl;
     }
 
@@ -174 +176 @@
      * @return The panel with the OK and CANCEL buttons
      */
     protected JPanel buildActionPanel() {
-        JPanel pnl = new JPanel(new FlowLayout(FlowLayout.CENTER));
+        JPanel pnl = new JPanel(new MultiLineFlowLayout(FlowLayout.CENTER));
         pnl.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
 
         // -- upload button
@@ -201 +203 @@
      */
     protected void build() {
         setTitle(tr("Upload to ''{0}''", OsmApi.getOsmApi().getBaseUrl()));
-        getContentPane().setLayout(new BorderLayout());
-        getContentPane().add(buildContentPanel(), BorderLayout.CENTER);
-        getContentPane().add(buildActionPanel(), BorderLayout.SOUTH);
+        setContentPane(buildContentPanel());
 
         addWindowListener(new WindowEventHandler());
 

new file src/org/openstreetmap/josm/tools/MultiLineFlowLayout.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.tools;
+
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.Insets;
+import java.util.function.Function;
+
+/**
+ * This is an extension of the flow layout that preferes wraping the text instead of increasing the component width when there is not enough
+ * space.
+ * <p>
+ * This allows for a better preffered size computation. It should be used in all places where a flow layout fills the full width of the parent
+ * container.
+ * <p>
+ * This does not support baseline alignment.
+ * @author Michael Zangl
+ * @since xxx
+ */
+public class MultiLineFlowLayout extends FlowLayout {
+    /**
+     * Same as {@link FlowLayout#FlowLayout()}
+     */
+    public MultiLineFlowLayout() {
+        super();
+    }
+
+    /**
+     * Same as {@link FlowLayout#FlowLayout(int, int, int)}
+     * @param align Alignment
+     * @param hgap horizontal gap
+     * @param vgap vertical gap
+     */
+    public MultiLineFlowLayout(int align, int hgap, int vgap) {
+        super(align, hgap, vgap);
+    }
+
+    /**
+     * Same as {@link FlowLayout#FlowLayout(int)}
+     * @param align Alignment
+     */
+    public MultiLineFlowLayout(int align) {
+        super(align);
+    }
+
+    @Override
+    public Dimension preferredLayoutSize(Container target) {
+        return getLayoutSize(target, c -> c.getPreferredSize());
+    }
+
+    @Override
+    public Dimension minimumLayoutSize(Container target) {
+        return getLayoutSize(target, c -> c.getMinimumSize());
+    }
+
+    private Dimension getLayoutSize(Container target, Function<Component, Dimension> baseSize) {
+        synchronized (target.getTreeLock()) {
+            int outerWidth = getWidthOf(target);
+
+            Insets insets = target.getInsets();
+            int containerWidth = outerWidth - insets.left - insets.right - getHgap() * 2;
+
+            int x = 0;
+            int totalHeight = insets.top + insets.bottom + getVgap() * 2;
+            int rowHeight = 0;
+            for (int i = 0; i < target.getComponentCount(); i++) {
+                Component child = target.getComponent(i);
+                if (!child.isVisible()) {
+                    continue;
+                }
+                Dimension size = baseSize.apply(child);
+                if (x != 0) {
+                    x += getHgap();
+                }
+                x += size.getWidth();
+                if (x > containerWidth) {
+                    totalHeight += rowHeight + getVgap();
+                    rowHeight = 0;
+                    x = 0;
+                }
+
+                rowHeight = Math.max(rowHeight, size.height);
+            }
+            totalHeight += rowHeight;
+
+            return new Dimension(outerWidth, totalHeight);
+        }
+    }
+
+    private static int getWidthOf(Container target) {
+        Container current = target;
+        while (current.getWidth() == 0 && current.getParent() != null) {
+            current = current.getParent();
+        }
+        int width = current.getWidth();
+        if (width == 0) {
+            return Integer.MAX_VALUE;
+        } else {
+            return width;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "WrapingFlowLayout [align=" + getAlignment() + "]";
+    }
+
+}

new file test/unit/org/openstreetmap/josm/tools/MultiLineFlowLayoutTest.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.tools;
+
+import static org.junit.Assert.assertEquals;
+
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+
+import javax.swing.BorderFactory;
+import javax.swing.JPanel;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
+/**
+ * Test {@link MultiLineFlowLayout}
+ * @author Michael Zangl
+ * @since xxx
+ */
+public class MultiLineFlowLayoutTest {
+    /**
+     * No special rules.
+     */
+    @Rule
+    @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
+    public JOSMTestRules test = new JOSMTestRules();
+
+    private static final int TEST_WIDHT = 500;
+    private JPanel container;
+
+    /**
+     * Prepare test container.
+     */
+    @Before
+    public void setUp() {
+        JPanel parent = new JPanel();
+        parent.setBounds(0, 0, TEST_WIDHT, 500);
+
+        container = new JPanel(new MultiLineFlowLayout(FlowLayout.CENTER, 0, 0));
+        parent.add(container);
+    }
+
+    /**
+     * Test that one line is layed out correctly
+     */
+    @Test
+    public void testOneLine() {
+        fillOneLine();
+
+        container.invalidate();
+        Dimension preffered = container.getPreferredSize();
+        assertEquals(TEST_WIDHT, preffered.width);
+        assertEquals(100, preffered.height);
+
+        Dimension minimum = container.getMinimumSize();
+        assertEquals(TEST_WIDHT, minimum.width);
+        assertEquals(50, minimum.height);
+    }
+
+    /**
+     * Test that insets are respected
+     */
+    @Test
+    public void testInsets() {
+        fillOneLine();
+
+        container.setBorder(BorderFactory.createEmptyBorder(3, 0, 7, 0));
+        container.invalidate();
+        Dimension preffered = container.getPreferredSize();
+        assertEquals(TEST_WIDHT, preffered.width);
+        assertEquals(110, preffered.height);
+
+        // This should force wraping
+        container.setBorder(BorderFactory.createEmptyBorder(0, 20, 0, 40));
+        container.invalidate();
+        preffered = container.getPreferredSize();
+        assertEquals(TEST_WIDHT, preffered.width);
+        assertEquals(200, preffered.height);
+    }
+
+    /**
+     * Test that gaps are respected
+     */
+    @Test
+    public void testGaps() {
+        fillOneLine();
+
+        container.setLayout(new MultiLineFlowLayout(FlowLayout.LEADING, 20, 10));
+        container.invalidate();
+        Dimension preffered = container.getPreferredSize();
+        assertEquals(TEST_WIDHT, preffered.width);
+        assertEquals(230, preffered.height);
+    }
+
+    /**
+     * Test that it behaves the same as FlowLayout for one line.
+     */
+    @Test
+    public void testSameAsFlowLayout() {
+        fillOneLine();
+        JPanel childx = new JPanel();
+        childx.setPreferredSize(new Dimension(300, 100));
+        childx.setMinimumSize(new Dimension(200, 50));
+        childx.setVisible(false);
+        container.add(childx);
+        container.setBorder(BorderFactory.createEmptyBorder(3, 4, 5, 6));
+
+        container.setLayout(new MultiLineFlowLayout(FlowLayout.LEADING, 2, 1));
+        container.invalidate();
+        Dimension is = container.getPreferredSize();
+
+        container.setLayout(new FlowLayout(FlowLayout.LEADING, 2, 1));
+        container.invalidate();
+        Dimension should = container.getPreferredSize();
+
+        assertEquals(should.height, is.height);
+    }
+
+    private void fillOneLine() {
+        JPanel child1 = new JPanel();
+        child1.setPreferredSize(new Dimension(300, 100));
+        child1.setMinimumSize(new Dimension(200, 50));
+        container.add(child1);
+        JPanel child2 = new JPanel();
+        child2.setPreferredSize(new Dimension(100, 100));
+        child1.setMinimumSize(new Dimension(100, 50));
+        container.add(child2);
+        JPanel child3 = new JPanel();
+        child3.setPreferredSize(new Dimension(50, 100));
+        child1.setMinimumSize(new Dimension(50, 50));
+        container.add(child3);
+    }
+}