    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     * XYLineAnnotation.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     * $Id: XYLineAnnotation.java,v 1.7.2.3 2007/03/06 16:12:18 mungady Exp $
    036     *
    037     * Changes:
    038     * --------
    039     * 02-Apr-2003 : Version 1 (DG);
    040     * 19-Aug-2003 : Added equals method, implemented Cloneable, and applied
    041     *               serialization fixes (DG);
    042     * 21-Jan-2004 : Update for renamed method in ValueAxis (DG);
    043     * 14-Apr-2004 : Fixed draw() method to handle plot orientation correctly (DG);
    044     * 29-Sep-2004 : Added support for tool tips and URLS, now extends
    045     *               AbstractXYAnnotation (DG);
    046     * 04-Oct-2004 : Renamed ShapeUtils --> ShapeUtilities (DG);
    047     * 08-Jun-2005 : Fixed equals() method to handle GradientPaint() (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.io.SerialUtilities;
    071    import org.jfree.ui.RectangleEdge;
    072    import org.jfree.util.ObjectUtilities;
    073    import org.jfree.util.PaintUtilities;
    074    import org.jfree.util.PublicCloneable;
    075    import org.jfree.util.ShapeUtilities;
    076
    077    /**
    078     * A simple line annotation that can be placed on an {@link XYPlot}.
    079     */
    080    public class XYLineAnnotation extends AbstractXYAnnotation
    081                                  implements Cloneable, PublicCloneable,
    082                                             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            g2.draw(line);
    200
    201            String toolTip = getToolTipText();
    202            String url = getURL();
    203            if (toolTip != null || url != null) {
    204                addEntity(info, ShapeUtilities.createLineRegion(line, 1.0f),
    205                        rendererIndex, toolTip, url);
    206            }
    207        }
    208
    209        /**
    210         * Tests this object for equality with an arbitrary object.
    211         *
    212         * @param obj  the object to test against (<code>null</code> permitted).
    213         *
    214         * @return <code>true</code> or <code>false</code>.
    215         */
    216        public boolean equals(Object obj) {
    217            if (obj == this) {
    218                return true;
    219            }
    220            if (!super.equals(obj)) {
    221                return false;
    222            }
    223            if (!(obj instanceof XYLineAnnotation)) {
    224                return false;
    225            }
    226            XYLineAnnotation that = (XYLineAnnotation) obj;
    227            if (this.x1 != that.x1) {
    228                return false;
    229            }
    230            if (this.y1 != that.y1) {
    231                return false;
    232            }
    233            if (this.x2 != that.x2) {
    234                return false;
    235            }
    236            if (this.y2 != that.y2) {
    237                return false;
    238            }
    239            if (!PaintUtilities.equal(this.paint, that.paint)) {
    240                return false;
    241            }
    242            if (!ObjectUtilities.equal(this.stroke, that.stroke)) {
    243                return false;
    244            }
    245            // seems to be the same...
    246            return true;
    247        }
    248
    249        /**
    250         * Returns a hash code.
    251         *
    252         * @return A hash code.
    253         */
    254        public int hashCode() {
    255            int result;
    256            long temp;
    257            temp = Double.doubleToLongBits(this.x1);
    258            result = (int) (temp ^ (temp >>> 32));
    259            temp = Double.doubleToLongBits(this.x2);
    260            result = 29 * result + (int) (temp ^ (temp >>> 32));
    261            temp = Double.doubleToLongBits(this.y1);
    262            result = 29 * result + (int) (temp ^ (temp >>> 32));
    263            temp = Double.doubleToLongBits(this.y2);
    264            result = 29 * result + (int) (temp ^ (temp >>> 32));
    265            return result;
    266        }
    267
    268        /**
    269         * Returns a clone of the annotation.
    270         *
    271         * @return A clone.
    272         *
    273         * @throws CloneNotSupportedException  if the annotation can't be cloned.
    274         */
    275        public Object clone() throws CloneNotSupportedException {
    276            return super.clone();
    277        }
    278
    279        /**
    280         * Provides serialization support.
    281         *
    282         * @param stream  the output stream.
    283         *
    284         * @throws IOException  if there is an I/O error.
    285         */
    286        private void writeObject(ObjectOutputStream stream) throws IOException {
    287            stream.defaultWriteObject();
    288            SerialUtilities.writePaint(this.paint, stream);
    289            SerialUtilities.writeStroke(this.stroke, stream);
    290        }
    291
    292        /**
    293         * Provides serialization support.
    294         *
    295         * @param stream  the input stream.
    296         *
    297         * @throws IOException  if there is an I/O error.
    298         * @throws ClassNotFoundException  if there is a classpath problem.
    299         */
    300        private void readObject(ObjectInputStream stream)
    301            throws IOException, ClassNotFoundException {
    302            stream.defaultReadObject();
    303            this.paint = SerialUtilities.readPaint(stream);
    304            this.stroke = SerialUtilities.readStroke(stream);
    305        }
    306
    307    }