XYLineAndShapeRenderer


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   * XYLineAndShapeRenderer.java
29   * ---------------------------
30   * (C) Copyright 2004-2006, by Object Refinery Limited.
31   *
32   * Original Author:  David Gilbert (for Object Refinery Limited);
33   * Contributor(s):   -;
34   *
35   * $Id: XYLineAndShapeRenderer.java,v 1.20.2.7 2006/07/20 16:21:58 mungady Exp $
36   *
37   * Changes:
38   * --------
39   * 27-Jan-2004 : Version 1 (DG);
40   * 10-Feb-2004 : Minor change to drawItem() method to make cut-and-paste 
41   *               overriding easier (DG);
42   * 25-Feb-2004 : Replaced CrosshairInfo with CrosshairState (DG);
43   * 25-Aug-2004 : Added support for chart entities (required for tooltips) (DG);
44   * 24-Sep-2004 : Added flag to allow whole series to be drawn as a path 
45   *               (necessary when using a dashed stroke with many data 
46   *               items) (DG);
47   * 04-Oct-2004 : Renamed BooleanUtils --> BooleanUtilities (DG);
48   * 11-Nov-2004 : Now uses ShapeUtilities to translate shapes (DG);
49   * 27-Jan-2005 : The getLegendItem() method now omits hidden series (DG);
50   * 28-Jan-2005 : Added new constructor (DG);
51   * 09-Mar-2005 : Added fillPaint settings (DG);
52   * 20-Apr-2005 : Use generators for legend tooltips and URLs (DG);
53   * 22-Jul-2005 : Renamed defaultLinesVisible --> baseLinesVisible, 
54   *               defaultShapesVisible --> baseShapesVisible and
55   *               defaultShapesFilled --> baseShapesFilled (DG);
56   * 29-Jul-2005 : Added code to draw item labels (DG);
57   * ------------- JFREECHART 1.0.0 ---------------------------------------------
58   * 20-Jul-2006 : Set dataset and series indices in LegendItem (DG);
59   *
60   */
61  
62  package org.jfree.chart.renderer.xy;
63  
64  import java.awt.Graphics2D  ;
65  import java.awt.Paint  ;
66  import java.awt.Shape  ;
67  import java.awt.Stroke  ;
68  import java.awt.geom.GeneralPath  ;
69  import java.awt.geom.Line2D  ;
70  import java.awt.geom.Rectangle2D  ;
71  import java.io.IOException  ;
72  import java.io.ObjectInputStream  ;
73  import java.io.ObjectOutputStream  ;
74  import java.io.Serializable  ;
75  
76  import org.jfree.chart.LegendItem;
77  import org.jfree.chart.axis.ValueAxis;
78  import org.jfree.chart.entity.EntityCollection;
79  import org.jfree.chart.event.RendererChangeEvent;
80  import org.jfree.chart.plot.CrosshairState;
81  import org.jfree.chart.plot.PlotOrientation;
82  import org.jfree.chart.plot.PlotRenderingInfo;
83  import org.jfree.chart.plot.XYPlot;
84  import org.jfree.data.xy.XYDataset;
85  import org.jfree.io.SerialUtilities;
86  import org.jfree.ui.RectangleEdge;
87  import org.jfree.util.BooleanList;
88  import org.jfree.util.BooleanUtilities;
89  import org.jfree.util.ObjectUtilities;
90  import org.jfree.util.PublicCloneable;
91  import org.jfree.util.ShapeUtilities;
92  
93  /**
94   * A renderer that can be used with the {@link XYPlot} class.
95   */
96  public class XYLineAndShapeRenderer extends AbstractXYItemRenderer 
97                                      implements XYItemRenderer, 
98                                                 Cloneable  ,
99                                                 PublicCloneable,
100                                                Serializable   {
101 
102     /** For serialization. */
103     private static final long serialVersionUID = -7435246895986425885L;
104     
105     /** A flag that controls whether or not lines are visible for ALL series. */
106     private Boolean   linesVisible;
107 
108     /** 
109      * A table of flags that control (per series) whether or not lines are 
110      * visible. 
111      */
112     private BooleanList seriesLinesVisible;
113 
114     /** The default value returned by the getLinesVisible() method. */
115     private boolean baseLinesVisible;
116 
117     /** The shape that is used to represent a line in the legend. */
118     private transient Shape   legendLine;
119     
120     /** 
121      * A flag that controls whether or not shapes are visible for ALL series. 
122      */
123     private Boolean   shapesVisible;
124 
125     /** 
126      * A table of flags that control (per series) whether or not shapes are 
127      * visible. 
128      */
129     private BooleanList seriesShapesVisible;
130 
131     /** The default value returned by the getShapeVisible() method. */
132     private boolean baseShapesVisible;
133 
134     /** A flag that controls whether or not shapes are filled for ALL series. */
135     private Boolean   shapesFilled;
136 
137     /** 
138      * A table of flags that control (per series) whether or not shapes are 
139      * filled. 
140      */
141     private BooleanList seriesShapesFilled;
142 
143     /** The default value returned by the getShapeFilled() method. */
144     private boolean baseShapesFilled;
145     
146     /** A flag that controls whether outlines are drawn for shapes. */
147     private boolean drawOutlines;
148     
149     /** 
150      * A flag that controls whether the fill paint is used for filling 
151      * shapes. 
152      */
153     private boolean useFillPaint;
154     
155     /** 
156      * A flag that controls whether the outline paint is used for drawing shape 
157      * outlines. 
158      */
159     private boolean useOutlinePaint;
160     
161     /** 
162      * A flag that controls whether or not each series is drawn as a single 
163      * path. 
164      */
165     private boolean drawSeriesLineAsPath;
166 
167     /**
168      * Creates a new renderer with both lines and shapes visible.
169      */
170     public XYLineAndShapeRenderer() {
171         this(true, true);
172     }
173     
174     /**
175      * Creates a new renderer.
176      * 
177      * @param lines  lines visible?
178      * @param shapes  shapes visible?
179      */
180     public XYLineAndShapeRenderer(boolean lines, boolean shapes) {
181         this.linesVisible = null;
182         this.seriesLinesVisible = new BooleanList();
183         this.baseLinesVisible = lines;
184         this.legendLine = new Line2D.Double  (-7.0, 0.0, 7.0, 0.0);
185         
186         this.shapesVisible = null;
187         this.seriesShapesVisible = new BooleanList();
188         this.baseShapesVisible = shapes;
189         
190         this.shapesFilled = null;
191         this.useFillPaint = false;     // use item paint for fills by default
192         this.seriesShapesFilled = new BooleanList();
193         this.baseShapesFilled = true;
194 
195         this.drawOutlines = true;     
196         this.useOutlinePaint = false;  // use item paint for outlines by 
197                                        // default, not outline paint
198         
199         this.drawSeriesLineAsPath = false;
200     }
201     
202     /**
203      * Returns a flag that controls whether or not each series is drawn as a 
204      * single path.
205      * 
206      * @return A boolean.
207      * 
208      * @see #setDrawSeriesLineAsPath(boolean)
209      */
210     public boolean getDrawSeriesLineAsPath() {
211         return this.drawSeriesLineAsPath;
212     }
213     
214     /**
215      * Sets the flag that controls whether or not each series is drawn as a 
216      * single path.
217      * 
218      * @param flag  the flag.
219      * 
220      * @see #getDrawSeriesLineAsPath()
221      */
222     public void setDrawSeriesLineAsPath(boolean flag) {
223         if (this.drawSeriesLineAsPath != flag) {
224             this.drawSeriesLineAsPath = flag;
225             notifyListeners(new RendererChangeEvent(this));
226         }
227     }
228     
229     /**
230      * Returns the number of passes through the data that the renderer requires 
231      * in order to draw the chart.  Most charts will require a single pass, but 
232      * some require two passes.
233      * 
234      * @return The pass count.
235      */
236     public int getPassCount() {
237         return 2;
238     }
239     
240     // LINES VISIBLE
241 
242     /**
243      * Returns the flag used to control whether or not the shape for an item is 
244      * visible.
245      *
246      * @param series  the series index (zero-based).
247      * @param item  the item index (zero-based).
248      *
249      * @return A boolean.
250      */
251     public boolean getItemLineVisible(int series, int item) {
252         Boolean   flag = this.linesVisible;
253         if (flag == null) {
254             flag = getSeriesLinesVisible(series);
255         }
256         if (flag != null) {
257             return flag.booleanValue();
258         }
259         else {
260             return this.baseLinesVisible;   
261         }
262     }
263 
264     /**
265      * Returns a flag that controls whether or not lines are drawn for ALL 
266      * series.  If this flag is <code>null</code>, then the "per series" 
267      * settings will apply.
268      * 
269      * @return A flag (possibly <code>null</code>).
270      */
271     public Boolean   getLinesVisible() {
272         return this.linesVisible;   
273     }
274     
275     /**
276      * Sets a flag that controls whether or not lines are drawn between the 
277      * items in ALL series, and sends a {@link RendererChangeEvent} to all 
278      * registered listeners.  You need to set this to <code>null</code> if you 
279      * want the "per series" settings to apply.
280      *
281      * @param visible  the flag (<code>null</code> permitted).
282      */
283     public void setLinesVisible(Boolean   visible) {
284         this.linesVisible = visible;
285         notifyListeners(new RendererChangeEvent(this));
286     }
287 
288     /**
289      * Sets a flag that controls whether or not lines are drawn between the 
290      * items in ALL series, and sends a {@link RendererChangeEvent} to all 
291      * registered listeners.
292      *
293      * @param visible  the flag.
294      */
295     public void setLinesVisible(boolean visible) {
296         setLinesVisible(BooleanUtilities.valueOf(visible));
297     }
298 
299     /**
300      * Returns the flag used to control whether or not the lines for a series 
301      * are visible.
302      *
303      * @param series  the series index (zero-based).
304      *
305      * @return The flag (possibly <code>null</code>).
306      */
307     public Boolean   getSeriesLinesVisible(int series) {
308         return this.seriesLinesVisible.getBoolean(series);
309     }
310 
311     /**
312      * Sets the 'lines visible' flag for a series.
313      *
314      * @param series  the series index (zero-based).
315      * @param flag  the flag (<code>null</code> permitted).
316      */
317     public void setSeriesLinesVisible(int series, Boolean   flag) {
318         this.seriesLinesVisible.setBoolean(series, flag);
319         notifyListeners(new RendererChangeEvent(this));
320     }
321 
322     /**
323      * Sets the 'lines visible' flag for a series.
324      * 
325      * @param series  the series index (zero-based).
326      * @param visible  the flag.
327      */
328     public void setSeriesLinesVisible(int series, boolean visible) {
329         setSeriesLinesVisible(series, BooleanUtilities.valueOf(visible));
330     }
331     
332     /**
333      * Returns the base 'lines visible' attribute.
334      *
335      * @return The base flag.
336      */
337     public boolean getBaseLinesVisible() {
338         return this.baseLinesVisible;
339     }
340 
341     /**
342      * Sets the base 'lines visible' flag.
343      *
344      * @param flag  the flag.
345      */
346     public void setBaseLinesVisible(boolean flag) {
347         this.baseLinesVisible = flag;
348         notifyListeners(new RendererChangeEvent(this));
349     }
350 
351     /**
352      * Returns the shape used to represent a line in the legend.
353      * 
354      * @return The legend line (never <code>null</code>).
355      */
356     public Shape   getLegendLine() {
357         return this.legendLine;   
358     }
359     
360     /**
361      * Sets the shape used as a line in each legend item and sends a 
362      * {@link RendererChangeEvent} to all registered listeners.
363      * 
364      * @param line  the line (<code>null</code> not permitted).
365      */
366     public void setLegendLine(Shape   line) {
367         if (line == null) {
368             throw new IllegalArgumentException  ("Null 'line' argument.");   
369         }
370         this.legendLine = line;
371         notifyListeners(new RendererChangeEvent(this));
372     }
373 
374     // SHAPES VISIBLE
375 
376     /**
377      * Returns the flag used to control whether or not the shape for an item is
378      * visible.
379      * <p>
380      * The default implementation passes control to the 
381      * <code>getSeriesShapesVisible</code> method. You can override this method
382      * if you require different behaviour.
383      *
384      * @param series  the series index (zero-based).
385      * @param item  the item index (zero-based).
386      *
387      * @return A boolean.
388      */
389     public boolean getItemShapeVisible(int series, int item) {
390         Boolean   flag = this.shapesVisible;
391         if (flag == null) {
392             flag = getSeriesShapesVisible(series);
393         }
394         if (flag != null) {
395             return flag.booleanValue();   
396         }
397         else {
398             return this.baseShapesVisible;
399         }
400     }
401 
402     /**
403      * Returns the flag that controls whether the shapes are visible for the 
404      * items in ALL series.
405      * 
406      * @return The flag (possibly <code>null</code>).
407      */
408     public Boolean   getShapesVisible() {
409         return this.shapesVisible;    
410     }
411     
412     /**
413      * Sets the 'shapes visible' for ALL series and sends a 
414      * {@link RendererChangeEvent} to all registered listeners.
415      *
416      * @param visible  the flag (<code>null</code> permitted).
417      */
418     public void setShapesVisible(Boolean   visible) {
419         this.shapesVisible = visible;
420         notifyListeners(new RendererChangeEvent(this));
421     }
422 
423     /**
424      * Sets the 'shapes visible' for ALL series and sends a 
425      * {@link RendererChangeEvent} to all registered listeners.
426      * 
427      * @param visible  the flag.
428      */
429     public void setShapesVisible(boolean visible) {
430         setShapesVisible(BooleanUtilities.valueOf(visible));
431     }
432 
433     /**
434      * Returns the flag used to control whether or not the shapes for a series
435      * are visible.
436      *
437      * @param series  the series index (zero-based).
438      *
439      * @return A boolean.
440      */
441     public Boolean   getSeriesShapesVisible(int series) {
442         return this.seriesShapesVisible.getBoolean(series);
443     }
444 
445     /**
446      * Sets the 'shapes visible' flag for a series and sends a 
447      * {@link RendererChangeEvent} to all registered listeners.
448      * 
449      * @param series  the series index (zero-based).
450      * @param visible  the flag.
451      */
452     public void setSeriesShapesVisible(int series, boolean visible) {
453         setSeriesShapesVisible(series, BooleanUtilities.valueOf(visible));
454     }
455     
456     /**
457      * Sets the 'shapes visible' flag for a series and sends a 
458      * {@link RendererChangeEvent} to all registered listeners.
459      *
460      * @param series  the series index (zero-based).
461      * @param flag  the flag.
462      */
463     public void setSeriesShapesVisible(int series, Boolean   flag) {
464         this.seriesShapesVisible.setBoolean(series, flag);
465         notifyListeners(new RendererChangeEvent(this));
466     }
467 
468     /**
469      * Returns the base 'shape visible' attribute.
470      *
471      * @return The base flag.
472      */
473     public boolean getBaseShapesVisible() {
474         return this.baseShapesVisible;
475     }
476 
477     /**
478      * Sets the base 'shapes visible' flag.
479      *
480      * @param flag  the flag.
481      */
482     public void setBaseShapesVisible(boolean flag) {
483         this.baseShapesVisible = flag;
484         notifyListeners(new RendererChangeEvent(this));
485     }
486 
487     // SHAPES FILLED
488 
489     /**
490      * Returns the flag used to control whether or not the shape for an item 
491      * is filled.
492      * <p>
493      * The default implementation passes control to the 
494      * <code>getSeriesShapesFilled</code> method. You can override this method
495      * if you require different behaviour.
496      *
497      * @param series  the series index (zero-based).
498      * @param item  the item index (zero-based).
499      *
500      * @return A boolean.
501      */
502     public boolean getItemShapeFilled(int series, int item) {
503         Boolean   flag = this.shapesFilled;
504         if (flag == null) {
505             flag = getSeriesShapesFilled(series);
506         }
507         if (flag != null) {
508             return flag.booleanValue();   
509         }
510         else {
511             return this.baseShapesFilled;   
512         }
513     }
514 
515     /**
516      * Sets the 'shapes filled' for ALL series and sends a 
517      * {@link RendererChangeEvent} to all registered listeners.
518      *
519      * @param filled  the flag.
520      */
521     public void setShapesFilled(boolean filled) {
522         setShapesFilled(BooleanUtilities.valueOf(filled));
523     }
524 
525     /**
526      * Sets the 'shapes filled' for ALL series and sends a 
527      * {@link RendererChangeEvent} to all registered listeners.
528      *
529      * @param filled  the flag (<code>null</code> permitted).
530      */
531     public void setShapesFilled(Boolean   filled) {
532         this.shapesFilled = filled;
533         notifyListeners(new RendererChangeEvent(this));
534     }
535     
536     /**
537      * Returns the flag used to control whether or not the shapes for a series
538      * are filled.
539      *
540      * @param series  the series index (zero-based).
541      *
542      * @return A boolean.
543      */
544     public Boolean   getSeriesShapesFilled(int series) {
545         return this.seriesShapesFilled.getBoolean(series);
546     }
547 
548     /**
549      * Sets the 'shapes filled' flag for a series.
550      *
551      * @param series  the series index (zero-based).
552      * @param flag  the flag.
553      */
554     public void setSeriesShapesFilled(int series, boolean flag) {
555         setSeriesShapesFilled(series, BooleanUtilities.valueOf(flag));
556     }
557 
558     /**
559      * Sets the 'shapes filled' flag for a series.
560      *
561      * @param series  the series index (zero-based).
562      * @param flag  the flag.
563      */
564     public void setSeriesShapesFilled(int series, Boolean   flag) {
565         this.seriesShapesFilled.setBoolean(series, flag);
566         notifyListeners(new RendererChangeEvent(this));
567     }
568 
569     /**
570      * Returns the base 'shape filled' attribute.
571      *
572      * @return The base flag.
573      */
574     public boolean getBaseShapesFilled() {
575         return this.baseShapesFilled;
576     }
577 
578     /**
579      * Sets the base 'shapes filled' flag.
580      *
581      * @param flag  the flag.
582      */
583     public void setBaseShapesFilled(boolean flag) {
584         this.baseShapesFilled = flag;
585         notifyListeners(new RendererChangeEvent(this));
586     }
587 
588     /**
589      * Returns <code>true</code> if outlines should be drawn for shapes, and 
590      * <code>false</code> otherwise.
591      * 
592      * @return A boolean.
593      */
594     public boolean getDrawOutlines() {
595         return this.drawOutlines;
596     }
597     
598     /**
599      * Sets the flag that controls whether outlines are drawn for 
600      * shapes, and sends a {@link RendererChangeEvent} to all registered 
601      * listeners. 
602      * <P>
603      * In some cases, shapes look better if they do NOT have an outline, but 
604      * this flag allows you to set your own preference.
605      * 
606      * @param flag  the flag.
607      */
608     public void setDrawOutlines(boolean flag) {
609         this.drawOutlines = flag;
610         notifyListeners(new RendererChangeEvent(this));
611     }
612     
613     /**
614      * Returns <code>true</code> if the renderer should use the fill paint 
615      * setting to fill shapes, and <code>false</code> if it should just
616      * use the regular paint.
617      * 
618      * @return A boolean.
619      */
620     public boolean getUseFillPaint() {
621         return this.useFillPaint;
622     }
623     
624     /**
625      * Sets the flag that controls whether the fill paint is used to fill 
626      * shapes, and sends a {@link RendererChangeEvent} to all 
627      * registered listeners.
628      * 
629      * @param flag  the flag.
630      */
631     public void setUseFillPaint(boolean flag) {
632         this.useFillPaint = flag;
633         notifyListeners(new RendererChangeEvent(this));
634     }
635     
636     /**
637      * Returns <code>true</code> if the renderer should use the outline paint 
638      * setting to draw shape outlines, and <code>false</code> if it should just
639      * use the regular paint.
640      * 
641      * @return A boolean.
642      */
643     public boolean getUseOutlinePaint() {
644         return this.useOutlinePaint;
645     }
646     
647     /**
648      * Sets the flag that controls whether the outline paint is used to draw 
649      * shape outlines, and sends a {@link RendererChangeEvent} to all 
650      * registered listeners.
651      * 
652      * @param flag  the flag.
653      */
654     public void setUseOutlinePaint(boolean flag) {
655         this.useOutlinePaint = flag;
656         notifyListeners(new RendererChangeEvent(this));
657     }
658     
659     /**
660      * Records the state for the renderer.  This is used to preserve state 
661      * information between calls to the drawItem() method for a single chart 
662      * drawing.
663      */
664     public static class State extends XYItemRendererState {
665         
666         /** The path for the current series. */
667         public GeneralPath   seriesPath;
668         
669         /** 
670          * A flag that indicates if the last (x, y) point was 'good' 
671          * (non-null). 
672          */
673         private boolean lastPointGood;
674         
675         /**
676          * Creates a new state instance.
677          * 
678          * @param info  the plot rendering info.
679          */
680         public State(PlotRenderingInfo info) {
681             super(info);
682         }
683         
684         /**
685          * Returns a flag that indicates if the last point drawn (in the 
686          * current series) was 'good' (non-null).
687          * 
688          * @return A boolean.
689          */
690         public boolean isLastPointGood() {
691             return this.lastPointGood;
692         }
693         
694         /**
695          * Sets a flag that indicates if the last point drawn (in the current 
696          * series) was 'good' (non-null).
697          * 
698          * @param good  the flag.
699          */
700         public void setLastPointGood(boolean good) {
701             this.lastPointGood = good;
702         }
703     }
704     
705     /**
706      * Initialises the renderer.
707      * <P>
708      * This method will be called before the first item is rendered, giving the
709      * renderer an opportunity to initialise any state information it wants to 
710      * maintain.  The renderer can do nothing if it chooses.
711      *
712      * @param g2  the graphics device.
713      * @param dataArea  the area inside the axes.
714      * @param plot  the plot.
715      * @param data  the data.
716      * @param info  an optional info collection object to return data back to 
717      *              the caller.
718      *
719      * @return The renderer state.
720      */
721     public XYItemRendererState initialise(Graphics2D   g2,
722                                           Rectangle2D   dataArea,
723                                           XYPlot plot,
724                                           XYDataset data,
725                                           PlotRenderingInfo info) {
726 
727         State state = new State(info);
728         state.seriesPath = new GeneralPath  ();
729         return state;
730 
731     }
732     
733     /**
734      * Draws the visual representation of a single data item.
735      *
736      * @param g2  the graphics device.
737      * @param state  the renderer state.
738      * @param dataArea  the area within which the data is being drawn.
739      * @param info  collects information about the drawing.
740      * @param plot  the plot (can be used to obtain standard color 
741      *              information etc).
742      * @param domainAxis  the domain axis.
743      * @param rangeAxis  the range axis.
744      * @param dataset  the dataset.
745      * @param series  the series index (zero-based).
746      * @param item  the item index (zero-based).
747      * @param crosshairState  crosshair information for the plot 
748      *                        (<code>null</code> permitted).
749      * @param pass  the pass index.
750      */
751     public void drawItem(Graphics2D   g2,
752                          XYItemRendererState state,
753                          Rectangle2D   dataArea,
754                          PlotRenderingInfo info,
755                          XYPlot plot,
756                          ValueAxis domainAxis,
757                          ValueAxis rangeAxis,
758                          XYDataset dataset,
759                          int series,
760                          int item,
761                          CrosshairState crosshairState,
762                          int pass) {
763 
764         // do nothing if item is not visible
765         if (!getItemVisible(series, item)) {
766             return;   
767         }
768 
769         // first pass draws the background (lines, for instance)
770         if (isLinePass(pass)) {
771             if (item == 0) {
772                 if (this.drawSeriesLineAsPath) {
773                     State s = (State) state;
774                     s.seriesPath.reset();
775                     s.lastPointGood = false;     
776                 }
777             }
778 
779             if (getItemLineVisible(series, item)) {
780                 if (this.drawSeriesLineAsPath) {
781                     drawPrimaryLineAsPath(state, g2, plot, dataset, pass, 
782                             series, item, domainAxis, rangeAxis, dataArea);
783                 }
784                 else {
785                     drawPrimaryLine(state, g2, plot, dataset, pass, series, 
786                             item, domainAxis, rangeAxis, dataArea);
787                 }
788             }
789         }
790         // second pass adds shapes where the items are ..
791         else if (isItemPass(pass)) {
792 
793             // setup for collecting optional entity info...
794             EntityCollection entities = null;
795             if (info != null) {
796                 entities = info.getOwner().getEntityCollection();
797             }
798 
799             drawSecondaryPass(g2, plot, dataset, pass, series, item, 
800                     domainAxis, dataArea, rangeAxis, crosshairState, entities);
801         }
802     }
803 
804     /**
805      * Returns <code>true</code> if the specified pass is the one for drawing 
806      * lines.
807      * 
808      * @param pass  the pass.
809      * 
810      * @return A boolean.
811      */
812     protected boolean isLinePass(int pass) {
813         return pass == 0;
814     }
815 
816     /**
817      * Returns <code>true</code> if the specified pass is the one for drawing 
818      * items.
819      * 
820      * @param pass  the pass.
821      * 
822      * @return A boolean.
823      */
824     protected boolean isItemPass(int pass) {
825         return pass == 1;
826     }
827 
828     /**
829      * Draws the item (first pass). This method draws the lines
830      * connecting the items.
831      *
832      * @param g2  the graphics device.
833      * @param state  the renderer state.
834      * @param dataArea  the area within which the data is being drawn.
835      * @param plot  the plot (can be used to obtain standard color 
836      *              information etc).
837      * @param domainAxis  the domain axis.
838      * @param rangeAxis  the range axis.
839      * @param dataset  the dataset.
840      * @param pass  the pass.
841      * @param series  the series index (zero-based).
842      * @param item  the item index (zero-based).
843      */
844     protected void drawPrimaryLine(XYItemRendererState state,
845                                    Graphics2D   g2,
846                                    XYPlot plot,
847                                    XYDataset dataset,
848                                    int pass,
849                                    int series,
850                                    int item,
851                                    ValueAxis domainAxis,
852                                    ValueAxis rangeAxis,
853                                    Rectangle2D   dataArea) {
854         if (item == 0) {
855             return;
856         }
857 
858         // get the data point...
859         double x1 = dataset.getXValue(series, item);
860         double y1 = dataset.getYValue(series, item);
861         if (Double.isNaN(y1) || Double.isNaN(x1)) {
862             return;
863         }
864 
865         double x0 = dataset.getXValue(series, item - 1);
866         double y0 = dataset.getYValue(series, item - 1);
867         if (Double.isNaN(y0) || Double.isNaN(x0)) {
868             return;
869         }
870 
871         RectangleEdge xAxisLocation = plot.getDomainAxisEdge();
872         RectangleEdge yAxisLocation = plot.getRangeAxisEdge();
873 
874         double transX0 = domainAxis.valueToJava2D(x0, dataArea, xAxisLocation);
875         double transY0 = rangeAxis.valueToJava2D(y0, dataArea, yAxisLocation);
876 
877         double transX1 = domainAxis.valueToJava2D(x1, dataArea, xAxisLocation);
878         double transY1 = rangeAxis.valueToJava2D(y1, dataArea, yAxisLocation);
879 
880         // only draw if we have good values
881         if (Double.isNaN(transX0) || Double.isNaN(transY0)
882             || Double.isNaN(transX1) || Double.isNaN(transY1)) {
883             return;
884         }
885 
886         PlotOrientation orientation = plot.getOrientation();
887         if (orientation == PlotOrientation.HORIZONTAL) {
888             state.workingLine.setLine(transY0, transX0, transY1, transX1);
889         }
890         else if (orientation == PlotOrientation.VERTICAL) {
891             state.workingLine.setLine(transX0, transY0, transX1, transY1);
892         }
893 
894         if (state.workingLine.intersects(dataArea)) {
895             drawFirstPassShape(g2, pass, series, item, state.workingLine);
896         }
897     }
898 
899     /**
900      * Draws the first pass shape.
901      * 
902      * @param g2  the graphics device.
903      * @param pass  the pass.
904      * @param series  the series index.
905      * @param item  the item index.
906      * @param shape  the shape.
907      */
908     protected void drawFirstPassShape(Graphics2D   g2, int pass, int series,
909                                       int item, Shape   shape) {
910         g2.setStroke(getItemStroke(series, item));
911         g2.setPaint(getItemPaint(series, item));
912         g2.draw(shape);
913     }
914 
915 
916     /**
917      * Draws the item (first pass). This method draws the lines
918      * connecting the items. Instead of drawing separate lines,
919      * a GeneralPath is constructed and drawn at the end of
920      * the series painting.
921      *
922      * @param g2  the graphics device.
923      * @param state  the renderer state.
924      * @param plot  the plot (can be used to obtain standard color information 
925      *              etc).
926      * @param dataset  the dataset.
927      * @param pass  the pass.
928      * @param series  the series index (zero-based).
929      * @param item  the item index (zero-based).
930      * @param domainAxis  the domain axis.
931      * @param rangeAxis  the range axis.
932      * @param dataArea  the area within which the data is being drawn.
933      */
934     protected void drawPrimaryLineAsPath(XYItemRendererState state,
935                                          Graphics2D   g2, XYPlot plot,
936                                          XYDataset dataset,
937                                          int pass,
938                        &n