    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     * GanttRenderer.java
    029     * ------------------
    030     * (C) Copyright 2003-2007, by Object Refinery Limited.
    031     *
    032     * Original Author:  David Gilbert (for Object Refinery Limited);
    033     * Contributor(s):   -;
    034     *
    035     * Changes
    036     * -------
    037     * 16-Sep-2003 : Version 1 (DG);
    038     * 23-Sep-2003 : Fixed Checkstyle issues (DG);
    039     * 21-Oct-2003 : Bar width moved into CategoryItemRendererState (DG);
    040     * 03-Feb-2004 : Added get/set methods for attributes (DG);
    041     * 12-Aug-2004 : Fixed rendering problem with maxBarWidth attribute (DG);
    042     * 05-Nov-2004 : Modified drawItem() signature (DG);
    043     * 20-Apr-2005 : Renamed CategoryLabelGenerator
    044     *               --> CategoryItemLabelGenerator (DG);
    045     * 01-Dec-2005 : Fix for bug 1369954, drawBarOutline flag ignored (DG);
    046     * ------------- JFREECHART 1.0.x --------------------------------------------
    047     * 17-Jan-2006 : Set includeBaseInRange flag to false (DG);
    048     * 20-Mar-2007 : Implemented equals() and fixed serialization (DG);
    049     *
    050     */
    051
    052    package org.jfree.chart.renderer.category;
    053
    054    import java.awt.Color;
    055    import java.awt.Graphics2D;
    056    import java.awt.Paint;
    057    import java.awt.Stroke;
    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
    064    import org.jfree.chart.axis.CategoryAxis;
    065    import org.jfree.chart.axis.ValueAxis;
    066    import org.jfree.chart.entity.CategoryItemEntity;
    067    import org.jfree.chart.entity.EntityCollection;
    068    import org.jfree.chart.event.RendererChangeEvent;
    069    import org.jfree.chart.labels.CategoryItemLabelGenerator;
    070    import org.jfree.chart.labels.CategoryToolTipGenerator;
    071    import org.jfree.chart.plot.CategoryPlot;
    072    import org.jfree.chart.plot.PlotOrientation;
    073    import org.jfree.data.category.CategoryDataset;
    074    import org.jfree.data.gantt.GanttCategoryDataset;
    075    import org.jfree.io.SerialUtilities;
    076    import org.jfree.ui.RectangleEdge;
    077    import org.jfree.util.PaintUtilities;
    078
    079    /**
    080     * A renderer for simple Gantt charts.
    081     */
    082    public class GanttRenderer extends IntervalBarRenderer
    083                               implements Serializable {
    084
    085        /** For serialization. */
    086        private static final long serialVersionUID = -4010349116350119512L;
    087
    088        /** The paint for displaying the percentage complete. */
    089        private transient Paint completePaint;
    090
    091        /** The paint for displaying the incomplete part of a task. */
    092        private transient Paint incompletePaint;
    093
    094        /**
    095         * Controls the starting edge of the progress indicator (expressed as a
    096         * percentage of the overall bar width).
    097         */
    098        private double startPercent;
    099
    100        /**
    101         * Controls the ending edge of the progress indicator (expressed as a
    102         * percentage of the overall bar width).
    103         */
    104        private double endPercent;
    105
    106        /**
    107         * Creates a new renderer.
    108         */
    109        public GanttRenderer() {
    110            super();
    111            setIncludeBaseInRange(false);
    112            this.completePaint = Color.green;
    113            this.incompletePaint = Color.red;
    114            this.startPercent = 0.35;
    115            this.endPercent = 0.65;
    116        }
    117
    118        /**
    119         * Returns the paint used to show the percentage complete.
    120         *
    121         * @return The paint (never <code>null</code>.
    122         *
    123         * @see #setCompletePaint(Paint)
    124         */
    125        public Paint getCompletePaint() {
    126            return this.completePaint;
    127        }
    128
    129        /**
    130         * Sets the paint used to show the percentage complete and sends a
    131         * {@link RendererChangeEvent} to all registered listeners.
    132         *
    133         * @param paint  the paint (<code>null</code> not permitted).
    134         *
    135         * @see #getCompletePaint()
    136         */
    137        public void setCompletePaint(Paint paint) {
    138            if (paint == null) {
    139                throw new IllegalArgumentException("Null 'paint' argument.");
    140            }
    141            this.completePaint = paint;
    142            fireChangeEvent();
    143        }
    144
    145        /**
    146         * Returns the paint used to show the percentage incomplete.
    147         *
    148         * @return The paint (never <code>null</code>).
    149         *
    150         * @see #setCompletePaint(Paint)
    151         */
    152        public Paint getIncompletePaint() {
    153            return this.incompletePaint;
    154        }
    155
    156        /**
    157         * Sets the paint used to show the percentage incomplete and sends a
    158         * {@link RendererChangeEvent} to all registered listeners.
    159         *
    160         * @param paint  the paint (<code>null</code> not permitted).
    161         *
    162         * @see #getIncompletePaint()
    163         */
    164        public void setIncompletePaint(Paint paint) {
    165            if (paint == null) {
    166                throw new IllegalArgumentException("Null 'paint' argument.");
    167            }
    168            this.incompletePaint = paint;
    169            fireChangeEvent();
    170        }
    171
    172        /**
    173         * Returns the position of the start of the progress indicator, as a
    174         * percentage of the bar width.
    175         *
    176         * @return The start percent.
    177         *
    178         * @see #setStartPercent(double)
    179         */
    180        public double getStartPercent() {
    181            return this.startPercent;
    182        }
    183
    184        /**
    185         * Sets the position of the start of the progress indicator, as a
    186         * percentage of the bar width, and sends a {@link RendererChangeEvent} to
    187         * all registered listeners.
    188         *
    189         * @param percent  the percent.
    190         *
    191         * @see #getStartPercent()
    192         */
    193        public void setStartPercent(double percent) {
    194            this.startPercent = percent;
    195            fireChangeEvent();
    196        }
    197
    198        /**
    199         * Returns the position of the end of the progress indicator, as a
    200         * percentage of the bar width.
    201         *
    202         * @return The end percent.
    203         *
    204         * @see #setEndPercent(double)
    205         */
    206        public double getEndPercent() {
    207            return this.endPercent;
    208        }
    209
    210        /**
    211         * Sets the position of the end of the progress indicator, as a percentage
    212         * of the bar width, and sends a {@link RendererChangeEvent} to all
    213         * registered listeners.
    214         *
    215         * @param percent  the percent.
    216         *
    217         * @see #getEndPercent()
    218         */
    219        public void setEndPercent(double percent) {
    220            this.endPercent = percent;
    221            fireChangeEvent();
    222        }
    223
    224        /**
    225         * Draws the bar for a single (series, category) data item.
    226         *
    227         * @param g2  the graphics device.
    228         * @param state  the renderer state.
    229         * @param dataArea  the data area.
    230         * @param plot  the plot.
    231         * @param domainAxis  the domain axis.
    232         * @param rangeAxis  the range axis.
    233         * @param dataset  the dataset.
    234         * @param row  the row index (zero-based).
    235         * @param column  the column index (zero-based).
    236         * @param pass  the pass index.
    237         */
    238        public void drawItem(Graphics2D g2,
    239                             CategoryItemRendererState state,
    240                             Rectangle2D dataArea,
    241                             CategoryPlot plot,
    242                             CategoryAxis domainAxis,
    243                             ValueAxis rangeAxis,
    244                             CategoryDataset dataset,
    245                             int row,
    246                             int column,
    247                             int pass) {
    248
    249             if (dataset instanceof GanttCategoryDataset) {
    250                 GanttCategoryDataset gcd = (GanttCategoryDataset) dataset;
    251                 drawTasks(g2, state, dataArea, plot, domainAxis, rangeAxis, gcd,
    252                         row, column);
    253             }
    254             else {  // let the superclass handle it...
    255                 super.drawItem(g2, state, dataArea, plot, domainAxis, rangeAxis,
    256                         dataset, row, column, pass);
    257             }
    258
    259         }
    260
    261        /**
    262         * Draws the tasks/subtasks for one item.
    263         *
    264         * @param g2  the graphics device.
    265         * @param state  the renderer state.
    266         * @param dataArea  the data plot area.
    267         * @param plot  the plot.
    268         * @param domainAxis  the domain axis.
    269         * @param rangeAxis  the range axis.
    270         * @param dataset  the data.
    271         * @param row  the row index (zero-based).
    272         * @param column  the column index (zero-based).
    273         */
    274        protected void drawTasks(Graphics2D g2,
    275                                 CategoryItemRendererState state,
    276                                 Rectangle2D dataArea,
    277                                 CategoryPlot plot,
    278                                 CategoryAxis domainAxis,
    279                                 ValueAxis rangeAxis,
    280                                 GanttCategoryDataset dataset,
    281                                 int row,
    282                                 int column) {
    283
    284            int count = dataset.getSubIntervalCount(row, column);
    285            if (count == 0) {
    286                drawTask(g2, state, dataArea, plot, domainAxis, rangeAxis,
    287                        dataset, row, column);
    288            }
    289
    290            for (int subinterval = 0; subinterval < count; subinterval++) {
    291
    292                RectangleEdge rangeAxisLocation = plot.getRangeAxisEdge();
    293
    294                // value 0
    295                Number value0 = dataset.getStartValue(row, column, subinterval);
    296                if (value0 == null) {
    297                    return;
    298                }
    299                double translatedValue0 = rangeAxis.valueToJava2D(
    300                        value0.doubleValue(), dataArea, rangeAxisLocation);
    301
    302                // value 1
    303                Number value1 = dataset.getEndValue(row, column, subinterval);
    304                if (value1 == null) {
    305                    return;
    306                }
    307                double translatedValue1 = rangeAxis.valueToJava2D(
    308                        value1.doubleValue(), dataArea, rangeAxisLocation);
    309
    310                if (translatedValue1 < translatedValue0) {
    311                    double temp = translatedValue1;
    312                    translatedValue1 = translatedValue0;
    313                    translatedValue0 = temp;
    314                }
    315
    316                double rectStart = calculateBarW0(plot, plot.getOrientation(),
    317                        dataArea, domainAxis, state, row, column);
    318                double rectLength = Math.abs(translatedValue1 - translatedValue0);
    319                double rectBreadth = state.getBarWidth();
    320
    321                // DRAW THE BARS...
    322                Rectangle2D bar = null;
    323
    324                if (plot.getOrientation() == PlotOrientation.HORIZONTAL) {
    325                    bar = new Rectangle2D.Double(translatedValue0, rectStart,
    326                            rectLength, rectBreadth);
    327                }
    328                else if (plot.getOrientation() == PlotOrientation.VERTICAL) {
    329                    bar = new Rectangle2D.Double(rectStart, translatedValue0,
    330                            rectBreadth, rectLength);
    331                }
    332
    333                Rectangle2D completeBar = null;
    334                Rectangle2D incompleteBar = null;
    335                Number percent = dataset.getPercentComplete(row, column,
    336                        subinterval);
    337                double start = getStartPercent();
    338                double end = getEndPercent();
    339                if (percent != null) {
    340                    double p = percent.doubleValue();
    341                    if (plot.getOrientation() == PlotOrientation.HORIZONTAL) {
    342                        completeBar = new Rectangle2D.Double(translatedValue0,
    343                                rectStart + start * rectBreadth, rectLength * p,
    344                                rectBreadth * (end - start));
    345                        incompleteBar = new Rectangle2D.Double(translatedValue0
    346                                + rectLength * p, rectStart + start * rectBreadth,
    347                                rectLength * (1 - p), rectBreadth * (end - start));
    348                    }
    349                    else if (plot.getOrientation() == PlotOrientation.VERTICAL) {
    350                        completeBar = new Rectangle2D.Double(rectStart + start
    351                                * rectBreadth, translatedValue0 + rectLength
    352                                * (1 - p), rectBreadth * (end - start),
    353                                rectLength * p);
    354                        incompleteBar = new Rectangle2D.Double(rectStart + start
    355                                * rectBreadth, translatedValue0, rectBreadth
    356                                * (end - start), rectLength * (1 - p));
    357                    }
    358
    359                }
    360
    361                Paint seriesPaint = getItemPaint(row, column);
    362                g2.setPaint(seriesPaint);
    363                g2.fill(bar);
    364                if (completeBar != null) {
    365                    g2.setPaint(getCompletePaint());
    366                    g2.fill(completeBar);
    367                }
    368                if (incompleteBar != null) {
    369                    g2.setPaint(getIncompletePaint());
    370                    g2.fill(incompleteBar);
    371                }
    372                if (isDrawBarOutline()
    373                        && state.getBarWidth() > BAR_OUTLINE_WIDTH_THRESHOLD) {
    374                    g2.setStroke(getItemStroke(row, column));
    375                    g2.setPaint(getItemOutlinePaint(row, column));
    376                    g2.draw(bar);
    377                }
    378
    379                // collect entity and tool tip information...
    380                if (state.getInfo() != null) {
    381                    EntityCollection entities = state.getEntityCollection();
    382                    if (entities != null) {
    383                        String tip = null;
    384                        if (getToolTipGenerator(row, column) != null) {
    385                            tip = getToolTipGenerator(row, column).generateToolTip(
    386                                    dataset, row, column);
    387                        }
    388                        String url = null;
    389                        if (getItemURLGenerator(row, column) != null) {
    390                            url = getItemURLGenerator(row, column).generateURL(
    391                                    dataset, row, column);
    392                        }
    393                        CategoryItemEntity entity = new CategoryItemEntity(
    394                                bar, tip, url, dataset, dataset.getRowKey(row),
    395                                dataset.getColumnKey(column));
    396                        entities.add(entity);
    397                    }
    398                }
    399            }
    400        }
    401
    402        /**
    403         * Draws a single task.
    404         *
    405         * @param g2  the graphics device.
    406         * @param state  the renderer state.
    407         * @param dataArea  the data plot area.
    408         * @param plot  the plot.
    409         * @param domainAxis  the domain axis.
    410         * @param rangeAxis  the range axis.
    411         * @param dataset  the data.
    412         * @param row  the row index (zero-based).
    413         * @param column  the column index (zero-based).
    414         */
    415        protected void drawTask(Graphics2D g2,
    416                                CategoryItemRendererState state,
    417                                Rectangle2D dataArea,
    418                                CategoryPlot plot,
    419                                CategoryAxis domainAxis,
    420                                ValueAxis rangeAxis,
    421                                GanttCategoryDataset dataset,
    422                                int row,
    423                                int column) {
    424
    425            PlotOrientation orientation = plot.getOrientation();
    426
    427            RectangleEdge rangeAxisLocation = plot.getRangeAxisEdge();
    428
    429            // Y0
    430            Number value0 = dataset.getEndValue(row, column);
    431            if (value0 == null) {
    432                return;
    433            }
    434            double java2dValue0 = rangeAxis.valueToJava2D(value0.doubleValue(),
    435                    dataArea, rangeAxisLocation);
    436
    437            // Y1
    438            Number value1 = dataset.getStartValue(row, column);
    439            if (value1 == null) {
    440                return;
    441            }
    442            double java2dValue1 = rangeAxis.valueToJava2D(value1.doubleValue(),
    443                    dataArea, rangeAxisLocation);
    444
    445            if (java2dValue1 < java2dValue0) {
    446                double temp = java2dValue1;
    447                java2dValue1 = java2dValue0;
    448                java2dValue0 = temp;
    449                Number tempNum = value1;
    450                value1 = value0;
    451                value0 = tempNum;
    452            }
    453
    454            double rectStart = calculateBarW0(plot, orientation, dataArea,
    455                    domainAxis, state, row, column);
    456            double rectBreadth = state.getBarWidth();
    457            double rectLength = Math.abs(java2dValue1 - java2dValue0);
    458
    459            Rectangle2D bar = null;
    460            if (orientation == PlotOrientation.HORIZONTAL) {
    461                bar = new Rectangle2D.Double(java2dValue0, rectStart, rectLength,
    462                        rectBreadth);
    463            }
    464            else if (orientation == PlotOrientation.VERTICAL) {
    465                bar = new Rectangle2D.Double(rectStart, java2dValue1, rectBreadth,
    466                        rectLength);
    467            }
    468
    469            Rectangle2D completeBar = null;
    470            Rectangle2D incompleteBar = null;
    471            Number percent = dataset.getPercentComplete(row, column);
    472            double start = getStartPercent();
    473            double end = getEndPercent();
    474            if (percent != null) {
    475                double p = percent.doubleValue();
    476                if (plot.getOrientation() == PlotOrientation.HORIZONTAL) {
    477                    completeBar = new Rectangle2D.Double(java2dValue0,
    478                            rectStart + start * rectBreadth, rectLength * p,
    479                            rectBreadth * (end - start));
    480                    incompleteBar = new Rectangle2D.Double(java2dValue0
    481                            + rectLength * p, rectStart + start * rectBreadth,
    482                            rectLength * (1 - p), rectBreadth * (end - start));
    483                }
    484                else if (plot.getOrientation() == PlotOrientation.VERTICAL) {
    485                    completeBar = new Rectangle2D.Double(rectStart + start
    486                            * rectBreadth, java2dValue1 + rectLength * (1 - p),
    487                            rectBreadth * (end - start), rectLength * p);
    488                    incompleteBar = new Rectangle2D.Double(rectStart + start
    489                            * rectBreadth, java2dValue1, rectBreadth * (end
    490                            - start), rectLength * (1 - p));
    491                }
    492
    493            }
    494
    495            Paint seriesPaint = getItemPaint(row, column);
    496            g2.setPaint(seriesPaint);
    497            g2.fill(bar);
    498
    499            if (completeBar != null) {
    500                g2.setPaint(getCompletePaint());
    501                g2.fill(completeBar);
    502            }
    503            if (incompleteBar != null) {
    504                g2.setPaint(getIncompletePaint());
    505                g2.fill(incompleteBar);
    506            }
    507
    508            // draw the outline...
    509            if (isDrawBarOutline()
    510                    && state.getBarWidth() > BAR_OUTLINE_WIDTH_THRESHOLD) {
    511                Stroke stroke = getItemOutlineStroke(row, column);
    512                Paint paint = getItemOutlinePaint(row, column);
    513                if (stroke != null && paint != null) {
    514                    g2.setStroke(stroke);
    515                    g2.setPaint(paint);
    516                    g2.draw(bar);
    517                }
    518            }
    519
    520            CategoryItemLabelGenerator generator = getItemLabelGenerator(row,
    521                    column);
    522            if (generator != null && isItemLabelVisible(row, column)) {
    523                drawItemLabel(g2, dataset, row, column, plot, generator, bar,
    524                        false);
    525            }
    526
    527            // collect entity and tool tip information...
    528            if (state.getInfo() != null) {
    529                EntityCollection entities = state.getEntityCollection();
    530                if (entities != null) {
    531                    String tip = null;
    532                    CategoryToolTipGenerator tipster = getToolTipGenerator(row,
    533                            column);
    534                    if (tipster != null) {
    535                        tip = tipster.generateToolTip(dataset, row, column);
    536                    }
    537                    String url = null;
    538                    if (getItemURLGenerator(row, column) != null) {
    539                        url = getItemURLGenerator(row, column).generateURL(
    540                                dataset, row, column);
    541                    }
    542                    CategoryItemEntity entity = new CategoryItemEntity(bar, tip,
    543                            url, dataset, dataset.getRowKey(row),
    544                            dataset.getColumnKey(column));
    545                    entities.add(entity);
    546                }
    547            }
    548
    549        }
    550
    551        /**
    552         * Tests this renderer for equality with an arbitrary object.
    553         *
    554         * @param obj  the object (<code>null</code> permitted).
    555         *
    556         * @return A boolean.
    557         */
    558        public boolean equals(Object obj) {
    559            if (obj == this) {
    560                return true;
    561            }
    562            if (!(obj instanceof GanttRenderer)) {
    563                return false;
    564            }
    565            GanttRenderer that = (GanttRenderer) obj;
    566            if (!PaintUtilities.equal(this.completePaint, that.completePaint)) {
    567                return false;
    568            }
    569            if (!PaintUtilities.equal(this.incompletePaint, that.incompletePaint)) {
    570                return false;
    571            }
    572            if (this.startPercent != that.startPercent) {
    573                return false;
    574            }
    575            if (this.endPercent != that.endPercent) {
    576                return false;
    577            }
    578            return super.equals(obj);
    579        }
    580
    581        /**
    582         * Provides serialization support.
    583         *
    584         * @param stream  the output stream.
    585         *
    586         * @throws IOException  if there is an I/O error.
    587         */
    588        private void writeObject(ObjectOutputStream stream) throws IOException {
    589            stream.defaultWriteObject();
    590            SerialUtilities.writePaint(this.completePaint, stream);
    591            SerialUtilities.writePaint(this.incompletePaint, stream);
    592        }
    593
    594        /**
    595         * Provides serialization support.
    596         *
    597         * @param stream  the input stream.
    598         *
    599         * @throws IOException  if there is an I/O error.
    600         * @throws ClassNotFoundException  if there is a classpath problem.
    601         */
    602        private void readObject(ObjectInputStream stream)
    603            throws IOException, ClassNotFoundException {
    604            stream.defaultReadObject();
    605            this.completePaint = SerialUtilities.readPaint(stream);
    606            this.incompletePaint = SerialUtilities.readPaint(stream);
    607        }
    608
    609    }