Add split/overflow renderer support for MulticolRenderer

DEVSIX-7584

Author: dmitry.radchuk

layout/src/main/java/com/itextpdf/layout/minmaxwidth/MinMaxWidthUtils.java

@@ -49,7 +49,7 @@ public static float getInfWidth() {
         return max;
     }
 
-    private static float getInfHeight() { return 1e6f; }
+    public static float getInfHeight() { return 1e6f; }
 
     public static boolean isEqual(double x, double y) {
         return Math.abs(x - y) < eps;

layout/src/main/java/com/itextpdf/layout/properties/ContinuousContainer.java

@@ -80,7 +80,7 @@ public static void clearPropertiesFromOverFlowRenderer(IPropertyContainer overFl
      *
      * @param blockRenderer the renderer that is used to set up continuous container.
      */
-    public static void setupContinuousContainerIfNeeded(BlockRenderer blockRenderer) {
+    public static void setupContinuousContainerIfNeeded(AbstractRenderer blockRenderer) {
         if (Boolean.TRUE.equals(blockRenderer.<Boolean>getProperty(Property.TREAT_AS_CONTINUOUS_CONTAINER))) {
             if (!blockRenderer.hasProperty(Property.TREAT_AS_CONTINUOUS_CONTAINER_RESULT)) {
                 final ContinuousContainer continuousContainer = new ContinuousContainer(blockRenderer);

layout/src/main/java/com/itextpdf/layout/renderer/MulticolRenderer.java

@@ -28,11 +28,13 @@ This file is part of the iText (R) project.
 import com.itextpdf.layout.layout.LayoutArea;
 import com.itextpdf.layout.layout.LayoutContext;
 import com.itextpdf.layout.layout.LayoutResult;
+import com.itextpdf.layout.properties.ContinuousContainer;
 import com.itextpdf.layout.properties.Property;
 import com.itextpdf.layout.properties.UnitValue;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.BiFunction;
 
 /**
  * Represents a renderer for columns.
@@ -43,6 +45,7 @@ public class MulticolRenderer extends AbstractRenderer {
     private static final float ZERO_DELTA = 0.0001F;
 
     private BlockRenderer elementRenderer;
+    private final HeightEnhancer heightCalculator = new HeightEnhancer();
     private int columnCount;
     private float columnWidth;
     private float approximateHeight;
@@ -79,29 +82,73 @@ public LayoutResult layout(LayoutContext layoutContext) {
         LayoutResult prelayoutResult = elementRenderer.layout(
                 new LayoutContext(new LayoutArea(1, new Rectangle(columnWidth, INF))));
         if (prelayoutResult.getStatus() != LayoutResult.FULL) {
-            return new LayoutResult(LayoutResult.NOTHING, null, null, this, elementRenderer);
+            return new LayoutResult(LayoutResult.NOTHING, null, null, this, prelayoutResult.getCauseOfNothing());
         }
 
         approximateHeight = prelayoutResult.getOccupiedArea().getBBox().getHeight() / columnCount;
 
-        List<IRenderer> container = balanceContentAndLayoutColumns(layoutContext, actualBBox);
+        MulticolLayoutResult layoutResult = balanceContentAndLayoutColumns(layoutContext, actualBBox);
 
-        this.occupiedArea = calculateContainerOccupiedArea(layoutContext);
-        this.setChildRenderers(container);
-        LayoutResult result = new LayoutResult(LayoutResult.FULL, this.occupiedArea, this, null);
-
-        // process some properties (keepTogether, margin collapsing), area breaks, adding height
-        // Check what we do at the end of BlockRenderer
-
-        return result;
+        if (layoutResult.getSplitRenderers().isEmpty()) {
+            return new LayoutResult(LayoutResult.NOTHING, null, null, this, layoutResult.getCauseOfNothing());
+        } else if (layoutResult.getOverflowRenderer() == null) {
+            this.setChildRenderers(layoutResult.getSplitRenderers());
+            this.occupiedArea = calculateContainerOccupiedArea(layoutContext, true);
+            return new LayoutResult(LayoutResult.FULL, this.occupiedArea, this, null);
+        } else {
+            this.occupiedArea = calculateContainerOccupiedArea(layoutContext, false);
+            return new LayoutResult(LayoutResult.PARTIAL, this.occupiedArea,
+                    createSplitRenderer(layoutResult.getSplitRenderers()),
+                    createOverflowRenderer(layoutResult.getOverflowRenderer()));
+        }
     }
 
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public IRenderer getNextRenderer() {
         logWarningIfGetNextRendererNotOverridden(MulticolRenderer.class, this.getClass());
         return new MulticolRenderer((MulticolContainer) modelElement);
     }
 
+
+    /**
+     * Creates a split renderer.
+     *
+     * @param children children of the split renderer
+     *
+     * @return a new {@link AbstractRenderer} instance
+     */
+    protected AbstractRenderer createSplitRenderer(List<IRenderer> children) {
+        AbstractRenderer splitRenderer = (AbstractRenderer) getNextRenderer();
+        splitRenderer.parent = parent;
+        splitRenderer.modelElement = modelElement;
+        splitRenderer.occupiedArea = occupiedArea;
+        splitRenderer.isLastRendererForModelElement = false;
+        splitRenderer.setChildRenderers(children);
+        splitRenderer.addAllProperties(getOwnProperties());
+        ContinuousContainer.setupContinuousContainerIfNeeded(splitRenderer);
+        return splitRenderer;
+    }
+
+    /**
+     * Creates an overflow renderer.
+     *
+     * @return a new {@link AbstractRenderer} instance
+     */
+    protected AbstractRenderer createOverflowRenderer(IRenderer overflowedContentRenderer) {
+        AbstractRenderer overflowRenderer = (AbstractRenderer) getNextRenderer();
+        overflowRenderer.parent = parent;
+        overflowRenderer.modelElement = modelElement;
+        overflowRenderer.addAllProperties(getOwnProperties());
+        List<IRenderer> children = new ArrayList<>(1);
+        children.add(overflowedContentRenderer);
+        overflowRenderer.setChildRenderers(children);
+        ContinuousContainer.clearPropertiesFromOverFlowRenderer(overflowRenderer);
+        return overflowRenderer;
+    }
+
     private float safelyRetrieveFloatProperty(int property) {
         final Object value = this.<Object>getProperty(property);
         if (value instanceof UnitValue) {
@@ -113,42 +160,46 @@ private float safelyRetrieveFloatProperty(int property) {
         return 0F;
     }
 
-    private List<IRenderer> balanceContentAndLayoutColumns(LayoutContext prelayoutContext, Rectangle actualBBox) {
-        Float additionalHeightPerIteration = null;
-        final List<IRenderer> container = new ArrayList<>();
-        int counter = MAX_RELAYOUT_COUNT;
+    private MulticolLayoutResult balanceContentAndLayoutColumns(LayoutContext prelayoutContext, Rectangle actualBbox) {
+        float additionalHeightPerIteration;
+        MulticolLayoutResult result = new MulticolLayoutResult();
+        int counter = MAX_RELAYOUT_COUNT + 1;
+        float maxHeight = actualBbox.getHeight();
+        boolean isLastLayout = false;
         while (counter-- > 0) {
-            final IRenderer overflowRenderer = layoutColumnsAndReturnOverflowRenderer(prelayoutContext, container,
-                    actualBBox);
-            if (overflowRenderer == null) {
-                return container;
+            if (approximateHeight > maxHeight) {
+                isLastLayout = true;
+                approximateHeight = maxHeight;
             }
-            if (additionalHeightPerIteration == null) {
-                LayoutResult overflowResult = overflowRenderer.layout(
-                        new LayoutContext(new LayoutArea(1, new Rectangle(columnWidth, INF))));
-                additionalHeightPerIteration =
-                        overflowResult.getOccupiedArea().getBBox().getHeight() / MAX_RELAYOUT_COUNT;
+            result = layoutColumnsAndReturnOverflowRenderer(prelayoutContext, actualBbox);
+            if (result.getOverflowRenderer() == null || isLastLayout) {
+                return result;
             }
-            if (Math.abs(additionalHeightPerIteration.floatValue()) <= ZERO_DELTA) {
-                return container;
+            additionalHeightPerIteration = heightCalculator.apply(this, result).floatValue();
+            if (Math.abs(additionalHeightPerIteration) <= ZERO_DELTA) {
+                return result;
             }
-            approximateHeight += additionalHeightPerIteration.floatValue();
+            approximateHeight += additionalHeightPerIteration;
         }
-        return container;
+        return result;
     }
 
-
-    private LayoutArea calculateContainerOccupiedArea(LayoutContext layoutContext) {
+    private LayoutArea calculateContainerOccupiedArea(LayoutContext layoutContext, boolean isFull) {
         LayoutArea area = layoutContext.getArea().clone();
         float totalHeight = approximateHeight;
 
-        totalHeight += safelyRetrieveFloatProperty(Property.PADDING_BOTTOM);
+        if (isFull) {
+            totalHeight += safelyRetrieveFloatProperty(Property.PADDING_BOTTOM);
+            totalHeight += safelyRetrieveFloatProperty(Property.MARGIN_BOTTOM);
+            totalHeight += safelyRetrieveFloatProperty(Property.BORDER_BOTTOM);
+        }
         totalHeight += safelyRetrieveFloatProperty(Property.PADDING_TOP);
-        totalHeight += safelyRetrieveFloatProperty(Property.MARGIN_BOTTOM);
+
         totalHeight += safelyRetrieveFloatProperty(Property.MARGIN_TOP);
-        totalHeight += safelyRetrieveFloatProperty(Property.BORDER_BOTTOM);
+
         totalHeight += safelyRetrieveFloatProperty(Property.BORDER_TOP);
-        final float TOP_AND_BOTTOM = 2;
+        final float TOP_AND_BOTTOM = isFull ? 2 : 1;
+
         totalHeight += safelyRetrieveFloatProperty(Property.BORDER) * TOP_AND_BOTTOM;
 
         area.getBBox().setHeight(totalHeight);
@@ -164,31 +215,94 @@ private BlockRenderer getElementsRenderer() {
         return (BlockRenderer) getChildRenderers().get(0);
     }
 
-    private IRenderer layoutColumnsAndReturnOverflowRenderer(LayoutContext preLayoutContext,
-            List<IRenderer> container, Rectangle actualBBox) {
-        container.clear();
-
-        final Rectangle initialBBox = actualBBox.clone();
+    private MulticolLayoutResult layoutColumnsAndReturnOverflowRenderer(LayoutContext preLayoutContext, Rectangle actualBBox) {
+        MulticolLayoutResult result = new MulticolLayoutResult();
         IRenderer renderer = elementRenderer;
         for (int i = 0; i < columnCount && renderer != null; i++) {
             LayoutArea tempArea = preLayoutContext.getArea().clone();
             tempArea.getBBox().setWidth(columnWidth);
             tempArea.getBBox().setHeight(approximateHeight);
-            tempArea.getBBox().setX(initialBBox.getX() + columnWidth * i);
-            tempArea.getBBox().setY(initialBBox.getY() + initialBBox.getHeight() - tempArea.getBBox()
+            tempArea.getBBox().setX(actualBBox.getX() + columnWidth * i);
+            tempArea.getBBox().setY(actualBBox.getY() + actualBBox.getHeight() - tempArea.getBBox()
                     .getHeight());
 
             LayoutContext columnContext = new LayoutContext(tempArea, preLayoutContext.getMarginsCollapseInfo(),
                     preLayoutContext.getFloatRendererAreas(), preLayoutContext.isClippedHeight());
             renderer.setProperty(Property.COLLAPSING_MARGINS, false);
             LayoutResult tempResultColumn = renderer.layout(columnContext);
+            if (tempResultColumn.getStatus() == LayoutResult.NOTHING) {
+                result.setOverflowRenderer((AbstractRenderer) renderer);
+                result.setCauseOfNothing(tempResultColumn.getCauseOfNothing());
+                return result;
+            }
             if (tempResultColumn.getSplitRenderer() == null) {
-                container.add(renderer);
+                result.getSplitRenderers().add(renderer);
             } else {
-                container.add(tempResultColumn.getSplitRenderer());
+                result.getSplitRenderers().add(tempResultColumn.getSplitRenderer());
             }
             renderer = tempResultColumn.getOverflowRenderer();
         }
-        return renderer;
+        result.setOverflowRenderer((AbstractRenderer)renderer);
+        return result;
+    }
+
+
+    /**
+     * Represents result of one iteration of MulticolRenderer layouting
+     * It contains split renderers which were lauded on a given height and overflow renderer
+     * for which height should be increased, so it can be lauded.
+     */
+    private static class MulticolLayoutResult {
+        private List<IRenderer> splitRenderers = new ArrayList<>();
+        private AbstractRenderer overflowRenderer;
+        private IRenderer causeOfNothing;
+
+        public List<IRenderer> getSplitRenderers() {
+            return splitRenderers;
+        }
+
+        public AbstractRenderer getOverflowRenderer() {
+            return overflowRenderer;
+        }
+
+        public IRenderer getCauseOfNothing() {
+            return causeOfNothing;
+        }
+
+        public void setOverflowRenderer(AbstractRenderer overflowRenderer) {
+            this.overflowRenderer = overflowRenderer;
+        }
+
+        public void setCauseOfNothing(IRenderer causeOfNothing) {
+            this.causeOfNothing = causeOfNothing;
+        }
+    }
+
+    /**
+     * Class which used for additional height calculation
+     */
+    private static class HeightEnhancer {
+        private Float height = null;
+
+        /**
+         * Calculate height, by which current height of given {@code MulticolRenderer} should be increased so
+         * {@code MulticolLayoutResult#getOverflowRenderer} could be lauded
+         *
+         * @param renderer multicol renderer for which height needs to be increased
+         * @param result result of one iteration of {@code MulticolRenderer} layouting
+         * @return height by which current height of given multicol renderer should be increased
+         */
+        public Float apply(MulticolRenderer renderer, MulticolLayoutResult result) {
+            if (height != null) {
+                return height;
+            }
+            if (result.getOverflowRenderer() == null) {
+                return 0.0f;
+            }
+            LayoutResult overflowResult = result.getOverflowRenderer().layout(
+                    new LayoutContext(new LayoutArea(1, new Rectangle(renderer.columnWidth, INF))));
+            height = overflowResult.getOccupiedArea().getBBox().getHeight() / MAX_RELAYOUT_COUNT;
+            return height;
+        }
     }
 }