Implement float elements splitting

pavel-morozov-duallab · pavel-morozov-duallab · commit 90f44ffeb03c · 2017-06-30T14:49:10.000+03:00
DEVSIX-1267
diff --git a/layout/src/main/java/com/itextpdf/layout/margincollapse/MarginsCollapseHandler.java b/layout/src/main/java/com/itextpdf/layout/margincollapse/MarginsCollapseHandler.java
@@ -240,6 +240,9 @@ public void endMarginsCollapse(Rectangle layoutBox) {
         boolean lastChildMarginJoinedToParent = prevChildMarginInfo != null && prevChildMarginInfo.isIgnoreOwnMarginBottom() && !lastKidCollapsedAfterHasClearanceApplied;
         if (lastChildMarginJoinedToParent) {
             ownCollapseAfter = prevChildMarginInfo.getOwnCollapseAfter();
+            if (ownCollapseAfter == null) {
+                ownCollapseAfter = new MarginsCollapse();
+            }
         } else {
             ownCollapseAfter = new MarginsCollapse();
         }
diff --git a/layout/src/main/java/com/itextpdf/layout/renderer/AbstractRenderer.java b/layout/src/main/java/com/itextpdf/layout/renderer/AbstractRenderer.java
@@ -538,23 +538,17 @@ public void drawBackground(DrawContext drawContext) {
      * @param drawContext the context (canvas, document, etc) of this drawing operation.
      */
     public void drawChildren(DrawContext drawContext) {
-        List<IRenderer> waitingRenderers = new ArrayList<>();
         for (IRenderer child : childRenderers) {
             if (FloatingHelper.isRendererFloating(child)) {
                 RootRenderer rootRenderer = getRootRenderer();
                 if (rootRenderer != null) {
                     rootRenderer.waitingDrawingElements.add(child);
                     child.setProperty(Property.FLOAT, null);
-                } else {
-                    waitingRenderers.add(child);
                 }
             } else {
                 child.draw(drawContext);
             }
         }
-        for (IRenderer waitingRenderer : waitingRenderers) {
-            waitingRenderer.draw(drawContext);
-        }
     }
 
     /**
diff --git a/layout/src/main/java/com/itextpdf/layout/renderer/BlockRenderer.java b/layout/src/main/java/com/itextpdf/layout/renderer/BlockRenderer.java
diff --git a/layout/src/main/java/com/itextpdf/layout/renderer/ImageRenderer.java b/layout/src/main/java/com/itextpdf/layout/renderer/ImageRenderer.java
@@ -122,6 +122,7 @@ public LayoutResult layout(LayoutContext layoutContext) {
         applyBorderBox(layoutBox, borders, false);
 
         if (isAbsolutePosition()) {
+            // TODO applying it after floats processing here and everywhere. is it correct?
             applyAbsolutePosition(layoutBox);
         }
 
diff --git a/layout/src/main/java/com/itextpdf/layout/renderer/ParagraphRenderer.java b/layout/src/main/java/com/itextpdf/layout/renderer/ParagraphRenderer.java
@@ -50,7 +50,10 @@ This file is part of the iText (R) project.
 import com.itextpdf.layout.layout.*;
 import com.itextpdf.layout.margincollapse.MarginsCollapseHandler;
 import com.itextpdf.layout.minmaxwidth.MinMaxWidth;
-import com.itextpdf.layout.property.*;
+import com.itextpdf.layout.property.FloatPropertyValue;
+import com.itextpdf.layout.property.Leading;
+import com.itextpdf.layout.property.Property;
+import com.itextpdf.layout.property.TextAlignment;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -181,6 +184,38 @@ public LayoutResult layout(LayoutContext layoutContext) {
             float childBBoxWidth = layoutBox.getWidth() - lineIndent;
             Rectangle childLayoutBox = new Rectangle(layoutBox.getX() + lineIndent, layoutBox.getY(), childBBoxWidth, layoutBox.getHeight());
 
+//            if (childAffectedByFloat) {
+//                currentRenderer.layout(new LayoutContext(new LayoutArea(pageNumber, childLayoutBox), layoutContext.getMarginsCollapseInfo(), floatRendererAreas));
+//                float bottom = currentRenderer.getOccupiedArea().getBBox().getBottom();
+//                float top = currentRenderer.getOccupiedArea().getBBox().getTop();
+//                float left = currentRenderer.getOccupiedArea().getBBox().getLeft();
+//                float right = currentRenderer.getOccupiedArea().getBBox().getRight();
+//                boolean childLayoutBoxWasAdjusted;
+//                float rightBorder = childLayoutBox.getRight();
+//                float curRendWidth = currentRenderer.getOccupiedAreaBBox().getWidth();
+//                do {
+//                    childLayoutBoxWasAdjusted = false;
+//                    for (Rectangle floatRendereArea : floatRendererAreas) {
+//                        if ((bottom > floatRendereArea.getBottom() && bottom < floatRendereArea.getTop()) || (top > floatRendereArea.getBottom() && top < floatRendereArea.getTop())) {
+//                            if ((left >= floatRendereArea.getLeft() && left < floatRendereArea.getRight()) ||
+//                                    (right > floatRendereArea.getLeft() && right < floatRendereArea.getRight()) ||
+//                                    (left > floatRendereArea.getLeft() && right < floatRendereArea.getRight())) {
+//                                childLayoutBox.setX(floatRendereArea.getRight());
+//
+//
+//                                if (childLayoutBox.getLeft() + curRendWidth > rightBorder) {
+//                                    childLayoutBox.setWidth(rightBorder - childLayoutBox.getLeft());
+//                                } else {
+//                                    childLayoutBox.setWidth(curRendWidth);
+//                                }
+//                                left = childLayoutBox.getLeft();
+//                                right = childLayoutBox.getRight();
+//                                childLayoutBoxWasAdjusted = true;
+//                            }
+//                        }
+//                    }
+//                } while(childLayoutBoxWasAdjusted);
+//            }
             LineLayoutResult result = ((LineRenderer) currentRenderer.setParent(this)).layout(new LayoutContext(
                     new LayoutArea(pageNumber, childLayoutBox), null,
                     floatRendererAreas));
diff --git a/layout/src/main/java/com/itextpdf/layout/renderer/RootRenderer.java b/layout/src/main/java/com/itextpdf/layout/renderer/RootRenderer.java
@@ -51,6 +51,7 @@ This file is part of the iText (R) project.
 import com.itextpdf.layout.layout.LayoutResult;
 import com.itextpdf.layout.margincollapse.MarginsCollapseHandler;
 import com.itextpdf.layout.margincollapse.MarginsCollapseInfo;
+import com.itextpdf.layout.property.FloatPropertyValue;
 import com.itextpdf.layout.property.Property;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -70,6 +71,7 @@ public abstract class RootRenderer extends AbstractRenderer {
     private MarginsCollapseHandler marginsCollapseHandler;
     private LayoutArea initialCurrentArea;
     private List<Rectangle> floatRendererAreas;
+    private List<IRenderer> waitingRenderers = new ArrayList<>();
 
     public void addChild(IRenderer renderer) {
         // Some positioned renderers might have been fetched from non-positioned child and added to this renderer,
@@ -78,6 +80,10 @@ public void addChild(IRenderer renderer) {
         int numberOfPositionedChildRenderers = positionedRenderers.size();
         super.addChild(renderer);
         List<IRenderer> addedRenderers = new ArrayList<>(1);
+        if (currentArea != null && currentArea.getPageNumber() > 1) {
+            addedRenderers.addAll(waitingRenderers);
+            waitingRenderers.clear();
+        }
         List<IRenderer> addedPositionedRenderers = new ArrayList<>(1);
         while (childRenderers.size() > numberOfChildRenderers) {
             addedRenderers.add(childRenderers.get(numberOfChildRenderers));
@@ -97,7 +103,7 @@ public void addChild(IRenderer renderer) {
         }
 
         // Static layout
-        for (int i = 0; currentArea != null && i < addedRenderers.size(); i++) {
+        for (int i = 0, l = addedRenderers.size(); currentArea != null && i < l; i++) {
             renderer = addedRenderers.get(i);
 
             processWaitingKeepWithNextElement(renderer);
@@ -111,11 +117,15 @@ public void addChild(IRenderer renderer) {
             if (marginsCollapsingEnabled && currentArea != null && renderer != null) {
                 childMarginsInfo = marginsCollapseHandler.startChildMarginsHandling(renderer, currentArea.getBBox());
             }
+            FloatPropertyValue floatPropertyValue = renderer.getProperty(Property.FLOAT);
+            boolean rendererIsFloat = floatPropertyValue != null && !floatPropertyValue.equals(FloatPropertyValue.NONE);
             while (currentArea != null && renderer != null && (result = renderer.setParent(this).layout(
                     new LayoutContext(currentArea.clone(), childMarginsInfo, floatRendererAreas)))
                     .getStatus() != LayoutResult.FULL) {
                 if (result.getStatus() == LayoutResult.PARTIAL) {
-                    if (result.getOverflowRenderer() instanceof ImageRenderer) {
+                    if (rendererIsFloat) {
+                        waitingRenderers.add(result.getOverflowRenderer());
+                    } else if (result.getOverflowRenderer() instanceof ImageRenderer) {
                         ((ImageRenderer) result.getOverflowRenderer()).autoScale(currentArea);
                     } else {
                         processRenderer(result.getSplitRenderer(), resultRenderers);
@@ -175,7 +185,18 @@ public void addChild(IRenderer renderer) {
                         }
                     }
                 }
-                renderer = result.getOverflowRenderer();
+                if (rendererIsFloat && result.getStatus() != LayoutResult.NOTHING) {
+                    renderer = null;
+                    continue;
+                }
+                if (!waitingRenderers.isEmpty()) {
+                    renderer = waitingRenderers.remove(0);
+                    addedRenderers.addAll(waitingRenderers);
+                    addedRenderers.add(result.getOverflowRenderer());
+                    l+= waitingRenderers.size() + 1;
+                } else {
+                    renderer = result.getOverflowRenderer();
+                }
 
                 if (marginsCollapsingEnabled) {
                     marginsCollapseHandler.endChildMarginsHandling(currentArea.getBBox());
diff --git a/layout/src/main/java/com/itextpdf/layout/renderer/TableRenderer.java b/layout/src/main/java/com/itextpdf/layout/renderer/TableRenderer.java
@@ -336,8 +336,8 @@ public LayoutResult layout(LayoutContext layoutContext) {
         // if this is the last renderer, we will use that information to enlarge rows proportionally
         List<Boolean> rowsHasCellWithSetHeight = new ArrayList<>();
 
+        List<Rectangle> childFloatRendererAreas = new ArrayList<>();
         for (row = 0; row < rows.size(); row++) {
-            List<Rectangle> childFloatRendererAreas = new ArrayList<>();
             // if forced placement was earlier set, this means the element did not fit into the area, and in this case
             // we only want to place the first row in a forced way, not the next ones, otherwise they will be invisible
             if (row == 1 && Boolean.TRUE.equals(this.<Boolean>getProperty(Property.FORCED_PLACEMENT))) {
diff --git a/layout/src/test/java/com/itextpdf/layout/FloatTest.java b/layout/src/test/java/com/itextpdf/layout/FloatTest.java
@@ -224,6 +224,10 @@ public void floatDivTest02() throws IOException, InterruptedException {
     @Test
     @Ignore("block level floating elements page-overflow and splitting not supported yet")
     public void floatDivTest03() throws IOException, InterruptedException {
+        //
+        // TODO probably we shouldn't review forced placement applying on floated elements
+        // May be check if there are any floated elements already on page
+        //
         String cmpFileName = sourceFolder + "cmp_floatDivTest03.pdf";
         String outFile = destinationFolder + "floatDivTest03.pdf";
 
diff --git a/layout/src/test/resources/com/itextpdf/layout/FloatTest/cmp_floatFixedHeightContentNotFit.pdf b/layout/src/test/resources/com/itextpdf/layout/FloatTest/cmp_floatFixedHeightContentNotFit.pdf

Original file line number	Diff line number	Diff line change
`@@ -538,23 +538,17 @@ public void drawBackground(DrawContext drawContext) {`
`538`	`538`	`* @param drawContext the context (canvas, document, etc) of this drawing operation.`
`539`	`539`	`*/`
`540`	`540`	`public void drawChildren(DrawContext drawContext) {`
`541`		`- List<IRenderer> waitingRenderers = new ArrayList<>();`
`542`	`541`	`for (IRenderer child : childRenderers) {`
`543`	`542`	`if (FloatingHelper.isRendererFloating(child)) {`
`544`	`543`	`RootRenderer rootRenderer = getRootRenderer();`
`545`	`544`	`if (rootRenderer != null) {`
`546`	`545`	`rootRenderer.waitingDrawingElements.add(child);`
`547`	`546`	`child.setProperty(Property.FLOAT, null);`
`548`		`- } else {`
`549`		`- waitingRenderers.add(child);`
`550`	`547`	`}`
`551`	`548`	`} else {`
`552`	`549`	`child.draw(drawContext);`
`553`	`550`	`}`
`554`	`551`	`}`
`555`		`- for (IRenderer waitingRenderer : waitingRenderers) {`
`556`		`- waitingRenderer.draw(drawContext);`
`557`		`- }`
`558`	`552`	`}`
`559`	`553`
`560`	`554`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -122,6 +122,7 @@ public LayoutResult layout(LayoutContext layoutContext) {`
`122`	`122`	`applyBorderBox(layoutBox, borders, false);`
`123`	`123`
`124`	`124`	`if (isAbsolutePosition()) {`
	`125`	`+ // TODO applying it after floats processing here and everywhere. is it correct?`
`125`	`126`	`applyAbsolutePosition(layoutBox);`
`126`	`127`	`}`
`127`	`128`