Java tutorial
/* * 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: InlineLayoutManager.java 1334058 2012-05-04 16:52:35Z gadams $ */ package org.apache.fop.layoutmgr.inline; import java.util.Iterator; 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.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.BasicLink; 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.CommonFont; import org.apache.fop.fo.properties.CommonMarginInline; import org.apache.fop.fo.properties.SpaceProperty; import org.apache.fop.fonts.Font; import org.apache.fop.fonts.FontInfo; import org.apache.fop.fonts.FontTriplet; import org.apache.fop.layoutmgr.BlockKnuthSequence; import org.apache.fop.layoutmgr.BlockLevelLayoutManager; import org.apache.fop.layoutmgr.BreakElement; import org.apache.fop.layoutmgr.InlineKnuthSequence; import org.apache.fop.layoutmgr.KnuthBox; import org.apache.fop.layoutmgr.KnuthSequence; import org.apache.fop.layoutmgr.LayoutContext; import org.apache.fop.layoutmgr.LayoutManager; import org.apache.fop.layoutmgr.NonLeafPosition; import org.apache.fop.layoutmgr.Position; import org.apache.fop.layoutmgr.PositionIterator; import org.apache.fop.layoutmgr.SpaceSpecifier; import org.apache.fop.layoutmgr.TraitSetter; import org.apache.fop.traits.MinOptMax; import org.apache.fop.traits.SpaceVal; import org.apache.fop.util.ListUtil; /** * LayoutManager for objects which stack children in the inline direction, * such as Inline or Line */ public class InlineLayoutManager extends InlineStackingLayoutManager { /** * logging instance */ private static Log log = LogFactory.getLog(InlineLayoutManager.class); private CommonMarginInline inlineProps = null; private CommonBorderPaddingBackground borderProps = null; private boolean areaCreated = false; private LayoutManager lastChildLM = null; // Set when return last breakposs; 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; /** The keep-together property */ //private KeepProperty keepTogether; 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); } /** {@inheritDoc} */ @Override public void initialize() { InlineLevel fobj = (InlineLevel) this.fobj; int padding = 0; FontInfo fi = fobj.getFOEventHandler().getFontInfo(); CommonFont commonFont = fobj.getCommonFont(); FontTriplet[] fontkeys = commonFont.getFontState(fi); font = fi.getFontInstance(fontkeys[0], commonFont.fontSize.getValue(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(); } else if (fobj instanceof BasicLink) { alignmentAdjust = ((BasicLink) fobj).getAlignmentAdjust(); alignmentBaseline = ((BasicLink) fobj).getAlignmentBaseline(); baselineShift = ((BasicLink) fobj).getBaselineShift(); dominantBaseline = ((BasicLink) 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 = MinOptMax.getInstance(padding); } /** {@inheritDoc} */ @Override 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 MinOptMax.getInstance(borderAndPadding); } /** {@inheritDoc} */ @Override protected boolean hasLeadingFence(boolean isNotFirst) { return borderProps != null && (borderProps.getPadding(CommonBorderPaddingBackground.START, isNotFirst, this) > 0 || borderProps.getBorderWidth(CommonBorderPaddingBackground.START, isNotFirst) > 0); } /** {@inheritDoc} */ @Override protected boolean hasTrailingFence(boolean isNotLast) { return borderProps != null && (borderProps.getPadding(CommonBorderPaddingBackground.END, isNotLast, this) > 0 || borderProps.getBorderWidth(CommonBorderPaddingBackground.END, isNotLast) > 0); } /** {@inheritDoc} */ @Override protected SpaceProperty getSpaceStart() { return inlineProps != null ? inlineProps.spaceStart : null; } /** {@inheritDoc} */ @Override protected SpaceProperty getSpaceEnd() { return inlineProps != null ? inlineProps.spaceEnd : null; } /** * Create and initialize an <code>InlineArea</code> * * @param isInline true if the parent is an inline * @return the area */ protected InlineArea createArea(boolean isInline) { InlineArea area; if (isInline) { area = createInlineParent(); area.setBlockProgressionOffset(0); } else { area = new InlineBlockParent(); } if (fobj instanceof Inline || fobj instanceof BasicLink) { TraitSetter.setProducerID(area, fobj.getId()); } return area; } /** * Creates the inline area that will contain the areas returned by the * children of this layout manager. * * @return a new inline area */ protected InlineParent createInlineParent() { return new InlineParent(); } /** {@inheritDoc} */ @Override 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 */ 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()); } } /** {@inheritDoc} */ @Override // CSOK: MethodLength public List getNextKnuthElements(LayoutContext context, int alignment) { LayoutManager curLM; // the list returned by child LM List<KnuthSequence> returnedList; // the list which will be returned to the parent LM List<KnuthSequence> returnList = new LinkedList<KnuthSequence>(); KnuthSequence lastSequence = null; 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)); } } 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 = 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.isEmpty() && childLC.isKeepWithPreviousPending()) { childLC.clearKeepWithPreviousPending(); } if (returnedList == null || returnedList.isEmpty()) { // curLM returned null or an empty list, because it finished; // just iterate once more to see if there is another child continue; } if (curLM instanceof InlineLevelLayoutManager) { context.clearKeepWithNextPending(); // "wrap" the Position stored in each element of returnedList ListIterator seqIter = returnedList.listIterator(); while (seqIter.hasNext()) { KnuthSequence sequence = (KnuthSequence) seqIter.next(); sequence.wrapPositions(this); } int insertionStartIndex = 0; if (lastSequence != null && lastSequence.appendSequenceOrClose(returnedList.get(0))) { insertionStartIndex = 1; } // add border and padding to the first complete sequence of this LM if (!borderAdded && !returnedList.isEmpty()) { addKnuthElementsForBorderPaddingStart(returnedList.get(0)); borderAdded = true; } for (Iterator<KnuthSequence> iter = returnedList.listIterator(insertionStartIndex); iter .hasNext();) { returnList.add(iter.next()); } } 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.updateKeepWithNextPending(childLC.getKeepWithNextPending()); childLC.clearKeepsPending(); } lastSequence = ListUtil.getLast(returnList); lastChildLM = curLM; // the context used to create this childLC above was applied a LayoutContext.SUPPRESS_BREAK_BEFORE // in the getNextChildElements() method of the parent BlockLayoutManger; as a consequence all // line breaks in blocks nested inside the inline associated with this ILM are being supressed; // here we revert that supression; we do not need to do that for the first element since that // is handled by the getBreakBefore() method of the wrapping BlockStackingLayoutManager. // Note: this fix seems to work but is far from being the ideal way to do this childLC.setFlags(LayoutContext.SUPPRESS_BREAK_BEFORE, false); } if (lastSequence != null) { addKnuthElementsForBorderPaddingEnd(lastSequence); } setFinished(true); log.trace(trace); if (returnList.isEmpty()) { /* * if the FO itself is empty, but has an id specified * or associated fo:markers, then we still need a dummy * sequence to register its position in the area tree */ if (fobj.hasId() || fobj.hasMarkers()) { InlineKnuthSequence emptySeq = new InlineKnuthSequence(); emptySeq.add(new KnuthInlineBox(0, alignmentContext, notifyPos(getAuxiliaryPosition()), true)); returnList.add(emptySeq); } } return returnList.isEmpty() ? 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. */ @Override public void addAreas(PositionIterator parentIter, LayoutContext context) { addId(); setChildContext(new LayoutContext(context)); // Store current value // "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. List<Position> positionList = new LinkedList<Position>(); Position pos; LayoutManager lastLM = null; // last child LM in this iterator Position lastPos = null; while (parentIter.hasNext()) { pos = parentIter.next(); if (pos != null && pos.getPosition() != null) { if (isFirst(pos)) { /* * If this element is a descendant of a table-header/footer, * its content may be repeated over pages, so the generation * of its areas may be restarted. */ areaCreated = false; } positionList.add(pos.getPosition()); lastLM = pos.getPosition().getLM(); lastPos = pos; } } // 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)); } addMarkersToPage(true, !areaCreated, lastPos == null || isLast(lastPos)); InlineArea parent = createArea(lastLM == null || lastLM instanceof InlineLevelLayoutManager); parent.setBPD(alignmentContext.getHeight()); if (parent instanceof InlineParent) { parent.setBlockProgressionOffset(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.setBlockProgressionOffset( borderProps.getPaddingBefore(false, this) + borderProps.getBorderBeforeWidth(false)); } } setCurrentArea(parent); PositionIterator childPosIter = new PositionIterator(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)); parentLayoutManager.addChildArea(getCurrentArea()); addMarkersToPage(false, !areaCreated, lastPos == null || isLast(lastPos)); context.setFlags(LayoutContext.LAST_AREA, isLast); areaCreated = true; checkEndOfLayout(lastPos); } /** {@inheritDoc} */ @Override public void addChildArea(Area childArea) { Area parent = getCurrentArea(); if (getContext().resolveLeadingSpace()) { addSpace(parent, getContext().getLeadingSpace().resolve(false), getContext().getSpaceAdjust()); } parent.addChildArea(childArea); } /** {@inheritDoc} */ @Override public List getChangedKnuthElements(List oldList, int alignment, int depth) { List returnedList = new LinkedList(); addKnuthElementsForBorderPaddingStart(returnedList); returnedList.addAll(super.getChangedKnuthElements(oldList, alignment, depth)); 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) /* * If the returnlist is a BlockKnuthSequence, the border and padding should be added * to the first paragraph inside it, but it is too late to do that now. * At least, avoid adding it to the bpd sequence. */ if (returnList instanceof BlockKnuthSequence) { return; } CommonBorderPaddingBackground borderAndPadding = ((InlineLevel) 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) /* * If the returnlist is a BlockKnuthSequence, the border and padding should be added * to the last paragraph inside it, but it is too late to do that now. * At least, avoid adding it to the bpd sequence. */ if (returnList instanceof BlockKnuthSequence) { return; } CommonBorderPaddingBackground borderAndPadding = ((InlineLevel) 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 an auxiliary {@link Position} instance used for things like spaces. */ protected Position getAuxiliaryPosition() { return new NonLeafPosition(this, null); } }