718 lines
23 KiB
Java
718 lines
23 KiB
Java
package net.sf.jasperreports.engine.fill;
|
|
|
|
import java.awt.Color;
|
|
import java.io.Serializable;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import net.sf.jasperreports.engine.JRCommonElement;
|
|
import net.sf.jasperreports.engine.JRDefaultStyleProvider;
|
|
import net.sf.jasperreports.engine.JRElement;
|
|
import net.sf.jasperreports.engine.JRElementGroup;
|
|
import net.sf.jasperreports.engine.JRException;
|
|
import net.sf.jasperreports.engine.JRExpression;
|
|
import net.sf.jasperreports.engine.JRExpressionChunk;
|
|
import net.sf.jasperreports.engine.JRGroup;
|
|
import net.sf.jasperreports.engine.JRPrintElement;
|
|
import net.sf.jasperreports.engine.JRPropertiesHolder;
|
|
import net.sf.jasperreports.engine.JRPropertiesMap;
|
|
import net.sf.jasperreports.engine.JRPropertyExpression;
|
|
import net.sf.jasperreports.engine.JRStyle;
|
|
import net.sf.jasperreports.engine.JRStyleContainer;
|
|
import net.sf.jasperreports.engine.JRStyleSetter;
|
|
import net.sf.jasperreports.engine.JRVisitable;
|
|
import net.sf.jasperreports.engine.util.JRProperties;
|
|
import net.sf.jasperreports.engine.util.JRStyleResolver;
|
|
|
|
public abstract class JRFillElement implements JRElement, JRFillCloneable, JRStyleSetter {
|
|
protected JRElement parent = null;
|
|
|
|
protected Map templates = new HashMap();
|
|
|
|
protected JRBaseFiller filler = null;
|
|
|
|
protected JRFillExpressionEvaluator expressionEvaluator = null;
|
|
|
|
protected JRDefaultStyleProvider defaultStyleProvider;
|
|
|
|
protected JRGroup printWhenGroupChanges = null;
|
|
|
|
protected JRFillElementGroup elementGroup = null;
|
|
|
|
protected JRFillBand band = null;
|
|
|
|
private boolean isPrintWhenExpressionNull = true;
|
|
|
|
private boolean isPrintWhenTrue = true;
|
|
|
|
private boolean isToPrint = true;
|
|
|
|
private boolean isReprinted = false;
|
|
|
|
private boolean isAlreadyPrinted = false;
|
|
|
|
private Collection dependantElements = new ArrayList();
|
|
|
|
private int relativeY = 0;
|
|
|
|
private int stretchHeight = 0;
|
|
|
|
private int bandBottomY = 0;
|
|
|
|
private int x;
|
|
|
|
private int y;
|
|
|
|
private int width;
|
|
|
|
private int height;
|
|
|
|
private boolean isValueRepeating = false;
|
|
|
|
protected byte currentEvaluation;
|
|
|
|
protected Map delayedEvaluationsMap;
|
|
|
|
protected JRFillElementContainer conditionalStylesContainer;
|
|
|
|
protected JRStyle initStyle;
|
|
|
|
private boolean shrinkable;
|
|
|
|
protected JRPropertiesMap staticProperties;
|
|
|
|
protected JRPropertiesMap dynamicProperties;
|
|
|
|
protected JRPropertiesMap mergedProperties;
|
|
|
|
protected JRFillElement(JRBaseFiller filler, JRElement element, JRFillObjectFactory factory) {
|
|
factory.put(element, this);
|
|
this.parent = element;
|
|
this.filler = filler;
|
|
this.expressionEvaluator = factory.getExpressionEvaluator();
|
|
this.defaultStyleProvider = factory.getDefaultStyleProvider();
|
|
this.printWhenGroupChanges = factory.getGroup(element.getPrintWhenGroupChanges());
|
|
this.elementGroup = (JRFillElementGroup)factory.getVisitResult((JRVisitable)element.getElementGroup());
|
|
this.x = element.getX();
|
|
this.y = element.getY();
|
|
this.width = element.getWidth();
|
|
this.height = element.getHeight();
|
|
this.staticProperties = element.hasProperties() ? element.getPropertiesMap().cloneProperties() : null;
|
|
this.mergedProperties = this.staticProperties;
|
|
factory.registerDelayedStyleSetter(this, (JRStyleContainer)this.parent);
|
|
}
|
|
|
|
protected JRFillElement(JRFillElement element, JRFillCloneFactory factory) {
|
|
factory.put(element, this);
|
|
this.parent = element.parent;
|
|
this.filler = element.filler;
|
|
this.expressionEvaluator = element.expressionEvaluator;
|
|
this.defaultStyleProvider = element.defaultStyleProvider;
|
|
this.printWhenGroupChanges = element.printWhenGroupChanges;
|
|
this.elementGroup = (JRFillElementGroup)factory.getClone((JRFillElementGroup)element.getElementGroup());
|
|
this.x = element.getX();
|
|
this.y = element.getY();
|
|
this.width = element.getWidth();
|
|
this.height = element.getHeight();
|
|
this.templates = element.templates;
|
|
this.initStyle = element.initStyle;
|
|
this.shrinkable = element.shrinkable;
|
|
this.staticProperties = (element.staticProperties == null) ? null : element.staticProperties.cloneProperties();
|
|
this.mergedProperties = this.staticProperties;
|
|
}
|
|
|
|
public JRDefaultStyleProvider getDefaultStyleProvider() {
|
|
return this.defaultStyleProvider;
|
|
}
|
|
|
|
public String getKey() {
|
|
return this.parent.getKey();
|
|
}
|
|
|
|
public byte getPositionType() {
|
|
return this.parent.getPositionType();
|
|
}
|
|
|
|
public void setPositionType(byte positionType) {}
|
|
|
|
public byte getStretchType() {
|
|
return this.parent.getStretchType();
|
|
}
|
|
|
|
public void setStretchType(byte stretchType) {}
|
|
|
|
public boolean isPrintRepeatedValues() {
|
|
return this.parent.isPrintRepeatedValues();
|
|
}
|
|
|
|
public void setPrintRepeatedValues(boolean isPrintRepeatedValues) {}
|
|
|
|
public byte getMode() {
|
|
return JRStyleResolver.getMode((JRCommonElement)this, (byte)1);
|
|
}
|
|
|
|
public Byte getOwnMode() {
|
|
return this.parent.getOwnMode();
|
|
}
|
|
|
|
public void setMode(byte mode) {}
|
|
|
|
public void setMode(Byte mode) {}
|
|
|
|
public int getX() {
|
|
return this.x;
|
|
}
|
|
|
|
public void setX(int x) {
|
|
this.x = x;
|
|
}
|
|
|
|
public void setY(int y) {
|
|
this.y = y;
|
|
}
|
|
|
|
public int getY() {
|
|
return this.y;
|
|
}
|
|
|
|
public int getWidth() {
|
|
return this.width;
|
|
}
|
|
|
|
public void setWidth(int width) {
|
|
this.width = width;
|
|
}
|
|
|
|
public void setHeight(int height) {
|
|
this.height = height;
|
|
}
|
|
|
|
public int getHeight() {
|
|
return this.height;
|
|
}
|
|
|
|
public boolean isRemoveLineWhenBlank() {
|
|
return this.parent.isRemoveLineWhenBlank();
|
|
}
|
|
|
|
public void setRemoveLineWhenBlank(boolean isRemoveLine) {}
|
|
|
|
public boolean isPrintInFirstWholeBand() {
|
|
return this.parent.isPrintInFirstWholeBand();
|
|
}
|
|
|
|
public void setPrintInFirstWholeBand(boolean isPrint) {}
|
|
|
|
public boolean isPrintWhenDetailOverflows() {
|
|
return this.parent.isPrintWhenDetailOverflows();
|
|
}
|
|
|
|
public void setPrintWhenDetailOverflows(boolean isPrint) {}
|
|
|
|
public Color getForecolor() {
|
|
return JRStyleResolver.getForecolor((JRCommonElement)this);
|
|
}
|
|
|
|
public Color getOwnForecolor() {
|
|
return this.parent.getOwnForecolor();
|
|
}
|
|
|
|
public void setForecolor(Color forecolor) {}
|
|
|
|
public Color getBackcolor() {
|
|
return JRStyleResolver.getBackcolor((JRCommonElement)this);
|
|
}
|
|
|
|
public Color getOwnBackcolor() {
|
|
return this.parent.getOwnBackcolor();
|
|
}
|
|
|
|
public void setBackcolor(Color backcolor) {}
|
|
|
|
public JRExpression getPrintWhenExpression() {
|
|
return this.parent.getPrintWhenExpression();
|
|
}
|
|
|
|
public JRGroup getPrintWhenGroupChanges() {
|
|
return this.printWhenGroupChanges;
|
|
}
|
|
|
|
public JRElementGroup getElementGroup() {
|
|
return this.elementGroup;
|
|
}
|
|
|
|
protected boolean isPrintWhenExpressionNull() {
|
|
return this.isPrintWhenExpressionNull;
|
|
}
|
|
|
|
protected void setPrintWhenExpressionNull(boolean isPrintWhenExpressionNull) {
|
|
this.isPrintWhenExpressionNull = isPrintWhenExpressionNull;
|
|
}
|
|
|
|
protected boolean isPrintWhenTrue() {
|
|
return this.isPrintWhenTrue;
|
|
}
|
|
|
|
protected void setPrintWhenTrue(boolean isPrintWhenTrue) {
|
|
this.isPrintWhenTrue = isPrintWhenTrue;
|
|
}
|
|
|
|
protected boolean isToPrint() {
|
|
return this.isToPrint;
|
|
}
|
|
|
|
protected void setToPrint(boolean isToPrint) {
|
|
this.isToPrint = isToPrint;
|
|
}
|
|
|
|
protected boolean isReprinted() {
|
|
return this.isReprinted;
|
|
}
|
|
|
|
protected void setReprinted(boolean isReprinted) {
|
|
this.isReprinted = isReprinted;
|
|
}
|
|
|
|
protected boolean isAlreadyPrinted() {
|
|
return this.isAlreadyPrinted;
|
|
}
|
|
|
|
protected void setAlreadyPrinted(boolean isAlreadyPrinted) {
|
|
this.isAlreadyPrinted = isAlreadyPrinted;
|
|
}
|
|
|
|
protected JRElement[] getGroupElements() {
|
|
JRElement[] groupElements = null;
|
|
if (this.elementGroup != null)
|
|
groupElements = this.elementGroup.getElements();
|
|
return groupElements;
|
|
}
|
|
|
|
protected Collection getDependantElements() {
|
|
return this.dependantElements;
|
|
}
|
|
|
|
protected void addDependantElement(JRElement element) {
|
|
this.dependantElements.add(element);
|
|
}
|
|
|
|
protected int getRelativeY() {
|
|
return this.relativeY;
|
|
}
|
|
|
|
protected void setRelativeY(int relativeY) {
|
|
this.relativeY = relativeY;
|
|
}
|
|
|
|
protected int getStretchHeight() {
|
|
return this.stretchHeight;
|
|
}
|
|
|
|
protected void setStretchHeight(int stretchHeight) {
|
|
if (stretchHeight > getHeight() || (this.shrinkable && isRemoveLineWhenBlank())) {
|
|
this.stretchHeight = stretchHeight;
|
|
} else {
|
|
this.stretchHeight = getHeight();
|
|
}
|
|
}
|
|
|
|
protected int getBandBottomY() {
|
|
return this.bandBottomY;
|
|
}
|
|
|
|
protected void setBandBottomY(int bandBottomY) {
|
|
this.bandBottomY = bandBottomY;
|
|
}
|
|
|
|
protected JRFillBand getBand() {
|
|
return this.band;
|
|
}
|
|
|
|
protected void setBand(JRFillBand band) {
|
|
this.band = band;
|
|
}
|
|
|
|
protected void reset() {
|
|
this.relativeY = this.y;
|
|
this.stretchHeight = this.height;
|
|
if (this.elementGroup != null)
|
|
this.elementGroup.reset();
|
|
}
|
|
|
|
protected void setCurrentEvaluation(byte evaluation) {
|
|
this.currentEvaluation = evaluation;
|
|
}
|
|
|
|
protected abstract void evaluate(byte paramByte) throws JRException;
|
|
|
|
protected void evaluatePrintWhenExpression(byte evaluation) throws JRException {
|
|
boolean isExprNull = true;
|
|
boolean isExprTrue = false;
|
|
JRExpression expression = getPrintWhenExpression();
|
|
if (expression != null) {
|
|
isExprNull = false;
|
|
Boolean printWhenExpressionValue = (Boolean)evaluateExpression(expression, evaluation);
|
|
if (printWhenExpressionValue == null) {
|
|
isExprTrue = false;
|
|
} else {
|
|
isExprTrue = printWhenExpressionValue.booleanValue();
|
|
}
|
|
}
|
|
setPrintWhenExpressionNull(isExprNull);
|
|
setPrintWhenTrue(isExprTrue);
|
|
}
|
|
|
|
protected abstract void rewind() throws JRException;
|
|
|
|
protected abstract JRPrintElement fill() throws JRException;
|
|
|
|
protected boolean prepare(int availableStretchHeight, boolean isOverflow) throws JRException {
|
|
if (isPrintWhenExpressionNull() || (!isPrintWhenExpressionNull() && isPrintWhenTrue())) {
|
|
setToPrint(true);
|
|
} else {
|
|
setToPrint(false);
|
|
}
|
|
setReprinted(false);
|
|
return false;
|
|
}
|
|
|
|
protected void stretchElement(int bandStretch) {
|
|
switch (getStretchType()) {
|
|
case 2:
|
|
setStretchHeight(getHeight() + bandStretch);
|
|
break;
|
|
case 1:
|
|
if (this.elementGroup != null)
|
|
setStretchHeight(getHeight() + this.elementGroup.getStretchHeightDiff());
|
|
break;
|
|
}
|
|
}
|
|
|
|
protected void moveDependantElements() {
|
|
Collection elements = getDependantElements();
|
|
if (elements != null && elements.size() > 0) {
|
|
JRFillElement element = null;
|
|
int diffY = 0;
|
|
for (Iterator it = elements.iterator(); it.hasNext(); ) {
|
|
element = it.next();
|
|
diffY = element.getY() - getY() - getHeight() - element.getRelativeY() - getRelativeY() - getStretchHeight();
|
|
if (diffY < 0)
|
|
diffY = 0;
|
|
element.setRelativeY(element.getRelativeY() + diffY);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected abstract void resolveElement(JRPrintElement paramJRPrintElement, byte paramByte) throws JRException;
|
|
|
|
protected final Object evaluateExpression(JRExpression expression, byte evaluation) throws JRException {
|
|
return this.expressionEvaluator.evaluate(expression, evaluation);
|
|
}
|
|
|
|
protected boolean isValueRepeating() {
|
|
return this.isValueRepeating;
|
|
}
|
|
|
|
protected void setValueRepeating(boolean isValueRepeating) {
|
|
this.isValueRepeating = isValueRepeating;
|
|
}
|
|
|
|
protected JRFillVariable getVariable(String variableName) {
|
|
return this.filler.getVariable(variableName);
|
|
}
|
|
|
|
protected JRFillField getField(String fieldName) {
|
|
return this.filler.getField(fieldName);
|
|
}
|
|
|
|
protected byte getEvaluationTime() {
|
|
return 1;
|
|
}
|
|
|
|
protected void resolveElement(JRPrintElement element, byte evaluation, JREvaluationTime evaluationTime) throws JRException {
|
|
byte evaluationTimeType = getEvaluationTime();
|
|
switch (evaluationTimeType) {
|
|
case 1:
|
|
return;
|
|
case 7:
|
|
delayedEvaluate((JRRecordedValuesPrintElement)element, evaluationTime, evaluation);
|
|
}
|
|
resolveElement(element, evaluation);
|
|
}
|
|
|
|
private static class DelayedEvaluations implements Serializable {
|
|
private static final long serialVersionUID = 10200L;
|
|
|
|
final Set fields = new HashSet();
|
|
|
|
final Set variables = new HashSet();
|
|
}
|
|
|
|
protected void initDelayedEvaluations() {
|
|
if (getEvaluationTime() == 7 && this.delayedEvaluationsMap == null) {
|
|
this.delayedEvaluationsMap = new HashMap();
|
|
collectDelayedEvaluations();
|
|
}
|
|
}
|
|
|
|
protected void collectDelayedEvaluations() {}
|
|
|
|
protected void collectDelayedEvaluations(JRExpression expression) {
|
|
if (expression != null) {
|
|
JRExpressionChunk[] chunks = expression.getChunks();
|
|
if (chunks != null)
|
|
for (int i = 0; i < chunks.length; i++) {
|
|
DelayedEvaluations delayedEvaluations;
|
|
JREvaluationTime time;
|
|
DelayedEvaluations delayedEvaluations1;
|
|
JRExpressionChunk chunk = chunks[i];
|
|
switch (chunk.getType()) {
|
|
case 3:
|
|
delayedEvaluations = getDelayedEvaluations(JREvaluationTime.EVALUATION_TIME_NOW);
|
|
delayedEvaluations.fields.add(chunk.getText());
|
|
break;
|
|
case 4:
|
|
time = autogetVariableEvaluationTime(chunk.getText());
|
|
delayedEvaluations1 = getDelayedEvaluations(time);
|
|
delayedEvaluations1.variables.add(chunk.getText());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private DelayedEvaluations getDelayedEvaluations(JREvaluationTime time) {
|
|
DelayedEvaluations delayedEvaluations = (DelayedEvaluations)this.delayedEvaluationsMap.get(time);
|
|
if (delayedEvaluations == null) {
|
|
delayedEvaluations = new DelayedEvaluations();
|
|
this.delayedEvaluationsMap.put(time, delayedEvaluations);
|
|
}
|
|
return delayedEvaluations;
|
|
}
|
|
|
|
private JREvaluationTime autogetVariableEvaluationTime(String variableName) {
|
|
JREvaluationTime evaluationTime;
|
|
JRFillVariable variable = getVariable(variableName);
|
|
switch (variable.getResetType()) {
|
|
case 1:
|
|
evaluationTime = JREvaluationTime.EVALUATION_TIME_REPORT;
|
|
break;
|
|
case 2:
|
|
evaluationTime = JREvaluationTime.EVALUATION_TIME_PAGE;
|
|
break;
|
|
case 3:
|
|
evaluationTime = JREvaluationTime.EVALUATION_TIME_COLUMN;
|
|
break;
|
|
case 4:
|
|
evaluationTime = JREvaluationTime.getGroupEvaluationTime(variable.getResetGroup().getName());
|
|
break;
|
|
default:
|
|
evaluationTime = JREvaluationTime.EVALUATION_TIME_NOW;
|
|
break;
|
|
}
|
|
if (!evaluationTime.equals(JREvaluationTime.EVALUATION_TIME_NOW) && this.band.isNowEvaluationTime(evaluationTime))
|
|
evaluationTime = JREvaluationTime.EVALUATION_TIME_NOW;
|
|
if (variable.getCalculation() == 8 && evaluationTime.equals(JREvaluationTime.EVALUATION_TIME_NOW) && this.band.isVariableUsedInSubreportReturns(variableName))
|
|
evaluationTime = JREvaluationTime.getBandEvaluationTime(this.band);
|
|
return evaluationTime;
|
|
}
|
|
|
|
protected void initDelayedEvaluationPrint(JRRecordedValuesPrintElement printElement) throws JRException {
|
|
for (Iterator it = this.delayedEvaluationsMap.keySet().iterator(); it.hasNext(); ) {
|
|
JREvaluationTime evaluationTime = it.next();
|
|
if (!evaluationTime.equals(JREvaluationTime.EVALUATION_TIME_NOW))
|
|
this.filler.addBoundElement(this, printElement, evaluationTime);
|
|
}
|
|
printElement.initRecordedValues(this.delayedEvaluationsMap.keySet());
|
|
if (this.delayedEvaluationsMap.containsKey(JREvaluationTime.EVALUATION_TIME_NOW))
|
|
delayedEvaluate(printElement, JREvaluationTime.EVALUATION_TIME_NOW, this.currentEvaluation);
|
|
}
|
|
|
|
protected void delayedEvaluate(JRRecordedValuesPrintElement printElement, JREvaluationTime evaluationTime, byte evaluation) throws JRException {
|
|
JRRecordedValues recordedValues = printElement.getRecordedValues();
|
|
if (!recordedValues.lastEvaluationTime()) {
|
|
DelayedEvaluations delayedEvaluations = (DelayedEvaluations)this.delayedEvaluationsMap.get(evaluationTime);
|
|
for (Iterator iterator1 = delayedEvaluations.fields.iterator(); iterator1.hasNext(); ) {
|
|
String fieldName = iterator1.next();
|
|
JRFillField field = getField(fieldName);
|
|
recordedValues.recordFieldValue(fieldName, field.getValue(evaluation));
|
|
}
|
|
for (Iterator it = delayedEvaluations.variables.iterator(); it.hasNext(); ) {
|
|
String variableName = it.next();
|
|
JRFillVariable variable = getVariable(variableName);
|
|
recordedValues.recordVariableValue(variableName, variable.getValue(evaluation));
|
|
}
|
|
}
|
|
recordedValues.doneEvaluation(evaluationTime);
|
|
if (recordedValues.finishedEvaluations()) {
|
|
overwriteWithRecordedValues(recordedValues, evaluation);
|
|
resolveElement(printElement, evaluation);
|
|
restoreValues(recordedValues, evaluation);
|
|
printElement.deleteRecordedValues();
|
|
}
|
|
}
|
|
|
|
private void overwriteWithRecordedValues(JRRecordedValues recordedValues, byte evaluation) {
|
|
Map fieldValues = recordedValues.getRecordedFieldValues();
|
|
if (fieldValues != null)
|
|
for (Iterator it = fieldValues.entrySet().iterator(); it.hasNext(); ) {
|
|
Map.Entry entry = it.next();
|
|
String fieldName = (String)entry.getKey();
|
|
Object fieldValue = entry.getValue();
|
|
JRFillField field = getField(fieldName);
|
|
field.overwriteValue(fieldValue, evaluation);
|
|
}
|
|
Map variableValues = recordedValues.getRecordedVariableValues();
|
|
if (variableValues != null)
|
|
for (Iterator it = variableValues.entrySet().iterator(); it.hasNext(); ) {
|
|
Map.Entry entry = it.next();
|
|
String variableName = (String)entry.getKey();
|
|
Object variableValue = entry.getValue();
|
|
JRFillVariable variable = getVariable(variableName);
|
|
variable.overwriteValue(variableValue, evaluation);
|
|
}
|
|
}
|
|
|
|
private void restoreValues(JRRecordedValues recordedValues, byte evaluation) {
|
|
Map fieldValues = recordedValues.getRecordedFieldValues();
|
|
if (fieldValues != null)
|
|
for (Iterator it = fieldValues.keySet().iterator(); it.hasNext(); ) {
|
|
String fieldName = it.next();
|
|
JRFillField field = getField(fieldName);
|
|
field.restoreValue(evaluation);
|
|
}
|
|
Map variableValues = recordedValues.getRecordedVariableValues();
|
|
if (variableValues != null)
|
|
for (Iterator it = variableValues.keySet().iterator(); it.hasNext(); ) {
|
|
String variableName = it.next();
|
|
JRFillVariable variable = getVariable(variableName);
|
|
variable.restoreValue(evaluation);
|
|
}
|
|
}
|
|
|
|
protected void setConditionalStylesContainer(JRFillElementContainer conditionalStylesContainer) {
|
|
this.conditionalStylesContainer = conditionalStylesContainer;
|
|
}
|
|
|
|
public JRStyle getStyle() {
|
|
JRStyle crtStyle = this.initStyle;
|
|
boolean isUsingDefaultStyle = false;
|
|
if (crtStyle == null) {
|
|
crtStyle = this.filler.getDefaultStyle();
|
|
isUsingDefaultStyle = true;
|
|
}
|
|
JRStyle evalStyle = crtStyle;
|
|
if (this.conditionalStylesContainer != null)
|
|
evalStyle = this.conditionalStylesContainer.getEvaluatedConditionalStyle(crtStyle);
|
|
if (isUsingDefaultStyle && evalStyle == crtStyle)
|
|
evalStyle = null;
|
|
return evalStyle;
|
|
}
|
|
|
|
protected JRTemplateElement getTemplate(JRStyle style) {
|
|
return (JRTemplateElement)this.templates.get(style);
|
|
}
|
|
|
|
protected void registerTemplate(JRStyle style, JRTemplateElement template) {
|
|
this.templates.put(style, template);
|
|
}
|
|
|
|
protected final void setShrinkable(boolean shrinkable) {
|
|
this.shrinkable = shrinkable;
|
|
}
|
|
|
|
protected void stretchHeightFinal() {}
|
|
|
|
protected boolean isEvaluateNow() {
|
|
switch (getEvaluationTime()) {
|
|
case 1:
|
|
evaluateNow = true;
|
|
return evaluateNow;
|
|
case 7:
|
|
evaluateNow = isAutoEvaluateNow();
|
|
return evaluateNow;
|
|
}
|
|
boolean evaluateNow = false;
|
|
return evaluateNow;
|
|
}
|
|
|
|
protected boolean isAutoEvaluateNow() {
|
|
return (this.delayedEvaluationsMap == null || this.delayedEvaluationsMap.isEmpty() || (this.delayedEvaluationsMap.size() == 1 && this.delayedEvaluationsMap.containsKey(JREvaluationTime.EVALUATION_TIME_NOW)));
|
|
}
|
|
|
|
protected boolean isEvaluateAuto() {
|
|
return (getEvaluationTime() == 7 && !isAutoEvaluateNow());
|
|
}
|
|
|
|
public String getStyleNameReference() {
|
|
return null;
|
|
}
|
|
|
|
public void setStyle(JRStyle style) {
|
|
this.initStyle = style;
|
|
this.conditionalStylesContainer.collectConditionalStyle(style);
|
|
}
|
|
|
|
public void setStyleNameReference(String name) {
|
|
throw new UnsupportedOperationException("Style name references not allowed at fill time");
|
|
}
|
|
|
|
public Object clone() {
|
|
return null;
|
|
}
|
|
|
|
public Object clone(JRElementGroup parentGroup) {
|
|
return null;
|
|
}
|
|
|
|
public boolean hasProperties() {
|
|
return (this.mergedProperties != null && this.mergedProperties.hasProperties());
|
|
}
|
|
|
|
public JRPropertiesMap getPropertiesMap() {
|
|
return this.mergedProperties;
|
|
}
|
|
|
|
public JRPropertiesHolder getParentProperties() {
|
|
return (JRPropertiesHolder)this.filler.getJasperReport();
|
|
}
|
|
|
|
public JRPropertyExpression[] getPropertyExpressions() {
|
|
return this.parent.getPropertyExpressions();
|
|
}
|
|
|
|
protected void transferProperties(JRTemplateElement template) {
|
|
JRProperties.transferProperties((JRPropertiesHolder)this.parent, template, "net.sf.jasperreports.print.transfer.");
|
|
}
|
|
|
|
protected void transferProperties(JRPrintElement element) {
|
|
JRProperties.transferProperties(this.dynamicProperties, (JRPropertiesHolder)element, "net.sf.jasperreports.print.transfer.");
|
|
}
|
|
|
|
protected JRPropertiesMap getEvaluatedProperties() {
|
|
return this.mergedProperties;
|
|
}
|
|
|
|
protected void evaluateProperties(byte evaluation) throws JRException {
|
|
JRPropertyExpression[] propExprs = getPropertyExpressions();
|
|
if (propExprs == null || propExprs.length == 0) {
|
|
this.dynamicProperties = null;
|
|
this.mergedProperties = this.staticProperties;
|
|
} else {
|
|
this.dynamicProperties = new JRPropertiesMap();
|
|
for (int i = 0; i < propExprs.length; i++) {
|
|
JRPropertyExpression prop = propExprs[i];
|
|
String value = (String)evaluateExpression(prop.getValueExpression(), evaluation);
|
|
if (value != null)
|
|
this.dynamicProperties.setProperty(prop.getName(), value);
|
|
}
|
|
this.mergedProperties = this.dynamicProperties.cloneProperties();
|
|
this.mergedProperties.setBaseProperties(this.staticProperties);
|
|
}
|
|
}
|
|
}
|