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 * CrosshairState.java
029 * -------------------
030 * (C) Copyright 2002-2007, by Object Refinery Limited.
031 *
032 * Original Author: David Gilbert (for Object Refinery Limited);
033 * Contributor(s): -;
034 *
035 * $Id: CrosshairState.java,v 1.3.2.4 2007/02/06 16:29:10 mungady Exp $
036 *
037 * Changes
038 * -------
039 * 24-Jan-2002 : Version 1 (DG);
040 * 05-Mar-2002 : Added Javadoc comments (DG);
041 * 26-Sep-2002 : Fixed errors reported by Checkstyle (DG);
042 * 19-Sep-2003 : Modified crosshair distance calculation (DG);
043 * 04-Dec-2003 : Crosshair anchor point now stored outside chart since it is
044 * dependent on the display target (DG);
045 * 25-Feb-2004 : Replaced CrosshairInfo --> CrosshairState (DG);
046 * ------------- JFREECHART 1.0.x ------------------------------------------
047 * 13-Oct-2006 : Fixed initialisation of CrosshairState - see bug report
048 * 1565168 (DG);
049 * 06-Feb-2007 : Added new fields and methods to fix bug 1086307 (DG);
050 *
051 */
052
053 package org.jfree.chart.plot;
054
055 import java.awt.geom.Point2D;
056
057 /**
058 * Maintains state information about crosshairs on a plot between successive
059 * calls to the renderer's draw method. This class is used internally by
060 * JFreeChart - it is not intended for external use.
061 */
062 public class CrosshairState {
063
064 /**
065 * A flag that controls whether the distance is calculated in data space
066 * or Java2D space.
067 */
068 private boolean calculateDistanceInDataSpace = false;
069
070 /** The x-value (in data space) for the anchor point. */
071 private double anchorX;
072
073 /** The y-value (in data space) for the anchor point. */
074 private double anchorY;
075
076 /** The anchor point in Java2D space - if null, don't update crosshair. */
077 private Point2D anchor;
078
079 /** The x-value for the current crosshair point. */
080 private double crosshairX;
081
082 /** The y-value for the current crosshair point. */
083 private double crosshairY;
084
085 /**
086 * The index of the domain axis that the crosshair x-value is measured
087 * against.
088 *
089 * @since 1.0.4
090 */
091 private int domainAxisIndex;
092
093 /**
094 * The index of the range axis that the crosshair y-value is measured
095 * against.
096 *
097 * @since 1.0.4
098 */
099 private int rangeAxisIndex;
100
101 /**
102 * The smallest distance (so far) between the anchor point and a data point.
103 */
104 private double distance;
105
106 /**
107 * Creates a new <code>CrosshairState</code> instance that calculates
108 * distance in Java2D space.
109 */
110 public CrosshairState() {
111 this(false);
112 }
113
114 /**
115 * Creates a new <code>CrosshairState</code> instance.
116 *
117 * @param calculateDistanceInDataSpace a flag that controls whether the
118 * distance is calculated in data
119 * space or Java2D space.
120 */
121 public CrosshairState(boolean calculateDistanceInDataSpace) {
122 this.calculateDistanceInDataSpace = calculateDistanceInDataSpace;
123 }
124
125 /**
126 * Returns the distance between the anchor point and the current crosshair
127 * point.
128 *
129 * @return The distance.
130 *
131 * @see #setCrosshairDistance(double)
132 * @since 1.0.3
133 */
134 public double getCrosshairDistance() {
135 return this.distance;
136 }
137
138 /**
139 * Sets the distance between the anchor point and the current crosshair
140 * point. As each data point is processed, its distance to the anchor
141 * point is compared with this value and, if it is closer, the data point
142 * becomes the new crosshair point.
143 *
144 * @param distance the distance.
145 *
146 * @see #getCrosshairDistance()
147 */
148 public void setCrosshairDistance(double distance) {
149 this.distance = distance;
150 }
151
152 /**
153 * Evaluates a data point and if it is the closest to the anchor point it
154 * becomes the new crosshair point.
155 * <P>
156 * To understand this method, you need to know the context in which it will
157 * be called. An instance of this class is passed to an
158 * {@link org.jfree.chart.renderer.xy.XYItemRenderer} as
159 * each data point is plotted. As the point is plotted, it is passed to
160 * this method to see if it should be the new crosshair point.
161 *
162 * @param x x coordinate (measured against the domain axis).
163 * @param y y coordinate (measured against the range axis).
164 * @param transX x translated into Java2D space.
165 * @param transY y translated into Java2D space.
166 * @param orientation the plot orientation.
167 *
168 * @deprecated Use {@link #updateCrosshairPoint(double, double, int, int,
169 * double, double, PlotOrientation)}. See bug report 1086307.
170 */
171 public void updateCrosshairPoint(double x, double y,
172 double transX, double transY,
173 PlotOrientation orientation) {
174 updateCrosshairPoint(x, y, 0, 0, transX, transY, orientation);
175 }
176
177 /**
178 * Evaluates a data point and if it is the closest to the anchor point it
179 * becomes the new crosshair point.
180 * <P>
181 * To understand this method, you need to know the context in which it will
182 * be called. An instance of this class is passed to an
183 * {@link org.jfree.chart.renderer.xy.XYItemRenderer} as
184 * each data point is plotted. As the point is plotted, it is passed to
185 * this method to see if it should be the new crosshair point.
186 *
187 * @param x x coordinate (measured against the domain axis).
188 * @param y y coordinate (measured against the range axis).
189 * @param domainAxisIndex the index of the domain axis for this point.
190 * @param rangeAxisIndex the index of the range axis for this point.
191 * @param transX x translated into Java2D space.
192 * @param transY y translated into Java2D space.
193 * @param orientation the plot orientation.
194 *
195 * @since 1.0.4
196 */
197 public void updateCrosshairPoint(double x, double y, int domainAxisIndex,
198 int rangeAxisIndex, double transX, double transY,
199 PlotOrientation orientation) {
200
201 if (this.anchor != null) {
202 double d = 0.0;
203 if (this.calculateDistanceInDataSpace) {
204 d = (x - this.anchorX) * (x - this.anchorX)
205 + (y - this.anchorY) * (y - this.anchorY);
206 }
207 else {
208 double xx = this.anchor.getX();
209 double yy = this.anchor.getY();
210 if (orientation == PlotOrientation.HORIZONTAL) {
211 double temp = yy;
212 yy = xx;
213 xx = temp;
214 }
215 d = (transX - xx) * (transX - xx)
216 + (transY - yy) * (transY - yy);
217 }
218
219 if (d < this.distance) {
220 this.crosshairX = x;
221 this.crosshairY = y;
222 this.domainAxisIndex = domainAxisIndex;
223 this.rangeAxisIndex = rangeAxisIndex;
224 this.distance = d;
225 }
226 }
227
228 }
229
230 /**
231 * Evaluates an x-value and if it is the closest to the anchor x-value it
232 * becomes the new crosshair value.
233 * <P>
234 * Used in cases where only the x-axis is numerical.
235 *
236 * @param candidateX x position of the candidate for the new crosshair
237 * point.
238 *
239 * @deprecated Use {@link #updateCrosshairX(double, int)}. See bug report
240 * 1086307.
241 */
242 public void updateCrosshairX(double candidateX) {
243 updateCrosshairX(candidateX, 0);
244 }
245
246 /**
247 * Evaluates an x-value and if it is the closest to the anchor x-value it
248 * becomes the new crosshair value.
249 * <P>
250 * Used in cases where only the x-axis is numerical.
251 *
252 * @param candidateX x position of the candidate for the new crosshair
253 * point.
254 * @param domainAxisIndex the index of the domain axis for this x-value.
255 *
256 * @since 1.0.4
257 */
258 public void updateCrosshairX(double candidateX, int domainAxisIndex) {
259
260 double d = Math.abs(candidateX - this.anchorX);
261 if (d < this.distance) {
262 this.crosshairX = candidateX;
263 this.domainAxisIndex = domainAxisIndex;
264 this.distance = d;
265 }
266
267 }
268
269 /**
270 * Evaluates a y-value and if it is the closest to the anchor y-value it
271 * becomes the new crosshair value.
272 * <P>
273 * Used in cases where only the y-axis is numerical.
274 *
275 * @param candidateY y position of the candidate for the new crosshair
276 * point.
277 *
278 * @deprecated Use {@link #updateCrosshairY(double, int)}. See bug report
279 * 1086307.
280 */
281 public void updateCrosshairY(double candidateY) {
282 updateCrosshairY(candidateY, 0);
283 }
284
285 /**
286 * Evaluates a y-value and if it is the closest to the anchor y-value it
287 * becomes the new crosshair value.
288 * <P>
289 * Used in cases where only the y-axis is numerical.
290 *
291 * @param candidateY y position of the candidate for the new crosshair
292 * point.
293 * @param rangeAxisIndex the index of the range axis for this y-value.
294 *
295 * @since 1.0.4
296 */
297 public void updateCrosshairY(double candidateY, int rangeAxisIndex) {
298 double d = Math.abs(candidateY - this.anchorY);
299 if (d < this.distance) {
300 this.crosshairY = candidateY;
301 this.rangeAxisIndex = rangeAxisIndex;
302 this.distance = d;
303 }
304
305 }
306
307 /**
308 * Returns the anchor point.
309 *
310 * @return The anchor point.
311 *
312 * @see #setAnchor(Point2D)
313 * @since 1.0.3
314 */
315 public Point2D getAnchor() {
316 return this.anchor;
317 }
318
319 /**
320 * Sets the anchor point. This is usually the mouse click point in a chart
321 * panel, and the crosshair point will often be the data item that is
322 * closest to the anchor point.
323 * <br><br>
324 * Note that the x and y coordinates (in data space) are not updated by
325 * this method - the caller is responsible for ensuring that this happens
326 * in sync.
327 *
328 * @param anchor the anchor point (<code>null</code> permitted).
329 *
330 * @see #getAnchor()
331 */
332 public void setAnchor(Point2D anchor) {
333 this.anchor = anchor;
334 }
335
336 /**
337 * Returns the x-coordinate (in data space) for the anchor point.
338 *
339 * @return The x-coordinate of the anchor point.
340 *
341 * @since 1.0.3
342 */
343 public double getAnchorX() {
344 return this.anchorX;
345 }
346
347 /**
348 * Sets the x-coordinate (in data space) for the anchor point. Note that
349 * this does NOT update the anchor itself - the caller is responsible for
350 * ensuring this is done in sync.
351 *
352 * @param x the x-coordinate.
353 *
354 * @since 1.0.3
355 */
356 public void setAnchorX(double x) {
357 this.anchorX = x;
358 }
359
360 /**
361 * Returns the y-coordinate (in data space) for the anchor point.
362 *
363 * @return The y-coordinate of teh anchor point.
364 *
365 * @since 1.0.3
366 */
367 public double getAnchorY() {
368 return this.anchorY;
369 }
370
371 /**
372 * Sets the y-coordinate (in data space) for the anchor point. Note that
373 * this does NOT update the anchor itself - the caller is responsible for
374 * ensuring this is done in sync.
375 *
376 * @param y the y-coordinate.
377 *
378 * @since 1.0.3
379 */
380 public void setAnchorY(double y) {
381 this.anchorY = y;
382 }
383
384 /**
385 * Get the x-value for the crosshair point.
386 *
387 * @return The x position of the crosshair point.
388 *
389 * @see #setCrosshairX(double)
390 */
391 public double getCrosshairX() {
392 return this.crosshairX;
393 }
394
395 /**
396 * Sets the x coordinate for the crosshair. This is the coordinate in data
397 * space measured against the domain axis.
398 *
399 * @param x the coordinate.
400 *
401 * @see #getCrosshairX()
402 * @see #setCrosshairY(double)
403 * @see #updateCrosshairPoint(double, double, double, double,
404 * PlotOrientation)
405 */
406 public void setCrosshairX(double x) {
407 this.crosshairX = x;
408 }
409
410 /**
411 * Get the y-value for the crosshair point. This is the coordinate in data
412 * space measured against the range axis.
413 *
414 * @return The y position of the crosshair point.
415 *
416 * @see #setCrosshairY(double)
417 */
418 public double getCrosshairY() {
419 return this.crosshairY;
420 }
421
422 /**
423 * Sets the y coordinate for the crosshair.
424 *
425 * @param y the y coordinate.
426 *
427 * @see #getCrosshairY()
428 * @see #setCrosshairX(double)
429 * @see #updateCrosshairPoint(double, double, double, double,
430 * PlotOrientation)
431 */
432 public void setCrosshairY(double y) {
433 this.crosshairY = y;
434 }
435
436 /**
437 * Returns the domain axis index for the crosshair x-value.
438 *
439 * @return The domain axis index.
440 *
441 * @since 1.0.4
442 */
443 public int getDomainAxisIndex() {
444 return this.domainAxisIndex;
445 }
446
447 /**
448 * Returns the range axis index for the crosshair y-value.
449 *
450 * @return The range axis index.
451 *
452 * @since 1.0.4
453 */
454 public int getRangeAxisIndex() {
455 return this.rangeAxisIndex;
456 }
457 }