import org.apache.xmlgraphics.util.QName;
+import org.apache.fop.layoutmgr.BlockLevelEventProducer;
+
/**
* Element mapping class for all XSL-FO elements.
*/
static class PageSequenceMasterMaker extends ElementMapping.Maker {
public FONode make(FONode parent) {
- return new org.apache.fop.fo.pagination.PageSequenceMaster(parent);
+ return new org.apache.fop.fo.pagination.PageSequenceMaster(parent,
+ BlockLevelEventProducer.Provider.get(
+ parent.getUserAgent().getEventBroadcaster()));
}
}
import org.apache.fop.fo.FObj;
import org.apache.fop.fo.PropertyList;
import org.apache.fop.fo.ValidationException;
+import org.apache.fop.layoutmgr.BlockLevelEventProducer;
/**
* Class modelling the <a href="http://www.w3.org/TR/xsl/#fo_conditional-page-master-reference">
public class ConditionalPageMasterReference extends FObj {
// The value of properties relevant for fo:conditional-page-master-reference.
private String masterReference;
+ // The simple page master referenced
+ private SimplePageMaster master;
private int pagePosition;
private int oddOrEven;
private int blankOrNotBlank;
* Get the value for the <code>master-reference</code> property.
* @return the "master-reference" property
*/
- public String getMasterReference() {
- return masterReference;
+ public SimplePageMaster getMaster() {
+ return master;
}
/**
public int getNameId() {
return FO_CONDITIONAL_PAGE_MASTER_REFERENCE;
}
+
+ /**
+ * called by the parent RepeatablePageMasterAlternatives to resolve object references
+ * from simple page master reference names
+ * @param layoutMasterSet the layout-master-set
+ * @throws ValidationException when a named reference cannot be resolved
+ * */
+ public void resolveReferences(LayoutMasterSet layoutMasterSet) throws ValidationException {
+ master = layoutMasterSet.getSimplePageMaster(masterReference);
+ if (master == null) {
+ BlockLevelEventProducer.Provider.get(
+ getUserAgent().getEventBroadcaster())
+ .noMatchingPageMaster(this, parent.getName(), masterReference, getLocator());
+ }
+ }
}
package org.apache.fop.fo.pagination;
// Java
-import java.util.Iterator;
import java.util.Map;
import org.xml.sax.Locator;
missingChildElementError("(simple-page-master|page-sequence-master)+");
}
checkRegionNames();
+ resolveSubSequenceReferences();
}
/**
for (Region region : spmRegions.values()) {
if (allRegions.containsKey(region.getRegionName())) {
String defaultRegionName
- = allRegions.get(region.getRegionName());
+ = allRegions.get(region.getRegionName());
if (!defaultRegionName.equals(region.getDefaultRegionName())) {
getFOValidationEventProducer().regionNameMappedToMultipleRegionClasses(this,
region.getRegionName(),
}
}
+ private void resolveSubSequenceReferences() throws ValidationException {
+ for (PageSequenceMaster psm : pageSequenceMasters.values()) {
+ for (SubSequenceSpecifier subSequenceSpecifier : psm.getSubSequenceSpecifier()) {
+ subSequenceSpecifier.resolveReferences(this);
+ }
+ }
+ }
+
/**
* Add a simple page master.
* The name is checked to throw an error if already added.
* @return the requested simple-page-master
*/
public SimplePageMaster getSimplePageMaster(String masterName) {
- return this.simplePageMasters.get(masterName);
+ return simplePageMasters.get(masterName);
}
/**
import org.xml.sax.helpers.LocatorImpl;
import org.apache.fop.events.Event;
-import org.apache.fop.events.EventFormatter;
import org.apache.fop.events.EventExceptionManager.ExceptionFactory;
+import org.apache.fop.events.EventFormatter;
/**
* Exception thrown by FOP if there is a problem while producing new pages.
private String localizedMessage;
private Locator locator;
+
+ /**
+ * Creates a new PageProductionException.
+ * @param message the message
+ */
+ public PageProductionException(String message) {
+ super(message);
+ }
+
/**
* Creates a new PageProductionException.
* @param message the message
setLocator(locator);
}
+
/**
* Set a location associated with the exception.
* @param locator the locator holding the location.
*/
public void setLocator(Locator locator) {
- this.locator = new LocatorImpl(locator);
+ this.locator = locator != null ? new LocatorImpl(locator) : null;
}
// the set of flows includes StaticContent flows also
/** Map of flows to their flow name (flow-name, Flow) */
- private Map<String, Flow> flowMap;
+ private Map<String, FONode> flowMap;
/**
* The currentSimplePageMaster is either the page master for the
/** {@inheritDoc} */
protected void startOfNode() throws FOPException {
super.startOfNode();
- flowMap = new java.util.HashMap<String, Flow>();
+ flowMap = new java.util.HashMap<String, FONode>();
this.simplePageMaster
= getRoot().getLayoutMasterSet().getSimplePageMaster(masterReference);
}
/** @return the flow map for this page-sequence */
- public Map<String, Flow> getFlowMap() {
+ public Map<String, FONode> getFlowMap() {
return this.flowMap;
}
+ " isBlank=" + isBlank + ")");
}
return pageSequenceMaster.getNextSimplePageMaster(isOddPage,
- isFirstPage, isLastPage, isBlank);
+ isFirstPage, isLastPage, isBlank, getMainFlow().getFlowName());
}
/**
package org.apache.fop.fo.pagination;
// Java
+import java.util.Collections;
import java.util.List;
import org.xml.sax.Locator;
private List<SubSequenceSpecifier> subSequenceSpecifiers;
private SubSequenceSpecifier currentSubSequence;
private int currentSubSequenceNumber = -1;
+ private BlockLevelEventProducer blockLevelEventProducer;
// The terminology may be confusing. A 'page-sequence-master' consists
// of a sequence of what the XSL spec refers to as
* given {@link FONode}.
*
* @param parent {@link FONode} that is the parent of this object
+ * @param blockLevelEventProducer event producer
*/
- public PageSequenceMaster(FONode parent) {
+ public PageSequenceMaster(FONode parent, BlockLevelEventProducer blockLevelEventProducer) {
super(parent);
+ this.blockLevelEventProducer = blockLevelEventProducer;
}
/** {@inheritDoc} */
return null;
}
+ List<SubSequenceSpecifier> getSubSequenceSpecifier() {
+ return Collections.unmodifiableList(subSequenceSpecifiers);
+ }
+
/**
* Resets the subsequence specifiers subsystem.
*/
* @param isFirstPage True if the next page is the first
* @param isLastPage True if the next page is the last
* @param isBlankPage True if the next page is blank
+ * @param mainFlowName the name of the main flow of the page sequence
* @return the requested page master
* @throws PageProductionException if there's a problem determining the next page master
*/
public SimplePageMaster getNextSimplePageMaster(boolean isOddPage,
boolean isFirstPage,
boolean isLastPage,
- boolean isBlankPage)
+ boolean isBlankPage,
+ String mainFlowName)
throws PageProductionException {
if (currentSubSequence == null) {
currentSubSequence = getNextSubSequence();
if (currentSubSequence == null) {
- BlockLevelEventProducer eventProducer = BlockLevelEventProducer.Provider.get(
- getUserAgent().getEventBroadcaster());
- eventProducer.missingSubsequencesInPageSequenceMaster(this,
+ blockLevelEventProducer.missingSubsequencesInPageSequenceMaster(this,
masterName, getLocator());
}
+ if (currentSubSequence.isInfinite() && !currentSubSequence.canProcess(mainFlowName)) {
+ throw new PageProductionException(
+ "The current sub-sequence will not terminate whilst processing then main flow");
+ }
}
- String pageMasterName = currentSubSequence
- .getNextPageMasterName(isOddPage, isFirstPage, isLastPage, isBlankPage);
+
+ SimplePageMaster pageMaster = currentSubSequence
+ .getNextPageMaster(isOddPage, isFirstPage, isLastPage, isBlankPage);
+
boolean canRecover = true;
- while (pageMasterName == null) {
+
+ while (pageMaster == null) {
SubSequenceSpecifier nextSubSequence = getNextSubSequence();
+
if (nextSubSequence == null) {
- BlockLevelEventProducer eventProducer = BlockLevelEventProducer.Provider.get(
- getUserAgent().getEventBroadcaster());
- eventProducer.pageSequenceMasterExhausted(this,
+ //Sub-sequence exhausted so attempt to reuse it
+ blockLevelEventProducer.pageSequenceMasterExhausted(this,
masterName, canRecover, getLocator());
currentSubSequence.reset();
+ if (!currentSubSequence.canProcess(mainFlowName)) {
+ throw new PageProductionException(
+ "The last simple-page-master does not reference the main flow");
+ }
canRecover = false;
} else {
currentSubSequence = nextSubSequence;
}
- pageMasterName = currentSubSequence
- .getNextPageMasterName(isOddPage, isFirstPage, isLastPage, isBlankPage);
- }
- SimplePageMaster pageMaster = this.layoutMasterSet
- .getSimplePageMaster(pageMasterName);
- if (pageMaster == null) {
- BlockLevelEventProducer eventProducer = BlockLevelEventProducer.Provider.get(
- getUserAgent().getEventBroadcaster());
- eventProducer.noMatchingPageMaster(this,
- masterName, pageMasterName, getLocator());
+
+ pageMaster = currentSubSequence
+ .getNextPageMaster(isOddPage, isFirstPage, isLastPage, isBlankPage);
}
+
return pageMaster;
}
+
/** {@inheritDoc} */
public String getLocalName() {
return "page-sequence-master";
public int getNameId() {
return FO_PAGE_SEQUENCE_MASTER;
}
+
+
}
package org.apache.fop.fo.pagination;
// Java
+import java.util.ArrayList;
import java.util.List;
import org.xml.sax.Locator;
}
/** {@inheritDoc} */
- public String getNextPageMasterName(boolean isOddPage,
+ public SimplePageMaster getNextPageMaster(boolean isOddPage,
boolean isFirstPage,
boolean isLastPage,
boolean isBlankPage) {
- if (getMaximumRepeats() != INFINITE) {
- if (numberConsumed < getMaximumRepeats()) {
- numberConsumed++;
- } else {
- return null;
- }
- } else {
- numberConsumed++;
+
+ if (!isInfinite() && numberConsumed >= getMaximumRepeats()) {
+ return null;
}
+ numberConsumed++;
+
for (ConditionalPageMasterReference cpmr : conditionalPageMasterRefs) {
if (cpmr.isValid(isOddPage, isFirstPage, isLastPage, isBlankPage)) {
- return cpmr.getMasterReference();
+ return cpmr.getMaster();
}
}
+
+
return null;
}
return FO_REPEATABLE_PAGE_MASTER_ALTERNATIVES;
}
+
+
+ /** {@inheritDoc} */
+ public void resolveReferences(LayoutMasterSet layoutMasterSet) throws ValidationException {
+ for (ConditionalPageMasterReference conditionalPageMasterReference
+ : conditionalPageMasterRefs) {
+ conditionalPageMasterReference.resolveReferences(layoutMasterSet);
+ }
+
+ }
+
+ /** {@inheritDoc} */
+ public boolean canProcess(String flowName) {
+
+ boolean willTerminate = true;
+
+
+ //Look for rest spm that cannot terminate
+ ArrayList<ConditionalPageMasterReference> rest
+ = new ArrayList<ConditionalPageMasterReference>();
+ for (ConditionalPageMasterReference cpmr
+ : conditionalPageMasterRefs) {
+ if (cpmr.isValid(true, false, false, false)
+ || cpmr.isValid(false, false, false, false)) {
+ rest.add(cpmr);
+ }
+ }
+ if (!rest.isEmpty()) {
+ willTerminate = false;
+ for (ConditionalPageMasterReference cpmr : rest) {
+ willTerminate |= cpmr.getMaster().getRegion(FO_REGION_BODY).getRegionName()
+ .equals(flowName);
+ }
+ }
+
+
+ return willTerminate;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isInfinite() {
+ return getMaximumRepeats() == INFINITE;
+ }
+
+
+
}
import org.apache.fop.fo.PropertyList;
import org.apache.fop.fo.ValidationException;
import org.apache.fop.fo.properties.Property;
+import org.apache.fop.layoutmgr.BlockLevelEventProducer;
/**
* Class modelling the <a href="http://www.w3.org/TR/xsl/#fo_repeatable-page-master-reference">
// The value of properties relevant for fo:repeatable-page-master-reference.
private String masterReference;
+ // The simple page master referenced
+ private SimplePageMaster master;
private Property maximumRepeats;
// End of property values
}
/** {@inheritDoc} */
- public String getNextPageMasterName(boolean isOddPage,
+ public SimplePageMaster getNextPageMaster(boolean isOddPage,
boolean isFirstPage,
boolean isLastPage,
boolean isEmptyPage) {
- if (getMaximumRepeats() != INFINITE) {
- if (numberConsumed < getMaximumRepeats()) {
- numberConsumed++;
- } else {
- return null;
- }
+ if (getMaximumRepeats() != INFINITE && numberConsumed >= getMaximumRepeats()) {
+ return null;
}
- return masterReference;
+ numberConsumed++;
+ return master;
}
/**
}
+ /** {@inheritDoc} */
+ public void resolveReferences(LayoutMasterSet layoutMasterSet) throws ValidationException {
+ master = layoutMasterSet.getSimplePageMaster(masterReference);
+ if (master == null) {
+ BlockLevelEventProducer.Provider.get(
+ getUserAgent().getEventBroadcaster())
+ .noMatchingPageMaster(this, parent.getName(), masterReference, getLocator());
+ }
+
+ }
+
+ /** {@inheritDoc} */
+ public boolean canProcess(String flowName) {
+ return master.getRegion(FO_REGION_BODY).getRegionName().equals(flowName);
+ }
+
+ /** {@inheritDoc} */
+ public boolean isInfinite() {
+ return getMaximumRepeats() == INFINITE;
+ }
+
+
+
}
// Java
import java.util.HashMap;
-import java.util.Iterator;
import java.util.Map;
import org.xml.sax.Locator;
import org.apache.fop.apps.FOPException;
import org.apache.fop.datatypes.Length;
import org.apache.fop.datatypes.Numeric;
-import org.apache.fop.datatypes.SimplePercentBaseContext;
import org.apache.fop.datatypes.PercentBaseContext;
+import org.apache.fop.datatypes.SimplePercentBaseContext;
import org.apache.fop.fo.FONode;
import org.apache.fop.fo.FObj;
import org.apache.fop.fo.PropertyList;
import org.apache.fop.fo.FObj;
import org.apache.fop.fo.PropertyList;
import org.apache.fop.fo.ValidationException;
+import org.apache.fop.layoutmgr.BlockLevelEventProducer;
/**
* Class modelling the <a href="http://www.w3.org/TR/xsl/#fo_single-page-master-reference">
// The value of properties relevant for fo:single-page-master-reference.
private String masterReference;
+
+ // The simple page master referenced
+ private SimplePageMaster master;
+
// End of property values
private static final int FIRST = 0;
}
/** {@inheritDoc} */
- public String getNextPageMasterName(boolean isOddPage,
+ public SimplePageMaster getNextPageMaster(boolean isOddPage,
boolean isFirstPage,
boolean isLastPage,
boolean isBlankPage) {
if (this.state == FIRST) {
this.state = DONE;
- return masterReference;
+ return master;
} else {
return null;
}
return FO_SINGLE_PAGE_MASTER_REFERENCE;
}
+ /** {@inheritDoc} */
+ public void resolveReferences(LayoutMasterSet layoutMasterSet) throws ValidationException {
+ master = layoutMasterSet.getSimplePageMaster(masterReference);
+ if (master == null) {
+ BlockLevelEventProducer.Provider.get(
+ getUserAgent().getEventBroadcaster())
+ .noMatchingPageMaster(this, parent.getName(), masterReference, getLocator());
+ }
+ }
+
+ /** {@inheritDoc} */
+ public boolean canProcess(String flowName) {
+ return master.getRegion(FO_REGION_BODY).getRegionName().equals(flowName);
+ }
+
+ /** {@inheritDoc} */
+ public boolean isInfinite() {
+ return false;
+ }
+
}
package org.apache.fop.fo.pagination;
+import org.apache.fop.fo.ValidationException;
/**
* Classes that implement this interface can be added to a {@link PageSequenceMaster},
* @return the page master name
* @throws PageProductionException if there's a problem determining the next page master
*/
- String getNextPageMasterName(boolean isOddPage,
+ SimplePageMaster getNextPageMaster(boolean isOddPage,
boolean isFirstPage,
boolean isLastPage,
boolean isBlankPage)
/** @return true if the subsequence has a page master for page-position "only" */
boolean hasPagePositionOnly();
+ /**
+ * called by the parent LayoutMasterSet to resolve object references
+ * from simple page master reference names
+ * @param layoutMasterSet the layout-master-set
+ * @throws ValidationException when a named reference cannot be resolved
+ * */
+ void resolveReferences(LayoutMasterSet layoutMasterSet) throws ValidationException;
+
+ /**
+ *
+ * @param flowName name of the main flow
+ * @return true iff page sequence is a finite sequence or can process the entire main flow
+ */
+ boolean canProcess(String flowName);
+
+ /**
+ * Test that this is a finite sequence
+ * @return true iff this is a finite sequence
+ */
+ boolean isInfinite();
+
}
* Makes a new page
*
* @param isBlank whether this page is blank or not
- * @param isLast whether this page is the last page or not
* @return a new page
*/
- protected Page makeNewPage(boolean isBlank, boolean isLast) {
+ protected Page makeNewPage(boolean isBlank) {
if (curPage != null) {
finishPage();
}
if (forcePageCount == Constants.EN_EVEN) {
if ((currentPageNum - startPageNum + 1) % 2 != 0) { // we have an odd number of pages
- curPage = makeNewPage(true, false);
+ curPage = makeNewPage(true);
}
} else if (forcePageCount == Constants.EN_ODD) {
if ((currentPageNum - startPageNum + 1) % 2 == 0) { // we have an even number of pages
- curPage = makeNewPage(true, false);
+ curPage = makeNewPage(true);
}
} else if (forcePageCount == Constants.EN_END_ON_EVEN) {
if (currentPageNum % 2 != 0) { // we are now on an odd page
- curPage = makeNewPage(true, false);
+ curPage = makeNewPage(true);
}
} else if (forcePageCount == Constants.EN_END_ON_ODD) {
if (currentPageNum % 2 == 0) { // we are now on an even page
- curPage = makeNewPage(true, false);
+ curPage = makeNewPage(true);
}
} else if (forcePageCount == Constants.EN_NO_FORCE) {
// i hope: nothing special at all
private void makePageForImage(ImageInfo info, ImageLayout layout) {
this.imageLayout = layout;
- curPage = makeNewPage(false, false);
+ curPage = makeNewPage(false);
fillPage(info.getOriginalURI());
finishPage();
}
addAreas(alg, restartPoint, partCount - restartPoint, originalList, effectiveList);
//...and add a blank last page
setLastPageIndex(currentPageNum + 1);
- pslm.setCurrentPage(pslm.makeNewPage(true, true));
+ pslm.setCurrentPage(pslm.makeNewPage(true));
return;
}
}
if (forceNewPageWithSpan) {
log.trace("Forcing new page with span");
- curPage = pslm.makeNewPage(false, false);
+ curPage = pslm.makeNewPage(false);
curPage.getPageViewport().createSpan(true);
} else if (pv.getCurrentSpan().hasMoreFlows()) {
log.trace("Moving to next flow");
pv.getCurrentSpan().moveToNextFlow();
} else {
log.trace("Making new page");
- /*curPage = */pslm.makeNewPage(false, false);
+ /*curPage = */pslm.makeNewPage(false);
}
return;
default:
+ " breakVal=" + getBreakClassName(breakVal));
if (needBlankPageBeforeNew(breakVal)) {
log.trace("Inserting blank page");
- /*curPage = */pslm.makeNewPage(true, false);
+ /*curPage = */pslm.makeNewPage(true);
}
if (needNewPage(breakVal)) {
log.trace("Making new page");
- /*curPage = */pslm.makeNewPage(false, false);
+ /*curPage = */pslm.makeNewPage(false);
}
}
}
import org.apache.fop.area.AreaTreeHandler;
import org.apache.fop.fo.Constants;
import org.apache.fop.fo.pagination.PageSequence;
-import org.apache.fop.fo.pagination.Region;
import org.apache.fop.fo.pagination.SimplePageMaster;
/**
private int startPageOfCurrentElementList;
private int startColumnOfCurrentElementList;
private boolean spanAllForCurrentElementList;
- private List cachedPages = new java.util.ArrayList();
+ private List<Page> cachedPages = new java.util.ArrayList<Page>();
private int lastPageIndex = -1;
private int indexOfCachedLastPage = -1;
}
cacheNextPage(index, isBlank, isLastPage, this.spanAllForCurrentElementList);
}
- Page page = (Page)cachedPages.get(intIndex);
+ Page page = cachedPages.get(intIndex);
boolean replace = false;
if (page.getPageViewport().isBlank() != isBlank) {
log.debug("blank condition doesn't match. Replacing PageViewport.");
SimplePageMaster spm = pageSeq.getNextSimplePageMaster(
index, isFirstPage, isLastPage, isBlank);
- Region body = spm.getRegion(FO_REGION_BODY);
- if (!pageSeq.getMainFlow().getFlowName().equals(body.getRegionName())) {
- // this is fine by the XSL Rec (fo:flow's flow-name can be mapped to
- // any region), but we don't support it yet.
- BlockLevelEventProducer eventProducer = BlockLevelEventProducer.Provider.get(
- pageSeq.getUserAgent().getEventBroadcaster());
- eventProducer.flowNotMappingToRegionBody(this,
- pageSeq.getMainFlow().getFlowName(), spm.getMasterName(), spm.getLocator());
- }
Page page = new Page(spm, index, pageNumberString, isBlank, spanAll);
//Set unique key obtained from the AreaTreeHandler
page.getPageViewport().setKey(areaTreeHandler.generatePageViewportKey());
log.debug("Starting layout");
}
- curPage = makeNewPage(false, false);
+ curPage = makeNewPage(false);
PageBreaker breaker = new PageBreaker(this);
int flowBPD = getCurrentPV().getBodyRegion().getRemainingBPD();
pageNumber, PageProvider.RELTO_PAGE_SEQUENCE);
}
+ @Override
+ protected Page makeNewPage(boolean isBlank) {
+ Page newPage;
+
+ do {
+ newPage = super.makeNewPage(isBlank);
+ } while (!getPageSequence().getMainFlow().getFlowName()
+ .equals(newPage.getSimplePageMaster().getRegion(FO_REGION_BODY).getRegionName()));
+
+ return newPage;
+ }
+
private void layoutSideRegion(int regionID) {
SideRegion reg = (SideRegion)curPage.getSimplePageMaster().getRegion(regionID);
if (reg == null) {
import java.util.Map;
import org.w3c.dom.Document;
-
import org.xml.sax.SAXException;
import org.apache.commons.io.IOUtils;
import org.apache.fop.render.rtf.rtflib.rtfdoc.RtfHyperLink;
import org.apache.fop.render.rtf.rtflib.rtfdoc.RtfList;
import org.apache.fop.render.rtf.rtflib.rtfdoc.RtfListItem;
+import org.apache.fop.render.rtf.rtflib.rtfdoc.RtfListItem.RtfListItemLabel;
import org.apache.fop.render.rtf.rtflib.rtfdoc.RtfPage;
import org.apache.fop.render.rtf.rtflib.rtfdoc.RtfSection;
import org.apache.fop.render.rtf.rtflib.rtfdoc.RtfTable;
import org.apache.fop.render.rtf.rtflib.rtfdoc.RtfTableCell;
import org.apache.fop.render.rtf.rtflib.rtfdoc.RtfTableRow;
import org.apache.fop.render.rtf.rtflib.rtfdoc.RtfTextrun;
-import org.apache.fop.render.rtf.rtflib.rtfdoc.RtfListItem.RtfListItemLabel;
import org.apache.fop.render.rtf.rtflib.tools.BuilderContext;
import org.apache.fop.render.rtf.rtflib.tools.PercentContext;
import org.apache.fop.render.rtf.rtflib.tools.TableContext;
PageSequenceMaster master
= pageSeq.getRoot().getLayoutMasterSet().getPageSequenceMaster(reference);
this.pagemaster = master.getNextSimplePageMaster(
- false, false, false, false);
+ false, false, false, false, pageSeq.getMainFlow().getFlowName());
}
}
documents. Example: the fix of marks layering will be such a case when it's done.
-->
<release version="FOP Trunk" date="TBD">
+ <action context="Code" dev="CB" type="add" fixes-bug="50391" due-to="Peter Hancock">
+ Add support for different flow-name of fo:region-body in FOP
+ </action>
<action context="Code" dev="CB" type="add" fixes-bug="51664" due-to="Mehdi Houshmand">
Tagged PDF performance improvement plus tests
</action>
--- /dev/null
+/*\r
+ * Licensed to the Apache Software Foundation (ASF) under one or more\r
+ * contributor license agreements. See the NOTICE file distributed with\r
+ * this work for additional information regarding copyright ownership.\r
+ * The ASF licenses this file to You under the Apache License, Version 2.0\r
+ * (the "License"); you may not use this file except in compliance with\r
+ * the License. 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
+\r
+/* $Id$ */\r
+\r
+package org.apache.fop.fo.flow.table;\r
+\r
+import org.junit.runners.Suite;\r
+\r
+/**\r
+ * All test to be added in FOTreeTestSuite\r
+ *\r
+ */\r
+@Suite.SuiteClasses({ CollapsedConditionalBorderTestCase.class, IllegalRowSpanTestCase.class,\r
+ RowGroupBuilderTestCase.class, TableColumnColumnNumberTestCase.class,\r
+ TooManyColumnsTestCase.class })\r
+\r
+public final class AllTests {\r
+}\r
+\r
--- /dev/null
+/*\r
+ * Licensed to the Apache Software Foundation (ASF) under one or more\r
+ * contributor license agreements. See the NOTICE file distributed with\r
+ * this work for additional information regarding copyright ownership.\r
+ * The ASF licenses this file to You under the Apache License, Version 2.0\r
+ * (the "License"); you may not use this file except in compliance with\r
+ * the License. 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
+\r
+/* $Id$ */\r
+\r
+package org.apache.fop.fo.pagination;\r
+\r
+import org.junit.runners.Suite;\r
+import org.junit.runner.RunWith;\r
+\r
+/**\r
+ * All test to be added in FOTreeTestSuite\r
+ *\r
+ */\r
+@RunWith(Suite.class)\r
+@Suite.SuiteClasses({ PageSequenceMasterTestCase.class,\r
+ RepeatablePageMasterAlternativesTestCase.class})\r
+\r
+public final class AllTests {\r
+\r
+}\r
--- /dev/null
+/*\r
+ * Licensed to the Apache Software Foundation (ASF) under one or more\r
+ * contributor license agreements. See the NOTICE file distributed with\r
+ * this work for additional information regarding copyright ownership.\r
+ * The ASF licenses this file to You under the Apache License, Version 2.0\r
+ * (the "License"); you may not use this file except in compliance with\r
+ * the License. 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
+\r
+/* $Id$ */\r
+\r
+package org.apache.fop.fo.pagination;\r
+\r
+import static org.junit.Assert.fail;\r
+\r
+import static org.mockito.Matchers.anyBoolean;\r
+import static org.mockito.Matchers.anyInt;\r
+import static org.mockito.Matchers.anyString;\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.when;\r
+\r
+import org.apache.fop.fo.FONode;\r
+import org.apache.fop.layoutmgr.BlockLevelEventProducer;\r
+\r
+import org.junit.Test;\r
+\r
+\r
+/**\r
+ * Unit Test for PageSequenceMaster\r
+ *\r
+ */\r
+public class PageSequenceMasterTestCase {\r
+\r
+ /**\r
+ * Test that PageProductionException is thrown if the final simple-page-master\r
+ * cannot handle the main-flow of the page sequence\r
+ * @throws Exception exception\r
+ */\r
+ @Test\r
+ public void testGetNextSimplePageMasterException() throws Exception {\r
+\r
+ final String mainFlowRegionName = "main";\r
+ final String emptyFlowRegionName = "empty";\r
+ // Create stubs\r
+\r
+ FONode mockParent = mock(FONode.class);\r
+ Root mockRoot = mock(Root.class);\r
+ LayoutMasterSet mockLayoutMasterSet = mock(LayoutMasterSet.class);\r
+\r
+ // This will represent a page master that does not map to the main flow\r
+ // of the page sequence\r
+ SimplePageMaster mockEmptySPM = mock(SimplePageMaster.class);\r
+ Region mockRegion = mock(Region.class);\r
+ SinglePageMasterReference mockSinglePageMasterReference\r
+ = mock(SinglePageMasterReference.class);\r
+ BlockLevelEventProducer mockBlockLevelEventProducer = mock(BlockLevelEventProducer.class);\r
+\r
+ //Stub behaviour\r
+ when(mockParent.getRoot()).thenReturn(mockRoot);\r
+ when(mockRoot.getLayoutMasterSet()).thenReturn(mockLayoutMasterSet);\r
+\r
+ //The layout master set should return the empty page master\r
+ when(mockLayoutMasterSet.getSimplePageMaster(anyString())).thenReturn(mockEmptySPM);\r
+ when(mockEmptySPM.getRegion(anyInt())).thenReturn(mockRegion);\r
+\r
+ when(mockRegion.getRegionName()).thenReturn(emptyFlowRegionName);\r
+\r
+ when(mockSinglePageMasterReference.getNextPageMaster(anyBoolean(), anyBoolean(),\r
+ anyBoolean(), anyBoolean()))\r
+ .thenReturn(null, mockEmptySPM);\r
+\r
+ PageSequenceMaster pageSequenceMaster = new PageSequenceMaster(mockParent,\r
+ mockBlockLevelEventProducer);\r
+ pageSequenceMaster.startOfNode();\r
+ pageSequenceMaster.addSubsequenceSpecifier(mockSinglePageMasterReference);\r
+\r
+ try {\r
+ pageSequenceMaster.getNextSimplePageMaster(false, false, false, false,\r
+ mainFlowRegionName);\r
+ fail("The next simple page master does not refer to the main flow");\r
+ } catch (PageProductionException ppe) {\r
+ //Passed test\r
+ }\r
+ }\r
+\r
+}\r
+\r
--- /dev/null
+/*\r
+ * Licensed to the Apache Software Foundation (ASF) under one or more\r
+ * contributor license agreements. See the NOTICE file distributed with\r
+ * this work for additional information regarding copyright ownership.\r
+ * The ASF licenses this file to You under the Apache License, Version 2.0\r
+ * (the "License"); you may not use this file except in compliance with\r
+ * the License. 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
+\r
+/* $Id$ */\r
+\r
+package org.apache.fop.fo.pagination;\r
+\r
+import static org.junit.Assert.assertTrue;\r
+import static org.mockito.Matchers.anyBoolean;\r
+import static org.mockito.Matchers.anyInt;\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.when;\r
+\r
+import org.junit.Test;\r
+\r
+import org.apache.fop.fo.Constants;\r
+import org.apache.fop.fo.PropertyList;\r
+import org.apache.fop.fo.expr.NumericProperty;\r
+import org.apache.fop.fo.properties.Property;\r
+\r
+\r
+\r
+/**\r
+ * Unit Test for RepeatablePageMasterAlternatives\r
+ *\r
+ */\r
+public class RepeatablePageMasterAlternativesTestCase\r
+implements Constants {\r
+\r
+ /**\r
+ *\r
+ * @throws Exception exception\r
+ */\r
+ @Test\r
+ public void testIsInfinite1() throws Exception {\r
+ // Create fixture\r
+ Property maximumRepeats = mock(Property.class);\r
+ ConditionalPageMasterReference cpmr = createCPMR("empty");\r
+\r
+ when(maximumRepeats.getEnum()).thenReturn(EN_NO_LIMIT);\r
+\r
+ RepeatablePageMasterAlternatives objectUnderTest\r
+ = createRepeatablePageMasterAlternatives(cpmr, maximumRepeats);\r
+\r
+ assertTrue("is infinite", objectUnderTest.isInfinite());\r
+ }\r
+\r
+ /**\r
+ *\r
+ * @throws Exception exception\r
+ */\r
+ @Test\r
+ public void testIsInfinite2() throws Exception {\r
+ // Create fixture\r
+ Property maximumRepeats = mock(Property.class);\r
+ ConditionalPageMasterReference cpmr = createCPMR("empty");\r
+\r
+ NumericProperty numericProperty = mock(NumericProperty.class);\r
+\r
+ final int maxRepeatNum = 0;\r
+ assertTrue(maxRepeatNum != EN_NO_LIMIT);\r
+\r
+ when(maximumRepeats.getEnum()).thenReturn(maxRepeatNum);\r
+ when(maximumRepeats.getNumeric()).thenReturn(numericProperty);\r
+\r
+ RepeatablePageMasterAlternatives objectUnderTest\r
+ = createRepeatablePageMasterAlternatives(createCPMR("empty"),\r
+ maximumRepeats);\r
+\r
+ assertTrue("is infinite", !objectUnderTest.isInfinite());\r
+ }\r
+\r
+ /**\r
+ * Test that an infinite sequence of empty page masters has\r
+ * willTerminiate() returning false\r
+ * @throws Exception exception\r
+ */\r
+ @Test\r
+ public void testCanProcess1() throws Exception {\r
+ // Create fixture\r
+ Property maximumRepeats = mock(Property.class);\r
+ ConditionalPageMasterReference cpmr = createCPMR("empty");\r
+\r
+ when(maximumRepeats.getEnum()).thenReturn(EN_NO_LIMIT);\r
+ when(cpmr.isValid(anyBoolean(), anyBoolean(), anyBoolean(), anyBoolean()))\r
+ .thenReturn(true);\r
+\r
+ RepeatablePageMasterAlternatives objectUnderTest\r
+ = createRepeatablePageMasterAlternatives(cpmr, maximumRepeats);\r
+\r
+ //Fixture assertion\r
+ assertTrue("Should be infinite", objectUnderTest.isInfinite());\r
+\r
+ //Test assertion\r
+ assertTrue("Infinite sequences that do not process the main flow will "\r
+ + " not terminate",\r
+ !objectUnderTest.canProcess("main-flow"));\r
+ }\r
+ /**\r
+ * Test that a finite sequence of simple page masters has\r
+ * willTerminate() returning true\r
+ *\r
+ * @throws Exception exception\r
+ */\r
+ @Test\r
+ public void testCanProcess2() throws Exception {\r
+ // Create fixture\r
+ Property maximumRepeats = mock(Property.class);\r
+ NumericProperty numericProperty = mock(NumericProperty.class);\r
+\r
+ final int maxRepeatNum = 0;\r
+\r
+ when(maximumRepeats.getEnum()).thenReturn(maxRepeatNum);\r
+ when(maximumRepeats.getNumeric()).thenReturn(numericProperty);\r
+\r
+ RepeatablePageMasterAlternatives objectUnderTest\r
+ = createRepeatablePageMasterAlternatives(createCPMR("empty"),\r
+ maximumRepeats);\r
+\r
+ //Fixture assertion\r
+ assertTrue("Should be finite sequence", !objectUnderTest.isInfinite());\r
+\r
+ //Test assertion\r
+ assertTrue("Finite sequences will terminate",\r
+ objectUnderTest.canProcess("main-flow"));\r
+ }\r
+\r
+ private ConditionalPageMasterReference createCPMR(String regionName) {\r
+ ConditionalPageMasterReference cpmr = mock(ConditionalPageMasterReference.class);\r
+ SimplePageMaster master = mock(SimplePageMaster.class);\r
+ Region region = mock(Region.class);\r
+ when(master.getRegion(anyInt())).thenReturn(region);\r
+ when(region.getRegionName()).thenReturn(regionName);\r
+ when(cpmr.getMaster()).thenReturn(master);\r
+\r
+ return cpmr;\r
+ }\r
+\r
+ private RepeatablePageMasterAlternatives createRepeatablePageMasterAlternatives(\r
+ ConditionalPageMasterReference cpmr, Property maximumRepeats) throws Exception {\r
+\r
+ PropertyList pList = mock(PropertyList.class);\r
+\r
+ when(pList.get(anyInt())).thenReturn(maximumRepeats);\r
+\r
+ PageSequenceMaster parent = mock(PageSequenceMaster.class);\r
+\r
+ RepeatablePageMasterAlternatives sut = new RepeatablePageMasterAlternatives(parent);\r
+\r
+ sut.startOfNode();\r
+ sut.bind(pList);\r
+ sut.addConditionalPageMasterReference(cpmr);\r
+ return sut;\r
+ }\r
+\r
+}\r
+\r
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
-import org.apache.fop.fo.flow.table.CollapsedConditionalBorderTestCase;
-import org.apache.fop.fo.flow.table.IllegalRowSpanTestCase;
-import org.apache.fop.fo.flow.table.RowGroupBuilderTestCase;
-import org.apache.fop.fo.flow.table.TableColumnColumnNumberTestCase;
-import org.apache.fop.fo.flow.table.TooManyColumnsTestCase;
-
/**
* JUnit test suit for running layout engine test under JUnit control.
*/
@RunWith(Suite.class)
@Suite.SuiteClasses({
- TooManyColumnsTestCase.class,
- IllegalRowSpanTestCase.class,
- RowGroupBuilderTestCase.class,
- TableColumnColumnNumberTestCase.class,
- CollapsedConditionalBorderTestCase.class,
+ org.apache.fop.fo.flow.table.AllTests.class,
+ org.apache.fop.fo.pagination.AllTests.class,
FOTreeTestCase.class })
+
public final class FOTreeTestSuite {
}
projects / xmlgraphics-fop.git / commitdiff