/**
* @param parentContext the context to be used for all percentages other than lengthBase
- * @param lengthBase the particular percentage length base for which this context provides a value
+ * @param lengthBase the particular percentage length base for which this context provides
+ * a value
* @param lengthBaseValue the value to be returned for requests to the given lengthBase
*/
public SimplePercentBaseContext(PercentBaseContext parentContext,
--- /dev/null
+/*
+ * Copyright 2005 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: SimplePercentBaseContext.java 279656 2005-09-08 22:06:48Z pietsch $ */
+
+package org.apache.fop.datatypes;
+
+import org.apache.fop.fo.FObj;
+
+/**
+ * This base context is used during validation when the actual base values are still unknown
+ * but should still already be checked. The actual value returned is not so important in this
+ * case. But it's important that zero and non-zero values can be distinguished.
+ * <p>
+ * Example: A table with collapsing border model has no padding. The Table FO should be able
+ * to check if non-zero values (even percentages) have been specified.
+ */
+public final class ValidationPercentBaseContext implements PercentBaseContext {
+
+ /**
+ * Main constructor.
+ */
+ private ValidationPercentBaseContext() {
+ }
+
+ /**
+ * Returns the value for the given lengthBase.
+ * @see org.apache.fop.datatypes.PercentBaseContext#getBaseLength(int, FObj)
+ */
+ public int getBaseLength(int lengthBase, FObj fobj) {
+ //Simply return a dummy value which produces a non-zero value when a non-zero percentage
+ //was specified.
+ return 100000;
+ }
+
+ private static PercentBaseContext pseudoContextForValidation = null;
+
+ /** @return a base context for validation purposes. See class description. */
+ public static PercentBaseContext getPseudoContextForValidationPurposes() {
+ if (pseudoContextForValidation == null) {
+ pseudoContextForValidation = new ValidationPercentBaseContext();
+ }
+ return pseudoContextForValidation;
+ }
+
+}
* @param problem text to display that indicates the problem
*/
protected void attributeWarning(String problem) {
- log.warn(errorText(locator) + getName() + ", " + problem);
+ log.warn(warningText(locator) + getName() + ", " + problem);
}
/**
* @param loc org.xml.sax.Locator object
* @return String the formatted text
*/
- protected static String getLocatorString(Locator loc) {
+ public static String getLocatorString(Locator loc) {
if (loc == null) {
return "Unknown location";
} else {
import org.xml.sax.Locator;
import org.apache.fop.apps.FOPException;
-import org.apache.fop.datatypes.Numeric;
+import org.apache.fop.datatypes.ValidationPercentBaseContext;
import org.apache.fop.fo.FONode;
-import org.apache.fop.fo.FObj;
import org.apache.fop.fo.PropertyList;
import org.apache.fop.fo.StaticPropertyList;
import org.apache.fop.fo.ValidationException;
colPList.setWritingMode();
defaultColumn.bind(colPList);
- /*if (borderCollapse != EN_SEPARATE && commonBorderPaddingBackground.hasPadding()) {
- //See "17.6.2 The collapsing border model" in CSS2
- getLogger().warn("Table may not have padding when using the collapsing "
- + "border model. Padding will be ignored.");
- }*/
if (borderCollapse != EN_SEPARATE) {
- getLogger().warn("The collapsing border model on an fo:table "
+ attributeWarning("The collapsing border model on an fo:table "
+ "is currently not supported by FOP");
}
if (tableLayout == EN_AUTO) {
- getLogger().warn("table-layout=\"auto\" is currently not supported by FOP");
+ attributeWarning("table-layout=\"auto\" is currently not supported by FOP");
+ }
+ if (!isSeparateBorderModel() && getCommonBorderPaddingBackground().hasPadding(
+ ValidationPercentBaseContext.getPseudoContextForValidationPurposes())) {
+ //See "17.6.2 The collapsing border model" in CSS2
+ attributeWarning("In collapsing border model a table does not have padding"
+ + " (see http://www.w3.org/TR/REC-CSS2/tables.html#collapsing-borders)"
+ + ", but a non-zero value for padding was found. The padding will be ignored.");
}
}
* @see org.apache.fop.fo.FONode#addChildNode(FONode)
*/
protected void addChildNode(FONode child) throws FOPException {
- if (child.getName().equals("fo:table-column")) {
+ if ("fo:table-column".equals(child.getName())) {
addColumnNode((TableColumn) child);
- } else if (child.getName().equals("fo:table-footer")) {
+ } else if ("fo:table-footer".equals(child.getName())) {
tableFooter = (TableBody)child;
- } else if (child.getName().equals("fo:table-header")) {
+ } else if ("fo:table-header".equals(child.getName())) {
tableHeader = (TableBody)child;
} else {
// add bodies
import org.apache.fop.apps.FOPException;
import org.apache.fop.datatypes.Numeric;
+import org.apache.fop.datatypes.ValidationPercentBaseContext;
import org.apache.fop.fo.FONode;
import org.apache.fop.fo.FObj;
import org.apache.fop.fo.PropertyList;
/**
* Superclass for table-related FOs
- *
*/
-
public abstract class TableFObj extends FObj {
private Numeric borderAfterPrecedence;
if (getNameId() != FO_TABLE && getNameId() != FO_TABLE_CELL
&& getTable().isSeparateBorderModel()
&& getCommonBorderPaddingBackground().hasBorderInfo()) {
- getLogger().warn("Borders on " + getName()
- + " non-applicable for table with border-collapse=\"separate\"");
+ attributeWarning("In the separate border model (border-collapse=\"separate\")"
+ + ", borders cannot be specified on a " + getName()
+ + ", but a non-zero value for border was found. The border will be ignored. ");
+ }
+ if (getNameId() != FO_TABLE //Separate check for fo:table in Table.java
+ && getNameId() != FO_TABLE_CELL
+ && getCommonBorderPaddingBackground().hasPadding(
+ ValidationPercentBaseContext.getPseudoContextForValidationPurposes())) {
+ attributeWarning(getName() + " does not have padding"
+ + " (see the property list for " + getName() + " in XSL 1.0)"
+ + ", but a non-zero value for padding was found. The padding will be ignored.");
}
}
return this.startOn;
}
- public BlockSequence endBlockSequence() {
- KnuthSequence temp = super.endSequence();
+ public BlockSequence endBlockSequence(Position breakPosition) {
+ KnuthSequence temp = super.endSequence(breakPosition);
if (temp != null) {
BlockSequence returnSequence = new BlockSequence(startOn);
returnSequence.addAll(temp);
ListIterator effectiveListIterator = effectiveList.listIterator();
int startElementIndex = 0;
int endElementIndex = 0;
+ int lastBreak = -1;
for (int p = 0; p < partCount; p++) {
PageBreakPosition pbp = (PageBreakPosition) alg.getPageBreaks().get(p);
int displayAlign = getCurrentDisplayAlign();
+ //The following is needed by SpaceResolver.performConditionalsNotification()
+ //further down as there may be important Position elements in the element list trailer
+ int notificationEndElementIndex = endElementIndex;
+
// ignore the last elements added by the
// PageSequenceLayoutManager
endElementIndex -= (endElementIndex == (originalList.size() - 1))
while (effectiveListIterator.hasNext()
&& !(firstElement = (KnuthElement) effectiveListIterator.next())
.isBox()) {
- if (firstElement.isGlue()) {
+ /*
+ if (firstElement.isGlue() && firstElement.getLayoutManager() != null) {
// discard the space representd by the glue element
((BlockLevelLayoutManager) firstElement
.getLayoutManager())
.discardSpace((KnuthGlue) firstElement);
- }
+ }*/
startElementIndex++;
}
}
/* *** *** non-standard extension *** *** */
+ // Handle SpaceHandling(Break)Positions, see SpaceResolver!
+ SpaceResolver.performConditionalsNotification(effectiveList,
+ startElementIndex, notificationEndElementIndex, lastBreak);
+
+ // Add areas now!
addAreas(new KnuthPossPosIter(effectiveList,
startElementIndex, endElementIndex + 1), childLC);
} else {
finishPart(alg, pbp);
+ lastBreak = endElementIndex;
startElementIndex = pbp.getLeafPos() + 1;
}
}
-
+ /**
+ * Notifies the layout managers about the space and conditional length situation based on
+ * the break decisions.
+ * @param effectiveList Element list to be painted
+ * @param startElementIndex start index of the part
+ * @param endElementIndex end index of the part
+ * @param lastBreak index of the last break element
+ */
/**
* Handles span changes reported through the <code>LayoutContext</code>.
* Only used by the PSLM and called by <code>getNextBlockList()</code>.
//Only implemented by the PSLM
nextSequenceStartsOn = handleSpanChange(childLC, nextSequenceStartsOn);
+ Position breakPosition = null;
if (((KnuthElement) returnedList.getLast()).isPenalty()
&& ((KnuthPenalty) returnedList.getLast()).getP() == -KnuthElement.INFINITE) {
KnuthPenalty breakPenalty = (KnuthPenalty) returnedList
.removeLast();
+ breakPosition = breakPenalty.getPosition();
switch (breakPenalty.getBreakClass()) {
case Constants.EN_PAGE:
log.debug("PLM> break - PAGE");
}
blockList.addAll(returnedList);
BlockSequence seq = null;
- seq = blockList.endBlockSequence();
+ seq = blockList.endBlockSequence(breakPosition);
if (seq != null) {
blockLists.add(seq);
}
import java.util.Iterator;
import java.util.LinkedList;
+import org.apache.fop.layoutmgr.SpaceResolver.SpaceHandlingBreakPosition;
+
+/**
+ * Utility class which provides common code for the addAreas stage.
+ */
public class AreaAdditionUtil {
private static class StackingIter extends PositionIterator {
}
}
+ /**
+ * Creates the child areas for the given layout manager.
+ * @param bslm the BlockStackingLayoutManager instance for which "addAreas" is performed.
+ * @param parentIter the position iterator
+ * @param layoutContext the layout context
+ */
public static void addAreas(BlockStackingLayoutManager bslm,
PositionIterator parentIter, LayoutContext layoutContext) {
LayoutManager childLM = null;
Position pos;
while (parentIter.hasNext()) {
pos = (Position)parentIter.next();
+ if (pos == null) {
+ continue;
+ }
if (pos.getIndex() >= 0) {
if (firstPos == null) {
firstPos = pos;
if (firstLM == null) {
firstLM = lastLM;
}
+ } else if (pos instanceof SpaceHandlingBreakPosition) {
+ positionList.add(pos);
} else {
// pos was created by this LM, so it must be ignored
}
}
- if (bslm.markers != null) {
+ if (bslm != null && bslm.markers != null) {
bslm.getCurrentPV().addMarkers(bslm.markers, true,
bslm.isFirst(firstPos), bslm.isLast(lastPos));
}
lc.setStackLimit(layoutContext.getStackLimit());
childLM.addAreas(childPosIter, lc);
}
- if (bslm.markers != null) {
+ if (bslm != null && bslm.markers != null) {
bslm.getCurrentPV().addMarkers(bslm.markers, false,
bslm.isFirst(firstPos), bslm.isLast(lastPos));
}
/**
* LayoutManager for a block-container FO.
*/
-public class BlockContainerLayoutManager extends BlockStackingLayoutManager {
+public class BlockContainerLayoutManager extends BlockStackingLayoutManager
+ implements ConditionalElementListener {
private BlockViewport viewportBlockArea;
private Block referenceArea;
private MinOptMax foBlockSpaceBefore;
private MinOptMax foBlockSpaceAfter;
+ private boolean discardBorderBefore;
+ private boolean discardBorderAfter;
+ private boolean discardPaddingBefore;
+ private boolean discardPaddingAfter;
+ private MinOptMax effSpaceBefore;
+ private MinOptMax effSpaceAfter;
+
+
/**
* Create a new block container layout manager.
* @param node block-container node to create the layout manager for.
super(node);
}
+ /** @see org.apache.fop.layoutmgr.LayoutManager#initialize() */
public void initialize() {
abProps = getBlockContainerFO().getCommonAbsolutePosition();
foBlockSpaceBefore = new SpaceVal(getBlockContainerFO().getCommonMarginBlock()
.spaceAfter.getSpace().getMinimum(this).getLength().getValue(this);
}
}
+
+ private void resetSpaces() {
+ this.discardBorderBefore = false;
+ this.discardBorderAfter = false;
+ this.discardPaddingBefore = false;
+ this.discardPaddingAfter = false;
+ this.effSpaceBefore = foSpaceBefore;
+ this.effSpaceAfter = foSpaceAfter;
+ }
/** @return the content IPD */
protected int getRotatedIPD() {
/** @see org.apache.fop.layoutmgr.LayoutManager */
public LinkedList getNextKnuthElements(LayoutContext context, int alignment) {
+ resetSpaces();
if (isAbsoluteOrFixed()) {
return getNextKnuthElementsAbsolute(context, alignment);
}
if (!bBreakBeforeServed) {
try {
- if (addKnuthElementsForBreakBefore(returnList)) {
+ if (addKnuthElementsForBreakBefore(returnList, context)) {
return returnList;
}
} finally {
}
}
- if (!bSpaceBeforeServed) {
- addKnuthElementsForSpaceBefore(returnList, alignment);
- bSpaceBeforeServed = true;
- }
+ addKnuthElementsForSpaceBefore(returnList, alignment);
- addKnuthElementsForBorderPaddingBefore(returnList);
+ addKnuthElementsForBorderPaddingBefore(returnList, !firstVisibleMarkServed);
+ firstVisibleMarkServed = true;
if (autoHeight) {
+ //Spaces, border and padding to be repeated at each break
+ addPendingMarks(context);
+
BlockLevelLayoutManager curLM; // currently active LM
BlockLevelLayoutManager prevLM = null; // previously active LM
while ((curLM = (BlockLevelLayoutManager) getChildLM()) != null) {
LayoutContext childLC = new LayoutContext(0);
+ childLC.copyPendingMarksFrom(context);
// curLM is a ?
childLC.setStackLimit(MinOptMax.subtract(context
.getStackLimit(), stackLimit));
// get elements from curLM
returnedList = curLM.getNextKnuthElements(childLC, alignment);
if (returnedList.size() == 1
- && ((KnuthElement)returnedList.getFirst()).isPenalty()
- && ((KnuthPenalty)returnedList.getFirst()).getP()
- == -KnuthElement.INFINITE) {
+ && ((KnuthElement)returnedList.getFirst()).isForcedBreak()) {
// a descendant of this block has break-before
+ /*
if (returnList.size() == 0) {
// the first child (or its first child ...) has
// break-before;
// the
// following page
bSpaceBeforeServed = false;
- }
+ }*/
contentList.addAll(returnedList);
// "wrap" the Position inside each element
|| curLM.mustKeepWithPrevious()) {
// add an infinite penalty to forbid a break between
// blocks
- contentList.add(new KnuthPenalty(0,
- KnuthElement.INFINITE, false,
- new Position(this), false));
+ contentList.add(new BreakElement(
+ new Position(this), KnuthElement.INFINITE, context));
+ //contentList.add(new KnuthPenalty(0,
+ // KnuthElement.INFINITE, false,
+ // new Position(this), false));
} else if (!((KnuthElement) contentList.getLast()).isGlue()) {
// add a null penalty to allow a break between blocks
- contentList.add(new KnuthPenalty(0, 0, false,
- new Position(this), false));
+ contentList.add(new BreakElement(
+ new Position(this), 0, context));
+ //contentList.add(new KnuthPenalty(0, 0, false,
+ // new Position(this), false));
} else {
// the last element in contentList is a glue;
// it is a feasible breakpoint, there is no need to add
//Avoid NoSuchElementException below (happens with empty blocks)
continue;
}
- if (((KnuthElement) returnedList.getLast()).isPenalty()
- && ((KnuthPenalty) returnedList.getLast()).getP()
- == -KnuthElement.INFINITE) {
+ if (((ListElement)returnedList.getLast()).isForcedBreak()) {
// a descendant of this block has break-after
if (curLM.isFinished()) {
// there is no other content in this block;
}
}
}
- addKnuthElementsForBorderPaddingAfter(returnList);
+ addKnuthElementsForBorderPaddingAfter(returnList, true);
addKnuthElementsForSpaceAfter(returnList, alignment);
- addKnuthElementsForBreakAfter(returnList);
+ addKnuthElementsForBreakAfter(returnList, context);
setFinished(true);
return returnList;
contentRectOffsetX += getBlockContainerFO()
.getCommonMarginBlock().startIndent.getValue(this);
double contentRectOffsetY = offset.getY();
- contentRectOffsetY += getSpaceBefore();
+ contentRectOffsetY += getSpaceBefore(); //TODO Uhm, is that necessary?
contentRectOffsetY += getBlockContainerFO()
.getCommonBorderPaddingBackground().getBorderBeforeWidth(false);
contentRectOffsetY += getBlockContainerFO()
}
if (returnedList != null) {
bclm.wrapPositionElements(returnedList, returnList);
- //returnList.addAll(returnedList);
}
}
+ SpaceResolver.resolveElementList(returnList);
setFinished(true);
return returnList;
}
return new Point(x, y);
}
- /**
- * @see org.apache.fop.layoutmgr.LayoutManager#addAreas(org.apache.fop.layoutmgr.PositionIterator, org.apache.fop.layoutmgr.LayoutContext)
- */
+ /** @see org.apache.fop.layoutmgr.LayoutManager */
public void addAreas(PositionIterator parentIter,
LayoutContext layoutContext) {
getParentArea(null);
//}
}
- // if adjusted space before
- if (bSpaceBefore) {
- addBlockSpacing(0, new MinOptMax(adjustedSpaceBefore));
- }
-
while ((childLM = childPosIter.getNextChildLM()) != null) {
// set last area flag
lc.setFlags(LayoutContext.LAST_AREA,
childLM.addAreas(childPosIter, lc);
}
} else {
- // if adjusted space before
- if (bSpaceBefore) {
- addBlockSpacing(0, new MinOptMax(adjustedSpaceBefore));
- }
//Add child areas inside the reference area
bcpos.getBreaker().addContainedAreas();
}
- //int bIndents = getBlockContainerFO().getCommonBorderPaddingBackground()
- // .getBPPaddingAndBorder(false);
-
if (markers != null) {
getCurrentPV().addMarkers(markers, false, isFirst(firstPos), isLast(lastPos));
}
+ TraitSetter.addSpaceBeforeAfter(viewportBlockArea, layoutContext.getSpaceAdjust(),
+ effSpaceBefore, effSpaceAfter);
flush();
- // if adjusted space after
- if (bSpaceAfter) {
- addBlockSpacing(0, new MinOptMax(adjustedSpaceAfter));
- }
-
viewportBlockArea = null;
referenceArea = null;
+ resetSpaces();
}
/**
TraitSetter.setProducerID(viewportBlockArea, getBlockContainerFO().getId());
TraitSetter.addBorders(viewportBlockArea,
- getBlockContainerFO().getCommonBorderPaddingBackground(), this);
+ getBlockContainerFO().getCommonBorderPaddingBackground(),
+ discardBorderBefore, discardBorderAfter, false, false, this);
+ TraitSetter.addPadding(viewportBlockArea,
+ getBlockContainerFO().getCommonBorderPaddingBackground(),
+ discardPaddingBefore, discardPaddingAfter, false, false, this);
// TraitSetter.addBackground(viewportBlockArea,
// getBlockContainerFO().getCommonBorderPaddingBackground(),
// this);
}
}
- /**
- * @see org.apache.fop.layoutmgr.BlockLevelLayoutManager#negotiateBPDAdjustment(int, org.apache.fop.layoutmgr.KnuthElement)
- */
+ /** @see org.apache.fop.layoutmgr.BlockLevelLayoutManager */
public int negotiateBPDAdjustment(int adj, KnuthElement lastElement) {
// TODO Auto-generated method stub
return 0;
}
- /**
- * @see org.apache.fop.layoutmgr.BlockLevelLayoutManager#discardSpace(org.apache.fop.layoutmgr.KnuthGlue)
- */
+ /** @see org.apache.fop.layoutmgr.BlockLevelLayoutManager */
public void discardSpace(KnuthGlue spaceGlue) {
// TODO Auto-generated method stub
public boolean getGeneratesBlockArea() {
return true;
}
-
+
+ /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+ public void notifySpace(RelSide side, MinOptMax effectiveLength) {
+ if (RelSide.BEFORE == side) {
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Space " + side + ", "
+ + this.effSpaceBefore + "-> " + effectiveLength);
+ }
+ this.effSpaceBefore = effectiveLength;
+ } else {
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Space " + side + ", "
+ + this.effSpaceAfter + "-> " + effectiveLength);
+ }
+ this.effSpaceAfter = effectiveLength;
+ }
+ }
+
+ /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+ public void notifyBorder(RelSide side, MinOptMax effectiveLength) {
+ if (effectiveLength == null) {
+ if (RelSide.BEFORE == side) {
+ this.discardBorderBefore = true;
+ } else {
+ this.discardBorderAfter = true;
+ }
+ }
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Border " + side + " -> " + effectiveLength);
+ }
+ }
+
+ /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+ public void notifyPadding(RelSide side, MinOptMax effectiveLength) {
+ if (effectiveLength == null) {
+ if (RelSide.BEFORE == side) {
+ this.discardPaddingBefore = true;
+ } else {
+ this.discardPaddingAfter = true;
+ }
+ }
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Padding " + side + " -> " + effectiveLength);
+ }
+ }
+
}
/**
* LayoutManager for a block FO.
*/
-public class BlockLayoutManager extends BlockStackingLayoutManager {
+public class BlockLayoutManager extends BlockStackingLayoutManager
+ implements ConditionalElementListener {
private Block curBlockArea;
private Length lineHeight;
private int follow = 2000;
private int middleShift = 0;
+
+ private boolean discardBorderBefore;
+ private boolean discardBorderAfter;
+ private boolean discardPaddingBefore;
+ private boolean discardPaddingAfter;
+ private MinOptMax effSpaceBefore;
+ private MinOptMax effSpaceAfter;
/** The list of child BreakPoss instances. */
protected List childBreaks = new java.util.ArrayList();
}
}
+ /** @see org.apache.fop.layoutmgr.BlockStackingLayoutManager */
+ public LinkedList getNextKnuthElements(LayoutContext context, int alignment) {
+ resetSpaces();
+ return super.getNextKnuthElements(context, alignment);
+ }
+
+ private void resetSpaces() {
+ this.discardBorderBefore = false;
+ this.discardBorderAfter = false;
+ this.discardPaddingBefore = false;
+ this.discardPaddingAfter = false;
+ this.effSpaceBefore = foSpaceBefore;
+ this.effSpaceAfter = foSpaceAfter;
+ }
+
/**
* Proxy iterator for Block LM.
* This iterator creates and holds the complete list
}
getPSLM().addIDToPage(getBlockFO().getId());
- /* TODO remove when markers are really ok
- log.debug("Checking on " + this);
- log.debug("Checking first=" + firstPos);
- log.debug("Checking last=" + lastPos);
- log.debug("->" + isFirst(firstPos) + "/" + isLast(lastPos));
- */
if (markers != null) {
getCurrentPV().addMarkers(markers, true, isFirst(firstPos), isLast(lastPos));
}
//}
}
- // if adjusted space before
- double adjust = layoutContext.getSpaceAdjust();
- addBlockSpacing(adjust, foSpaceBefore);
- foSpaceBefore = null;
- //if (bSpaceBefore) {
- // addBlockSpacing(0, new MinOptMax(adjustedSpaceBefore));
- //}
-
while ((childLM = childPosIter.getNextChildLM()) != null) {
// set last area flag
lc.setFlags(LayoutContext.LAST_AREA,
childLM.addAreas(childPosIter, lc);
}
- //int bIndents = getBlockFO().getCommonBorderPaddingBackground()
- // .getBPPaddingAndBorder(false);
-
if (markers != null) {
getCurrentPV().addMarkers(markers, false, isFirst(firstPos), isLast(lastPos));
}
+ TraitSetter.addSpaceBeforeAfter(curBlockArea, layoutContext.getSpaceAdjust(),
+ effSpaceBefore, effSpaceAfter);
flush();
- // if adjusted space after
- addBlockSpacing(adjust, foSpaceAfter);
- //if (bSpaceAfter) {
- // addBlockSpacing(0, new MinOptMax(adjustedSpaceAfter));
- //}
-
curBlockArea = null;
+ resetSpaces();
}
/**
// set traits
TraitSetter.setProducerID(curBlockArea, getBlockFO().getId());
TraitSetter.addBorders(curBlockArea,
- getBlockFO().getCommonBorderPaddingBackground(), this);
+ getBlockFO().getCommonBorderPaddingBackground(),
+ discardBorderBefore, discardBorderAfter, false, false, this);
+ TraitSetter.addPadding(curBlockArea,
+ getBlockFO().getCommonBorderPaddingBackground(),
+ discardPaddingBefore, discardPaddingAfter, false, false, this);
TraitSetter.addMargins(curBlockArea,
getBlockFO().getCommonBorderPaddingBackground(),
getBlockFO().getCommonMarginBlock(),
this);
- // Set up dimensions
- // Get reference IPD from parentArea
- //int referenceIPD = parentArea.getIPD();
- //curBlockArea.setIPD(referenceIPD);
-
- // Set the width of the block based on the parent block
- // Need to be careful though, if parent is BC then width may not be set
- /* TODO remove if really not used anymore
- int parentwidth = 0;
- if (parentArea instanceof BlockParent) {
- parentwidth = ((BlockParent) parentArea).getIPD();
- }
- if (parentwidth == 0) {
- parentwidth = referenceIPD;
- }
- parentwidth -= getIPIndents();
- */
-
setCurrentArea(curBlockArea); // ??? for generic operations
}
return curBlockArea;
public boolean getGeneratesBlockArea() {
return true;
}
-
+
+ /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+ public void notifySpace(RelSide side, MinOptMax effectiveLength) {
+ if (RelSide.BEFORE == side) {
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Space " + side + ", "
+ + this.effSpaceBefore + "-> " + effectiveLength);
+ }
+ this.effSpaceBefore = effectiveLength;
+ } else {
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Space " + side + ", "
+ + this.effSpaceAfter + "-> " + effectiveLength);
+ }
+ this.effSpaceAfter = effectiveLength;
+ }
+ }
+
+ /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+ public void notifyBorder(RelSide side, MinOptMax effectiveLength) {
+ if (effectiveLength == null) {
+ if (RelSide.BEFORE == side) {
+ this.discardBorderBefore = true;
+ } else {
+ this.discardBorderAfter = true;
+ }
+ }
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Border " + side + " -> " + effectiveLength);
+ }
+ }
+
+ /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+ public void notifyPadding(RelSide side, MinOptMax effectiveLength) {
+ if (effectiveLength == null) {
+ if (RelSide.BEFORE == side) {
+ this.discardPaddingBefore = true;
+ } else {
+ this.discardPaddingAfter = true;
+ }
+ }
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Padding " + side + " -> " + effectiveLength);
+ }
+ }
+
}
protected int adjustedSpaceAfter = 0;
/** Only used to store the original list when createUnitElements is called */
protected LinkedList storedList = null;
- /** FO node */
- protected FObj fobj;
/** Indicates whether break before has been served or not */
protected boolean bBreakBeforeServed = false;
- /** Indicates whether space before has been served or not */
- protected boolean bSpaceBeforeServed = false;
+ /** Indicates whether the first visible mark has been returned by this LM, yet */
+ protected boolean firstVisibleMarkServed = false;
/** Reference IPD available */
protected int referenceIPD = 0;
/**
public BlockStackingLayoutManager(FObj node) {
super(node);
setGeneratesBlockArea(true);
- fobj = node;
}
/**
this.parentArea = parentArea;
}
- protected MinOptMax resolveSpaceSpecifier(Area nextArea) {
- SpaceSpecifier spaceSpec = new SpaceSpecifier(false);
- // Area prevArea = getCurrentArea().getLast();
- // if (prevArea != null) {
- // spaceSpec.addSpace(prevArea.getSpaceAfter());
- // }
- // spaceSpec.addSpace(nextArea.getSpaceBefore());
- return spaceSpec.resolve(false);
- }
-
/**
* Add a block spacer for space before and space after a block.
* This adds an empty Block area that acts as a block space.
* @param minoptmax the min/opt/max value of the spacing
*/
public void addBlockSpacing(double adjust, MinOptMax minoptmax) {
- if (minoptmax == null) {
- return;
- }
- int sp = minoptmax.opt;
- if (adjust > 0) {
- sp = sp + (int)(adjust * (minoptmax.max - minoptmax.opt));
- } else {
- sp = sp + (int)(adjust * (minoptmax.opt - minoptmax.min));
- }
+ int sp = TraitSetter.getEffectiveSpace(adjust, minoptmax);
if (sp != 0) {
Block spacer = new Block();
spacer.setBPD(sp);
//log.error("Child not a Block in BlockStackingLM!");
}
- MinOptMax spaceBefore = resolveSpaceSpecifier(childArea);
parentArea.addBlock((Block) childArea);
flush(); // hand off current area to parent
}
if (!bBreakBeforeServed) {
try {
- if (addKnuthElementsForBreakBefore(returnList)) {
+ if (addKnuthElementsForBreakBefore(returnList, context)) {
return returnList;
}
} finally {
}
}
- if (!bSpaceBeforeServed) {
- addKnuthElementsForSpaceBefore(returnList, alignment);
- bSpaceBeforeServed = true;
- }
+ addKnuthElementsForSpaceBefore(returnList, alignment);
- addKnuthElementsForBorderPaddingBefore(returnList);
+ addKnuthElementsForBorderPaddingBefore(returnList, !firstVisibleMarkServed);
+ firstVisibleMarkServed = true;
+
+ //Spaces, border and padding to be repeated at each break
+ addPendingMarks(context);
while ((curLM = (BlockLevelLayoutManager) getChildLM()) != null) {
LayoutContext childLC = new LayoutContext(0);
+ childLC.copyPendingMarksFrom(context);
if (curLM instanceof LineLayoutManager) {
// curLM is a LineLayoutManager
// set stackLimit for lines
}
if (returnedList != null
&& returnedList.size() == 1
- && ((KnuthElement) returnedList.getFirst()).isPenalty()
- && ((KnuthPenalty) returnedList.getFirst()).getP() == -KnuthElement.INFINITE) {
+ && ((ListElement) returnedList.getFirst()).isForcedBreak()) {
// a descendant of this block has break-before
+ /*
if (returnList.size() == 0) {
// the first child (or its first child ...) has
// break-before;
// the
// following page
bSpaceBeforeServed = false;
- }
+ }*/
contentList.addAll(returnedList);
/* extension: conversione di tutta la sequenza fin'ora ottenuta */
childLC.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING, false);
// add an infinite penalty to forbid a break between
// blocks
+ contentList.add(new BreakElement(
+ new Position(this), KnuthElement.INFINITE, context));
+ /*
contentList.add(new KnuthPenalty(0,
KnuthElement.INFINITE, false,
new Position(this), false));
- } else if (!((KnuthElement) contentList.getLast()).isGlue()) {
+ */
+ } else if (!((ListElement) contentList.getLast()).isGlue()) {
// add a null penalty to allow a break between blocks
+ contentList.add(new BreakElement(
+ new Position(this), 0, context));
+ /*
contentList.add(new KnuthPenalty(0, 0, false,
- new Position(this), false));
+ new Position(this), false));*/
} else {
// the last element in contentList is a glue;
// it is a feasible breakpoint, there is no need to add
// a penalty
+ log.warn("glue-type break possibility not handled properly, yet");
+ //TODO Does this happen? If yes, need to deal with border and padding
+ //at the break possibility
}
}
if (returnedList == null || returnedList.size() == 0) {
continue;
}
contentList.addAll(returnedList);
- if (((KnuthElement) returnedList.getLast()).isPenalty()
- && ((KnuthPenalty) returnedList.getLast()).getP()
- == -KnuthElement.INFINITE) {
+ if (((ListElement) returnedList.getLast()).isForcedBreak()) {
// a descendant of this block has break-after
if (curLM.isFinished()) {
// there is no other content in this block;
returnList.add(new KnuthBox(0, notifyPos(new Position(this)), true));
}
- addKnuthElementsForBorderPaddingAfter(returnList);
+ addKnuthElementsForBorderPaddingAfter(returnList, true);
addKnuthElementsForSpaceAfter(returnList, alignment);
- addKnuthElementsForBreakAfter(returnList);
+ addKnuthElementsForBreakAfter(returnList, context);
if (mustKeepWithNext()) {
context.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING);
}
/**
- * Creates Knuth elements for before border padding and adds them to the return list.
- * @param returnList return list to add the additional elements to
+ * Adds the unresolved elements for border and padding to a layout context so break
+ * possibilities can be properly constructed.
+ * @param context the layout context
*/
- protected void addKnuthElementsForBorderPaddingBefore(LinkedList returnList/*,
- Position returnPosition*/) {
- //Border and Padding (before)
- CommonBorderPaddingBackground borderAndPadding = null;
+ protected void addPendingMarks(LayoutContext context) {
+ SpaceProperty spaceBefore = getSpaceBeforeProperty();
+ if (spaceBefore != null
+ && !(spaceBefore.getMinimum(this).getLength().getValue(this) == 0
+ && spaceBefore.getMaximum(this).getLength().getValue(this) == 0)) {
+ context.addPendingBeforeMark(new SpaceElement(getAuxiliaryPosition(), spaceBefore,
+ RelSide.BEFORE,
+ true, false, this));
+ }
+ SpaceProperty spaceAfter = getSpaceAfterProperty();
+ if (spaceAfter != null
+ && !(spaceAfter.getMinimum(this).getLength().getValue(this) == 0
+ && spaceAfter.getMaximum(this).getLength().getValue(this) == 0)) {
+ context.addPendingAfterMark(new SpaceElement(getAuxiliaryPosition(), spaceAfter,
+ RelSide.AFTER,
+ false, true, this));
+ }
+ CommonBorderPaddingBackground borderAndPadding = getBorderPaddingBackground();
+ if (borderAndPadding != null) {
+ if (borderAndPadding.getBorderBeforeWidth(false) > 0) {
+ context.addPendingBeforeMark(new BorderElement(
+ getAuxiliaryPosition(),
+ borderAndPadding.getBorderInfo(
+ CommonBorderPaddingBackground.BEFORE).getWidth(),
+ RelSide.BEFORE,
+ false, false, this));
+ }
+ if (borderAndPadding.getPaddingBefore(false, this) > 0) {
+ context.addPendingBeforeMark(new PaddingElement(
+ getAuxiliaryPosition(),
+ borderAndPadding.getPaddingLengthProperty(
+ CommonBorderPaddingBackground.BEFORE),
+ RelSide.BEFORE,
+ false, false, this));
+ }
+ if (borderAndPadding.getBorderAfterWidth(false) > 0) {
+ context.addPendingAfterMark(new BorderElement(
+ getAuxiliaryPosition(),
+ borderAndPadding.getBorderInfo(
+ CommonBorderPaddingBackground.AFTER).getWidth(),
+ RelSide.AFTER,
+ false, false, this));
+ }
+ if (borderAndPadding.getPaddingAfter(false, this) > 0) {
+ context.addPendingAfterMark(new PaddingElement(
+ getAuxiliaryPosition(),
+ borderAndPadding.getPaddingLengthProperty(
+ CommonBorderPaddingBackground.AFTER),
+ RelSide.AFTER,
+ false, false, this));
+ }
+ }
+ }
+
+ /** @return the border, padding and background info structure */
+ private CommonBorderPaddingBackground getBorderPaddingBackground() {
if (fobj instanceof org.apache.fop.fo.flow.Block) {
- borderAndPadding = ((org.apache.fop.fo.flow.Block)fobj)
+ return ((org.apache.fop.fo.flow.Block)fobj)
.getCommonBorderPaddingBackground();
} else if (fobj instanceof org.apache.fop.fo.flow.BlockContainer) {
- borderAndPadding = ((org.apache.fop.fo.flow.BlockContainer)fobj)
+ return ((org.apache.fop.fo.flow.BlockContainer)fobj)
+ .getCommonBorderPaddingBackground();
+ } else if (fobj instanceof org.apache.fop.fo.flow.ListBlock) {
+ return ((org.apache.fop.fo.flow.ListBlock)fobj)
.getCommonBorderPaddingBackground();
+ } else if (fobj instanceof org.apache.fop.fo.flow.ListItem) {
+ return ((org.apache.fop.fo.flow.ListItem)fobj)
+ .getCommonBorderPaddingBackground();
+ } else if (fobj instanceof org.apache.fop.fo.flow.Table) {
+ return ((org.apache.fop.fo.flow.Table)fobj)
+ .getCommonBorderPaddingBackground();
+ } else {
+ return null;
+ }
+ }
+
+ /** @return the space-before property */
+ private SpaceProperty getSpaceBeforeProperty() {
+ if (fobj instanceof org.apache.fop.fo.flow.Block) {
+ return ((org.apache.fop.fo.flow.Block)fobj)
+ .getCommonMarginBlock().spaceBefore;
+ } else if (fobj instanceof org.apache.fop.fo.flow.BlockContainer) {
+ return ((org.apache.fop.fo.flow.BlockContainer)fobj)
+ .getCommonMarginBlock().spaceBefore;
+ } else if (fobj instanceof org.apache.fop.fo.flow.ListBlock) {
+ return ((org.apache.fop.fo.flow.ListBlock)fobj)
+ .getCommonMarginBlock().spaceBefore;
+ } else if (fobj instanceof org.apache.fop.fo.flow.ListItem) {
+ return ((org.apache.fop.fo.flow.ListItem)fobj)
+ .getCommonMarginBlock().spaceBefore;
+ } else if (fobj instanceof org.apache.fop.fo.flow.Table) {
+ return ((org.apache.fop.fo.flow.Table)fobj)
+ .getCommonMarginBlock().spaceBefore;
+ } else {
+ return null;
+ }
+ }
+
+ /** @return the space-after property */
+ private SpaceProperty getSpaceAfterProperty() {
+ if (fobj instanceof org.apache.fop.fo.flow.Block) {
+ return ((org.apache.fop.fo.flow.Block)fobj)
+ .getCommonMarginBlock().spaceAfter;
+ } else if (fobj instanceof org.apache.fop.fo.flow.BlockContainer) {
+ return ((org.apache.fop.fo.flow.BlockContainer)fobj)
+ .getCommonMarginBlock().spaceAfter;
+ } else if (fobj instanceof org.apache.fop.fo.flow.ListBlock) {
+ return ((org.apache.fop.fo.flow.ListBlock)fobj)
+ .getCommonMarginBlock().spaceAfter;
+ } else if (fobj instanceof org.apache.fop.fo.flow.ListItem) {
+ return ((org.apache.fop.fo.flow.ListItem)fobj)
+ .getCommonMarginBlock().spaceAfter;
+ } else if (fobj instanceof org.apache.fop.fo.flow.Table) {
+ return ((org.apache.fop.fo.flow.Table)fobj)
+ .getCommonMarginBlock().spaceAfter;
+ } else {
+ return null;
}
+ }
+
+ /**
+ * Creates Knuth elements for before border padding and adds them to the return list.
+ * @param returnList return list to add the additional elements to
+ */
+ protected void addKnuthElementsForBorderPaddingBefore(LinkedList returnList, boolean isFirst) {
+ //Border and Padding (before)
+ CommonBorderPaddingBackground borderAndPadding = getBorderPaddingBackground();
if (borderAndPadding != null) {
+ if (borderAndPadding.getBorderBeforeWidth(false) > 0) {
+ returnList.add(new BorderElement(
+ getAuxiliaryPosition(),
+ borderAndPadding.getBorderInfo(CommonBorderPaddingBackground.BEFORE)
+ .getWidth(),
+ RelSide.BEFORE, isFirst, false, this));
+ }
+ if (borderAndPadding.getPaddingBefore(false, this) > 0) {
+ returnList.add(new PaddingElement(
+ getAuxiliaryPosition(),
+ borderAndPadding.getPaddingLengthProperty(
+ CommonBorderPaddingBackground.BEFORE),
+ RelSide.BEFORE, isFirst, false, this));
+ }
//TODO Handle conditionality
+ /*
int bpBefore = borderAndPadding.getBorderBeforeWidth(false)
+ borderAndPadding.getPaddingBefore(false, this);
if (bpBefore > 0) {
returnList.add(new KnuthBox(bpBefore, getAuxiliaryPosition(), true));
- }
+ }*/
}
}
* Creates Knuth elements for after border padding and adds them to the return list.
* @param returnList return list to add the additional elements to
*/
- protected void addKnuthElementsForBorderPaddingAfter(LinkedList returnList/*,
- Position returnPosition*/) {
+ protected void addKnuthElementsForBorderPaddingAfter(LinkedList returnList, boolean isLast) {
//Border and Padding (after)
- CommonBorderPaddingBackground borderAndPadding = null;
- if (fobj instanceof org.apache.fop.fo.flow.Block) {
- borderAndPadding = ((org.apache.fop.fo.flow.Block)fobj)
- .getCommonBorderPaddingBackground();
- } else if (fobj instanceof org.apache.fop.fo.flow.BlockContainer) {
- borderAndPadding = ((org.apache.fop.fo.flow.BlockContainer)fobj)
- .getCommonBorderPaddingBackground();
- }
+ CommonBorderPaddingBackground borderAndPadding = getBorderPaddingBackground();
if (borderAndPadding != null) {
+ if (borderAndPadding.getPaddingAfter(false, this) > 0) {
+ returnList.add(new PaddingElement(
+ getAuxiliaryPosition(),
+ borderAndPadding.getPaddingLengthProperty(
+ CommonBorderPaddingBackground.AFTER),
+ RelSide.AFTER, false, isLast, this));
+ }
+ if (borderAndPadding.getBorderAfterWidth(false) > 0) {
+ returnList.add(new BorderElement(
+ getAuxiliaryPosition(),
+ borderAndPadding.getBorderInfo(CommonBorderPaddingBackground.AFTER)
+ .getWidth(),
+ RelSide.AFTER, false, isLast, this));
+ }
//TODO Handle conditionality
+ /*
int bpAfter = borderAndPadding.getBorderAfterWidth(false)
+ borderAndPadding.getPaddingAfter(false, this);
if (bpAfter > 0) {
returnList.add(new KnuthBox(bpAfter, getAuxiliaryPosition(), true));
- }
+ }*/
}
}
* @param returnList return list to add the additional elements to
* @return true if an element has been added due to a break-before.
*/
- protected boolean addKnuthElementsForBreakBefore(LinkedList returnList/*,
- Position returnPosition*/) {
+ protected boolean addKnuthElementsForBreakBefore(LinkedList returnList,
+ LayoutContext context) {
int breakBefore = -1;
if (fobj instanceof org.apache.fop.fo.flow.Block) {
breakBefore = ((org.apache.fop.fo.flow.Block) fobj).getBreakBefore();
|| breakBefore == EN_EVEN_PAGE
|| breakBefore == EN_ODD_PAGE) {
// return a penalty element, representing a forced page break
- returnList.add(new KnuthPenalty(0, -KnuthElement.INFINITE, false,
- breakBefore, getAuxiliaryPosition(), false));
+ returnList.add(new BreakElement(getAuxiliaryPosition(),
+ 0, -KnuthElement.INFINITE, breakBefore, context));
+ //returnList.add(new KnuthPenalty(0, -KnuthElement.INFINITE, false,
+ // breakBefore, getAuxiliaryPosition(), false));
return true;
} else {
return false;
* @param returnList return list to add the additional elements to
* @return true if an element has been added due to a break-after.
*/
- protected boolean addKnuthElementsForBreakAfter(LinkedList returnList/*,
- Position returnPosition*/) {
+ protected boolean addKnuthElementsForBreakAfter(LinkedList returnList,
+ LayoutContext context) {
int breakAfter = -1;
if (fobj instanceof org.apache.fop.fo.flow.Block) {
breakAfter = ((org.apache.fop.fo.flow.Block) fobj).getBreakAfter();
|| breakAfter == EN_EVEN_PAGE
|| breakAfter == EN_ODD_PAGE) {
// add a penalty element, representing a forced page break
- returnList.add(new KnuthPenalty(0, -KnuthElement.INFINITE, false,
- breakAfter, getAuxiliaryPosition(), false));
+ returnList.add(new BreakElement(getAuxiliaryPosition(),
+ 0, -KnuthElement.INFINITE, breakAfter, context));
+ //returnList.add(new KnuthPenalty(0, -KnuthElement.INFINITE, false,
+ // breakAfter, getAuxiliaryPosition(), false));
return true;
} else {
return false;
*/
protected void addKnuthElementsForSpaceBefore(LinkedList returnList/*,
Position returnPosition*/, int alignment) {
- SpaceProperty spaceBefore = null;
- if (fobj instanceof org.apache.fop.fo.flow.Block) {
- spaceBefore = ((org.apache.fop.fo.flow.Block)fobj)
- .getCommonMarginBlock().spaceBefore;
- } else if (fobj instanceof org.apache.fop.fo.flow.BlockContainer) {
- spaceBefore = ((org.apache.fop.fo.flow.BlockContainer)fobj)
- .getCommonMarginBlock().spaceBefore;
- } else if (fobj instanceof org.apache.fop.fo.flow.ListBlock) {
- spaceBefore = ((org.apache.fop.fo.flow.ListBlock)fobj)
- .getCommonMarginBlock().spaceBefore;
- } else if (fobj instanceof org.apache.fop.fo.flow.ListItem) {
- spaceBefore = ((org.apache.fop.fo.flow.ListItem)fobj)
- .getCommonMarginBlock().spaceBefore;
- }
+ SpaceProperty spaceBefore = getSpaceBeforeProperty();
// append elements representing space-before
+ if (spaceBefore != null
+ && !(spaceBefore.getMinimum(this).getLength().getValue(this) == 0
+ && spaceBefore.getMaximum(this).getLength().getValue(this) == 0)) {
+ returnList.add(new SpaceElement(getAuxiliaryPosition(), spaceBefore,
+ RelSide.BEFORE,
+ true, false, this));
+ }
+ /*
if (bpUnit > 0
|| spaceBefore != null
&& !(spaceBefore.getMinimum(this).getLength().getValue(this) == 0
returnList.add(new KnuthGlue(0, 0, 0,
BlockLevelLayoutManager.SPACE_BEFORE_ADJUSTMENT,
getAuxiliaryPosition(), true));
- } else /*if (alignment == EN_JUSTIFY)*/ {
+ } else { //if (alignment == EN_JUSTIFY) {
returnList.add(new KnuthGlue(
spaceBefore.getOptimum(this).getLength().getValue(this),
spaceBefore.getMaximum(this).getLength().getValue(this)
- spaceBefore.getMinimum(this).getLength().getValue(this),
BlockLevelLayoutManager.SPACE_BEFORE_ADJUSTMENT,
getAuxiliaryPosition(), true));
- } /*else {
- returnList.add(new KnuthGlue(
- spaceBefore.getOptimum().getLength().getValue(this),
- 0, 0, BlockLevelLayoutManager.SPACE_BEFORE_ADJUSTMENT,
- returnPosition, true));
- }*/
- }
+// } else {
+// returnList.add(new KnuthGlue(
+// spaceBefore.getOptimum().getLength().getValue(this),
+// 0, 0, BlockLevelLayoutManager.SPACE_BEFORE_ADJUSTMENT,
+// returnPosition, true));
+ }
+ }*/
}
/**
*/
protected void addKnuthElementsForSpaceAfter(LinkedList returnList/*, Position returnPosition*/,
int alignment) {
- SpaceProperty spaceAfter = null;
- if (fobj instanceof org.apache.fop.fo.flow.Block) {
- spaceAfter = ((org.apache.fop.fo.flow.Block)fobj)
- .getCommonMarginBlock().spaceAfter;
- } else if (fobj instanceof org.apache.fop.fo.flow.BlockContainer) {
- spaceAfter = ((org.apache.fop.fo.flow.BlockContainer)fobj)
- .getCommonMarginBlock().spaceAfter;
- } else if (fobj instanceof org.apache.fop.fo.flow.ListBlock) {
- spaceAfter = ((org.apache.fop.fo.flow.ListBlock)fobj)
- .getCommonMarginBlock().spaceAfter;
- } else if (fobj instanceof org.apache.fop.fo.flow.ListItem) {
- spaceAfter = ((org.apache.fop.fo.flow.ListItem)fobj)
- .getCommonMarginBlock().spaceAfter;
- }
+ SpaceProperty spaceAfter = getSpaceAfterProperty();
// append elements representing space-after
+ if (spaceAfter != null
+ && !(spaceAfter.getMinimum(this).getLength().getValue(this) == 0
+ && spaceAfter.getMaximum(this).getLength().getValue(this) == 0)) {
+ returnList.add(new SpaceElement(getAuxiliaryPosition(), spaceAfter,
+ RelSide.AFTER,
+ false, true, this));
+ }
+ /*
if (bpUnit > 0
|| spaceAfter != null
&& !(spaceAfter.getMinimum(this).getLength().getValue(this) == 0
returnList.add(new KnuthGlue(0, 0, 0,
BlockLevelLayoutManager.SPACE_AFTER_ADJUSTMENT,
getAuxiliaryPosition(), true));
- } else /*if (alignment == EN_JUSTIFY)*/ {
+ } else { //if (alignment == EN_JUSTIFY) {
returnList.add(new KnuthGlue(
spaceAfter.getOptimum(this).getLength().getValue(this),
spaceAfter.getMaximum(this).getLength().getValue(this)
- spaceAfter.getMinimum(this).getLength().getValue(this),
BlockLevelLayoutManager.SPACE_AFTER_ADJUSTMENT, getAuxiliaryPosition(),
(!spaceAfter.getSpace().isDiscard()) ? false : true));
- } /*else {
- returnList.add(new KnuthGlue(
- spaceAfter.getOptimum().getLength().getValue(this), 0, 0,
- BlockLevelLayoutManager.SPACE_AFTER_ADJUSTMENT, returnPosition,
- (!spaceAfter.getSpace().isDiscard()) ? false : true));
- }*/
+// } else {
+// returnList.add(new KnuthGlue(
+// spaceAfter.getOptimum().getLength().getValue(this), 0, 0,
+// BlockLevelLayoutManager.SPACE_AFTER_ADJUSTMENT, returnPosition,
+// (!spaceAfter.getSpace().isDiscard()) ? false : true));
+ }
if (spaceAfter != null && !spaceAfter.getSpace().isDiscard()) {
returnList.add(new KnuthBox(0, getAuxiliaryPosition(), true));
}
- }
+ }*/
}
protected LinkedList createUnitElements(LinkedList oldList) {
ListIterator listIter = sourceList.listIterator();
while (listIter.hasNext()) {
- KnuthElement tempElement;
- tempElement = (KnuthElement) listIter.next();
+ ListElement tempElement;
+ tempElement = (ListElement) listIter.next();
if (force || tempElement.getLayoutManager() != this) {
tempElement.setPosition(notifyPos(new NonLeafPosition(this,
tempElement.getPosition())));
--- /dev/null
+/*
+ * Copyright 2005 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;
+
+import org.apache.fop.datatypes.PercentBaseContext;
+import org.apache.fop.fo.properties.CondLengthProperty;
+import org.apache.fop.traits.MinOptMax;
+
+/**
+ * This represents an unresolved border element.
+ */
+public class BorderElement extends BorderOrPaddingElement {
+
+ /**
+ * Main constructor
+ * @param position the Position instance needed by the addAreas stage of the LMs.
+ * @param side the side to which this space element applies.
+ * @param condLength the length-conditional property for a border or padding specification
+ * @param isFirst true if this is a padding- or border-before of the first area generated.
+ * @param isLast true if this is a padding- or border-after of the last area generated.
+ * @param context the property evaluation context
+ */
+ public BorderElement(Position position, CondLengthProperty condLength,
+ RelSide side,
+ boolean isFirst, boolean isLast, PercentBaseContext context) {
+ super(position, condLength, side, isFirst, isLast, context);
+ }
+
+ /** @see org.apache.fop.layoutmgr.UnresolvedListElementWithLength */
+ public void notifyLayoutManager(MinOptMax effectiveLength) {
+ LayoutManager lm = getOriginatingLayoutManager();
+ if (lm instanceof ConditionalElementListener) {
+ ((ConditionalElementListener)lm).notifyBorder(
+ getSide(), effectiveLength);
+ } else {
+ log.warn("Cannot notify LM. It does not implement ConditionalElementListener: "
+ + lm.getClass().getName());
+ }
+ }
+
+ /** @see java.lang.Object#toString() */
+ public String toString() {
+ StringBuffer sb = new StringBuffer("Border[");
+ sb.append(super.toString());
+ sb.append("]");
+ return sb.toString();
+ }
+
+}
--- /dev/null
+/*
+ * Copyright 2005 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;
+
+import org.apache.fop.datatypes.PercentBaseContext;
+import org.apache.fop.fo.properties.CondLengthProperty;
+import org.apache.fop.traits.MinOptMax;
+
+/**
+ * This class represents an unresolved border or padding element.
+ */
+public abstract class BorderOrPaddingElement extends UnresolvedListElementWithLength {
+
+ /**
+ * Main constructor
+ * @param position the Position instance needed by the addAreas stage of the LMs.
+ * @param side the side to which this space element applies.
+ * @param condLength the length-conditional property for a border or padding specification
+ * @param isFirst true if this is a padding- or border-before of the first area generated.
+ * @param isLast true if this is a padding- or border-after of the last area generated.
+ * @param context the property evaluation context
+ */
+ public BorderOrPaddingElement(Position position, CondLengthProperty condLength,
+ RelSide side,
+ boolean isFirst, boolean isLast, PercentBaseContext context) {
+ super(position,
+ new MinOptMax(condLength.getLength().getValue(context)), side,
+ condLength.isDiscard(), isFirst, isLast);
+ }
+
+ /** @see org.apache.fop.layoutmgr.UnresolvedListElementWithLength */
+ public abstract void notifyLayoutManager(MinOptMax effectiveLength);
+
+}
--- /dev/null
+/*
+ * Copyright 2005 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;
+
+import java.util.List;
+
+import org.apache.fop.fo.Constants;
+
+/**
+ * This class represents an unresolved break possibility.
+ */
+public class BreakElement extends UnresolvedListElement {
+
+ private int penaltyWidth;
+ private int penaltyValue;
+ private int breakClass = -1;
+ private List pendingBeforeMarks;
+ private List pendingAfterMarks;
+
+ /**
+ * Main constructor
+ * @param position the Position instance needed by the addAreas stage of the LMs.
+ * @param penaltyValue the penalty value for the penalty element to be constructed
+ * @param context the layout context which contains the pending conditional elements
+ */
+ public BreakElement(Position position, int penaltyValue, LayoutContext context) {
+ this(position, 0, penaltyValue, -1, context);
+ }
+
+ /**
+ * Constructor for hard breaks.
+ * @param position the Position instance needed by the addAreas stage of the LMs.
+ * @param penaltyWidth the penalty width
+ * @param penaltyValue the penalty value for the penalty element to be constructed
+ * @param breakClass the break class of this penalty (one of the break-* constants)
+ * @param context the layout context which contains the pending conditional elements
+ */
+ public BreakElement(Position position, int penaltyWidth, int penaltyValue,
+ int breakClass, LayoutContext context) {
+ super(position);
+ this.penaltyWidth = penaltyWidth;
+ this.penaltyValue = penaltyValue;
+ this.breakClass = breakClass;
+ this.pendingBeforeMarks = context.getPendingBeforeMarks();
+ this.pendingAfterMarks = context.getPendingAfterMarks();
+ }
+
+ /** @see org.apache.fop.layoutmgr.UnresolvedListElement#isConditional() */
+ public boolean isConditional() {
+ return false; //Does not really apply here
+ }
+
+ /** @see org.apache.fop.layoutmgr.ListElement#isPenalty() */
+ /*
+ public boolean isPenalty() {
+ return true; //not entirely true but a BreakElement will generate a penalty later
+ }*/
+
+ /** @return the penalty width */
+ public int getPenaltyWidth() {
+ return this.penaltyWidth;
+ }
+
+ /** @return the penalty value */
+ public int getPenaltyValue() {
+ return this.penaltyValue;
+ }
+
+ /**
+ * Sets the penalty value.
+ * @param p the new penalty value
+ */
+ public void setPenaltyValue(int p) {
+ this.penaltyValue = p;
+ }
+
+ /** @see org.apache.fop.layoutmgr.ListElement#isForcedBreak() */
+ public boolean isForcedBreak() {
+ return penaltyValue == -KnuthElement.INFINITE;
+ }
+
+ /** @return the break class of this penalty (one of the break-* constants) */
+ public int getBreakClass() {
+ return breakClass;
+ }
+
+ /**
+ * Sets the break class.
+ * @param breakClass the new break class
+ */
+ public void setBreakClass(int breakClass) {
+ this.breakClass = breakClass;
+ }
+
+ /** @return the pending border and padding elements at the before edge */
+ public List getPendingBeforeMarks() {
+ return this.pendingBeforeMarks;
+ }
+
+ /** @return the pending border and padding elements at the after edge */
+ public List getPendingAfterMarks() {
+ return this.pendingAfterMarks;
+ }
+
+ /** @see java.lang.Object#toString() */
+ public String toString() {
+ StringBuffer sb = new StringBuffer();
+ sb.append("BreakPossibility[p:");
+ sb.append(this.penaltyValue);
+ if (isForcedBreak()) {
+ sb.append(" (forced break");
+ switch (getBreakClass()) {
+ case Constants.EN_PAGE:
+ sb.append(", page");
+ break;
+ case Constants.EN_COLUMN:
+ sb.append(", column");
+ break;
+ case Constants.EN_EVEN_PAGE:
+ sb.append(", even page");
+ break;
+ case Constants.EN_ODD_PAGE:
+ sb.append(", odd page");
+ break;
+ default:
+ }
+ sb.append(")");
+ }
+ sb.append("]");
+ return sb.toString();
+ }
+
+}
--- /dev/null
+/*
+ * Copyright 2005 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;
+
+import org.apache.fop.traits.MinOptMax;
+
+/**
+ * This interface is used to notify layout managers about the situation around spaces, borders
+ * and padding just before the addArea() method is called when a part is being painted.
+ */
+public interface ConditionalElementListener {
+
+ /**
+ * Notifies the layout manager about the effective length of its space.
+ * @param side the side to which the space applies
+ * @param effectiveLength the effective length after space-resolution (null means zero length)
+ */
+ void notifySpace(RelSide side, MinOptMax effectiveLength);
+
+ /**
+ * Notifies the layout manager about the effective length/width of its border.
+ * @param side the side to which the border applies
+ * @param effectiveLength the effective length in the current break situation
+ * (null means zero length)
+ */
+ void notifyBorder(RelSide side, MinOptMax effectiveLength);
+
+ /**
+ * Notifies the layout manager about the effective length/width of its padding.
+ * @param side the side to which the padding applies
+ * @param effectiveLength the effective length in the current break situation
+ * (null means zero length)
+ */
+ void notifyPadding(RelSide side, MinOptMax effectiveLength);
+
+}
public static void removeLegalBreaks(LinkedList elements) {
ListIterator i = elements.listIterator();
while (i.hasNext()) {
- KnuthElement el = (KnuthElement)i.next();
+ ListElement el = (ListElement)i.next();
if (el.isPenalty()) {
- KnuthPenalty penalty = (KnuthPenalty)el;
+ BreakElement breakPoss = (BreakElement)el;
//Convert all penalties no break inhibitors
- if (penalty.getP() < KnuthPenalty.INFINITE) {
+ if (breakPoss.getPenaltyValue() < KnuthPenalty.INFINITE) {
+ breakPoss.setPenaltyValue(KnuthPenalty.INFINITE);
+ /*
i.set(new KnuthPenalty(penalty.getW(), KnuthPenalty.INFINITE,
penalty.isFlagged(), penalty.getPosition(), penalty.isAuxiliary()));
+ */
}
} else if (el.isGlue()) {
i.previous();
int count = end - start + 1;
int len = 0;
while (iter.hasNext()) {
- KnuthElement el = (KnuthElement)iter.next();
+ ListElement el = (ListElement)iter.next();
if (el.isBox()) {
- len += el.getW();
+ len += ((KnuthElement)el).getW();
} else if (el.isGlue()) {
- len += el.getW();
+ len += ((KnuthElement)el).getW();
} else {
//log.debug("Ignoring penalty: " + el);
//ignore penalties
return calcContentLength(elems, 0, elems.size() - 1);
}
+ /**
+ * Indicates whether the given element list ends with a forced break.
+ * @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();
+ return last.isForcedBreak();
+ }
+
}
*/
public class FlowLayoutManager extends BlockStackingLayoutManager
implements BlockLevelLayoutManager {
- private Flow fobj;
/** Array of areas currently being filled stored by area class */
private BlockParent[] currentAreas = new BlockParent[Area.CLASS_MAX];
*/
public FlowLayoutManager(PageSequenceLayoutManager pslm, Flow node) {
super(node);
- fobj = node;
setParent(pslm);
}
log.debug("span change from " + currentSpan + " to " + span);
context.signalSpanChange(span);
currentSpan = span;
+ SpaceResolver.resolveElementList(returnList);
return returnList;
}
wrapPositionElements(tempList, returnedList);
if (returnedList.size() == 1
- && ((KnuthElement)returnedList.getFirst()).isPenalty()
- && ((KnuthPenalty)returnedList.getFirst()).getP() == -KnuthElement.INFINITE) {
+ && ElementListUtils.endsWithForcedBreak(returnedList)) {
// a descendant of this flow has break-before
returnList.addAll(returnedList);
+ SpaceResolver.resolveElementList(returnList);
return returnList;
} else {
if (returnList.size() > 0) {
context.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING, false);
childLC.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING, false);
// add an infinite penalty to forbid a break between blocks
- returnList.add(new KnuthPenalty(0, KnuthElement.INFINITE, false,
- new Position(this), false));
- } else if (!((KnuthElement) returnList.getLast()).isGlue()) {
+ returnList.add(new BreakElement(
+ new Position(this), KnuthElement.INFINITE, context));
+ } else if (!((ListElement) returnList.getLast()).isGlue()) {
// add a null penalty to allow a break between blocks
- returnList.add(new KnuthPenalty(0, 0, false,
- new Position(this), false));
+ returnList.add(new BreakElement(
+ new Position(this), 0, context));
}
}
- if (returnedList.size() > 0) { // controllare!
+ if (returnedList.size() > 0) {
returnList.addAll(returnedList);
- if (((KnuthElement)returnedList.getLast()).isPenalty()
- && ((KnuthPenalty)returnedList.getLast()).getP()
- == -KnuthElement.INFINITE) {
+ if (ElementListUtils.endsWithForcedBreak(returnList)) {
// a descendant of this flow has break-after
+ SpaceResolver.resolveElementList(returnList);
return returnList;
}
}
}
}
+ SpaceResolver.resolveElementList(returnList);
setFinished(true);
if (returnList.size() > 0) {
import java.util.LinkedList;
+/**
+ * Layout manager for footnote bodies.
+ */
public class FootnoteBodyLayoutManager extends BlockStackingLayoutManager {
+ /**
+ * Creates a new FootnoteBodyLayoutManager.
+ * @param body the footnote-body element
+ */
public FootnoteBodyLayoutManager(FootnoteBody body) {
super(body);
}
+ /** @see org.apache.fop.layoutmgr.LayoutManager */
public void addAreas(PositionIterator parentIter, LayoutContext layoutContext) {
LayoutManager childLM = null;
LayoutManager lastLM = null;
// and put them in a new list;
LinkedList positionList = new LinkedList();
Position pos;
- boolean bSpaceBefore = false;
- boolean bSpaceAfter = false;
while (parentIter.hasNext()) {
pos = (Position) parentIter.next();
//log.trace("pos = " + pos.getClass().getName() + "; " + pos);
}
}
+ /** @see org.apache.fop.layoutmgr.LayoutManager#addChildArea(org.apache.fop.area.Area) */
public void addChildArea(Area childArea) {
childArea.setAreaClass(Area.CLASS_FOOTNOTE);
parentLM.addChildArea(childArea);
}
- /**
- * convenience method that returns the FootnoteBody node
- */
+ /** @return the FootnoteBody node */
protected FootnoteBody getFootnodeBodyFO() {
return (FootnoteBody) fobj;
}
* special feature (for example, the additional elements used to represent
* a space when text alignment is right, left or center).
*/
-public abstract class KnuthElement {
+public abstract class KnuthElement extends ListElement {
+ /** The value used as an infinite indicator. */
public static final int INFINITE = 1000;
private int width;
- private Position position;
private boolean bIsAuxiliary;
/**
* @param bAux is this an auxiliary element?
*/
protected KnuthElement(int w, Position pos, boolean bAux) {
+ super(pos);
width = w;
- position = pos;
bIsAuxiliary = bAux;
}
- /**
- * Return true if this element is a KnuthBox.
- */
- public boolean isBox() {
- return false;
- }
-
- /**
- * Return true if this element is a KnuthGlue.
- */
- public boolean isGlue() {
- return false;
- }
-
- /**
- * Return true if this element is a KnuthPenalty.
- */
- public boolean isPenalty() {
- return false;
- }
-
- /**
- * Return true if this element is an auxiliary one.
- */
+ /** @return true if this element is an auxiliary one. */
public boolean isAuxiliary() {
return bIsAuxiliary;
}
- /**
- * Return the width of this element.
- */
+ /** @return the width of this element. */
public int getW() {
return width;
}
+ /** @return the penalty value of this element, if applicable. */
public int getP() {
throw new RuntimeException("Element is not a penalty");
}
+ /** @return the stretch value of this element, if applicable. */
public int getY() {
throw new RuntimeException("Element is not a glue");
}
+ /** @return the shrink value of this element, if applicable. */
public int getZ() {
throw new RuntimeException("Element is not a glue");
}
-
- public boolean isForcedBreak() {
+
+ /** @see org.apache.fop.layoutmgr.ListElement#isUnresolvedElement() */
+ public boolean isUnresolvedElement() {
return false;
}
- /**
- * Return the Position stored in this element.
- */
- public Position getPosition() {
- return position;
- }
-
- /**
- * Change the Position stored in this element.
- */
- public void setPosition(Position pos) {
- position = pos;
- }
-
- /**
- * Return the LayoutManager responsible for this element.
- */
- public LayoutManager getLayoutManager() {
- if (position != null) {
- return position.getLM();
- } else {
- return null;
- }
- }
}
return super.next();
}
- public KnuthElement getKE() {
- return (KnuthElement) peekNext();
+ public ListElement getKE() {
+ return (ListElement) peekNext();
}
protected LayoutManager getLM(Object nextObj) {
- return ((KnuthElement) nextObj).getLayoutManager();
+ return ((ListElement) nextObj).getLayoutManager();
}
protected Position getPos(Object nextObj) {
- return ((KnuthElement) nextObj).getPosition();
+ return ((ListElement) nextObj).getPosition();
}
}
}
/**
+ * Finalizes a Knuth sequence.
* @return a finalized sequence.
*/
public KnuthSequence endSequence() {
+ return endSequence(null);
+ }
+
+ /**
+ * Finalizes a Knuth sequence.
+ * @param breakPosition a Position instance for the last penalty (may be null)
+ * @return a finalized sequence.
+ */
+ public KnuthSequence endSequence(Position breakPosition) {
// remove glue and penalty item at the end of the paragraph
while (this.size() > ignoreAtStart
&& !((KnuthElement)this.get(this.size() - 1)).isBox()) {
// and the forced break
this.add(new KnuthPenalty(0, KnuthElement.INFINITE, false, null, false));
this.add(new KnuthGlue(0, 10000000, 0, null, false));
- this.add(new KnuthPenalty(0, -KnuthElement.INFINITE, false, null, false));
+ this.add(new KnuthPenalty(0, -KnuthElement.INFINITE, false, breakPosition, false));
ignoreAtEnd = 3;
return this;
} else {
/*
- * Copyright 1999-2004 The Apache Software Foundation.
+ * Copyright 1999-2005 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.
package org.apache.fop.layoutmgr;
+import java.util.Collections;
+import java.util.List;
+
import org.apache.fop.fo.Constants;
import org.apache.fop.layoutmgr.inline.HyphContext;
import org.apache.fop.traits.MinOptMax;
/**
- * This class is used to pass information to the getNextBreakPoss()
+ * This class is used to pass information to the getNextKnuthElements()
* method. It is set up by higher level LM and used by lower level LM.
*/
public class LayoutContext {
/** Current pending space-before or space-start from ancestor areas */
SpaceSpecifier leadingSpace;
+
+ /**
+ * A list of pending marks (border and padding) on the after edge when a page break occurs.
+ * May be null.
+ */
+ private List pendingAfterMarks;
+
+ /**
+ * A list of pending marks (border and padding) on the before edge when a page break occurs.
+ * May be null.
+ */
+ private List pendingBeforeMarks;
/** Current hyphenation context. May be null. */
private HyphContext hyphContext = null;
/** Amount of space to reserve at the end of each line */
private int lineEndBorderAndPaddingWidth = 0;
+ /**
+ * Copy constructor for creating child layout contexts.
+ * @param parentLC the parent layout context to copy from
+ */
public LayoutContext(LayoutContext parentLC) {
this.flags = parentLC.flags;
this.refIPD = parentLC.refIPD;
this.alignmentContext = parentLC.alignmentContext;
this.lineStartBorderAndPaddingWidth = parentLC.lineStartBorderAndPaddingWidth;
this.lineEndBorderAndPaddingWidth = parentLC.lineEndBorderAndPaddingWidth;
- // Copy other fields as necessary. Use clone???
+ copyPendingMarksFrom(parentLC);
+ // Copy other fields as necessary.
}
+ /**
+ * Main constructor.
+ * @param flags the initial flags
+ */
public LayoutContext(int flags) {
this.flags = flags;
this.refIPD = 0;
trailingSpace = null;
}
+ public void copyPendingMarksFrom(LayoutContext source) {
+ if (source.pendingAfterMarks != null) {
+ this.pendingAfterMarks = new java.util.ArrayList(source.pendingAfterMarks);
+ }
+ if (source.pendingBeforeMarks != null) {
+ this.pendingBeforeMarks = new java.util.ArrayList(source.pendingBeforeMarks);
+ }
+ }
+
public void setFlags(int flags) {
setFlags(flags, true);
}
return trailingSpace;
}
+ /**
+ * Adds a border or padding element to the pending list which will be used to generate
+ * the right element list for break possibilities. Conditionality resolution will be done
+ * elsewhere.
+ * @param element the border, padding or space element
+ */
+ public void addPendingAfterMark(UnresolvedListElementWithLength element) {
+ if (this.pendingAfterMarks == null) {
+ this.pendingAfterMarks = new java.util.ArrayList();
+ }
+ this.pendingAfterMarks.add(element);
+ }
+
+ /**
+ * @return the pending border and padding elements at the after edge
+ * @see addPendingAfterMark(BorderOrPaddingElement)
+ */
+ public List getPendingAfterMarks() {
+ if (this.pendingAfterMarks != null) {
+ return Collections.unmodifiableList(this.pendingAfterMarks);
+ } else {
+ return null;
+ }
+ }
+
+ /**
+ * Adds a border or padding element to the pending list which will be used to generate
+ * the right element list for break possibilities. Conditionality resolution will be done
+ * elsewhere.
+ * @param element the border, padding or space element
+ */
+ public void addPendingBeforeMark(UnresolvedListElementWithLength element) {
+ if (this.pendingBeforeMarks == null) {
+ this.pendingBeforeMarks = new java.util.ArrayList();
+ }
+ this.pendingBeforeMarks.add(element);
+ }
+
+ /**
+ * @return the pending border and padding elements at the before edge
+ * @see addPendingBeforeMark(BorderOrPaddingElement)
+ */
+ public List getPendingBeforeMarks() {
+ if (this.pendingBeforeMarks != null) {
+ return Collections.unmodifiableList(this.pendingBeforeMarks);
+ } else {
+ return null;
+ }
+ }
+
public void setStackLimit(MinOptMax limit) {
stackLimit = limit;
}
--- /dev/null
+/*
+ * Copyright 2005 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;
+
+/**
+ * This class is the base class for all kinds of elements that are added to element lists. There
+ * are basically two kinds of list elements: Knuth elements and unresolved elements like spaces,
+ * border and padding elements which are converted to Knuth elements prior to the breaking
+ * process.
+ */
+public abstract class ListElement {
+
+ private Position position;
+
+ /**
+ * Main constructor
+ * @param position the Position instance needed by the addAreas stage of the LMs.
+ */
+ public ListElement(Position position) {
+ this.position = position;
+ }
+
+ /**
+ * @return the Position instance for this element.
+ */
+ public Position getPosition() {
+ return this.position;
+ }
+
+ /**
+ * Change the Position stored in this element.
+ * @param position the Position instance
+ */
+ public void setPosition(Position position) {
+ this.position = position;
+ }
+
+ /**
+ * @return the LayoutManager responsible for this element.
+ */
+ public LayoutManager getLayoutManager() {
+ if (position != null) {
+ return position.getLM();
+ } else {
+ return null;
+ }
+ }
+
+ /** @return true if this element is a KnuthBox. */
+ public boolean isBox() {
+ return false;
+ }
+
+ /** @return true if this element is a KnuthGlue. */
+ public boolean isGlue() {
+ return false;
+ }
+
+ /** @return true if this element is a KnuthPenalty. */
+ public boolean isPenalty() {
+ return false;
+ }
+
+ /** @return true if the element is a penalty and represents a forced break. */
+ public boolean isForcedBreak() {
+ return false;
+ }
+
+ /** @return true if the element is an unresolved element such as a space or a border. */
+ public boolean isUnresolvedElement() {
+ return true;
+ }
+
+}
--- /dev/null
+/*
+ * Copyright 2005 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;
+
+import org.apache.fop.datatypes.PercentBaseContext;
+import org.apache.fop.fo.properties.CondLengthProperty;
+import org.apache.fop.traits.MinOptMax;
+
+/**
+ * This represents an unresolved padding element.
+ */
+public class PaddingElement extends BorderOrPaddingElement {
+
+ /**
+ * Main constructor
+ * @param position the Position instance needed by the addAreas stage of the LMs.
+ * @param side the side to which this space element applies.
+ * @param condLength the length-conditional property for a border or padding specification
+ * @param isFirst true if this is a padding- or border-before of the first area generated.
+ * @param isLast true if this is a padding- or border-after of the last area generated.
+ * @param context the property evaluation context
+ */
+ public PaddingElement(Position position, CondLengthProperty condLength,
+ RelSide side,
+ boolean isFirst, boolean isLast, PercentBaseContext context) {
+ super(position, condLength, side, isFirst, isLast, context);
+ }
+
+ /** @see org.apache.fop.layoutmgr.UnresolvedListElementWithLength */
+ public void notifyLayoutManager(MinOptMax effectiveLength) {
+ LayoutManager lm = getOriginatingLayoutManager();
+ if (lm instanceof ConditionalElementListener) {
+ ((ConditionalElementListener)lm).notifyPadding(
+ getSide(), effectiveLength);
+ } else {
+ log.warn("Cannot notify LM. It does not implement ConditionalElementListene: "
+ + lm.getClass().getName());
+ }
+ }
+
+ /** @see java.lang.Object#toString() */
+ public String toString() {
+ StringBuffer sb = new StringBuffer("Padding[");
+ sb.append(super.toString());
+ sb.append("]");
+ return sb.toString();
+ }
+
+}
ListIterator elementListsIterator = elementLists.listIterator();
while (elementListsIterator.hasNext()) {
LinkedList noteList = (LinkedList) elementListsIterator.next();
+
+ //Space resolution (Note: this does not respect possible stacking constraints
+ //between footnotes!)
+ SpaceResolver.resolveElementList(noteList);
+
int noteLength = 0;
footnotesList.add(noteList);
ListIterator noteListIterator = noteList.listIterator();
if (contentList != null) {
ListIterator contentListIterator = contentList.listIterator();
while (contentListIterator.hasNext()) {
- KnuthElement element = (KnuthElement) contentListIterator.next();
+ ListElement element = (ListElement) contentListIterator.next();
if (element instanceof KnuthBlockBox
&& ((KnuthBlockBox) element).hasAnchors()) {
// element represents a line with footnote citations
int lastIndex = (i == pbp.footnoteLastListIndex
? pbp.footnoteLastElementIndex : elementList.size() - 1);
- FootnoteBodyLayoutManager fblm = (FootnoteBodyLayoutManager)
- ((KnuthElement) elementList.getFirst()).getLayoutManager();
+ SpaceResolver.performConditionalsNotification(elementList,
+ firstIndex, lastIndex, -1);
LayoutContext childLC = new LayoutContext(0);
- fblm.addAreas(new KnuthPossPosIter(elementList, firstIndex, lastIndex + 1),
+ AreaAdditionUtil.addAreas(null,
+ new KnuthPossPosIter(elementList, firstIndex, lastIndex + 1),
childLC);
}
// set the offset from the top margin
return childFLM;
}
+ /** @see org.apache.fop.layoutmgr.AbstractBreaker#observeElementList(java.util.List) */
+ protected void observeElementList(List elementList) {
+ ElementListObserver.observe(elementList, "breaker",
+ ((PageSequence)pslm.getFObj()).getId());
+ }
+
}
/**
LayoutManager lm = getLM(nextObj);
if (childLM == null) {
childLM = lm;
- } else if (childLM != lm) {
+ } else if (childLM != lm && lm != null) {
// End of this sub-sequence with same child LM
bHasNext = false;
childLM = null;
--- /dev/null
+/*
+ * Copyright 2005 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;
+
+/** Enum class for relative sides. */
+public final class RelSide {
+
+ /** the before side */
+ public static final RelSide BEFORE = new RelSide("before");
+ /** the after side */
+ public static final RelSide AFTER = new RelSide("after");
+ /** the start side */
+ public static final RelSide START = new RelSide("start");
+ /** the end side */
+ public static final RelSide END = new RelSide("end");
+
+ private String name;
+
+ /**
+ * Constructor to add a new named item.
+ * @param name Name of the item.
+ */
+ private RelSide(String name) {
+ this.name = name;
+ }
+
+ /** @return the name of the enum */
+ public String getName() {
+ return this.name;
+ }
+
+ /** @see java.lang.Object#toString() */
+ public String toString() {
+ return "RelSide:" + name;
+ }
+
+}
--- /dev/null
+/*
+ * Copyright 2005 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;
+
+import org.apache.fop.datatypes.PercentBaseContext;
+import org.apache.fop.fo.Constants;
+import org.apache.fop.fo.properties.SpaceProperty;
+import org.apache.fop.traits.MinOptMax;
+
+/**
+ * This class represents an unresolved space element.
+ */
+public class SpaceElement extends UnresolvedListElementWithLength {
+
+ private int precedence;
+
+ /**
+ * Main constructor
+ * @param position the Position instance needed by the addAreas stage of the LMs.
+ * @param space the space property
+ * @param side the side to which this space element applies.
+ * @param isFirst true if this is a space-before of the first area generated.
+ * @param isLast true if this is a space-after of the last area generated.
+ * @param context the property evaluation context
+ */
+ public SpaceElement(Position position, SpaceProperty space, RelSide side,
+ boolean isFirst, boolean isLast,
+ PercentBaseContext context) {
+ super(position,
+ MinOptMaxUtil.toMinOptMax(
+ space.getSpace().getLengthRange(),
+ context), side, space.isDiscard(), isFirst, isLast);
+ int en = space.getSpace().getPrecedence().getEnum();
+ if (en == Constants.EN_FORCE) {
+ this.precedence = Integer.MAX_VALUE;
+ } else {
+ this.precedence = space.getSpace().getPrecedence().getNumber().intValue();
+ }
+ }
+
+ /** @return true if the space is forcing. */
+ public boolean isForcing() {
+ return this.precedence == Integer.MAX_VALUE;
+ }
+
+ /** @return the precedence of the space */
+ public int getPrecedence() {
+ return this.precedence;
+ }
+
+ /** @see org.apache.fop.layoutmgr.UnresolvedListElementWithLength */
+ public void notifyLayoutManager(MinOptMax effectiveLength) {
+ LayoutManager lm = getOriginatingLayoutManager();
+ if (lm instanceof ConditionalElementListener) {
+ ((ConditionalElementListener)lm).notifySpace(
+ getSide(), effectiveLength);
+ } else {
+ log.warn("Cannot notify LM. It does not implement ConditionalElementListener:"
+ + lm.getClass().getName());
+ }
+ }
+
+ /** @see java.lang.Object#toString() */
+ public String toString() {
+ StringBuffer sb = new StringBuffer("Space[");
+ sb.append(super.toString());
+ sb.append(", precedence=");
+ if (isForcing()) {
+ sb.append("forcing");
+ } else {
+ sb.append(getPrecedence());
+ }
+ sb.append("]");
+ return sb.toString();
+ }
+
+}
--- /dev/null
+/*
+ * Copyright 2005 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;
+
+import java.util.Arrays;
+import java.util.Collections;
+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.traits.MinOptMax;
+
+/**
+ * This class resolves spaces and conditional borders and paddings by replacing the
+ * UnresolvedListElements descendants by the right combination of KnuthElements on an element
+ * list.
+ */
+public class SpaceResolver {
+
+ /** Logger instance */
+ protected static Log log = LogFactory.getLog(SpaceResolver.class);
+
+ private UnresolvedListElementWithLength[] firstPart;
+ private BreakElement breakPoss;
+ private UnresolvedListElementWithLength[] secondPart;
+ private UnresolvedListElementWithLength[] noBreak;
+
+ private MinOptMax[] firstPartLengths;
+ private MinOptMax[] secondPartLengths;
+ private MinOptMax[] noBreakLengths;
+
+ private boolean isFirst;
+ private boolean isLast;
+
+ /**
+ * Main constructor.
+ * @param first Element list before a break (optional)
+ * @param breakPoss Break possibility (optional)
+ * @param second Element list after a break (or if no break possibility in vicinity)
+ * @param isFirst Resolution at the beginning of a (full) element list
+ * @param isLast Resolution at the end of a (full) element list
+ */
+ public SpaceResolver(List first, BreakElement breakPoss, List second,
+ boolean isFirst, boolean isLast) {
+ this.isFirst = isFirst;
+ this.isLast = isLast;
+ //Create combined no-break list
+ int c = 0;
+ if (first != null) {
+ c += first.size();
+ }
+ if (second != null) {
+ c += second.size();
+ }
+ noBreak = new UnresolvedListElementWithLength[c];
+ noBreakLengths = new MinOptMax[c];
+ int i = 0;
+ ListIterator iter;
+ if (first != null) {
+ iter = first.listIterator();
+ while (iter.hasNext()) {
+ noBreak[i] = (UnresolvedListElementWithLength)iter.next();
+ noBreakLengths[i] = noBreak[i].getLength();
+ i++;
+ }
+ }
+ if (second != null) {
+ iter = second.listIterator();
+ while (iter.hasNext()) {
+ noBreak[i] = (UnresolvedListElementWithLength)iter.next();
+ noBreakLengths[i] = noBreak[i].getLength();
+ i++;
+ }
+ }
+
+ //Add pending elements from higher level FOs
+ if (breakPoss != null) {
+ if (breakPoss.getPendingAfterMarks() != null) {
+ if (log.isTraceEnabled()) {
+ log.trace(" adding pending before break: "
+ + breakPoss.getPendingAfterMarks());
+ }
+ first.addAll(0, breakPoss.getPendingAfterMarks());
+ }
+ if (breakPoss.getPendingBeforeMarks() != null) {
+ if (log.isTraceEnabled()) {
+ log.trace(" adding pending after break: "
+ + breakPoss.getPendingBeforeMarks());
+ }
+ second.addAll(0, breakPoss.getPendingBeforeMarks());
+ }
+ }
+ if (log.isTraceEnabled()) {
+ log.trace("before: " + first);
+ log.trace(" break: " + breakPoss);
+ log.trace("after: " + second);
+ log.trace("NO-BREAK: " + toString(noBreak, noBreakLengths));
+ }
+
+ if (first != null) {
+ firstPart = new UnresolvedListElementWithLength[first.size()];
+ firstPartLengths = new MinOptMax[firstPart.length];
+ first.toArray(firstPart);
+ for (i = 0; i < firstPart.length; i++) {
+ firstPartLengths[i] = firstPart[i].getLength();
+ }
+ }
+ this.breakPoss = breakPoss;
+ if (second != null) {
+ secondPart = new UnresolvedListElementWithLength[second.size()];
+ secondPartLengths = new MinOptMax[secondPart.length];
+ second.toArray(secondPart);
+ for (i = 0; i < secondPart.length; i++) {
+ secondPartLengths[i] = secondPart[i].getLength();
+ }
+ }
+ resolve();
+ }
+
+ private String toString(Object[] arr1, Object[] arr2) {
+ if (arr1.length != arr2.length) {
+ new IllegalArgumentException("The length of both arrays must be equal");
+ }
+ StringBuffer sb = new StringBuffer("[");
+ for (int i = 0; i < arr1.length; i++) {
+ if (i > 0) {
+ sb.append(", ");
+ }
+ sb.append(String.valueOf(arr1[i]));
+ sb.append("/");
+ sb.append(String.valueOf(arr2[i]));
+ }
+ sb.append("]");
+ return sb.toString();
+ }
+
+ private void removeConditionalBorderAndPadding(
+ UnresolvedListElement[] elems, MinOptMax[] lengths, boolean reverse) {
+ for (int i = 0; i < elems.length; i++) {
+ int effIndex;
+ if (reverse) {
+ effIndex = elems.length - 1 - i;
+ } else {
+ effIndex = i;
+ }
+ if (elems[effIndex] instanceof BorderOrPaddingElement) {
+ BorderOrPaddingElement bop = (BorderOrPaddingElement)elems[effIndex];
+ if (bop.isConditional() && !(bop.isFirst() || bop.isLast())) {
+ if (log.isDebugEnabled()) {
+ log.debug("Nulling conditional element: " + bop);
+ }
+ lengths[effIndex] = null;
+ }
+ }
+ }
+ if (log.isTraceEnabled() && elems.length > 0) {
+ log.trace("-->Resulting list: " + toString(elems, lengths));
+ }
+ }
+
+ private void performSpaceResolutionRule1(UnresolvedListElement[] elems, MinOptMax[] lengths,
+ boolean reverse) {
+ for (int i = 0; i < elems.length; i++) {
+ int effIndex;
+ if (reverse) {
+ effIndex = elems.length - 1 - i;
+ } else {
+ effIndex = i;
+ }
+ if (lengths[effIndex] == null) {
+ //Zeroed border or padding doesn't create a fence
+ continue;
+ } else if (elems[effIndex] instanceof BorderOrPaddingElement) {
+ //Border or padding form fences!
+ break;
+ } else if (!elems[effIndex].isConditional()) {
+ break;
+ }
+ if (log.isDebugEnabled()) {
+ log.debug("Nulling conditional element using 4.3.1, rule 1: " + elems[effIndex]);
+ }
+ lengths[effIndex] = null;
+ }
+ if (log.isTraceEnabled() && elems.length > 0) {
+ log.trace("-->Resulting list: " + toString(elems, lengths));
+ }
+ }
+
+ private void performSpaceResolutionRules2to3(UnresolvedListElement[] elems,
+ MinOptMax[] lengths, int start, int end) {
+ if (log.isTraceEnabled()) {
+ log.trace("rule 2-3: " + start + "-" + end);
+ }
+ SpaceElement space;
+ int remaining;
+
+ //Rule 2 (4.3.1, XSL 1.0)
+ boolean hasForcing = false;
+ remaining = 0;
+ for (int i = start; i <= end; i++) {
+ if (lengths[i] == null) {
+ continue;
+ }
+ remaining++;
+ space = (SpaceElement)elems[i];
+ if (space.isForcing()) {
+ hasForcing = true;
+ break;
+ }
+ }
+ if (remaining == 0) {
+ return; //shortcut
+ }
+ if (hasForcing) {
+ for (int i = start; i <= end; i++) {
+ if (lengths[i] == null) {
+ continue;
+ }
+ space = (SpaceElement)elems[i];
+ if (!space.isForcing()) {
+ if (log.isDebugEnabled()) {
+ log.debug("Nulling non-forcing space-specifier using 4.3.1, rule 2: "
+ + elems[i]);
+ }
+ lengths[i] = null;
+ }
+ }
+ return; //If rule is triggered skip rule 3
+ }
+
+ //Rule 3 (4.3.1, XSL 1.0)
+ //Determine highes precedence
+ int highestPrecedence = Integer.MIN_VALUE;
+ for (int i = start; i <= end; i++) {
+ if (lengths[i] == null) {
+ continue;
+ }
+ space = (SpaceElement)elems[i];
+ highestPrecedence = Math.max(highestPrecedence, space.getPrecedence());
+ }
+ if (highestPrecedence != 0 && log.isDebugEnabled()) {
+ log.debug("Highest precedence is " + highestPrecedence);
+ }
+ //Suppress space-specifiers with lower precedence
+ remaining = 0;
+ int greatestOptimum = Integer.MIN_VALUE;
+ for (int i = start; i <= end; i++) {
+ if (lengths[i] == null) {
+ continue;
+ }
+ space = (SpaceElement)elems[i];
+ if (space.getPrecedence() != highestPrecedence) {
+ if (log.isDebugEnabled()) {
+ log.debug("Nulling space-specifier with precedence "
+ + space.getPrecedence() + " using 4.3.1, rule 3: "
+ + elems[i]);
+ }
+ lengths[i] = null;
+ } else {
+ greatestOptimum = Math.max(greatestOptimum, space.getLength().opt);
+ remaining++;
+ }
+ }
+ if (log.isDebugEnabled()) {
+ log.debug("Greatest optimum: " + greatestOptimum);
+ }
+ if (remaining <= 1) {
+ return;
+ }
+ //Suppress space-specifiers with smaller optimum length
+ remaining = 0;
+ for (int i = start; i <= end; i++) {
+ if (lengths[i] == null) {
+ continue;
+ }
+ space = (SpaceElement)elems[i];
+ if (space.getLength().opt < greatestOptimum) {
+ if (log.isDebugEnabled()) {
+ log.debug("Nulling space-specifier with smaller optimum length "
+ + "using 4.3.1, rule 3: "
+ + elems[i]);
+ }
+ lengths[i] = null;
+ } else {
+ remaining++;
+ }
+ }
+ if (remaining <= 1) {
+ return;
+ }
+ //Construct resolved space-specifier from the remaining spaces
+ int min = Integer.MIN_VALUE;
+ int max = Integer.MAX_VALUE;
+ for (int i = start; i <= end; i++) {
+ if (lengths[i] == null) {
+ continue;
+ }
+ space = (SpaceElement)elems[i];
+ min = Math.max(min, space.getLength().min);
+ max = Math.min(max, space.getLength().max);
+ if (remaining > 1) {
+ if (log.isDebugEnabled()) {
+ log.debug("Nulling non-last space-specifier using 4.3.1, rule 3, second part: "
+ + elems[i]);
+ }
+ lengths[i] = null;
+ remaining--;
+ } else {
+ lengths[i].min = min;
+ lengths[i].max = max;
+ }
+ }
+
+ if (log.isTraceEnabled() && elems.length > 0) {
+ log.trace("Remaining spaces: " + remaining);
+ log.trace("-->Resulting list: " + toString(elems, lengths));
+ }
+ }
+
+ private void performSpaceResolutionRules2to3(UnresolvedListElement[] elems,
+ MinOptMax[] lengths) {
+ int start = 0;
+ int i = start;
+ while (i < elems.length) {
+ if (elems[i] instanceof SpaceElement) {
+ while (i < elems.length) {
+ if (elems[i] == null || elems[i] instanceof SpaceElement) {
+ i++;
+ } else {
+ break;
+ }
+ }
+ performSpaceResolutionRules2to3(elems, lengths, start, i - 1);
+ }
+ i++;
+ start = i;
+ }
+ }
+
+ private boolean hasFirstPart() {
+ return firstPart != null && firstPart.length > 0;
+ }
+
+ private boolean hasSecondPart() {
+ return secondPart != null && secondPart.length > 0;
+ }
+
+ private void resolve() {
+ if (breakPoss != null) {
+ if (hasFirstPart()) {
+ removeConditionalBorderAndPadding(firstPart, firstPartLengths, true);
+ performSpaceResolutionRule1(firstPart, firstPartLengths, true);
+ performSpaceResolutionRules2to3(firstPart, firstPartLengths);
+ }
+ if (hasSecondPart()) {
+ removeConditionalBorderAndPadding(secondPart, secondPartLengths, false);
+ performSpaceResolutionRule1(secondPart, secondPartLengths, false);
+ performSpaceResolutionRules2to3(secondPart, secondPartLengths);
+ }
+ if (noBreak != null) {
+ performSpaceResolutionRules2to3(noBreak, noBreakLengths);
+ }
+ } else {
+ if (isFirst) {
+ removeConditionalBorderAndPadding(secondPart, secondPartLengths, false);
+ performSpaceResolutionRule1(secondPart, secondPartLengths, false);
+ }
+ if (isLast) {
+ removeConditionalBorderAndPadding(firstPart, firstPartLengths, true);
+ performSpaceResolutionRule1(firstPart, firstPartLengths, true);
+ }
+
+ if (hasFirstPart()) {
+ //Now that we've handled isFirst/isLast conditions, we need to look at the
+ //active part in its normal order so swap it back.
+ log.trace("Swapping first and second parts.");
+ UnresolvedListElementWithLength[] tempList;
+ MinOptMax[] tempLengths;
+ tempList = secondPart;
+ tempLengths = secondPartLengths;
+ secondPart = firstPart;
+ secondPartLengths = firstPartLengths;
+ firstPart = tempList;
+ firstPartLengths = tempLengths;
+ if (hasFirstPart()) {
+ throw new IllegalStateException("Didn't expect more than one parts in a"
+ + "no-break condition.");
+ }
+ }
+ performSpaceResolutionRules2to3(secondPart, secondPartLengths);
+ }
+ }
+
+ private MinOptMax sum(MinOptMax[] lengths) {
+ MinOptMax sum = new MinOptMax();
+ for (int i = 0; i < lengths.length; i++) {
+ if (lengths[i] != null) {
+ sum.add(lengths[i]);
+ }
+ }
+ return sum;
+ }
+
+ private void generate(ListIterator iter) {
+ MinOptMax noBreakLength = new MinOptMax();
+ MinOptMax glue1; //space before break possibility if break occurs
+ //MinOptMax glue2; //difference between glue 1 and 3 when no break occurs
+ MinOptMax glue3; //space after break possibility if break occurs
+ glue1 = sum(firstPartLengths);
+ glue3 = sum(secondPartLengths);
+ noBreakLength = sum(noBreakLengths);
+
+ //This doesn't produce the right glue2
+ //glue2 = new MinOptMax(noBreakLength);
+ //glue2.subtract(glue1);
+ //glue2.subtract(glue3);
+
+ int glue2w = noBreakLength.opt - glue1.opt - glue3.opt;
+ int glue2stretch = (noBreakLength.max - noBreakLength.opt);
+ int glue2shrink = (noBreakLength.opt - noBreakLength.min);
+ glue2stretch -= glue1.max - glue1.opt;
+ glue2stretch -= glue3.max - glue3.opt;
+ glue2shrink -= glue1.opt - glue1.min;
+ glue2shrink -= glue3.opt - glue3.min;
+
+ boolean hasPrecedingNonBlock = false;
+ if (log.isDebugEnabled()) {
+ log.debug("noBreakLength=" + noBreakLength
+ + ", glue1=" + glue1
+ + ", glue2=" + glue2w + "+" + glue2stretch + "-" + glue2shrink
+ + ", glue3=" + glue3);
+ }
+ if (breakPoss != null) {
+ if (glue1.isNonZero()) {
+ iter.add(new KnuthPenalty(0, KnuthPenalty.INFINITE,
+ false, (Position)null, true));
+ iter.add(new KnuthGlue(glue1.opt, glue1.max - glue1.opt, glue1.opt - glue1.min,
+ (Position)null, true));
+ }
+ iter.add(new KnuthPenalty(breakPoss.getPenaltyWidth(), breakPoss.getPenaltyValue(),
+ false, breakPoss.getBreakClass(),
+ new SpaceHandlingBreakPosition(this, breakPoss), false));
+ //if (glue2.isNonZero()) {
+ if (glue2w != 0 || glue2stretch != 0 || glue2shrink != 0) {
+ /*
+ iter.add(new KnuthGlue(glue2.opt, glue2.max - glue2.opt, glue2.opt - glue2.min,
+ (Position)null, true));
+ */
+ iter.add(new KnuthGlue(glue2w, glue2stretch, glue2shrink,
+ (Position)null, true));
+ }
+ } else {
+ if (glue1.isNonZero()) {
+ throw new IllegalStateException("glue1 should be 0 in this case");
+ }
+ }
+ Position pos = null;
+ if (breakPoss == null) {
+ pos = new SpaceHandlingPosition(this);
+ }
+ if (glue3.isNonZero() || pos != null) {
+ iter.add(new KnuthBox(0, pos, true));
+ }
+ if (glue3.isNonZero()) {
+ iter.add(new KnuthPenalty(0, KnuthPenalty.INFINITE,
+ false, (Position)null, true));
+ iter.add(new KnuthGlue(glue3.opt, glue3.max - glue3.opt, glue3.opt - glue3.min,
+ (Position)null, true));
+ hasPrecedingNonBlock = true;
+ }
+ if (isLast && hasPrecedingNonBlock) {
+ //Otherwise, the preceding penalty and glue will be cut off
+ iter.add(new KnuthBox(0, (Position)null, true));
+ }
+ }
+
+ /**
+ * Position class for break possibilities. It is used to notify layout manager about the
+ * effective spaces and conditional lengths.
+ */
+ public class SpaceHandlingBreakPosition extends Position {
+
+ private SpaceResolver resolver;
+ private Position originalPosition;
+
+ /**
+ * Main constructor.
+ * @param resolver the space resolver that provides the info about the actual situation
+ */
+ public SpaceHandlingBreakPosition(SpaceResolver resolver, BreakElement breakPoss) {
+ super(null);
+ this.resolver = resolver;
+ this.originalPosition = breakPoss.getPosition();
+ //Unpack since the SpaceHandlingBreakPosition is a non-wrapped Position, too
+ while (this.originalPosition instanceof NonLeafPosition) {
+ this.originalPosition = this.originalPosition.getPosition();
+ }
+ }
+
+ /** @return the space resolver */
+ public SpaceResolver getSpaceResolver() {
+ return this.resolver;
+ }
+
+ /**
+ * Notifies all affected layout managers about the current situation in the part to be
+ * handled for area generation.
+ * @param isBreakSituation true if this is a break situation.
+ * @param side defines to notify about the situation whether before or after the break.
+ * May be null if isBreakSituation is null.
+ */
+ public void notifyBreakSituation(boolean isBreakSituation, RelSide side) {
+ if (isBreakSituation) {
+ if (RelSide.BEFORE == side) {
+ for (int i = 0; i < resolver.secondPart.length; i++) {
+ resolver.secondPart[i].notifyLayoutManager(resolver.secondPartLengths[i]);
+ }
+ } else {
+ for (int i = 0; i < resolver.firstPart.length; i++) {
+ resolver.firstPart[i].notifyLayoutManager(resolver.firstPartLengths[i]);
+ }
+ }
+ } else {
+ for (int i = 0; i < resolver.noBreak.length; i++) {
+ resolver.noBreak[i].notifyLayoutManager(resolver.noBreakLengths[i]);
+ }
+ }
+ }
+
+ /** @see java.lang.Object#toString() */
+ public String toString() {
+ StringBuffer sb = new StringBuffer();
+ sb.append("SpaceHandlingBreakPosition(");
+ sb.append(this.originalPosition);
+ sb.append(")");
+ return sb.toString();
+ }
+
+ /**
+ * @return the original Position instance set at the BreakElement that this Position was
+ * created for.
+ */
+ public Position getOriginalBreakPosition() {
+ return this.originalPosition;
+ }
+ }
+
+ /**
+ * Position class for no-break situations. It is used to notify layout manager about the
+ * effective spaces and conditional lengths.
+ */
+ public class SpaceHandlingPosition extends Position {
+
+ private SpaceResolver resolver;
+
+ /**
+ * Main constructor.
+ * @param resolver the space resolver that provides the info about the actual situation
+ */
+ public SpaceHandlingPosition(SpaceResolver resolver) {
+ super(null);
+ this.resolver = resolver;
+ }
+
+ /** @return the space resolver */
+ public SpaceResolver getSpaceResolver() {
+ return this.resolver;
+ }
+
+ /**
+ * Notifies all affected layout managers about the current situation in the part to be
+ * handled for area generation.
+ */
+ public void notifySpaceSituation() {
+ if (resolver.breakPoss != null) {
+ throw new IllegalStateException("Only applicable to no-break situations");
+ }
+ for (int i = 0; i < resolver.secondPart.length; i++) {
+ resolver.secondPart[i].notifyLayoutManager(resolver.secondPartLengths[i]);
+ }
+ }
+
+ /** @see java.lang.Object#toString() */
+ public String toString() {
+ StringBuffer sb = new StringBuffer();
+ sb.append("SpaceHandlingPosition");
+ return sb.toString();
+ }
+ }
+
+ /**
+ * Resolves unresolved elements applying the space resolution rules defined in 4.3.1.
+ * @param elems the element list
+ */
+ public static void resolveElementList(LinkedList elems) {
+ if (log.isTraceEnabled()) {
+ log.trace(elems);
+ }
+ boolean first = true;
+ boolean last = false;
+ boolean skipNextElement = false;
+ List unresolvedFirst = new java.util.ArrayList();
+ List unresolvedSecond = new java.util.ArrayList();
+ List currentGroup;
+ ListIterator iter = elems.listIterator();
+ while (iter.hasNext()) {
+ ListElement el = (ListElement)iter.next();
+ if (el.isUnresolvedElement()) {
+ if (log.isTraceEnabled()) {
+ log.trace("unresolved found: " + el + " " + first + "/" + last);
+ }
+ BreakElement breakPoss = null;
+ //Clear temp lists
+ unresolvedFirst.clear();
+ unresolvedSecond.clear();
+ //Collect groups
+ if (el instanceof BreakElement) {
+ breakPoss = (BreakElement)el;
+ currentGroup = unresolvedSecond;
+ } else {
+ currentGroup = unresolvedFirst;
+ currentGroup.add(el);
+ }
+ iter.remove();
+ last = true;
+ skipNextElement = true;
+ while (iter.hasNext()) {
+ el = (ListElement)iter.next();
+ if (el instanceof BreakElement && breakPoss != null) {
+ skipNextElement = false;
+ last = false;
+ break;
+ } else if (currentGroup == unresolvedFirst && (el instanceof BreakElement)) {
+ breakPoss = (BreakElement)el;
+ iter.remove();
+ currentGroup = unresolvedSecond;
+ } else if (el.isUnresolvedElement()) {
+ currentGroup.add(el);
+ iter.remove();
+ } else {
+ last = false;
+ break;
+ }
+ }
+ //last = !iter.hasNext();
+ if (breakPoss == null && unresolvedSecond.size() == 0 && !last) {
+ log.trace("Swap first and second parts in no-break condition,"
+ + " second part is empty.");
+ //The first list is reversed, so swap if this shouldn't happen
+ List swapList = unresolvedSecond;
+ unresolvedSecond = unresolvedFirst;
+ unresolvedFirst = swapList;
+ }
+
+ log.debug("----start space resolution (first=" + first + ", last=" + last + ")...");
+ SpaceResolver resolver = new SpaceResolver(
+ unresolvedFirst, breakPoss, unresolvedSecond, first, last);
+ if (!last) {
+ iter.previous();
+ }
+ resolver.generate(iter);
+ if (!last && skipNextElement) {
+ iter.next();
+ }
+ log.debug("----end space resolution.");
+ }
+ first = false;
+ }
+ }
+
+ /**
+ * Inspects an effective element list and notifies all layout managers about the state of
+ * the spaces and conditional lengths.
+ * @param effectiveList the effective element list
+ * @param startElementIndex index of the first element in the part to be processed
+ * @param endElementIndex index of the last element in the part to be processed
+ * @param lastBreak index of the the break possibility just before this part (used to
+ * identify a break condition, lastBreak <= 0 represents a no-break condition)
+ */
+ public static void performConditionalsNotification(List effectiveList,
+ int startElementIndex, int endElementIndex, int lastBreak) {
+ KnuthElement el = null;
+ if (lastBreak > 0) {
+ el = (KnuthElement)effectiveList.get(lastBreak);
+ }
+ SpaceResolver.SpaceHandlingBreakPosition beforeBreak = null;
+ SpaceResolver.SpaceHandlingBreakPosition afterBreak = null;
+ if (el != null && el.isPenalty()) {
+ Position pos = el.getPosition();
+ if (pos instanceof SpaceResolver.SpaceHandlingBreakPosition) {
+ beforeBreak = (SpaceResolver.SpaceHandlingBreakPosition)pos;
+ beforeBreak.notifyBreakSituation(true, RelSide.BEFORE);
+ }
+ }
+ el = (KnuthElement)effectiveList.get(endElementIndex);
+ if (el != null && el.isPenalty()) {
+ Position pos = el.getPosition();
+ if (pos instanceof SpaceResolver.SpaceHandlingBreakPosition) {
+ afterBreak = (SpaceResolver.SpaceHandlingBreakPosition)pos;
+ afterBreak.notifyBreakSituation(true, RelSide.AFTER);
+ }
+ }
+ for (int i = startElementIndex; i <= endElementIndex; i++) {
+ Position pos = ((KnuthElement)effectiveList.get(i)).getPosition();
+ if (pos instanceof SpaceResolver.SpaceHandlingPosition) {
+ ((SpaceResolver.SpaceHandlingPosition)pos).notifySpaceSituation();
+ } else if (pos instanceof SpaceResolver.SpaceHandlingBreakPosition) {
+ SpaceResolver.SpaceHandlingBreakPosition noBreak;
+ noBreak = (SpaceResolver.SpaceHandlingBreakPosition)pos;
+ if (noBreak != beforeBreak && noBreak != afterBreak) {
+ noBreak.notifyBreakSituation(false, null);
+ }
+ }
+ }
+ }
+
+
+
+}
package org.apache.fop.layoutmgr;
import java.util.LinkedList;
+import java.util.List;
import java.util.ListIterator;
import org.apache.fop.area.RegionReference;
import org.apache.fop.area.Area;
import org.apache.fop.area.Block;
+import org.apache.fop.fo.pagination.PageSequence;
import org.apache.fop.fo.pagination.SideRegion;
import org.apache.fop.fo.pagination.StaticContent;
import org.apache.fop.layoutmgr.inline.InlineLevelLayoutManager;
this.displayAlign = displayAlign;
}
+ /** @see org.apache.fop.layoutmgr.AbstractBreaker#observeElementList(java.util.List) */
+ protected void observeElementList(List elementList) {
+ String elementListID = getStaticContentFO().getFlowName();
+ String pageSequenceID = ((PageSequence)lm.getParent().getFObj()).getId();
+ if (pageSequenceID != null && pageSequenceID.length() > 0) {
+ elementListID += "-" + pageSequenceID;
+ }
+ ElementListObserver.observe(elementList, "static-content", elementListID);
+ }
+
/** @see org.apache.fop.layoutmgr.AbstractBreaker#isPartOverflowRecoveryActivated() */
protected boolean isPartOverflowRecoveryActivated() {
//For side regions, this must be disabled because of wanted overflow.
}
if (returnedList != null) {
lm.wrapPositionElements(returnedList, returnList);
- //returnList.addAll(returnedList);
}
}
+ SpaceResolver.resolveElementList(returnList);
setFinished(true);
return returnList;
}
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.fop.traits.BorderProps;
+import org.apache.fop.traits.MinOptMax;
import org.apache.fop.area.Area;
import org.apache.fop.area.Trait;
import org.apache.fop.datatypes.LengthBase;
}
/**
- * Add borders to an area.
+ * Add borders to an area. Note: this method also adds unconditional padding. Don't use!
* Layout managers that create areas with borders can use this to
* add the borders to the area.
* @param area the area to set the traits on.
* @param bordProps border properties
* @param context Property evaluation context
+ * @deprecated Call the other addBorders() method and addPadding separately.
*/
public static void addBorders(Area area, CommonBorderPaddingBackground bordProps,
PercentBaseContext context) {
addPadding(area, bordProps, context);
}
+ /**
+ * Add borders to an area.
+ * Layout managers that create areas with borders can use this to
+ * add the borders to the area.
+ * @param area the area to set the traits on.
+ * @param bordProps border properties
+ * @param discardBefore true if the before border should be discarded
+ * @param discardAfter true if the after border should be discarded
+ * @param discardStart true if the start border should be discarded
+ * @param discardEnd true if the end border should be discarded
+ * @param context Property evaluation context
+ */
+ public static void addBorders(Area area, CommonBorderPaddingBackground bordProps,
+ boolean discardBefore, boolean discardAfter,
+ boolean discardStart, boolean discardEnd,
+ PercentBaseContext context) {
+ BorderProps bps = getBorderProps(bordProps, CommonBorderPaddingBackground.BEFORE);
+ if (bps != null && !discardBefore) {
+ area.addTrait(Trait.BORDER_BEFORE, bps);
+ }
+ bps = getBorderProps(bordProps, CommonBorderPaddingBackground.AFTER);
+ if (bps != null && !discardAfter) {
+ area.addTrait(Trait.BORDER_AFTER, bps);
+ }
+ bps = getBorderProps(bordProps, CommonBorderPaddingBackground.START);
+ if (bps != null && !discardStart) {
+ area.addTrait(Trait.BORDER_START, bps);
+ }
+ bps = getBorderProps(bordProps, CommonBorderPaddingBackground.END);
+ if (bps != null && !discardEnd) {
+ area.addTrait(Trait.BORDER_END, bps);
+ }
+ }
+
/**
* Add borders to an area for the collapsing border model in tables.
* Layout managers that create areas with borders can use this to
private static void addPadding(Area area, CommonBorderPaddingBackground bordProps,
PercentBaseContext context) {
- int padding = bordProps.getPadding(CommonBorderPaddingBackground.START, false, context);
+ addPadding(area, bordProps, false, false, false, false, context);
+ }
+
+ /**
+ * Add padding to an area.
+ * Layout managers that create areas with padding can use this to
+ * add the borders to the area.
+ * @param area the area to set the traits on.
+ * @param bordProps border and padding properties
+ * @param discardBefore true if the before padding should be discarded
+ * @param discardAfter true if the after padding should be discarded
+ * @param discardStart true if the start padding should be discarded
+ * @param discardEnd true if the end padding should be discarded
+ * @param context Property evaluation context
+ */
+ public static void addPadding(Area area, CommonBorderPaddingBackground bordProps,
+ boolean discardBefore, boolean discardAfter,
+ boolean discardStart, boolean discardEnd,
+ PercentBaseContext context) {
+ int padding = bordProps.getPadding(CommonBorderPaddingBackground.BEFORE,
+ discardBefore, context);
if (padding != 0) {
- area.addTrait(Trait.PADDING_START, new java.lang.Integer(padding));
+ area.addTrait(Trait.PADDING_BEFORE, new java.lang.Integer(padding));
}
- padding = bordProps.getPadding(CommonBorderPaddingBackground.END, false, context);
+ padding = bordProps.getPadding(CommonBorderPaddingBackground.AFTER,
+ discardAfter, context);
if (padding != 0) {
- area.addTrait(Trait.PADDING_END, new java.lang.Integer(padding));
+ area.addTrait(Trait.PADDING_AFTER, new java.lang.Integer(padding));
}
- padding = bordProps.getPadding(CommonBorderPaddingBackground.BEFORE, false, context);
+ padding = bordProps.getPadding(CommonBorderPaddingBackground.START,
+ discardStart, context);
if (padding != 0) {
- area.addTrait(Trait.PADDING_BEFORE, new java.lang.Integer(padding));
+ area.addTrait(Trait.PADDING_START, new java.lang.Integer(padding));
}
- padding = bordProps.getPadding(CommonBorderPaddingBackground.AFTER, false, context);
+ padding = bordProps.getPadding(CommonBorderPaddingBackground.END,
+ discardEnd, context);
if (padding != 0) {
- area.addTrait(Trait.PADDING_AFTER, new java.lang.Integer(padding));
+ area.addTrait(Trait.PADDING_END, new java.lang.Integer(padding));
}
+
}
private static BorderProps getBorderProps(CommonBorderPaddingBackground bordProps, int side) {
width += backProps.getPaddingEnd(false, context);
back.setHoriz(backProps.backgroundPositionHorizontal.getValue(
new SimplePercentBaseContext(context,
- LengthBase.IMAGE_BACKGROUND_POSITION_HORIZONTAL,
- (width - back.getFopImage().getIntrinsicWidth())
- )
+ LengthBase.IMAGE_BACKGROUND_POSITION_HORIZONTAL,
+ (width - back.getFopImage().getIntrinsicWidth())
+ )
));
} else {
//TODO Area IPD has to be set for this to work
height += backProps.getPaddingAfter(false, context);
back.setVertical(backProps.backgroundPositionVertical.getValue(
new SimplePercentBaseContext(context,
- LengthBase.IMAGE_BACKGROUND_POSITION_VERTICAL,
- (height - back.getFopImage().getIntrinsicHeight())
- )
+ LengthBase.IMAGE_BACKGROUND_POSITION_VERTICAL,
+ (height - back.getFopImage().getIntrinsicHeight())
+ )
));
} else {
//TODO Area BPD has to be set for this to work
}
}
+ public static int getEffectiveSpace(double adjust, MinOptMax space) {
+ if (space == null) {
+ return 0;
+ }
+ int sp = space.opt;
+ if (adjust > 0) {
+ sp = sp + (int)(adjust * (space.max - space.opt));
+ } else {
+ sp = sp + (int)(adjust * (space.opt - space.min));
+ }
+ return sp;
+ }
+
+ public static void addSpaceBeforeAfter(Area area, double adjust,
+ MinOptMax spaceBefore, MinOptMax spaceAfter) {
+ int space;
+ space = getEffectiveSpace(adjust, spaceBefore);
+ if (space != 0) {
+ area.addTrait(Trait.SPACE_BEFORE, new Integer(space));
+ }
+ space = getEffectiveSpace(adjust, spaceAfter);
+ if (space != 0) {
+ area.addTrait(Trait.SPACE_AFTER, new Integer(space));
+ }
+ }
+
/**
* Sets the traits for breaks on an area.
* @param area the area to set the traits on.
--- /dev/null
+/*
+ * Copyright 2005 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;
+
+/**
+ * This class represents an unresolved list element.
+ */
+public abstract class UnresolvedListElement extends ListElement {
+
+ /**
+ * Main constructor
+ * @param position the Position instance needed by the addAreas stage of the LMs.
+ */
+ public UnresolvedListElement(Position position) {
+ super(position);
+ }
+
+ /** @return true if the element is conditional (conditionality="discard") */
+ public abstract boolean isConditional();
+
+ /** @return the layout manager that created this ListElement */
+ protected LayoutManager getOriginatingLayoutManager() {
+ Position pos = getPosition();
+ while (pos instanceof NonLeafPosition && pos.getPosition() != null) {
+ pos = pos.getPosition();
+ }
+ return pos.getLM();
+ }
+
+}
--- /dev/null
+/*
+ * Copyright 2005 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;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.fop.traits.MinOptMax;
+
+/**
+ * This class represents an unresolved list element element with a (conditional) length. This
+ * is the base class for spaces, borders and paddings.
+ */
+public abstract class UnresolvedListElementWithLength extends UnresolvedListElement {
+
+ /** Logger instance */
+ protected static Log log = LogFactory.getLog(UnresolvedListElementWithLength.class);
+
+ private MinOptMax length;
+ private boolean conditional;
+ private RelSide side;
+ private boolean isFirst;
+ private boolean isLast;
+
+ /**
+ * Main constructor
+ * @param position the Position instance needed by the addAreas stage of the LMs.
+ * @param length the length of the element
+ * @param side the side to which this element applies
+ * @param conditional true if it's a conditional element (conditionality=discard)
+ * @param isFirst true if this is a space-before of the first area generated.
+ * @param isLast true if this is a space-after of the last area generated.
+ */
+ public UnresolvedListElementWithLength(Position position, MinOptMax length,
+ RelSide side,
+ boolean conditional, boolean isFirst, boolean isLast) {
+ super(position);
+ this.length = length;
+ this.side = side;
+ this.conditional = conditional;
+ this.isFirst = isFirst;
+ this.isLast = isLast;
+ }
+
+ /** @see org.apache.fop.layoutmgr.UnresolvedListElement#isConditional() */
+ public boolean isConditional() {
+ return this.conditional;
+ }
+
+ /** @return the space as resolved MinOptMax instance */
+ public MinOptMax getLength() {
+ return this.length;
+ }
+
+ /** @return the side this element was generated for */
+ public RelSide getSide() {
+ return this.side;
+ }
+
+ /** @return true if this is a space-before of the first area generated. */
+ public boolean isFirst() {
+ return this.isFirst;
+ }
+
+ /** @return true if this is a space-after of the last area generated. */
+ public boolean isLast() {
+ return this.isLast;
+ }
+
+ /**
+ * Called to notify the affected layout manager about the effective length after resolution.
+ * This method is called once before each call to the layout manager's addAreas() method.
+ * @param effectiveLength the effective length after resolution (may be null which equals to
+ * zero effective length)
+ */
+ public abstract void notifyLayoutManager(MinOptMax effectiveLength);
+
+ /** @see java.lang.Object#toString() */
+ public String toString() {
+ StringBuffer sb = new StringBuffer();
+ sb.append(getSide().getName()).append(", ");
+ sb.append(this.length.toString());
+ if (isConditional()) {
+ sb.append("[discard]");
+ } else {
+ sb.append("[RETAIN]");
+ }
+ if (isFirst()) {
+ sb.append("[first]");
+ }
+ if (isLast()) {
+ sb.append("[last]");
+ }
+ return sb.toString();
+ }
+
+}
import org.apache.fop.hyphenation.Hyphenation;
import org.apache.fop.hyphenation.Hyphenator;
import org.apache.fop.layoutmgr.BlockLevelLayoutManager;
+import org.apache.fop.layoutmgr.BreakElement;
import org.apache.fop.layoutmgr.BreakingAlgorithm;
import org.apache.fop.layoutmgr.ElementListObserver;
import org.apache.fop.layoutmgr.KnuthBlockBox;
}
//PHASE 2: Create line breaks
- return createLineBreaks(context.getBPAlignment());
+ return createLineBreaks(context.getBPAlignment(), context);
/*
LineBreakPosition lbp = null;
if (breakpoints == null) {
/**
* Phase 2 of Knuth algorithm: find optimal break points.
* @param alignment alignment in BP direction of the paragraph
+ * @param context the layout context
* @return a list of Knuth elements representing broken lines
*/
- private LinkedList createLineBreaks(int alignment) {
+ private LinkedList createLineBreaks(int alignment, LayoutContext context) {
// find the optimal line breaking points for each paragraph
ListIterator paragraphsIterator
setFinished(true);
//Post-process the line breaks found
- return postProcessLineBreaks(alignment);
+ return postProcessLineBreaks(alignment, context);
}
/**
/**
* Creates the element list in BP direction for the broken lines.
* @param alignment the currently applicable vertical alignment
+ * @param context the layout context
* @return the newly built element list
*/
- private LinkedList postProcessLineBreaks(int alignment) {
+ private LinkedList postProcessLineBreaks(int alignment, LayoutContext context) {
LinkedList returnList = new LinkedList();
for (int p = 0; p < knuthParagraphs.size(); p++) {
// null penalty between paragraphs
- if (p > 0
- && !((BlockLevelLayoutManager) parentLM).mustKeepTogether()) {
- returnList.add(new KnuthPenalty(0, 0, false, new Position(this), false));
+ if (p > 0 && !((BlockLevelLayoutManager) parentLM).mustKeepTogether()) {
+ returnList.add(new BreakElement(
+ new Position(this), 0, context));
+ //returnList.add(new KnuthPenalty(0, 0, false, new Position(this), false));
}
lineLayouts = (LineLayoutPossibilities)lineLayoutsList.get(p);
i < lineLayouts.getChosenLineCount();
i++) {
if (!((BlockLevelLayoutManager) parentLM).mustKeepTogether()
- && i >= fobj.getOrphans()
- && i <= lineLayouts.getChosenLineCount() - fobj.getWidows()
- && returnList.size() > 0) {
+ && i >= fobj.getOrphans()
+ && i <= lineLayouts.getChosenLineCount() - fobj.getWidows()
+ && returnList.size() > 0) {
// null penalty allowing a page break between lines
- returnList.add(new KnuthPenalty(0, 0, false, returnPosition, false));
+ returnList.add(new BreakElement(
+ returnPosition, 0, context));
+ //returnList.add(new KnuthPenalty(0, 0, false, returnPosition, false));
}
int endIndex = ((LineBreakPosition) lineLayouts.getChosenPosition(i)).getLeafPos();
// create a list of the FootnoteBodyLM handling footnotes
import org.apache.fop.fo.flow.ListBlock;
import org.apache.fop.layoutmgr.BlockLevelLayoutManager;
import org.apache.fop.layoutmgr.BlockStackingLayoutManager;
+import org.apache.fop.layoutmgr.ConditionalElementListener;
import org.apache.fop.layoutmgr.LayoutManager;
import org.apache.fop.layoutmgr.LayoutContext;
import org.apache.fop.layoutmgr.PositionIterator;
import org.apache.fop.layoutmgr.Position;
import org.apache.fop.layoutmgr.NonLeafPosition;
+import org.apache.fop.layoutmgr.RelSide;
import org.apache.fop.layoutmgr.TraitSetter;
import org.apache.fop.area.Area;
import org.apache.fop.area.Block;
* A list block contains list items which are stacked within
* the list block area..
*/
-public class ListBlockLayoutManager extends BlockStackingLayoutManager {
+public class ListBlockLayoutManager extends BlockStackingLayoutManager
+ implements ConditionalElementListener {
private Block curBlockArea;
- //TODO space-before|after: handle space-resolution rules
+ private boolean discardBorderBefore;
+ private boolean discardBorderAfter;
+ private boolean discardPaddingBefore;
+ private boolean discardPaddingAfter;
+ private MinOptMax effSpaceBefore;
+ private MinOptMax effSpaceAfter;
private static class StackingIter extends PositionIterator {
StackingIter(Iterator parentIter) {
return (ListBlock)fobj;
}
+ /** @see org.apache.fop.layoutmgr.LayoutManager#initialize() */
public void initialize() {
- foSpaceBefore = new SpaceVal(getListBlockFO().getCommonMarginBlock().spaceBefore, this).getSpace();
- foSpaceAfter = new SpaceVal(getListBlockFO().getCommonMarginBlock().spaceAfter, this).getSpace();
+ foSpaceBefore = new SpaceVal(
+ getListBlockFO().getCommonMarginBlock().spaceBefore, this).getSpace();
+ foSpaceAfter = new SpaceVal(
+ getListBlockFO().getCommonMarginBlock().spaceAfter, this).getSpace();
}
+ private void resetSpaces() {
+ this.discardBorderBefore = false;
+ this.discardBorderAfter = false;
+ this.discardPaddingBefore = false;
+ this.discardPaddingAfter = false;
+ this.effSpaceBefore = foSpaceBefore;
+ this.effSpaceAfter = foSpaceAfter;
+ }
+
private int getIPIndents() {
int iIndents = 0;
iIndents += getListBlockFO().getCommonMarginBlock().startIndent.getValue(this);
return iIndents;
}
+ /** @see org.apache.fop.layoutmgr.BlockStackingLayoutManager */
+ public LinkedList getNextKnuthElements(LayoutContext context, int alignment) {
+ resetSpaces();
+ return super.getNextKnuthElements(context, alignment);
+ }
+
/** @see org.apache.fop.layoutmgr.LayoutManager#getChangedKnuthElements(java.util.List, int) */
public LinkedList getChangedKnuthElements(List oldList, int alignment) {
//log.debug("LBLM.getChangedKnuthElements>");
addBlockSpacing(0.0, new MinOptMax(layoutContext.getSpaceBefore()));
}
- // if adjusted space before
- double adjust = layoutContext.getSpaceAdjust();
- addBlockSpacing(adjust, foSpaceBefore);
- foSpaceBefore = null;
-
getPSLM().addIDToPage(getListBlockFO().getId());
// the list block contains areas stacked from each list item
TraitSetter.addBackground(curBlockArea,
getListBlockFO().getCommonBorderPaddingBackground(),
this);
+ TraitSetter.addSpaceBeforeAfter(curBlockArea, layoutContext.getSpaceAdjust(),
+ effSpaceBefore, effSpaceAfter);
flush();
- // if adjusted space after
- addBlockSpacing(adjust, foSpaceAfter);
-
curBlockArea = null;
+ resetSpaces();
}
/**
// set traits
TraitSetter.setProducerID(curBlockArea, getListBlockFO().getId());
TraitSetter.addBorders(curBlockArea,
- getListBlockFO().getCommonBorderPaddingBackground(), this);
+ getListBlockFO().getCommonBorderPaddingBackground(),
+ discardBorderBefore, discardBorderAfter, false, false, this);
+ TraitSetter.addPadding(curBlockArea,
+ getListBlockFO().getCommonBorderPaddingBackground(),
+ discardPaddingBefore, discardPaddingAfter, false, false, this);
TraitSetter.addMargins(curBlockArea,
getListBlockFO().getCommonBorderPaddingBackground(),
getListBlockFO().getCommonMarginBlock(),
|| !getListBlockFO().getKeepWithNext().getWithinColumn().isAuto();
}
+ /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+ public void notifySpace(RelSide side, MinOptMax effectiveLength) {
+ if (RelSide.BEFORE == side) {
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Space " + side + ", "
+ + this.effSpaceBefore + "-> " + effectiveLength);
+ }
+ this.effSpaceBefore = effectiveLength;
+ } else {
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Space " + side + ", "
+ + this.effSpaceAfter + "-> " + effectiveLength);
+ }
+ this.effSpaceAfter = effectiveLength;
+ }
+ }
+
+ /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+ public void notifyBorder(RelSide side, MinOptMax effectiveLength) {
+ if (effectiveLength == null) {
+ if (RelSide.BEFORE == side) {
+ this.discardBorderBefore = true;
+ } else {
+ this.discardBorderAfter = true;
+ }
+ }
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Border " + side + " -> " + effectiveLength);
+ }
+ }
+
+ /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+ public void notifyPadding(RelSide side, MinOptMax effectiveLength) {
+ if (effectiveLength == null) {
+ if (RelSide.BEFORE == side) {
+ this.discardPaddingBefore = true;
+ } else {
+ this.discardPaddingAfter = true;
+ }
+ }
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Padding " + side + " -> " + effectiveLength);
+ }
+ }
+
}
import org.apache.fop.fo.flow.ListItemLabel;
import org.apache.fop.layoutmgr.BlockLevelLayoutManager;
import org.apache.fop.layoutmgr.BlockStackingLayoutManager;
+import org.apache.fop.layoutmgr.BreakElement;
+import org.apache.fop.layoutmgr.ConditionalElementListener;
+import org.apache.fop.layoutmgr.ElementListObserver;
+import org.apache.fop.layoutmgr.ElementListUtils;
import org.apache.fop.layoutmgr.LayoutManager;
import org.apache.fop.layoutmgr.LayoutContext;
import org.apache.fop.layoutmgr.PositionIterator;
import org.apache.fop.layoutmgr.Position;
import org.apache.fop.layoutmgr.NonLeafPosition;
+import org.apache.fop.layoutmgr.RelSide;
+import org.apache.fop.layoutmgr.SpaceResolver;
import org.apache.fop.layoutmgr.TraitSetter;
import org.apache.fop.layoutmgr.KnuthElement;
import org.apache.fop.layoutmgr.KnuthBox;
import org.apache.fop.layoutmgr.KnuthPossPosIter;
import org.apache.fop.area.Area;
import org.apache.fop.area.Block;
+import org.apache.fop.traits.MinOptMax;
import org.apache.fop.traits.SpaceVal;
import java.util.ArrayList;
* LayoutManager for a list-item FO.
* The list item contains a list item label and a list item body.
*/
-public class ListItemLayoutManager extends BlockStackingLayoutManager {
+public class ListItemLayoutManager extends BlockStackingLayoutManager
+ implements ConditionalElementListener {
private ListItemContentLayoutManager label;
private ListItemContentLayoutManager body;
private int listItemHeight;
- //TODO space-before|after: handle space-resolution rules
+ private boolean discardBorderBefore;
+ private boolean discardBorderAfter;
+ private boolean discardPaddingBefore;
+ private boolean discardPaddingAfter;
+ private MinOptMax effSpaceBefore;
+ private MinOptMax effSpaceAfter;
private boolean keepWithNextPendingOnLabel;
private boolean keepWithNextPendingOnBody;
-
- /*
- private class ItemPosition extends LeafPosition {
- protected List cellBreaks;
- protected ItemPosition(LayoutManager lm, int pos, List l) {
- super(lm, pos);
- cellBreaks = l;
- }
- }*/
-
+
private class ListItemPosition extends Position {
private int iLabelFirstIndex;
private int iLabelLastIndex;
body.setParent(this);
}
+ /** @see org.apache.fop.layoutmgr.LayoutManager#initialize() */
public void initialize() {
- foSpaceBefore = new SpaceVal(getListItemFO().getCommonMarginBlock().spaceBefore, this).getSpace();
- foSpaceAfter = new SpaceVal(getListItemFO().getCommonMarginBlock().spaceAfter, this).getSpace();
+ foSpaceBefore = new SpaceVal(
+ getListItemFO().getCommonMarginBlock().spaceBefore, this).getSpace();
+ foSpaceAfter = new SpaceVal(
+ getListItemFO().getCommonMarginBlock().spaceAfter, this).getSpace();
}
+ private void resetSpaces() {
+ this.discardBorderBefore = false;
+ this.discardBorderAfter = false;
+ this.discardPaddingBefore = false;
+ this.discardPaddingAfter = false;
+ this.effSpaceBefore = foSpaceBefore;
+ this.effSpaceAfter = foSpaceAfter;
+ }
+
private int getIPIndents() {
int iIndents = 0;
iIndents += getListItemFO().getCommonMarginBlock().startIndent.getValue(this);
LinkedList returnList = new LinkedList();
- if (!bSpaceBeforeServed) {
- addKnuthElementsForSpaceBefore(returnList, alignment);
- bSpaceBeforeServed = true;
- }
+ addKnuthElementsForSpaceBefore(returnList, alignment);
+ //Spaces, border and padding to be repeated at each break
+ addPendingMarks(context);
+
// label
childLC = new LayoutContext(0);
childLC.setRefIPD(context.getRefIPD());
label.initialize();
labelList = label.getNextKnuthElements(childLC, alignment);
+
+ //Space resolution as if the contents were placed in a new reference area
+ //(see 6.8.3, XSL 1.0, section on Constraints, last paragraph)
+ SpaceResolver.resolveElementList(labelList);
+ ElementListObserver.observe(labelList, "list-item-label", label.getPartFO().getId());
+
if (childLC.isKeepWithPreviousPending()) {
context.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING);
}
childLC.setRefIPD(context.getRefIPD());
body.initialize();
bodyList = body.getNextKnuthElements(childLC, alignment);
+
+ //Space resolution as if the contents were placed in a new reference area
+ //(see 6.8.3, XSL 1.0, section on Constraints, last paragraph)
+ SpaceResolver.resolveElementList(bodyList);
+ ElementListObserver.observe(bodyList, "list-item-body", body.getPartFO().getId());
+
if (childLC.isKeepWithPreviousPending()) {
context.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING);
}
this.keepWithNextPendingOnBody = childLC.isKeepWithNextPending();
// create a combined list
- LinkedList returnedList = getCombinedKnuthElementsForListItem(labelList, bodyList);
+ LinkedList returnedList = getCombinedKnuthElementsForListItem(labelList, bodyList, context);
// "wrap" the Position inside each element
wrapPositionElements(returnedList, returnList, true);
}
setFinished(true);
+ resetSpaces();
return returnList;
}
private LinkedList getCombinedKnuthElementsForListItem(LinkedList labelElements,
- LinkedList bodyElements) {
+ LinkedList bodyElements,
+ LayoutContext context) {
//Copy elements to array lists to improve element access performance
List[] elementLists = {new ArrayList(labelElements),
new ArrayList(bodyElements)};
- int[] fullHeights = {calcItemHeightFromContents(elementLists[0]),
- calcItemHeightFromContents(elementLists[1])};
+ int[] fullHeights = {ElementListUtils.calcContentLength(elementLists[0]),
+ ElementListUtils.calcContentLength(elementLists[1])};
int[] partialHeights = {0, 0};
int[] start = {-1, -1};
int[] end = {-1, -1};
if (keepWithNextActive || mustKeepTogether()) {
p = KnuthPenalty.INFINITE;
}
- returnList.add(new KnuthPenalty(penaltyHeight, p, false, stepPosition, false));
+ //returnList.add(new KnuthPenalty(penaltyHeight, p, false, stepPosition, false));
+ returnList.add(new BreakElement(stepPosition, penaltyHeight, p, 0, context));
}
}
return returnList;
}
- private int calcItemHeightFromContents(List elements, int start, int end) {
- ListIterator iter = elements.listIterator(start);
- int count = end - start + 1;
- int len = 0;
- while (iter.hasNext()) {
- KnuthElement el = (KnuthElement)iter.next();
- if (el.isBox()) {
- len += el.getW();
- } else if (el.isGlue()) {
- len += el.getW();
- } else {
- log.debug("Ignoring penalty: " + el);
- //ignore penalties
- }
- count--;
- if (count == 0) {
- break;
- }
- }
- return len;
- }
-
- private int calcItemHeightFromContents(List elements) {
- return calcItemHeightFromContents(elements, 0, elements.size() - 1);
- }
-
private int getNextStep(List[] elementLists, int[] start, int[] end, int[] partialHeights) {
// backup of partial heights
int[] backupHeights = {partialHeights[0], partialHeights[1]};
LayoutContext layoutContext) {
getParentArea(null);
- // if adjusted space before
- double adjust = layoutContext.getSpaceAdjust();
- addBlockSpacing(adjust, foSpaceBefore);
- foSpaceBefore = null;
-
getPSLM().addIDToPage(getListItemFO().getId());
LayoutContext lc = new LayoutContext(0);
int bodyFirstIndex = ((ListItemPosition) positionList.getFirst()).getBodyFirstIndex();
int bodyLastIndex = ((ListItemPosition) positionList.getLast()).getBodyLastIndex();
+ int lastBreak;
+ //Determine last break if any
+ lastBreak = labelFirstIndex - 1;
+ while (lastBreak >= 0) {
+ KnuthElement el = (KnuthElement)labelList.get(lastBreak);
+ if (el.isPenalty() && el.getP() < KnuthElement.INFINITE) {
+ break;
+ }
+ lastBreak--;
+ }
+ SpaceResolver.performConditionalsNotification(labelList,
+ labelFirstIndex, labelLastIndex, lastBreak);
+
+ //Determine last break if any
+ lastBreak = bodyFirstIndex - 1;
+ while (lastBreak >= 0) {
+ KnuthElement el = (KnuthElement)bodyList.get(lastBreak);
+ if (el.isPenalty() && el.getP() < KnuthElement.INFINITE) {
+ break;
+ }
+ lastBreak--;
+ }
+ SpaceResolver.performConditionalsNotification(bodyList,
+ bodyFirstIndex, bodyLastIndex, lastBreak);
+
// add label areas
if (labelFirstIndex <= labelLastIndex) {
KnuthPossPosIter labelIter = new KnuthPossPosIter(labelList,
TraitSetter.addBackground(curBlockArea,
getListItemFO().getCommonBorderPaddingBackground(),
this);
+ TraitSetter.addSpaceBeforeAfter(curBlockArea, layoutContext.getSpaceAdjust(),
+ effSpaceBefore, effSpaceAfter);
flush();
- // if adjusted space after
- addBlockSpacing(adjust, foSpaceAfter);
-
curBlockArea = null;
+ resetSpaces();
}
/**
// set traits
TraitSetter.setProducerID(curBlockArea, getListItemFO().getId());
TraitSetter.addBorders(curBlockArea,
- getListItemFO().getCommonBorderPaddingBackground(), this);
+ getListItemFO().getCommonBorderPaddingBackground(),
+ discardBorderBefore, discardBorderAfter, false, false, this);
+ TraitSetter.addPadding(curBlockArea,
+ getListItemFO().getCommonBorderPaddingBackground(),
+ discardPaddingBefore, discardPaddingAfter, false, false, this);
TraitSetter.addMargins(curBlockArea,
getListItemFO().getCommonBorderPaddingBackground(),
getListItemFO().getCommonMarginBlock(), this);
|| !getListItemFO().getKeepWithNext().getWithinColumn().isAuto();
}
+ /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+ public void notifySpace(RelSide side, MinOptMax effectiveLength) {
+ if (RelSide.BEFORE == side) {
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Space " + side + ", "
+ + this.effSpaceBefore + "-> " + effectiveLength);
+ }
+ this.effSpaceBefore = effectiveLength;
+ } else {
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Space " + side + ", "
+ + this.effSpaceAfter + "-> " + effectiveLength);
+ }
+ this.effSpaceAfter = effectiveLength;
+ }
+ }
+
+ /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+ public void notifyBorder(RelSide side, MinOptMax effectiveLength) {
+ if (effectiveLength == null) {
+ if (RelSide.BEFORE == side) {
+ this.discardBorderBefore = true;
+ } else {
+ this.discardBorderAfter = true;
+ }
+ }
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Border " + side + " -> " + effectiveLength);
+ }
+ }
+
+ /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+ public void notifyPadding(RelSide side, MinOptMax effectiveLength) {
+ if (effectiveLength == null) {
+ if (RelSide.BEFORE == side) {
+ this.discardPaddingBefore = true;
+ } else {
+ this.discardPaddingAfter = true;
+ }
+ }
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Padding " + side + " -> " + effectiveLength);
+ }
+ }
+
+
}
import org.apache.fop.layoutmgr.AreaAdditionUtil;
import org.apache.fop.layoutmgr.BlockLevelLayoutManager;
import org.apache.fop.layoutmgr.BlockStackingLayoutManager;
+import org.apache.fop.layoutmgr.BreakElement;
import org.apache.fop.layoutmgr.KnuthElement;
import org.apache.fop.layoutmgr.KnuthGlue;
-import org.apache.fop.layoutmgr.KnuthPenalty;
import org.apache.fop.layoutmgr.LayoutContext;
+import org.apache.fop.layoutmgr.ListElement;
import org.apache.fop.layoutmgr.PositionIterator;
import org.apache.fop.layoutmgr.Position;
+import org.apache.fop.layoutmgr.SpaceResolver;
import org.apache.fop.layoutmgr.TraitSetter;
import org.apache.fop.area.Area;
import org.apache.fop.area.Block;
* LayoutManager for a table-cell FO.
* A cell contains blocks. These blocks fill the cell.
*/
-public class TableCellLayoutManager extends BlockStackingLayoutManager implements BlockLevelLayoutManager {
+public class TableCellLayoutManager extends BlockStackingLayoutManager
+ implements BlockLevelLayoutManager {
- private TableCell fobj;
private PrimaryGridUnit gridUnit;
private Block curBlockArea;
/** @return the table-cell FO */
public TableCell getTableCell() {
- return this.fobj;
+ return (TableCell)this.fobj;
}
private boolean isSeparateBorderModel() {
- return fobj.isSeparateBorderModel();
+ return getTableCell().isSeparateBorderModel();
}
+ /** @see org.apache.fop.layoutmgr.LayoutManager#initialize() */
public void initialize() {
borderAndPaddingBPD = 0;
- borderAndPaddingBPD += fobj.getCommonBorderPaddingBackground().getBorderBeforeWidth(false);
- borderAndPaddingBPD += fobj.getCommonBorderPaddingBackground().getBorderAfterWidth(false);
+ borderAndPaddingBPD += getTableCell()
+ .getCommonBorderPaddingBackground().getBorderBeforeWidth(false);
+ borderAndPaddingBPD += getTableCell()
+ .getCommonBorderPaddingBackground().getBorderAfterWidth(false);
if (!isSeparateBorderModel()) {
borderAndPaddingBPD /= 2;
}
- borderAndPaddingBPD += fobj.getCommonBorderPaddingBackground().getPaddingBefore(false, this);
- borderAndPaddingBPD += fobj.getCommonBorderPaddingBackground().getPaddingAfter(false, this);
+ borderAndPaddingBPD += getTableCell().getCommonBorderPaddingBackground()
+ .getPaddingBefore(false, this);
+ borderAndPaddingBPD += getTableCell().getCommonBorderPaddingBackground()
+ .getPaddingAfter(false, this);
}
/**
if (!isSeparateBorderModel()) {
iIndents /= 2;
}
- iIndents += fobj.getCommonBorderPaddingBackground().getPaddingStart(false, this);
- iIndents += fobj.getCommonBorderPaddingBackground().getPaddingEnd(false, this);
+ iIndents += getTableCell().getCommonBorderPaddingBackground().getPaddingStart(false, this);
+ iIndents += getTableCell().getCommonBorderPaddingBackground().getPaddingEnd(false, this);
return iIndents;
}
cellIPD = referenceIPD;
cellIPD -= getIPIndents();
if (isSeparateBorderModel()) {
- int borderSep = fobj.getBorderSeparation().getLengthPair()
+ int borderSep = getTableCell().getBorderSeparation().getLengthPair()
.getIPD().getLength().getValue(this);
cellIPD -= borderSep;
}
}
if (returnedList.size() == 1
- && ((KnuthElement) returnedList.getFirst()).isPenalty()
- && ((KnuthPenalty) returnedList.getFirst()).getP() == -KnuthElement.INFINITE) {
+ && ((ListElement)returnedList.getFirst()).isForcedBreak()) {
// a descendant of this block has break-before
if (returnList.size() == 0) {
// the first child (or its first child ...) has
returnedList = new LinkedList();
wrapPositionElements(contentList, returnList);
+ //Space resolution
+ SpaceResolver.resolveElementList(returnList);
+
return returnList;
} else {
if (prevLM != null) {
childLC.setFlags(LayoutContext.KEEP_WITH_PREVIOUS_PENDING, false);
// add an infinite penalty to forbid a break between
// blocks
- contentList.add(new KnuthPenalty(0,
- KnuthElement.INFINITE, false,
- new Position(this), false));
+ contentList.add(new BreakElement(
+ new Position(this), KnuthElement.INFINITE, context));
+ //contentList.add(new KnuthPenalty(0,
+ // KnuthElement.INFINITE, false,
+ // new Position(this), false));
} else if (!((KnuthElement) contentList.getLast()).isGlue()) {
// add a null penalty to allow a break between blocks
- contentList.add(new KnuthPenalty(0, 0, false,
- new Position(this), false));
+ contentList.add(new BreakElement(
+ new Position(this), 0, context));
+ //contentList.add(new KnuthPenalty(0, 0, false,
+ // new Position(this), false));
} else {
// the last element in contentList is a glue;
// it is a feasible breakpoint, there is no need to add
//Avoid NoSuchElementException below (happens with empty blocks)
continue;
}
- if (((KnuthElement) returnedList.getLast()).isPenalty()
- && ((KnuthPenalty) returnedList.getLast()).getP()
- == -KnuthElement.INFINITE) {
+ if (((ListElement)returnedList.getLast()).isForcedBreak()) {
// a descendant of this block has break-after
if (curLM.isFinished()) {
// there is no other content in this block;
returnedList = new LinkedList();
wrapPositionElements(contentList, returnList);
+ //Space resolution
+ SpaceResolver.resolveElementList(returnList);
+
return returnList;
}
}
returnedList = new LinkedList();
wrapPositionElements(contentList, returnList);
+ //Space resolution
+ SpaceResolver.resolveElementList(returnList);
+
setFinished(true);
return returnList;
}
LayoutContext layoutContext) {
getParentArea(null);
- getPSLM().addIDToPage(fobj.getId());
+ getPSLM().addIDToPage(getTableCell().getId());
if (isSeparateBorderModel()) {
- if (!emptyCell || fobj.showEmptyCells()) {
- TraitSetter.addBorders(curBlockArea, fobj.getCommonBorderPaddingBackground(), this);
+ if (!emptyCell || getTableCell().showEmptyCells()) {
+ TraitSetter.addBorders(curBlockArea,
+ getTableCell().getCommonBorderPaddingBackground(), this);
}
} else {
boolean[] outer = new boolean[] {
//Handle display-align
int contentBPD = getContentHeight(rowHeight, gridUnit);
if (usedBPD < contentBPD) {
- if (fobj.getDisplayAlign() == EN_CENTER) {
+ if (getTableCell().getDisplayAlign() == EN_CENTER) {
Block space = new Block();
space.setBPD((contentBPD - usedBPD) / 2);
curBlockArea.addBlock(space);
- } else if (fobj.getDisplayAlign() == EN_AFTER) {
+ } else if (getTableCell().getDisplayAlign() == EN_AFTER) {
Block space = new Block();
space.setBPD((contentBPD - usedBPD));
curBlockArea.addBlock(space);
// Add background after we know the BPD
if (isSeparateBorderModel()) {
- if (!emptyCell || fobj.showEmptyCells()) {
+ if (!emptyCell || getTableCell().showEmptyCells()) {
TraitSetter.addBackground(curBlockArea,
- fobj.getCommonBorderPaddingBackground(),
- this);
+ getTableCell().getCommonBorderPaddingBackground(),
+ this);
}
} else {
TraitSetter.addBackground(curBlockArea,
- fobj.getCommonBorderPaddingBackground(),
- this);
+ getTableCell().getCommonBorderPaddingBackground(),
+ this);
}
flush();
if (curBlockArea == null) {
curBlockArea = new Block();
curBlockArea.addTrait(Trait.IS_REFERENCE_AREA, Boolean.TRUE);
- TraitSetter.setProducerID(curBlockArea, fobj.getId());
+ TraitSetter.setProducerID(curBlockArea, getTableCell().getId());
curBlockArea.setPositioning(Block.ABSOLUTE);
int indent = 0;
indent += startBorderWidth;
if (!isSeparateBorderModel()) {
indent /= 2;
}
- indent += fobj.getCommonBorderPaddingBackground().getPaddingStart(false, this);
+ indent += getTableCell()
+ .getCommonBorderPaddingBackground().getPaddingStart(false, this);
// set position
int halfBorderSep = 0;
if (isSeparateBorderModel()) {
- halfBorderSep = fobj.getBorderSeparation().getLengthPair()
+ halfBorderSep = getTableCell().getBorderSeparation().getLengthPair()
.getIPD().getLength().getValue(this) / 2;
}
int borderAdjust = 0;
import org.apache.fop.fo.flow.TableRow;
import org.apache.fop.fo.properties.CommonBorderPaddingBackground;
import org.apache.fop.fo.properties.LengthRangeProperty;
+import org.apache.fop.layoutmgr.BreakElement;
import org.apache.fop.layoutmgr.ElementListObserver;
import org.apache.fop.layoutmgr.ElementListUtils;
import org.apache.fop.layoutmgr.KnuthBox;
import org.apache.fop.layoutmgr.KnuthPossPosIter;
import org.apache.fop.layoutmgr.LayoutContext;
import org.apache.fop.layoutmgr.LayoutManager;
+import org.apache.fop.layoutmgr.ListElement;
import org.apache.fop.layoutmgr.MinOptMaxUtil;
import org.apache.fop.layoutmgr.Position;
import org.apache.fop.layoutmgr.PositionIterator;
import org.apache.fop.layoutmgr.TraitSetter;
+import org.apache.fop.layoutmgr.SpaceResolver.SpaceHandlingBreakPosition;
import org.apache.fop.traits.MinOptMax;
/**
if (rowFO != null && rowFO.getBreakBefore() != Constants.EN_AUTO) {
log.info("break-before found");
if (returnList.size() > 0) {
- KnuthElement last = (KnuthElement)returnList.getLast();
+ ListElement last = (ListElement)returnList.getLast();
if (last.isPenalty()) {
KnuthPenalty pen = (KnuthPenalty)last;
pen.setP(-KnuthPenalty.INFINITE);
pen.setBreakClass(rowFO.getBreakBefore());
+ } else if (last instanceof BreakElement) {
+ BreakElement breakPoss = (BreakElement)last;
+ breakPoss.setPenaltyValue(-KnuthPenalty.INFINITE);
+ breakPoss.setBreakClass(rowFO.getBreakBefore());
}
} else {
if (!firstBreakBeforeServed) {
- returnList.add(new KnuthPenalty(0, -KnuthPenalty.INFINITE,
- false, rowFO.getBreakBefore(), new Position(getTableLM()), true));
+ //returnList.add(new KnuthPenalty(0, -KnuthPenalty.INFINITE,
+ // false, rowFO.getBreakBefore(), new Position(getTableLM()), true));
+ returnList.add(new BreakElement(new Position(getTableLM()),
+ 0, -KnuthPenalty.INFINITE, rowFO.getBreakBefore(), context));
iter.backToPreviousRow();
firstBreakBeforeServed = true;
break;
log.debug("child LM (row group) signals pending keep-with-previous");
if (returnList.size() > 0) {
//Modify last penalty
- KnuthElement last = (KnuthElement)returnList.getLast();
+ ListElement last = (ListElement)returnList.getLast();
if (last.isPenalty()) {
- KnuthPenalty pen = (KnuthPenalty)last;
+ BreakElement breakPoss = (BreakElement)last;
//Only honor keep if there's no forced break
- if (!pen.isForcedBreak()) {
- pen.setP(KnuthPenalty.INFINITE);
+ if (!breakPoss.isForcedBreak()) {
+ breakPoss.setPenaltyValue(KnuthPenalty.INFINITE);
}
}
}
if (rowFO != null && rowFO.getBreakAfter() != Constants.EN_AUTO) {
log.info("break-after found");
if (returnList.size() > 0) {
- KnuthElement last = (KnuthElement)returnList.getLast();
- if (last.isPenalty()) {
+ ListElement last = (ListElement)returnList.getLast();
+ if (last instanceof KnuthPenalty) {
KnuthPenalty pen = (KnuthPenalty)last;
pen.setP(-KnuthPenalty.INFINITE);
pen.setBreakClass(rowFO.getBreakAfter());
+ } else if (last instanceof BreakElement) {
+ BreakElement breakPoss = (BreakElement)last;
+ breakPoss.setPenaltyValue(-KnuthPenalty.INFINITE);
+ breakPoss.setBreakClass(rowFO.getBreakAfter());
}
}
}
if (returnList.size() > 0) {
//Remove last penalty
- KnuthElement last = (KnuthElement)returnList.getLast();
- if (last.isPenalty()) {
- KnuthPenalty pen = (KnuthPenalty)last;
- if (!pen.isForcedBreak()) {
+ ListElement last = (ListElement)returnList.getLast();
+ if (last.isPenalty() || last instanceof BreakElement) {
+ if (!last.isForcedBreak()) {
//Only remove if we don't signal a forced break
returnList.removeLast();
}
ElementListObserver.observe(elems, "table-cell", primary.getCell().getId());
if ((elems.size() > 0)
- && ((KnuthElement)elems.getLast()).isPenalty()
- && ((KnuthPenalty)elems.getLast()).getP()
- == -KnuthElement.INFINITE) {
+ && ((KnuthElement)elems.getLast()).isForcedBreak()) {
// a descendant of this block has break-after
log.warn("Descendant of table-cell signals break: "
+ primary.getCellLM().isFinished());
List footerElements = null;
Position firstPos = null;
Position lastPos = null;
+ Position lastCheckPos = null;
while (parentIter.hasNext()) {
Position pos = (Position)parentIter.next();
+ if (pos instanceof SpaceHandlingBreakPosition) {
+ //This position has only been needed before addAreas was called, now we need the
+ //original one created by the layout manager.
+ pos = ((SpaceHandlingBreakPosition)pos).getOriginalBreakPosition();
+ }
+ if (pos == null) {
+ continue;
+ }
if (firstPos == null) {
firstPos = pos;
}
lastPos = pos;
+ if (pos.getIndex() >= 0) {
+ lastCheckPos = pos;
+ }
if (pos instanceof TableHeaderFooterPosition) {
TableHeaderFooterPosition thfpos = (TableHeaderFooterPosition)pos;
//these positions need to be unpacked
Map markers = getTableLM().getTable().getMarkers();
if (markers != null) {
getTableLM().getCurrentPV().addMarkers(markers,
- true, getTableLM().isFirst(firstPos), getTableLM().isLast(lastPos));
+ true, getTableLM().isFirst(firstPos), getTableLM().isLast(lastCheckPos));
}
if (headerElements != null) {
if (markers != null) {
getTableLM().getCurrentPV().addMarkers(markers,
- false, getTableLM().isFirst(firstPos), getTableLM().isLast(lastPos));
+ false, getTableLM().isFirst(firstPos), getTableLM().isLast(lastCheckPos));
}
}
import org.apache.fop.fo.properties.TableColLength;
import org.apache.fop.layoutmgr.BlockLevelLayoutManager;
import org.apache.fop.layoutmgr.BlockStackingLayoutManager;
+import org.apache.fop.layoutmgr.ConditionalElementListener;
import org.apache.fop.layoutmgr.KnuthElement;
import org.apache.fop.layoutmgr.KnuthGlue;
-import org.apache.fop.layoutmgr.KnuthPenalty;
import org.apache.fop.layoutmgr.LayoutContext;
+import org.apache.fop.layoutmgr.ListElement;
import org.apache.fop.layoutmgr.PositionIterator;
import org.apache.fop.layoutmgr.Position;
+import org.apache.fop.layoutmgr.RelSide;
import org.apache.fop.layoutmgr.TraitSetter;
import org.apache.fop.area.Area;
import org.apache.fop.area.Block;
* the render background.
*/
public class TableLayoutManager extends BlockStackingLayoutManager
- implements BlockLevelLayoutManager {
- private Table fobj;
+ implements ConditionalElementListener {
private TableContentLayoutManager contentLM;
private ColumnSetup columns = null;
private double tableUnits;
private boolean autoLayout = true;
- //TODO space-before|after: handle space-resolution rules
- private MinOptMax spaceBefore;
- private MinOptMax spaceAfter;
+ private boolean discardBorderBefore;
+ private boolean discardBorderAfter;
+ private boolean discardPaddingBefore;
+ private boolean discardPaddingAfter;
+ private MinOptMax effSpaceBefore;
+ private MinOptMax effSpaceAfter;
/**
* Create a new table layout manager.
*/
public TableLayoutManager(Table node) {
super(node);
- fobj = node;
this.columns = new ColumnSetup(node);
}
/** @return the table FO */
public Table getTable() {
- return this.fobj;
+ return (Table)this.fobj;
}
/**
/** @see org.apache.fop.layoutmgr.LayoutManager#initialize() */
public void initialize() {
- spaceBefore = new SpaceVal(fobj.getCommonMarginBlock().spaceBefore, this).getSpace();
- spaceAfter = new SpaceVal(fobj.getCommonMarginBlock().spaceAfter, this).getSpace();
+ foSpaceBefore = new SpaceVal(
+ getTable().getCommonMarginBlock().spaceBefore, this).getSpace();
+ foSpaceAfter = new SpaceVal(
+ getTable().getCommonMarginBlock().spaceAfter, this).getSpace();
- if (!fobj.isAutoLayout()
- && fobj.getInlineProgressionDimension().getOptimum(this).getEnum() != EN_AUTO) {
+ if (!getTable().isAutoLayout()
+ && getTable().getInlineProgressionDimension().getOptimum(this).getEnum()
+ != EN_AUTO) {
autoLayout = false;
}
}
+ private void resetSpaces() {
+ this.discardBorderBefore = false;
+ this.discardBorderAfter = false;
+ this.discardPaddingBefore = false;
+ this.discardPaddingAfter = false;
+ this.effSpaceBefore = foSpaceBefore;
+ this.effSpaceAfter = foSpaceAfter;
+ }
+
private int getIPIndents() {
int iIndents = 0;
- iIndents += fobj.getCommonMarginBlock().startIndent.getValue(this);
- iIndents += fobj.getCommonMarginBlock().endIndent.getValue(this);
+ iIndents += getTable().getCommonMarginBlock().startIndent.getValue(this);
+ iIndents += getTable().getCommonMarginBlock().endIndent.getValue(this);
return iIndents;
}
if (!bBreakBeforeServed) {
try {
- if (addKnuthElementsForBreakBefore(returnList)) {
+ if (addKnuthElementsForBreakBefore(returnList, context)) {
return returnList;
}
} finally {
referenceBPD = context.getStackLimit().opt;
referenceIPD = context.getRefIPD();
- if (fobj.getInlineProgressionDimension().getOptimum(this).getEnum() != EN_AUTO) {
- referenceIPD = fobj.getInlineProgressionDimension().getOptimum(this)
+ if (getTable().getInlineProgressionDimension().getOptimum(this).getEnum() != EN_AUTO) {
+ referenceIPD = getTable().getInlineProgressionDimension().getOptimum(this)
.getLength().getValue(this);
contentIPD = referenceIPD;
} else {
- if (!fobj.isAutoLayout()) {
+ if (!getTable().isAutoLayout()) {
log.info("table-layout=\"fixed\" and width=\"auto\", "
+ "but auto-layout not supported "
+ "=> assuming width=\"100%\"");
log.warn("Allocated IPD exceeds available reference IPD");
}
- MinOptMax stackSize = new MinOptMax();
- //Add spacing
- if (spaceAfter != null) {
- stackSize.add(spaceAfter);
- }
- if (spaceBefore != null) {
- stackSize.add(spaceBefore);
- }
-
// either works out table of column widths or if proportional-column-width function
// is used works out total factor, so that value of single unit can be computed.
int sumCols = 0;
}
}
+ addKnuthElementsForSpaceBefore(returnList, alignment);
+
+ if (getTable().isSeparateBorderModel()) {
+ addKnuthElementsForBorderPaddingBefore(returnList, !firstVisibleMarkServed);
+ firstVisibleMarkServed = true;
+ }
+
+ //Spaces, border and padding to be repeated at each break
+ addPendingMarks(context);
+
LinkedList returnedList = null;
LinkedList contentList = new LinkedList();
//Position returnPosition = new NonLeafPosition(this, null);
//Body prevLM = null;
LayoutContext childLC = new LayoutContext(0);
+ /*
childLC.setStackLimit(
MinOptMax.subtract(context.getStackLimit(),
- stackSize));
+ stackSize));*/
childLC.setRefIPD(context.getRefIPD());
+ childLC.copyPendingMarksFrom(context);
if (contentLM == null) {
contentLM = new TableContentLayoutManager(this);
//Set index values on elements coming from the content LM
Iterator iter = returnedList.iterator();
while (iter.hasNext()) {
- KnuthElement el = (KnuthElement)iter.next();
+ ListElement el = (ListElement)iter.next();
notifyPos(el.getPosition());
}
log.debug(returnedList);
if (returnedList.size() == 1
- && ((KnuthElement) returnedList.getFirst()).isPenalty()
- && ((KnuthPenalty) returnedList.getFirst()).getP() == -KnuthElement.INFINITE) {
+ && ((ListElement)returnedList.getFirst()).isForcedBreak()) {
// a descendant of this block has break-before
if (returnList.size() == 0) {
// the first child (or its first child ...) has
}*/
contentList.addAll(returnedList);
if (returnedList.size() > 0) {
- if (((KnuthElement) returnedList.getLast()).isPenalty()
- && ((KnuthPenalty) returnedList.getLast()).getP() == -KnuthElement.INFINITE) {
+ if (((ListElement)returnedList.getLast()).isForcedBreak()) {
// a descendant of this block has break-after
if (false /*curLM.isFinished()*/) {
// there is no other content in this block;
}
}
wrapPositionElements(contentList, returnList);
- addKnuthElementsForBreakAfter(returnList);
+ if (getTable().isSeparateBorderModel()) {
+ addKnuthElementsForBorderPaddingAfter(returnList, true);
+ }
+ addKnuthElementsForSpaceAfter(returnList, alignment);
+ addKnuthElementsForBreakAfter(returnList, context);
setFinished(true);
+ resetSpaces();
return returnList;
}
public void addAreas(PositionIterator parentIter,
LayoutContext layoutContext) {
getParentArea(null);
- getPSLM().addIDToPage(fobj.getId());
+ getPSLM().addIDToPage(getTable().getId());
- // if adjusted space before
- double adjust = layoutContext.getSpaceAdjust();
- addBlockSpacing(adjust, spaceBefore);
- spaceBefore = null;
-
- int startXOffset = fobj.getCommonMarginBlock().startIndent.getValue(this);
+ int startXOffset = getTable().getCommonMarginBlock().startIndent.getValue(this);
// add column, body then row areas
curBlockArea.setBPD(tableHeight);
- if (fobj.isSeparateBorderModel()) {
- TraitSetter.addBorders(curBlockArea, fobj.getCommonBorderPaddingBackground(), this);
+ if (getTable().isSeparateBorderModel()) {
+ TraitSetter.addBorders(curBlockArea,
+ getTable().getCommonBorderPaddingBackground(),
+ discardBorderBefore, discardBorderAfter, false, false, this);
+ TraitSetter.addPadding(curBlockArea,
+ getTable().getCommonBorderPaddingBackground(),
+ discardPaddingBefore, discardPaddingAfter, false, false, this);
}
TraitSetter.addBackground(curBlockArea,
- fobj.getCommonBorderPaddingBackground(),
+ getTable().getCommonBorderPaddingBackground(),
this);
TraitSetter.addMargins(curBlockArea,
- fobj.getCommonBorderPaddingBackground(),
- fobj.getCommonMarginBlock(),
+ getTable().getCommonBorderPaddingBackground(),
+ getTable().getCommonMarginBlock(),
this);
TraitSetter.addBreaks(curBlockArea,
- fobj.getBreakBefore(), fobj.getBreakAfter());
+ getTable().getBreakBefore(), getTable().getBreakAfter());
+ TraitSetter.addSpaceBeforeAfter(curBlockArea, layoutContext.getSpaceAdjust(),
+ effSpaceBefore, effSpaceAfter);
flush();
- // if adjusted space after
- addBlockSpacing(adjust, spaceAfter);
-
- //bodyBreaks.clear();
+ resetSpaces();
curBlockArea = null;
}
}
}
- /**
- * @see org.apache.fop.layoutmgr.BlockLevelLayoutManager#negotiateBPDAdjustment(int, org.apache.fop.layoutmgr.KnuthElement)
- */
+ /** @see org.apache.fop.layoutmgr.BlockLevelLayoutManager */
public int negotiateBPDAdjustment(int adj, KnuthElement lastElement) {
// TODO Auto-generated method stub
return 0;
}
- /**
- * @see org.apache.fop.layoutmgr.BlockLevelLayoutManager#discardSpace(org.apache.fop.layoutmgr.KnuthGlue)
- */
+ /** @see org.apache.fop.layoutmgr.BlockLevelLayoutManager */
public void discardSpace(KnuthGlue spaceGlue) {
// TODO Auto-generated method stub
public boolean mustKeepTogether() {
//TODO Keeps will have to be more sophisticated sooner or later
return ((BlockLevelLayoutManager)getParent()).mustKeepTogether()
- || !fobj.getKeepTogether().getWithinPage().isAuto()
- || !fobj.getKeepTogether().getWithinColumn().isAuto();
+ || !getTable().getKeepTogether().getWithinPage().isAuto()
+ || !getTable().getKeepTogether().getWithinColumn().isAuto();
}
/**
* @see org.apache.fop.layoutmgr.BlockLevelLayoutManager#mustKeepWithPrevious()
*/
public boolean mustKeepWithPrevious() {
- return !fobj.getKeepWithPrevious().getWithinPage().isAuto()
- || !fobj.getKeepWithPrevious().getWithinColumn().isAuto();
+ return !getTable().getKeepWithPrevious().getWithinPage().isAuto()
+ || !getTable().getKeepWithPrevious().getWithinColumn().isAuto();
}
/**
* @see org.apache.fop.layoutmgr.BlockLevelLayoutManager#mustKeepWithNext()
*/
public boolean mustKeepWithNext() {
- return !fobj.getKeepWithNext().getWithinPage().isAuto()
- || !fobj.getKeepWithNext().getWithinColumn().isAuto();
+ return !getTable().getKeepWithNext().getWithinPage().isAuto()
+ || !getTable().getKeepWithNext().getWithinColumn().isAuto();
}
// --------- Property Resolution related functions --------- //
return referenceBPD;
}
+ /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+ public void notifySpace(RelSide side, MinOptMax effectiveLength) {
+ if (RelSide.BEFORE == side) {
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Space " + side + ", "
+ + this.effSpaceBefore + "-> " + effectiveLength);
+ }
+ this.effSpaceBefore = effectiveLength;
+ } else {
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Space " + side + ", "
+ + this.effSpaceAfter + "-> " + effectiveLength);
+ }
+ this.effSpaceAfter = effectiveLength;
+ }
+ }
+
+ /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+ public void notifyBorder(RelSide side, MinOptMax effectiveLength) {
+ if (effectiveLength == null) {
+ if (RelSide.BEFORE == side) {
+ this.discardBorderBefore = true;
+ } else {
+ this.discardBorderAfter = true;
+ }
+ }
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Border " + side + " -> " + effectiveLength);
+ }
+ }
+
+ /** @see org.apache.fop.layoutmgr.ConditionalElementListener */
+ public void notifyPadding(RelSide side, MinOptMax effectiveLength) {
+ if (effectiveLength == null) {
+ if (RelSide.BEFORE == side) {
+ this.discardPaddingBefore = true;
+ } else {
+ this.discardPaddingAfter = true;
+ }
+ }
+ if (log.isDebugEnabled()) {
+ log.debug(this + ": Padding " + side + " -> " + effectiveLength);
+ }
+ }
+
}
\ No newline at end of file
import org.apache.fop.fo.Constants;
import org.apache.fop.fo.flow.TableRow;
import org.apache.fop.fo.properties.CommonBorderPaddingBackground;
+import org.apache.fop.layoutmgr.BreakElement;
import org.apache.fop.layoutmgr.ElementListUtils;
import org.apache.fop.layoutmgr.KnuthBox;
import org.apache.fop.layoutmgr.KnuthElement;
private void setupElementList(int column) {
GridUnit gu = getActiveGridUnit(column);
EffRow row = getActiveRow();
- if (gu.isEmpty()){
+ if (gu.isEmpty()) {
elementLists[column] = null;
start[column] = 0;
end[column] = -1;
//Create elements for step
int effPenaltyLen = penaltyLen;
- if (isSeparateBorderModel()) {
- CommonBorderPaddingBackground borders
- = getTableLM().getTable().getCommonBorderPaddingBackground();
- effPenaltyLen += borders.getBorderBeforeWidth(false);
- effPenaltyLen += borders.getBorderAfterWidth(false);
- effPenaltyLen += borders.getPaddingBefore(false, getTableLM());
- effPenaltyLen += borders.getPaddingAfter(false, getTableLM());
- }
TableContentPosition tcpos = new TableContentPosition(getTableLM(),
gridUnitParts, getActiveRow());
if (returnList.size() == 0) {
p = -KnuthPenalty.INFINITE; //Overrides any keeps (see 4.8 in XSL 1.0)
clearBreakCondition();
}
- returnList.add(new KnuthPenalty(effPenaltyLen, p, false, penaltyPos, false));
+ //returnList.add(new KnuthPenalty(effPenaltyLen, p, false, penaltyPos, false));
+ returnList.add(new BreakElement(penaltyPos, effPenaltyLen, p, 0, context));
log.debug("step=" + step + " (+" + increase + ")"
+ " box=" + boxLen
context.setFlags(LayoutContext.KEEP_WITH_NEXT_PENDING);
}
if (isBreakCondition()) {
- ((KnuthPenalty)returnList.getLast()).setP(-KnuthPenalty.INFINITE);
+ ((BreakElement)returnList.getLast()).setPenaltyValue(-KnuthPenalty.INFINITE);
}
lastTCPos.setFlag(TableContentPosition.LAST_IN_ROWGROUP, true);
return returnList;
int saveBP = currentBPPosition;
if (block.getPositioning() == Block.ABSOLUTE) {
- currentIPPosition = containingIPPosition + block.getXOffset();
- currentBPPosition = containingBPPosition + block.getYOffset();
+ currentIPPosition += block.getXOffset();
+ currentBPPosition += block.getYOffset();
+ currentBPPosition += block.getSpaceBefore();
handleBlockTraits(block);
// relative blocks are offset
currentIPPosition += block.getXOffset();
currentBPPosition += block.getYOffset();
+ currentBPPosition += block.getSpaceBefore();
handleBlockTraits(block);
opt -= op.opt;
max -= op.min;
}
+
+ /** @return true if this instance represents a zero-width length (min=opt=max=0) */
+ public boolean isNonZero() {
+ return (min != 0 || max != 0);
+ }
/** @see java.lang.Object#toString() */
public String toString() {
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<!-- This test verifies what happens if shorthand and normal properties are mixed. -->
+<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:test="http://xmlgraphics.apache.org/fop/test">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="A4" page-height="29.7cm" page-width="21cm" margin="2cm">
+ <fo:region-body/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="A4">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:block border="solid 5pt"
+ border-before-width.conditionality="retain" border-after-width.conditionality="retain"
+ padding="5pt"
+ padding-before.conditionality="retain" padding-after.conditionality="retain">
+ <test:assert property="border-before-width" expected="CondLength[1000mpt, RETAIN]"/>
+ <test:assert property="border-after-width" expected="CondLength[1000mpt, RETAIN]"/>
+ <test:assert property="padding-before" expected="CondLength[0mpt, RETAIN]"/>
+ <test:assert property="padding-after" expected="CondLength[0mpt, RETAIN]"/>
+ <!-- Discussion: see http://marc.theaimsgroup.com/?t=112607409300001&r=1&w=2 -->
+ <fo:block background-color="yellow">Hello World!</fo:block>
+ <fo:block>Hello World!</fo:block>
+ <fo:block>Hello World!</fo:block>
+ <fo:block background-color="orange">Hello World!</fo:block>
+ </fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+</fo:root>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<!-- This test verifies the correct values of border-separation and its shorthand, border-spacing. -->
+<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:test="http://xmlgraphics.apache.org/fop/test">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="A4" page-height="29.7cm" page-width="21cm">
+ <fo:region-body/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="A4">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:table table-layout="fixed" border-collapse="separate" border-spacing="5pt 2pt">
+ <test:assert property="border-separation.inline-progression-direction" expected="5000mpt"/>
+ <test:assert property="border-separation.block-progression-direction" expected="2000mpt"/>
+ <fo:table-column column-width="160pt"/>
+ <fo:table-column column-width="160pt"/>
+ <fo:table-body>
+ <fo:table-row>
+ <fo:table-cell>
+ <fo:block>cell1</fo:block>
+ </fo:table-cell>
+ <fo:table-cell border="solid 5pt black">
+ <fo:block>cell2</fo:block>
+ </fo:table-cell>
+ </fo:table-row>
+ <fo:table-row>
+ <fo:table-cell border="solid 5pt">
+ <fo:block>cell3</fo:block>
+ </fo:table-cell>
+ <fo:table-cell height="20pt" border="solid 10pt red">
+ <fo:block>cell4</fo:block>
+ </fo:table-cell>
+ </fo:table-row>
+ </fo:table-body>
+ </fo:table>
+ <fo:table table-layout="fixed" border-collapse="separate"
+ border-separation.inline-progression-direction="5pt"
+ border-separation.block-progression-direction="2pt">
+ <test:assert property="border-separation.inline-progression-direction" expected="5000mpt"/>
+ <test:assert property="border-separation.block-progression-direction" expected="2000mpt"/>
+ <fo:table-column column-width="160pt"/>
+ <fo:table-column column-width="160pt"/>
+ <fo:table-body start-indent="0pt" end-indent="0pt">
+ <fo:table-row>
+ <fo:table-cell>
+ <fo:block>cell1</fo:block>
+ </fo:table-cell>
+ <fo:table-cell border="solid 5pt black">
+ <fo:block>cell2</fo:block>
+ </fo:table-cell>
+ </fo:table-row>
+ <fo:table-row>
+ <fo:table-cell border="solid 5pt">
+ <fo:block>cell3</fo:block>
+ </fo:table-cell>
+ <fo:table-cell height="20pt" border="solid 10pt red">
+ <fo:block>cell4</fo:block>
+ </fo:table-cell>
+ </fo:table-row>
+ </fo:table-body>
+ </fo:table>
+ </fo:flow>
+ </fo:page-sequence>
+</fo:root>
import org.apache.fop.fo.FONode;
import org.apache.fop.fo.FOPropertyMapping;
import org.apache.fop.fo.PropertyList;
+import org.apache.fop.fo.properties.LengthPairProperty;
import org.apache.fop.fo.properties.Property;
import org.apache.fop.fotreetest.ResultCollector;
//super.processNode(elementName, locator, attlist, propertyList);
ResultCollector collector = ResultCollector.getInstance();
- String propName = attlist.getValue("property");
+ String propName = attlist.getValue("property");
+ String component = null;
+ int dotIndex = propName.indexOf('.');
+ if (dotIndex >= 0) {
+ component = propName.substring(dotIndex + 1);
+ propName = propName.substring(0, dotIndex);
+ }
int propID = FOPropertyMapping.getPropertyId(propName);
if (propID < 0) {
collector.notifyException(new IllegalArgumentException(
"Property not found: " + propName));
} else {
- Property prop = propertyList.getParentPropertyList().get(propID);
+ Property prop;
+ prop = propertyList.getParentPropertyList().get(propID);
+ if (component != null) {
+ //Access subcomponent
+ Property mainProp = prop;
+ prop = null;
+ LengthPairProperty lpp = mainProp.getLengthPair();
+ if (lpp != null) {
+ prop = lpp.getComponent(FOPropertyMapping.getSubPropertyId(component));
+ }
+ }
String s = String.valueOf(prop);
String expected = attlist.getValue("expected");
if (!expected.equals(s)) {
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
-import org.apache.fop.layoutmgr.KnuthElement;
+import org.apache.fop.layoutmgr.ListElement;
import org.apache.fop.layoutmgr.ElementListObserver.Observer;
/**
return;
}
ListIterator tempIter = elementList.listIterator();
- KnuthElement temp;
+ ListElement temp;
while (tempIter.hasNext()) {
- temp = (KnuthElement) tempIter.next();
+ temp = (ListElement) tempIter.next();
if (temp.isBox()) {
log.debug(tempIter.previousIndex()
+ ") " + temp);
block-container_reference-orientation_bug36391.xml
+block-container_space-before_space-after_3.xml
block_font-stretch.xml
block_padding_2.xml
-block_space-before_space-after_2.xml
-block_space-before_space-after_3.xml
+block_space-before_space-after_8.xml
block_word-spacing.xml
block_word-spacing_text-align_justify.xml
external-graphic_oversized.xml
+footnote_space-resolution.xml
inline-block_keep-together.xml
inline_block_nested_3.xml
inline-container_block_nested.xml
leader-alignment.xml
list-block_keep-with-previous.xml
list-item_block_keep-with-previous.xml
-list-item_space-before_space-after_2.xml
page-breaking_4.xml
page-breaking_6.xml
page-height_indefinite_simple.xml
table_border-collapse_collapse_2.xml
table_border_padding.xml
table-cell_block_keep-with-previous.xml
+table-cell_border_padding_conditionality.xml
table-column_first-row-width.xml
table-header_background-image.xml
table-row_keep-with-previous.xml
</fo>
<checks>
<!-- first block-container -->
- <true xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@is-viewport-area"/>
- <eval expected="[1.0 0.0 0.0 1.0 0.0 0.0]" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@ctm"/>
- <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@ipd"/>
- <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@ipda"/>
- <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bpd"/>
- <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bpda"/>
+ <true xpath="//flow/block[1]/@is-viewport-area"/>
+ <eval expected="[1.0 0.0 0.0 1.0 0.0 0.0]" xpath="//flow/block[1]/@ctm"/>
+ <eval expected="120000" xpath="//flow/block[1]/@ipd"/>
+ <eval expected="120000" xpath="//flow/block[1]/@ipda"/>
+ <eval expected="80000" xpath="//flow/block[1]/@bpd"/>
+ <eval expected="80000" xpath="//flow/block[1]/@bpda"/>
<!-- -> reference area -->
- <true xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@is-reference-area"/>
- <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@ipd"/>
- <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@ipda"/>
- <eval expected="28800" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@bpd"/>
- <eval expected="28800" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@bpda"/>
+ <true xpath="//flow/block[1]/block[1]/@is-reference-area"/>
+ <eval expected="120000" xpath="//flow/block[1]/block[1]/@ipd"/>
+ <eval expected="120000" xpath="//flow/block[1]/block[1]/@ipda"/>
+ <eval expected="28800" xpath="//flow/block[1]/block[1]/@bpd"/>
+ <eval expected="28800" xpath="//flow/block[1]/block[1]/@bpda"/>
<!-- space-before of second block-container -->
- <eval expected="10000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bpda"/>
+ <eval expected="10000" xpath="//flow/block[2]/@space-before"/>
<!-- second block-container -->
- <true xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@is-viewport-area"/>
- <eval expected="[0.0 -1.0 1.0 0.0 0.0 80000.0]" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@ctm"/>
- <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@ipd"/>
- <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@ipda"/>
- <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@bpd"/>
- <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@bpda"/>
+ <true xpath="//flow/block[2]/@is-viewport-area"/>
+ <eval expected="[0.0 -1.0 1.0 0.0 0.0 80000.0]" xpath="//flow/block[2]/@ctm"/>
+ <eval expected="120000" xpath="//flow/block[2]/@ipd"/>
+ <eval expected="120000" xpath="//flow/block[2]/@ipda"/>
+ <eval expected="80000" xpath="//flow/block[2]/@bpd"/>
+ <eval expected="100000" xpath="//flow/block[2]/@bpda"/>
<!-- -> reference area -->
- <true xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/block[1]/@is-reference-area"/>
- <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/block[1]/@ipd"/>
- <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/block[1]/@ipda"/>
- <eval expected="43200" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/block[1]/@bpd"/>
- <eval expected="43200" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/block[1]/@bpda"/>
+ <true xpath="//flow/block[2]/block[1]/@is-reference-area"/>
+ <eval expected="80000" xpath="//flow/block[2]/block[1]/@ipd"/>
+ <eval expected="80000" xpath="//flow/block[2]/block[1]/@ipda"/>
+ <eval expected="43200" xpath="//flow/block[2]/block[1]/@bpd"/>
+ <eval expected="43200" xpath="//flow/block[2]/block[1]/@bpda"/>
<!-- space-after of second block-container -->
- <eval expected="10000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@bpda"/>
+ <eval expected="10000" xpath="//flow/block[2]/@space-after"/>
<!-- third block-container -->
- <true xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@is-viewport-area"/>
- <eval expected="[-1.0 -0.0 0.0 -1.0 120000.0 80000.0]" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@ctm"/>
- <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@ipd"/>
- <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@ipda"/>
- <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@bpd"/>
- <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@bpda"/>
+ <true xpath="//flow/block[3]/@is-viewport-area"/>
+ <eval expected="[-1.0 -0.0 0.0 -1.0 120000.0 80000.0]" xpath="//flow/block[3]/@ctm"/>
+ <eval expected="120000" xpath="//flow/block[3]/@ipd"/>
+ <eval expected="120000" xpath="//flow/block[3]/@ipda"/>
+ <eval expected="80000" xpath="//flow/block[3]/@bpd"/>
+ <eval expected="80000" xpath="//flow/block[3]/@bpda"/>
<!-- -> reference area -->
- <true xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/block[1]/@is-reference-area"/>
- <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/block[1]/@ipd"/>
- <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/block[1]/@ipda"/>
- <eval expected="61600" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/block[1]/@bpd"/>
- <eval expected="61600" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/block[1]/@bpda"/>
+ <true xpath="//flow/block[3]/block[1]/@is-reference-area"/>
+ <eval expected="120000" xpath="//flow/block[3]/block[1]/@ipd"/>
+ <eval expected="120000" xpath="//flow/block[3]/block[1]/@ipda"/>
+ <eval expected="61600" xpath="//flow/block[3]/block[1]/@bpd"/>
+ <eval expected="61600" xpath="//flow/block[3]/block[1]/@bpda"/>
<!-- contents (spacer first, then three lines) -->
- <eval expected="18400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/block[1]/block[1]/@bpda"/>
- <eval expected="28800" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/block[1]/block[2]/@bpda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/block[1]/block[3]/@bpda"/>
+ <eval expected="18400" xpath="//flow/block[3]/block[1]/block[1]/@bpda"/>
+ <eval expected="28800" xpath="//flow/block[3]/block[1]/block[2]/@bpda"/>
+ <eval expected="14400" xpath="//flow/block[3]/block[1]/block[3]/@bpda"/>
<!-- space-before of fourth block-container -->
- <eval expected="10000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@bpda"/>
+ <eval expected="10000" xpath="//flow/block[4]/@space-before"/>
<!-- fourth block-container -->
- <true xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/@is-viewport-area"/>
- <eval expected="[0.0 1.0 -1.0 0.0 120000.0 0.0]" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/@ctm"/>
- <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/@ipd"/>
- <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/@ipda"/>
- <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/@bpd"/>
- <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/@bpda"/>
+ <true xpath="//flow/block[4]/@is-viewport-area"/>
+ <eval expected="[0.0 1.0 -1.0 0.0 120000.0 0.0]" xpath="//flow/block[4]/@ctm"/>
+ <eval expected="120000" xpath="//flow/block[4]/@ipd"/>
+ <eval expected="120000" xpath="//flow/block[4]/@ipda"/>
+ <eval expected="80000" xpath="//flow/block[4]/@bpd"/>
+ <eval expected="90000" xpath="//flow/block[4]/@bpda"/>
<!-- -> reference area -->
- <true xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/block[1]/@is-reference-area"/>
- <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/block[1]/@ipd"/>
- <eval expected="80000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/block[1]/@ipda"/>
- <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/block[1]/@bpd"/>
- <eval expected="120000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/block[1]/@bpda"/>
+ <true xpath="//flow/block[4]/block[1]/@is-reference-area"/>
+ <eval expected="80000" xpath="//flow/block[4]/block[1]/@ipd"/>
+ <eval expected="80000" xpath="//flow/block[4]/block[1]/@ipda"/>
+ <eval expected="120000" xpath="//flow/block[4]/block[1]/@bpd"/>
+ <eval expected="120000" xpath="//flow/block[4]/block[1]/@bpda"/>
<!-- contents (spacer first, then three lines) -->
- <eval expected="76800" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/block[1]/block[1]/@bpda"/>
- <eval expected="28800" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/block[1]/block[2]/@bpda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/block[1]/block[3]/@bpda"/>
+ <eval expected="76800" xpath="//flow/block[4]/block[1]/block[1]/@bpda"/>
+ <eval expected="28800" xpath="//flow/block[4]/block[1]/block[2]/@bpda"/>
+ <eval expected="14400" xpath="//flow/block[4]/block[1]/block[3]/@bpda"/>
</checks>
</testcase>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<testcase>
+ <info>
+ <p>
+ This test checks space properties on block-container.
+ </p>
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="5in">
+ <fo:region-body/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal" id="retain">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:block-container space-before.optimum="20pt" space-before.conditionality="retain" space-after.optimum="10pt" space-after.conditionality="retain">
+ <fo:block text-align="justify">
+In olden times when wishing still helped one, there lived a king whose daughters
+were all beautiful; and the youngest was so beautiful that the sun itself, which
+has seen so much, was astonished whenever it shone in her face. Close by the king's
+castle lay a great dark forest, and under an old lime-tree in the forest was a well,
+and when the day was very warm, the king's child went out into the forest and sat
+down by the side of the cool fountain; and when she was bored she took a golden ball,
+and threw it up on high and caught it; and this ball was her favorite plaything.
+ </fo:block>
+ </fo:block-container>
+ <fo:block space-before.optimum="10pt" space-before.conditionality="retain" space-after.optimum="20pt" space-after.conditionality="retain">
+Two blocks, testing conditionality="retain".
+ </fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+ <fo:page-sequence master-reference="normal" id="discard">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:block-container space-before.optimum="20pt" space-before.conditionality="discard" space-after.optimum="10pt" space-after.conditionality="discard">
+ <fo:block text-align="justify">
+In olden times when wishing still helped one, there lived a king whose daughters
+were all beautiful; and the youngest was so beautiful that the sun itself, which
+has seen so much, was astonished whenever it shone in her face. Close by the king's
+castle lay a great dark forest, and under an old lime-tree in the forest was a well,
+and when the day was very warm, the king's child went out into the forest and sat
+down by the side of the cool fountain; and when she was bored she took a golden ball,
+and threw it up on high and caught it; and this ball was her favorite plaything.
+ </fo:block>
+ </fo:block-container>
+ <fo:block space-before.optimum="10pt" space-before.conditionality="discard" space-after.optimum="20pt" space-after.conditionality="discard">
+Two blocks, testing conditionality="discard".
+ </fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <element-list category="breaker" id="retain">
+ <box w="0"/> <!-- Helper box bearing the SpaceHandlingPosition and making sure the glue gets processed -->
+ <penalty w="0" p="INF"/>
+ <glue w="20000" y="0" z="20000"/>
+
+ <box w="14400"/>
+ <box w="14400"/>
+
+ <penalty w="0" p="INF"/>
+ <glue w="10000" y="0" z="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-30000" y="0" z="-30000"/>
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="20000" y="0" z="20000"/>
+
+ <box w="14400"/>
+
+ <penalty w="0" p="INF"/>
+ <glue w="10000" y="0" z="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-30000" y="0" z="-30000"/>
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="20000" y="0" z="20000"/>
+
+ <box w="14400"/>
+
+ <!-- skip three more lines -->
+ <skip>8</skip>
+ <skip>8</skip>
+ <skip>8</skip>
+
+ <penalty w="0" p="INF"/>
+ <glue w="10000" y="0" z="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-30000" y="0" z="-30000"/>
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="20000" y="0" z="20000"/>
+
+ <box w="14400"/>
+ <box w="14400"/>
+
+ <penalty w="0" p="INF" aux="true"/>
+ <glue w="10000" aux="true"/>
+ <penalty w="0" p="0"/>
+ <glue w="-10000" aux="true"/>
+
+ <box w="0" aux="true"/>
+ <penalty w="0" p="INF" aux="true"/>
+ <glue w="10000" aux="true"/>
+
+ <box w="14400"/> <!-- second block -->
+
+ <box w="0" aux="true"/>
+ <penalty w="0" p="INF" aux="true"/>
+ <glue w="20000" aux="true"/>
+
+ <box w="0" aux="true"/> <!-- This is used to make sure the preceding glue is not cut off -->
+
+ <skip>3</skip>
+ </element-list>
+ <element-list category="breaker" id="discard">
+ <box w="0"/> <!-- Helper box used to notify the LM for the addAreas stage about the discarded spaces -->
+ <box w="14400"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <glue w="10000"/>
+
+ <box w="14400"/> <!-- second block -->
+
+ <box w="0"/> <!-- SpaceHandlingPosition-bearing helper box -->
+
+ <skip>3</skip>
+ </element-list>
+ </checks>
+</testcase>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<testcase>
+ <info>
+ <p>
+ This test checks block-level space properties. Demonstrates that spaces are repeated on every generated area.
+ </p>
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="30pt">
+ <fo:region-body/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal" white-space-collapse="true">
+ <fo:flow flow-name="xsl-region-body" line-height="10pt" font-size="9pt">
+ <fo:block-container space-before="5pt" space-before.conditionality="retain" background-color="yellow">
+ <fo:block>line 1</fo:block>
+ <fo:block>line 2</fo:block>
+ <fo:block>line 3</fo:block>
+ <fo:block>line 4</fo:block>
+ <fo:block>line 5</fo:block>
+ </fo:block-container>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <element-list category="breaker">
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="5000"/>
+ <box w="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-5000"/>
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="5000"/>
+ <box w="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-5000"/>
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="5000"/>
+ <box w="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-5000"/>
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="5000"/>
+ <box w="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-5000"/>
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="5000"/>
+ <box w="10000"/>
+
+ <skip>3</skip>
+ </element-list>
+ <eval expected="3" xpath="count(//pageViewport)"/>
+ <eval expected="5000" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+ <eval expected="5000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+ <eval expected="5000" xpath="//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+ <eval expected="1" xpath="count(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block)"/>
+ <eval expected="1" xpath="count(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block)"/>
+ <eval expected="1" xpath="count(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block)"/>
+ <eval expected="2" xpath="count(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block)"/>
+ <eval expected="2" xpath="count(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block)"/>
+ <eval expected="1" xpath="count(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block)"/>
+
+ </checks>
+</testcase>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<testcase>
+ <info>
+ <p>
+ This test checks space properties on block-containers. The focus is on space properties on content inside the block-containers.
+ </p>
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="2in">
+ <fo:region-body/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal" id="no-height">
+ <fo:flow flow-name="xsl-region-body" line-height="10pt" font-size="9pt">
+ <fo:block-container space-before="1em" background-color="yellow" id="page1-bc1">
+ <fo:block space-before="1em">line 1</fo:block>
+ <fo:block>line 2</fo:block>
+ </fo:block-container>
+ <fo:block>A block between block-containers.</fo:block>
+ <fo:block-container background-color="yellow" id="page1-bc2">
+ <!-- ATM, the block-container without height behaves like a block which is wrong. It generates a viewport/reference pair. -->
+ <fo:block space-before="1em">line 1</fo:block>
+ <fo:block>line 2</fo:block>
+ </fo:block-container>
+ </fo:flow>
+ </fo:page-sequence>
+ <fo:page-sequence master-reference="normal" id="with-height">
+ <fo:flow flow-name="xsl-region-body" line-height="10pt" font-size="9pt">
+ <fo:block-container space-before="1em" height="50pt" background-color="yellow" id="page2-bc1">
+ <fo:block space-before="1em">line 1</fo:block>
+ <fo:block>line 2</fo:block>
+ </fo:block-container>
+ <fo:block>A block between block-containers.</fo:block>
+ <fo:block-container height="50pt" background-color="yellow" id="page2-bc2">
+ <fo:block space-before="1em">line 1</fo:block>
+ <fo:block>line 2</fo:block>
+ </fo:block-container>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <element-list category="breaker" id="no-height">
+ <box w="0"/> <!-- SpaceHandlingPosition -->
+
+ <box w="10000"/>
+ <penalty w="0" p="0"/>
+ <box w="10000"/>
+
+ <penalty w="0" p="0"/>
+ <box w="10000"/> <!-- block between block-containers -->
+ <penalty w="0" p="0"/>
+
+ <box w="10000"/>
+ <penalty w="0" p="0"/>
+ <box w="10000"/>
+
+ <skip>3</skip>
+ </element-list>
+ <element-list category="block-container" id="page1-bc1">
+ <box w="0"/> <!-- SpaceHandlingPosition -->
+
+ <box w="10000"/>
+ <penalty w="0" p="0"/>
+ <box w="10000"/>
+
+ <skip>3</skip>
+ </element-list>
+ <element-list category="block-container" id="page1-bc2">
+ <box w="0"/> <!-- SpaceHandlingPosition -->
+
+ <box w="10000"/>
+ <penalty w="0" p="0"/>
+ <box w="10000"/>
+
+ <skip>3</skip>
+ </element-list>
+ <element-list category="breaker" id="no-height">
+ <box w="0"/> <!-- SpaceHandlingPosition -->
+
+ <box w="50000"/>
+
+ <penalty w="0" p="0"/>
+ <box w="10000"/> <!-- block between block-containers -->
+ <penalty w="0" p="0"/>
+
+ <box w="50000"/>
+
+ <skip>3</skip>
+ </element-list>
+ <element-list category="block-container" id="page2-bc1">
+ <box w="0"/> <!-- SpaceHandlingPosition -->
+
+ <box w="10000"/>
+ <box w="10000"/>
+
+ <skip>3</skip>
+ </element-list>
+ <element-list category="block-container" id="page2-bc2">
+ <box w="0"/> <!-- SpaceHandlingPosition -->
+
+ <box w="10000"/>
+ <box w="10000"/>
+
+ <skip>3</skip>
+ </element-list>
+ </checks>
+</testcase>
</fo>
<checks>
<!-- First block, no gap -->
- <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@border-start"/>
- <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@border-end"/>
- <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@border-before"/>
- <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@border-after"/>
- <eval expected="5000 5000 5000 5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bap"/>
- <eval expected="350000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@ipd"/>
- <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@ipda"/>
- <eval expected="24400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bpd"/>
- <eval expected="34400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bpda"/>
+ <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[1]/@border-start"/>
+ <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[1]/@border-end"/>
+ <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[1]/@border-before"/>
+ <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[1]/@border-after"/>
+ <eval expected="5000 5000 5000 5000" xpath="//flow/block[1]/@bap"/>
+ <eval expected="350000" xpath="//flow/block[1]/@ipd"/>
+ <eval expected="360000" xpath="//flow/block[1]/@ipda"/>
+ <eval expected="24400" xpath="//flow/block[1]/@bpd"/>
+ <eval expected="34400" xpath="//flow/block[1]/@bpda"/>
<!-- Nested block of first block -->
- <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@border-start"/>
- <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@border-end"/>
- <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@border-before"/>
- <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@border-after"/>
- <eval expected="5000 5000 5000 5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@bap"/>
- <eval expected="340000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@ipd"/>
- <eval expected="350000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@ipda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@bpd"/>
- <eval expected="24400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@bpda"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[1]/block[1]/@border-start"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[1]/block[1]/@border-end"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[1]/block[1]/@border-before"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[1]/block[1]/@border-after"/>
+ <eval expected="5000 5000 5000 5000" xpath="//flow/block[1]/block[1]/@bap"/>
+ <eval expected="340000" xpath="//flow/block[1]/block[1]/@ipd"/>
+ <eval expected="350000" xpath="//flow/block[1]/block[1]/@ipda"/>
+ <eval expected="14400" xpath="//flow/block[1]/block[1]/@bpd"/>
+ <eval expected="24400" xpath="//flow/block[1]/block[1]/@bpda"/>
<!-- Second block, 5pt gap -->
- <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@border-start"/>
- <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@border-end"/>
- <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@border-before"/>
- <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@border-after"/>
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@padding-start"/>
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@padding-end"/>
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@padding-before"/>
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@padding-after"/>
- <eval expected="10000 10000 10000 10000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bap"/>
- <eval expected="340000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@ipd"/>
- <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@ipda"/>
- <eval expected="24400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bpd"/>
- <eval expected="44400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bpda"/>
+ <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[2]/@border-start"/>
+ <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[2]/@border-end"/>
+ <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[2]/@border-before"/>
+ <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[2]/@border-after"/>
+ <eval expected="5000" xpath="//flow/block[2]/@padding-start"/>
+ <eval expected="5000" xpath="//flow/block[2]/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[2]/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[2]/@padding-after"/>
+ <eval expected="10000 10000 10000 10000" xpath="//flow/block[2]/@bap"/>
+ <eval expected="340000" xpath="//flow/block[2]/@ipd"/>
+ <eval expected="360000" xpath="//flow/block[2]/@ipda"/>
+ <eval expected="24400" xpath="//flow/block[2]/@bpd"/>
+ <eval expected="44400" xpath="//flow/block[2]/@bpda"/>
<!-- Nested block of second block -->
- <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@border-start"/>
- <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@border-end"/>
- <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@border-before"/>
- <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@border-after"/>
- <eval expected="5000 5000 5000 5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@bap"/>
- <eval expected="330000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@ipd"/>
- <eval expected="340000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@ipda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@bpd"/>
- <eval expected="24400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@bpda"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/block[1]/@border-start"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/block[1]/@border-end"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/block[1]/@border-before"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/block[1]/@border-after"/>
+ <eval expected="5000 5000 5000 5000" xpath="//flow/block[2]/block[1]/@bap"/>
+ <eval expected="330000" xpath="//flow/block[2]/block[1]/@ipd"/>
+ <eval expected="340000" xpath="//flow/block[2]/block[1]/@ipda"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[1]/@bpd"/>
+ <eval expected="24400" xpath="//flow/block[2]/block[1]/@bpda"/>
<!-- third block, no gap between borders but margin around outer block -->
<!-- space before block -->
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@bpd"/>
+ <eval expected="5000" xpath="//flow/block[3]/@space-before"/>
<!-- actual block -->
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@space-start"/>
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@space-end"/>
- <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@border-start"/>
- <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@border-end"/>
- <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@border-before"/>
- <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@border-after"/>
- <eval expected="5000 5000 5000 5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@bap"/>
- <eval expected="340000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@ipd"/>
- <eval expected="350000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@ipda"/>
- <eval expected="24400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@bpd"/>
- <eval expected="34400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@bpda"/>
+ <eval expected="5000" xpath="//flow/block[3]/@space-start"/>
+ <eval expected="5000" xpath="//flow/block[3]/@space-end"/>
+ <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[3]/@border-start"/>
+ <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[3]/@border-end"/>
+ <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[3]/@border-before"/>
+ <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[3]/@border-after"/>
+ <eval expected="5000 5000 5000 5000" xpath="//flow/block[3]/@bap"/>
+ <eval expected="340000" xpath="//flow/block[3]/@ipd"/>
+ <eval expected="350000" xpath="//flow/block[3]/@ipda"/>
+ <eval expected="24400" xpath="//flow/block[3]/@bpd"/>
+ <eval expected="44400" xpath="//flow/block[3]/@bpda"/>
<!-- space after block -->
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@bpd"/>
+ <eval expected="5000" xpath="//flow/block[3]/@space-after"/>
<!-- Nested block of third block -->
- <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/block[1]/@border-start"/>
- <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/block[1]/@border-end"/>
- <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/block[1]/@border-before"/>
- <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/block[1]/@border-after"/>
- <eval expected="5000 5000 5000 5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/block[1]/@bap"/>
- <eval expected="330000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/block[1]/@ipd"/>
- <eval expected="340000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/block[1]/@ipda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/block[1]/@bpd"/>
- <eval expected="24400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/block[1]/@bpda"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[3]/block[1]/@border-start"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[3]/block[1]/@border-end"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[3]/block[1]/@border-before"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[3]/block[1]/@border-after"/>
+ <eval expected="5000 5000 5000 5000" xpath="//flow/block[3]/block[1]/@bap"/>
+ <eval expected="330000" xpath="//flow/block[3]/block[1]/@ipd"/>
+ <eval expected="340000" xpath="//flow/block[3]/block[1]/@ipda"/>
+ <eval expected="14400" xpath="//flow/block[3]/block[1]/@bpd"/>
+ <eval expected="24400" xpath="//flow/block[3]/block[1]/@bpda"/>
<!-- Fourth block, looks like the second block, but using margin on inner block instead of padding on outer block -->
- <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@border-start"/>
- <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@border-end"/>
- <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@border-before"/>
- <eval expected="(solid,#0000ff,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@border-after"/>
- <eval expected="5000 5000 5000 5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@bap"/>
- <eval expected="350000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@ipd"/>
- <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@ipda"/>
- <eval expected="34400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@bpd"/>
- <eval expected="44400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@bpda"/>
+ <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[4]/@border-start"/>
+ <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[4]/@border-end"/>
+ <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[4]/@border-before"/>
+ <eval expected="(solid,#0000ff,5000)" xpath="//flow/block[4]/@border-after"/>
+ <eval expected="5000 5000 5000 5000" xpath="//flow/block[4]/@bap"/>
+ <eval expected="350000" xpath="//flow/block[4]/@ipd"/>
+ <eval expected="360000" xpath="//flow/block[4]/@ipda"/>
+ <eval expected="34400" xpath="//flow/block[4]/@bpd"/>
+ <eval expected="44400" xpath="//flow/block[4]/@bpda"/>
<!-- Nested block of second block -->
<!-- space before block -->
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[1]/@bpd"/>
+ <eval expected="5000" xpath="//flow/block[4]/block[1]/@space-before"/>
<!-- actual block -->
- <eval expected="10000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@space-start"/>
- <eval expected="10000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@space-end"/>
- <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@border-start"/>
- <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@border-end"/>
- <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@border-before"/>
- <eval expected="(solid,#ff0000,5000)" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@border-after"/>
- <eval expected="5000 5000 5000 5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@bap"/>
- <eval expected="330000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@ipd"/>
- <eval expected="340000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@ipda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@bpd"/>
- <eval expected="24400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[2]/@bpda"/>
+ <eval expected="10000" xpath="//flow/block[4]/block[1]/@space-start"/>
+ <eval expected="10000" xpath="//flow/block[4]/block[1]/@space-end"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/block[1]/@border-start"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/block[1]/@border-end"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/block[1]/@border-before"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/block[1]/@border-after"/>
+ <eval expected="5000 5000 5000 5000" xpath="//flow/block[4]/block[1]/@bap"/>
+ <eval expected="330000" xpath="//flow/block[4]/block[1]/@ipd"/>
+ <eval expected="340000" xpath="//flow/block[4]/block[1]/@ipda"/>
+ <eval expected="14400" xpath="//flow/block[4]/block[1]/@bpd"/>
+ <eval expected="34400" xpath="//flow/block[4]/block[1]/@bpda"/>
<!-- space after block -->
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/block[3]/@bpd"/>
+ <eval expected="5000" xpath="//flow/block[4]/block[1]/@space-after"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
- <!-- padding-left -->
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-start"/>
- <eval expected="0 0 0 0" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bap"/>
- <eval expected="355000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@ipd"/>
- <eval expected="355000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@ipda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bpd"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bpda"/>
- <!-- padding-right -->
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@space-end"/>
- <eval expected="0 0 0 0" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bap"/>
- <eval expected="355000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@ipd"/>
- <eval expected="355000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@ipda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bpd"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bpda"/>
- <!-- padding-top -->
+ <!-- margin-left -->
+ <eval expected="5000" xpath="//flow/block[1]/@space-start"/>
+ <eval expected="0 0 0 0" xpath="//flow/block[1]/@bap"/>
+ <eval expected="355000" xpath="//flow/block[1]/@ipd"/>
+ <eval expected="355000" xpath="//flow/block[1]/@ipda"/>
+ <eval expected="14400" xpath="//flow/block[1]/@bpd"/>
+ <eval expected="14400" xpath="//flow/block[1]/@bpda"/>
+ <!-- margin-right -->
+ <eval expected="5000" xpath="//flow/block[2]/@space-end"/>
+ <eval expected="0 0 0 0" xpath="//flow/block[2]/@bap"/>
+ <eval expected="355000" xpath="//flow/block[2]/@ipd"/>
+ <eval expected="355000" xpath="//flow/block[2]/@ipda"/>
+ <eval expected="14400" xpath="//flow/block[2]/@bpd"/>
+ <eval expected="14400" xpath="//flow/block[2]/@bpda"/>
+ <!-- margin-top -->
<!-- space before block -->
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@bpd"/>
+ <eval expected="5000" xpath="//flow/block[3]/@space-before"/>
<!-- actual block -->
- <eval expected="0 0 0 0" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@bap"/>
- <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@ipda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@bpda"/>
- <!-- padding-bottom -->
+ <eval expected="0 0 0 0" xpath="//flow/block[3]/@bap"/>
+ <eval expected="360000" xpath="//flow/block[3]/@ipda"/>
+ <eval expected="14400" xpath="//flow/block[3]/@bpd"/>
+ <eval expected="19400" xpath="//flow/block[3]/@bpda"/>
+ <!-- margin-bottom -->
<!-- actual block -->
- <eval expected="0 0 0 0" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@bap"/>
- <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@ipda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@bpda"/>
+ <eval expected="0 0 0 0" xpath="//flow/block[4]/@bap"/>
+ <eval expected="360000" xpath="//flow/block[4]/@ipda"/>
+ <eval expected="14400" xpath="//flow/block[4]/@bpd"/>
+ <eval expected="19400" xpath="//flow/block[4]/@bpda"/>
<!-- space after block -->
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@bpd"/>
+ <eval expected="5000" xpath="//flow/block[4]/@space-after"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
- <eval expected="0" xpath="//flow/block[1]/@ipd"/>
- <eval expected="18000" xpath="//flow/block[1]/@bpd"/>
- <eval expected="324000" xpath="//flow/block[2]/@ipd"/>
- <eval expected="18000" xpath="//flow/block[2]/@start-indent"/>
- <eval expected="18000" xpath="//flow/block[2]/@end-indent"/>
- <eval expected="18000" xpath="//flow/block[2]/@space-start"/>
- <eval expected="18000" xpath="//flow/block[2]/@space-end"/>
- <eval expected="0" xpath="//flow/block[2]/block[1]/@ipd"/>
- <eval expected="18000" xpath="//flow/block[2]/block[1]/@bpd"/>
- <eval expected="288000" xpath="//flow/block[2]/block[2]/@ipd"/>
- <eval expected="36000" xpath="//flow/block[2]/block[2]/@start-indent"/>
- <eval expected="36000" xpath="//flow/block[2]/block[2]/@end-indent"/>
- <eval expected="36000" xpath="//flow/block[2]/block[2]/@space-start"/>
- <eval expected="36000" xpath="//flow/block[2]/block[2]/@space-end"/>
- <eval expected="0" xpath="//flow/block[2]/block[3]/@ipd"/>
- <eval expected="18000" xpath="//flow/block[2]/block[3]/@bpd"/>
- <eval expected="0" xpath="//flow/block[3]/@ipd"/>
- <eval expected="18000" xpath="//flow/block[3]/@bpd"/>
+ <element-list category="breaker">
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="18000" y="0" z="0"/>
+ <box w="14400"/>
+ <box w="14400"/>
+ <penalty w="0" p="INF"/>
+ <glue w="18000" y="0" z="0"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <box w="14400"/>
+ <skip>3</skip>
+ </element-list>
+
+ <true xpath="not(boolean(//flow/block[1]/@space-before))"/> <!-- space collapsed under space resolution rules -->
+ <eval expected="324000" xpath="//flow/block[1]/@ipd"/>
+ <eval expected="18000" xpath="//flow/block[1]/@start-indent"/>
+ <eval expected="18000" xpath="//flow/block[1]/@end-indent"/>
+ <eval expected="18000" xpath="//flow/block[1]/@space-start"/>
+ <eval expected="18000" xpath="//flow/block[1]/@space-end"/>
+
+ <eval expected="18000" xpath="//flow/block[1]/block[1]/@space-before"/>
+ <eval expected="288000" xpath="//flow/block[1]/block[1]/@ipd"/>
+ <eval expected="36000" xpath="//flow/block[1]/block[1]/@start-indent"/>
+ <eval expected="36000" xpath="//flow/block[1]/block[1]/@end-indent"/>
+ <eval expected="36000" xpath="//flow/block[1]/block[1]/@space-start"/>
+ <eval expected="36000" xpath="//flow/block[1]/block[1]/@space-end"/>
+ <true xpath="not(boolean(//flow/block[1]/block[1]/@space-after))"/> <!-- space collapsed under space resolution rules -->
+ <true xpath="not(boolean(//flow/block[1]/block[2]))"/>
+
+ <eval expected="18000" xpath="//flow/block[1]/@space-after"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
- <eval expected="0" xpath="//flow/block[1]/@ipd"/>
- <eval expected="18000" xpath="//flow/block[1]/@bpd"/>
- <eval expected="324000" xpath="//flow/block[2]/@ipd"/>
- <eval expected="18000" xpath="//flow/block[2]/@start-indent"/>
- <eval expected="18000" xpath="//flow/block[2]/@end-indent"/>
- <eval expected="18000" xpath="//flow/block[2]/@space-start"/>
- <eval expected="18000" xpath="//flow/block[2]/@space-end"/>
- <eval expected="0" xpath="//flow/block[2]/block[1]/@ipd"/>
- <eval expected="16200" xpath="//flow/block[2]/block[1]/@bpd"/>
- <eval expected="291600" xpath="//flow/block[2]/block[2]/@ipd"/>
- <eval expected="34200" xpath="//flow/block[2]/block[2]/@start-indent"/>
- <eval expected="34200" xpath="//flow/block[2]/block[2]/@end-indent"/>
- <eval expected="34200" xpath="//flow/block[2]/block[2]/@space-start"/>
- <eval expected="34200" xpath="//flow/block[2]/block[2]/@space-end"/>
- <eval expected="0" xpath="//flow/block[2]/block[3]/@ipd"/>
- <eval expected="16200" xpath="//flow/block[2]/block[3]/@bpd"/>
- <eval expected="0" xpath="//flow/block[3]/@ipd"/>
- <eval expected="18000" xpath="//flow/block[3]/@bpd"/>
+ <element-list category="breaker">
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="18000" y="0" z="0"/>
+ <box w="14400"/>
+ <box w="14400"/>
+ <penalty w="0" p="INF"/>
+ <glue w="18000" y="0" z="0"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <box w="14400"/>
+ <skip>3</skip>
+ </element-list>
+
+ <eval expected="18000" xpath="//flow/block[1]/@space-before"/>
+ <eval expected="324000" xpath="//flow/block[1]/@ipd"/>
+ <eval expected="18000" xpath="//flow/block[1]/@start-indent"/>
+ <eval expected="18000" xpath="//flow/block[1]/@end-indent"/>
+ <eval expected="18000" xpath="//flow/block[1]/@space-start"/>
+ <eval expected="18000" xpath="//flow/block[1]/@space-end"/>
+
+ <true xpath="not(boolean(//flow/block[1]/block[1]/@space-before))"/> <!-- space collapsed under space resolution rules -->
+ <eval expected="291600" xpath="//flow/block[1]/block[1]/@ipd"/>
+ <eval expected="34200" xpath="//flow/block[1]/block[1]/@start-indent"/>
+ <eval expected="34200" xpath="//flow/block[1]/block[1]/@end-indent"/>
+ <eval expected="34200" xpath="//flow/block[1]/block[1]/@space-start"/>
+ <eval expected="34200" xpath="//flow/block[1]/block[1]/@space-end"/>
+ <true xpath="not(boolean(//flow/block[1]/block[1]/@space-after))"/> <!-- space collapsed under space resolution rules -->
+ <true xpath="not(boolean(//flow/block[1]/block[2]))"/>
+
+ <eval expected="18000" xpath="//flow/block[1]/@space-after"/>
</checks>
</testcase>
</fo:layout-master-set>
<fo:page-sequence master-reference="normal" white-space-collapse="true">
<fo:flow flow-name="xsl-region-body">
+ <fo:block border-before-style="solid" border-before-width="1pt"/> <!-- These are to avoid stacking constraints between tests -->
<fo:block margin="5pt">all</fo:block>
+ <fo:block border-before-style="solid" border-before-width="1pt"/>
<fo:block margin="0pt 5pt">left/right</fo:block>
+ <fo:block border-before-style="solid" border-before-width="1pt"/>
<fo:block margin="5pt 0pt">top/bottom</fo:block>
+ <fo:block border-before-style="solid" border-before-width="1pt"/>
<fo:block margin="1pt 2pt 3pt">three values</fo:block>
+ <fo:block border-before-style="solid" border-before-width="1pt"/>
<fo:block>EOF</fo:block>
</fo:flow>
</fo:page-sequence>
<checks>
<!-- *** all *** -->
<!-- space before block -->
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bpd"/>
+ <eval expected="5000" xpath="//flow/block[2]/@space-before"/>
<!-- actual block -->
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@space-start"/>
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@space-end"/>
- <eval expected="0 0 0 0" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bap"/>
- <eval expected="350000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@ipda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bpda"/>
+ <eval expected="5000" xpath="//flow/block[2]/@space-start"/>
+ <eval expected="5000" xpath="//flow/block[2]/@space-end"/>
+ <eval expected="0 0 0 0" xpath="//flow/block[2]/@bap"/>
+ <eval expected="350000" xpath="//flow/block[2]/@ipda"/>
+ <eval expected="14400" xpath="//flow/block[2]/@bpd"/>
+ <eval expected="24400" xpath="//flow/block[2]/@bpda"/>
<!-- space after block -->
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@bpd"/>
+ <eval expected="5000" xpath="//flow/block[2]/@space-after"/>
<!-- *** left/right *** -->
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@space-start"/>
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@space-end"/>
- <eval expected="0 0 0 0" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@bap"/>
- <eval expected="350000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@ipda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@bpda"/>
+ <eval expected="5000" xpath="//flow/block[4]/@space-start"/>
+ <eval expected="5000" xpath="//flow/block[4]/@space-end"/>
+ <eval expected="0 0 0 0" xpath="//flow/block[4]/@bap"/>
+ <eval expected="350000" xpath="//flow/block[4]/@ipda"/>
+ <eval expected="14400" xpath="//flow/block[4]/@bpda"/>
<!-- *** top/bottom *** -->
<!-- space before block -->
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@bpd"/>
+ <eval expected="5000" xpath="//flow/block[6]/@space-before"/>
<!-- actual block -->
- <true xpath="not(/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@space-start)"/>
- <true xpath="not(/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@space-end)"/>
- <eval expected="0 0 0 0" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@bap"/>
- <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@ipda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@bpda"/>
+ <true xpath="not(//flow/block[6]/@space-start)"/>
+ <true xpath="not(//flow/block[6]/@space-end)"/>
+ <eval expected="0 0 0 0" xpath="//flow/block[6]/@bap"/>
+ <eval expected="360000" xpath="//flow/block[6]/@ipda"/>
+ <eval expected="14400" xpath="//flow/block[6]/@bpd"/>
+ <eval expected="24400" xpath="//flow/block[6]/@bpda"/>
<!-- space after block -->
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/@bpd"/>
+ <eval expected="5000" xpath="//flow/block[6]/@space-after"/>
<!-- *** three values *** -->
<!-- space before block -->
- <eval expected="1000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[8]/@bpd"/>
+ <eval expected="1000" xpath="//flow/block[8]/@space-before"/>
<!-- actual block -->
- <eval expected="2000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[9]/@space-start"/>
- <eval expected="2000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[9]/@space-end"/>
- <eval expected="0 0 0 0" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[9]/@bap"/>
- <eval expected="356000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[9]/@ipda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[9]/@bpda"/>
+ <eval expected="2000" xpath="//flow/block[8]/@space-start"/>
+ <eval expected="2000" xpath="//flow/block[8]/@space-end"/>
+ <eval expected="0 0 0 0" xpath="//flow/block[8]/@bap"/>
+ <eval expected="356000" xpath="//flow/block[8]/@ipda"/>
+ <eval expected="14400" xpath="//flow/block[8]/@bpd"/>
+ <eval expected="18400" xpath="//flow/block[8]/@bpda"/>
<!-- space after block -->
- <eval expected="3000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[10]/@bpd"/>
+ <eval expected="3000" xpath="//flow/block[8]/@space-after"/>
</checks>
</testcase>
</fo>\r
<checks>\r
<element-list category="breaker">\r
- <box w="30000"/>\r
+ <box w="0"/>\r
+ <penalty w="0" p="INF"/>\r
+ <glue w="30000" aux="true"/>\r
+ \r
<box w="14400"/>\r
- <penalty w="30000" p="0"/> <!-- w="30000" is for the padding-after -->\r
- <glue w="-30000" aux="true"/> <!-- get's discarded if a break happens on the penalty above -->\r
+ \r
+ <glue w="30000" aux="true"/> <!-- w="30000" is for the padding-after -->\r
+ <penalty w="0" p="0"/>\r
+ <glue w="-60000" aux="true"/> <!-- difference between break and no-break situation -->\r
<box w="0"/>\r
<penalty w="0" p="INF"/>\r
<glue w="30000" aux="true"/> <!-- w="30000" is for the padding-before -->\r
+ \r
<box w="14400"/>\r
- <penalty w="30000" p="0"/>\r
- <glue w="-30000" aux="true"/>\r
+ \r
+ <glue w="30000" aux="true"/>\r
+ <penalty w="0" p="0"/>\r
+ <glue w="-60000" aux="true"/>\r
<box w="0"/>\r
<penalty w="0" p="INF"/>\r
<glue w="30000" aux="true"/>\r
+ \r
<box w="14400"/>\r
- <penalty w="30000" p="0"/>\r
- <glue w="-30000" aux="true"/>\r
+\r
+ <glue w="30000" aux="true"/>\r
+ <penalty w="0" p="0"/>\r
+ <glue w="-60000" aux="true"/>\r
<box w="0"/>\r
<penalty w="0" p="INF"/>\r
<glue w="30000" aux="true"/>\r
+ \r
<box w="14400"/>\r
- <penalty w="30000" p="0"/>\r
- <glue w="-30000" aux="true"/>\r
+\r
+ <glue w="30000" aux="true"/>\r
+ <penalty w="0" p="0"/>\r
+ <glue w="-60000" aux="true"/>\r
<box w="0"/>\r
<penalty w="0" p="INF"/>\r
<glue w="30000" aux="true"/>\r
+ \r
<box w="14400"/>\r
- <penalty w="30000" p="0"/>\r
- <glue w="-30000" aux="true"/>\r
+\r
+ <glue w="30000" aux="true"/>\r
+ <penalty w="0" p="0"/>\r
+ <glue w="-60000" aux="true"/>\r
<box w="0"/>\r
<penalty w="0" p="INF"/>\r
<glue w="30000" aux="true"/>\r
+ \r
<box w="14400"/>\r
- <box w="30000"/>\r
+ \r
+ <box w="0"/>\r
+ <penalty w="0" p="INF"/>\r
+ <glue w="30000" aux="true"/>\r
+ \r
<skip>3</skip>\r
</element-list>\r
</checks>\r
</fo>
<checks>
<!-- overlapping block1 -->
- <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@ipda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[1]/@bpda"/>
+ <eval expected="360000" xpath="//flow/block[1]/@ipda"/>
+ <eval expected="14400" xpath="//flow/block[1]/@bpd"/>
+ <eval expected="6400" xpath="//flow/block[1]/@bpda"/>
<!-- space after overlapping block1 -->
- <eval expected="-8000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[2]/@bpd"/>
+ <eval expected="-8000" xpath="//flow/block[1]/@space-after"/>
<!-- normal block1 -->
- <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@ipda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[3]/@bpda"/>
+ <eval expected="360000" xpath="//flow/block[2]/@ipda"/>
+ <eval expected="14400" xpath="//flow/block[2]/@bpda"/>
<!-- space before spaced block1 -->
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[4]/@bpd"/>
+ <eval expected="5000" xpath="//flow/block[3]/@space-before"/>
<!-- spaced block1 -->
- <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@ipda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[5]/@bpda"/>
+ <eval expected="360000" xpath="//flow/block[3]/@ipda"/>
+ <eval expected="14400" xpath="//flow/block[3]/@bpd"/>
+ <eval expected="19400" xpath="//flow/block[3]/@bpda"/>
<!-- spaced block2 -->
- <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@ipda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[6]/@bpda"/>
+ <eval expected="360000" xpath="//flow/block[4]/@ipda"/>
+ <eval expected="14400" xpath="//flow/block[4]/@bpd"/>
+ <eval expected="19400" xpath="//flow/block[4]/@bpda"/>
<!-- space after spaced block2 -->
- <eval expected="5000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[7]/@bpd"/>
+ <eval expected="5000" xpath="//flow/block[4]/@space-after"/>
<!-- normal block2 -->
- <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[8]/@ipda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[8]/@bpda"/>
+ <eval expected="360000" xpath="//flow/block[5]/@ipda"/>
+ <eval expected="14400" xpath="//flow/block[5]/@bpda"/>
<!-- space before overlapping block2 -->
- <eval expected="-8000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[9]/@bpd"/>
+ <eval expected="-8000" xpath="//flow/block[6]/@space-before"/>
<!-- overlapping block2 -->
- <eval expected="360000" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[10]/@ipda"/>
- <eval expected="14400" xpath="/areaTree/pageSequence/pageViewport/page[1]/regionViewport/regionBody/mainReference/span/flow/block[10]/@bpda"/>
+ <eval expected="360000" xpath="//flow/block[6]/@ipda"/>
+ <eval expected="14400" xpath="//flow/block[6]/@bpd"/>
+ <eval expected="6400" xpath="//flow/block[6]/@bpda"/>
</checks>
</testcase>
<fo:region-body/>
</fo:simple-page-master>
</fo:layout-master-set>
- <fo:page-sequence master-reference="normal" white-space-collapse="true">
+ <fo:page-sequence master-reference="normal" id="retain">
<fo:flow flow-name="xsl-region-body">
<fo:block space-before.optimum="20pt" space-before.conditionality="retain" space-after.optimum="10pt" space-after.conditionality="retain" text-align="justify">
In olden times when wishing still helped one, there lived a king whose daughters
</fo:block>
</fo:flow>
</fo:page-sequence>
- <fo:page-sequence master-reference="normal" white-space-collapse="true">
+ <fo:page-sequence master-reference="normal" id="discard">
<fo:flow flow-name="xsl-region-body">
<fo:block space-before.optimum="20pt" space-before.conditionality="discard" space-after.optimum="10pt" space-after.conditionality="discard" text-align="justify">
In olden times when wishing still helped one, there lived a king whose daughters
</fo:root>
</fo>
<checks>
+ <element-list category="breaker" id="retain">
+ <box w="0"/> <!-- Helper box bearing the SpaceHandlingPosition and making sure the glue gets processed -->
+ <penalty w="0" p="INF"/>
+ <glue w="20000" y="0" z="20000"/>
+
+ <box w="14400"/>
+ <box w="14400"/>
+
+ <penalty w="0" p="INF"/>
+ <glue w="10000" y="0" z="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-30000" y="0" z="-30000"/>
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="20000" y="0" z="20000"/>
+
+ <box w="14400"/>
+
+ <penalty w="0" p="INF"/>
+ <glue w="10000" y="0" z="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-30000" y="0" z="-30000"/>
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="20000" y="0" z="20000"/>
+
+ <box w="14400"/>
+
+ <!-- skip three more lines -->
+ <skip>8</skip>
+ <skip>8</skip>
+ <skip>8</skip>
+
+ <penalty w="0" p="INF"/>
+ <glue w="10000" y="0" z="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-30000" y="0" z="-30000"/>
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="20000" y="0" z="20000"/>
+
+ <box w="14400"/>
+ <box w="14400"/>
+
+ <penalty w="0" p="INF" aux="true"/>
+ <glue w="10000" aux="true"/>
+ <penalty w="0" p="0"/>
+ <glue w="-10000" aux="true"/>
+
+ <box w="0" aux="true"/>
+ <penalty w="0" p="INF" aux="true"/>
+ <glue w="10000" aux="true"/>
+
+ <box w="14400"/> <!-- second block -->
+
+ <box w="0" aux="true"/>
+ <penalty w="0" p="INF" aux="true"/>
+ <glue w="20000" aux="true"/>
+
+ <box w="0" aux="true"/> <!-- This is used to make sure the preceding glue is not cut off -->
+
+ <skip>3</skip>
+ </element-list>
+ <element-list category="breaker" id="discard">
+ <box w="0"/> <!-- Helper box used to notify the LM for the addAreas stage about the discarded spaces -->
+ <box w="14400"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <glue w="10000"/>
+
+ <box w="14400"/> <!-- second block -->
+
+ <box w="0"/> <!-- SpaceHandlingPosition-bearing helper box -->
+
+ <skip>3</skip>
+ </element-list>
</checks>
</testcase>
<element-list category="breaker">\r
<box w="0"/>\r
<penalty w="0" p="INF"/>\r
- <glue w="5000" aux="true"/>\r
+ <glue w="5000"/>\r
<box w="14400"/>\r
<box w="14400"/>\r
<skip>3</skip>\r
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<testcase>
+ <info>
+ <p>
+ This test checks block-level space properties. Demonstrates that spaces are repeated on every generated area.
+ </p>
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="30pt">
+ <fo:region-body/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal" white-space-collapse="true">
+ <fo:flow flow-name="xsl-region-body" line-height="10pt" font-size="9pt">
+ <fo:block space-before="5pt" space-before.conditionality="retain" background-color="yellow">
+ <fo:block>line 1</fo:block>
+ <fo:block>line 2</fo:block>
+ <fo:block>line 3</fo:block>
+ <fo:block>line 4</fo:block>
+ <fo:block>line 5</fo:block>
+ </fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <element-list category="breaker">
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="5000"/>
+ <box w="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-5000"/>
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="5000"/>
+ <box w="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-5000"/>
+
+ <!-- skip two more lines -->
+ <skip>6</skip>
+ <skip>6</skip>
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="5000"/>
+ <box w="10000"/>
+
+ <skip>3</skip>
+ </element-list>
+ <eval expected="3" xpath="count(//pageViewport)"/>
+ <eval expected="5000" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+ <eval expected="5000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+ <eval expected="5000" xpath="//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+ <eval expected="1" xpath="count(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block)"/>
+ <eval expected="1" xpath="count(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block)"/>
+ <eval expected="1" xpath="count(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block)"/>
+ <eval expected="2" xpath="count(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block)"/>
+ <eval expected="2" xpath="count(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block)"/>
+ <eval expected="1" xpath="count(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block)"/>
+
+ </checks>
+</testcase>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<testcase>
+ <info>
+ <p>
+ This test checks block-level space properties. These here are the
+ <a href="http://wiki.apache.org/xmlgraphics-fop/SpaceResolution/Examples">examples 3 to 5 on the Wiki</a>.
+ </p>
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="1in">
+ <fo:region-body background-color="lightgray"/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal" id="cond-cond">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:block space-after="11pt">block 1: space-after conditional</fo:block>
+ <fo:block space-before="12pt">block 2: space-before conditional</fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+ <fo:page-sequence master-reference="normal" id="retain-cond">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:block space-after="11pt" space-after.conditionality="retain">block 1: space-after retained</fo:block>
+ <fo:block space-before="12pt">block 2: space-before: conditional</fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+ <fo:page-sequence master-reference="normal" id="retain-cond-2">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:block space-after="10pt" space-after.conditionality="retain">block 1: space-after retained</fo:block>
+ <fo:block space-before="10pt">block 2: space-before: conditional</fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+ <fo:page-sequence master-reference="normal" id="retain-retain">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:block space-after="11pt" space-after.conditionality="retain">block 1: space-after retained</fo:block>
+ <fo:block space-before="12pt" space-before.conditionality="retain">block 2: space-before retained</fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <element-list category="breaker" id="cond-cond">
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <glue w="12000"/>
+ <box w="14400"/>
+ <skip>3</skip>
+ </element-list>
+ <element-list category="breaker" id="retain-cond">
+ <box w="14400"/>
+ <penalty w="0" p="INF"/>
+ <glue w="11000"/>
+ <penalty w="0" p="0"/>
+ <glue w="1000"/>
+ <box w="14400"/>
+ <skip>3</skip>
+ </element-list>
+ <element-list category="breaker" id="retain-cond-2">
+ <box w="14400"/>
+ <penalty w="0" p="INF"/>
+ <glue w="10000"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <skip>3</skip>
+ </element-list>
+ <element-list category="breaker" id="retain-retain">
+ <box w="14400"/>
+ <penalty w="0" p="INF"/>
+ <glue w="11000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-11000"/>
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="12000"/>
+ <box w="14400"/>
+ <skip>3</skip>
+ </element-list>
+ </checks>
+</testcase>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<testcase>
+ <info>
+ <p>
+ This test checks block-level space properties. These here are the
+ <a href="http://wiki.apache.org/xmlgraphics-fop/SpaceResolution/Examples">examples 1 and 2 on the Wiki</a>.
+ </p>
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="1in">
+ <fo:region-body background-color="lightgray"/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal" id="ex1">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:block>first line</fo:block>
+ <fo:block space-before="10pt">
+ <fo:block>before break</fo:block>
+ <fo:block>after break</fo:block>
+ </fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+ <fo:page-sequence master-reference="normal" id="ex2">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:block>first line</fo:block>
+ <fo:block space-before="10pt" space-before.conditionality="retain">
+ <fo:block>before break</fo:block>
+ <fo:block>after break</fo:block>
+ </fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <element-list category="breaker" id="ex1">
+ <box w="14400"/>
+
+ <penalty w="0" p="0"/>
+
+ <glue w="10000"/>
+ <box w="14400"/>
+
+ <penalty w="0" p="0"/>
+
+ <box w="14400"/>
+
+ <skip>3</skip>
+ </element-list>
+
+ <element-list category="breaker" id="ex2">
+ <box w="14400"/>
+
+ <penalty w="0" p="0"/>
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="10000"/>
+
+ <box w="14400"/>
+
+ <penalty w="0" p="0"/>
+
+ <glue w="-10000"/>
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="10000"/>
+
+ <box w="14400"/>
+
+ <skip>3</skip>
+ </element-list>
+ </checks>
+</testcase>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<testcase>
+ <info>
+ <p>
+ This test checks block-level space properties. These here are the
+ <a href="http://wiki.apache.org/xmlgraphics-fop/SpaceResolution/Examples">examples 1 and 2 on the Wiki</a>.
+ </p>
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="1in">
+ <fo:region-body background-color="lightgray"/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal" id="ex8">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:block space-before="10pt" padding-before="5pt" border-before-style="solid" border-before-width="2pt">
+ first line
+ <fo:block space-before="6pt">second line</fo:block>
+ </fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <element-list category="breaker" id="ex8">
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="7000"/>
+ <box w="14400"/>
+
+ <penalty w="0" p="0"/>
+
+ <glue w="6000"/>
+ <box w="14400"/>
+ <skip>3</skip>
+ </element-list>
+ </checks>
+</testcase>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<testcase>
+ <info>
+ <p>
+ This test checks if the special case is properly handled when an empty block is between two
+ space-specifiers which should form a stacking constraint.
+ </p>
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="1in">
+ <fo:region-body/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal" id="ex8">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:block space-after="10pt">
+ first line
+ </fo:block>
+ <fo:block id="empty-block"/>
+ <fo:block space-before="10pt">
+ second line
+ </fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <true xpath="not(boolean(//flow/block[1]/@space-after))"/>
+ <eval expected="10000" xpath="//flow/block[2]/@space-before"/>
+ </checks>
+</testcase>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<testcase>
+ <info>
+ <p>
+ This test checks if the isLast case is properly handled. In this case the part list has to be
+ reversed to do the conditionals removal, but then has to be reversed again to its natural order
+ so space resolution rules 2 and 3 are properly performed.
+ </p>
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="1in">
+ <fo:region-body/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:block space-before="11pt" space-after="11pt">
+ <fo:block space-before="12pt" space-after="12pt">
+ <fo:block space-before="13pt" space-after="13pt" border="solid 1pt">
+ Apache FOP!
+ </fo:block>
+ </fo:block>
+ </fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <element-list category="breaker">
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="1000"/>
+
+ <box w="14400"/>
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="1000"/>
+
+ <box w="0"/>
+ <skip>3</skip>
+ </element-list>
+ <true xpath="not(boolean(//flow/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//flow/block[1]/@space-after))"/>
+ <true xpath="not(boolean(//flow/block[1]/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//flow/block[1]/block[1]/@space-after))"/>
+ <true xpath="not(boolean(//flow/block[1]/block[1]/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//flow/block[1]/block[1]/block[1]/@space-after))"/>
+ <eval expected="1000 1000 1000 1000" xpath="//flow/block[1]/block[1]/block[1]/@bap"/>
+ </checks>
+</testcase>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<testcase>
+ <info>
+ <p>
+ This test checks if the isLast case is properly handled. In this case the part list has to be
+ reversed to do the conditionals removal, but then has to be reversed again to its natural order
+ so space resolution rules 2 and 3 are properly performed.
+ </p>
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="1in">
+ <fo:region-body/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:block space-before="11pt" space-after="11pt">
+ <fo:block space-before="12pt" space-after="12pt">
+ <fo:block space-before="13pt" space-after="13pt" border="solid 1pt">
+ Apache FOP!
+ <fo:block break-before="page"/>
+ Apache FOP!!!
+ </fo:block>
+ </fo:block>
+ </fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <element-list category="breaker" index="0">
+ <box w="0"/> <!-- SpaceHandlingPosition -->
+ <penalty w="0" p="INF"/>
+ <glue w="1000"/>
+
+ <box w="14400"/>
+
+ <skip>3</skip> <!-- the last of the three holds a SpaceHandlingBreakPosition -->
+ </element-list>
+ <element-list category="breaker" index="1">
+ <box w="0"/> <!-- SpaceHandlingPosition -->
+
+ <box w="0"/> <!-- empty block used to cause the break-before -->
+ <penalty w="0" p="0"/>
+
+ <box w="14400"/>
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="1000"/>
+ <box w="0"/> <!-- SpaceHandlingPosition -->
+
+ <skip>3</skip>
+ </element-list>
+
+ <true xpath="not(boolean(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-after))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@space-after))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block[1]/@space-after))"/>
+ <eval expected="1000 1000 1000 0" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block[1]/@bap"/>
+
+ <true xpath="not(boolean(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-after))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@space-after))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block[1]/@space-after))"/>
+ <eval expected="1000 1000 0 1000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block[1]/@bap"/>
+ </checks>
+</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="7180" xpath="//flow/block[1]/lineArea/char/@baseline"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea/char/@offset"/>
+ <eval expected="5560" xpath="//flow/block[1]/lineArea/char/@ipd"/>
+ <eval expected="7560" xpath="//flow/block[1]/lineArea/char/@ipda"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/char/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/char/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/char/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/char/@border-start"/>
+
<eval expected="7180" xpath="//flow/block[2]/lineArea/char/@baseline"/>
<eval expected="0" xpath="//flow/block[2]/lineArea/char/@offset"/>
<eval expected="5560" xpath="//flow/block[2]/lineArea/char/@ipd"/>
- <eval expected="7560" xpath="//flow/block[2]/lineArea/char/@ipda"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/char/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/char/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/char/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/char/@border-start"/>
-
- <eval expected="7180" xpath="//flow/block[5]/lineArea/char/@baseline"/>
- <eval expected="0" xpath="//flow/block[5]/lineArea/char/@offset"/>
- <eval expected="5560" xpath="//flow/block[5]/lineArea/char/@ipd"/>
- <eval expected="25560" xpath="//flow/block[5]/lineArea/char/@ipda"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/char/@border-after"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/char/@border-before"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/char/@border-end"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/char/@border-start"/>
- <eval expected="5000" xpath="//flow/block[5]/lineArea/char/@padding-after"/>
- <eval expected="5000" xpath="//flow/block[5]/lineArea/char/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[5]/lineArea/char/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[5]/lineArea/char/@padding-start"/>
+ <eval expected="25560" xpath="//flow/block[2]/lineArea/char/@ipda"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/char/@border-after"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/char/@border-before"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/char/@border-end"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/char/@border-start"/>
+ <eval expected="5000" xpath="//flow/block[2]/lineArea/char/@padding-after"/>
+ <eval expected="5000" xpath="//flow/block[2]/lineArea/char/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[2]/lineArea/char/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[2]/lineArea/char/@padding-start"/>
- <eval expected="7180" xpath="//flow/block[8]/lineArea/char/@baseline"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea/char/@offset"/>
- <eval expected="5000" xpath="//flow/block[8]/lineArea/char/@ipd"/>
- <eval expected="17000" xpath="//flow/block[8]/lineArea/char/@ipda"/>
- <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[8]/lineArea/char/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea/char/@border-before"/>
- <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[8]/lineArea/char/@border-end"/>
- <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[8]/lineArea/char/@border-start"/>
- <eval expected="3000" xpath="//flow/block[8]/lineArea/char/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[8]/lineArea/char/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[8]/lineArea/char/@padding-end"/>
- <eval expected="4000" xpath="//flow/block[8]/lineArea/char/@padding-start"/>
+ <eval expected="7180" xpath="//flow/block[3]/lineArea/char/@baseline"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea/char/@offset"/>
+ <eval expected="5000" xpath="//flow/block[3]/lineArea/char/@ipd"/>
+ <eval expected="17000" xpath="//flow/block[3]/lineArea/char/@ipda"/>
+ <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[3]/lineArea/char/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea/char/@border-before"/>
+ <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[3]/lineArea/char/@border-end"/>
+ <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[3]/lineArea/char/@border-start"/>
+ <eval expected="3000" xpath="//flow/block[3]/lineArea/char/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea/char/@padding-before"/>
+ <eval expected="2000" xpath="//flow/block[3]/lineArea/char/@padding-end"/>
+ <eval expected="4000" xpath="//flow/block[3]/lineArea/char/@padding-start"/>
- <eval expected="5744" xpath="//flow/block[11]/lineArea/char/@baseline"/>
- <eval expected="8616" xpath="//flow/block[11]/lineArea/char/@offset"/>
- <eval expected="4448" xpath="//flow/block[11]/lineArea/char/@ipd"/>
- <eval expected="24448" xpath="//flow/block[11]/lineArea/char/@ipda"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/char/@border-after"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/char/@border-before"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/char/@border-end"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/char/@border-start"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea/char/@padding-after"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea/char/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea/char/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea/char/@padding-start"/>
+ <eval expected="5744" xpath="//flow/block[4]/lineArea/char/@baseline"/>
+ <eval expected="8616" xpath="//flow/block[4]/lineArea/char/@offset"/>
+ <eval expected="4448" xpath="//flow/block[4]/lineArea/char/@ipd"/>
+ <eval expected="24448" xpath="//flow/block[4]/lineArea/char/@ipda"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/char/@border-after"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/char/@border-before"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/char/@border-end"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/char/@border-start"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea/char/@padding-after"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea/char/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea/char/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea/char/@padding-start"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="7180" xpath="//flow/block[1]/lineArea/char/@offset"/>
<eval expected="7180" xpath="//flow/block[2]/lineArea/char/@offset"/>
- <eval expected="7180" xpath="//flow/block[5]/lineArea/char/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea/char/@offset"/>
- <eval expected="4565" xpath="//flow/block[11]/lineArea/char/@offset"/>
- <eval expected="9250" xpath="//flow/block[14]/lineArea/char/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea/char/@offset"/>
+ <eval expected="4565" xpath="//flow/block[4]/lineArea/char/@offset"/>
+ <eval expected="9250" xpath="//flow/block[5]/lineArea/char/@offset"/>
</checks>
</testcase>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<testcase>
+ <info>
+ <p>
+ This test checks space-resolution inside the footnotes area.
+ </p>
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="3in">
+ <fo:region-body/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal" white-space-collapse="true">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:block>region-body<fo:footnote>
+ <fo:inline font-size="50%" vertical-align="super">1</fo:inline>
+ <fo:footnote-body>
+ <fo:block space-before="1em" space-after="1em">
+ <fo:inline font-size="50%" vertical-align="super">1</fo:inline>I'm a footnote!</fo:block>
+ </fo:footnote-body>
+ </fo:footnote>
+ blah<fo:footnote>
+ <fo:inline font-size="50%" vertical-align="super">2</fo:inline>
+ <fo:footnote-body>
+ <fo:block space-before="1em" space-after="1em">
+ <fo:inline font-size="50%" vertical-align="super">2</fo:inline>I'm a footnote!</fo:block>
+ </fo:footnote-body>
+ </fo:footnote>
+ </fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <true xpath="not(boolean(//footnotes/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//footnotes/block[1]/@space-after))"/>
+ <eval expected="12000" xpath="//footnotes/block[2]/@space-before"/>
+ <true xpath="not(boolean(//footnotes/block[2]/@space-after))"/>
+ </checks>
+</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="2872" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
<eval expected="2872" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="2872" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="2872" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="10052" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="2872" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="10052" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="10052" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="5427" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="5487" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="802" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="802" xpath="//flow/block[9]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="802" xpath="//flow/block[10]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="2872" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="8616" xpath="//flow/block[12]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="6462" xpath="//flow/block[13]/lineArea[1]/inlineparent/@offset"/>
<eval expected="10052" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="5427" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="5487" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="802" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="802" xpath="//flow/block[26]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="802" xpath="//flow/block[29]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="2872" xpath="//flow/block[32]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="8616" xpath="//flow/block[35]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="6462" xpath="//flow/block[38]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="10052" xpath="//flow/block[41]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="802" xpath="//flow/block[44]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="10052" xpath="//flow/block[47]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="802" xpath="//flow/block[50]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="802" xpath="//flow/block[15]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="10052" xpath="//flow/block[16]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="802" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="12950" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+ <eval expected="1925" xpath="//flow/block[1]/lineArea[1]/@space-before"/>
+ <eval expected="1925" xpath="//flow/block[1]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="2872" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[2]/@offset"/>
+
<eval expected="12950" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
<eval expected="1925" xpath="//flow/block[2]/lineArea[1]/@space-before"/>
<eval expected="1925" xpath="//flow/block[2]/lineArea[1]/@space-after"/>
<eval expected="2872" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
- <eval expected="12950" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
- <eval expected="1925" xpath="//flow/block[5]/lineArea[1]/@space-before"/>
- <eval expected="1925" xpath="//flow/block[5]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
- <eval expected="2872" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="13078" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
- <eval expected="1925" xpath="//flow/block[8]/lineArea[1]/@space-before"/>
- <eval expected="1925" xpath="//flow/block[8]/lineArea[1]/@space-after"/>
- <eval expected="128" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="128" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="13078" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+ <eval expected="1925" xpath="//flow/block[3]/lineArea[1]/@space-before"/>
+ <eval expected="1925" xpath="//flow/block[3]/lineArea[1]/@space-after"/>
+ <eval expected="128" xpath="//flow/block[3]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="128" xpath="//flow/block[3]/lineArea[1]/text[2]/@offset"/>
- <eval expected="15122" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
- <eval expected="1925" xpath="//flow/block[11]/lineArea[1]/@space-before"/>
- <eval expected="1925" xpath="//flow/block[11]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
- <eval expected="5872" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="15122" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+ <eval expected="1925" xpath="//flow/block[4]/lineArea[1]/@space-before"/>
+ <eval expected="1925" xpath="//flow/block[4]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="5872" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[2]/@offset"/>
- <eval expected="13678" xpath="//flow/block[14]/lineArea[1]/@bpd"/>
- <eval expected="1925" xpath="//flow/block[14]/lineArea[1]/@space-before"/>
- <eval expected="1925" xpath="//flow/block[14]/lineArea[1]/@space-after"/>
- <eval expected="728" xpath="//flow/block[14]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="728" xpath="//flow/block[14]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="13678" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
+ <eval expected="1925" xpath="//flow/block[5]/lineArea[1]/@space-before"/>
+ <eval expected="1925" xpath="//flow/block[5]/lineArea[1]/@space-after"/>
+ <eval expected="728" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="728" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
- <eval expected="15722" xpath="//flow/block[17]/lineArea[1]/@bpd"/>
- <eval expected="1925" xpath="//flow/block[17]/lineArea[1]/@space-before"/>
- <eval expected="1925" xpath="//flow/block[17]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/text[1]/@offset"/>
- <eval expected="6472" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="15722" xpath="//flow/block[6]/lineArea[1]/@bpd"/>
+ <eval expected="1925" xpath="//flow/block[6]/lineArea[1]/@space-before"/>
+ <eval expected="1925" xpath="//flow/block[6]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="6472" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/text[2]/@offset"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="2872" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
<eval expected="2872" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="2872" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="2872" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="2872" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="1850" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="1826" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="3700" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="3700" xpath="//flow/block[9]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="3700" xpath="//flow/block[10]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="2872" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="574" xpath="//flow/block[12]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="1436" xpath="//flow/block[13]/lineArea[1]/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="1850" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="1826" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="3700" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="3700" xpath="//flow/block[26]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="3700" xpath="//flow/block[29]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="2872" xpath="//flow/block[32]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="574" xpath="//flow/block[35]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="1436" xpath="//flow/block[38]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[41]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="3700" xpath="//flow/block[44]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[47]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="3700" xpath="//flow/block[50]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="3700" xpath="//flow/block[15]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[16]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="3700" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="2872" xpath="//flow/block[1]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="2872" xpath="//flow/block[1]/lineArea[1]/text[2]/@offset"/>
+
<eval expected="2872" xpath="//flow/block[2]/lineArea[1]/text[1]/@offset"/>
<eval expected="2872" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
- <eval expected="2872" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
- <eval expected="2872" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="2872" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
- <eval expected="2872" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="2872" xpath="//flow/block[3]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="2872" xpath="//flow/block[3]/lineArea[1]/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
- <eval expected="1850" xpath="//flow/block[17]/lineArea[1]/text[1]/@offset"/>
- <eval expected="1850" xpath="//flow/block[17]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="1850" xpath="//flow/block[6]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="1850" xpath="//flow/block[6]/lineArea[1]/text[2]/@offset"/>
- <eval expected="1826" xpath="//flow/block[20]/lineArea[1]/text[1]/@offset"/>
- <eval expected="1826" xpath="//flow/block[20]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="1826" xpath="//flow/block[7]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="1826" xpath="//flow/block[7]/lineArea[1]/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
- <eval expected="3700" xpath="//flow/block[26]/lineArea[1]/text[1]/@offset"/>
- <eval expected="3700" xpath="//flow/block[26]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="3700" xpath="//flow/block[9]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="3700" xpath="//flow/block[9]/lineArea[1]/text[2]/@offset"/>
- <eval expected="3700" xpath="//flow/block[29]/lineArea[1]/text[1]/@offset"/>
- <eval expected="3700" xpath="//flow/block[29]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="3700" xpath="//flow/block[10]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="3700" xpath="//flow/block[10]/lineArea[1]/text[2]/@offset"/>
- <eval expected="2872" xpath="//flow/block[32]/lineArea[1]/text[1]/@offset"/>
- <eval expected="2872" xpath="//flow/block[32]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="2872" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="2872" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
- <eval expected="574" xpath="//flow/block[35]/lineArea[1]/text[1]/@offset"/>
- <eval expected="574" xpath="//flow/block[35]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="574" xpath="//flow/block[12]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="574" xpath="//flow/block[12]/lineArea[1]/text[2]/@offset"/>
- <eval expected="1436" xpath="//flow/block[38]/lineArea[1]/text[1]/@offset"/>
- <eval expected="1436" xpath="//flow/block[38]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="1436" xpath="//flow/block[13]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="1436" xpath="//flow/block[13]/lineArea[1]/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[41]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[41]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[44]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[44]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[15]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[15]/lineArea[1]/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[47]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[47]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[16]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[16]/lineArea[1]/text[2]/@offset"/>
- <eval expected="3700" xpath="//flow/block[50]/lineArea[1]/text[1]/@offset"/>
- <eval expected="3700" xpath="//flow/block[50]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="3700" xpath="//flow/block[17]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="3700" xpath="//flow/block[17]/lineArea[1]/text[2]/@offset"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="2872" xpath="//flow/block[1]/lineArea[1]/inlineparent[2]/@offset"/>
<eval expected="2872" xpath="//flow/block[2]/lineArea[1]/inlineparent[2]/@offset"/>
- <eval expected="2872" xpath="//flow/block[5]/lineArea[1]/inlineparent[2]/@offset"/>
- <eval expected="2872" xpath="//flow/block[8]/lineArea[1]/inlineparent[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent[2]/@offset"/>
- <eval expected="1436" xpath="//flow/block[14]/lineArea[1]/inlineparent[2]/@offset"/>
- <eval expected="2361" xpath="//flow/block[17]/lineArea[1]/inlineparent[2]/@offset"/>
- <eval expected="2349" xpath="//flow/block[20]/lineArea[1]/inlineparent[2]/@offset"/>
- <eval expected="3700" xpath="//flow/block[23]/lineArea[1]/inlineparent[2]/@offset"/>
- <eval expected="3286" xpath="//flow/block[26]/lineArea[1]/inlineparent[2]/@offset"/>
- <eval expected="3286" xpath="//flow/block[29]/lineArea[1]/inlineparent[2]/@offset"/>
- <eval expected="2872" xpath="//flow/block[32]/lineArea[1]/inlineparent[2]/@offset"/>
- <eval expected="1723" xpath="//flow/block[35]/lineArea[1]/inlineparent[2]/@offset"/>
- <eval expected="2154" xpath="//flow/block[38]/lineArea[1]/inlineparent[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[41]/lineArea[1]/inlineparent[2]/@offset"/>
- <eval expected="3700" xpath="//flow/block[44]/lineArea[1]/inlineparent[2]/@offset"/>
- <eval expected="1436" xpath="//flow/block[47]/lineArea[1]/inlineparent[2]/@offset"/>
- <eval expected="3286" xpath="//flow/block[50]/lineArea[1]/inlineparent[2]/@offset"/>
+ <eval expected="2872" xpath="//flow/block[3]/lineArea[1]/inlineparent[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent[2]/@offset"/>
+ <eval expected="1436" xpath="//flow/block[5]/lineArea[1]/inlineparent[2]/@offset"/>
+ <eval expected="2361" xpath="//flow/block[6]/lineArea[1]/inlineparent[2]/@offset"/>
+ <eval expected="2349" xpath="//flow/block[7]/lineArea[1]/inlineparent[2]/@offset"/>
+ <eval expected="3700" xpath="//flow/block[8]/lineArea[1]/inlineparent[2]/@offset"/>
+ <eval expected="3286" xpath="//flow/block[9]/lineArea[1]/inlineparent[2]/@offset"/>
+ <eval expected="3286" xpath="//flow/block[10]/lineArea[1]/inlineparent[2]/@offset"/>
+ <eval expected="2872" xpath="//flow/block[11]/lineArea[1]/inlineparent[2]/@offset"/>
+ <eval expected="1723" xpath="//flow/block[12]/lineArea[1]/inlineparent[2]/@offset"/>
+ <eval expected="2154" xpath="//flow/block[13]/lineArea[1]/inlineparent[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent[2]/@offset"/>
+ <eval expected="3700" xpath="//flow/block[15]/lineArea[1]/inlineparent[2]/@offset"/>
+ <eval expected="1436" xpath="//flow/block[16]/lineArea[1]/inlineparent[2]/@offset"/>
+ <eval expected="3286" xpath="//flow/block[17]/lineArea[1]/inlineparent[2]/@offset"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="22200" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="8616" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="-4308" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[2]/@offset"/>
+
<eval expected="22200" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[1]/@offset"/>
<eval expected="8616" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/text[2]/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="22200" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="1723" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="6494" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[2]/@offset"/>
+
+ <eval expected="22200" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="1723" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="2739" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[2]/@offset"/>
+
<eval expected="22200" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
- <eval expected="8616" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="-4308" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="5550" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/text[2]/@offset"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
- <eval expected="22200" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
- <eval expected="1723" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="6494" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="22200" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
- <eval expected="1723" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="2739" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="22200" xpath="//flow/block[14]/lineArea[1]/@bpd"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="5550" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="27750" xpath="//flow/block[6]/lineArea[1]/@bpd"/>
+ <eval expected="5550" xpath="//flow/block[6]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="5550" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="-5550" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/text[2]/@offset"/>
+ <eval expected="5550" xpath="//flow/block[6]/lineArea[1]/text[2]/@offset"/>
- <eval expected="27750" xpath="//flow/block[17]/lineArea[1]/@bpd"/>
- <eval expected="5550" xpath="//flow/block[17]/lineArea[1]/text[1]/@offset"/>
- <eval expected="5550" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="-5550" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/text[2]/@offset"/>
- <eval expected="5550" xpath="//flow/block[17]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="22200" xpath="//flow/block[7]/lineArea[1]/@bpd"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="8325" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="-8325" xpath="//flow/block[7]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
+ <eval expected="4308" xpath="//flow/block[7]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/inlineparent/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[1]/text[2]/@offset"/>
- <eval expected="22200" xpath="//flow/block[20]/lineArea[1]/@bpd"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[1]/text[1]/@offset"/>
- <eval expected="8325" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="-8325" xpath="//flow/block[20]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
- <eval expected="4308" xpath="//flow/block[20]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/inlineparent/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="22491" xpath="//flow/block[23]/lineArea[1]/@bpd"/>
- <eval expected="291" xpath="//flow/block[23]/lineArea[1]/text[1]/@offset"/>
- <eval expected="8616" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
- <eval expected="-8616" xpath="//flow/block[23]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/inlineparent/text[2]/@offset"/>
- <eval expected="291" xpath="//flow/block[23]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="22491" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
+ <eval expected="291" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="8616" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
+ <eval expected="-8616" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/text[2]/@offset"/>
+ <eval expected="291" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
- <eval expected="22200" xpath="//flow/block[26]/lineArea[1]/@bpd"/>
- <eval expected="0" xpath="//flow/block[26]/lineArea[1]/text[1]/@offset"/>
- <eval expected="8325" xpath="//flow/block[26]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[26]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[26]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[26]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
- <eval expected="-6462" xpath="//flow/block[26]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[26]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[26]/lineArea[1]/inlineparent/inlineparent/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[26]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="22200" xpath="//flow/block[9]/lineArea[1]/@bpd"/>
+ <eval expected="0" xpath="//flow/block[9]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="8325" xpath="//flow/block[9]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[9]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[9]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[9]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
+ <eval expected="-6462" xpath="//flow/block[9]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[9]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[9]/lineArea[1]/inlineparent/inlineparent/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[9]/lineArea[1]/text[2]/@offset"/>
- <eval expected="27750" xpath="//flow/block[29]/lineArea[1]/@bpd"/>
- <eval expected="5550" xpath="//flow/block[29]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[29]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[29]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="-5550" xpath="//flow/block[29]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[29]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[29]/lineArea[1]/inlineparent/text[2]/@offset"/>
- <eval expected="5550" xpath="//flow/block[29]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="27750" xpath="//flow/block[10]/lineArea[1]/@bpd"/>
+ <eval expected="5550" xpath="//flow/block[10]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[10]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[10]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="-5550" xpath="//flow/block[10]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[10]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[10]/lineArea[1]/inlineparent/text[2]/@offset"/>
+ <eval expected="5550" xpath="//flow/block[10]/lineArea[1]/text[2]/@offset"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="90040" xpath="//flow/block[1]/lineArea/inlineparent/@ipd"/>
+ <eval expected="color=#ffff00" xpath="//flow/block[1]/lineArea/inlineparent/@background"/>
+
<eval expected="90040" xpath="//flow/block[2]/lineArea/inlineparent/@ipd"/>
<eval expected="color=#ffff00" xpath="//flow/block[2]/lineArea/inlineparent/@background"/>
- <eval expected="90040" xpath="//flow/block[5]/lineArea/inlineparent/@ipd"/>
- <eval expected="color=#ffff00" xpath="//flow/block[5]/lineArea/inlineparent/@background"/>
-
- <eval expected="90040" xpath="//flow/block[8]/lineArea/inlineparent/@ipd"/>
- <eval expected="color=#ffff00" xpath="//flow/block[8]/lineArea/inlineparent/@background"/>
+ <eval expected="90040" xpath="//flow/block[3]/lineArea/inlineparent/@ipd"/>
+ <eval expected="color=#ffff00" xpath="//flow/block[3]/lineArea/inlineparent/@background"/>
- <eval expected="90040" xpath="//flow/block[11]/lineArea/inlineparent/@ipd"/>
- <eval expected="color=#ffff00" xpath="//flow/block[11]/lineArea/inlineparent/@background"/>
+ <eval expected="90040" xpath="//flow/block[4]/lineArea/inlineparent/@ipd"/>
+ <eval expected="color=#ffff00" xpath="//flow/block[4]/lineArea/inlineparent/@background"/>
- <eval expected="188950" xpath="//flow/block[14]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="color=#ffff00" xpath="//flow/block[14]/lineArea[1]/inlineparent/@background"/>
- <eval expected="313470" xpath="//flow/block[14]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="color=#ffff00" xpath="//flow/block[14]/lineArea[2]/inlineparent/@background"/>
- <eval expected="145610" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="color=#ffff00" xpath="//flow/block[14]/lineArea[3]/inlineparent/@background"/>
+ <eval expected="188950" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="color=#ffff00" xpath="//flow/block[5]/lineArea[1]/inlineparent/@background"/>
+ <eval expected="313470" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="color=#ffff00" xpath="//flow/block[5]/lineArea[2]/inlineparent/@background"/>
+ <eval expected="145610" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="color=#ffff00" xpath="//flow/block[5]/lineArea[3]/inlineparent/@background"/>
- <eval expected="188950" xpath="//flow/block[17]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="color=#ffff00" xpath="//flow/block[17]/lineArea[1]/inlineparent/@background"/>
- <eval expected="313470" xpath="//flow/block[17]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="color=#ffff00" xpath="//flow/block[17]/lineArea[2]/inlineparent/@background"/>
- <eval expected="109650" xpath="//flow/block[17]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="color=#ffff00" xpath="//flow/block[17]/lineArea[3]/inlineparent/@background"/>
+ <eval expected="188950" xpath="//flow/block[6]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="color=#ffff00" xpath="//flow/block[6]/lineArea[1]/inlineparent/@background"/>
+ <eval expected="313470" xpath="//flow/block[6]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="color=#ffff00" xpath="//flow/block[6]/lineArea[2]/inlineparent/@background"/>
+ <eval expected="109650" xpath="//flow/block[6]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="color=#ffff00" xpath="//flow/block[6]/lineArea[3]/inlineparent/@background"/>
- <eval expected="199793" xpath="//flow/block[20]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="color=#ffff00" xpath="//flow/block[20]/lineArea[1]/inlineparent/@background"/>
- <eval expected="350000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="color=#ffff00" xpath="//flow/block[20]/lineArea[2]/inlineparent/@background"/>
- <eval expected="118530" xpath="//flow/block[20]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="color=#ffff00" xpath="//flow/block[20]/lineArea[3]/inlineparent/@background"/>
+ <eval expected="199793" xpath="//flow/block[7]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="color=#ffff00" xpath="//flow/block[7]/lineArea[1]/inlineparent/@background"/>
+ <eval expected="350000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="color=#ffff00" xpath="//flow/block[7]/lineArea[2]/inlineparent/@background"/>
+ <eval expected="118530" xpath="//flow/block[7]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="color=#ffff00" xpath="//flow/block[7]/lineArea[3]/inlineparent/@background"/>
- <eval expected="128370" xpath="//flow/block[23]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="color=#ffff00" xpath="//flow/block[23]/lineArea[1]/inlineparent/@background"/>
- <eval expected="269560" xpath="//flow/block[23]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="color=#ffff00" xpath="//flow/block[23]/lineArea[2]/inlineparent/@background"/>
- <eval expected="225250" xpath="//flow/block[23]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="color=#ffff00" xpath="//flow/block[23]/lineArea[3]/inlineparent/@background"/>
+ <eval expected="128370" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="color=#ffff00" xpath="//flow/block[8]/lineArea[1]/inlineparent/@background"/>
+ <eval expected="269560" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="color=#ffff00" xpath="//flow/block[8]/lineArea[2]/inlineparent/@background"/>
+ <eval expected="225250" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="color=#ffff00" xpath="//flow/block[8]/lineArea[3]/inlineparent/@background"/>
- <eval expected="151184" xpath="//flow/block[26]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="color=#ffff00" xpath="//flow/block[26]/lineArea[1]/inlineparent/@background"/>
- <eval expected="81704" xpath="//flow/block[26]/lineArea[1]/inlineparent/inlineparent/@ipd"/>
- <eval expected="161644" xpath="//flow/block[26]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="color=#ffff00" xpath="//flow/block[26]/lineArea[2]/inlineparent/@background"/>
- <eval expected="67704" xpath="//flow/block[26]/lineArea[2]/inlineparent/inlineparent/@ipd"/>
+ <eval expected="151184" xpath="//flow/block[9]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="color=#ffff00" xpath="//flow/block[9]/lineArea[1]/inlineparent/@background"/>
+ <eval expected="81704" xpath="//flow/block[9]/lineArea[1]/inlineparent/inlineparent/@ipd"/>
+ <eval expected="161644" xpath="//flow/block[9]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="color=#ffff00" xpath="//flow/block[9]/lineArea[2]/inlineparent/@background"/>
+ <eval expected="67704" xpath="//flow/block[9]/lineArea[2]/inlineparent/inlineparent/@ipd"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
- <eval expected="12950" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
+ <eval expected="12950" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+ <eval expected="1925" xpath="//flow/block[1]/lineArea[1]/@space-before"/>
+ <eval expected="1925" xpath="//flow/block[1]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="2872" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[2]/@offset"/>
+
+ <eval expected="14737" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
<eval expected="1925" xpath="//flow/block[2]/lineArea[1]/@space-before"/>
<eval expected="1925" xpath="//flow/block[2]/lineArea[1]/@space-after"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[1]/@offset"/>
- <eval expected="2872" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="5487" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
- <eval expected="14737" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
+ <eval expected="17400" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+ <eval expected="1925" xpath="//flow/block[3]/lineArea[1]/@space-before"/>
+ <eval expected="1925" xpath="//flow/block[3]/lineArea[1]/@space-after"/>
+ <eval expected="4450" xpath="//flow/block[3]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="4450" xpath="//flow/block[3]/lineArea[1]/text[2]/@offset"/>
+
+ <eval expected="12950" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+ <eval expected="1925" xpath="//flow/block[4]/lineArea[1]/@space-before"/>
+ <eval expected="1925" xpath="//flow/block[4]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="2872" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[2]/@offset"/>
+
+ <eval expected="12950" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
<eval expected="1925" xpath="//flow/block[5]/lineArea[1]/@space-before"/>
<eval expected="1925" xpath="//flow/block[5]/lineArea[1]/@space-after"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
- <eval expected="5487" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="2872" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
- <eval expected="17400" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
+ <eval expected="13078" xpath="//flow/block[6]/lineArea[1]/@bpd"/>
+ <eval expected="1925" xpath="//flow/block[6]/lineArea[1]/@space-before"/>
+ <eval expected="1925" xpath="//flow/block[6]/lineArea[1]/@space-after"/>
+ <eval expected="128" xpath="//flow/block[6]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="128" xpath="//flow/block[6]/lineArea[1]/text[2]/@offset"/>
+
+ <eval expected="15122" xpath="//flow/block[7]/lineArea[1]/@bpd"/>
+ <eval expected="1925" xpath="//flow/block[7]/lineArea[1]/@space-before"/>
+ <eval expected="1925" xpath="//flow/block[7]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="5872" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[1]/text[2]/@offset"/>
+
+ <eval expected="15118" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
<eval expected="1925" xpath="//flow/block[8]/lineArea[1]/@space-before"/>
<eval expected="1925" xpath="//flow/block[8]/lineArea[1]/@space-after"/>
- <eval expected="4450" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="2168" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
<eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="4450" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="12950" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
- <eval expected="1925" xpath="//flow/block[11]/lineArea[1]/@space-before"/>
- <eval expected="1925" xpath="//flow/block[11]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
- <eval expected="2872" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="12950" xpath="//flow/block[14]/lineArea[1]/@bpd"/>
- <eval expected="1925" xpath="//flow/block[14]/lineArea[1]/@space-before"/>
- <eval expected="1925" xpath="//flow/block[14]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[1]/@offset"/>
- <eval expected="2872" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="13078" xpath="//flow/block[17]/lineArea[1]/@bpd"/>
- <eval expected="1925" xpath="//flow/block[17]/lineArea[1]/@space-before"/>
- <eval expected="1925" xpath="//flow/block[17]/lineArea[1]/@space-after"/>
- <eval expected="128" xpath="//flow/block[17]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="128" xpath="//flow/block[17]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="15122" xpath="//flow/block[20]/lineArea[1]/@bpd"/>
- <eval expected="1925" xpath="//flow/block[20]/lineArea[1]/@space-before"/>
- <eval expected="1925" xpath="//flow/block[20]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[1]/text[1]/@offset"/>
- <eval expected="5872" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="15118" xpath="//flow/block[23]/lineArea[1]/@bpd"/>
- <eval expected="1925" xpath="//flow/block[23]/lineArea[1]/@space-before"/>
- <eval expected="1925" xpath="//flow/block[23]/lineArea[1]/@space-after"/>
- <eval expected="2168" xpath="//flow/block[23]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="2168" xpath="//flow/block[23]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="2168" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
- <eval expected="17162" xpath="//flow/block[26]/lineArea[1]/@bpd"/>
- <eval expected="1925" xpath="//flow/block[26]/lineArea[1]/@space-before"/>
- <eval expected="1925" xpath="//flow/block[26]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[26]/lineArea[1]/text[1]/@offset"/>
- <eval expected="7912" xpath="//flow/block[26]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[26]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="17162" xpath="//flow/block[9]/lineArea[1]/@bpd"/>
+ <eval expected="1925" xpath="//flow/block[9]/lineArea[1]/@space-before"/>
+ <eval expected="1925" xpath="//flow/block[9]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[9]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="7912" xpath="//flow/block[9]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[9]/lineArea[1]/text[2]/@offset"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
- <eval expected="16415" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
+ <eval expected="16415" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="5487" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="3528" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[2]/@offset"/>
+
+ <eval expected="14737" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[1]/@offset"/>
<eval expected="5487" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="3528" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="-3794" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/text[2]/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
- <eval expected="14737" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
- <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
- <eval expected="5487" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="21194" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+ <eval expected="8244" xpath="//flow/block[3]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="3794" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="-3794" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/text[2]/@offset"/>
+ <eval expected="8244" xpath="//flow/block[3]/lineArea[1]/text[2]/@offset"/>
+
+ <eval expected="17400" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+ <eval expected="4450" xpath="//flow/block[4]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="3528" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/text[2]/@offset"/>
+ <eval expected="4450" xpath="//flow/block[4]/lineArea[1]/text[2]/@offset"/>
+
+ <eval expected="15118" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
+ <eval expected="2168" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="-3794" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="7436" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="21194" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
- <eval expected="8244" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
- <eval expected="3794" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="-3794" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[2]/@offset"/>
- <eval expected="8244" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="2168" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
- <eval expected="17400" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
- <eval expected="4450" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="3528" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/text[2]/@offset"/>
- <eval expected="4450" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="15118" xpath="//flow/block[14]/lineArea[1]/@bpd"/>
- <eval expected="2168" xpath="//flow/block[14]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="7436" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/text[2]/@offset"/>
- <eval expected="2168" xpath="//flow/block[14]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="39060" xpath="//flow/block[17]/lineArea[1]/@bpd"/>
- <eval expected="25086" xpath="//flow/block[17]/lineArea[1]/text[1]/@offset"/>
- <eval expected="14892" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="1968" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
- <eval expected="-16860" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/text[2]/@offset"/>
- <eval expected="25086" xpath="//flow/block[17]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="39060" xpath="//flow/block[6]/lineArea[1]/@bpd"/>
+ <eval expected="25086" xpath="//flow/block[6]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="14892" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="1968" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
+ <eval expected="-16860" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/text[2]/@offset"/>
+ <eval expected="25086" xpath="//flow/block[6]/lineArea[1]/text[2]/@offset"/>
</checks>
</testcase>
+
</fo:root>
</fo>
<checks>
- <eval expected="14846" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
+ <eval expected="14846" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="1826" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="5620" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[2]/@offset"/>
+
+ <eval expected="12950" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[1]/@offset"/>
<eval expected="1826" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="5620" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="-1702" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/text[2]/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
+
+ <eval expected="12950" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="3700" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="-1750" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[2]/@offset"/>
+
+ <eval expected="13400" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="6000" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[2]/@offset"/>
<eval expected="12950" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
<eval expected="1826" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="-1702" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="3528" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/text[2]/@offset"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="12950" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
+
+ <eval expected="14918" xpath="//flow/block[6]/lineArea[1]/@bpd"/>
+ <eval expected="1968" xpath="//flow/block[6]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="3794" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="-3794" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/text[2]/@offset"/>
+ <eval expected="1968" xpath="//flow/block[6]/lineArea[1]/text[2]/@offset"/>
+
+ <eval expected="12950" xpath="//flow/block[7]/lineArea[1]/@bpd"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="3700" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="-2992" xpath="//flow/block[7]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[1]/text[2]/@offset"/>
+
+ <eval expected="17708" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
<eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
- <eval expected="3700" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="-1750" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="10308" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
<eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[2]/@offset"/>
<eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="13400" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="6000" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="12950" xpath="//flow/block[14]/lineArea[1]/@bpd"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[1]/@offset"/>
- <eval expected="1826" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="3528" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="14918" xpath="//flow/block[17]/lineArea[1]/@bpd"/>
- <eval expected="1968" xpath="//flow/block[17]/lineArea[1]/text[1]/@offset"/>
- <eval expected="3794" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="-3794" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/text[2]/@offset"/>
- <eval expected="1968" xpath="//flow/block[17]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="12950" xpath="//flow/block[20]/lineArea[1]/@bpd"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[1]/text[1]/@offset"/>
- <eval expected="3700" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="-2992" xpath="//flow/block[20]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="17708" xpath="//flow/block[23]/lineArea[1]/@bpd"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="10308" xpath="//flow/block[23]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[1]/text[2]/@offset"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="17100" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+ <eval expected="2300" xpath="//flow/block[1]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent[1]/text[1]/@offset"/>
+ <eval expected="6000" xpath="//flow/block[1]/lineArea[1]/inlineparent[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent[2]/text[1]/@offset"/>
+ <eval expected="2300" xpath="//flow/block[1]/lineArea[1]/text[2]/@offset"/>
+
<eval expected="17100" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
- <eval expected="2300" xpath="//flow/block[2]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="9700" xpath="//flow/block[2]/lineArea[1]/inlineparent[1]/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent[1]/text[1]/@offset"/>
- <eval expected="6000" xpath="//flow/block[2]/lineArea[1]/inlineparent[2]/@offset"/>
+ <eval expected="3700" xpath="//flow/block[2]/lineArea[1]/inlineparent[2]/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent[2]/text[1]/@offset"/>
- <eval expected="2300" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="17100" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
- <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
- <eval expected="9700" xpath="//flow/block[5]/lineArea[1]/inlineparent[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent[1]/text[1]/@offset"/>
- <eval expected="3700" xpath="//flow/block[5]/lineArea[1]/inlineparent[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent[2]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
- <eval expected="16892" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
- <eval expected="5792" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
- <eval expected="1436" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="16892" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="5792" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="1436" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[2]/@offset"/>
- <eval expected="23168" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
- <eval expected="8368" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
- <eval expected="3700" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="-3700" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
- <eval expected="5136" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/text[2]/@offset"/>
- <eval expected="8368" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="23168" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+ <eval expected="8368" xpath="//flow/block[4]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="3700" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="-3700" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="5136" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/text[2]/@offset"/>
+ <eval expected="8368" xpath="//flow/block[4]/lineArea[1]/text[2]/@offset"/>
- <eval expected="14800" xpath="//flow/block[14]/lineArea[1]/@bpd"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[1]/@offset"/>
- <eval expected="5792" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="-2872" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="14800" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
+ <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="5792" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="-2872" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
- <eval expected="22340" xpath="//flow/block[17]/lineArea[1]/@bpd"/>
- <eval expected="7540" xpath="//flow/block[17]/lineArea[1]/text[1]/@offset"/>
- <eval expected="2872" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="-2872" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
- <eval expected="5550" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/text[2]/@offset"/>
- <eval expected="7540" xpath="//flow/block[17]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="22340" xpath="//flow/block[6]/lineArea[1]/@bpd"/>
+ <eval expected="7540" xpath="//flow/block[6]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="2872" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="-2872" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="5550" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/inlineparent/text/@offset"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/text[2]/@offset"/>
+ <eval expected="7540" xpath="//flow/block[6]/lineArea[1]/text[2]/@offset"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
- <eval expected="48350" xpath="//flow/block[2]/lineArea/inlineparent/@ipd"/>
- <eval expected="50350" xpath="//flow/block[2]/lineArea/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[2]/lineArea/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/inlineparent/@border-start"/>
+ <eval expected="48350" xpath="//flow/block[1]/lineArea/inlineparent/@ipd"/>
+ <eval expected="50350" xpath="//flow/block[1]/lineArea/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/inlineparent/@border-start"/>
- <eval expected="208190" xpath="//flow/block[5]/lineArea/inlineparent/@ipd"/>
- <eval expected="228190" xpath="//flow/block[5]/lineArea/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[5]/lineArea/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/inlineparent/@border-start"/>
- <eval expected="5000" xpath="//flow/block[5]/lineArea/inlineparent/@padding-after"/>
- <eval expected="5000" xpath="//flow/block[5]/lineArea/inlineparent/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[5]/lineArea/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[5]/lineArea/inlineparent/@padding-start"/>
+ <eval expected="208190" xpath="//flow/block[2]/lineArea/inlineparent/@ipd"/>
+ <eval expected="228190" xpath="//flow/block[2]/lineArea/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[2]/lineArea/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/inlineparent/@border-start"/>
+ <eval expected="5000" xpath="//flow/block[2]/lineArea/inlineparent/@padding-after"/>
+ <eval expected="5000" xpath="//flow/block[2]/lineArea/inlineparent/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[2]/lineArea/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[2]/lineArea/inlineparent/@padding-start"/>
- <eval expected="151170" xpath="//flow/block[8]/lineArea/inlineparent/@ipd"/>
- <eval expected="163170" xpath="//flow/block[8]/lineArea/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[8]/lineArea/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[8]/lineArea/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[8]/lineArea/inlineparent/@border-start"/>
- <eval expected="3000" xpath="//flow/block[8]/lineArea/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[8]/lineArea/inlineparent/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[8]/lineArea/inlineparent/@padding-end"/>
- <eval expected="4000" xpath="//flow/block[8]/lineArea/inlineparent/@padding-start"/>
+ <eval expected="151170" xpath="//flow/block[3]/lineArea/inlineparent/@ipd"/>
+ <eval expected="163170" xpath="//flow/block[3]/lineArea/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[3]/lineArea/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[3]/lineArea/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[3]/lineArea/inlineparent/@border-start"/>
+ <eval expected="3000" xpath="//flow/block[3]/lineArea/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea/inlineparent/@padding-before"/>
+ <eval expected="2000" xpath="//flow/block[3]/lineArea/inlineparent/@padding-end"/>
+ <eval expected="4000" xpath="//flow/block[3]/lineArea/inlineparent/@padding-start"/>
- <eval expected="64464" xpath="//flow/block[11]/lineArea/inlineparent/@ipd"/>
- <eval expected="84464" xpath="//flow/block[11]/lineArea/inlineparent/@ipda"/>
- <eval expected="8616" xpath="//flow/block[11]/lineArea/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/inlineparent/@border-start"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea/inlineparent/@padding-after"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea/inlineparent/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea/inlineparent/@padding-start"/>
+ <eval expected="64464" xpath="//flow/block[4]/lineArea/inlineparent/@ipd"/>
+ <eval expected="84464" xpath="//flow/block[4]/lineArea/inlineparent/@ipda"/>
+ <eval expected="8616" xpath="//flow/block[4]/lineArea/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/inlineparent/@border-start"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea/inlineparent/@padding-after"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea/inlineparent/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea/inlineparent/@padding-start"/>
- <eval expected="340710" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="343710" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-start"/>
- <eval expected="2000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-start"/>
- <eval expected="193840" xpath="//flow/block[14]/lineArea[4]/inlineparent/@ipd"/>
- <eval expected="196840" xpath="//flow/block[14]/lineArea[4]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[4]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[4]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[4]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[4]/inlineparent/@border-end"/>
- <eval expected="2000" xpath="//flow/block[14]/lineArea[4]/inlineparent/@padding-end"/>
+ <eval expected="340710" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="343710" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[5]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-start"/>
+ <eval expected="2000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-start"/>
+ <eval expected="193840" xpath="//flow/block[5]/lineArea[4]/inlineparent/@ipd"/>
+ <eval expected="196840" xpath="//flow/block[5]/lineArea[4]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[5]/lineArea[4]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[4]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[4]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[4]/inlineparent/@border-end"/>
+ <eval expected="2000" xpath="//flow/block[5]/lineArea[4]/inlineparent/@padding-end"/>
- <eval expected="118830" xpath="//flow/block[17]/lineArea/inlineparent/@ipd"/>
- <eval expected="126830" xpath="//flow/block[17]/lineArea/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[17]/lineArea/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[17]/lineArea/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[17]/lineArea/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[17]/lineArea/inlineparent/@border-start"/>
- <eval expected="2000" xpath="//flow/block[17]/lineArea/inlineparent/@padding-end"/>
- <eval expected="2000" xpath="//flow/block[17]/lineArea/inlineparent/@padding-start"/>
- <eval expected="78930" xpath="//flow/block[17]/lineArea/inlineparent/inlineparent/@ipd"/>
- <eval expected="84930" xpath="//flow/block[17]/lineArea/inlineparent/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea/inlineparent/inlineparent/@offset"/>
- <eval expected="(solid,#008000,1000)" xpath="//flow/block[17]/lineArea/inlineparent/inlineparent/@border-after"/>
- <eval expected="(solid,#008000,1000)" xpath="//flow/block[17]/lineArea/inlineparent/inlineparent/@border-before"/>
- <eval expected="(solid,#008000,1000)" xpath="//flow/block[17]/lineArea/inlineparent/inlineparent/@border-end"/>
- <eval expected="(solid,#008000,1000)" xpath="//flow/block[17]/lineArea/inlineparent/inlineparent/@border-start"/>
- <eval expected="2000" xpath="//flow/block[17]/lineArea/inlineparent/inlineparent/@padding-end"/>
- <eval expected="2000" xpath="//flow/block[17]/lineArea/inlineparent/inlineparent/@padding-start"/>
+ <eval expected="118830" xpath="//flow/block[6]/lineArea/inlineparent/@ipd"/>
+ <eval expected="126830" xpath="//flow/block[6]/lineArea/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[6]/lineArea/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[6]/lineArea/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[6]/lineArea/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[6]/lineArea/inlineparent/@border-start"/>
+ <eval expected="2000" xpath="//flow/block[6]/lineArea/inlineparent/@padding-end"/>
+ <eval expected="2000" xpath="//flow/block[6]/lineArea/inlineparent/@padding-start"/>
+ <eval expected="78930" xpath="//flow/block[6]/lineArea/inlineparent/inlineparent/@ipd"/>
+ <eval expected="84930" xpath="//flow/block[6]/lineArea/inlineparent/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea/inlineparent/inlineparent/@offset"/>
+ <eval expected="(solid,#008000,1000)" xpath="//flow/block[6]/lineArea/inlineparent/inlineparent/@border-after"/>
+ <eval expected="(solid,#008000,1000)" xpath="//flow/block[6]/lineArea/inlineparent/inlineparent/@border-before"/>
+ <eval expected="(solid,#008000,1000)" xpath="//flow/block[6]/lineArea/inlineparent/inlineparent/@border-end"/>
+ <eval expected="(solid,#008000,1000)" xpath="//flow/block[6]/lineArea/inlineparent/inlineparent/@border-start"/>
+ <eval expected="2000" xpath="//flow/block[6]/lineArea/inlineparent/inlineparent/@padding-end"/>
+ <eval expected="2000" xpath="//flow/block[6]/lineArea/inlineparent/inlineparent/@padding-start"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="347000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@ipd"/>
+ <eval expected="350000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@ipda"/>
+ <eval expected="3000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@border-start"/>
+ <eval expected="2000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@padding-after"/>
+ <eval expected="2000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@padding-before"/>
+ <eval expected="2000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@padding-start"/>
+ <eval expected="46130" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="49130" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="2000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="2000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="2000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-end"/>
+
+ <eval expected="54470" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="57470" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="3000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="2000" xpath="//flow/block[2]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="2000" xpath="//flow/block[2]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="2000" xpath="//flow/block[2]/lineArea[1]/inlineparent/@padding-start"/>
<eval expected="347000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@ipd"/>
<eval expected="350000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@ipda"/>
- <eval expected="3000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-start"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-end"/>
<eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-after"/>
<eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-start"/>
- <eval expected="46130" xpath="//flow/block[2]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="49130" xpath="//flow/block[2]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="2000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="2000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-end"/>
-
- <eval expected="54470" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="57470" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="2000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="2000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="347000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@ipd"/>
- <eval expected="350000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@ipda"/>
- <eval expected="3000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@border-end"/>
- <eval expected="2000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@padding-after"/>
- <eval expected="2000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@padding-end"/>
+ <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-end"/>
- <eval expected="54470" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="57470" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="350000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@ipd"/>
- <eval expected="350000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@ipda"/>
- <eval expected="2000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@border-before"/>
- <eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@padding-before"/>
- <eval expected="46130" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="49130" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-end"/>
+ <eval expected="54470" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="57470" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="2000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="2000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="350000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@ipd"/>
+ <eval expected="350000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@ipda"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@border-before"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@padding-before"/>
+ <eval expected="46130" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="49130" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="2000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-end"/>
</checks>
</testcase>
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
- Copyright 2005 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$ -->
-<testcase>
- <info>
- <p>
- This test checks fo:inlines with border and padding properties and nested inner blocks.
- </p>
- </info>
- <fo>
- <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
- <fo:layout-master-set>
- <fo:simple-page-master master-name="normal" page-width="5in" page-height="5in" margin="5pt">
- <fo:region-body/>
- </fo:simple-page-master>
- </fo:layout-master-set>
- <fo:page-sequence master-reference="normal" white-space-collapse="true" language="en">
- <fo:flow flow-name="xsl-region-body" font-size="10pt">
- <fo:block background-color="silver" margin="3pt 0pt 3pt 0pt">
- Before inline
- <fo:inline
- border="solid 1pt red"
- border-start-width.length="1pt"
- border-start-width.conditionality="retain"
- border-end-width.length="1pt"
- border-end-width.conditionality="retain"
- padding="2pt"
- padding-start.length="2pt"
- padding-start.conditionality="retain"
- padding-end.length="2pt"
- padding-end.conditionality="retain"
- background-color="yellow"><fo:block>starting with a block</fo:block>
- after block</fo:inline>
- After inline with conditionality="retain"
- </fo:block>
- <fo:block background-color="silver" margin="3pt 0pt 3pt 0pt">
- Before inline
- <fo:inline
- border="solid 1pt red"
- border-start-width.length="1pt"
- border-start-width.conditionality="retain"
- border-end-width.length="1pt"
- border-end-width.conditionality="retain"
- padding="2pt"
- padding-start.length="2pt"
- padding-start.conditionality="retain"
- padding-end.length="2pt"
- padding-end.conditionality="retain"
- background-color="yellow">before block
- <fo:block>having a block at the end of an inline</fo:block></fo:inline>
- After inline with conditionality="retain"
- </fo:block>
- <fo:block background-color="silver" margin="3pt 0pt 3pt 0pt">
- Before inline
- <fo:inline
- border="solid 1pt red"
- border-start-width.length="1pt"
- border-start-width.conditionality="retain"
- border-end-width.length="1pt"
- border-end-width.conditionality="retain"
- padding="2pt"
- padding-start.length="2pt"
- padding-start.conditionality="retain"
- padding-end.length="2pt"
- padding-end.conditionality="retain"
- background-color="yellow">before block
- <fo:block>As far as the laws of mathematics refer to reality, they are not certain,
- and as far as they are certain, they do not refer to reality - Albert Einstein</fo:block>
- after block</fo:inline>
- After inline with conditionality="retain"
- </fo:block>
- </fo:flow>
- </fo:page-sequence>
- </fo:root>
- </fo>
- <checks>
- <eval expected="344000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@ipd"/>
- <eval expected="350000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@ipda"/>
- <eval expected="3000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-start"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-end"/>
- <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-after"/>
- <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-start"/>
- <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-end"/>
- <eval expected="46130" xpath="//flow/block[2]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="52130" xpath="//flow/block[2]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[3]/inlineparent/@border-start"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="2000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="2000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-start"/>
- <eval expected="2000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-end"/>
-
- <eval expected="54470" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="60470" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-end"/>
- <eval expected="2000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="2000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="2000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-end"/>
- <eval expected="344000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@ipd"/>
- <eval expected="350000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@ipda"/>
- <eval expected="3000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@border-start"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@border-end"/>
- <eval expected="2000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@padding-after"/>
- <eval expected="2000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@padding-start"/>
- <eval expected="2000" xpath="//flow/block[5]/lineArea[2]/inlineblockparent/@padding-end"/>
-
- <eval expected="54470" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="60470" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-end"/>
- <eval expected="2000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="2000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="2000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-end"/>
- <eval expected="344000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@ipd"/>
- <eval expected="350000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@ipda"/>
- <eval expected="3000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@border-start"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@border-end"/>
- <eval expected="2000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@padding-after"/>
- <eval expected="2000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@padding-start"/>
- <eval expected="2000" xpath="//flow/block[8]/lineArea[2]/inlineblockparent/@padding-end"/>
- <eval expected="46130" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="52130" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-start"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="2000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="2000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-start"/>
- <eval expected="2000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-end"/>
-
- </checks>
-</testcase>
+<?xml version="1.0" encoding="UTF-8"?>\r
+<!--\r
+ Copyright 2005 The Apache Software Foundation\r
+\r
+ Licensed under the Apache License, Version 2.0 (the "License");\r
+ you may not use this file except in compliance with the License.\r
+ You may obtain a copy of the License at\r
+\r
+ http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+ Unless required by applicable law or agreed to in writing, software\r
+ distributed under the License is distributed on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ See the License for the specific language governing permissions and\r
+ limitations under the License.\r
+-->\r
+<!-- $Id$ -->\r
+<testcase>\r
+ <info>\r
+ <p>\r
+ This test checks fo:inlines with border and padding properties and nested inner blocks.\r
+ </p>\r
+ </info>\r
+ <fo>\r
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">\r
+ <fo:layout-master-set>\r
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="5in" margin="5pt">\r
+ <fo:region-body/>\r
+ </fo:simple-page-master>\r
+ </fo:layout-master-set>\r
+ <fo:page-sequence master-reference="normal" white-space-collapse="true" language="en">\r
+ <fo:flow flow-name="xsl-region-body" font-size="10pt">\r
+ <fo:block background-color="silver" margin="3pt 0pt 3pt 0pt">\r
+ Before inline\r
+ <fo:inline \r
+ border="solid 1pt red" \r
+ border-start-width.length="1pt" \r
+ border-start-width.conditionality="retain" \r
+ border-end-width.length="1pt" \r
+ border-end-width.conditionality="retain" \r
+ padding="2pt"\r
+ padding-start.length="2pt" \r
+ padding-start.conditionality="retain" \r
+ padding-end.length="2pt" \r
+ padding-end.conditionality="retain" \r
+ background-color="yellow"><fo:block>starting with a block</fo:block>\r
+ after block</fo:inline>\r
+ After inline with conditionality="retain"\r
+ </fo:block>\r
+ <fo:block background-color="silver" margin="3pt 0pt 3pt 0pt">\r
+ Before inline\r
+ <fo:inline \r
+ border="solid 1pt red" \r
+ border-start-width.length="1pt" \r
+ border-start-width.conditionality="retain" \r
+ border-end-width.length="1pt" \r
+ border-end-width.conditionality="retain" \r
+ padding="2pt"\r
+ padding-start.length="2pt" \r
+ padding-start.conditionality="retain" \r
+ padding-end.length="2pt" \r
+ padding-end.conditionality="retain" \r
+ background-color="yellow">before block\r
+ <fo:block>having a block at the end of an inline</fo:block></fo:inline>\r
+ After inline with conditionality="retain"\r
+ </fo:block>\r
+ <fo:block background-color="silver" margin="3pt 0pt 3pt 0pt">\r
+ Before inline\r
+ <fo:inline \r
+ border="solid 1pt red"\r
+ border-start-width.length="1pt" \r
+ border-start-width.conditionality="retain" \r
+ border-end-width.length="1pt" \r
+ border-end-width.conditionality="retain" \r
+ padding="2pt"\r
+ padding-start.length="2pt" \r
+ padding-start.conditionality="retain" \r
+ padding-end.length="2pt" \r
+ padding-end.conditionality="retain" \r
+ background-color="yellow">before block\r
+ <fo:block>As far as the laws of mathematics refer to reality, they are not certain,\r
+ and as far as they are certain, they do not refer to reality - Albert Einstein</fo:block>\r
+ after block</fo:inline>\r
+ After inline with conditionality="retain"\r
+ </fo:block>\r
+ </fo:flow>\r
+ </fo:page-sequence>\r
+ </fo:root>\r
+ </fo>\r
+ <checks>\r
+ <eval expected="344000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@ipd"/>\r
+ <eval expected="350000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@ipda"/>\r
+ <eval expected="3000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@offset"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@border-after"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@border-before"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@border-start"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@border-end"/>\r
+ <eval expected="2000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@padding-after"/>\r
+ <eval expected="2000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@padding-before"/>\r
+ <eval expected="2000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@padding-start"/>\r
+ <eval expected="2000" xpath="//flow/block[1]/lineArea[2]/inlineblockparent/@padding-end"/>\r
+ <eval expected="46130" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipd"/>\r
+ <eval expected="52130" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipda"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-after"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-before"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-start"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-end"/>\r
+ <eval expected="2000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-after"/>\r
+ <eval expected="2000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-before"/>\r
+ <eval expected="2000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-start"/>\r
+ <eval expected="2000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-end"/>\r
+\r
+ <eval expected="54470" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipd"/>\r
+ <eval expected="60470" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipda"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[1]/inlineparent/@border-after"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[1]/inlineparent/@border-before"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[1]/inlineparent/@border-start"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[1]/inlineparent/@border-end"/>\r
+ <eval expected="2000" xpath="//flow/block[2]/lineArea[1]/inlineparent/@padding-after"/>\r
+ <eval expected="2000" xpath="//flow/block[2]/lineArea[1]/inlineparent/@padding-before"/>\r
+ <eval expected="2000" xpath="//flow/block[2]/lineArea[1]/inlineparent/@padding-start"/>\r
+ <eval expected="2000" xpath="//flow/block[2]/lineArea[1]/inlineparent/@padding-end"/>\r
+ <eval expected="344000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@ipd"/>\r
+ <eval expected="350000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@ipda"/>\r
+ <eval expected="3000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@offset"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-after"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-before"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-start"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@border-end"/>\r
+ <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-after"/>\r
+ <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-before"/>\r
+ <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-start"/>\r
+ <eval expected="2000" xpath="//flow/block[2]/lineArea[2]/inlineblockparent/@padding-end"/>\r
+ \r
+ <eval expected="54470" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipd"/>\r
+ <eval expected="60470" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipda"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-after"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-before"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-start"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-end"/>\r
+ <eval expected="2000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-after"/>\r
+ <eval expected="2000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-before"/>\r
+ <eval expected="2000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-start"/>\r
+ <eval expected="2000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-end"/>\r
+ <eval expected="344000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@ipd"/>\r
+ <eval expected="350000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@ipda"/>\r
+ <eval expected="3000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@offset"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@border-after"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@border-before"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@border-start"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@border-end"/>\r
+ <eval expected="2000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@padding-after"/>\r
+ <eval expected="2000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@padding-before"/>\r
+ <eval expected="2000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@padding-start"/>\r
+ <eval expected="2000" xpath="//flow/block[3]/lineArea[2]/inlineblockparent/@padding-end"/>\r
+ <eval expected="46130" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipd"/>\r
+ <eval expected="52130" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipda"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-after"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-before"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-start"/>\r
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-end"/>\r
+ <eval expected="2000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-after"/>\r
+ <eval expected="2000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-before"/>\r
+ <eval expected="2000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-start"/>\r
+ <eval expected="2000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-end"/>\r
+ \r
+ </checks>\r
+</testcase>\r
</fo:root>
</fo>
<checks>
+ <eval expected="255100" xpath="//flow/block[1]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="265100" xpath="//flow/block[1]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="335720" xpath="//flow/block[1]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="345720" xpath="//flow/block[1]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[2]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-start"/>
+ <eval expected="35570" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="45570" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-start"/>
+
<eval expected="255100" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipd"/>
<eval expected="265100" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
<eval expected="3000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-end"/>
<eval expected="5000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-start"/>
+ <eval expected="259229" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="269229" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="340000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="350000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[2]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-start"/>
+ <eval expected="35570" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="45570" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-start"/>
+
+ <eval expected="216190" xpath="//flow/block[4]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="226190" xpath="//flow/block[4]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="299050" xpath="//flow/block[4]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="309050" xpath="//flow/block[4]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[2]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-start"/>
+ <eval expected="111150" xpath="//flow/block[4]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="121150" xpath="//flow/block[4]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-start"/>
+
<eval expected="255100" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="265100" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="261100" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-end"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-end"/>
<eval expected="5000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-start"/>
<eval expected="335720" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="345720" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="335720" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[2]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-start"/>
<eval expected="35570" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="45570" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="39570" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[3]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-before"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-before"/>
<eval expected="3000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-start"/>
- <eval expected="259229" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="269229" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="255100" xpath="//flow/block[6]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="261100" xpath="//flow/block[6]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="335720" xpath="//flow/block[6]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="335720" xpath="//flow/block[6]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[2]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="35570" xpath="//flow/block[6]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="39570" xpath="//flow/block[6]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-end"/>
+
+ <eval expected="262613" xpath="//flow/block[7]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="268613" xpath="//flow/block[7]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="350000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="350000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[2]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="1000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="35570" xpath="//flow/block[7]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="39570" xpath="//flow/block[7]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="1000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-end"/>
+
+ <eval expected="216190" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="222190" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-end"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-end"/>
<eval expected="5000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="340000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="350000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="310170" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="310170" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[8]/lineArea[2]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-start"/>
- <eval expected="35570" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="45570" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="100030" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="104030" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[8]/lineArea[3]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-before"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-before"/>
<eval expected="3000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-start"/>
-
- <eval expected="216190" xpath="//flow/block[11]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="226190" xpath="//flow/block[11]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="299050" xpath="//flow/block[11]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="309050" xpath="//flow/block[11]/lineArea[2]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[2]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-start"/>
- <eval expected="111150" xpath="//flow/block[11]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="121150" xpath="//flow/block[11]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-start"/>
-
- <eval expected="255100" xpath="//flow/block[14]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="261100" xpath="//flow/block[14]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="335720" xpath="//flow/block[14]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="335720" xpath="//flow/block[14]/lineArea[2]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[2]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="35570" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="39570" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-end"/>
-
- <eval expected="255100" xpath="//flow/block[17]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="261100" xpath="//flow/block[17]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="335720" xpath="//flow/block[17]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="335720" xpath="//flow/block[17]/lineArea[2]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[2]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="35570" xpath="//flow/block[17]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="39570" xpath="//flow/block[17]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-end"/>
-
- <eval expected="262613" xpath="//flow/block[20]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="268613" xpath="//flow/block[20]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="350000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="350000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[2]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="1000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="35570" xpath="//flow/block[20]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="39570" xpath="//flow/block[20]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="1000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-end"/>
-
- <eval expected="216190" xpath="//flow/block[23]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="222190" xpath="//flow/block[23]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="310170" xpath="//flow/block[23]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="310170" xpath="//flow/block[23]/lineArea[2]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[2]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="1000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="100030" xpath="//flow/block[23]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="104030" xpath="//flow/block[23]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="1000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-end"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="255100" xpath="//flow/block[1]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="264100" xpath="//flow/block[1]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="335720" xpath="//flow/block[1]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="343720" xpath="//flow/block[1]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[2]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-start"/>
+ <eval expected="35570" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="44570" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-start"/>
+
<eval expected="255100" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipd"/>
<eval expected="264100" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
<eval expected="3000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-end"/>
<eval expected="5000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-start"/>
- <eval expected="255100" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="264100" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="260075" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="269075" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="342000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="350000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[2]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-start"/>
+ <eval expected="35570" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="44570" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-start"/>
+
+ <eval expected="237870" xpath="//flow/block[4]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="246870" xpath="//flow/block[4]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="317940" xpath="//flow/block[4]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="325940" xpath="//flow/block[4]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[2]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-start"/>
+ <eval expected="70580" xpath="//flow/block[4]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="79580" xpath="//flow/block[4]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-start"/>
+
+ <eval expected="183960" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="193960" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-end"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-before"/>
<eval expected="3000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-end"/>
<eval expected="5000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="335720" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="343720" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="255680" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="265680" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[2]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-before"/>
<eval expected="3000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-end"/>
<eval expected="5000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-start"/>
- <eval expected="35570" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="44570" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="186750" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="196750" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[3]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-before"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-before"/>
<eval expected="3000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-end"/>
<eval expected="5000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-start"/>
- <eval expected="260075" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="269075" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="342000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="350000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[2]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-start"/>
- <eval expected="35570" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="44570" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-start"/>
-
- <eval expected="237870" xpath="//flow/block[11]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="246870" xpath="//flow/block[11]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="317940" xpath="//flow/block[11]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="325940" xpath="//flow/block[11]/lineArea[2]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[2]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-start"/>
- <eval expected="70580" xpath="//flow/block[11]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="79580" xpath="//flow/block[11]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-start"/>
-
- <eval expected="183960" xpath="//flow/block[14]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="193960" xpath="//flow/block[14]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="255680" xpath="//flow/block[14]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="265680" xpath="//flow/block[14]/lineArea[2]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[2]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-start"/>
- <eval expected="186750" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="196750" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-start"/>
-
- <eval expected="172840" xpath="//flow/block[17]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="178840" xpath="//flow/block[17]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="266800" xpath="//flow/block[17]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="266800" xpath="//flow/block[17]/lineArea[2]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[2]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="186750" xpath="//flow/block[17]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="190750" xpath="//flow/block[17]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-end"/>
+ <eval expected="172840" xpath="//flow/block[6]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="178840" xpath="//flow/block[6]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="266800" xpath="//flow/block[6]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="266800" xpath="//flow/block[6]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[2]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="186750" xpath="//flow/block[6]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="190750" xpath="//flow/block[6]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-end"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="255100" xpath="//flow/block[1]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="261100" xpath="//flow/block[1]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="335720" xpath="//flow/block[1]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="335720" xpath="//flow/block[1]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[2]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="35570" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="39570" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-end"/>
+
<eval expected="255100" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipd"/>
<eval expected="261100" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
<eval expected="1000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-before"/>
<eval expected="3000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-end"/>
+ <eval expected="262613" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="268613" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="350000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="350000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[2]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="35570" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="39570" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-end"/>
+
+ <eval expected="216190" xpath="//flow/block[4]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="222190" xpath="//flow/block[4]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="310170" xpath="//flow/block[4]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="310170" xpath="//flow/block[4]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[2]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="100030" xpath="//flow/block[4]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="104030" xpath="//flow/block[4]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-end"/>
+
<eval expected="255100" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="261100" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="265100" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-end"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-end"/>
<eval expected="5000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-start"/>
<eval expected="335720" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="335720" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="345720" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[2]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-start"/>
<eval expected="35570" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="39570" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="45570" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[3]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-before"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-before"/>
<eval expected="3000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-start"/>
+
+ <eval expected="255100" xpath="//flow/block[6]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="265100" xpath="//flow/block[6]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="335720" xpath="//flow/block[6]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="345720" xpath="//flow/block[6]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[2]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-start"/>
+ <eval expected="35570" xpath="//flow/block[6]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="45570" xpath="//flow/block[6]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-start"/>
+
+ <eval expected="259229" xpath="//flow/block[7]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="269229" xpath="//flow/block[7]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="340000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="350000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[2]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-start"/>
+ <eval expected="35570" xpath="//flow/block[7]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="45570" xpath="//flow/block[7]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-start"/>
- <eval expected="262613" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="268613" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="216190" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="226190" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-end"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-end"/>
<eval expected="5000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="350000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="350000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="299050" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="309050" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[8]/lineArea[2]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="35570" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="39570" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="3000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-start"/>
+ <eval expected="111150" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="121150" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[8]/lineArea[3]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-before"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-before"/>
<eval expected="3000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-end"/>
-
- <eval expected="216190" xpath="//flow/block[11]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="222190" xpath="//flow/block[11]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="310170" xpath="//flow/block[11]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="310170" xpath="//flow/block[11]/lineArea[2]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[2]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="100030" xpath="//flow/block[11]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="104030" xpath="//flow/block[11]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-end"/>
-
- <eval expected="255100" xpath="//flow/block[14]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="265100" xpath="//flow/block[14]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="335720" xpath="//flow/block[14]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="345720" xpath="//flow/block[14]/lineArea[2]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[2]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-start"/>
- <eval expected="35570" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="45570" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-start"/>
-
- <eval expected="255100" xpath="//flow/block[17]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="265100" xpath="//flow/block[17]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="335720" xpath="//flow/block[17]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="345720" xpath="//flow/block[17]/lineArea[2]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[2]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-start"/>
- <eval expected="35570" xpath="//flow/block[17]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="45570" xpath="//flow/block[17]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-start"/>
-
- <eval expected="259229" xpath="//flow/block[20]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="269229" xpath="//flow/block[20]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="340000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="350000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[2]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-start"/>
- <eval expected="35570" xpath="//flow/block[20]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="45570" xpath="//flow/block[20]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-start"/>
-
- <eval expected="216190" xpath="//flow/block[23]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="226190" xpath="//flow/block[23]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="299050" xpath="//flow/block[23]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="309050" xpath="//flow/block[23]/lineArea[2]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[2]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-start"/>
- <eval expected="111150" xpath="//flow/block[23]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="121150" xpath="//flow/block[23]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-start"/>
+ <eval expected="5000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-start"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="250110" xpath="//flow/block[1]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="256110" xpath="//flow/block[1]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[1]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="348490" xpath="//flow/block[1]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="348490" xpath="//flow/block[1]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[2]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="91710" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="95710" xpath="//flow/block[1]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[1]/lineArea[3]/inlineparent/@padding-end"/>
+
<eval expected="250110" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipd"/>
<eval expected="256110" xpath="//flow/block[2]/lineArea[1]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
<eval expected="1000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-before"/>
<eval expected="3000" xpath="//flow/block[2]/lineArea[3]/inlineparent/@padding-end"/>
+ <eval expected="250110" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="256110" xpath="//flow/block[3]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[3]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="349999" xpath="//flow/block[3]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="349999" xpath="//flow/block[3]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[2]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="91710" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="95710" xpath="//flow/block[3]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[3]/lineArea[3]/inlineparent/@padding-end"/>
+
+ <eval expected="238440" xpath="//flow/block[4]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="244440" xpath="//flow/block[4]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="320690" xpath="//flow/block[4]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="320690" xpath="//flow/block[4]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[2]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="131180" xpath="//flow/block[4]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="135180" xpath="//flow/block[4]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[4]/lineArea[3]/inlineparent/@padding-end"/>
+
<eval expected="250110" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="256110" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="260110" xpath="//flow/block[5]/lineArea[1]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-end"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[1]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-end"/>
<eval expected="5000" xpath="//flow/block[5]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="348490" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="348490" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="336820" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="346820" xpath="//flow/block[5]/lineArea[2]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[2]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[2]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="91710" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="95710" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="3000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[5]/lineArea[2]/inlineparent/@padding-start"/>
+ <eval expected="103380" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="113380" xpath="//flow/block[5]/lineArea[3]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[3]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-before"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[5]/lineArea[3]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-before"/>
<eval expected="3000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[5]/lineArea[3]/inlineparent/@padding-start"/>
+
+ <eval expected="250110" xpath="//flow/block[6]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="260110" xpath="//flow/block[6]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[6]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="336820" xpath="//flow/block[6]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="346820" xpath="//flow/block[6]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[2]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[2]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[6]/lineArea[2]/inlineparent/@padding-start"/>
+ <eval expected="103380" xpath="//flow/block[6]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="113380" xpath="//flow/block[6]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[6]/lineArea[3]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[6]/lineArea[3]/inlineparent/@padding-start"/>
+
+ <eval expected="250110" xpath="//flow/block[7]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="260110" xpath="//flow/block[7]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[1]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[7]/lineArea[1]/inlineparent/@padding-start"/>
+ <eval expected="340000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="350000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[2]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[2]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[7]/lineArea[2]/inlineparent/@padding-start"/>
+ <eval expected="103380" xpath="//flow/block[7]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="113380" xpath="//flow/block[7]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[3]/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[7]/lineArea[3]/inlineparent/@border-start"/>
+ <eval expected="1000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[7]/lineArea[3]/inlineparent/@padding-start"/>
- <eval expected="250110" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="256110" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipda"/>
+ <eval expected="238440" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipd"/>
+ <eval expected="248440" xpath="//flow/block[8]/lineArea[1]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-end"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[1]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-before"/>
+ <eval expected="3000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-end"/>
<eval expected="5000" xpath="//flow/block[8]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="349999" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="349999" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipda"/>
+ <eval expected="320690" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipd"/>
+ <eval expected="330690" xpath="//flow/block[8]/lineArea[2]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[8]/lineArea[2]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[2]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="91710" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="95710" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipda"/>
+ <eval expected="3000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[8]/lineArea[2]/inlineparent/@padding-start"/>
+ <eval expected="131180" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipd"/>
+ <eval expected="141180" xpath="//flow/block[8]/lineArea[3]/inlineparent/@ipda"/>
<eval expected="0" xpath="//flow/block[8]/lineArea[3]/inlineparent/@offset"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-after"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-before"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea[3]/inlineparent/@border-start"/>
<eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-after"/>
<eval expected="1000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-before"/>
<eval expected="3000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-end"/>
-
- <eval expected="238440" xpath="//flow/block[11]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="244440" xpath="//flow/block[11]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="320690" xpath="//flow/block[11]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="320690" xpath="//flow/block[11]/lineArea[2]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[2]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="131180" xpath="//flow/block[11]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="135180" xpath="//flow/block[11]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[11]/lineArea[3]/inlineparent/@padding-end"/>
-
- <eval expected="250110" xpath="//flow/block[14]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="260110" xpath="//flow/block[14]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[14]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="336820" xpath="//flow/block[14]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="346820" xpath="//flow/block[14]/lineArea[2]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[2]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[2]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[14]/lineArea[2]/inlineparent/@padding-start"/>
- <eval expected="103380" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="113380" xpath="//flow/block[14]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea[3]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[14]/lineArea[3]/inlineparent/@padding-start"/>
-
- <eval expected="250110" xpath="//flow/block[17]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="260110" xpath="//flow/block[17]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[17]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="336820" xpath="//flow/block[17]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="346820" xpath="//flow/block[17]/lineArea[2]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[2]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[2]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[17]/lineArea[2]/inlineparent/@padding-start"/>
- <eval expected="103380" xpath="//flow/block[17]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="113380" xpath="//flow/block[17]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[17]/lineArea[3]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[17]/lineArea[3]/inlineparent/@padding-start"/>
-
- <eval expected="250110" xpath="//flow/block[20]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="260110" xpath="//flow/block[20]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[20]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="340000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="350000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[2]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[2]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[20]/lineArea[2]/inlineparent/@padding-start"/>
- <eval expected="103380" xpath="//flow/block[20]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="113380" xpath="//flow/block[20]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[20]/lineArea[3]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[20]/lineArea[3]/inlineparent/@padding-start"/>
-
- <eval expected="238440" xpath="//flow/block[23]/lineArea[1]/inlineparent/@ipd"/>
- <eval expected="248440" xpath="//flow/block[23]/lineArea[1]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[1]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[23]/lineArea[1]/inlineparent/@padding-start"/>
- <eval expected="320690" xpath="//flow/block[23]/lineArea[2]/inlineparent/@ipd"/>
- <eval expected="330690" xpath="//flow/block[23]/lineArea[2]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[2]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[2]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[23]/lineArea[2]/inlineparent/@padding-start"/>
- <eval expected="131180" xpath="//flow/block[23]/lineArea[3]/inlineparent/@ipd"/>
- <eval expected="141180" xpath="//flow/block[23]/lineArea[3]/inlineparent/@ipda"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[3]/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[23]/lineArea[3]/inlineparent/@border-start"/>
- <eval expected="1000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-before"/>
- <eval expected="3000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[23]/lineArea[3]/inlineparent/@padding-start"/>
+ <eval expected="5000" xpath="//flow/block[8]/lineArea[3]/inlineparent/@padding-start"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="12950" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+ <eval expected="1925" xpath="//flow/block[1]/lineArea[1]/@space-before"/>
+ <eval expected="1925" xpath="//flow/block[1]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="2872" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
<eval expected="12950" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
<eval expected="1925" xpath="//flow/block[2]/lineArea[1]/@space-before"/>
<eval expected="1925" xpath="//flow/block[2]/lineArea[1]/@space-after"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
<eval expected="2872" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="12950" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+ <eval expected="1925" xpath="//flow/block[3]/lineArea[1]/@space-before"/>
+ <eval expected="1925" xpath="//flow/block[3]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="3700" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
+ <eval expected="12950" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+ <eval expected="1925" xpath="//flow/block[4]/lineArea[1]/@space-before"/>
+ <eval expected="1925" xpath="//flow/block[4]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="2872" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
<eval expected="12950" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
<eval expected="1925" xpath="//flow/block[5]/lineArea[1]/@space-before"/>
<eval expected="1925" xpath="//flow/block[5]/lineArea[1]/@space-after"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="2872" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="574" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
+ <eval expected="12950" xpath="//flow/block[6]/lineArea[1]/@bpd"/>
+ <eval expected="1925" xpath="//flow/block[6]/lineArea[1]/@space-before"/>
+ <eval expected="1925" xpath="//flow/block[6]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="1436" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
+ <eval expected="12950" xpath="//flow/block[7]/lineArea[1]/@bpd"/>
+ <eval expected="1925" xpath="//flow/block[7]/lineArea[1]/@space-before"/>
+ <eval expected="1925" xpath="//flow/block[7]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="1850" xpath="//flow/block[7]/lineArea[1]/inlineparent/inlineparent/@offset"/>
<eval expected="12950" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
<eval expected="1925" xpath="//flow/block[8]/lineArea[1]/@space-before"/>
<eval expected="1925" xpath="//flow/block[8]/lineArea[1]/@space-after"/>
<eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="3700" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
- <eval expected="12950" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
- <eval expected="1925" xpath="//flow/block[11]/lineArea[1]/@space-before"/>
- <eval expected="1925" xpath="//flow/block[11]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="2872" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
- <eval expected="12950" xpath="//flow/block[14]/lineArea[1]/@bpd"/>
- <eval expected="1925" xpath="//flow/block[14]/lineArea[1]/@space-before"/>
- <eval expected="1925" xpath="//flow/block[14]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="574" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
- <eval expected="12950" xpath="//flow/block[17]/lineArea[1]/@bpd"/>
- <eval expected="1925" xpath="//flow/block[17]/lineArea[1]/@space-before"/>
- <eval expected="1925" xpath="//flow/block[17]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="1436" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
- <eval expected="12950" xpath="//flow/block[20]/lineArea[1]/@bpd"/>
- <eval expected="1925" xpath="//flow/block[20]/lineArea[1]/@space-before"/>
- <eval expected="1925" xpath="//flow/block[20]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="1850" xpath="//flow/block[20]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
- <eval expected="12950" xpath="//flow/block[23]/lineArea[1]/@bpd"/>
- <eval expected="1925" xpath="//flow/block[23]/lineArea[1]/@space-before"/>
- <eval expected="1925" xpath="//flow/block[23]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="1826" xpath="//flow/block[23]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="1826" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="12950" xpath="//flow/block[26]/lineArea[1]/@bpd"/>
- <eval expected="1925" xpath="//flow/block[26]/lineArea[1]/@space-before"/>
- <eval expected="1925" xpath="//flow/block[26]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[26]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="3700" xpath="//flow/block[26]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="12950" xpath="//flow/block[9]/lineArea[1]/@bpd"/>
+ <eval expected="1925" xpath="//flow/block[9]/lineArea[1]/@space-before"/>
+ <eval expected="1925" xpath="//flow/block[9]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[9]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="3700" xpath="//flow/block[9]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="12950" xpath="//flow/block[29]/lineArea[1]/@bpd"/>
- <eval expected="1925" xpath="//flow/block[29]/lineArea[1]/@space-before"/>
- <eval expected="1925" xpath="//flow/block[29]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[29]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[29]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="12950" xpath="//flow/block[10]/lineArea[1]/@bpd"/>
+ <eval expected="1925" xpath="//flow/block[10]/lineArea[1]/@space-before"/>
+ <eval expected="1925" xpath="//flow/block[10]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[10]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[10]/lineArea[1]/inlineparent/inlineparent/@offset"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="12950" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+ <eval expected="1375" xpath="//flow/block[1]/lineArea[1]/@space-before"/>
+ <eval expected="1375" xpath="//flow/block[1]/lineArea[1]/@space-after"/>
+ <eval expected="2872" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="-2872" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
<eval expected="12950" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
<eval expected="1375" xpath="//flow/block[2]/lineArea[1]/@space-before"/>
<eval expected="1375" xpath="//flow/block[2]/lineArea[1]/@space-after"/>
<eval expected="2872" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
<eval expected="-2872" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="12950" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+ <eval expected="1375" xpath="//flow/block[3]/lineArea[1]/@space-before"/>
+ <eval expected="1375" xpath="//flow/block[3]/lineArea[1]/@space-after"/>
+ <eval expected="3700" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="-3700" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
+ <eval expected="12950" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+ <eval expected="1375" xpath="//flow/block[4]/lineArea[1]/@space-before"/>
+ <eval expected="1375" xpath="//flow/block[4]/lineArea[1]/@space-after"/>
+ <eval expected="2872" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="-2872" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
<eval expected="12950" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
<eval expected="1375" xpath="//flow/block[5]/lineArea[1]/@space-before"/>
<eval expected="1375" xpath="//flow/block[5]/lineArea[1]/@space-after"/>
- <eval expected="2872" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="-2872" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="574" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="-574" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
+ <eval expected="12950" xpath="//flow/block[6]/lineArea[1]/@bpd"/>
+ <eval expected="1375" xpath="//flow/block[6]/lineArea[1]/@space-before"/>
+ <eval expected="1375" xpath="//flow/block[6]/lineArea[1]/@space-after"/>
+ <eval expected="1436" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="-1436" xpath="//flow/block[6]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+
+ <eval expected="12950" xpath="//flow/block[7]/lineArea[1]/@bpd"/>
+ <eval expected="1375" xpath="//flow/block[7]/lineArea[1]/@space-before"/>
+ <eval expected="1375" xpath="//flow/block[7]/lineArea[1]/@space-after"/>
+ <eval expected="1850" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="-1850" xpath="//flow/block[7]/lineArea[1]/inlineparent/inlineparent/@offset"/>
<eval expected="12950" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
<eval expected="1375" xpath="//flow/block[8]/lineArea[1]/@space-before"/>
<eval expected="1375" xpath="//flow/block[8]/lineArea[1]/@space-after"/>
- <eval expected="3700" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="-3700" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
- <eval expected="12950" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
- <eval expected="1375" xpath="//flow/block[11]/lineArea[1]/@space-before"/>
- <eval expected="1375" xpath="//flow/block[11]/lineArea[1]/@space-after"/>
- <eval expected="2872" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="-2872" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
- <eval expected="12950" xpath="//flow/block[14]/lineArea[1]/@bpd"/>
- <eval expected="1375" xpath="//flow/block[14]/lineArea[1]/@space-before"/>
- <eval expected="1375" xpath="//flow/block[14]/lineArea[1]/@space-after"/>
- <eval expected="574" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="-574" xpath="//flow/block[14]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
- <eval expected="12950" xpath="//flow/block[17]/lineArea[1]/@bpd"/>
- <eval expected="1375" xpath="//flow/block[17]/lineArea[1]/@space-before"/>
- <eval expected="1375" xpath="//flow/block[17]/lineArea[1]/@space-after"/>
- <eval expected="1436" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="-1436" xpath="//flow/block[17]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
- <eval expected="12950" xpath="//flow/block[20]/lineArea[1]/@bpd"/>
- <eval expected="1375" xpath="//flow/block[20]/lineArea[1]/@space-before"/>
- <eval expected="1375" xpath="//flow/block[20]/lineArea[1]/@space-after"/>
- <eval expected="1850" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="-1850" xpath="//flow/block[20]/lineArea[1]/inlineparent/inlineparent/@offset"/>
-
- <eval expected="12950" xpath="//flow/block[23]/lineArea[1]/@bpd"/>
- <eval expected="1375" xpath="//flow/block[23]/lineArea[1]/@space-before"/>
- <eval expected="1375" xpath="//flow/block[23]/lineArea[1]/@space-after"/>
- <eval expected="1826" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="-1826" xpath="//flow/block[23]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="1826" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="-1826" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="12950" xpath="//flow/block[26]/lineArea[1]/@bpd"/>
- <eval expected="1375" xpath="//flow/block[26]/lineArea[1]/@space-before"/>
- <eval expected="1375" xpath="//flow/block[26]/lineArea[1]/@space-after"/>
- <eval expected="3700" xpath="//flow/block[26]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="-3700" xpath="//flow/block[26]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="12950" xpath="//flow/block[9]/lineArea[1]/@bpd"/>
+ <eval expected="1375" xpath="//flow/block[9]/lineArea[1]/@space-before"/>
+ <eval expected="1375" xpath="//flow/block[9]/lineArea[1]/@space-after"/>
+ <eval expected="3700" xpath="//flow/block[9]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="-3700" xpath="//flow/block[9]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="12950" xpath="//flow/block[29]/lineArea[1]/@bpd"/>
- <eval expected="1375" xpath="//flow/block[29]/lineArea[1]/@space-before"/>
- <eval expected="1375" xpath="//flow/block[29]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[29]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[29]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="12950" xpath="//flow/block[10]/lineArea[1]/@bpd"/>
+ <eval expected="1375" xpath="//flow/block[10]/lineArea[1]/@space-before"/>
+ <eval expected="1375" xpath="//flow/block[10]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[10]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[10]/lineArea[1]/inlineparent/inlineparent/@offset"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="14800" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="5744" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="1850" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[2]/@offset"/>
+
<eval expected="14800" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[1]/@offset"/>
<eval expected="5744" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="1850" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
- <eval expected="14800" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
- <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
- <eval expected="5744" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[5]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="14800" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
- <eval expected="5744" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="-3700" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="14800" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="5744" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="-3700" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[2]/@offset"/>
- <eval expected="15018" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
- <eval expected="5744" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/text[1]/@offset"/>
- <eval expected="-1826" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="15018" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="5744" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/text[1]/@offset"/>
+ <eval expected="-1826" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/inlineparent/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[2]/@offset"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="18500" xpath="//flow/block[1]/lineArea[1]/@bpd"/>
+ <eval expected="2750" xpath="//flow/block[1]/lineArea[1]/@space-before"/>
+ <eval expected="2750" xpath="//flow/block[1]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="7180" xpath="//flow/block[1]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[1]/text[2]/@offset"/>
+
<eval expected="18500" xpath="//flow/block[2]/lineArea[1]/@bpd"/>
<eval expected="2750" xpath="//flow/block[2]/lineArea[1]/@space-before"/>
<eval expected="2750" xpath="//flow/block[2]/lineArea[1]/@space-after"/>
<eval expected="7180" xpath="//flow/block[2]/lineArea[1]/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="18500" xpath="//flow/block[3]/lineArea[1]/@bpd"/>
+ <eval expected="2750" xpath="//flow/block[3]/lineArea[1]/@space-before"/>
+ <eval expected="2750" xpath="//flow/block[3]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[1]/text[2]/@offset"/>
+
+ <eval expected="18500" xpath="//flow/block[4]/lineArea[1]/@bpd"/>
+ <eval expected="2750" xpath="//flow/block[4]/lineArea[1]/@space-before"/>
+ <eval expected="2750" xpath="//flow/block[4]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[1]/text[2]/@offset"/>
+
<eval expected="18500" xpath="//flow/block[5]/lineArea[1]/@bpd"/>
<eval expected="2750" xpath="//flow/block[5]/lineArea[1]/@space-before"/>
<eval expected="2750" xpath="//flow/block[5]/lineArea[1]/@space-after"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[1]/@offset"/>
- <eval expected="7180" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="4565" xpath="//flow/block[5]/lineArea[1]/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[1]/text[2]/@offset"/>
- <eval expected="18500" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
+ <eval expected="18500" xpath="//flow/block[6]/lineArea[1]/@bpd"/>
+ <eval expected="2750" xpath="//flow/block[6]/lineArea[1]/@space-before"/>
+ <eval expected="2750" xpath="//flow/block[6]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="9250" xpath="//flow/block[6]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[6]/lineArea[1]/text[2]/@offset"/>
+
+ <eval expected="18500" xpath="//flow/block[7]/lineArea[1]/@bpd"/>
+ <eval expected="2750" xpath="//flow/block[7]/lineArea[1]/@space-before"/>
+ <eval expected="2750" xpath="//flow/block[7]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="9250" xpath="//flow/block[7]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[7]/lineArea[1]/text[2]/@offset"/>
+
+ <eval expected="21780" xpath="//flow/block[8]/lineArea[1]/@bpd"/>
<eval expected="2750" xpath="//flow/block[8]/lineArea[1]/@space-before"/>
<eval expected="2750" xpath="//flow/block[8]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="3280" xpath="//flow/block[8]/lineArea[1]/text[1]/@offset"/>
<eval expected="0" xpath="//flow/block[8]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
+ <eval expected="3280" xpath="//flow/block[8]/lineArea[1]/text[2]/@offset"/>
+
+ <eval expected="19045" xpath="//flow/block[9]/lineArea[1]/@bpd"/>
+ <eval expected="2750" xpath="//flow/block[9]/lineArea[1]/@space-before"/>
+ <eval expected="2750" xpath="//flow/block[9]/lineArea[1]/@space-after"/>
+ <eval expected="0" xpath="//flow/block[9]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="9795" xpath="//flow/block[9]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="0" xpath="//flow/block[9]/lineArea[1]/text[2]/@offset"/>
+
+ <eval expected="28960" xpath="//flow/block[10]/lineArea[1]/@bpd"/>
+ <eval expected="2750" xpath="//flow/block[10]/lineArea[1]/@space-before"/>
+ <eval expected="2750" xpath="//flow/block[10]/lineArea[1]/@space-after"/>
+ <eval expected="10460" xpath="//flow/block[10]/lineArea[1]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[10]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="10460" xpath="//flow/block[10]/lineArea[1]/text[2]/@offset"/>
- <eval expected="18500" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
+ <eval expected="23730" xpath="//flow/block[11]/lineArea[1]/@bpd"/>
<eval expected="2750" xpath="//flow/block[11]/lineArea[1]/@space-before"/>
<eval expected="2750" xpath="//flow/block[11]/lineArea[1]/@space-after"/>
<eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
+ <eval expected="5230" xpath="//flow/block[11]/lineArea[1]/inlineparent/@offset"/>
<eval expected="0" xpath="//flow/block[11]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="18500" xpath="//flow/block[14]/lineArea[1]/@bpd"/>
- <eval expected="2750" xpath="//flow/block[14]/lineArea[1]/@space-before"/>
- <eval expected="2750" xpath="//flow/block[14]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[1]/@offset"/>
- <eval expected="4565" xpath="//flow/block[14]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="18500" xpath="//flow/block[17]/lineArea[1]/@bpd"/>
- <eval expected="2750" xpath="//flow/block[17]/lineArea[1]/@space-before"/>
- <eval expected="2750" xpath="//flow/block[17]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/text[1]/@offset"/>
- <eval expected="9250" xpath="//flow/block[17]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[17]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="18500" xpath="//flow/block[20]/lineArea[1]/@bpd"/>
- <eval expected="2750" xpath="//flow/block[20]/lineArea[1]/@space-before"/>
- <eval expected="2750" xpath="//flow/block[20]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[1]/text[1]/@offset"/>
- <eval expected="9250" xpath="//flow/block[20]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[20]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="21780" xpath="//flow/block[23]/lineArea[1]/@bpd"/>
- <eval expected="2750" xpath="//flow/block[23]/lineArea[1]/@space-before"/>
- <eval expected="2750" xpath="//flow/block[23]/lineArea[1]/@space-after"/>
- <eval expected="3280" xpath="//flow/block[23]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[23]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="3280" xpath="//flow/block[23]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="19045" xpath="//flow/block[26]/lineArea[1]/@bpd"/>
- <eval expected="2750" xpath="//flow/block[26]/lineArea[1]/@space-before"/>
- <eval expected="2750" xpath="//flow/block[26]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[26]/lineArea[1]/text[1]/@offset"/>
- <eval expected="9795" xpath="//flow/block[26]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[26]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="28960" xpath="//flow/block[29]/lineArea[1]/@bpd"/>
- <eval expected="2750" xpath="//flow/block[29]/lineArea[1]/@space-before"/>
- <eval expected="2750" xpath="//flow/block[29]/lineArea[1]/@space-after"/>
- <eval expected="10460" xpath="//flow/block[29]/lineArea[1]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[29]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="10460" xpath="//flow/block[29]/lineArea[1]/text[2]/@offset"/>
-
- <eval expected="23730" xpath="//flow/block[32]/lineArea[1]/@bpd"/>
- <eval expected="2750" xpath="//flow/block[32]/lineArea[1]/@space-before"/>
- <eval expected="2750" xpath="//flow/block[32]/lineArea[1]/@space-after"/>
- <eval expected="0" xpath="//flow/block[32]/lineArea[1]/text[1]/@offset"/>
- <eval expected="5230" xpath="//flow/block[32]/lineArea[1]/inlineparent/@offset"/>
- <eval expected="0" xpath="//flow/block[32]/lineArea[1]/text[2]/@offset"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
- <eval expected="48812" xpath="//flow/block[2]/lineArea[2]/text[1]/@offset"/>
+ <eval expected="48812" xpath="//flow/block[1]/lineArea[2]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[2]/viewport[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[2]/viewport[2]/@offset"/>
+ <eval expected="48812" xpath="//flow/block[1]/lineArea[2]/text[2]/@offset"/>
+ <eval expected="35995" xpath="//flow/block[1]/lineArea[2]/viewport[3]/@offset"/>
+ <eval expected="17998" xpath="//flow/block[1]/lineArea[2]/viewport[4]/@offset"/>
+ <eval expected="48812" xpath="//flow/block[1]/lineArea[2]/text[3]/@offset"/>
+ <eval expected="34379" xpath="//flow/block[1]/lineArea[2]/viewport[5]/@offset"/>
+ <eval expected="48812" xpath="//flow/block[1]/lineArea[2]/text[4]/@offset"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea[2]/viewport[6]/@offset"/>
+ <eval expected="48812" xpath="//flow/block[1]/lineArea[2]/text[5]/@offset"/>
+
+ <eval expected="14433" xpath="//flow/block[2]/lineArea[2]/text[1]/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[2]/viewport[1]/@offset"/>
<eval expected="0" xpath="//flow/block[2]/lineArea[2]/viewport[2]/@offset"/>
- <eval expected="48812" xpath="//flow/block[2]/lineArea[2]/text[2]/@offset"/>
+ <eval expected="14433" xpath="//flow/block[2]/lineArea[2]/text[2]/@offset"/>
<eval expected="35995" xpath="//flow/block[2]/lineArea[2]/viewport[3]/@offset"/>
<eval expected="17998" xpath="//flow/block[2]/lineArea[2]/viewport[4]/@offset"/>
- <eval expected="48812" xpath="//flow/block[2]/lineArea[2]/text[3]/@offset"/>
- <eval expected="34379" xpath="//flow/block[2]/lineArea[2]/viewport[5]/@offset"/>
- <eval expected="48812" xpath="//flow/block[2]/lineArea[2]/text[4]/@offset"/>
- <eval expected="0" xpath="//flow/block[2]/lineArea[2]/viewport[6]/@offset"/>
- <eval expected="48812" xpath="//flow/block[2]/lineArea[2]/text[5]/@offset"/>
+ <eval expected="14433" xpath="//flow/block[2]/lineArea[2]/text[3]/@offset"/>
+ <eval expected="0" xpath="//flow/block[2]/lineArea[2]/viewport[5]/@offset"/>
+ <eval expected="14433" xpath="//flow/block[2]/lineArea[2]/text[4]/@offset"/>
+
+ <eval expected="0" xpath="//flow/block[3]/lineArea[2]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[2]/viewport[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[2]/viewport[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[2]/text[2]/@offset"/>
+ <eval expected="35995" xpath="//flow/block[3]/lineArea[2]/viewport[3]/@offset"/>
+ <eval expected="17998" xpath="//flow/block[3]/lineArea[2]/viewport[4]/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea[2]/text[3]/@offset"/>
+
+ <eval expected="0" xpath="//flow/block[4]/lineArea[2]/text[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[2]/viewport[1]/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[2]/viewport[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[2]/text[2]/@offset"/>
+ <eval expected="35995" xpath="//flow/block[4]/lineArea[2]/viewport[3]/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[2]/viewport[4]/@offset"/>
+ <eval expected="0" xpath="//flow/block[4]/lineArea[2]/text[3]/@offset"/>
<eval expected="14433" xpath="//flow/block[5]/lineArea[2]/text[1]/@offset"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[2]/viewport[1]/@offset"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[2]/viewport[2]/@offset"/>
<eval expected="14433" xpath="//flow/block[5]/lineArea[2]/text[2]/@offset"/>
<eval expected="35995" xpath="//flow/block[5]/lineArea[2]/viewport[3]/@offset"/>
- <eval expected="17998" xpath="//flow/block[5]/lineArea[2]/viewport[4]/@offset"/>
+ <eval expected="0" xpath="//flow/block[5]/lineArea[2]/viewport[4]/@offset"/>
<eval expected="14433" xpath="//flow/block[5]/lineArea[2]/text[3]/@offset"/>
<eval expected="0" xpath="//flow/block[5]/lineArea[2]/viewport[5]/@offset"/>
<eval expected="14433" xpath="//flow/block[5]/lineArea[2]/text[4]/@offset"/>
-
- <eval expected="0" xpath="//flow/block[8]/lineArea[2]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[2]/viewport[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[2]/viewport[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[2]/text[2]/@offset"/>
- <eval expected="35995" xpath="//flow/block[8]/lineArea[2]/viewport[3]/@offset"/>
- <eval expected="17998" xpath="//flow/block[8]/lineArea[2]/viewport[4]/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea[2]/text[3]/@offset"/>
-
- <eval expected="0" xpath="//flow/block[11]/lineArea[2]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[2]/viewport[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[2]/viewport[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[2]/text[2]/@offset"/>
- <eval expected="35995" xpath="//flow/block[11]/lineArea[2]/viewport[3]/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[2]/viewport[4]/@offset"/>
- <eval expected="0" xpath="//flow/block[11]/lineArea[2]/text[3]/@offset"/>
-
- <eval expected="14433" xpath="//flow/block[14]/lineArea[2]/text[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[2]/viewport[1]/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[2]/viewport[2]/@offset"/>
- <eval expected="14433" xpath="//flow/block[14]/lineArea[2]/text[2]/@offset"/>
- <eval expected="35995" xpath="//flow/block[14]/lineArea[2]/viewport[3]/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[2]/viewport[4]/@offset"/>
- <eval expected="14433" xpath="//flow/block[14]/lineArea[2]/text[3]/@offset"/>
- <eval expected="0" xpath="//flow/block[14]/lineArea[2]/viewport[5]/@offset"/>
- <eval expected="14433" xpath="//flow/block[14]/lineArea[2]/text[4]/@offset"/>
</checks>
</testcase>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea/space/@border-end"/>
<eval expected="(solid,#ff0000,1000)" xpath="//flow/block[4]/lineArea/space/@border-start"/>
+ <eval expected="11100" xpath="//flow/block[6]/lineArea/@bpd"/>
+ <eval expected="360000" xpath="//flow/block[6]/lineArea/@ipd"/>
+ <eval expected="16000" xpath="//flow/block[6]/lineArea/inlineparent/@ipd"/>
+ <eval expected="36000" xpath="//flow/block[6]/lineArea/inlineparent/@ipda"/>
+ <eval expected="5280" xpath="//flow/block[6]/lineArea/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[6]/lineArea/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[6]/lineArea/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[6]/lineArea/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[6]/lineArea/inlineparent/@border-start"/>
+ <eval expected="5000" xpath="//flow/block[6]/lineArea/inlineparent/@padding-after"/>
+ <eval expected="5000" xpath="//flow/block[6]/lineArea/inlineparent/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[6]/lineArea/inlineparent/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[6]/lineArea/inlineparent/@padding-start"/>
+
<eval expected="11100" xpath="//flow/block[7]/lineArea/@bpd"/>
<eval expected="360000" xpath="//flow/block[7]/lineArea/@ipd"/>
- <eval expected="16000" xpath="//flow/block[7]/lineArea/inlineparent/@ipd"/>
- <eval expected="36000" xpath="//flow/block[7]/lineArea/inlineparent/@ipda"/>
- <eval expected="5280" xpath="//flow/block[7]/lineArea/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[7]/lineArea/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[7]/lineArea/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[7]/lineArea/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[7]/lineArea/inlineparent/@border-start"/>
- <eval expected="5000" xpath="//flow/block[7]/lineArea/inlineparent/@padding-after"/>
- <eval expected="5000" xpath="//flow/block[7]/lineArea/inlineparent/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[7]/lineArea/inlineparent/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[7]/lineArea/inlineparent/@padding-start"/>
+ <eval expected="16000" xpath="//flow/block[7]/lineArea/leader/@ipd"/>
+ <eval expected="36000" xpath="//flow/block[7]/lineArea/leader/@ipda"/>
+ <eval expected="7616" xpath="//flow/block[7]/lineArea/leader/@offset"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[7]/lineArea/leader/@border-after"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[7]/lineArea/leader/@border-before"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[7]/lineArea/leader/@border-end"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[7]/lineArea/leader/@border-start"/>
+ <eval expected="5000" xpath="//flow/block[7]/lineArea/leader/@padding-after"/>
+ <eval expected="5000" xpath="//flow/block[7]/lineArea/leader/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[7]/lineArea/leader/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[7]/lineArea/leader/@padding-start"/>
+
+ <eval expected="11100" xpath="//flow/block[8]/lineArea/@bpd"/>
+ <eval expected="360000" xpath="//flow/block[8]/lineArea/@ipd"/>
+ <eval expected="16000" xpath="//flow/block[8]/lineArea/leader/@ipd"/>
+ <eval expected="36000" xpath="//flow/block[8]/lineArea/leader/@ipda"/>
+ <eval expected="7616" xpath="//flow/block[8]/lineArea/leader/@offset"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[8]/lineArea/leader/@border-after"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[8]/lineArea/leader/@border-before"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[8]/lineArea/leader/@border-end"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[8]/lineArea/leader/@border-start"/>
+ <eval expected="5000" xpath="//flow/block[8]/lineArea/leader/@padding-after"/>
+ <eval expected="5000" xpath="//flow/block[8]/lineArea/leader/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[8]/lineArea/leader/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[8]/lineArea/leader/@padding-start"/>
+
+ <eval expected="11100" xpath="//flow/block[9]/lineArea/@bpd"/>
+ <eval expected="360000" xpath="//flow/block[9]/lineArea/@ipd"/>
+ <eval expected="16000" xpath="//flow/block[9]/lineArea/space/@ipd"/>
+ <eval expected="36000" xpath="//flow/block[9]/lineArea/space/@ipda"/>
+ <eval expected="8615" xpath="//flow/block[9]/lineArea/space/@offset"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[9]/lineArea/space/@border-after"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[9]/lineArea/space/@border-before"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[9]/lineArea/space/@border-end"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[9]/lineArea/space/@border-start"/>
+ <eval expected="5000" xpath="//flow/block[9]/lineArea/space/@padding-after"/>
+ <eval expected="5000" xpath="//flow/block[9]/lineArea/space/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[9]/lineArea/space/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[9]/lineArea/space/@padding-start"/>
+
+ <eval expected="11100" xpath="//flow/block[11]/lineArea/@bpd"/>
+ <eval expected="360000" xpath="//flow/block[11]/lineArea/@ipd"/>
+ <eval expected="24000" xpath="//flow/block[11]/lineArea/inlineparent/@ipd"/>
+ <eval expected="36000" xpath="//flow/block[11]/lineArea/inlineparent/@ipda"/>
+ <eval expected="5280" xpath="//flow/block[11]/lineArea/inlineparent/@offset"/>
+ <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[11]/lineArea/inlineparent/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[11]/lineArea/inlineparent/@border-before"/>
+ <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[11]/lineArea/inlineparent/@border-end"/>
+ <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[11]/lineArea/inlineparent/@border-start"/>
+ <eval expected="3000" xpath="//flow/block[11]/lineArea/inlineparent/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[11]/lineArea/inlineparent/@padding-before"/>
+ <eval expected="2000" xpath="//flow/block[11]/lineArea/inlineparent/@padding-end"/>
+ <eval expected="4000" xpath="//flow/block[11]/lineArea/inlineparent/@padding-start"/>
- <eval expected="11100" xpath="//flow/block[10]/lineArea/@bpd"/>
- <eval expected="360000" xpath="//flow/block[10]/lineArea/@ipd"/>
- <eval expected="16000" xpath="//flow/block[10]/lineArea/leader/@ipd"/>
- <eval expected="36000" xpath="//flow/block[10]/lineArea/leader/@ipda"/>
- <eval expected="7616" xpath="//flow/block[10]/lineArea/leader/@offset"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[10]/lineArea/leader/@border-after"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[10]/lineArea/leader/@border-before"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[10]/lineArea/leader/@border-end"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[10]/lineArea/leader/@border-start"/>
- <eval expected="5000" xpath="//flow/block[10]/lineArea/leader/@padding-after"/>
- <eval expected="5000" xpath="//flow/block[10]/lineArea/leader/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[10]/lineArea/leader/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[10]/lineArea/leader/@padding-start"/>
+ <eval expected="11100" xpath="//flow/block[12]/lineArea/@bpd"/>
+ <eval expected="360000" xpath="//flow/block[12]/lineArea/@ipd"/>
+ <eval expected="24000" xpath="//flow/block[12]/lineArea/leader/@ipd"/>
+ <eval expected="36000" xpath="//flow/block[12]/lineArea/leader/@ipda"/>
+ <eval expected="7616" xpath="//flow/block[12]/lineArea/leader/@offset"/>
+ <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[12]/lineArea/leader/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[12]/lineArea/leader/@border-before"/>
+ <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[12]/lineArea/leader/@border-end"/>
+ <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[12]/lineArea/leader/@border-start"/>
+ <eval expected="3000" xpath="//flow/block[12]/lineArea/leader/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[12]/lineArea/leader/@padding-before"/>
+ <eval expected="2000" xpath="//flow/block[12]/lineArea/leader/@padding-end"/>
+ <eval expected="4000" xpath="//flow/block[12]/lineArea/leader/@padding-start"/>
<eval expected="11100" xpath="//flow/block[13]/lineArea/@bpd"/>
<eval expected="360000" xpath="//flow/block[13]/lineArea/@ipd"/>
- <eval expected="16000" xpath="//flow/block[13]/lineArea/leader/@ipd"/>
+ <eval expected="24000" xpath="//flow/block[13]/lineArea/leader/@ipd"/>
<eval expected="36000" xpath="//flow/block[13]/lineArea/leader/@ipda"/>
<eval expected="7616" xpath="//flow/block[13]/lineArea/leader/@offset"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[13]/lineArea/leader/@border-after"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[13]/lineArea/leader/@border-before"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[13]/lineArea/leader/@border-end"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[13]/lineArea/leader/@border-start"/>
- <eval expected="5000" xpath="//flow/block[13]/lineArea/leader/@padding-after"/>
- <eval expected="5000" xpath="//flow/block[13]/lineArea/leader/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[13]/lineArea/leader/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[13]/lineArea/leader/@padding-start"/>
-
- <eval expected="11100" xpath="//flow/block[16]/lineArea/@bpd"/>
- <eval expected="360000" xpath="//flow/block[16]/lineArea/@ipd"/>
- <eval expected="16000" xpath="//flow/block[16]/lineArea/space/@ipd"/>
- <eval expected="36000" xpath="//flow/block[16]/lineArea/space/@ipda"/>
- <eval expected="8615" xpath="//flow/block[16]/lineArea/space/@offset"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[16]/lineArea/space/@border-after"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[16]/lineArea/space/@border-before"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[16]/lineArea/space/@border-end"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[16]/lineArea/space/@border-start"/>
- <eval expected="5000" xpath="//flow/block[16]/lineArea/space/@padding-after"/>
- <eval expected="5000" xpath="//flow/block[16]/lineArea/space/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[16]/lineArea/space/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[16]/lineArea/space/@padding-start"/>
-
- <eval expected="11100" xpath="//flow/block[22]/lineArea/@bpd"/>
- <eval expected="360000" xpath="//flow/block[22]/lineArea/@ipd"/>
- <eval expected="24000" xpath="//flow/block[22]/lineArea/inlineparent/@ipd"/>
- <eval expected="36000" xpath="//flow/block[22]/lineArea/inlineparent/@ipda"/>
- <eval expected="5280" xpath="//flow/block[22]/lineArea/inlineparent/@offset"/>
- <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[22]/lineArea/inlineparent/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[22]/lineArea/inlineparent/@border-before"/>
- <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[22]/lineArea/inlineparent/@border-end"/>
- <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[22]/lineArea/inlineparent/@border-start"/>
- <eval expected="3000" xpath="//flow/block[22]/lineArea/inlineparent/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[22]/lineArea/inlineparent/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[22]/lineArea/inlineparent/@padding-end"/>
- <eval expected="4000" xpath="//flow/block[22]/lineArea/inlineparent/@padding-start"/>
-
- <eval expected="11100" xpath="//flow/block[25]/lineArea/@bpd"/>
- <eval expected="360000" xpath="//flow/block[25]/lineArea/@ipd"/>
- <eval expected="24000" xpath="//flow/block[25]/lineArea/leader/@ipd"/>
- <eval expected="36000" xpath="//flow/block[25]/lineArea/leader/@ipda"/>
- <eval expected="7616" xpath="//flow/block[25]/lineArea/leader/@offset"/>
- <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[25]/lineArea/leader/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[25]/lineArea/leader/@border-before"/>
- <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[25]/lineArea/leader/@border-end"/>
- <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[25]/lineArea/leader/@border-start"/>
- <eval expected="3000" xpath="//flow/block[25]/lineArea/leader/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[25]/lineArea/leader/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[25]/lineArea/leader/@padding-end"/>
- <eval expected="4000" xpath="//flow/block[25]/lineArea/leader/@padding-start"/>
-
- <eval expected="11100" xpath="//flow/block[28]/lineArea/@bpd"/>
- <eval expected="360000" xpath="//flow/block[28]/lineArea/@ipd"/>
- <eval expected="24000" xpath="//flow/block[28]/lineArea/leader/@ipd"/>
- <eval expected="36000" xpath="//flow/block[28]/lineArea/leader/@ipda"/>
- <eval expected="7616" xpath="//flow/block[28]/lineArea/leader/@offset"/>
- <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[28]/lineArea/leader/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[28]/lineArea/leader/@border-before"/>
- <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[28]/lineArea/leader/@border-end"/>
- <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[28]/lineArea/leader/@border-start"/>
- <eval expected="3000" xpath="//flow/block[28]/lineArea/leader/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[28]/lineArea/leader/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[28]/lineArea/leader/@padding-end"/>
- <eval expected="4000" xpath="//flow/block[28]/lineArea/leader/@padding-start"/>
+ <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[13]/lineArea/leader/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[13]/lineArea/leader/@border-before"/>
+ <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[13]/lineArea/leader/@border-end"/>
+ <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[13]/lineArea/leader/@border-start"/>
+ <eval expected="3000" xpath="//flow/block[13]/lineArea/leader/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[13]/lineArea/leader/@padding-before"/>
+ <eval expected="2000" xpath="//flow/block[13]/lineArea/leader/@padding-end"/>
+ <eval expected="4000" xpath="//flow/block[13]/lineArea/leader/@padding-start"/>
- <eval expected="11100" xpath="//flow/block[31]/lineArea/@bpd"/>
- <eval expected="360000" xpath="//flow/block[31]/lineArea/@ipd"/>
- <eval expected="24000" xpath="//flow/block[31]/lineArea/space/@ipd"/>
- <eval expected="36000" xpath="//flow/block[31]/lineArea/space/@ipda"/>
- <eval expected="8615" xpath="//flow/block[31]/lineArea/space/@offset"/>
- <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[31]/lineArea/space/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[31]/lineArea/space/@border-before"/>
- <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[31]/lineArea/space/@border-end"/>
- <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[31]/lineArea/space/@border-start"/>
- <eval expected="3000" xpath="//flow/block[31]/lineArea/space/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[31]/lineArea/space/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[31]/lineArea/space/@padding-end"/>
- <eval expected="4000" xpath="//flow/block[31]/lineArea/space/@padding-start"/>
+ <eval expected="11100" xpath="//flow/block[14]/lineArea/@bpd"/>
+ <eval expected="360000" xpath="//flow/block[14]/lineArea/@ipd"/>
+ <eval expected="24000" xpath="//flow/block[14]/lineArea/space/@ipd"/>
+ <eval expected="36000" xpath="//flow/block[14]/lineArea/space/@ipda"/>
+ <eval expected="8615" xpath="//flow/block[14]/lineArea/space/@offset"/>
+ <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[14]/lineArea/space/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[14]/lineArea/space/@border-before"/>
+ <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[14]/lineArea/space/@border-end"/>
+ <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[14]/lineArea/space/@border-start"/>
+ <eval expected="3000" xpath="//flow/block[14]/lineArea/space/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[14]/lineArea/space/@padding-before"/>
+ <eval expected="2000" xpath="//flow/block[14]/lineArea/space/@padding-end"/>
+ <eval expected="4000" xpath="//flow/block[14]/lineArea/space/@padding-start"/>
</checks>
</testcase>
<eval expected="360000" xpath="//flow/@ipd"/>
<!-- spacer block for space-before on list-block -->
- <eval expected="5000" xpath="//flow/block[2]/@bpd"/>
+ <eval expected="5000" xpath="//flow/block[2]/@space-before"/>
<!-- list-block -->
- <eval expected="360000" xpath="//flow/block[3]/@ipda"/>
- <eval expected="340000" xpath="//flow/block[3]/@ipd"/>
- <!--eval expected="??" xpath="//flow/block[3]/@bpda"/>
- <eval expected="??" xpath="//flow/block[3]/@bpd"/-->
- <eval expected="10000 10000 10000 10000" xpath="//flow/block[3]/@bap"/>
- <eval expected="5000" xpath="//flow/block[3]/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[3]/@padding-after"/>
- <eval expected="5000" xpath="//flow/block[3]/@padding-start"/>
- <eval expected="5000" xpath="//flow/block[3]/@padding-end"/>
- <eval expected="10000" xpath="//flow/block[3]/@start-indent"/>
- <eval expected="10000" xpath="//flow/block[3]/@end-indent"/>
+ <eval expected="360000" xpath="//flow/block[2]/@ipda"/>
+ <eval expected="340000" xpath="//flow/block[2]/@ipd"/>
+ <!--eval expected="??" xpath="//flow/block[2]/@bpda"/>
+ <eval expected="??" xpath="//flow/block[2]/@bpd"/-->
+ <eval expected="10000 10000 10000 10000" xpath="//flow/block[2]/@bap"/>
+ <eval expected="5000" xpath="//flow/block[2]/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[2]/@padding-after"/>
+ <eval expected="5000" xpath="//flow/block[2]/@padding-start"/>
+ <eval expected="5000" xpath="//flow/block[2]/@padding-end"/>
+ <eval expected="10000" xpath="//flow/block[2]/@start-indent"/>
+ <eval expected="10000" xpath="//flow/block[2]/@end-indent"/>
<!-- first list-item -->
- <eval expected="340000" xpath="//flow/block[3]/block[1]/@ipda"/>
- <eval expected="340000" xpath="//flow/block[3]/block[1]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[1]/@bpda"/>
- <eval expected="14400" xpath="//flow/block[3]/block[1]/@bpd"/>
- <eval expected="10000" xpath="//flow/block[3]/block[1]/@start-indent"/>
- <eval expected="10000" xpath="//flow/block[3]/block[1]/@end-indent"/>
+ <eval expected="340000" xpath="//flow/block[2]/block[1]/@ipda"/>
+ <eval expected="340000" xpath="//flow/block[2]/block[1]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[1]/@bpda"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[1]/@bpd"/>
+ <eval expected="10000" xpath="//flow/block[2]/block[1]/@start-indent"/>
+ <eval expected="10000" xpath="//flow/block[2]/block[1]/@end-indent"/>
- <eval expected="340000" xpath="//flow/block[3]/block[1]/block[1]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[1]/block[1]/@bpd"/>
- <eval expected="40000" xpath="//flow/block[3]/block[1]/block[1]/block[1]/@ipda"/>
- <eval expected="40000" xpath="//flow/block[3]/block[1]/block[1]/block[1]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[1]/block[1]/block[1]/@bpda"/>
- <eval expected="14400" xpath="//flow/block[3]/block[1]/block[1]/block[1]/@bpda"/>
- <eval expected="10000" xpath="//flow/block[3]/block[1]/block[1]/block[1]/@start-indent"/>
- <eval expected="310000" xpath="//flow/block[3]/block[1]/block[1]/block[1]/@end-indent"/>
- <eval expected="10000" xpath="//flow/block[3]/block[1]/block[1]/block[1]/@space-start"/>
- <eval expected="310000" xpath="//flow/block[3]/block[1]/block[1]/block[1]/@space-end"/>
+ <eval expected="340000" xpath="//flow/block[2]/block[1]/block[1]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[1]/block[1]/@bpd"/>
+ <eval expected="40000" xpath="//flow/block[2]/block[1]/block[1]/block[1]/@ipda"/>
+ <eval expected="40000" xpath="//flow/block[2]/block[1]/block[1]/block[1]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[1]/block[1]/block[1]/@bpda"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[1]/block[1]/block[1]/@bpda"/>
+ <eval expected="10000" xpath="//flow/block[2]/block[1]/block[1]/block[1]/@start-indent"/>
+ <eval expected="310000" xpath="//flow/block[2]/block[1]/block[1]/block[1]/@end-indent"/>
+ <eval expected="10000" xpath="//flow/block[2]/block[1]/block[1]/block[1]/@space-start"/>
+ <eval expected="310000" xpath="//flow/block[2]/block[1]/block[1]/block[1]/@space-end"/>
- <eval expected="340000" xpath="//flow/block[3]/block[1]/block[2]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[1]/block[2]/@bpd"/>
- <eval expected="290000" xpath="//flow/block[3]/block[1]/block[2]/block[1]/@ipda"/>
- <eval expected="280000" xpath="//flow/block[3]/block[1]/block[2]/block[1]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[1]/block[2]/block[1]/@bpda"/>
- <eval expected="14400" xpath="//flow/block[3]/block[1]/block[2]/block[1]/@bpda"/>
- <eval expected="65000" xpath="//flow/block[3]/block[1]/block[2]/block[1]/@start-indent"/>
- <eval expected="15000" xpath="//flow/block[3]/block[1]/block[2]/block[1]/@end-indent"/>
- <eval expected="60000" xpath="//flow/block[3]/block[1]/block[2]/block[1]/@space-start"/>
- <eval expected="10000" xpath="//flow/block[3]/block[1]/block[2]/block[1]/@space-end"/>
+ <eval expected="340000" xpath="//flow/block[2]/block[1]/block[2]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[1]/block[2]/@bpd"/>
+ <eval expected="290000" xpath="//flow/block[2]/block[1]/block[2]/block[1]/@ipda"/>
+ <eval expected="280000" xpath="//flow/block[2]/block[1]/block[2]/block[1]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[1]/block[2]/block[1]/@bpda"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[1]/block[2]/block[1]/@bpda"/>
+ <eval expected="65000" xpath="//flow/block[2]/block[1]/block[2]/block[1]/@start-indent"/>
+ <eval expected="15000" xpath="//flow/block[2]/block[1]/block[2]/block[1]/@end-indent"/>
+ <eval expected="60000" xpath="//flow/block[2]/block[1]/block[2]/block[1]/@space-start"/>
+ <eval expected="10000" xpath="//flow/block[2]/block[1]/block[2]/block[1]/@space-end"/>
<!-- spacer block for space-before on second list-item -->
- <eval expected="5000" xpath="//flow/block[3]/block[2]/@bpd"/>
+ <eval expected="5000" xpath="//flow/block[2]/block[2]/@space-before"/>
<!-- second list-item -->
- <eval expected="340000" xpath="//flow/block[3]/block[3]/@ipda"/>
- <eval expected="340000" xpath="//flow/block[3]/block[3]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[3]/@bpda"/>
- <eval expected="14400" xpath="//flow/block[3]/block[3]/@bpd"/>
- <eval expected="10000" xpath="//flow/block[3]/block[3]/@start-indent"/>
- <eval expected="10000" xpath="//flow/block[3]/block[3]/@end-indent"/>
+ <eval expected="340000" xpath="//flow/block[2]/block[2]/@ipda"/>
+ <eval expected="340000" xpath="//flow/block[2]/block[2]/@ipd"/>
+ <eval expected="29400" xpath="//flow/block[2]/block[2]/@bpda"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[2]/@bpd"/>
+ <eval expected="10000" xpath="//flow/block[2]/block[2]/@start-indent"/>
+ <eval expected="10000" xpath="//flow/block[2]/block[2]/@end-indent"/>
- <eval expected="340000" xpath="//flow/block[3]/block[3]/block[1]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[3]/block[1]/@bpd"/>
- <eval expected="40000" xpath="//flow/block[3]/block[3]/block[1]/block[1]/@ipda"/>
- <eval expected="40000" xpath="//flow/block[3]/block[3]/block[1]/block[1]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[3]/block[1]/block[1]/@bpda"/>
- <eval expected="14400" xpath="//flow/block[3]/block[3]/block[1]/block[1]/@bpda"/>
- <eval expected="10000" xpath="//flow/block[3]/block[3]/block[1]/block[1]/@start-indent"/>
- <eval expected="310000" xpath="//flow/block[3]/block[3]/block[1]/block[1]/@end-indent"/>
- <eval expected="10000" xpath="//flow/block[3]/block[3]/block[1]/block[1]/@space-start"/>
- <eval expected="310000" xpath="//flow/block[3]/block[3]/block[1]/block[1]/@space-end"/>
+ <eval expected="340000" xpath="//flow/block[2]/block[2]/block[1]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[2]/block[1]/@bpd"/>
+ <eval expected="40000" xpath="//flow/block[2]/block[2]/block[1]/block[1]/@ipda"/>
+ <eval expected="40000" xpath="//flow/block[2]/block[2]/block[1]/block[1]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[2]/block[1]/block[1]/@bpda"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[2]/block[1]/block[1]/@bpda"/>
+ <eval expected="10000" xpath="//flow/block[2]/block[2]/block[1]/block[1]/@start-indent"/>
+ <eval expected="310000" xpath="//flow/block[2]/block[2]/block[1]/block[1]/@end-indent"/>
+ <eval expected="10000" xpath="//flow/block[2]/block[2]/block[1]/block[1]/@space-start"/>
+ <eval expected="310000" xpath="//flow/block[2]/block[2]/block[1]/block[1]/@space-end"/>
- <eval expected="340000" xpath="//flow/block[3]/block[3]/block[2]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[3]/block[2]/@bpd"/>
- <eval expected="295000" xpath="//flow/block[3]/block[3]/block[2]/block[1]/@ipda"/>
- <eval expected="285000" xpath="//flow/block[3]/block[3]/block[2]/block[1]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[3]/block[2]/block[1]/@bpda"/>
- <eval expected="14400" xpath="//flow/block[3]/block[3]/block[2]/block[1]/@bpda"/>
- <eval expected="60000" xpath="//flow/block[3]/block[3]/block[2]/block[1]/@start-indent"/>
- <eval expected="15000" xpath="//flow/block[3]/block[3]/block[2]/block[1]/@end-indent"/>
- <eval expected="55000" xpath="//flow/block[3]/block[3]/block[2]/block[1]/@space-start"/>
- <eval expected="10000" xpath="//flow/block[3]/block[3]/block[2]/block[1]/@space-end"/>
+ <eval expected="340000" xpath="//flow/block[2]/block[2]/block[2]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[2]/block[2]/@bpd"/>
+ <eval expected="295000" xpath="//flow/block[2]/block[2]/block[2]/block[1]/@ipda"/>
+ <eval expected="285000" xpath="//flow/block[2]/block[2]/block[2]/block[1]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[2]/block[2]/block[1]/@bpda"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[2]/block[2]/block[1]/@bpda"/>
+ <eval expected="60000" xpath="//flow/block[2]/block[2]/block[2]/block[1]/@start-indent"/>
+ <eval expected="15000" xpath="//flow/block[2]/block[2]/block[2]/block[1]/@end-indent"/>
+ <eval expected="55000" xpath="//flow/block[2]/block[2]/block[2]/block[1]/@space-start"/>
+ <eval expected="10000" xpath="//flow/block[2]/block[2]/block[2]/block[1]/@space-end"/>
<!-- spacer block for space-after on second list-item -->
- <eval expected="10000" xpath="//flow/block[3]/block[4]/@bpd"/>
+ <eval expected="10000" xpath="//flow/block[2]/block[2]/@space-after"/>
<!-- third list-item -->
- <eval expected="340000" xpath="//flow/block[3]/block[5]/@ipda"/>
- <eval expected="320000" xpath="//flow/block[3]/block[5]/@ipd"/>
- <eval expected="34400" xpath="//flow/block[3]/block[5]/@bpda"/>
- <eval expected="14400" xpath="//flow/block[3]/block[5]/@bpd"/>
- <eval expected="10000 10000 10000 10000" xpath="//flow/block[3]/block[5]/@bap"/>
- <eval expected="5000" xpath="//flow/block[3]/block[5]/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[3]/block[5]/@padding-after"/>
- <eval expected="5000" xpath="//flow/block[3]/block[5]/@padding-start"/>
- <eval expected="5000" xpath="//flow/block[3]/block[5]/@padding-end"/>
- <eval expected="20000" xpath="//flow/block[3]/block[5]/@start-indent"/>
- <eval expected="20000" xpath="//flow/block[3]/block[5]/@end-indent"/>
+ <eval expected="340000" xpath="//flow/block[2]/block[3]/@ipda"/>
+ <eval expected="320000" xpath="//flow/block[2]/block[3]/@ipd"/>
+ <eval expected="34400" xpath="//flow/block[2]/block[3]/@bpda"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[3]/@bpd"/>
+ <eval expected="10000 10000 10000 10000" xpath="//flow/block[2]/block[3]/@bap"/>
+ <eval expected="5000" xpath="//flow/block[2]/block[3]/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[2]/block[3]/@padding-after"/>
+ <eval expected="5000" xpath="//flow/block[2]/block[3]/@padding-start"/>
+ <eval expected="5000" xpath="//flow/block[2]/block[3]/@padding-end"/>
+ <eval expected="20000" xpath="//flow/block[2]/block[3]/@start-indent"/>
+ <eval expected="20000" xpath="//flow/block[2]/block[3]/@end-indent"/>
- <eval expected="320000" xpath="//flow/block[3]/block[5]/block[1]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[5]/block[1]/@bpd"/>
- <eval expected="40000" xpath="//flow/block[3]/block[5]/block[1]/block[1]/@ipda"/>
- <eval expected="40000" xpath="//flow/block[3]/block[5]/block[1]/block[1]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[5]/block[1]/block[1]/@bpda"/>
- <eval expected="14400" xpath="//flow/block[3]/block[5]/block[1]/block[1]/@bpda"/>
- <eval expected="20000" xpath="//flow/block[3]/block[5]/block[1]/block[1]/@start-indent"/>
- <eval expected="300000" xpath="//flow/block[3]/block[5]/block[1]/block[1]/@end-indent"/>
- <eval expected="20000" xpath="//flow/block[3]/block[5]/block[1]/block[1]/@space-start"/>
- <eval expected="300000" xpath="//flow/block[3]/block[5]/block[1]/block[1]/@space-end"/>
+ <eval expected="320000" xpath="//flow/block[2]/block[3]/block[1]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[3]/block[1]/@bpd"/>
+ <eval expected="40000" xpath="//flow/block[2]/block[3]/block[1]/block[1]/@ipda"/>
+ <eval expected="40000" xpath="//flow/block[2]/block[3]/block[1]/block[1]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[3]/block[1]/block[1]/@bpda"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[3]/block[1]/block[1]/@bpda"/>
+ <eval expected="20000" xpath="//flow/block[2]/block[3]/block[1]/block[1]/@start-indent"/>
+ <eval expected="300000" xpath="//flow/block[2]/block[3]/block[1]/block[1]/@end-indent"/>
+ <eval expected="20000" xpath="//flow/block[2]/block[3]/block[1]/block[1]/@space-start"/>
+ <eval expected="300000" xpath="//flow/block[2]/block[3]/block[1]/block[1]/@space-end"/>
- <eval expected="320000" xpath="//flow/block[3]/block[5]/block[2]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[5]/block[2]/@bpd"/>
- <eval expected="280000" xpath="//flow/block[3]/block[5]/block[2]/block[1]/@ipda"/>
- <eval expected="270000" xpath="//flow/block[3]/block[5]/block[2]/block[1]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[5]/block[2]/block[1]/@bpda"/>
- <eval expected="14400" xpath="//flow/block[3]/block[5]/block[2]/block[1]/@bpda"/>
- <eval expected="70000" xpath="//flow/block[3]/block[5]/block[2]/block[1]/@start-indent"/>
- <eval expected="20000" xpath="//flow/block[3]/block[5]/block[2]/block[1]/@end-indent"/>
- <eval expected="65000" xpath="//flow/block[3]/block[5]/block[2]/block[1]/@space-start"/>
- <eval expected="15000" xpath="//flow/block[3]/block[5]/block[2]/block[1]/@space-end"/>
+ <eval expected="320000" xpath="//flow/block[2]/block[3]/block[2]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[3]/block[2]/@bpd"/>
+ <eval expected="280000" xpath="//flow/block[2]/block[3]/block[2]/block[1]/@ipda"/>
+ <eval expected="270000" xpath="//flow/block[2]/block[3]/block[2]/block[1]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[3]/block[2]/block[1]/@bpda"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[3]/block[2]/block[1]/@bpda"/>
+ <eval expected="70000" xpath="//flow/block[2]/block[3]/block[2]/block[1]/@start-indent"/>
+ <eval expected="20000" xpath="//flow/block[2]/block[3]/block[2]/block[1]/@end-indent"/>
+ <eval expected="65000" xpath="//flow/block[2]/block[3]/block[2]/block[1]/@space-start"/>
+ <eval expected="15000" xpath="//flow/block[2]/block[3]/block[2]/block[1]/@space-end"/>
<!-- spacer block for space-after on list-block -->
- <eval expected="10000" xpath="//flow/block[4]/@bpd"/>
+ <eval expected="10000" xpath="//flow/block[2]/@space-after"/>
</checks>
</testcase>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<testcase>
+ <info>
+ <p>
+ This test checks spaces on tables.
+ </p>
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="1.7in">
+ <fo:region-body/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal" id="retain">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:list-block provisional-distance-between-starts="8pt" provisional-label-separation="5pt"
+ space-before="20pt" space-before.conditionality="retain"
+ space-after="10pt" space-after.conditionality="retain">
+ <fo:list-item space-before="1em">
+ <fo:list-item-label end-indent="label-end()">
+ <fo:block>•</fo:block>
+ </fo:list-item-label>
+ <fo:list-item-body start-indent="body-start()">
+ <fo:block text-align="justify">
+In olden times when wishing still helped one, there lived a king whose daughters
+were all beautiful; and the youngest was so beautiful that the sun itself, which
+has seen so much, was astonished whenever it shone in her face. Close by the king's
+castle lay a great dark forest, and under an old lime-tree in the forest was a well,
+and when the day was very warm, the king's child went out into the forest and sat
+down by the side of the cool fountain; and when she was bored she took a golden ball,
+and threw it up on high and caught it; and this ball was her favorite plaything.
+ </fo:block>
+ </fo:list-item-body>
+ </fo:list-item>
+ <fo:list-item>
+ <fo:list-item-label end-indent="label-end()">
+ <fo:block>•</fo:block>
+ </fo:list-item-label>
+ <fo:list-item-body start-indent="body-start()">
+ <fo:block>here is text in the list item body</fo:block>
+ </fo:list-item-body>
+ </fo:list-item>
+ </fo:list-block>
+ <fo:block space-before.optimum="10pt" space-before.conditionality="retain" space-after.optimum="20pt" space-after.conditionality="retain">
+Two blocks, testing conditionality="retain".
+ </fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+ <fo:page-sequence master-reference="normal" id="discard">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:list-block provisional-distance-between-starts="8pt" provisional-label-separation="5pt"
+ space-before="20pt" space-before.conditionality="discard"
+ space-after="10pt" space-after.conditionality="discard">
+ <fo:list-item space-before="1em">
+ <fo:list-item-label end-indent="label-end()">
+ <fo:block>•</fo:block>
+ </fo:list-item-label>
+ <fo:list-item-body start-indent="body-start()">
+ <fo:block text-align="justify">
+In olden times when wishing still helped one, there lived a king whose daughters
+were all beautiful; and the youngest was so beautiful that the sun itself, which
+has seen so much, was astonished whenever it shone in her face. Close by the king's
+castle lay a great dark forest, and under an old lime-tree in the forest was a well,
+and when the day was very warm, the king's child went out into the forest and sat
+down by the side of the cool fountain; and when she was bored she took a golden ball,
+and threw it up on high and caught it; and this ball was her favorite plaything.
+ </fo:block>
+ </fo:list-item-body>
+ </fo:list-item>
+ <fo:list-item>
+ <fo:list-item-label end-indent="label-end()">
+ <fo:block>•</fo:block>
+ </fo:list-item-label>
+ <fo:list-item-body start-indent="body-start()">
+ <fo:block>here is text in the list item body</fo:block>
+ </fo:list-item-body>
+ </fo:list-item>
+ </fo:list-block>
+ <fo:block space-before.optimum="10pt" space-before.conditionality="discard" space-after.optimum="20pt" space-after.conditionality="discard">
+Two blocks, testing conditionality="discard".
+ </fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <element-list category="breaker" id="retain">
+ <box w="0"/> <!-- Helper box bearing the SpaceHandlingPosition and making sure the glue gets processed -->
+ <penalty w="0" p="INF"/>
+ <glue w="20000"/>
+
+ <box w="28800"/>
+
+ <penalty w="0" p="INF"/>
+ <glue w="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-30000"/>
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="20000"/>
+
+ <box w="14400"/>
+
+ <penalty w="0" p="INF"/>
+ <glue w="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-30000"/>
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="20000"/>
+
+ <box w="14400"/>
+
+ <!-- skip three more lines -->
+ <skip>8</skip>
+ <skip>8</skip>
+ <skip>8</skip>
+
+ <penalty w="0" p="INF"/>
+ <glue w="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-30000"/>
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="20000"/>
+
+ <box w="28800"/> <!-- end of first list item -->
+
+ <penalty w="0" p="INF"/>
+ <glue w="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-30000"/>
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="20000"/>
+
+ <box w="14400"/> <!-- second list-item -->
+
+ <penalty w="0" p="INF" aux="true"/>
+ <glue w="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-10000"/>
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="10000"/>
+
+ <box w="14400"/> <!-- second block -->
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="20000"/>
+
+ <box w="0"/> <!-- This is used to make sure the preceding glue is not cut off -->
+
+ <skip>3</skip>
+ </element-list>
+ <element-list category="breaker" id="discard">
+ <box w="0"/> <!-- Helper box used to notify the LM for the addAreas stage about the discarded spaces -->
+ <box w="28800"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="28800"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <glue w="10000"/>
+
+ <box w="14400"/> <!-- second block -->
+
+ <box w="0"/> <!-- SpaceHandlingPosition-bearing helper box -->
+
+ <skip>3</skip>
+ </element-list>
+
+ <eval expected="4" xpath="count(//pageViewport)"/>
+
+ <!-- 1: retain -->
+ <eval expected="20000" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+ <eval expected="10000" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-after"/>
+ <eval expected="20000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+ <!-- the following space is eliminated/collapsed through space resolution -->
+ <true xpath="not(boolean(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-after))"/>
+ <eval expected="10000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[2]/@space-before"/>
+ <eval expected="20000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[2]/@space-after"/>
+
+ <!-- 2: discard -->
+ <true xpath="not(boolean(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-after))"/>
+ <eval expected="10000" xpath="//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[2]/@space-before"/>
+ <true xpath="not(boolean(//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[2]/@space-after))"/>
+ </checks>
+</testcase>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<testcase>
+ <info>
+ <p>
+ This test checks lists. Checks space-before and space-after on list-block.
+ </p>
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="2in"
+ margin="20pt">
+ <fo:region-body background-color="yellow"/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal" white-space-collapse="true">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:block>test</fo:block>
+ <fo:list-block provisional-distance-between-starts="50pt" provisional-label-separation="5pt">
+ <fo:list-item space-before="1em">
+ <fo:list-item-label end-indent="label-end()">
+ <fo:block>•</fo:block>
+ </fo:list-item-label>
+ <fo:list-item-body start-indent="body-start()">
+ <fo:block>here is text in the list item body</fo:block>
+ </fo:list-item-body>
+ </fo:list-item>
+ <fo:list-item space-before="1em">
+ <fo:list-item-label end-indent="label-end()">
+ <fo:block>•</fo:block>
+ </fo:list-item-label>
+ <fo:list-item-body start-indent="body-start()">
+ <fo:block>here is text in the list item body</fo:block>
+ </fo:list-item-body>
+ </fo:list-item>
+ <fo:list-item space-before="1em" space-after="1em">
+ <fo:list-item-label end-indent="label-end()">
+ <fo:block>•</fo:block>
+ </fo:list-item-label>
+ <fo:list-item-body start-indent="body-start()">
+ <fo:block>here is text in the list item body</fo:block>
+ </fo:list-item-body>
+ </fo:list-item>
+ <fo:list-item space-after="1em">
+ <fo:list-item-label end-indent="label-end()">
+ <fo:block>•</fo:block>
+ </fo:list-item-label>
+ <fo:list-item-body start-indent="body-start()">
+ <fo:block>here is text in the list item body</fo:block>
+ </fo:list-item-body>
+ </fo:list-item>
+ <fo:list-item>
+ <fo:list-item-label end-indent="label-end()">
+ <fo:block>•</fo:block>
+ </fo:list-item-label>
+ <fo:list-item-body start-indent="body-start()">
+ <fo:block>here is text in the list item body</fo:block>
+ </fo:list-item-body>
+ </fo:list-item>
+ </fo:list-block>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <eval expected="2" xpath="count(//pageViewport)"/>
+ <element-list category="breaker">
+ <box w="14400"/>
+
+ <penalty w="0" p="0"/>
+
+ <glue w="12000"/>
+ <box w="14400"/>
+
+ <penalty w="0" p="0"/>
+
+ <glue w="12000"/>
+ <box w="14400"/>
+
+ <penalty w="0" p="0"/>
+
+ <glue w="12000"/>
+ <box w="14400"/>
+
+ <penalty w="0" p="0"/>
+
+ <glue w="12000"/>
+ <box w="14400"/>
+
+ <penalty w="0" p="0"/>
+
+ <glue w="12000"/>
+ <box w="14400"/>
+
+ <skip>3</skip>
+ </element-list>
+ </checks>
+</testcase>
<eval expected="2" xpath="count(//pageViewport)"/>
<element-list category="breaker">
<box w="14400"/>
+
<penalty w="0" p="0"/>
+
<glue w="12000"/>
<box w="14400"/>
+
<penalty w="0" p="0"/>
+
<glue w="12000"/>
<box w="14400"/>
+
<penalty w="0" p="0"/>
+
<glue w="12000"/>
<box w="14400"/>
+
+ <penalty w="0" p="0"/>
+
<glue w="12000"/>
<box w="14400"/>
+
+ <penalty w="0" p="0"/>
+
<glue w="12000"/>
<box w="14400"/>
+
<skip>3</skip>
</element-list>
</checks>
instead of optimum and the addAreas stage doesn't create smaller space-before/after
spacers. -->
+ <!-- We don't check the exact effective space-before value, but simply make sure it's smaller than 12pt=1em in this test case -->
+ <true xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[2]/block[1]/@space-before < 12000"/>
+
<element-list category="breaker">
<box w="14400"/>
+
<penalty w="0" p="0"/>
- <glue w="12000"/> <!-- TODO Check shrink/stretch -->
+
+ <glue w="12000" y="0" z="12000"/>
<box w="14400"/>
+
<penalty w="0" p="0"/>
- <glue w="12000"/>
+
+ <glue w="12000" y="0" z="12000"/>
<box w="14400"/>
+
<penalty w="0" p="0"/>
- <glue w="12000"/>
+
+ <glue w="12000" y="0" z="12000"/>
<box w="14400"/>
- <glue w="12000"/>
+
+ <penalty w="0" p="0"/>
+
+ <glue w="12000" y="0" z="12000"/>
<box w="14400"/>
- <glue w="12000"/>
+
+ <penalty w="0" p="0"/>
+
+ <glue w="12000" y="0" z="12000"/>
<box w="14400"/>
+
<skip>3</skip>
</element-list>
</checks>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<testcase>
+ <info>
+ <p>
+ This test checks lists. Checks spaces inside list-item content.
+ </p>
+ <p>
+ Some additional code is notify the LMs about the effective spaces, otherwise discardable spaces don't get discarded.
+ </p>
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="2in"
+ margin="20pt">
+ <fo:region-body background-color="yellow"/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal" white-space-collapse="true">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:list-block provisional-distance-between-starts="50pt" provisional-label-separation="5pt">
+ <fo:list-item space-before="1em">
+ <fo:list-item-label end-indent="label-end()">
+ <fo:block space-before="1em">•</fo:block>
+ </fo:list-item-label>
+ <fo:list-item-body start-indent="body-start()">
+ <fo:block space-before="1em">here is text in the list item body</fo:block>
+ </fo:list-item-body>
+ </fo:list-item>
+ </fo:list-block>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <element-list category="list-item-label">
+ <box w="0"/> <!-- Starting SpaceHandlingPosition -->
+ <box w="14400"/>
+ </element-list>
+ <element-list category="list-item-body">
+ <box w="0"/> <!-- Starting SpaceHandlingPosition -->
+ <box w="14400"/>
+ </element-list>
+ <element-list category="breaker">
+ <box w="0"/> <!-- Starting SpaceHandlingPosition -->
+ <box w="14400"/>
+
+ <skip>3</skip>
+ </element-list>
+ <true xpath="not(boolean(//flow/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//flow/block[1]/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//flow/block[1]/block[1]/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//flow/block[1]/block[1]/block[1]/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//flow/block[1]/block[1]/block[2]/@space-before))"/>
+ <true xpath="not(boolean(//flow/block[1]/block[1]/block[2]/block[1]/@space-before))"/>
+ </checks>
+</testcase>
</fo:layout-master-set>
<fo:page-sequence master-reference="simple">
<fo:flow flow-name="xsl-region-body">
- <fo:block line-height="10pt" space-before.optimum="5cm"
+ <fo:block-container height="5cm">
+ <fo:block/>
+ </fo:block-container>
+ <fo:block line-height="10pt"
white-space-collapse="false" white-space-treatment="preserve" linefeed-treatment="preserve" wrap-option="no-wrap">
<![CDATA[<!-- list level 1 -->
<fo:list-block provisional-distance-between-starts="0.4cm"
</fo:root>
</fo>
<checks>
+ <eval expected="7180" xpath="//flow/block[1]/lineArea/text[2]/@baseline"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea/text[2]/@offset"/>
+ <eval expected="5560" xpath="//flow/block[1]/lineArea/text[2]/@ipd"/>
+ <eval expected="7560" xpath="//flow/block[1]/lineArea/text[2]/@ipda"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/text[2]/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/text[2]/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/text[2]/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/text[2]/@border-start"/>
+
<eval expected="7180" xpath="//flow/block[2]/lineArea/text[2]/@baseline"/>
<eval expected="0" xpath="//flow/block[2]/lineArea/text[2]/@offset"/>
<eval expected="5560" xpath="//flow/block[2]/lineArea/text[2]/@ipd"/>
- <eval expected="7560" xpath="//flow/block[2]/lineArea/text[2]/@ipda"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/text[2]/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/text[2]/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/text[2]/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/text[2]/@border-start"/>
-
- <eval expected="7180" xpath="//flow/block[5]/lineArea/text[2]/@baseline"/>
- <eval expected="0" xpath="//flow/block[5]/lineArea/text[2]/@offset"/>
- <eval expected="5560" xpath="//flow/block[5]/lineArea/text[2]/@ipd"/>
- <eval expected="25560" xpath="//flow/block[5]/lineArea/text[2]/@ipda"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/text[2]/@border-after"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/text[2]/@border-before"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/text[2]/@border-end"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/text[2]/@border-start"/>
- <eval expected="5000" xpath="//flow/block[5]/lineArea/text[2]/@padding-after"/>
- <eval expected="5000" xpath="//flow/block[5]/lineArea/text[2]/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[5]/lineArea/text[2]/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[5]/lineArea/text[2]/@padding-start"/>
+ <eval expected="25560" xpath="//flow/block[2]/lineArea/text[2]/@ipda"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/text[2]/@border-after"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/text[2]/@border-before"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/text[2]/@border-end"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/text[2]/@border-start"/>
+ <eval expected="5000" xpath="//flow/block[2]/lineArea/text[2]/@padding-after"/>
+ <eval expected="5000" xpath="//flow/block[2]/lineArea/text[2]/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[2]/lineArea/text[2]/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[2]/lineArea/text[2]/@padding-start"/>
- <eval expected="7180" xpath="//flow/block[8]/lineArea/text[2]/@baseline"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea/text[2]/@offset"/>
- <eval expected="5560" xpath="//flow/block[8]/lineArea/text[2]/@ipd"/>
- <eval expected="17560" xpath="//flow/block[8]/lineArea/text[2]/@ipda"/>
- <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[8]/lineArea/text[2]/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea/text[2]/@border-before"/>
- <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[8]/lineArea/text[2]/@border-end"/>
- <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[8]/lineArea/text[2]/@border-start"/>
- <eval expected="3000" xpath="//flow/block[8]/lineArea/text[2]/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[8]/lineArea/text[2]/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[8]/lineArea/text[2]/@padding-end"/>
- <eval expected="4000" xpath="//flow/block[8]/lineArea/text[2]/@padding-start"/>
+ <eval expected="7180" xpath="//flow/block[3]/lineArea/text[2]/@baseline"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea/text[2]/@offset"/>
+ <eval expected="5560" xpath="//flow/block[3]/lineArea/text[2]/@ipd"/>
+ <eval expected="17560" xpath="//flow/block[3]/lineArea/text[2]/@ipda"/>
+ <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[3]/lineArea/text[2]/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea/text[2]/@border-before"/>
+ <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[3]/lineArea/text[2]/@border-end"/>
+ <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[3]/lineArea/text[2]/@border-start"/>
+ <eval expected="3000" xpath="//flow/block[3]/lineArea/text[2]/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea/text[2]/@padding-before"/>
+ <eval expected="2000" xpath="//flow/block[3]/lineArea/text[2]/@padding-end"/>
+ <eval expected="4000" xpath="//flow/block[3]/lineArea/text[2]/@padding-start"/>
- <eval expected="5744" xpath="//flow/block[11]/lineArea/text[2]/@baseline"/>
- <eval expected="8616" xpath="//flow/block[11]/lineArea/text[2]/@offset"/>
- <eval expected="4448" xpath="//flow/block[11]/lineArea/text[2]/@ipd"/>
- <eval expected="24448" xpath="//flow/block[11]/lineArea/text[2]/@ipda"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/text[2]/@border-after"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/text[2]/@border-before"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/text[2]/@border-end"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/text[2]/@border-start"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea/text[2]/@padding-after"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea/text[2]/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea/text[2]/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea/text[2]/@padding-start"/>
+ <eval expected="5744" xpath="//flow/block[4]/lineArea/text[2]/@baseline"/>
+ <eval expected="8616" xpath="//flow/block[4]/lineArea/text[2]/@offset"/>
+ <eval expected="4448" xpath="//flow/block[4]/lineArea/text[2]/@ipd"/>
+ <eval expected="24448" xpath="//flow/block[4]/lineArea/text[2]/@ipda"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/text[2]/@border-after"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/text[2]/@border-before"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/text[2]/@border-end"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/text[2]/@border-start"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea/text[2]/@padding-after"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea/text[2]/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea/text[2]/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea/text[2]/@padding-start"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="7180" xpath="//flow/block[1]/lineArea/text[2]/@offset"/>
<eval expected="7180" xpath="//flow/block[2]/lineArea/text[2]/@offset"/>
- <eval expected="7180" xpath="//flow/block[5]/lineArea/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea/text[2]/@offset"/>
- <eval expected="4565" xpath="//flow/block[11]/lineArea/text[2]/@offset"/>
- <eval expected="9250" xpath="//flow/block[14]/lineArea/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea/text[2]/@offset"/>
+ <eval expected="4565" xpath="//flow/block[4]/lineArea/text[2]/@offset"/>
+ <eval expected="9250" xpath="//flow/block[5]/lineArea/text[2]/@offset"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="7180" xpath="//flow/block[1]/lineArea/text[2]/@baseline"/>
+ <eval expected="0" xpath="//flow/block[1]/lineArea/text[2]/@offset"/>
+ <eval expected="5560" xpath="//flow/block[1]/lineArea/text[2]/@ipd"/>
+ <eval expected="7560" xpath="//flow/block[1]/lineArea/text[2]/@ipda"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/text[2]/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/text[2]/@border-before"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/text[2]/@border-end"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[1]/lineArea/text[2]/@border-start"/>
+
<eval expected="7180" xpath="//flow/block[2]/lineArea/text[2]/@baseline"/>
<eval expected="0" xpath="//flow/block[2]/lineArea/text[2]/@offset"/>
<eval expected="5560" xpath="//flow/block[2]/lineArea/text[2]/@ipd"/>
- <eval expected="7560" xpath="//flow/block[2]/lineArea/text[2]/@ipda"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/text[2]/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/text[2]/@border-before"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/text[2]/@border-end"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[2]/lineArea/text[2]/@border-start"/>
-
- <eval expected="7180" xpath="//flow/block[5]/lineArea/text[2]/@baseline"/>
- <eval expected="0" xpath="//flow/block[5]/lineArea/text[2]/@offset"/>
- <eval expected="5560" xpath="//flow/block[5]/lineArea/text[2]/@ipd"/>
- <eval expected="25560" xpath="//flow/block[5]/lineArea/text[2]/@ipda"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/text[2]/@border-after"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/text[2]/@border-before"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/text[2]/@border-end"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[5]/lineArea/text[2]/@border-start"/>
- <eval expected="5000" xpath="//flow/block[5]/lineArea/text[2]/@padding-after"/>
- <eval expected="5000" xpath="//flow/block[5]/lineArea/text[2]/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[5]/lineArea/text[2]/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[5]/lineArea/text[2]/@padding-start"/>
+ <eval expected="25560" xpath="//flow/block[2]/lineArea/text[2]/@ipda"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/text[2]/@border-after"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/text[2]/@border-before"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/text[2]/@border-end"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[2]/lineArea/text[2]/@border-start"/>
+ <eval expected="5000" xpath="//flow/block[2]/lineArea/text[2]/@padding-after"/>
+ <eval expected="5000" xpath="//flow/block[2]/lineArea/text[2]/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[2]/lineArea/text[2]/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[2]/lineArea/text[2]/@padding-start"/>
- <eval expected="7180" xpath="//flow/block[8]/lineArea/text[2]/@baseline"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea/text[2]/@offset"/>
- <eval expected="5560" xpath="//flow/block[8]/lineArea/text[2]/@ipd"/>
- <eval expected="17560" xpath="//flow/block[8]/lineArea/text[2]/@ipda"/>
- <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[8]/lineArea/text[2]/@border-after"/>
- <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[8]/lineArea/text[2]/@border-before"/>
- <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[8]/lineArea/text[2]/@border-end"/>
- <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[8]/lineArea/text[2]/@border-start"/>
- <eval expected="3000" xpath="//flow/block[8]/lineArea/text[2]/@padding-after"/>
- <eval expected="1000" xpath="//flow/block[8]/lineArea/text[2]/@padding-before"/>
- <eval expected="2000" xpath="//flow/block[8]/lineArea/text[2]/@padding-end"/>
- <eval expected="4000" xpath="//flow/block[8]/lineArea/text[2]/@padding-start"/>
+ <eval expected="7180" xpath="//flow/block[3]/lineArea/text[2]/@baseline"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea/text[2]/@offset"/>
+ <eval expected="5560" xpath="//flow/block[3]/lineArea/text[2]/@ipd"/>
+ <eval expected="17560" xpath="//flow/block[3]/lineArea/text[2]/@ipda"/>
+ <eval expected="(solid,#ff0000,3000)" xpath="//flow/block[3]/lineArea/text[2]/@border-after"/>
+ <eval expected="(solid,#ff0000,1000)" xpath="//flow/block[3]/lineArea/text[2]/@border-before"/>
+ <eval expected="(solid,#ff0000,2000)" xpath="//flow/block[3]/lineArea/text[2]/@border-end"/>
+ <eval expected="(solid,#ff0000,4000)" xpath="//flow/block[3]/lineArea/text[2]/@border-start"/>
+ <eval expected="3000" xpath="//flow/block[3]/lineArea/text[2]/@padding-after"/>
+ <eval expected="1000" xpath="//flow/block[3]/lineArea/text[2]/@padding-before"/>
+ <eval expected="2000" xpath="//flow/block[3]/lineArea/text[2]/@padding-end"/>
+ <eval expected="4000" xpath="//flow/block[3]/lineArea/text[2]/@padding-start"/>
- <eval expected="5744" xpath="//flow/block[11]/lineArea/text[2]/@baseline"/>
- <eval expected="8616" xpath="//flow/block[11]/lineArea/text[2]/@offset"/>
- <eval expected="4448" xpath="//flow/block[11]/lineArea/text[2]/@ipd"/>
- <eval expected="24448" xpath="//flow/block[11]/lineArea/text[2]/@ipda"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/text[2]/@border-after"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/text[2]/@border-before"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/text[2]/@border-end"/>
- <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[11]/lineArea/text[2]/@border-start"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea/text[2]/@padding-after"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea/text[2]/@padding-before"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea/text[2]/@padding-end"/>
- <eval expected="5000" xpath="//flow/block[11]/lineArea/text[2]/@padding-start"/>
+ <eval expected="5744" xpath="//flow/block[4]/lineArea/text[2]/@baseline"/>
+ <eval expected="8616" xpath="//flow/block[4]/lineArea/text[2]/@offset"/>
+ <eval expected="4448" xpath="//flow/block[4]/lineArea/text[2]/@ipd"/>
+ <eval expected="24448" xpath="//flow/block[4]/lineArea/text[2]/@ipda"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/text[2]/@border-after"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/text[2]/@border-before"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/text[2]/@border-end"/>
+ <eval expected="(solid,#ff0000,5000)" xpath="//flow/block[4]/lineArea/text[2]/@border-start"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea/text[2]/@padding-after"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea/text[2]/@padding-before"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea/text[2]/@padding-end"/>
+ <eval expected="5000" xpath="//flow/block[4]/lineArea/text[2]/@padding-start"/>
</checks>
</testcase>
</fo:root>
</fo>
<checks>
+ <eval expected="7180" xpath="//flow/block[1]/lineArea/text[2]/@offset"/>
<eval expected="7180" xpath="//flow/block[2]/lineArea/text[2]/@offset"/>
- <eval expected="7180" xpath="//flow/block[5]/lineArea/text[2]/@offset"/>
- <eval expected="0" xpath="//flow/block[8]/lineArea/text[2]/@offset"/>
- <eval expected="4565" xpath="//flow/block[11]/lineArea/text[2]/@offset"/>
- <eval expected="9250" xpath="//flow/block[14]/lineArea/text[2]/@offset"/>
+ <eval expected="0" xpath="//flow/block[3]/lineArea/text[2]/@offset"/>
+ <eval expected="4565" xpath="//flow/block[4]/lineArea/text[2]/@offset"/>
+ <eval expected="9250" xpath="//flow/block[5]/lineArea/text[2]/@offset"/>
</checks>
</testcase>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<testcase>
+ <info>
+ <p>
+ This test checks if space resolution works in side regions.
+ </p>
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="5in">
+ <fo:region-body margin-top="50pt"/>
+ <fo:region-before extent="50pt" background-color="yellow"/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal" white-space-collapse="true">
+ <fo:static-content flow-name="xsl-region-before">
+ <fo:block space-before="1em" space-after="1em">line 1</fo:block>
+ <fo:block space-before="1em" space-after="1em">line 2</fo:block>
+ </fo:static-content>
+ <fo:flow flow-name="xsl-region-body">
+ <fo:block>region-body</fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <element-list category="static-content" id="xsl-region-before">
+ <box w="0"/> <!-- SpaceHandlingPosition -->
+ <box w="14400"/>
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="12000"/>
+
+ <box w="14400"/>
+
+ <box w="0"/> <!-- SpaceHandlingPosition -->
+ <skip>3</skip>
+ </element-list>
+
+ <true xpath="not(boolean(//regionBefore/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//regionBefore/block[1]/@space-after))"/>
+ <eval expected="12000" xpath="//regionBefore/block[2]/@space-before"/>
+ <true xpath="not(boolean(//regionBefore/block[2]/@space-after))"/>
+ </checks>
+</testcase>
<true xpath="//flow/block[1]/block[1]/@is-reference-area"/>
<eval expected="144000" xpath="//flow/block[1]/block[1]/@ipd"/>
<eval expected="43200" xpath="//flow/block[1]/block[1]/@bpd"/>
- <eval expected="115200" xpath="//flow/block[1]/block[1]/block[2]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[1]/block[1]/block[2]/@bpd"/>
- <eval expected="14400" xpath="//flow/block[1]/block[1]/block[2]/@start-indent"/>
- <eval expected="14400" xpath="//flow/block[1]/block[1]/block[2]/@space-start"/>
- <eval expected="14400" xpath="//flow/block[1]/block[1]/block[2]/@end-indent"/>
- <eval expected="14400" xpath="//flow/block[1]/block[1]/block[2]/@space-end"/>
+ <eval expected="115200" xpath="//flow/block[1]/block[1]/block[1]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[1]/block[1]/block[1]/@bpd"/>
+ <eval expected="14400" xpath="//flow/block[1]/block[1]/block[1]/@space-before"/>
+ <eval expected="14400" xpath="//flow/block[1]/block[1]/block[1]/@space-after"/>
+ <eval expected="14400" xpath="//flow/block[1]/block[1]/block[1]/@start-indent"/>
+ <eval expected="14400" xpath="//flow/block[1]/block[1]/block[1]/@space-start"/>
+ <eval expected="14400" xpath="//flow/block[1]/block[1]/block[1]/@end-indent"/>
+ <eval expected="14400" xpath="//flow/block[1]/block[1]/block[1]/@space-end"/>
<!-- cell 2 -->
<true xpath="//flow/block[1]/block[2]/@is-reference-area"/>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<testcase>
+ <info>
+ <p>
+ This test checks border and padding conditionality on table.
+ </p>
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="2in">
+ <fo:region-body/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal" id="retain">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:table table-layout="fixed" width="100%" border-collapse="separate" border-spacing="5pt">
+ <fo:table-column column-width="proportional-column-width(1)"/>
+ <fo:table-column column-width="proportional-column-width(9)"/>
+ <fo:table-body>
+ <fo:table-row>
+ <fo:table-cell background-color="yellow"
+ padding-before="20pt" padding-before.conditionality="retain"
+ padding-after="20pt" padding-after.conditionality="retain"
+ border-before-style="solid" border-before-width="5pt" border-before-width.conditionality="retain"
+ border-after-style="solid" border-after-width="5pt" border-after-width.conditionality="retain">
+ <fo:block>cell1</fo:block>
+ </fo:table-cell>
+ <fo:table-cell background-color="orange"
+ padding-before="20pt" padding-before.conditionality="retain"
+ padding-after="20pt" padding-after.conditionality="retain"
+ border-before-style="solid" border-before-width="5pt" border-before-width.conditionality="retain"
+ border-after-style="solid" border-after-width="5pt" border-after-width.conditionality="retain">
+ <fo:block text-align="justify">
+In olden times when wishing still helped one, there lived a king whose daughters
+were all beautiful; and the youngest was so beautiful that the sun itself, which
+has seen so much, was astonished whenever it shone in her face. Close by the king's
+castle lay a great dark forest, and under an old lime-tree in the forest was a well,
+and when the day was very warm, the king's child went out into the forest and sat
+down by the side of the cool fountain; and when she was bored she took a golden ball,
+and threw it up on high and caught it; and this ball was her favorite plaything.
+ </fo:block>
+ </fo:table-cell>
+ </fo:table-row>
+ </fo:table-body>
+ </fo:table>
+ </fo:flow>
+ </fo:page-sequence>
+ <fo:page-sequence master-reference="normal" id="discard">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:table table-layout="fixed" width="100%" border-collapse="separate" border-spacing="5pt">
+ <fo:table-column column-width="proportional-column-width(1)"/>
+ <fo:table-column column-width="proportional-column-width(9)"/>
+ <fo:table-body>
+ <fo:table-row>
+ <fo:table-cell background-color="yellow"
+ padding-before="20pt" padding-before.conditionality="discard"
+ padding-after="20pt" padding-after.conditionality="discard"
+ border-before-style="solid" border-before-width="5pt" border-before-width.conditionality="discard"
+ border-after-style="solid" border-after-width="5pt" border-after-width.conditionality="discard">
+ <fo:block>cell1</fo:block>
+ </fo:table-cell>
+ <fo:table-cell background-color="orange"
+ padding-before="20pt" padding-before.conditionality="discard"
+ padding-after="20pt" padding-after.conditionality="discard"
+ border-before-style="solid" border-before-width="5pt" border-before-width.conditionality="discard"
+ border-after-style="solid" border-after-width="5pt" border-after-width.conditionality="discard">
+ <fo:block text-align="justify">
+In olden times when wishing still helped one, there lived a king whose daughters
+were all beautiful; and the youngest was so beautiful that the sun itself, which
+has seen so much, was astonished whenever it shone in her face. Close by the king's
+castle lay a great dark forest, and under an old lime-tree in the forest was a well,
+and when the day was very warm, the king's child went out into the forest and sat
+down by the side of the cool fountain; and when she was bored she took a golden ball,
+and threw it up on high and caught it; and this ball was her favorite plaything.
+ </fo:block>
+ </fo:table-cell>
+ </fo:table-row>
+ </fo:table-body>
+ </fo:table>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <!-- retain case -->
+ <eval expected="(solid,#000000,5000)" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@border-before"/>
+ <eval expected="20000" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@padding-before"/>
+
+ <eval expected="(solid,#000000,5000)" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@border-after"/>
+ <eval expected="20000" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@padding-after"/>
+
+ <eval expected="(solid,#000000,5000)" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@border-before"/>
+ <eval expected="20000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@padding-before"/>
+
+ <eval expected="(solid,#000000,5000)" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@border-after"/>
+ <eval expected="20000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@padding-after"/>
+
+ <!-- discard case -->
+ <eval expected="(solid,#000000,5000)" xpath="//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@border-before"/>
+ <eval expected="20000" xpath="//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@padding-before"/>
+
+ <true xpath="not(boolean(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@border-after))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@padding-after))"/>
+
+ <true xpath="not(boolean(//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@border-before))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@padding-before))"/>
+
+ <eval expected="(solid,#000000,5000)" xpath="//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@border-after"/>
+ <eval expected="20000" xpath="//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/@padding-after"/>
+ </checks>
+</testcase>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<testcase>
+ <info>
+ <p>
+ This test checks border and padding conditionality on table.
+ </p>
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="2in">
+ <fo:region-body/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal" id="retain">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:table table-layout="fixed" width="100%" border-collapse="separate" border-spacing="5pt"
+ padding-before="20pt" padding-before.conditionality="retain"
+ padding-after="20pt" padding-after.conditionality="retain"
+ border-before-style="solid" border-before-width="5pt" border-before-width.conditionality="retain"
+ border-after-style="solid" border-after-width="5pt" border-after-width.conditionality="retain">
+ <fo:table-column column-width="proportional-column-width(1)"/>
+ <fo:table-column column-width="proportional-column-width(9)"/>
+ <fo:table-body>
+ <fo:table-row>
+ <fo:table-cell background-color="yellow">
+ <fo:block>cell1</fo:block>
+ </fo:table-cell>
+ <fo:table-cell background-color="orange">
+ <fo:block text-align="justify">
+In olden times when wishing still helped one, there lived a king whose daughters
+were all beautiful; and the youngest was so beautiful that the sun itself, which
+has seen so much, was astonished whenever it shone in her face. Close by the king's
+castle lay a great dark forest, and under an old lime-tree in the forest was a well,
+and when the day was very warm, the king's child went out into the forest and sat
+down by the side of the cool fountain; and when she was bored she took a golden ball,
+and threw it up on high and caught it; and this ball was her favorite plaything.
+ </fo:block>
+ </fo:table-cell>
+ </fo:table-row>
+ </fo:table-body>
+ </fo:table>
+ </fo:flow>
+ </fo:page-sequence>
+ <fo:page-sequence master-reference="normal" id="discard">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:table table-layout="fixed" width="100%" border-collapse="separate" border-spacing="5pt"
+ padding-before="20pt" padding-before.conditionality="discard"
+ padding-after="20pt" padding-after.conditionality="discard"
+ border-before-style="solid" border-before-width="5pt" border-before-width.conditionality="discard"
+ border-after-style="solid" border-after-width="5pt" border-after-width.conditionality="discard">
+ <fo:table-column column-width="proportional-column-width(1)"/>
+ <fo:table-column column-width="proportional-column-width(9)"/>
+ <fo:table-body>
+ <fo:table-row>
+ <fo:table-cell background-color="yellow">
+ <fo:block>cell1</fo:block>
+ </fo:table-cell>
+ <fo:table-cell background-color="orange">
+ <fo:block text-align="justify">
+In olden times when wishing still helped one, there lived a king whose daughters
+were all beautiful; and the youngest was so beautiful that the sun itself, which
+has seen so much, was astonished whenever it shone in her face. Close by the king's
+castle lay a great dark forest, and under an old lime-tree in the forest was a well,
+and when the day was very warm, the king's child went out into the forest and sat
+down by the side of the cool fountain; and when she was bored she took a golden ball,
+and threw it up on high and caught it; and this ball was her favorite plaything.
+ </fo:block>
+ </fo:table-cell>
+ </fo:table-row>
+ </fo:table-body>
+ </fo:table>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <element-list category="breaker" id="retain">
+ <box w="0"/> <!-- Helper box bearing the SpaceHandlingPosition and making sure the glue gets processed -->
+ <penalty w="0" p="INF"/>
+ <glue w="25000"/>
+
+ <box w="0"/>
+
+ <penalty w="0" p="INF"/>
+ <glue w="25000"/>
+ <penalty w="14400"/> <!-- p is not of interest here -->
+ <glue w="-50000"/>
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="25000"/>
+
+ <box w="28800"/>
+
+ <penalty w="0" p="INF"/>
+ <glue w="25000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-50000"/>
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="25000"/>
+
+ <box w="14400"/>
+
+ <!-- skip three more lines -->
+ <skip>8</skip>
+ <skip>8</skip>
+ <skip>8</skip>
+ <skip>8</skip>
+ <skip>8</skip>
+
+ <penalty w="0" p="INF"/>
+ <glue w="25000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-50000"/>
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="25000"/>
+
+ <box w="28800"/> <!-- end of table -->
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="25000"/>
+
+ <box w="0"/> <!-- This is used to make sure the preceding glue is not cut off -->
+
+ <skip>3</skip>
+ </element-list>
+ <element-list category="breaker" id="discard">
+ <box w="0"/> <!-- Helper box used to notify the LM for the addAreas stage about the discarded spaces -->
+ <penalty w="0" p="INF"/>
+ <glue w="25000"/>
+ <box w="0"/>
+ <penalty w="14400"/> <!-- p is not of interest here -->
+ <box w="28800"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="28800"/>
+
+ <box w="0"/> <!-- SpaceHandlingPosition-bearing helper box -->
+
+ <penalty w="0" p="INF"/>
+ <glue w="25000"/>
+ <box w="0"/> <!-- This is used to make sure the preceding glue is not cut off -->
+
+ <skip>3</skip>
+ </element-list>
+
+ <!-- retain case -->
+ <eval expected="(solid,#000000,5000)" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@border-before"/>
+ <eval expected="20000" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@padding-before"/>
+
+ <eval expected="(solid,#000000,5000)" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@border-after"/>
+ <eval expected="20000" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@padding-after"/>
+
+ <eval expected="(solid,#000000,5000)" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@border-before"/>
+ <eval expected="20000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@padding-before"/>
+
+ <eval expected="(solid,#000000,5000)" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@border-after"/>
+ <eval expected="20000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@padding-after"/>
+
+ <!-- discard case -->
+ <eval expected="(solid,#000000,5000)" xpath="//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@border-before"/>
+ <eval expected="20000" xpath="//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@padding-before"/>
+
+ <true xpath="not(boolean(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@border-after))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@padding-after))"/>
+
+ <true xpath="not(boolean(//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@border-before))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@padding-before))"/>
+
+ <eval expected="(solid,#000000,5000)" xpath="//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@border-after"/>
+ <eval expected="20000" xpath="//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@padding-after"/>
+ </checks>
+</testcase>
-->
<!-- $Id$ -->
<testcase>
- <info>
+ <info>
+ <p>
This test checks basic tables. Tests table spaces and margins.
</p>
- </info>
- <fo>
- <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
- <fo:layout-master-set>
- <fo:simple-page-master master-name="normal" page-width="5in" page-height="5in">
- <fo:region-body/>
- </fo:simple-page-master>
- </fo:layout-master-set>
- <fo:page-sequence master-reference="normal" white-space-collapse="true">
- <fo:flow flow-name="xsl-region-body">
- <fo:block background-color="orange">before table</fo:block>
- <fo:table table-layout="fixed" space-before="5pt" space-after="10pt" margin-left="5pt" margin-right="10pt" width="4in + 15pt" background-color="lightgray">
- <fo:table-column column-width="2in"/>
- <fo:table-column column-width="2in"/>
- <fo:table-body start-indent="0pt" end-indent="0pt">
- <fo:table-row>
- <fo:table-cell>
- <fo:block>cell1</fo:block>
- </fo:table-cell>
- <fo:table-cell background-color="yellow">
- <fo:block>cell2</fo:block>
- </fo:table-cell>
- </fo:table-row>
- <fo:table-row>
- <fo:table-cell background-color="orange">
- <fo:block text-align="end">cell3</fo:block>
- </fo:table-cell>
- <fo:table-cell>
- <fo:block>cell4</fo:block>
- </fo:table-cell>
- </fo:table-row>
- </fo:table-body>
- </fo:table>
- <fo:block background-color="orange">after table</fo:block>
- <fo:block-container width="4in + 15pt">
- <fo:block space-before="5pt" space-after="10pt" margin-left="5pt" margin-right="10pt" background-color="lightgray">
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="5in">
+ <fo:region-body/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal" white-space-collapse="true">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:block background-color="orange">before table</fo:block>
+ <fo:table table-layout="fixed" space-before="5pt" space-after="10pt" margin-left="5pt" margin-right="10pt" width="4in + 15pt" background-color="lightgray">
+ <fo:table-column column-width="2in"/>
+ <fo:table-column column-width="2in"/>
+ <fo:table-body start-indent="0pt" end-indent="0pt">
+ <fo:table-row>
+ <fo:table-cell>
+ <fo:block>cell1</fo:block>
+ </fo:table-cell>
+ <fo:table-cell background-color="yellow">
+ <fo:block>cell2</fo:block>
+ </fo:table-cell>
+ </fo:table-row>
+ <fo:table-row>
+ <fo:table-cell background-color="orange">
+ <fo:block text-align="end">cell3</fo:block>
+ </fo:table-cell>
+ <fo:table-cell>
+ <fo:block>cell4</fo:block>
+ </fo:table-cell>
+ </fo:table-row>
+ </fo:table-body>
+ </fo:table>
+ <fo:block background-color="orange">after table</fo:block>
+ <fo:block-container width="4in + 15pt">
+ <fo:block space-before="5pt" space-after="10pt" margin-left="5pt" margin-right="10pt" background-color="lightgray">
reference block
</fo:block>
- </fo:block-container>
- </fo:flow>
- </fo:page-sequence>
- </fo:root>
- </fo>
- <checks>
- <!-- spaces -->
- <eval expected="5000" xpath="//flow/block[2]/@bpd"/>
- <eval expected="10000" xpath="//flow/block[4]/@bpd"/>
- <!-- table dimensions -->
- <eval expected="303000" xpath="//flow/block[3]/@ipda"/>
- <eval expected="303000" xpath="//flow/block[3]/@ipd"/>
- <eval expected="28800" xpath="//flow/block[3]/@bpda"/>
- <eval expected="28800" xpath="//flow/block[3]/@bpd"/>
- <!-- cell 1 -->
- <true xpath="//flow/block[3]/block[1]/@is-reference-area"/>
- <eval expected="5000" xpath="//flow/block[3]/block[1]/@left-offset"/>
- <true xpath="not(boolean(//flow/block[3]/block[1]/@top-offset)) or (//flow/block[3]/block[1]/@top-offset = 0)"/>
- <eval expected="144000" xpath="//flow/block[3]/block[1]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[1]/@bpd"/>
- <eval expected="144000" xpath="//flow/block[3]/block[1]/block[1]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[1]/block[1]/@bpd"/>
- <eval expected="cell1" xpath="//flow/block[3]/block[1]/block[1]/lineArea"/>
- <!-- cell 2 -->
- <true xpath="//flow/block[3]/block[2]/@is-reference-area"/>
- <eval expected="149000" xpath="//flow/block[3]/block[2]/@left-offset"/>
- <true xpath="not(boolean(//flow/block[3]/block[2]/@top-offset)) or (//flow/block[3]/block[2]/@top-offset = 0)"/>
- <eval expected="144000" xpath="//flow/block[3]/block[2]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[2]/@bpd"/>
- <eval expected="144000" xpath="//flow/block[3]/block[2]/block[1]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[2]/block[1]/@bpd"/>
- <eval expected="cell2" xpath="//flow/block[3]/block[2]/block[1]/lineArea"/>
- <eval expected="color=#ffff00" xpath="//flow/block[3]/block[2]/@background"/>
- <!-- cell 3 -->
- <true xpath="//flow/block[3]/block[3]/@is-reference-area"/>
- <eval expected="5000" xpath="//flow/block[3]/block[3]/@left-offset"/>
- <eval expected="14400" xpath="//flow/block[3]/block[3]/@top-offset"/>
- <eval expected="144000" xpath="//flow/block[3]/block[3]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[3]/@bpd"/>
- <eval expected="144000" xpath="//flow/block[3]/block[3]/block[1]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[3]/block[1]/@bpd"/>
- <eval expected="cell3" xpath="//flow/block[3]/block[3]/block[1]/lineArea"/>
- <eval expected="color=#ffa500" xpath="//flow/block[3]/block[3]/@background"/>
- <!-- cell 4 -->
- <true xpath="//flow/block[3]/block[4]/@is-reference-area"/>
- <eval expected="149000" xpath="//flow/block[3]/block[4]/@left-offset"/>
- <eval expected="14400" xpath="//flow/block[3]/block[4]/@top-offset"/>
- <eval expected="144000" xpath="//flow/block[3]/block[4]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[4]/@bpd"/>
- <eval expected="144000" xpath="//flow/block[3]/block[4]/block[1]/@ipd"/>
- <eval expected="14400" xpath="//flow/block[3]/block[4]/block[1]/@bpd"/>
- <eval expected="cell4" xpath="//flow/block[3]/block[4]/block[1]/lineArea"/>
- </checks>
+ </fo:block-container>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <!-- spaces -->
+ <eval expected="5000" xpath="//flow/block[2]/@space-before"/>
+ <eval expected="10000" xpath="//flow/block[2]/@space-after"/>
+ <!-- table dimensions -->
+ <eval expected="303000" xpath="//flow/block[2]/@ipda"/>
+ <eval expected="303000" xpath="//flow/block[2]/@ipd"/>
+ <eval expected="43800" xpath="//flow/block[2]/@bpda"/>
+ <eval expected="28800" xpath="//flow/block[2]/@bpd"/>
+ <!-- cell 1 -->
+ <true xpath="//flow/block[2]/block[1]/@is-reference-area"/>
+ <eval expected="5000" xpath="//flow/block[2]/block[1]/@left-offset"/>
+ <true xpath="not(boolean(//flow/block[2]/block[1]/@top-offset)) or (//flow/block[3]/block[1]/@top-offset = 0)"/>
+ <eval expected="144000" xpath="//flow/block[2]/block[1]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[1]/@bpd"/>
+ <eval expected="144000" xpath="//flow/block[2]/block[1]/block[1]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[1]/block[1]/@bpd"/>
+ <eval expected="cell1" xpath="//flow/block[2]/block[1]/block[1]/lineArea"/>
+ <!-- cell 2 -->
+ <true xpath="//flow/block[2]/block[2]/@is-reference-area"/>
+ <eval expected="149000" xpath="//flow/block[2]/block[2]/@left-offset"/>
+ <true xpath="not(boolean(//flow/block[2]/block[2]/@top-offset)) or (//flow/block[3]/block[2]/@top-offset = 0)"/>
+ <eval expected="144000" xpath="//flow/block[2]/block[2]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[2]/@bpd"/>
+ <eval expected="144000" xpath="//flow/block[2]/block[2]/block[1]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[2]/block[1]/@bpd"/>
+ <eval expected="cell2" xpath="//flow/block[2]/block[2]/block[1]/lineArea"/>
+ <eval expected="color=#ffff00" xpath="//flow/block[2]/block[2]/@background"/>
+ <!-- cell 3 -->
+ <true xpath="//flow/block[2]/block[3]/@is-reference-area"/>
+ <eval expected="5000" xpath="//flow/block[2]/block[3]/@left-offset"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[3]/@top-offset"/>
+ <eval expected="144000" xpath="//flow/block[2]/block[3]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[3]/@bpd"/>
+ <eval expected="144000" xpath="//flow/block[2]/block[3]/block[1]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[3]/block[1]/@bpd"/>
+ <eval expected="cell3" xpath="//flow/block[2]/block[3]/block[1]/lineArea"/>
+ <eval expected="color=#ffa500" xpath="//flow/block[2]/block[3]/@background"/>
+ <!-- cell 4 -->
+ <true xpath="//flow/block[2]/block[4]/@is-reference-area"/>
+ <eval expected="149000" xpath="//flow/block[2]/block[4]/@left-offset"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[4]/@top-offset"/>
+ <eval expected="144000" xpath="//flow/block[2]/block[4]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[4]/@bpd"/>
+ <eval expected="144000" xpath="//flow/block[2]/block[4]/block[1]/@ipd"/>
+ <eval expected="14400" xpath="//flow/block[2]/block[4]/block[1]/@bpd"/>
+ <eval expected="cell4" xpath="//flow/block[2]/block[4]/block[1]/lineArea"/>
+ </checks>
</testcase>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<testcase>
+ <info>
+ <p>
+ This test checks space properties on table.
+ </p>
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="1.8in">
+ <fo:region-body/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal" id="retain">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:table table-layout="fixed" width="100%" border-collapse="separate" space-before="20pt" space-before.conditionality="retain" space-after="10pt" space-after.conditionality="retain">
+ <fo:table-column column-width="proportional-column-width(1)"/>
+ <fo:table-column column-width="proportional-column-width(9)"/>
+ <fo:table-body>
+ <fo:table-row>
+ <fo:table-cell>
+ <fo:block>cell1</fo:block>
+ </fo:table-cell>
+ <fo:table-cell>
+ <fo:block text-align="justify">
+In olden times when wishing still helped one, there lived a king whose daughters
+were all beautiful; and the youngest was so beautiful that the sun itself, which
+has seen so much, was astonished whenever it shone in her face. Close by the king's
+castle lay a great dark forest, and under an old lime-tree in the forest was a well,
+and when the day was very warm, the king's child went out into the forest and sat
+down by the side of the cool fountain; and when she was bored she took a golden ball,
+and threw it up on high and caught it; and this ball was her favorite plaything.
+ </fo:block>
+ </fo:table-cell>
+ </fo:table-row>
+ </fo:table-body>
+ </fo:table>
+ <fo:block space-before.optimum="10pt" space-before.conditionality="retain" space-after="20pt" space-after.conditionality="retain">
+Two blocks, testing conditionality="retain".
+ </fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+ <fo:page-sequence master-reference="normal" id="discard">
+ <fo:flow flow-name="xsl-region-body">
+ <fo:table table-layout="fixed" width="100%" border-collapse="separate" space-before="20pt" space-before.conditionality="discard" space-after="10pt" space-after.conditionality="discard">
+ <fo:table-column column-width="proportional-column-width(1)"/>
+ <fo:table-column column-width="proportional-column-width(9)"/>
+ <fo:table-body>
+ <fo:table-row>
+ <fo:table-cell>
+ <fo:block>cell1</fo:block>
+ </fo:table-cell>
+ <fo:table-cell>
+ <fo:block text-align="justify">
+In olden times when wishing still helped one, there lived a king whose daughters
+were all beautiful; and the youngest was so beautiful that the sun itself, which
+has seen so much, was astonished whenever it shone in her face. Close by the king's
+castle lay a great dark forest, and under an old lime-tree in the forest was a well,
+and when the day was very warm, the king's child went out into the forest and sat
+down by the side of the cool fountain; and when she was bored she took a golden ball,
+and threw it up on high and caught it; and this ball was her favorite plaything.
+ </fo:block>
+ </fo:table-cell>
+ </fo:table-row>
+ </fo:table-body>
+ </fo:table>
+ <fo:block space-before="10pt" space-before.conditionality="discard" space-after="20pt" space-after.conditionality="discard">
+Two blocks, testing conditionality="discard".
+ </fo:block>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <element-list category="breaker" id="retain">
+ <box w="0"/> <!-- Helper box bearing the SpaceHandlingPosition and making sure the glue gets processed -->
+ <penalty w="0" p="INF"/>
+ <glue w="20000"/>
+
+ <box w="0"/>
+
+ <penalty w="0" p="INF"/>
+ <glue w="10000"/>
+ <penalty w="14400"/> <!-- p is not of interest here -->
+ <glue w="-30000"/>
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="20000"/>
+
+ <box w="28800"/>
+
+ <penalty w="0" p="INF"/>
+ <glue w="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-30000"/>
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="20000"/>
+
+ <box w="14400"/>
+
+ <!-- skip three more lines -->
+ <skip>8</skip>
+ <skip>8</skip>
+ <skip>8</skip>
+ <skip>8</skip>
+ <skip>8</skip>
+
+ <penalty w="0" p="INF"/>
+ <glue w="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-30000"/>
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="20000"/>
+
+ <box w="28800"/> <!-- end of table -->
+
+ <penalty w="0" p="INF" aux="true"/>
+ <glue w="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-10000"/>
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="10000"/>
+
+ <box w="14400"/> <!-- second block -->
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="20000"/>
+
+ <box w="0"/> <!-- This is used to make sure the preceding glue is not cut off -->
+
+ <skip>3</skip>
+ </element-list>
+ <element-list category="breaker" id="discard">
+ <box w="0"/> <!-- Helper box used to notify the LM for the addAreas stage about the discarded spaces -->
+ <box w="0"/>
+ <penalty w="14400"/> <!-- p is not of interest here -->
+ <box w="28800"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="14400"/>
+ <penalty w="0" p="0"/>
+ <box w="28800"/>
+ <penalty w="0" p="0"/>
+ <glue w="10000"/>
+
+ <box w="14400"/> <!-- second block -->
+
+ <box w="0"/> <!-- SpaceHandlingPosition-bearing helper box -->
+
+ <skip>3</skip>
+ </element-list>
+
+ <eval expected="4" xpath="count(//pageViewport)"/>
+
+ <!-- 1: retain -->
+ <eval expected="20000" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+ <eval expected="10000" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-after"/>
+ <eval expected="20000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+ <!-- the following space is eliminated/collapsed through space resolution -->
+ <true xpath="not(boolean(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-after))"/>
+ <eval expected="10000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[2]/@space-before"/>
+ <eval expected="20000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[2]/@space-after"/>
+
+ <!-- 2: discard -->
+ <true xpath="not(boolean(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before))"/>
+ <true xpath="not(boolean(//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-after))"/>
+ <eval expected="10000" xpath="//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[2]/@space-before"/>
+ <true xpath="not(boolean(//pageViewport[@nr=4]/page/regionViewport/regionBody/mainReference/span/flow/block[2]/@space-after))"/>
+ </checks>
+</testcase>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2005 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$ -->
+<testcase>
+ <info>
+ <p>
+ This test checks space properties on table. Demonstrates that spaces are repeated on every generated area.
+ </p>
+ </info>
+ <fo>
+ <fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:svg="http://www.w3.org/2000/svg">
+ <fo:layout-master-set>
+ <fo:simple-page-master master-name="normal" page-width="5in" page-height="30pt">
+ <fo:region-body/>
+ </fo:simple-page-master>
+ </fo:layout-master-set>
+ <fo:page-sequence master-reference="normal" white-space-collapse="true">
+ <fo:flow flow-name="xsl-region-body" line-height="10pt" font-size="9pt">
+ <fo:table table-layout="fixed" width="100%" border-collapse="separate" space-before="5pt" space-before.conditionality="retain" background-color="yellow">
+ <fo:table-column column-width="proportional-column-width(1)"/>
+ <fo:table-column column-width="proportional-column-width(9)"/>
+ <fo:table-body>
+ <fo:table-row>
+ <fo:table-cell>
+ <fo:block>cell1</fo:block>
+ </fo:table-cell>
+ <fo:table-cell>
+ <fo:block>line 1</fo:block>
+ <fo:block>line 2</fo:block>
+ <fo:block>line 3</fo:block>
+ <fo:block>line 4</fo:block>
+ <fo:block>line 5</fo:block>
+ </fo:table-cell>
+ </fo:table-row>
+ </fo:table-body>
+ </fo:table>
+ </fo:flow>
+ </fo:page-sequence>
+ </fo:root>
+ </fo>
+ <checks>
+ <element-list category="breaker">
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="5000"/>
+ <box w="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-5000"/>
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="5000"/>
+ <box w="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-5000"/>
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="5000"/>
+ <box w="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-5000"/>
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="5000"/>
+ <box w="10000"/>
+ <penalty w="0" p="0"/>
+ <glue w="-5000"/>
+
+ <box w="0"/>
+ <penalty w="0" p="INF"/>
+ <glue w="5000"/>
+ <box w="10000"/>
+
+ <skip>3</skip>
+ </element-list>
+ <eval expected="3" xpath="count(//pageViewport)"/>
+ <eval expected="5000" xpath="//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+ <eval expected="5000" xpath="//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+ <eval expected="5000" xpath="//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/@space-before"/>
+ <eval expected="1" xpath="count(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block)"/>
+ <eval expected="1" xpath="count(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block)"/>
+ <eval expected="1" xpath="count(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block)"/>
+ <eval expected="2" xpath="count(//pageViewport[@nr=1]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[2]/block)"/>
+ <eval expected="2" xpath="count(//pageViewport[@nr=2]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block)"/>
+ <eval expected="1" xpath="count(//pageViewport[@nr=3]/page/regionViewport/regionBody/mainReference/span/flow/block[1]/block[1]/block)"/>
+
+ </checks>
+</testcase>
<eval expected="220000" xpath="//flow/block[1]/block[2]/@ipda"/>
<eval expected="220000" xpath="//flow/block[1]/block[2]/@ipd"/>
- <eval expected="10000" xpath="//flow/block[2]/@bpda"/> <!-- space-before -->
+ <eval expected="10000" xpath="//flow/block[2]/@space-before"/>
<!-- table 2 -->
- <eval expected="310000" xpath="//flow/block[3]/@ipda"/>
- <eval expected="300000" xpath="//flow/block[3]/@ipd"/>
- <eval expected="100000" xpath="//flow/block[3]/block[1]/@ipda"/>
- <eval expected="100000" xpath="//flow/block[3]/block[1]/@ipd"/>
- <eval expected="66666" xpath="//flow/block[3]/block[2]/@ipda"/>
- <eval expected="66666" xpath="//flow/block[3]/block[2]/@ipd"/>
- <eval expected="133333" xpath="//flow/block[3]/block[3]/@ipda"/>
- <eval expected="133333" xpath="//flow/block[3]/block[3]/@ipd"/>
+ <eval expected="310000" xpath="//flow/block[2]/@ipda"/>
+ <eval expected="300000" xpath="//flow/block[2]/@ipd"/>
+ <eval expected="100000" xpath="//flow/block[2]/block[1]/@ipda"/>
+ <eval expected="100000" xpath="//flow/block[2]/block[1]/@ipd"/>
+ <eval expected="66666" xpath="//flow/block[2]/block[2]/@ipda"/>
+ <eval expected="66666" xpath="//flow/block[2]/block[2]/@ipd"/>
+ <eval expected="133333" xpath="//flow/block[2]/block[3]/@ipda"/>
+ <eval expected="133333" xpath="//flow/block[2]/block[3]/@ipd"/>
</checks>
</testcase>
projects / xmlgraphics-fop.git / commitdiff