Application: gvSIG desktop

package org.gvsig.remotesensing.scatterplot.chart;

import java.awt.AWTEvent;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.Insets;

import java.awt.Point;

import java.awt.Shape;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import java.awt.event.MouseMotionListener;

import java.awt.geom.AffineTransform;

import java.awt.geom.Line2D;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.print.PageFormat;

import java.awt.print.Printable;

import java.awt.print.PrinterException;

import java.awt.print.PrinterJob;

import java.io.File;

import java.io.IOException;

import java.io.Serializable;

import java.util.EventListener;

import java.util.Iterator;

import java.util.ResourceBundle;

import javax.swing.JFileChooser;

import javax.swing.JMenu;

import javax.swing.JMenuItem;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JPopupMenu;

import javax.swing.SwingUtilities;

import javax.swing.ToolTipManager;

import javax.swing.event.EventListenerList;

import org.jfree.chart.ChartMouseEvent;

import org.jfree.chart.ChartMouseListener;

import org.jfree.chart.ChartRenderingInfo;

import org.jfree.chart.ChartUtilities;

import org.jfree.chart.JFreeChart;

import org.jfree.chart.entity.ChartEntity;

import org.jfree.chart.entity.EntityCollection;

import org.jfree.chart.event.ChartChangeEvent;

import org.jfree.chart.event.ChartChangeListener;

import org.jfree.chart.event.ChartProgressEvent;

import org.jfree.chart.event.ChartProgressListener;

import org.jfree.chart.plot.Plot;

import org.jfree.chart.plot.PlotOrientation;

import org.jfree.chart.plot.PlotRenderingInfo;

import org.jfree.chart.plot.Zoomable;

import org.jfree.data.Range;

import org.jfree.data.general.DatasetGroup;

import org.jfree.ui.ExtensionFileFilter;

import com.iver.andami.PluginServices;

public class ScatterPlotDiagram extends JPanel implements ChartChangeListener,

        ChartProgressListener, ActionListener, MouseListener, 

        MouseMotionListener, Printable, Serializable {

    /** For serialization. */

    private static final long serialVersionUID = 6046366297214274674L;

    /** Default setting for buffer usage. */

    public static final boolean DEFAULT_BUFFER_USED = false;

    /** The default panel width. */

    public static final int DEFAULT_WIDTH = 680;

    /** The default panel height. */

    public static final int DEFAULT_HEIGHT = 420;

    /** The default limit below which chart scaling kicks in. */

    public static final int DEFAULT_MINIMUM_DRAW_WIDTH = 300;

    /** The default limit below which chart scaling kicks in. */

    public static final int DEFAULT_MINIMUM_DRAW_HEIGHT = 200;

    /** The default limit below which chart scaling kicks in. */

    public static final int DEFAULT_MAXIMUM_DRAW_WIDTH = 800;

    /** The default limit below which chart scaling kicks in. */

    public static final int DEFAULT_MAXIMUM_DRAW_HEIGHT = 600;

    /** The minimum size required to perform a zoom on a rectangle */

    public static final int DEFAULT_ZOOM_TRIGGER_DISTANCE = 10;

    /** Properties action command. */

    public static final String PROPERTIES_COMMAND = "PROPERTIES";

    /** Save action command. */

    public static final String SAVE_COMMAND = "SAVE";

    /** Print action command. */

    public static final String PRINT_COMMAND = "PRINT";

    /** Zoom in (both axes) action command. */

    public static final String ZOOM_IN_BOTH_COMMAND = "ZOOM_IN_BOTH";

    /** Zoom in (domain axis only) action command. */

    public static final String ZOOM_IN_DOMAIN_COMMAND = "ZOOM_IN_DOMAIN";

    /** Zoom in (range axis only) action command. */

    public static final String ZOOM_IN_RANGE_COMMAND = "ZOOM_IN_RANGE";

    /** Zoom out (both axes) action command. */

    public static final String ZOOM_OUT_BOTH_COMMAND = "ZOOM_OUT_BOTH";

    /** Zoom out (domain axis only) action command. */

    public static final String ZOOM_OUT_DOMAIN_COMMAND = "ZOOM_DOMAIN_BOTH";

    /** Zoom out (range axis only) action command. */

    public static final String ZOOM_OUT_RANGE_COMMAND = "ZOOM_RANGE_BOTH";

    /** Zoom reset (both axes) action command. */

    public static final String ZOOM_RESET_BOTH_COMMAND = "ZOOM_RESET_BOTH";

    /** Zoom reset (domain axis only) action command. */

    public static final String ZOOM_RESET_DOMAIN_COMMAND = "ZOOM_RESET_DOMAIN";

    /** Zoom reset (range axis only) action command. */

    public static final String ZOOM_RESET_RANGE_COMMAND = "ZOOM_RESET_RANGE";

    /** Definicion de nueva Roi **/

    public static final String NEW_CLASS_COMMAND ="NEW_CLASS";

    /** Borrado de las Rois sobre el grafico **/

    public static final String CLEAR_CHART ="CLEAR_CHART";

    /**Contador de Rois definidas para el diagrama*/

    int contador= 0;

    /** The chart that is displayed in the panel. */

    private JFreeChart chart;

    /** Storage for registered (chart) mouse listeners. */

    private EventListenerList chartMouseListeners;

    /** A flag that controls whether or not the off-screen buffer is used. */

    private boolean useBuffer;

    /** A flag that indicates that the buffer should be refreshed. */

    private boolean refreshBuffer;

    /** A buffer for the rendered chart. */

    private Image chartBuffer;

    /** The height of the chart buffer. */

    private int chartBufferHeight;

    /** The width of the chart buffer. */

    private int chartBufferWidth;

    /** 

     * The minimum width for drawing a chart (uses scaling for smaller widths). 

     */

    private int minimumDrawWidth;

    /** 

     * The minimum height for drawing a chart (uses scaling for smaller 

     * heights). 

     */

    private int minimumDrawHeight;

    /** 

     * The maximum width for drawing a chart (uses scaling for bigger 

     * widths). 

     */

    private int maximumDrawWidth;

    /** 

     * The maximum height for drawing a chart (uses scaling for bigger 

     * heights). 

     */

    private int maximumDrawHeight;

    /** The popup menu for the frame. */

    private JPopupMenu popup;

    /** The drawing info collected the last time the chart was drawn. */

    private ChartRenderingInfo info;

    /** The chart anchor point. */

    private Point2D anchor;

    /** The scale factor used to draw the chart. */

    private double scaleX;

    /** The scale factor used to draw the chart. */

    private double scaleY;

    /** The plot orientation. */

    private PlotOrientation orientation = PlotOrientation.VERTICAL;

    /** A flag that controls whether or not domain zooming is enabled. */

    private boolean domainZoomable = false;

    /** A flag that controls whether or not range zooming is enabled. */

    private boolean rangeZoomable = false;

    /** 

     * The zoom rectangle starting point (selected by the user with a mouse 

     * click).  This is a point on the screen, not the chart (which may have

     * been scaled up or down to fit the panel).  

     */

    private Point zoomPoint = null;

    /** The zoom rectangle (selected by the user with the mouse). */

    private transient Rectangle2D zoomRectangle = null;

    /** Controls if the zoom rectangle is drawn as an outline or filled. */

    private boolean fillZoomRectangle = true;

    /** The minimum distance required to drag the mouse to trigger a zoom. */

    private int zoomTriggerDistance;

    /** A flag that controls whether or not horizontal tracing is enabled. */

    private boolean horizontalAxisTrace = false;

    /** A flag that controls whether or not vertical tracing is enabled. */

    private boolean verticalAxisTrace =false;

    /** A vertical trace line. */

    private transient Line2D verticalTraceLine;

    /** A horizontal trace line. */

    private transient Line2D horizontalTraceLine;

    /** Menu item for zooming in on a chart (both axes). */

    private JMenuItem zoomInBothMenuItem;

    /** Menu item for zooming in on a chart (domain axis). */

    private JMenuItem zoomInDomainMenuItem;

    /** Menu item for zooming in on a chart (range axis). */

    private JMenuItem zoomInRangeMenuItem;

    /** Menu item for zooming out on a chart. */

    private JMenuItem zoomOutBothMenuItem;

    /** Menu item for zooming out on a chart (domain axis). */

    private JMenuItem zoomOutDomainMenuItem;

    /** Menu item for zooming out on a chart (range axis). */

    private JMenuItem zoomOutRangeMenuItem;

    /** Menu item for resetting the zoom (both axes). */

    private JMenuItem zoomResetBothMenuItem;

    /** Menu item for resetting the zoom (domain axis only). */

    private JMenuItem zoomResetDomainMenuItem;

    /** Menu item for resetting the zoom (range axis only). */

    private JMenuItem zoomResetRangeMenuItem;

    /**

     * The default directory for saving charts to file.

     * 

     * @since 1.0.7

     */

    private File defaultDirectoryForSaveAs;

    /** A flag that controls whether or not file extensions are enforced. */

    private boolean enforceFileExtensions;

    /** A flag that indicates if original tooltip delays are changed. */

    private boolean ownToolTipDelaysActive;  

    /** Original initial tooltip delay of ToolTipManager.sharedInstance(). */

    private int originalToolTipInitialDelay;

    /** Original reshow tooltip delay of ToolTipManager.sharedInstance(). */

    private int originalToolTipReshowDelay;  

    /** Original dismiss tooltip delay of ToolTipManager.sharedInstance(). */

    private int originalToolTipDismissDelay;

    /** Own initial tooltip delay to be used in this chart panel. */

    private int ownToolTipInitialDelay;

    /** Own reshow tooltip delay to be used in this chart panel. */

    private int ownToolTipReshowDelay;  

    /** Own dismiss tooltip delay to be used in this chart panel. */

    private int ownToolTipDismissDelay;    

    /** The factor used to zoom in on an axis range. */

    private double zoomInFactor = 0.5;

    /** The factor used to zoom out on an axis range. */

    private double zoomOutFactor = 2.0;

    /**

     * A flag that controls whether zoom operations are centred on the

     * current anchor point, or the centre point of the relevant axis.

     *

     * @since 1.0.7

     */

    private boolean zoomAroundAnchor;

    /** The resourceBundle for the localization. */

    protected static ResourceBundle localizationResources 

            = ResourceBundle.getBundle("org.jfree.chart.LocalizationBundle");

    private ROIChart activeROI= new ROIChart(Color.GREEN,"ROICHARt1");

    private ROIChartList roiList= new ROIChartList();

    Graphics2D g2= null;

    /**

     * Constructs a panel that displays the specified chart.

     *

     * @param chart  the chart.

     */

    public ScatterPlotDiagram(JFreeChart chart) {

        this(

            chart,

            DEFAULT_WIDTH,

            DEFAULT_HEIGHT,

            DEFAULT_MINIMUM_DRAW_WIDTH,

            DEFAULT_MINIMUM_DRAW_HEIGHT,

            DEFAULT_MAXIMUM_DRAW_WIDTH,

            DEFAULT_MAXIMUM_DRAW_HEIGHT,

            DEFAULT_BUFFER_USED,

            true,  // properties

            true,  // save

            true,  // print

            true,  // zoom

            true   // tooltips

        );

    }

    /**

     * Constructs a JFreeChart panel.

     *

     * @param chart  the chart.

     * @param width  the preferred width of the panel.

     * @param height  the preferred height of the panel.

     * @param minimumDrawWidth  the minimum drawing width.

     * @param minimumDrawHeight  the minimum drawing height.

     * @param maximumDrawWidth  the maximum drawing width.

     * @param maximumDrawHeight  the maximum drawing height.

     * @param useBuffer  a flag that indicates whether to use the off-screen

     *                   buffer to improve performance (at the expense of 

     *                   memory).

     * @param properties  a flag indicating whether or not the chart property

     *                    editor should be available via the popup menu.

     * @param save  a flag indicating whether or not save options should be

     *              available via the popup menu.

     * @param print  a flag indicating whether or not the print option

     *               should be available via the popup menu.

     * @param zoom  a flag indicating whether or not zoom options should be 

     *              added to the popup menu.

     * @param tooltips  a flag indicating whether or not tooltips should be 

     *                  enabled for the chart.

     */

    public ScatterPlotDiagram(JFreeChart chart,

                      int width,

                      int height,

                      int minimumDrawWidth,

                      int minimumDrawHeight,

                      int maximumDrawWidth,

                      int maximumDrawHeight,

                      boolean useBuffer,

                      boolean properties,

                      boolean save,

                      boolean print,

                      boolean zoom,

                      boolean tooltips) {

        this.setChart(chart);

        this.chartMouseListeners = new EventListenerList();

        this.info = new ChartRenderingInfo();

        setPreferredSize(new Dimension(width, height));

        this.useBuffer = useBuffer;

        this.refreshBuffer = false;

        this.minimumDrawWidth = minimumDrawWidth;

        this.minimumDrawHeight = minimumDrawHeight;

        this.maximumDrawWidth = maximumDrawWidth;

        this.maximumDrawHeight = maximumDrawHeight;

        this.zoomTriggerDistance = DEFAULT_ZOOM_TRIGGER_DISTANCE;

        // set up popup menu...

        this.popup = null;

        if (properties || save || print || zoom) {

            this.popup = createPopupMenu(properties, save, print, zoom);

        }

        enableEvents(AWTEvent.MOUSE_EVENT_MASK);

        enableEvents(AWTEvent.MOUSE_MOTION_EVENT_MASK);

        setDisplayToolTips(tooltips);

        addMouseListener(this);

        addMouseMotionListener(this);

        this.defaultDirectoryForSaveAs = null;

        this.enforceFileExtensions = true;

        // initialize ChartPanel-specific tool tip delays with

        // values the from ToolTipManager.sharedInstance()

        ToolTipManager ttm = ToolTipManager.sharedInstance();       

        this.ownToolTipInitialDelay = ttm.getInitialDelay();

        this.ownToolTipDismissDelay = ttm.getDismissDelay();

        this.ownToolTipReshowDelay = ttm.getReshowDelay();

        this.zoomAroundAnchor = false;

    }

    /**

     * Returns the chart contained in the panel.

     *

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

     */

    public JFreeChart getChart() {

        return this.chart;

    }

    /**

     * Sets the chart that is displayed in the panel.

     *

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

     */

    public void setChart(JFreeChart chart) {

        // stop listening for changes to the existing chart

        if (this.chart != null) {

            this.chart.removeChangeListener(this);

            this.chart.removeProgressListener(this);

        }

        // add the new chart

        this.chart = chart;

        if (chart != null) {

            this.chart.addChangeListener(this);

            this.chart.addProgressListener(this);

            Plot plot = chart.getPlot();

            this.domainZoomable = false;

            this.rangeZoomable = false;

            if (plot instanceof Zoomable) {

                Zoomable z = (Zoomable) plot;

                this.domainZoomable = z.isDomainZoomable();

                this.rangeZoomable = z.isRangeZoomable();

                this.orientation = z.getOrientation();

            }

        }

        else {

            this.domainZoomable = false;

            this.rangeZoomable = false;

        }

        if (this.useBuffer) {

            this.refreshBuffer = true;

        }

        repaint();

    }

    /**

     * Returns the minimum drawing width for charts.

     * <P>

     * If the width available on the panel is less than this, then the chart is

     * drawn at the minimum width then scaled down to fit.

     *

     * @return The minimum drawing width.

     */

    public int getMinimumDrawWidth() {

        return this.minimumDrawWidth;

    }

    /**

     * Sets the minimum drawing width for the chart on this panel.

     * <P>

     * At the time the chart is drawn on the panel, if the available width is

     * less than this amount, the chart will be drawn using the minimum width

     * then scaled down to fit the available space.

     *

     * @param width  The width.

     */

    public void setMinimumDrawWidth(int width) {

        this.minimumDrawWidth = width;

    }

    /**

     * Returns the maximum drawing width for charts.

     * <P>

     * If the width available on the panel is greater than this, then the chart

     * is drawn at the maximum width then scaled up to fit.

     *

     * @return The maximum drawing width.

     */

    public int getMaximumDrawWidth() {

        return this.maximumDrawWidth;

    }

    /**

     * Sets the maximum drawing width for the chart on this panel.

     * <P>

     * At the time the chart is drawn on the panel, if the available width is

     * greater than this amount, the chart will be drawn using the maximum

     * width then scaled up to fit the available space.

     *

     * @param width  The width.

     */

    public void setMaximumDrawWidth(int width) {

        this.maximumDrawWidth = width;

    }

    /**

     * Returns the minimum drawing height for charts.

     * <P>

     * If the height available on the panel is less than this, then the chart

     * is drawn at the minimum height then scaled down to fit.

     *

     * @return The minimum drawing height.

     */

    public int getMinimumDrawHeight() {

        return this.minimumDrawHeight;

    }

    /**

     * Sets the minimum drawing height for the chart on this panel.

     * <P>

     * At the time the chart is drawn on the panel, if the available height is

     * less than this amount, the chart will be drawn using the minimum height

     * then scaled down to fit the available space.

     *

     * @param height  The height.

     */

    public void setMinimumDrawHeight(int height) {

        this.minimumDrawHeight = height;

    }

    /**

     * Returns the maximum drawing height for charts.

     * <P>

     * If the height available on the panel is greater than this, then the

     * chart is drawn at the maximum height then scaled up to fit.

     *

     * @return The maximum drawing height.

     */

    public int getMaximumDrawHeight() {

        return this.maximumDrawHeight;

    }

    /**

     * Sets the maximum drawing height for the chart on this panel.

     * <P>

     * At the time the chart is drawn on the panel, if the available height is

     * greater than this amount, the chart will be drawn using the maximum

     * height then scaled up to fit the available space.

     *

     * @param height  The height.

     */

    public void setMaximumDrawHeight(int height) {

        this.maximumDrawHeight = height;

    }

    /**

     * Returns the X scale factor for the chart.  This will be 1.0 if no 

     * scaling has been used.

     * 

     * @return The scale factor.

     */

    public double getScaleX() {

        return this.scaleX;

    }

    /**

     * Returns the Y scale factory for the chart.  This will be 1.0 if no 

     * scaling has been used.

     * 

     * @return The scale factor.

     */

    public double getScaleY() {

        return this.scaleY;

    }

    /**

     * Returns the anchor point.

     * 

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

     */

    public Point2D getAnchor() {

        return this.anchor;   

    }

    /**

     * Sets the anchor point.  This method is provided for the use of 

     * subclasses, not end users.

     * 

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

     */

    protected void setAnchor(Point2D anchor) {

        this.anchor = anchor;   

    }

    /**

     * Returns the popup menu.

     *

     * @return The popup menu.

     */

    public JPopupMenu getPopupMenu() {

        return this.popup;

    }

    /**

     * Sets the popup menu for the panel.

     *

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

     */

    public void setPopupMenu(JPopupMenu popup) {

        this.popup = popup;

    }

    /**

     * Returns the chart rendering info from the most recent chart redraw.

     *

     * @return The chart rendering info.

     */

    public ChartRenderingInfo getChartRenderingInfo() {

        return this.info;

    }

    /**

     * A convenience method that switches on mouse-based zooming.

     *

     * @param flag  <code>true</code> enables zooming and rectangle fill on 

     *              zoom.

     */

    public void setMouseZoomable(boolean flag) {

        setMouseZoomable(flag, true);

    }

    /**

     * A convenience method that switches on mouse-based zooming.

     *

     * @param flag  <code>true</code> if zooming enabled

     * @param fillRectangle  <code>true</code> if zoom rectangle is filled,

     *                       false if rectangle is shown as outline only.

     */

    public void setMouseZoomable(boolean flag, boolean fillRectangle) {

        setDomainZoomable(flag);

        setRangeZoomable(flag);

        setFillZoomRectangle(fillRectangle);

    }

    /**

     * Returns the flag that determines whether or not zooming is enabled for 

     * the domain axis.

     * 

     * @return A boolean.

     */

    public boolean isDomainZoomable() {

        return this.domainZoomable;

    }

    /**

     * Sets the flag that controls whether or not zooming is enable for the 

     * domain axis.  A check is made to ensure that the current plot supports

     * zooming for the domain values.

     *

     * @param flag  <code>true</code> enables zooming if possible.

     */

    public void setDomainZoomable(boolean flag) {

        if (flag) {

            Plot plot = this.chart.getPlot();

            if (plot instanceof Zoomable) {

                Zoomable z = (Zoomable) plot;

                this.domainZoomable = flag && (z.isDomainZoomable());  

            }

        }

        else {

            this.domainZoomable = false;

        }

    }

    /**

     * Returns the flag that determines whether or not zooming is enabled for 

     * the range axis.

     * 

     * @return A boolean.

     */

    public boolean isRangeZoomable() {

        return this.rangeZoomable;

    }

    /**

     * A flag that controls mouse-based zooming on the vertical axis.

     *

     * @param flag  <code>true</code> enables zooming.

     */

    public void setRangeZoomable(boolean flag) {

        if (flag) {

            Plot plot = this.chart.getPlot();

            if (plot instanceof Zoomable) {

                Zoomable z = (Zoomable) plot;

                this.rangeZoomable = flag && (z.isRangeZoomable());  

            }

        }

        else {

            this.rangeZoomable = false;

        }

    }

    /**

     * Returns the flag that controls whether or not the zoom rectangle is

     * filled when drawn.

     * 

     * @return A boolean.

     */

    public boolean getFillZoomRectangle() {

        return this.fillZoomRectangle;

    }

    /**

     * A flag that controls how the zoom rectangle is drawn.

     *

     * @param flag  <code>true</code> instructs to fill the rectangle on

     *              zoom, otherwise it will be outlined.

     */

    public void setFillZoomRectangle(boolean flag) {

        this.fillZoomRectangle = flag;

    }

    /**

     * Returns the zoom trigger distance.  This controls how far the mouse must

     * move before a zoom action is triggered.

     * 

     * @return The distance (in Java2D units).

     */

    public int getZoomTriggerDistance() {

        return this.zoomTriggerDistance;

    }

    /**

     * Sets the zoom trigger distance.  This controls how far the mouse must 

     * move before a zoom action is triggered.

     * 

     * @param distance  the distance (in Java2D units).

     */

    public void setZoomTriggerDistance(int distance) {

        this.zoomTriggerDistance = distance;

    }

    /**

     * Returns the flag that controls whether or not a horizontal axis trace

     * line is drawn over the plot area at the current mouse location.

     * 

     * @return A boolean.

     */

    public boolean getHorizontalAxisTrace() {

        return this.horizontalAxisTrace;    

    }

    /**

     * A flag that controls trace lines on the horizontal axis.

     *

     * @param flag  <code>true</code> enables trace lines for the mouse

     *      pointer on the horizontal axis.

     */

    public void setHorizontalAxisTrace(boolean flag) {

        this.horizontalAxisTrace = flag;

    }

    /**

     * Returns the horizontal trace line.

     * 

     * @return The horizontal trace line (possibly <code>null</code>).

     */

    protected Line2D getHorizontalTraceLine() {

        return this.horizontalTraceLine;   

    }

    /**

     * Sets the horizontal trace line.

     * 

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

     */

    protected void setHorizontalTraceLine(Line2D line) {

        this.horizontalTraceLine = line;   

    }

    /**

     * Returns the flag that controls whether or not a vertical axis trace

     * line is drawn over the plot area at the current mouse location.

     * 

     * @return A boolean.

     */

    public boolean getVerticalAxisTrace() {

        return this.verticalAxisTrace;    

    }

    /**

     * A flag that controls trace lines on the vertical axis.

     *

     * @param flag  <code>true</code> enables trace lines for the mouse

     *              pointer on the vertical axis.

     */

    public void setVerticalAxisTrace(boolean flag) {

        this.verticalAxisTrace = flag;

    }

    /**

     * Returns the vertical trace line.

     * 

     * @return The vertical trace line (possibly <code>null</code>).

     */

    protected Line2D getVerticalTraceLine() {

        return this.verticalTraceLine;   

    }

    /**

     * Sets the vertical trace line.

     * 

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

     */

    protected void setVerticalTraceLine(Line2D line) {

        this.verticalTraceLine = line;   

    }

    /**

     * Returns the default directory for the "save as" option.

     * 

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

     * 

     * @since 1.0.7

     */

    public File getDefaultDirectoryForSaveAs() {

        return this.defaultDirectoryForSaveAs;

    }

    /**

     * Sets the default directory for the "save as" option.  If you set this

     * to <code>null</code>, the user's default directory will be used.

     * 

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

     * 

     * @since 1.0.7

     */

    public void setDefaultDirectoryForSaveAs(File directory) {

        if (directory != null) {

            if (!directory.isDirectory()) {

                throw new IllegalArgumentException(

                        "The 'directory' argument is not a directory.");

            }

        }

        this.defaultDirectoryForSaveAs = directory;

    }

    /**

     * Returns <code>true</code> if file extensions should be enforced, and 

     * <code>false</code> otherwise.

     *

     * @return The flag.

     * 

     * @see #setEnforceFileExtensions(boolean)

     */

    public boolean isEnforceFileExtensions() {

        return this.enforceFileExtensions;

    }

    /**

     * Sets a flag that controls whether or not file extensions are enforced.

     *

     * @param enforce  the new flag value.

     * 

     * @see #isEnforceFileExtensions()

     */

    public void setEnforceFileExtensions(boolean enforce) {

        this.enforceFileExtensions = enforce;

    }

    /**

     * Returns the flag that controls whether or not zoom operations are 

     * centered around the current anchor point.

     * 

     * @return A boolean.

     * 

     * @since 1.0.7

     * 

     * @see #setZoomAroundAnchor(boolean)

     */

    public boolean getZoomAroundAnchor() {

        return this.zoomAroundAnchor;

    }

    /**

     * Sets the flag that controls whether or not zoom operations are

     * centered around the current anchor point.

     * 

     * @param zoomAroundAnchor  the new flag value.

     * 

     * @since 1.0.7

     * 

     * @see #getZoomAroundAnchor()

     */

    public void setZoomAroundAnchor(boolean zoomAroundAnchor) {

        this.zoomAroundAnchor = zoomAroundAnchor;

    }

    /**

     * Switches the display of tooltips for the panel on or off.  Note that 

     * tooltips can only be displayed if the chart has been configured to

     * generate tooltip items.

     *

     * @param flag  <code>true</code> to enable tooltips, <code>false</code> to

     *              disable tooltips.

     */

    public void setDisplayToolTips(boolean flag) {

        if (flag) {

            ToolTipManager.sharedInstance().registerComponent(this);

        }

        else {

            ToolTipManager.sharedInstance().unregisterComponent(this);

        }

    }

    /**

     * Returns a string for the tooltip.

     *

     * @param e  the mouse event.

     *

     * @return A tool tip or <code>null</code> if no tooltip is available.

     */

    public String getToolTipText(MouseEvent e) {

        String result = null;

        if (this.info != null) {

            EntityCollection entities = this.info.getEntityCollection();

            if (entities != null) {

                Insets insets = getInsets();

                ChartEntity entity = entities.getEntity(

                        (int) ((e.getX() - insets.left) / this.scaleX),

                        (int) ((e.getY() - insets.top) / this.scaleY));

                if (entity != null) {

                    result = entity.getToolTipText();

                }

            }

        }

        return result;

    }

    /**

     * Translates a Java2D point on the chart to a screen location.

     *

     * @param java2DPoint  the Java2D point.

     *

     * @return The screen location.

     */

    public Point translateJava2DToScreen(Point2D java2DPoint) {

        Insets insets = getInsets();

        int x = (int) (java2DPoint.getX() * this.scaleX + insets.left);

        int y = (int) (java2DPoint.getY() * this.scaleY + insets.top);

        return new Point(x, y);

    }

    /**

     * Translates a panel (component) location to a Java2D point.

     *

     * @param screenPoint  the screen location (<code>null</code> not 

     *                     permitted).

     *

     * @return The Java2D coordinates.

     */

    public Point2D translateScreenToJava2D(Point screenPoint) {

        Insets insets = getInsets();

        double x = (screenPoint.getX() - insets.left) / this.scaleX;

        double y = (screenPoint.getY() - insets.top) / this.scaleY;

        return new Point2D.Double(x, y);

    }

    /**

     * Applies any scaling that is in effect for the chart drawing to the

     * given rectangle.

     *  

     * @param rect  the rectangle.

     * 

     * @return A new scaled rectangle.

     */

    public Rectangle2D scale(Rectangle2D rect) {

        Insets insets = getInsets();

        double x = rect.getX() * getScaleX() + insets.left;

        double y = rect.getY() * this.getScaleY() + insets.top;

        double w = rect.getWidth() * this.getScaleX();

        double h = rect.getHeight() * this.getScaleY();

        return new Rectangle2D.Double(x, y, w, h);

    }

    /**

     * Returns the chart entity at a given point.

     * <P>

     * This method will return null if there is (a) no entity at the given 

     * point, or (b) no entity collection has been generated.

     *

     * @param viewX  the x-coordinate.

     * @param viewY  the y-coordinate.

     *

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

     */

    public ChartEntity getEntityForPoint(int viewX, int viewY) {

        ChartEntity result = null;

        if (this.info != null) {

            Insets insets = getInsets();

            double x = (viewX - insets.left) / this.scaleX;

            double y = (viewY - insets.top) / this.scaleY;

            EntityCollection entities = this.info.getEntityCollection();

            result = entities != null ? entities.getEntity(x, y) : null; 

        }

        return result;

    }

    /**

     * Returns the flag that controls whether or not the offscreen buffer

     * needs to be refreshed.

     * 

     * @return A boolean.

     */

    public boolean getRefreshBuffer() {

        return this.refreshBuffer;

    }

    /**

     * Sets the refresh buffer flag.  This flag is used to avoid unnecessary

     * redrawing of the chart when the offscreen image buffer is used.

     *

     * @param flag  <code>true</code> indicates that the buffer should be 

     *              refreshed.

     */

    public void setRefreshBuffer(boolean flag) {

        this.refreshBuffer = flag;

    }

    /**

     * Paints the component by drawing the chart to fill the entire component,

     * but allowing for the insets (which will be non-zero if a border has been

     * set for this component).  To increase performance (at the expense of

     * memory), an off-screen buffer image can be used.

     *

     * @param g  the graphics device for drawing on.

     */

    public void paintComponent(Graphics g) {

        super.paintComponent(g);

        if (this.chart == null) {

            return;

        }

        Graphics2D g2 = (Graphics2D) g.create();

        // first determine the size of the chart rendering area...

        Dimension size = getSize();

        Insets insets = getInsets();

        Rectangle2D available = new Rectangle2D.Double(insets.left, insets.top,

                size.getWidth() - insets.left - insets.right,

                size.getHeight() - insets.top - insets.bottom);

        // work out if scaling is required...

        boolean scale = false;

        double drawWidth = available.getWidth();

        double drawHeight = available.getHeight();

        this.scaleX = 1.0;

        this.scaleY = 1.0;

        if (drawWidth < this.minimumDrawWidth) {

            this.scaleX = drawWidth / this.minimumDrawWidth;

            drawWidth = this.minimumDrawWidth;

            scale = true;

        }

        else if (drawWidth > this.maximumDrawWidth) {

            this.scaleX = drawWidth / this.maximumDrawWidth;

            drawWidth = this.maximumDrawWidth;

            scale = true;

        }

        if (drawHeight < this.minimumDrawHeight) {

            this.scaleY = drawHeight / this.minimumDrawHeight;

            drawHeight = this.minimumDrawHeight;

            scale = true;

        }

        else if (drawHeight > this.maximumDrawHeight) {

            this.scaleY = drawHeight / this.maximumDrawHeight;

            drawHeight = this.maximumDrawHeight;

            scale = true;

        }

        Rectangle2D chartArea = new Rectangle2D.Double(0.0, 0.0, drawWidth, 

                drawHeight);

        // are we using the chart buffer?

        if (this.useBuffer) {

            // if buffer is being refreshed, it needs clearing unless it is

            // new - use the following flag to track this...

            boolean clearBuffer = true;

            // do we need to resize the buffer?

            if ((this.chartBuffer == null) 

                    || (this.chartBufferWidth != available.getWidth())

                    || (this.chartBufferHeight != available.getHeight())) {

                this.chartBufferWidth = (int) available.getWidth();

                this.chartBufferHeight = (int) available.getHeight();

                this.chartBuffer = createImage(this.chartBufferWidth, 

                        this.chartBufferHeight);

//                GraphicsConfiguration gc = g2.getDeviceConfiguration();

//                this.chartBuffer = gc.createCompatibleImage(

//                        this.chartBufferWidth, this.chartBufferHeight, 

//                        Transparency.TRANSLUCENT);

                this.refreshBuffer = true;

                clearBuffer = false;  // buffer is new, no clearing required

            }

            // do we need to redraw the buffer?

            if (this.refreshBuffer) {

                this.refreshBuffer = false; // clear the flag

                Rectangle2D bufferArea = new Rectangle2D.Double(

                        0, 0, this.chartBufferWidth, this.chartBufferHeight);

                Graphics2D bufferG2 = (Graphics2D) 

                        this.chartBuffer.getGraphics();

                if (clearBuffer) {

                    bufferG2.clearRect(0, 0, this.chartBufferWidth, 

                            this.chartBufferHeight);

                }

                if (scale) {

                    AffineTransform saved = bufferG2.getTransform();

                    AffineTransform st = AffineTransform.getScaleInstance(

                            this.scaleX, this.scaleY);

                    bufferG2.transform(st);

                    this.chart.draw(bufferG2, chartArea, this.anchor, 

                            this.info);

                    bufferG2.setTransform(saved);

                }

                else {

                    this.chart.draw(bufferG2, bufferArea, this.anchor, 

                            this.info);

                }

            }

            // zap the buffer onto the panel...

            g2.drawImage(this.chartBuffer, insets.left, insets.top, this);

            g2.draw((Shape)activeROI.shapeList.get(1));

          // Dibujar las rois que se encuentren activas

        }

        // or redrawing the chart every time...

        else {

            AffineTransform saved = g2.getTransform();

            g2.translate(insets.left, insets.top);

            if (scale) {

                AffineTransform st = AffineTransform.getScaleInstance(

                        this.scaleX, this.scaleY);

                g2.transform(st);

            }

            this.chart.draw(g2, chartArea, this.anchor, this.info);

            g2.drawImage(this.chartBuffer, insets.left, insets.top, this);

            // Se pintan las Roi activa

            drawsROIs(g2);

            g2.setTransform(saved);

        }

        // Redraw the zoom rectangle (if present)

        drawZoomRectangle(g2);

        g2.dispose();

        this.anchor = null;

        this.verticalTraceLine = null;

        this.horizontalTraceLine = null;

    }

        /**

     * Receives notification of changes to the chart, and redraws the chart.

     *

     * @param event  details of the chart change event.

     */

    public void chartChanged(ChartChangeEvent event) {

        this.refreshBuffer = true;

        Plot plot = this.chart.getPlot();

        if (plot instanceof Zoomable) {

            Zoomable z = (Zoomable) plot;

            this.orientation = z.getOrientation();

        }

        repaint();

    }

    /**

     * Receives notification of a chart progress event.

     *

     * @param event  the event.

     */

    public void chartProgress(ChartProgressEvent event) {

        // does nothing - override if necessary

    }

    /**

     * Handles action events generated by the popup menu.

     *

     * @param event  the event.

     */

    public void actionPerformed(ActionEvent event) {

        String command = event.getActionCommand();

        // many of the zoom methods need a screen location - all we have is 

        // the zoomPoint, but it might be null.  Here we grab the x and y

        // coordinates, or use defaults...

        double screenX = -1.0;

        double screenY = -1.0;

        if (this.zoomPoint != null) {

            screenX = this.zoomPoint.getX();

            screenY = this.zoomPoint.getY();

        }

        if (command.equals(SAVE_COMMAND)) {

            try {

                doSaveAs();

            }

            catch (IOException e) {

                e.printStackTrace();

            }

        }

        else if (command.equals(PRINT_COMMAND)) {

            createChartPrintJob();

        }

        else if (command.equals(ZOOM_IN_BOTH_COMMAND)) {

            zoomInBoth(screenX, screenY);

        }

        else if (command.equals(ZOOM_IN_DOMAIN_COMMAND)) {

            zoomInDomain(screenX, screenY);

        }

        else if (command.equals(ZOOM_IN_RANGE_COMMAND)) {

            zoomInRange(screenX, screenY);

        }

        else if (command.equals(ZOOM_OUT_BOTH_COMMAND)) {

            zoomOutBoth(screenX, screenY);

        }

        else if (command.equals(ZOOM_OUT_DOMAIN_COMMAND)) {

            zoomOutDomain(screenX, screenY);

        }

        else if (command.equals(ZOOM_OUT_RANGE_COMMAND)) {

            zoomOutRange(screenX, screenY);

        }

        else if (command.equals(ZOOM_RESET_BOTH_COMMAND)) {

            restoreAutoBounds();

        }

        else if (command.equals(ZOOM_RESET_DOMAIN_COMMAND)) {

            restoreAutoDomainBounds();

        }

        else if (command.equals(ZOOM_RESET_RANGE_COMMAND)) {

            restoreAutoRangeBounds();

        }

        else if (command.equals(NEW_CLASS_COMMAND)) {

            // Definicion de nueba clase

        //        if (activeROI!=null)

                roiList.add(activeROI);

                // se genera una nueva ROI

                activeROI= new ROIChart(new Color((float)Math.random(),(float)Math.random(),(float)Math.random()), "ROIChart"+contador);

        }

        // Acciones para el borrado de la visualizacion de las rois

        else if (command.equals(CLEAR_CHART)) {

            // Definicion de nueba clase