AbstractCategoryItemRenderer


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   * AbstractCategoryItemRenderer.java
29   * ---------------------------------
30   * (C) Copyright 2002-2006, by Object Refinery Limited.
31   *
32   * Original Author:  David Gilbert (for Object Refinery Limited);
33   * Contributor(s):   Richard Atkinson;
34   *
35   * $Id: AbstractCategoryItemRenderer.java,v 1.17.2.9 2006/10/24 15:10:23 mungady Exp $
36   *
37   * Changes:
38   * --------
39   * 29-May-2002 : Version 1 (DG);
40   * 06-Jun-2002 : Added accessor methods for the tool tip generator (DG);
41   * 11-Jun-2002 : Made constructors protected (DG);
42   * 26-Jun-2002 : Added axis to initialise method (DG);
43   * 05-Aug-2002 : Added urlGenerator member variable plus accessors (RA);
44   * 22-Aug-2002 : Added categoriesPaint attribute, based on code submitted by 
45   *               Janet Banks.  This can be used when there is only one series, 
46   *               and you want each category item to have a different color (DG);
47   * 01-Oct-2002 : Fixed errors reported by Checkstyle (DG);
48   * 29-Oct-2002 : Fixed bug where background image for plot was not being 
49   *               drawn (DG);
50   * 05-Nov-2002 : Replaced references to CategoryDataset with TableDataset (DG);
51   * 26-Nov 2002 : Replaced the isStacked() method with getRangeType() (DG);
52   * 09-Jan-2003 : Renamed grid-line methods (DG);
53   * 17-Jan-2003 : Moved plot classes into separate package (DG);
54   * 25-Mar-2003 : Implemented Serializable (DG);
55   * 12-May-2003 : Modified to take into account the plot orientation (DG);
56   * 12-Aug-2003 : Very minor javadoc corrections (DB)
57   * 13-Aug-2003 : Implemented Cloneable (DG);
58   * 16-Sep-2003 : Changed ChartRenderingInfo --> PlotRenderingInfo (DG);
59   * 05-Nov-2003 : Fixed marker rendering bug (833623) (DG);
60   * 21-Jan-2004 : Update for renamed method in ValueAxis (DG);
61   * 11-Feb-2004 : Modified labelling for markers (DG);
62   * 12-Feb-2004 : Updated clone() method (DG);
63   * 15-Apr-2004 : Created a new CategoryToolTipGenerator interface (DG);
64   * 05-May-2004 : Fixed bug (948310) where interval markers extend outside axis 
65   *               range (DG);
66   * 14-Jun-2004 : Fixed bug in drawRangeMarker() method - now uses 'paint' and 
67   *               'stroke' rather than 'outlinePaint' and 'outlineStroke' (DG);
68   * 15-Jun-2004 : Interval markers can now use GradientPaint (DG);
69   * 30-Sep-2004 : Moved drawRotatedString() from RefineryUtilities 
70   *               --> TextUtilities (DG);
71   * 01-Oct-2004 : Fixed bug 1029697, problem with label alignment in 
72   *               drawRangeMarker() method (DG);
73   * 07-Jan-2005 : Renamed getRangeExtent() --> findRangeBounds() (DG);
74   * 21-Jan-2005 : Modified return type of calculateRangeMarkerTextAnchorPoint() 
75   *               method (DG);
76   * 08-Mar-2005 : Fixed positioning of marker labels (DG);
77   * 20-Apr-2005 : Added legend label, tooltip and URL generators (DG);
78   * 01-Jun-2005 : Handle one dimension of the marker label adjustment 
79   *               automatically (DG);
80   * 09-Jun-2005 : Added utility method for adding an item entity (DG);
81   * ------------- JFREECHART 1.0.x ---------------------------------------------
82   * 01-Mar-2006 : Updated getLegendItems() to check seriesVisibleInLegend 
83   *               flags (DG);
84   * 20-Jul-2006 : Set dataset and series indices in LegendItem (DG);
85   * 23-Oct-2006 : Draw outlines for interval markers (DG);
86   * 24-Oct-2006 : Respect alpha setting in markers, as suggested by Sergei
87   *               Ivanov in patch 1567843 (DG);
88   *               
89   */
90  
91  package org.jfree.chart.renderer.category;
92  
93  import java.awt.AlphaComposite  ;
94  import java.awt.Composite  ;
95  import java.awt.Font  ;
96  import java.awt.GradientPaint  ;
97  import java.awt.Graphics2D  ;
98  import java.awt.Paint  ;
99  import java.awt.Shape  ;
100 import java.awt.Stroke  ;
101 import java.awt.geom.Line2D  ;
102 import java.awt.geom.Point2D  ;
103 import java.awt.geom.Rectangle2D  ;
104 import java.io.Serializable  ;
105 
106 import org.jfree.chart.LegendItem;
107 import org.jfree.chart.LegendItemCollection;
108 import org.jfree.chart.axis.CategoryAxis;
109 import org.jfree.chart.axis.ValueAxis;
110 import org.jfree.chart.entity.CategoryItemEntity;
111 import org.jfree.chart.entity.EntityCollection;
112 import org.jfree.chart.event.RendererChangeEvent;
113 import org.jfree.chart.labels.CategoryItemLabelGenerator;
114 import org.jfree.chart.labels.CategorySeriesLabelGenerator;
115 import org.jfree.chart.labels.CategoryToolTipGenerator;
116 import org.jfree.chart.labels.ItemLabelPosition;
117 import org.jfree.chart.labels.StandardCategorySeriesLabelGenerator;
118 import org.jfree.chart.plot.CategoryMarker;
119 import org.jfree.chart.plot.CategoryPlot;
120 import org.jfree.chart.plot.DrawingSupplier;
121 import org.jfree.chart.plot.IntervalMarker;
122 import org.jfree.chart.plot.Marker;
123 import org.jfree.chart.plot.PlotOrientation;
124 import org.jfree.chart.plot.PlotRenderingInfo;
125 import org.jfree.chart.plot.ValueMarker;
126 import org.jfree.chart.renderer.AbstractRenderer;
127 import org.jfree.chart.urls.CategoryURLGenerator;
128 import org.jfree.data.Range;
129 import org.jfree.data.category.CategoryDataset;
130 import org.jfree.data.general.DatasetUtilities;
131 import org.jfree.text.TextUtilities;
132 import org.jfree.ui.GradientPaintTransformer;
133 import org.jfree.ui.LengthAdjustmentType;
134 import org.jfree.ui.RectangleAnchor;
135 import org.jfree.ui.RectangleInsets;
136 import org.jfree.util.ObjectList;
137 import org.jfree.util.ObjectUtilities;
138 import org.jfree.util.PublicCloneable;
139 
140 /**
141  * An abstract base class that you can use to implement a new 
142  * {@link CategoryItemRenderer}.  When you create a new 
143  * {@link CategoryItemRenderer} you are not required to extend this class,
144  * but it makes the job easier.
145  */
146 public abstract class AbstractCategoryItemRenderer extends AbstractRenderer
147     implements CategoryItemRenderer, Cloneable  , PublicCloneable, Serializable   {
148 
149     /** For serialization. */
150     private static final long serialVersionUID = 1247553218442497391L;
151     
152     /** The plot that the renderer is assigned to. */
153     private CategoryPlot plot;
154 
155     /** The item label generator for ALL series. */
156     private CategoryItemLabelGenerator itemLabelGenerator;
157 
158     /** A list of item label generators (one per series). */
159     private ObjectList itemLabelGeneratorList;
160 
161     /** The base item label generator. */
162     private CategoryItemLabelGenerator baseItemLabelGenerator;
163 
164     /** The tool tip generator for ALL series. */
165     private CategoryToolTipGenerator toolTipGenerator;
166 
167     /** A list of tool tip generators (one per series). */
168     private ObjectList toolTipGeneratorList;
169 
170     /** The base tool tip generator. */
171     private CategoryToolTipGenerator baseToolTipGenerator;
172 
173     /** The URL generator. */
174     private CategoryURLGenerator itemURLGenerator;
175 
176     /** A list of item label generators (one per series). */
177     private ObjectList itemURLGeneratorList;
178 
179     /** The base item label generator. */
180     private CategoryURLGenerator baseItemURLGenerator;
181 
182     /** The legend item label generator. */
183     private CategorySeriesLabelGenerator legendItemLabelGenerator;
184     
185     /** The legend item tool tip generator. */
186     private CategorySeriesLabelGenerator legendItemToolTipGenerator;
187 
188     /** The legend item URL generator. */
189     private CategorySeriesLabelGenerator legendItemURLGenerator;
190     
191     /** The number of rows in the dataset (temporary record). */
192     private transient int rowCount;
193 
194     /** The number of columns in the dataset (temporary record). */
195     private transient int columnCount;
196 
197     /**
198      * Creates a new renderer with no tool tip generator and no URL generator.
199      * The defaults (no tool tip or URL generators) have been chosen to 
200      * minimise the processing required to generate a default chart.  If you 
201      * require tool tips or URLs, then you can easily add the required 
202      * generators.
203      */
204     protected AbstractCategoryItemRenderer() {
205         this.itemLabelGenerator = null;
206         this.itemLabelGeneratorList = new ObjectList();
207         this.toolTipGenerator = null;
208         this.toolTipGeneratorList = new ObjectList();
209         this.itemURLGenerator = null;
210         this.itemURLGeneratorList = new ObjectList();
211         this.legendItemLabelGenerator 
212             = new StandardCategorySeriesLabelGenerator();
213     }
214     
215     /**
216      * Returns the number of passes through the dataset required by the 
217      * renderer.  This method returns <code>1</code>, subclasses should 
218      * override if they need more passes.
219      * 
220      * @return The pass count.
221      */
222     public int getPassCount() {
223         return 1;
224     }
225 
226     /**
227      * Returns the plot that the renderer has been assigned to (where 
228      * <code>null</code> indicates that the renderer is not currently assigned 
229      * to a plot).
230      *
231      * @return The plot (possibly <code>null</code>).
232      */
233     public CategoryPlot getPlot() {
234         return this.plot;
235     }
236 
237     /**
238      * Sets the plot that the renderer has been assigned to.  This method is 
239      * usually called by the {@link CategoryPlot}, in normal usage you 
240      * shouldn't need to call this method directly.
241      *
242      * @param plot  the plot (<code>null</code> not permitted).
243      */
244     public void setPlot(CategoryPlot plot) {
245         if (plot == null) {
246             throw new IllegalArgumentException  ("Null 'plot' argument.");   
247         }
248         this.plot = plot;
249     }
250     
251     // ITEM LABEL GENERATOR
252 
253     /**
254      * Returns the item label generator for a data item.  This implementation 
255      * simply passes control to the {@link #getSeriesItemLabelGenerator(int)} 
256      * method.  If, for some reason, you want a different generator for 
257      * individual items, you can override this method.
258      *
259      * @param row  the row index (zero based).
260      * @param column  the column index (zero based).
261      *
262      * @return The generator (possibly <code>null</code>).
263      */
264     public CategoryItemLabelGenerator getItemLabelGenerator(int row, 
265             int column) {
266         return getSeriesItemLabelGenerator(row);
267     }
268 
269     /**
270      * Returns the item label generator for a series.
271      *
272      * @param series  the series index (zero based).
273      *
274      * @return The generator (possibly <code>null</code>).
275      */
276     public CategoryItemLabelGenerator getSeriesItemLabelGenerator(int series) {
277 
278         // return the generator for ALL series, if there is one...
279         if (this.itemLabelGenerator != null) {
280             return this.itemLabelGenerator;
281         }
282 
283         // otherwise look up the generator table
284         CategoryItemLabelGenerator generator = (CategoryItemLabelGenerator) 
285             this.itemLabelGeneratorList.get(series);
286         if (generator == null) {
287             generator = this.baseItemLabelGenerator;
288         }
289         return generator;
290 
291     }
292 
293     /**
294      * Sets the item label generator for ALL series and sends a 
295      * {@link RendererChangeEvent} to all registered listeners.
296      *
297      * @param generator  the generator (<code>null</code> permitted).
298      */
299     public void setItemLabelGenerator(CategoryItemLabelGenerator generator) {
300         this.itemLabelGenerator = generator;
301         notifyListeners(new RendererChangeEvent(this));
302     }
303 
304     /**
305      * Sets the item label generator for a series and sends a 
306      * {@link RendererChangeEvent} to all registered listeners.
307      *
308      * @param series  the series index (zero based).
309      * @param generator  the generator (<code>null</code> permitted).
310      */
311     public void setSeriesItemLabelGenerator(int series, 
312                                         CategoryItemLabelGenerator generator) {
313         this.itemLabelGeneratorList.set(series, generator);
314         notifyListeners(new RendererChangeEvent(this));
315     }
316 
317     /**
318      * Returns the base item label generator.
319      *
320      * @return The generator (possibly <code>null</code>).
321      */
322     public CategoryItemLabelGenerator getBaseItemLabelGenerator() {
323         return this.baseItemLabelGenerator;
324     }
325 
326     /**
327      * Sets the base item label generator and sends a 
328      * {@link RendererChangeEvent} to all registered listeners.
329      *
330      * @param generator  the generator (<code>null</code> permitted).
331      */
332     public void setBaseItemLabelGenerator(CategoryItemLabelGenerator generator) 
333     {
334         this.baseItemLabelGenerator = generator;
335         notifyListeners(new RendererChangeEvent(this));
336     }
337 
338     // TOOL TIP GENERATOR
339 
340     /**
341      * Returns the tool tip generator that should be used for the specified 
342      * item.  This method looks up the generator using the "three-layer" 
343      * approach outlined in the general description of this interface.  You 
344      * can override this method if you want to return a different generator per
345      * item.
346      *
347      * @param row  the row index (zero-based).
348      * @param column  the column index (zero-based).
349      *
350      * @return The generator (possibly <code>null</code>).
351      */
352     public CategoryToolTipGenerator getToolTipGenerator(int row, int column) {
353 
354         CategoryToolTipGenerator result = null;
355         if (this.toolTipGenerator != null) {
356             result = this.toolTipGenerator;
357         }
358         else {
359             result = getSeriesToolTipGenerator(row);  
360             if (result == null) {
361                 result = this.baseToolTipGenerator;   
362             }
363         }
364         return result;
365     }
366 
367     /**
368      * Returns the tool tip generator that will be used for ALL items in the 
369      * dataset (the "layer 0" generator).
370      * 
371      * @return A tool tip generator (possibly <code>null</code>).
372      */
373     public CategoryToolTipGenerator getToolTipGenerator() {
374         return this.toolTipGenerator;    
375     }
376     
377     /**
378      * Sets the tool tip generator for ALL series and sends a 
379      * {@link org.jfree.chart.event.RendererChangeEvent} to all registered 
380      * listeners.
381      * 
382      * @param generator  the generator (<code>null</code> permitted).
383      */
384     public void setToolTipGenerator(CategoryToolTipGenerator generator) {
385         this.toolTipGenerator = generator;
386         notifyListeners(new RendererChangeEvent(this));
387     }
388 
389     /**
390      * Returns the tool tip generator for the specified series (a "layer 1" 
391      * generator).
392      *
393      * @param series  the series index (zero-based).
394      *
395      * @return The tool tip generator (possibly <code>null</code>).
396      */
397     public CategoryToolTipGenerator getSeriesToolTipGenerator(int series) {
398         return (CategoryToolTipGenerator) this.toolTipGeneratorList.get(series);
399     }
400 
401     /**
402      * Sets the tool tip generator for a series and sends a 
403      * {@link org.jfree.chart.event.RendererChangeEvent} to all registered 
404      * listeners.
405      *
406      * @param series  the series index (zero-based).
407      * @param generator  the generator (<code>null</code> permitted).
408      */
409     public void setSeriesToolTipGenerator(int series, 
410                                           CategoryToolTipGenerator generator) {
411         this.toolTipGeneratorList.set(series, generator);
412         notifyListeners(new RendererChangeEvent(this));
413     }
414 
415     /**
416      * Returns the base tool tip generator (the "layer 2" generator).
417      *
418      * @return The tool tip generator (possibly <code>null</code>).
419      */
420     public CategoryToolTipGenerator getBaseToolTipGenerator() {
421         return this.baseToolTipGenerator;
422     }
423 
424     /**
425      * Sets the base tool tip generator and sends a 
426      * {@link org.jfree.chart.event.RendererChangeEvent} to all registered 
427      * listeners.
428      *
429      * @param generator  the generator (<code>null</code> permitted).
430      */
431     public void setBaseToolTipGenerator(CategoryToolTipGenerator generator) {
432         this.baseToolTipGenerator = generator;
433         notifyListeners(new RendererChangeEvent(this));
434     }
435 
436     // URL GENERATOR
437     
438     /**
439      * Returns the URL generator for a data item.  This method just calls the
440      * getSeriesItemURLGenerator method, but you can override this behaviour if
441      * you want to.
442      *
443      * @param row  the row index (zero based).
444      * @param column  the column index (zero based).
445      *
446      * @return The URL generator.
447      */
448     public CategoryURLGenerator getItemURLGenerator(int row, int column) {
449         return getSeriesItemURLGenerator(row);
450     }
451 
452     /**
453      * Returns the URL generator for a series.
454      *
455      * @param series  the series index (zero based).
456      *
457      * @return The URL generator for the series.
458      */
459     public CategoryURLGenerator getSeriesItemURLGenerator(int series) {
460 
461         // return the generator for ALL series, if there is one...
462         if (this.itemURLGenerator != null) {
463             return this.itemURLGenerator;
464         }
465 
466         // otherwise look up the generator table
467         CategoryURLGenerator generator
468             = (CategoryURLGenerator) this.itemURLGeneratorList.get(series);
469         if (generator == null) {
470             generator = this.baseItemURLGenerator;
471         }
472         return generator;
473 
474     }
475 
476     /**
477      * Sets the item URL generator for ALL series.
478      *
479      * @param generator  the generator.
480      */
481     public void setItemURLGenerator(CategoryURLGenerator generator) {
482         this.itemURLGenerator = generator;
483     }
484 
485     /**
486      * Sets the URL generator for a series.
487      *
488      * @param series  the series index (zero based).
489      * @param generator  the generator.
490      */
491     public void setSeriesItemURLGenerator(int series, 
492                                           CategoryURLGenerator generator) {
493         this.itemURLGeneratorList.set(series, generator);
494     }
495 
496     /**
497      * Returns the base item URL generator.
498      *
499      * @return The item URL generator.
500      */
501     public CategoryURLGenerator getBaseItemURLGenerator() {
502         return this.baseItemURLGenerator;
503     }
504 
505     /**
506      * Sets the base item URL generator.
507      *
508      * @param generator  the item URL generator.
509      */
510     public void setBaseItemURLGenerator(CategoryURLGenerator generator) {
511         this.baseItemURLGenerator = generator;
512     }
513 
514     /**
515      * Returns the number of rows in the dataset.  This value is updated in the
516      * {@link AbstractCategoryItemRenderer#initialise} method.
517      *
518      * @return The row count.
519      */
520     public int getRowCount() {
521         return this.rowCount;
522     }
523 
524     /**
525      * Returns the number of columns in the dataset.  This value is updated in 
526      * the {@link AbstractCategoryItemRenderer#initialise} method.
527      *
528      * @return The column count.
529      */
530     public int getColumnCount() {
531         return this.columnCount;
532     }
533 
534     /**
535      * Initialises the renderer and returns a state object that will be used 
536      * for the remainder of the drawing process for a single chart.  The state 
537      * object allows for the fact that the renderer may be used simultaneously 
538      * by multiple threads (each thread will work with a separate state object).
539      * <P>
540      * Stores a reference to the {@link PlotRenderingInfo} object (which might 
541      * be <code>null</code>), and then sets the useCategoriesPaint flag 
542      * according to the special case conditions a) there is only one series 
543      * and b) the categoriesPaint array is not null.
544      *
545      * @param g2  the graphics device.
546      * @param dataArea  the data area.
547      * @param plot  the plot.
548      * @param rendererIndex  the renderer index.
549      * @param info  an object for returning information about the structure of 
550      *              the plot (<code>null</code> permitted).
551      * 
552      * @return The renderer state.
553      *
554      */
555     public CategoryItemRendererState initialise(Graphics2D   g2, 
556                                                 Rectangle2D   dataArea,
557                                                 CategoryPlot plot, 
558                                                 int rendererIndex,
559                                                 PlotRenderingInfo info) {
560 
561         setPlot(plot);
562         CategoryDataset data = plot.getDataset(rendererIndex);
563         if (data != null) {
564             this.rowCount = data.getRowCount();
565             this.columnCount = data.getColumnCount();
566         }
567         else {
568             this.rowCount = 0;
569             this.columnCount = 0;
570         }
571         return new CategoryItemRendererState(info);
572 
573     }
574 
575     /**
576      * Returns the range of values the renderer requires to display all the 
577      * items from the specified dataset.
578      * 
579      * @param dataset  the dataset (<code>null</code> permitted).
580      * 
581      * @return The range (or <code>null</code> if the dataset is 
582      *         <code>null</code> or empty).
583      */
584     public Range findRangeBounds(CategoryDataset dataset) {
585         return DatasetUtilities.findRangeBounds(dataset);   
586     }
587 
588     /**
589      * Draws a background for the data area.  The default implementation just 
590      * gets the plot to draw the outline, but some renderers will override this
591      * behaviour.
592      *
593      * @param g2  the graphics device.
594      * @param plot  the plot.
595      * @param dataArea  the data area.
596      */
597     public void drawBackground(Graphics2D   g2,
598                                CategoryPlot plot,
599                                Rectangle2D   dataArea) {
600 
601         plot.drawBackground(g2, dataArea);
602 
603     }
604 
605     /**
606      * Draws an outline for the data area.  The default implementation just 
607      * gets the plot to draw the outline, but some renderers will override this
608      * behaviour.
609      *
610      * @param g2  the graphics device.
611      * @param plot  the plot.
612      * @param dataArea  the data area.
613      */
614     public void drawOutline(Graphics2D   g2,
615                             CategoryPlot plot,
616                             Rectangle2D   dataArea) {
617 
618         plot.drawOutline(g2, dataArea);
619 
620     }
621 
622     /**
623      * Draws a grid line against the domain axis.
624      * <P>
625      * Note that this default implementation assumes that the horizontal axis 
626      * is the domain axis. If this is not the case, you will need to override 
627      * this method.
628      *
629      * @param g2  the graphics device.
630      * @param plot  the plot.
631      * @param dataArea  the area for plotting data (not yet adjusted for any 
632      *                  3D effect).
633      * @param value  the Java2D value at which the grid line should be drawn.
634      */
635     public void drawDomainGridline(Graphics2D   g2,
636                                    CategoryPlot plot,
637                                    Rectangle2D   dataArea,
638                                    double value) {
639 
640         Line2D   line = null;
641         PlotOrientation orientation = plot.getOrientation();
642 
643         if (orientation == PlotOrientation.HORIZONTAL) {
644             line = new Line2D.Double  (dataArea.getMinX(), value, 
645                     dataArea.getMaxX(), value);
646         }
647         else if (orientation == PlotOrientation.VERTICAL) {
648             line = new Line2D.Double  (value, dataArea.getMinY(), value, 
649                     dataArea.getMaxY());
650         }
651 
652         Paint   paint = plot.getDomainGridlinePaint();
653         if (paint == null) {
654             paint = CategoryPlot.DEFAULT_GRIDLINE_PAINT;
655         }
656         g2.setPaint(paint);
657 
658         Stroke   stroke = plot.getDomainGridlineStroke();
659         if (stroke == null) {
660             stroke = CategoryPlot.DEFAULT_GRIDLINE_STROKE;
661         }
662         g2.setStroke(stroke);
663 
664         g2.draw(line);
665 
666     }
667 
668     /**
669      * Draws a grid line against the range axis.
670      *
671      * @param g2  the graphics device.
672      * @param plot  the plot.
673      * @param axis  the value axis.
674      * @param dataArea  the area for plotting data (not yet adjusted for any 
675      *                  3D effect).
676      * @param value  the value at which the grid line should be drawn.
677      *
678      */
679     public void drawRangeGridline(Graphics2D   g2,
680                                   CategoryPlot plot,
681                                   ValueAxis axis,
682                                   Rectangle2D   dataArea,
683                                   double value) {
684 
685         Range range = axis.getRange();
686         if (!range.contains(value)) {
687             return;
688         }
689 
690         PlotOrientation orientation = plot.getOrientation();
691         double v = axis.valueToJava2D(value, dataArea, plot.getRangeAxisEdge());
692         Line2D   line = null;
693         if (orientation == PlotOrientation.HORIZONTAL) {
694             line = new Line2D.Double  (v, dataArea.getMinY(), v, 
695                     dataArea.getMaxY());
696         }
697         else if (orientation == PlotOrientation.VERTICAL) {
698             line = new Line2D.Double  (dataArea.getMinX(), v, 
699                     dataArea.getMaxX(), v);
700         }
701 
702         Paint   paint = plot.getRangeGridlinePaint();
703         if (paint == null) {
704             paint = CategoryPlot.DEFAULT_GRIDLINE_PAINT;
705         }
706         g2.setPaint(paint);
707 
708         Stroke   stroke = plot.getRangeGridlineStroke();
709         if (stroke == null) {
710             stroke = CategoryPlot.DEFAULT_GRIDLINE_STROKE;
711         }
712         g2.setStroke(stroke);
713 
714         g2.draw(line);
715 
716     }
717 
718     /**
719      * Draws a marker for the domain axis.
720      *
721      * @param g2  the graphics device (not <code>null</code>).
722      * @param plot  the plot (not <code>null</code>).
723      * @param axis  the range axis (not <code>null</code>).
724      * @param marker  the marker to be drawn (not <code>null</code>).
725      * @param dataArea  the area inside the axes (not <code>null</code>).
726      */
727     public void drawDomainMarker(Graphics2D   g2,
728                                  CategoryPlot plot,
729                                  CategoryAxis axis,
730                                  CategoryMarker marker,
731                                  Rectangle2D   dataArea) {
732 
733         Comparable   category = marker.getKey();
734         CategoryDataset dataset = plot.getDataset(plot.getIndexOf(this));
735         int columnIndex = dataset.getColumnIndex(category);
736         if (columnIndex < 0) {
737             return;   
738         }
739 
740         final Composite   savedComposite = g2.getComposite();
741         g2.setComposite(AlphaComposite.getInstance(
742                 AlphaComposite.SRC_OVER, marker.getAlpha()));
743         
744         PlotOrientation orientation = plot.getOrientation();
745         Rectangle2D   bounds = null;
746         if (marker.getDrawAsLine()) {
747             double v = axis.getCategoryMiddle(columnIndex, 
748                     dataset.getColumnCount(), dataArea, 
749                     plot.getDomainAxisEdge());
750             Line2D   line = null;
751             if (orientation == PlotOrientation.HORIZONTAL) {
752                 line = new Line2D.Double  (dataArea.getMinX(), v, 
753                         dataArea.getMaxX(), v);
754             }
755             else if (orientation == PlotOrientation.VERTICAL) {
756                 line = new Line2D.Double  (v, dataArea.getMinY(), v, 
757                         dataArea.getMaxY());
758             }
759             g2.setPaint(marker.getPaint());
760             g2.setStroke(marker.getStroke());
761             g2.draw(line);
762             bounds = line.getBounds2D();
763         }
764         else {
765             double v0 = axis.getCategoryStart(columnIndex, 
766                     dataset.getColumnCount(), dataArea, 
767                     plot.getDomainAxisEdge());
768             double v1 = axis.getCategoryEnd(columnIndex, 
769                     dataset.getColumnCount(), dataArea, 
770                     plot.getDomainAxisEdge());
771             Rectangle2D   area = null;
772             if (orientation == PlotOrientation.HORIZONTAL) {
773                 area = new Rectangle2D.Double  (dataArea.getMinX(), v0, 
774                         dataArea.getWidth(), (v1 - v0));
775             }
776             else if (orientation == PlotOrientation.VERTICAL) {
777                 area = new Rectangle2D.Double  (v0, dataArea.getMinY(), 
778                         (v1 - v0), dataArea.getHeight());
779             }
780             g2.setPaint(marker.getPaint());
781             g2.fill(area);
782             bounds = area;
783         }
784         
785         String   label = marker.getLabel();
786         RectangleAnchor anchor = marker.getLabelAnchor();
787         if (label != null) {
788             Font   labelFont = marker.getLabelFont();
789             g2.setFont(labelFont);
790             g2.setPaint(marker.getLabelPaint());
791             Point2D   coordinates = calculateDomainMarkerTextAnchorPoint(
792                     g2, orientation, dataArea, bounds, marker.getLabelOffset(),
793                     marker.getLabelOffsetType(), anchor);
794             TextUtilities.drawAlignedString(label, g2, 
795                     (float) coordinates.getX(), (float) coordinates.getY(), 
796                     marker.getLabelTextAnchor());
797         }
798         g2.setComposite(savedComposite);
799     }
800 
801     /**
802      * Draws a marker for the range axis.
803      *
804      * @param g2  the graphics device (not <code>null</code>).
805      * @param plot  the plot (not <code>null</code>).
806      * @param axis  the range axis (not <code>null</code>).
807      * @param marker  the marker to be drawn (not <code>null</code>).
808      * @param dataArea  the area inside the axes (not <code>null</code>).
809      */
810     public void drawRangeMarker(Graphics2D   g2,
811                                 CategoryPlot plot,
812                                 ValueAxis axis,
813                                 Marker marker,
814                                 Rectangle2D   dataArea) {
815 
816         if (marker instanceof ValueMarker) {
817             ValueMarker vm = (ValueMarker) marker;
818             double value = vm.getValue();
819             Range range = axis.getRange();
820 
821             if (!range.contains(value)) {
822                 return;
823             }
824 
825             final Composite   savedComposite = g2.getComposite();
826             g2.setComposite(AlphaComposite.getInstance(
827                     AlphaComposite.SRC_OVER, marker.getAlpha()));
828 
829             PlotOrientation orientation = plot.getOrientation();
830             double v = axis.valueToJava2D(value, dataArea, 
831                     plot.getRangeAxisEdge());
832             Line2D   line = null;
833             if (orientation == PlotOrientation.HORIZONTAL) {
834                 line = new Line2D.Double  (v, dataArea.getMinY(), v, 
835                         dataArea.getMaxY());
836             }
837             else if (orientation == PlotOrientation.VERTICAL) {
838                 line = new Line2D.Double  (dataArea.getMinX(), v, 
839                         dataArea.getMaxX(), v);
840             }
841 
842             g2.setPaint(marker.getPaint());
843             g2.setStroke(marker.getStroke());
844             g2.draw(line);
845         
846             String   label = marker.getLabel();
847             RectangleAnchor anchor = marker.getLabelAnchor();
848             if (label != null) {
849                 Font   labelFont = marker.getLabelFont();
850                 g2.setFont(labelFont);
851                 g2.setPaint(marker.getLabelPaint());
852                 Point2D   coordinates = calculateRangeMarkerTextAnchorPoint(
853                         g2, orientation, dataArea, line.getBounds2D(), 
854                         marker.getLabelOffset(), LengthAdjustmentType.EXPAND, 
855                         anchor);
856                 TextUtilities.drawAlignedString(label, g2, 
857                         (float) coordinates.getX(), (float) coordinates.getY(), 
858                         marker.getLabelTextAnchor());
859