001 /* ===========================================================
002 * JFreeChart : a free chart library for the Java(tm) platform
003 * ===========================================================
004 *
005 * (C) Copyright 2000-2008, by Object Refinery Limited and Contributors.
006 *
007 * Project Info: http://www.jfree.org/jfreechart/index.html
008 *
009 * This library is free software; you can redistribute it and/or modify it
010 * under the terms of the GNU Lesser General Public License as published by
011 * the Free Software Foundation; either version 2.1 of the License, or
012 * (at your option) any later version.
013 *
014 * This library is distributed in the hope that it will be useful, but
015 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
016 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
017 * License for more details.
018 *
019 * You should have received a copy of the GNU Lesser General Public
020 * License along with this library; if not, write to the Free Software
021 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
022 * USA.
023 *
024 * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
025 * in the United States and other countries.]
026 *
027 * ---------------------
028 * XYLineAnnotation.java
029 * ---------------------
030 * (C) Copyright 2003-2008, by Object Refinery Limited.
031 *
032 * Original Author: David Gilbert (for Object Refinery Limited);
033 * Contributor(s): -;
034 *
035 * Changes:
036 * --------
037 * 02-Apr-2003 : Version 1 (DG);
038 * 19-Aug-2003 : Added equals method, implemented Cloneable, and applied
039 * serialization fixes (DG);
040 * 21-Jan-2004 : Update for renamed method in ValueAxis (DG);
041 * 14-Apr-2004 : Fixed draw() method to handle plot orientation correctly (DG);
042 * 29-Sep-2004 : Added support for tool tips and URLS, now extends
043 * AbstractXYAnnotation (DG);
044 * 04-Oct-2004 : Renamed ShapeUtils --> ShapeUtilities (DG);
045 * 08-Jun-2005 : Fixed equals() method to handle GradientPaint() (DG);
046 * 05-Nov-2008 : Added workaround for JRE bug 6574155, see JFreeChart bug
047 * 2221495 (DG);
048 *
049 */
050
051 package org.jfree.chart.annotations;
052
053 import java.awt.BasicStroke;
054 import java.awt.Color;
055 import java.awt.Graphics2D;
056 import java.awt.Paint;
057 import java.awt.Stroke;
058 import java.awt.geom.Line2D;
059 import java.awt.geom.Rectangle2D;
060 import java.io.IOException;
061 import java.io.ObjectInputStream;
062 import java.io.ObjectOutputStream;
063 import java.io.Serializable;
064
065 import org.jfree.chart.axis.ValueAxis;
066 import org.jfree.chart.plot.Plot;
067 import org.jfree.chart.plot.PlotOrientation;
068 import org.jfree.chart.plot.PlotRenderingInfo;
069 import org.jfree.chart.plot.XYPlot;
070 import org.jfree.chart.util.LineUtilities;
071 import org.jfree.io.SerialUtilities;
072 import org.jfree.ui.RectangleEdge;
073 import org.jfree.util.ObjectUtilities;
074 import org.jfree.util.PaintUtilities;
075 import org.jfree.util.PublicCloneable;
076 import org.jfree.util.ShapeUtilities;
077
078 /**
079 * A simple line annotation that can be placed on an {@link XYPlot}.
080 */
081 public class XYLineAnnotation extends AbstractXYAnnotation
082 implements Cloneable, PublicCloneable, Serializable {
083
084 /** For serialization. */
085 private static final long serialVersionUID = -80535465244091334L;
086
087 /** The x-coordinate. */
088 private double x1;
089
090 /** The y-coordinate. */
091 private double y1;
092
093 /** The x-coordinate. */
094 private double x2;
095
096 /** The y-coordinate. */
097 private double y2;
098
099 /** The line stroke. */
100 private transient Stroke stroke;
101
102 /** The line color. */
103 private transient Paint paint;
104
105 /**
106 * Creates a new annotation that draws a line from (x1, y1) to (x2, y2)
107 * where the coordinates are measured in data space (that is, against the
108 * plot's axes).
109 *
110 * @param x1 the x-coordinate for the start of the line.
111 * @param y1 the y-coordinate for the start of the line.
112 * @param x2 the x-coordinate for the end of the line.
113 * @param y2 the y-coordinate for the end of the line.
114 */
115 public XYLineAnnotation(double x1, double y1, double x2, double y2) {
116 this(x1, y1, x2, y2, new BasicStroke(1.0f), Color.black);
117 }
118
119 /**
120 * Creates a new annotation that draws a line from (x1, y1) to (x2, y2)
121 * where the coordinates are measured in data space (that is, against the
122 * plot's axes).
123 *
124 * @param x1 the x-coordinate for the start of the line.
125 * @param y1 the y-coordinate for the start of the line.
126 * @param x2 the x-coordinate for the end of the line.
127 * @param y2 the y-coordinate for the end of the line.
128 * @param stroke the line stroke (<code>null</code> not permitted).
129 * @param paint the line color (<code>null</code> not permitted).
130 */
131 public XYLineAnnotation(double x1, double y1, double x2, double y2,
132 Stroke stroke, Paint paint) {
133
134 if (stroke == null) {
135 throw new IllegalArgumentException("Null 'stroke' argument.");
136 }
137 if (paint == null) {
138 throw new IllegalArgumentException("Null 'paint' argument.");
139 }
140 this.x1 = x1;
141 this.y1 = y1;
142 this.x2 = x2;
143 this.y2 = y2;
144 this.stroke = stroke;
145 this.paint = paint;
146
147 }
148
149 /**
150 * Draws the annotation. This method is called by the {@link XYPlot}
151 * class, you won't normally need to call it yourself.
152 *
153 * @param g2 the graphics device.
154 * @param plot the plot.
155 * @param dataArea the data area.
156 * @param domainAxis the domain axis.
157 * @param rangeAxis the range axis.
158 * @param rendererIndex the renderer index.
159 * @param info if supplied, this info object will be populated with
160 * entity information.
161 */
162 public void draw(Graphics2D g2, XYPlot plot, Rectangle2D dataArea,
163 ValueAxis domainAxis, ValueAxis rangeAxis,
164 int rendererIndex,
165 PlotRenderingInfo info) {
166
167 PlotOrientation orientation = plot.getOrientation();
168 RectangleEdge domainEdge = Plot.resolveDomainAxisLocation(
169 plot.getDomainAxisLocation(), orientation);
170 RectangleEdge rangeEdge = Plot.resolveRangeAxisLocation(
171 plot.getRangeAxisLocation(), orientation);
172 float j2DX1 = 0.0f;
173 float j2DX2 = 0.0f;
174 float j2DY1 = 0.0f;
175 float j2DY2 = 0.0f;
176 if (orientation == PlotOrientation.VERTICAL) {
177 j2DX1 = (float) domainAxis.valueToJava2D(this.x1, dataArea,
178 domainEdge);
179 j2DY1 = (float) rangeAxis.valueToJava2D(this.y1, dataArea,
180 rangeEdge);
181 j2DX2 = (float) domainAxis.valueToJava2D(this.x2, dataArea,
182 domainEdge);
183 j2DY2 = (float) rangeAxis.valueToJava2D(this.y2, dataArea,
184 rangeEdge);
185 }
186 else if (orientation == PlotOrientation.HORIZONTAL) {
187 j2DY1 = (float) domainAxis.valueToJava2D(this.x1, dataArea,
188 domainEdge);
189 j2DX1 = (float) rangeAxis.valueToJava2D(this.y1, dataArea,
190 rangeEdge);
191 j2DY2 = (float) domainAxis.valueToJava2D(this.x2, dataArea,
192 domainEdge);
193 j2DX2 = (float) rangeAxis.valueToJava2D(this.y2, dataArea,
194 rangeEdge);
195 }
196 g2.setPaint(this.paint);
197 g2.setStroke(this.stroke);
198 Line2D line = new Line2D.Float(j2DX1, j2DY1, j2DX2, j2DY2);
199 // line is clipped to avoid JRE bug 6574155, for more info
200 // see JFreeChart bug 2221495
201 boolean visible = LineUtilities.clipLine(line, dataArea);
202 if (visible) {
203 g2.draw(line);
204 }
205
206 String toolTip = getToolTipText();
207 String url = getURL();
208 if (toolTip != null || url != null) {
209 addEntity(info, ShapeUtilities.createLineRegion(line, 1.0f),
210 rendererIndex, toolTip, url);
211 }
212 }
213
214 /**
215 * Tests this object for equality with an arbitrary object.
216 *
217 * @param obj the object to test against (<code>null</code> permitted).
218 *
219 * @return <code>true</code> or <code>false</code>.
220 */
221 public boolean equals(Object obj) {
222 if (obj == this) {
223 return true;
224 }
225 if (!super.equals(obj)) {
226 return false;
227 }
228 if (!(obj instanceof XYLineAnnotation)) {
229 return false;
230 }
231 XYLineAnnotation that = (XYLineAnnotation) obj;
232 if (this.x1 != that.x1) {
233 return false;
234 }
235 if (this.y1 != that.y1) {
236 return false;
237 }
238 if (this.x2 != that.x2) {
239 return false;
240 }
241 if (this.y2 != that.y2) {
242 return false;
243 }
244 if (!PaintUtilities.equal(this.paint, that.paint)) {
245 return false;
246 }
247 if (!ObjectUtilities.equal(this.stroke, that.stroke)) {
248 return false;
249 }
250 // seems to be the same...
251 return true;
252 }
253
254 /**
255 * Returns a hash code.
256 *
257 * @return A hash code.
258 */
259 public int hashCode() {
260 int result;
261 long temp;
262 temp = Double.doubleToLongBits(this.x1);
263 result = (int) (temp ^ (temp >>> 32));
264 temp = Double.doubleToLongBits(this.x2);
265 result = 29 * result + (int) (temp ^ (temp >>> 32));
266 temp = Double.doubleToLongBits(this.y1);
267 result = 29 * result + (int) (temp ^ (temp >>> 32));
268 temp = Double.doubleToLongBits(this.y2);
269 result = 29 * result + (int) (temp ^ (temp >>> 32));
270 return result;
271 }
272
273 /**
274 * Returns a clone of the annotation.
275 *
276 * @return A clone.
277 *
278 * @throws CloneNotSupportedException if the annotation can't be cloned.
279 */
280 public Object clone() throws CloneNotSupportedException {
281 return super.clone();
282 }
283
284 /**
285 * Provides serialization support.
286 *
287 * @param stream the output stream.
288 *
289 * @throws IOException if there is an I/O error.
290 */
291 private void writeObject(ObjectOutputStream stream) throws IOException {
292 stream.defaultWriteObject();
293 SerialUtilities.writePaint(this.paint, stream);
294 SerialUtilities.writeStroke(this.stroke, stream);
295 }
296
297 /**
298 * Provides serialization support.
299 *
300 * @param stream the input stream.
301 *
302 * @throws IOException if there is an I/O error.
303 * @throws ClassNotFoundException if there is a classpath problem.
304 */
305 private void readObject(ObjectInputStream stream)
306 throws IOException, ClassNotFoundException {
307 stream.defaultReadObject();
308 this.paint = SerialUtilities.readPaint(stream);
309 this.stroke = SerialUtilities.readStroke(stream);
310 }
311
312 }