/* * Copyright 1999-2006 The Apache Software Foundation. * * Licensed 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$ */ package org.apache.fop.layoutmgr.inline; import java.util.ListIterator; import java.util.LinkedList; import java.util.List; import org.apache.fop.area.Area; import org.apache.fop.area.inline.InlineArea; import org.apache.fop.area.inline.InlineBlockParent; import org.apache.fop.area.inline.InlineParent; import org.apache.fop.datatypes.Length; import org.apache.fop.fo.flow.Inline; import org.apache.fop.fo.flow.InlineLevel; import org.apache.fop.fo.flow.Leader; import org.apache.fop.fo.pagination.Title; import org.apache.fop.fo.properties.CommonBorderPaddingBackground; import org.apache.fop.fo.properties.CommonMarginInline; import org.apache.fop.fo.properties.SpaceProperty; import org.apache.fop.fonts.Font; import org.apache.fop.layoutmgr.BlockKnuthSequence; import org.apache.fop.layoutmgr.BlockLevelLayoutManager; import org.apache.fop.layoutmgr.BreakElement; import org.apache.fop.layoutmgr.KnuthBox; import org.apache.fop.layoutmgr.KnuthSequence; import org.apache.fop.layoutmgr.LayoutContext; import org.apache.fop.layoutmgr.NonLeafPosition; import org.apache.fop.layoutmgr.SpaceSpecifier; import org.apache.fop.layoutmgr.TraitSetter; import org.apache.fop.layoutmgr.LayoutManager; import org.apache.fop.layoutmgr.Position; import org.apache.fop.layoutmgr.PositionIterator; import org.apache.fop.traits.MinOptMax; import org.apache.fop.traits.SpaceVal; /** * LayoutManager for objects which stack children in the inline direction, * such as Inline or Line */ public class InlineLayoutManager extends InlineStackingLayoutManager { private InlineLevel fobj; private CommonMarginInline inlineProps = null; private CommonBorderPaddingBackground borderProps = null; private boolean areaCreated = false; private LayoutManager lastChildLM = null; // Set when return last breakposs; private Position auxiliaryPosition; private Font font; /** The alignment adjust property */ protected Length alignmentAdjust; /** The alignment baseline property */ protected int alignmentBaseline = EN_BASELINE; /** The baseline shift property */ protected Length baselineShift; /** The dominant baseline property */ protected int dominantBaseline; /** The line height property */ protected SpaceProperty lineHeight; private AlignmentContext alignmentContext = null; /** * Create an inline layout manager. * This is used for fo's that create areas that * contain inline areas. * * @param node the formatting object that creates the area */ // The node should be FObjMixed public InlineLayoutManager(InlineLevel node) { super(node); fobj = node; } private Inline getInlineFO() { return (Inline)fobj; } /** @see LayoutManager#initialize */ public void initialize() { int padding = 0; font = fobj.getCommonFont().getFontState(fobj.getFOEventHandler().getFontInfo(), this); lineHeight = fobj.getLineHeight(); borderProps = fobj.getCommonBorderPaddingBackground(); inlineProps = fobj.getCommonMarginInline(); if (fobj instanceof Inline) { alignmentAdjust = ((Inline)fobj).getAlignmentAdjust(); alignmentBaseline = ((Inline)fobj).getAlignmentBaseline(); baselineShift = ((Inline)fobj).getBaselineShift(); dominantBaseline = ((Inline)fobj).getDominantBaseline(); } else if (fobj instanceof Leader) { alignmentAdjust = ((Leader)fobj).getAlignmentAdjust(); alignmentBaseline = ((Leader)fobj).getAlignmentBaseline(); baselineShift = ((Leader)fobj).getBaselineShift(); dominantBaseline = ((Leader)fobj).getDominantBaseline(); } if (borderProps != null) { padding = borderProps.getPadding(CommonBorderPaddingBackground.BEFORE, false, this); padding += borderProps.getBorderWidth(CommonBorderPaddingBackground.BEFORE, false); padding += borderProps.getPadding(CommonBorderPaddingBackground.AFTER, false, this); padding += borderProps.getBorderWidth(CommonBorderPaddingBackground.AFTER, false); } extraBPD = new MinOptMax(padding); } /** @see InlineStackingLayoutManager#getExtraIPD(boolean, boolean) */ protected MinOptMax getExtraIPD(boolean isNotFirst, boolean isNotLast) { int borderAndPadding = 0; if (borderProps != null) { borderAndPadding = borderProps.getPadding(CommonBorderPaddingBackground.START, isNotFirst, this); borderAndPadding += borderProps.getBorderWidth(CommonBorderPaddingBackground.START, isNotFirst); borderAndPadding += borderProps.getPadding(CommonBorderPaddingBackground.END, isNotLast, this); borderAndPadding += borderProps.getBorderWidth(CommonBorderPaddingBackground.END, isNotLast); } return new MinOptMax(borderAndPadding); } /** @see InlineStackingLayoutManager#hasLeadingFence(boolean) */ protected boolean hasLeadingFence(boolean isNotFirst) { return borderProps != null && (borderProps.getPadding(CommonBorderPaddingBackground.START, isNotFirst, this) > 0 || borderProps.getBorderWidth(CommonBorderPaddingBackground.START, isNotFirst) > 0 ); } /** @see InlineStackingLayoutManager#hasTrailingFence(boolean) */ protected boolean hasTrailingFence(boolean isNotLast) { return borderProps != null && (borderProps.getPadding(CommonBorderPaddingBackground.END, isNotLast, this) > 0 || borderProps.getBorderWidth(CommonBorderPaddingBackground.END, isNotLast) > 0 ); } /** @see InlineStackingLayoutManager#getSpaceStart */ protected SpaceProperty getSpaceStart() { return inlineProps != null ? inlineProps.spaceStart : null; } /** @see InlineStackingLayoutManager#getSpaceEnd */ protected SpaceProperty getSpaceEnd() { return inlineProps != null ? inlineProps.spaceEnd : null; } /** @see org.apache.fop.layoutmgr.inline.InlineLayoutManager#createArea(boolean) */ protected InlineArea createArea(boolean hasInlineParent) { InlineArea area; if (hasInlineParent) { area = new InlineParent(); area.setOffset(0); } else { area = new InlineBlockParent(); } if (fobj instanceof Inline) { TraitSetter.setProducerID(area, getInlineFO().getId()); } return area; } /** * @see org.apache.fop.layoutmgr.inline.InlineStackingLayoutManager#setTraits(boolean, boolean) */ protected void setTraits(boolean isNotFirst, boolean isNotLast) { if (borderProps != null) { // Add border and padding to current area and set flags (FIRST, LAST ...) TraitSetter.setBorderPaddingTraits(getCurrentArea(), borderProps, isNotFirst, isNotLast, this); TraitSetter.addBackground(getCurrentArea(), borderProps, this); } } /** * @return true if this element must be kept together */ // TODO Use the keep-together property on Inline as well public boolean mustKeepTogether() { return mustKeepTogether(this.getParent()); } private boolean mustKeepTogether(LayoutManager lm) { if (lm instanceof BlockLevelLayoutManager) { return ((BlockLevelLayoutManager) lm).mustKeepTogether(); } else if (lm instanceof InlineLayoutManager) { return ((InlineLayoutManager) lm).mustKeepTogether(); } else { return mustKeepTogether(lm.getParent()); } } /** @see org.apache.fop.layoutmgr.LayoutManager */ public LinkedList getNextKnuthElements(LayoutContext context, int alignment) { LayoutManager curLM; // the list returned by child LM LinkedList returnedList; // the list which will be returned to the parent LM LinkedList returnList = new LinkedList(); KnuthSequence lastSequence = null; SpaceSpecifier leadingSpace = context.getLeadingSpace(); if (fobj instanceof Title) { alignmentContext = new AlignmentContext(font, lineHeight.getOptimum(this).getLength().getValue(this), context.getWritingMode()); } else { alignmentContext = new AlignmentContext(font , lineHeight.getOptimum(this).getLength().getValue(this) , alignmentAdjust , alignmentBaseline , baselineShift , dominantBaseline , context.getAlignmentContext()); } childLC = new LayoutContext(context); childLC.setAlignmentContext(alignmentContext); if (context.startsNewArea()) { // First call to this LM in new parent "area", but this may // not be the first area created by this inline if (getSpaceStart() != null) { context.getLeadingSpace().addSpace(new SpaceVal(getSpaceStart(), this)); } // Check for "fence" if (hasLeadingFence(!context.isFirstArea())) { // Reset leading space sequence for child areas leadingSpace = new SpaceSpecifier(false); } // Reset state variables clearPrevIPD(); // Clear stored prev content dimensions } StringBuffer trace = new StringBuffer("InlineLM:"); // We'll add the border to the first inline sequence created. // This flag makes sure we do it only once. boolean borderAdded = false; if (borderProps != null) { childLC.setLineStartBorderAndPaddingWidth(context.getLineStartBorderAndPaddingWidth() + borderProps.getPaddingStart(true, this) + borderProps.getBorderStartWidth(true) ); childLC.setLineEndBorderAndPaddingWidth(context.getLineEndBorderAndPaddingWidth() + borderProps.getPaddingEnd(true, this) + borderProps.getBorderEndWidth(true) ); } while ((curLM = (LayoutManager) getChildLM()) != null) { if (!(curLM instanceof InlineLevelLayoutManager)) { // A block LM // Leave room for start/end border and padding if (borderProps != null) { childLC.setRefIPD(childLC.getRefIPD() - borderProps.getPaddingStart(lastChildLM != null, this) - borderProps.getBorderStartWidth(lastChildLM != null) - borderProps.getPaddingEnd(hasNextChildLM(), this) - borderProps.getBorderEndWidth(hasNextChildLM())); } } // get KnuthElements from curLM returnedList = curLM.getNextKnuthElements(childLC, alignment); if (returnList.size() == 0 && childLC.isKeepWithPreviousPending()) { childLC.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING, false); } if (returnedList == null) { // curLM returned null because it finished; // just iterate once more to see if there is another child continue; } if (returnedList.size() == 0) { continue; } if (curLM instanceof InlineLevelLayoutManager) { context.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING, false); // "wrap" the Position stored in each element of returnedList ListIterator seqIter = returnedList.listIterator(); while (seqIter.hasNext()) { KnuthSequence sequence = (KnuthSequence) seqIter.next(); sequence.wrapPositions(this); } if (lastSequence != null && lastSequence.appendSequenceOrClose ((KnuthSequence) returnedList.get(0))) { returnedList.remove(0); } // add border and padding to the first complete sequence of this LM if (!borderAdded && returnedList.size() != 0) { addKnuthElementsForBorderPaddingStart((KnuthSequence) returnedList.get(0)); borderAdded = true; } returnList.addAll(returnedList); } else { // A block LM BlockKnuthSequence sequence = new BlockKnuthSequence(returnedList); sequence.wrapPositions(this); boolean appended = false; if (lastSequence != null) { if (lastSequence.canAppendSequence(sequence)) { BreakElement bk = new BreakElement(new Position(this), 0, context); boolean keepTogether = (mustKeepTogether() || context.isKeepWithNextPending() || childLC.isKeepWithPreviousPending()); appended = lastSequence.appendSequenceOrClose(sequence, keepTogether, bk); } else { lastSequence.endSequence(); } } if (!appended) { // add border and padding to the first complete sequence of this LM if (!borderAdded) { addKnuthElementsForBorderPaddingStart(sequence); borderAdded = true; } returnList.add(sequence); } // propagate and clear context.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING, childLC.isKeepWithNextPending()); childLC.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING, false); childLC.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING, false); } lastSequence = (KnuthSequence) returnList.getLast(); lastChildLM = curLM; } if (lastSequence != null) { addKnuthElementsForBorderPaddingEnd(lastSequence); } setFinished(true); log.trace(trace); return returnList.size() == 0 ? null : returnList; } /** * Generate and add areas to parent area. * Set size of each area. This should only create and return one * inline area for any inline parent area. * * @param parentIter Iterator over Position information returned * by this LayoutManager. * @param context layout context. */ public void addAreas(PositionIterator parentIter, LayoutContext context) { Position lastPos = null; addId(); setChildContext(new LayoutContext(context)); // Store current value // If this LM has fence, make a new leading space specifier. if (hasLeadingFence(areaCreated)) { getContext().setLeadingSpace(new SpaceSpecifier(false)); getContext().setFlags(LayoutContext.RESOLVE_LEADING_SPACE, true); } else { getContext().setFlags(LayoutContext.RESOLVE_LEADING_SPACE, false); } if (getSpaceStart() != null) { context.getLeadingSpace().addSpace(new SpaceVal(getSpaceStart(), this)); } // "Unwrap" the NonLeafPositions stored in parentIter and put // them in a new list. Set lastLM to be the LayoutManager // which created the last Position: if the LAST_AREA flag is // 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(); NonLeafPosition pos = null; LayoutManager lastLM = null; // last child LM in this iterator while (parentIter.hasNext()) { pos = (NonLeafPosition) parentIter.next(); if (pos != null && pos.getPosition() != null) { positionList.add(pos.getPosition()); lastLM = pos.getPosition().getLM(); lastPos = pos; } } /*if (pos != null) { lastLM = pos.getPosition().getLM(); }*/ InlineArea parent = createArea(lastLM == null || lastLM instanceof InlineLevelLayoutManager); parent.setBPD(alignmentContext.getHeight()); if (parent instanceof InlineParent) { parent.setOffset(alignmentContext.getOffset()); } else if (parent instanceof InlineBlockParent) { // All inline elements are positioned by the renderers relative to // the before edge of their content rectangle if (borderProps != null) { parent.setOffset(borderProps.getPaddingBefore(false, this) + borderProps.getBorderBeforeWidth(false)); } } setCurrentArea(parent); StackingIter childPosIter = new StackingIter(positionList.listIterator()); LayoutManager prevLM = null; LayoutManager childLM; while ((childLM = childPosIter.getNextChildLM()) != null) { getContext().setFlags(LayoutContext.LAST_AREA, context.isLastArea() && childLM == lastLM); childLM.addAreas(childPosIter, getContext()); getContext().setLeadingSpace(getContext().getTrailingSpace()); getContext().setFlags(LayoutContext.RESOLVE_LEADING_SPACE, true); prevLM = childLM; } /* If this LM has a trailing fence, resolve trailing space * specs from descendants. Otherwise, propagate any trailing * space specs to the parent LM via the layout context. If * the last child LM called returns LAST_AREA in the layout * context and it is the last child LM for this LM, then this * must be the last area for the current LM too. */ boolean isLast = (getContext().isLastArea() && prevLM == lastChildLM); if (hasTrailingFence(isLast)) { addSpace(getCurrentArea(), getContext().getTrailingSpace().resolve(false), getContext().getSpaceAdjust()); context.setTrailingSpace(new SpaceSpecifier(false)); } else { // Propagate trailing space-spec sequence to parent LM in context. context.setTrailingSpace(getContext().getTrailingSpace()); } // Add own trailing space to parent context (or set on area?) if (context.getTrailingSpace() != null && getSpaceEnd() != null) { context.getTrailingSpace().addSpace(new SpaceVal(getSpaceEnd(), this)); } // Not sure if lastPos can legally be null or if that masks a different problem. // But it seems to fix bug 38053. setTraits(areaCreated, lastPos == null || !isLast(lastPos)); parentLM.addChildArea(getCurrentArea()); context.setFlags(LayoutContext.LAST_AREA, isLast); areaCreated = true; } /** @see LayoutManager#addChildArea(Area) */ public void addChildArea(Area childArea) { Area parent = getCurrentArea(); if (getContext().resolveLeadingSpace()) { addSpace(parent, getContext().getLeadingSpace().resolve(false), getContext().getSpaceAdjust()); } parent.addChildArea(childArea); } /** @see LayoutManager#getChangedKnuthElements(List, int) */ public LinkedList getChangedKnuthElements(List oldList, int alignment) { LinkedList returnedList = new LinkedList(); addKnuthElementsForBorderPaddingStart(returnedList); returnedList.addAll(super.getChangedKnuthElements(oldList, alignment)); addKnuthElementsForBorderPaddingEnd(returnedList); return returnedList; } /** * Creates Knuth elements for start border padding and adds them to the return list. * @param returnList return list to add the additional elements to */ protected void addKnuthElementsForBorderPaddingStart(List returnList) { //Border and Padding (start) CommonBorderPaddingBackground borderAndPadding = fobj.getCommonBorderPaddingBackground(); if (borderAndPadding != null) { int ipStart = borderAndPadding.getBorderStartWidth(false) + borderAndPadding.getPaddingStart(false, this); if (ipStart > 0) { returnList.add(0,new KnuthBox(ipStart, getAuxiliaryPosition(), true)); } } } /** * Creates Knuth elements for end border padding and adds them to the return list. * @param returnList return list to add the additional elements to */ protected void addKnuthElementsForBorderPaddingEnd(List returnList) { //Border and Padding (after) CommonBorderPaddingBackground borderAndPadding = fobj.getCommonBorderPaddingBackground(); if (borderAndPadding != null) { int ipEnd = borderAndPadding.getBorderEndWidth(false) + borderAndPadding.getPaddingEnd(false, this); if (ipEnd > 0) { returnList.add(new KnuthBox(ipEnd, getAuxiliaryPosition(), true)); } } } /** @return a cached auxiliary Position instance used for things like spaces. */ protected Position getAuxiliaryPosition() { //if (this.auxiliaryPosition == null) { //this.auxiliaryPosition = new NonLeafPosition(this, new LeafPosition(this, -1)); this.auxiliaryPosition = new NonLeafPosition(this, null); //} return this.auxiliaryPosition; } /** @see org.apache.fop.layoutmgr.inline.LeafNodeLayoutManager#addId() */ protected void addId() { if (fobj instanceof Inline) { getPSLM().addIDToPage(getInlineFO().getId()); } } }