/*!
* This program is free software; you can redistribute it and/or modify it under the
* terms of the GNU Lesser General Public License, version 2.1 as published by the Free Software
* Foundation.
*
* You should have received a copy of the GNU Lesser General Public License along with this
* program; if not, you can obtain a copy at http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html
* or from the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* Copyright (c) 2002-2017 Pentaho Corporation.. All rights reserved.
*/
package org.pentaho.plugin.jfreereport.reportcharts;
import org.apache.bsf.BSFException;
import org.apache.bsf.BSFManager;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.NumberAxis;
import org.jfree.chart.axis.NumberTickUnit;
import org.jfree.chart.axis.TickUnits;
import org.jfree.chart.block.BlockBorder;
import org.jfree.chart.plot.Plot;
import org.jfree.chart.title.LegendTitle;
import org.jfree.chart.title.TextTitle;
import org.jfree.data.general.Dataset;
import org.jfree.ui.RectangleEdge;
import org.pentaho.reporting.engine.classic.core.DataRow;
import org.pentaho.reporting.engine.classic.core.DynamicExpression;
import org.pentaho.reporting.engine.classic.core.function.AbstractExpression;
import org.pentaho.reporting.engine.classic.core.function.Expression;
import org.pentaho.reporting.engine.classic.core.function.ExpressionRuntime;
import org.pentaho.reporting.engine.classic.core.function.FormulaExpression;
import org.pentaho.reporting.engine.classic.core.function.ProcessingContext;
import org.pentaho.reporting.engine.classic.core.function.WrapperExpressionRuntime;
import org.pentaho.reporting.engine.classic.core.states.LayoutProcess;
import org.pentaho.reporting.engine.classic.core.states.LegacyDataRowWrapper;
import org.pentaho.reporting.engine.classic.core.util.StrokeUtility;
import org.pentaho.reporting.engine.classic.core.util.beans.BeanUtility;
import org.pentaho.reporting.libraries.base.util.StringUtils;
import org.pentaho.reporting.libraries.resourceloader.Resource;
import org.pentaho.reporting.libraries.resourceloader.ResourceException;
import org.pentaho.reporting.libraries.resourceloader.ResourceKey;
import org.pentaho.reporting.libraries.resourceloader.ResourceManager;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.Image;
import java.awt.Stroke;
import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* @noinspection UnusedDeclaration, JavaDoc
*/
public abstract class AbstractChartExpression extends AbstractExpression implements ChartExpression, DynamicExpression {
public static final String LINE_STYLE_SOLID_STR = "solid"; //$NON-NLS-1$
public static final String LINE_STYLE_DASH_STR = "dash"; //$NON-NLS-1$
public static final String LINE_STYLE_DOT_STR = "dot"; //$NON-NLS-1$
public static final String LINE_STYLE_DASHDOT_STR = "dashdot"; //$NON-NLS-1$
public static final String LINE_STYLE_DASHDOTDOT_STR = "dashdotdot"; //$NON-NLS-1$
protected static final Stroke EMPTY_STROKE = new BasicStroke( 0.0f );
private static final Log logger = LogFactory.getLog( AbstractChartExpression.class );
private static final Map<String, RectangleEdge> LEGEND_LOCATIONS;
static {
final Map<String, RectangleEdge> locations = new HashMap<String, RectangleEdge>();
locations.put( "left", RectangleEdge.LEFT ); //$NON-NLS-1$
locations.put( "west", RectangleEdge.LEFT ); //$NON-NLS-1$
locations.put( "right", RectangleEdge.RIGHT ); //$NON-NLS-1$
locations.put( "east", RectangleEdge.RIGHT ); //$NON-NLS-1$
locations.put( "top", RectangleEdge.TOP ); //$NON-NLS-1$
locations.put( "north", RectangleEdge.TOP ); //$NON-NLS-1$
locations.put( "bottom", RectangleEdge.BOTTOM ); //$NON-NLS-1$
locations.put( "south", RectangleEdge.BOTTOM ); //$NON-NLS-1$
LEGEND_LOCATIONS = Collections.unmodifiableMap( locations );
}
private String dataSource;
private String titleText;
private String titleField;
private String noDataMessage;
private boolean antiAlias;
private String legendLocation;
private String titleFont;
private String labelFont;
private String legendFont;
private Font itemLabelFont;
private boolean showBorder;
private String borderColor;
private String backgroundColor;
private Color plotBackgroundColor;
private Color legendBackgroundColor;
private float plotForegroundAlpha;
private float plotBackgroundAlpha;
private boolean drawLegendBorder;
private Boolean itemsLabelVisible;
private boolean showLegend;
private boolean threeD;
private boolean chartSectionOutline;
private String backgroundImage;
private HashMap<Object, JFreeChart> chartCache;
private ArrayList<String> seriesColors;
// cache the images, since we roll through here multiple times...
private transient Image plotImageCache;
private Color legendTextColor;
private String postProcessingLanguage;
private String postProcessingScript;
private String tooltipFormula;
private String urlFormula;
private LinkedHashMap<String, Expression> expressionMap;
protected AbstractChartExpression() {
seriesColors = new ArrayList<String>();
seriesColors.add( "#ff6600" );
seriesColors.add( "#fcd202" );
seriesColors.add( "#b0de09" );
seriesColors.add( "#0d8ecf" );
seriesColors.add( "#2a0cd0" );
seriesColors.add( "#cd0d74" );
seriesColors.add( "#cc0000" );
seriesColors.add( "#00cc00" );
seriesColors.add( "#0000cc" );
seriesColors.add( "#3a3a3a" );
seriesColors.add( "#ffaa72" );
seriesColors.add( "#fde673" );
seriesColors.add( "#d3ed77" );
seriesColors.add( "#79c1e4" );
seriesColors.add( "#8979e5" );
seriesColors.add( "#e379b2" );
seriesColors.add( "#e37272" );
seriesColors.add( "#72e372" );
seriesColors.add( "#7272e3" );
seriesColors.add( "#929292" );
seriesColors.add( "#a64100" );
seriesColors.add( "#a48901" );
seriesColors.add( "#739106" );
seriesColors.add( "#085c87" );
seriesColors.add( "#1b0887" );
seriesColors.add( "#85084c" );
seriesColors.add( "#850000" );
seriesColors.add( "#008500" );
seriesColors.add( "#000085" );
seriesColors.add( "#000000" );
backgroundColor = "#ffffff";
drawLegendBorder = true;
legendFont = "SansSerif--8";
labelFont = "SansSerif--8";
titleFont = "SansSerif-BOLD-14";
legendLocation = "bottom";
antiAlias = true;
noDataMessage = "CHART.USER_NO_DATA_AVAILABLE";
showLegend = true;
chartCache = new HashMap<Object, JFreeChart>();
plotBackgroundAlpha = 1;
plotForegroundAlpha = 1;
expressionMap = new LinkedHashMap<>();
}
public Font getItemLabelFont() {
return itemLabelFont;
}
public void setItemLabelFont( final Font itemLabelFont ) {
this.itemLabelFont = itemLabelFont;
}
public String getTooltipFormula() {
return tooltipFormula;
}
public void setTooltipFormula( final String tooltipFormula ) {
this.tooltipFormula = tooltipFormula;
}
public String getUrlFormula() {
return urlFormula;
}
public void setUrlFormula( final String urlFormula ) {
this.urlFormula = urlFormula;
}
public String getPostProcessingLanguage() {
return postProcessingLanguage;
}
public void setPostProcessingLanguage( final String postProcessingLanguage ) {
this.postProcessingLanguage = postProcessingLanguage;
}
public String getPostProcessingScript() {
return postProcessingScript;
}
public void setPostProcessingScript( final String postProcessingScript ) {
this.postProcessingScript = postProcessingScript;
}
public Color getLegendBackgroundColor() {
return legendBackgroundColor;
}
public void setLegendBackgroundColor( final Color legendBackgroundColor ) {
this.legendBackgroundColor = legendBackgroundColor;
}
public Color getLegendTextColor() {
return legendTextColor;
}
public void setLegendTextColor( final Color legendTextColor ) {
this.legendTextColor = legendTextColor;
}
public float getPlotForegroundAlpha() {
return plotForegroundAlpha;
}
public void setPlotForegroundAlpha( final float plotForegroundAlpha ) {
this.plotForegroundAlpha = plotForegroundAlpha;
}
public float getPlotBackgroundAlpha() {
return plotBackgroundAlpha;
}
public void setPlotBackgroundAlpha( final float plotBackgroundAlpha ) {
this.plotBackgroundAlpha = plotBackgroundAlpha;
}
public Color getPlotBackgroundColor() {
return plotBackgroundColor;
}
public void setPlotBackgroundColor( final Color plotBackgroundColor ) {
this.plotBackgroundColor = plotBackgroundColor;
}
public String getTitleFont() {
return titleFont;
}
public void setTitleFont( final String value ) {
this.titleFont = value;
}
public String getLegendFont() {
return legendFont;
}
public void setLegendFont( final String value ) {
legendFont = value;
}
public String getLabelFont() {
return labelFont;
}
public void setLabelFont( final String value ) {
this.labelFont = value;
}
public String getDataSource() {
return dataSource;
}
public void setDataSource( final String dataSource ) {
this.dataSource = dataSource;
}
@Override
public String[] getHyperlinkFormulas() {
if ( !StringUtils.isEmpty( this.urlFormula ) ) {
return new String[]{this.urlFormula};
}
return new String[]{};
}
public String getTitleField() {
return titleField;
}
public void setTitleField( final String titleField ) {
this.titleField = titleField;
}
public String getTitleText() {
return titleText;
}
public void setTitleText( final String titleText ) {
this.titleText = titleText;
}
public boolean isAntiAlias() {
return antiAlias;
}
public void setAntiAlias( final boolean value ) {
antiAlias = value;
}
public String getBorderColor() {
return borderColor;
}
public void setBorderColor( final String value ) {
borderColor = value;
}
public String getBackgroundColor() {
return backgroundColor;
}
public void setBackgroundColor( final String value ) {
backgroundColor = value;
}
public boolean isShowBorder() {
return showBorder;
}
public void setShowBorder( final boolean value ) {
showBorder = value;
}
public String getLegendLocation() {
return legendLocation;
}
public void setLegendLocation( final String value ) {
legendLocation = value;
}
public boolean isDrawLegendBorder() {
return drawLegendBorder;
}
public void setDrawLegendBorder( final boolean value ) {
drawLegendBorder = value;
}
public boolean isShowLegend() {
return showLegend;
}
public void setShowLegend( final boolean value ) {
showLegend = value;
}
public boolean isThreeD() {
return threeD;
}
public void setThreeD( final boolean value ) {
threeD = value;
}
public boolean isChartSectionOutline() {
return chartSectionOutline;
}
public void setChartSectionOutline( final boolean value ) {
chartSectionOutline = value;
}
public String getNoDataMessage() {
return noDataMessage;
}
public void setNoDataMessage( final String noDataMessage ) {
this.noDataMessage = noDataMessage;
}
public void setBackgroundImage( final String value ) {
this.backgroundImage = value;
this.plotImageCache = null;
}
public String getBackgroundImage() {
return this.backgroundImage;
}
public Boolean getItemsLabelVisible() {
return itemsLabelVisible;
}
public void setItemsLabelVisible( final Boolean itemsLabelVisible ) {
this.itemsLabelVisible = itemsLabelVisible;
}
public void setSeriesColor( final int index, final String field ) {
if ( seriesColors.size() == index ) {
seriesColors.add( field );
} else {
seriesColors.set( index, field );
}
}
public String getSeriesColor( final int index ) {
return seriesColors.get( index );
}
public int getSeriesColorCount() {
return seriesColors.size();
}
public String[] getSeriesColor() {
return seriesColors.toArray( new String[seriesColors.size()] );
}
public void setSeriesColor( final String[] fields ) {
this.seriesColors.clear();
this.seriesColors.addAll( Arrays.asList( fields ) );
}
@Override
public Map<String, Expression> getExpressionMap() {
return new LinkedHashMap<>( expressionMap );
}
@Override
public void setExpressionMap( Map<String, Expression> values ) {
expressionMap.clear();
expressionMap.putAll( values );
}
public void addExpression( String property, Expression e ) {
expressionMap.put( property, e );
}
public void removeExpression( String property ) {
expressionMap.remove( property );
}
protected void storeChartInCache( final Object key, final JFreeChart chart ) {
if ( key == null ) {
return;
}
if ( chart == null ) {
throw new NullPointerException();
}
chartCache.put( key, chart );
}
protected JFreeChart loadChartFromCache( final Object key ) {
if ( key == null ) {
return null;
}
final JFreeChart o = chartCache.get( key );
if ( o != null ) {
return o;
}
return null;
}
/**
* Return a completly separated copy of this function. The copy does no longer share any changeable objects with the
* original function.
*
* @return a copy of this function.
*/
public Expression getInstance() {
final AbstractChartExpression instance = (AbstractChartExpression) super.getInstance();
instance.chartCache = (HashMap<Object, JFreeChart>) instance.chartCache.clone();
instance.chartCache.clear();
instance.seriesColors = (ArrayList<String>) seriesColors.clone();
instance.plotImageCache = null;
instance.expressionMap = (LinkedHashMap<String, Expression>) expressionMap.clone();
for ( Map.Entry<String, Expression> entry : expressionMap.entrySet() ) {
entry.setValue( entry.getValue().getInstance() );
}
return instance;
}
public Object getValue() {
try {
Iterator it = expressionMap.entrySet().iterator();
while ( it.hasNext() ) {
Map.Entry pair = (Map.Entry) it.next();
FormulaExpression formulaExpression = (FormulaExpression) pair.getValue();
formulaExpression.setRuntime( getRuntime() );
final Object o = formulaExpression.getValue();
BeanUtility beanUtility = new BeanUtility( this );
Class propertyType = beanUtility.getPropertyType( (String) pair.getKey() );
beanUtility.setPropertyAsString( (String) pair.getKey(), propertyType, String.valueOf( o ) );
}
final Object maybeCollector = getDataRow().get( getDataSource() );
final Dataset dataset;
final Object cacheKey;
if ( maybeCollector instanceof ICollectorFunction ) {
final ICollectorFunction collector = (ICollectorFunction) maybeCollector;
dataset = (Dataset) collector.getDatasourceValue();
cacheKey = collector.getCacheKey();
} else if ( maybeCollector instanceof CollectorFunctionResult ) {
final CollectorFunctionResult collector = (CollectorFunctionResult) maybeCollector;
dataset = collector.getDataSet();
cacheKey = collector.getCacheKey();
} else {
logger.debug( "CATEGORICALCHARTEXPRESSION.USER_NOT_A_DATASET" ); //$NON-NLS-1$
return null;
}
if ( dataset == null ) {
return null;
}
final Object key;
if ( cacheKey != null ) {
key = cacheKey;
} else {
key = getName();
}
final JFreeChart chartFromCache = loadChartFromCache( key );
final JFreeChart chart;
if ( chartFromCache != null ) {
chart = chartFromCache;
} else {
chart = computeChart( dataset );
if ( chart == null ) {
return null;
}
storeChartInCache( key, chart );
}
// we have to call the deprecated method to let that method call the real method to catch all
// subclasses that exist out there.
configureChart( chart );
postProcessChart( chart );
return new JFreeChartReportDrawable( chart,
StringUtils.isEmpty( getUrlFormula() ) == false || StringUtils.isEmpty( getTooltipFormula() ) == false );
} catch ( Exception e ) {
logger.error( "Failed to configure chart", e );
return null;
}
}
protected JFreeChart postProcessChart( final JFreeChart originalChart ) {
if ( postProcessingLanguage == null || postProcessingScript == null ) {
return originalChart;
}
final LegacyDataRowWrapper legacyDataRowWrapper = new LegacyDataRowWrapper();
final WrapperExpressionRuntime runtimeWrapper = new WrapperExpressionRuntime();
runtimeWrapper.update( null, getRuntime() );
legacyDataRowWrapper.setParent( getDataRow() );
try {
final BSFManager interpreter = new BSFManager();
interpreter.declareBean( "chartExpression", this, getClass() ); //$NON-NLS-1$
interpreter.declareBean( "chart", originalChart, JFreeChart.class ); //$NON-NLS-1$
interpreter.declareBean( "runtime", runtimeWrapper, ExpressionRuntime.class ); //$NON-NLS-1$
interpreter.declareBean( "dataRow", legacyDataRowWrapper, DataRow.class ); //$NON-NLS-1$
final Object o = interpreter.eval( postProcessingLanguage, "expression", 1, 1, postProcessingScript ); //$NON-NLS-1$
if ( o instanceof JFreeChart ) {
return (JFreeChart) o;
}
return originalChart;
} catch ( BSFException e ) {
// this is not nice
AbstractChartExpression.logger.warn( "Failed to evaluate post processing script", e );
} finally {
legacyDataRowWrapper.setParent( null );
runtimeWrapper.update( null, null );
}
return originalChart;
}
protected JFreeChart computeChart( final Dataset dataset ) {
return null;
}
protected void configureChart( final JFreeChart chart ) {
// Misc Properties
final TextTitle chartTitle = chart.getTitle();
if ( chartTitle != null ) {
final Font titleFont = Font.decode( getTitleFont() );
chartTitle.setFont( titleFont );
}
if ( isAntiAlias() == false ) {
chart.setAntiAlias( false );
}
chart.setBorderVisible( isShowBorder() );
final Color backgroundColor = parseColorFromString( getBackgroundColor() );
if ( backgroundColor != null ) {
chart.setBackgroundPaint( backgroundColor );
}
if ( plotBackgroundColor != null ) {
chart.getPlot().setBackgroundPaint( plotBackgroundColor );
}
chart.getPlot().setBackgroundAlpha( plotBackgroundAlpha );
chart.getPlot().setForegroundAlpha( plotForegroundAlpha );
final Color borderCol = parseColorFromString( getBorderColor() );
if ( borderCol != null ) {
chart.setBorderPaint( borderCol );
}
//remove legend if showLegend = false
if ( !isShowLegend() ) {
chart.removeLegend();
} else { //if true format legend
final LegendTitle chLegend = chart.getLegend();
if ( chLegend != null ) {
final RectangleEdge loc = translateEdge( legendLocation.toLowerCase() );
if ( loc != null ) {
chLegend.setPosition( loc );
}
if ( getLegendFont() != null ) {
chLegend.setItemFont( Font.decode( getLegendFont() ) );
}
if ( !isDrawLegendBorder() ) {
chLegend.setBorder( BlockBorder.NONE );
}
if ( legendBackgroundColor != null ) {
chLegend.setBackgroundPaint( legendBackgroundColor );
}
if ( legendTextColor != null ) {
chLegend.setItemPaint( legendTextColor );
}
}
}
final Plot plot = chart.getPlot();
plot.setNoDataMessageFont( Font.decode( getLabelFont() ) );
final String message = getNoDataMessage();
if ( message != null ) {
plot.setNoDataMessage( message );
}
plot.setOutlineVisible( isChartSectionOutline() );
if ( backgroundImage != null ) {
if ( plotImageCache != null ) {
plot.setBackgroundImage( plotImageCache );
} else {
final ExpressionRuntime expressionRuntime = getRuntime();
final ProcessingContext context = expressionRuntime.getProcessingContext();
final ResourceKey contentBase = context.getContentBase();
final ResourceManager manager = context.getResourceManager();
try {
final ResourceKey key = createKeyFromString( manager, contentBase, backgroundImage );
final Resource resource = manager.create( key, null, Image.class );
final Image image = (Image) resource.getResource();
plot.setBackgroundImage( image );
plotImageCache = image;
} catch ( Exception e ) {
logger.error( "ABSTRACTCHARTEXPRESSION.ERROR_0007_ERROR_RETRIEVING_PLOT_IMAGE", e ); //$NON-NLS-1$
throw new IllegalStateException( "Failed to process chart" );
}
}
}
}
private ResourceKey createKeyFromString( final ResourceManager resourceManager,
final ResourceKey contextKey,
final String file ) {
try {
if ( contextKey != null ) {
return resourceManager.deriveKey( contextKey, file );
}
} catch ( ResourceException re ) {
// failed to load from context
logger.debug( "Failed to load background-image as derived path: " + re );
}
try {
return resourceManager.createKey( new URL( file ) );
} catch ( ResourceException re ) {
logger.debug( "Failed to load background-image as URL: " + re );
} catch ( MalformedURLException e ) {
//
}
try {
return resourceManager.createKey( new File( file ) );
} catch ( ResourceException re ) {
// failed to load from context
logger.debug( "Failed to load background-image as file: " + re );
}
return null;
}
protected Color parseColorFromString( final String colStr ) {
if ( colStr == null ) {
return null;
}
try {
return Color.decode( colStr );
} catch ( NumberFormatException ex ) {
// Ignored - try other parser...
}
return ColorHelper.lookupColor( colStr );
}
protected String computeTitle() {
if ( titleField != null ) {
final Object computedTitle = getDataRow().get( titleField );
if ( computedTitle != null ) {
return String.valueOf( computedTitle );
}
}
if ( titleText != null ) {
// this is a deprecated behaviour, later we will not interpret the title anymore.
final Object computedTitle = getDataRow().get( titleText );
if ( computedTitle != null ) {
return String.valueOf( computedTitle );
}
}
return titleText;
}
protected RectangleEdge translateEdge( final String edge ) {
final RectangleEdge translatedEdge = LEGEND_LOCATIONS.get( edge );
if ( translatedEdge != null ) {
return translatedEdge;
}
return RectangleEdge.LEFT;
}
/**
* Overrides the dependency level to only execute this function on the pagination and content-generation level.
*
* @return LayoutProcess.LEVEL_PAGINATE.
*/
public int getDependencyLevel() {
return LayoutProcess.LEVEL_PAGINATE;
}
public void setDependencyLevel( final int ignored ) {
// do nothing
}
/**
* @return java.awt.Stroke for JFreeChart renderer to draw lines
*/
public static Stroke translateLineStyle( float lineWidth, final String lineStyle ) {
// Negative linewidths not allowed, reset to default.
if ( lineWidth < 0 ) {
logger.error( ( "LineChartExpression.ERROR_0001_INVALID_LINE_WIDTH" ) ); //$NON-NLS-1$
lineWidth = 1.0f;
}
final int strokeType;
if ( LINE_STYLE_DASH_STR.equals( lineStyle ) ) {
strokeType = StrokeUtility.STROKE_DASHED;
} else if ( LINE_STYLE_DOT_STR.equals( lineStyle ) ) {
strokeType = StrokeUtility.STROKE_DOTTED;
} else if ( LINE_STYLE_DASHDOT_STR.equals( lineStyle ) ) {
strokeType = StrokeUtility.STROKE_DOT_DASH;
} else if ( LINE_STYLE_DASHDOTDOT_STR.equals( lineStyle ) ) {
strokeType = StrokeUtility.STROKE_DOT_DOT_DASH;
} else {
if ( lineWidth == 0 ) {
strokeType = StrokeUtility.STROKE_NONE;
} else {
strokeType = StrokeUtility.STROKE_SOLID;
}
}
return StrokeUtility.createStroke( strokeType, lineWidth );
}
/**
* @param value ignored.
* @deprecated This property is no longer used.
*/
public void setChartWidth( final int value ) {
}
/**
* @return always zero.
* @deprecated This property is no longer used.
*/
public int getChartWidth() {
return 0;
}
/**
* @param value ignored.
* @deprecated This property is no longer used.
*/
public void setChartHeight( final int value ) {
}
/**
* @return always zero.
* @deprecated This property is no longer used.
*/
public int getChartHeight() {
return 0;
}
/**
* @param value ignored.
* @deprecated This property is no longer used.
*/
public void setChartDirectory( final String value ) {
}
/**
* @param value ignored.
* @deprecated This property is no longer used.
*/
public void setChartFile( final String value ) {
}
/**
* @param value ignored.
* @deprecated This property is no longer used.
*/
public void setChartUrlMask( final String value ) {
}
/**
* @return always null.
* @deprecated This property is no longer used.
*/
public String getChartDirectory() {
return null;
}
/**
* @return always null.
* @deprecated This property is no longer used.
*/
public String getChartFile() {
return null;
}
/**
* @return always null.
* @deprecated This property is no longer used.
*/
public String getChartUrlMask() {
return null;
}
/**
* @return always false.
* @deprecated This property is no longer used.
*/
public boolean isReturnFileNameOnly() {
return false;
}
/**
* @param value ignored.
* @deprecated This property is no longer used.
*/
public void setReturnFileNameOnly( final boolean value ) {
}
/**
* @return always false.
* @deprecated This property is no longer used.
*/
public boolean isReturnImageReference() {
return false;
}
/**
* @param value ignored.
* @deprecated This property is no longer used.
*/
public void setReturnImageReference( final boolean value ) {
}
/**
* @param key
* @deprecated This method should not be public and should check for null-values. Use #storeChartInCache now.
*/
public JFreeChart getChartFromCache( final Object key ) {
if ( key == null ) {
return null;
}
return loadChartFromCache( key );
}
/**
* @param chart
* @param key
* @deprecated This method should not be public and should check for null-values. Use #storeChartInCache now.
*/
public void putChartInCache( final JFreeChart chart, final Object key ) {
if ( chart == null || key == null ) {
return;
}
storeChartInCache( key, chart );
}
/**
* @return
* @deprecated This property should no longer be defined manually. The only sensible value it can take is "true" now.
*/
public boolean isUseDrawable() {
return true;
}
/**
* @param value
* @deprecated This property should no longer be defined manually. The only sensible value it can take is "true" now.
*/
public void setUseDrawable( final boolean value ) {
}
/**
* @param colStr
* @return
* @deprecated This is no getter and therefor should not call itself a getter.
*/
protected Color getColorFromString( final String colStr ) {
return parseColorFromString( colStr );
}
/**
* @param lookupValue
* @return
* @deprecated This method should not be public and is part of a messed up title-semantic. Will be removed later.
*/
public String getPossibleExpressionStringValue( final String lookupValue ) {
if ( lookupValue == null ) {
return null;
}
Object maybeExpression = null;
try {
maybeExpression = getDataRow().get( lookupValue );
} catch ( Exception ignored ) {
// ignore the expression
}
if ( maybeExpression != null ) {
return maybeExpression.toString();
} else {
return lookupValue;
}
}
/**
* Reduces standard tick unit array to meet formatting precision and avoid duplicated values (PRD-5821)
*
* @return
*/
protected void standardTickUnitsApplyFormat( NumberAxis numberAxis, NumberFormat format ) {
final TickUnits standardTickUnits = (TickUnits) numberAxis.getStandardTickUnits();
TickUnits cutTickUnits = new TickUnits();
double formatterMinSize = 1 / Math.pow( 10, format.getMaximumFractionDigits() );
for ( int i = 0; i < standardTickUnits.size(); i++ ) {
if ( Double.compare( standardTickUnits.get( i ).getSize(), formatterMinSize ) >= 0 ) {
cutTickUnits.add( new NumberTickUnit( standardTickUnits.get( i ).getSize() ) );
}
}
numberAxis.setStandardTickUnits( cutTickUnits );
}
/**
* @return
* @deprecated The semantics of this property is all messed up and thus we can only deprecate it.
*/
public String getTitle() {
return getPossibleExpressionStringValue( getTitleText() );
}
/**
* @deprecated The semantics of this property is all messed up and thus we can only deprecate it.
*/
public void setTitle( final String title ) {
this.titleText = title;
}
/**
* @deprecated use bean accessors instead: getSeriesColor(), getSeriesColor(int index)
*/
public List getSeriesColors() {
return seriesColors;
}
}