1332 lines
56 KiB
Java
1332 lines
56 KiB
Java
package net.sf.jasperreports.engine.fill;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Comparator;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.ResourceBundle;
|
|
import net.sf.jasperreports.crosstabs.JRCellContents;
|
|
import net.sf.jasperreports.crosstabs.JRCrosstab;
|
|
import net.sf.jasperreports.crosstabs.JRCrosstabBucket;
|
|
import net.sf.jasperreports.crosstabs.JRCrosstabCell;
|
|
import net.sf.jasperreports.crosstabs.JRCrosstabColumnGroup;
|
|
import net.sf.jasperreports.crosstabs.JRCrosstabDataset;
|
|
import net.sf.jasperreports.crosstabs.JRCrosstabGroup;
|
|
import net.sf.jasperreports.crosstabs.JRCrosstabMeasure;
|
|
import net.sf.jasperreports.crosstabs.JRCrosstabParameter;
|
|
import net.sf.jasperreports.crosstabs.JRCrosstabRowGroup;
|
|
import net.sf.jasperreports.crosstabs.base.JRBaseCrosstab;
|
|
import net.sf.jasperreports.crosstabs.design.JRDesignCrosstab;
|
|
import net.sf.jasperreports.crosstabs.fill.JRCrosstabExpressionEvaluator;
|
|
import net.sf.jasperreports.crosstabs.fill.JRFillCrosstabCell;
|
|
import net.sf.jasperreports.crosstabs.fill.JRFillCrosstabColumnGroup;
|
|
import net.sf.jasperreports.crosstabs.fill.JRFillCrosstabGroup;
|
|
import net.sf.jasperreports.crosstabs.fill.JRFillCrosstabMeasure;
|
|
import net.sf.jasperreports.crosstabs.fill.JRFillCrosstabParameter;
|
|
import net.sf.jasperreports.crosstabs.fill.JRFillCrosstabRowGroup;
|
|
import net.sf.jasperreports.crosstabs.fill.calculation.BucketDefinition;
|
|
import net.sf.jasperreports.crosstabs.fill.calculation.BucketingService;
|
|
import net.sf.jasperreports.crosstabs.fill.calculation.CrosstabCell;
|
|
import net.sf.jasperreports.crosstabs.fill.calculation.HeaderCell;
|
|
import net.sf.jasperreports.crosstabs.fill.calculation.MeasureDefinition;
|
|
import net.sf.jasperreports.engine.JRCommonElement;
|
|
import net.sf.jasperreports.engine.JRDatasetParameter;
|
|
import net.sf.jasperreports.engine.JRElement;
|
|
import net.sf.jasperreports.engine.JRElementDataset;
|
|
import net.sf.jasperreports.engine.JRException;
|
|
import net.sf.jasperreports.engine.JRExpression;
|
|
import net.sf.jasperreports.engine.JRExpressionChunk;
|
|
import net.sf.jasperreports.engine.JRExpressionCollector;
|
|
import net.sf.jasperreports.engine.JRPrintElement;
|
|
import net.sf.jasperreports.engine.JRPrintFrame;
|
|
import net.sf.jasperreports.engine.JRPrintRectangle;
|
|
import net.sf.jasperreports.engine.JRRectangle;
|
|
import net.sf.jasperreports.engine.JRReport;
|
|
import net.sf.jasperreports.engine.JRRuntimeException;
|
|
import net.sf.jasperreports.engine.JRStyle;
|
|
import net.sf.jasperreports.engine.JRVariable;
|
|
import net.sf.jasperreports.engine.JRVisitor;
|
|
import net.sf.jasperreports.engine.JasperCompileManager;
|
|
import net.sf.jasperreports.engine.JasperReport;
|
|
import net.sf.jasperreports.engine.design.JRDesignRectangle;
|
|
import net.sf.jasperreports.engine.util.JRStyleResolver;
|
|
import org.jfree.data.general.Dataset;
|
|
|
|
public class JRFillCrosstab extends JRFillElement implements JRCrosstab {
|
|
protected final JRCrosstab parentCrosstab;
|
|
|
|
protected JRFillCrosstabDataset dataset;
|
|
|
|
protected JRFillCrosstabRowGroup[] rowGroups;
|
|
|
|
protected Map rowGroupsMap;
|
|
|
|
protected JRFillCrosstabColumnGroup[] columnGroups;
|
|
|
|
protected Map columnGroupsMap;
|
|
|
|
protected JRFillCrosstabMeasure[] measures;
|
|
|
|
protected BucketingService bucketingService;
|
|
|
|
protected JRFillVariable[] variables;
|
|
|
|
protected Map variablesMap;
|
|
|
|
protected JRFillVariable[][][] totalVariables;
|
|
|
|
protected boolean[][] retrieveTotal;
|
|
|
|
protected JRFillCrosstabParameter[] parameters;
|
|
|
|
protected Map parametersMap;
|
|
|
|
protected JRCrosstabExpressionEvaluator crosstabEvaluator;
|
|
|
|
protected JRFillCrosstabCell[][] crossCells;
|
|
|
|
protected JRFillCellContents headerCell;
|
|
|
|
protected JRFillCellContents whenNoDataCell;
|
|
|
|
protected boolean hasData;
|
|
|
|
protected HeaderCell[][] columnHeadersData;
|
|
|
|
protected HeaderCell[][] rowHeadersData;
|
|
|
|
protected CrosstabCell[][] cellData;
|
|
|
|
protected MeasureDefinition.MeasureValue[] grandTotals;
|
|
|
|
private boolean percentage;
|
|
|
|
private CrosstabFiller crosstabFiller;
|
|
|
|
public JRFillCrosstab(JRBaseFiller filler, JRCrosstab crosstab, JRFillObjectFactory factory) {
|
|
super(filler, (JRElement)crosstab, factory);
|
|
this.parentCrosstab = crosstab;
|
|
loadEvaluator(filler.getJasperReport());
|
|
JRFillObjectFactory crosstabFactory = new JRFillObjectFactory(factory, (JRFillExpressionEvaluator)this.crosstabEvaluator);
|
|
this.headerCell = crosstabFactory.getCell(crosstab.getHeaderCell());
|
|
copyRowGroups(crosstab, crosstabFactory);
|
|
copyColumnGroups(crosstab, crosstabFactory);
|
|
copyMeasures(crosstab, crosstabFactory);
|
|
copyCells(crosstab, crosstabFactory);
|
|
this.whenNoDataCell = crosstabFactory.getCell(crosstab.getWhenNoDataCell());
|
|
this.dataset = factory.getCrosstabDataset(crosstab.getDataset(), this);
|
|
copyParameters(crosstab, factory);
|
|
copyVariables(crosstab, crosstabFactory);
|
|
this.crosstabFiller = new CrosstabFiller();
|
|
}
|
|
|
|
public byte getMode() {
|
|
return JRStyleResolver.getMode((JRCommonElement)this, (byte)2);
|
|
}
|
|
|
|
private void copyRowGroups(JRCrosstab crosstab, JRFillObjectFactory factory) {
|
|
JRCrosstabRowGroup[] groups = crosstab.getRowGroups();
|
|
this.rowGroups = new JRFillCrosstabRowGroup[groups.length];
|
|
this.rowGroupsMap = new HashMap();
|
|
for (int i = 0; i < groups.length; i++) {
|
|
JRFillCrosstabRowGroup group = factory.getCrosstabRowGroup(groups[i]);
|
|
group.getFillHeader().setVerticalPositionType(groups[i].getPosition());
|
|
this.rowGroups[i] = group;
|
|
this.rowGroupsMap.put(group.getName(), new Integer(i));
|
|
}
|
|
}
|
|
|
|
private void copyColumnGroups(JRCrosstab crosstab, JRFillObjectFactory factory) {
|
|
JRCrosstabColumnGroup[] groups = crosstab.getColumnGroups();
|
|
this.columnGroups = new JRFillCrosstabColumnGroup[groups.length];
|
|
this.columnGroupsMap = new HashMap();
|
|
for (int i = 0; i < groups.length; i++) {
|
|
JRFillCrosstabColumnGroup group = factory.getCrosstabColumnGroup(groups[i]);
|
|
this.columnGroups[i] = group;
|
|
this.columnGroupsMap.put(group.getName(), new Integer(i));
|
|
}
|
|
}
|
|
|
|
private void copyMeasures(JRCrosstab crosstab, JRFillObjectFactory factory) {
|
|
JRCrosstabMeasure[] crossMeasures = crosstab.getMeasures();
|
|
this.measures = new JRFillCrosstabMeasure[crossMeasures.length];
|
|
for (int i = 0; i < crossMeasures.length; i++)
|
|
this.measures[i] = factory.getCrosstabMeasure(crossMeasures[i]);
|
|
}
|
|
|
|
private void copyParameters(JRCrosstab crosstab, JRFillObjectFactory factory) {
|
|
JRCrosstabParameter[] crossParams = crosstab.getParameters();
|
|
this.parameters = new JRFillCrosstabParameter[crossParams.length];
|
|
this.parametersMap = new HashMap();
|
|
for (int i = 0; i < crossParams.length; i++) {
|
|
this.parameters[i] = factory.getCrosstabParameter(crossParams[i]);
|
|
this.parametersMap.put(this.parameters[i].getName(), this.parameters[i]);
|
|
}
|
|
}
|
|
|
|
private void copyCells(JRCrosstab crosstab, JRFillObjectFactory factory) {
|
|
JRCrosstabCell[][] crosstabCells = crosstab.getCells();
|
|
this.crossCells = new JRFillCrosstabCell[this.rowGroups.length + 1][this.columnGroups.length + 1];
|
|
for (int i = 0; i <= this.rowGroups.length; i++) {
|
|
for (int j = 0; j <= this.columnGroups.length; j++) {
|
|
if (crosstabCells[i][j] != null)
|
|
this.crossCells[i][j] = factory.getCrosstabCell(crosstabCells[i][j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void copyVariables(JRCrosstab crosstab, JRFillObjectFactory factory) {
|
|
JRVariable[] vars = crosstab.getVariables();
|
|
this.variables = new JRFillVariable[vars.length];
|
|
this.variablesMap = new HashMap();
|
|
for (int i = 0; i < this.variables.length; i++) {
|
|
this.variables[i] = factory.getVariable(vars[i]);
|
|
this.variablesMap.put(this.variables[i].getName(), this.variables[i]);
|
|
}
|
|
Map totalVarPos = new HashMap();
|
|
this.totalVariables = new JRFillVariable[this.rowGroups.length + 1][this.columnGroups.length + 1][this.measures.length];
|
|
for (int row = 0; row <= this.rowGroups.length; row++) {
|
|
JRFillCrosstabRowGroup jRFillCrosstabRowGroup = (row == this.rowGroups.length) ? null : this.rowGroups[row];
|
|
for (int col = 0; col <= this.columnGroups.length; col++) {
|
|
JRFillCrosstabColumnGroup jRFillCrosstabColumnGroup = (col == this.columnGroups.length) ? null : this.columnGroups[col];
|
|
if (row < this.rowGroups.length || col < this.columnGroups.length)
|
|
for (int m = 0; m < this.measures.length; m++) {
|
|
String totalVariableName = JRDesignCrosstab.getTotalVariableName((JRCrosstabMeasure)this.measures[m], (JRCrosstabRowGroup)jRFillCrosstabRowGroup, (JRCrosstabColumnGroup)jRFillCrosstabColumnGroup);
|
|
this.totalVariables[row][col][m] = (JRFillVariable)this.variablesMap.get(totalVariableName);
|
|
totalVarPos.put(totalVariableName, new int[] { row, col });
|
|
}
|
|
}
|
|
}
|
|
this.retrieveTotal = new boolean[this.rowGroups.length + 1][this.columnGroups.length + 1];
|
|
List expressions = JRExpressionCollector.collectExpressions((JRReport)this.filler.getJasperReport(), crosstab);
|
|
for (Iterator iter = expressions.iterator(); iter.hasNext(); ) {
|
|
JRExpression expression = iter.next();
|
|
JRExpressionChunk[] chunks = expression.getChunks();
|
|
if (chunks != null)
|
|
for (int j = 0; j < chunks.length; j++) {
|
|
JRExpressionChunk chunk = chunks[j];
|
|
if (chunk.getType() == 4) {
|
|
String varName = chunk.getText();
|
|
int[] pos = (int[])totalVarPos.get(varName);
|
|
if (pos != null)
|
|
this.retrieveTotal[pos[0]][pos[1]] = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void loadEvaluator(JasperReport jasperReport) {
|
|
try {
|
|
JREvaluator evaluator = JasperCompileManager.loadEvaluator(jasperReport, this.parentCrosstab);
|
|
this.crosstabEvaluator = new JRCrosstabExpressionEvaluator(evaluator);
|
|
} catch (JRException e) {
|
|
throw new JRRuntimeException("Could not load evaluator for crosstab.", e);
|
|
}
|
|
}
|
|
|
|
private BucketingService createService(byte evaluation) throws JRException {
|
|
List rowBuckets = new ArrayList(this.rowGroups.length);
|
|
for (int i = 0; i < this.rowGroups.length; i++)
|
|
rowBuckets.add(createServiceBucket((JRCrosstabGroup)this.rowGroups[i], evaluation));
|
|
List colBuckets = new ArrayList(this.columnGroups.length);
|
|
for (int j = 0; j < this.columnGroups.length; j++)
|
|
colBuckets.add(createServiceBucket((JRCrosstabGroup)this.columnGroups[j], evaluation));
|
|
this.percentage = false;
|
|
List measureList = new ArrayList(this.measures.length);
|
|
for (int k = 0; k < this.measures.length; k++) {
|
|
measureList.add(createServiceMeasure(this.measures[k]));
|
|
this.percentage |= (this.measures[k].getPercentageOfType() == 1) ? 1 : 0;
|
|
}
|
|
if (this.percentage) {
|
|
((BucketDefinition)rowBuckets.get(0)).setComputeTotal();
|
|
((BucketDefinition)colBuckets.get(0)).setComputeTotal();
|
|
}
|
|
return new BucketingService(rowBuckets, colBuckets, measureList, this.dataset.isDataPreSorted(), this.retrieveTotal);
|
|
}
|
|
|
|
private BucketDefinition createServiceBucket(JRCrosstabGroup group, byte evaluation) throws JRException {
|
|
JRCrosstabBucket bucket = group.getBucket();
|
|
Comparator comparator = null;
|
|
JRExpression comparatorExpression = bucket.getComparatorExpression();
|
|
if (comparatorExpression != null)
|
|
comparator = (Comparator)evaluateExpression(comparatorExpression, evaluation);
|
|
byte totalPosition = group.getTotalPosition();
|
|
return new BucketDefinition(bucket.getExpression().getValueClass(), comparator, bucket.getOrder(), totalPosition);
|
|
}
|
|
|
|
private MeasureDefinition createServiceMeasure(JRFillCrosstabMeasure measure) {
|
|
return new MeasureDefinition(measure.getValueClass(), measure.getCalculation(), measure.getIncrementerFactory());
|
|
}
|
|
|
|
protected void reset() {
|
|
super.reset();
|
|
for (int i = 0; i < this.variables.length; i++) {
|
|
this.variables[i].setValue(null);
|
|
this.variables[i].setInitialized(true);
|
|
}
|
|
}
|
|
|
|
protected void evaluate(byte evaluation) throws JRException {
|
|
reset();
|
|
evaluatePrintWhenExpression(evaluation);
|
|
evaluateProperties(evaluation);
|
|
if (isPrintWhenExpressionNull() || isPrintWhenTrue()) {
|
|
this.dataset.evaluateDatasetRun(evaluation);
|
|
initEvaluator(evaluation);
|
|
this.bucketingService.processData();
|
|
this.hasData = this.bucketingService.hasData();
|
|
if (this.hasData) {
|
|
this.columnHeadersData = this.bucketingService.getColumnHeaders();
|
|
this.rowHeadersData = this.bucketingService.getRowHeaders();
|
|
this.cellData = this.bucketingService.getCrosstabCells();
|
|
if (this.percentage)
|
|
this.grandTotals = this.bucketingService.getGrandTotals();
|
|
this.crosstabFiller.initCrosstab();
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void initEvaluator(byte evaluation) throws JRException {
|
|
Map parameterValues = JRFillSubreport.getParameterValues(this.filler, getParametersMapExpression(), (JRDatasetParameter[])getParameters(), evaluation, true, false, false);
|
|
ResourceBundle resBdl = (ResourceBundle)parameterValues.get("REPORT_RESOURCE_BUNDLE");
|
|
if (resBdl == null) {
|
|
JRFillParameter resourceBundleParam = (JRFillParameter)this.filler.getParametersMap().get("REPORT_RESOURCE_BUNDLE");
|
|
parameterValues.put("REPORT_RESOURCE_BUNDLE", resourceBundleParam.getValue());
|
|
}
|
|
parameterValues.put("REPORT_PARAMETERS_MAP", parameterValues);
|
|
for (int i = 0; i < this.parameters.length; i++) {
|
|
Object value = parameterValues.get(this.parameters[i].getName());
|
|
this.parameters[i].setValue(value);
|
|
}
|
|
this.crosstabEvaluator.init(this.parametersMap, this.variablesMap, this.filler.getWhenResourceMissingType());
|
|
}
|
|
|
|
protected void initBucketingService() {
|
|
if (this.bucketingService == null) {
|
|
try {
|
|
this.bucketingService = createService((byte)1);
|
|
} catch (JRException e) {
|
|
throw new JRRuntimeException("Could not create bucketing service", e);
|
|
}
|
|
} else {
|
|
this.bucketingService.clear();
|
|
}
|
|
}
|
|
|
|
protected boolean prepare(int availableStretchHeight, boolean isOverflow) throws JRException {
|
|
super.prepare(availableStretchHeight, isOverflow);
|
|
if (!isToPrint())
|
|
return false;
|
|
if (availableStretchHeight < getRelativeY() - getY() - getBandBottomY()) {
|
|
setToPrint(false);
|
|
return true;
|
|
}
|
|
if (isOverflow && this.crosstabFiller.ended() && isAlreadyPrinted())
|
|
if (isPrintWhenDetailOverflows()) {
|
|
rewind();
|
|
setReprinted(true);
|
|
} else {
|
|
setStretchHeight(getHeight());
|
|
setToPrint(false);
|
|
return false;
|
|
}
|
|
if (isOverflow && isPrintWhenDetailOverflows())
|
|
setReprinted(true);
|
|
int availableHeight = getHeight() + availableStretchHeight - getRelativeY() + getY() + getBandBottomY();
|
|
this.crosstabFiller.fill(availableHeight);
|
|
boolean willOverflow = this.crosstabFiller.willOverflow();
|
|
setStretchHeight(willOverflow ? availableHeight : this.crosstabFiller.getUsedHeight());
|
|
return willOverflow;
|
|
}
|
|
|
|
protected JRPrintElement fill() {
|
|
JRPrintRectangle printRectangle = null;
|
|
printRectangle = new JRTemplatePrintRectangle(getJRTemplateRectangle());
|
|
printRectangle.setX(getX());
|
|
printRectangle.setY(getRelativeY());
|
|
printRectangle.setWidth(getWidth());
|
|
printRectangle.setHeight(getStretchHeight());
|
|
return (JRPrintElement)printRectangle;
|
|
}
|
|
|
|
protected JRTemplateRectangle getJRTemplateRectangle() {
|
|
JRStyle style = getStyle();
|
|
JRTemplateRectangle template = (JRTemplateRectangle)getTemplate(style);
|
|
if (template == null) {
|
|
JRDesignRectangle rectangle = new JRDesignRectangle();
|
|
rectangle.setKey(getKey());
|
|
rectangle.setPositionType(getPositionType());
|
|
rectangle.setMode(getMode());
|
|
rectangle.setX(getX());
|
|
rectangle.setY(getY());
|
|
rectangle.setWidth(getWidth());
|
|
rectangle.setHeight(getHeight());
|
|
rectangle.setRemoveLineWhenBlank(isRemoveLineWhenBlank());
|
|
rectangle.setPrintInFirstWholeBand(isPrintInFirstWholeBand());
|
|
rectangle.setPrintWhenDetailOverflows(isPrintWhenDetailOverflows());
|
|
rectangle.setPrintWhenGroupChanges(getPrintWhenGroupChanges());
|
|
rectangle.setForecolor(getForecolor());
|
|
rectangle.setBackcolor(getBackcolor());
|
|
rectangle.getLinePen().setLineWidth(0.0F);
|
|
template = new JRTemplateRectangle(this.band.getOrigin(), this.filler.getJasperPrint().getDefaultStyleProvider(), (JRRectangle)rectangle);
|
|
registerTemplate(style, template);
|
|
}
|
|
return template;
|
|
}
|
|
|
|
protected void rewind() {
|
|
this.crosstabFiller.initCrosstab();
|
|
}
|
|
|
|
protected List getPrintElements() {
|
|
List printElements = this.crosstabFiller.getPrintElements();
|
|
if (getRunDirection() == 1)
|
|
mirrorPrintElements(printElements);
|
|
return printElements;
|
|
}
|
|
|
|
protected void mirrorPrintElements(List printElements) {
|
|
for (Iterator it = printElements.iterator(); it.hasNext(); ) {
|
|
JRPrintElement element = it.next();
|
|
int mirrorX = getWidth() - element.getX() - element.getWidth();
|
|
element.setX(mirrorX);
|
|
}
|
|
}
|
|
|
|
protected void resolveElement(JRPrintElement element, byte evaluation) {}
|
|
|
|
public void collectExpressions(JRExpressionCollector collector) {
|
|
collector.collect(this);
|
|
}
|
|
|
|
public void visit(JRVisitor visitor) {
|
|
visitor.visitCrosstab(this);
|
|
}
|
|
|
|
public int getId() {
|
|
return this.parentCrosstab.getId();
|
|
}
|
|
|
|
public JRCrosstabDataset getDataset() {
|
|
return this.dataset;
|
|
}
|
|
|
|
public JRCrosstabRowGroup[] getRowGroups() {
|
|
return (JRCrosstabRowGroup[])this.rowGroups;
|
|
}
|
|
|
|
public JRCrosstabColumnGroup[] getColumnGroups() {
|
|
return (JRCrosstabColumnGroup[])this.columnGroups;
|
|
}
|
|
|
|
public JRCrosstabMeasure[] getMeasures() {
|
|
return (JRCrosstabMeasure[])this.measures;
|
|
}
|
|
|
|
public class JRFillCrosstabDataset extends JRFillElementDataset implements JRCrosstabDataset {
|
|
private Object[] bucketValues;
|
|
|
|
private Object[] measureValues;
|
|
|
|
private final JRFillCrosstab this$0;
|
|
|
|
public JRFillCrosstabDataset(JRCrosstabDataset dataset, JRFillObjectFactory factory) {
|
|
super((JRElementDataset)dataset, factory);
|
|
this.bucketValues = new Object[JRFillCrosstab.this.rowGroups.length + JRFillCrosstab.this.columnGroups.length];
|
|
this.measureValues = new Object[JRFillCrosstab.this.measures.length];
|
|
}
|
|
|
|
protected void customInitialize() {
|
|
JRFillCrosstab.this.initBucketingService();
|
|
}
|
|
|
|
protected void customEvaluate(JRCalculator calculator) throws JRExpressionEvalException {
|
|
int i;
|
|
for (i = 0; i < JRFillCrosstab.this.rowGroups.length; i++)
|
|
this.bucketValues[i] = calculator.evaluate(JRFillCrosstab.this.rowGroups[i].getBucket().getExpression());
|
|
for (i = 0; i < JRFillCrosstab.this.columnGroups.length; i++)
|
|
this.bucketValues[i + JRFillCrosstab.this.rowGroups.length] = calculator.evaluate(JRFillCrosstab.this.columnGroups[i].getBucket().getExpression());
|
|
for (i = 0; i < JRFillCrosstab.this.measures.length; i++)
|
|
this.measureValues[i] = calculator.evaluate(JRFillCrosstab.this.measures[i].getValueExpression());
|
|
}
|
|
|
|
protected void customIncrement() {
|
|
try {
|
|
JRFillCrosstab.this.bucketingService.addData(this.bucketValues, this.measureValues);
|
|
} catch (JRException e) {
|
|
throw new JRRuntimeException("Error incrementing crosstab dataset", e);
|
|
}
|
|
}
|
|
|
|
protected Dataset getCustomDataset() {
|
|
return null;
|
|
}
|
|
|
|
public void collectExpressions(JRExpressionCollector collector) {}
|
|
|
|
public boolean isDataPreSorted() {
|
|
return ((JRCrosstabDataset)this.parent).isDataPreSorted();
|
|
}
|
|
}
|
|
|
|
protected class CrosstabFiller {
|
|
private int yOffset;
|
|
|
|
private boolean willOverflow;
|
|
|
|
private int[] rowHeadersXOffsets;
|
|
|
|
private boolean[] columnBreakable;
|
|
|
|
private boolean[] rowBreakable;
|
|
|
|
private int[] columnCount;
|
|
|
|
private int[] rowCount;
|
|
|
|
private int[] columnXOffsets;
|
|
|
|
private boolean noDataCellPrinted;
|
|
|
|
private int startRowIndex;
|
|
|
|
private int startColumnIndex;
|
|
|
|
private int lastColumnIndex;
|
|
|
|
private List columnHeaders;
|
|
|
|
private List printRows;
|
|
|
|
private HeaderCell[] spanHeaders;
|
|
|
|
private int[] spanHeadersStart;
|
|
|
|
private List rowYs = new ArrayList();
|
|
|
|
private int rowIdx;
|
|
|
|
private List preparedRow = new ArrayList();
|
|
|
|
private int preparedRowHeight;
|
|
|
|
private boolean printRowHeaders;
|
|
|
|
private boolean printColumnHeaders;
|
|
|
|
private JRFillVariable rowCountVar;
|
|
|
|
private JRFillVariable colCountVar;
|
|
|
|
private final JRFillCrosstab this$0;
|
|
|
|
protected CrosstabFiller() {
|
|
setRowHeadersXOffsets();
|
|
this.printRows = new ArrayList();
|
|
this.rowCountVar = (JRFillVariable)JRFillCrosstab.this.variablesMap.get("ROW_COUNT");
|
|
this.colCountVar = (JRFillVariable)JRFillCrosstab.this.variablesMap.get("COLUMN_COUNT");
|
|
}
|
|
|
|
protected void initCrosstab() {
|
|
this.columnXOffsets = computeOffsets(JRFillCrosstab.this.columnHeadersData, (JRFillCrosstabGroup[])JRFillCrosstab.this.columnGroups, true);
|
|
this.columnBreakable = computeBreakableHeaders(JRFillCrosstab.this.columnHeadersData, (JRFillCrosstabGroup[])JRFillCrosstab.this.columnGroups, this.columnXOffsets, true, true);
|
|
this.columnCount = computeCounts(JRFillCrosstab.this.columnHeadersData);
|
|
int[] rowYOffsets = computeOffsets(JRFillCrosstab.this.rowHeadersData, (JRFillCrosstabGroup[])JRFillCrosstab.this.rowGroups, false);
|
|
this.rowBreakable = computeBreakableHeaders(JRFillCrosstab.this.rowHeadersData, (JRFillCrosstabGroup[])JRFillCrosstab.this.rowGroups, rowYOffsets, false, false);
|
|
this.rowCount = computeCounts(JRFillCrosstab.this.rowHeadersData);
|
|
this.spanHeaders = new HeaderCell[JRFillCrosstab.this.rowGroups.length - 1];
|
|
this.spanHeadersStart = new int[JRFillCrosstab.this.rowGroups.length - 1];
|
|
this.startRowIndex = 0;
|
|
this.startColumnIndex = 0;
|
|
this.lastColumnIndex = 0;
|
|
this.noDataCellPrinted = false;
|
|
}
|
|
|
|
protected void setRowHeadersXOffsets() {
|
|
this.rowHeadersXOffsets = new int[JRFillCrosstab.this.rowGroups.length + 1];
|
|
this.rowHeadersXOffsets[0] = 0;
|
|
for (int i = 0; i < JRFillCrosstab.this.rowGroups.length; i++)
|
|
this.rowHeadersXOffsets[i + 1] = this.rowHeadersXOffsets[i] + JRFillCrosstab.this.rowGroups[i].getWidth();
|
|
}
|
|
|
|
protected int[] computeOffsets(HeaderCell[][] headersData, JRFillCrosstabGroup[] groups, boolean width) {
|
|
int[] offsets = new int[(headersData[0]).length + 1];
|
|
offsets[0] = 0;
|
|
for (int i = 0; i < (headersData[0]).length; i++) {
|
|
int size = 0;
|
|
for (int j = groups.length - 1; j >= 0; j--) {
|
|
if (headersData[j][i] != null) {
|
|
JRFillCellContents cell = headersData[j][i].isTotal() ? groups[j].getFillTotalHeader() : groups[j].getFillHeader();
|
|
size = (cell == null) ? 0 : (width ? cell.getWidth() : cell.getHeight());
|
|
break;
|
|
}
|
|
}
|
|
offsets[i + 1] = offsets[i] + size;
|
|
}
|
|
return offsets;
|
|
}
|
|
|
|
protected boolean[] computeBreakableHeaders(HeaderCell[][] headersData, JRFillCrosstabGroup[] groups, int[] offsets, boolean width, boolean startHeaders) {
|
|
boolean[] breakable = new boolean[(headersData[0]).length];
|
|
for (int i = 0; i < breakable.length; i++)
|
|
breakable[i] = true;
|
|
for (int j = 0; j < groups.length; j++) {
|
|
JRFillCellContents fillHeader = groups[j].getFillHeader();
|
|
if (fillHeader != null) {
|
|
int size = width ? fillHeader.getWidth() : fillHeader.getHeight();
|
|
for (int k = 0; k < (headersData[0]).length; k++) {
|
|
HeaderCell header = headersData[j][k];
|
|
if (header != null && !header.isTotal() && header.getLevelSpan() > 1) {
|
|
int span = header.getLevelSpan();
|
|
if (startHeaders)
|
|
for (int n = k + 1; n < k + span && offsets[n] - offsets[k] < size; n++)
|
|
breakable[n] = false;
|
|
for (int m = k + span - 1; m > k && offsets[k + span] - offsets[m] < size; m--)
|
|
breakable[m] = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return breakable;
|
|
}
|
|
|
|
private int[] computeCounts(HeaderCell[][] headersData) {
|
|
int[] counts = new int[(headersData[0]).length];
|
|
HeaderCell[] lastHeaders = headersData[headersData.length - 1];
|
|
for (int i = 0, c = 0; i < counts.length; i++) {
|
|
HeaderCell lastHeader = lastHeaders[i];
|
|
if (lastHeader != null && !lastHeader.isTotal())
|
|
c++;
|
|
counts[i] = c;
|
|
}
|
|
return counts;
|
|
}
|
|
|
|
protected void fill(int availableHeight) throws JRException {
|
|
this.printRows.clear();
|
|
this.yOffset = 0;
|
|
this.willOverflow = false;
|
|
fillVerticalCrosstab(availableHeight);
|
|
}
|
|
|
|
protected boolean willOverflow() {
|
|
return this.willOverflow;
|
|
}
|
|
|
|
protected int getUsedHeight() {
|
|
return this.yOffset;
|
|
}
|
|
|
|
protected boolean ended() {
|
|
return JRFillCrosstab.this.hasData ? ((this.startRowIndex >= (JRFillCrosstab.this.rowHeadersData[0]).length && this.startColumnIndex >= (JRFillCrosstab.this.columnHeadersData[0]).length)) : this.noDataCellPrinted;
|
|
}
|
|
|
|
protected void fillVerticalCrosstab(int availableHeight) throws JRException {
|
|
if (!JRFillCrosstab.this.hasData) {
|
|
fillNoDataCell(availableHeight);
|
|
return;
|
|
}
|
|
this.printRowHeaders = (this.startColumnIndex == 0 || JRFillCrosstab.this.isRepeatRowHeaders());
|
|
int rowHeadersXOffset = this.printRowHeaders ? this.rowHeadersXOffsets[JRFillCrosstab.this.rowGroups.length] : 0;
|
|
if (this.startColumnIndex == this.lastColumnIndex) {
|
|
int availableWidth = JRFillCrosstab.this.getWidth();
|
|
this.columnHeaders = getGroupHeaders(availableWidth - rowHeadersXOffset, this.columnXOffsets, this.columnBreakable, this.startColumnIndex, JRFillCrosstab.this.columnHeadersData, (JRFillCrosstabGroup[])JRFillCrosstab.this.columnGroups);
|
|
this.lastColumnIndex = this.startColumnIndex + this.columnHeaders.size();
|
|
if (this.startColumnIndex == this.lastColumnIndex)
|
|
throw new JRRuntimeException("Not enough space to render the crosstab.");
|
|
}
|
|
this.printColumnHeaders = (this.startRowIndex == 0 || JRFillCrosstab.this.isRepeatColumnHeaders());
|
|
List columnHeaderRows = null;
|
|
if (this.printColumnHeaders) {
|
|
columnHeaderRows = fillColumnHeaders(rowHeadersXOffset, availableHeight - this.yOffset);
|
|
if (this.willOverflow)
|
|
return;
|
|
}
|
|
int lastRowIndex = fillRows(rowHeadersXOffset, availableHeight - this.yOffset);
|
|
if (lastRowIndex == this.startRowIndex) {
|
|
this.willOverflow = true;
|
|
return;
|
|
}
|
|
if (columnHeaderRows != null)
|
|
this.printRows.addAll(columnHeaderRows);
|
|
if (lastRowIndex >= (JRFillCrosstab.this.rowHeadersData[0]).length) {
|
|
this.startColumnIndex = this.lastColumnIndex;
|
|
if (this.startColumnIndex < (JRFillCrosstab.this.columnHeadersData[0]).length) {
|
|
this.startRowIndex = lastRowIndex = 0;
|
|
this.yOffset += JRFillCrosstab.this.getColumnBreakOffset();
|
|
fillVerticalCrosstab(availableHeight);
|
|
return;
|
|
}
|
|
}
|
|
boolean fillEnded = (lastRowIndex >= (JRFillCrosstab.this.rowHeadersData[0]).length && this.lastColumnIndex >= (JRFillCrosstab.this.columnHeadersData[0]).length);
|
|
if (fillEnded) {
|
|
JRFillCrosstab.this.setStretchHeight(this.yOffset);
|
|
} else {
|
|
JRFillCrosstab.this.setStretchHeight(availableHeight);
|
|
}
|
|
this.startRowIndex = lastRowIndex;
|
|
this.willOverflow = !fillEnded;
|
|
}
|
|
|
|
protected List getGroupHeaders(int available, int[] offsets, boolean[] breakable, int firstIndex, HeaderCell[][] headersData, JRFillCrosstabGroup[] groups) {
|
|
List headers = new ArrayList();
|
|
int maxOffset = available + offsets[firstIndex];
|
|
int lastIndex;
|
|
for (lastIndex = firstIndex; lastIndex < (headersData[0]).length && offsets[lastIndex + 1] <= maxOffset; lastIndex++) {
|
|
HeaderCell[] groupHeaders = new HeaderCell[groups.length];
|
|
for (int j = 0; j < groups.length; j++)
|
|
groupHeaders[j] = headersData[j][lastIndex];
|
|
headers.add(groupHeaders);
|
|
}
|
|
if (lastIndex < (headersData[0]).length)
|
|
while (lastIndex > firstIndex && !breakable[lastIndex]) {
|
|
lastIndex--;
|
|
headers.remove(headers.size() - 1);
|
|
}
|
|
if (lastIndex > firstIndex) {
|
|
if (firstIndex > 0) {
|
|
HeaderCell[] firstHeaders = headers.get(0);
|
|
for (int j = 0; j < groups.length; j++) {
|
|
HeaderCell header = headersData[j][firstIndex];
|
|
if (header == null) {
|
|
int spanIndex = getSpanIndex(firstIndex, j, headersData);
|
|
if (spanIndex >= 0) {
|
|
HeaderCell spanCell = headersData[j][spanIndex];
|
|
int headerEndIdx = spanCell.getLevelSpan() + spanIndex;
|
|
if (headerEndIdx > lastIndex)
|
|
headerEndIdx = lastIndex;
|
|
firstHeaders[j] = HeaderCell.createLevelSpanCopy(spanCell, headerEndIdx - firstIndex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (lastIndex < (headersData[0]).length)
|
|
for (int j = 0; j < groups.length; j++) {
|
|
HeaderCell header = headersData[j][lastIndex];
|
|
if (header == null) {
|
|
int spanIndex = getSpanIndex(lastIndex, j, headersData);
|
|
if (spanIndex >= firstIndex) {
|
|
HeaderCell spanCell = headersData[j][spanIndex];
|
|
HeaderCell[] headerCells = headers.get(spanIndex - firstIndex);
|
|
headerCells[j] = HeaderCell.createLevelSpanCopy(spanCell, lastIndex - spanIndex);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return headers;
|
|
}
|
|
|
|
protected int getSpanIndex(int i, int j, HeaderCell[][] headersData) {
|
|
int spanIndex = i - 1;
|
|
while (spanIndex >= 0 && headersData[j][spanIndex] == null)
|
|
spanIndex--;
|
|
if (spanIndex >= 0) {
|
|
HeaderCell spanCell = headersData[j][spanIndex];
|
|
int span = spanCell.getLevelSpan();
|
|
if (span > i - spanIndex)
|
|
return spanIndex;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
protected void fillNoDataCell(int availableHeight) throws JRException {
|
|
if (JRFillCrosstab.this.whenNoDataCell == null) {
|
|
this.noDataCellPrinted = true;
|
|
} else if (availableHeight < JRFillCrosstab.this.whenNoDataCell.getHeight()) {
|
|
this.willOverflow = true;
|
|
} else {
|
|
JRFillCrosstab.this.whenNoDataCell.evaluate((byte)3);
|
|
JRFillCrosstab.this.whenNoDataCell.prepare(availableHeight - JRFillCrosstab.this.whenNoDataCell.getHeight());
|
|
this.willOverflow = JRFillCrosstab.this.whenNoDataCell.willOverflow();
|
|
if (!this.willOverflow) {
|
|
JRFillCrosstab.this.whenNoDataCell.setX(0);
|
|
JRFillCrosstab.this.whenNoDataCell.setY(0);
|
|
JRPrintFrame printCell = JRFillCrosstab.this.whenNoDataCell.fill();
|
|
List noDataRow = new ArrayList(1);
|
|
noDataRow.add(printCell);
|
|
addPrintRow(noDataRow);
|
|
this.yOffset += JRFillCrosstab.this.whenNoDataCell.getPrintHeight();
|
|
this.noDataCellPrinted = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected List fillColumnHeaders(int rowHeadersXOffset, int availableHeight) throws JRException {
|
|
List headerRows;
|
|
JRFillCellContents[][] columnHeaderRows = new JRFillCellContents[JRFillCrosstab.this.columnGroups.length][this.lastColumnIndex - this.startColumnIndex + 1];
|
|
this.rowYs.clear();
|
|
this.rowYs.add(new Integer(0));
|
|
if (this.printRowHeaders && JRFillCrosstab.this.headerCell != null) {
|
|
JRFillCellContents contents = fillHeader(availableHeight);
|
|
if (this.willOverflow)
|
|
return null;
|
|
columnHeaderRows[JRFillCrosstab.this.columnGroups.length - 1][0] = contents;
|
|
}
|
|
label29: for (this.rowIdx = 0; this.rowIdx < JRFillCrosstab.this.columnGroups.length; this.rowIdx++) {
|
|
for (int columnIdx = this.startColumnIndex; columnIdx < this.lastColumnIndex; columnIdx++) {
|
|
HeaderCell[] headers = this.columnHeaders.get(columnIdx - this.startColumnIndex);
|
|
HeaderCell cell = headers[this.rowIdx];
|
|
if (cell != null) {
|
|
JRFillCellContents contents = prepareColumnHeader(cell, columnIdx, rowHeadersXOffset, availableHeight);
|
|
columnHeaderRows[this.rowIdx + cell.getDepthSpan() - 1][columnIdx - this.startColumnIndex + 1] = contents;
|
|
if (this.willOverflow)
|
|
break label29;
|
|
}
|
|
}
|
|
int rowStretchHeight = stretchColumnHeadersRow(columnHeaderRows[this.rowIdx]);
|
|
this.rowYs.add(new Integer(((Integer)this.rowYs.get(this.rowIdx)).intValue() + rowStretchHeight));
|
|
}
|
|
if (this.willOverflow) {
|
|
headerRows = null;
|
|
releaseColumnHeaderCells(columnHeaderRows);
|
|
} else {
|
|
headerRows = fillColumnHeaders(columnHeaderRows);
|
|
this.yOffset += ((Integer)this.rowYs.get(JRFillCrosstab.this.columnGroups.length)).intValue();
|
|
}
|
|
resetVariables();
|
|
return headerRows;
|
|
}
|
|
|
|
private void setCountVars(int rowIdx, int colIdx) {
|
|
if (rowIdx == -1) {
|
|
this.rowCountVar.setValue(null);
|
|
} else {
|
|
this.rowCountVar.setValue(new Integer(this.rowCount[rowIdx]));
|
|
}
|
|
if (colIdx == -1) {
|
|
this.colCountVar.setValue(null);
|
|
} else {
|
|
this.colCountVar.setValue(new Integer(this.columnCount[colIdx]));
|
|
}
|
|
}
|
|
|
|
private JRFillCellContents fillHeader(int availableHeight) throws JRException {
|
|
setCountVars(-1, -1);
|
|
JRFillCellContents contents = JRFillCrosstab.this.headerCell.getWorkingClone();
|
|
contents.evaluate((byte)3);
|
|
contents.prepare(availableHeight - JRFillCrosstab.this.headerCell.getHeight());
|
|
this.willOverflow = contents.willOverflow();
|
|
if (!this.willOverflow) {
|
|
contents.setX(0);
|
|
contents.setY(this.yOffset);
|
|
contents.setVerticalSpan(JRFillCrosstab.this.columnGroups.length);
|
|
}
|
|
return contents;
|
|
}
|
|
|
|
private JRFillCellContents prepareColumnHeader(HeaderCell cell, int columnIdx, int xOffset, int availableHeight) throws JRException {
|
|
JRFillCrosstabColumnGroup group = JRFillCrosstab.this.columnGroups[this.rowIdx];
|
|
JRFillCellContents contents = cell.isTotal() ? group.getFillTotalHeader() : group.getFillHeader();
|
|
int width = this.columnXOffsets[columnIdx + cell.getLevelSpan()] - this.columnXOffsets[columnIdx];
|
|
int height = contents.getHeight();
|
|
if (width <= 0 || height <= 0)
|
|
return null;
|
|
JRFillCellContents preparedContents = null;
|
|
int rowY = ((Integer)this.rowYs.get(this.rowIdx)).intValue();
|
|
int cellAvailableStretch = availableHeight - rowY - height;
|
|
if (cellAvailableStretch >= 0) {
|
|
setCountVars(-1, columnIdx);
|
|
setGroupVariables((JRFillCrosstabGroup[])JRFillCrosstab.this.columnGroups, cell.getBucketValues());
|
|
contents = contents.getTransformedContents(width, height, group.getPosition(), (byte)1);
|
|
boolean firstOnRow = (columnIdx == this.startColumnIndex && (!this.printRowHeaders || JRFillCrosstab.this.headerCell == null));
|
|
contents = contents.getBoxContents((firstOnRow && JRFillCrosstab.this.getRunDirection() == 0), (firstOnRow && JRFillCrosstab.this.getRunDirection() == 1), false);
|
|
contents = contents.getWorkingClone();
|
|
contents.evaluate((byte)3);
|
|
contents.prepare(cellAvailableStretch);
|
|
if (contents.willOverflow()) {
|
|
this.willOverflow = true;
|
|
} else {
|
|
contents.setX(this.columnXOffsets[columnIdx] - this.columnXOffsets[this.startColumnIndex] + xOffset);
|
|
contents.setY(rowY + this.yOffset);
|
|
contents.setVerticalSpan(cell.getDepthSpan());
|
|
preparedContents = contents;
|
|
}
|
|
} else {
|
|
this.willOverflow = true;
|
|
}
|
|
return preparedContents;
|
|
}
|
|
|
|
private int stretchColumnHeadersRow(JRFillCellContents[] headers) {
|
|
int rowY = ((Integer)this.rowYs.get(this.rowIdx)).intValue();
|
|
int rowStretchHeight = 0;
|
|
int j;
|
|
for (j = 0; j < headers.length; j++) {
|
|
JRFillCellContents contents = headers[j];
|
|
if (contents != null) {
|
|
int startRowY = rowY;
|
|
if (contents.getVerticalSpan() > 1)
|
|
startRowY = ((Integer)this.rowYs.get(this.rowIdx - contents.getVerticalSpan() + 1)).intValue();
|
|
int height = contents.getPrintHeight() - rowY + startRowY;
|
|
if (height > rowStretchHeight)
|
|
rowStretchHeight = height;
|
|
}
|
|
}
|
|
for (j = 0; j < headers.length; j++) {
|
|
JRFillCellContents contents = headers[j];
|
|
if (contents != null) {
|
|
int startRowY = rowY;
|
|
if (contents.getVerticalSpan() > 1)
|
|
startRowY = ((Integer)this.rowYs.get(this.rowIdx - contents.getVerticalSpan() + 1)).intValue();
|
|
contents.stretchTo(rowStretchHeight + rowY - startRowY);
|
|
}
|
|
}
|
|
return rowStretchHeight;
|
|
}
|
|
|
|
private List fillColumnHeaders(JRFillCellContents[][] columnHeaderRows) throws JRException {
|
|
List headerRows = new ArrayList(JRFillCrosstab.this.columnGroups.length);
|
|
for (int i = 0; i < columnHeaderRows.length; i++) {
|
|
List headerRow = new ArrayList(this.lastColumnIndex - this.startColumnIndex);
|
|
headerRows.add(headerRow);
|
|
for (int j = 0; j < (columnHeaderRows[i]).length; j++) {
|
|
JRFillCellContents contents = columnHeaderRows[i][j];
|
|
if (contents != null) {
|
|
headerRow.add(contents.fill());
|
|
contents.releaseWorkingClone();
|
|
}
|
|
}
|
|
}
|
|
return headerRows;
|
|
}
|
|
|
|
private void releaseColumnHeaderCells(JRFillCellContents[][] columnHeaderRows) throws JRException {
|
|
for (int i = 0; i < columnHeaderRows.length; i++) {
|
|
for (int j = 0; j < (columnHeaderRows[i]).length; j++) {
|
|
JRFillCellContents contents = columnHeaderRows[i][j];
|
|
if (contents != null) {
|
|
contents.rewind();
|
|
contents.releaseWorkingClone();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected int fillRows(int xOffset, int availableHeight) throws JRException {
|
|
this.rowYs.clear();
|
|
this.rowYs.add(new Integer(0));
|
|
for (this.rowIdx = 0; this.rowIdx < JRFillCrosstab.this.cellData.length - this.startRowIndex; this.rowIdx++) {
|
|
initPreparedRow();
|
|
prepareRow(xOffset, availableHeight);
|
|
if (this.willOverflow)
|
|
break;
|
|
fillRow();
|
|
this.rowYs.add(new Integer(((Integer)this.rowYs.get(this.rowIdx)).intValue() + this.preparedRowHeight));
|
|
}
|
|
if (this.rowIdx < JRFillCrosstab.this.cellData.length - this.startRowIndex) {
|
|
releasePreparedRow();
|
|
if (this.printRowHeaders)
|
|
fillContinuingRowHeaders(xOffset, availableHeight);
|
|
}
|
|
this.yOffset += ((Integer)this.rowYs.get(this.rowIdx)).intValue();
|
|
return this.rowIdx + this.startRowIndex;
|
|
}
|
|
|
|
private void initPreparedRow() {
|
|
this.preparedRow.clear();
|
|
this.preparedRowHeight = 0;
|
|
}
|
|
|
|
private void removeFilledRows(int rowsToRemove) {
|
|
if (rowsToRemove > 0) {
|
|
for (int i = 0; i < rowsToRemove; i++) {
|
|
this.printRows.remove(this.printRows.size() - 1);
|
|
this.rowYs.remove(this.rowYs.size() - 1);
|
|
}
|
|
this.rowIdx -= rowsToRemove;
|
|
}
|
|
}
|
|
|
|
private void releasePreparedRow() throws JRException {
|
|
for (Iterator it = this.preparedRow.iterator(); it.hasNext(); ) {
|
|
JRFillCellContents cell = it.next();
|
|
cell.rewind();
|
|
cell.releaseWorkingClone();
|
|
}
|
|
this.preparedRow.clear();
|
|
}
|
|
|
|
private void fillRow() throws JRException {
|
|
int rowY = ((Integer)this.rowYs.get(this.rowIdx)).intValue();
|
|
List rowPrints = new ArrayList(this.preparedRow.size());
|
|
for (Iterator it = this.preparedRow.iterator(); it.hasNext(); ) {
|
|
JRFillCellContents cell = it.next();
|
|
int spanHeight = 0;
|
|
if (cell.getVerticalSpan() > 1)
|
|
spanHeight = rowY - ((Integer)this.rowYs.get(this.rowIdx - cell.getVerticalSpan() + 1)).intValue();
|
|
cell.stretchTo(this.preparedRowHeight + spanHeight);
|
|
rowPrints.add(cell.fill());
|
|
cell.releaseWorkingClone();
|
|
}
|
|
addPrintRow(rowPrints);
|
|
}
|
|
|
|
private void prepareRow(int xOffset, int availableHeight) throws JRException {
|
|
for (int col = this.startColumnIndex; col < this.lastColumnIndex; col++) {
|
|
CrosstabCell data = JRFillCrosstab.this.cellData[this.rowIdx + this.startRowIndex][col];
|
|
boolean overflow = prepareDataCell(data, col, availableHeight, xOffset);
|
|
if (overflow) {
|
|
this.willOverflow = true;
|
|
return;
|
|
}
|
|
}
|
|
resetVariables();
|
|
if (this.printRowHeaders) {
|
|
int j = 0;
|
|
while (true) {
|
|
boolean overflow;
|
|
if (j < JRFillCrosstab.this.rowGroups.length) {
|
|
HeaderCell cell = JRFillCrosstab.this.rowHeadersData[j][this.rowIdx + this.startRowIndex];
|
|
overflow = false;
|
|
if (cell == null) {
|
|
overflow = prepareClosingRowHeader(j, availableHeight);
|
|
} else {
|
|
if (cell.getLevelSpan() > 1) {
|
|
this.spanHeaders[j] = cell;
|
|
this.spanHeadersStart[j] = this.rowIdx + this.startRowIndex;
|
|
} else {
|
|
overflow = prepareRowHeader(j, cell, 1, availableHeight);
|
|
if (overflow) {
|
|
this.willOverflow = true;
|
|
return;
|
|
}
|
|
}
|
|
j++;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
if (overflow) {
|
|
this.willOverflow = true;
|
|
return;
|
|
}
|
|
}
|
|
resetVariables();
|
|
}
|
|
}
|
|
|
|
private boolean prepareDataCell(CrosstabCell data, int column, int availableHeight, int xOffset) throws JRException {
|
|
int rowY = ((Integer)this.rowYs.get(this.rowIdx)).intValue();
|
|
JRFillCrosstabCell cell = JRFillCrosstab.this.crossCells[data.getRowTotalGroupIndex()][data.getColumnTotalGroupIndex()];
|
|
JRFillCellContents contents = (cell == null) ? null : cell.getFillContents();
|
|
if (contents == null || contents.getWidth() <= 0 || contents.getHeight() <= 0)
|
|
return false;
|
|
int cellAvailableStretch = availableHeight - rowY - contents.getHeight();
|
|
boolean overflow = (cellAvailableStretch < 0);
|
|
if (!overflow) {
|
|
boolean leftEmpty = (this.startColumnIndex != 0 && !JRFillCrosstab.this.isRepeatRowHeaders());
|
|
boolean topEmpty = (this.startRowIndex != 0 && !JRFillCrosstab.this.isRepeatColumnHeaders());
|
|
setCountVars(this.rowIdx + this.startRowIndex, column);
|
|
setGroupVariables((JRFillCrosstabGroup[])JRFillCrosstab.this.rowGroups, data.getRowBucketValues());
|
|
setGroupVariables((JRFillCrosstabGroup[])JRFillCrosstab.this.columnGroups, data.getColumnBucketValues());
|
|
setMeasureVariables(data);
|
|
boolean firstOnRow = (leftEmpty && column == this.startColumnIndex);
|
|
contents = contents.getBoxContents((firstOnRow && JRFillCrosstab.this.getRunDirection() == 0), (firstOnRow && JRFillCrosstab.this.getRunDirection() == 1), (topEmpty && this.rowIdx == 0));
|
|
contents = contents.getWorkingClone();
|
|
contents.evaluate((byte)3);
|
|
contents.prepare(cellAvailableStretch);
|
|
this.preparedRow.add(contents);
|
|
overflow = contents.willOverflow();
|
|
if (!overflow) {
|
|
contents.setX(this.columnXOffsets[column] - this.columnXOffsets[this.startColumnIndex] + xOffset);
|
|
contents.setY(rowY + this.yOffset);
|
|
int rowCellHeight = contents.getPrintHeight();
|
|
if (rowCellHeight > this.preparedRowHeight)
|
|
this.preparedRowHeight = rowCellHeight;
|
|
}
|
|
}
|
|
return overflow;
|
|
}
|
|
|
|
private boolean prepareRowHeader(int rowGroup, HeaderCell cell, int vSpan, int availableHeight) throws JRException {
|
|
JRFillCrosstabRowGroup group = JRFillCrosstab.this.rowGroups[rowGroup];
|
|
JRFillCellContents contents = cell.isTotal() ? group.getFillTotalHeader() : group.getFillHeader();
|
|
if (contents.getWidth() <= 0 || contents.getHeight() <= 0)
|
|
return false;
|
|
int spanHeight = 0;
|
|
int headerY = ((Integer)this.rowYs.get(this.rowIdx - vSpan + 1)).intValue();
|
|
if (vSpan > 1)
|
|
spanHeight += ((Integer)this.rowYs.get(this.rowIdx)).intValue() - headerY;
|
|
int rowHeight = spanHeight + this.preparedRowHeight;
|
|
boolean stretchContents = (group.getPosition() == 4);
|
|
int contentsHeight = stretchContents ? rowHeight : contents.getHeight();
|
|
int cellAvailableStretch = availableHeight - headerY - contentsHeight;
|
|
boolean headerOverflow = (cellAvailableStretch < 0 || rowHeight < contents.getHeight());
|
|
if (!headerOverflow) {
|
|
setCountVars(this.rowIdx + this.startRowIndex - vSpan + 1, -1);
|
|
setGroupVariables((JRFillCrosstabGroup[])JRFillCrosstab.this.rowGroups, cell.getBucketValues());
|
|
if (stretchContents)
|
|
contents = contents.getTransformedContents(contents.getWidth(), rowHeight, (byte)1, (byte)4);
|
|
contents = contents.getBoxContents(false, false, (this.rowIdx + 1 == vSpan && (!this.printColumnHeaders || JRFillCrosstab.this.headerCell == null)));
|
|
contents.getWorkingClone();
|
|
contents.evaluate((byte)3);
|
|
contents.prepare(cellAvailableStretch);
|
|
this.preparedRow.add(contents);
|
|
headerOverflow = contents.willOverflow();
|
|
if (!headerOverflow) {
|
|
contents.setX(this.rowHeadersXOffsets[rowGroup]);
|
|
contents.setY(headerY + this.yOffset);
|
|
contents.setVerticalSpan(vSpan);
|
|
int rowCellHeight = contents.getPrintHeight() - spanHeight;
|
|
if (rowCellHeight > this.preparedRowHeight)
|
|
this.preparedRowHeight = rowCellHeight;
|
|
}
|
|
}
|
|
if (headerOverflow)
|
|
removeFilledRows(vSpan - 1);
|
|
return headerOverflow;
|
|
}
|
|
|
|
private boolean prepareClosingRowHeader(int rowGroup, int availableHeight) throws JRException {
|
|
if (rowGroup < JRFillCrosstab.this.rowGroups.length - 1 && this.spanHeaders[rowGroup] != null && this.spanHeaders[rowGroup].getLevelSpan() + this.spanHeadersStart[rowGroup] == this.rowIdx + this.startRowIndex + 1) {
|
|
HeaderCell cell = this.spanHeaders[rowGroup];
|
|
int vSpan = cell.getLevelSpan();
|
|
if (this.spanHeadersStart[rowGroup] < this.startRowIndex)
|
|
vSpan += this.spanHeadersStart[rowGroup] - this.startRowIndex;
|
|
this.spanHeaders[rowGroup] = null;
|
|
return prepareRowHeader(rowGroup, cell, vSpan, availableHeight);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void removeExceedingSpanHeaders() {
|
|
for (int j = JRFillCrosstab.this.rowGroups.length - 2; j >= 0; j--) {
|
|
if (this.spanHeaders[j] != null && this.spanHeadersStart[j] >= this.rowIdx + this.startRowIndex)
|
|
this.spanHeaders[j] = null;
|
|
}
|
|
}
|
|
|
|
private void setBackSpanHeaders() {
|
|
for (int j = JRFillCrosstab.this.rowGroups.length - 2; j >= 0 && this.spanHeaders[j] == null; j--) {
|
|
int spanIndex = getSpanIndex(this.rowIdx + this.startRowIndex, j, JRFillCrosstab.this.rowHeadersData);
|
|
if (spanIndex >= 0) {
|
|
this.spanHeaders[j] = JRFillCrosstab.this.rowHeadersData[j][spanIndex];
|
|
this.spanHeadersStart[j] = spanIndex;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void fillContinuingRowHeaders(int xOffset, int availableHeight) throws JRException {
|
|
boolean done = false;
|
|
label27: do {
|
|
removeExceedingSpanHeaders();
|
|
if (!this.rowBreakable[this.rowIdx + this.startRowIndex]) {
|
|
removeFilledRows(1);
|
|
setBackSpanHeaders();
|
|
} else {
|
|
initPreparedRow();
|
|
for (int j = 0; j < JRFillCrosstab.this.rowGroups.length - 1; j++) {
|
|
if (this.spanHeaders[j] != null) {
|
|
boolean headerOverflow = prepareContinuingRowHeader(j, availableHeight);
|
|
if (headerOverflow) {
|
|
releasePreparedRow();
|
|
continue label27;
|
|
}
|
|
}
|
|
}
|
|
if (!this.preparedRow.isEmpty()) {
|
|
int lastRowHeight = ((Integer)this.rowYs.get(this.rowIdx)).intValue() - ((Integer)this.rowYs.get(this.rowIdx - 1)).intValue();
|
|
if (this.preparedRowHeight > lastRowHeight) {
|
|
refillLastRow(xOffset, availableHeight);
|
|
} else {
|
|
fillContinuingHeaders(lastRowHeight);
|
|
}
|
|
}
|
|
done = true;
|
|
}
|
|
} while (!done && this.rowIdx > 0);
|
|
}
|
|
|
|
private void fillContinuingHeaders(int lastRowHeight) throws JRException {
|
|
int nextToLastHeaderY = ((Integer)this.rowYs.get(this.rowIdx - 1)).intValue();
|
|
List lastPrintRow = getLastPrintRow();
|
|
for (int j = 0; j < this.preparedRow.size(); j++) {
|
|
JRFillCellContents contents = this.preparedRow.get(j);
|
|
int headerY = ((Integer)this.rowYs.get(this.rowIdx - contents.getVerticalSpan())).intValue();
|
|
contents.stretchTo(nextToLastHeaderY - headerY + lastRowHeight);
|
|
lastPrintRow.add(contents.fill());
|
|
contents.releaseWorkingClone();
|
|
}
|
|
}
|
|
|
|
private void refillLastRow(int xOffset, int availableHeight) throws JRException {
|
|
removeFilledRows(1);
|
|
setBackSpanHeaders();
|
|
prepareRow(xOffset, availableHeight);
|
|
fillRow();
|
|
this.rowYs.add(new Integer(((Integer)this.rowYs.get(this.rowIdx)).intValue() + this.preparedRowHeight));
|
|
this.rowIdx++;
|
|
}
|
|
|
|
private boolean prepareContinuingRowHeader(int rowGroup, int availableHeight) throws JRException {
|
|
HeaderCell cell = this.spanHeaders[rowGroup];
|
|
int vSpan = this.rowIdx + this.startRowIndex - this.spanHeadersStart[rowGroup];
|
|
if (this.spanHeadersStart[rowGroup] < this.startRowIndex)
|
|
vSpan += this.spanHeadersStart[rowGroup] - this.startRowIndex;
|
|
int headerY = ((Integer)this.rowYs.get(this.rowIdx - vSpan)).intValue();
|
|
int lastHeaderY = ((Integer)this.rowYs.get(this.rowIdx)).intValue();
|
|
int headerHeight = lastHeaderY - headerY;
|
|
int nextToLastHeaderY = ((Integer)this.rowYs.get(this.rowIdx - 1)).intValue();
|
|
int stretchHeight = nextToLastHeaderY - headerY;
|
|
JRFillCrosstabRowGroup group = JRFillCrosstab.this.rowGroups[rowGroup];
|
|
JRFillCellContents contents = cell.isTotal() ? group.getFillTotalHeader() : group.getFillHeader();
|
|
boolean stretchContents = (group.getPosition() == 4);
|
|
int contentsHeight = stretchContents ? headerHeight : contents.getHeight();
|
|
int cellAvailableStretch = availableHeight - headerY - contentsHeight;
|
|
boolean headerOverflow = (cellAvailableStretch < 0 || headerHeight < contents.getHeight());
|
|
if (!headerOverflow) {
|
|
setCountVars(this.rowIdx + this.startRowIndex - vSpan, -1);
|
|
setGroupVariables((JRFillCrosstabGroup[])JRFillCrosstab.this.rowGroups, cell.getBucketValues());
|
|
if (stretchContents)
|
|
contents = contents.getTransformedContents(contents.getWidth(), headerHeight, (byte)1, (byte)4);
|
|
contents = contents.getBoxContents(false, false, (this.rowIdx == vSpan && (!this.printColumnHeaders || JRFillCrosstab.this.headerCell == null)));
|
|
contents.getWorkingClone();
|
|
contents.evaluate((byte)3);
|
|
contents.prepare(cellAvailableStretch);
|
|
this.preparedRow.add(contents);
|
|
headerOverflow = contents.willOverflow();
|
|
if (!headerOverflow) {
|
|
contents.setX(this.rowHeadersXOffsets[rowGroup]);
|
|
contents.setY(headerY + this.yOffset);
|
|
contents.setVerticalSpan(vSpan);
|
|
int rowHeight = contents.getPrintHeight() - stretchHeight;
|
|
if (rowHeight > this.preparedRowHeight)
|
|
this.preparedRowHeight = rowHeight;
|
|
}
|
|
}
|
|
if (headerOverflow)
|
|
removeFilledRows(vSpan);
|
|
return headerOverflow;
|
|
}
|
|
|
|
protected void addPrintRow(List printRow) {
|
|
this.printRows.add(printRow);
|
|
}
|
|
|
|
protected List getLastPrintRow() {
|
|
return this.printRows.get(this.printRows.size() - 1);
|
|
}
|
|
|
|
protected List getPrintElements() {
|
|
List prints = new ArrayList();
|
|
for (Iterator it = this.printRows.iterator(); it.hasNext(); ) {
|
|
List rowPrints = it.next();
|
|
prints.addAll(rowPrints);
|
|
}
|
|
return prints;
|
|
}
|
|
|
|
protected void setGroupVariables(JRFillCrosstabGroup[] groups, BucketDefinition.Bucket[] bucketValues) {
|
|
for (int i = 0; i < groups.length; i++) {
|
|
Object value = null;
|
|
if (bucketValues[i] != null && !bucketValues[i].isTotal())
|
|
value = bucketValues[i].getValue();
|
|
groups[i].getFillVariable().setValue(value);
|
|
}
|
|
}
|
|
|
|
protected void setMeasureVariables(CrosstabCell cell) {
|
|
MeasureDefinition.MeasureValue[] values = cell.getMesureValues();
|
|
for (int i = 0; i < JRFillCrosstab.this.measures.length; i++) {
|
|
Object value = measureValue(values, i);
|
|
JRFillCrosstab.this.measures[i].getFillVariable().setValue(value);
|
|
}
|
|
MeasureDefinition.MeasureValue[][][] totals = cell.getTotals();
|
|
for (int row = 0; row <= JRFillCrosstab.this.rowGroups.length; row++) {
|
|
for (int col = 0; col <= JRFillCrosstab.this.columnGroups.length; col++) {
|
|
MeasureDefinition.MeasureValue[] vals = totals[row][col];
|
|
if (JRFillCrosstab.this.retrieveTotal[row][col])
|
|
for (int m = 0; m < JRFillCrosstab.this.measures.length; m++) {
|
|
JRFillVariable totalVar = JRFillCrosstab.this.totalVariables[row][col][m];
|
|
Object value = measureValue(vals, m);
|
|
totalVar.setValue(value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected Object measureValue(MeasureDefinition.MeasureValue[] values, int measureIdx) {
|
|
Object value;
|
|
if (JRFillCrosstab.this.measures[measureIdx].getPercentageOfType() == 1) {
|
|
if (values[measureIdx].isInitialized()) {
|
|
value = values[measureIdx].getValue();
|
|
} else {
|
|
value = JRFillCrosstab.this.measures[measureIdx].getPercentageCalculator().calculatePercentage((JRCalculable)values[measureIdx], (JRCalculable)JRFillCrosstab.this.grandTotals[measureIdx]);
|
|
}
|
|
} else {
|
|
value = values[measureIdx].getValue();
|
|
}
|
|
return value;
|
|
}
|
|
|
|
protected void resetVariables() {
|
|
int i;
|
|
for (i = 0; i < JRFillCrosstab.this.rowGroups.length; i++)
|
|
JRFillCrosstab.this.rowGroups[i].getFillVariable().setValue(null);
|
|
for (i = 0; i < JRFillCrosstab.this.columnGroups.length; i++)
|
|
JRFillCrosstab.this.columnGroups[i].getFillVariable().setValue(null);
|
|
for (i = 0; i < JRFillCrosstab.this.measures.length; i++)
|
|
JRFillCrosstab.this.measures[i].getFillVariable().setValue(null);
|
|
for (int row = 0; row <= JRFillCrosstab.this.rowGroups.length; row++) {
|
|
for (int col = 0; col <= JRFillCrosstab.this.columnGroups.length; col++) {
|
|
if (JRFillCrosstab.this.retrieveTotal[row][col])
|
|
for (int j = 0; j < JRFillCrosstab.this.measures.length; j++)
|
|
JRFillCrosstab.this.totalVariables[row][col][j].setValue(null);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public int getColumnBreakOffset() {
|
|
return this.parentCrosstab.getColumnBreakOffset();
|
|
}
|
|
|
|
public boolean isRepeatColumnHeaders() {
|
|
return this.parentCrosstab.isRepeatColumnHeaders();
|
|
}
|
|
|
|
public boolean isRepeatRowHeaders() {
|
|
return this.parentCrosstab.isRepeatRowHeaders();
|
|
}
|
|
|
|
public JRCrosstabCell[][] getCells() {
|
|
return (JRCrosstabCell[][])this.crossCells;
|
|
}
|
|
|
|
public JRCellContents getWhenNoDataCell() {
|
|
return this.whenNoDataCell;
|
|
}
|
|
|
|
public JRCrosstabParameter[] getParameters() {
|
|
return (JRCrosstabParameter[])this.parameters;
|
|
}
|
|
|
|
public JRExpression getParametersMapExpression() {
|
|
return this.parentCrosstab.getParametersMapExpression();
|
|
}
|
|
|
|
public JRElement getElementByKey(String elementKey) {
|
|
return JRBaseCrosstab.getElementByKey(this, elementKey);
|
|
}
|
|
|
|
public JRFillCloneable createClone(JRFillCloneFactory factory) {
|
|
return null;
|
|
}
|
|
|
|
public JRCellContents getHeaderCell() {
|
|
return this.headerCell;
|
|
}
|
|
|
|
public JRVariable[] getVariables() {
|
|
return (JRVariable[])this.variables;
|
|
}
|
|
|
|
public byte getRunDirection() {
|
|
return this.parentCrosstab.getRunDirection();
|
|
}
|
|
|
|
public void setRunDirection(byte direction) {}
|
|
}
|