Java > Open Source Codes > org > jfree > chart > renderer > xy > CandlestickRenderer


1 /* ===========================================================
2  * JFreeChart : a free chart library for the Java(tm) platform
3  * ===========================================================
4  *
5  * (C) Copyright 2000-2006, by Object Refinery Limited and Contributors.
6  *
7  * Project Info: http://www.jfree.org/jfreechart/index.html
8  *
9  * This library is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU Lesser General Public License as published by
11  * the Free Software Foundation; either version 2.1 of the License, or
12  * (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful, but
15  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
17  * License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
22  * USA.
23  *
24  * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
25  * in the United States and other countries.]
26  *
27  * ------------------------
28  * CandlestickRenderer.java
29  * ------------------------
30  * (C) Copyright 2001-2006, by Object Refinery Limited.
31  *
32  * Original Authors: David Gilbert (for Object Refinery Limited);
33  * Sylvain Vieujot;
34  * Contributor(s): Richard Atkinson;
35  * Christian W. Zuckschwerdt;
36  * Jerome Fisher;
37  *
38  * $Id: CandlestickRenderer.java,v 1.7.2.3 2006/08/17 09:21:25 mungady Exp $
39  *
40  * Changes
41  * -------
42  * 13-Dec-2001 : Version 1. Based on code in the (now redundant)
43  * CandlestickPlot class, written by Sylvain Vieujot (DG);
44  * 23-Jan-2002 : Added DrawInfo parameter to drawItem() method (DG);
45  * 28-Mar-2002 : Added a property change listener mechanism so that renderers
46  * no longer need to be immutable. Added properties for up and
47  * down colors (DG);
48  * 04-Apr-2002 : Updated with new automatic width calculation and optional
49  * volume display, contributed by Sylvain Vieujot (DG);
50  * 09-Apr-2002 : Removed translatedRangeZero from the drawItem() method, and
51  * changed the return type of the drawItem method to void,
52  * reflecting a change in the XYItemRenderer interface. Added
53  * tooltip code to drawItem() method (DG);
54  * 25-Jun-2002 : Removed redundant code (DG);
55  * 05-Aug-2002 : Small modification to drawItem method to support URLs for HTML
56  * image maps (RA);
57  * 19-Sep-2002 : Fixed errors reported by Checkstyle (DG);
58  * 25-Mar-2003 : Implemented Serializable (DG);
59  * 01-May-2003 : Modified drawItem() method signature (DG);
60  * 30-Jun-2003 : Added support for PlotOrientation (for completeness, this
61  * renderer is unlikely to be used with a HORIZONTAL
62  * orientation) (DG);
63  * 30-Jul-2003 : Modified entity constructor (CZ);
64  * 20-Aug-2003 : Implemented Cloneable and PublicCloneable (DG);
65  * 29-Aug-2003 : Moved maxVolume calculation to initialise method (see bug
66  * report 796619) (DG);
67  * 02-Sep-2003 : Added maxCandleWidthInMilliseconds as workaround for bug
68  * 796621 (DG);
69  * 08-Sep-2003 : Changed ValueAxis API (DG);
70  * 16-Sep-2003 : Changed ChartRenderingInfo --> PlotRenderingInfo (DG);
71  * 13-Oct-2003 : Applied patch from Jerome Fisher to improve auto width
72  * calculations (DG);
73  * 23-Dec-2003 : Fixed bug where up and down paint are used incorrectly (DG);
74  * 25-Feb-2004 : Replaced CrosshairInfo with CrosshairState (DG);
75  * 15-Jul-2004 : Switched getX() with getXValue() and getY() with
76  * getYValue() (DG);
77  * ------------- JFREECHART 1.0.0 ---------------------------------------------
78  * 06-Jul-2006 : Swapped calls to getX() --> getXValue(), and the same for the
79  * other data values (DG);
80  * 17-Aug-2006 : Corrections to the equals() method (DG);
81  *
82  */
83
84 package org.jfree.chart.renderer.xy;
85
86 import java.awt.AlphaComposite ;
87 import java.awt.Color ;
88 import java.awt.Composite ;
89 import java.awt.Graphics2D ;
90 import java.awt.Paint ;
91 import java.awt.Shape ;
92 import java.awt.Stroke ;
93 import java.awt.geom.Line2D ;
94 import java.awt.geom.Rectangle2D ;
95 import java.io.IOException ;
96 import java.io.ObjectInputStream ;
97 import java.io.ObjectOutputStream ;
98 import java.io.Serializable ;
99
100 import org.jfree.chart.axis.ValueAxis;
101 import org.jfree.chart.entity.EntityCollection;
102 import org.jfree.chart.entity.XYItemEntity;
103 import org.jfree.chart.event.RendererChangeEvent;
104 import org.jfree.chart.labels.HighLowItemLabelGenerator;
105 import org.jfree.chart.labels.XYToolTipGenerator;
106 import org.jfree.chart.plot.CrosshairState;
107 import org.jfree.chart.plot.PlotOrientation;
108 import org.jfree.chart.plot.PlotRenderingInfo;
109 import org.jfree.chart.plot.XYPlot;
110 import org.jfree.data.xy.IntervalXYDataset;
111 import org.jfree.data.xy.OHLCDataset;
112 import org.jfree.data.xy.XYDataset;
113 import org.jfree.io.SerialUtilities;
114 import org.jfree.ui.RectangleEdge;
115 import org.jfree.util.PaintUtilities;
116 import org.jfree.util.PublicCloneable;
117
118 /**
119  * A renderer that draws candlesticks on an {@link XYPlot} (requires a
120  * {@link OHLCDataset}).
121  * <P>
122  * This renderer does not include code to calculate the crosshair point for the
123  * plot.
124  */
125 public class CandlestickRenderer extends AbstractXYItemRenderer
126                                  implements XYItemRenderer,
127                                             Cloneable ,
128                                             PublicCloneable,
129                                             Serializable {
130             
131     /** For serialization. */
132     private static final long serialVersionUID = 50390395841817121L;
133     
134     /** The average width method. */
135     public static final int WIDTHMETHOD_AVERAGE = 0;
136     
137     /** The smallest width method. */
138     public static final int WIDTHMETHOD_SMALLEST = 1;
139     
140     /** The interval data method. */
141     public static final int WIDTHMETHOD_INTERVALDATA = 2;
142
143     /** The method of automatically calculating the candle width. */
144     private int autoWidthMethod = WIDTHMETHOD_AVERAGE;
145
146     /**
147      * The number (generally between 0.0 and 1.0) by which the available space
148      * automatically calculated for the candles will be multiplied to determine
149      * the actual width to use.
150      */
151     private double autoWidthFactor = 4.5 / 7;
152
153     /** The minimum gap between one candle and the next */
154     private double autoWidthGap = 0.0;
155
156     /** The candle width. */
157     private double candleWidth;
158     
159     /** The maximum candlewidth in milliseconds. */
160     private double maxCandleWidthInMilliseconds = 1000.0 * 60.0 * 60.0 * 20.0;
161     
162     /** Temporary storage for the maximum candle width. */
163     private double maxCandleWidth;
164
165     /**
166      * The paint used to fill the candle when the price moved up from open to
167      * close.
168      */
169     private transient Paint upPaint;
170
171     /**
172      * The paint used to fill the candle when the price moved down from open
173      * to close.
174      */
175     private transient Paint downPaint;
176
177     /** A flag controlling whether or not volume bars are drawn on the chart. */
178     private boolean drawVolume;
179     
180     /** Temporary storage for the maximum volume. */
181     private transient double maxVolume;
182
183     /**
184      * Creates a new renderer for candlestick charts.
185      */
186     public CandlestickRenderer() {
187         this(-1.0);
188     }
189
190     /**
191      * Creates a new renderer for candlestick charts.
192      * <P>
193      * Use -1 for the candle width if you prefer the width to be calculated
194      * automatically.
195      *
196      * @param candleWidth The candle width.
197      */
198     public CandlestickRenderer(double candleWidth) {
199         this(candleWidth, true, new HighLowItemLabelGenerator());
200     }
201
202     /**
203      * Creates a new renderer for candlestick charts.
204      * <P>
205      * Use -1 for the candle width if you prefer the width to be calculated
206      * automatically.
207      *
208      * @param candleWidth the candle width.
209      * @param drawVolume a flag indicating whether or not volume bars should
210      * be drawn.
211      * @param toolTipGenerator the tool tip generator. <code>null</code> is
212      * none.
213      */
214     public CandlestickRenderer(double candleWidth, boolean drawVolume,
215                                XYToolTipGenerator toolTipGenerator) {
216
217         super();
218         setToolTipGenerator(toolTipGenerator);
219         this.candleWidth = candleWidth;
220         this.drawVolume = drawVolume;
221         this.upPaint = Color.green;
222         this.downPaint = Color.red;
223
224     }
225
226     /**
227      * Returns the width of each candle.
228      *
229      * @return The candle width.
230      *
231      * @see #setCandleWidth(double)
232      */
233     public double getCandleWidth() {
234         return this.candleWidth;
235     }
236
237     /**
238      * Sets the candle width.
239      * <P>
240      * If you set the width to a negative value, the renderer will calculate
241      * the candle width automatically based on the space available on the chart.
242      *
243      * @param width The width.
244      * @see #setAutoWidthMethod(int)
245      * @see #setAutoWidthGap(double)
246      * @see #setAutoWidthFactor(double)
247      * @see #setMaxCandleWidthInMilliseconds(double)
248      */
249     public void setCandleWidth(double width) {
250         if (width != this.candleWidth) {
251             this.candleWidth = width;
252             notifyListeners(new RendererChangeEvent(this));
253         }
254     }
255
256     /**
257      * Returns the maximum width (in milliseconds) of each candle.
258      *
259      * @return The maximum candle width in milliseconds.
260      */
261     public double getMaxCandleWidthInMilliseconds() {
262         return this.maxCandleWidthInMilliseconds;
263     }
264
265     /**
266      * Sets the maximum candle width (in milliseconds).
267      *
268      * @param millis The maximum width.
269      * @see #setCandleWidth(double)
270      * @see #setAutoWidthMethod(int)
271      * @see #setAutoWidthGap(double)
272      * @see #setAutoWidthFactor(double)
273      */
274     public void setMaxCandleWidthInMilliseconds(double millis) {
275         this.maxCandleWidthInMilliseconds = millis;
276         notifyListeners(new RendererChangeEvent(this));
277     }
278
279     /**
280      * Returns the method of automatically calculating the candle width.
281      *
282      * @return The method of automatically calculating the candle width.
283      */
284     public int getAutoWidthMethod() {
285         return this.autoWidthMethod;
286     }
287
288     /**
289      * Sets the method of automatically calculating the candle width.
290      * <p>
291      * <code>WIDTHMETHOD_AVERAGE</code>: Divides the entire display (ignoring
292      * scale factor) by the number of items, and uses this as the available
293      * width.<br>
294      * <code>WIDTHMETHOD_SMALLEST</code>: Checks the interval between each
295      * item, and uses the smallest as the available width.<br>
296      * <code>WIDTHMETHOD_INTERVALDATA</code>: Assumes that the dataset supports
297      * the IntervalXYDataset interface, and uses the startXValue - endXValue as
298      * the available width.
299      * <br>
300      *
301      * @param autoWidthMethod The method of automatically calculating the
302      * candle width.
303      *
304      * @see #WIDTHMETHOD_AVERAGE
305      * @see #WIDTHMETHOD_SMALLEST
306      * @see #WIDTHMETHOD_INTERVALDATA
307      * @see #setCandleWidth(double)
308      * @see #setAutoWidthGap(double)
309      * @see #setAutoWidthFactor(double)
310      * @see #setMaxCandleWidthInMilliseconds(double)
311      */
312     public void setAutoWidthMethod(int autoWidthMethod) {
313         if (this.autoWidthMethod != autoWidthMethod) {
314             this.autoWidthMethod = autoWidthMethod;
315             notifyListeners(new RendererChangeEvent(this));
316         }
317     }
318
319     /**
320      * Returns the factor by which the available space automatically
321      * calculated for the candles will be multiplied to determine the actual
322      * width to use.
323      *
324      * @return The width factor (generally between 0.0 and 1.0).
325      */
326     public double getAutoWidthFactor() {
327         return this.autoWidthFactor;
328     }
329
330     /**
331      * Sets the factor by which the available space automatically calculated
332      * for the candles will be multiplied to determine the actual width to use.
333      *
334      * @param autoWidthFactor The width factor (generally between 0.0 and 1.0).
335      * @see #setCandleWidth(double)
336      * @see #setAutoWidthMethod(int)
337      * @see #setAutoWidthGap(double)
338      * @see #setMaxCandleWidthInMilliseconds(double)
339      */
340     public void setAutoWidthFactor(double autoWidthFactor) {
341         if (this.autoWidthFactor != autoWidthFactor) {
342             this.autoWidthFactor = autoWidthFactor;
343             notifyListeners(new RendererChangeEvent(this));
344         }
345     }
346
347     /**
348      * Returns the amount of space to leave on the left and right of each
349      * candle when automatically calculating widths.
350      *
351      * @return The gap.
352      */
353     public double getAutoWidthGap() {
354         return this.autoWidthGap;
355     }
356
357     /**
358      * Sets the amount of space to leave on the left and right of each candle
359      * when automatically calculating widths.
360      *
361      * @param autoWidthGap The gap.
362      * @see #setCandleWidth(double)
363      * @see #setAutoWidthMethod(int)
364      * @see #setAutoWidthFactor(double)
365      * @see #setMaxCandleWidthInMilliseconds(double)
366      */
367     public void setAutoWidthGap(double autoWidthGap) {
368         if (this.autoWidthGap != autoWidthGap) {
369             this.autoWidthGap = autoWidthGap;
370             notifyListeners(new RendererChangeEvent(this));
371         }
372     }
373
374     /**
375      * Returns the paint used to fill candles when the price moves up from open
376      * to close.
377      *
378      * @return The paint.
379      */
380     public Paint getUpPaint() {
381         return this.upPaint;
382     }
383
384     /**
385      * Sets the paint used to fill candles when the price moves up from open
386      * to close.
387      * <P>
388      * Registered property change listeners are notified that the
389      * "CandleStickRenderer.upPaint" property has changed.
390      *
391      * @param paint The paint.
392      */
393     public void setUpPaint(Paint paint) {
394         this.upPaint = paint;
395         notifyListeners(new RendererChangeEvent(this));
396     }
397
398     /**
399      * Returns the paint used to fill candles when the price moves down from
400      * open to close.
401      *
402      * @return The paint.
403      */
404     public Paint getDownPaint() {
405         return this.downPaint;
406     }
407
408     /**
409      * Sets the paint used to fill candles when the price moves down from open
410      * to close.
411      * <P>
412      * Registered property change listeners are notified that the
413      * "CandleStickRenderer.downPaint" property has changed.
414      *
415      * @param paint The paint.
416      */
417     public void setDownPaint(Paint paint) {
418         this.downPaint = paint;
419         notifyListeners(new RendererChangeEvent(this));
420     }
421
422     /**
423      * Returns a flag indicating whether or not volume bars are drawn on the
424      * chart.
425      *
426      * @return <code>true</code> if volume bars are drawn on the chart.
427      */
428     public boolean drawVolume() {
429         return this.drawVolume;
430     }
431
432     /**
433      * Sets a flag that controls whether or not volume bars are drawn in the
434      * background.
435      *
436      * @param flag The flag.
437      */
438     public void setDrawVolume(boolean flag) {
439         if (this.drawVolume != flag) {
440             this.drawVolume = flag;
441             notifyListeners(new RendererChangeEvent(this));
442         }
443     }
444
445     /**
446      * Initialises the renderer then returns the number of 'passes' through the
447      * data that the renderer will require (usually just one). This method
448      * will be called before the first item is rendered, giving the renderer
449      * an opportunity to initialise any state information it wants to maintain.
450      * The renderer can do nothing if it chooses.
451      *
452      * @param g2 the graphics device.
453      * @param dataArea the area inside the axes.
454      * @param plot the plot.
455      * @param dataset the data.
456      * @param info an optional info collection object to return data back to
457      * the caller.
458      *
459      * @return The number of passes the renderer requires.
460      */
461     public XYItemRendererState initialise(Graphics2D g2,
462                                           Rectangle2D dataArea,
463                                           XYPlot plot,
464                                           XYDataset dataset,
465                                           PlotRenderingInfo info) {
466           
467         // calculate the maximum allowed candle width from the axis...
468 ValueAxis axis = plot.getDomainAxis();
469         double x1 = axis.getLowerBound();
470         double x2 = x1 + this.maxCandleWidthInMilliseconds;
471         RectangleEdge edge = plot.getDomainAxisEdge();
472         double xx1 = axis.valueToJava2D(x1, dataArea, edge);
473         double xx2 = axis.valueToJava2D(x2, dataArea, edge);
474         this.maxCandleWidth = Math.abs(xx2 - xx1);
475             // Absolute value, since the relative x
476 // positions are reversed for horizontal orientation
477
478         // calculate the highest volume in the dataset...
479 if (this.drawVolume) {
480             OHLCDataset highLowDataset = (OHLCDataset) dataset;
481             this.maxVolume = 0.0;
482             for (int series = 0; series < highLowDataset.getSeriesCount();
483                  series++) {
484                 for (int item = 0; item < highLowDataset.getItemCount(series);
485                      item++) {
486                     double volume = highLowDataset.getVolumeValue(series, item);
487                     if (volume > this.maxVolume) {
488                         this.maxVolume = volume;
489                     }
490                     
491                 }
492             }
493         }
494         
495         return new XYItemRendererState(info);
496     }
497
498     /**
499      * Draws the visual representation of a single data item.
500      *
501      * @param g2 the graphics device.
502      * @param state the renderer state.
503      * @param dataArea the area within which the plot is being drawn.
504      * @param info collects info about the drawing.
505      * @param plot the plot (can be used to obtain standard color
506      * information etc).
507      * @param domainAxis the domain axis.
508      * @param rangeAxis the range axis.
509      * @param dataset the dataset.
510      * @param series the series index (zero-based).
511      * @param item the item index (zero-based).
512      * @param crosshairState crosshair information for the plot
513      * (<code>null</code> permitted).
514      * @param pass the pass index.
515      */
516     public void drawItem(Graphics2D g2,
517                          XYItemRendererState state,
518                          Rectangle2D dataArea,
519                          PlotRenderingInfo info,
520                          XYPlot plot,
521                          ValueAxis domainAxis,
522                          ValueAxis rangeAxis,
523                          XYDataset dataset,
524                          int series,
525                          int item,
526                          CrosshairState crosshairState,
527                          int pass) {
528
529         boolean horiz;
530         PlotOrientation orientation = plot.getOrientation();
531         if (orientation == PlotOrientation.HORIZONTAL) {
532             horiz = true;
533         }
534         else if (orientation == PlotOrientation.VERTICAL) {
535             horiz = false;
536         }
537         else {
538             return;
539         }
540         
541         // setup for collecting optional entity info...
542 EntityCollection entities = null;
543         if (info != null) {
544             entities = info.getOwner().getEntityCollection();
545         }
546
547         OHLCDataset highLowData = (OHLCDataset) dataset;
548
549         double x = highLowData.getXValue(series, item);
550         double yHigh = highLowData.getHighValue(series, item);
551         double yLow = highLowData.getLowValue(series, item);
552         double yOpen = highLowData.getOpenValue(series, item);
553         double yClose = highLowData.getCloseValue(series, item);
554
555         RectangleEdge domainEdge = plot.getDomainAxisEdge();
556         double xx = domainAxis.valueToJava2D(x, dataArea, domainEdge);
557
558         RectangleEdge edge = plot.getRangeAxisEdge();
559         double yyHigh = rangeAxis.valueToJava2D(yHigh, dataArea, edge);
560         double yyLow = rangeAxis.valueToJava2D(yLow, dataArea, edge);
561         double yyOpen = rangeAxis.valueToJava2D(yOpen, dataArea, edge);
562         double yyClose = rangeAxis.valueToJava2D(yClose, dataArea, edge);
563
564         double volumeWidth;
565         double stickWidth;
566         if (this.candleWidth > 0) {
567             // These are deliberately not bounded to minimums/maxCandleWidth to
568 // retain old behaviour.
569 volumeWidth = this.candleWidth;
570             stickWidth = this.candleWidth;
571         }
572         else {
573             double xxWidth = 0;
574             int itemCount;
575             switch (this.autoWidthMethod) {
576             
577                 case WIDTHMETHOD_AVERAGE:
578                     itemCount = highLowData.getItemCount(series);
579                     if (horiz) {
580                         xxWidth = dataArea.getHeight() / itemCount;
581                     }
582                     else {
583                         xxWidth = dataArea.getWidth() / itemCount;
584                     }
585                     break;
586             
587                 case WIDTHMETHOD_SMALLEST:
588                     // Note: It would be nice to pre-calculate this per series
589 itemCount = highLowData.getItemCount(series);
590                     double lastPos = -1;
591                     xxWidth = dataArea.getWidth();
592                     for (int i = 0; i < itemCount; i++) {
593                         double pos = domainAxis.valueToJava2D(
594                             highLowData.getXValue(series, i), dataArea,
595                             domainEdge
596                         );
597                         if (lastPos != -1) {
598                             xxWidth = Math.min(
599                                 xxWidth, Math.abs(pos - lastPos)
600                             );
601                         }
602                         lastPos = pos;
603                     }
604                     break;
605             
606                 case WIDTHMETHOD_INTERVALDATA:
607                     IntervalXYDataset intervalXYData
608                         = (IntervalXYDataset) dataset;
609                     double startPos = domainAxis.valueToJava2D(
610                         intervalXYData.getStartXValue(series, item), dataArea,
611                         plot.getDomainAxisEdge()
612                     );
613                     double endPos = domainAxis.valueToJava2D(
614                         intervalXYData.getEndXValue(series, item), dataArea,
615                         plot.getDomainAxisEdge()
616                     );
617                     xxWidth = Math.abs(endPos - startPos);
618                     break;
619                 
620             }
621             xxWidth -= 2 * this.autoWidthGap;
622             xxWidth *= this.autoWidthFactor;
623             xxWidth = Math.min(xxWidth, this.maxCandleWidth);
624             volumeWidth = Math.max(Math.min(1, this.maxCandleWidth), xxWidth);
625             stickWidth = Math.max(Math.min(3, this.maxCandleWidth), xxWidth);
626         }
627
628         Paint p = getItemPaint(series, item);
629         Stroke s = getItemStroke(series, item);
630
631         g2.setStroke(s);
632
633         if (this.drawVolume) {
634             int volume = (int) highLowData.getVolumeValue(series, item);
635             double volumeHeight = volume / this.maxVolume;
636
637             double min, max;
638             if (horiz) {
639                 min = dataArea.getMinX();
640                 max = dataArea.getMaxX();
641             }
642             else {
643                 min = dataArea.getMinY();
644                 max = dataArea.getMaxY();
645             }
646
647             double zzVolume = volumeHeight * (max - min);
648
649             g2.setPaint(Color.gray);
650             Composite originalComposite = g2.getComposite();
651             g2.setComposite(
652                 AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.3f)
653             );
654
655             if (horiz) {
656                 g2.fill(new Rectangle2D.Double (min,
657                                                xx - volumeWidth / 2,
658                                                zzVolume, volumeWidth));
659             }
660             else {
661                 g2.fill(
662                     new Rectangle2D.Double (
663                         xx - volumeWidth / 2,
664                         max - zzVolume, volumeWidth, zzVolume
665                     )
666                 );
667             }
668
669             g2.setComposite(originalComposite);
670         }
671
672         g2.setPaint(p);
673
674         double yyMaxOpenClose = Math.max(yyOpen, yyClose);
675         double yyMinOpenClose = Math.min(yyOpen, yyClose);
676         double maxOpenClose = Math.max(yOpen, yClose);
677         double minOpenClose = Math.min(yOpen, yClose);
678
679         // draw the upper shadow
680 if (yHigh > maxOpenClose) {
681             if (horiz) {
682                 g2.draw(new Line2D.Double (yyHigh, xx, yyMaxOpenClose, xx));
683             }
684             else {
685                 g2.draw(new Line2D.Double (xx, yyHigh, xx, yyMaxOpenClose));
686             }
687         }
688
689         // draw the lower shadow
690 if (yLow < minOpenClose) {
691             if (horiz) {
692                 g2.draw(new Line2D.Double (yyLow, xx, yyMinOpenClose, xx));
693             }
694             else {
695                 g2.draw(new Line2D.Double (xx, yyLow, xx, yyMinOpenClose));
696             }
697         }
698
699         // draw the body
700 Shape body = null;
701         if (horiz) {
702             body = new Rectangle2D.Double (
703                 yyMinOpenClose, xx - stickWidth / 2,
704                 yyMaxOpenClose - yyMinOpenClose, stickWidth
705             );
706         }
707         else {
708             body = new Rectangle2D.Double (
709                 xx - stickWidth / 2, yyMinOpenClose,
710                 stickWidth, yyMaxOpenClose - yyMinOpenClose
711             );
712         }
713         if (yClose > yOpen) {
714             if (this.upPaint != null) {
715                 g2.setPaint(this.upPaint);
716                 g2.fill(body);
717             }
718         }
719         else {
720             if (this.downPaint != null) {
721                 g2.setPaint(this.downPaint);
722             }
723             g2.fill(body);
724         }
725         g2.setPaint(p);
726         g2.draw(body);
727
728         // add an entity for the item...
729 if (entities != null) {
730             String tip = null;
731             XYToolTipGenerator generator = getToolTipGenerator(series, item);
732             if (generator != null) {
733                 tip = generator.generateToolTip(dataset, series, item);
734             }
735             String url = null;
736             if (getURLGenerator() != null) {
737                 url = getURLGenerator().generateURL(dataset, series, item);
738             }
739             XYItemEntity entity = new XYItemEntity(body, dataset, series, item,
740                     tip, url);
741             entities.add(entity);
742         }
743
744     }
745
746     /**
747      * Tests this renderer for equality with another object.
748      *
749      * @param obj the object (<code>null</code> permitted).
750      *
751      * @return <code>true</code> or <code>false</code>.
752      */
753     public boolean equals(Object obj) {
754         if (obj == this) {
755             return true;
756         }
757         if (! (obj instanceof CandlestickRenderer)) {
758             return false;
759         }
760         CandlestickRenderer that = (CandlestickRenderer) obj;
761         if (this.candleWidth != that.candleWidth) {
762             return false;
763         }
764         if (!PaintUtilities.equal(this.upPaint, that.upPaint)) {
765             return false;
766         }
767         if (!PaintUtilities.equal(this.downPaint, that.downPaint)) {
768             return false;
769         }
770         if (this.drawVolume != that.drawVolume) {
771             return false;
772         }
773         if (this.maxCandleWidthInMilliseconds
774                 != that.maxCandleWidthInMilliseconds) {
775             return false;
776         }
777         if (this.autoWidthMethod != that.autoWidthMethod) {
778             return false;
779         }
780         if (this.autoWidthFactor != that.autoWidthFactor) {
781             return false;
782         }
783         if (this.autoWidthGap != that.autoWidthGap) {
784             return false;
785         }
786         return super.equals(obj);
787     }
788
789     /**
790      * Returns a clone of the renderer.
791      *
792      * @return A clone.
793      *
794      * @throws CloneNotSupportedException if the renderer cannot be cloned.
795      */
796     public Object clone() throws CloneNotSupportedException {
797         return super.clone();
798     }
799
800     /**
801      * Provides serialization support.
802      *
803      * @param stream the output stream.
804      *
805      * @throws IOException if there is an I/O error.
806      */
807     private void writeObject(ObjectOutputStream stream) throws IOException {
808         stream.defaultWriteObject();
809         SerialUtilities.writePaint(this.upPaint, stream);
810         SerialUtilities.writePaint(this.downPaint, stream);
811     }
812
813     /**
814      * Provides serialization support.
815      *
816      * @param stream the input stream.
817      *
818      * @throws IOException if there is an I/O error.
819      * @throws ClassNotFoundException if there is a classpath problem.
820      */
821     private void readObject(ObjectInputStream stream)
822             throws IOException , ClassNotFoundException {
823         stream.defaultReadObject();
824         this.upPaint = SerialUtilities.readPaint(stream);
825         this.downPaint = SerialUtilities.readPaint(stream);
826     }
827     
828 }
829

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags