/*
* 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$ */
package org.apache.fop.layoutmgr.table;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.fop.fo.Constants;
import org.apache.fop.fo.flow.table.EffRow;
import org.apache.fop.fo.flow.table.GridUnit;
import org.apache.fop.fo.flow.table.PrimaryGridUnit;
import org.apache.fop.fo.flow.table.TableColumn;
import org.apache.fop.fo.flow.table.TableRow;
import org.apache.fop.fo.properties.CommonBorderPaddingBackground;
import org.apache.fop.fo.properties.LengthRangeProperty;
import org.apache.fop.layoutmgr.ElementListObserver;
import org.apache.fop.layoutmgr.LayoutContext;
import org.apache.fop.traits.MinOptMax;
import org.apache.fop.util.BreakUtil;
class RowGroupLayoutManager {
private static Log log = LogFactory.getLog(RowGroupLayoutManager.class);
private static final MinOptMax MAX_STRETCH = MinOptMax.getInstance(0, 0, Integer.MAX_VALUE);
private EffRow[] rowGroup;
private TableLayoutManager tableLM;
private TableStepper tableStepper;
RowGroupLayoutManager(TableLayoutManager tableLM, EffRow[] rowGroup,
TableStepper tableStepper) {
this.tableLM = tableLM;
this.rowGroup = rowGroup;
this.tableStepper = tableStepper;
}
public LinkedList getNextKnuthElements(LayoutContext context, int alignment, int bodyType) {
LinkedList returnList = new LinkedList();
createElementsForRowGroup(context, alignment, bodyType, returnList);
context.updateKeepWithPreviousPending(rowGroup[0].getKeepWithPrevious());
context.updateKeepWithNextPending(rowGroup[rowGroup.length - 1].getKeepWithNext());
int breakBefore = Constants.EN_AUTO;
TableRow firstRow = rowGroup[0].getTableRow();
if (firstRow != null) {
breakBefore = firstRow.getBreakBefore();
}
context.setBreakBefore(BreakUtil.compareBreakClasses(breakBefore,
rowGroup[0].getBreakBefore()));
int breakAfter = Constants.EN_AUTO;
TableRow lastRow = rowGroup[rowGroup.length - 1].getTableRow();
if (lastRow != null) {
breakAfter = lastRow.getBreakAfter();
}
context.setBreakAfter(BreakUtil.compareBreakClasses(breakAfter,
rowGroup[rowGroup.length - 1].getBreakAfter()));
return returnList;
}
/**
* Creates Knuth elements for a row group (see TableRowIterator.getNextRowGroup()).
* @param context Active LayoutContext
* @param alignment alignment indicator
* @param bodyType Indicates what kind of body is being processed (BODY, HEADER or FOOTER)
* @param returnList List to received the generated elements
*/
private void createElementsForRowGroup(LayoutContext context, int alignment,
int bodyType, LinkedList returnList) {
log.debug("Handling row group with " + rowGroup.length + " rows...");
EffRow row;
for (EffRow aRowGroup : rowGroup) {
row = aRowGroup;
for (Object o : row.getGridUnits()) {
GridUnit gu = (GridUnit) o;
if (gu.isPrimary()) {
PrimaryGridUnit primary = gu.getPrimary();
// TODO a new LM must be created for every new static-content
primary.createCellLM();
primary.getCellLM().setParent(tableLM);
//Calculate width of cell
int spanWidth = 0;
Iterator colIter = tableLM.getTable().getColumns().listIterator(
primary.getColIndex());
for (int i = 0, c = primary.getCell().getNumberColumnsSpanned(); i < c; i++) {
spanWidth += ((TableColumn) colIter.next()).getColumnWidth().getValue(
tableLM);
}
LayoutContext childLC = LayoutContext.newInstance();
childLC.setStackLimitBP(context.getStackLimitBP()); //necessary?
childLC.setRefIPD(spanWidth);
//Get the element list for the cell contents
List elems = primary.getCellLM().getNextKnuthElements(
childLC, alignment);
ElementListObserver.observe(elems, "table-cell", primary.getCell().getId());
primary.setElements(elems);
}
}
}
computeRowHeights();
List elements = tableStepper.getCombinedKnuthElementsForRowGroup(context,
rowGroup, bodyType);
returnList.addAll(elements);
}
/**
* Calculate the heights of the rows in the row group, see CSS21, 17.5.3 Table height
* algorithms.
*
* TODO this method will need to be adapted once clarification has been made by the
* W3C regarding whether borders or border-separation must be included or not
*/
private void computeRowHeights() {
log.debug("rowGroup:");
MinOptMax[] rowHeights = new MinOptMax[rowGroup.length];
EffRow row;
for (int rgi = 0; rgi < rowGroup.length; rgi++) {
row = rowGroup[rgi];
// The BPD of the biggest cell in the row
// int maxCellBPD = 0;
MinOptMax explicitRowHeight;
TableRow tableRowFO = rowGroup[rgi].getTableRow();
if (tableRowFO == null) {
rowHeights[rgi] = MAX_STRETCH;
explicitRowHeight = MAX_STRETCH;
} else {
LengthRangeProperty rowBPD = tableRowFO.getBlockProgressionDimension();
rowHeights[rgi] = rowBPD.toMinOptMax(tableLM);
explicitRowHeight = rowBPD.toMinOptMax(tableLM);
}
for (Object o : row.getGridUnits()) {
GridUnit gu = (GridUnit) o;
if (!gu.isEmpty() && gu.getColSpanIndex() == 0 && gu.isLastGridUnitRowSpan()) {
PrimaryGridUnit primary = gu.getPrimary();
int effectiveCellBPD = 0;
LengthRangeProperty cellBPD = primary.getCell().getBlockProgressionDimension();
if (!cellBPD.getMinimum(tableLM).isAuto()) {
effectiveCellBPD = cellBPD.getMinimum(tableLM).getLength()
.getValue(tableLM);
}
if (!cellBPD.getOptimum(tableLM).isAuto()) {
effectiveCellBPD = cellBPD.getOptimum(tableLM).getLength()
.getValue(tableLM);
}
if (gu.getRowSpanIndex() == 0) {
effectiveCellBPD = Math.max(effectiveCellBPD, explicitRowHeight.getOpt());
}
effectiveCellBPD = Math.max(effectiveCellBPD, primary.getContentLength());
int borderWidths = primary.getBeforeAfterBorderWidth();
int padding = 0;
CommonBorderPaddingBackground cbpb = primary.getCell()
.getCommonBorderPaddingBackground();
padding += cbpb.getPaddingBefore(false, primary.getCellLM());
padding += cbpb.getPaddingAfter(false, primary.getCellLM());
int effRowHeight = effectiveCellBPD + padding + borderWidths;
for (int prev = rgi - 1; prev >= rgi - gu.getRowSpanIndex(); prev--) {
effRowHeight -= rowHeights[prev].getOpt();
}
if (effRowHeight > rowHeights[rgi].getMin()) {
// This is the new height of the (grid) row
rowHeights[rgi] = rowHeights[rgi].extendMinimum(effRowHeight);
}
}
}
row.setHeight(rowHeights[rgi]);
row.setExplicitHeight(explicitRowHeight);
// TODO re-enable and improve after clarification
//See http://markmail.org/message/h25ycwwu7qglr4k4
// if (maxCellBPD > row.getExplicitHeight().max) {
//old:
// log.warn(FONode.decorateWithContextInfo(
// "The contents of row " + (row.getIndex() + 1)
// + " are taller than they should be (there is a"
// + " block-progression-dimension or height constraint
// + " on the indicated row)."
// + " Due to its contents the row grows"
// + " to " + maxCellBPD + " millipoints, but the row shouldn't get"
// + " any taller than " + row.getExplicitHeight() + " millipoints.",
// row.getTableRow()));
//new (with events):
// BlockLevelEventProducer eventProducer = BlockLevelEventProducer.Factory.create(
// tableRow.getUserAgent().getEventBroadcaster());
// eventProducer.rowTooTall(this, row.getIndex() + 1,
// maxCellBPD, row.getExplicitHeight().max, tableRow.getLocator());
// }
}
}
}