001 /* ===========================================================
002 * JFreeChart : a free chart library for the Java(tm) platform
003 * ===========================================================
004 *
005 * (C) Copyright 2000-2007, 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-2007, by Object Refinery Limited.
031 *
032 * Original Author: David Gilbert (for Object Refinery Limited);
033 * Contributor(s): -;
034 *
035 * $Id: XYLineAnnotation.java,v 1.7.2.3 2007/03/06 16:12:18 mungady Exp $
036 *
037 * Changes:
038 * --------
039 * 02-Apr-2003 : Version 1 (DG);
040 * 19-Aug-2003 : Added equals method, implemented Cloneable, and applied
041 * serialization fixes (DG);
042 * 21-Jan-2004 : Update for renamed method in ValueAxis (DG);
043 * 14-Apr-2004 : Fixed draw() method to handle plot orientation correctly (DG);
044 * 29-Sep-2004 : Added support for tool tips and URLS, now extends
045 * AbstractXYAnnotation (DG);
046 * 04-Oct-2004 : Renamed ShapeUtils --> ShapeUtilities (DG);
047 * 08-Jun-2005 : Fixed equals() method to handle GradientPaint() (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.io.SerialUtilities;
071 import org.jfree.ui.RectangleEdge;
072 import org.jfree.util.ObjectUtilities;
073 import org.jfree.util.PaintUtilities;
074 import org.jfree.util.PublicCloneable;
075 import org.jfree.util.ShapeUtilities;
076
077 /**
078 * A simple line annotation that can be placed on an {@link XYPlot}.
079 */
080 public class XYLineAnnotation extends AbstractXYAnnotation
081 implements Cloneable, PublicCloneable,
082 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 g2.draw(line);
200
201 String toolTip = getToolTipText();
202 String url = getURL();
203 if (toolTip != null || url != null) {
204 addEntity(info, ShapeUtilities.createLineRegion(line, 1.0f),
205 rendererIndex, toolTip, url);
206 }
207 }
208
209 /**
210 * Tests this object for equality with an arbitrary object.
211 *
212 * @param obj the object to test against (<code>null</code> permitted).
213 *
214 * @return <code>true</code> or <code>false</code>.
215 */
216 public boolean equals(Object obj) {
217 if (obj == this) {
218 return true;
219 }
220 if (!super.equals(obj)) {
221 return false;
222 }
223 if (!(obj instanceof XYLineAnnotation)) {
224 return false;
225 }
226 XYLineAnnotation that = (XYLineAnnotation) obj;
227 if (this.x1 != that.x1) {
228 return false;
229 }
230 if (this.y1 != that.y1) {
231 return false;
232 }
233 if (this.x2 != that.x2) {
234 return false;
235 }
236 if (this.y2 != that.y2) {
237 return false;
238 }
239 if (!PaintUtilities.equal(this.paint, that.paint)) {
240 return false;
241 }
242 if (!ObjectUtilities.equal(this.stroke, that.stroke)) {
243 return false;
244 }
245 // seems to be the same...
246 return true;
247 }
248
249 /**
250 * Returns a hash code.
251 *
252 * @return A hash code.
253 */
254 public int hashCode() {
255 int result;
256 long temp;
257 temp = Double.doubleToLongBits(this.x1);
258 result = (int) (temp ^ (temp >>> 32));
259 temp = Double.doubleToLongBits(this.x2);
260 result = 29 * result + (int) (temp ^ (temp >>> 32));
261 temp = Double.doubleToLongBits(this.y1);
262 result = 29 * result + (int) (temp ^ (temp >>> 32));
263 temp = Double.doubleToLongBits(this.y2);
264 result = 29 * result + (int) (temp ^ (temp >>> 32));
265 return result;
266 }
267
268 /**
269 * Returns a clone of the annotation.
270 *
271 * @return A clone.
272 *
273 * @throws CloneNotSupportedException if the annotation can't be cloned.
274 */
275 public Object clone() throws CloneNotSupportedException {
276 return super.clone();
277 }
278
279 /**
280 * Provides serialization support.
281 *
282 * @param stream the output stream.
283 *
284 * @throws IOException if there is an I/O error.
285 */
286 private void writeObject(ObjectOutputStream stream) throws IOException {
287 stream.defaultWriteObject();
288 SerialUtilities.writePaint(this.paint, stream);
289 SerialUtilities.writeStroke(this.stroke, stream);
290 }
291
292 /**
293 * Provides serialization support.
294 *
295 * @param stream the input stream.
296 *
297 * @throws IOException if there is an I/O error.
298 * @throws ClassNotFoundException if there is a classpath problem.
299 */
300 private void readObject(ObjectInputStream stream)
301 throws IOException, ClassNotFoundException {
302 stream.defaultReadObject();
303 this.paint = SerialUtilities.readPaint(stream);
304 this.stroke = SerialUtilities.readStroke(stream);
305 }
306
307 }