Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* $Id: PageSequenceMaster.java 1733431 2016-03-03 09:40:50Z gadams $ */
package org.apache.fop.fo.pagination;
// Java
import java.util.Collections;
import java.util.List;
import org.xml.sax.Locator;
import org.apache.fop.apps.FOPException;
import org.apache.fop.fo.FONode;
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
* fo:page-sequence-master object.
*
* This class handles a list of subsequence specifiers
* which are simple or complex references to page-masters.
*/
public class PageSequenceMaster extends FObj {
// The value of properties relevant for fo:page-sequence-master.
private String masterName;
// End of property values
private LayoutMasterSet layoutMasterSet;
private List 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
// 'sub-sequence-specifiers'. These are, in fact, simple or complex
// references to page-masters. So the methods use the former
// terminology ('sub-sequence-specifiers', or SSS),
// but the actual FO's are MasterReferences.
/**
* Create a PageSequenceMaster instance that is a child of the
* given {@link FONode}.
*
* @param parent {@link FONode} that is the parent of this object
* @param blockLevelEventProducer event producer
*/
public PageSequenceMaster(FONode parent, BlockLevelEventProducer blockLevelEventProducer) {
super(parent);
this.blockLevelEventProducer = blockLevelEventProducer;
}
/** {@inheritDoc} */
public void bind(PropertyList pList) throws FOPException {
masterName = pList.get(PR_MASTER_NAME).getString();
if (masterName == null || masterName.equals("")) {
missingPropertyError("master-name");
}
}
/** {@inheritDoc} */
public void startOfNode() throws FOPException {
subSequenceSpecifiers = new java.util.ArrayList();
layoutMasterSet = parent.getRoot().getLayoutMasterSet();
layoutMasterSet.addPageSequenceMaster(masterName, this);
}
/** {@inheritDoc} */
public void endOfNode() throws FOPException {
if (firstChild == null) {
missingChildElementError("(single-page-master-reference|"
+ "repeatable-page-master-reference|repeatable-page-master-alternatives)+");
}
}
/**
* {@inheritDoc}
* XSL/FOP: (single-page-master-reference|repeatable-page-master-reference|
* repeatable-page-master-alternatives)+
*/
protected void validateChildNode(Locator loc, String nsURI, String localName)
throws ValidationException {
if (FO_URI.equals(nsURI)) {
if (!"single-page-master-reference".equals(localName)
&& !"repeatable-page-master-reference".equals(localName)
&& !"repeatable-page-master-alternatives".equals(localName)) {
invalidChildError(loc, nsURI, localName);
}
}
}
/**
* Adds a new suqsequence specifier to the page sequence master.
* @param pageMasterReference the subsequence to add
*/
protected void addSubsequenceSpecifier(SubSequenceSpecifier pageMasterReference) {
subSequenceSpecifiers.add(pageMasterReference);
}
public LayoutMasterSet getLayoutMasterSet() {
return layoutMasterSet;
}
/**
* Returns the next subsequence specifier
* @return a subsequence specifier
*/
private SubSequenceSpecifier getNextSubSequence() {
currentSubSequenceNumber++;
if (currentSubSequenceNumber >= 0
&& currentSubSequenceNumber < subSequenceSpecifiers.size()) {
return subSequenceSpecifiers.get(currentSubSequenceNumber);
}
return null;
}
List getSubSequenceSpecifier() {
return Collections.unmodifiableList(subSequenceSpecifiers);
}
/**
* Resets the subsequence specifiers subsystem.
*/
public void reset() {
currentSubSequenceNumber = -1;
currentSubSequence = null;
if (subSequenceSpecifiers != null) {
for (SubSequenceSpecifier subSequenceSpecifier : subSequenceSpecifiers) {
subSequenceSpecifier.reset();
}
}
}
/**
* Used to set the "cursor position" for the page masters to the previous item.
* @return true if there is a previous item, false if the current one was the first one.
*/
public boolean goToPreviousSimplePageMaster() {
if (currentSubSequence != null) {
boolean success = currentSubSequence.goToPrevious();
if (!success) {
if (currentSubSequenceNumber > 0) {
currentSubSequenceNumber--;
currentSubSequence = subSequenceSpecifiers
.get(currentSubSequenceNumber);
} else {
currentSubSequence = null;
}
}
}
return (currentSubSequence != null);
}
/** @return true if the page-sequence-master has a page-master with page-position="last" */
public boolean hasPagePositionLast() {
return (currentSubSequence != null
&& currentSubSequence.hasPagePositionLast());
}
/** @return true if the page-sequence-master has a page-master with page-position="only" */
public boolean hasPagePositionOnly() {
return (currentSubSequence != null
&& currentSubSequence.hasPagePositionOnly());
}
/**
* Returns the next simple-page-master.
* @param isOddPage True if the next page number is odd
* @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,
String mainFlowName)
throws PageProductionException {
if (currentSubSequence == null) {
currentSubSequence = getNextSubSequence();
if (currentSubSequence == null) {
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");
}
}
SimplePageMaster pageMaster = currentSubSequence
.getNextPageMaster(isOddPage, isFirstPage, isLastPage, isBlankPage);
boolean canRecover = true;
while (pageMaster == null) {
SubSequenceSpecifier nextSubSequence = getNextSubSequence();
if (nextSubSequence == null) {
//Sub-sequence exhausted so attempt to reuse it
blockLevelEventProducer.pageSequenceMasterExhausted(this,
masterName, canRecover & currentSubSequence.isReusable(), 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;
}
pageMaster = currentSubSequence
.getNextPageMaster(isOddPage, isFirstPage, isLastPage, isBlankPage);
}
return pageMaster;
}
/** {@inheritDoc} */
public String getLocalName() {
return "page-sequence-master";
}
/**
* {@inheritDoc}
* @return {@link org.apache.fop.fo.Constants#FO_PAGE_SEQUENCE_MASTER}
*/
public int getNameId() {
return FO_PAGE_SEQUENCE_MASTER;
}
public SimplePageMaster getLastSimplePageMaster(boolean isOddPage, boolean isFirstPage, boolean isBlank,
String flowName) {
if (currentSubSequence == null) {
currentSubSequence = getNextSubSequence();
if (currentSubSequence == null) {
blockLevelEventProducer.missingSubsequencesInPageSequenceMaster(this, masterName,
getLocator());
}
if (currentSubSequence.isInfinite() && !currentSubSequence.canProcess(flowName)) {
throw new PageProductionException(
"The current sub-sequence will not terminate whilst processing the main flow");
}
}
SimplePageMaster pageMaster = currentSubSequence.getLastPageMaster(isOddPage, isFirstPage, isBlank,
blockLevelEventProducer);
return pageMaster;
}
}
