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     * XYDataImageAnnotation.java
029     * --------------------------
030     * (C) Copyright 2008, by Object Refinery Limited and Contributors.
031     *
032     * Original Author:  David Gilbert (for Object Refinery Limited);
033     * Contributor(s):   -;
034     *
035     * Changes:
036     * --------
037     * 17-Sep-2008 : Version 1, based on XYImageAnnotation (DG);
038     */
039    
040    package org.jfree.chart.annotations;
041    
042    import java.awt.Graphics2D;
043    import java.awt.Image;
044    import java.awt.geom.Rectangle2D;
045    import java.io.IOException;
046    import java.io.ObjectInputStream;
047    import java.io.ObjectOutputStream;
048    
049    import org.jfree.chart.axis.AxisLocation;
050    import org.jfree.chart.axis.ValueAxis;
051    import org.jfree.chart.plot.Plot;
052    import org.jfree.chart.plot.PlotOrientation;
053    import org.jfree.chart.plot.PlotRenderingInfo;
054    import org.jfree.chart.plot.XYPlot;
055    import org.jfree.ui.RectangleEdge;
056    import org.jfree.util.ObjectUtilities;
057    import org.jfree.util.PublicCloneable;
058    
059    /**
060     * An annotation that allows an image to be placed within a rectangle specified
061     * in data coordinates on an {@link XYPlot}.  Note that this annotation
062     * is not currently serializable, so don't use it if you plan on serializing
063     * your chart(s).
064     *
065     * @since 1.0.11
066     */
067    public class XYDataImageAnnotation extends AbstractXYAnnotation
068            implements Cloneable, PublicCloneable {
069    
070        /** The image. */
071        private transient Image image;
072    
073        /**
074         * The x-coordinate (in data space).
075         */
076        private double x;
077    
078        /**
079         * The y-coordinate (in data space).
080         */
081        private double y;
082    
083        /**
084         * The image display area width in data coordinates.
085         */
086        private double w;
087    
088        /**
089         * The image display area height in data coordinates.
090         */
091        private double h;
092    
093        /**
094         * Creates a new annotation to be displayed within the specified rectangle.
095         *
096         * @param image  the image (<code>null</code> not permitted).
097         * @param x  the x-coordinate (in data space).
098         * @param y  the y-coordinate (in data space).
099         * @param w  the image display area width.
100         * @param h  the image display area height.
101         */
102        public XYDataImageAnnotation(Image image, double x, double y, double w,
103                double h) {
104            if (image == null) {
105                throw new IllegalArgumentException("Null 'image' argument.");
106            }
107            this.image = image;
108            this.x = x;
109            this.y = y;
110            this.w = w;
111            this.h = h;
112        }
113    
114        /**
115         * Returns the image for the annotation.
116         *
117         * @return The image.
118         */
119        public Image getImage() {
120            return this.image;
121        }
122    
123        /**
124         * Returns the x-coordinate (in data space) for the annotation.
125         *
126         * @return The x-coordinate.
127         */
128        public double getX() {
129            return this.x;
130        }
131    
132        /**
133         * Returns the y-coordinate (in data space) for the annotation.
134         *
135         * @return The y-coordinate.
136         */
137        public double getY() {
138            return this.y;
139        }
140    
141        /**
142         * Returns the width (in data space) of the data rectangle into which the
143         * image will be drawn.
144         *
145         * @return The width.
146         */
147        public double getWidth() {
148            return this.w;
149        }
150    
151        /**
152         * Returns the height (in data space) of the data rectangle into which the
153         * image will be drawn.
154         *
155         * @return The height.
156         */
157        public double getHeight() {
158            return this.h;
159        }
160    
161        /**
162         * Draws the annotation.  This method is called by the drawing code in the
163         * {@link XYPlot} class, you don't normally need to call this method
164         * directly.
165         *
166         * @param g2  the graphics device.
167         * @param plot  the plot.
168         * @param dataArea  the data area.
169         * @param domainAxis  the domain axis.
170         * @param rangeAxis  the range axis.
171         * @param rendererIndex  the renderer index.
172         * @param info  if supplied, this info object will be populated with
173         *              entity information.
174         */
175        public void draw(Graphics2D g2, XYPlot plot, Rectangle2D dataArea,
176                         ValueAxis domainAxis, ValueAxis rangeAxis,
177                         int rendererIndex,
178                         PlotRenderingInfo info) {
179    
180            PlotOrientation orientation = plot.getOrientation();
181            AxisLocation xAxisLocation = plot.getDomainAxisLocation();
182            AxisLocation yAxisLocation = plot.getRangeAxisLocation();
183            RectangleEdge xEdge = Plot.resolveDomainAxisLocation(xAxisLocation,
184                    orientation);
185            RectangleEdge yEdge = Plot.resolveRangeAxisLocation(yAxisLocation,
186                    orientation);
187            float j2DX0 = (float) domainAxis.valueToJava2D(this.x, dataArea, xEdge);
188            float j2DY0 = (float) rangeAxis.valueToJava2D(this.y, dataArea, yEdge);
189            float j2DX1 = (float) domainAxis.valueToJava2D(this.x + this.w,
190                    dataArea, xEdge);
191            float j2DY1 = (float) rangeAxis.valueToJava2D(this.y + this.h,
192                    dataArea, yEdge);
193            float xx0 = 0.0f;
194            float yy0 = 0.0f;
195            float xx1 = 0.0f;
196            float yy1 = 0.0f;
197            if (orientation == PlotOrientation.HORIZONTAL) {
198                xx0 = j2DY0;
199                xx1 = j2DY1;
200                yy0 = j2DX0;
201                yy1 = j2DX1;
202            }
203            else if (orientation == PlotOrientation.VERTICAL) {
204                xx0 = j2DX0;
205                xx1 = j2DX1;
206                yy0 = j2DY0;
207                yy1 = j2DY1;
208            }
209            // TODO: rotate the image when drawn with horizontal orientation?
210            g2.drawImage(this.image, (int) xx0, (int) Math.min(yy0, yy1),
211                    (int) (xx1 - xx0), (int) Math.abs(yy1 - yy0), null);
212            String toolTip = getToolTipText();
213            String url = getURL();
214            if (toolTip != null || url != null) {
215                addEntity(info, new Rectangle2D.Float(xx0, yy0, (xx1 - xx0),
216                        (yy1 - yy0)), rendererIndex, toolTip, url);
217            }
218        }
219    
220        /**
221         * Tests this object for equality with an arbitrary object.
222         *
223         * @param obj  the object (<code>null</code> permitted).
224         *
225         * @return A boolean.
226         */
227        public boolean equals(Object obj) {
228            if (obj == this) {
229                return true;
230            }
231            // now try to reject equality...
232            if (!super.equals(obj)) {
233                return false;
234            }
235            if (!(obj instanceof XYDataImageAnnotation)) {
236                return false;
237            }
238            XYDataImageAnnotation that = (XYDataImageAnnotation) obj;
239            if (this.x != that.x) {
240                return false;
241            }
242            if (this.y != that.y) {
243                return false;
244            }
245            if (this.w != that.w) {
246                return false;
247            }
248            if (this.h != that.h) {
249                return false;
250            }
251            if (!ObjectUtilities.equal(this.image, that.image)) {
252                return false;
253            }
254            // seems to be the same...
255            return true;
256        }
257    
258        /**
259         * Returns a hash code for this object.
260         *
261         * @return A hash code.
262         */
263        public int hashCode() {
264            return this.image.hashCode();
265        }
266    
267        /**
268         * Returns a clone of the annotation.
269         *
270         * @return A clone.
271         *
272         * @throws CloneNotSupportedException  if the annotation can't be cloned.
273         */
274        public Object clone() throws CloneNotSupportedException {
275            return super.clone();
276        }
277    
278        /**
279         * Provides serialization support.
280         *
281         * @param stream  the output stream.
282         *
283         * @throws IOException  if there is an I/O error.
284         */
285        private void writeObject(ObjectOutputStream stream) throws IOException {
286            stream.defaultWriteObject();
287            // FIXME
288            //SerialUtilities.writeImage(this.image, stream);
289        }
290    
291        /**
292         * Provides serialization support.
293         *
294         * @param stream  the input stream.
295         *
296         * @throws IOException  if there is an I/O error.
297         * @throws ClassNotFoundException  if there is a classpath problem.
298         */
299        private void readObject(ObjectInputStream stream)
300            throws IOException, ClassNotFoundException {
301            stream.defaultReadObject();
302            // FIXME
303            //this.image = SerialUtilities.readImage(stream);
304        }
305    
306    }