    001    /* ===========================================================
    002     * JFreeChart : a free chart library for the Java(tm) platform
    003     * ===========================================================
    004     *
    005     * (C) Copyright 2000-2011, 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     * [Oracle and Java are registered trademarks of Oracle and/or its affiliates.
    025     * Other names may be trademarks of their respective owners.]
    026     *
    027     * ---------------------
    028     * XYLineAnnotation.java
    029     * ---------------------
    030     * (C) Copyright 2003-2009, by Object Refinery Limited.
    031     *
    032     * Original Author:  David Gilbert (for Object Refinery Limited);
    033     * Contributor(s):   Peter Kolb (see patch 2809117);
    034     *
    035     * Changes:
    036     * --------
    037     * 02-Apr-2003 : Version 1 (DG);
    038     * 19-Aug-2003 : Added equals method, implemented Cloneable, and applied
    039     *               serialization fixes (DG);
    040     * 21-Jan-2004 : Update for renamed method in ValueAxis (DG);
    041     * 14-Apr-2004 : Fixed draw() method to handle plot orientation correctly (DG);
    042     * 29-Sep-2004 : Added support for tool tips and URLS, now extends
    043     *               AbstractXYAnnotation (DG);
    044     * 04-Oct-2004 : Renamed ShapeUtils --> ShapeUtilities (DG);
    045     * 08-Jun-2005 : Fixed equals() method to handle GradientPaint() (DG);
    046     * 05-Nov-2008 : Added workaround for JRE bug 6574155, see JFreeChart bug
    047     *               2221495 (DG);
    048     *
    049     */
    050
    051    package org.jfree.chart.annotations;
    052
    053    import java.awt.BasicStroke;
    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.Line2D;
    059    import java.awt.geom.Rectangle2D;
    060    import java.io.IOException;
    061    import java.io.ObjectInputStream;
    062    import java.io.ObjectOutputStream;
    063    import java.io.Serializable;
    064
    065    import org.jfree.chart.axis.ValueAxis;
    066    import org.jfree.chart.plot.Plot;
    067    import org.jfree.chart.plot.PlotOrientation;
    068    import org.jfree.chart.plot.PlotRenderingInfo;
    069    import org.jfree.chart.plot.XYPlot;
    070    import org.jfree.chart.util.LineUtilities;
    071    import org.jfree.io.SerialUtilities;
    072    import org.jfree.ui.RectangleEdge;
    073    import org.jfree.util.ObjectUtilities;
    074    import org.jfree.util.PaintUtilities;
    075    import org.jfree.util.PublicCloneable;
    076    import org.jfree.util.ShapeUtilities;
    077
    078    /**
    079     * A simple line annotation that can be placed on an {@link XYPlot}.
    080     */
    081    public class XYLineAnnotation extends AbstractXYAnnotation
    082            implements Cloneable, PublicCloneable, Serializable {
    083
    084        /** For serialization. */
    085        private static final long serialVersionUID = -80535465244091334L;
    086
    087        /** The x-coordinate. */
    088        private double x1;
    089
    090        /** The y-coordinate. */
    091        private double y1;
    092
    093        /** The x-coordinate. */
    094        private double x2;
    095
    096        /** The y-coordinate. */
    097        private double y2;
    098
    099        /** The line stroke. */
    100        private transient Stroke stroke;
    101
    102        /** The line color. */
    103        private transient Paint paint;
    104
    105        /**
    106         * Creates a new annotation that draws a line from (x1, y1) to (x2, y2)
    107         * where the coordinates are measured in data space (that is, against the
    108         * plot's axes).
    109         *
    110         * @param x1  the x-coordinate for the start of the line.
    111         * @param y1  the y-coordinate for the start of the line.
    112         * @param x2  the x-coordinate for the end of the line.
    113         * @param y2  the y-coordinate for the end of the line.
    114         */
    115        public XYLineAnnotation(double x1, double y1, double x2, double y2) {
    116            this(x1, y1, x2, y2, new BasicStroke(1.0f), Color.black);
    117        }
    118
    119        /**
    120         * Creates a new annotation that draws a line from (x1, y1) to (x2, y2)
    121         * where the coordinates are measured in data space (that is, against the
    122         * plot's axes).
    123         *
    124         * @param x1  the x-coordinate for the start of the line.
    125         * @param y1  the y-coordinate for the start of the line.
    126         * @param x2  the x-coordinate for the end of the line.
    127         * @param y2  the y-coordinate for the end of the line.
    128         * @param stroke  the line stroke (<code>null</code> not permitted).
    129         * @param paint  the line color (<code>null</code> not permitted).
    130         */
    131        public XYLineAnnotation(double x1, double y1, double x2, double y2,
    132                                Stroke stroke, Paint paint) {
    133
    134            super();
    135            if (stroke == null) {
    136                throw new IllegalArgumentException("Null 'stroke' argument.");
    137            }
    138            if (paint == null) {
    139                throw new IllegalArgumentException("Null 'paint' argument.");
    140            }
    141            this.x1 = x1;
    142            this.y1 = y1;
    143            this.x2 = x2;
    144            this.y2 = y2;
    145            this.stroke = stroke;
    146            this.paint = paint;
    147
    148        }
    149
    150        /**
    151         * Draws the annotation.  This method is called by the {@link XYPlot}
    152         * class, you won't normally need to call it yourself.
    153         *
    154         * @param g2  the graphics device.
    155         * @param plot  the plot.
    156         * @param dataArea  the data area.
    157         * @param domainAxis  the domain axis.
    158         * @param rangeAxis  the range axis.
    159         * @param rendererIndex  the renderer index.
    160         * @param info  if supplied, this info object will be populated with
    161         *              entity information.
    162         */
    163        public void draw(Graphics2D g2, XYPlot plot, Rectangle2D dataArea,
    164                         ValueAxis domainAxis, ValueAxis rangeAxis,
    165                         int rendererIndex,
    166                         PlotRenderingInfo info) {
    167
    168            PlotOrientation orientation = plot.getOrientation();
    169            RectangleEdge domainEdge = Plot.resolveDomainAxisLocation(
    170                    plot.getDomainAxisLocation(), orientation);
    171            RectangleEdge rangeEdge = Plot.resolveRangeAxisLocation(
    172                    plot.getRangeAxisLocation(), orientation);
    173            float j2DX1 = 0.0f;
    174            float j2DX2 = 0.0f;
    175            float j2DY1 = 0.0f;
    176            float j2DY2 = 0.0f;
    177            if (orientation == PlotOrientation.VERTICAL) {
    178                j2DX1 = (float) domainAxis.valueToJava2D(this.x1, dataArea,
    179                        domainEdge);
    180                j2DY1 = (float) rangeAxis.valueToJava2D(this.y1, dataArea,
    181                        rangeEdge);
    182                j2DX2 = (float) domainAxis.valueToJava2D(this.x2, dataArea,
    183                        domainEdge);
    184                j2DY2 = (float) rangeAxis.valueToJava2D(this.y2, dataArea,
    185                        rangeEdge);
    186            }
    187            else if (orientation == PlotOrientation.HORIZONTAL) {
    188                j2DY1 = (float) domainAxis.valueToJava2D(this.x1, dataArea,
    189                        domainEdge);
    190                j2DX1 = (float) rangeAxis.valueToJava2D(this.y1, dataArea,
    191                        rangeEdge);
    192                j2DY2 = (float) domainAxis.valueToJava2D(this.x2, dataArea,
    193                        domainEdge);
    194                j2DX2 = (float) rangeAxis.valueToJava2D(this.y2, dataArea,
    195                        rangeEdge);
    196            }
    197            g2.setPaint(this.paint);
    198            g2.setStroke(this.stroke);
    199            Line2D line = new Line2D.Float(j2DX1, j2DY1, j2DX2, j2DY2);
    200            // line is clipped to avoid JRE bug 6574155, for more info
    201            // see JFreeChart bug 2221495
    202            boolean visible = LineUtilities.clipLine(line, dataArea);
    203            if (visible) {
    204                g2.draw(line);
    205            }
    206
    207            String toolTip = getToolTipText();
    208            String url = getURL();
    209            if (toolTip != null || url != null) {
    210                addEntity(info, ShapeUtilities.createLineRegion(line, 1.0f),
    211                        rendererIndex, toolTip, url);
    212            }
    213        }
    214
    215        /**
    216         * Tests this object for equality with an arbitrary object.
    217         *
    218         * @param obj  the object to test against (<code>null</code> permitted).
    219         *
    220         * @return <code>true</code> or <code>false</code>.
    221         */
    222        public boolean equals(Object obj) {
    223            if (obj == this) {
    224                return true;
    225            }
    226            if (!super.equals(obj)) {
    227                return false;
    228            }
    229            if (!(obj instanceof XYLineAnnotation)) {
    230                return false;
    231            }
    232            XYLineAnnotation that = (XYLineAnnotation) obj;
    233            if (this.x1 != that.x1) {
    234                return false;
    235            }
    236            if (this.y1 != that.y1) {
    237                return false;
    238            }
    239            if (this.x2 != that.x2) {
    240                return false;
    241            }
    242            if (this.y2 != that.y2) {
    243                return false;
    244            }
    245            if (!PaintUtilities.equal(this.paint, that.paint)) {
    246                return false;
    247            }
    248            if (!ObjectUtilities.equal(this.stroke, that.stroke)) {
    249                return false;
    250            }
    251            // seems to be the same...
    252            return true;
    253        }
    254
    255        /**
    256         * Returns a hash code.
    257         *
    258         * @return A hash code.
    259         */
    260        public int hashCode() {
    261            int result;
    262            long temp;
    263            temp = Double.doubleToLongBits(this.x1);
    264            result = (int) (temp ^ (temp >>> 32));
    265            temp = Double.doubleToLongBits(this.x2);
    266            result = 29 * result + (int) (temp ^ (temp >>> 32));
    267            temp = Double.doubleToLongBits(this.y1);
    268            result = 29 * result + (int) (temp ^ (temp >>> 32));
    269            temp = Double.doubleToLongBits(this.y2);
    270            result = 29 * result + (int) (temp ^ (temp >>> 32));
    271            return result;
    272        }
    273
    274        /**
    275         * Returns a clone of the annotation.
    276         *
    277         * @return A clone.
    278         *
    279         * @throws CloneNotSupportedException  if the annotation can't be cloned.
    280         */
    281        public Object clone() throws CloneNotSupportedException {
    282            return super.clone();
    283        }
    284
    285        /**
    286         * Provides serialization support.
    287         *
    288         * @param stream  the output stream.
    289         *
    290         * @throws IOException  if there is an I/O error.
    291         */
    292        private void writeObject(ObjectOutputStream stream) throws IOException {
    293            stream.defaultWriteObject();
    294            SerialUtilities.writePaint(this.paint, stream);
    295            SerialUtilities.writeStroke(this.stroke, stream);
    296        }
    297
    298        /**
    299         * Provides serialization support.
    300         *
    301         * @param stream  the input stream.
    302         *
    303         * @throws IOException  if there is an I/O error.
    304         * @throws ClassNotFoundException  if there is a classpath problem.
    305         */
    306        private void readObject(ObjectInputStream stream)
    307            throws IOException, ClassNotFoundException {
    308            stream.defaultReadObject();
    309            this.paint = SerialUtilities.readPaint(stream);
    310            this.stroke = SerialUtilities.readStroke(stream);
    311        }
    312
    313    }