package org.apache.fop.layoutmgr.table;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.fop.datatypes.PercentBaseContext;
import org.apache.fop.fo.Constants;
import org.apache.fop.fo.FObj;
import org.apache.fop.fo.flow.Marker;
import org.apache.fop.fo.flow.table.EffRow;
import org.apache.fop.fo.flow.table.PrimaryGridUnit;
import org.apache.fop.fo.flow.table.Table;
import org.apache.fop.fo.flow.table.TableBody;
import org.apache.fop.fo.flow.table.TablePart;
import org.apache.fop.layoutmgr.BreakElement;
import org.apache.fop.layoutmgr.ElementListUtils;
import org.apache.fop.layoutmgr.FootenoteUtil;
import org.apache.fop.layoutmgr.FootnoteBodyLayoutManager;
import org.apache.fop.layoutmgr.Keep;
import org.apache.fop.layoutmgr.KnuthBlockBox;
import org.apache.fop.layoutmgr.KnuthBox;
import org.apache.fop.layoutmgr.KnuthElement;
import org.apache.fop.layoutmgr.KnuthGlue;
import org.apache.fop.layoutmgr.KnuthPossPosIter;
import org.apache.fop.layoutmgr.LayoutContext;
import org.apache.fop.layoutmgr.ListElement;
import org.apache.fop.layoutmgr.PageBreaker;
import org.apache.fop.layoutmgr.Position;
import org.apache.fop.layoutmgr.PositionIterator;
import org.apache.fop.layoutmgr.SpaceResolver.SpaceHandlingBreakPosition;
import org.apache.fop.util.BreakUtil;
public class TableContentLayoutManager implements PercentBaseContext {
private static final Log LOG = LogFactory.getLog(TableContentLayoutManager.class);
private TableLayoutManager tableLM;
private TableRowIterator bodyIter;
private TableRowIterator ;
private TableRowIterator ;
private LinkedList ;
private LinkedList ;
private int ;
private int ;
private int startXOffset;
private int usedBPD;
private TableStepper stepper;
private boolean ;
private boolean atLeastOnce;
TableContentLayoutManager(TableLayoutManager parent) {
this.tableLM = parent;
Table table = getTableLM().getTable();
this.bodyIter = new TableRowIterator(table, TableRowIterator.BODY);
if (table.getTableHeader() != null) {
headerIter = new TableRowIterator(table, TableRowIterator.HEADER);
}
if (table.getTableFooter() != null) {
footerIter = new TableRowIterator(table, TableRowIterator.FOOTER);
}
stepper = new TableStepper(this);
}
TableLayoutManager getTableLM() {
return this.tableLM;
}
boolean isSeparateBorderModel() {
return getTableLM().getTable().isSeparateBorderModel();
}
ColumnSetup getColumns() {
return getTableLM().getColumns();
}
protected int () {
return this.headerNetHeight;
}
protected int () {
return this.footerNetHeight;
}
protected LinkedList () {
return this.headerList;
}
protected LinkedList () {
return this.footerList;
}
public List getNextKnuthElements(LayoutContext context, int alignment) {
if (LOG.isDebugEnabled()) {
LOG.debug("==> Columns: " + getTableLM().getColumns());
}
KnuthBox headerAsFirst = null;
KnuthBox headerAsSecondToLast = null;
KnuthBox footerAsLast = null;
LinkedList returnList = new LinkedList();
int headerFootnoteBPD = 0;
if (headerIter != null && headerList == null) {
this.headerList = getKnuthElementsForRowIterator(
headerIter, context, alignment, TableRowIterator.HEADER);
this.headerNetHeight
= ElementListUtils.calcContentLength(this.headerList);
if (LOG.isDebugEnabled()) {
LOG.debug("==> Header: "
+ headerNetHeight + " - " + this.headerList);
}
TableHeaderFooterPosition pos = new TableHeaderFooterPosition(
getTableLM(), true, this.headerList);
List<FootnoteBodyLayoutManager> footnoteList = FootenoteUtil.getFootnotes(headerList);
KnuthBox box = (footnoteList.isEmpty() || !getTableLM().getTable().omitHeaderAtBreak())
? new KnuthBox(headerNetHeight, pos, false)
: new KnuthBlockBox(headerNetHeight, footnoteList, pos, false);
if (getTableLM().getTable().omitHeaderAtBreak()) {
headerAsFirst = box;
} else {
if (!footnoteList.isEmpty()) {
List<List<KnuthElement>> footnotes = PageBreaker.getFootnoteKnuthElements(
getTableLM().getPSLM().getFlowLayoutManager(), context, footnoteList);
getTableLM().setHeaderFootnotes(footnotes);
headerFootnoteBPD = getFootnotesBPD(footnotes);
returnList.add(new KnuthBlockBox(-headerFootnoteBPD, footnoteList,
new Position(getTableLM()), true));
headerNetHeight += headerFootnoteBPD;
}
headerAsSecondToLast = box;
}
}
if (footerIter != null && footerList == null) {
this.footerList = getKnuthElementsForRowIterator(
footerIter, context, alignment, TableRowIterator.FOOTER);
this.footerNetHeight
= ElementListUtils.calcContentLength(this.footerList);
if (LOG.isDebugEnabled()) {
LOG.debug("==> Footer: "
+ footerNetHeight + " - " + this.footerList);
}
TableHeaderFooterPosition pos = new TableHeaderFooterPosition(
getTableLM(), false, this.footerList);
List<FootnoteBodyLayoutManager> footnoteList = FootenoteUtil.getFootnotes(footerList);
footerAsLast = footnoteList.isEmpty()
? new KnuthBox(footerNetHeight, pos, false)
: new KnuthBlockBox(footerNetHeight, footnoteList, pos, false);
if (!(getTableLM().getTable().omitFooterAtBreak() || footnoteList.isEmpty())) {
List<List<KnuthElement>> footnotes = PageBreaker.getFootnoteKnuthElements(
getTableLM().getPSLM().getFlowLayoutManager(), context, footnoteList);
getTableLM().setFooterFootnotes(footnotes);
footerNetHeight += getFootnotesBPD(footnotes);
}
}
returnList.addAll(getKnuthElementsForRowIterator(
bodyIter, context, alignment, TableRowIterator.BODY));
if (headerAsFirst != null) {
int insertionPoint = 0;
if (returnList.size() > 0 && ((ListElement)returnList.getFirst()).isForcedBreak()) {
insertionPoint++;
}
returnList.add(insertionPoint, headerAsFirst);
} else if (headerAsSecondToLast != null) {
int insertionPoint = returnList.size();
if (returnList.size() > 0 && ((ListElement)returnList.getLast()).isForcedBreak()) {
insertionPoint--;
}
returnList.add(insertionPoint, headerAsSecondToLast);
}
if (footerAsLast != null) {
int insertionPoint = returnList.size();
if (returnList.size() > 0 && ((ListElement)returnList.getLast()).isForcedBreak()) {
insertionPoint--;
}
returnList.add(insertionPoint, footerAsLast);
}
if (headerFootnoteBPD != 0) {
returnList.add(new KnuthBox(headerFootnoteBPD, new Position(getTableLM()), true));
}
return returnList;
}
private int (List<List<KnuthElement>> footnotes) {
int bpd = 0;
for (List<KnuthElement> footnote : footnotes) {
bpd += ElementListUtils.calcContentLength(footnote);
}
return bpd;
}
private LinkedList getKnuthElementsForRowIterator(TableRowIterator iter,
LayoutContext context, int alignment, int bodyType) {
LinkedList returnList = new LinkedList();
EffRow[] rowGroup = iter.getNextRowGroup();
context.clearKeepsPending();
context.setBreakBefore(Constants.EN_AUTO);
context.setBreakAfter(Constants.EN_AUTO);
Keep keepWithPrevious = Keep.KEEP_AUTO;
int breakBefore = Constants.EN_AUTO;
if (rowGroup != null) {
RowGroupLayoutManager rowGroupLM = new RowGroupLayoutManager(getTableLM(), rowGroup,
stepper);
List nextRowGroupElems = rowGroupLM.getNextKnuthElements(context, alignment, bodyType);
keepWithPrevious = keepWithPrevious.compare(context.getKeepWithPreviousPending());
breakBefore = context.getBreakBefore();
int breakBetween = context.getBreakAfter();
returnList.addAll(nextRowGroupElems);
while ((rowGroup = iter.getNextRowGroup()) != null) {
rowGroupLM = new RowGroupLayoutManager(getTableLM(), rowGroup, stepper);
Keep keepWithNextPending = context.getKeepWithNextPending();
context.clearKeepWithNextPending();
nextRowGroupElems = rowGroupLM.getNextKnuthElements(context, alignment, bodyType);
Keep keep = keepWithNextPending.compare(context.getKeepWithPreviousPending());
context.clearKeepWithPreviousPending();
keep = keep.compare(getTableLM().getKeepTogether());
int penaltyValue = keep.getPenalty();
int breakClass = keep.getContext();
breakBetween = BreakUtil.compareBreakClasses(breakBetween,
context.getBreakBefore());
if (breakBetween != Constants.EN_AUTO) {
penaltyValue = -KnuthElement.INFINITE;
breakClass = breakBetween;
}
BreakElement breakElement;
ListIterator elemIter = returnList.listIterator(returnList.size());
ListElement elem = (ListElement) elemIter.previous();
if (elem instanceof KnuthGlue) {
breakElement = (BreakElement) elemIter.previous();
} else {
breakElement = (BreakElement) elem;
}
breakElement.setPenaltyValue(penaltyValue);
breakElement.setBreakClass(breakClass);
returnList.addAll(nextRowGroupElems);
breakBetween = context.getBreakAfter();
}
}
ListIterator elemIter = returnList.listIterator(returnList.size());
ListElement elem = (ListElement) elemIter.previous();
if (elem instanceof KnuthGlue) {
BreakElement breakElement = (BreakElement) elemIter.previous();
breakElement.setPenaltyValue(KnuthElement.INFINITE);
} else {
elemIter.remove();
}
context.updateKeepWithPreviousPending(keepWithPrevious);
context.setBreakBefore(breakBefore);
int widowContentLimit = getTableLM().getTable().getWidowContentLimit().getValue();
if (widowContentLimit != 0 && bodyType == TableRowIterator.BODY) {
ElementListUtils.removeLegalBreaks(returnList, widowContentLimit);
}
int orphanContentLimit = getTableLM().getTable().getOrphanContentLimit().getValue();
if (orphanContentLimit != 0 && bodyType == TableRowIterator.BODY) {
ElementListUtils.removeLegalBreaksFromEnd(returnList, orphanContentLimit);
}
return returnList;
}
protected int getXOffsetOfGridUnit(PrimaryGridUnit gu) {
return getXOffsetOfGridUnit(gu.getColIndex(), gu.getCell().getNumberColumnsSpanned());
}
protected int getXOffsetOfGridUnit(int colIndex, int nrColSpan) {
return startXOffset + getTableLM().getColumns().getXOffset(colIndex + 1, nrColSpan, getTableLM());
}
void addAreas(PositionIterator parentIter, LayoutContext layoutContext) {
this.usedBPD = 0;
RowPainter painter = new RowPainter(this, layoutContext);
List tablePositions = new java.util.ArrayList();
List headerElements = null;
List footerElements = null;
Position firstPos = null;
Position lastPos = null;
Position lastCheckPos = null;
while (parentIter.hasNext()) {
Position pos = parentIter.next();
if (pos instanceof SpaceHandlingBreakPosition) {
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;
if (thfpos.header) {
headerElements = thfpos.nestedElements;
} else {
footerElements = thfpos.nestedElements;
}
} else if (pos instanceof TableHFPenaltyPosition) {
} else if (pos instanceof TableContentPosition) {
tablePositions.add(pos);
} else {
if (LOG.isDebugEnabled()) {
LOG.debug("Ignoring position: " + pos);
}
}
}
boolean treatFooterAsArtifact = layoutContext.treatAsArtifact();
if (lastPos instanceof TableHFPenaltyPosition) {
TableHFPenaltyPosition penaltyPos = (TableHFPenaltyPosition)lastPos;
LOG.debug("Break at penalty!");
if (penaltyPos.headerElements != null) {
headerElements = penaltyPos.headerElements;
}
if (penaltyPos.footerElements != null) {
footerElements = penaltyPos.footerElements;
treatFooterAsArtifact = true;
}
}
tableLM.clearTableFragmentMarkers();
Map<String, Marker> markers = getTableLM().getTable().getMarkers();
if (markers != null) {
getTableLM().getCurrentPV().registerMarkers(markers,
true, getTableLM().isFirst(firstPos), getTableLM().isLast(lastCheckPos));
}
if (headerElements != null) {
boolean ancestorTreatAsArtifact = layoutContext.treatAsArtifact();
if (headerIsBeingRepeated) {
layoutContext.setTreatAsArtifact(true);
if (!getTableLM().getHeaderFootnotes().isEmpty()) {
getTableLM().getPSLM().addTableHeaderFootnotes(getTableLM().getHeaderFootnotes());
}
}
addHeaderFooterAreas(headerElements, tableLM.getTable().getTableHeader(), painter,
false);
if (!ancestorTreatAsArtifact) {
headerIsBeingRepeated = true;
}
layoutContext.setTreatAsArtifact(ancestorTreatAsArtifact);
}
if (tablePositions.isEmpty()) {
LOG.error("tablePositions empty."
+ " Please send your FO file to fop-users@xmlgraphics.apache.org");
} else {
addBodyAreas(tablePositions.iterator(), painter, footerElements == null);
}
tableLM.setRepeateHeader(atLeastOnce);
tableLM.repeatAddAreasForSavedTableHeaderTableCellLayoutManagers();
atLeastOnce = true;
if (footerElements != null) {
boolean ancestorTreatAsArtifact = layoutContext.treatAsArtifact();
layoutContext.setTreatAsArtifact(treatFooterAsArtifact);
addHeaderFooterAreas(footerElements, tableLM.getTable().getTableFooter(), painter, true);
if (lastPos instanceof TableHFPenaltyPosition && !tableLM.getFooterFootnotes().isEmpty()) {
tableLM.getPSLM().addTableFooterFootnotes(getTableLM().getFooterFootnotes());
}
layoutContext.setTreatAsArtifact(ancestorTreatAsArtifact);
}
this.usedBPD += painter.getAccumulatedBPD();
if (markers != null) {
getTableLM().getCurrentPV().registerMarkers(markers,
false, getTableLM().isFirst(firstPos), getTableLM().isLast(lastCheckPos));
}
}
private void (List elements, TablePart part, RowPainter painter,
boolean lastOnPage) {
List lst = new java.util.ArrayList(elements.size());
for (Iterator iter = new KnuthPossPosIter(elements); iter.hasNext();) {
Position pos = (Position) iter.next();
if (pos instanceof TableContentPosition) {
lst.add((TableContentPosition) pos);
}
}
addTablePartAreas(lst, painter, part, true, true, true, lastOnPage);
}
private void addBodyAreas(Iterator iterator, RowPainter painter,
boolean lastOnPage) {
painter.startBody();
List lst = new java.util.ArrayList();
TableContentPosition pos = (TableContentPosition) iterator.next();
boolean isFirstPos = pos.getFlag(TableContentPosition.FIRST_IN_ROWGROUP)
&& pos.getRow().getFlag(EffRow.FIRST_IN_PART);
TablePart part = pos.getTablePart();
lst.add(pos);
while (iterator.hasNext()) {
pos = (TableContentPosition) iterator.next();
if (pos.getTablePart() != part) {
addTablePartAreas(lst, painter, part, isFirstPos, true, false, false);
isFirstPos = true;
lst.clear();
part = pos.getTablePart();
}
lst.add(pos);
}
boolean isLastPos = pos.getFlag(TableContentPosition.LAST_IN_ROWGROUP)
&& pos.getRow().getFlag(EffRow.LAST_IN_PART);
addTablePartAreas(lst, painter, part, isFirstPos, isLastPos, true, lastOnPage);
painter.endBody();
}
private void addTablePartAreas(List positions, RowPainter painter, TablePart body,
boolean isFirstPos, boolean isLastPos, boolean lastInBody, boolean lastOnPage) {
getTableLM().getCurrentPV().registerMarkers(body.getMarkers(),
true, isFirstPos, isLastPos);
if (body instanceof TableBody) {
getTableLM().registerMarkers(body.getMarkers(), true, isFirstPos, isLastPos);
}
painter.startTablePart(body);
for (Object position : positions) {
painter.handleTableContentPosition((TableContentPosition) position);
}
getTableLM().getCurrentPV().registerMarkers(body.getMarkers(),
false, isFirstPos, isLastPos);
if (body instanceof TableBody) {
getTableLM().registerMarkers(body.getMarkers(), false, isFirstPos, isLastPos);
}
painter.endTablePart(lastInBody, lastOnPage);
}
void setStartXOffset(int startXOffset) {
this.startXOffset = startXOffset;
}
int getUsedBPD() {
return this.usedBPD;
}
public int getBaseLength(int lengthBase, FObj fobj) {
return tableLM.getBaseLength(lengthBase, fobj);
}
}