    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     * DefaultDrawingSupplier.java
    029     * ---------------------------
    030     * (C) Copyright 2003-2007, by Object Refinery Limited.
    031     *
    032     * Original Author:  David Gilbert (for Object Refinery Limited);
    033     * Contributor(s):   Jeremy Bowman;
    034     *
    035     * Changes
    036     * -------
    037     * 16-Jan-2003 : Version 1 (DG);
    038     * 17-Jan-2003 : Added stroke method, renamed DefaultPaintSupplier
    039     *               --> DefaultDrawingSupplier (DG)
    040     * 27-Jan-2003 : Incorporated code from SeriesShapeFactory, originally
    041     *               contributed by Jeremy Bowman (DG);
    042     * 25-Mar-2003 : Implemented Serializable (DG);
    043     * 20-Aug-2003 : Implemented Cloneable and PublicCloneable (DG);
    044     * ------------- JFREECHART 1.0.x ---------------------------------------------
    045     * 13-Jun-2007 : Added fillPaintSequence (DG);
    046     *
    047     */
    048
    049     package org.jfree.chart.plot;
    050
    051    import java.awt.BasicStroke;
    052    import java.awt.Color;
    053    import java.awt.Paint;
    054    import java.awt.Polygon;
    055    import java.awt.Shape;
    056    import java.awt.Stroke;
    057    import java.awt.geom.Ellipse2D;
    058    import java.awt.geom.Rectangle2D;
    059    import java.io.IOException;
    060    import java.io.ObjectInputStream;
    061    import java.io.ObjectOutputStream;
    062    import java.io.Serializable;
    063    import java.util.Arrays;
    064
    065    import org.jfree.chart.ChartColor;
    066    import org.jfree.io.SerialUtilities;
    067    import org.jfree.util.PublicCloneable;
    068    import org.jfree.util.ShapeUtilities;
    069
    070    /**
    071     * A default implementation of the {@link DrawingSupplier} interface.  All
    072     * {@link Plot} instances have a new instance of this class installed by
    073     * default.
    074     */
    075    public class DefaultDrawingSupplier implements DrawingSupplier, Cloneable,
    076            PublicCloneable, Serializable {
    077
    078        /** For serialization. */
    079        private static final long serialVersionUID = -7339847061039422538L;
    080
    081        /** The default fill paint sequence. */
    082        public static final Paint[] DEFAULT_PAINT_SEQUENCE
    083                = ChartColor.createDefaultPaintArray();
    084
    085        /** The default outline paint sequence. */
    086        public static final Paint[] DEFAULT_OUTLINE_PAINT_SEQUENCE = new Paint[] {
    087                Color.lightGray};
    088
    089        /** The default fill paint sequence. */
    090        public static final Paint[] DEFAULT_FILL_PAINT_SEQUENCE = new Paint[] {
    091                Color.white};
    092
    093        /** The default stroke sequence. */
    094        public static final Stroke[] DEFAULT_STROKE_SEQUENCE = new Stroke[] {
    095                new BasicStroke(1.0f, BasicStroke.CAP_SQUARE,
    096                        BasicStroke.JOIN_BEVEL)};
    097
    098        /** The default outline stroke sequence. */
    099        public static final Stroke[] DEFAULT_OUTLINE_STROKE_SEQUENCE
    100                = new Stroke[] {new BasicStroke(1.0f, BasicStroke.CAP_SQUARE,
    101                        BasicStroke.JOIN_BEVEL)};
    102
    103        /** The default shape sequence. */
    104        public static final Shape[] DEFAULT_SHAPE_SEQUENCE
    105                = createStandardSeriesShapes();
    106
    107        /** The paint sequence. */
    108        private transient Paint[] paintSequence;
    109
    110        /** The current paint index. */
    111        private int paintIndex;
    112
    113        /** The outline paint sequence. */
    114        private transient Paint[] outlinePaintSequence;
    115
    116        /** The current outline paint index. */
    117        private int outlinePaintIndex;
    118
    119        /** The fill paint sequence. */
    120        private transient Paint[] fillPaintSequence;
    121
    122        /** The current fill paint index. */
    123        private int fillPaintIndex;
    124
    125        /** The stroke sequence. */
    126        private transient Stroke[] strokeSequence;
    127
    128        /** The current stroke index. */
    129        private int strokeIndex;
    130
    131        /** The outline stroke sequence. */
    132        private transient Stroke[] outlineStrokeSequence;
    133
    134        /** The current outline stroke index. */
    135        private int outlineStrokeIndex;
    136
    137        /** The shape sequence. */
    138        private transient Shape[] shapeSequence;
    139
    140        /** The current shape index. */
    141        private int shapeIndex;
    142
    143        /**
    144         * Creates a new supplier, with default sequences for fill paint, outline
    145         * paint, stroke and shapes.
    146         */
    147        public DefaultDrawingSupplier() {
    148
    149            this(DEFAULT_PAINT_SEQUENCE, DEFAULT_FILL_PAINT_SEQUENCE,
    150                 DEFAULT_OUTLINE_PAINT_SEQUENCE,
    151                 DEFAULT_STROKE_SEQUENCE,
    152                 DEFAULT_OUTLINE_STROKE_SEQUENCE,
    153                 DEFAULT_SHAPE_SEQUENCE);
    154
    155        }
    156
    157        /**
    158         * Creates a new supplier.
    159         *
    160         * @param paintSequence  the fill paint sequence.
    161         * @param outlinePaintSequence  the outline paint sequence.
    162         * @param strokeSequence  the stroke sequence.
    163         * @param outlineStrokeSequence  the outline stroke sequence.
    164         * @param shapeSequence  the shape sequence.
    165         */
    166        public DefaultDrawingSupplier(Paint[] paintSequence,
    167                                      Paint[] outlinePaintSequence,
    168                                      Stroke[] strokeSequence,
    169                                      Stroke[] outlineStrokeSequence,
    170                                      Shape[] shapeSequence) {
    171
    172            this.paintSequence = paintSequence;
    173            this.fillPaintSequence = DEFAULT_FILL_PAINT_SEQUENCE;
    174            this.outlinePaintSequence = outlinePaintSequence;
    175            this.strokeSequence = strokeSequence;
    176            this.outlineStrokeSequence = outlineStrokeSequence;
    177            this.shapeSequence = shapeSequence;
    178
    179        }
    180
    181        /**
    182         * Creates a new supplier.
    183         *
    184         * @param paintSequence  the paint sequence.
    185         * @param fillPaintSequence  the fill paint sequence.
    186         * @param outlinePaintSequence  the outline paint sequence.
    187         * @param strokeSequence  the stroke sequence.
    188         * @param outlineStrokeSequence  the outline stroke sequence.
    189         * @param shapeSequence  the shape sequence.
    190         *
    191         * @since 1.0.6
    192         */
    193        public DefaultDrawingSupplier(Paint[] paintSequence,
    194                Paint[] fillPaintSequence, Paint[] outlinePaintSequence,
    195                Stroke[] strokeSequence, Stroke[] outlineStrokeSequence,
    196                Shape[] shapeSequence) {
    197
    198            this.paintSequence = paintSequence;
    199            this.fillPaintSequence = fillPaintSequence;
    200            this.outlinePaintSequence = outlinePaintSequence;
    201            this.strokeSequence = strokeSequence;
    202            this.outlineStrokeSequence = outlineStrokeSequence;
    203            this.shapeSequence = shapeSequence;
    204        }
    205
    206        /**
    207         * Returns the next paint in the sequence.
    208         *
    209         * @return The paint.
    210         */
    211        public Paint getNextPaint() {
    212            Paint result
    213                = this.paintSequence[this.paintIndex % this.paintSequence.length];
    214            this.paintIndex++;
    215            return result;
    216        }
    217
    218        /**
    219         * Returns the next outline paint in the sequence.
    220         *
    221         * @return The paint.
    222         */
    223        public Paint getNextOutlinePaint() {
    224            Paint result = this.outlinePaintSequence[
    225                    this.outlinePaintIndex % this.outlinePaintSequence.length];
    226            this.outlinePaintIndex++;
    227            return result;
    228        }
    229
    230        /**
    231         * Returns the next fill paint in the sequence.
    232         *
    233         * @return The paint.
    234         *
    235         * @since 1.0.6
    236         */
    237        public Paint getNextFillPaint() {
    238            Paint result = this.fillPaintSequence[this.fillPaintIndex
    239                    % this.fillPaintSequence.length];
    240            this.fillPaintIndex++;
    241            return result;
    242        }
    243
    244        /**
    245         * Returns the next stroke in the sequence.
    246         *
    247         * @return The stroke.
    248         */
    249        public Stroke getNextStroke() {
    250            Stroke result = this.strokeSequence[
    251                    this.strokeIndex % this.strokeSequence.length];
    252            this.strokeIndex++;
    253            return result;
    254        }
    255
    256        /**
    257         * Returns the next outline stroke in the sequence.
    258         *
    259         * @return The stroke.
    260         */
    261        public Stroke getNextOutlineStroke() {
    262            Stroke result = this.outlineStrokeSequence[
    263                    this.outlineStrokeIndex % this.outlineStrokeSequence.length];
    264            this.outlineStrokeIndex++;
    265            return result;
    266        }
    267
    268        /**
    269         * Returns the next shape in the sequence.
    270         *
    271         * @return The shape.
    272         */
    273        public Shape getNextShape() {
    274            Shape result = this.shapeSequence[
    275                    this.shapeIndex % this.shapeSequence.length];
    276            this.shapeIndex++;
    277            return result;
    278        }
    279
    280        /**
    281         * Creates an array of standard shapes to display for the items in series
    282         * on charts.
    283         *
    284         * @return The array of shapes.
    285         */
    286        public static Shape[] createStandardSeriesShapes() {
    287
    288            Shape[] result = new Shape[10];
    289
    290            double size = 6.0;
    291            double delta = size / 2.0;
    292            int[] xpoints = null;
    293            int[] ypoints = null;
    294
    295            // square
    296            result[0] = new Rectangle2D.Double(-delta, -delta, size, size);
    297            // circle
    298            result[1] = new Ellipse2D.Double(-delta, -delta, size, size);
    299
    300            // up-pointing triangle
    301            xpoints = intArray(0.0, delta, -delta);
    302            ypoints = intArray(-delta, delta, delta);
    303            result[2] = new Polygon(xpoints, ypoints, 3);
    304
    305            // diamond
    306            xpoints = intArray(0.0, delta, 0.0, -delta);
    307            ypoints = intArray(-delta, 0.0, delta, 0.0);
    308            result[3] = new Polygon(xpoints, ypoints, 4);
    309
    310            // horizontal rectangle
    311            result[4] = new Rectangle2D.Double(-delta, -delta / 2, size, size / 2);
    312
    313            // down-pointing triangle
    314            xpoints = intArray(-delta, +delta, 0.0);
    315            ypoints = intArray(-delta, -delta, delta);
    316            result[5] = new Polygon(xpoints, ypoints, 3);
    317
    318            // horizontal ellipse
    319            result[6] = new Ellipse2D.Double(-delta, -delta / 2, size, size / 2);
    320
    321            // right-pointing triangle
    322            xpoints = intArray(-delta, delta, -delta);
    323            ypoints = intArray(-delta, 0.0, delta);
    324            result[7] = new Polygon(xpoints, ypoints, 3);
    325
    326            // vertical rectangle
    327            result[8] = new Rectangle2D.Double(-delta / 2, -delta, size / 2, size);
    328
    329            // left-pointing triangle
    330            xpoints = intArray(-delta, delta, delta);
    331            ypoints = intArray(0.0, -delta, +delta);
    332            result[9] = new Polygon(xpoints, ypoints, 3);
    333
    334            return result;
    335
    336        }
    337
    338        /**
    339         * Tests this object for equality with another object.
    340         *
    341         * @param obj  the object (<code>null</code> permitted).
    342         *
    343         * @return A boolean.
    344         */
    345        public boolean equals(Object obj) {
    346
    347            if (obj == this) {
    348                return true;
    349            }
    350
    351            if (!(obj instanceof DefaultDrawingSupplier)) {
    352                return false;
    353            }
    354
    355            DefaultDrawingSupplier that = (DefaultDrawingSupplier) obj;
    356
    357            if (!Arrays.equals(this.paintSequence, that.paintSequence)) {
    358                return false;
    359            }
    360            if (this.paintIndex != that.paintIndex) {
    361                return false;
    362            }
    363            if (!Arrays.equals(this.outlinePaintSequence,
    364                    that.outlinePaintSequence)) {
    365                return false;
    366            }
    367            if (this.outlinePaintIndex != that.outlinePaintIndex) {
    368                return false;
    369            }
    370            if (!Arrays.equals(this.strokeSequence, that.strokeSequence)) {
    371                return false;
    372            }
    373            if (this.strokeIndex != that.strokeIndex) {
    374                return false;
    375            }
    376            if (!Arrays.equals(this.outlineStrokeSequence,
    377                    that.outlineStrokeSequence)) {
    378                return false;
    379            }
    380            if (this.outlineStrokeIndex != that.outlineStrokeIndex) {
    381                return false;
    382            }
    383            if (!equalShapes(this.shapeSequence, that.shapeSequence)) {
    384                return false;
    385            }
    386            if (this.shapeIndex != that.shapeIndex) {
    387                return false;
    388            }
    389            return true;
    390
    391        }
    392
    393        /**
    394         * A utility method for testing the equality of two arrays of shapes.
    395         *
    396         * @param s1  the first array (<code>null</code> permitted).
    397         * @param s2  the second array (<code>null</code> permitted).
    398         *
    399         * @return A boolean.
    400         */
    401        private boolean equalShapes(Shape[] s1, Shape[] s2) {
    402            if (s1 == null) {
    403                return s2 == null;
    404            }
    405            if (s2 == null) {
    406                return false;
    407            }
    408            if (s1.length != s2.length) {
    409                return false;
    410            }
    411            for (int i = 0; i < s1.length; i++) {
    412                if (!ShapeUtilities.equal(s1[i], s2[i])) {
    413                    return false;
    414                }
    415            }
    416            return true;
    417        }
    418
    419        /**
    420         * Handles serialization.
    421         *
    422         * @param stream  the output stream.
    423         *
    424         * @throws IOException if there is an I/O problem.
    425         */
    426        private void writeObject(ObjectOutputStream stream) throws IOException {
    427            stream.defaultWriteObject();
    428
    429            int paintCount = this.paintSequence.length;
    430            stream.writeInt(paintCount);
    431            for (int i = 0; i < paintCount; i++) {
    432                SerialUtilities.writePaint(this.paintSequence[i], stream);
    433            }
    434
    435            int outlinePaintCount = this.outlinePaintSequence.length;
    436            stream.writeInt(outlinePaintCount);
    437            for (int i = 0; i < outlinePaintCount; i++) {
    438                SerialUtilities.writePaint(this.outlinePaintSequence[i], stream);
    439            }
    440
    441            int strokeCount = this.strokeSequence.length;
    442            stream.writeInt(strokeCount);
    443            for (int i = 0; i < strokeCount; i++) {
    444                SerialUtilities.writeStroke(this.strokeSequence[i], stream);
    445            }
    446
    447            int outlineStrokeCount = this.outlineStrokeSequence.length;
    448            stream.writeInt(outlineStrokeCount);
    449            for (int i = 0; i < outlineStrokeCount; i++) {
    450                SerialUtilities.writeStroke(this.outlineStrokeSequence[i], stream);
    451            }
    452
    453            int shapeCount = this.shapeSequence.length;
    454            stream.writeInt(shapeCount);
    455            for (int i = 0; i < shapeCount; i++) {
    456                SerialUtilities.writeShape(this.shapeSequence[i], stream);
    457            }
    458
    459        }
    460
    461        /**
    462         * Restores a serialized object.
    463         *
    464         * @param stream  the input stream.
    465         *
    466         * @throws IOException if there is an I/O problem.
    467         * @throws ClassNotFoundException if there is a problem loading a class.
    468         */
    469        private void readObject(ObjectInputStream stream)
    470            throws IOException, ClassNotFoundException {
    471            stream.defaultReadObject();
    472
    473            int paintCount = stream.readInt();
    474            this.paintSequence = new Paint[paintCount];
    475            for (int i = 0; i < paintCount; i++) {
    476                this.paintSequence[i] = SerialUtilities.readPaint(stream);
    477            }
    478
    479            int outlinePaintCount = stream.readInt();
    480            this.outlinePaintSequence = new Paint[outlinePaintCount];
    481            for (int i = 0; i < outlinePaintCount; i++) {
    482                this.outlinePaintSequence[i] = SerialUtilities.readPaint(stream);
    483            }
    484
    485            int strokeCount = stream.readInt();
    486            this.strokeSequence = new Stroke[strokeCount];
    487            for (int i = 0; i < strokeCount; i++) {
    488                this.strokeSequence[i] = SerialUtilities.readStroke(stream);
    489            }
    490
    491            int outlineStrokeCount = stream.readInt();
    492            this.outlineStrokeSequence = new Stroke[outlineStrokeCount];
    493            for (int i = 0; i < outlineStrokeCount; i++) {
    494                this.outlineStrokeSequence[i] = SerialUtilities.readStroke(stream);
    495            }
    496
    497            int shapeCount = stream.readInt();
    498            this.shapeSequence = new Shape[shapeCount];
    499            for (int i = 0; i < shapeCount; i++) {
    500                this.shapeSequence[i] = SerialUtilities.readShape(stream);
    501            }
    502
    503        }
    504
    505        /**
    506         * Helper method to avoid lots of explicit casts in getShape().  Returns
    507         * an array containing the provided doubles cast to ints.
    508         *
    509         * @param a  x
    510         * @param b  y
    511         * @param c  z
    512         *
    513         * @return int[3] with converted params.
    514         */
    515        private static int[] intArray(double a, double b, double c) {
    516            return new int[] {(int) a, (int) b, (int) c};
    517        }
    518
    519        /**
    520         * Helper method to avoid lots of explicit casts in getShape().  Returns
    521         * an array containing the provided doubles cast to ints.
    522         *
    523         * @param a  x
    524         * @param b  y
    525         * @param c  z
    526         * @param d  t
    527         *
    528         * @return int[4] with converted params.
    529         */
    530        private static int[] intArray(double a, double b, double c, double d) {
    531            return new int[] {(int) a, (int) b, (int) c, (int) d};
    532        }
    533
    534        /**
    535         * Returns a clone.
    536         *
    537         * @return A clone.
    538         *
    539         * @throws CloneNotSupportedException if a component of the supplier does
    540         *                                    not support cloning.
    541         */
    542        public Object clone() throws CloneNotSupportedException {
    543            DefaultDrawingSupplier clone = (DefaultDrawingSupplier) super.clone();
    544            return clone;
    545        }
    546    }