    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
    051package org.jfree.chart.annotations;
    052
    053import java.awt.BasicStroke;
    054import java.awt.Color;
    055import java.awt.Graphics2D;
    056import java.awt.Paint;
    057import java.awt.Stroke;
    058import java.awt.geom.Line2D;
    059import java.awt.geom.Rectangle2D;
    060import java.io.IOException;
    061import java.io.ObjectInputStream;
    062import java.io.ObjectOutputStream;
    063import java.io.Serializable;
    064
    065import org.jfree.chart.axis.ValueAxis;
    066import org.jfree.chart.plot.Plot;
    067import org.jfree.chart.plot.PlotOrientation;
    068import org.jfree.chart.plot.PlotRenderingInfo;
    069import org.jfree.chart.plot.XYPlot;
    070import org.jfree.chart.util.LineUtilities;
    071import org.jfree.io.SerialUtilities;
    072import org.jfree.ui.RectangleEdge;
    073import org.jfree.util.ObjectUtilities;
    074import org.jfree.util.PaintUtilities;
    075import org.jfree.util.PublicCloneable;
    076import org.jfree.util.ShapeUtilities;
    077
    078/**
    079 * A simple line annotation that can be placed on an {@link XYPlot}.
    080 */
    081public 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}