    001    /* ===========================================================
    002     * JFreeChart : a free chart library for the Java(tm) platform
    003     * ===========================================================
    004     *
    005     * (C) Copyright 2000-2007, 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     * ClusteredXYBarRenderer.java
    029     * ---------------------------
    030     * (C) Copyright 2003-2007, by Paolo Cova and Contributors.
    031     *
    032     * Original Author:  Paolo Cova;
    033     * Contributor(s):   David Gilbert (for Object Refinery Limited);
    034     *                   Christian W. Zuckschwerdt;
    035     *                   Matthias Rose;
    036     *
    037     * Changes
    038     * -------
    039     * 24-Jan-2003 : Version 1, contributed by Paolo Cova (DG);
    040     * 25-Mar-2003 : Implemented Serializable (DG);
    041     * 01-May-2003 : Modified drawItem() method signature (DG);
    042     * 30-Jul-2003 : Modified entity constructor (CZ);
    043     * 20-Aug-2003 : Implemented Cloneable and PublicCloneable (DG);
    044     * 16-Sep-2003 : Changed ChartRenderingInfo --> PlotRenderingInfo (DG);
    045     * 07-Oct-2003 : Added renderer state (DG);
    046     * 03-Nov-2003 : In draw method added state parameter and y==null value
    047     *               handling (MR);
    048     * 25-Feb-2004 : Replaced CrosshairInfo with CrosshairState (DG);
    049     * 15-Jul-2004 : Switched getX() with getXValue() and getY() with
    050     *               getYValue() (DG);
    051     * 01-Oct-2004 : Fixed bug where 'drawBarOutline' flag is ignored (DG);
    052     * 16-May-2005 : Fixed to used outline stroke for bar outlines.  Removed some
    053     *               redundant code with the result that the renderer now respects
    054     *               the 'base' setting from the super-class. Added an equals()
    055     *               method (DG);
    056     * 19-May-2005 : Added minimal item label implementation - needs improving (DG);
    057     * ------------- JFREECHART 1.0.x ---------------------------------------------
    058     * 11-Dec-2006 : Added support for GradientPaint (DG);
    059     * 12-Jun-2007 : Added override to findDomainBounds() to handle cluster offset,
    060     *               fixed rendering to handle inverted axes, and simplified
    061     *               entity generation code (DG);
    062     *
    063     */
    064
    065    package org.jfree.chart.renderer.xy;
    066
    067    import java.awt.GradientPaint;
    068    import java.awt.Graphics2D;
    069    import java.awt.Paint;
    070    import java.awt.geom.Rectangle2D;
    071    import java.io.Serializable;
    072
    073    import org.jfree.chart.axis.ValueAxis;
    074    import org.jfree.chart.entity.EntityCollection;
    075    import org.jfree.chart.labels.XYItemLabelGenerator;
    076    import org.jfree.chart.plot.CrosshairState;
    077    import org.jfree.chart.plot.PlotOrientation;
    078    import org.jfree.chart.plot.PlotRenderingInfo;
    079    import org.jfree.chart.plot.XYPlot;
    080    import org.jfree.data.Range;
    081    import org.jfree.data.xy.IntervalXYDataset;
    082    import org.jfree.data.xy.XYDataset;
    083    import org.jfree.ui.RectangleEdge;
    084    import org.jfree.util.PublicCloneable;
    085
    086    /**
    087     * An extension of {@link XYBarRenderer} that displays bars for different
    088     * series values at the same x next to each other. The assumption here is
    089     * that for each x (time or else) there is a y value for each series. If
    090     * this is not the case, there will be spaces between bars for a given x.
    091     * <P>
    092     * This renderer does not include code to calculate the crosshair point for the
    093     * plot.
    094     */
    095    public class ClusteredXYBarRenderer extends XYBarRenderer
    096            implements Cloneable, PublicCloneable, Serializable {
    097
    098        /** For serialization. */
    099        private static final long serialVersionUID = 5864462149177133147L;
    100
    101        /** Determines whether bar center should be interval start. */
    102        private boolean centerBarAtStartValue;
    103
    104        /**
    105         * Default constructor. Bar margin is set to 0.0.
    106         */
    107        public ClusteredXYBarRenderer() {
    108            this(0.0, false);
    109        }
    110
    111        /**
    112         * Constructs a new XY clustered bar renderer.
    113         *
    114         * @param margin  the percentage amount to trim from the width of each bar.
    115         * @param centerBarAtStartValue  if true, bars will be centered on the
    116         *         start of the time period.
    117         */
    118        public ClusteredXYBarRenderer(double margin,
    119                                      boolean centerBarAtStartValue) {
    120            super(margin);
    121            this.centerBarAtStartValue = centerBarAtStartValue;
    122        }
    123
    124        /**
    125         * Returns the x-value bounds for the specified dataset.
    126         *
    127         * @param dataset  the dataset (<code>null</code> permitted).
    128         *
    129         * @return The bounds (possibly <code>null</code>).
    130         */
    131        public Range findDomainBounds(XYDataset dataset) {
    132            if (dataset == null) {
    133                return null;
    134            }
    135            // need to handle cluster centering as a special case
    136            if (this.centerBarAtStartValue) {
    137                return findDomainBoundsWithOffset((IntervalXYDataset) dataset);
    138            }
    139            else {
    140                return super.findDomainBounds(dataset);
    141            }
    142        }
    143
    144        /**
    145         * Iterates over the items in an {@link IntervalXYDataset} to find
    146         * the range of x-values including the interval OFFSET so that it centers
    147         * the interval around the start value.
    148         *
    149         * @param dataset  the dataset (<code>null</code> not permitted).
    150         *
    151         * @return The range (possibly <code>null</code>).
    152         */
    153        protected Range findDomainBoundsWithOffset(IntervalXYDataset dataset) {
    154            if (dataset == null) {
    155                throw new IllegalArgumentException("Null 'dataset' argument.");
    156            }
    157            double minimum = Double.POSITIVE_INFINITY;
    158            double maximum = Double.NEGATIVE_INFINITY;
    159            int seriesCount = dataset.getSeriesCount();
    160            double lvalue;
    161            double uvalue;
    162            for (int series = 0; series < seriesCount; series++) {
    163                int itemCount = dataset.getItemCount(series);
    164                for (int item = 0; item < itemCount; item++) {
    165                    lvalue = dataset.getStartXValue(series, item);
    166                    uvalue = dataset.getEndXValue(series, item);
    167                    double offset = (uvalue - lvalue) / 2.0;
    168                    lvalue = lvalue - offset;
    169                    uvalue = uvalue - offset;
    170                    minimum = Math.min(minimum, lvalue);
    171                    maximum = Math.max(maximum, uvalue);
    172                }
    173            }
    174
    175            if (minimum > maximum) {
    176                return null;
    177            }
    178            else {
    179                return new Range(minimum, maximum);
    180            }
    181        }
    182
    183        /**
    184         * Draws the visual representation of a single data item. This method
    185         * is mostly copied from the superclass, the change is that in the
    186         * calculated space for a singe bar we draw bars for each series next to
    187         * each other. The width of each bar is the available width divided by
    188         * the number of series. Bars for each series are drawn in order left to
    189         * right.
    190         *
    191         * @param g2  the graphics device.
    192         * @param state  the renderer state.
    193         * @param dataArea  the area within which the plot is being drawn.
    194         * @param info  collects information about the drawing.
    195         * @param plot  the plot (can be used to obtain standard color
    196         *              information etc).
    197         * @param domainAxis  the domain axis.
    198         * @param rangeAxis  the range axis.
    199         * @param dataset  the dataset.
    200         * @param series  the series index.
    201         * @param item  the item index.
    202         * @param crosshairState  crosshair information for the plot
    203         *                        (<code>null</code> permitted).
    204         * @param pass  the pass index.
    205         */
    206        public void drawItem(Graphics2D g2,
    207                             XYItemRendererState state,
    208                             Rectangle2D dataArea,
    209                             PlotRenderingInfo info,
    210                             XYPlot plot,
    211                             ValueAxis domainAxis,
    212                             ValueAxis rangeAxis,
    213                             XYDataset dataset, int series, int item,
    214                             CrosshairState crosshairState,
    215                             int pass) {
    216
    217            IntervalXYDataset intervalDataset = (IntervalXYDataset) dataset;
    218
    219            double y0;
    220            double y1;
    221            if (getUseYInterval()) {
    222                y0 = intervalDataset.getStartYValue(series, item);
    223                y1 = intervalDataset.getEndYValue(series, item);
    224            }
    225            else {
    226                y0 = getBase();
    227                y1 = intervalDataset.getYValue(series, item);
    228            }
    229            if (Double.isNaN(y0) || Double.isNaN(y1)) {
    230                return;
    231            }
    232
    233            double yy0 = rangeAxis.valueToJava2D(y0, dataArea,
    234                    plot.getRangeAxisEdge());
    235            double yy1 = rangeAxis.valueToJava2D(y1, dataArea,
    236                    plot.getRangeAxisEdge());
    237
    238            RectangleEdge xAxisLocation = plot.getDomainAxisEdge();
    239            double x0 = intervalDataset.getStartXValue(series, item);
    240            double xx0 = domainAxis.valueToJava2D(x0, dataArea, xAxisLocation);
    241
    242            double x1 = intervalDataset.getEndXValue(series, item);
    243            double xx1 = domainAxis.valueToJava2D(x1, dataArea, xAxisLocation);
    244
    245            double intervalW = xx1 - xx0;  // this may be negative
    246            double baseX = xx0;
    247            if (this.centerBarAtStartValue) {
    248                baseX = baseX - intervalW / 2.0;
    249            }
    250            double m = getMargin();
    251            if (m > 0.0) {
    252                double cut = intervalW * getMargin();
    253                intervalW = intervalW - cut;
    254                baseX = baseX + (cut / 2);
    255            }
    256
    257            double intervalH = Math.abs(yy0 - yy1);  // we don't need the sign
    258
    259            PlotOrientation orientation = plot.getOrientation();
    260
    261            int numSeries = dataset.getSeriesCount();
    262            double seriesBarWidth = intervalW / numSeries;  // may be negative
    263
    264            Rectangle2D bar = null;
    265            if (orientation == PlotOrientation.HORIZONTAL) {
    266                double barY0 = baseX + (seriesBarWidth * series);
    267                double barY1 = barY0 + seriesBarWidth;
    268                double rx = Math.min(yy0, yy1);
    269                double rw = intervalH;
    270                double ry = Math.min(barY0, barY1);
    271                double rh = Math.abs(barY1 - barY0);
    272                bar = new Rectangle2D.Double(rx, ry, rw, rh);
    273            }
    274            else if (orientation == PlotOrientation.VERTICAL) {
    275                double barX0 = baseX + (seriesBarWidth * series);
    276                double barX1 = barX0 + seriesBarWidth;
    277                double rx = Math.min(barX0, barX1);
    278                double rw = Math.abs(barX1 - barX0);
    279                double ry = Math.min(yy0, yy1);
    280                double rh = intervalH;
    281                bar = new Rectangle2D.Double(rx, ry, rw, rh);
    282            }
    283            Paint itemPaint = getItemPaint(series, item);
    284            if (getGradientPaintTransformer()
    285                    != null && itemPaint instanceof GradientPaint) {
    286                GradientPaint gp = (GradientPaint) itemPaint;
    287                itemPaint = getGradientPaintTransformer().transform(gp, bar);
    288            }
    289            g2.setPaint(itemPaint);
    290
    291            g2.fill(bar);
    292            if (isDrawBarOutline() && Math.abs(seriesBarWidth) > 3) {
    293                g2.setStroke(getItemOutlineStroke(series, item));
    294                g2.setPaint(getItemOutlinePaint(series, item));
    295                g2.draw(bar);
    296            }
    297
    298            if (isItemLabelVisible(series, item)) {
    299                XYItemLabelGenerator generator = getItemLabelGenerator(series,
    300                        item);
    301                drawItemLabel(g2, dataset, series, item, plot, generator, bar,
    302                        y1 < 0.0);
    303            }
    304
    305            // add an entity for the item...
    306            if (info != null) {
    307                EntityCollection entities = info.getOwner().getEntityCollection();
    308                if (entities != null) {
    309                    addEntity(entities, bar, dataset, series, item,
    310                            bar.getCenterX(), bar.getCenterY());
    311                }
    312            }
    313
    314        }
    315
    316        /**
    317         * Tests this renderer for equality with an arbitrary object, returning
    318         * <code>true</code> if <code>obj</code> is a
    319         * <code>ClusteredXYBarRenderer</code> with the same settings as this
    320         * renderer, and <code>false</code> otherwise.
    321         *
    322         * @param obj  the object (<code>null</code> permitted).
    323         *
    324         * @return A boolean.
    325         */
    326        public boolean equals(Object obj) {
    327            if (obj == this) {
    328                return true;
    329            }
    330            if (!(obj instanceof ClusteredXYBarRenderer)) {
    331                return false;
    332            }
    333            ClusteredXYBarRenderer that = (ClusteredXYBarRenderer) obj;
    334            if (this.centerBarAtStartValue != that.centerBarAtStartValue) {
    335                return false;
    336            }
    337            return super.equals(obj);
    338        }
    339
    340        /**
    341         * Returns a clone of the renderer.
    342         *
    343         * @return A clone.
    344         *
    345         * @throws CloneNotSupportedException  if the renderer cannot be cloned.
    346         */
    347        public Object clone() throws CloneNotSupportedException {
    348            return super.clone();
    349        }
    350
    351    }