/ - Diff - | gvSIG desktop 1 - gvSIG

Revision 17613

trunk/extensions/extRemoteSensing/src/org/gvsig/remotesensing/scatterplot/chart/ScatterPlotChart.java
76	76
77	77	super(data,domainAxis,rangeAxis);
78	78	setPaint(Color.BLACK);
	79
79	80	}
80	81
81	82

     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.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.event.EventListenerList;
     import org.gvsig.remotesensing.scatterplot.gui.ManagerROIChartPanel;
     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;
-...
     /**
+     *
      *  Reescritura de la clase ChartPanel. Se a?den los elementos necesarios para poder dibujar
      *  rectangulos sobre el chart.
      *  Reescritura de la clase ChartPanel. Se reescribe para personalizar el grafico con
      *  opciones de dibujado de rectangulos sobre el area del gr?fico.
+     *
      *  @see CharPanel JfreeChart
+     *
+     *
      * */
     public class ScatterPlotDiagram extends JPanel implements ChartChangeListener,
             ChartProgressListener, ActionListener, MouseListener,
              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. */
     	private static final long serialVersionUID = 1L;
     	public static final boolean DEFAULT_BUFFER_USED = false;
         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 int DEFAULT_ZOOM_TRIGGER_DISTANCE = 1;
         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");
         protected static ResourceBundle localizationResources  = ResourceBundle.getBundle("org.jfree.chart.LocalizationBundle");
-...
             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);
-...
             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;
+        }
         /**
-...
          * @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;
-...
                 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.
+         *
-...
         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>).
-...
+            }
+        }
         /**
          * 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
-...
             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
-...
                 drawWidth = this.maximumDrawWidth;
                 scale = true;
+            }
             if (drawHeight < this.minimumDrawHeight) {
                 this.scaleY = drawHeight / this.minimumDrawHeight;
                 drawHeight = this.minimumDrawHeight;
-...
                 g2.setTransform(saved);
+            }
             // Redraw the zoom rectangle (if present)
           //  drawZoomRectangle(g2);
             g2.dispose();
             this.anchor = null;
             this.verticalTraceLine = null;
             this.horizontalTraceLine = null;
             g2.dispose();
             this.anchor = null;
+        }
-...
+         *
          * @param event  the event.
          */
         public void chartProgress(ChartProgressEvent event) {
             // does nothing - override if necessary
+        }
         /**
          * Handles action events generated by the popup menu.
+         *
-...
             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();
-...
             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
             	newRoiChart();
-...
             	updateList();
+            }
             // Acciones para el borrado de la visualizacion de las rois
             else if (command.equals(CLEAR_CHART)) {
                 // Definicion de nueba clase
+            }
+        }
-...
+        }
         /**
          * Handles a 'mouse entered' event. This method changes the tooltip delays
          * of ToolTipManager.sharedInstance() to the possibly different values set
          * for this chart panel.
+         *
          * @param e  the mouse event.
          */
         public void mouseEntered(MouseEvent e) {
             if (!this.ownToolTipDelaysActive) {
                 ToolTipManager ttm = ToolTipManager.sharedInstance();
                 this.originalToolTipInitialDelay = ttm.getInitialDelay();
                 ttm.setInitialDelay(this.ownToolTipInitialDelay);
                 this.originalToolTipReshowDelay = ttm.getReshowDelay();
                 ttm.setReshowDelay(this.ownToolTipReshowDelay);
                 this.originalToolTipDismissDelay = ttm.getDismissDelay();
                 ttm.setDismissDelay(this.ownToolTipDismissDelay);
                 this.ownToolTipDelaysActive = true;
+            }
+        }
         /**
          * Handles a 'mouse exited' event. This method resets the tooltip delays of
          * ToolTipManager.sharedInstance() to their
          * original values in effect before mouseEntered()
+         *
          * @param e  the mouse event.
          */
         public void mouseExited(MouseEvent e) {
             if (this.ownToolTipDelaysActive) {
                 // restore original tooltip dealys
                 ToolTipManager ttm = ToolTipManager.sharedInstance();
                 ttm.setInitialDelay(this.originalToolTipInitialDelay);
                 ttm.setReshowDelay(this.originalToolTipReshowDelay);
                 ttm.setDismissDelay(this.originalToolTipDismissDelay);
                 this.ownToolTipDelaysActive = false;
+            }
+        }
         /**
-...
             Graphics2D g2 = (Graphics2D) getGraphics();
             // Erase the previous zoom rectangle (if any)...
             drawZoomRectangle(g2);
             drawRectangle(g2);
             boolean hZoom = false;
             boolean vZoom = false;
-...
+            }
             // Draw the new zoom rectangle...
             drawZoomRectangle(g2);
             drawRectangle(g2);
             g2.dispose();
+        }
         /**
-...
                 if (zoomTrigger1 || zoomTrigger2) {
                     if ((hZoom && (e.getX() < this.zoomPoint.getX()))
                         || (vZoom && (e.getY() < this.zoomPoint.getY()))) {
                         restoreAutoBounds();
                        // restoreAutoBounds();
+                    }
                     else {
                         double x, y, w, h;
-...
                         	Rectangle2D rectangleArea = new Rectangle2D.Double(x, y, w, h);
                         	g2 = (Graphics2D)getGraphics();
                         	g2.setPaint(activeROI.getColor());
                         	g2.draw(rectangleArea);
                         	activeROI.add(rectangleArea, getRange(rectangleArea));
                         	Range r[]=getRange(rectangleArea);
                         	System.out.print("\n"+r[0]);
                         	System.out.print("\n");
                         	System.out.print(r[1]);
                         	if(gestorRois!= null){
                         		// Cargar la nueva ROI en el destor
                         		gestorRois.clearRoiGraphics();
+                        	}
+                        }
-...
                 else {
                     // Erase the zoom rectangle
                     Graphics2D g2 = (Graphics2D) getGraphics();
                     drawZoomRectangle(g2);
                     drawRectangle(g2);
                     g2.dispose();
                     this.zoomPoint = null;
                     this.zoomRectangle = null;
-...
                     displayPopupMenu(e.getX(), e.getY());
+                }
+            }
+        }
         /**
          * Receives notification of mouse clicks on the panel. These are
          * translated and passed on to any registered chart mouse click listeners.
+         *
          * @param event  Information about the mouse event.
          * @param selection .
          * @return range[] rangos del rectangulo
          */
         public void mouseClicked(MouseEvent event) {
             Insets insets = getInsets();
             int x = (int) ((event.getX() - insets.left) / this.scaleX);
             int y = (int) ((event.getY() - insets.top) / this.scaleY);
             this.anchor = new Point2D.Double(x, y);
             if (this.chart == null) {
                 return;
+            }
             this.chart.setNotify(true);  // force a redraw
             // new entity code...
             Object[] listeners = this.chartMouseListeners.getListeners(
                     ChartMouseListener.class);
             if (listeners.length == 0) {
                 return;
+            }
             ChartEntity entity = null;
             if (this.info != null) {
                 EntityCollection entities = this.info.getEntityCollection();
                 if (entities != null) {
                     entity = entities.getEntity(x, y);
+                }
+            }
             ChartMouseEvent chartEvent = new ChartMouseEvent(getChart(), event,
                     entity);
             for (int i = listeners.length - 1; i >= 0; i -= 1) {
                 ((ChartMouseListener) listeners[i]).chartMouseClicked(chartEvent);
+            }
             updateUI();
+        }
         /**
          * Implementation of the MouseMotionListener's method.
+         *
          * @param e  the event.
          */
         public void mouseMoved(MouseEvent e) {
         /*	g2 = (Graphics2D) getGraphics();
             if (this.horizontalAxisTrace) {
                 drawHorizontalAxisTrace(g2, e.getX());
+            }
             if (this.verticalAxisTrace) {
                 drawVerticalAxisTrace(g2, e.getY());
+            }
             g2.dispose();
             Object[] listeners = this.chartMouseListeners.getListeners(
                     ChartMouseListener.class);
             if (listeners.length == 0) {
                 return;
+            }
             Insets insets = getInsets();
             int x = (int) ((e.getX() - insets.left) / this.scaleX);
             int y = (int) ((e.getY() - insets.top) / this.scaleY);
             ChartEntity entity = null;
             if (this.info != null) {
                 EntityCollection entities = this.info.getEntityCollection();
                 if (entities != null) {
                     entity = entities.getEntity(x, y);
+                }
+            }
             // we can only generate events if the panel's chart is not null
             // (see bug report 1556951)
             if (this.chart != null) {
                 ChartMouseEvent event = new ChartMouseEvent(getChart(), e, entity);
                 for (int i = listeners.length - 1; i >= 0; i -= 1) {
                     ((ChartMouseListener) listeners[i]).chartMouseMoved(event);
+                }
             }*/
+        }
         /**
          * Zooms in on an anchor point (specified in screen coordinate space).
+         *
          * @param x  the x value (in screen coordinates).
          * @param y  the y value (in screen coordinates).
          */
         public void zoomInBoth(double x, double y) {
             zoomInDomain(x, y);
             zoomInRange(x, y);
+        }
         /**
          * Decreases the length of the domain axis, centered about the given
          * coordinate on the screen.  The length of the domain axis is reduced
          * by the value of {@link #getZoomInFactor()}.
+         *
          * @param x  the x coordinate (in screen coordinates).
          * @param y  the y-coordinate (in screen coordinates).
          */
         public void zoomInDomain(double x, double y) {
+        }
         /**
          * Decreases the length of the range axis, centered about the given
          * coordinate on the screen.  The length of the range axis is reduced by
          * the value of {@link #getZoomInFactor()}.
+         *
          * @param x  the x-coordinate (in screen coordinates).
          * @param y  the y coordinate (in screen coordinates).
          */
         public void zoomInRange(double x, double y) {
+        }
         /**
          * Zooms out on an anchor point (specified in screen coordinate space).
+         *
          * @param x  the x value (in screen coordinates).
          * @param y  the y value (in screen coordinates).
          */
         public void zoomOutBoth(double x, double y) {
             zoomOutDomain(x, y);
             zoomOutRange(x, y);
+        }
         /**
          * Increases the length of the domain axis, centered about the given
          * coordinate on the screen.  The length of the domain axis is increased
          * by the value of {@link #getZoomOutFactor()}.
+         *
          * @param x  the x coordinate (in screen coordinates).
          * @param y  the y-coordinate (in screen coordinates).
          */
         public void zoomOutDomain(double x, double y) {
+        }
         /**
          * Increases the length the range axis, centered about the given
          * coordinate on the screen.  The length of the range axis is increased
          * by the value of {@link #getZoomOutFactor()}.
+         *
          * @param x  the x coordinate (in screen coordinates).
          * @param y  the y-coordinate (in screen coordinates).
          */
         public void zoomOutRange(double x, double y) {
+        }
         /**
          * Zooms in on a selected region.
+         *
          * @param selection  the selected region.
          */
         public Range[] getRange(Rectangle2D selection) {
         	Range[] rangos= new Range[2];
-...
             return rangos;
+        }
         /**
          * Restores the auto-range calculation on both axes.
          */
         public void restoreAutoBounds() {
             restoreAutoDomainBounds();
             restoreAutoRangeBounds();
+        }
         /**
          * Restores the auto-range calculation on the domain axis.
          */
         public void restoreAutoDomainBounds() {
             Plot p = this.chart.getPlot();
             if (p instanceof Zoomable) {
                 Zoomable z = (Zoomable) p;
                 // we need to guard against this.zoomPoint being null
                 Point zp = (this.zoomPoint != null ? this.zoomPoint : new Point());
                 z.zoomDomainAxes(0.0, this.info.getPlotInfo(), zp);
+            }
+        }
         /**
          * Restores the auto-range calculation on the range axis.
          */
         public void restoreAutoRangeBounds() {
             Plot p = this.chart.getPlot();
             if (p instanceof Zoomable) {
                 Zoomable z = (Zoomable) p;
                 // we need to guard against this.zoomPoint being null
                 Point zp = (this.zoomPoint != null ? this.zoomPoint : new Point());
                 z.zoomRangeAxes(0.0, this.info.getPlotInfo(), zp);
+            }
+        }
         /**
          * Returns the data area for the chart (the area inside the axes) with the
          * current scaling applied (that is, the area as it appears on screen).
+         *
-...
                 result = getScreenDataArea();
+            }
             else {
                 // get the origin of the zoom selection in the Java2D space used for
                 // drawing the chart (that is, before any scaling to fit the panel)
                 Point2D selectOrigin = translateScreenToJava2D(new Point(x, y));
                 int subplotIndex = plotInfo.getSubplotIndex(selectOrigin);
                 if (subplotIndex == -1) {
-...
+            }
             return result;
+        }
         /**
          * Returns the initial tooltip delay value used inside this chart panel.
+         *
          * @return An integer representing the initial delay value, in milliseconds.
+         *
          * @see javax.swing.ToolTipManager#getInitialDelay()
          */
         public int getInitialDelay() {
             return this.ownToolTipInitialDelay;
+        }
         /**
          * Returns the reshow tooltip delay value used inside this chart panel.
+         *
          * @return An integer representing the reshow  delay value, in milliseconds.
+         *
          * @see javax.swing.ToolTipManager#getReshowDelay()
          */
         public int getReshowDelay() {
             return this.ownToolTipReshowDelay;
+        }
         /**
          * Returns the dismissal tooltip delay value used inside this chart panel.
+         *
          * @return An integer representing the dismissal delay value, in
          *         milliseconds.
+         *
          * @see javax.swing.ToolTipManager#getDismissDelay()
          */
         public int getDismissDelay() {
             return this.ownToolTipDismissDelay;
+        }
         /**
          * Specifies the initial delay value for this chart panel.
+         *
          * @param delay  the number of milliseconds to delay (after the cursor has
          *               paused) before displaying.
+         *
          * @see javax.swing.ToolTipManager#setInitialDelay(int)
          */
         public void setInitialDelay(int delay) {
             this.ownToolTipInitialDelay = delay;
+        }
         /**
          * Specifies the amount of time before the user has to wait initialDelay
          * milliseconds before a tooltip will be shown.
+         *
          * @param delay  time in milliseconds
+         *
          * @see javax.swing.ToolTipManager#setReshowDelay(int)
          */
         public void setReshowDelay(int delay) {
             this.ownToolTipReshowDelay = delay;
+        }
         /**
          * Specifies the dismissal delay value for this chart panel.
+         *
          * @param delay the number of milliseconds to delay before taking away the
          *              tooltip
+         *
          * @see javax.swing.ToolTipManager#setDismissDelay(int)
          */
         public void setDismissDelay(int delay) {
             this.ownToolTipDismissDelay = delay;
+        }
         /**
          * Returns the zoom in factor.
+         *
          * @return The zoom in factor.
+         *
          * @see #setZoomInFactor(double)
          */
         public double getZoomInFactor() {
             return this.zoomInFactor;
+        }
         /**
          * Sets the zoom in factor.
+         *
          * @param factor  the factor.
+         *
          * @see #getZoomInFactor()
          */
         public void setZoomInFactor(double factor) {
             this.zoomInFactor = factor;
+        }
         /**
          * Returns the zoom out factor.
+         *
          * @return The zoom out factor.
+         *
          * @see #setZoomOutFactor(double)
          */
         public double getZoomOutFactor() {
             return this.zoomOutFactor;
+        }
         /**
          * Sets the zoom out factor.
+         *
          * @param factor  the factor.
+         *
          * @see #getZoomOutFactor()
          */
         public void setZoomOutFactor(double factor) {
             this.zoomOutFactor = factor;
+        }
         /**
          * Draws zoom rectangle (if present).
          * The drawing is performed in XOR mode, therefore
          * when this method is called twice in a row,
          * the second call will completely restore the state
          * of the canvas.
+         *
          * Pinta el rectangulo sombreado mientras se realiza la selecci?n
          * @param g2 the graphics device.
          */
         private void drawZoomRectangle(Graphics2D g2) {
         private void drawRectangle(Graphics2D g2) {
             // Set XOR mode to draw the zoom rectangle
             g2.setXORMode(Color.gray);
             if (this.zoomRectangle != null) {
-...
             g2.setPaintMode();
+        }
         /**
          * Draws a vertical line used to trace the mouse position to the horizontal
          * axis.
+         *
          * @param g2 the graphics device.
          * @param x  the x-coordinate of the trace line.
          */
         private void drawHorizontalAxisTrace(Graphics2D g2, int x) {
             Rectangle2D dataArea = getScreenDataArea();
             g2.setXORMode(Color.orange);
             if (((int) dataArea.getMinX() < x) && (x < (int) dataArea.getMaxX())) {
                 if (this.verticalTraceLine != null) {
                     g2.draw(this.verticalTraceLine);
                     this.verticalTraceLine.setLine(x, (int) dataArea.getMinY(), x,
                             (int) dataArea.getMaxY());
+                }
                 else {
                     this.verticalTraceLine = new Line2D.Float(x,
                             (int) dataArea.getMinY(), x, (int) dataArea.getMaxY());
+                }
                 g2.draw(this.verticalTraceLine);
+            }
             // Reset to the default 'overwrite' mode
             g2.setPaintMode();
+        }
         /**
          * Draws a horizontal line used to trace the mouse position to the vertical
          * axis.
+         *
          * @param g2 the graphics device.
          * @param y  the y-coordinate of the trace line.
          */
         private void drawVerticalAxisTrace(Graphics2D g2, int y) {
             Rectangle2D dataArea = getScreenDataArea();
             g2.setXORMode(Color.orange);
             if (((int) dataArea.getMinY() < y) && (y < (int) dataArea.getMaxY())) {
                 if (this.horizontalTraceLine != null) {
                     g2.draw(this.horizontalTraceLine);
                     this.horizontalTraceLine.setLine((int) dataArea.getMinX(), y,
                             (int) dataArea.getMaxX(), y);
+                }
                 else {
                     this.horizontalTraceLine = new Line2D.Float(
                             (int) dataArea.getMinX(), y, (int) dataArea.getMaxX(),
                             y);
+                }
                 g2.draw(this.horizontalTraceLine);
+            }
             // Reset to the default 'overwrite' mode
             g2.setPaintMode();
+        }
         /**
          * Displays a dialog that allows the user to edit the properties for the
          * current chart.
+         *
-...
             this.chartMouseListeners.remove(ChartMouseListener.class, listener);
+        }
         /**
          * Returns an array of the listeners of the given type registered with the
          * panel.
+         *
          * @param listenerType  the listener type.
+         *
          * @return An array of listeners.
          */
         public EventListener[] getListeners(Class listenerType) {
             if (listenerType == ChartMouseListener.class) {
                 // fetch listeners from local storage
                 return this.chartMouseListeners.getListeners(listenerType);
+            }
             else {
                 return super.getListeners(listenerType);
+            }
+        }
         /**
          * Creates a popup menu for the panel.
-...
             newClassItem.addActionListener(this);
             result.add(newClassItem);
             separator = true;
             JMenuItem newClassItem2 = new JMenuItem( PluginServices.getText(this,"clear_chart"));
             newClassItem2.setActionCommand(CLEAR_CHART);
             newClassItem2.addActionListener(this);
             result.add(newClassItem2);
             separator = true;
             if (properties) {
             if (properties) {
+            }
             if (save) {
-...
                     result.addSeparator();
                     separator = false;
+                }
                 JMenu zoomInMenu = new JMenu(
                         localizationResources.getString("Zoom_In"));
                 this.zoomInBothMenuItem = new JMenuItem(
                         localizationResources.getString("All_Axes"));
                 this.zoomInBothMenuItem.setActionCommand(ZOOM_IN_BOTH_COMMAND);
                 this.zoomInBothMenuItem.addActionListener(this);
                 zoomInMenu.add(this.zoomInBothMenuItem);

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff