From 64e7cf871471538b8591d6647575d107dd98b3ec Mon Sep 17 00:00:00 2001 From: Maximilian Berger Date: Mon, 9 Jun 2008 14:15:38 +0000 Subject: [PATCH] Replaced LinkedList with generic List interface git-svn-id: https://svn.apache.org/repos/asf/xmlgraphics/fop/trunk@665699 13f79535-47bb-0310-9956-ffa450edef68 --- .../fop/fo/flow/table/PrimaryGridUnit.java | 6 +- .../apache/fop/layoutmgr/AbstractBreaker.java | 10 +-- .../fop/layoutmgr/AbstractLayoutManager.java | 6 +- .../BlockContainerLayoutManager.java | 32 +++++----- .../fop/layoutmgr/BlockLayoutManager.java | 2 +- .../layoutmgr/BlockStackingLayoutManager.java | 61 ++++++++++--------- .../fop/layoutmgr/ElementListUtils.java | 14 ++--- .../fop/layoutmgr/FlowLayoutManager.java | 17 +++--- .../apache/fop/layoutmgr/KnuthBlockBox.java | 17 +++--- .../apache/fop/layoutmgr/LayoutManager.java | 5 +- .../org/apache/fop/layoutmgr/PageBreaker.java | 6 +- .../fop/layoutmgr/PageBreakingAlgorithm.java | 6 +- .../apache/fop/layoutmgr/SpaceResolver.java | 2 +- .../layoutmgr/StaticContentLayoutManager.java | 28 +++++---- .../inline/AbstractGraphicsLayoutManager.java | 4 +- .../inline/CharacterLayoutManager.java | 4 +- .../inline/ContentLayoutManager.java | 14 ++--- .../inline/FootnoteLayoutManager.java | 12 ++-- .../layoutmgr/inline/InlineLayoutManager.java | 15 ++--- .../inline/InlineStackingLayoutManager.java | 2 +- .../layoutmgr/inline/LeaderLayoutManager.java | 8 +-- .../inline/LeafNodeLayoutManager.java | 4 +- .../layoutmgr/inline/LineLayoutManager.java | 24 ++++---- .../layoutmgr/inline/TextLayoutManager.java | 12 ++-- .../list/ListBlockLayoutManager.java | 6 +- .../list/ListItemContentLayoutManager.java | 2 +- .../layoutmgr/list/ListItemLayoutManager.java | 23 ++++--- .../table/RowGroupLayoutManager.java | 6 +- .../table/TableCellLayoutManager.java | 23 ++++--- .../layoutmgr/table/TableLayoutManager.java | 8 +-- 30 files changed, 195 insertions(+), 184 deletions(-) diff --git a/src/java/org/apache/fop/fo/flow/table/PrimaryGridUnit.java b/src/java/org/apache/fop/fo/flow/table/PrimaryGridUnit.java index 55bcfa44e..915208e2d 100644 --- a/src/java/org/apache/fop/fo/flow/table/PrimaryGridUnit.java +++ b/src/java/org/apache/fop/fo/flow/table/PrimaryGridUnit.java @@ -38,7 +38,7 @@ public class PrimaryGridUnit extends GridUnit { /** Cell layout manager. */ private TableCellLayoutManager cellLM; /** List of Knuth elements representing the contents of the cell. */ - private LinkedList elements; + private List elements; /** Index of the row where this cell starts. */ private int rowIndex; @@ -106,11 +106,11 @@ public class PrimaryGridUnit extends GridUnit { * * @param elements a list of ListElement (?) */ - public void setElements(LinkedList elements) { + public void setElements(List elements) { this.elements = elements; } - public LinkedList getElements() { + public List getElements() { return this.elements; } diff --git a/src/java/org/apache/fop/layoutmgr/AbstractBreaker.java b/src/java/org/apache/fop/layoutmgr/AbstractBreaker.java index 4ef0579f2..6f204383d 100644 --- a/src/java/org/apache/fop/layoutmgr/AbstractBreaker.java +++ b/src/java/org/apache/fop/layoutmgr/AbstractBreaker.java @@ -211,7 +211,7 @@ public abstract class AbstractBreaker { * getNextKnuthElements() implementation(s) that are to be called. * @return LinkedList of Knuth elements. */ - protected abstract LinkedList getNextKnuthElements(LayoutContext context, int alignment); + protected abstract List getNextKnuthElements(LayoutContext context, int alignment); /** @return true if there's no content that could be handled. */ public boolean isEmpty() { @@ -549,7 +549,7 @@ public abstract class AbstractBreaker { childLC.signalSpanChange(Constants.NOT_SET); BlockSequence blockList; - LinkedList returnedList = getNextKnuthElements(childLC, alignment); + List returnedList = getNextKnuthElements(childLC, alignment); if (returnedList != null) { if (returnedList.size() == 0) { nextSequenceStartsOn = handleSpanChange(childLC, nextSequenceStartsOn); @@ -561,8 +561,10 @@ public abstract class AbstractBreaker { nextSequenceStartsOn = handleSpanChange(childLC, nextSequenceStartsOn); Position breakPosition = null; - if (((KnuthElement) returnedList.getLast()).isForcedBreak()) { - KnuthPenalty breakPenalty = (KnuthPenalty)returnedList.removeLast(); + if (((KnuthElement) returnedList.get(returnedList.size() - 1)) + .isForcedBreak()) { + KnuthPenalty breakPenalty = (KnuthPenalty) returnedList + .remove(returnedList.size() - 1); breakPosition = breakPenalty.getPosition(); switch (breakPenalty.getBreakClass()) { case Constants.EN_PAGE: diff --git a/src/java/org/apache/fop/layoutmgr/AbstractLayoutManager.java b/src/java/org/apache/fop/layoutmgr/AbstractLayoutManager.java index 3f2143bae..13ea66d1f 100644 --- a/src/java/org/apache/fop/layoutmgr/AbstractLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/AbstractLayoutManager.java @@ -20,14 +20,12 @@ package org.apache.fop.layoutmgr; import java.util.ArrayList; -import java.util.LinkedList; import java.util.List; import java.util.ListIterator; import java.util.Map; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; - import org.apache.fop.area.Area; import org.apache.fop.area.PageViewport; import org.apache.fop.fo.Constants; @@ -152,7 +150,7 @@ public abstract class AbstractLayoutManager extends AbstractBaseLayoutManager } /** {@inheritDoc} */ - public LinkedList getNextKnuthElements(LayoutContext context, + public List getNextKnuthElements(LayoutContext context, int alignment) { log.warn("null implementation of getNextKnuthElements() called!"); setFinished(true); @@ -160,7 +158,7 @@ public abstract class AbstractLayoutManager extends AbstractBaseLayoutManager } /** {@inheritDoc} */ - public LinkedList getChangedKnuthElements(List oldList, + public List getChangedKnuthElements(List oldList, int alignment) { log.warn("null implementation of getChangeKnuthElement() called!"); return null; diff --git a/src/java/org/apache/fop/layoutmgr/BlockContainerLayoutManager.java b/src/java/org/apache/fop/layoutmgr/BlockContainerLayoutManager.java index 0e6c2cb40..22d5fb941 100644 --- a/src/java/org/apache/fop/layoutmgr/BlockContainerLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/BlockContainerLayoutManager.java @@ -189,7 +189,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager } /** {@inheritDoc} */ - public LinkedList getNextKnuthElements(LayoutContext context, int alignment) { + public List getNextKnuthElements(LayoutContext context, int alignment) { resetSpaces(); if (isAbsoluteOrFixed()) { return getNextKnuthElementsAbsolute(context, alignment); @@ -247,9 +247,9 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager MinOptMax stackLimit = new MinOptMax(relDims.bpd); - LinkedList returnedList; - LinkedList contentList = new LinkedList(); - LinkedList returnList = new LinkedList(); + List returnedList; + List contentList = new LinkedList(); + List returnList = new LinkedList(); if (!breakBeforeServed) { try { @@ -291,7 +291,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager childLC.clearKeepWithPreviousPending(); } if (returnedList.size() == 1 - && ((ListElement)returnedList.getFirst()).isForcedBreak()) { + && ((ListElement)returnedList.get(0)).isForcedBreak()) { // a descendant of this block has break-before /* if (returnList.size() == 0) { @@ -321,7 +321,8 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager //Avoid NoSuchElementException below (happens with empty blocks) continue; } - if (((ListElement)returnedList.getLast()).isForcedBreak()) { + if (((ListElement) returnedList + .get(returnedList.size() - 1)).isForcedBreak()) { // a descendant of this block has break-after if (curLM.isFinished()) { // there is no other content in this block; @@ -392,7 +393,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager return returnList; } - private LinkedList getNextKnuthElementsAbsolute(LayoutContext context, int alignment) { + private List getNextKnuthElementsAbsolute(LayoutContext context, int alignment) { autoHeight = false; boolean switchedProgressionDirection @@ -515,7 +516,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager } updateRelDims(0, 0, false); } - LinkedList returnList = new LinkedList(); + List returnList = new LinkedList(); if (!breaker.isEmpty()) { Position bcPosition = new BlockContainerPosition(this, breaker); returnList.add(new KnuthBox(0, notifyPos(bcPosition), false)); @@ -622,9 +623,9 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager return lc; } - protected LinkedList getNextKnuthElements(LayoutContext context, int alignment) { + protected List getNextKnuthElements(LayoutContext context, int alignment) { LayoutManager curLM; // currently active LM - LinkedList returnList = new LinkedList(); + List returnList = new LinkedList(); while ((curLM = getChildLM()) != null) { LayoutContext childLC = new LayoutContext(0); @@ -632,7 +633,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager childLC.setRefIPD(context.getRefIPD()); childLC.setWritingMode(getBlockContainerFO().getWritingMode()); - LinkedList returnedList = null; + List returnedList = null; if (!curLM.isFinished()) { returnedList = curLM.getNextKnuthElements(childLC, alignment); } @@ -723,7 +724,7 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager // "unwrap" the NonLeafPositions stored in parentIter // and put them in a new list; - LinkedList positionList = new LinkedList(); + List positionList = new LinkedList(); Position pos; boolean bSpaceBefore = false; boolean bSpaceAfter = false; @@ -798,10 +799,11 @@ public class BlockContainerLayoutManager extends BlockStackingLayoutManager // // the last item inside positionList is a Position; // // this means that the paragraph has been split // // between consecutive pages - LinkedList splitList = new LinkedList(); + List splitList = new LinkedList(); int splitLength = 0; - int iFirst = ((MappingPosition) positionList.getFirst()).getFirstIndex(); - int iLast = ((MappingPosition) positionList.getLast()).getLastIndex(); + int iFirst = ((MappingPosition) positionList.get(0)).getFirstIndex(); + int iLast = ((MappingPosition) positionList.get(positionList + .size() - 1)).getLastIndex(); // copy from storedList to splitList all the elements from // iFirst to iLast ListIterator storedListIterator = storedList.listIterator(iFirst); diff --git a/src/java/org/apache/fop/layoutmgr/BlockLayoutManager.java b/src/java/org/apache/fop/layoutmgr/BlockLayoutManager.java index c5c7d9445..b6b6f921f 100644 --- a/src/java/org/apache/fop/layoutmgr/BlockLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/BlockLayoutManager.java @@ -113,7 +113,7 @@ public class BlockLayoutManager extends BlockStackingLayoutManager } /** {@inheritDoc} */ - public LinkedList getNextKnuthElements(LayoutContext context, int alignment) { + public List getNextKnuthElements(LayoutContext context, int alignment) { resetSpaces(); return super.getNextKnuthElements(context, alignment); } diff --git a/src/java/org/apache/fop/layoutmgr/BlockStackingLayoutManager.java b/src/java/org/apache/fop/layoutmgr/BlockStackingLayoutManager.java index b208e4e9b..b2fb98ccd 100644 --- a/src/java/org/apache/fop/layoutmgr/BlockStackingLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/BlockStackingLayoutManager.java @@ -63,7 +63,7 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager /** space-after value adjusted for block-progression-unit handling */ protected int adjustedSpaceAfter = 0; /** Only used to store the original list when createUnitElements is called */ - protected LinkedList storedList = null; + protected List storedList = null; /** Indicates whether break before has been served or not */ protected boolean breakBeforeServed = false; /** Indicates whether the first visible mark has been returned by this LM, yet */ @@ -235,7 +235,7 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager } /** {@inheritDoc} */ - public LinkedList getNextKnuthElements(LayoutContext context, int alignment) { + public List getNextKnuthElements(LayoutContext context, int alignment) { //log.debug("BLM.getNextKnuthElements> keep-together = " // + layoutProps.keepTogether.getType()); //log.debug(" keep-with-previous = " + @@ -249,9 +249,9 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager updateContentAreaIPDwithOverconstrainedAdjust(); - LinkedList returnedList = null; - LinkedList contentList = new LinkedList(); - LinkedList returnList = new LinkedList(); + List returnedList = null; + List contentList = new LinkedList(); + List returnList = new LinkedList(); if (!breakBeforeServed) { try { @@ -303,11 +303,11 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager } if (returnedList != null && returnedList.size() == 1 - && ((ListElement) returnedList.getFirst()).isForcedBreak()) { + && ((ListElement) returnedList.get(0)).isForcedBreak()) { if (curLM.isFinished() && !hasNextChildLM()) { // a descendant of this block has break-before - forcedBreakAfterLast = (BreakElement) returnedList.getFirst(); + forcedBreakAfterLast = (BreakElement) returnedList.get(0); context.clearPendingMarks(); break; } @@ -344,10 +344,12 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager continue; } contentList.addAll(returnedList); - if (((ListElement) returnedList.getLast()).isForcedBreak()) { + if (((ListElement) returnedList.get(returnedList.size() - 1)) + .isForcedBreak()) { // a descendant of this block has break-after if (curLM.isFinished() && !hasNextChildLM()) { - forcedBreakAfterLast = (BreakElement)contentList.removeLast(); + forcedBreakAfterLast = (BreakElement) contentList + .remove(contentList.size() - 1); context.clearPendingMarks(); break; } @@ -414,7 +416,7 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager * @param context the current layout context * @param childLC the currently active child layout context */ - protected void addInBetweenBreak(LinkedList contentList, LayoutContext context, + protected void addInBetweenBreak(List contentList, LayoutContext context, LayoutContext childLC) { if (mustKeepTogether() || context.isKeepWithNextPending() @@ -438,7 +440,8 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager return; } - ListElement last = (ListElement)contentList.getLast(); + ListElement last = (ListElement) contentList + .get(contentList.size() - 1); if (last.isGlue()) { // the last element in contentList is a glue; // it is a feasible breakpoint, there is no need to add @@ -585,7 +588,7 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager /** * {@inheritDoc} */ - public LinkedList getChangedKnuthElements(List oldList, int alignment) { + public List getChangedKnuthElements(List oldList, int alignment) { /*LF*/ //log.debug(""); /*LF*/ //log.debug(" BLM.getChangedKnuthElements> inizio: oldList.size() = " // + oldList.size()); @@ -593,8 +596,8 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager KnuthElement returnedElement; KnuthElement currElement = null; KnuthElement prevElement = null; - LinkedList returnedList = new LinkedList(); - LinkedList returnList = new LinkedList(); + List returnedList = new LinkedList(); + List returnList = new LinkedList(); int fromIndex = 0; // "unwrap" the Positions stored in the elements @@ -691,7 +694,9 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager // add an infinite penalty to forbid a break between blocks returnedList.add(new KnuthPenalty(0, KnuthElement.INFINITE, false, new Position(this), false)); - } else if (bSomethingAdded && !((KnuthElement) returnedList.getLast()).isGlue()) { + } else if (bSomethingAdded + && !((KnuthElement) returnedList.get(returnedList + .size() - 1)).isGlue()) { // add a null penalty to allow a break between blocks returnedList.add(new KnuthPenalty(0, 0, false, new Position(this), false)); } @@ -711,7 +716,7 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager // there are no more elements to add // remove the last penalty added to returnedList if (returnedList.size() > 0) { - returnedList.removeLast(); + returnedList.remove(returnedList.size() - 1); } //log.debug(" BLM.getChangedKnuthElements> elementi propri, ignorati, da " // + fromIndex + " a " + workList.size()); @@ -943,7 +948,7 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager * @param isFirst true if this is the first time a layout manager instance needs to generate * border and padding */ - protected void addKnuthElementsForBorderPaddingBefore(LinkedList returnList, boolean isFirst) { + protected void addKnuthElementsForBorderPaddingBefore(List returnList, boolean isFirst) { //Border and Padding (before) CommonBorderPaddingBackground borderAndPadding = getBorderPaddingBackground(); if (borderAndPadding != null) { @@ -970,7 +975,7 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager * @param isLast true if this is the last time a layout manager instance needs to generate * border and padding */ - protected void addKnuthElementsForBorderPaddingAfter(LinkedList returnList, boolean isLast) { + protected void addKnuthElementsForBorderPaddingAfter(List returnList, boolean isLast) { //Border and Padding (after) CommonBorderPaddingBackground borderAndPadding = getBorderPaddingBackground(); if (borderAndPadding != null) { @@ -997,7 +1002,7 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager * @param context the layout context * @return true if an element has been added due to a break-before. */ - protected boolean addKnuthElementsForBreakBefore(LinkedList returnList, + protected boolean addKnuthElementsForBreakBefore(List returnList, LayoutContext context) { int breakBefore = -1; if (fobj instanceof org.apache.fop.fo.flow.Block) { @@ -1030,7 +1035,7 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager * @param context the layout context * @return true if an element has been added due to a break-after. */ - protected boolean addKnuthElementsForBreakAfter(LinkedList returnList, + protected boolean addKnuthElementsForBreakAfter(List returnList, LayoutContext context) { int breakAfter = -1; if (fobj instanceof org.apache.fop.fo.flow.Block) { @@ -1062,7 +1067,7 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager * @param returnList return list to add the additional elements to * @param alignment vertical alignment */ - protected void addKnuthElementsForSpaceBefore(LinkedList returnList/*, + protected void addKnuthElementsForSpaceBefore(List returnList/*, Position returnPosition*/, int alignment) { SpaceProperty spaceBefore = getSpaceBeforeProperty(); // append elements representing space-before @@ -1111,7 +1116,7 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager * @param returnList return list to add the additional elements to * @param alignment vertical alignment */ - protected void addKnuthElementsForSpaceAfter(LinkedList returnList/*, Position returnPosition*/, + protected void addKnuthElementsForSpaceAfter(List returnList/*, Position returnPosition*/, int alignment) { SpaceProperty spaceAfter = getSpaceAfterProperty(); // append elements representing space-after @@ -1156,22 +1161,22 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager }*/ } - protected LinkedList createUnitElements(LinkedList oldList) { + protected List createUnitElements(List oldList) { //log.debug("Start conversion: " + oldList.size() // + " elements, space-before.min=" + layoutProps.spaceBefore.getSpace().min // + " space-after.min=" + layoutProps.spaceAfter.getSpace().min); // add elements at the beginning and at the end of oldList // representing minimum spaces - LayoutManager lm = ((KnuthElement)oldList.getFirst()).getLayoutManager(); + LayoutManager lm = ((KnuthElement)oldList.get(0)).getLayoutManager(); boolean bAddedBoxBefore = false; boolean bAddedBoxAfter = false; if (adjustedSpaceBefore > 0) { - oldList.addFirst(new KnuthBox(adjustedSpaceBefore, + oldList.add(0, new KnuthBox(adjustedSpaceBefore, new Position(lm), true)); bAddedBoxBefore = true; } if (adjustedSpaceAfter > 0) { - oldList.addLast(new KnuthBox(adjustedSpaceAfter, + oldList.add(new KnuthBox(adjustedSpaceAfter, new Position(lm), true)); bAddedBoxAfter = true; } @@ -1399,10 +1404,10 @@ public abstract class BlockStackingLayoutManager extends AbstractLayoutManager // remove elements at the beginning and at the end of oldList // representing minimum spaces if (adjustedSpaceBefore > 0) { - oldList.removeFirst(); + oldList.remove(0); } if (adjustedSpaceAfter > 0) { - oldList.removeLast(); + oldList.remove(oldList.size() - 1); } // if space-before.conditionality is "discard", correct newList diff --git a/src/java/org/apache/fop/layoutmgr/ElementListUtils.java b/src/java/org/apache/fop/layoutmgr/ElementListUtils.java index 9a87e71c4..f3d36276c 100644 --- a/src/java/org/apache/fop/layoutmgr/ElementListUtils.java +++ b/src/java/org/apache/fop/layoutmgr/ElementListUtils.java @@ -38,7 +38,7 @@ public class ElementListUtils { * @param constraint min/opt/max value to restrict the range in which the breaks are removed. * @return true if the opt constraint is bigger than the list contents */ - public static boolean removeLegalBreaks(LinkedList elements, MinOptMax constraint) { + public static boolean removeLegalBreaks(List elements, MinOptMax constraint) { return removeLegalBreaks(elements, constraint.opt); } @@ -50,7 +50,7 @@ public class ElementListUtils { * @param constraint value to restrict the range in which the breaks are removed. * @return true if the constraint is bigger than the list contents */ - public static boolean removeLegalBreaks(LinkedList elements, int constraint) { + public static boolean removeLegalBreaks(List elements, int constraint) { int len = 0; ListIterator iter = elements.listIterator(); while (iter.hasNext()) { @@ -97,7 +97,7 @@ public class ElementListUtils { * @param constraint value to restrict the range in which the breaks are removed. * @return true if the constraint is bigger than the list contents */ - public static boolean removeLegalBreaksFromEnd(LinkedList elements, int constraint) { + public static boolean removeLegalBreaksFromEnd(List elements, int constraint) { int len = 0; ListIterator i = elements.listIterator(elements.size()); while (i.hasPrevious()) { @@ -184,8 +184,8 @@ public class ElementListUtils { * @param elems the element list * @return true if the list ends with a forced break */ - public static boolean endsWithForcedBreak(LinkedList elems) { - ListElement last = (ListElement)elems.getLast(); + public static boolean endsWithForcedBreak(List elems) { + ListElement last = (ListElement) elems.get(elems.size() - 1); return last.isForcedBreak(); } @@ -195,8 +195,8 @@ public class ElementListUtils { * @param elems the element list * @return true if the list ends with a non-infinite penalty */ - public static boolean endsWithNonInfinitePenalty(LinkedList elems) { - ListElement last = (ListElement)elems.getLast(); + public static boolean endsWithNonInfinitePenalty(List elems) { + ListElement last = (ListElement) elems.get(elems.size() - 1); if (last.isPenalty() && ((KnuthPenalty)last).getP() < KnuthElement.INFINITE) { return true; } else if (last instanceof BreakElement diff --git a/src/java/org/apache/fop/layoutmgr/FlowLayoutManager.java b/src/java/org/apache/fop/layoutmgr/FlowLayoutManager.java index 9cd5c622d..2410c19cd 100644 --- a/src/java/org/apache/fop/layoutmgr/FlowLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/FlowLayoutManager.java @@ -64,7 +64,7 @@ public class FlowLayoutManager extends BlockStackingLayoutManager } /** {@inheritDoc} */ - public LinkedList getNextKnuthElements(LayoutContext context, int alignment) { + public List getNextKnuthElements(LayoutContext context, int alignment) { // set layout dimensions int flowIPD = getCurrentPV().getCurrentSpan().getColumnWidth(); @@ -72,8 +72,8 @@ public class FlowLayoutManager extends BlockStackingLayoutManager // currently active LM LayoutManager curLM; - LinkedList returnedList; - LinkedList returnList = new LinkedList(); + List returnedList; + List returnList = new LinkedList(); while ((curLM = getChildLM()) != null) { if (!(curLM instanceof WrapperLayoutManager) @@ -114,7 +114,7 @@ public class FlowLayoutManager extends BlockStackingLayoutManager } // "wrap" the Position inside each element - LinkedList tempList = returnedList; + List tempList = returnedList; returnedList = new LinkedList(); wrapPositionElements(tempList, returnedList); @@ -213,11 +213,11 @@ public class FlowLayoutManager extends BlockStackingLayoutManager } /** {@inheritDoc} */ - public LinkedList getChangedKnuthElements(List oldList, /*int flaggedPenalty,*/ int alignment) { + public List getChangedKnuthElements(List oldList, /*int flaggedPenalty,*/ int alignment) { ListIterator oldListIterator = oldList.listIterator(); KnuthElement returnedElement; - LinkedList returnedList = new LinkedList(); - LinkedList returnList = new LinkedList(); + List returnedList = new LinkedList(); + List returnList = new LinkedList(); KnuthElement prevElement = null; KnuthElement currElement = null; int fromIndex = 0; @@ -257,7 +257,8 @@ public class FlowLayoutManager extends BlockStackingLayoutManager // add an infinite penalty to forbid a break between blocks returnedList.add(new KnuthPenalty(0, KnuthElement.INFINITE, false, new Position(this), false)); - } else if (!((KnuthElement) returnedList.getLast()).isGlue()) { + } else if (!((KnuthElement) returnedList.get(returnedList + .size() - 1)).isGlue()) { // add a null penalty to allow a break between blocks returnedList.add(new KnuthPenalty(0, 0, false, new Position(this), false)); } diff --git a/src/java/org/apache/fop/layoutmgr/KnuthBlockBox.java b/src/java/org/apache/fop/layoutmgr/KnuthBlockBox.java index 53f285377..364c896ad 100644 --- a/src/java/org/apache/fop/layoutmgr/KnuthBlockBox.java +++ b/src/java/org/apache/fop/layoutmgr/KnuthBlockBox.java @@ -19,9 +19,10 @@ package org.apache.fop.layoutmgr; -import org.apache.fop.traits.MinOptMax; - import java.util.LinkedList; +import java.util.List; + +import org.apache.fop.traits.MinOptMax; /** * Knuth box used to represent a line in block-progression-dimension (i.e. the width is its height). @@ -34,9 +35,9 @@ public class KnuthBlockBox extends KnuthBox { * it isn't possible to get the opt value stored in a MinOptMax object. */ private int bpd; - private LinkedList footnoteList; + private List footnoteList; /** List of Knuth elements. This is a list of LinkedList elements. */ - private LinkedList elementLists = null; + private List elementLists = null; /** * Creates a new box. @@ -61,7 +62,7 @@ public class KnuthBlockBox extends KnuthBox { * @param pos the Position stored in this box * @param bAux is this box auxiliary? */ - public KnuthBlockBox(int w, LinkedList list, Position pos, boolean bAux) { + public KnuthBlockBox(int w, List list, Position pos, boolean bAux) { super(w, pos, bAux); ipdRange = new MinOptMax(0); bpd = 0; @@ -71,7 +72,7 @@ public class KnuthBlockBox extends KnuthBox { /** * @return the LMs for the footnotes cited in this box. */ - public LinkedList getFootnoteBodyLMs() { + public List getFootnoteBodyLMs() { return footnoteList; } @@ -86,7 +87,7 @@ public class KnuthBlockBox extends KnuthBox { * Adds the given list of Knuth elements to this box' list of elements. * @param list elements corresponding to a footnote body */ - public void addElementList(LinkedList list) { + public void addElementList(List list) { if (elementLists == null) { elementLists = new LinkedList(); } @@ -98,7 +99,7 @@ public class KnuthBlockBox extends KnuthBox { * @return a list of KnuthElement sequences corresponding to footnotes cited in this * box */ - public LinkedList getElementLists() { + public List getElementLists() { return elementLists; } diff --git a/src/java/org/apache/fop/layoutmgr/LayoutManager.java b/src/java/org/apache/fop/layoutmgr/LayoutManager.java index 0b17c9a27..0700ea43a 100644 --- a/src/java/org/apache/fop/layoutmgr/LayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/LayoutManager.java @@ -19,7 +19,6 @@ package org.apache.fop.layoutmgr; -import java.util.LinkedList; import java.util.List; import org.apache.fop.area.Area; @@ -138,7 +137,7 @@ public interface LayoutManager extends PercentBaseContext { * @param alignment the desired text alignement * @return the list of KnuthElements */ - LinkedList getNextKnuthElements(LayoutContext context, int alignment); + List getNextKnuthElements(LayoutContext context, int alignment); /** * Get a sequence of KnuthElements representing the content @@ -175,7 +174,7 @@ public interface LayoutManager extends PercentBaseContext { * @param alignment the desired text alignment * @return the updated list of KnuthElements */ - LinkedList getChangedKnuthElements(List oldList, int alignment); + List getChangedKnuthElements(List oldList, int alignment); /** * Returns the IPD of the content area diff --git a/src/java/org/apache/fop/layoutmgr/PageBreaker.java b/src/java/org/apache/fop/layoutmgr/PageBreaker.java index d6be75758..b25e4bd4f 100644 --- a/src/java/org/apache/fop/layoutmgr/PageBreaker.java +++ b/src/java/org/apache/fop/layoutmgr/PageBreaker.java @@ -135,8 +135,8 @@ public class PageBreaker extends AbstractBreaker { } /** {@inheritDoc} */ - protected LinkedList getNextKnuthElements(LayoutContext context, int alignment) { - LinkedList contentList = null; + protected List getNextKnuthElements(LayoutContext context, int alignment) { + List contentList = null; while (!childFLM.isFinished() && contentList == null) { contentList = childFLM.getNextKnuthElements(context, alignment); @@ -156,7 +156,7 @@ public class PageBreaker extends AbstractBreaker { footnoteContext.setStackLimitBP(context.getStackLimitBP()); footnoteContext.setRefIPD(pslm.getCurrentPV() .getRegionReference(Constants.FO_REGION_BODY).getIPD()); - LinkedList footnoteBodyLMs = ((KnuthBlockBox) element).getFootnoteBodyLMs(); + List footnoteBodyLMs = ((KnuthBlockBox) element).getFootnoteBodyLMs(); ListIterator footnoteBodyIterator = footnoteBodyLMs.listIterator(); // store the lists of elements representing the footnote bodies // in the box representing the line containing their references diff --git a/src/java/org/apache/fop/layoutmgr/PageBreakingAlgorithm.java b/src/java/org/apache/fop/layoutmgr/PageBreakingAlgorithm.java index 5e3d0a887..a3155e102 100644 --- a/src/java/org/apache/fop/layoutmgr/PageBreakingAlgorithm.java +++ b/src/java/org/apache/fop/layoutmgr/PageBreakingAlgorithm.java @@ -21,11 +21,11 @@ package org.apache.fop.layoutmgr; import java.util.ArrayList; import java.util.LinkedList; +import java.util.List; import java.util.ListIterator; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; - import org.apache.fop.fo.Constants; import org.apache.fop.fo.FObj; import org.apache.fop.layoutmgr.AbstractBreaker.PageBreakPosition; @@ -230,7 +230,7 @@ class PageBreakingAlgorithm extends BreakingAlgorithm { * @param elementLists list of KnuthElement sequences corresponding to the footnotes * bodies */ - private void handleFootnotes(LinkedList elementLists) { + private void handleFootnotes(List elementLists) { // initialization if (!footnotesPending) { footnotesPending = true; @@ -286,7 +286,7 @@ class PageBreakingAlgorithm extends BreakingAlgorithm { return returnValue; } - private void resetFootnotes(LinkedList elementLists) { + private void resetFootnotes(List elementLists) { for (int i = 0; i < elementLists.size(); i++) { /*LinkedList removedList = (LinkedList)*/footnotesList.remove(footnotesList.size() - 1); lengthList.remove(lengthList.size() - 1); diff --git a/src/java/org/apache/fop/layoutmgr/SpaceResolver.java b/src/java/org/apache/fop/layoutmgr/SpaceResolver.java index 58de6a980..051f76d7f 100644 --- a/src/java/org/apache/fop/layoutmgr/SpaceResolver.java +++ b/src/java/org/apache/fop/layoutmgr/SpaceResolver.java @@ -614,7 +614,7 @@ public class SpaceResolver { * Resolves unresolved elements applying the space resolution rules defined in 4.3.1. * @param elems the element list */ - public static void resolveElementList(LinkedList elems) { + public static void resolveElementList(List elems) { if (log.isTraceEnabled()) { log.trace(elems); } diff --git a/src/java/org/apache/fop/layoutmgr/StaticContentLayoutManager.java b/src/java/org/apache/fop/layoutmgr/StaticContentLayoutManager.java index 8065f9aad..3a8786bd7 100644 --- a/src/java/org/apache/fop/layoutmgr/StaticContentLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/StaticContentLayoutManager.java @@ -87,7 +87,7 @@ public class StaticContentLayoutManager extends BlockStackingLayoutManager { } /** {@inheritDoc} */ - public LinkedList getNextKnuthElements(LayoutContext context, int alignment) { + public List getNextKnuthElements(LayoutContext context, int alignment) { if (true) { throw new UnsupportedOperationException( "Shouldn't this method be emptied because it's never called at all?"); @@ -102,8 +102,8 @@ public class StaticContentLayoutManager extends BlockStackingLayoutManager { BlockLevelLayoutManager curLM; BlockLevelLayoutManager prevLM = null; MinOptMax stackSize = new MinOptMax(); - LinkedList returnedList; - LinkedList returnList = new LinkedList(); + List returnedList; + List returnList = new LinkedList(); while ((curLM = ((BlockLevelLayoutManager) getChildLM())) != null) { if (curLM instanceof InlineLevelLayoutManager) { @@ -125,7 +125,7 @@ public class StaticContentLayoutManager extends BlockStackingLayoutManager { // + returnedList.size()); // "wrap" the Position inside each element - LinkedList tempList = returnedList; + List tempList = returnedList; KnuthElement tempElement; returnedList = new LinkedList(); ListIterator listIter = tempList.listIterator(); @@ -136,8 +136,8 @@ public class StaticContentLayoutManager extends BlockStackingLayoutManager { } if (returnedList.size() == 1 - && ((KnuthElement)returnedList.getFirst()).isPenalty() - && ((KnuthPenalty)returnedList.getFirst()).getP() == -KnuthElement.INFINITE) { + && ((KnuthElement)returnedList.get(0)).isPenalty() + && ((KnuthPenalty)returnedList.get(0)).getP() == -KnuthElement.INFINITE) { // a descendant of this flow has break-before returnList.addAll(returnedList); return returnList; @@ -150,16 +150,18 @@ public class StaticContentLayoutManager extends BlockStackingLayoutManager { returnList.add(new KnuthPenalty(0, KnuthElement.INFINITE, false, new Position(this), false)); - } else if (!((KnuthElement) returnList.getLast()).isGlue()) { + } else if (!((KnuthElement) returnList.get(returnList + .size() - 1)).isGlue()) { // add a null penalty to allow a break between blocks returnList.add(new KnuthPenalty(0, 0, false, new Position(this), false)); } } /*LF*/ if (returnedList.size() > 0) { // controllare! returnList.addAll(returnedList); - if (((KnuthElement)returnedList.getLast()).isPenalty() - && ((KnuthPenalty)returnedList.getLast()).getP() - == -KnuthElement.INFINITE) { + final KnuthElement last = (KnuthElement) returnedList + .get(returnedList.size() - 1); + if (last.isPenalty() + && ((KnuthPenalty) last).getP() == -KnuthElement.INFINITE) { // a descendant of this flow has break-after /*LF*/ //log.debug("FLM - break after!!"); return returnList; @@ -325,9 +327,9 @@ public class StaticContentLayoutManager extends BlockStackingLayoutManager { return lc; } - protected LinkedList getNextKnuthElements(LayoutContext context, int alignment) { + protected List getNextKnuthElements(LayoutContext context, int alignment) { LayoutManager curLM; // currently active LM - LinkedList returnList = new LinkedList(); + List returnList = new LinkedList(); while ((curLM = getChildLM()) != null) { LayoutContext childLC = new LayoutContext(0); @@ -335,7 +337,7 @@ public class StaticContentLayoutManager extends BlockStackingLayoutManager { childLC.setRefIPD(context.getRefIPD()); childLC.setWritingMode(context.getWritingMode()); - LinkedList returnedList = null; + List returnedList = null; //The following is a HACK! Ignore leading and trailing white space boolean ignore = curLM instanceof TextLayoutManager; if (!curLM.isFinished()) { diff --git a/src/java/org/apache/fop/layoutmgr/inline/AbstractGraphicsLayoutManager.java b/src/java/org/apache/fop/layoutmgr/inline/AbstractGraphicsLayoutManager.java index 38e0c35bc..e90927699 100644 --- a/src/java/org/apache/fop/layoutmgr/inline/AbstractGraphicsLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/inline/AbstractGraphicsLayoutManager.java @@ -21,7 +21,7 @@ package org.apache.fop.layoutmgr.inline; import java.awt.Dimension; import java.awt.Rectangle; -import java.util.LinkedList; +import java.util.List; import org.apache.fop.area.Area; import org.apache.fop.area.inline.Viewport; @@ -104,7 +104,7 @@ public abstract class AbstractGraphicsLayoutManager extends LeafNodeLayoutManage } /** {@inheritDoc} */ - public LinkedList getNextKnuthElements(LayoutContext context, + public List getNextKnuthElements(LayoutContext context, int alignment) { Viewport areaCurrent = getInlineArea(); setCurrentArea(areaCurrent); diff --git a/src/java/org/apache/fop/layoutmgr/inline/CharacterLayoutManager.java b/src/java/org/apache/fop/layoutmgr/inline/CharacterLayoutManager.java index a6f9be7af..c81a23a9c 100644 --- a/src/java/org/apache/fop/layoutmgr/inline/CharacterLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/inline/CharacterLayoutManager.java @@ -90,7 +90,7 @@ public class CharacterLayoutManager extends LeafNodeLayoutManager { } /** {@inheritDoc} */ - public LinkedList getNextKnuthElements(LayoutContext context, int alignment) { + public List getNextKnuthElements(LayoutContext context, int alignment) { MinOptMax ipd; curArea = get(context); KnuthSequence seq = new InlineKnuthSequence(); @@ -179,7 +179,7 @@ public class CharacterLayoutManager extends LeafNodeLayoutManager { } /** {@inheritDoc} */ - public LinkedList getChangedKnuthElements(List oldList, int alignment) { + public List getChangedKnuthElements(List oldList, int alignment) { if (isFinished()) { return null; } diff --git a/src/java/org/apache/fop/layoutmgr/inline/ContentLayoutManager.java b/src/java/org/apache/fop/layoutmgr/inline/ContentLayoutManager.java index 2af844c5c..b43c4c841 100644 --- a/src/java/org/apache/fop/layoutmgr/inline/ContentLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/inline/ContentLayoutManager.java @@ -27,8 +27,6 @@ import java.util.ListIterator; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; - -import org.apache.fop.apps.FOUserAgent; import org.apache.fop.area.Area; import org.apache.fop.area.Block; import org.apache.fop.area.LineArea; @@ -131,7 +129,7 @@ public class ContentLayoutManager extends AbstractBaseLayoutManager stackSize = 0; - LinkedList contentList = + List contentList = getNextKnuthElements(childLC, Constants.EN_START); ListIterator contentIter = contentList.listIterator(); while (contentIter.hasNext()) { @@ -254,9 +252,9 @@ public class ContentLayoutManager extends AbstractBaseLayoutManager } } - public LinkedList getNextKnuthElements(LayoutContext context, int alignment) { - LinkedList contentList = new LinkedList(); - LinkedList returnedList; + public List getNextKnuthElements(LayoutContext context, int alignment) { + List contentList = new LinkedList(); + List returnedList; childLM.initialize(); while (!childLM.isFinished()) { @@ -267,7 +265,7 @@ public class ContentLayoutManager extends AbstractBaseLayoutManager // move elements to contentList, and accumulate their size KnuthElement contentElement; while (returnedList.size() > 0) { - Object obj = returnedList.removeFirst(); + Object obj = returnedList.remove(0); if (obj instanceof KnuthSequence) { KnuthSequence ks = (KnuthSequence)obj; for (Iterator it = ks.iterator(); it.hasNext(); ) { @@ -312,7 +310,7 @@ public class ContentLayoutManager extends AbstractBaseLayoutManager return false; } - public LinkedList getChangedKnuthElements(List oldList, + public List getChangedKnuthElements(List oldList, /*int flaggedPenalty,*/ int alignment) { return null; diff --git a/src/java/org/apache/fop/layoutmgr/inline/FootnoteLayoutManager.java b/src/java/org/apache/fop/layoutmgr/inline/FootnoteLayoutManager.java index adb0e5a73..a02cfee89 100644 --- a/src/java/org/apache/fop/layoutmgr/inline/FootnoteLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/inline/FootnoteLayoutManager.java @@ -71,7 +71,7 @@ public class FootnoteLayoutManager extends InlineStackingLayoutManager { } /** {@inheritDoc} */ - public LinkedList getNextKnuthElements(LayoutContext context, + public List getNextKnuthElements(LayoutContext context, int alignment) { // for the moment, this LM is set as the citationLM's parent // later on, when this LM will have nothing more to do, the citationLM's parent @@ -82,9 +82,9 @@ public class FootnoteLayoutManager extends InlineStackingLayoutManager { bodyLM.initialize(); // get Knuth elements representing the footnote citation - LinkedList returnedList = new LinkedList(); + List returnedList = new LinkedList(); while (!citationLM.isFinished()) { - LinkedList partialList = citationLM.getNextKnuthElements(context, alignment); + List partialList = citationLM.getNextKnuthElements(context, alignment); if (partialList != null) { returnedList.addAll(partialList); } @@ -122,9 +122,9 @@ public class FootnoteLayoutManager extends InlineStackingLayoutManager { /** * {@inheritDoc} */ - public LinkedList getChangedKnuthElements(List oldList, + public List getChangedKnuthElements(List oldList, int alignment) { - LinkedList returnedList = super.getChangedKnuthElements(oldList, alignment); + List returnedList = super.getChangedKnuthElements(oldList, alignment); addAnchor(returnedList); return returnedList; } @@ -164,7 +164,7 @@ public class FootnoteLayoutManager extends InlineStackingLayoutManager { * Find the last box in the sequence, and add a reference to the FootnoteBodyLM * @param citationList the list of elements representing the footnote citation */ - private void addAnchor(LinkedList citationList) { + private void addAnchor(List citationList) { KnuthInlineBox lastBox = null; // the list of elements is searched backwards, until we find a box ListIterator citationIterator = citationList.listIterator(citationList.size()); diff --git a/src/java/org/apache/fop/layoutmgr/inline/InlineLayoutManager.java b/src/java/org/apache/fop/layoutmgr/inline/InlineLayoutManager.java index 7c2e4748a..123259cd4 100755 --- a/src/java/org/apache/fop/layoutmgr/inline/InlineLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/inline/InlineLayoutManager.java @@ -233,14 +233,14 @@ public class InlineLayoutManager extends InlineStackingLayoutManager { } /** {@inheritDoc} */ - public LinkedList getNextKnuthElements(LayoutContext context, int alignment) { + public List getNextKnuthElements(LayoutContext context, int alignment) { LayoutManager curLM; // the list returned by child LM - LinkedList returnedList; + List returnedList; // the list which will be returned to the parent LM - LinkedList returnList = new LinkedList(); + List returnList = new LinkedList(); KnuthSequence lastSequence = null; SpaceSpecifier leadingSpace = context.getLeadingSpace(); @@ -367,7 +367,8 @@ public class InlineLayoutManager extends InlineStackingLayoutManager { context.updateKeepWithNextPending(childLC.getKeepWithNextPending()); childLC.clearKeepsPending(); } - lastSequence = (KnuthSequence) returnList.getLast(); + lastSequence = (KnuthSequence) returnList + .get(returnList.size() - 1); lastChildLM = curLM; } @@ -432,7 +433,7 @@ public class InlineLayoutManager extends InlineStackingLayoutManager { // set in the layout context, it must be also set in the // layout context given to lastLM, but must be cleared in the // layout context given to the other LMs. - LinkedList positionList = new LinkedList(); + List positionList = new LinkedList(); NonLeafPosition pos; LayoutManager lastLM = null;// last child LM in this iterator Position lastPos = null; @@ -533,8 +534,8 @@ public class InlineLayoutManager extends InlineStackingLayoutManager { } /** {@inheritDoc} */ - public LinkedList getChangedKnuthElements(List oldList, int alignment) { - LinkedList returnedList = new LinkedList(); + public List getChangedKnuthElements(List oldList, int alignment) { + List returnedList = new LinkedList(); addKnuthElementsForBorderPaddingStart(returnedList); returnedList.addAll(super.getChangedKnuthElements(oldList, alignment)); addKnuthElementsForBorderPaddingEnd(returnedList); diff --git a/src/java/org/apache/fop/layoutmgr/inline/InlineStackingLayoutManager.java b/src/java/org/apache/fop/layoutmgr/inline/InlineStackingLayoutManager.java index bf1538a7c..81fc7901d 100644 --- a/src/java/org/apache/fop/layoutmgr/inline/InlineStackingLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/inline/InlineStackingLayoutManager.java @@ -364,7 +364,7 @@ public abstract class InlineStackingLayoutManager extends AbstractLayoutManager /** * {@inheritDoc} */ - public LinkedList getChangedKnuthElements(List oldList, int alignment) { + public List getChangedKnuthElements(List oldList, int alignment) { // "unwrap" the Positions stored in the elements ListIterator oldListIterator = oldList.listIterator(); KnuthElement oldElement; diff --git a/src/java/org/apache/fop/layoutmgr/inline/LeaderLayoutManager.java b/src/java/org/apache/fop/layoutmgr/inline/LeaderLayoutManager.java index 1e7c793df..3bb82aa11 100644 --- a/src/java/org/apache/fop/layoutmgr/inline/LeaderLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/inline/LeaderLayoutManager.java @@ -52,7 +52,7 @@ public class LeaderLayoutManager extends LeafNodeLayoutManager { private Leader fobj; private Font font = null; - private LinkedList contentList = null; + private List contentList = null; private ContentLayoutManager clm = null; private int contentAreaIPD = 0; @@ -230,7 +230,7 @@ public class LeaderLayoutManager extends LeafNodeLayoutManager { } /** {@inheritDoc} */ - public LinkedList getNextKnuthElements(LayoutContext context, + public List getNextKnuthElements(LayoutContext context, int alignment) { MinOptMax ipd; curArea = get(context); @@ -305,13 +305,13 @@ public class LeaderLayoutManager extends LeafNodeLayoutManager { } /** {@inheritDoc} */ - public LinkedList getChangedKnuthElements(List oldList, + public List getChangedKnuthElements(List oldList, int alignment) { if (isFinished()) { return null; } - LinkedList returnList = new LinkedList(); + List returnList = new LinkedList(); addKnuthElementsForBorderPaddingStart(returnList); diff --git a/src/java/org/apache/fop/layoutmgr/inline/LeafNodeLayoutManager.java b/src/java/org/apache/fop/layoutmgr/inline/LeafNodeLayoutManager.java index fb5e9ee4d..552e74889 100644 --- a/src/java/org/apache/fop/layoutmgr/inline/LeafNodeLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/inline/LeafNodeLayoutManager.java @@ -249,7 +249,7 @@ public abstract class LeafNodeLayoutManager extends AbstractLayoutManager } /** {@inheritDoc} */ - public LinkedList getNextKnuthElements(LayoutContext context, int alignment) { + public List getNextKnuthElements(LayoutContext context, int alignment) { curArea = get(context); if (curArea == null) { @@ -313,7 +313,7 @@ public abstract class LeafNodeLayoutManager extends AbstractLayoutManager } /** {@inheritDoc} */ - public LinkedList getChangedKnuthElements(List oldList, + public List getChangedKnuthElements(List oldList, int alignment) { if (isFinished()) { return null; diff --git a/src/java/org/apache/fop/layoutmgr/inline/LineLayoutManager.java b/src/java/org/apache/fop/layoutmgr/inline/LineLayoutManager.java index c9f72e64f..b77f36f0d 100644 --- a/src/java/org/apache/fop/layoutmgr/inline/LineLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/inline/LineLayoutManager.java @@ -574,7 +574,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager } /** {@inheritDoc} */ - public LinkedList getNextKnuthElements(LayoutContext context, int alignment) { + public List getNextKnuthElements(LayoutContext context, int alignment) { FontInfo fi = fobj.getFOEventHandler().getFontInfo(); FontTriplet[] fontkeys = fobj.getCommonFont().getFontState(fi); Font fs = fi.getFontInstance(fontkeys[0], fobj.getCommonFont().fontSize.getValue(this)); @@ -644,7 +644,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager LayoutContext inlineLC = new LayoutContext(context); InlineLevelLayoutManager curLM; - LinkedList returnedList = null; + List returnedList = null; iLineWidth = context.getStackLimitIP().opt; // convert all the text in a sequence of paragraphs made @@ -666,7 +666,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager } if (lastPar != null) { - KnuthSequence firstSeq = (KnuthSequence) returnedList.getFirst(); + KnuthSequence firstSeq = (KnuthSequence) returnedList.get(0); // finish last paragraph before a new block sequence if (!firstSeq.isInlineSequence()) { @@ -901,7 +901,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager * @param context the layout context * @return a list of Knuth elements representing broken lines */ - private LinkedList createLineBreaks(int alignment, LayoutContext context) { + private List createLineBreaks(int alignment, LayoutContext context) { // find the optimal line breaking points for each paragraph ListIterator paragraphsIterator @@ -1048,9 +1048,9 @@ public class LineLayoutManager extends InlineStackingLayoutManager * @param context the layout context * @return the newly built element list */ - private LinkedList postProcessLineBreaks(int alignment, LayoutContext context) { + private List postProcessLineBreaks(int alignment, LayoutContext context) { - LinkedList returnList = new LinkedList(); + List returnList = new LinkedList(); for (int p = 0; p < knuthParagraphs.size(); p++) { // penalty between paragraphs @@ -1068,7 +1068,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager KnuthSequence seq = (KnuthSequence) knuthParagraphs.get(p); if (!seq.isInlineSequence()) { - LinkedList targetList = new LinkedList(); + List targetList = new LinkedList(); ListIterator listIter = seq.listIterator(); while (listIter.hasNext()) { ListElement tempElement; @@ -1110,7 +1110,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager = ((LineBreakPosition) llPoss.getChosenPosition(i)).getLeafPos(); // create a list of the FootnoteBodyLM handling footnotes // whose citations are in this line - LinkedList footnoteList = new LinkedList(); + List footnoteList = new LinkedList(); ListIterator elementIterator = seq.listIterator(startIndex); while (elementIterator.nextIndex() <= endIndex) { KnuthElement element = (KnuthElement) elementIterator.next(); @@ -1334,8 +1334,8 @@ public class LineLayoutManager extends InlineStackingLayoutManager /** * {@inheritDoc} */ - public LinkedList getChangedKnuthElements(List oldList, int alignment) { - LinkedList returnList = new LinkedList(); + public List getChangedKnuthElements(List oldList, int alignment) { + List returnList = new LinkedList(); for (int p = 0; p < knuthParagraphs.size(); p++) { LineLayoutPossibilities llPoss; llPoss = (LineLayoutPossibilities)lineLayoutsList.get(p); @@ -1384,7 +1384,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager ListIterator currParIterator = currPar.listIterator(currPar.ignoreAtStart); // list of TLM involved in hyphenation - LinkedList updateList = new LinkedList(); + List updateList = new LinkedList(); KnuthElement firstElement = null; KnuthElement nextElement = null; // current InlineLevelLayoutManager @@ -1497,7 +1497,7 @@ public class LineLayoutManager extends InlineStackingLayoutManager .applyChanges(currPar.subList(fromIndex + iAddedElements, toIndex + iAddedElements))) { // insert the new KnuthElements - LinkedList newElements = null; + List newElements = null; newElements = currUpdate.inlineLM.getChangedKnuthElements (currPar.subList(fromIndex + iAddedElements, diff --git a/src/java/org/apache/fop/layoutmgr/inline/TextLayoutManager.java b/src/java/org/apache/fop/layoutmgr/inline/TextLayoutManager.java index 903ec84ae..eec2b1e91 100644 --- a/src/java/org/apache/fop/layoutmgr/inline/TextLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/inline/TextLayoutManager.java @@ -523,12 +523,12 @@ public class TextLayoutManager extends LeafNodeLayoutManager { } /** {@inheritDoc} */ - public LinkedList getNextKnuthElements(final LayoutContext context, final int alignment) { + public List getNextKnuthElements(final LayoutContext context, final int alignment) { this.lineStartBAP = context.getLineStartBorderAndPaddingWidth(); this.lineEndBAP = context.getLineEndBorderAndPaddingWidth(); this.alignmentContext = context.getAlignmentContext(); - final LinkedList returnList = new LinkedList(); + final List returnList = new LinkedList(); KnuthSequence sequence = new InlineKnuthSequence(); AreaInfo ai = null; AreaInfo prevAi = null; @@ -624,9 +624,9 @@ public class TextLayoutManager extends LeafNodeLayoutManager { sequence = this.processLinebreak(returnList, sequence); } - if (((List)returnList.getLast()).size() == 0) { + if (((List) returnList.get(returnList.size() - 1)).isEmpty()) { //Remove an empty sequence because of a trailing newline - returnList.removeLast(); + returnList.remove(returnList.size() - 1); } this.setFinished(true); @@ -637,7 +637,7 @@ public class TextLayoutManager extends LeafNodeLayoutManager { } } - private KnuthSequence processLinebreak(final LinkedList returnList, + private KnuthSequence processLinebreak(final List returnList, KnuthSequence sequence) { if (this.lineEndBAP != 0) { sequence.add( @@ -942,7 +942,7 @@ public class TextLayoutManager extends LeafNodeLayoutManager { } /** {@inheritDoc} */ - public LinkedList getChangedKnuthElements(final List oldList, + public List getChangedKnuthElements(final List oldList, final int alignment) { if (this.isFinished()) { return null; diff --git a/src/java/org/apache/fop/layoutmgr/list/ListBlockLayoutManager.java b/src/java/org/apache/fop/layoutmgr/list/ListBlockLayoutManager.java index dfffbdd04..11e69970e 100644 --- a/src/java/org/apache/fop/layoutmgr/list/ListBlockLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/list/ListBlockLayoutManager.java @@ -115,9 +115,9 @@ public class ListBlockLayoutManager extends BlockStackingLayoutManager } /** {@inheritDoc} */ - public LinkedList getNextKnuthElements(LayoutContext context, int alignment) { + public List getNextKnuthElements(LayoutContext context, int alignment) { resetSpaces(); - LinkedList returnList = super.getNextKnuthElements(context, alignment); + List returnList = super.getNextKnuthElements(context, alignment); //fox:widow-content-limit int widowRowLimit = getListBlockFO().getWidowContentLimit().getValue(); @@ -135,7 +135,7 @@ public class ListBlockLayoutManager extends BlockStackingLayoutManager } /** {@inheritDoc} */ - public LinkedList getChangedKnuthElements(List oldList, int alignment) { + public List getChangedKnuthElements(List oldList, int alignment) { //log.debug("LBLM.getChangedKnuthElements>"); return super.getChangedKnuthElements(oldList, alignment); } diff --git a/src/java/org/apache/fop/layoutmgr/list/ListItemContentLayoutManager.java b/src/java/org/apache/fop/layoutmgr/list/ListItemContentLayoutManager.java index 549244267..124827976 100644 --- a/src/java/org/apache/fop/layoutmgr/list/ListItemContentLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/list/ListItemContentLayoutManager.java @@ -98,7 +98,7 @@ public class ListItemContentLayoutManager extends BlockStackingLayoutManager { } /** {@inheritDoc} */ - public LinkedList getChangedKnuthElements(List oldList, int alignment) { + public List getChangedKnuthElements(List oldList, int alignment) { //log.debug(" ListItemContentLayoutManager.getChanged>"); return super.getChangedKnuthElements(oldList, alignment); } diff --git a/src/java/org/apache/fop/layoutmgr/list/ListItemLayoutManager.java b/src/java/org/apache/fop/layoutmgr/list/ListItemLayoutManager.java index 9d08415ff..37ec4964d 100644 --- a/src/java/org/apache/fop/layoutmgr/list/ListItemLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/list/ListItemLayoutManager.java @@ -72,8 +72,8 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager private Block curBlockArea = null; - private LinkedList labelList = null; - private LinkedList bodyList = null; + private List labelList = null; + private List bodyList = null; private boolean discardBorderBefore; private boolean discardBorderAfter; @@ -190,11 +190,11 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager } /** {@inheritDoc} */ - public LinkedList getNextKnuthElements(LayoutContext context, int alignment) { + public List getNextKnuthElements(LayoutContext context, int alignment) { referenceIPD = context.getRefIPD(); LayoutContext childLC; - LinkedList returnList = new LinkedList(); + List returnList = new LinkedList(); if (!breakBeforeServed) { try { @@ -243,7 +243,7 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager this.keepWithNextPendingOnBody = childLC.getKeepWithNextPending(); // create a combined list - LinkedList returnedList = getCombinedKnuthElementsForListItem(labelList, bodyList, context); + List returnedList = getCombinedKnuthElementsForListItem(labelList, bodyList, context); // "wrap" the Position inside each element wrapPositionElements(returnedList, returnList, true); @@ -262,10 +262,9 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager return returnList; } - private LinkedList getCombinedKnuthElementsForListItem(LinkedList labelElements, - LinkedList bodyElements, - LayoutContext context) { - //Copy elements to array lists to improve element access performance + private List getCombinedKnuthElementsForListItem(List labelElements, + List bodyElements, LayoutContext context) { + // Copy elements to array lists to improve element access performance List[] elementLists = {new ArrayList(labelElements), new ArrayList(bodyElements)}; int[] fullHeights = {ElementListUtils.calcContentLength(elementLists[0]), @@ -429,7 +428,7 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager /** * {@inheritDoc} */ - public LinkedList getChangedKnuthElements(List oldList, int alignment) { + public List getChangedKnuthElements(List oldList, int alignment) { //log.debug(" LILM.getChanged> label"); // label labelList = label.getChangedKnuthElements(labelList, alignment); @@ -458,9 +457,9 @@ public class ListItemLayoutManager extends BlockStackingLayoutManager } } - LinkedList returnedList = body.getChangedKnuthElements(oldList, alignment); + List returnedList = body.getChangedKnuthElements(oldList, alignment); // "wrap" the Position inside each element - LinkedList tempList = returnedList; + List tempList = returnedList; KnuthElement tempElement; returnedList = new LinkedList(); ListIterator listIter = tempList.listIterator(); diff --git a/src/java/org/apache/fop/layoutmgr/table/RowGroupLayoutManager.java b/src/java/org/apache/fop/layoutmgr/table/RowGroupLayoutManager.java index 19b97322c..50688dd0e 100644 --- a/src/java/org/apache/fop/layoutmgr/table/RowGroupLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/table/RowGroupLayoutManager.java @@ -21,10 +21,10 @@ package org.apache.fop.layoutmgr.table; import java.util.Iterator; import java.util.LinkedList; +import java.util.List; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; - import org.apache.fop.fo.Constants; import org.apache.fop.fo.flow.table.EffRow; import org.apache.fop.fo.flow.table.GridUnit; @@ -116,7 +116,7 @@ class RowGroupLayoutManager { childLC.setRefIPD(spanWidth); //Get the element list for the cell contents - LinkedList elems = primary.getCellLM().getNextKnuthElements( + List elems = primary.getCellLM().getNextKnuthElements( childLC, alignment); ElementListObserver.observe(elems, "table-cell", primary.getCell().getId()); primary.setElements(elems); @@ -124,7 +124,7 @@ class RowGroupLayoutManager { } } computeRowHeights(); - LinkedList elements = tableStepper.getCombinedKnuthElementsForRowGroup(context, + List elements = tableStepper.getCombinedKnuthElementsForRowGroup(context, rowGroup, bodyType); returnList.addAll(elements); } diff --git a/src/java/org/apache/fop/layoutmgr/table/TableCellLayoutManager.java b/src/java/org/apache/fop/layoutmgr/table/TableCellLayoutManager.java index 6afb57dca..1b402095d 100644 --- a/src/java/org/apache/fop/layoutmgr/table/TableCellLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/table/TableCellLayoutManager.java @@ -20,13 +20,14 @@ package org.apache.fop.layoutmgr.table; import java.util.LinkedList; +import java.util.List; 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.Trait; +import org.apache.fop.fo.flow.ListItem; import org.apache.fop.fo.flow.table.ConditionalBorder; import org.apache.fop.fo.flow.table.GridUnit; import org.apache.fop.fo.flow.table.PrimaryGridUnit; @@ -126,16 +127,16 @@ public class TableCellLayoutManager extends BlockStackingLayoutManager /** * {@inheritDoc} */ - public LinkedList getNextKnuthElements(LayoutContext context, int alignment) { + public List getNextKnuthElements(LayoutContext context, int alignment) { MinOptMax stackLimit = new MinOptMax(context.getStackLimitBP()); referenceIPD = context.getRefIPD(); cellIPD = referenceIPD; cellIPD -= getIPIndents(); - LinkedList returnedList; - LinkedList contentList = new LinkedList(); - LinkedList returnList = new LinkedList(); + List returnedList; + List contentList = new LinkedList(); + List returnList = new LinkedList(); BlockLevelLayoutManager curLM; // currently active LM BlockLevelLayoutManager prevLM = null; // previously active LM @@ -187,13 +188,15 @@ public class TableCellLayoutManager extends BlockStackingLayoutManager } //Space resolution SpaceResolver.resolveElementList(returnList); - if (((KnuthElement) returnList.getFirst()).isForcedBreak()) { - primaryGridUnit.setBreakBefore(((KnuthPenalty) returnList.getFirst()).getBreakClass()); - returnList.removeFirst(); + if (((KnuthElement) returnList.get(0)).isForcedBreak()) { + primaryGridUnit.setBreakBefore(((KnuthPenalty) returnList.get(0)).getBreakClass()); + returnList.remove(0); assert !returnList.isEmpty(); } - if (((KnuthElement) returnList.getLast()).isForcedBreak()) { - KnuthPenalty p = (KnuthPenalty) returnList.getLast(); + final KnuthElement lastItem = (KnuthElement) returnList + .get(returnList.size() - 1); + if (((KnuthElement) lastItem).isForcedBreak()) { + KnuthPenalty p = (KnuthPenalty) lastItem; primaryGridUnit.setBreakAfter(p.getBreakClass()); p.setP(0); } diff --git a/src/java/org/apache/fop/layoutmgr/table/TableLayoutManager.java b/src/java/org/apache/fop/layoutmgr/table/TableLayoutManager.java index 0fe47d7b4..d370dc37f 100644 --- a/src/java/org/apache/fop/layoutmgr/table/TableLayoutManager.java +++ b/src/java/org/apache/fop/layoutmgr/table/TableLayoutManager.java @@ -178,9 +178,9 @@ public class TableLayoutManager extends BlockStackingLayoutManager } /** {@inheritDoc} */ - public LinkedList getNextKnuthElements(LayoutContext context, int alignment) { + public List getNextKnuthElements(LayoutContext context, int alignment) { - LinkedList returnList = new LinkedList(); + List returnList = new LinkedList(); /* * Compute the IPD and adjust it if necessary (overconstrained) @@ -271,8 +271,8 @@ public class TableLayoutManager extends BlockStackingLayoutManager int breakBefore = BreakUtil.compareBreakClasses(getTable().getBreakBefore(), childLC.getBreakBefore()); if (breakBefore != Constants.EN_AUTO) { - returnList.addFirst(new BreakElement(getAuxiliaryPosition(), - 0, -KnuthElement.INFINITE, breakBefore, context)); + returnList.add(0, new BreakElement(getAuxiliaryPosition(), 0, + -KnuthElement.INFINITE, breakBefore, context)); } //addKnuthElementsForBreakAfter(returnList, context); -- 2.39.5