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 * DialValueIndicator.java
029 * -----------------------
030 * (C) Copyright 2006-2008, by Object Refinery Limited.
031 *
032 * Original Author: David Gilbert (for Object Refinery Limited);
033 * Contributor(s): -;
034 *
035 * Changes
036 * -------
037 * 03-Nov-2006 : Version 1 (DG);
038 * 17-Oct-2007 : Updated equals() (DG);
039 * 24-Oct-2007 : Added default constructor and missing event notification (DG);
040 *
041 */
042
043 package org.jfree.chart.plot.dial;
044
045 import java.awt.BasicStroke;
046 import java.awt.Color;
047 import java.awt.Font;
048 import java.awt.FontMetrics;
049 import java.awt.Graphics2D;
050 import java.awt.Paint;
051 import java.awt.Stroke;
052 import java.awt.geom.Arc2D;
053 import java.awt.geom.Point2D;
054 import java.awt.geom.Rectangle2D;
055 import java.io.IOException;
056 import java.io.ObjectInputStream;
057 import java.io.ObjectOutputStream;
058 import java.io.Serializable;
059 import java.text.DecimalFormat;
060 import java.text.NumberFormat;
061
062 import org.jfree.chart.HashUtilities;
063 import org.jfree.io.SerialUtilities;
064 import org.jfree.text.TextUtilities;
065 import org.jfree.ui.RectangleAnchor;
066 import org.jfree.ui.RectangleInsets;
067 import org.jfree.ui.Size2D;
068 import org.jfree.ui.TextAnchor;
069 import org.jfree.util.PaintUtilities;
070 import org.jfree.util.PublicCloneable;
071
072 /**
073 * A value indicator for a {@link DialPlot}.
074 *
075 * @since 1.0.7
076 */
077 public class DialValueIndicator extends AbstractDialLayer implements DialLayer,
078 Cloneable, PublicCloneable, Serializable {
079
080 /** For serialization. */
081 static final long serialVersionUID = 803094354130942585L;
082
083 /** The dataset index. */
084 private int datasetIndex;
085
086 /** The angle that defines the anchor point. */
087 private double angle;
088
089 /** The radius that defines the anchor point. */
090 private double radius;
091
092 /** The frame anchor. */
093 private RectangleAnchor frameAnchor;
094
095 /** The template value. */
096 private Number templateValue;
097
098 /** The formatter. */
099 private NumberFormat formatter;
100
101 /** The font. */
102 private Font font;
103
104 /** The paint. */
105 private transient Paint paint;
106
107 /** The background paint. */
108 private transient Paint backgroundPaint;
109
110 /** The outline stroke. */
111 private transient Stroke outlineStroke;
112
113 /** The outline paint. */
114 private transient Paint outlinePaint;
115
116 /** The insets. */
117 private RectangleInsets insets;
118
119 /** The value anchor. */
120 private RectangleAnchor valueAnchor;
121
122 /** The text anchor for displaying the value. */
123 private TextAnchor textAnchor;
124
125 /**
126 * Creates a new instance of <code>DialValueIndicator</code>.
127 */
128 public DialValueIndicator() {
129 this(0);
130 }
131
132 /**
133 * Creates a new instance of <code>DialValueIndicator</code>.
134 *
135 * @param datasetIndex the dataset index.
136 */
137 public DialValueIndicator(int datasetIndex) {
138 this.datasetIndex = datasetIndex;
139 this.angle = -90.0;
140 this.radius = 0.3;
141 this.frameAnchor = RectangleAnchor.CENTER;
142 this.templateValue = new Double(100.0);
143 this.formatter = new DecimalFormat("0.0");
144 this.font = new Font("Dialog", Font.BOLD, 14);
145 this.paint = Color.black;
146 this.backgroundPaint = Color.white;
147 this.outlineStroke = new BasicStroke(1.0f);
148 this.outlinePaint = Color.blue;
149 this.insets = new RectangleInsets(4, 4, 4, 4);
150 this.valueAnchor = RectangleAnchor.RIGHT;
151 this.textAnchor = TextAnchor.CENTER_RIGHT;
152 }
153
154 /**
155 * Returns the index of the dataset from which this indicator fetches its
156 * current value.
157 *
158 * @return The dataset index.
159 *
160 * @see #setDatasetIndex(int)
161 */
162 public int getDatasetIndex() {
163 return this.datasetIndex;
164 }
165
166 /**
167 * Sets the dataset index and sends a {@link DialLayerChangeEvent} to all
168 * registered listeners.
169 *
170 * @param index the index.
171 *
172 * @see #getDatasetIndex()
173 */
174 public void setDatasetIndex(int index) {
175 this.datasetIndex = index;
176 notifyListeners(new DialLayerChangeEvent(this));
177 }
178
179 /**
180 * Returns the angle for the anchor point. The angle is specified in
181 * degrees using the same orientation as Java's <code>Arc2D</code> class.
182 *
183 * @return The angle (in degrees).
184 *
185 * @see #setAngle(double)
186 */
187 public double getAngle() {
188 return this.angle;
189 }
190
191 /**
192 * Sets the angle for the anchor point and sends a
193 * {@link DialLayerChangeEvent} to all registered listeners.
194 *
195 * @param angle the angle (in degrees).
196 *
197 * @see #getAngle()
198 */
199 public void setAngle(double angle) {
200 this.angle = angle;
201 notifyListeners(new DialLayerChangeEvent(this));
202 }
203
204 /**
205 * Returns the radius.
206 *
207 * @return The radius.
208 *
209 * @see #setRadius(double)
210 */
211 public double getRadius() {
212 return this.radius;
213 }
214
215 /**
216 * Sets the radius and sends a {@link DialLayerChangeEvent} to all
217 * registered listeners.
218 *
219 * @param radius the radius.
220 *
221 * @see #getRadius()
222 */
223 public void setRadius(double radius) {
224 this.radius = radius;
225 notifyListeners(new DialLayerChangeEvent(this));
226 }
227
228 /**
229 * Returns the frame anchor.
230 *
231 * @return The frame anchor.
232 *
233 * @see #setFrameAnchor(RectangleAnchor)
234 */
235 public RectangleAnchor getFrameAnchor() {
236 return this.frameAnchor;
237 }
238
239 /**
240 * Sets the frame anchor and sends a {@link DialLayerChangeEvent} to all
241 * registered listeners.
242 *
243 * @param anchor the anchor (<code>null</code> not permitted).
244 *
245 * @see #getFrameAnchor()
246 */
247 public void setFrameAnchor(RectangleAnchor anchor) {
248 if (anchor == null) {
249 throw new IllegalArgumentException("Null 'anchor' argument.");
250 }
251 this.frameAnchor = anchor;
252 notifyListeners(new DialLayerChangeEvent(this));
253 }
254
255 /**
256 * Returns the template value.
257 *
258 * @return The template value (never <code>null</code>).
259 *
260 * @see #setTemplateValue(Number)
261 */
262 public Number getTemplateValue() {
263 return this.templateValue;
264 }
265
266 /**
267 * Sets the template value and sends a {@link DialLayerChangeEvent} to
268 * all registered listeners.
269 *
270 * @param value the value (<code>null</code> not permitted).
271 *
272 * @see #setTemplateValue(Number)
273 */
274 public void setTemplateValue(Number value) {
275 if (value == null) {
276 throw new IllegalArgumentException("Null 'value' argument.");
277 }
278 this.templateValue = value;
279 notifyListeners(new DialLayerChangeEvent(this));
280 }
281
282 /**
283 * Returns the formatter used to format the value.
284 *
285 * @return The formatter (never <code>null</code>).
286 *
287 * @see #setNumberFormat(NumberFormat)
288 */
289 public NumberFormat getNumberFormat() {
290 return this.formatter;
291 }
292
293 /**
294 * Sets the formatter used to format the value and sends a
295 * {@link DialLayerChangeEvent} to all registered listeners.
296 *
297 * @param formatter the formatter (<code>null</code> not permitted).
298 *
299 * @see #getNumberFormat()
300 */
301 public void setNumberFormat(NumberFormat formatter) {
302 if (formatter == null) {
303 throw new IllegalArgumentException("Null 'formatter' argument.");
304 }
305 this.formatter = formatter;
306 notifyListeners(new DialLayerChangeEvent(this));
307 }
308
309 /**
310 * Returns the font.
311 *
312 * @return The font (never <code>null</code>).
313 *
314 * @see #getFont()
315 */
316 public Font getFont() {
317 return this.font;
318 }
319
320 /**
321 * Sets the font and sends a {@link DialLayerChangeEvent} to all registered
322 * listeners.
323 *
324 * @param font the font (<code>null</code> not permitted).
325 */
326 public void setFont(Font font) {
327 if (font == null) {
328 throw new IllegalArgumentException("Null 'font' argument.");
329 }
330 this.font = font;
331 notifyListeners(new DialLayerChangeEvent(this));
332 }
333
334 /**
335 * Returns the paint.
336 *
337 * @return The paint (never <code>null</code>).
338 *
339 * @see #setPaint(Paint)
340 */
341 public Paint getPaint() {
342 return this.paint;
343 }
344
345 /**
346 * Sets the paint and sends a {@link DialLayerChangeEvent} to all
347 * registered listeners.
348 *
349 * @param paint the paint (<code>null</code> not permitted).
350 *
351 * @see #getPaint()
352 */
353 public void setPaint(Paint paint) {
354 if (paint == null) {
355 throw new IllegalArgumentException("Null 'paint' argument.");
356 }
357 this.paint = paint;
358 notifyListeners(new DialLayerChangeEvent(this));
359 }
360
361 /**
362 * Returns the background paint.
363 *
364 * @return The background paint.
365 *
366 * @see #setBackgroundPaint(Paint)
367 */
368 public Paint getBackgroundPaint() {
369 return this.backgroundPaint;
370 }
371
372 /**
373 * Sets the background paint and sends a {@link DialLayerChangeEvent} to
374 * all registered listeners.
375 *
376 * @param paint the paint (<code>null</code> not permitted).
377 *
378 * @see #getBackgroundPaint()
379 */
380 public void setBackgroundPaint(Paint paint) {
381 if (paint == null) {
382 throw new IllegalArgumentException("Null 'paint' argument.");
383 }
384 this.backgroundPaint = paint;
385 notifyListeners(new DialLayerChangeEvent(this));
386 }
387
388 /**
389 * Returns the outline stroke.
390 *
391 * @return The outline stroke (never <code>null</code>).
392 *
393 * @see #setOutlineStroke(Stroke)
394 */
395 public Stroke getOutlineStroke() {
396 return this.outlineStroke;
397 }
398
399 /**
400 * Sets the outline stroke and sends a {@link DialLayerChangeEvent} to
401 * all registered listeners.
402 *
403 * @param stroke the stroke (<code>null</code> not permitted).
404 *
405 * @see #getOutlineStroke()
406 */
407 public void setOutlineStroke(Stroke stroke) {
408 if (stroke == null) {
409 throw new IllegalArgumentException("Null 'stroke' argument.");
410 }
411 this.outlineStroke = stroke;
412 notifyListeners(new DialLayerChangeEvent(this));
413 }
414
415 /**
416 * Returns the outline paint.
417 *
418 * @return The outline paint (never <code>null</code>).
419 *
420 * @see #setOutlinePaint(Paint)
421 */
422 public Paint getOutlinePaint() {
423 return this.outlinePaint;
424 }
425
426 /**
427 * Sets the outline paint and sends a {@link DialLayerChangeEvent} to all
428 * registered listeners.
429 *
430 * @param paint the paint (<code>null</code> not permitted).
431 *
432 * @see #getOutlinePaint()
433 */
434 public void setOutlinePaint(Paint paint) {
435 if (paint == null) {
436 throw new IllegalArgumentException("Null 'paint' argument.");
437 }
438 this.outlinePaint = paint;
439 notifyListeners(new DialLayerChangeEvent(this));
440 }
441
442 /**
443 * Returns the insets.
444 *
445 * @return The insets (never <code>null</code>).
446 *
447 * @see #setInsets(RectangleInsets)
448 */
449 public RectangleInsets getInsets() {
450 return this.insets;
451 }
452
453 /**
454 * Sets the insets and sends a {@link DialLayerChangeEvent} to all
455 * registered listeners.
456 *
457 * @param insets the insets (<code>null</code> not permitted).
458 *
459 * @see #getInsets()
460 */
461 public void setInsets(RectangleInsets insets) {
462 if (insets == null) {
463 throw new IllegalArgumentException("Null 'insets' argument.");
464 }
465 this.insets = insets;
466 notifyListeners(new DialLayerChangeEvent(this));
467 }
468
469 /**
470 * Returns the value anchor.
471 *
472 * @return The value anchor (never <code>null</code>).
473 *
474 * @see #setValueAnchor(RectangleAnchor)
475 */
476 public RectangleAnchor getValueAnchor() {
477 return this.valueAnchor;
478 }
479
480 /**
481 * Sets the value anchor and sends a {@link DialLayerChangeEvent} to all
482 * registered listeners.
483 *
484 * @param anchor the anchor (<code>null</code> not permitted).
485 *
486 * @see #getValueAnchor()
487 */
488 public void setValueAnchor(RectangleAnchor anchor) {
489 if (anchor == null) {
490 throw new IllegalArgumentException("Null 'anchor' argument.");
491 }
492 this.valueAnchor = anchor;
493 notifyListeners(new DialLayerChangeEvent(this));
494 }
495
496 /**
497 * Returns the text anchor.
498 *
499 * @return The text anchor (never <code>null</code>).
500 *
501 * @see #setTextAnchor(TextAnchor)
502 */
503 public TextAnchor getTextAnchor() {
504 return this.textAnchor;
505 }
506
507 /**
508 * Sets the text anchor and sends a {@link DialLayerChangeEvent} to all
509 * registered listeners.
510 *
511 * @param anchor the anchor (<code>null</code> not permitted).
512 *
513 * @see #getTextAnchor()
514 */
515 public void setTextAnchor(TextAnchor anchor) {
516 if (anchor == null) {
517 throw new IllegalArgumentException("Null 'anchor' argument.");
518 }
519 this.textAnchor = anchor;
520 notifyListeners(new DialLayerChangeEvent(this));
521 }
522
523 /**
524 * Returns <code>true</code> to indicate that this layer should be
525 * clipped within the dial window.
526 *
527 * @return <code>true</code>.
528 */
529 public boolean isClippedToWindow() {
530 return true;
531 }
532
533 /**
534 * Draws the background to the specified graphics device. If the dial
535 * frame specifies a window, the clipping region will already have been
536 * set to this window before this method is called.
537 *
538 * @param g2 the graphics device (<code>null</code> not permitted).
539 * @param plot the plot (ignored here).
540 * @param frame the dial frame (ignored here).
541 * @param view the view rectangle (<code>null</code> not permitted).
542 */
543 public void draw(Graphics2D g2, DialPlot plot, Rectangle2D frame,
544 Rectangle2D view) {
545
546 // work out the anchor point
547 Rectangle2D f = DialPlot.rectangleByRadius(frame, this.radius,
548 this.radius);
549 Arc2D arc = new Arc2D.Double(f, this.angle, 0.0, Arc2D.OPEN);
550 Point2D pt = arc.getStartPoint();
551
552 // calculate the bounds of the template value
553 FontMetrics fm = g2.getFontMetrics(this.font);
554 String s = this.formatter.format(this.templateValue);
555 Rectangle2D tb = TextUtilities.getTextBounds(s, g2, fm);
556
557 // align this rectangle to the frameAnchor
558 Rectangle2D bounds = RectangleAnchor.createRectangle(new Size2D(
559 tb.getWidth(), tb.getHeight()), pt.getX(), pt.getY(),
560 this.frameAnchor);
561
562 // add the insets
563 Rectangle2D fb = this.insets.createOutsetRectangle(bounds);
564
565 // draw the background
566 g2.setPaint(this.backgroundPaint);
567 g2.fill(fb);
568
569 // draw the border
570 g2.setStroke(this.outlineStroke);
571 g2.setPaint(this.outlinePaint);
572 g2.draw(fb);
573
574
575 // now find the text anchor point
576 double value = plot.getValue(this.datasetIndex);
577 String valueStr = this.formatter.format(value);
578 Point2D pt2 = RectangleAnchor.coordinates(bounds, this.valueAnchor);
579 g2.setPaint(this.paint);
580 g2.setFont(this.font);
581 TextUtilities.drawAlignedString(valueStr, g2, (float) pt2.getX(),
582 (float) pt2.getY(), this.textAnchor);
583
584 }
585
586 /**
587 * Tests this instance for equality with an arbitrary object.
588 *
589 * @param obj the object (<code>null</code> permitted).
590 *
591 * @return A boolean.
592 */
593 public boolean equals(Object obj) {
594 if (obj == this) {
595 return true;
596 }
597 if (!(obj instanceof DialValueIndicator)) {
598 return false;
599 }
600 DialValueIndicator that = (DialValueIndicator) obj;
601 if (this.datasetIndex != that.datasetIndex) {
602 return false;
603 }
604 if (this.angle != that.angle) {
605 return false;
606 }
607 if (this.radius != that.radius) {
608 return false;
609 }
610 if (!this.frameAnchor.equals(that.frameAnchor)) {
611 return false;
612 }
613 if (!this.templateValue.equals(that.templateValue)) {
614 return false;
615 }
616 if (!this.font.equals(that.font)) {
617 return false;
618 }
619 if (!PaintUtilities.equal(this.paint, that.paint)) {
620 return false;
621 }
622 if (!PaintUtilities.equal(this.backgroundPaint, that.backgroundPaint)) {
623 return false;
624 }
625 if (!this.outlineStroke.equals(that.outlineStroke)) {
626 return false;
627 }
628 if (!PaintUtilities.equal(this.outlinePaint, that.outlinePaint)) {
629 return false;
630 }
631 if (!this.insets.equals(that.insets)) {
632 return false;
633 }
634 if (!this.valueAnchor.equals(that.valueAnchor)) {
635 return false;
636 }
637 if (!this.textAnchor.equals(that.textAnchor)) {
638 return false;
639 }
640
641 return super.equals(obj);
642 }
643
644 /**
645 * Returns a hash code for this instance.
646 *
647 * @return The hash code.
648 */
649 public int hashCode() {
650 int result = 193;
651 result = 37 * result + HashUtilities.hashCodeForPaint(this.paint);
652 result = 37 * result + HashUtilities.hashCodeForPaint(
653 this.backgroundPaint);
654 result = 37 * result + HashUtilities.hashCodeForPaint(
655 this.outlinePaint);
656 result = 37 * result + this.outlineStroke.hashCode();
657 return result;
658 }
659
660 /**
661 * Returns a clone of this instance.
662 *
663 * @return The clone.
664 *
665 * @throws CloneNotSupportedException if some attribute of this instance
666 * cannot be cloned.
667 */
668 public Object clone() throws CloneNotSupportedException {
669 return super.clone();
670 }
671
672 /**
673 * Provides serialization support.
674 *
675 * @param stream the output stream.
676 *
677 * @throws IOException if there is an I/O error.
678 */
679 private void writeObject(ObjectOutputStream stream) throws IOException {
680 stream.defaultWriteObject();
681 SerialUtilities.writePaint(this.paint, stream);
682 SerialUtilities.writePaint(this.backgroundPaint, stream);
683 SerialUtilities.writePaint(this.outlinePaint, stream);
684 SerialUtilities.writeStroke(this.outlineStroke, stream);
685 }
686
687 /**
688 * Provides serialization support.
689 *
690 * @param stream the input stream.
691 *
692 * @throws IOException if there is an I/O error.
693 * @throws ClassNotFoundException if there is a classpath problem.
694 */
695 private void readObject(ObjectInputStream stream)
696 throws IOException, ClassNotFoundException {
697 stream.defaultReadObject();
698 this.paint = SerialUtilities.readPaint(stream);
699 this.backgroundPaint = SerialUtilities.readPaint(stream);
700 this.outlinePaint = SerialUtilities.readPaint(stream);
701 this.outlineStroke = SerialUtilities.readStroke(stream);
702 }
703
704 }