package com.positive.charts.renderer.xy;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Rectangle;
import com.positive.charts.axis.ValueAxis;
import com.positive.charts.common.RectangleEdge;
import com.positive.charts.data.Range;
import com.positive.charts.data.util.DatasetUtilities;
import com.positive.charts.data.xy.IntervalXYDataset;
import com.positive.charts.data.xy.TableXYDataset;
import com.positive.charts.data.xy.XYDataset;
import com.positive.charts.plot.PlotOrientation;
import com.positive.charts.plot.PlotRenderingInfo;
import com.positive.charts.plot.xy.XYPlot;
/**
* A bar renderer that displays the series items stacked. The dataset used
* together with this renderer must be a
* {@link org.jfree.data.xy.IntervalXYDataset} and a
* {@link org.jfree.data.xy.TableXYDataset}. For example, the dataset class
* {@link org.jfree.data.xy.CategoryTableXYDataset} implements both interfaces.
*
* @author andreas.schroeder
*/
public class StackedXYBarRenderer extends XYBarRenderer {
/**
* Creates a new renderer.
*/
public StackedXYBarRenderer() {
super();
}
/**
* Creates a new renderer.
*
* @param margin
* the percentual amount of the bars that are cut away.
*/
public StackedXYBarRenderer(final double margin) {
super(margin);
}
/**
* Draws the visual representation of a single data item.
*
* @param g2
* the graphics device.
* @param state
* the renderer state.
* @param dataArea
* the area within which the plot is being drawn.
* @param info
* collects information about the drawing.
* @param plot
* the plot (can be used to obtain standard color information
* etc).
* @param domainAxis
* the domain axis.
* @param rangeAxis
* the range axis.
* @param dataset
* the dataset.
* @param series
* the series index (zero-based).
* @param item
* the item index (zero-based).
* @param crosshairState
* crosshair information for the plot (<code>null</code>
* permitted).
* @param pass
* the pass index.
*/
public void drawItem(final GC g2, final XYItemRendererState state,
final Rectangle dataArea, final PlotRenderingInfo info,
final XYPlot plot, final ValueAxis domainAxis,
final ValueAxis rangeAxis, final XYDataset dataset,
final int series, final int item, final int pass) {
if (!((dataset instanceof IntervalXYDataset) && (dataset instanceof TableXYDataset))) {
String message = "dataset (type " + dataset.getClass().getName()
+ ") has wrong type:";
boolean and = false;
if (!IntervalXYDataset.class.isAssignableFrom(dataset.getClass())) {
message += " it is no IntervalXYDataset";
and = true;
}
if (!TableXYDataset.class.isAssignableFrom(dataset.getClass())) {
if (and) {
message += " and";
}
message += " it is no TableXYDataset";
}
throw new IllegalArgumentException(message);
}
final IntervalXYDataset intervalDataset = (IntervalXYDataset) dataset;
final double value = intervalDataset.getYValue(series, item);
if (Double.isNaN(value)) {
return;
}
double positiveBase = 0.0;
double negativeBase = 0.0;
for (int i = 0; i < series; i++) {
final double v = dataset.getYValue(i, item);
if (!Double.isNaN(v)) {
if (v > 0) {
positiveBase = positiveBase + v;
} else {
negativeBase = negativeBase + v;
}
}
}
double translatedBase;
double translatedValue;
final RectangleEdge edgeR = plot.getRangeAxisEdge();
if (value > 0.0) {
translatedBase = rangeAxis.valueToJava2D(positiveBase, dataArea,
edgeR);
translatedValue = rangeAxis.valueToJava2D(positiveBase + value,
dataArea, edgeR);
} else {
translatedBase = rangeAxis.valueToJava2D(negativeBase, dataArea,
edgeR);
translatedValue = rangeAxis.valueToJava2D(negativeBase + value,
dataArea, edgeR);
}
final RectangleEdge edgeD = plot.getDomainAxisEdge();
final double startX = intervalDataset.getStartXValue(series, item);
if (Double.isNaN(startX)) {
return;
}
double translatedStartX = domainAxis.valueToJava2D(startX, dataArea,
edgeD);
final double endX = intervalDataset.getEndXValue(series, item);
if (Double.isNaN(endX)) {
return;
}
final double translatedEndX = domainAxis.valueToJava2D(endX, dataArea,
edgeD);
double translatedWidth = Math.max(1, Math.abs(translatedEndX
- translatedStartX));
final double translatedHeight = Math.abs(translatedValue
- translatedBase);
if (this.getMargin() > 0.0) {
final double cut = translatedWidth * this.getMargin();
translatedWidth = translatedWidth - cut;
translatedStartX = translatedStartX + cut / 2;
}
Rectangle bar = null;
final PlotOrientation orientation = plot.getOrientation();
if (orientation == PlotOrientation.HORIZONTAL) {
bar = new Rectangle(
(int) Math.min(translatedBase, translatedValue),
(int) translatedEndX, (int) translatedHeight,
(int) translatedWidth);
} else if (orientation == PlotOrientation.VERTICAL) {
bar = new Rectangle((int) translatedStartX, (int) Math.min(
translatedBase, translatedValue), (int) translatedWidth,
(int) translatedHeight);
}
g2.setBackground(this.getItemColor(series, item));
g2.fillRectangle(bar);
// if (isDrawBarOutline()
// && Math.abs(translatedEndX - translatedStartX) > 3) {
// g2.setStroke(getItemStroke(series, item));
// g2.setPaint(getItemOutlinePaint(series, item));
// g2.draw(bar);
// }
// // add an entity for the item...
// if (info != null) {
// EntityCollection entities = info.getOwner().getEntityCollection();
// if (entities != null) {
// String tip = null;
// XYToolTipGenerator generator
// = getToolTipGenerator(series, item);
// if (generator != null) {
// tip = generator.generateToolTip(dataset, series, item);
// }
// String url = null;
// if (getURLGenerator() != null) {
// url = getURLGenerator().generateURL(dataset, series, item);
// }
// XYItemEntity entity = new XYItemEntity(bar, dataset, series,
// item, tip, url);
// entities.add(entity);
// }
// }
}
/**
* Returns the range of values the renderer requires to display all the
* items from the specified dataset.
*
* @param dataset
* the dataset (<code>null</code> permitted).
*
* @return The range (<code>null</code> if the dataset is <code>null</code>
* or empty).
*/
public Range findRangeBounds(final XYDataset dataset) {
if (dataset != null) {
return DatasetUtilities
.findStackedRangeBounds((TableXYDataset) dataset);
} else {
return null;
}
}
/**
* Initialises the renderer and returns a state object that should be passed
* to all subsequent calls to the drawItem() method. Here there is nothing
* to do.
*
* @param g2
* the graphics device.
* @param dataArea
* the area inside the axes.
* @param plot
* the plot.
* @param data
* the data.
* @param info
* an optional info collection object to return data back to the
* caller.
*
* @return A state object.
*/
public XYItemRendererState initialise(final GC g2,
final Rectangle dataArea, final XYPlot plot, final XYDataset data,
final PlotRenderingInfo info) {
return new XYBarRendererState(info);
}
}