/* ===========================================================

 * JFreeChart : a free chart library for the Java(tm) platform

 * ===========================================================

 *

 * (C) Copyright 2000-2004, by Object Refinery Limited and Contributors.

 *

 * Project Info:  http://www.jfree.org/jfreechart/index.html

 *

 * This library is free software; you can redistribute it and/or modify it under the terms

 * of the GNU Lesser General Public License as published by the Free Software Foundation;

 * either version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;

 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 * See the GNU Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License along with this

 * library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,

 * Boston, MA 02111-1307, USA.

 *

 * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 

 * in the United States and other countries.]

 *

 * ---------

 * Plot.java

 * ---------

 * (C) Copyright 2000-2004, by Object Refinery Limited and Contributors.

 *

 * Original Author:  David Gilbert (for Object Refinery Limited);

 * Contributor(s):   Sylvain Vieujot;

 *                   Jeremy Bowman;

 *                   Andreas Schneider;

 *                   Gideon Krause;

 *                   Nicolas Brodu;

 *

 * $Id: Plot.java,v 1.1 2004/08/31 14:39:21 mungady Exp $

 *

 * Changes (from 21-Jun-2001)

 * --------------------------

 * 21-Jun-2001 : Removed redundant JFreeChart parameter from constructors (DG);

 * 18-Sep-2001 : Updated header info and fixed DOS encoding problem (DG);

 * 19-Oct-2001 : Moved series paint and stroke methods from JFreeChart class (DG);

 * 23-Oct-2001 : Created renderer for LinePlot class (DG);

 * 07-Nov-2001 : Changed type names for ChartChangeEvent (DG);

 *               Tidied up some Javadoc comments (DG);

 * 13-Nov-2001 : Changes to allow for null axes on plots such as PiePlot (DG);

 *               Added plot/axis compatibility checks (DG);

 * 12-Dec-2001 : Changed constructors to protected, and removed unnecessary 'throws' clauses (DG);

 * 13-Dec-2001 : Added tooltips (DG);

 * 22-Jan-2002 : Added handleClick(...) method, as part of implementation for crosshairs (DG);

 *               Moved tooltips reference into ChartInfo class (DG);

 * 23-Jan-2002 : Added test for null axes in chartChanged(...) method, thanks to Barry Evans for

 *               the bug report (number 506979 on SourceForge) (DG);

 *               Added a zoom(...) method (DG);

 * 05-Feb-2002 : Updated setBackgroundPaint(), setOutlineStroke() and setOutlinePaint() to better

 *               handle null values, as suggested by Sylvain Vieujot (DG);

 * 06-Feb-2002 : Added background image, plus alpha transparency for background and foreground (DG);

 * 06-Mar-2002 : Added AxisConstants interface (DG);

 * 26-Mar-2002 : Changed zoom method from empty to abstract (DG);

 * 23-Apr-2002 : Moved dataset from JFreeChart class (DG);

 * 11-May-2002 : Added ShapeFactory interface for getShape() methods, contributed by Jeremy

 *               Bowman (DG);

 * 28-May-2002 : Fixed bug in setSeriesPaint(int, Paint) for subplots (AS);

 * 25-Jun-2002 : Removed redundant imports (DG);

 * 30-Jul-2002 : Added 'no data' message for charts with null or empty datasets (DG);

 * 21-Aug-2002 : Added code to extend series array if necessary (refer to SourceForge bug

 *               id 594547 for details) (DG);

 * 17-Sep-2002 : Fixed bug in getSeriesOutlineStroke(...) method, reported by Andreas

 *               Schroeder (DG);

 * 23-Sep-2002 : Added getLegendItems() abstract method (DG);

 * 24-Sep-2002 : Removed firstSeriesIndex, subplots now use their own paint settings, there is a

 *               new mechanism for the legend to collect the legend items (DG);

 * 27-Sep-2002 : Added dataset group (DG);

 * 14-Oct-2002 : Moved listener storage into EventListenerList.  Changed some abstract methods

 *               to empty implementations (DG);

 * 28-Oct-2002 : Added a getBackgroundImage() method (DG);

 * 21-Nov-2002 : Added a plot index for identifying subplots in combined and overlaid charts (DG);

 * 22-Nov-2002 : Changed all attributes from 'protected' to 'private'.  Added dataAreaRatio

 *               attribute from David M O'Donnell's code (DG);

 * 09-Jan-2003 : Integrated fix for plot border contributed by Gideon Krause (DG);

 * 17-Jan-2003 : Moved to com.jrefinery.chart.plot (DG);

 * 23-Jan-2003 : Removed one constructor (DG);

 * 26-Mar-2003 : Implemented Serializable (DG);

 * 14-Jul-2003 : Moved the dataset and secondaryDataset attributes to the CategoryPlot and

 *               XYPlot classes (DG);

 * 21-Jul-2003 : Moved DrawingSupplier from CategoryPlot and XYPlot up to this class (DG);

 * 20-Aug-2003 : Implemented Cloneable (DG);

 * 11-Sep-2003 : Listeners and clone (NB);

 * 29-Oct-2003 : Added workaround for font alignment in PDF output (DG);

 * 03-Dec-2003 : Modified draw method to accept anchor (DG);

 * 12-Mar-2004 : Fixed clipping bug in drawNoDataMessage() method (DG);

 * 07-Apr-2004 : Modified string bounds calculation (DG);

 *

 */



package org.jfree.chart.plot;



import java.awt.AlphaComposite;

import java.awt.BasicStroke;

import java.awt.Color;

import java.awt.Composite;

import java.awt.Font;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.Insets;

import java.awt.Paint;

import java.awt.Shape;

import java.awt.Stroke;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.Serializable;



import javax.swing.event.EventListenerList;



import org.jfree.chart.LegendItemCollection;

import org.jfree.chart.axis.AxisLocation;

import org.jfree.chart.event.AxisChangeEvent;

import org.jfree.chart.event.AxisChangeListener;

import org.jfree.chart.event.PlotChangeEvent;

import org.jfree.chart.event.PlotChangeListener;

import org.jfree.data.general.DatasetChangeEvent;

import org.jfree.data.general.DatasetChangeListener;

import org.jfree.data.general.DatasetGroup;

import org.jfree.io.SerialUtilities;

import org.jfree.text.G2TextMeasurer;

import org.jfree.text.TextBlock;

import org.jfree.text.TextBlockAnchor;

import org.jfree.text.TextUtilities;

import org.jfree.ui.Align;

import org.jfree.ui.RectangleEdge;

import org.jfree.ui.Size2D;

import org.jfree.util.ObjectUtils;



/**

 * The base class for all plots in JFreeChart.  The {@link org.jfree.chart.JFreeChart} class

 * delegates the drawing of axes and data to the plot.  This base class provides facilities common

 * to most plot types.

 */

public abstract class Plot implements AxisChangeListener,

                                      DatasetChangeListener,

                                      Serializable,

                                      Cloneable {



    /** Useful constant representing zero. */

    public static final Number ZERO = new Integer(0);



    /** The default insets. */

    public static final Insets DEFAULT_INSETS = new Insets(4, 8, 4, 8);



    /** The default outline stroke. */

    public static final Stroke DEFAULT_OUTLINE_STROKE = new BasicStroke(0.5f);



    /** The default outline color. */

    public static final Paint DEFAULT_OUTLINE_PAINT = Color.gray;



    /** The default foreground alpha transparency. */

    public static final float DEFAULT_FOREGROUND_ALPHA = 1.0f;



    /** The default background alpha transparency. */

    public static final float DEFAULT_BACKGROUND_ALPHA = 1.0f;



    /** The default background color. */

    public static final Paint DEFAULT_BACKGROUND_PAINT = Color.white;



    /** The minimum width at which the plot should be drawn. */

    public static final int MINIMUM_WIDTH_TO_DRAW = 10;



    /** The minimum height at which the plot should be drawn. */

    public static final int MINIMUM_HEIGHT_TO_DRAW = 10;



    /** The parent plot (<code>null</code> if this is the root plot). */

    private Plot parent;



    /** The dataset group (to be used for thread synchronisation). */

    private DatasetGroup datasetGroup;



    /** The message to display if no data is available. */

    private String noDataMessage;



    /** The font used to display the 'no data' message. */

    private Font noDataMessageFont;



    /** The paint used to draw the 'no data' message. */

    private transient Paint noDataMessagePaint;



    /** Amount of blank space around the plot area. */

    private Insets insets;



    /** The Stroke used to draw an outline around the plot. */

    private transient Stroke outlineStroke;



    /** The Paint used to draw an outline around the plot. */

    private transient Paint outlinePaint;



    /** An optional color used to fill the plot background. */

    private transient Paint backgroundPaint;



    /** An optional image for the plot background. */

    private transient Image backgroundImage;  // not currently serialized



    /** The alignment for the background image. */

    private int backgroundImageAlignment = Align.FIT;



    /** The alpha-transparency for the plot. */

    private float foregroundAlpha;



    /** The alpha transparency for the background paint. */

    private float backgroundAlpha;



    /** The drawing supplier. */

    private DrawingSupplier drawingSupplier;



    /** Storage for registered change listeners. */

    private transient EventListenerList listenerList;



    /** Defines dataArea rectangle as the ratio formed from dividing height by width

     * (of the dataArea).  Modifies plot area calculations.

     * ratio>0 will attempt to layout the plot so that the

     * dataArea.height/dataArea.width = ratio.

     * ratio<0 will attempt to layout the plot so that the

     * dataArea.height/dataArea.width in plot units (not java2D units as when ratio>0)

     * = -1.*ratio.

     */         //dmo

    private double dataAreaRatio = 0.0;  //zero when the parameter is not set



    /**

     * Creates a new plot.

     */

    protected Plot() {



        this.parent = null;

        // make sure, that no one modifies the global default insets. 

        this.insets = new Insets (DEFAULT_INSETS.top, DEFAULT_INSETS.left,

            DEFAULT_INSETS.bottom, DEFAULT_INSETS.right);

        this.backgroundPaint = DEFAULT_BACKGROUND_PAINT;

        this.backgroundAlpha = DEFAULT_BACKGROUND_ALPHA;

        this.backgroundImage = null;

        this.outlineStroke = DEFAULT_OUTLINE_STROKE;

        this.outlinePaint = DEFAULT_OUTLINE_PAINT;

        this.foregroundAlpha = DEFAULT_FOREGROUND_ALPHA;



        this.noDataMessage = null;

        this.noDataMessageFont = new Font("SansSerif", Font.PLAIN, 12);

        this.noDataMessagePaint = Color.black;



        this.drawingSupplier = new DefaultDrawingSupplier();



        this.listenerList = new EventListenerList();



    }



    /**

     * Returns the dataset group for the plot (not currently used).

     *

     * @return The dataset group.

     */

    public DatasetGroup getDatasetGroup() {

        return this.datasetGroup;

    }



    /**

     * Sets the dataset group (not currently used).

     *

     * @param group  the dataset group (<code>null</code> permitted).

     */

    protected void setDatasetGroup(DatasetGroup group) {

        this.datasetGroup = group;

    }



    /**

     * Returns the string that is displayed when the dataset is empty or <code>null</code>.

     *

     * @return The 'no data' message (<code>null</code> possible).

     */

    public String getNoDataMessage() {

        return this.noDataMessage;

    }



    /**

     * Sets the message that is displayed when the dataset is empty or null.

     *

     * @param message  the message (null permitted).

     */

    public void setNoDataMessage(String message) {

        this.noDataMessage = message;

    }



    /**

     * Returns the font used to display the 'no data' message.

     *

     * @return the font.

     */

    public Font getNoDataMessageFont() {

        return this.noDataMessageFont;

    }



    /**

     * Sets the font used to display the 'no data' message.

     *

     * @param font  the font.

     */

    public void setNoDataMessageFont(Font font) {

        this.noDataMessageFont = font;

    }



    /**

     * Returns the paint used to display the 'no data' message.

     *

     * @return the paint.

     */

    public Paint getNoDataMessagePaint() {

        return this.noDataMessagePaint;

    }



    /**

     * Sets the paint used to display the 'no data' message.

     *

     * @param paint  the paint.

     */

    public void setNoDataMessagePaint(Paint paint) {

        this.noDataMessagePaint = paint;

    }



    /**

     * Returns a short string describing the plot type.

     * <P>

     * Note: this gets used in the chart property editing user interface,

     * but there needs to be a better mechanism for identifying the plot type.

     *

     * @return a short string describing the plot type.

     */

    public abstract String getPlotType();



    /**

     * Returns the parent plot (or null if this plot is not part of a combined plot).

     *

     * @return the parent plot.

     */

    public Plot getParent() {

        return this.parent;

    }



    /**

     * Sets the parent plot.

     *

     * @param parent  the parent plot.

     */

    public void setParent(Plot parent) {

        this.parent = parent;

    }



    /**

     * Returns the root plot.

     *

     * @return The root plot.

     */

    public Plot getRootPlot() {



        Plot p = getParent();

        if (p == null) {

            return this;

        }

        else {

            return p.getRootPlot();

        }



    }



    /**

     * Returns true if this plot is part of a combined plot structure.

     *

     * @return <code>true</code> if this plot is part of a combined plot structure.

     */

    public boolean isSubplot() {

        return (getParent() != null);

    }





    /**

     * Returns the insets for the plot area.

     *

     * @return The insets.

     */

    public Insets getInsets() {

        return this.insets;

    }



    /**

     * Sets the insets for the plot and notifies registered listeners that the

     * plot has been modified.

     *

     * @param insets  the new insets.

     */

    public void setInsets(Insets insets) {

        setInsets(insets, true);

    }



    /**

     * Sets the insets for the plot and, if requested, notifies registered listeners that the

     * plot has been modified.

     *

     * @param insets  the new insets (<code>null</code> not permitted).

     * @param notify  a flag that controls whether the registered listeners are notified.

     */

    public void setInsets(Insets insets, boolean notify) {

        if (insets == null) {

            throw new IllegalArgumentException("Null 'insets' argument.");

        }

        if (!this.insets.equals(insets)) {

            this.insets = insets;

            if (notify) {

                notifyListeners(new PlotChangeEvent(this));

            }

        }



    }



    /**

     * Returns the background color of the plot area.

     *

     * @return the paint (possibly <code>null</code>).

     */

    public Paint getBackgroundPaint() {

        return this.backgroundPaint;

    }



    /**

     * Sets the background color of the plot area and sends a {@link PlotChangeEvent} to

     * all registered listeners.

     *

     * @param paint  the paint (<code>null</code> permitted).

     */

    public void setBackgroundPaint(Paint paint) {



        if (paint == null) {

            if (this.backgroundPaint != null) {

                this.backgroundPaint = null;

                notifyListeners(new PlotChangeEvent(this));

            }

        }

        else {

            if (this.backgroundPaint != null) {

                if (this.backgroundPaint.equals(paint)) {

                    return;  // nothing to do

                }

            }

            this.backgroundPaint = paint;

            notifyListeners(new PlotChangeEvent(this));

        }



    }



    /**

     * Returns the alpha transparency of the plot area background.

     *

     * @return the alpha transparency.

     */

    public float getBackgroundAlpha() {

        return this.backgroundAlpha;

    }



    /**

     * Sets the alpha transparency of the plot area background, and notifies

     * registered listeners that the plot has been modified.

     *

     * @param alpha the new alpha value.

     */

    public void setBackgroundAlpha(float alpha) {



        if (this.backgroundAlpha != alpha) {

            this.backgroundAlpha = alpha;

            notifyListeners(new PlotChangeEvent(this));

        }



    }



    /**

     * Returns the drawing supplier for the plot.

     *

     * @return the drawing supplier (possibly <code>null</code>).

     */

    public DrawingSupplier getDrawingSupplier() {

        DrawingSupplier result = null;

        Plot p = getParent();

        if (p != null) {

            result = p.getDrawingSupplier();

        }

        else {

            result = this.drawingSupplier;

        }

        return result;

    }



    /**

     * Sets the drawing supplier for the plot.  The drawing supplier is responsible for

     * supplying a limitless (possibly repeating) sequence of <code>Paint</code>,

     * <code>Stroke</code> and <code>Shape</code> objects that the plot's renderer(s) can use

     * to populate its(their) tables.

     *

     * @param supplier  the new supplier.

     */

    public void setDrawingSupplier(DrawingSupplier supplier) {

        this.drawingSupplier = supplier;

        notifyListeners(new PlotChangeEvent(this));

    }



    /**

     * Returns the background image that is used to fill the plot's background area.

     *

     * @return The image (possibly <code>null</code>).

     */

    public Image getBackgroundImage() {

        return this.backgroundImage;

    }



    /**

     * Sets the background image for the plot.

     *

     * @param image  the image (<code>null</code> permitted).

     */

    public void setBackgroundImage(Image image) {

        this.backgroundImage = image;

        notifyListeners(new PlotChangeEvent(this));

    }



    /**

     * Returns the background image alignment. Alignment constants are defined in the

     * <code>org.jfree.ui.Align</code> class in the JCommon class library.

     *

     * @return The alignment.

     */

    public int getBackgroundImageAlignment() {

        return this.backgroundImageAlignment;

    }



    /**

     * Sets the background alignment.

     * <p>

     * Alignment options are defined by the {@link org.jfree.ui.Align} class.

     *

     * @param alignment  the alignment.

     */

    public void setBackgroundImageAlignment(int alignment) {

        if (this.backgroundImageAlignment != alignment) {

            this.backgroundImageAlignment = alignment;

            notifyListeners(new PlotChangeEvent(this));

        }

    }



    /**

     * Returns the stroke used to outline the plot area.

     *

     * @return the stroke (possibly <code>null</code>).

     */

    public Stroke getOutlineStroke() {

        return this.outlineStroke;

    }



    /**

     * Sets the stroke used to outline the plot area and sends a {@link PlotChangeEvent} to all

     * registered listeners. If you set this attribute to <code>null<.code>, no outline will be 

     * drawn.

     *

     * @param stroke  the stroke (<code>null</code> permitted).

     */

    public void setOutlineStroke(Stroke stroke) {



        if (stroke == null) {

            if (this.outlineStroke != null) {

                this.outlineStroke = null;

                notifyListeners(new PlotChangeEvent(this));

            }

        }

        else {

            if (this.outlineStroke != null) {

                if (this.outlineStroke.equals(stroke)) {

                    return;  // nothing to do

                }

            }

            this.outlineStroke = stroke;

            notifyListeners(new PlotChangeEvent(this));

        }



    }



    /**

     * Returns the color used to draw the outline of the plot area.

     *

     * @return The color (possibly <code>null<code>).

     */

    public Paint getOutlinePaint() {

        return this.outlinePaint;

    }



    /**

     * Sets the paint used to draw the outline of the plot area and sends a {@link PlotChangeEvent} 

     * to all registered listeners.  If you set this attribute to <code>null</code>, no outline 

     * will be drawn.

     *

     * @param paint  the paint (<code>null</code> permitted).

     */

    public void setOutlinePaint(Paint paint) {



        if (paint == null) {

            if (this.outlinePaint != null) {

                this.outlinePaint = null;

                notifyListeners(new PlotChangeEvent(this));

            }

        }

        else {

            if (this.outlinePaint != null) {

                if (this.outlinePaint.equals(paint)) {

                    return;  // nothing to do

                }

            }

            this.outlinePaint = paint;

            notifyListeners(new PlotChangeEvent(this));

        }



    }



    /**

     * Returns the alpha-transparency for the plot foreground.

     *

     * @return the alpha-transparency.

     */

    public float getForegroundAlpha() {

        return this.foregroundAlpha;

    }



    /**

     * Sets the alpha-transparency for the plot.

     *

     * @param alpha  the new alpha transparency.

     */

    public void setForegroundAlpha(float alpha) {



        if (this.foregroundAlpha != alpha) {

            this.foregroundAlpha = alpha;

            notifyListeners(new PlotChangeEvent(this));

        }



    }



    /**

     * Returns the legend items for the plot.  By default, this method returns <code>null</code>.  

     * Subclasses should override to return a {@link LegendItemCollection}.

     *

     * @return The legend items for the plot (possibly <code>null</code>).

     */

    public LegendItemCollection getLegendItems() {

        return null;

    }



    /**

     * Registers an object for notification of changes to the plot.

     *

     * @param listener  the object to be registered.

     */

    public void addChangeListener(PlotChangeListener listener) {

        this.listenerList.add(PlotChangeListener.class, listener);

    }



    /**

     * Unregisters an object for notification of changes to the plot.

     *

     * @param listener  the object to be unregistered.

     */

    public void removeChangeListener(PlotChangeListener listener) {

        this.listenerList.remove(PlotChangeListener.class, listener);

    }



    /**

     * Notifies all registered listeners that the plot has been modified.

     *

     * @param event  information about the change event.

     */

    public void notifyListeners(PlotChangeEvent event) {



        Object[] listeners = this.listenerList.getListenerList();

        for (int i = listeners.length - 2; i >= 0; i -= 2) {

            if (listeners[i] == PlotChangeListener.class) {

                ((PlotChangeListener) listeners[i + 1]).plotChanged(event);

            }

        }



    }



    /**

     * Draws the plot on a Java 2D graphics device (such as the screen or a printer).

     * <P>

     * This class does not store any information about where the individual

     * items that make up the plot are actually drawn.  If you want to collect

     * this information, pass in a ChartRenderingInfo object.  After the

     * drawing is complete, the info object will contain lots of information

     * about the chart.  If you don't want the information, pass in null.

     * *

     * @param g2  the graphics device.

     * @param plotArea  the area within which the plot should be drawn.

     * @param parentState  the state from the parent plot, if there is one.

     * @param info  an object for collecting information about the drawing of the chart.

     */

    public abstract void draw(Graphics2D g2, 

                              Rectangle2D plotArea, 

                              PlotState parentState, 

                              PlotRenderingInfo info);



    /**

     * Implement later to make use of anchor.

     * 

     * @param g2  the graphics device.

     * @param area  the plot area.

     * @param anchor  the anchor point.

     * @param parentState  the parent state (if any).

     * @param info  carries back plot rendering info.

     */

    public void draw(Graphics2D g2,

                     Rectangle2D area,

                     Point2D anchor,

                     PlotState parentState,

                     PlotRenderingInfo info) {

        draw(g2, area, parentState, info);                          

    }

                              

    /**

     * Draws the plot background (the background color and/or image).

     * <P>

     * This method will be called during the chart drawing process and is declared public

     * so that it can be accessed by the renderers used by certain subclasses.  You shouldn't 

     * need to call this method directly.

     *

     * @param g2  the graphics device.

     * @param area  the area within which the plot should be drawn.

     */

    public void drawBackground(Graphics2D g2, Rectangle2D area) {

        fillBackground(g2, area);

        drawBackgroundImage(g2, area);

    }



    /**

     * Fills the specified area with the background paint.

     * 

     * @param g2  the graphics device.

     * @param area  the area.

     */

    protected void fillBackground(Graphics2D g2, Rectangle2D area) {

        if (this.backgroundPaint != null) {

            Composite originalComposite = g2.getComposite();

            g2.setComposite(

                AlphaComposite.getInstance(AlphaComposite.SRC_OVER, this.backgroundAlpha)

            );

            g2.setPaint(this.backgroundPaint);

            g2.fill(area);

            g2.setComposite(originalComposite);

        }        

    }

    

    /**

     * Draws the background image (if there is one) aligned within the specified area.

     * 

     * @param g2  the graphics device.

     * @param area  the area.

     */

    protected void drawBackgroundImage(Graphics2D g2, Rectangle2D area) {

        if (this.backgroundImage != null) {

            Composite originalComposite = g2.getComposite();

            g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC, this.backgroundAlpha));

            Rectangle2D dest = new Rectangle2D.Double(

                0.0, 0.0,

                this.backgroundImage.getWidth(null), this.backgroundImage.getHeight(null)

            );

            Align.align(dest, area, this.backgroundImageAlignment);

            g2.drawImage(

                this.backgroundImage,

                (int) dest.getX(), (int) dest.getY(),

                (int) dest.getWidth() + 1, (int) dest.getHeight() + 1, null

            );

            g2.setComposite(originalComposite);

        }

    }

    

    /**

     * Draws the plot outline.  This method will be called during the chart drawing process and is

     * declared public so that it can be accessed by the renderers used by certain subclasses.  

     * You shouldn't need to call this method directly.

     * 

     * @param g2  the graphics device.

     * @param area  the area within which the plot should be drawn.

     */

    public void drawOutline(Graphics2D g2, Rectangle2D area) {

        if ((this.outlineStroke != null) && (this.outlinePaint != null)) {

            g2.setStroke(this.outlineStroke);

            g2.setPaint(this.outlinePaint);

            g2.draw(area);

        }

    }



    /**

     * Draws a message to state that there is no data to plot.

     *

     * @param g2  the graphics device.

     * @param area  the area within which the plot should be drawn.

     */

    protected void drawNoDataMessage(Graphics2D g2, Rectangle2D area) {



        Shape savedClip = g2.getClip();

        g2.clip(area);

        String message = this.noDataMessage;

        if (message != null) {

            g2.setFont(this.noDataMessageFont);

            g2.setPaint(this.noDataMessagePaint);

//            FontMetrics fm = g2.getFontMetrics(this.noDataMessageFont);

//            Rectangle2D bounds = TextUtilities.getTextBounds(message, g2, fm);

//            float x = (float) (area.getX() + area.getWidth() / 2 - bounds.getWidth() / 2);

//            float y = (float) (area.getMinY() + (area.getHeight() / 2) - (bounds.getHeight() / 2));

//            g2.drawString(message, x, y);

            TextBlock block = TextUtilities.createTextBlock(

                this.noDataMessage, this.noDataMessageFont, this.noDataMessagePaint, 

                0.9f * (float) area.getWidth(), new G2TextMeasurer(g2)

            );

            block.draw(

                g2, (float) area.getCenterX(), (float) area.getCenterY(), TextBlockAnchor.CENTER

            );

        }

        g2.setClip(savedClip);



    }



    /**

     * Handles a 'click' on the plot.  Since the plot does not maintain any

     * information about where it has been drawn, the plot rendering info is supplied as

     * an argument.

     *

     * @param x  the x coordinate (in Java2D space).

     * @param y  the y coordinate (in Java2D space).

     * @param info  an object containing information about the dimensions of the plot.

     */

    public void handleClick(int x, int y, PlotRenderingInfo info) {

        // provides a 'no action' default

    }



    /**

     * Performs a zoom on the plot.  Subclasses should override if zooming is appropriate for

     * the type of plot.

     *

     * @param percent  the zoom percentage.

     */

    public void zoom(double percent) {

        // do nothing by default.

    }



    /**

     * Receives notification of a change to one of the plot's axes.

     *

     * @param event  information about the event (not used here).

     */

    public void axisChanged(AxisChangeEvent event) {

        notifyListeners(new PlotChangeEvent(this));

    }



    /**

     * Receives notification of a change to the plot's dataset.

     * <P>

     * The plot reacts by passing on a plot change event to all registered listeners.

     *

     * @param event  information about the event (not used here).

     */

    public void datasetChanged(DatasetChangeEvent event) {



        PlotChangeEvent newEvent = new PlotChangeEvent(this);

        notifyListeners(newEvent);



    }



    /**

     * Adjusts the supplied x-value.

     *

     * @param x  the x-value.

     * @param w1  width 1.

     * @param w2  width 2.

     * @param edge  the edge (left or right).

     *

     * @return the adjusted x-value.

     */

    protected double getRectX(double x, double w1, double w2, RectangleEdge edge) {



        double result = x;

        if (edge == RectangleEdge.LEFT) {

            result = result + w1;

        }

        else if (edge == RectangleEdge.RIGHT) {

            result = result + w2;

        }

        return result;



    }



    /**

     * Adjusts the supplied y-value.

     *

     * @param y  the x-value.

     * @param h1  height 1.

     * @param h2  height 2.

     * @param edge  the edge (top or bottom).

     *

     * @return the adjusted y-value.

     */

    protected double getRectY(double y, double h1, double h2, RectangleEdge edge) {



        double result = y;

        if (edge == RectangleEdge.TOP) {

            result = result + h1;

        }

        else if (edge == RectangleEdge.BOTTOM) {

            result = result + h2;

        }

        return result;



    }



    /**

     * Returns the data area ratio.

     *

     * @return The ratio.

     */

    public double getDataAreaRatio() {

        return this.dataAreaRatio;

    }



    /**

     * Sets the data area ratio.

     *

     * @param ratio  the ratio.

     */

    public void setDataAreaRatio(double ratio) {

        this.dataAreaRatio = ratio;

    }



    /**

     * Tests this plot for equality with another object.

     *

     * @param obj  the object.

     *

     * @return <code>true</code> or <code>false</code>.

     */

    public boolean equals(Object obj) {



        if (obj == null) {

            return false;

        }



        if (obj == this) {

            return true;

        }



        if (obj instanceof Plot) {



            Plot p = (Plot) obj;



            boolean b5 = ObjectUtils.equal(this.noDataMessage, p.noDataMessage);

            boolean b6 = ObjectUtils.equal(this.noDataMessageFont, p.noDataMessageFont);

            boolean b7 = ObjectUtils.equal(this.noDataMessagePaint, p.noDataMessagePaint);



            boolean b8 = ObjectUtils.equal(this.insets, p.insets);

            boolean b9 = ObjectUtils.equal(this.outlineStroke, p.outlineStroke);

            boolean b10 = ObjectUtils.equal(this.outlinePaint, p.outlinePaint);



            boolean b11 = ObjectUtils.equal(this.backgroundPaint, p.backgroundPaint);

            boolean b12 = ObjectUtils.equal(this.backgroundImage, p.backgroundImage);

            boolean b13 = (this.backgroundImageAlignment == p.backgroundImageAlignment);



            boolean b14 = (this.foregroundAlpha == p.foregroundAlpha);

            boolean b15 = (this.backgroundAlpha == p.backgroundAlpha);



            return b5 && b6 && b7 && b8 && b9

                && b10 && b11 && b12 && b13 && b14 && b15;



        }



        return false;



    }



    /**

     * Creates a clone of the plot.

     *

     * @return A clone.

     *

     * @throws CloneNotSupportedException if some component of the plot does not support cloning.

     */

    public Object clone() throws CloneNotSupportedException {



        Plot clone = (Plot) super.clone();

        //private Plot parent <-- don't clone the parent plot, but take care childs in combined 

        // plots instead

        clone.datasetGroup = (DatasetGroup) ObjectUtils.clone(this.datasetGroup);

        //private String noDataMessage <-- immutable

        //private Font noDataMessageFont <-- immutable

        //private transient Paint noDataMessagePaint <-- immutable

        //private Insets insets <-- immutable

        //private transient Stroke outlineStroke <-- immutable

        //private transient Paint outlinePaint <-- immutable

        //private transient Paint backgroundPaint <-- immutable

        //private transient Image backgroundImage <-- ???

        //private int backgroundImageAlignment<-- primitive

        //private float foregroundAlpha <-- primitive

        //private float backgroundAlpha <-- primitive

        clone.drawingSupplier = (DrawingSupplier) ObjectUtils.clone(this.drawingSupplier);

        //private transient EventListenerList listenerList <-- ???

        //private double dataAreaRatio <-- primitive



        clone.listenerList = new EventListenerList();

        return clone;



    }



    /**

     * Provides serialization support.

     *

     * @param stream  the output stream.

     *

     * @throws IOException  if there is an I/O error.

     */

    private void writeObject(ObjectOutputStream stream) throws IOException {

        stream.defaultWriteObject();

        SerialUtilities.writePaint(this.noDataMessagePaint, stream);

        SerialUtilities.writeStroke(this.outlineStroke, stream);

        SerialUtilities.writePaint(this.outlinePaint, stream);

        // backgroundImage

        SerialUtilities.writePaint(this.backgroundPaint, stream);

    }



    /**

     * Provides serialization support.

     *

     * @param stream  the input stream.

     *

     * @throws IOException  if there is an I/O error.

     * @throws ClassNotFoundException  if there is a classpath problem.

     */

    private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {

        stream.defaultReadObject();

        this.noDataMessagePaint = SerialUtilities.readPaint(stream);

        this.outlineStroke = SerialUtilities.readStroke(stream);

        this.outlinePaint = SerialUtilities.readPaint(stream);

        // backgroundImage

        this.backgroundPaint = SerialUtilities.readPaint(stream);



        this.listenerList = new EventListenerList();



    }



    /**

     * Resolves a domain axis location for a given plot orientation.

     *

     * @param location  the location (<code>null</code> not permitted).

     * @param orientation  the orientation (<code>null</code> not permitted).

     *

     * @return The edge (never <code>null</code>).

     */

    public static RectangleEdge resolveDomainAxisLocation(AxisLocation location,

                                                          PlotOrientation orientation) {

        

        if (location == null) {

            throw new IllegalArgumentException("Null 'location' argument.");   

        }

        if (orientation == null) {

            throw new IllegalArgumentException("Null 'orientation' argument.");   

        }



        RectangleEdge result = null;

        

        if (location == AxisLocation.TOP_OR_RIGHT) {

            if (orientation == PlotOrientation.HORIZONTAL) {

                result = RectangleEdge.RIGHT;

            }

            else if (orientation == PlotOrientation.VERTICAL) {

                result = RectangleEdge.TOP;

            }

        }

        else if (location == AxisLocation.TOP_OR_LEFT) {

            if (orientation == PlotOrientation.HORIZONTAL) {

                result = RectangleEdge.LEFT;

            }

            else if (orientation == PlotOrientation.VERTICAL) {

                result = RectangleEdge.TOP;

            }

        }

        else if (location == AxisLocation.BOTTOM_OR_RIGHT) {

            if (orientation == PlotOrientation.HORIZONTAL) {

                result = RectangleEdge.RIGHT;

            }

            else if (orientation == PlotOrientation.VERTICAL) {

                result = RectangleEdge.BOTTOM;

            }

        }

        else if (location == AxisLocation.BOTTOM_OR_LEFT) {

            if (orientation == PlotOrientation.HORIZONTAL) {

                result = RectangleEdge.LEFT;

            }

            else if (orientation == PlotOrientation.VERTICAL) {

                result = RectangleEdge.BOTTOM;

            }

        }

        // the above should cover all the options...

        if (result == null) {

            throw new IllegalStateException("XYPlot.resolveDomainAxisLocation(...)");

        }

        return result;

        

    }



    /**

     * Resolves a range axis location for a given plot orientation.

     *

     * @param location  the location (<code>null</code> not permitted).

     * @param orientation  the orientation (<code>null</code> not permitted).

     *

     * @return the edge (never <code>null</code>).

     */

    public static RectangleEdge resolveRangeAxisLocation(AxisLocation location,

                                                         PlotOrientation orientation) {



        if (location == null) {

            throw new IllegalArgumentException("Null 'location' argument.");   

        }

        if (orientation == null) {

            throw new IllegalArgumentException("Null 'orientation' argument.");   

        }



        RectangleEdge result = null;

        

        if (location == AxisLocation.TOP_OR_RIGHT) {

            if (orientation == PlotOrientation.HORIZONTAL) {

                result = RectangleEdge.TOP;

            }

            else if (orientation == PlotOrientation.VERTICAL) {

                result = RectangleEdge.RIGHT;

            }

        }

        else if (location == AxisLocation.TOP_OR_LEFT) {

            if (orientation == PlotOrientation.HORIZONTAL) {

                result = RectangleEdge.TOP;

            }

            else if (orientation == PlotOrientation.VERTICAL) {

                result = RectangleEdge.LEFT;

            }

        }

        else if (location == AxisLocation.BOTTOM_OR_RIGHT) {

            if (orientation == PlotOrientation.HORIZONTAL) {

                result = RectangleEdge.BOTTOM;

            }

            else if (orientation == PlotOrientation.VERTICAL) {

                result = RectangleEdge.RIGHT;

            }

        }

        else if (location == AxisLocation.BOTTOM_OR_LEFT) {

            if (orientation == PlotOrientation.HORIZONTAL) {

                result = RectangleEdge.BOTTOM;

            }

            else if (orientation == PlotOrientation.VERTICAL) {

                result = RectangleEdge.LEFT;

            }

        }



        // the above should cover all the options...

        if (result == null) {

            throw new IllegalStateException("XYPlot.resolveRangeAxisLocation(...)");

        }

        return result;

        

    }



}



