コード例 #1
0
  private void setFullAddedElementsStateRight(SplitResult result, int elementCount, double height) {
    result
        .setRightElementSplitHeight(0, 0)
        .setRightColumnHeight(height)
        .setElementsAddedCount(elementCount)
        .setPageSplit(elementCount, false);

    bestResult.assignIfWorseThan(result);
  }
コード例 #2
0
  private AtomicIncreaseResult iterateOnRight(
      int currentIndex,
      SplitResult currentResult,
      float elementTop,
      Iterator<AtomicIncreaseResult> iterator) {
    AtomicIncreaseResult lastIncreaseResult = null;

    currentResult
        .setRightColumnHeight(rightCTB.getCurrentHeight())
        .setRightElementSplitHeight(
            elementTop - rightCTB.getYLine(), sequence.getHeight(currentIndex));

    bestResult.assignIfWorseThan(currentResult);

    cycle:
    while (iterator.hasNext()) {
      AtomicIncreaseResult r = iterator.next();
      currentResult.setRightColumnHeight(rightCTB.getCurrentHeight());

      lastIncreaseResult = r;

      switch (r.type) {
        case PAGE_OVERFLOW:
          break cycle;
        case NORMAL:
          currentResult.setRightElementSplitHeight(
              elementTop - rightCTB.getYLine(), sequence.getHeight(currentIndex));
          bestResult.assignIfWorseThan(currentResult);
          break;
        case NO_MORE_CONTENT:
          // must be done in the main cycle
          //                    setFullAddedElementsStateRight(currentResult, currentIndex + 1,
          // rightCTB.getCurrentHeight());

          break cycle;
      }
    }
    return lastIncreaseResult == null
        ? new AtomicIncreaseResult(0, ColumnTextBuilder.GrowthResultType.NO_MORE_CONTENT)
        : lastIncreaseResult;
  }
コード例 #3
0
  private boolean iterateOnLeft(
      Iterator<AtomicIncreaseResult> iterator,
      int currentIndex,
      SplitResult currentResult,
      float elementTop,
      float elementHeight) {
    currentResult
        .setLeftColumnHeight(leftCTB.getCurrentHeight())
        .setLeftElementSplitHeight(elementTop - leftCTB.getYLine(), elementHeight);

    if (currentResult.leftElementSplitHeight > 0) {
      considerAddingToRight(currentIndex + 1, true);
    }

    while (iterator.hasNext()) {
      AtomicIncreaseResult r = iterator.next();

      currentResult
          .setLeftColumnHeight(leftCTB.getCurrentHeight())
          .setLeftElementSplitHeight(elementTop - leftCTB.getYLine(), elementHeight);

      switch (r.type) {
        case PAGE_OVERFLOW:
          return true;

        case NORMAL:
          considerAddingToRight(currentIndex + 1, true);
          break;

        case NO_MORE_CONTENT:
          // don't consider adding to right as this case must be checked in the main loop
          //                    considerAddingToRight(currentIndex + 1, false);
          break;
      }
    }
    return false;
  }
コード例 #4
0
  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);
    }
  }
コード例 #5
0
  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();
  }