Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
What Is fop.jar in fop-2.7-bin.zip
What Is fop.jar? I got it from the fop-2.7-bin.zip.
✍: FYIcenter.com
fop.jar in fop-2.7-bin.zip is the JAR file for FOP 2.7, which
is a print formatter driven by XSL formatting objects (XSL-FO).
You can obtain fop.jar from the build folder of the fop-2.7-bin.zip file.
Below is the information about the fop.jar (2.2) file:
JAR File Size and Download Location:
JAR name: fop.jar, fop-2.7.jar Target JDK version: 1.7 File name: fop.jar File size: 4442817 bytes Release date: 20-Jan-2022 Download: Apache FOP Website
Java source code files for fop.jar:
⏎ org/apache/fop/layoutmgr/PageBreaker.java
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* $Id: PageBreaker.java 1880106 2020-07-21 13:28:42Z ssteiner $ */ package org.apache.fop.layoutmgr; import java.util.ArrayList; import java.util.Collections; import java.util.Iterator; import java.util.List; import org.apache.fop.area.Block; import org.apache.fop.area.BodyRegion; import org.apache.fop.area.Footnote; import org.apache.fop.area.PageViewport; import org.apache.fop.fo.Constants; import org.apache.fop.fo.FObj; import org.apache.fop.fo.pagination.Region; import org.apache.fop.fo.pagination.RegionBody; import org.apache.fop.fo.pagination.StaticContent; import org.apache.fop.layoutmgr.BreakingAlgorithm.KnuthNode; import org.apache.fop.layoutmgr.PageBreakingAlgorithm.PageBreakingLayoutListener; import org.apache.fop.layoutmgr.list.ListItemLayoutManager; import org.apache.fop.traits.MinOptMax; /** * Handles the breaking of pages in an fo:flow */ public class PageBreaker extends AbstractBreaker { private boolean firstPart = true; private boolean pageBreakHandled; private boolean needColumnBalancing; private PageProvider pageProvider; private Block separatorArea; private boolean spanAllActive; private boolean layoutRedone; private int previousIndex; private boolean handlingStartOfFloat; private boolean handlingEndOfFloat; private int floatHeight; private int floatYOffset; private List relayedFootnotesList; private List relayedLengthList; private int relayedTotalFootnotesLength; private int relayedInsertedFootnotesLength; private boolean relayedFootnotesPending; private boolean relayedNewFootnotes; private int relayedFirstNewFootnoteIndex; private int relayedFootnoteListIndex; private int relayedFootnoteElementIndex = -1; private MinOptMax relayedFootnoteSeparatorLength; private int previousFootnoteListIndex = -2; private int previousFootnoteElementIndex = -2; private int prevousColumnCount; /** * The FlowLayoutManager object, which processes * the single fo:flow of the fo:page-sequence */ private FlowLayoutManager childFLM; private StaticContentLayoutManager footnoteSeparatorLM; /** * Construct page breaker. * @param pslm the page sequence layout manager */ public PageBreaker(PageSequenceLayoutManager pslm) { this.pslm = pslm; this.pageProvider = pslm.getPageProvider(); this.childFLM = pslm.getLayoutManagerMaker().makeFlowLayoutManager( pslm, pslm.getPageSequence().getMainFlow()); } /** {@inheritDoc} */ protected void updateLayoutContext(LayoutContext context) { int flowIPD = pslm.getCurrentColumnWidth(); context.setRefIPD(flowIPD); } /** {@inheritDoc} */ protected LayoutManager getTopLevelLM() { return pslm; } /** {@inheritDoc} */ protected PageProvider getPageProvider() { return pslm.getPageProvider(); } /** * Starts the page breaking process. * @param flowBPD the constant available block-progression-dimension (used for every part) */ boolean doLayout(int flowBPD) { return doLayout(flowBPD, false); } /** {@inheritDoc} */ protected PageBreakingLayoutListener createLayoutListener() { return new PageBreakingLayoutListener() { public void notifyOverflow(int part, int amount, FObj obj) { Page p = pageProvider.getPageFromColumnIndex(part); RegionBody body = (RegionBody)p.getSimplePageMaster().getRegion( Region.FO_REGION_BODY); BlockLevelEventProducer eventProducer = BlockLevelEventProducer.Provider.get( body.getUserAgent().getEventBroadcaster()); boolean canRecover = (body.getOverflow() != Constants.EN_ERROR_IF_OVERFLOW); boolean needClip = (body.getOverflow() == Constants.EN_HIDDEN || body.getOverflow() == Constants.EN_ERROR_IF_OVERFLOW); eventProducer.regionOverflow(this, body.getName(), p.getPageViewport().getPageNumberString(), amount, needClip, canRecover, body.getLocator()); } }; } /** {@inheritDoc} */ protected int handleSpanChange(LayoutContext childLC, int nextSequenceStartsOn) { needColumnBalancing = false; if (childLC.getNextSpan() != Constants.NOT_SET) { //Next block list will have a different span. nextSequenceStartsOn = childLC.getNextSpan(); needColumnBalancing = childLC.getNextSpan() == Constants.EN_ALL && childLC.getDisableColumnBalancing() == Constants.EN_FALSE; } if (needColumnBalancing) { log.debug( "Column balancing necessary for the next element list!!!"); } return nextSequenceStartsOn; } /** {@inheritDoc} */ protected int getNextBlockList(LayoutContext childLC, int nextSequenceStartsOn) { return getNextBlockList(childLC, nextSequenceStartsOn, null, null, null); } /** {@inheritDoc} */ protected int getNextBlockList(LayoutContext childLC, int nextSequenceStartsOn, Position positionAtIPDChange, LayoutManager restartLM, List firstElements) { if (!layoutRedone && !handlingFloat()) { if (!firstPart) { // if this is the first page that will be created by // the current BlockSequence, it could have a break // condition that must be satisfied; // otherwise, we may simply need a new page handleBreakTrait(nextSequenceStartsOn); } firstPart = false; pageBreakHandled = true; pageProvider.setStartOfNextElementList(pslm.getCurrentPageNum(), pslm.getCurrentPV() .getCurrentSpan().getCurrentFlowIndex(), this.spanAllActive); } return super.getNextBlockList(childLC, nextSequenceStartsOn, positionAtIPDChange, restartLM, firstElements); } private boolean containsFootnotes(List contentList, LayoutContext context) { boolean containsFootnotes = false; if (contentList != null) { for (Object aContentList : contentList) { ListElement element = (ListElement) aContentList; if (element instanceof KnuthBlockBox && ((KnuthBlockBox) element).hasAnchors()) { // element represents a line with footnote citations containsFootnotes = true; KnuthBlockBox box = (KnuthBlockBox) element; List<List<KnuthElement>> footnotes = getFootnoteKnuthElements(childFLM, context, box.getFootnoteBodyLMs()); for (List<KnuthElement> footnote : footnotes) { box.addElementList(footnote); } } } } return containsFootnotes; } public static List<List<KnuthElement>> getFootnoteKnuthElements(FlowLayoutManager flowLM, LayoutContext context, List<FootnoteBodyLayoutManager> footnoteBodyLMs) { List<List<KnuthElement>> footnotes = new ArrayList<List<KnuthElement>>(); LayoutContext footnoteContext = LayoutContext.copyOf(context); footnoteContext.setStackLimitBP(context.getStackLimitBP()); footnoteContext.setRefIPD(flowLM.getPSLM() .getCurrentPV().getRegionReference(Constants.FO_REGION_BODY).getIPD()); for (FootnoteBodyLayoutManager fblm : footnoteBodyLMs) { fblm.setParent(flowLM); fblm.initialize(); List<KnuthElement> footnote = fblm.getNextKnuthElements(footnoteContext, Constants.EN_START); // TODO this does not respect possible stacking constraints between footnotes SpaceResolver.resolveElementList(footnote); footnotes.add(footnote); } return footnotes; } private void handleFootnoteSeparator() { StaticContent footnoteSeparator; footnoteSeparator = pslm.getPageSequence().getStaticContent("xsl-footnote-separator"); if (footnoteSeparator != null) { // the footnote separator can contain page-dependent content such as // page numbers or retrieve markers, so its areas cannot simply be // obtained now and repeated in each page; // we need to know in advance the separator bpd: the actual separator // could be different from page to page, but its bpd would likely be // always the same // create a Block area that will contain the separator areas separatorArea = new Block(); separatorArea.setIPD(pslm.getCurrentPV() .getRegionReference(Constants.FO_REGION_BODY).getIPD()); // create a StaticContentLM for the footnote separator footnoteSeparatorLM = pslm.getLayoutManagerMaker().makeStaticContentLayoutManager( pslm, footnoteSeparator, separatorArea); footnoteSeparatorLM.doLayout(); footnoteSeparatorLength = MinOptMax.getInstance(separatorArea.getBPD()); } } /** {@inheritDoc} */ protected List getNextKnuthElements(LayoutContext context, int alignment) { List contentList = null; while (!childFLM.isFinished() && contentList == null) { contentList = childFLM.getNextKnuthElements(context, alignment); } // scan contentList, searching for footnotes if (containsFootnotes(contentList, context)) { // handle the footnote separator handleFootnoteSeparator(); } return contentList; } /** {@inheritDoc} */ protected List getNextKnuthElements(LayoutContext context, int alignment, Position positionAtIPDChange, LayoutManager restartAtLM) { List contentList = null; do { contentList = childFLM.getNextKnuthElements(context, alignment, positionAtIPDChange, restartAtLM); } while (!childFLM.isFinished() && contentList == null); // scan contentList, searching for footnotes if (containsFootnotes(contentList, context)) { // handle the footnote separator handleFootnoteSeparator(); } return contentList; } /** * @return current display alignment */ protected int getCurrentDisplayAlign() { return pslm.getCurrentPage().getSimplePageMaster().getRegion( Constants.FO_REGION_BODY).getDisplayAlign(); } /** * @return whether or not this flow has more page break opportunities */ protected boolean hasMoreContent() { return !childFLM.isFinished(); } /** * Adds an area to the flow layout manager * @param posIter the position iterator * @param context the layout context */ protected void addAreas(PositionIterator posIter, LayoutContext context) { if (footnoteSeparatorLM != null) { StaticContent footnoteSeparator = pslm.getPageSequence().getStaticContent( "xsl-footnote-separator"); // create a Block area that will contain the separator areas separatorArea = new Block(); separatorArea.setIPD( pslm.getCurrentPV().getRegionReference(Constants.FO_REGION_BODY).getIPD()); // create a StaticContentLM for the footnote separator footnoteSeparatorLM = pslm.getLayoutManagerMaker().makeStaticContentLayoutManager( pslm, footnoteSeparator, separatorArea); footnoteSeparatorLM.doLayout(); } childFLM.addAreas(posIter, context); } /** * {@inheritDoc} * This implementation checks whether to trigger column-balancing, * or whether to take into account a 'last-page' condition. */ protected void doPhase3(PageBreakingAlgorithm alg, int partCount, BlockSequence originalList, BlockSequence effectiveList) { if (needColumnBalancing) { //column balancing for the last part redoLayout(alg, partCount, originalList, effectiveList); return; } if (shouldRedoLayout(partCount)) { redoLayout(alg, partCount, originalList, effectiveList); return; } //nothing special: just add the areas now addAreas(alg, partCount, originalList, effectiveList); } protected void prepareToRedoLayout(PageBreakingAlgorithm alg, int partCount, BlockSequence originalList, BlockSequence effectiveList) { int newStartPos = 0; int restartPoint = pageProvider.getStartingPartIndexForLastPage(partCount); if (restartPoint > 0 && !layoutRedone) { // Add definitive areas for the parts before the // restarting point addAreas(alg, restartPoint, originalList, effectiveList); // Get page break from which we restart PageBreakPosition pbp = alg.getPageBreaks().get(restartPoint - 1); newStartPos = alg.par.getFirstBoxIndex(pbp.getLeafPos() + 1); // Handle page break right here to avoid any side-effects if (newStartPos > 0) { handleBreakTrait(Constants.EN_PAGE); } } pageBreakHandled = true; // Update so the available BPD is reported correctly int currentPageNum = pslm.getCurrentPageNum(); int currentColumn = pslm.getCurrentPV().getCurrentSpan().getCurrentFlowIndex(); pageProvider.setStartOfNextElementList(currentPageNum, currentColumn, spanAllActive); // Make sure we only add the areas we haven't added already effectiveList.ignoreAtStart = newStartPos; if (!layoutRedone) { // Handle special page-master for last page setLastPageIndex(currentPageNum); // BodyRegion lastBody = pageProvider.getPage(false, currentPageNum).getPageViewport().getBodyRegion(); pslm.setCurrentPage(pageProvider.getPage(false, currentPageNum)); previousIndex = pageProvider.getIndexOfCachedLastPage(); } else { setLastPageIndex(currentPageNum + 1); // pslm.setCurrentPage(previousPage); pageProvider.discardCacheStartingWith(previousIndex); pslm.setCurrentPage(pageProvider.getPage(false, currentPageNum)); } layoutRedone = true; } /** * Restart the algorithm at the break corresponding to the given partCount. Used to * re-do the part after the last break in case of either column-balancing or a last * page-master. */ private void redoLayout(PageBreakingAlgorithm alg, int partCount, BlockSequence originalList, BlockSequence effectiveList) { int newStartPos = 0; int restartPoint = pageProvider.getStartingPartIndexForLastPage(partCount); if (restartPoint > 0) { //Add definitive areas for the parts before the //restarting point addAreas(alg, restartPoint, originalList, effectiveList); //Get page break from which we restart PageBreakPosition pbp = alg.getPageBreaks().get(restartPoint - 1); newStartPos = alg.par.getFirstBoxIndex(pbp.getLeafPos() + 1); //Handle page break right here to avoid any side-effects if (newStartPos > 0) { handleBreakTrait(Constants.EN_PAGE); } } log.debug("Restarting at " + restartPoint + ", new start position: " + newStartPos); pageBreakHandled = true; //Update so the available BPD is reported correctly int currentPageNum = pslm.getCurrentPageNum(); pageProvider.setStartOfNextElementList(currentPageNum, pslm.getCurrentPV().getCurrentSpan().getCurrentFlowIndex(), this.spanAllActive); //Make sure we only add the areas we haven't added already effectiveList.ignoreAtStart = newStartPos; PageBreakingAlgorithm algRestart; if (needColumnBalancing) { log.debug("Column balancing now!!!"); log.debug("==================================================="); //Restart last page algRestart = new BalancingColumnBreakingAlgorithm( getTopLevelLM(), getPageProvider(), createLayoutListener(), alignment, Constants.EN_START, footnoteSeparatorLength, isPartOverflowRecoveryActivated(), pslm.getCurrentPV().getBodyRegion().getColumnCount()); log.debug("==================================================="); } else { // Handle special page-master for last page BodyRegion currentBody = pageProvider.getPage(false, currentPageNum) .getPageViewport().getBodyRegion(); setLastPageIndex(currentPageNum); BodyRegion lastBody = pageProvider.getPage(false, currentPageNum) .getPageViewport().getBodyRegion(); lastBody.getMainReference().setSpans(currentBody.getMainReference().getSpans()); log.debug("Last page handling now!!!"); log.debug("==================================================="); //Restart last page algRestart = new PageBreakingAlgorithm( getTopLevelLM(), getPageProvider(), createLayoutListener(), alg.getAlignment(), alg.getAlignmentLast(), footnoteSeparatorLength, isPartOverflowRecoveryActivated(), false, false); log.debug("==================================================="); } int optimalPageCount = algRestart.findBreakingPoints(effectiveList, newStartPos, 1, true, BreakingAlgorithm.ALL_BREAKS); log.debug("restart: optimalPageCount= " + optimalPageCount + " pageBreaks.size()= " + algRestart.getPageBreaks().size()); boolean fitsOnePage = optimalPageCount <= pslm.getCurrentPV() .getBodyRegion().getMainReference().getCurrentSpan().getColumnCount(); if (needColumnBalancing) { if (!fitsOnePage) { log.warn( "Breaking algorithm produced more columns than are available."); /* reenable when everything works throw new IllegalStateException( "Breaking algorithm must not produce more columns than available."); */ } } else { boolean ipdChange = algRestart.getIPDdifference() != 0; if (fitsOnePage && !ipdChange) { //Replace last page pslm.setCurrentPage(pageProvider.getPage(false, currentPageNum)); } else { //Last page-master cannot hold the content. //Add areas now... addAreas(alg, restartPoint, partCount - restartPoint, originalList, effectiveList); if (!ipdChange) { //...and add a blank last page setLastPageIndex(currentPageNum + 1); pslm.setCurrentPage(pslm.makeNewPage(true)); } return; } } addAreas(algRestart, optimalPageCount, originalList, effectiveList); } private void setLastPageIndex(int currentPageNum) { int lastPageIndex = pslm.getForcedLastPageNum(currentPageNum); pageProvider.setLastPageIndex(lastPageIndex); } /** {@inheritDoc} */ protected void startPart(BlockSequence list, int breakClass, boolean emptyContent) { log.debug("startPart() breakClass=" + getBreakClassName(breakClass)); if (pslm.getCurrentPage() == null) { throw new IllegalStateException("curPage must not be null"); } if (!pageBreakHandled) { //firstPart is necessary because we need the first page before we start the //algorithm so we have a BPD and IPD. This may subject to change later when we //start handling more complex cases. if (!firstPart) { // if this is the first page that will be created by // the current BlockSequence, it could have a break // condition that must be satisfied; // otherwise, we may simply need a new page handleBreakTrait(breakClass, emptyContent); } pageProvider.setStartOfNextElementList(pslm.getCurrentPageNum(), pslm.getCurrentPV().getCurrentSpan().getCurrentFlowIndex(), this.spanAllActive); } pageBreakHandled = false; // add static areas and resolve any new id areas // finish page and add to area tree firstPart = false; } /** {@inheritDoc} */ protected void handleEmptyContent() { pslm.getCurrentPV().getPage().fakeNonEmpty(); } /** {@inheritDoc} */ protected void finishPart(PageBreakingAlgorithm alg, PageBreakPosition pbp) { // add footnote areas if (!pslm.getTableHeaderFootnotes().isEmpty() || pbp.footnoteFirstListIndex < pbp.footnoteLastListIndex || pbp.footnoteFirstElementIndex <= pbp.footnoteLastElementIndex || !pslm.getTableFooterFootnotes().isEmpty()) { for (List<KnuthElement> footnote : pslm.getTableHeaderFootnotes()) { addFootnoteAreas(footnote); } // call addAreas() for each FootnoteBodyLM for (int i = pbp.footnoteFirstListIndex; i <= pbp.footnoteLastListIndex; i++) { List elementList = alg.getFootnoteList(i); int firstIndex = (i == pbp.footnoteFirstListIndex ? pbp.footnoteFirstElementIndex : 0); int lastIndex = (i == pbp.footnoteLastListIndex ? pbp.footnoteLastElementIndex : elementList.size() - 1); addFootnoteAreas(elementList, firstIndex, lastIndex + 1); } for (List<KnuthElement> footnote : pslm.getTableFooterFootnotes()) { addFootnoteAreas(footnote); } // set the offset from the top margin Footnote parentArea = pslm.getCurrentPV().getBodyRegion().getFootnote(); int topOffset = pslm.getCurrentPV().getBodyRegion().getBPD() - parentArea.getBPD(); if (separatorArea != null) { topOffset -= separatorArea.getBPD(); } parentArea.setTop(topOffset); parentArea.setSeparator(separatorArea); } pslm.getCurrentPV().getCurrentSpan().notifyFlowsFinished(); pslm.clearTableHeadingFootnotes(); } private void addFootnoteAreas(List<KnuthElement> footnote) { addFootnoteAreas(footnote, 0, footnote.size()); } private void addFootnoteAreas(List<KnuthElement> footnote, int startIndex, int endIndex) { SpaceResolver.performConditionalsNotification(footnote, startIndex, endIndex - 1, -1); LayoutContext childLC = LayoutContext.newInstance(); AreaAdditionUtil.addAreas(null, new KnuthPossPosIter(footnote, startIndex, endIndex), childLC); } /** {@inheritDoc} */ protected FlowLayoutManager getCurrentChildLM() { return childFLM; } /** {@inheritDoc} */ protected void observeElementList(List elementList) { ElementListObserver.observe(elementList, "breaker", pslm.getFObj().getId()); } /** * Depending on the kind of break condition, move to next column * or page. May need to make an empty page if next page would * not have the desired "handedness". * @param breakVal - value of break-before or break-after trait. */ private void handleBreakTrait(int breakVal) { handleBreakTrait(breakVal, false); } private void handleBreakTrait(int breakVal, boolean emptyContent) { Page curPage = pslm.getCurrentPage(); switch (breakVal) { case Constants.EN_ALL: //break due to span change in multi-column layout curPage.getPageViewport().createSpan(true); this.spanAllActive = true; return; case Constants.EN_NONE: curPage.getPageViewport().createSpan(false); this.spanAllActive = false; return; case Constants.EN_COLUMN: case Constants.EN_AUTO: case Constants.EN_PAGE: case -1: PageViewport pv = curPage.getPageViewport(); //Check if previous page was spanned boolean forceNewPageWithSpan = false; RegionBody rb = (RegionBody)curPage.getSimplePageMaster().getRegion( Constants.FO_REGION_BODY); forceNewPageWithSpan = (rb.getColumnCount() > 1 && pv.getCurrentSpan().getColumnCount() == 1); if (forceNewPageWithSpan) { log.trace("Forcing new page with span"); curPage = pslm.makeNewPage(false); curPage.getPageViewport().createSpan(true); } else { if (breakVal == Constants.EN_PAGE) { handleBreakBeforeFollowingPage(breakVal); } else { if (pv.getCurrentSpan().hasMoreFlows()) { log.trace("Moving to next flow"); pv.getCurrentSpan().moveToNextFlow(); } else { log.trace("Making new page"); pslm.makeNewPage(false, emptyContent); } } } return; default: handleBreakBeforeFollowingPage(breakVal); } } private void handleBreakBeforeFollowingPage(int breakVal) { log.debug("handling break-before after page " + pslm.getCurrentPageNum() + " breakVal=" + getBreakClassName(breakVal)); if (needBlankPageBeforeNew(breakVal)) { log.trace("Inserting blank page"); /* curPage = */pslm.makeNewPage(true); } if (needNewPage(breakVal)) { log.trace("Making new page"); /* curPage = */pslm.makeNewPage(false); } } /** * Check if a blank page is needed to accommodate * desired even or odd page number. * @param breakVal - value of break-before or break-after trait. */ private boolean needBlankPageBeforeNew(int breakVal) { if (breakVal == Constants.EN_PAGE || (pslm.getCurrentPage().getPageViewport().getPage().isEmpty())) { // any page is OK or we already have an empty page return false; } else { /* IF we are on the kind of page we need, we'll need a new page. */ if (pslm.getCurrentPageNum() % 2 == 0) { // even page return (breakVal == Constants.EN_EVEN_PAGE); } else { // odd page return (breakVal == Constants.EN_ODD_PAGE); } } } /** * See if need to generate a new page * @param breakVal - value of break-before or break-after trait. */ private boolean needNewPage(int breakVal) { if (pslm.getCurrentPage().getPageViewport().getPage().isEmpty()) { if (breakVal == Constants.EN_PAGE) { return false; } else if (pslm.getCurrentPageNum() % 2 == 0) { // even page return (breakVal == Constants.EN_ODD_PAGE); } else { // odd page return (breakVal == Constants.EN_EVEN_PAGE); } } else { return true; } } protected boolean shouldRedoLayout() { return shouldRedoLayout(-1); } protected boolean shouldRedoLayout(int partCount) { boolean lastPageMasterDefined = pslm.getPageSequence().hasPagePositionLast(); if (!lastPageMasterDefined && partCount != -1) { lastPageMasterDefined = pslm.getPageSequence().hasPagePositionOnly() && pslm.isOnFirstPage(partCount - 1); } return (!hasMoreContent() && lastPageMasterDefined && !layoutRedone); } protected boolean wasLayoutRedone() { return layoutRedone; } protected boolean lastPageHasIPDChange(int optimalPageCount) { boolean lastPageMasterDefined = pslm.getPageSequence().hasPagePositionLast(); boolean onlyPageMasterDefined = pslm.getPageSequence().hasPagePositionOnly(); if (lastPageMasterDefined && !onlyPageMasterDefined) { // code not very robust and unable to handle situations were only and last are defined int currentColumnCount = pageProvider.getCurrentColumnCount(); boolean changeInColumnCount = prevousColumnCount > 0 && prevousColumnCount != currentColumnCount; prevousColumnCount = currentColumnCount; if ((currentColumnCount > 1 && optimalPageCount % currentColumnCount == 0) || changeInColumnCount) { return false; } int currentIPD = this.pageProvider.getCurrentIPD(); int lastPageIPD = this.pageProvider.getLastPageIPD(); return lastPageIPD != -1 && currentIPD != lastPageIPD; } return false; } protected boolean handlingStartOfFloat() { return handlingStartOfFloat; } protected void handleStartOfFloat(int fHeight, int fYOffset) { handlingStartOfFloat = true; handlingEndOfFloat = false; floatHeight = fHeight; floatYOffset = fYOffset; childFLM.handleFloatOn(); } protected int getFloatHeight() { return floatHeight; } protected int getFloatYOffset() { return floatYOffset; } protected boolean handlingEndOfFloat() { return handlingEndOfFloat; } protected void handleEndOfFloat(int fHeight) { handlingEndOfFloat = true; handlingStartOfFloat = false; floatHeight = fHeight; childFLM.handleFloatOff(); } protected boolean handlingFloat() { return (handlingStartOfFloat || handlingEndOfFloat); } public int getOffsetDueToFloat() { handlingEndOfFloat = false; return floatHeight + floatYOffset; } protected int handleFloatLayout(PageBreakingAlgorithm alg, int optimalPageCount, BlockSequence blockList, LayoutContext childLC) { pageBreakHandled = true; List firstElements = Collections.EMPTY_LIST; KnuthNode floatNode = alg.getBestFloatEdgeNode(); int floatPosition = floatNode.position; KnuthElement floatElem = alg.getElement(floatPosition); Position positionAtBreak = floatElem.getPosition(); if (!(positionAtBreak instanceof SpaceResolver.SpaceHandlingBreakPosition)) { throw new UnsupportedOperationException("Don't know how to restart at position" + positionAtBreak); } /* Retrieve the original position wrapped into this space position */ positionAtBreak = positionAtBreak.getPosition(); addAreas(alg, optimalPageCount, blockList, blockList); blockLists.clear(); blockListIndex = -1; LayoutManager restartAtLM = null; if (positionAtBreak != null && positionAtBreak.getIndex() == -1) { if (positionAtBreak instanceof ListItemLayoutManager.ListItemPosition) { restartAtLM = positionAtBreak.getLM(); } else { Position position; Iterator iter = blockList.listIterator(floatPosition + 1); do { KnuthElement nextElement = (KnuthElement) iter.next(); position = nextElement.getPosition(); } while (position == null || position instanceof SpaceResolver.SpaceHandlingPosition || position instanceof SpaceResolver.SpaceHandlingBreakPosition && position.getPosition().getIndex() == -1); LayoutManager surroundingLM = positionAtBreak.getLM(); while (position.getLM() != surroundingLM) { position = position.getPosition(); } restartAtLM = position.getPosition().getLM(); } } int nextSequenceStartsOn = getNextBlockList(childLC, Constants.EN_COLUMN, positionAtBreak, restartAtLM, firstElements); return nextSequenceStartsOn; } protected void addAreasForFloats(PageBreakingAlgorithm alg, int startPart, int partCount, BlockSequence originalList, BlockSequence effectiveList, final LayoutContext childLC, int lastBreak, int startElementIndex, int endElementIndex) { FloatPosition pbp = alg.getFloatPosition(); // Check the last break position for forced breaks int lastBreakClass; if (startElementIndex == 0) { lastBreakClass = effectiveList.getStartOn(); } else { ListElement lastBreakElement = effectiveList.getElement(endElementIndex); if (lastBreakElement.isPenalty()) { KnuthPenalty pen = (KnuthPenalty) lastBreakElement; if (pen.getPenalty() == KnuthPenalty.INFINITE) { /** * That means that there was a keep.within-page="always", but that * it's OK to break at a column. TODO The break class is being * abused to implement keep.within-column and keep.within-page. * This is very misleading and must be revised. */ lastBreakClass = Constants.EN_COLUMN; } else { lastBreakClass = pen.getBreakClass(); } } else { lastBreakClass = Constants.EN_COLUMN; } } // the end of the new part endElementIndex = pbp.getLeafPos(); // ignore the first elements added by the // PageSequenceLayoutManager startElementIndex += (startElementIndex == 0) ? effectiveList.ignoreAtStart : 0; log.debug("PLM> part: " + (startPart + partCount + 1) + ", start at pos " + startElementIndex + ", break at pos " + endElementIndex + ", break class = " + getBreakClassName(lastBreakClass)); startPart(effectiveList, lastBreakClass, false); int displayAlign = getCurrentDisplayAlign(); // The following is needed by SpaceResolver.performConditionalsNotification() // further down as there may be important Position elements in the element list trailer int notificationEndElementIndex = endElementIndex; // ignore the last elements added by the // PageSequenceLayoutManager endElementIndex -= (endElementIndex == (originalList.size() - 1)) ? effectiveList.ignoreAtEnd : 0; // ignore the last element in the page if it is a KnuthGlue // object if (((KnuthElement) effectiveList.get(endElementIndex)).isGlue()) { endElementIndex--; } // ignore KnuthGlue and KnuthPenalty objects // at the beginning of the line startElementIndex = alg.par.getFirstBoxIndex(startElementIndex); if (startElementIndex <= endElementIndex) { if (log.isDebugEnabled()) { log.debug(" addAreas from " + startElementIndex + " to " + endElementIndex); } // set the space adjustment ratio childLC.setSpaceAdjust(pbp.bpdAdjust); // add space before if display-align is center or bottom // add space after if display-align is distribute and // this is not the last page if (pbp.difference != 0 && displayAlign == Constants.EN_CENTER) { childLC.setSpaceBefore(pbp.difference / 2); } else if (pbp.difference != 0 && displayAlign == Constants.EN_AFTER) { childLC.setSpaceBefore(pbp.difference); } // Handle SpaceHandling(Break)Positions, see SpaceResolver! SpaceResolver.performConditionalsNotification(effectiveList, startElementIndex, notificationEndElementIndex, lastBreak); // Add areas of lines, in the current page, before the float or during float addAreas(new KnuthPossPosIter(effectiveList, startElementIndex, endElementIndex + 1), childLC); // add areas for the float, if applicable if (alg.handlingStartOfFloat()) { for (int k = startElementIndex; k < endElementIndex + 1; k++) { ListElement le = effectiveList.getElement(k); if (le instanceof KnuthBlockBox) { KnuthBlockBox kbb = (KnuthBlockBox) le; for (FloatContentLayoutManager fclm : kbb.getFloatContentLMs()) { fclm.processAreas(childLC); int floatHeight = fclm.getFloatHeight(); int floatYOffset = fclm.getFloatYOffset(); PageSequenceLayoutManager pslm = (PageSequenceLayoutManager) getTopLevelLM(); pslm.recordStartOfFloat(floatHeight, floatYOffset); } } } } if (alg.handlingEndOfFloat()) { PageSequenceLayoutManager pslm = (PageSequenceLayoutManager) getTopLevelLM(); pslm.setEndIntrusionAdjustment(0); pslm.setStartIntrusionAdjustment(0); int effectiveFloatHeight = alg.getFloatHeight(); pslm.recordEndOfFloat(effectiveFloatHeight); } if (alg.handlingFloat()) { PageSequenceLayoutManager pslm = (PageSequenceLayoutManager) getTopLevelLM(); alg.relayFootnotes(pslm); } } else { // no content for this part handleEmptyContent(); } pageBreakHandled = true; } public void holdFootnotes(List fl, List ll, int tfl, int ifl, boolean fp, boolean nf, int fnfi, int fli, int fei, MinOptMax fsl, int pfli, int pfei) { relayedFootnotesList = fl; relayedLengthList = ll; relayedTotalFootnotesLength = tfl; relayedInsertedFootnotesLength = ifl; relayedFootnotesPending = fp; relayedNewFootnotes = nf; relayedFirstNewFootnoteIndex = fnfi; relayedFootnoteListIndex = fli; relayedFootnoteElementIndex = fei; relayedFootnoteSeparatorLength = fsl; previousFootnoteListIndex = pfli; previousFootnoteElementIndex = pfei; } public void retrieveFootones(PageBreakingAlgorithm alg) { if (relayedFootnotesList != null && relayedFootnotesList.size() > 0) { alg.loadFootnotes(relayedFootnotesList, relayedLengthList, relayedTotalFootnotesLength, relayedInsertedFootnotesLength, relayedFootnotesPending, relayedNewFootnotes, relayedFirstNewFootnoteIndex, relayedFootnoteListIndex, relayedFootnoteElementIndex, relayedFootnoteSeparatorLength, previousFootnoteListIndex, previousFootnoteElementIndex); relayedFootnotesList = null; relayedLengthList = null; relayedTotalFootnotesLength = 0; relayedInsertedFootnotesLength = 0; relayedFootnotesPending = false; relayedNewFootnotes = false; relayedFirstNewFootnoteIndex = 0; relayedFootnoteListIndex = 0; relayedFootnoteElementIndex = -1; relayedFootnoteSeparatorLength = null; } } }
⏎ org/apache/fop/layoutmgr/PageBreaker.java
Or download all of them as a single archive file:
File name: fop-2.7-src.zip File size: 3401312 bytes Release date: 2022-01-20 Download
⇒ "fop" Command in fop-2.7-bin.zip
2016-07-07, 22057👍, 0💬
Popular Posts:
maven-core-3.8.6.jar is the JAR file for Apache Maven 3.8.6 Core module. Apache Maven is a software ...
Java Cryptography Extension 1.2.2 JAR File Size and Download Location: File name: jce.jar, jce-1.2.2...
JRE 8 rt.jar is the JAR file for JRE 8 RT (Runtime) libraries. JRE (Java Runtime) 8 is the runtime e...
Where Can I see Java Source Code files for Xerces Java 2.11.2? Here are Java Source Code files for X...
commons-io-2.6-sources.j aris the source JAR file for Apache Commons IO 2.6, which is a library of u...