Support column flex direction

DEVSIX-7619

Author: vitali-pr

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

@@ -108,7 +108,8 @@ public LayoutResult layout(LayoutContext layoutContext) {
         if (rotation != null || isFixedLayout()) {
             parentBBox.moveDown(AbstractRenderer.INF - parentBBox.getHeight()).setHeight(AbstractRenderer.INF);
         }
-        if (rotation != null && !FloatingHelper.isRendererFloating(this, floatPropertyValue)) {
+        if (rotation != null && !FloatingHelper.isRendererFloating(this, floatPropertyValue) &&
+                !(this instanceof FlexContainerRenderer)) {
             blockWidth = RotationUtils.retrieveRotatedLayoutWidth(parentBBox.getWidth(), this);
         }
         boolean includeFloatsInOccupiedArea = BlockFormattingContextUtil.isRendererCreateBfc(this);

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

@@ -0,0 +1,69 @@
+/*
+    This file is part of the iText (R) project.
+    Copyright (c) 1998-2023 Apryse Group NV
+    Authors: Apryse Software.
+
+    This program is offered under a commercial and under the AGPL license.
+    For commercial licensing, contact us at https://itextpdf.com/sales.  For AGPL licensing, see below.
+
+    AGPL licensing:
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.itextpdf.layout.renderer;
+
+import com.itextpdf.layout.properties.JustifyContent;
+import com.itextpdf.layout.renderer.FlexUtil.FlexItemCalculationInfo;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+class BottomToTopFlexItemMainDirector extends FlexColumnItemMainDirector {
+    BottomToTopFlexItemMainDirector() {
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public <T> void applyDirectionForLine(List<T> renderers) {
+        Collections.reverse(renderers);
+    }
+
+    @Override
+    public void applyJustifyContent(List<FlexItemCalculationInfo> line, JustifyContent justifyContent,
+            float freeSpace) {
+        switch (justifyContent) {
+            case NORMAL:
+            case END:
+            case SELF_END:
+            case STRETCH:
+            case SELF_START:
+            case START:
+            case FLEX_START:
+                line.get(line.size() - 1).yShift = freeSpace;
+                break;
+            case CENTER:
+                line.get(line.size() - 1).yShift = freeSpace / 2;
+                break;
+            case FLEX_END:
+
+            case LEFT:
+
+            case RIGHT:
+            default:
+                // We don't need to do anything in these cases
+        }
+    }
+}

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

@@ -0,0 +1,52 @@
+/*
+    This file is part of the iText (R) project.
+    Copyright (c) 1998-2023 Apryse Group NV
+    Authors: Apryse Software.
+
+    This program is offered under a commercial and under the AGPL license.
+    For commercial licensing, contact us at https://itextpdf.com/sales.  For AGPL licensing, see below.
+
+    AGPL licensing:
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.itextpdf.layout.renderer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+abstract class FlexColumnItemMainDirector implements IFlexItemMainDirector {
+    FlexColumnItemMainDirector() {
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public List<IRenderer> applyDirection(List<List<FlexItemInfo>> lines) {
+        List<IRenderer> renderers = new ArrayList<>();
+        for (List<FlexItemInfo> line : lines) {
+            applyDirectionForLine(line);
+            for (FlexItemInfo itemInfo : line) {
+                renderers.add(itemInfo.getRenderer());
+            }
+        }
+        return renderers;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    abstract public <T> void applyDirectionForLine(List<T> renderers);
+}

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

@@ -212,14 +212,15 @@ AbstractRenderer[] createSplitAndOverflowRenderers(int childPos, int layoutStatu
             metChildRenderer = metChildRenderer || isSplitLine;
 
             // If the renderer to split is in the current line
-            if (isSplitLine && !forcedPlacement && layoutStatus == LayoutResult.PARTIAL) {
+            if (isSplitLine && !forcedPlacement && layoutStatus == LayoutResult.PARTIAL &&
+                    !FlexUtil.isColumnDirection(this)) {
                 // It has sense to call it also for LayoutResult.NOTHING. And then try to layout remaining renderers
                 // in line inside fillSplitOverflowRenderersForPartialResult to see if some of them can be left or
                 // partially left on the first page (in split renderer). But it's not that easy.
                 // So currently, if the 1st not fully layouted renderer is layouted with LayoutResult.NOTHING,
                 // the whole line is moved to the next page (overflow renderer).
-                fillSplitOverflowRenderersForPartialResult(splitRenderer, overflowRenderer, line, childRenderer,
-                        childResult);
+                    fillSplitOverflowRenderersForPartialResult(splitRenderer, overflowRenderer, line, childRenderer,
+                            childResult);
                 getFlexItemMainDirector().applyDirectionForLine(overflowRenderer.getChildRenderers());
             } else {
                 List<IRenderer> overflowRendererChildren = new ArrayList<IRenderer>();
@@ -339,6 +340,15 @@ MarginsCollapseInfo startChildMarginsHandling(IRenderer childRenderer,
 
     @Override
     void decreaseLayoutBoxAfterChildPlacement(Rectangle layoutBox, LayoutResult result, IRenderer childRenderer) {
+        if (FlexUtil.isColumnDirection(this)) {
+            decreaseLayoutBoxAfterChildPlacementColumnLayout(layoutBox, childRenderer);
+        } else {
+            decreaseLayoutBoxAfterChildPlacementRowLayout(layoutBox,result, childRenderer);
+        }
+    }
+
+    void decreaseLayoutBoxAfterChildPlacementRowLayout(Rectangle layoutBox, LayoutResult result,
+                                                       IRenderer childRenderer) {
         layoutBox.decreaseWidth(result.getOccupiedArea().getBBox().getRight() - layoutBox.getLeft());
         layoutBox.setX(result.getOccupiedArea().getBBox().getRight());
 
@@ -362,6 +372,28 @@ void decreaseLayoutBoxAfterChildPlacement(Rectangle layoutBox, LayoutResult resu
         }
     }
 
+    void decreaseLayoutBoxAfterChildPlacementColumnLayout(Rectangle layoutBox, IRenderer childRenderer) {
+        FlexItemInfo childFlexItemInfo = findFlexItemInfo((AbstractRenderer) childRenderer);
+        layoutBox.decreaseHeight(childFlexItemInfo.getRenderer().getOccupiedArea().getBBox().getHeight() +
+                childFlexItemInfo.getRectangle().getY());
+
+        List<FlexItemInfo> line = findLine(childRenderer);
+        final boolean isLastInLine = childRenderer.equals(line.get(line.size() - 1).getRenderer());
+        // If it was the last renderer in line we have to go to the next line (row)
+        if (isLastInLine) {
+            float maxWidth = 0;
+            float commonHeight = 0;
+            for (FlexItemInfo item : line) {
+                maxWidth = Math.max(maxWidth, item.getRenderer().getOccupiedArea().getBBox().getWidth()
+                        + item.getRectangle().getX());
+                commonHeight += item.getRectangle().getY() + item.getRenderer().getOccupiedArea().getBBox().getHeight();
+            }
+            layoutBox.increaseHeight(commonHeight);
+            layoutBox.decreaseWidth(maxWidth);
+            layoutBox.moveRight(maxWidth);
+        }
+    }
+
     @Override
     Rectangle recalculateLayoutBoxBeforeChildLayout(Rectangle layoutBox,
                                                     IRenderer childRenderer, Rectangle initialLayoutBox) {
@@ -459,8 +491,8 @@ private static void addSimulateDiv(AbstractRenderer overflowRenderer, float widt
     }
 
     private void fillSplitOverflowRenderersForPartialResult(AbstractRenderer splitRenderer,
-            AbstractRenderer overflowRenderer, List<FlexItemInfo> line, IRenderer childRenderer,
-            LayoutResult childResult) {
+                    AbstractRenderer overflowRenderer, List<FlexItemInfo> line, IRenderer childRenderer,
+                    LayoutResult childResult) {
         float occupiedSpace = 0;
         float maxHeightInLine = 0;
         boolean metChildRendererInLine = false;
@@ -562,8 +594,13 @@ private void findMinMaxWidth(float initialMinWidth, float initialMaxWidth, Abstr
             } else {
                 childMinMaxWidth = MinMaxWidthUtils.countDefaultMinMaxWidth(childRenderer);
             }
-            maxWidth += childMinMaxWidth.getMaxWidth();
-            minWidth += childMinMaxWidth.getMinWidth();
+            if (FlexUtil.isColumnDirection(this)) {
+                maxWidth = Math.max(maxWidth, childMinMaxWidth.getMaxWidth());
+                minWidth = Math.max(minWidth, childMinMaxWidth.getMinWidth());
+            } else {
+                maxWidth += childMinMaxWidth.getMaxWidth();
+                minWidth += childMinMaxWidth.getMinWidth();
+            }
         }
         minMaxWidthHandler.updateMaxChildWidth(maxWidth);
         minMaxWidthHandler.updateMinChildWidth(minWidth);
@@ -579,10 +616,16 @@ private boolean isRowReverse() {
                 this.<FlexDirectionPropertyValue>getProperty(Property.FLEX_DIRECTION, null);
     }
 
+    private boolean isColumnReverse() {
+        return FlexDirectionPropertyValue.COLUMN_REVERSE ==
+                this.<FlexDirectionPropertyValue>getProperty(Property.FLEX_DIRECTION, null);
+    }
+
     private IFlexItemMainDirector createMainDirector() {
-        if (FlexDirectionPropertyValue.COLUMN ==
-                this.<FlexDirectionPropertyValue>getProperty(Property.FLEX_DIRECTION)) {
-            return new TopToBottomFlexItemMainDirector();
+        if (FlexUtil.isColumnDirection(this)) {
+            return isColumnReverse()
+                    ? (IFlexItemMainDirector) new BottomToTopFlexItemMainDirector() :
+                    new TopToBottomFlexItemMainDirector();
         } else {
             final boolean isRtlDirection = BaseDirection.RIGHT_TO_LEFT ==
                     this.<BaseDirection>getProperty(Property.BASE_DIRECTION, null);