Plot.java
| Index Score | ||
|---|---|---|
 |
 |
org.jfree.chart.plot |
 |
 |
JFreeChart |
View: Reasons, Metrics, Source Code
These are the metrics that contribute to the Enerjy Score for this file, ranked by impact. So the metrics listed at the top influence the score to a greater extent that the metrics listed at the bottom.
| Metric | Description | |
|---|---|---|
| DECL_COMMENTS | Comments in declarations |  |
| DOC_COMMENT | Number of javadoc comment lines | |
| COMMENTS | Comment lines | |
| SIZE | Size of the file in bytes | |
| LINES | Number of lines in the source file | |
| RETURNS | Number of return points from functions | |
| INTERFACE_COMPLEXITY | Interface complexity | |
| BLOCKS | Number of blocks | |
| CYCLOMATIC | Cyclomatic complexity | |
| FUNCTIONS | Number of function declarations | |
| PARAMS | Number of formal parameter declarations | |
| LOC | Lines of code | |
| OPERATORS | Number of operators | |
| COMPARISONS | Number of comparison operators | |
| ELOC | Effective lines of code | |
| PROGRAM_LENGTH | Halstead program length | |
| LOGICAL_LINES | Number of statements | |
| BLOCK_COMMENT | Number of block comment lines | |
| OPERANDS | Number of operands | |
| UNIQUE_OPERANDS | Number of unique operands | |
| PROGRAM_VOCAB | Halstead program vocabulary | |
| JAVA0173 | JAVA0173 Unused method parameter | |
| JAVA0078 | JAVA0078 Floating point values compared with == | |
| JAVA0084 | JAVA0084 Should use compound assignment operator | |
| JAVA0034 | JAVA0034 Missing braces in if statement | |
| EXITS | Procedure exits | |
| WHITESPACE | Number of whitespace lines | |
| UNIQUE_OPERATORS | Number of unique operators | |
| JAVA0117 | JAVA0117 Missing javadoc: method 'method' | |
| PROGRAM_VOLUME | Halstead program volume | |
| JAVA0136 | JAVA0136 N methods defined in class (maximum: M) | |
| JAVA0126 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0110 | JAVA0110 Incorrect javadoc: no @return tag | |
| JAVA0100 | JAVA0100 Class contains N non-final fields (maximum: M) | |
| LOOPS | Number of loops | |
| JAVA0108 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0145 | JAVA0145 Tab character used in source file | |
/* ===========================================================
* JFreeChart : a free chart library for the Java(tm) platform
* ===========================================================
*
* (C) Copyright 2000-2008, by Object Refinery Limited 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.
*
* [Java is a trademark or registered trademark of Sun Microsystems, Inc.
* in the United States and other countries.]
*
* ---------
* Plot.java
* ---------
* (C) Copyright 2000-2008, by Object Refinery Limited and Contributors.
*
* Original Author: David Gilbert (for Object Refinery Limited);
* Contributor(s): Sylvain Vieujot;
* Jeremy Bowman;
* Andreas Schneider;
* Gideon Krause;
* Nicolas Brodu;
* Michal Krause;
* Richard West, Advanced Micro Devices, Inc.;
*
* Changes (from 21-Jun-2001)
* --------------------------
* 21-Jun-2001 : Removed redundant JFreeChart parameter from constructors (DG);
* 18-Sep-2001 : Updated header info and fixed DOS encoding problem (DG);
* 19-Oct-2001 : Moved series paint and stroke methods from JFreeChart
* class (DG);
* 23-Oct-2001 : Created renderer for LinePlot class (DG);
* 07-Nov-2001 : Changed type names for ChartChangeEvent (DG);
* Tidied up some Javadoc comments (DG);
* 13-Nov-2001 : Changes to allow for null axes on plots such as PiePlot (DG);
* Added plot/axis compatibility checks (DG);
* 12-Dec-2001 : Changed constructors to protected, and removed unnecessary
* 'throws' clauses (DG);
* 13-Dec-2001 : Added tooltips (DG);
* 22-Jan-2002 : Added handleClick() method, as part of implementation for
* crosshairs (DG);
* Moved tooltips reference into ChartInfo class (DG);
* 23-Jan-2002 : Added test for null axes in chartChanged() method, thanks
* to Barry Evans for the bug report (number 506979 on
* SourceForge) (DG);
* Added a zoom() method (DG);
* 05-Feb-2002 : Updated setBackgroundPaint(), setOutlineStroke() and
* setOutlinePaint() to better handle null values, as suggested
* by Sylvain Vieujot (DG);
* 06-Feb-2002 : Added background image, plus alpha transparency for background
* and foreground (DG);
* 06-Mar-2002 : Added AxisConstants interface (DG);
* 26-Mar-2002 : Changed zoom method from empty to abstract (DG);
* 23-Apr-2002 : Moved dataset from JFreeChart class (DG);
* 11-May-2002 : Added ShapeFactory interface for getShape() methods,
* contributed by Jeremy Bowman (DG);
* 28-May-2002 : Fixed bug in setSeriesPaint(int, Paint) for subplots (AS);
* 25-Jun-2002 : Removed redundant imports (DG);
* 30-Jul-2002 : Added 'no data' message for charts with null or empty
* datasets (DG);
* 21-Aug-2002 : Added code to extend series array if necessary (refer to
* SourceForge bug id 594547 for details) (DG);
* 17-Sep-2002 : Fixed bug in getSeriesOutlineStroke() method, reported by
* Andreas Schroeder (DG);
* 23-Sep-2002 : Added getLegendItems() abstract method (DG);
* 24-Sep-2002 : Removed firstSeriesIndex, subplots now use their own paint
* settings, there is a new mechanism for the legend to collect
* the legend items (DG);
* 27-Sep-2002 : Added dataset group (DG);
* 14-Oct-2002 : Moved listener storage into EventListenerList. Changed some
* abstract methods to empty implementations (DG);
* 28-Oct-2002 : Added a getBackgroundImage() method (DG);
* 21-Nov-2002 : Added a plot index for identifying subplots in combined and
* overlaid charts (DG);
* 22-Nov-2002 : Changed all attributes from 'protected' to 'private'. Added
* dataAreaRatio attribute from David M O'Donnell's code (DG);
* 09-Jan-2003 : Integrated fix for plot border contributed by Gideon
* Krause (DG);
* 17-Jan-2003 : Moved to com.jrefinery.chart.plot (DG);
* 23-Jan-2003 : Removed one constructor (DG);
* 26-Mar-2003 : Implemented Serializable (DG);
* 14-Jul-2003 : Moved the dataset and secondaryDataset attributes to the
* CategoryPlot and XYPlot classes (DG);
* 21-Jul-2003 : Moved DrawingSupplier from CategoryPlot and XYPlot up to this
* class (DG);
* 20-Aug-2003 : Implemented Cloneable (DG);
* 11-Sep-2003 : Listeners and clone (NB);
* 29-Oct-2003 : Added workaround for font alignment in PDF output (DG);
* 03-Dec-2003 : Modified draw method to accept anchor (DG);
* 12-Mar-2004 : Fixed clipping bug in drawNoDataMessage() method (DG);
* 07-Apr-2004 : Modified string bounds calculation (DG);
* 04-Nov-2004 : Added default shapes for legend items (DG);
* 25-Nov-2004 : Some changes to the clone() method implementation (DG);
* 23-Feb-2005 : Implemented new LegendItemSource interface (and also
* PublicCloneable) (DG);
* 21-Apr-2005 : Replaced Insets with RectangleInsets (DG);
* 05-May-2005 : Removed unused draw() method (DG);
* 06-Jun-2005 : Fixed bugs in equals() method (DG);
* 01-Sep-2005 : Moved dataAreaRatio from here to ContourPlot (DG);
* ------------- JFREECHART 1.0.x ---------------------------------------------
* 30-Jun-2006 : Added background image alpha - see bug report 1514904 (DG);
* 05-Sep-2006 : Implemented the MarkerChangeListener interface (DG);
* 11-Jan-2007 : Added some argument checks, event notifications, and many
* API doc updates (DG);
* 03-Apr-2007 : Made drawBackgroundImage() public (DG);
* 07-Jun-2007 : Added new fillBackground() method to handle GradientPaint
* taking into account orientation (DG);
* 20-Jun-2007 : Removed JCommon dependencies (DG);
* 06-Jul-2007 : Changed default background color to LIGHT_GRAY (DG);
* 25-Mar-2008 : Added fireChangeEvent() method - see patch 1914411 (DG);
* 15-Aug-2008 : Added setDrawingSupplier() method with notify flag (DG);
*
*/
package org.jfree.chart.plot;
import java.awt.AlphaComposite;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Composite;
import java.awt.Font;
import java.awt.GradientPaint;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Paint;
import java.awt.Shape;
import java.awt.Stroke;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import javax.swing.event.EventListenerList;
import org.jfree.chart.LegendItemCollection;
import org.jfree.chart.LegendItemSource;
import org.jfree.chart.axis.AxisLocation;
import org.jfree.chart.event.AxisChangeEvent;
import org.jfree.chart.event.AxisChangeListener;
import org.jfree.chart.event.ChartChangeEventType;
import org.jfree.chart.event.MarkerChangeEvent;
import org.jfree.chart.event.MarkerChangeListener;
import org.jfree.chart.event.PlotChangeEvent;
import org.jfree.chart.event.PlotChangeListener;
import org.jfree.chart.text.G2TextMeasurer;
import org.jfree.chart.text.TextBlock;
import org.jfree.chart.text.TextBlockAnchor;
import org.jfree.chart.text.TextUtilities;
import org.jfree.chart.util.Align;
import org.jfree.chart.util.ObjectUtilities;
import org.jfree.chart.util.PaintUtilities;
import org.jfree.chart.util.PublicCloneable;
import org.jfree.chart.util.RectangleEdge;
import org.jfree.chart.util.RectangleInsets;
import org.jfree.chart.util.SerialUtilities;
import org.jfree.data.general.DatasetChangeEvent;
import org.jfree.data.general.DatasetChangeListener;
import org.jfree.data.general.DatasetGroup;
/**
* The base class for all plots in JFreeChart. The
* {@link org.jfree.chart.JFreeChart} class delegates the drawing of axes and
* data to the plot. This base class provides facilities common to most plot
* types.
*/
public abstract class Plot implements AxisChangeListener,
DatasetChangeListener, MarkerChangeListener, LegendItemSource,
PublicCloneable, Cloneable, Serializable {
/** For serialization. */
private static final long serialVersionUID = -8831571430103671324L;
/** Useful constant representing zero. */
public static final Number ZERO = new Integer(0);
/** The default insets. */
public static final RectangleInsets DEFAULT_INSETS
= new RectangleInsets(4.0, 8.0, 4.0, 8.0);
/** The default outline stroke. */
public static final Stroke DEFAULT_OUTLINE_STROKE = new BasicStroke(0.5f);
/** The default outline color. */
public static final Paint DEFAULT_OUTLINE_PAINT = Color.gray;
/** The default foreground alpha transparency. */
public static final float DEFAULT_FOREGROUND_ALPHA = 1.0f;
/** The default background alpha transparency. */
public static final float DEFAULT_BACKGROUND_ALPHA = 1.0f;
/** The default background color. */
public static final Paint DEFAULT_BACKGROUND_PAINT = Color.LIGHT_GRAY;
/** The minimum width at which the plot should be drawn. */
public static final int MINIMUM_WIDTH_TO_DRAW = 10;
/** The minimum height at which the plot should be drawn. */
public static final int MINIMUM_HEIGHT_TO_DRAW = 10;
/** A default box shape for legend items. */
public static final Shape DEFAULT_LEGEND_ITEM_BOX
= new Rectangle2D.Double(-4.0, -4.0, 8.0, 8.0);
/** A default circle shape for legend items. */
public static final Shape DEFAULT_LEGEND_ITEM_CIRCLE
= new Ellipse2D.Double(-4.0, -4.0, 8.0, 8.0);
/** The parent plot (<code>null</code> if this is the root plot). */
private Plot parent;
/** The dataset group (to be used for thread synchronisation). */
private DatasetGroup datasetGroup;
/** The message to display if no data is available. */
private String noDataMessage;
/** The font used to display the 'no data' message. */
private Font noDataMessageFont;
/** The paint used to draw the 'no data' message. */
private transient Paint noDataMessagePaint;
/** Amount of blank space around the plot area. */
private RectangleInsets insets;
/**
* A flag that controls whether or not the plot outline is drawn.
*
* @since 1.0.6
*/
private boolean outlineVisible;
/** The Stroke used to draw an outline around the plot. */
private transient Stroke outlineStroke;
/** The Paint used to draw an outline around the plot. */
private transient Paint outlinePaint;
/** An optional color used to fill the plot background. */
private transient Paint backgroundPaint;
/** An optional image for the plot background. */
private transient Image backgroundImage; // not currently serialized
/** The alignment for the background image. */
private int backgroundImageAlignment = Align.FIT;
/** The alpha value used to draw the background image. */
private float backgroundImageAlpha = 0.5f;
/** The alpha-transparency for the plot. */
private float foregroundAlpha;
/** The alpha transparency for the background paint. */
private float backgroundAlpha;
/** The drawing supplier. */
private DrawingSupplier drawingSupplier;
/** Storage for registered change listeners. */
private transient EventListenerList listenerList;
/**
* Creates a new plot.
*/
protected Plot() {
this.parent = null;
this.insets = DEFAULT_INSETS;
this.backgroundPaint = DEFAULT_BACKGROUND_PAINT;
this.backgroundAlpha = DEFAULT_BACKGROUND_ALPHA;
this.backgroundImage = null;
this.outlineVisible = true;
this.outlineStroke = DEFAULT_OUTLINE_STROKE;
this.outlinePaint = DEFAULT_OUTLINE_PAINT;
this.foregroundAlpha = DEFAULT_FOREGROUND_ALPHA;
this.noDataMessage = null;
this.noDataMessageFont = new Font("SansSerif", Font.PLAIN, 12);
this.noDataMessagePaint = Color.black;
this.drawingSupplier = new DefaultDrawingSupplier();
this.listenerList = new EventListenerList();
}
/**
* Returns the dataset group for the plot (not currently used).
*
* @return The dataset group.
*
* @see #setDatasetGroup(DatasetGroup)
*/
public DatasetGroup getDatasetGroup() {
return this.datasetGroup;
}
/**
* Sets the dataset group (not currently used).
*
* @param group the dataset group (<code>null</code> permitted).
*
* @see #getDatasetGroup()
*/
protected void setDatasetGroup(DatasetGroup group) {
this.datasetGroup = group;
}
/**
* Returns the string that is displayed when the dataset is empty or
* <code>null</code>.
*
* @return The 'no data' message (<code>null</code> possible).
*
* @see #setNoDataMessage(String)
* @see #getNoDataMessageFont()
* @see #getNoDataMessagePaint()
*/
public String getNoDataMessage() {
return this.noDataMessage;
}
/**
* Sets the message that is displayed when the dataset is empty or
* <code>null</code>, and sends a {@link PlotChangeEvent} to all registered
* listeners.
*
* @param message the message (<code>null</code> permitted).
*
* @see #getNoDataMessage()
*/
public void setNoDataMessage(String message) {
this.noDataMessage = message;
fireChangeEvent();
}
/**
* Returns the font used to display the 'no data' message.
*
* @return The font (never <code>null</code>).
*
* @see #setNoDataMessageFont(Font)
* @see #getNoDataMessage()
*/
public Font getNoDataMessageFont() {
return this.noDataMessageFont;
}
/**
* Sets the font used to display the 'no data' message and sends a
* {@link PlotChangeEvent} to all registered listeners.
*
* @param font the font (<code>null</code> not permitted).
*
* @see #getNoDataMessageFont()
*/
public void setNoDataMessageFont(Font font) {
if (font == null) {
throw new IllegalArgumentException("Null 'font' argument.");
}
this.noDataMessageFont = font;
fireChangeEvent();
}
/**
* Returns the paint used to display the 'no data' message.
*
* @return The paint (never <code>null</code>).
*
* @see #setNoDataMessagePaint(Paint)
* @see #getNoDataMessage()
*/
public Paint getNoDataMessagePaint() {
return this.noDataMessagePaint;
}
/**
* Sets the paint used to display the 'no data' message and sends a
* {@link PlotChangeEvent} to all registered listeners.
*
* @param paint the paint (<code>null</code> not permitted).
*
* @see #getNoDataMessagePaint()
*/
public void setNoDataMessagePaint(Paint paint) {
if (paint == null) {
throw new IllegalArgumentException("Null 'paint' argument.");
}
this.noDataMessagePaint = paint;
fireChangeEvent();
}
/**
* Returns a short string describing the plot type.
* <P>
* Note: this gets used in the chart property editing user interface,
* but there needs to be a better mechanism for identifying the plot type.
*
* @return A short string describing the plot type (never
* <code>null</code>).
*/
public abstract String getPlotType();
/**
* Returns the parent plot (or <code>null</code> if this plot is not part
* of a combined plot).
*
* @return The parent plot.
*
* @see #setParent(Plot)
* @see #getRootPlot()
*/
public Plot getParent() {
return this.parent;
}
/**
* Sets the parent plot. This method is intended for internal use, you
* shouldn't need to call it directly.
*
* @param parent the parent plot (<code>null</code> permitted).
*
* @see #getParent()
*/
public void setParent(Plot parent) {
this.parent = parent;
}
/**
* Returns the root plot.
*
* @return The root plot.
*
* @see #getParent()
*/
public Plot getRootPlot() {
Plot p = getParent();
if (p == null) {
return this;
}
else {
return p.getRootPlot();
}
}
/**
* Returns <code>true</code> if this plot is part of a combined plot
* structure (that is, {@link #getParent()} returns a non-<code>null</code>
* value), and <code>false</code> otherwise.
*
* @return <code>true</code> if this plot is part of a combined plot
* structure.
*
* @see #getParent()
*/
public boolean isSubplot() {
return (getParent() != null);
}
/**
* Returns the insets for the plot area.
*
* @return The insets (never <code>null</code>).
*
* @see #setInsets(RectangleInsets)
*/
public RectangleInsets getInsets() {
return this.insets;
}
/**
* Sets the insets for the plot and sends a {@link PlotChangeEvent} to
* all registered listeners.
*
* @param insets the new insets (<code>null</code> not permitted).
*
* @see #getInsets()
* @see #setInsets(RectangleInsets, boolean)
*/
public void setInsets(RectangleInsets insets) {
setInsets(insets, true);
}
/**
* Sets the insets for the plot and, if requested, and sends a
* {@link PlotChangeEvent} to all registered listeners.
*
* @param insets the new insets (<code>null</code> not permitted).
* @param notify a flag that controls whether the registered listeners are
* notified.
*
* @see #getInsets()
* @see #setInsets(RectangleInsets)
*/
public void setInsets(RectangleInsets insets, boolean notify) {
if (insets == null) {
throw new IllegalArgumentException("Null 'insets' argument.");
}
if (!this.insets.equals(insets)) {
this.insets = insets;
if (notify) {
fireChangeEvent();
}
}
}
/**
* Returns the background color of the plot area.
*
* @return The paint (possibly <code>null</code>).
*
* @see #setBackgroundPaint(Paint)
*/
public Paint getBackgroundPaint() {
return this.backgroundPaint;
}
/**
* Sets the background color of the plot area and sends a
* {@link PlotChangeEvent} to all registered listeners.
*
* @param paint the paint (<code>null</code> permitted).
*
* @see #getBackgroundPaint()
*/
public void setBackgroundPaint(Paint paint) {
if (paint == null) {
if (this.backgroundPaint != null) {
this.backgroundPaint = null;
fireChangeEvent();
}
}
else {
if (this.backgroundPaint != null) {
if (this.backgroundPaint.equals(paint)) {
return; // nothing to do
}
}
this.backgroundPaint = paint;
fireChangeEvent();
}
}
/**
* Returns the alpha transparency of the plot area background.
*
* @return The alpha transparency.
*
* @see #setBackgroundAlpha(float)
*/
public float getBackgroundAlpha() {
return this.backgroundAlpha;
}
/**
* Sets the alpha transparency of the plot area background, and notifies
* registered listeners that the plot has been modified.
*
* @param alpha the new alpha value (in the range 0.0f to 1.0f).
*
* @see #getBackgroundAlpha()
*/
public void setBackgroundAlpha(float alpha) {
if (this.backgroundAlpha != alpha) {
this.backgroundAlpha = alpha;
fireChangeEvent();
}
}
/**
* Returns the drawing supplier for the plot.
*
* @return The drawing supplier (possibly <code>null</code>).
*
* @see #setDrawingSupplier(DrawingSupplier)
*/
public DrawingSupplier getDrawingSupplier() {
DrawingSupplier result = null;
Plot p = getParent();
if (p != null) {
result = p.getDrawingSupplier();
}
else {
result = this.drawingSupplier;
}
return result;
}
/**
* Sets the drawing supplier for the plot and sends a
* {@link PlotChangeEvent} to all registered listeners. The drawing
* supplier is responsible for supplying a limitless (possibly repeating)
* sequence of <code>Paint</code>, <code>Stroke</code> and
* <code>Shape</code> objects that the plot's renderer(s) can use to
* populate its (their) tables.
*
* @param supplier the new supplier.
*
* @see #getDrawingSupplier()
*/
public void setDrawingSupplier(DrawingSupplier supplier) {
this.drawingSupplier = supplier;
fireChangeEvent();
}
/**
* Sets the drawing supplier for the plot and, if requested, sends a
* {@link PlotChangeEvent} to all registered listeners. The drawing
* supplier is responsible for supplying a limitless (possibly repeating)
* sequence of <code>Paint</code>, <code>Stroke</code> and
* <code>Shape</code> objects that the plot's renderer(s) can use to
* populate its (their) tables.
*
* @param supplier the new supplier.
* @param notify notify listeners?
*
* @see #getDrawingSupplier()
*
* @since 1.0.11
*/
public void setDrawingSupplier(DrawingSupplier supplier, boolean notify) {
this.drawingSupplier = supplier;
if (notify) {
fireChangeEvent();
}
}
/**
* Returns the background image that is used to fill the plot's background
* area.
*
* @return The image (possibly <code>null</code>).
*
* @see #setBackgroundImage(Image)
*/
public Image getBackgroundImage() {
return this.backgroundImage;
}
/**
* Sets the background image for the plot and sends a
* {@link PlotChangeEvent} to all registered listeners.
*
* @param image the image (<code>null</code> permitted).
*
* @see #getBackgroundImage()
*/
public void setBackgroundImage(Image image) {
this.backgroundImage = image;
fireChangeEvent();
}
/**
* Returns the background image alignment. Alignment constants are defined
* in the {@link Align} class.
*
* @return The alignment.
*
* @see #setBackgroundImageAlignment(int)
*/
public int getBackgroundImageAlignment() {
return this.backgroundImageAlignment;
}
/**
* Sets the alignment for the background image and sends a
* {@link PlotChangeEvent} to all registered listeners. Alignment options
* are defined by the {@link Align} class.
*
* @param alignment the alignment.
*
* @see #getBackgroundImageAlignment()
*/
public void setBackgroundImageAlignment(int alignment) {
if (this.backgroundImageAlignment != alignment) {
this.backgroundImageAlignment = alignment;
fireChangeEvent();
}
}
/**
* Returns the alpha transparency used to draw the background image. This
* is a value in the range 0.0f to 1.0f, where 0.0f is fully transparent
* and 1.0f is fully opaque.
*
* @return The alpha transparency.
*
* @see #setBackgroundImageAlpha(float)
*/
public float getBackgroundImageAlpha() {
return this.backgroundImageAlpha;
}
/**
* Sets the alpha transparency used when drawing the background image.
*
* @param alpha the alpha transparency (in the range 0.0f to 1.0f, where
* 0.0f is fully transparent, and 1.0f is fully opaque).
*
* @throws IllegalArgumentException if <code>alpha</code> is not within
* the specified range.
*
* @see #getBackgroundImageAlpha()
*/
public void setBackgroundImageAlpha(float alpha) {
if (alpha < 0.0f || alpha > 1.0f)
throw new IllegalArgumentException(
"The 'alpha' value must be in the range 0.0f to 1.0f.");
if (this.backgroundImageAlpha != alpha) {
this.backgroundImageAlpha = alpha;
fireChangeEvent();
}
}
/**
* Returns the flag that controls whether or not the plot outline is
* drawn. The default value is <code>true</code>. Note that for
* historical reasons, the plot's outline paint and stroke can take on
* <code>null</code> values, in which case the outline will not be drawn
* even if this flag is set to <code>true</code>.
*
* @return The outline visibility flag.
*
* @since 1.0.6
*
* @see #setOutlineVisible(boolean)
*/
public boolean isOutlineVisible() {
return this.outlineVisible;
}
/**
* Sets the flag that controls whether or not the plot's outline is
* drawn, and sends a {@link PlotChangeEvent} to all registered listeners.
*
* @param visible the new flag value.
*
* @since 1.0.6
*
* @see #isOutlineVisible()
*/
public void setOutlineVisible(boolean visible) {
this.outlineVisible = visible;
fireChangeEvent();
}
/**
* Returns the stroke used to outline the plot area.
*
* @return The stroke (possibly <code>null</code>).
*
* @see #setOutlineStroke(Stroke)
*/
public Stroke getOutlineStroke() {
return this.outlineStroke;
}
/**
* Sets the stroke used to outline the plot area and sends a
* {@link PlotChangeEvent} to all registered listeners. If you set this
* attribute to <code>null</code>, no outline will be drawn.
*
* @param stroke the stroke (<code>null</code> permitted).
*
* @see #getOutlineStroke()
*/
public void setOutlineStroke(Stroke stroke) {
if (stroke == null) {
if (this.outlineStroke != null) {
this.outlineStroke = null;
fireChangeEvent();
}
}
else {
if (this.outlineStroke != null) {
if (this.outlineStroke.equals(stroke)) {
return; // nothing to do
}
}
this.outlineStroke = stroke;
fireChangeEvent();
}
}
/**
* Returns the color used to draw the outline of the plot area.
*
* @return The color (possibly <code>null<code>).
*
* @see #setOutlinePaint(Paint)
*/
public Paint getOutlinePaint() {
return this.outlinePaint;
}
/**
* Sets the paint used to draw the outline of the plot area and sends a
* {@link PlotChangeEvent} to all registered listeners. If you set this
* attribute to <code>null</code>, no outline will be drawn.
*
* @param paint the paint (<code>null</code> permitted).
*
* @see #getOutlinePaint()
*/
public void setOutlinePaint(Paint paint) {
if (paint == null) {
if (this.outlinePaint != null) {
this.outlinePaint = null;
fireChangeEvent();
}
}
else {
if (this.outlinePaint != null) {
if (this.outlinePaint.equals(paint)) {
return; // nothing to do
}
}
this.outlinePaint = paint;
fireChangeEvent();
}
}
/**
* Returns the alpha-transparency for the plot foreground.
*
* @return The alpha-transparency.
*
* @see #setForegroundAlpha(float)
*/
public float getForegroundAlpha() {
return this.foregroundAlpha;
}
/**
* Sets the alpha-transparency for the plot and sends a
* {@link PlotChangeEvent} to all registered listeners.
*
* @param alpha the new alpha transparency.
*
* @see #getForegroundAlpha()
*/
public void setForegroundAlpha(float alpha) {
if (this.foregroundAlpha != alpha) {
this.foregroundAlpha = alpha;
fireChangeEvent();
}
}
/**
* Returns the legend items for the plot. By default, this method returns
* <code>null</code>. Subclasses should override to return a
* {@link LegendItemCollection}.
*
* @return The legend items for the plot (possibly <code>null</code>).
*/
public LegendItemCollection getLegendItems() {
return null;
}
/**
* Registers an object for notification of changes to the plot.
*
* @param listener the object to be registered.
*
* @see #removeChangeListener(PlotChangeListener)
*/
public void addChangeListener(PlotChangeListener listener) {
this.listenerList.add(PlotChangeListener.class, listener);
}
/**
* Unregisters an object for notification of changes to the plot.
*
* @param listener the object to be unregistered.
*
* @see #addChangeListener(PlotChangeListener)
*/
public void removeChangeListener(PlotChangeListener listener) {
this.listenerList.remove(PlotChangeListener.class, listener);
}
/**
* Notifies all registered listeners that the plot has been modified.
*
* @param event information about the change event.
*/
public void notifyListeners(PlotChangeEvent event) {
Object[] listeners = this.listenerList.getListenerList();
for (int i = listeners.length - 2; i >= 0; i -= 2) {
if (listeners[i] == PlotChangeListener.class) {
((PlotChangeListener) listeners[i + 1]).plotChanged(event);
}
}
}
/**
* Sends a {@link PlotChangeEvent} to all registered listeners.
*
* @since 1.0.10
*/
protected void fireChangeEvent() {
notifyListeners(new PlotChangeEvent(this));
}
/**
* Draws the plot within the specified area. The anchor is a point on the
* chart that is specified externally (for instance, it may be the last
* point of the last mouse click performed by the user) - plots can use or
* ignore this value as they see fit.
* <br><br>
* Subclasses need to provide an implementation of this method, obviously.
*
* @param g2 the graphics device.
* @param area the plot area.
* @param anchor the anchor point (<code>null</code> permitted).
* @param parentState the parent state (if any).
* @param info carries back plot rendering info.
*/
public abstract void draw(Graphics2D g2,
Rectangle2D area,
Point2D anchor,
PlotState parentState,
PlotRenderingInfo info);
/**
* Draws the plot background (the background color and/or image).
* <P>
* This method will be called during the chart drawing process and is
* declared public so that it can be accessed by the renderers used by
* certain subclasses. You shouldn't need to call this method directly.
*
* @param g2 the graphics device.
* @param area the area within which the plot should be drawn.
*/
public void drawBackground(Graphics2D g2, Rectangle2D area) {
// some subclasses override this method completely, so don't put
// anything here that *must* be done
fillBackground(g2, area);
drawBackgroundImage(g2, area);
}
/**
* Fills the specified area with the background paint.
*
* @param g2 the graphics device.
* @param area the area.
*
* @see #getBackgroundPaint()
* @see #getBackgroundAlpha()
* @see #fillBackground(Graphics2D, Rectangle2D, PlotOrientation)
*/
protected void fillBackground(Graphics2D g2, Rectangle2D area) {
fillBackground(g2, area, PlotOrientation.VERTICAL);
}
/**
* Fills the specified area with the background paint. If the background
* paint is an instance of <code>GradientPaint</code>, the gradient will
* run in the direction suggested by the plot's orientation.
*
* @param g2 the graphics target.
* @param area the plot area.
* @param orientation the plot orientation (<code>null</code> not
* permitted).
*
* @since 1.0.6
*/
protected void fillBackground(Graphics2D g2, Rectangle2D area,
PlotOrientation orientation) {
if (orientation == null) {
throw new IllegalArgumentException("Null 'orientation' argument.");
}
if (this.backgroundPaint == null) {
return;
}
Paint p = this.backgroundPaint;
if (p instanceof GradientPaint) {
GradientPaint gp = (GradientPaint) p;
if (orientation == PlotOrientation.VERTICAL) {
p = new GradientPaint((float) area.getCenterX(),
(float) area.getMaxY(), gp.getColor1(),
(float) area.getCenterX(), (float) area.getMinY(),
gp.getColor2());
}
else if (orientation == PlotOrientation.HORIZONTAL) {
p = new GradientPaint((float) area.getMinX(),
(float) area.getCenterY(), gp.getColor1(),
(float) area.getMaxX(), (float) area.getCenterY(),
gp.getColor2());
}
}
Composite originalComposite = g2.getComposite();
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
this.backgroundAlpha));
g2.setPaint(p);
g2.fill(area);
g2.setComposite(originalComposite);
}
/**
* Draws the background image (if there is one) aligned within the
* specified area.
*
* @param g2 the graphics device.
* @param area the area.
*
* @see #getBackgroundImage()
* @see #getBackgroundImageAlignment()
* @see #getBackgroundImageAlpha()
*/
public void drawBackgroundImage(Graphics2D g2, Rectangle2D area) {
if (this.backgroundImage != null) {
Composite originalComposite = g2.getComposite();
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
this.backgroundImageAlpha));
Rectangle2D dest = new Rectangle2D.Double(0.0, 0.0,
this.backgroundImage.getWidth(null),
this.backgroundImage.getHeight(null));
Align.align(dest, area, this.backgroundImageAlignment);
g2.drawImage(this.backgroundImage, (int) dest.getX(),
(int) dest.getY(), (int) dest.getWidth() + 1,
(int) dest.getHeight() + 1, null);
g2.setComposite(originalComposite);
}
}
/**
* Draws the plot outline. This method will be called during the chart
* drawing process and is declared public so that it can be accessed by the
* renderers used by certain subclasses. You shouldn't need to call this
* method directly.
*
* @param g2 the graphics device.
* @param area the area within which the plot should be drawn.
*/
public void drawOutline(Graphics2D g2, Rectangle2D area) {
if (!this.outlineVisible) {
return;
}
if ((this.outlineStroke != null) && (this.outlinePaint != null)) {
g2.setStroke(this.outlineStroke);
g2.setPaint(this.outlinePaint);
g2.draw(area);
}
}
/**
* Draws a message to state that there is no data to plot.
*
* @param g2 the graphics device.
* @param area the area within which the plot should be drawn.
*/
protected void drawNoDataMessage(Graphics2D g2, Rectangle2D area) {
Shape savedClip = g2.getClip();
g2.clip(area);
String message = this.noDataMessage;
if (message != null) {
g2.setFont(this.noDataMessageFont);
g2.setPaint(this.noDataMessagePaint);
TextBlock block = TextUtilities.createTextBlock(
this.noDataMessage, this.noDataMessageFont,
this.noDataMessagePaint, 0.9f * (float) area.getWidth(),
new G2TextMeasurer(g2));
block.draw(g2, (float) area.getCenterX(),
(float) area.getCenterY(), TextBlockAnchor.CENTER);
}
g2.setClip(savedClip);
}
/**
* Handles a 'click' on the plot. Since the plot does not maintain any
* information about where it has been drawn, the plot rendering info is
* supplied as an argument so that the plot dimensions can be determined.
*
* @param x the x coordinate (in Java2D space).
* @param y the y coordinate (in Java2D space).
* @param info an object containing information about the dimensions of
* the plot.
*/
public void handleClick(int x, int y, PlotRenderingInfo info) {
// provides a 'no action' default
}
/**
* Performs a zoom on the plot. Subclasses should override if zooming is
* appropriate for the type of plot.
*
* @param percent the zoom percentage.
*/
public void zoom(double percent) {
// do nothing by default.
}
/**
* Receives notification of a change to one of the plot's axes.
*
* @param event information about the event (not used here).
*/
public void axisChanged(AxisChangeEvent event) {
fireChangeEvent();
}
/**
* Receives notification of a change to the plot's dataset.
* <P>
* The plot reacts by passing on a plot change event to all registered
* listeners.
*
* @param event information about the event (not used here).
*/
public void datasetChanged(DatasetChangeEvent event) {
PlotChangeEvent newEvent = new PlotChangeEvent(this);
newEvent.setType(ChartChangeEventType.DATASET_UPDATED);
notifyListeners(newEvent);
}
/**
* Receives notification of a change to a marker that is assigned to the
* plot.
*
* @param event the event.
*
* @since 1.0.3
*/
public void markerChanged(MarkerChangeEvent event) {
fireChangeEvent();
}
/**
* Adjusts the supplied x-value.
*
* @param x the x-value.
* @param w1 width 1.
* @param w2 width 2.
* @param edge the edge (left or right).
*
* @return The adjusted x-value.
*/
protected double getRectX(double x, double w1, double w2,
RectangleEdge edge) {
double result = x;
if (edge == RectangleEdge.LEFT) {
result = result + w1;
}
else if (edge == RectangleEdge.RIGHT) {
result = result + w2;
}
return result;
}
/**
* Adjusts the supplied y-value.
*
* @param y the x-value.
* @param h1 height 1.
* @param h2 height 2.
* @param edge the edge (top or bottom).
*
* @return The adjusted y-value.
*/
protected double getRectY(double y, double h1, double h2,
RectangleEdge edge) {
double result = y;
if (edge == RectangleEdge.TOP) {
result = result + h1;
}
else if (edge == RectangleEdge.BOTTOM) {
result = result + h2;
}
return result;
}
/**
* Tests this plot for equality with another object.
*
* @param obj the object (<code>null</code> permitted).
*
* @return <code>true</code> or <code>false</code>.
*/
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof Plot)) {
return false;
}
Plot that = (Plot) obj;
if (!ObjectUtilities.equal(this.noDataMessage, that.noDataMessage)) {
return false;
}
if (!ObjectUtilities.equal(
this.noDataMessageFont, that.noDataMessageFont
)) {
return false;
}
if (!PaintUtilities.equal(this.noDataMessagePaint,
that.noDataMessagePaint)) {
return false;
}
if (!ObjectUtilities.equal(this.insets, that.insets)) {
return false;
}
if (this.outlineVisible != that.outlineVisible) {
return false;
}
if (!ObjectUtilities.equal(this.outlineStroke, that.outlineStroke)) {
return false;
}
if (!PaintUtilities.equal(this.outlinePaint, that.outlinePaint)) {
return false;
}
if (!PaintUtilities.equal(this.backgroundPaint, that.backgroundPaint)) {
return false;
}
if (!ObjectUtilities.equal(this.backgroundImage,
that.backgroundImage)) {
return false;
}
if (this.backgroundImageAlignment != that.backgroundImageAlignment) {
return false;
}
if (this.backgroundImageAlpha != that.backgroundImageAlpha) {
return false;
}
if (this.foregroundAlpha != that.foregroundAlpha) {
return false;
}
if (this.backgroundAlpha != that.backgroundAlpha) {
return false;
}
if (!this.drawingSupplier.equals(that.drawingSupplier)) {
return false;
}
return true;
}
/**
* Creates a clone of the plot.
*
* @return A clone.
*
* @throws CloneNotSupportedException if some component of the plot does not
* support cloning.
*/
public Object clone() throws CloneNotSupportedException {
Plot clone = (Plot) super.clone();
// private Plot parent <-- don't clone the parent plot, but take care
// childs in combined plots instead
if (this.datasetGroup != null) {
clone.datasetGroup
= (DatasetGroup) ObjectUtilities.clone(this.datasetGroup);
}
clone.drawingSupplier
= (DrawingSupplier) ObjectUtilities.clone(this.drawingSupplier);
clone.listenerList = new EventListenerList();
return clone;
}
/**
* Provides serialization support.
*
* @param stream the output stream.
*
* @throws IOException if there is an I/O error.
*/
private void writeObject(ObjectOutputStream stream) throws IOException {
stream.defaultWriteObject();
SerialUtilities.writePaint(this.noDataMessagePaint, stream);
SerialUtilities.writeStroke(this.outlineStroke, stream);
SerialUtilities.writePaint(this.outlinePaint, stream);
// backgroundImage
SerialUtilities.writePaint(this.backgroundPaint, stream);
}
/**
* Provides serialization support.
*
* @param stream the input stream.
*
* @throws IOException if there is an I/O error.
* @throws ClassNotFoundException if there is a classpath problem.
*/
private void readObject(ObjectInputStream stream)
throws IOException, ClassNotFoundException {
stream.defaultReadObject();
this.noDataMessagePaint = SerialUtilities.readPaint(stream);
this.outlineStroke = SerialUtilities.readStroke(stream);
this.outlinePaint = SerialUtilities.readPaint(stream);
// backgroundImage
this.backgroundPaint = SerialUtilities.readPaint(stream);
this.listenerList = new EventListenerList();
}
/**
* Resolves a domain axis location for a given plot orientation.
*
* @param location the location (<code>null</code> not permitted).
* @param orientation the orientation (<code>null</code> not permitted).
*
* @return The edge (never <code>null</code>).
*/
public static RectangleEdge resolveDomainAxisLocation(
AxisLocation location, PlotOrientation orientation) {
if (location == null) {
throw new IllegalArgumentException("Null 'location' argument.");
}
if (orientation == null) {
throw new IllegalArgumentException("Null 'orientation' argument.");
}
RectangleEdge result = null;
if (location == AxisLocation.TOP_OR_RIGHT) {
if (orientation == PlotOrientation.HORIZONTAL) {
result = RectangleEdge.RIGHT;
}
else if (orientation == PlotOrientation.VERTICAL) {
result = RectangleEdge.TOP;
}
}
else if (location == AxisLocation.TOP_OR_LEFT) {
if (orientation == PlotOrientation.HORIZONTAL) {
result = RectangleEdge.LEFT;
}
else if (orientation == PlotOrientation.VERTICAL) {
result = RectangleEdge.TOP;
}
}
else if (location == AxisLocation.BOTTOM_OR_RIGHT) {
if (orientation == PlotOrientation.HORIZONTAL) {
result = RectangleEdge.RIGHT;
}
else if (orientation == PlotOrientation.VERTICAL) {
result = RectangleEdge.BOTTOM;
}
}
else if (location == AxisLocation.BOTTOM_OR_LEFT) {
if (orientation == PlotOrientation.HORIZONTAL) {
result = RectangleEdge.LEFT;
}
else if (orientation == PlotOrientation.VERTICAL) {
result = RectangleEdge.BOTTOM;
}
}
// the above should cover all the options...
if (result == null) {
throw new IllegalStateException("resolveDomainAxisLocation()");
}
return result;
}
/**
* Resolves a range axis location for a given plot orientation.
*
* @param location the location (<code>null</code> not permitted).
* @param orientation the orientation (<code>null</code> not permitted).
*
* @return The edge (never <code>null</code>).
*/
public static RectangleEdge resolveRangeAxisLocation(
AxisLocation location, PlotOrientation orientation) {
if (location == null) {
throw new IllegalArgumentException("Null 'location' argument.");
}
if (orientation == null) {
throw new IllegalArgumentException("Null 'orientation' argument.");
}
RectangleEdge result = null;
if (location == AxisLocation.TOP_OR_RIGHT) {
if (orientation == PlotOrientation.HORIZONTAL) {
result = RectangleEdge.TOP;
}
else if (orientation == PlotOrientation.VERTICAL) {
result = RectangleEdge.RIGHT;
}
}
else if (location == AxisLocation.TOP_OR_LEFT) {
if (orientation == PlotOrientation.HORIZONTAL) {
result = RectangleEdge.TOP;
}
else if (orientation == PlotOrientation.VERTICAL) {
result = RectangleEdge.LEFT;
}
}
else if (location == AxisLocation.BOTTOM_OR_RIGHT) {
if (orientation == PlotOrientation.HORIZONTAL) {
result = RectangleEdge.BOTTOM;
}
else if (orientation == PlotOrientation.VERTICAL) {
result = RectangleEdge.RIGHT;
}
}
else if (location == AxisLocation.BOTTOM_OR_LEFT) {
if (orientation == PlotOrientation.HORIZONTAL) {
result = RectangleEdge.BOTTOM;
}
else if (orientation == PlotOrientation.VERTICAL) {
result = RectangleEdge.LEFT;
}
}
// the above should cover all the options...
if (result == null) {
throw new IllegalStateException("resolveRangeAxisLocation()");
}
return result;
}
}
The table below shows all metrics for Plot.java.
| Metric | Value | Description | |
|---|---|---|---|
| BLOCKS | 152.00 | Number of blocks | |
| BLOCK_COMMENT | 128.00 | Number of block comment lines | |
| COMMENTS | 708.00 | Comment lines | |
| COMMENT_DENSITY | 1.53 | Comment density | |
| COMPARISONS | 85.00 | Number of comparison operators | |
| CYCLOMATIC | 150.00 | Cyclomatic complexity | |
| DECL_COMMENTS | 94.00 | Comments in declarations | |
| DOC_COMMENT | 570.00 | Number of javadoc comment lines | |
| ELOC | 462.00 | Effective lines of code | |
| EXEC_COMMENTS | 8.00 | Comments in executable code | |
| EXITS | 54.00 | Procedure exits | |
| FUNCTIONS | 63.00 | Number of function declarations | |
| HALSTEAD_DIFFICULTY | 87.97 | Halstead difficulty | |
| HALSTEAD_EFFORT | 0.00 | Halstead effort | |
| INTERFACE_COMPLEXITY | 174.00 | Interface complexity | |
| JAVA0001 | 0.00 | JAVA0001 Package name does not contain only lower case letters | |
| JAVA0002 | 0.00 | JAVA0002 Package name does not begin with a top level domain name or country code | |
| JAVA0003 | 0.00 | JAVA0003 Minimize use of on-demand (.*) imports | |
| JAVA0004 | 0.00 | JAVA0004 Unnecessary import from java.lang | |
| JAVA0005 | 0.00 | JAVA0005 Imports not in specified order | |
| JAVA0006 | 0.00 | JAVA0006 Empty finally block | |
| JAVA0007 | 0.00 | JAVA0007 Should not declare public field | |
| JAVA0008 | 0.00 | JAVA0008 Empty catch block | |
| JAVA0009 | 0.00 | JAVA0009 Protected member in final class | |
| JAVA0010 | 0.00 | JAVA0010 Non-instantiable class does not contain a non-private static member | |
| JAVA0011 | 0.00 | JAVA0011 Abstract class does not contain an abstract method | |
| JAVA0012 | 0.00 | JAVA0012 Non-constructor method with same name as declaring class | |
| JAVA0013 | 0.00 | JAVA0013 Non-blank final field is not static | |
| JAVA0014 | 0.00 | JAVA0014 Class with only static members has non-private constructor | |
| JAVA0015 | 0.00 | JAVA0015 Package class contains public nested type | |
| JAVA0016 | 0.00 | JAVA0016 Abstract class contains public constructor | |
| JAVA0017 | 0.00 | JAVA0017 Class name does not have required form | |
| JAVA0018 | 0.00 | JAVA0018 Method name does not have required form | |
| JAVA0019 | 0.00 | JAVA0019 Interface name does not have required form | |
| JAVA0020 | 0.00 | JAVA0020 Field name does not have required form | |
| JAVA0021 | 0.00 | JAVA0021 Interface method name does not have required form | |
| JAVA0022 | 0.00 | JAVA0022 Static final field name does not have required form | |
| JAVA0023 | 0.00 | JAVA0023 Empty finalize method | |
| JAVA0024 | 0.00 | JAVA0024 Empty class | |
| JAVA0025 | 0.00 | JAVA0025 Method override is empty | |
| JAVA0026 | 0.00 | JAVA0026 Finalize method with parameters | |
| JAVA0029 | 0.00 | JAVA0029 Private method not used | |
| JAVA0030 | 0.00 | JAVA0030 Private field not used | |
| JAVA0031 | 0.00 | JAVA0031 Case statement not properly closed | |
| JAVA0032 | 0.00 | JAVA0032 Switch statement missing default | |
| JAVA0033 | 0.00 | JAVA0033 default: not last case in switch statement | |
| JAVA0034 | 1.00 | JAVA0034 Missing braces in if statement | |
| JAVA0035 | 0.00 | JAVA0035 Missing braces in for statement | |
| JAVA0036 | 0.00 | JAVA0036 Missing braces in while statement | |
| JAVA0038 | 0.00 | JAVA0038 Non-case label in switch statement | |
| JAVA0039 | 0.00 | JAVA0039 Break statement with label | |
| JAVA0040 | 0.00 | JAVA0040 Switch statement contains N cases (maximum: M) | |
| JAVA0041 | 0.00 | JAVA0041 Nested synchronized block | |
| JAVA0042 | 0.00 | JAVA0042 Empty synchronized statement | |
| JAVA0043 | 0.00 | JAVA0043 Inner class does not use outer class | |
| JAVA0044 | 0.00 | JAVA0044 Serializable class with no instance variables | |
| JAVA0045 | 0.00 | JAVA0045 Serializable class with only transient fields | |
| JAVA0046 | 0.00 | JAVA0046 Name of class not derived from Exception ends with 'Exception' | |
| JAVA0047 | 0.00 | JAVA0047 Serializable class derives from invalid base class | |
| JAVA0048 | 0.00 | JAVA0048 Name of class derived from Exception does not end with 'Exception' | |
| JAVA0049 | 0.00 | JAVA0049 Nested block at depth N (maximum: M) | |
| JAVA0050 | 0.00 | JAVA0050 Class derives from java.lang.Error | |
| JAVA0051 | 0.00 | JAVA0051 Class derives from java.lang.RuntimeException | |
| JAVA0052 | 0.00 | JAVA0052 Class derives from java.lang.Throwable | |
| JAVA0053 | 0.00 | JAVA0053 Unused label | |
| JAVA0054 | 0.00 | JAVA0054 Inheritance depth N exceeds maximum M | |
| JAVA0055 | 0.00 | JAVA0055 Class should be interface | |
| JAVA0056 | 0.00 | JAVA0056 Unnecessary abstract modifier for interface or annotation | |
| JAVA0057 | 0.00 | JAVA0057 Unnecessary default constructor | |
| JAVA0058 | 0.00 | JAVA0058 Constructor calls super() | |
| JAVA0059 | 0.00 | JAVA0059 Method override only calls super() | |
| JAVA0061 | 0.00 | JAVA0061 Inaccessible member in anonymous class | |
| JAVA0062 | 0.00 | JAVA0062 Public class missing public member or protected constructor | |
| JAVA0063 | 0.00 | JAVA0063 Identifier name should not contain '$' | |
| JAVA0064 | 0.00 | JAVA0064 N variations of identifier name (maximum: M) | |
| JAVA0065 | 0.00 | JAVA0065 Unnecessary final modifier for method in final class | |
| JAVA0066 | 0.00 | JAVA0066 Unnecessary modifier for interface nested type | |
| JAVA0067 | 0.00 | JAVA0067 Array descriptor on identifier name | |
| JAVA0068 | 0.00 | JAVA0068 Modifiers not declared in recommended order | |
| JAVA0071 | 0.00 | JAVA0071 Strings compared with == | |
| JAVA0073 | 0.00 | JAVA0073 Integer division in floating-point context | |
| JAVA0074 | 0.00 | JAVA0074 Use of Object.notify() | |
| JAVA0075 | 0.00 | JAVA0075 Method parameter hides field | |
| JAVA0076 | 1.00 | JAVA0076 Use of magic number | |
| JAVA0077 | 0.00 | JAVA0077 Private field not used in declaring class | |
| JAVA0078 | 6.00 | JAVA0078 Floating point values compared with == | |
| JAVA0079 | 0.00 | JAVA0079 Use of instance to reference static member | |
| JAVA0080 | 0.00 | JAVA0080 Import declaration not used | |
| JAVA0081 | 0.00 | JAVA0081 Boolean literal in comparison | |
| JAVA0082 | 0.00 | JAVA0082 Unnecessary widening cast | |
| JAVA0083 | 0.00 | JAVA0083 Unnecessary instanceof test | |
| JAVA0084 | 4.00 | JAVA0084 Should use compound assignment operator | |
| JAVA0085 | 0.00 | JAVA0085 Use of sun.* class | |
| JAVA0087 | 0.00 | JAVA0087 Use of Thread.sleep() | |
| JAVA0089 | 0.00 | JAVA0089 Use of restricted package | |
| JAVA0092 | 0.00 | JAVA0092 Use of restricted type | |
| JAVA0093 | 0.00 | JAVA0093 Redundant assignment | |
| JAVA0094 | 0.00 | JAVA0094 Field hides a superclass field | |
| JAVA0095 | 0.00 | JAVA0095 Uninitialized private field | |
| JAVA0096 | 0.00 | JAVA0096 Field in nested class hides outer field | |
| JAVA0098 | 0.00 | JAVA0098 Minimize use of implicit field initializers | |
| JAVA0100 | 1.00 | JAVA0100 Class contains N non-final fields (maximum: M) | |
| JAVA0101 | 0.00 | JAVA0101 Unnecessary modifier for field in interface | |
| JAVA0102 | 0.00 | JAVA0102 Last statement in finalize() not super.finalize() | |
| JAVA0103 | 0.00 | JAVA0103 Explicit call to finalize() | |
| JAVA0104 | 0.00 | JAVA0104 finalize() only calls super.finalize() | |
| JAVA0105 | 0.00 | JAVA0105 Duplicate import declaration | |
| JAVA0106 | 0.00 | JAVA0106 Unnecessary import from current package | |
| JAVA0108 | 0.00 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0109 | 0.00 | JAVA0109 Incorrect javadoc: no parameter 'parameter' | |
| JAVA0110 | 0.00 | JAVA0110 Incorrect javadoc: no @return tag | |
| JAVA0111 | 0.00 | JAVA0111 Incorrect javadoc: @return tag for void method | |
| JAVA0112 | 0.00 | JAVA0112 Incorrect javadoc: no exception 'exception' in throws | |
| JAVA0113 | 1.00 | JAVA0113 Incorrect javadoc: no @author tag | |
| JAVA0114 | 1.00 | JAVA0114 Incorrect javadoc: no @version tag | |
| JAVA0115 | 0.00 | JAVA0115 Incorrect javadoc: no @throws or @exception tag for 'exception' | |
| JAVA0116 | 0.00 | JAVA0116 Missing javadoc: field 'field' | |
| JAVA0117 | 0.00 | JAVA0117 Missing javadoc: method 'method' | |
| JAVA0118 | 0.00 | JAVA0118 Missing javadoc: type 'type' | |
| JAVA0119 | 0.00 | JAVA0119 Control variable changed within body of for loop | |
| JAVA0123 | 0.00 | JAVA0123 Use all three components of for loop | |
| JAVA0125 | 0.00 | JAVA0125 Continue statement with label | |
| JAVA0126 | 0.00 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0128 | 0.00 | JAVA0128 Public constructor in non-public class | |
| JAVA0130 | 0.00 | JAVA0130 Non-static method does not use instance fields | |
| JAVA0131 | 0.00 | JAVA0131 Compatible method does not override base | |
| JAVA0132 | 0.00 | JAVA0132 Method overload with compatible signature | |
| JAVA0133 | 0.00 | JAVA0133 Non-synchronized method overrides synchronized method | |
| JAVA0135 | 1.00 | JAVA0135 Only one of Object.equals and Object.hashCode defined: missing 'method' | |
| JAVA0136 | 1.00 | JAVA0136 N methods defined in class (maximum: M) | |
| JAVA0137 | 0.00 | JAVA0137 Non-abstract class missing constructor | |
| JAVA0138 | 0.00 | JAVA0138 N parameters defined for method (maximum: M) | |
| JAVA0139 | 0.00 | JAVA0139 Definition of main other than public static void main(java.lang.String[]) | |
| JAVA0141 | 0.00 | JAVA0141 Unnecessary modifier for method in interface | |
| JAVA0143 | 0.00 | JAVA0143 Synchronized method | |
| JAVA0144 | 0.00 | JAVA0144 Line exceeds maximum M characters | |
| JAVA0145 | 0.00 | JAVA0145 Tab character used in source file | |
| JAVA0150 | 0.00 | JAVA0150 java.lang.Error (or subclass) thrown | |
| JAVA0153 | 0.00 | JAVA0153 Inefficient conversion of integer to string | |
| JAVA0159 | 0.00 | JAVA0159 Inefficient conversion of string to integer | |
| JAVA0160 | 0.00 | JAVA0160 Method does not throw specified exception | |
| JAVA0161 | 0.00 | JAVA0161 Conditional wait() not in loop | |
| JAVA0163 | 0.00 | JAVA0163 Empty statement | |
| JAVA0165 | 0.00 | JAVA0165 Conflicting return statement in finally block | |
| JAVA0166 | 0.00 | JAVA0166 Generic exception caught | |
| JAVA0167 | 0.00 | JAVA0167 ThreadDeath not rethrown | |
| JAVA0169 | 0.00 | JAVA0169 Unnecessary catch block: exception 'exception' | |
| JAVA0170 | 0.00 | JAVA0170 Caught exception not derived from java.lang.Exception | |
| JAVA0171 | 0.00 | JAVA0171 Unused local variable | |
| JAVA0173 | 4.00 | JAVA0173 Unused method parameter | |
| JAVA0174 | 0.00 | JAVA0174 Assigned local variable never used | |
| JAVA0175 | 0.00 | JAVA0175 Successive assignment to variable | |
| JAVA0176 | 0.00 | JAVA0176 Local variable name does not have required form | |
| JAVA0177 | 0.00 | JAVA0177 Variable declaration missing initializer | |
| JAVA0179 | 0.00 | JAVA0179 Local variable hides visible field | |
| JAVA0233 | 0.00 | JAVA0233 Definition of serialVersionUID other than 'private static final long serialVersionUID' | |
| JAVA0234 | 0.00 | JAVA0234 Class is Serializable but does not define serialVersionUID | |
| JAVA0235 | 0.00 | JAVA0235 Class defines serialVersionUID but does not implement Serializable | |
| JAVA0236 | 0.00 | JAVA0236 Attempt to clone an object which does not implement Cloneable | |
| JAVA0237 | 0.00 | JAVA0237 Class implements Cloneable but does not have public clone method | |
| JAVA0238 | 0.00 | JAVA0238 Clone method does not call super.clone() | |
| JAVA0239 | 0.00 | JAVA0239 Class declares 'readObject' or 'writeObject' but does not implement Serializable | |
| JAVA0240 | 0.00 | JAVA0240 Serializable class which declares readObject or writeObject but not both | |
| JAVA0241 | 0.00 | JAVA0241 'readObject' or 'writeObject' should be declared private in Serializable class | |
| JAVA0242 | 0.00 | JAVA0242 Transient field in non-Serializable class | |
| JAVA0243 | 0.00 | JAVA0243 'readResolve' or 'writeReplace' should be declared private or protected | |
| JAVA0244 | 0.00 | JAVA0244 Field or method name in subclass differs only by case from inherited field or method | |
| JAVA0245 | 0.00 | JAVA0245 JUnit TestCase with non-trivial constructor | |
| JAVA0246 | 0.00 | JAVA0246 JUnit assertXXX statement missing message parameter | |
| JAVA0247 | 0.00 | JAVA0247 JUnit 'setUp()' and 'tearDown()' should call super method | |
| JAVA0248 | 0.00 | JAVA0248 JUnit method 'setUp' or 'tearDown' with incorrect signature | |
| JAVA0249 | 0.00 | JAVA0249 JUnit TestCase 'suite()' should be declared static | |
| JAVA0250 | 0.00 | JAVA0250 JUnit TestCase declares testXXX method with incorrect signature | |
| JAVA0251 | 0.00 | JAVA0251 Use '%n' for line breaks in printf/format for platform independence | |
| JAVA0252 | 0.00 | JAVA0252 'enum' is a Java 1.5 reserved word | |
| JAVA0253 | 0.00 | JAVA0253 Not all enum constants consumed in switch statement | |
| JAVA0254 | 0.00 | JAVA0254 Use enhanced for loop construct instead of Iterator | |
| JAVA0255 | 0.00 | JAVA0255 Result of method invocation not used | |
| JAVA0256 | 0.00 | JAVA0256 Assignment of external collection/array to field | |
| JAVA0257 | 0.00 | JAVA0257 Use of 'Constant Interface' anti-pattern | |
| JAVA0258 | 0.00 | JAVA0258 Implement Iterable for foreach compatibility | |
| JAVA0259 | 0.00 | JAVA0259 Return of collection/array field | |
| JAVA0260 | 0.00 | JAVA0260 Use 'enum' instead of Enumerated Type pattern | |
| JAVA0261 | 0.00 | JAVA0261 Use specialized Enum collection types | |
| JAVA0262 | 0.00 | JAVA0262 Use of char in integer context | |
| JAVA0263 | 0.00 | JAVA0263 Long literal ends with 'l' instead of 'L' | |
| JAVA0264 | 0.00 | JAVA0264 Integer math in long context - check for overflow | |
| JAVA0265 | 0.00 | JAVA0265 Use of Throwable.printStackTrace() | |
| JAVA0266 | 0.00 | JAVA0266 Use of System.out | |
| JAVA0267 | 0.00 | JAVA0267 Use of System.err | |
| JAVA0269 | 0.00 | JAVA0269 Contents of StringBuffer never used | |
| JAVA0270 | 0.00 | JAVA0270 Use Java 5.0 enhanced for loop construct to iterate over all elements in an array | |
| JAVA0271 | 0.00 | JAVA0271 Minimize use of on-demand (.*) static imports | |
| JAVA0272 | 0.00 | JAVA0272 Thread.run() called | |
| JAVA0273 | 0.00 | JAVA0273 Non-final derivative of Thread calls start() in constructor | |
| JAVA0274 | 0.00 | JAVA0274 Serializable class has a synchronized readObject() | |
| JAVA0275 | 0.00 | JAVA0275 Serializable class has a synchronized writeObject() and no other synchronized methods | |
| JAVA0276 | 0.00 | JAVA0276 Unnecessary use of String constructor | |
| JAVA0277 | 0.00 | JAVA0277 Iterator.next() implementation does not throw NoSuchElementException | |
| JAVA0278 | 0.00 | JAVA0278 Unnecessary use of Boolean constructor | |
| JAVA0279 | 0.00 | JAVA0279 Serialization method readObject or readObjectNoData calls an overridable method | |
| JAVA0280 | 0.00 | JAVA0280 IllegalMonitorStateException caught | |
| JAVA0281 | 0.00 | JAVA0281 Iterator.next() not called in loop | |
| JAVA0282 | 0.00 | JAVA0282 Call to Iterator.next() in loop which does not test Iterator.hasNext() | |
| JAVA0283 | 0.00 | JAVA0283 Control variable not updated in loop body | |
| JAVA0284 | 0.00 | JAVA0284 Explicit garbage collection | |
| JAVA0285 | 0.00 | JAVA0285 Dereference of potentially null variable | |
| JAVA0286 | 0.00 | JAVA0286 Dereference of null variable | |
| JAVA0287 | 0.00 | JAVA0287 Unnecessary null check | |
| JAVA0288 | 0.00 | JAVA0288 Inconsistent null check | |
| LINES | 1448.00 | Number of lines in the source file | |
| LINE_COMMENT | 10.00 | Number of line comments | |
| LOC | 615.00 | Lines of code | |
| LOGICAL_LINES | 272.00 | Number of statements | |
| LOOPS | 1.00 | Number of loops | |
| NEST_DEPTH | 4.00 | Maximum nesting depth | |
| OPERANDS | 1147.00 | Number of operands | |
| OPERATORS | 2541.00 | Number of operators | |
| PARAMS | 63.00 | Number of formal parameter declarations | |
| PROGRAM_LENGTH | 3688.00 | Halstead program length | |
| PROGRAM_VOCAB | 391.00 | Halstead program vocabulary | |
| PROGRAM_VOLUME | 0.00 | Halstead program volume | |
| RETURNS | 111.00 | Number of return points from functions | |
| SIZE | 50450.00 | Size of the file in bytes | |
| UNIQUE_OPERANDS | 339.00 | Number of unique operands | |
| UNIQUE_OPERATORS | 52.00 | Number of unique operators | |
| WHITESPACE | 125.00 | Number of whitespace lines | |