001    /* ===========================================================
002     * JFreeChart : a free chart library for the Java(tm) platform
003     * ===========================================================
004     *
005     * (C) Copyright 2000-2006, by Object Refinery Limited and Contributors.
006     *
007     * Project Info:  http://www.jfree.org/jfreechart/index.html
008     *
009     * This library is free software; you can redistribute it and/or modify it 
010     * under the terms of the GNU Lesser General Public License as published by 
011     * the Free Software Foundation; either version 2.1 of the License, or 
012     * (at your option) any later version.
013     *
014     * This library is distributed in the hope that it will be useful, but 
015     * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
016     * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 
017     * License for more details.
018     *
019     * You should have received a copy of the GNU Lesser General Public
020     * License along with this library; if not, write to the Free Software
021     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, 
022     * USA.  
023     *
024     * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 
025     * in the United States and other countries.]
026     *
027     * -----------------------
028     * LayeredBarRenderer.java
029     * -----------------------
030     * (C) Copyright 2003-2007, by Arnaud Lelievre and Contributors.
031     *
032     * Original Author:  Arnaud Lelievre (for Garden);
033     * Contributor(s):   David Gilbert (for Object Refinery Limited);
034     *                   Zoheb Borbora;
035     *
036     * Changes
037     * -------
038     * 28-Aug-2003 : Version 1 (AL);
039     * 16-Sep-2003 : Changed ChartRenderingInfo --> PlotRenderingInfo (DG);
040     * 07-Oct-2003 : Added renderer state (DG);
041     * 21-Oct-2003 : Bar width moved to renderer state (DG);
042     * 05-Nov-2004 : Modified drawItem() signature (DG);
043     * 20-Apr-2005 : Renamed CategoryLabelGenerator 
044     *               --> CategoryItemLabelGenerator (DG);
045     * 17-Nov-2005 : Added support for gradient paint (DG);
046     * ------------- JFREECHART 1.0.x ---------------------------------------------
047     * 18-Aug-2006 : Fixed the bar width calculation to respect the maximum bar 
048     *               width setting (thanks to Zoheb Borbora) (DG);
049     * 02-Feb-2007 : Removed author tags all over JFreeChart sources (DG);
050     *
051     */
052    
053    package org.jfree.chart.renderer.category;
054    
055    import java.awt.GradientPaint;
056    import java.awt.Graphics2D;
057    import java.awt.Paint;
058    import java.awt.Stroke;
059    import java.awt.geom.Rectangle2D;
060    import java.io.Serializable;
061    
062    import org.jfree.chart.axis.CategoryAxis;
063    import org.jfree.chart.axis.ValueAxis;
064    import org.jfree.chart.entity.CategoryItemEntity;
065    import org.jfree.chart.entity.EntityCollection;
066    import org.jfree.chart.labels.CategoryItemLabelGenerator;
067    import org.jfree.chart.labels.CategoryToolTipGenerator;
068    import org.jfree.chart.plot.CategoryPlot;
069    import org.jfree.chart.plot.PlotOrientation;
070    import org.jfree.data.category.CategoryDataset;
071    import org.jfree.ui.GradientPaintTransformer;
072    import org.jfree.ui.RectangleEdge;
073    import org.jfree.util.ObjectList;
074    
075    /**
076     * A {@link CategoryItemRenderer} that represents data using bars which are 
077     * superimposed.
078     */
079    public class LayeredBarRenderer extends BarRenderer 
080                                    implements Serializable {
081        
082        /** For serialization. */
083        private static final long serialVersionUID = -8716572894780469487L;
084    
085        /** A list of the width of each series bar. */
086        protected ObjectList seriesBarWidthList;
087    
088        /**
089         * Default constructor.
090         */
091        public LayeredBarRenderer() {
092            super();
093            this.seriesBarWidthList = new ObjectList();
094        }
095    
096        /**
097         * Returns the bar width for a series, or <code>Double.NaN</code> if no
098         * width has been set.
099         *
100         * @param series  the series index (zero based).
101         *
102         * @return The width for the series (1.0=100%, it is the maximum).
103         */
104        public double getSeriesBarWidth(int series) {
105            double result = Double.NaN;
106            Number n = (Number) this.seriesBarWidthList.get(series);
107            if (n != null) {
108                result = n.doubleValue();
109            }
110            return result;
111        }
112    
113        /**
114         * Sets the width of the bars of a series.
115         *
116         * @param series  the series index (zero based).
117         * @param width  the width of the series bar in percentage (1.0=100%, it is 
118         *               the maximum).
119         */ 
120        public void setSeriesBarWidth(int series, double width) {
121            this.seriesBarWidthList.set(series, new Double(width));
122        }
123    
124        /**
125         * Calculates the bar width and stores it in the renderer state.
126         * 
127         * @param plot  the plot.
128         * @param dataArea  the data area.
129         * @param rendererIndex  the renderer index.
130         * @param state  the renderer state.
131         */
132        protected void calculateBarWidth(CategoryPlot plot, 
133                                         Rectangle2D dataArea, 
134                                         int rendererIndex,
135                                         CategoryItemRendererState state) {
136    
137            // calculate the bar width - this calculation differs from the
138            // BarRenderer calculation because the bars are layered on top of one
139            // another, so there is effectively only one bar per category for
140            // the purpose of the bar width calculation
141            CategoryAxis domainAxis = getDomainAxis(plot, rendererIndex);
142            CategoryDataset dataset = plot.getDataset(rendererIndex);
143            if (dataset != null) {
144                int columns = dataset.getColumnCount();
145                int rows = dataset.getRowCount();
146                double space = 0.0;
147                PlotOrientation orientation = plot.getOrientation();
148                if (orientation == PlotOrientation.HORIZONTAL) {
149                    space = dataArea.getHeight();
150                }
151                else if (orientation == PlotOrientation.VERTICAL) {
152                    space = dataArea.getWidth();
153                }
154                double maxWidth = space * getMaximumBarWidth();
155                double categoryMargin = 0.0;
156                if (columns > 1) {
157                    categoryMargin = domainAxis.getCategoryMargin();
158                }
159                double used = space * (1 - domainAxis.getLowerMargin() 
160                    - domainAxis.getUpperMargin() - categoryMargin);
161                if ((rows * columns) > 0) {
162                    state.setBarWidth(Math.min(used / (dataset.getColumnCount()), 
163                            maxWidth));
164                } 
165                else {
166                    state.setBarWidth(Math.min(used, maxWidth));
167                }
168            }
169        }
170    
171        /**
172         * Draws the bar for one item in the dataset.
173         *
174         * @param g2  the graphics device.
175         * @param state  the renderer state.
176         * @param dataArea  the plot area.
177         * @param plot  the plot.
178         * @param domainAxis  the domain (category) axis.
179         * @param rangeAxis  the range (value) axis.
180         * @param data  the data.
181         * @param row  the row index (zero-based).
182         * @param column  the column index (zero-based).
183         * @param pass  the pass index.
184         */
185        public void drawItem(Graphics2D g2,
186                             CategoryItemRendererState state,
187                             Rectangle2D dataArea,
188                             CategoryPlot plot,
189                             CategoryAxis domainAxis,
190                             ValueAxis rangeAxis,
191                             CategoryDataset data,
192                             int row,
193                             int column,
194                             int pass) {
195    
196            PlotOrientation orientation = plot.getOrientation();
197            if (orientation == PlotOrientation.HORIZONTAL) {
198                drawHorizontalItem(g2, state, dataArea, plot, domainAxis, rangeAxis, 
199                    data, row, column);
200            }
201            else if (orientation == PlotOrientation.VERTICAL) {
202                drawVerticalItem(g2, state, dataArea, plot, domainAxis, rangeAxis, 
203                    data, row, column);
204            }
205    
206        }
207    
208        /**
209         * Draws the bar for a single (series, category) data item.
210         *
211         * @param g2  the graphics device.
212         * @param state  the renderer state.
213         * @param dataArea  the data area.
214         * @param plot  the plot.
215         * @param domainAxis  the domain axis.
216         * @param rangeAxis  the range axis.
217         * @param data  the data.
218         * @param row  the row index (zero-based).
219         * @param column  the column index (zero-based).
220         */
221        protected void drawHorizontalItem(Graphics2D g2,
222                                          CategoryItemRendererState state,
223                                          Rectangle2D dataArea,
224                                          CategoryPlot plot,
225                                          CategoryAxis domainAxis,
226                                          ValueAxis rangeAxis,
227                                          CategoryDataset data,
228                                          int row,
229                                          int column) {
230    
231            // nothing is drawn for null values...
232            Number dataValue = data.getValue(row, column);
233            if (dataValue == null) {
234                return;
235            }
236    
237            // X
238            double value = dataValue.doubleValue();
239            double base = 0.0;
240            double lclip = getLowerClip();
241            double uclip = getUpperClip();
242            if (uclip <= 0.0) {  // cases 1, 2, 3 and 4
243                if (value >= uclip) {
244                    return; // bar is not visible
245                }
246                base = uclip;
247                if (value <= lclip) {
248                    value = lclip;
249                }
250            }
251            else if (lclip <= 0.0) { // cases 5, 6, 7 and 8
252                if (value >= uclip) {
253                    value = uclip;
254                }
255                else {
256                    if (value <= lclip) {
257                        value = lclip;
258                    }
259                }
260            }
261            else { // cases 9, 10, 11 and 12
262                if (value <= lclip) {
263                    return; // bar is not visible
264                }
265                base = lclip;
266                if (value >= uclip) {
267                    value = uclip;
268                }
269            }
270    
271            RectangleEdge edge = plot.getRangeAxisEdge();
272            double transX1 = rangeAxis.valueToJava2D(base, dataArea, edge);
273            double transX2 = rangeAxis.valueToJava2D(value, dataArea, edge);
274            double rectX = Math.min(transX1, transX2);
275            double rectWidth = Math.abs(transX2 - transX1);
276    
277            // Y
278            double rectY = domainAxis.getCategoryMiddle(column, getColumnCount(), 
279                    dataArea, plot.getDomainAxisEdge()) - state.getBarWidth() / 2.0;
280    
281            int seriesCount = getRowCount();
282    
283            // draw the bar...
284            double shift = 0.0;
285            double rectHeight = 0.0;
286            double widthFactor = 1.0;
287            double seriesBarWidth = getSeriesBarWidth(row);
288            if (!Double.isNaN(seriesBarWidth)) {
289                widthFactor = seriesBarWidth;
290            } 
291            rectHeight = widthFactor * state.getBarWidth();
292            rectY = rectY + (1 - widthFactor) * state.getBarWidth() / 2.0;
293            if (seriesCount > 1) {
294                shift = rectHeight * 0.20 / (seriesCount - 1);
295            }
296    
297            Rectangle2D bar = new Rectangle2D.Double(rectX, 
298                    (rectY + ((seriesCount - 1 - row) * shift)), rectWidth, 
299                    (rectHeight - (seriesCount - 1 - row) * shift * 2));
300    
301            Paint itemPaint = getItemPaint(row, column);
302            GradientPaintTransformer t = getGradientPaintTransformer();
303            if (t != null && itemPaint instanceof GradientPaint) {
304                itemPaint = t.transform((GradientPaint) itemPaint, bar);
305            }
306            g2.setPaint(itemPaint);
307            g2.fill(bar);
308    
309            // draw the outline...
310            if (isDrawBarOutline() 
311                    && state.getBarWidth() > BAR_OUTLINE_WIDTH_THRESHOLD) {
312                Stroke stroke = getItemOutlineStroke(row, column);
313                Paint paint = getItemOutlinePaint(row, column);
314                if (stroke != null && paint != null) {
315                    g2.setStroke(stroke);
316                    g2.setPaint(paint);
317                    g2.draw(bar);
318                }
319            }
320    
321            CategoryItemLabelGenerator generator 
322                = getItemLabelGenerator(row, column);
323            if (generator != null && isItemLabelVisible(row, column)) {
324                drawItemLabel(g2, data, row, column, plot, generator, bar, 
325                        (transX1 > transX2));
326            }        
327    
328            // collect entity and tool tip information...
329            if (state.getInfo() != null) {
330                EntityCollection entities = state.getEntityCollection();
331                if (entities != null) {
332                    String tip = null;
333                    CategoryToolTipGenerator tipster 
334                        = getToolTipGenerator(row, column);
335                    if (tipster != null) {
336                        tip = tipster.generateToolTip(data, row, column);
337                    }
338                    String url = null;
339                    if (getItemURLGenerator(row, column) != null) {
340                        url = getItemURLGenerator(row, column).generateURL(data, 
341                                row, column);
342                    }
343                    CategoryItemEntity entity = new CategoryItemEntity(bar, tip, 
344                            url, data, row, data.getColumnKey(column), column);
345                    entities.add(entity);
346                }
347            }
348        }
349    
350        /**
351         * Draws the bar for a single (series, category) data item.
352         *
353         * @param g2  the graphics device.
354         * @param state  the renderer state.
355         * @param dataArea  the data area.
356         * @param plot  the plot.
357         * @param domainAxis  the domain axis.
358         * @param rangeAxis  the range axis.
359         * @param data  the data.
360         * @param row  the row index (zero-based).
361         * @param column  the column index (zero-based).
362         */
363        protected void drawVerticalItem(Graphics2D g2,
364                                        CategoryItemRendererState state,
365                                        Rectangle2D dataArea,
366                                        CategoryPlot plot,
367                                        CategoryAxis domainAxis,
368                                        ValueAxis rangeAxis,
369                                        CategoryDataset data,
370                                        int row,
371                                        int column) {
372    
373            // nothing is drawn for null values...
374            Number dataValue = data.getValue(row, column);
375            if (dataValue == null) {
376                return;
377            }
378    
379            // BAR X
380            double rectX = domainAxis.getCategoryMiddle(column, getColumnCount(), 
381                    dataArea, plot.getDomainAxisEdge()) - state.getBarWidth() / 2.0;
382    
383            int seriesCount = getRowCount();
384    
385            // BAR Y
386            double value = dataValue.doubleValue();
387            double base = 0.0;
388            double lclip = getLowerClip();
389            double uclip = getUpperClip();
390    
391            if (uclip <= 0.0) {  // cases 1, 2, 3 and 4
392                if (value >= uclip) {
393                    return; // bar is not visible
394                }
395                base = uclip;
396                if (value <= lclip) {
397                    value = lclip;
398                }
399            }
400            else if (lclip <= 0.0) { // cases 5, 6, 7 and 8
401                if (value >= uclip) {
402                    value = uclip;
403                }
404                else {
405                    if (value <= lclip) {
406                        value = lclip;
407                    }
408                }
409            }
410            else { // cases 9, 10, 11 and 12
411                if (value <= lclip) {
412                    return; // bar is not visible
413                }
414                base = getLowerClip();
415                if (value >= uclip) {
416                   value = uclip;
417                }
418            }
419    
420            RectangleEdge edge = plot.getRangeAxisEdge();
421            double transY1 = rangeAxis.valueToJava2D(base, dataArea, edge);
422            double transY2 = rangeAxis.valueToJava2D(value, dataArea, edge);
423            double rectY = Math.min(transY2, transY1);
424    
425            double rectWidth = state.getBarWidth();
426            double rectHeight = Math.abs(transY2 - transY1);
427    
428            // draw the bar...
429            double shift = 0.0;
430            rectWidth = 0.0;
431            double widthFactor = 1.0;
432            double seriesBarWidth = getSeriesBarWidth(row);
433            if (!Double.isNaN(seriesBarWidth)) {
434                widthFactor = seriesBarWidth;
435            } 
436            rectWidth = widthFactor * state.getBarWidth();
437            rectX = rectX + (1 - widthFactor) * state.getBarWidth() / 2.0;
438            if (seriesCount > 1) {
439                // needs to be improved !!!
440                shift = rectWidth * 0.20 / (seriesCount - 1);
441            }
442    
443            Rectangle2D bar = new Rectangle2D.Double(
444                (rectX + ((seriesCount - 1 - row) * shift)), rectY,
445                (rectWidth - (seriesCount - 1 - row) * shift * 2), rectHeight);
446            Paint itemPaint = getItemPaint(row, column);
447            GradientPaintTransformer t = getGradientPaintTransformer();
448            if (t != null && itemPaint instanceof GradientPaint) {
449                itemPaint = t.transform((GradientPaint) itemPaint, bar);
450            }
451            g2.setPaint(itemPaint);
452            g2.fill(bar);
453    
454            // draw the outline...
455            if (isDrawBarOutline() 
456                    && state.getBarWidth() > BAR_OUTLINE_WIDTH_THRESHOLD) {
457                Stroke stroke = getItemOutlineStroke(row, column);
458                Paint paint = getItemOutlinePaint(row, column);
459                if (stroke != null && paint != null) {
460                    g2.setStroke(stroke);
461                    g2.setPaint(paint);
462                    g2.draw(bar);
463                }
464            }
465    
466            // draw the item labels if there are any...
467            double transX1 = rangeAxis.valueToJava2D(base, dataArea, edge);
468            double transX2 = rangeAxis.valueToJava2D(value, dataArea, edge);
469    
470            CategoryItemLabelGenerator generator 
471                = getItemLabelGenerator(row, column);
472            if (generator != null && isItemLabelVisible(row, column)) {
473                drawItemLabel(g2, data, row, column, plot, generator, bar, 
474                        (transX1 > transX2));
475            }        
476    
477            // collect entity and tool tip information...
478            if (state.getInfo() != null) {
479                EntityCollection entities = state.getEntityCollection();
480                if (entities != null) {
481                    String tip = null;
482                    CategoryToolTipGenerator tipster 
483                        = getToolTipGenerator(row, column);
484                    if (tipster != null) {
485                        tip = tipster.generateToolTip(data, row, column);
486                    }
487                    String url = null;
488                    if (getItemURLGenerator(row, column) != null) {
489                        url = getItemURLGenerator(row, column).generateURL(
490                            data, row, column);
491                    }
492                    CategoryItemEntity entity = new CategoryItemEntity(bar, tip, 
493                            url, data, row, data.getColumnKey(column), column);
494                    entities.add(entity);
495                }
496            }
497        }
498    
499    }