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();
}
private void considerAddingToRight(int startAt, boolean hasNotFlushedText) {
logger.trace(
"adding to right, i: {}, leftHeight: {}, leftSplit: {}",
startAt,
currentLeftResult.leftColumnHeight,
currentLeftResult.leftElementSplitHeight);
// copy content from the left
rightCTB.setACopy(leftCTB).setYLine(leftCTB.getTop());
if (!hasNotFlushedText && sequence.isSpace(startAt)) {
startAt++;
}
// we can flush what's left from the previous column
if (rightCTB.hasMoreText()) {
rightCTB.go(true);
}
currentRightResult.copyFrom(currentLeftResult);
// copied from left method
int i;
List<Element> elements = sequence.getElements();
final DirectContentAdder.Result quickResult =
new DirectContentAdder(rightCTB)
.setStartWith(leftCTB)
.setStartAtIndex(startAt)
.setQuickHeight(leftCTB.getCurrentHeight())
.setSimulate(true)
.go();
i = quickResult.index;
int elementsAdded = quickResult.contentLeft == null ? i : i - 1;
bestResult.assignIfWorseThan(
currentRightResult
.setElementsAddedCount(elementsAdded) // todo!!!
.setRightElementSplitHeight(0, 0)
.setRightColumnHeight(rightCTB.getCurrentHeight())
.setPageSplit(elementsAdded, quickResult.hasContentLeft(elements.size())));
boolean pageOverFlow = false;
if (quickResult.contentLeft != null) {
rightCTB.copyContentFrom(quickResult.contentLeft);
AtomicIncreaseResult lastResult =
iterateOnRight(
i - 1, currentRightResult, rightCTB.getTop(), rightCTB.newAtomicIteratorFor());
if (lastResult.type == ColumnTextBuilder.GrowthResultType.PAGE_OVERFLOW) {
pageOverFlow = true;
}
}
if (i == elements.size()) {
bestResult.assignIfWorseThan(
currentRightResult
.setRightElementSplitHeight(0, 0)
.setRightColumnHeight(rightCTB.getCurrentHeight())
.setElementsAddedCount(i)
.setPageSplit(i, rightCTB.hasMoreText()));
}
if (pageOverFlow) return;
elementsCycle:
for (; i < elements.size(); i++) {
Element el = elements.get(i);
final SplitResult currentResult = currentRightResult;
setFullAddedElementsStateRight(currentResult, i, rightCTB.getCurrentHeight());
currentResult.setPageSplit(true); // temporary pessimism
if (el instanceof SpaceElement) {
// todo extract method
SpaceElement space = (SpaceElement) el;
bestResult.assignIfWorseThan(currentResult.setElementsAddedCount(i).setPageSplit(i, false));
if (space.fits(rightCTB, origRectangle.getBottom())) {
space.add(rightCTB, true);
} else {
if (rightCTB.getSimpleColumnRectangle().getBottom() - space.getHeight()
< b.getDocument().bottom()) {
break;
}
rightCTB.growBottom(space.getHeight()).setYLine(rightCTB.getYLine() - space.getHeight());
}
} else {
float elementTop = rightCTB.getYLine();
final Iterator<AtomicIncreaseResult> iterator = rightCTB.newAtomicIteratorFor(el);
AtomicIncreaseResult lastResult = iterateOnRight(i, currentResult, elementTop, iterator);
if (lastResult.type == ColumnTextBuilder.GrowthResultType.PAGE_OVERFLOW) {
break;
}
}
// element is fully added here
currentResult
.setRightColumnHeight(rightCTB.getCurrentHeight())
.setRightElementSplitHeight(0, 0);
bestResult.assignIfWorseThan(currentResult);
}
}
public Result go() {
if (quickHeight != 0) {
if (rightCTB != null) {
throw new IllegalStateException("if quickHeight !=0 then rightCTB == null!");
}
}
Preconditions.checkNotNull(dest);
ColumnTextBuilder currentCtb = dest;
List<Element> elements = sequence.getElements();
int i;
if (quickHeight != 0) {
currentCtb.adjustBottom((float) quickHeight);
}
if (startWith != null) {
currentCtb.copyContentFrom(startWith);
float yBefore = currentCtb.getYLine();
int status = currentCtb.go(simulate);
if (setHeights) {
startContentHeight = yBefore - currentCtb.getYLine();
}
if (ColumnText.hasMoreText(status)) {
if (rightCTB != null) { // => quickHeight == 0
rightCTB.copyContentFrom(currentCtb);
currentCtb = rightCTB;
yBefore = currentCtb.getYLine();
status = currentCtb.go(simulate);
if (setHeights) {
startContentHeight += yBefore - currentCtb.getYLine();
}
if (ColumnText.hasMoreText(status)) {
return new Result(ColumnText.NO_MORE_COLUMN, startAtIndex, currentCtb);
}
} else {
return new Result(ColumnText.NO_MORE_COLUMN, startAtIndex, currentCtb);
}
}
}
// optimisation mode
if (quickHeight != 0) {
for (i = startAtIndex; i < elements.size(); i++) {
Element el = elements.get(i);
if (currentCtb.fits(el)) {
if (el instanceof SpaceElement) {
SpaceElement spaceElement = (SpaceElement) el;
spaceElement.add(currentCtb, simulate);
currentCtb.go(simulate);
} else {
currentCtb.addElement(el).go(simulate);
}
} else {
break;
}
}
return new Result(ColumnText.NO_MORE_TEXT, i, null);
}
for (i = startAtElement; i < elements.size(); i++) {
Element el = elements.get(i);
float yBefore = currentCtb.getYLine();
if (el instanceof SpaceElement) {
SpaceElement space = (SpaceElement) el;
if (space.fits(currentCtb, currentCtb.getBottom())) {
space.add(currentCtb, simulate);
} else {
if (currentCtb == dest) {
currentCtb = rightCTB;
} else if (currentCtb == rightCTB) {
return new Result(ColumnText.NO_MORE_COLUMN, i + 1, currentCtb.clearContent());
}
}
} else {
currentCtb.addElement(el);
if (ColumnText.hasMoreText(currentCtb.go(simulate))) {
if (currentCtb == dest) {
if (rightCTB == null) {
return new Result(ColumnText.NO_MORE_COLUMN, i + 1, currentCtb);
} else {
rightCTB.copyContentFrom(currentCtb);
currentCtb = rightCTB;
final int status = currentCtb.go(simulate);
if (ColumnText.hasMoreText(status)) {
return new Result(ColumnText.NO_MORE_COLUMN, i + 1, currentCtb);
}
}
} else {
return new Result(ColumnText.NO_MORE_COLUMN, i + 1, currentCtb);
}
}
}
if (setHeights) {
sequence.setHeight(i, yBefore - currentCtb.getYLine());
}
}
return new Result(ColumnText.NO_MORE_TEXT, elements.size(), null);
}