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/BlockStackingLayoutManager.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: BlockStackingLayoutManager.java 1889102 2021-04-22 10:45:11Z ssteiner $ */ package org.apache.fop.layoutmgr; import java.util.LinkedList; import java.util.List; import java.util.ListIterator; 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.BlockParent; import org.apache.fop.fo.Constants; import org.apache.fop.fo.FObj; import org.apache.fop.fo.properties.BreakPropertySet; import org.apache.fop.fo.properties.CommonBorderPaddingBackground; import org.apache.fop.fo.properties.KeepProperty; import org.apache.fop.fo.properties.SpaceProperty; import org.apache.fop.layoutmgr.inline.InlineContainerLayoutManager; import org.apache.fop.layoutmgr.inline.InlineLayoutManager; import org.apache.fop.traits.MinOptMax; import org.apache.fop.util.ListUtil; /** * Base LayoutManager class for all areas which stack their child * areas in the block-progression direction, such as Flow, Block, ListBlock. */ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager implements BlockLevelLayoutManager { /** logging instance */ private static Log log = LogFactory.getLog(BlockStackingLayoutManager.class); /** parent area */ protected BlockParent parentArea; /** Value of the block-progression-unit (non-standard property) */ protected int bpUnit; /** space-before value adjusted for block-progression-unit handling */ protected int adjustedSpaceBefore; /** space-after value adjusted for block-progression-unit handling */ protected int adjustedSpaceAfter; /** Only used to store the original list when createUnitElements is called */ protected List<KnuthElement> storedList; /** Indicates whether break before has been served or not */ protected boolean breakBeforeServed; /** Indicates whether the first visible mark has been returned by this LM, yet */ protected boolean firstVisibleMarkServed; /** Reference IPD available */ protected int referenceIPD; /** the effective start-indent value */ protected int startIndent; /** the effective end-indent value */ protected int endIndent; /** * 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. */ protected MinOptMax foSpaceBefore; /** see foSpaceBefore */ protected MinOptMax foSpaceAfter; private Position auxiliaryPosition; private int contentAreaIPD; private boolean isRestartAtLM; /** * @param node the fo this LM deals with */ public BlockStackingLayoutManager(FObj node) { super(node); setGeneratesBlockArea(true); } /** * @return current area being filled */ protected BlockParent getCurrentArea() { return this.parentArea; } /** * Set the current area being filled. * @param parentArea the current area to be filled */ protected void setCurrentArea(BlockParent parentArea) { this.parentArea = parentArea; } /** * Add a block spacer for space before and space after a block. * This adds an empty Block area that acts as a block space. * * @param adjust the adjustment value * @param minoptmax the min/opt/max value of the spacing */ public void addBlockSpacing(double adjust, MinOptMax minoptmax) { int sp = TraitSetter.getEffectiveSpace(adjust, minoptmax); if (sp != 0) { Block spacer = new Block(); spacer.setChangeBarList(getChangeBarList()); spacer.setBPD(sp); parentLayoutManager.addChildArea(spacer); } } /** * Add the childArea to the passed area. * Called by child LayoutManager when it has filled one of its areas. * The LM should already have an Area in which to put the child. * See if the area will fit in the current area. * If so, add it. Otherwise initiate breaking. * @param childArea the area to add: will be some block-stacked Area. * @param parentArea the area in which to add the childArea */ protected void addChildToArea(Area childArea, BlockParent parentArea) { // This should be a block-level Area (Block in the generic sense) /* if (!(childArea instanceof Block)) { //log.error("Child not a Block in BlockStackingLM!"); } */ parentArea.addBlock((Block) childArea); flush(); // hand off current area to parent } /** * Add the childArea to the current area. * Called by child LayoutManager when it has filled one of its areas. * The LM should already have an Area in which to put the child. * See if the area will fit in the current area. * If so, add it. Otherwise initiate breaking. * @param childArea the area to add: will be some block-stacked Area. */ @Override public void addChildArea(Area childArea) { addChildToArea(childArea, getCurrentArea()); } /** * Force current area to be added to parent area. */ protected void flush() { if (getCurrentArea() != null) { parentLayoutManager.addChildArea(getCurrentArea()); } } /** @return a cached auxiliary Position instance used for things like spaces. */ protected Position getAuxiliaryPosition() { if (this.auxiliaryPosition == null) { this.auxiliaryPosition = new NonLeafPosition(this, null); } return this.auxiliaryPosition; } /** * @param len length in millipoints to span with bp units * @return the minimum integer n such that n * bpUnit >= len */ protected int neededUnits(int len) { return (int) Math.ceil((float)len / bpUnit); } /** * Determines and sets the content area IPD based on available reference area IPD, start- and * end-indent properties. * end-indent is adjusted based on overconstrained geometry rules, if necessary. * * @return the resulting content area IPD */ protected int updateContentAreaIPDwithOverconstrainedAdjust() { int ipd = referenceIPD - (startIndent + endIndent); if (ipd < 0) { //5.3.4, XSL 1.0, Overconstrained Geometry log.debug("Adjusting end-indent based on overconstrained geometry rules for " + fobj); BlockLevelEventProducer eventProducer = BlockLevelEventProducer.Provider.get( getFObj().getUserAgent().getEventBroadcaster()); eventProducer.overconstrainedAdjustEndIndent(this, getFObj().getName(), ipd, getFObj().getLocator()); endIndent += ipd; ipd = 0; //TODO Should we skip layout for a block that has ipd=0? } setContentAreaIPD(ipd); return ipd; } /** * Sets the content area IPD by directly supplying the value. * end-indent is adjusted based on overconstrained geometry rules, if necessary. * @param contentIPD the IPD of the content * @return the resulting content area IPD */ protected int updateContentAreaIPDwithOverconstrainedAdjust(int contentIPD) { int ipd = referenceIPD - (contentIPD + (startIndent + endIndent)); if (ipd < 0) { //5.3.4, XSL 1.0, Overconstrained Geometry log.debug("Adjusting end-indent based on overconstrained geometry rules for " + fobj); BlockLevelEventProducer eventProducer = BlockLevelEventProducer.Provider.get( getFObj().getUserAgent().getEventBroadcaster()); eventProducer.overconstrainedAdjustEndIndent(this, getFObj().getName(), ipd, getFObj().getLocator()); endIndent += ipd; } setContentAreaIPD(contentIPD); return contentIPD; } /** {@inheritDoc} */ @Override public List getNextKnuthElements(LayoutContext context, int alignment) { return getNextKnuthElements(context, alignment, null, null, null); } /** {@inheritDoc} */ @Override public List getNextKnuthElements(LayoutContext context, int alignment, Stack lmStack, Position restartPosition, LayoutManager restartAtLM) { isRestartAtLM = restartAtLM != null; referenceIPD = context.getRefIPD(); updateContentAreaIPDwithOverconstrainedAdjust(); boolean isRestart = (lmStack != null); boolean emptyStack = (!isRestart || lmStack.isEmpty()); List<ListElement> contentList = new LinkedList<ListElement>(); List<ListElement> elements = new LinkedList<ListElement>(); if (!breakBeforeServed(context, elements)) { // if this FO has break-before specified, and it // has not yet been processed, return now return elements; } addFirstVisibleMarks(elements, context, alignment); //Used to indicate a special break-after case when all content has already been generated. BreakElement forcedBreakAfterLast = null; LayoutContext childLC; List<ListElement> childElements; LayoutManager currentChildLM; if (isRestart) { if (emptyStack) { assert restartAtLM != null && restartAtLM.getParent() == this; currentChildLM = restartAtLM; } else { currentChildLM = (LayoutManager) lmStack.pop(); } setCurrentChildLM(currentChildLM); } else { currentChildLM = getChildLM(); } while (currentChildLM != null) { childLC = makeChildLayoutContext(context); if (!isRestart || emptyStack) { if (isRestart) { currentChildLM.reset(); // TODO won't work with forced breaks } childElements = getNextChildElements(currentChildLM, context, childLC, alignment, null, null, null); } else { // restart && non-empty LM stack childElements = getNextChildElements(currentChildLM, context, childLC, alignment, lmStack, restartPosition, restartAtLM); // once encountered, irrelevant for following child LMs emptyStack = true; } if (contentList.isEmpty()) { // propagate keep-with-previous up from the first child context.updateKeepWithPreviousPending(childLC.getKeepWithPreviousPending()); } // handle non-empty child if (childElements != null && !childElements.isEmpty()) { if (!contentList.isEmpty() && !ElementListUtils.startsWithForcedBreak(childElements)) { // there is a block handled by prevLM before the one // handled by curLM, and the one handled // by the current LM does not begin with a break addInBetweenBreak(contentList, context, childLC); } if (childElements.size() == 1 && ElementListUtils.startsWithForcedBreak(childElements)) { // a descendant of this block has break-before if (currentChildLM.isFinished() && !hasNextChildLM()) { // if there is no more content, make sure pending // marks are cleared forcedBreakAfterLast = (BreakElement) childElements.get(0); context.clearPendingMarks(); // break without adding the child elements break; } if (contentList.isEmpty()) { // empty fo:block: zero-length box makes sure the IDs and/or markers // are registered and borders/padding are painted. elements.add(makeAuxiliaryZeroWidthBox()); } // add the forced break contentList.addAll(childElements); // wrap position and return wrapPositionElements(contentList, elements); return elements; } else { // add all accumulated child elements contentList.addAll(childElements); if (ElementListUtils.endsWithForcedBreak(childElements)) { // a descendant of this block has break-after if (currentChildLM.isFinished() && !hasNextChildLM()) { // if there is no more content, make sure any // pending marks are cleared forcedBreakAfterLast = (BreakElement) ListUtil.removeLast(contentList); context.clearPendingMarks(); break; } //wrap positions and return wrapPositionElements(contentList, elements); return elements; } } context.updateKeepWithNextPending(childLC.getKeepWithNextPending()); } currentChildLM = getChildLM(); } if (contentList.isEmpty()) { if (forcedBreakAfterLast == null) { // empty fo:block: zero-length box makes sure the IDs and/or markers // are registered. elements.add(makeAuxiliaryZeroWidthBox()); } } else { // wrap child positions wrapPositionElements(contentList, elements); } addLastVisibleMarks(elements, context, alignment); if (forcedBreakAfterLast == null) { addKnuthElementsForBreakAfter(elements, context); } else { forcedBreakAfterLast.clearPendingMarks(); elements.add(forcedBreakAfterLast); } context.updateKeepWithNextPending(getKeepWithNext()); setFinished(true); return elements; } /** * Creates and initializes a {@link LayoutContext} to pass to the child LM * @param context the parent {@link LayoutContext} * @return a new child layout context */ protected LayoutContext makeChildLayoutContext(LayoutContext context) { LayoutContext childLC = LayoutContext.newInstance(); childLC.copyPendingMarksFrom(context); childLC.setStackLimitBP(context.getStackLimitBP()); childLC.setRefIPD(referenceIPD); return childLC; } /** * Checks if this LM's first "visible marks" (= borders, padding, spaces) have * already been processed, and if necessary, adds corresponding elements to * the specified list, and updates the given layout context accordingly. * @param elements the element list * @param context the layout context * @param alignment the vertical alignment */ protected void addFirstVisibleMarks(List<ListElement> elements, LayoutContext context, int alignment) { if (!firstVisibleMarkServed) { addKnuthElementsForSpaceBefore(elements, alignment); context.updateKeepWithPreviousPending(getKeepWithPrevious()); } addKnuthElementsForBorderPaddingBefore(elements, !firstVisibleMarkServed); firstVisibleMarkServed = true; //Spaces, border and padding to be repeated at each break addPendingMarks(context); } /** * Adds elements the LM's last/closing marks to the specified list, and * updates the layout context accordingly. * @param elements the element list * @param context the layout context * @param alignment the vertical alignment */ protected void addLastVisibleMarks(List<ListElement> elements, LayoutContext context, int alignment) { addKnuthElementsForBorderPaddingAfter(elements, true); addKnuthElementsForSpaceAfter(elements, alignment); // All child content processed. Only break-after can occur now, so... context.clearPendingMarks(); } /** * Check whether there is a break-before condition. If so, and * the specified {@code context} allows it, add the necessary elements * to the given {@code elements} list. * @param context the layout context * @param elements the element list * @return {@code false} if there is a break-before condition, and it has not been served; * {@code true} otherwise */ protected boolean breakBeforeServed(LayoutContext context, List<ListElement> elements) { if (!breakBeforeServed) { breakBeforeServed = true; if (!context.suppressBreakBefore()) { if (addKnuthElementsForBreakBefore(elements, context)) { return false; } } } return breakBeforeServed; } private KnuthBox makeZeroWidthBox() { return new KnuthBox(0, new NonLeafPosition(this, null), false); } private KnuthBox makeAuxiliaryZeroWidthBox() { return new KnuthBox(0, notifyPos(new Position(this)), true); } private KnuthPenalty makeZeroWidthPenalty(int penaltyValue) { return new KnuthPenalty(0, penaltyValue, false, new NonLeafPosition(this, null), false); } private KnuthGlue makeSpaceAdjustmentGlue(int width, Adjustment adjustmentClass, boolean isAuxiliary) { return new KnuthGlue(width, 0, 0, adjustmentClass, new NonLeafPosition(this, null), isAuxiliary); } /** * Gets the next set of child elements for the given childLM. * The default implementation basically copies the pending marks to the child layout context, * and subsequently calls the appropriate variant of {@code childLM.getNextKnuthElements()}, * passing it all relevant parameters. * @param childLM the current child LM * @param context the layout context * @param childLC the child layout context * @param alignment the vertical alignment * @param lmStack the stack of currently active LMs (if any) * @param restartPosition the position to restart from (if any) * @param restartAtLM the LM to restart from (if any) * @return list of elements corresponding to the content generated by childLM */ protected List<ListElement> getNextChildElements(LayoutManager childLM, LayoutContext context, LayoutContext childLC, int alignment, Stack<LayoutManager> lmStack, Position restartPosition, LayoutManager restartAtLM) { if (childLM == this.childLMs.get(0)) { childLC.setFlags(LayoutContext.SUPPRESS_BREAK_BEFORE); //Handled already by the parent (break collapsing, see above) } if (lmStack == null) { // route to default implementation, in case childLM does not provide // an override similar to this class return childLM.getNextKnuthElements(childLC, alignment); } else { return childLM.getNextKnuthElements(childLC, alignment, lmStack, restartPosition, restartAtLM); } } /** * Adds a break element to the content list between individual child elements. * @param contentList the content list * @param parentLC the parent layout context * @param childLC the currently active child layout context */ protected void addInBetweenBreak(List<ListElement> contentList, LayoutContext parentLC, LayoutContext childLC) { if (mustKeepTogether() || parentLC.isKeepWithNextPending() || childLC.isKeepWithPreviousPending()) { Keep keep = getKeepTogether(); //Handle pending keep-with-next keep = keep.compare(parentLC.getKeepWithNextPending()); parentLC.clearKeepWithNextPending(); //Handle pending keep-with-previous from child LM keep = keep.compare(childLC.getKeepWithPreviousPending()); childLC.clearKeepWithPreviousPending(); // add a penalty to forbid or discourage a break between blocks contentList.add(new BreakElement( new Position(this), keep.getPenalty(), keep.getContext(), parentLC)); return; } ListElement last = ListUtil.getLastListElement(contentList); if (last == null || last.isGlue()) { // the last element in contentList is a glue; // it is a feasible breakpoint, there is no need to add // a penalty log.warn("glue-type break possibility not handled properly, yet"); //TODO Does this happen? If yes, need to deal with border and padding //at the break possibility } else if (!ElementListUtils.endsWithNonInfinitePenalty(contentList)) { // TODO vh: this is hacky // The getNextKnuthElements method of TableCellLM must not be called // twice, otherwise some settings like indents or borders will be // counted several times and lead to a wrong output. Anyway the // getNextKnuthElements methods should be called only once eventually // (i.e., when multi-threading the code), even when there are forced // breaks. // If we add a break possibility after a forced break the // AreaAdditionUtil.addAreas method will act on a sequence starting // with a SpaceResolver.SpaceHandlingBreakPosition element, having no // LM associated to it. Thus it will stop early instead of adding // areas for following Positions. The above test aims at preventing // such a situation from occurring. add a null penalty to allow a break // between blocks // add a null penalty to allow a break between blocks contentList.add(new BreakElement( new Position(this), 0, Constants.EN_AUTO, parentLC)); } } /** {@inheritDoc} */ public int negotiateBPDAdjustment(int adj, KnuthElement lastElement) { assert (lastElement != null && lastElement.getPosition() != null); Position innerPosition = lastElement.getPosition().getPosition(); if (innerPosition == null && lastElement.isGlue()) { // this adjustment applies to space-before or space-after of this block if (((KnuthGlue) lastElement).getAdjustmentClass() == Adjustment.SPACE_BEFORE_ADJUSTMENT) { // this adjustment applies to space-before adjustedSpaceBefore += adj; } else { // this adjustment applies to space-after adjustedSpaceAfter += adj; } return adj; } else if (innerPosition instanceof MappingPosition) { // this block has block-progression-unit > 0: the adjustment can concern // - the space-before or space-after of this block, // - the line number of a descendant of this block MappingPosition mappingPos = (MappingPosition)innerPosition; if (lastElement.isGlue()) { // lastElement is a glue ListIterator storedListIterator = storedList.listIterator( mappingPos.getFirstIndex()); int newAdjustment = 0; while (storedListIterator.nextIndex() <= mappingPos.getLastIndex()) { KnuthElement storedElement = (KnuthElement)storedListIterator.next(); if (storedElement.isGlue()) { newAdjustment += ((BlockLevelLayoutManager)storedElement .getLayoutManager()).negotiateBPDAdjustment( adj - newAdjustment, storedElement); } } newAdjustment = (newAdjustment > 0 ? bpUnit * neededUnits(newAdjustment) : -bpUnit * neededUnits(-newAdjustment)); return newAdjustment; } else { // lastElement is a penalty: this means that the paragraph // has been split between consecutive pages: // this may involve a change in the number of lines KnuthPenalty storedPenalty = (KnuthPenalty) storedList.get(mappingPos.getLastIndex()); if (storedPenalty.getWidth() > 0) { // the original penalty has width > 0 return ((BlockLevelLayoutManager)storedPenalty.getLayoutManager()) .negotiateBPDAdjustment(storedPenalty.getWidth(), storedPenalty); } else { // the original penalty has width = 0 // the adjustment involves only the spaces before and after return adj; } } } else if (innerPosition != null && innerPosition.getLM() != this) { Position lastPosition = lastElement.getPosition(); assert (lastPosition instanceof NonLeafPosition); // this adjustment concerns another LM NonLeafPosition savedPos = (NonLeafPosition) lastPosition; lastElement.setPosition(innerPosition); int returnValue = ((BlockLevelLayoutManager) lastElement.getLayoutManager()) .negotiateBPDAdjustment(adj, lastElement); lastElement.setPosition(savedPos); return returnValue; } else { // this should never happen log.error("BlockLayoutManager.negotiateBPDAdjustment(): unexpected Position"); return 0; } } /** {@inheritDoc} */ public void discardSpace(KnuthGlue spaceGlue) { assert (spaceGlue != null && spaceGlue.getPosition() != null); Position mainPosition = spaceGlue.getPosition(); Position innerPosition = mainPosition.getPosition(); if (innerPosition == null || innerPosition.getLM() == this) { // if this block has block-progression-unit > 0, innerPosition can be // a MappingPosition // spaceGlue represents space before or space after of this block if (spaceGlue.getAdjustmentClass() == Adjustment.SPACE_BEFORE_ADJUSTMENT) { // space-before must be discarded adjustedSpaceBefore = 0; foSpaceBefore = MinOptMax.ZERO; } else { // space-after must be discarded adjustedSpaceAfter = 0; foSpaceAfter = MinOptMax.ZERO; //TODO Why are both cases handled in the same way? } } else { assert (mainPosition instanceof NonLeafPosition); // this element was not created by this BlockLM NonLeafPosition savedPos = (NonLeafPosition) mainPosition; spaceGlue.setPosition(innerPosition); ((BlockLevelLayoutManager) spaceGlue.getLayoutManager()).discardSpace(spaceGlue); spaceGlue.setPosition(savedPos); } } /** {@inheritDoc} */ @Override public List getChangedKnuthElements(List oldList, int alignment) { ListIterator<KnuthElement> oldListIterator = oldList.listIterator(); KnuthElement currElement = null; KnuthElement prevElement = null; List<KnuthElement> returnedList = new LinkedList<KnuthElement>(); List<KnuthElement> returnList = new LinkedList<KnuthElement>(); int fromIndex = 0; // "unwrap" the Positions stored in the elements KnuthElement oldElement; while (oldListIterator.hasNext()) { oldElement = oldListIterator.next(); assert oldElement.getPosition() != null; Position innerPosition = oldElement.getPosition().getPosition(); if (innerPosition != null) { // oldElement was created by a descendant oldElement.setPosition(innerPosition); } else { // oldElement was created by this LM: // modify its position in order to recognize it was not created // by a child oldElement.setPosition(new Position(this)); } } // create the iterator ListIterator<KnuthElement> workListIterator = oldList.listIterator(); while (workListIterator.hasNext()) { currElement = workListIterator.next(); if (prevElement != null && prevElement.getLayoutManager() != currElement.getLayoutManager()) { // prevElement is the last element generated by the same LM BlockLevelLayoutManager prevLM = (BlockLevelLayoutManager)prevElement.getLayoutManager(); BlockLevelLayoutManager currLM = (BlockLevelLayoutManager)currElement.getLayoutManager(); boolean somethingAdded = false; if (prevLM != this) { returnedList.addAll( prevLM.getChangedKnuthElements( oldList.subList(fromIndex, workListIterator.previousIndex()), alignment)); somethingAdded = true; } else { // do nothing } fromIndex = workListIterator.previousIndex(); /* * TODO: why are KnuthPenalties added here, * while in getNextKE they were changed to BreakElements? */ // there is another block after this one if (somethingAdded && (this.mustKeepTogether() || prevLM.mustKeepWithNext() || currLM.mustKeepWithPrevious())) { // add an infinite penalty to forbid a break between blocks returnedList.add(makeZeroWidthPenalty(KnuthPenalty.INFINITE)); } else if (somethingAdded && !ListUtil.getLast(returnedList).isGlue()) { // add a null penalty to allow a break between blocks returnedList.add(makeZeroWidthPenalty(KnuthPenalty.INFINITE)); } } prevElement = currElement; } if (currElement != null) { LayoutManager currLM = currElement.getLayoutManager(); if (currLM != this) { returnedList.addAll(currLM.getChangedKnuthElements( oldList.subList(fromIndex, oldList.size()), alignment)); } else { // there are no more elements to add // remove the last penalty added to returnedList if (!returnedList.isEmpty()) { ListUtil.removeLast(returnedList); } } } // append elements representing space-before boolean spaceBeforeIsConditional = true; if (fobj instanceof org.apache.fop.fo.flow.Block) { spaceBeforeIsConditional = getSpaceBeforeProperty().isDiscard(); } if (adjustedSpaceBefore != 0) { if (!spaceBeforeIsConditional) { // add elements to prevent the glue to be discarded returnList.add(makeZeroWidthBox()); returnList.add(makeZeroWidthPenalty(KnuthPenalty.INFINITE)); } returnList.add(makeSpaceAdjustmentGlue(adjustedSpaceBefore, Adjustment.SPACE_BEFORE_ADJUSTMENT, false)); } // "wrap" the Position stored in each element of returnedList // and add elements to returnList for (KnuthElement el : returnedList) { el.setPosition(new NonLeafPosition(this, el.getPosition())); returnList.add(el); } // append elements representing space-after boolean spaceAfterIsConditional = true; if (fobj instanceof org.apache.fop.fo.flow.Block) { spaceAfterIsConditional = getSpaceAfterProperty().isDiscard(); } if (adjustedSpaceAfter != 0) { if (!spaceAfterIsConditional) { returnList.add(makeZeroWidthPenalty(KnuthPenalty.INFINITE)); } returnList.add(makeSpaceAdjustmentGlue(adjustedSpaceAfter, Adjustment.SPACE_AFTER_ADJUSTMENT, spaceAfterIsConditional)); if (!spaceAfterIsConditional) { returnList.add(makeZeroWidthBox()); } } return returnList; } /** * Retrieves and returns the keep-together strength from the parent element. * @return the keep-together strength */ protected Keep getParentKeepTogether() { Keep keep = Keep.KEEP_AUTO; if (getParent() instanceof BlockLevelLayoutManager) { keep = ((BlockLevelLayoutManager)getParent()).getKeepTogether(); } else if (getParent() instanceof InlineLayoutManager) { if (((InlineLayoutManager) getParent()).mustKeepTogether()) { keep = Keep.KEEP_ALWAYS; } //TODO Fix me //strength = ((InlineLayoutManager) getParent()).getKeepTogetherStrength(); } return keep; } /** {@inheritDoc} */ public boolean mustKeepTogether() { return !getKeepTogether().isAuto(); } /** {@inheritDoc} */ public boolean mustKeepWithPrevious() { return !getKeepWithPrevious().isAuto(); } /** {@inheritDoc} */ public boolean mustKeepWithNext() { return !getKeepWithNext().isAuto(); } /** {@inheritDoc} */ public Keep getKeepTogether() { Keep keep = Keep.getKeep(getKeepTogetherProperty()); keep = keep.compare(getParentKeepTogether()); if (getFObj().isForceKeepTogether()) { keep = Keep.KEEP_ALWAYS; } return keep; } /** {@inheritDoc} */ public Keep getKeepWithPrevious() { return Keep.getKeep(getKeepWithPreviousProperty()); } /** {@inheritDoc} */ public Keep getKeepWithNext() { return Keep.getKeep(getKeepWithNextProperty()); } /** * {@inheritDoc} * Default implementation throws a {@link IllegalStateException}. * Must be implemented by the subclass, if applicable. */ public KeepProperty getKeepTogetherProperty() { throw new IllegalStateException(); } /** * {@inheritDoc} * Default implementation throws a {@link IllegalStateException}. * Must be implemented by the subclass, if applicable. */ public KeepProperty getKeepWithPreviousProperty() { throw new IllegalStateException(); } /** * {@inheritDoc} * Default implementation throws a {@link IllegalStateException}. * Must be implemented by the subclass, if applicable. */ public KeepProperty getKeepWithNextProperty() { throw new IllegalStateException(); } /** * Adds the unresolved elements for border and padding to a layout context so break * possibilities can be properly constructed. * @param context the layout context */ protected void addPendingMarks(LayoutContext context) { CommonBorderPaddingBackground borderAndPadding = getBorderPaddingBackground(); if (borderAndPadding != null) { if (borderAndPadding.getBorderBeforeWidth(false) > 0) { context.addPendingBeforeMark(new BorderElement( getAuxiliaryPosition(), borderAndPadding.getBorderInfo( CommonBorderPaddingBackground.BEFORE).getWidth(), RelSide.BEFORE, false, false, this)); } if (borderAndPadding.getPaddingBefore(false, this) > 0) { context.addPendingBeforeMark(new PaddingElement( getAuxiliaryPosition(), borderAndPadding.getPaddingLengthProperty( CommonBorderPaddingBackground.BEFORE), RelSide.BEFORE, false, false, this)); } if (borderAndPadding.getBorderAfterWidth(false) > 0) { context.addPendingAfterMark(new BorderElement( getAuxiliaryPosition(), borderAndPadding.getBorderInfo( CommonBorderPaddingBackground.AFTER).getWidth(), RelSide.AFTER, false, false, this)); } if (borderAndPadding.getPaddingAfter(false, this) > 0) { context.addPendingAfterMark(new PaddingElement( getAuxiliaryPosition(), borderAndPadding.getPaddingLengthProperty( CommonBorderPaddingBackground.AFTER), RelSide.AFTER, false, false, this)); } } } /** @return the border, padding and background info structure */ private CommonBorderPaddingBackground getBorderPaddingBackground() { if (fobj instanceof org.apache.fop.fo.flow.Block) { return ((org.apache.fop.fo.flow.Block)fobj) .getCommonBorderPaddingBackground(); } else if (fobj instanceof org.apache.fop.fo.flow.BlockContainer) { return ((org.apache.fop.fo.flow.BlockContainer)fobj) .getCommonBorderPaddingBackground(); } else if (fobj instanceof org.apache.fop.fo.flow.ListBlock) { return ((org.apache.fop.fo.flow.ListBlock)fobj) .getCommonBorderPaddingBackground(); } else if (fobj instanceof org.apache.fop.fo.flow.ListItem) { return ((org.apache.fop.fo.flow.ListItem)fobj) .getCommonBorderPaddingBackground(); } else if (fobj instanceof org.apache.fop.fo.flow.table.Table) { return ((org.apache.fop.fo.flow.table.Table)fobj) .getCommonBorderPaddingBackground(); } else { return null; } } /** @return the space-before property */ protected SpaceProperty getSpaceBeforeProperty() { if (fobj instanceof org.apache.fop.fo.flow.Block) { return ((org.apache.fop.fo.flow.Block)fobj) .getCommonMarginBlock().spaceBefore; } else if (fobj instanceof org.apache.fop.fo.flow.BlockContainer) { return ((org.apache.fop.fo.flow.BlockContainer)fobj) .getCommonMarginBlock().spaceBefore; } else if (fobj instanceof org.apache.fop.fo.flow.ListBlock) { return ((org.apache.fop.fo.flow.ListBlock)fobj) .getCommonMarginBlock().spaceBefore; } else if (fobj instanceof org.apache.fop.fo.flow.ListItem) { return ((org.apache.fop.fo.flow.ListItem)fobj) .getCommonMarginBlock().spaceBefore; } else if (fobj instanceof org.apache.fop.fo.flow.table.Table) { return ((org.apache.fop.fo.flow.table.Table)fobj) .getCommonMarginBlock().spaceBefore; } else { return null; } } /** @return the space-after property */ protected SpaceProperty getSpaceAfterProperty() { if (fobj instanceof org.apache.fop.fo.flow.Block) { return ((org.apache.fop.fo.flow.Block)fobj) .getCommonMarginBlock().spaceAfter; } else if (fobj instanceof org.apache.fop.fo.flow.BlockContainer) { return ((org.apache.fop.fo.flow.BlockContainer)fobj) .getCommonMarginBlock().spaceAfter; } else if (fobj instanceof org.apache.fop.fo.flow.ListBlock) { return ((org.apache.fop.fo.flow.ListBlock)fobj) .getCommonMarginBlock().spaceAfter; } else if (fobj instanceof org.apache.fop.fo.flow.ListItem) { return ((org.apache.fop.fo.flow.ListItem)fobj) .getCommonMarginBlock().spaceAfter; } else if (fobj instanceof org.apache.fop.fo.flow.table.Table) { return ((org.apache.fop.fo.flow.table.Table)fobj) .getCommonMarginBlock().spaceAfter; } else { return null; } } /** * Creates Knuth elements for before border padding and adds them to the return list. * @param returnList return list to add the additional elements to * @param isFirst true if this is the first time a layout manager instance needs to generate * border and padding */ protected void addKnuthElementsForBorderPaddingBefore(List returnList, boolean isFirst) { //Border and Padding (before) CommonBorderPaddingBackground borderAndPadding = getBorderPaddingBackground(); if (borderAndPadding != null) { if (borderAndPadding.getBorderBeforeWidth(false) > 0) { returnList.add(new BorderElement( getAuxiliaryPosition(), borderAndPadding.getBorderInfo(CommonBorderPaddingBackground.BEFORE) .getWidth(), RelSide.BEFORE, isFirst, false, this)); } if (borderAndPadding.getPaddingBefore(false, this) > 0) { returnList.add(new PaddingElement( getAuxiliaryPosition(), borderAndPadding.getPaddingLengthProperty( CommonBorderPaddingBackground.BEFORE), RelSide.BEFORE, isFirst, false, this)); } } } /** * Creates Knuth elements for after border padding and adds them to the return list. * @param returnList return list to add the additional elements to * @param isLast true if this is the last time a layout manager instance needs to generate * border and padding */ protected void addKnuthElementsForBorderPaddingAfter(List returnList, boolean isLast) { //Border and Padding (after) CommonBorderPaddingBackground borderAndPadding = getBorderPaddingBackground(); if (borderAndPadding != null) { if (borderAndPadding.getPaddingAfter(false, this) > 0) { returnList.add(new PaddingElement( getAuxiliaryPosition(), borderAndPadding.getPaddingLengthProperty( CommonBorderPaddingBackground.AFTER), RelSide.AFTER, false, isLast, this)); } if (borderAndPadding.getBorderAfterWidth(false) > 0) { returnList.add(new BorderElement( getAuxiliaryPosition(), borderAndPadding.getBorderInfo(CommonBorderPaddingBackground.AFTER) .getWidth(), RelSide.AFTER, false, isLast, this)); } } } /** * Creates Knuth elements for break-before and adds them to the return list. * @param returnList return list to add the additional elements to * @param context the layout context * @return true if an element has been added due to a break-before. */ protected boolean addKnuthElementsForBreakBefore(List returnList, LayoutContext context) { int breakBefore = getBreakBefore(); if (breakBefore == EN_PAGE || breakBefore == EN_COLUMN || breakBefore == EN_EVEN_PAGE || breakBefore == EN_ODD_PAGE) { // return a penalty element, representing a forced page break returnList.add(new BreakElement(getAuxiliaryPosition(), 0, -KnuthElement.INFINITE, breakBefore, context)); return true; } else { return false; } } /** * Returns the highest priority break-before value on this layout manager or its * relevant descendants. * * @return the break-before value (Constants.EN_*) * @see BreakOpportunity#getBreakBefore() */ public int getBreakBefore() { return BreakOpportunityHelper.getBreakBefore(this); } /** * Creates Knuth elements for break-after and adds them to the return list. * @param returnList return list to add the additional elements to * @param context the layout context * @return true if an element has been added due to a break-after. */ protected boolean addKnuthElementsForBreakAfter(List returnList, LayoutContext context) { int breakAfter = -1; if (fobj instanceof BreakPropertySet) { breakAfter = ((BreakPropertySet)fobj).getBreakAfter(); } if (breakAfter == EN_PAGE || breakAfter == EN_COLUMN || breakAfter == EN_EVEN_PAGE || breakAfter == EN_ODD_PAGE) { // add a penalty element, representing a forced page break returnList.add(new BreakElement(getAuxiliaryPosition(), 0, -KnuthElement.INFINITE, breakAfter, context)); return true; } else { return false; } } /** * Creates Knuth elements for space-before and adds them to the return list. * @param returnList return list to add the additional elements to * @param alignment vertical alignment */ protected void addKnuthElementsForSpaceBefore(List returnList, int alignment) { SpaceProperty spaceBefore = getSpaceBeforeProperty(); // append elements representing space-before if (spaceBefore != null && !(spaceBefore.getMinimum(this).getLength().getValue(this) == 0 && spaceBefore.getMaximum(this).getLength().getValue(this) == 0)) { returnList.add(new SpaceElement(getAuxiliaryPosition(), spaceBefore, RelSide.BEFORE, true, false, this)); } } /** * Creates Knuth elements for space-after and adds them to the return list. * @param returnList return list to add the additional elements to * @param alignment vertical alignment */ protected void addKnuthElementsForSpaceAfter(List returnList, int alignment) { SpaceProperty spaceAfter = getSpaceAfterProperty(); // append elements representing space-after if (spaceAfter != null && !(spaceAfter.getMinimum(this).getLength().getValue(this) == 0 && spaceAfter.getMaximum(this).getLength().getValue(this) == 0)) { returnList.add(new SpaceElement(getAuxiliaryPosition(), spaceAfter, RelSide.AFTER, false, true, this)); } } /** A mapping position. */ protected static class MappingPosition extends Position { private int firstIndex; private int lastIndex; /** * Construct mapping position. * @param lm layout manager * @param first position * @param last position */ public MappingPosition(LayoutManager lm, int first, int last) { super(lm); firstIndex = first; lastIndex = last; } /** @return first index */ public int getFirstIndex() { return firstIndex; } /** @return last index */ public int getLastIndex() { return lastIndex; } } /** * "wrap" the Position inside each element moving the elements from * SourceList to targetList * @param sourceList source list * @param targetList target list receiving the wrapped position elements */ protected void wrapPositionElements(List sourceList, List targetList) { wrapPositionElements(sourceList, targetList, false); } /** * "wrap" the Position inside each element moving the elements from * SourceList to targetList * @param sourceList source list * @param targetList target list receiving the wrapped position elements * @param force if true, every Position is wrapped regardless of its LM of origin */ protected void wrapPositionElements(List sourceList, List targetList, boolean force) { ListIterator listIter = sourceList.listIterator(); Object tempElement; while (listIter.hasNext()) { tempElement = listIter.next(); if (tempElement instanceof ListElement) { wrapPositionElement( (ListElement) tempElement, targetList, force); } else if (tempElement instanceof List) { wrapPositionElements( (List) tempElement, targetList, force); } } } /** * "wrap" the Position inside the given element and add it to the target list. * @param el the list element * @param targetList target list receiving the wrapped position elements * @param force if true, every Position is wrapped regardless of its LM of origin */ protected void wrapPositionElement(ListElement el, List targetList, boolean force) { if (force || el.getLayoutManager() != this) { el.setPosition(notifyPos(new NonLeafPosition(this, el.getPosition()))); } targetList.add(el); } /** @return the sum of start-indent and end-indent */ protected int getIPIndents() { return startIndent + endIndent; } /** * Returns the IPD of the content area * @return the IPD of the content area */ @Override public int getContentAreaIPD() { return contentAreaIPD; } /** * Sets the IPD of the content area * @param contentAreaIPD the IPD of the content area */ protected void setContentAreaIPD(int contentAreaIPD) { this.contentAreaIPD = contentAreaIPD; } /** * Returns the BPD of the content area * @return the BPD of the content area */ @Override public int getContentAreaBPD() { return -1; } /** {@inheritDoc} */ @Override public void reset() { super.reset(); breakBeforeServed = false; firstVisibleMarkServed = false; // TODO startIndent, endIndent } /** * Whether this LM can handle horizontal overflow error messages (only a BlockContainerLayoutManager can). * @param milliPoints horizontal overflow * @return true if handled by a BlockContainerLayoutManager */ public boolean handleOverflow(int milliPoints) { if (getParent() instanceof BlockStackingLayoutManager) { return ((BlockStackingLayoutManager) getParent()).handleOverflow(milliPoints); } else if (getParent() instanceof InlineContainerLayoutManager) { return ((InlineContainerLayoutManager) getParent()).handleOverflow(milliPoints); } return false; } public boolean isRestartAtLM() { return isRestartAtLM; } }
⏎ org/apache/fop/layoutmgr/BlockStackingLayoutManager.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, 59277👍, 0💬
Popular Posts:
What Is fop.jar? I got it from the fop-2.7-bin.zip. fop.jar in fop-2.7-bin.zip is the JAR file for F...
XOM™ is a new XML object model. It is an open source (LGPL), tree-based API for processing XML with ...
commons-collections4-4.4 -sources.jaris the source JAR file for Apache Commons Collections 4.2, whic...
JDK 11 jrt-fs.jar is the JAR file for JDK 11 JRT-FS (Java RunTime - File System) defined in the "jdk...
Apache Commons Codec library provides implementations of common encoders and decoders such as Base64...