    001    /* ===========================================================
    002     * JFreeChart : a free chart library for the Java(tm) platform
    003     * ===========================================================
    004     *
    005     * (C) Copyright 2000-2008, 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     * XYLineAnnotation.java
    029     * ---------------------
    030     * (C) Copyright 2003-2008, by Object Refinery Limited.
    031     *
    032     * Original Author:  David Gilbert (for Object Refinery Limited);
    033     * Contributor(s):   -;
    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            if (stroke == null) {
    135                throw new IllegalArgumentException("Null 'stroke' argument.");
    136            }
    137            if (paint == null) {
    138                throw new IllegalArgumentException("Null 'paint' argument.");
    139            }
    140            this.x1 = x1;
    141            this.y1 = y1;
    142            this.x2 = x2;
    143            this.y2 = y2;
    144            this.stroke = stroke;
    145            this.paint = paint;
    146
    147        }
    148
    149        /**
    150         * Draws the annotation.  This method is called by the {@link XYPlot}
    151         * class, you won't normally need to call it yourself.
    152         *
    153         * @param g2  the graphics device.
    154         * @param plot  the plot.
    155         * @param dataArea  the data area.
    156         * @param domainAxis  the domain axis.
    157         * @param rangeAxis  the range axis.
    158         * @param rendererIndex  the renderer index.
    159         * @param info  if supplied, this info object will be populated with
    160         *              entity information.
    161         */
    162        public void draw(Graphics2D g2, XYPlot plot, Rectangle2D dataArea,
    163                         ValueAxis domainAxis, ValueAxis rangeAxis,
    164                         int rendererIndex,
    165                         PlotRenderingInfo info) {
    166
    167            PlotOrientation orientation = plot.getOrientation();
    168            RectangleEdge domainEdge = Plot.resolveDomainAxisLocation(
    169                    plot.getDomainAxisLocation(), orientation);
    170            RectangleEdge rangeEdge = Plot.resolveRangeAxisLocation(
    171                    plot.getRangeAxisLocation(), orientation);
    172            float j2DX1 = 0.0f;
    173            float j2DX2 = 0.0f;
    174            float j2DY1 = 0.0f;
    175            float j2DY2 = 0.0f;
    176            if (orientation == PlotOrientation.VERTICAL) {
    177                j2DX1 = (float) domainAxis.valueToJava2D(this.x1, dataArea,
    178                        domainEdge);
    179                j2DY1 = (float) rangeAxis.valueToJava2D(this.y1, dataArea,
    180                        rangeEdge);
    181                j2DX2 = (float) domainAxis.valueToJava2D(this.x2, dataArea,
    182                        domainEdge);
    183                j2DY2 = (float) rangeAxis.valueToJava2D(this.y2, dataArea,
    184                        rangeEdge);
    185            }
    186            else if (orientation == PlotOrientation.HORIZONTAL) {
    187                j2DY1 = (float) domainAxis.valueToJava2D(this.x1, dataArea,
    188                        domainEdge);
    189                j2DX1 = (float) rangeAxis.valueToJava2D(this.y1, dataArea,
    190                        rangeEdge);
    191                j2DY2 = (float) domainAxis.valueToJava2D(this.x2, dataArea,
    192                        domainEdge);
    193                j2DX2 = (float) rangeAxis.valueToJava2D(this.y2, dataArea,
    194                        rangeEdge);
    195            }
    196            g2.setPaint(this.paint);
    197            g2.setStroke(this.stroke);
    198            Line2D line = new Line2D.Float(j2DX1, j2DY1, j2DX2, j2DY2);
    199            // line is clipped to avoid JRE bug 6574155, for more info
    200            // see JFreeChart bug 2221495
    201            boolean visible = LineUtilities.clipLine(line, dataArea);
    202            if (visible) {
    203                g2.draw(line);
    204            }
    205
    206            String toolTip = getToolTipText();
    207            String url = getURL();
    208            if (toolTip != null || url != null) {
    209                addEntity(info, ShapeUtilities.createLineRegion(line, 1.0f),
    210                        rendererIndex, toolTip, url);
    211            }
    212        }
    213
    214        /**
    215         * Tests this object for equality with an arbitrary object.
    216         *
    217         * @param obj  the object to test against (<code>null</code> permitted).
    218         *
    219         * @return <code>true</code> or <code>false</code>.
    220         */
    221        public boolean equals(Object obj) {
    222            if (obj == this) {
    223                return true;
    224            }
    225            if (!super.equals(obj)) {
    226                return false;
    227            }
    228            if (!(obj instanceof XYLineAnnotation)) {
    229                return false;
    230            }
    231            XYLineAnnotation that = (XYLineAnnotation) obj;
    232            if (this.x1 != that.x1) {
    233                return false;
    234            }
    235            if (this.y1 != that.y1) {
    236                return false;
    237            }
    238            if (this.x2 != that.x2) {
    239                return false;
    240            }
    241            if (this.y2 != that.y2) {
    242                return false;
    243            }
    244            if (!PaintUtilities.equal(this.paint, that.paint)) {
    245                return false;
    246            }
    247            if (!ObjectUtilities.equal(this.stroke, that.stroke)) {
    248                return false;
    249            }
    250            // seems to be the same...
    251            return true;
    252        }
    253
    254        /**
    255         * Returns a hash code.
    256         *
    257         * @return A hash code.
    258         */
    259        public int hashCode() {
    260            int result;
    261            long temp;
    262            temp = Double.doubleToLongBits(this.x1);
    263            result = (int) (temp ^ (temp >>> 32));
    264            temp = Double.doubleToLongBits(this.x2);
    265            result = 29 * result + (int) (temp ^ (temp >>> 32));
    266            temp = Double.doubleToLongBits(this.y1);
    267            result = 29 * result + (int) (temp ^ (temp >>> 32));
    268            temp = Double.doubleToLongBits(this.y2);
    269            result = 29 * result + (int) (temp ^ (temp >>> 32));
    270            return result;
    271        }
    272
    273        /**
    274         * Returns a clone of the annotation.
    275         *
    276         * @return A clone.
    277         *
    278         * @throws CloneNotSupportedException  if the annotation can't be cloned.
    279         */
    280        public Object clone() throws CloneNotSupportedException {
    281            return super.clone();
    282        }
    283
    284        /**
    285         * Provides serialization support.
    286         *
    287         * @param stream  the output stream.
    288         *
    289         * @throws IOException  if there is an I/O error.
    290         */
    291        private void writeObject(ObjectOutputStream stream) throws IOException {
    292            stream.defaultWriteObject();
    293            SerialUtilities.writePaint(this.paint, stream);
    294            SerialUtilities.writeStroke(this.stroke, stream);
    295        }
    296
    297        /**
    298         * Provides serialization support.
    299         *
    300         * @param stream  the input stream.
    301         *
    302         * @throws IOException  if there is an I/O error.
    303         * @throws ClassNotFoundException  if there is a classpath problem.
    304         */
    305        private void readObject(ObjectInputStream stream)
    306            throws IOException, ClassNotFoundException {
    307            stream.defaultReadObject();
    308            this.paint = SerialUtilities.readPaint(stream);
    309            this.stroke = SerialUtilities.readStroke(stream);
    310        }
    311
    312    }