org.jfree.chart.OfflineRenderingChartPanel Maven / Gradle / Ivy
Show all versions of jfreechart Show documentation
/* ===========================================================
* JFreeChart : a free chart library for the Java(tm) platform
* ===========================================================
*
* (C) Copyright 2000-present, by David Gilbert and Contributors.
*
* Project Info: http://www.jfree.org/jfreechart/index.html
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2.1 of the License, or
* (at your option) any later version.
*
* This library 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.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
* USA.
*
* [Oracle and Java are registered trademarks of Oracle and/or its affiliates.
* Other names may be trademarks of their respective owners.]
*
* -------------------------------
* OfflineRenderingChartPanel.java
* -------------------------------
* (C) Copyright 2000-present, by Yuri Blankenstein and Contributors.
*
* Original Author: Yuri Blankenstein;
*/
package org.jfree.chart;
import java.awt.AlphaComposite;
import java.awt.Container;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.Rectangle;
import java.awt.Transparency;
import java.awt.geom.Point2D;
import java.awt.image.BufferedImage;
import javax.swing.SwingWorker;
import org.jfree.chart.entity.EntityCollection;
import org.jfree.chart.plot.PlotRenderingInfo;
/**
* A {@link ChartPanel} that applies offline rendering, for better performance
* when navigating (i.e. panning / zooming) {@link JFreeChart charts} with lots
* of data.
*
* This chart panel uses a {@link SwingWorker} to perform the actual
* {@link JFreeChart} rendering. While rendering, a {@link Cursor#WAIT_CURSOR
* wait cursor} is visible and the current buffered image of the chart will be
* scaled and drawn to the screen. When - while rendering - another
* {@link #setRefreshBuffer(boolean) refresh} is requested, this will be either
* postponed until the current rendering is done or ignored when another refresh
* is requested.
*/
public class OfflineRenderingChartPanel extends ChartPanel {
private static final long serialVersionUID = -724633596883320084L;
/**
* Using enum state pattern to control the 'offline' rendering
*/
protected enum State {
IDLE {
@Override
protected State renderOffline(OfflineRenderingChartPanel panel,
OfflineChartRenderer renderer) {
// Start rendering offline
renderer.execute();
panel.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
return RENDERING;
}
@Override
protected State offlineRenderingDone(
OfflineRenderingChartPanel panel,
OfflineChartRenderer renderer) {
throw new IllegalStateException(
"offlineRenderingDone not expected in IDLE state");
}
},
RENDERING {
@Override
protected State renderOffline(OfflineRenderingChartPanel panel,
OfflineChartRenderer renderer) {
// We're already rendering, we'll start this renderer when we're
// finished. If another rendering is requested, this one will be
// ignored, see RE_RENDERING_PENDING. This gains a lot of speed
// as not all requested (intermediate) renderings are executed
// for large plots.
panel.pendingOfflineRenderer = renderer;
return RE_RENDERING_PENDING;
}
@Override
protected State offlineRenderingDone(
OfflineRenderingChartPanel panel,
OfflineChartRenderer renderer) {
// Offline rendering done, prepare the buffer and info for the
// next repaint and request it.
panel.currentChartBuffer = renderer.buffer;
panel.currentChartRenderingInfo = renderer.info;
panel.repaint();
panel.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
return IDLE;
}
},
RE_RENDERING_PENDING {
@Override
protected State renderOffline(OfflineRenderingChartPanel panel,
OfflineChartRenderer renderer) {
// We're already rendering, we'll start this renderer when we're
// finished.
panel.pendingOfflineRenderer = renderer;
return RE_RENDERING_PENDING;
}
@Override
protected State offlineRenderingDone(
OfflineRenderingChartPanel panel,
OfflineChartRenderer renderer) {
// Store the intermediate result, but do not actively repaint
// as this could trigger another RE_RENDERING_PENDING if i.e.
// the buffer-image-size of the pending renderer differs from
// the current buffer-image-size.
panel.currentChartBuffer = renderer.buffer;
panel.currentChartRenderingInfo = renderer.info;
// Immediately start rendering again to update the chart to the
// latest requested state.
panel.pendingOfflineRenderer.execute();
panel.pendingOfflineRenderer = null;
return RENDERING;
}
};
protected abstract State renderOffline(
final OfflineRenderingChartPanel panel,
final OfflineChartRenderer renderer);
protected abstract State offlineRenderingDone(
final OfflineRenderingChartPanel panel,
final OfflineChartRenderer renderer);
}
/** A buffer for the rendered chart. */
private transient BufferedImage currentChartBuffer = null;
private transient ChartRenderingInfo currentChartRenderingInfo = null;
/** A pending rendering for the chart. */
private transient OfflineChartRenderer pendingOfflineRenderer = null;
private State state = State.IDLE;
/**
* Constructs a double buffered JFreeChart panel that displays the specified
* chart.
*
* @param chart the chart.
*/
public OfflineRenderingChartPanel(JFreeChart chart) {
this(chart, DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_MINIMUM_DRAW_WIDTH,
DEFAULT_MINIMUM_DRAW_HEIGHT, DEFAULT_MAXIMUM_DRAW_WIDTH,
DEFAULT_MAXIMUM_DRAW_HEIGHT, true, // properties
true, // save
true, // print
true, // zoom
true // tooltips
);
}
/**
* Constructs a double buffered JFreeChart panel.
*
* @param chart the chart.
* @param properties a flag indicating whether or not the chart property
* editor should be available via the popup menu.
* @param save a flag indicating whether or not save options should be
* available via the popup menu.
* @param print a flag indicating whether or not the print option
* should be available via the popup menu.
* @param zoom a flag indicating whether or not zoom options should be
* added to the popup menu.
* @param tooltips a flag indicating whether or not tooltips should be
* enabled for the chart.
*/
public OfflineRenderingChartPanel(JFreeChart chart, boolean properties,
boolean save, boolean print, boolean zoom, boolean tooltips) {
this(chart, DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_MINIMUM_DRAW_WIDTH,
DEFAULT_MINIMUM_DRAW_HEIGHT, DEFAULT_MAXIMUM_DRAW_WIDTH,
DEFAULT_MAXIMUM_DRAW_HEIGHT, properties, save, print, zoom,
tooltips);
}
/**
* Constructs a double buffered JFreeChart panel.
*
* @param chart the chart.
* @param width the preferred width of the panel.
* @param height the preferred height of the panel.
* @param minimumDrawWidth the minimum drawing width.
* @param minimumDrawHeight the minimum drawing height.
* @param maximumDrawWidth the maximum drawing width.
* @param maximumDrawHeight the maximum drawing height.
* @param properties a flag indicating whether or not the chart
* property editor should be available via the
* popup menu.
* @param save a flag indicating whether or not save options
* should be available via the popup menu.
* @param print a flag indicating whether or not the print
* option should be available via the popup menu.
* @param zoom a flag indicating whether or not zoom options
* should be added to the popup menu.
* @param tooltips a flag indicating whether or not tooltips should
* be enabled for the chart.
*/
public OfflineRenderingChartPanel(JFreeChart chart, int width, int height,
int minimumDrawWidth, int minimumDrawHeight, int maximumDrawWidth,
int maximumDrawHeight, boolean properties, boolean save,
boolean print, boolean zoom, boolean tooltips) {
this(chart, width, height, minimumDrawWidth, minimumDrawHeight,
maximumDrawWidth, maximumDrawHeight, properties, true, save,
print, zoom, tooltips);
}
/**
* Constructs a double buffered JFreeChart panel.
*
* @param chart the chart.
* @param width the preferred width of the panel.
* @param height the preferred height of the panel.
* @param minimumDrawWidth the minimum drawing width.
* @param minimumDrawHeight the minimum drawing height.
* @param maximumDrawWidth the maximum drawing width.
* @param maximumDrawHeight the maximum drawing height.
* @param properties a flag indicating whether or not the chart
* property editor should be available via the
* popup menu.
* @param copy a flag indicating whether or not a copy option
* should be available via the popup menu.
* @param save a flag indicating whether or not save options
* should be available via the popup menu.
* @param print a flag indicating whether or not the print
* option should be available via the popup menu.
* @param zoom a flag indicating whether or not zoom options
* should be added to the popup menu.
* @param tooltips a flag indicating whether or not tooltips should
* be enabled for the chart.
*/
public OfflineRenderingChartPanel(JFreeChart chart, int width, int height,
int minimumDrawWidth, int minimumDrawHeight, int maximumDrawWidth,
int maximumDrawHeight, boolean properties, boolean copy,
boolean save, boolean print, boolean zoom, boolean tooltips) {
super(chart, width, height, minimumDrawWidth, minimumDrawHeight,
maximumDrawWidth, maximumDrawHeight, true, properties, copy,
save, print, zoom, tooltips);
}
@Override
protected BufferedImage paintChartToBuffer(Graphics2D g2,
Dimension bufferSize, Dimension chartSize, Point2D anchor,
ChartRenderingInfo info) {
synchronized (state) {
if (this.currentChartBuffer == null) {
// Rendering the first time, prepare an empty buffer and
// start rendering, no need for an additional state
this.currentChartBuffer = createChartBuffer(g2, bufferSize);
clearChartBuffer(currentChartBuffer);
setRefreshBuffer(true);
} else if ((this.currentChartBuffer.getWidth() != bufferSize.width)
|| (this.currentChartBuffer
.getHeight() != bufferSize.height)) {
setRefreshBuffer(true);
}
// do we need to redraw the buffer?
if (getRefreshBuffer()) {
setRefreshBuffer(false); // clear the flag
// Rendering is done offline, hence it requires a fresh buffer
// and rendering info
BufferedImage rendererBuffer = createChartBuffer(g2,
bufferSize);
ChartRenderingInfo rendererInfo = info;
if (rendererInfo != null) {
// As the chart will be re-rendered, the current chart
// entities cannot be trusted
final EntityCollection entityCollection =
rendererInfo.getEntityCollection();
if (entityCollection != null) {
entityCollection.clear();
}
// Offline rendering requires its own instance of
// ChartRenderingInfo, using clone if possible
try {
rendererInfo = rendererInfo.clone();
} catch (CloneNotSupportedException e) {
// Not expected
e.printStackTrace();
rendererInfo = new ChartRenderingInfo();
}
}
OfflineChartRenderer offlineRenderer = new OfflineChartRenderer(
getChart(), rendererBuffer, chartSize, anchor,
rendererInfo);
state = state.renderOffline(this, offlineRenderer);
}
// Copy the rendered ChartRenderingInfo into the passed info
// argument and mark that we have done so.
copyChartRenderingInfo(this.currentChartRenderingInfo, info);
this.currentChartRenderingInfo = info;
return this.currentChartBuffer;
}
}
private class OfflineChartRenderer extends SwingWorker {
private final JFreeChart chart;
private final BufferedImage buffer;
private final Dimension chartSize;
private final Point2D anchor;
private final ChartRenderingInfo info;
public OfflineChartRenderer(JFreeChart chart, BufferedImage image,
Dimension chartSize, Point2D anchor, ChartRenderingInfo info) {
this.chart = chart;
this.buffer = image;
this.chartSize = chartSize;
this.anchor = anchor;
this.info = info;
}
@Override
protected Object doInBackground() throws Exception {
clearChartBuffer(buffer);
Graphics2D bufferG2 = buffer.createGraphics();
if ((this.buffer.getWidth() != this.chartSize.width)
|| (this.buffer.getHeight() != this.chartSize.height)) {
// Scale the chart to fit the buffer
bufferG2.scale(
this.buffer.getWidth() / this.chartSize.getWidth(),
this.buffer.getHeight() / this.chartSize.getHeight());
}
Rectangle chartArea = new Rectangle(this.chartSize);
this.chart.draw(bufferG2, chartArea, this.anchor, this.info);
bufferG2.dispose();
// Return type is not used
return null;
}
@Override
protected void done() {
synchronized (state) {
state = state.offlineRenderingDone(
OfflineRenderingChartPanel.this, this);
}
}
}
@Override
public void setCursor(Cursor cursor) {
super.setCursor(cursor);
// Buggy mouse cursor: setting both behaves as expected
Container root = getTopLevelAncestor();
if (null != root) {
root.setCursor(cursor);
}
}
private static void copyChartRenderingInfo(ChartRenderingInfo source,
ChartRenderingInfo target) {
if (source == null || target == null || source == target) {
// Nothing to do
return;
}
target.clear();
target.setChartArea(source.getChartArea());
target.setEntityCollection(source.getEntityCollection());
copyPlotRenderingInfo(source.getPlotInfo(), target.getPlotInfo());
}
private static void copyPlotRenderingInfo(PlotRenderingInfo source,
PlotRenderingInfo target) {
target.setDataArea(source.getDataArea());
target.setPlotArea(source.getPlotArea());
for (int i = 0; i < target.getSubplotCount(); i++) {
PlotRenderingInfo subSource = source.getSubplotInfo(i);
PlotRenderingInfo subTarget = new PlotRenderingInfo(
target.getOwner());
copyPlotRenderingInfo(subSource, subTarget);
target.addSubplotInfo(subTarget);
}
}
private static BufferedImage createChartBuffer(Graphics2D g2,
Dimension bufferSize) {
GraphicsConfiguration gc = g2.getDeviceConfiguration();
return gc.createCompatibleImage(bufferSize.width, bufferSize.height,
Transparency.TRANSLUCENT);
}
private static void clearChartBuffer(BufferedImage buffer) {
Graphics2D bufferG2 = buffer.createGraphics();
// make the background of the buffer clear and transparent
bufferG2.setComposite(AlphaComposite.getInstance(AlphaComposite.CLEAR, 0.0f));
bufferG2.fill(new Rectangle(buffer.getWidth(), buffer.getHeight()));
bufferG2.dispose();
}
}