private BalancingResult applyBestResult() {
final float hCenter = horCenter();
List<Element> elements = sequence.getElements();
setColumn((float) bestResult.leftColumnHeight, hCenter, true, true, singleColumnRect, leftCTB);
setColumn(
(float) bestResult.rightColumnHeight, hCenter, false, false, singleColumnRect, rightCTB);
if (b.drawBorders) {
b.getCanvasBuilder().drawGrayRectangle(leftCTB.getSimpleColumnRectangle(), BaseColor.RED);
b.getCanvasBuilder().drawGrayRectangle(rightCTB.getSimpleColumnRectangle(), BaseColor.GREEN);
}
leftCTB.clearContent();
rightCTB.clearContent();
final DirectContentAdder.Result addResult =
new DirectContentAdder(leftCTB)
.setStartWith(initialLeftCTB)
.setStartAtIndex(startAtElement)
.setSwitchToRightCTB(rightCTB)
.setSimulate(false)
.go();
float yLine = Math.min(leftCTB.getYLine(), rightCTB.getYLine());
final BalancingResult r;
if (addResult.hasContentLeft(elements.size())) {
final ColumnTextBuilder contentCopy =
addResult.contentLeft == null
? null
: b.newColumnTextBuilder().setACopy(addResult.contentLeft);
r = startWithANewPage(contentCopy, addResult.index);
} else {
r = new BalancingResult(yLine);
// if(updateAfterRun != null){
// updateAfterRun.growBottom(origRectangle.getTop() - yLine);
// }
}
if (updateAfterRun != null) {
updateAfterRun.setSimpleColumn(
b.reuseRectangleBuilder(new Rectangle(origRectangle.get()))
.setTop(yLine)
.setBottom(b.getDocument().bottom())
.get());
}
return r;
}
private BalancingResult _go() {
if (b.drawBorders) {
b.getCanvasBuilder().drawGrayRectangle(origRectangle.get(), BaseColor.LIGHT_GRAY);
}
currentLeftResult.totalElementCount =
currentRightResult.totalElementCount = bestResult.totalElementCount = sequence.size();
// try adding into a single infinite column to calc height
final float hCenter = horCenter();
referenceHeight = calcReferenceHeight(hCenter);
currentLeftResult.referenceHeight =
currentRightResult.referenceHeight = bestResult.referenceHeight = referenceHeight;
leftCTB =
setColumn(
(float) referenceHeight,
hCenter,
true,
true,
singleColumnRect,
b.newColumnTextBuilder());
rightCTB =
setColumn(
(float) referenceHeight,
hCenter,
false,
true,
singleColumnRect,
b.newColumnTextBuilder());
minimalLeftColumnHeight = MINIMAL_HEIGHT_COEFFICIENT * referenceHeight / 2;
int i;
List<Element> elements = sequence.getElements();
final DirectContentAdder.Result quickResult =
new DirectContentAdder(leftCTB)
.setStartWith(initialLeftCTB)
.setStartAtIndex(startAtElement)
.setQuickHeight(minimalLeftColumnHeight)
.setSimulate(true)
.go();
i = quickResult.index;
bestResult.assignIfWorseThan(
currentLeftResult
.setElementsAddedCount(i)
.setLeftElementSplitHeight(0, 0)
.setLeftColumnHeight(leftCTB.getCurrentHeight())
.setPageSplit(i, quickResult.hasContentLeft(elements.size())));
boolean pageOverFlow = false;
// the only situation possible is the content left from initialContent
if (quickResult.contentLeft != null) {
leftCTB.copyContentFrom(quickResult.contentLeft);
pageOverFlow =
iterateOnLeft(
leftCTB.newAtomicIteratorFor(),
i - 1,
currentLeftResult,
leftCTB.getTop(),
sequence.initialContentHeight);
}
if (i == elements.size()) {
bestResult.assignIfWorseThan(
currentLeftResult
.setLeftElementSplitHeight(0, 0)
.setLeftColumnHeight(leftCTB.getCurrentHeight())
.setElementsAddedCount(i)
.setPageSplit(i, leftCTB.hasMoreText()));
}
if (pageOverFlow) {
return applyBestResult();
}
elementsCycle:
for (; i < elements.size(); i++) {
Element el = elements.get(i);
final SplitResult currentResult = currentLeftResult;
currentResult
.setLeftElementSplitHeight(0, 0)
.setElementsAddedCount(i)
.setLeftColumnHeight(leftCTB.getCurrentHeight());
considerAddingOnRightAtWholeElement(i);
if (el instanceof SpaceElement) {
SpaceElement space = (SpaceElement) el;
currentResult.setElementsAddedCount(i);
considerAddingToRight(i + 1, false);
if (space.fits(leftCTB, origRectangle.getBottom())) {
space.add(leftCTB, true);
} else {
if (leftCTB.getSimpleColumnRectangle().getBottom() - space.getHeight()
< b.getDocument().bottom()) {
break;
}
leftCTB.growBottom(space.getHeight()).setYLine(leftCTB.getYLine() - space.getHeight());
}
} else {
float elementTop = leftCTB.getYLine();
final Iterator<AtomicIncreaseResult> iterator = leftCTB.newAtomicIteratorFor(el);
if (iterateOnLeft(iterator, i, currentResult, elementTop, sequence.getHeight(i))) {
break elementsCycle;
}
// leftCTB.restoreState();
}
currentResult.setLeftColumnHeight(leftCTB.getCurrentHeight()).setElementsAddedCount(i + 1);
}
considerAddingOnRightAtWholeElement(i);
// here we have bestResult, so let's add our content with no simulation!
// setColumn(bestResult, b.newColumnTextBuilder())
return applyBestResult();
}