Fix align content workflow

DEVSIX-9178

Author: Fedorov Alexandr

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

@@ -27,6 +27,8 @@ public enum AlignContentPropertyValue {
     CENTER,
     FLEX_START,
     FLEX_END,
+    END,
+    START,
     STRETCH,
     SPACE_BETWEEN,
     SPACE_AROUND,

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

@@ -84,6 +84,7 @@ public final class Property {
     public static final int FLEX_SHRINK = 127;
     public static final int FLEX_WRAP = 128;
     public static final int FLEX_DIRECTION = 139;
+    public static final int FLEX_FORCE_START_ON_TOP = 158;
 
     public static final int FLOAT = 99;
     public static final int FLUSH_ON_DRAW = 19;

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

@@ -535,7 +535,7 @@ private void fillSplitOverflowRenderersForPartialResult(AbstractRenderer splitRe
                     // Get rid of vertical alignment for item with partial result. For column direction, justify-content
                     // is applied to the entire line, not the single item, so there is no point in getting rid of it
                     if (!FlexUtil.isColumnDirection(this)) {
-                        setAlignSelfIfNotStretch(childResult.getOverflowRenderer());
+                        startContentOnTopOfNewPage(childResult.getOverflowRenderer(), overflowRenderer);
                     }
                     overflowRenderer.addChildRenderer(childResult.getOverflowRenderer());
                 }
@@ -575,7 +575,7 @@ private void fillSplitOverflowRenderersForPartialResult(AbstractRenderer splitRe
                 if (neighbourLayoutResult.getOverflowRenderer() != null) {
                     if (neighbourLayoutResult.getStatus() == LayoutResult.PARTIAL) {
                         // Get rid of cross alignment for item with partial result
-                        setAlignSelfIfNotStretch(neighbourLayoutResult.getOverflowRenderer());
+                        startContentOnTopOfNewPage(neighbourLayoutResult.getOverflowRenderer(), overflowRenderer);
                     }
                     overflowRenderer.addChildRenderer(neighbourLayoutResult.getOverflowRenderer());
                 } else {
@@ -600,16 +600,17 @@ private void fillSplitOverflowRenderersForPartialResult(AbstractRenderer splitRe
         }
     }
 
-    private void setAlignSelfIfNotStretch(IRenderer overflowRenderer) {
+    private void startContentOnTopOfNewPage(IRenderer overflowChildRenderer, AbstractRenderer overflowRenderer) {
         AlignmentPropertyValue alignItems =
                 (AlignmentPropertyValue) this.<AlignmentPropertyValue>getProperty(
                         Property.ALIGN_ITEMS, AlignmentPropertyValue.STRETCH);
         AlignmentPropertyValue alignSelf =
-                (AlignmentPropertyValue) overflowRenderer.<AlignmentPropertyValue>getProperty(
+                (AlignmentPropertyValue) overflowChildRenderer.<AlignmentPropertyValue>getProperty(
                         Property.ALIGN_SELF, alignItems);
         if (alignSelf != AlignmentPropertyValue.STRETCH) {
-            overflowRenderer.setProperty(Property.ALIGN_SELF, AlignmentPropertyValue.START);
+            overflowChildRenderer.setProperty(Property.ALIGN_SELF, AlignmentPropertyValue.START);
         }
+        overflowRenderer.setProperty(Property.FLEX_FORCE_START_ON_TOP, true);
     }
 
     private void restoreHeightForOverflowRenderer(IRenderer childRenderer, IRenderer overflowRenderer) {
@@ -701,6 +702,10 @@ private IFlexItemMainDirector createMainDirector() {
     private List<IRenderer> retrieveRenderersToOverflow(Rectangle flexContainerBBox) {
         List<IRenderer> renderersToOverflow = new ArrayList<>();
         Rectangle layoutContextRectangle = flexContainerBBox.clone();
+        UnitValue unitWidthValue =  (UnitValue) this.modelElement.<UnitValue>getProperty(Property.WIDTH);
+        if (unitWidthValue != null && unitWidthValue.getValue() < layoutContextRectangle.getWidth()){
+            layoutContextRectangle.setWidth(unitWidthValue.getValue());
+        }
         applyMarginsBordersPaddings(layoutContextRectangle, false);
         if (FlexUtil.isColumnDirection(this) &&
                 FlexUtil.getMainSize(this, layoutContextRectangle) >= layoutContextRectangle.getHeight()) {

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

@@ -88,6 +88,9 @@ public static List<List<FlexItemInfo>> calculateChildrenRectangles(Rectangle fle
         // We need to have crossSize only if its value is definite.
         Float[] crossSizes = getCrossSizes(flexContainerRenderer, layoutBox);
         Float crossSize = crossSizes[0];
+        if (crossSize == null && isColumnDirection(flexContainerRenderer)) {
+            crossSize = layoutBox.getWidth();
+        }
         Float minCrossSize = crossSizes[1];
         Float maxCrossSize = crossSizes[2];
 
@@ -194,27 +197,44 @@ private static void applyAlignContent(List<List<FlexItemCalculationInfo>> lines,
         AlignContentPropertyValue alignContent = (AlignContentPropertyValue) renderer
                 .<AlignContentPropertyValue>getProperty(Property.ALIGN_CONTENT, AlignContentPropertyValue.NORMAL);
 
+        boolean isFirstFlexStart = (boolean) renderer.<Boolean>getProperty(Property.FLEX_FORCE_START_ON_TOP, false);
+
         if (crossSize != null) {
             if (renderer.isWrapReverse()) {
                 Collections.reverse(lines);
             }
 
-            float lineCrossSize = 0;
-
-            for (List<FlexItemCalculationInfo> line : lines) {
-                float maxItemSize = getItemMaxCrossSize(line);
-                lineCrossSize += maxItemSize;
-            }
-
+            float boxSize;
             float freeSpace;
 
             if (isColumnDirection(renderer)) {
-                freeSpace = Math.min(layoutBox.getWidth(), (float) crossSize) - lineCrossSize;
+                boxSize = Math.min(layoutBox.getWidth(), (float) crossSize);
             } else {
-                freeSpace = Math.min(layoutBox.getHeight(), (float) crossSize) - lineCrossSize;
+                boxSize = Math.min(layoutBox.getHeight(), (float) crossSize);
+            }
+
+            float lineCrossSize = 0;
+            int columnsOnPage = 0;
+
+            for (List<FlexItemCalculationInfo> line : lines) {
+                float maxItemSize = getItemMaxCrossSize(line);
+                if (isColumnDirection(renderer)) {
+                    if (lineCrossSize + maxItemSize <= boxSize) {
+                        lineCrossSize += maxItemSize;
+                        columnsOnPage++;
+                    } else {
+                        break;
+                    }
+                } else {
+                    lineCrossSize += maxItemSize;
+                }
             }
 
-            applyAlignContent(lines, alignContent, freeSpace, isColumnDirection(renderer));
+            freeSpace = boxSize - lineCrossSize;
+            applyAlignContent(lines, isColumnDirection(renderer) ? columnsOnPage : lines.size(),
+                    alignContent, freeSpace < 0 ? 0 : freeSpace,
+                    isColumnDirection(renderer),
+                    isFirstFlexStart);
 
             if (renderer.isWrapReverse()) {
                 Collections.reverse(lines);
@@ -223,36 +243,43 @@ private static void applyAlignContent(List<List<FlexItemCalculationInfo>> lines,
     }
 
     private static void applyAlignContent(List<List<FlexItemCalculationInfo>> lines,
-            AlignContentPropertyValue alignContent,
-            float freeSpace, boolean isColumnDirection) {
+            int linesOnPage, AlignContentPropertyValue alignContent,
+            float freeSpace, boolean isColumnDirection, boolean isFirstFlexStart) {
         if (!lines.isEmpty()) {
             switch (alignContent) {
                 case CENTER:
-                    applyCentralAlignment(lines, freeSpace, isColumnDirection);
+                    applyCenterAlignment(lines, freeSpace, isColumnDirection, isFirstFlexStart);
                     break;
                 case FLEX_END:
-                    applyFlexEndAlignment(lines, freeSpace, isColumnDirection);
+                case END:
+                    applyFlexEndAlignment(lines, freeSpace, isColumnDirection, isFirstFlexStart);
                     break;
                 case SPACE_BETWEEN:
-                    applySpaceBetweenAlignment(lines, freeSpace, isColumnDirection);
+                    applySpaceBetweenAlignment(lines, linesOnPage, freeSpace, isColumnDirection);
                     break;
                 case SPACE_AROUND:
-                    applySpaceAroundAlignment(lines, freeSpace, isColumnDirection);
+                    applySpaceAroundAlignment(lines, linesOnPage, freeSpace, isColumnDirection, isFirstFlexStart);
                     break;
                 case SPACE_EVENLY:
-                    applySpaceEvenlyAlignment(lines, freeSpace, isColumnDirection);
+                    applySpaceEvenlyAlignment(lines, linesOnPage, freeSpace, isColumnDirection, isFirstFlexStart);
                     break;
                 case FLEX_START:
+                case START:
+
                 default:
                     break;
-                    // We don't need to do anything in these cases
+                // We don't need to do anything in these cases
             }
         }
     }
 
     private static void applyFlexEndAlignment(List<List<FlexItemCalculationInfo>> lines, float freeSpace,
-            boolean isColumnDirection) {
-        for (FlexItemCalculationInfo item : lines.get(0)) {
+            boolean isColumnDirection, boolean isFirstFlexStart) {
+        if (isFirstFlexStart && lines.size() < 2) {
+            return;
+        }
+        List<FlexItemCalculationInfo> targetLine = isFirstFlexStart && lines.size() > 1 ? lines.get(1) : lines.get(0);
+        for (FlexItemCalculationInfo item : targetLine) {
             if (isColumnDirection) {
                 item.xShift = freeSpace;
             } else {
@@ -261,11 +288,12 @@ private static void applyFlexEndAlignment(List<List<FlexItemCalculationInfo>> li
         }
     }
 
-    private static void applySpaceBetweenAlignment(List<List<FlexItemCalculationInfo>> lines, float freeSpace,
+    private static void applySpaceBetweenAlignment(List<List<FlexItemCalculationInfo>> lines, int linesOnPage,
+            float freeSpace,
             boolean isColumnDirection) {
-        if(lines.size() != 1) {
-            float indentation = freeSpace / (lines.size() - 1);
-            for (int i = 1; i < lines.size(); i++) {
+        if (linesOnPage > 1) {
+            final float indentation = freeSpace / (linesOnPage - 1);
+            for (int i = 1; i < linesOnPage; i++) {
                 for (FlexItemCalculationInfo item : lines.get(i)) {
                     if (isColumnDirection) {
                         item.xShift = indentation;
@@ -277,12 +305,12 @@ private static void applySpaceBetweenAlignment(List<List<FlexItemCalculationInfo
         }
     }
 
-    private static void applySpaceEvenlyAlignment(List<List<FlexItemCalculationInfo>> lines, float freeSpace,
-            boolean isColumnDirection) {
-        float indentation = freeSpace / (lines.size() + 1);
-
-        for (List<FlexItemCalculationInfo> line : lines) {
-            for (FlexItemCalculationInfo item : line) {
+    private static void applySpaceEvenlyAlignment(List<List<FlexItemCalculationInfo>> lines, int linesOnPage,
+            float freeSpace, boolean isColumnDirection, boolean isFirstFlexStart) {
+        final float indentation = freeSpace / (linesOnPage + 1);
+        final int startIndex = isFirstFlexStart ? 1 : 0;
+        for (int i = startIndex; i < linesOnPage; i++) {
+            for (FlexItemCalculationInfo item : lines.get(i)) {
                 if (isColumnDirection) {
                     item.xShift = indentation;
                 } else {
@@ -292,40 +320,36 @@ private static void applySpaceEvenlyAlignment(List<List<FlexItemCalculationInfo>
         }
     }
 
-    private static void applySpaceAroundAlignment(List<List<FlexItemCalculationInfo>> lines, float freeSpace,
-            boolean isColumnDirection) {
-        float indentation = freeSpace / lines.size();
-
-        for (FlexItemCalculationInfo item : lines.get(0)) {
-            if (isColumnDirection) {
-                item.xShift = indentation / 2;
-            } else {
-                item.yShift = indentation / 2;
-            }
-        }
-
-        if(lines.size() != 1) {
-            for (int i = 1; i < lines.size(); i++) {
-                for (FlexItemCalculationInfo item : lines.get(i)) {
-                    if (isColumnDirection) {
-                        item.xShift = indentation;
-                    } else {
-                        item.yShift = indentation;
-                    }
+    private static void applySpaceAroundAlignment(List<List<FlexItemCalculationInfo>> lines, int linesOnPage,
+            float freeSpace,
+            boolean isColumnDirection, boolean isFirstFlexStart) {
+        final int startIndex = isFirstFlexStart ? 1 : 0;
+        final float indentation = freeSpace / linesOnPage;
+        for (int i = startIndex; i < linesOnPage; i++) {
+            float shift = (i == 0) ? (indentation / 2) : indentation;
+            for (FlexItemCalculationInfo item : lines.get(i)) {
+                if (isColumnDirection) {
+                    item.xShift = shift;
+                } else {
+                    item.yShift = shift;
                 }
             }
         }
     }
 
-    private static void applyCentralAlignment(List<List<FlexItemCalculationInfo>> lines, float freeSpace,
-            boolean isColumnDirection) {
-        for (FlexItemCalculationInfo item : lines.get(0)) {
+    private static void applyCenterAlignment(List<List<FlexItemCalculationInfo>> lines, float freeSpace,
+            boolean isColumnDirection, boolean isFirstFlexStart) {
+        if (isFirstFlexStart && lines.size() < 2) {
+            return;
+        }
+        final float indentation = freeSpace / 2;
+        final int targetIndex = isFirstFlexStart && lines.size() > 1 ? 1 : 0;
+        for (FlexItemCalculationInfo item : lines.get(targetIndex)) {
             if (isColumnDirection) {
-                item.xShift = freeSpace / 2;
+                item.xShift = indentation;
             } else {
-                item.yShift = freeSpace / 2;
+                item.yShift = indentation;
             }
-
         }
     }