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/BlockContainerLayoutManager.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: BlockContainerLayoutManager.java 1877372 2020-05-05 08:12:02Z ssteiner $ */ package org.apache.fop.layoutmgr; import java.awt.Point; import java.awt.geom.Rectangle2D; import java.util.LinkedList; import java.util.List; import java.util.Stack; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.fop.area.Area; import org.apache.fop.area.Block; import org.apache.fop.area.BlockViewport; import org.apache.fop.area.CTM; import org.apache.fop.area.Trait; import org.apache.fop.datatypes.FODimension; import org.apache.fop.datatypes.Length; import org.apache.fop.fo.flow.BlockContainer; import org.apache.fop.fo.properties.CommonAbsolutePosition; import org.apache.fop.fo.properties.CommonBorderPaddingBackground; import org.apache.fop.fo.properties.KeepProperty; import org.apache.fop.traits.MinOptMax; import org.apache.fop.traits.SpaceVal; /** * LayoutManager for a block-container FO. */ public class BlockContainerLayoutManager extends SpacedBorderedPaddedBlockLayoutManager implements BreakOpportunity { /** * logging instance */ private static Log log = LogFactory.getLog(BlockContainerLayoutManager.class); private BlockViewport viewportBlockArea; private Block referenceArea; private CommonAbsolutePosition abProps; private FODimension relDims; private CTM absoluteCTM; private Length width; private Length height; //private int vpContentIPD; private int vpContentBPD; // When viewport should grow with the content. private boolean autoHeight = true; private boolean inlineElementList; /* holds the (one-time use) fo:block space-before and -after properties. Large fo:blocks are split into multiple Area.Blocks to accomodate the subsequent regions (pages) they are placed on. space-before is applied at the beginning of the first Block and space-after at the end of the last Block used in rendering the fo:block. */ //TODO space-before|after: handle space-resolution rules private MinOptMax foBlockSpaceBefore; private MinOptMax foBlockSpaceAfter; private int horizontalOverflow; private double contentRectOffsetX; private double contentRectOffsetY; /** * Create a new block container layout manager. * @param node block-container node to create the layout manager for. */ public BlockContainerLayoutManager(BlockContainer node) { super(node); setGeneratesBlockArea(true); } /** {@inheritDoc} */ @Override public void initialize() { abProps = getBlockContainerFO().getCommonAbsolutePosition(); foBlockSpaceBefore = new SpaceVal(getBlockContainerFO().getCommonMarginBlock() .spaceBefore, this).getSpace(); foBlockSpaceAfter = new SpaceVal(getBlockContainerFO().getCommonMarginBlock() .spaceAfter, this).getSpace(); startIndent = getBlockContainerFO().getCommonMarginBlock().startIndent.getValue(this); endIndent = getBlockContainerFO().getCommonMarginBlock().endIndent.getValue(this); if (blockProgressionDirectionChanges()) { height = getBlockContainerFO().getInlineProgressionDimension() .getOptimum(this).getLength(); width = getBlockContainerFO().getBlockProgressionDimension() .getOptimum(this).getLength(); } else { height = getBlockContainerFO().getBlockProgressionDimension() .getOptimum(this).getLength(); width = getBlockContainerFO().getInlineProgressionDimension() .getOptimum(this).getLength(); } // use optimum space values adjustedSpaceBefore = getBlockContainerFO().getCommonMarginBlock() .spaceBefore.getSpace().getOptimum(this).getLength().getValue(this); adjustedSpaceAfter = getBlockContainerFO().getCommonMarginBlock() .spaceAfter.getSpace().getOptimum(this).getLength().getValue(this); } @Override protected CommonBorderPaddingBackground getCommonBorderPaddingBackground() { return getBlockContainerFO().getCommonBorderPaddingBackground(); } private void resetSpaces() { this.discardBorderBefore = false; this.discardBorderAfter = false; this.discardPaddingBefore = false; this.discardPaddingAfter = false; this.effSpaceBefore = null; this.effSpaceAfter = null; } /** @return the content IPD */ protected int getRotatedIPD() { return getBlockContainerFO().getInlineProgressionDimension() .getOptimum(this).getLength().getValue(this); } private boolean needClip() { int overflow = getBlockContainerFO().getOverflow(); return (overflow == EN_HIDDEN || overflow == EN_ERROR_IF_OVERFLOW); } private int getBPIndents() { int indents = 0; /* TODO This is wrong isn't it? indents += getBlockContainerFO().getCommonMarginBlock() .spaceBefore.getOptimum(this).getLength().getValue(this); indents += getBlockContainerFO().getCommonMarginBlock() .spaceAfter.getOptimum(this).getLength().getValue(this); */ indents += getBlockContainerFO().getCommonBorderPaddingBackground() .getBPPaddingAndBorder(false, this); return indents; } protected boolean isAbsoluteOrFixed() { return (abProps.absolutePosition == EN_ABSOLUTE || abProps.absolutePosition == EN_FIXED); } private boolean isFixed() { return (abProps.absolutePosition == EN_FIXED); } /** {@inheritDoc} */ @Override public int getContentAreaBPD() { if (autoHeight) { return -1; } else { return this.vpContentBPD; } } /** {@inheritDoc} */ @Override public List getNextKnuthElements(LayoutContext context, int alignment) { return getNextKnuthElements(context, alignment, null, null, null); } /** * Overridden to handle writing-mode, and different stack limit * setup. * {@inheritDoc} */ @Override protected LayoutContext makeChildLayoutContext(LayoutContext context) { LayoutContext childLC = LayoutContext.newInstance(); childLC.setStackLimitBP( context.getStackLimitBP().minus(MinOptMax.getInstance(relDims.bpd))); childLC.setRefIPD(relDims.ipd); childLC.setWritingMode(getBlockContainerFO().getWritingMode()); return childLC; } /** {@inheritDoc} */ @Override public List getNextKnuthElements(LayoutContext context, int alignment, Stack lmStack, Position restartPosition, LayoutManager restartAtLM) { resetSpaces(); // special treatment for position="absolute|fixed" if (isAbsoluteOrFixed()) { return getNextKnuthElementsAbsolute(context); } boolean isRestart = (lmStack != null); boolean emptyStack = (!isRestart || lmStack.isEmpty()); setupAreaDimensions(context); List<ListElement> returnedList; List<ListElement> contentList = new LinkedList<ListElement>(); List<ListElement> returnList = new LinkedList<ListElement>(); if (!breakBeforeServed(context, returnList)) { return returnList; } addFirstVisibleMarks(returnList, context, alignment); if (autoHeight && inlineElementList) { LayoutManager curLM; // currently active LM LayoutManager prevLM = null; // previously active LM LayoutContext childLC; if (isRestart) { if (emptyStack) { assert restartAtLM != null && restartAtLM.getParent() == this; curLM = restartAtLM; } else { curLM = (LayoutManager) lmStack.pop(); } setCurrentChildLM(curLM); } else { curLM = getChildLM(); } while (curLM != null) { childLC = makeChildLayoutContext(context); // get elements from curLM if (!isRestart || emptyStack) { if (isRestart) { curLM.reset(); } returnedList = getNextChildElements(curLM, context, childLC, alignment, null, null, null); } else { returnedList = getNextChildElements(curLM, context, childLC, alignment, lmStack, restartPosition, restartAtLM); // once encountered, irrelevant for following child LMs emptyStack = true; } if (contentList.isEmpty() && childLC.isKeepWithPreviousPending()) { //Propagate keep-with-previous up from the first child context.updateKeepWithPreviousPending(childLC.getKeepWithPreviousPending()); childLC.clearKeepWithPreviousPending(); } if (returnedList.size() == 1 && ElementListUtils.startsWithForcedBreak(returnedList)) { // a descendant of this block has break-before contentList.addAll(returnedList); // "wrap" the Position inside each element // moving the elements from contentList to returnList wrapPositionElements(contentList, returnList); return returnList; } else { if (prevLM != null) { // there is a block handled by prevLM // before the one handled by curLM addInBetweenBreak(contentList, context, childLC); } contentList.addAll(returnedList); if (returnedList.isEmpty()) { //Avoid NoSuchElementException below (happens with empty blocks) continue; } if (ElementListUtils.endsWithForcedBreak(returnedList)) { // a descendant of this block has break-after if (curLM.isFinished() && !hasNextChildLM()) { // there is no other content in this block; // it's useless to add space after before a page break setFinished(true); } wrapPositionElements(contentList, returnList); return returnList; } } // propagate and clear context.updateKeepWithNextPending(childLC.getKeepWithNextPending()); childLC.clearKeepsPending(); prevLM = curLM; curLM = getChildLM(); } wrapPositionElements(contentList, returnList); } else { returnList.add(generateNonInlinedBox()); } addLastVisibleMarks(returnList, context, alignment); addKnuthElementsForBreakAfter(returnList, context); context.updateKeepWithNextPending(getKeepWithNext()); setFinished(true); return returnList; } private void setupAreaDimensions(LayoutContext context) { autoHeight = false; int maxbpd = context.getStackLimitBP().getOpt(); int allocBPD; BlockContainer fo = getBlockContainerFO(); if (height.getEnum() == EN_AUTO || (!height.isAbsolute() && getAncestorBlockAreaBPD() <= 0)) { //auto height when height="auto" or "if that dimension is not specified explicitly //(i.e., it depends on content's block-progression-dimension)" (XSL 1.0, 7.14.1) allocBPD = maxbpd; autoHeight = true; //Cannot easily inline element list when ref-or<>"0" inlineElementList = (fo.getReferenceOrientation() == 0); } else { allocBPD = height.getValue(this); //this is the content-height allocBPD += getBPIndents(); } vpContentBPD = allocBPD - getBPIndents(); referenceIPD = context.getRefIPD(); if (width.getEnum() == EN_AUTO) { updateContentAreaIPDwithOverconstrainedAdjust(); } else { int contentWidth = width.getValue(this); updateContentAreaIPDwithOverconstrainedAdjust(contentWidth); } contentRectOffsetX = 0; contentRectOffsetY = 0; int level = fo.getBidiLevel(); if ((level < 0) || ((level & 1) == 0)) { contentRectOffsetX += fo.getCommonMarginBlock().startIndent.getValue(this); } else { contentRectOffsetX += fo.getCommonMarginBlock().endIndent.getValue(this); } contentRectOffsetY += fo.getCommonBorderPaddingBackground().getBorderBeforeWidth(false); contentRectOffsetY += fo.getCommonBorderPaddingBackground().getPaddingBefore(false, this); updateRelDims(); int availableIPD = referenceIPD - getIPIndents(); if (getContentAreaIPD() > availableIPD) { BlockLevelEventProducer eventProducer = BlockLevelEventProducer.Provider.get( fo.getUserAgent().getEventBroadcaster()); eventProducer.objectTooWide(this, fo.getName(), getContentAreaIPD(), context.getRefIPD(), fo.getLocator()); } } private KnuthBox generateNonInlinedBox() { MinOptMax range = MinOptMax.getInstance(relDims.ipd); BlockContainerBreaker breaker = new BlockContainerBreaker(this, range); breaker.doLayout(relDims.bpd, autoHeight); boolean contentOverflows = breaker.isOverflow(); if (autoHeight) { //Update content BPD now that it is known int newHeight = breaker.deferredAlg.totalWidth; if (blockProgressionDirectionChanges()) { setContentAreaIPD(newHeight); } else { vpContentBPD = newHeight; } updateRelDims(); } Position bcPosition = new BlockContainerPosition(this, breaker); KnuthBox knuthBox = new KnuthBox(vpContentBPD, notifyPos(bcPosition), false); //TODO Handle min/opt/max for block-progression-dimension /* These two elements will be used to add stretchability to the above box returnList.add(new KnuthPenalty(0, KnuthElement.INFINITE, false, returnPosition, false)); returnList.add(new KnuthGlue(0, 1 * constantLineHeight, 0, LINE_NUMBER_ADJUSTMENT, returnPosition, false)); */ if (contentOverflows) { BlockLevelEventProducer eventProducer = BlockLevelEventProducer.Provider.get( getBlockContainerFO().getUserAgent().getEventBroadcaster()); boolean canRecover = (getBlockContainerFO().getOverflow() != EN_ERROR_IF_OVERFLOW); eventProducer.viewportBPDOverflow(this, getBlockContainerFO().getName(), breaker.getOverflowAmount(), needClip(), canRecover, getBlockContainerFO().getLocator()); } return knuthBox; } private boolean blockProgressionDirectionChanges() { return getBlockContainerFO().getReferenceOrientation() % 180 != 0; } /** {@inheritDoc} */ @Override public boolean isRestartable() { return true; } private List<ListElement> getNextKnuthElementsAbsolute(LayoutContext context) { autoHeight = false; boolean bpDirectionChanges = blockProgressionDirectionChanges(); Point offset = getAbsOffset(); int allocBPD; int allocIPD; if (height.getEnum() == EN_AUTO || (!height.isAbsolute() && getAncestorBlockAreaBPD() <= 0)) { //auto height when height="auto" or "if that dimension is not specified explicitly //(i.e., it depends on content's blockprogression-dimension)" (XSL 1.0, 7.14.1) allocBPD = 0; if (abProps.bottom.getEnum() != EN_AUTO) { int availHeight; if (isFixed()) { availHeight = (int)getCurrentPV().getViewArea().getHeight(); } else { availHeight = context.getStackLimitBP().getOpt(); } allocBPD = availHeight; allocBPD -= offset.y; if (abProps.bottom.getEnum() != EN_AUTO) { allocBPD -= abProps.bottom.getValue(this); if (allocBPD < 0) { //TODO Fix absolute b-c layout, layout may need to be defferred until //after page breaking when the size of the containing box is known. /* Warning disabled due to a interpretation mistake. * See: http://marc.theaimsgroup.com/?l=fop-dev&m=113189981926163&w=2 log.error("The current combination of top and bottom properties results" + " in a negative extent for the block-container. 'bottom' may be" + " at most " + (allocBPD + abProps.bottom.getValue(this)) + " mpt," + " but was actually " + abProps.bottom.getValue(this) + " mpt." + " The nominal available height is " + availHeight + " mpt."); */ allocBPD = 0; } } else { if (allocBPD < 0) { /* Warning disabled due to a interpretation mistake. * See: http://marc.theaimsgroup.com/?l=fop-dev&m=113189981926163&w=2 log.error("The current combination of top and bottom properties results" + " in a negative extent for the block-container. 'top' may be" + " at most " + availHeight + " mpt," + " but was actually " + offset.y + " mpt." + " The nominal available height is " + availHeight + " mpt."); */ allocBPD = 0; } } } else { allocBPD = context.getStackLimitBP().getOpt(); if (!bpDirectionChanges) { autoHeight = true; } } } else { allocBPD = height.getValue(this); //this is the content-height allocBPD += getBPIndents(); } if (width.getEnum() == EN_AUTO) { int availWidth; if (isFixed()) { availWidth = (int)getCurrentPV().getViewArea().getWidth(); } else { availWidth = context.getRefIPD(); } allocIPD = availWidth; if (abProps.left.getEnum() != EN_AUTO) { allocIPD -= abProps.left.getValue(this); } if (abProps.right.getEnum() != EN_AUTO) { allocIPD -= abProps.right.getValue(this); if (allocIPD < 0) { /* Warning disabled due to a interpretation mistake. * See: http://marc.theaimsgroup.com/?l=fop-dev&m=113189981926163&w=2 log.error("The current combination of left and right properties results" + " in a negative extent for the block-container. 'right' may be" + " at most " + (allocIPD + abProps.right.getValue(this)) + " mpt," + " but was actually " + abProps.right.getValue(this) + " mpt." + " The nominal available width is " + availWidth + " mpt."); */ allocIPD = 0; } } else { if (allocIPD < 0) { /* Warning disabled due to a interpretation mistake. * See: http://marc.theaimsgroup.com/?l=fop-dev&m=113189981926163&w=2 log.error("The current combination of left and right properties results" + " in a negative extent for the block-container. 'left' may be" + " at most " + allocIPD + " mpt," + " but was actually " + abProps.left.getValue(this) + " mpt." + " The nominal available width is " + availWidth + " mpt."); */ allocIPD = 0; } if (bpDirectionChanges) { autoHeight = true; } } } else { allocIPD = width.getValue(this); //this is the content-width allocIPD += getIPIndents(); } vpContentBPD = allocBPD - getBPIndents(); setContentAreaIPD(allocIPD - getIPIndents()); contentRectOffsetX = 0; contentRectOffsetY = 0; updateRelDims(); MinOptMax range = MinOptMax.getInstance(relDims.ipd); BlockContainerBreaker breaker = new BlockContainerBreaker(this, range); breaker.doLayout((autoHeight ? 0 : relDims.bpd), autoHeight); boolean contentOverflows = breaker.isOverflow(); if (autoHeight) { //Update content BPD now that it is known int newHeight = breaker.deferredAlg.totalWidth; if (bpDirectionChanges) { setContentAreaIPD(newHeight); } else { vpContentBPD = newHeight; } updateRelDims(); } List<ListElement> returnList = new LinkedList<ListElement>(); if (!breaker.isEmpty()) { Position bcPosition = new BlockContainerPosition(this, breaker); returnList.add(new KnuthBox(0, notifyPos(bcPosition), false)); //TODO Maybe check for page overflow when autoHeight=true if (!autoHeight & (contentOverflows)) { BlockLevelEventProducer eventProducer = BlockLevelEventProducer.Provider.get( getBlockContainerFO().getUserAgent().getEventBroadcaster()); boolean canRecover = (getBlockContainerFO().getOverflow() != EN_ERROR_IF_OVERFLOW); eventProducer.viewportBPDOverflow(this, getBlockContainerFO().getName(), breaker.getOverflowAmount(), needClip(), canRecover, getBlockContainerFO().getLocator()); } // this handles the IPD (horizontal) overflow if (this.horizontalOverflow > 0) { BlockLevelEventProducer eventProducer = BlockLevelEventProducer.Provider .get(getBlockContainerFO().getUserAgent().getEventBroadcaster()); boolean canRecover = (getBlockContainerFO().getOverflow() != EN_ERROR_IF_OVERFLOW); eventProducer.viewportIPDOverflow(this, getBlockContainerFO().getName(), this.horizontalOverflow, needClip(), canRecover, getBlockContainerFO().getLocator()); } } setFinished(true); return returnList; } private void updateRelDims() { Rectangle2D rect = new Rectangle2D.Double( contentRectOffsetX, contentRectOffsetY, getContentAreaIPD(), this.vpContentBPD); relDims = new FODimension(0, 0); absoluteCTM = CTM.getCTMandRelDims( getBlockContainerFO().getReferenceOrientation(), getBlockContainerFO().getWritingMode(), rect, relDims); } private class BlockContainerPosition extends NonLeafPosition { private BlockContainerBreaker breaker; public BlockContainerPosition(LayoutManager lm, BlockContainerBreaker breaker) { super(lm, null); this.breaker = breaker; } public BlockContainerBreaker getBreaker() { return this.breaker; } } private class BlockContainerBreaker extends AbstractBreaker { private BlockContainerLayoutManager bclm; private MinOptMax ipd; //Info for deferred adding of areas private PageBreakingAlgorithm deferredAlg; private BlockSequence deferredOriginalList; private BlockSequence deferredEffectiveList; public BlockContainerBreaker(BlockContainerLayoutManager bclm, MinOptMax ipd) { this.bclm = bclm; this.ipd = ipd; } /** {@inheritDoc} */ protected void observeElementList(List elementList) { ElementListObserver.observe(elementList, "block-container", bclm.getBlockContainerFO().getId()); } /** {@inheritDoc} */ protected boolean isPartOverflowRecoveryActivated() { //For block-containers, this must be disabled because of wanted overflow. return false; } /** {@inheritDoc} */ protected boolean isSinglePartFavored() { return true; } public int getDifferenceOfFirstPart() { PageBreakPosition pbp = this.deferredAlg.getPageBreaks().getFirst(); return pbp.difference; } public boolean isOverflow() { return !isEmpty() && ((deferredAlg.getPageBreaks().size() > 1) || (deferredAlg.totalWidth - deferredAlg.totalShrink) > deferredAlg.getLineWidth()); } public int getOverflowAmount() { return (deferredAlg.totalWidth - deferredAlg.totalShrink) - deferredAlg.getLineWidth(); } protected LayoutManager getTopLevelLM() { return bclm; } protected LayoutContext createLayoutContext() { LayoutContext lc = super.createLayoutContext(); lc.setRefIPD(ipd.getOpt()); lc.setWritingMode(getBlockContainerFO().getWritingMode()); return lc; } protected List getNextKnuthElements(LayoutContext context, int alignment) { LayoutManager curLM; // currently active LM List<ListElement> returnList = new LinkedList<ListElement>(); while ((curLM = getChildLM()) != null) { LayoutContext childLC = makeChildLayoutContext(context); List returnedList = null; if (!curLM.isFinished()) { returnedList = curLM.getNextKnuthElements(childLC, alignment); } if (returnedList != null) { bclm.wrapPositionElements(returnedList, returnList); } } SpaceResolver.resolveElementList(returnList); setFinished(true); return returnList; } protected int getCurrentDisplayAlign() { return getBlockContainerFO().getDisplayAlign(); } protected boolean hasMoreContent() { return !isFinished(); } protected void addAreas(PositionIterator posIter, LayoutContext context) { AreaAdditionUtil.addAreas(bclm, posIter, context); } protected void doPhase3(PageBreakingAlgorithm alg, int partCount, BlockSequence originalList, BlockSequence effectiveList) { //Defer adding of areas until addAreas is called by the parent LM this.deferredAlg = alg; this.deferredOriginalList = originalList; this.deferredEffectiveList = effectiveList; } protected void finishPart(PageBreakingAlgorithm alg, PageBreakPosition pbp) { //nop for bclm } protected LayoutManager getCurrentChildLM() { return curChildLM; } public void addContainedAreas(LayoutContext layoutContext) { if (isEmpty()) { return; } //Rendering all parts (not just the first) at once for the case where the parts that //overflow should be visible. this.deferredAlg.removeAllPageBreaks(); this.addAreas(this.deferredAlg, 0, this.deferredAlg.getPageBreaks().size(), this.deferredOriginalList, this.deferredEffectiveList, LayoutContext.offspringOf(layoutContext)); } } private Point getAbsOffset() { int x = 0; int y = 0; if (abProps.left.getEnum() != EN_AUTO) { x = abProps.left.getValue(this); } else if (abProps.right.getEnum() != EN_AUTO && width.getEnum() != EN_AUTO) { x = getReferenceAreaIPD() - abProps.right.getValue(this) - width.getValue(this); } if (abProps.top.getEnum() != EN_AUTO) { y = abProps.top.getValue(this); } else if (abProps.bottom.getEnum() != EN_AUTO && height.getEnum() != EN_AUTO) { y = getReferenceAreaBPD() - abProps.bottom.getValue(this) - height.getValue(this); } return new Point(x, y); } /** {@inheritDoc} */ @Override public void addAreas(PositionIterator parentIter, LayoutContext layoutContext) { getParentArea(null); // if this will create the first block area in a page // and display-align is bottom or center, add space before if (layoutContext.getSpaceBefore() > 0) { addBlockSpacing(0.0, MinOptMax.getInstance(layoutContext.getSpaceBefore())); } LayoutManager childLM; LayoutManager lastLM = null; LayoutContext lc = LayoutContext.offspringOf(layoutContext); lc.setSpaceAdjust(layoutContext.getSpaceAdjust()); // set space after in the LayoutContext for children if (layoutContext.getSpaceAfter() > 0) { lc.setSpaceAfter(layoutContext.getSpaceAfter()); } BlockContainerPosition bcpos = null; PositionIterator childPosIter; // "unwrap" the NonLeafPositions stored in parentIter // and put them in a new list; List<Position> positionList = new LinkedList<Position>(); Position pos; Position firstPos = null; Position lastPos = null; while (parentIter.hasNext()) { pos = parentIter.next(); if (pos.getIndex() >= 0) { if (firstPos == null) { firstPos = pos; } lastPos = pos; } Position innerPosition = pos; if (pos instanceof NonLeafPosition) { innerPosition = pos.getPosition(); } if (pos instanceof BlockContainerPosition) { if (bcpos != null) { throw new IllegalStateException("Only one BlockContainerPosition allowed"); } bcpos = (BlockContainerPosition)pos; //Add child areas inside the reference area //bcpos.getBreaker().addContainedAreas(); } else if (innerPosition == null) { //ignore (probably a Position for a simple penalty between blocks) } else if (innerPosition.getLM() == this && !(innerPosition instanceof MappingPosition)) { // pos was created by this BlockLM and was inside a penalty // allowing or forbidding a page break // nothing to do } else { // innerPosition was created by another LM positionList.add(innerPosition); lastLM = innerPosition.getLM(); } } addId(); registerMarkers(true, isFirst(firstPos), isLast(lastPos)); if (bcpos == null) { // the Positions in positionList were inside the elements // created by the LineLM childPosIter = new PositionIterator(positionList.listIterator()); while ((childLM = childPosIter.getNextChildLM()) != null) { // set last area flag lc.setFlags(LayoutContext.LAST_AREA, (layoutContext.isLastArea() && childLM == lastLM)); lc.setStackLimitBP(layoutContext.getStackLimitBP()); // Add the line areas to Area childLM.addAreas(childPosIter, lc); } } else { //Add child areas inside the reference area bcpos.getBreaker().addContainedAreas(layoutContext); } registerMarkers(false, isFirst(firstPos), isLast(lastPos)); TraitSetter.addSpaceBeforeAfter(viewportBlockArea, layoutContext.getSpaceAdjust(), effSpaceBefore, effSpaceAfter); flush(); viewportBlockArea = null; referenceArea = null; resetSpaces(); notifyEndOfLayout(); } /** * Get the parent area for children of this block container. * This returns the current block container area * and creates it if required. * * {@inheritDoc} */ @Override public Area getParentArea(Area childArea) { if (referenceArea == null) { boolean switchedProgressionDirection = blockProgressionDirectionChanges(); boolean allowBPDUpdate = autoHeight && !switchedProgressionDirection; int level = getBlockContainerFO().getBidiLevel(); viewportBlockArea = new BlockViewport(allowBPDUpdate); viewportBlockArea.setChangeBarList(getChangeBarList()); viewportBlockArea.addTrait(Trait.IS_VIEWPORT_AREA, Boolean.TRUE); if (level >= 0) { viewportBlockArea.setBidiLevel(level); } viewportBlockArea.setIPD(getContentAreaIPD()); if (allowBPDUpdate) { viewportBlockArea.setBPD(0); } else { viewportBlockArea.setBPD(this.vpContentBPD); } transferForeignAttributes(viewportBlockArea); TraitSetter.setProducerID(viewportBlockArea, getBlockContainerFO().getId()); TraitSetter.setLayer(viewportBlockArea, getBlockContainerFO().getLayer()); TraitSetter.addBorders(viewportBlockArea, getBlockContainerFO().getCommonBorderPaddingBackground(), discardBorderBefore, discardBorderAfter, false, false, this); TraitSetter.addPadding(viewportBlockArea, getBlockContainerFO().getCommonBorderPaddingBackground(), discardPaddingBefore, discardPaddingAfter, false, false, this); TraitSetter.addMargins(viewportBlockArea, getBlockContainerFO().getCommonBorderPaddingBackground(), startIndent, endIndent, this); viewportBlockArea.setCTM(absoluteCTM); viewportBlockArea.setClip(needClip()); if (abProps.absolutePosition == EN_ABSOLUTE || abProps.absolutePosition == EN_FIXED) { Point offset = getAbsOffset(); viewportBlockArea.setXOffset(offset.x); viewportBlockArea.setYOffset(offset.y); } else { //nop } referenceArea = new Block(); referenceArea.setChangeBarList(getChangeBarList()); referenceArea.addTrait(Trait.IS_REFERENCE_AREA, Boolean.TRUE); if (level >= 0) { referenceArea.setBidiLevel(level); } TraitSetter.setProducerID(referenceArea, getBlockContainerFO().getId()); if (abProps.absolutePosition == EN_ABSOLUTE) { viewportBlockArea.setPositioning(Block.ABSOLUTE); } else if (abProps.absolutePosition == EN_FIXED) { viewportBlockArea.setPositioning(Block.FIXED); } // Set up dimensions // Must get dimensions from parent area /*Area parentArea =*/ parentLayoutManager.getParentArea(referenceArea); //int referenceIPD = parentArea.getIPD(); referenceArea.setIPD(relDims.ipd); // Get reference IPD from parentArea setCurrentArea(viewportBlockArea); // ??? for generic operations } return referenceArea; } /** * Add the child to the block container. * * {@inheritDoc} */ @Override public void addChildArea(Area childArea) { if (referenceArea != null) { referenceArea.addBlock((Block) childArea); } } /** * Force current area to be added to parent area. * {@inheritDoc} */ @Override protected void flush() { viewportBlockArea.addBlock(referenceArea, autoHeight); TraitSetter.addBackground(viewportBlockArea, getBlockContainerFO().getCommonBorderPaddingBackground(), this); super.flush(); } /** {@inheritDoc} */ @Override public int negotiateBPDAdjustment(int adj, KnuthElement lastElement) { // TODO Auto-generated method stub return 0; } /** {@inheritDoc} */ @Override public void discardSpace(KnuthGlue spaceGlue) { // TODO Auto-generated method stub } /** {@inheritDoc} */ @Override public KeepProperty getKeepTogetherProperty() { return getBlockContainerFO().getKeepTogether(); } /** {@inheritDoc} */ @Override public KeepProperty getKeepWithPreviousProperty() { return getBlockContainerFO().getKeepWithPrevious(); } /** {@inheritDoc} */ @Override public KeepProperty getKeepWithNextProperty() { return getBlockContainerFO().getKeepWithNext(); } /** * @return the BlockContainer node */ protected BlockContainer getBlockContainerFO() { return (BlockContainer) fobj; } // --------- Property Resolution related functions --------- // /** {@inheritDoc} */ @Override public boolean getGeneratesReferenceArea() { return true; } /** {@inheritDoc} */ @Override public boolean getGeneratesBlockArea() { return true; } /** {@inheritDoc} */ public boolean handleOverflow(int milliPoints) { if (milliPoints > this.horizontalOverflow) { this.horizontalOverflow = milliPoints; } return true; } }
⏎ org/apache/fop/layoutmgr/BlockContainerLayoutManager.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, 22038👍, 0💬
Popular Posts:
The Apache FontBox library is an open source Java tool to obtain low level information from font fil...
ANTLR is a powerful parser generator for multiple programming languages including Java. ANTLR contai...
What Is commons-collections4-4.4 .jar?commons-collections4-4.4 .jaris the JAR file for Apache Common...
Apache Log4j provides the interface that applications should code to and provides the adapter compon...
MP3SPI is a Java Service Provider Interface that adds MP3 (MPEG 1/2/2.5 Layer 1/2/3) audio format su...