    001    /* ===========================================================
    002     * JFreeChart : a free chart library for the Java(tm) platform
    003     * ===========================================================
    004     *
    005     * (C) Copyright 2000-2009, 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     * GradientXYBarPainter.java
    029     * -------------------------
    030     * (C) Copyright 2008, 2009, by Object Refinery Limited.
    031     *
    032     * Original Author:  David Gilbert (for Object Refinery Limited);
    033     * Contributor(s):   -;
    034     *
    035     * Changes:
    036     * --------
    037     * 19-Jun-2008 : Version 1 (DG);
    038     * 22-Feb-2009 : Fixed bug drawing outlines (DG);
    039     *
    040     */
    041
    042    package org.jfree.chart.renderer.xy;
    043
    044    import java.awt.Color;
    045    import java.awt.GradientPaint;
    046    import java.awt.Graphics2D;
    047    import java.awt.Paint;
    048    import java.awt.Stroke;
    049    import java.awt.geom.Rectangle2D;
    050    import java.awt.geom.RectangularShape;
    051    import java.io.Serializable;
    052
    053    import org.jfree.chart.HashUtilities;
    054    import org.jfree.ui.RectangleEdge;
    055
    056    /**
    057     * An implementation of the {@link XYBarPainter} interface that uses several
    058     * gradient fills to enrich the appearance of the bars.
    059     *
    060     * @since 1.0.11
    061     */
    062    public class GradientXYBarPainter implements XYBarPainter, Serializable {
    063
    064        /** The division point between the first and second gradient regions. */
    065        private double g1;
    066
    067        /** The division point between the second and third gradient regions. */
    068        private double g2;
    069
    070        /** The division point between the third and fourth gradient regions. */
    071        private double g3;
    072
    073        /**
    074         * Creates a new instance.
    075         */
    076        public GradientXYBarPainter() {
    077            this(0.10, 0.20, 0.80);
    078        }
    079
    080        /**
    081         * Creates a new instance.
    082         *
    083         * @param g1
    084         * @param g2
    085         * @param g3
    086         */
    087        public GradientXYBarPainter(double g1, double g2, double g3) {
    088            this.g1 = g1;
    089            this.g2 = g2;
    090            this.g3 = g3;
    091        }
    092
    093        /**
    094         * Paints a single bar instance.
    095         *
    096         * @param g2  the graphics target.
    097         * @param renderer  the renderer.
    098         * @param row  the row index.
    099         * @param column  the column index.
    100         * @param bar  the bar
    101         * @param base  indicates which side of the rectangle is the base of the
    102         *              bar.
    103         */
    104        public void paintBar(Graphics2D g2, XYBarRenderer renderer, int row,
    105                int column, RectangularShape bar, RectangleEdge base) {
    106
    107            Paint itemPaint = renderer.getItemPaint(row, column);
    108
    109            Color c0, c1;
    110            if (itemPaint instanceof Color) {
    111                c0 = (Color) itemPaint;
    112                c1 = c0.brighter();
    113            }
    114            else if (itemPaint instanceof GradientPaint) {
    115                GradientPaint gp = (GradientPaint) itemPaint;
    116                c0 = gp.getColor1();
    117                c1 = gp.getColor2();
    118            }
    119            else {
    120                c0 = Color.blue;
    121                c1 = Color.blue.brighter();
    122            }
    123
    124            // as a special case, if the bar colour has alpha == 0, we draw
    125            // nothing.
    126            if (c0.getAlpha() == 0) {
    127                return;
    128            }
    129
    130            if (base == RectangleEdge.TOP || base == RectangleEdge.BOTTOM) {
    131                Rectangle2D[] regions = splitVerticalBar(bar, this.g1, this.g2,
    132                        this.g3);
    133                GradientPaint gp = new GradientPaint((float) regions[0].getMinX(),
    134                        0.0f, c0, (float) regions[0].getMaxX(), 0.0f, Color.white);
    135                g2.setPaint(gp);
    136                g2.fill(regions[0]);
    137
    138                gp = new GradientPaint((float) regions[1].getMinX(), 0.0f,
    139                        Color.white, (float) regions[1].getMaxX(), 0.0f, c0);
    140                g2.setPaint(gp);
    141                g2.fill(regions[1]);
    142
    143                gp = new GradientPaint((float) regions[2].getMinX(), 0.0f, c0,
    144                        (float) regions[2].getMaxX(), 0.0f, c1);
    145                g2.setPaint(gp);
    146                g2.fill(regions[2]);
    147
    148                gp = new GradientPaint((float) regions[3].getMinX(), 0.0f, c1,
    149                         (float) regions[3].getMaxX(), 0.0f, c0);
    150                g2.setPaint(gp);
    151                g2.fill(regions[3]);
    152            }
    153            else if (base == RectangleEdge.LEFT || base == RectangleEdge.RIGHT) {
    154                Rectangle2D[] regions = splitHorizontalBar(bar, this.g1, this.g2,
    155                        this.g3);
    156                GradientPaint gp = new GradientPaint(0.0f,
    157                        (float) regions[0].getMinY(), c0, 0.0f,
    158                        (float) regions[0].getMaxX(), Color.white);
    159                g2.setPaint(gp);
    160                g2.fill(regions[0]);
    161
    162                gp = new GradientPaint(0.0f, (float) regions[1].getMinY(),
    163                        Color.white, 0.0f, (float) regions[1].getMaxY(), c0);
    164                g2.setPaint(gp);
    165                g2.fill(regions[1]);
    166
    167                gp = new GradientPaint(0.0f, (float) regions[2].getMinY(), c0,
    168                        0.0f, (float) regions[2].getMaxY(), c1);
    169                g2.setPaint(gp);
    170                g2.fill(regions[2]);
    171
    172                gp = new GradientPaint(0.0f, (float) regions[3].getMinY(), c1,
    173                         0.0f, (float) regions[3].getMaxY(), c0);
    174                g2.setPaint(gp);
    175                g2.fill(regions[3]);
    176
    177            }
    178
    179            // draw the outline...
    180            if (renderer.isDrawBarOutline()) {
    181                Stroke stroke = renderer.getItemOutlineStroke(row, column);
    182                Paint paint = renderer.getItemOutlinePaint(row, column);
    183                if (stroke != null && paint != null) {
    184                    g2.setStroke(stroke);
    185                    g2.setPaint(paint);
    186                    g2.draw(bar);
    187                }
    188            }
    189
    190        }
    191
    192        /**
    193         * Paints a single bar instance.
    194         *
    195         * @param g2  the graphics target.
    196         * @param renderer  the renderer.
    197         * @param row  the row index.
    198         * @param column  the column index.
    199         * @param bar  the bar
    200         * @param base  indicates which side of the rectangle is the base of the
    201         *              bar.
    202         * @param pegShadow  peg the shadow to the base of the bar?
    203         */
    204        public void paintBarShadow(Graphics2D g2, XYBarRenderer renderer, int row,
    205                int column, RectangularShape bar, RectangleEdge base,
    206                boolean pegShadow) {
    207
    208            // handle a special case - if the bar colour has alpha == 0, it is
    209            // invisible so we shouldn't draw any shadow
    210            Paint itemPaint = renderer.getItemPaint(row, column);
    211            if (itemPaint instanceof Color) {
    212                Color c = (Color) itemPaint;
    213                if (c.getAlpha() == 0) {
    214                    return;
    215                }
    216            }
    217
    218            RectangularShape shadow = createShadow(bar, renderer.getShadowXOffset(),
    219                    renderer.getShadowYOffset(), base, pegShadow);
    220            g2.setPaint(Color.gray);
    221            g2.fill(shadow);
    222
    223        }
    224
    225        /**
    226         * Creates a shadow for the bar.
    227         *
    228         * @param bar  the bar shape.
    229         * @param xOffset  the x-offset for the shadow.
    230         * @param yOffset  the y-offset for the shadow.
    231         * @param base  the edge that is the base of the bar.
    232         * @param pegShadow  peg the shadow to the base?
    233         *
    234         * @return A rectangle for the shadow.
    235         */
    236        private Rectangle2D createShadow(RectangularShape bar, double xOffset,
    237                double yOffset, RectangleEdge base, boolean pegShadow) {
    238            double x0 = bar.getMinX();
    239            double x1 = bar.getMaxX();
    240            double y0 = bar.getMinY();
    241            double y1 = bar.getMaxY();
    242            if (base == RectangleEdge.TOP) {
    243                x0 += xOffset;
    244                x1 += xOffset;
    245                if (!pegShadow) {
    246                    y0 += yOffset;
    247                }
    248                y1 += yOffset;
    249            }
    250            else if (base == RectangleEdge.BOTTOM) {
    251                x0 += xOffset;
    252                x1 += xOffset;
    253                y0 += yOffset;
    254                if (!pegShadow) {
    255                    y1 += yOffset;
    256                }
    257            }
    258            else if (base == RectangleEdge.LEFT) {
    259                if (!pegShadow) {
    260                    x0 += xOffset;
    261                }
    262                x1 += xOffset;
    263                y0 += yOffset;
    264                y1 += yOffset;
    265            }
    266            else if (base == RectangleEdge.RIGHT) {
    267                x0 += xOffset;
    268                if (!pegShadow) {
    269                    x1 += xOffset;
    270                }
    271                y0 += yOffset;
    272                y1 += yOffset;
    273            }
    274            return new Rectangle2D.Double(x0, y0, (x1 - x0), (y1 - y0));
    275        }
    276
    277        /**
    278         * Splits a bar into subregions (elsewhere, these subregions will have
    279         * different gradients applied to them).
    280         *
    281         * @param bar  the bar shape.
    282         * @param a  the first division.
    283         * @param b  the second division.
    284         * @param c  the third division.
    285         *
    286         * @return An array containing four subregions.
    287         */
    288        private Rectangle2D[] splitVerticalBar(RectangularShape bar, double a,
    289                double b, double c) {
    290            Rectangle2D[] result = new Rectangle2D[4];
    291            double x0 = bar.getMinX();
    292            double x1 = Math.rint(x0 + (bar.getWidth() * a));
    293            double x2 = Math.rint(x0 + (bar.getWidth() * b));
    294            double x3 = Math.rint(x0 + (bar.getWidth() * c));
    295            result[0] = new Rectangle2D.Double(bar.getMinX(), bar.getMinY(),
    296                    x1 - x0, bar.getHeight());
    297            result[1] = new Rectangle2D.Double(x1, bar.getMinY(), x2 - x1,
    298                    bar.getHeight());
    299            result[2] = new Rectangle2D.Double(x2, bar.getMinY(), x3 - x2,
    300                    bar.getHeight());
    301            result[3] = new Rectangle2D.Double(x3, bar.getMinY(),
    302                    bar.getMaxX() - x3, bar.getHeight());
    303            return result;
    304        }
    305
    306        /**
    307         * Splits a bar into subregions (elsewhere, these subregions will have
    308         * different gradients applied to them).
    309         *
    310         * @param bar  the bar shape.
    311         * @param a  the first division.
    312         * @param b  the second division.
    313         * @param c  the third division.
    314         *
    315         * @return An array containing four subregions.
    316         */
    317        private Rectangle2D[] splitHorizontalBar(RectangularShape bar, double a,
    318                double b, double c) {
    319            Rectangle2D[] result = new Rectangle2D[4];
    320            double y0 = bar.getMinY();
    321            double y1 = Math.rint(y0 + (bar.getHeight() * a));
    322            double y2 = Math.rint(y0 + (bar.getHeight() * b));
    323            double y3 = Math.rint(y0 + (bar.getHeight() * c));
    324            result[0] = new Rectangle2D.Double(bar.getMinX(), bar.getMinY(),
    325                    bar.getWidth(), y1 - y0);
    326            result[1] = new Rectangle2D.Double(bar.getMinX(), y1, bar.getWidth(),
    327                    y2 - y1);
    328            result[2] = new Rectangle2D.Double(bar.getMinX(), y2, bar.getWidth(),
    329                    y3 - y2);
    330            result[3] = new Rectangle2D.Double(bar.getMinX(), y3, bar.getWidth(),
    331                    bar.getMaxY() - y3);
    332            return result;
    333        }
    334
    335        /**
    336         * Tests this instance for equality with an arbitrary object.
    337         *
    338         * @param obj  the obj (<code>null</code> permitted).
    339         *
    340         * @return A boolean.
    341         */
    342        public boolean equals(Object obj) {
    343            if (obj == this) {
    344                return true;
    345            }
    346            if (!(obj instanceof GradientXYBarPainter)) {
    347                return false;
    348            }
    349            GradientXYBarPainter that = (GradientXYBarPainter) obj;
    350            if (this.g1 != that.g1) {
    351                return false;
    352            }
    353            if (this.g2 != that.g2) {
    354                return false;
    355            }
    356            if (this.g3 != that.g3) {
    357                return false;
    358            }
    359            return true;
    360        }
    361
    362        /**
    363         * Returns a hash code for this instance.
    364         *
    365         * @return A hash code.
    366         */
    367        public int hashCode() {
    368            int hash = 37;
    369            hash = HashUtilities.hashCode(hash, this.g1);
    370            hash = HashUtilities.hashCode(hash, this.g2);
    371            hash = HashUtilities.hashCode(hash, this.g3);
    372            return hash;
    373        }
    374
    375    }