/branches/v2_0_0_prep/libraries/libFMap_mapcontext/src/org/gvsig/fmap/mapcontext/ViewPort.java - Annotate - Application: gvSIG desktop - gvSIG

svn-gvsig-desktop / branches / v2_0_0_prep / libraries / libFMap_mapcontext / src / org / gvsig / fmap / mapcontext / ViewPort.java @ 35753

History | View | Annotate | Download (59.4 KB)

-            jjdelcerro
+/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
             vcaballero
  * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.
+ *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.
+ *
  * For more information, contact:
+ *
  *  Generalitat Valenciana
  *   Conselleria d'Infraestructures i Transport
-            jtorres
+ *   Av. Blasco Ib??ez, 50
-            vcaballero
+ *   46010 VALENCIA
  *   SPAIN
+ *
  *      +34 963862235
  *   gvsig@gva.es
  *      www.gvsig.gva.es
+ *
  *    or
+ *
  *   IVER T.I. S.A
  *   Salamanca 50
  *   46005 Valencia
  *   Spain
+ *
  *   +34 963163400
  *   dac@iver.es
  */
 package org.gvsig.fmap.mapcontext;
 import java.awt.Color;
 import java.awt.Dimension;
-            jmvivo
+import java.awt.Toolkit;
-            vcaballero
+import java.awt.geom.AffineTransform;
 import java.awt.geom.NoninvertibleTransformException;
 import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.util.ArrayList;
 import org.cresques.cts.GeoCalc;
 import org.cresques.cts.IProjection;
-            cmartinez
+import org.cresques.cts.UTM;
-            jjdelcerro
+import org.gvsig.fmap.geom.Geometry.SUBTYPES;
-            fdiaz
+import org.gvsig.fmap.geom.Geometry;
-            jpiera
+import org.gvsig.fmap.geom.GeometryLocator;
 import org.gvsig.fmap.geom.GeometryManager;
 import org.gvsig.fmap.geom.exception.CreateEnvelopeException;
-            fdiaz
+import org.gvsig.fmap.geom.exception.CreateGeometryException;
-            vcaballero
+import org.gvsig.fmap.geom.primitive.Envelope;
-            fdiaz
+import org.gvsig.fmap.geom.primitive.Point;
-            vcaballero
+import org.gvsig.fmap.mapcontext.events.ColorEvent;
 import org.gvsig.fmap.mapcontext.events.ExtentEvent;
 import org.gvsig.fmap.mapcontext.events.ProjectionEvent;
 import org.gvsig.fmap.mapcontext.events.listeners.ViewPortListener;
-            jldominguez
+import org.gvsig.tools.ToolsLocator;
-            jjdelcerro
+import org.gvsig.tools.dynobject.DynStruct;
-            jjdelcerro
+import org.gvsig.tools.lang.Cloneable;
-            cmartinez
+import org.gvsig.tools.persistence.PersistenceManager;
-            jldominguez
+import org.gvsig.tools.persistence.Persistent;
 import org.gvsig.tools.persistence.PersistentState;
-            jjdelcerro
+import org.gvsig.tools.persistence.exception.PersistenceException;
-            jjdelcerro
+import org.gvsig.tools.util.Callable;
-            jpiera
+import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
             vcaballero
 /**
-            jtorres
+ * <p>
  * <code>ViewPort</code> class represents the logic needed to transform a
  * rectangular area of a map to the available area in screen to display it.
  * </p>
+ *
  * <p>
  * Includes an affine transformation, between the rectangular area selected of
  * the external map, in its own <i>map coordinates</i>, to the rectangular area
  * available of a view in <i>screen coordinates</i>.
  * </p>
+ *
  * <p>
  * Elements:
-            vcaballero
+ * <ul>
  * <li><i>extent</i>: the area selected of the map, in <i>map coordinates</i>.
-            jtorres
+ * <li><i>imageSize</i>: width and height in pixels (<i>screen coordinates</i>)
  * of the area available in screen to display the area selected of the map.
  * <li><i>adjustedExtent</i>: the area selected must be an scale of
  * <i>imageSize</i>.<br>
  * This implies adapt the extent, preserving and centering it, and adding around
  * the needed area to fill all the image size. That added area will be extracted
  * from the original map, wherever exists, and filled with the background color
  * wherever not.
-            vcaballero
+ * <li><i>scale</i>: the scale between the adjusted extent and the image size.
-            jtorres
+ * <li><i>backColor</i>: the default background color in the view, if there is
  * no map.
-            vcaballero
+ * <li><i>trans</i>: the affine transformation.
  * <li><i>proj</i>: map projection used in this view.
  * <li><i>distanceUnits</i>: distance measurement units, of data in screen.
  * <li><i>mapUnits</i>: measurement units, of data in map.
-            jtorres
+ * <li><i>extents</i>: an {@link ExtentHistory ExtentHistory} with the last
  * previous extents.
  * <li><i>offset</i>: position in pixels of the available rectangular area,
  * where start drawing the map.
  * <li><i>dist1pixel</i>: the distance in <i>world coordinates</i> equivalent to
  * 1 pixel in the view with the current extent.
  * <li><i>dist3pixel</i>: the distance in <i>world coordinates</i> equivalent to
  * 3 pixels in the view with the current extent.
  * <li><i>listeners</i>: list with the {@link ViewPortListener ViewPortListener}
  * registered.
-            vcaballero
+ * </ul>
  * </p>
             jtorres
-            vcaballero
+ * @author Vicente Caballero Navarro
  */
-            fdiaz
+public class ViewPort implements Persistent, Cloneable {
             cordinyana
-            fdiaz
+    private static final String FIELD_DISTANCE_AREA = "distanceArea";
     private static final String FIELD_IMAGE_SIZE = "imageSize";
     private static final String FIELD_PROJ = "proj";
     private static final String FIELD_OFFSET = "offset";
     private static final String FIELD_MAP_UNITS = "mapUnits";
     private static final String FIELD_EXTENT = "extent";
     private static final String FIELD_EXTENTS = "extents";
     private static final String FIELD_DISTANCE_UNITS = "distanceUnits";
     private static final String FIELD_DIST3PIXEL = "dist3pixel";
     private static final String FIELD_DIST1PIXEL = "dist1pixel";
     private static final String FIELD_CLIP = "clip";
     private static final String FIELD_BACK_COLOR = "backColor";
     private static final String FIELD_ADJUSTED_EXTENT = "adjustedExtent";
             jtorres
-            fdiaz
+    private static final GeometryManager geomManager =
         GeometryLocator.getGeometryManager();
     private static final Logger logger =
         LoggerFactory.getLogger(ViewPort.class);
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Screen resolution in <i>dots-per-inch</i>. Useful to calculate the
      * geographic scale of the view.
      * </p>
+     *
      * @see Toolkit#getScreenResolution()
      * @see #getScale()
      */
     private static int dpi = java.awt.Toolkit.getDefaultToolkit()
         .getScreenResolution();
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Area selected by user using some tool.
      * </p>
+     *
      * <p>
      * When the zoom changes (for instance when using the zoom in or zoom out
      * tools, but also zooming to a selected feature or shape) the extent that
      * covers that area is the value returned by this method. It is not the
      * actual area shown in the view because it does not care about the aspect
      * ratio of the available area. However, any part of the real world
      * contained in this extent is shown in the view.
      * </p>
      * <p>
      * Probably this is not what you are looking for. If you are looking for the
      * complete extent currently shown, you must use
      * {@linkplain #getAdjustedExtent()} method which returns the extent that
      * contains this one but regarding the current view's aspect ratio.
      * </p>
+     *
      * @see #getExtent()
      * @see #setEnvelope(Envelope)
      */
     protected Rectangle2D extent;
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Location and dimensions of the extent adjusted to the image size.
      * </p>
+     *
      * @see #getAdjustedExtent()
      */
     protected Rectangle2D adjustedExtent;
             jtorres
-            fdiaz
+    /**
      * Draw version of the context. It's used for know when de componend has
      * changed any visualization property
+     *
      * @see getDrawVersion
      * @see updateDrawVersion
      */
     private long drawVersion = 0L;
             vcaballero
-            fdiaz
+    /**
      * <p>
      * History with the last extents of the view.
      * </p>
+     *
      * @see #setPreviousExtent()
      * @see #getExtents()
      */
     protected ExtentHistory extents = new ExtentHistory();
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Size in <i>screen coordinates</i> of the rectangle where the image is
      * displayed.
      * </p>
      * <p>
      * Used by {@linkplain #calculateAffineTransform()} to calculate:<br>
+     *
      * <ul>
      * <li>The new {@link #scale scale} .
      * <li>The new {@link #adjustedExtent adjustableExtent} .
      * <li>The new {@link #trans trans} .
      * <li>The new real world coordinates equivalent to 1 pixel (
      * {@link #dist1pixel dist1pixel}) .
      * <li>The new real world coordinates equivalent to 3 pixels (
      * {@link #dist3pixel dist3pixel}) .
      * </ul>
      * </p>
+     *
      * @see #getImageSize()
      * @see #getImageHeight()
      * @see #getImageWidth()
      * @see #setImageSize(Dimension)
      */
     private Dimension imageSize;
             vcaballero
-            fdiaz
+    /**
      * <p>
      * the affine transformation between the {@link #extent extent} in <i>map 2D
      * coordinates</i> to the image area in the screen, in <i>screen 2D
      * coordinates</i> (pixels).
      * </p>
+     *
      * @see AffineTransform
+     *
      * @see #getAffineTransform()
      * @see #setAffineTransform(AffineTransform)
      * @see #calculateAffineTransform()
      */
     private AffineTransform trans = new AffineTransform();
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Measurement unit used for measuring distances and displaying information.
      * </p>
+     *
      * @see #getDistanceUnits()
      * @see #setDistanceUnits(int)
      */
     private int distanceUnits = 1;
     /**
      * <p>
      * Measurement unit used for measuring areas and displaying information.
      * </p>
+     *
      * @see #getDistanceArea()
      * @see #setDistanceArea(int)
      */
     private int distanceArea = 1;
     /**
      * <p>
      * Measurement unit used by this view port for the map.
      * </p>
+     *
      * @see #getMapUnits()
      * @see #setMapUnits(int)
      */
     private int mapUnits = 1;
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Array with the {@link ViewPortListener ViewPortListener}s registered to
      * this view port.
      * </p>
+     *
      * @see #addViewPortListener(ViewPortListener)
      * @see #removeViewPortListener(ViewPortListener)
      */
     private ArrayList listeners = new ArrayList();
             vcaballero
-            fdiaz
+    /**
      * <p>
      * The offset is the position where start drawing the map.
      * </p>
      * <p>
      * The offset of a <a href="http://www.gvsig.gva.es/">gvSIG</a>'s
      * <i>View</i> is always (0, 0) because the drawing area fits with the full
      * window area. But in a <a href="http://www.gvsig.gva.es/">gvSIG</a>'s
      * <i>Layout</i> it's up to the place where the <code>FFrameView</code> is
      * located.
      * </p>
+     *
      * @see #getOffset()
      * @see #setOffset(Point2D)
      */
     private Point2D offset = new Point2D.Double(0, 0);
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Clipping area.
      * </p>
      */
     // private Rectangle2D clip;
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Background color of this view.
      * </p>
+     *
      * @see #getBackColor()
      * @see #setBackColor(Color)
      */
     private Color backColor = null; // Color.WHITE;
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Information about the map projection used in this view.
      * </p>
+     *
      * @see #getProjection()
      * @see #setProjection(IProjection)
      */
     private IProjection proj;
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Represents the distance in <i>world coordinates</i> equivalent to 1 pixel
      * in the view with the current extent.
      * </p>
+     *
      * @see #getDist1pixel()
      * @see #setDist1pixel(double)
      */
     private double dist1pixel;
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Represents the distance in <i>world coordinates</i> equivalent to 3
      * pixels in the view with the current extent.
      * </p>
+     *
      * @see #getDist3pixel()
      * @see #setDist3pixel(double)
      */
     private double dist3pixel;
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Ratio between the size of <code>imageSize</code> and <code>extent</code>:
      * <br>
      * <i>
+     *
      * <pre>
      * min{(imageSize.getHeight()/extent.getHeight(), imageSize.getWidth()/extent.getWidth())}
      * </pre>
+     *
      * </i>
      * </p>
      */
     private double scale;
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Clipping area.
      * </p>
+     *
      * @see #setClipRect(Rectangle2D)
      */
     private Rectangle2D cliprect;
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Enables or disables the <i>"adjustable extent"</i> mode.
      * </p>
+     *
      * <p>
      * When calculates the affine transform, if
      * <ul>
      * <li><i>enabled</i>: the new <code>adjustedExtent</code> will have the (X,
      * Y) coordinates of the <code>extent</code> and an area that will be an
      * scale of the image size. That area will have different height or width
      * (not both) of the extent according the least ratio (height or width) in
+     *
      * <pre>
      * image.size/extent.size&quot;
      * </pre>.
      * <li><i>disabled</i>: the new <code>adjustedExtent</code> will be like
      * <code>extent</code>.
      * </ul>
      * </p>
+     *
      * @see #setAdjustable(boolean)
      */
     private boolean adjustableExtent = true;
             vcaballero
-            fdiaz
+    public ViewPort() {
             vcaballero
             fdiaz
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Creates a new view port with the information of the projection in
      * <code>proj</code> argument, and default configuration:
      * </p>
      * <p>
      * <ul>
      * <li><i><code>distanceUnits</code></i> = meters
      * <li><i><code>mapUnits</code></i> = meters
      * <li><i><code>backColor</code></i> = <i>undefined</i>
      * <li><i><code>offset</code></i> = <code>new Point2D.Double(0, 0);</code>
      * </ul>
      * </p>
+     *
      * @param proj
      *            information of the projection for this view port
      */
     public ViewPort(IProjection proj) {
         // Por defecto
         this.proj = proj;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Changes the status of the <i>"adjustable extent"</i> option to enabled or
      * disabled.
      * </p>
+     *
      * <p>
      * If view port isn't adjustable, won't bear in mind the aspect ratio of the
      * available rectangular area to calculate the affine transform from the
      * original map in real coordinates. (Won't scale the image to adapt it to
      * the available rectangular area).
      * </p>
+     *
      * @param boolean the boolean to be set
      */
     public void setAdjustable(boolean adjustable) {
         if (adjustable == adjustableExtent) {
             return;
+        }
         adjustableExtent = adjustable;
         this.updateDrawVersion();
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Appends the specified {@link ViewPortListener ViewPortListener} listener
      * if weren't.
      * </p>
+     *
      * @param arg0
      *            the listener to add
+     *
      * @return <code>true</code> if has been added successfully
+     *
      * @see #removeViewPortListener(ViewPortListener)
      */
     public boolean addViewPortListener(ViewPortListener arg0) {
         if (!listeners.contains(arg0)) {
             return listeners.add(arg0);
+        }
         return false;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Removes the specified {@link ViewPortListener ViewPortListener} listener,
      * if existed.
      * </p>
+     *
      * @param arg0
      *            the listener to remove
+     *
      * @return <code>true</code> if the contained the specified listener.
+     *
      * @see #addViewPortListener(ViewPortListener)
      */
     public boolean removeViewPortListener(ViewPortListener arg0) {
         return listeners.remove(arg0);
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Converts and returns the distance <code>d</code>, that is in <i>map
      * coordinates</i> to <i>screen coordinates</i> using a <i>delta
      * transform</i> with the transformation affine information in the
      * {@link #trans #trans} attribute.
      * </p>
+     *
      * @param d
      *            distance in <i>map coordinates</i>
+     *
      * @return distance equivalent in <i>screen coordinates</i>
+     *
      * @see #toMapDistance(int)
      * @see AffineTransform#deltaTransform(Point2D, Point2D)S
      */
     public int fromMapDistance(double d) {
         Point2D.Double pWorld = new Point2D.Double(1, 1);
         Point2D.Double pScreen = new Point2D.Double();
             vcaballero
-            fdiaz
+        try {
             trans.deltaTransform(pWorld, pScreen);
         } catch (Exception e) {
             System.err.print(e.getMessage());
+        }
             vcaballero
-            fdiaz
+        return (int) (d * pScreen.x);
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Converts and returns the 2D point <code>(x,y)</code>, that is in <i>map
      * coordinates</i> to <i>screen coordinates</i> (pixels) using the affine
      * transformation in the {@link #trans #trans} attribute.
      * </p>
+     *
      * @param x
      *            the <code>x</code> <i>map coordinate</i> of a 2D point
      * @param y
      *            the <code>y</code> <i>map coordinate</i> of a 2D point
+     *
      * @return 2D point equivalent in <i>screen coordinates</i> (pixels)
+     *
      * @see #fromMapPoint(Point2D)
      * @see AffineTransform#transform(Point2D, Point2D)
      */
     public Point2D fromMapPoint(double x, double y) {
         Point2D.Double pWorld = new Point2D.Double(x, y);
         Point2D.Double pScreen = new Point2D.Double();
             vcaballero
-            fdiaz
+        try {
             trans.transform(pWorld, pScreen);
         } catch (Exception e) {
             System.err.print(e.getMessage());
+        }
             vcaballero
-            fdiaz
+        return pScreen;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Converts and returns the 2D point argument, that is in <i>map
      * coordinates</i> to <i>screen coordinates</i> (pixels) using the affine
      * transformation in the {@link #trans #trans} attribute.
      * </p>
+     *
      * @param point
      *            the 2D point in <i>map coordinates</i>
+     *
      * @return 2D point equivalent in <i>screen coordinates</i> (pixels)
+     *
      * @see #toMapPoint(Point2D)
      * @see #fromMapPoint(double, double)
      */
     public Point2D fromMapPoint(Point2D point) {
         return fromMapPoint(point.getX(), point.getY());
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Converts and returns the 2D point <code>(x,y)</code>, that is in
      * <i>screen coordinates</i> (pixels) to <i>map coordinates</i> using the
      * affine transformation in the {@link #trans #trans} attribute.
      * </p>
+     *
      * @param x
      *            the <code>x</code> <i>screen coordinate</i> of a 2D point
      * @param y
      *            the <code>y</code> <i>screen coordinate</i> of a 2D point
+     *
      * @return 2D point equivalent in <i>map coordinates</i>
+     *
      * @see #toMapPoint(Point2D)
      * @see #fromMapPoint(double, double)
-            fdiaz
+     * @deprecated use {@link #convertToMapPoint(int, int)}
-            fdiaz
+     */
     public Point2D toMapPoint(int x, int y) {
         Point2D pScreen = new Point2D.Double(x, y);
             vcaballero
-            fdiaz
+        return toMapPoint(pScreen);
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Converts and returns the {@link Rectangle2D Rectangle2D}, that is in
      * <i>screen coordinates</i> (pixels) to <i>map coordinates</i> using
      * {@linkplain #toMapDistance(int)}, and {@linkplain #toMapPoint(int, int)}.
      * </p>
+     *
      * @param r
      *            the 2D rectangle in <i>screen coordinates</i> (pixels)
      * @return 2D rectangle equivalent in <i>map coordinates</i>
+     *
      * @see #fromMapRectangle(Rectangle2D)
      * @see #toMapDistance(int)
      * @see #toMapPoint(int, int)
      */
     public Rectangle2D toMapRectangle(Rectangle2D r) {
         Rectangle2D rect = new Rectangle2D.Double();
         Point2D p1 = toMapPoint((int) r.getX(), (int) r.getY());
         Point2D p2 = toMapPoint((int) r.getMaxX(), (int) r.getMaxY());
         rect.setFrameFromDiagonal(p1, p2);
         return rect;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Converts and returns the distance <code>d</code>, that is in <i>screen
      * coordinates</i> to <i>map coordinates</i> using the transformation affine
      * information in the {@link #trans #trans} attribute.
      * </p>
+     *
      * @param d
      *            distance in pixels
+     *
      * @return distance equivalent in <i>map coordinates</i>
+     *
      * @see #fromMapDistance(double)
      * @see AffineTransform
      */
     public double toMapDistance(int d) {
         double dist = d / trans.getScaleX();
             vcaballero
-            fdiaz
+        return dist;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Converts and returns the 2D point argument, that is in <i>screen
      * coordinates</i> (pixels) to <i>map coordinates</i> using the inverse
      * affine transformation of the {@link #trans #trans} attribute.
      * </p>
+     *
      * @param pScreen
      *            the 2D point in <i>screen coordinates</i> (pixels)
+     *
      * @return 2D point equivalent in <i>map coordinates</i>
+     *
      * @see #toMapPoint(int, int)
      * @see AffineTransform#createInverse()
      * @see AffineTransform#transform(Point2D, Point2D)
-            fdiaz
+     * @deprecated use {@link #convertToMapPoint(Point2D)}
-            fdiaz
+     */
     public Point2D toMapPoint(Point2D pScreen) {
         Point2D.Double pWorld = new Point2D.Double();
         AffineTransform at;
             vcaballero
-            fdiaz
+        try {
             at = trans.createInverse();
             at.transform(pScreen, pWorld);
         } catch (NoninvertibleTransformException e) {
             throw new RuntimeException("Non invertible transform Exception", e);
+        }
             vcaballero
-            fdiaz
+        return pWorld;
+    }
             jtorres
-            fdiaz
+    public Point convertToMapPoint(Point2D pScreen) {
             Point2D p = toMapPoint(pScreen);
                 try {
                         return geomManager.createPoint(
                                 p.getX(),
                                 p.getY(),
                                 Geometry.SUBTYPES.GEOM2D
                         );
                 } catch (CreateGeometryException e) {
                         // FIXME: Use a most especific exception.
                         throw new RuntimeException(e);
+                }
+    }
     public Point convertToMapPoint(int x, int y) {
         Point2D pScreen = new Point2D.Double(x, y);
         return convertToMapPoint(pScreen);
+    }
-            fdiaz
+    /**
      * <p>
      * Returns the real distance (in <i>world coordinates</i>) at the graphic
      * layers of two 2D points (in <i>map coordinates</i>) of the plane where is
      * selected the <i>extent</i>.
      * </p>
      * <p>
      * If the projection of this view is UTM, considers the Earth curvature.
      * </p>
+     *
      * @param pt1
      *            a 2D point in <i>map coordinates</i>
      * @param pt2
      *            another 2D point in <i>map coordinates</i>
+     *
      * @return the distance in meters between the two points 2D
+     *
      * @see GeoCalcImpl#distanceVincenty(Point2D, Point2D)
      */
     public double distanceWorld(Point2D pt1, Point2D pt2) {
         double dist = -1;
         dist = pt1.distance(pt2);
             vcaballero
-            fdiaz
+        if ((proj != null) && !(proj instanceof UTM)) {
             dist =
                 new GeoCalc(proj).distanceVincenty(proj.toGeo(pt1),
                     proj.toGeo(pt2));
             return dist;
+        }
         return (dist * MapContext.getDistanceTrans2Meter()[getMapUnits()]);
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Sets as extent and adjusted extent of this view port, the previous.
      * Recalculating its parameters.
      * </p>
+     *
      * @see #getExtents()
      * @see #calculateAffineTransform()
      * @deprecated use {@link ViewPort#setPreviousEnvelope()}
      */
     public void setPreviousExtent() {
         setPreviousEnvelope();
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Sets as envelope and adjusted envelope of this view port, the previous.
      * Recalculating its parameters.
      * </p>
+     *
      * @see #getExtents()
      * @see #calculateAffineTransform()
      */
     public void setPreviousEnvelope() {
         this.updateDrawVersion();
         extent = extents.removePrev();
             jtorres
-            fdiaz
+        // Calcula la transformaci?n af?n
         calculateAffineTransform();
             vcaballero
-            fdiaz
+        // Lanzamos los eventos de extent cambiado
         callExtentChanged(getAdjustedExtent());
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Gets the area selected by user using some tool.
      * </p>
+     *
      * <p>
      * When the zoom changes (for instance using the <i>zoom in</i> or <i>zoom
      * out</i> tools, but also zooming to a selected feature or shape) the
      * extent that covers that area is the value returned by this method. It is
      * not the actual area shown because it doesn't care about the aspect ratio
      * of the image size of the view. However, any part of the real world
      * contained in this extent is shown in the view.
      * </p>
+     *
      * <p>
      * If you are looking for the complete extent currently shown, you must use
      * the {@linkplain #getAdjustedExtent()} method.
      * </p>
+     *
      * @return the current extent
+     *
      * @see #setEnvelope(Envelope)
      * @see #getAdjustedExtent()
      * @see #setPreviousExtent()
      * @see #getExtents()
+     *
      * @deprecated use {@link ViewPort#getEnvelope()}
      */
     public Rectangle2D getExtent() {
         return extent;
+    }
             jmvivo
-            fdiaz
+    /**
      * <p>
      * Gets the envelope selected by user using some tool.
      * </p>
+     *
      * <p>
      * When the zoom changes (for instance using the <i>zoom in</i> or <i>zoom
      * out</i> tools, but also zooming to a selected feature or shape) the
      * envelope that covers that area is the value returned by this method. It
      * is not the actual envelope shown because it doesn't care about the aspect
      * ratio of the image size of the view. However, any part of the real world
      * contained in this envelope is shown in the view.
      * </p>
+     *
      * <p>
      * If you are looking for the complete extent currently shown, you must use
      * the {@linkplain #getAdjustedEnvelope()} method.
      * </p>
+     *
      * @return the current envelope
+     *
      * @see #setEnvelope(Envelope)
      * @see #getAdjustedEnvelope()
      * @see #setPreviousEnvelope()
      * @see #getEnvelopes()
      */
     public Envelope getEnvelope() {
         if (this.extent == null) {
             return null;
+        }
         try {
             return geomManager.createEnvelope(extent.getMinX(),
                 extent.getMinY(),
                 extent.getMaxX(),
                 extent.getMaxY(),
                 SUBTYPES.GEOM2D);
             // This class has to use Envelope instead of Rectangle2D. This catch
             // will disappear
         } catch (CreateEnvelopeException e) {
             logger.error("Error creating the envelope");
+        }
         return null;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Changes the <i>extent</i> and <i>adjusted extent</i> of this view port:<br>
      * <ul>
      * <li>Stores the previous extent.
      * <li>Calculates the new extent using <code>r</code>:
+     *
      * <pre>
      * extent =
      *     new Rectangle2D.Double(r.getMinX() - 0.1,
      *         r.getMinY() - 0.1,
      *         r.getWidth() + 0.2,
      *         r.getHeight() + 0.2);
      * </pre>
+     *
      * <li>Executes {@linkplain #calculateAffineTransform()}: getting the new
      * scale, adjusted extent, affine transformation between map and screen
      * coordinates, the real world coordinates equivalent to 1 pixel, and the
      * real world coordinates equivalent to 3 pixels.
      * <li>Notifies all {@link ViewPortListener ViewPortListener} registered
      * that the extent has changed.
      * </ul>
      * </p>
+     *
      * @param r
      *            the new extent
+     *
      * @see #getExtent()
      * @see #getExtents()
      * @see #calculateAffineTransform()
      * @see #setPreviousExtent()
      */
     public void setEnvelope(Envelope r) {
         Rectangle2D newExtent = null;
         // Esto comprueba que el extent no es de anchura o altura = "0"
         // y si es as? lo redimensiona.
         if (r != null) {
             if ((r.getMaximum(0) - r.getMinimum(0) == 0)
                 || (r.getMaximum(1) - r.getMinimum(1) == 0)) {
                 newExtent =
                     new Rectangle2D.Double(r.getMinimum(0) - 0.1,
                         r.getMinimum(1) - 0.1,
                         r.getMaximum(0) - r.getMinimum(0) + 0.2,
                         r.getMaximum(1) - r.getMinimum(1) + 0.2);
             } else {
                 newExtent =
                     new Rectangle2D.Double(r.getMinimum(0),
                         r.getMinimum(1),
                         Math.abs(r.getMaximum(0) - r.getMinimum(0)),
                         Math.abs(r.getMaximum(1) - r.getMinimum(1)));
+            }
+        }
             vcaballero
-            fdiaz
+        if (this.extent != null && this.extent.equals(newExtent)) {
             return;
+        }
         if (extent != null) {
             extents.put(extent);
+        }
         this.updateDrawVersion();
         this.extent = newExtent;
             vcaballero
-            fdiaz
+        // Calcula la transformaci?n af?n
         calculateAffineTransform();
             vcaballero
-            fdiaz
+        // Lanzamos los eventos de extent cambiado
         callExtentChanged(getAdjustedExtent());
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Changes the <i>extent</i> and <i>adjusted extent</i> of this view port:<br>
      * <ul>
      * <li>Executes {@linkplain #calculateAffineTransform()}: getting the new
      * scale, adjusted extent, affine transformation between map and screen
      * coordinates, the real world coordinates equivalent to 1 pixel, and the
      * real world coordinates equivalent to 3 pixels.
      * <li>Notifies to all {@link ViewPortListener ViewPortListener} registered
      * that the extent has changed.
      * </ul>
      * </p>
+     *
      * @see #setEnvelope(Envelope)
      * @see #calculateAffineTransform()
      */
     public void refreshExtent() {
         // this.scale = scale;
             vcaballero
-            fdiaz
+        // Calcula la transformaci?n af?n
         calculateAffineTransform();
             vcaballero
-            fdiaz
+        // Lanzamos los eventos de extent cambiado
         callExtentChanged(getAdjustedExtent());
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Calculates and returns using the current projection of this view port,
      * the scale that is the extent in <i>screen coordinates</i> from the image
      * in <i>map coordinates</i>.
      * </p>
+     *
      * @return the scale <i>extent / image size</i> projected by this view port
+     *
      * @deprecated since 07/09/07, use {@linkplain MapContext#getScaleView()}
      */
     public double getScale() {
         return proj.getScale(extent.getMinX(),
             extent.getMaxX(),
             imageSize.width,
             dpi);
+    }
             jmvivo
-            fdiaz
+    /**
      * <p>
      * Affine transformation between <i>map 2D coordinates</i> to <i>screen 2D
      * coordinates</i> (pixels), preserving the "straightness" and "parallelism"
      * of the lines.
      * </p>
+     *
      * @return the affine transformation
+     *
      * @see #setAffineTransform(AffineTransform)
      * @see #calculateAffineTransform()
      */
     public AffineTransform getAffineTransform() {
         return trans;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Returns the size of the image projected.
      * </p>
+     *
      * @return the image size
+     *
      * @see #setImageSize(Dimension)
      * @see #getImageHeight()
      * @see #getImageWidth()
      */
     public Dimension getImageSize() {
         return imageSize;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Sets the size of the image projected, recalculating the parameters of
      * this view port.
      * </p>
+     *
      * @param imageSize
      *            the image size
+     *
      * @see #getImageSize()
      * @see #calculateAffineTransform()
      */
     public void setImageSize(Dimension imageSize) {
             vcaballero
-            fdiaz
+        if (this.imageSize == null || (!this.imageSize.equals(imageSize))) {
             this.updateDrawVersion();
             this.imageSize = imageSize;
             calculateAffineTransform();
+        }
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Notifies to all view port listeners registered, that the adjusted extent
      * of this view port has changed.
      * </p>
+     *
      * @param newRect
      *            the new adjusted extend
+     *
      * @see #refreshExtent()
      * @see #setEnvelope(Envelope)
      * @see #setPreviousExtent()
      * @see ExtentEvent
      * @see ViewPortListener
      */
     protected void callExtentChanged(Envelope newRect) {
         ExtentEvent ev = ExtentEvent.createExtentEvent(newRect);
             vcaballero
-            fdiaz
+        for (int i = 0; i < listeners.size(); i++) {
             ViewPortListener listener = (ViewPortListener) listeners.get(i);
             listener.extentChanged(ev);
+        }
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Notifies to all view port listeners registered, that the background color
      * of this view port has changed.
      * </p>
+     *
      * @param c
      *            the new background color
+     *
      * @see #setBackColor(Color)
      * @see ColorEvent
      * @see ViewPortListener
      */
     private void callColorChanged(Color c) {
         ColorEvent ce = ColorEvent.createColorEvent(c);
             vcaballero
-            fdiaz
+        for (int i = 0; i < listeners.size(); i++) {
             ViewPortListener listener = (ViewPortListener) listeners.get(i);
             listener.backColorChanged(ce);
+        }
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Notifies to all view port listeners registered, that the projection of
      * this view port has changed.
      * </p>
+     *
      * @param projection
      *            the new projection
+     *
      * @see #setProjection(IProjection)
      * @see ProjectionEvent
      * @see ViewPortListener
      */
     private void callProjectionChanged(IProjection projection) {
         ProjectionEvent ev = ProjectionEvent.createProjectionEvent(projection);
             vcaballero
-            fdiaz
+        for (int i = 0; i < listeners.size(); i++) {
             ViewPortListener listener = (ViewPortListener) listeners.get(i);
             listener.projectionChanged(ev);
+        }
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Calculates the affine transformation between the {@link #extent extent}
      * in <i>map 2D coordinates</i> to the image area in the screen, in
      * <i>screen 2D coordinates</i> (pixels).
      * </p>
+     *
      * <p>
      * This process recalculates some parameters of this view port:<br>
+     *
      * <ul>
      * <li>The new {@link #scale scale} .
      * <li>The new {@link #adjustedExtent adjustedExtent} .
      * <li>The new {@link #trans trans} .
      * <li>The new real world coordinates equivalent to 1 pixel (
      * {@link #dist1pixel dist1pixel}) .
      * <li>The new real world coordinates equivalent to 3 pixels (
      * {@link #dist3pixel dist3pixel}) .
      * </ul>
      * </p>
+     *
      * @see #getAffineTransform()
      * @see #setAffineTransform(AffineTransform)
      * @see #refreshExtent()
      * @see #setEnvelope(Envelope)
      * @see #setImageSize(Dimension)
      * @see #setPreviousExtent()
      * @see #createFromXML(XMLEntity)
      * @see AffineTransform
      */
     private void calculateAffineTransform() {
         if ((imageSize == null) || (extent == null) || (imageSize.width <= 0)
             || (imageSize.height <= 0)) {
             return;
+        }
             vcaballero
-            fdiaz
+        AffineTransform escalado = new AffineTransform();
         AffineTransform translacion = new AffineTransform();
             vcaballero
-            fdiaz
+        double escalaX;
         double escalaY;
             vcaballero
-            fdiaz
+        escalaX = imageSize.width / extent.getWidth();
         escalaY = imageSize.height / extent.getHeight();
             vcaballero
-            fdiaz
+        double xCenter = extent.getCenterX();
         double yCenter = extent.getCenterY();
         double newHeight;
         double newWidth;
             vcaballero
-            fdiaz
+        adjustedExtent = new Rectangle2D.Double();
             vcaballero
-            fdiaz
+        if (adjustableExtent) {
             if (escalaX < escalaY) {
                 scale = escalaX;
                 newHeight = imageSize.height / scale;
                 adjustedExtent.setRect(xCenter - (extent.getWidth() / 2.0),
                     yCenter - (newHeight / 2.0),
                     extent.getWidth(),
                     newHeight);
             } else {
                 scale = escalaY;
                 newWidth = imageSize.width / scale;
                 adjustedExtent.setRect(xCenter - (newWidth / 2.0), yCenter
                     - (extent.getHeight() / 2.0), newWidth, extent.getHeight());
+            }
             escalado.setToScale(scale, -scale);
         } else { // adjusted is same as extent
             scale = escalaX;
             adjustedExtent.setFrame(extent);
             escalado.setToScale(escalaX, -escalaY);
+        }
         Envelope env = getAdjustedExtent();
         if (env == null) {
             return;
+        }
         translacion.setToTranslation(-env.getMinimum(0), -env.getMinimum(1)
             - getAdjustedExtent().getLength(1));
             vcaballero
-            fdiaz
+        AffineTransform offsetTrans = new AffineTransform();
         offsetTrans.setToTranslation(offset.getX(), offset.getY());
             vcaballero
-            fdiaz
+        trans.setToIdentity();
         trans.concatenate(offsetTrans);
         trans.concatenate(escalado);
             vcaballero
-            fdiaz
+        trans.concatenate(translacion);
             vcaballero
-            fdiaz
+        // Calculamos las distancias de 1 pixel y 3 pixel con esa
         // transformaci?n
         // de coordenadas, de forma que est?n precalculadas para cuando las
         // necesitemos
         AffineTransform at;
             vcaballero
-            fdiaz
+        try {
             at = trans.createInverse();
             vcaballero
-            fdiaz
+            Point2D pPixel = new Point2D.Float(1, 1);
             vcaballero
-            fdiaz
+            Point2D.Float pProv = new Point2D.Float();
             at.deltaTransform(pPixel, pProv);
             vcaballero
-            fdiaz
+            dist1pixel = pProv.x;
             dist3pixel = 3 * pProv.x;
         } catch (NoninvertibleTransformException e) {
             System.err.println("transformada afin = " + trans.toString());
             System.err.println("extent = " + extent.toString() + " imageSize= "
                 + imageSize.toString());
             throw new RuntimeException("Non invertible transform Exception", e);
+        }
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Sets the offset.
      * </p>
      * <p>
      * The offset is the position where start drawing the map.
      * </p>
+     *
      * @param p
      *            2D point that represents the offset in pixels
+     *
      * @see #getOffset()
      */
     public void setOffset(Point2D p) {
         if (!offset.equals(p)) {
             this.updateDrawVersion();
             offset = p;
+        }
+    }
             jtorres
-            fdiaz
+    /**
      * <p>
      * Gets the offset.
      * </p>
      * <p>
      * The offset is the position where start drawing the map.
      * </p>
+     *
      * @return 2D point that represents the offset in pixels
+     *
      * @see #setOffset(Point2D)
      */
     public Point2D getOffset() {
         return offset;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Sets the background color.
      * </p>
+     *
      * @param c
      *            the new background color
+     *
      * @see #getBackColor()
      */
     public void setBackColor(Color c) {
         if (!c.equals(this.backColor)) {
             this.updateDrawVersion();
             backColor = c;
             callColorChanged(backColor);
+        }
+    }
             jtorres
-            fdiaz
+    /**
      * <p>
      * Gets the background color.
      * </p>
+     *
      * @return the background color of the view
+     *
      * @see #setBackColor(Color)
      */
     public Color getBackColor() {
         return backColor;
+    }
             jtorres
-            fdiaz
+    /**
      * <p>
      * Returns the extent currently covered by the view adjusted (scaled) to the
      * image size aspect.
      * </p>
+     *
      * @return extent of the view adjusted to the image size aspect
+     *
      * @see #setAdjustable(boolean)
      * @deprecated use {@link ViewPort#getAdjustedEnvelope()} instead
      */
     public Envelope getAdjustedExtent() {
         return getAdjustedEnvelope();
+    }
             jtorres
-            fdiaz
+    /**
      * <p>
      * Returns the envelope currently covered by the view adjusted (scaled) to
      * the image size aspect.
      * </p>
+     *
      * @return envelope of the view adjusted to the image size aspect
+     *
      * @see #setAdjustable(boolean)
      */
     public Envelope getAdjustedEnvelope() {
         if (cliprect != null) {
             Rectangle2D r = adjustedExtent.createIntersection(cliprect);
             try {
                 return geomManager.createEnvelope(r.getX(),
                     r.getY(),
                     r.getMaxX(),
                     r.getMaxY(),
                     SUBTYPES.GEOM2D);
             } catch (CreateEnvelopeException e) {
                 e.printStackTrace();
                 logger.error("Error adjusting the extent", e);
+            }
+        }
         if (adjustedExtent != null) {
             try {
                 return geomManager.createEnvelope(adjustedExtent.getX(),
                     adjustedExtent.getY(),
                     adjustedExtent.getMaxX(),
                     adjustedExtent.getMaxY(),
                     SUBTYPES.GEOM2D);
             } catch (CreateEnvelopeException e) {
                 e.printStackTrace();
                 logger.error("Error adjusting the extent", e);
+            }
+        }
         return null;
+    }
             jtorres
-            fdiaz
+    /**
      * <p>
      * Returns the measurement unit of this view port used for measuring
      * distances and displaying information.
      * </p>
+     *
      * @return the measurement unit of this view used for measuring distances
      *         and displaying information
+     *
      * @see #setDistanceUnits(int)
      */
     public int getDistanceUnits() {
         return distanceUnits;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Returns the measurement unit of this view port used for measuring areas
      * and displaying information.
      * </p>
+     *
      * @return the measurement unit of this view used for measuring areas and
      *         displaying information
+     *
      * @see #setDistanceUnits(int)
      */
     public int getDistanceArea() {
         return distanceArea;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Sets the measurement unit of this view port used for measuring distances
      * and displaying information.
      * </p>
+     *
      * @param distanceUnits
      *            the measurement unit of this view used for measuring distances
      *            and displaying information
+     *
      * @see #getDistanceUnits()
      */
     public void setDistanceUnits(int distanceUnits) {
         this.distanceUnits = distanceUnits;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Sets the measurement unit of this view port used for measuring areas and
      * displaying information.
      * </p>
+     *
      * @param distanceUnits
      *            the measurement unit of this view used for measuring areas and
      *            displaying information
+     *
      * @see #getDistanceUnits()
      */
     public void setDistanceArea(int distanceArea) {
         this.distanceArea = distanceArea;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Gets the measurement unit used by this view port for the map.
      * </p>
+     *
      * @return Returns the current map measure unit
+     *
      * @see #setMapUnits(int)
      */
     public int getMapUnits() {
         return mapUnits;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Sets the measurement unit used by this view port for the map.
      * </p>
+     *
      * @param mapUnits
      *            the new map measure unit
+     *
      * @see #getMapUnits()
      */
     public void setMapUnits(int mapUnits) {
         this.mapUnits = mapUnits;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Gets the width in <i>screen coordinates</i> of the rectangle where the
      * image is displayed.
      * </p>
      * <p>
      * Used by {@linkplain #calculateAffineTransform()} to calculate:<br>
+     *
      * <ul>
      * <li>The new {@link #scale scale} .
      * <li>The new {@link #adjustedExtent adjustableExtent} .
      * <li>The new {@link #trans trans} .
      * <li>The new real world coordinates equivalent to 1 pixel (
      * {@link #dist1pixel dist1pixel}) .
      * <li>The new real world coordinates equivalent to 3 pixels (
      * {@link #dist3pixel dist3pixel}) .
      * </ul>
      * </p>
+     *
      * @see #getImageHeight()
      * @see #getImageSize()
      * @see #setImageSize(Dimension)
      */
     public int getImageWidth() {
         return imageSize.width;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Gets the height in <i>screen coordinates</i> of the rectangle where the
      * image is displayed.
      * </p>
      * <p>
      * Used by {@linkplain #calculateAffineTransform()} to calculate:<br>
+     *
      * <ul>
      * <li>The new {@link #scale scale} .
      * <li>The new {@link #adjustedExtent adjustableExtent} .
      * <li>The new {@link #trans trans} .
      * <li>The new real world coordinates equivalent to 1 pixel (
      * {@link #dist1pixel dist1pixel}) .
      * <li>The new real world coordinates equivalent to 3 pixels (
      * {@link #dist3pixel dist3pixel}) .
      * </ul>
      * </p>
+     *
      * @see #getImageWidth()
      * @see #getImageSize()
      * @see #setImageSize(Dimension)
      */
     public int getImageHeight() {
         return imageSize.height;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Gets the distance in <i>world coordinates</i> equivalent to 1 pixel in
      * the view with the current extent.
      * </p>
+     *
      * @return the distance
+     *
      * @see #setDist1pixel(double)
      */
     public double getDist1pixel() {
         return dist1pixel;
+    }
             jtorres
-            fdiaz
+    /**
      * <p>
      * Sets the distance in <i>world coordinates</i> equivalent to 1 pixel in
      * the view with the current extent.
      * </p>
+     *
      * @param dist1pixel
      *            the distance
+     *
      * @see #getDist1pixel()
      */
     public void setDist1pixel(double dist1pixel) {
         if (dist1pixel == this.dist1pixel) {
             return;
+        }
         this.updateDrawVersion();
         this.dist1pixel = dist1pixel;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Gets the distance in <i>world coordinates</i> equivalent to 3 pixels in
      * the view with the current extent.
      * </p>
+     *
      * @return the distance
+     *
      * @see #setDist3pixel(double)
      */
     public double getDist3pixel() {
         return dist3pixel;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Sets the distance in <i>world coordinates</i> equivalent to 3 pixels in
      * the view with the current extent.
      * </p>
+     *
      * @param dist3pixel
      *            the distance
+     *
      * @see #getDist3pixel()
      */
     public void setDist3pixel(double dist3pixel) {
         if (this.dist3pixel == dist3pixel) {
             return;
+        }
         this.updateDrawVersion();
         this.dist3pixel = dist3pixel;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Returns the last previous extents of this view port.
      * </p>
+     *
      * @return the last previous extents of this view port
+     *
      * @see #setPreviousExtent()
      * @deprecated use {@link ViewPort#getEnvelopes()}
      */
     public ExtentHistory getExtents() {
         return getEnvelopes();
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Returns the last previous extents of this view port.
      * </p>
+     *
      * @return the last previous extents of this view port
+     *
      * @see #setPreviousExtent()
      */
     public ExtentHistory getEnvelopes() {
         return extents;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Gets the projection used in this view port.
      * </p>
+     *
      * @return projection used in this view port
+     *
      * @see #setProjection(IProjection)
      */
     public IProjection getProjection() {
         return proj;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Sets the projection to this view port.
      * </p>
+     *
      * @param proj
      *            the new projection
+     *
      * @see #getProjection()
      */
     public void setProjection(IProjection proj) {
         if (this.proj == null || !this.proj.getAbrev().equals(proj.getAbrev())) {
             this.updateDrawVersion();
             this.proj = proj;
             callProjectionChanged(proj);
+        }
+    }
             vcaballero
-            fdiaz
+    // -----------------------------------------------------------------------------------------------------------
     // NOTA PARA DESARROLLADORES SOBRE EL M?TODO
     // "public void setAffineTransform(AffineTransform at)"
     // ==============================================================================================
     // Only used for print, should be removed, redefining the {@link
     // RasterAdapter RasterAdapter} interface,
     // allowing it to receive a {@link ViewPortData ViewPortData} .
     // -----------------------------------------------------------------------------------------------------------
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Sets only the affine transform to this view port, without updating
      * dependent attributes.
      * </p>
      * <p>
      * <b><i>This method could be problematic!</i></b>
      * </p>
+     *
      * @param at
      *            the affine transform to set
+     *
      * @see #getAffineTransform()
      * @see #calculateAffineTransform()
      */
     public void setAffineTransform(AffineTransform at) {
         this.trans = at;
+    }
             jldominguez
-            fdiaz
+    /**
      * <p>
      * Returns an XML entity that represents this view port instance:<br>
      * <ul>
      * <li>Properties:
      * <ul>
      * <li><i>className</i>: name of this class.
      * <li>If defined, the adjusted extent:
      * <ul>
      * <li><i>adjustedExtentX</i>: X coordinate of the adjusted extent.
      * <li><i>adjustedExtentY</i>: Y coordinate of the adjusted extent.
      * <li><i>adjustedExtentW</i>: width of the adjusted extent.
      * <li><i>adjustedExtentH</i>: height of the adjusted extent.
      * </ul>
      * <li>If defined, the background color:
      * <ul>
      * <li><i>backColor</i>: background color.
      * </ul>
      * <li>If defined, the clip:
      * <ul>
      * <li><i>clipX</i>: X coordinate of the clip.
      * <li><i>clipY</i>: Y coordinate of clip.
      * <li><i>clipW</i>: width of the clip.
      * <li><i>clipH</i>: height of the clip.
      * </ul>
      * <li><i>dist1pixel</i>: the distance in world coordinates equivalent to 1
      * pixel in the view.
      * <li><i>dist3pixel</i>: the distance in world coordinates equivalent to 3
      * pixels in the view.
      * <li><i>distanceUnits</i>: the distance measurement unit.
      * <li>If defined, the extent:
      * <ul>
      * <li><i>extentX</i>: X coordinate of the extent.
      * <li><i>extentY</i>: Y coordinate of the extent.
      * <li><i>extentW</i>: width of the extent.
      * <li><i>extentH</i>: height of the extent.
      * </ul>
      * <li><i>mapUnits</i>: the map measurement unit.
      * <li><i>offsetX</i>: X coordinate of the offset.
      * <li><i>offsetY</i>: Y coordinate of the offset.
      * <li>If defined, the projection:
      * <ul>
      * <li>If its defined, the projection:
      * <ul>
      * <li><i>proj</i>: the projection.</li>
      * </ul>
      * </ul>
      * <li><i>scale</i>: ratio between the size of <code>imageSize</code> and
      * <code>extent</code>.
      * </ul>
      * <li>Child branches:
      * <ul>
      * <li>XML entity of the internal {@link ExtentHistory ExtentHistory} .
      * </ul>
      * </ul>
+     *
      * @return the XML entity
+     *
      * @see #createFromXML(XMLEntity)
      */
     public void saveToState(PersistentState state) throws PersistenceException {
             jldominguez
-            fdiaz
+        state.set(FIELD_ADJUSTED_EXTENT, adjustedExtent);
         state.set(FIELD_BACK_COLOR, backColor);
         state.set(FIELD_CLIP, cliprect);
         state.set(FIELD_DIST1PIXEL, dist1pixel);
         state.set(FIELD_DIST3PIXEL, dist3pixel);
         state.set(FIELD_DISTANCE_UNITS, distanceUnits);
         state.set(FIELD_DISTANCE_AREA, distanceArea);
         state.set(FIELD_EXTENT, extent);
         state.set(FIELD_EXTENTS, extents);
         state.set(FIELD_MAP_UNITS, mapUnits);
         state.set(FIELD_OFFSET, offset);
         state.set(FIELD_PROJ, proj);
         state.set(FIELD_IMAGE_SIZE, imageSize);
+    }
     public void loadFromState(PersistentState state) throws PersistenceException {
         adjustedExtent = (Rectangle2D) state.get(FIELD_ADJUSTED_EXTENT);
         backColor = (Color) state.get(FIELD_BACK_COLOR);
         cliprect = (Rectangle2D) state.get(FIELD_CLIP);
         dist1pixel = state.getDouble(FIELD_DIST1PIXEL);
         dist3pixel = state.getDouble(FIELD_DIST3PIXEL);
         distanceUnits = state.getInt(FIELD_DISTANCE_UNITS);
         extents = (ExtentHistory) state.get(FIELD_EXTENTS);
         extent = (Rectangle2D) state.get(FIELD_EXTENT);
         mapUnits = state.getInt(FIELD_MAP_UNITS);
         offset = (Point2D) state.get(FIELD_OFFSET);
         proj = (IProjection) state.get(FIELD_PROJ);
         imageSize = (Dimension) state.get(FIELD_IMAGE_SIZE);
         distanceArea = state.getInt(FIELD_DISTANCE_AREA);
         refreshExtent();
+    }
-            jjdelcerro
+        public static class RegisterPersistence implements Callable {
                 public Object call() throws Exception {
                         PersistenceManager manager = ToolsLocator.getPersistenceManager();
                         if( manager.getDefinition("ViewPort")==null ) {
                         DynStruct definition =
                             manager.addDefinition(ViewPort.class,
                                 "ViewPort",
                                 "ViewPort Persistence definition",
                                 null,
                                 null);
                         definition.addDynFieldObject(FIELD_ADJUSTED_EXTENT)
                             .setClassOfValue(Rectangle2D.class)
                             .setMandatory(false);
                         definition.addDynFieldObject(FIELD_BACK_COLOR)
                             .setClassOfValue(Color.class)
                             .setMandatory(false);
                         definition.addDynFieldObject(FIELD_CLIP)
                             .setClassOfValue(Rectangle2D.class)
                             .setMandatory(false);
                         definition.addDynFieldDouble(FIELD_DIST1PIXEL).setMandatory(true);
                         definition.addDynFieldDouble(FIELD_DIST3PIXEL).setMandatory(true);
                         definition.addDynFieldInt(FIELD_DISTANCE_UNITS).setMandatory(true);
                         definition.addDynFieldInt(FIELD_DISTANCE_AREA).setMandatory(false);
                         definition.addDynFieldObject(FIELD_EXTENT)
                             .setClassOfValue(Rectangle2D.class)
                             .setMandatory(false);
                         definition.addDynFieldObject(FIELD_EXTENTS)
                             .setClassOfValue(ExtentHistory.class)
                             .setMandatory(true);
                         definition.addDynFieldInt(FIELD_MAP_UNITS).setMandatory(true);
                         definition.addDynFieldObject(FIELD_OFFSET)
                             .setClassOfValue(Point2D.class)
                             .setMandatory(false);
                         definition.addDynFieldObject(FIELD_PROJ)
                             .setClassOfValue(IProjection.class)
                             .setMandatory(true);
                         definition.addDynFieldObject(FIELD_IMAGE_SIZE)
                             .setClassOfValue(Dimension.class)
                             .setMandatory(false);
+                        }
                         return Boolean.TRUE;
+                }
+        }
         /**
-            fdiaz
+     * Clone the view port without clone the listeners nor the extent history.
+     *
      * @return the cloned view port
      */
     public Object clone() throws CloneNotSupportedException {
         ViewPort clonedViewPort = (ViewPort) super.clone();
         clonedViewPort.listeners = new ArrayList();
         clonedViewPort.extents = new ExtentHistory();
         if (this.adjustedExtent!=null){
             clonedViewPort.adjustedExtent =
                 (Rectangle2D) this.adjustedExtent.clone();
+        }
         if (this.cliprect!=null){
             clonedViewPort.cliprect = (Rectangle2D) this.cliprect.clone();
+        }
             jldominguez
-            fdiaz
+        if (this.extent!=null) {
             clonedViewPort.extent = (Rectangle2D) this.extent.clone();
+        }
         if (this.imageSize!=null){
             clonedViewPort.imageSize = (Dimension) this.imageSize.clone();
+        }
             jldominguez
-            fdiaz
+        if (this.offset!=null){
             clonedViewPort.offset = (Point2D) this.offset.clone();
+        }
         if (proj!=null){
             clonedViewPort.proj = (IProjection) this.proj.clone();
+        }
             jldominguez
-            fdiaz
+        clonedViewPort.trans = (AffineTransform) this.trans.clone();
             jldominguez
-            fdiaz
+        return clonedViewPort;
+    }
             jldominguez
-            fdiaz
+    /**
      * <p>
      * Returns a <code>String</code> representation of the main values of this
      * view port: <code>{@linkplain #extent}</code>,
      * <code>{@linkplain #adjustedExtent}</code>,
      * <code>{@linkplain #imageSize}</code>, <code>{@linkplain #scale}</code>,
      * and <code>{@linkplain #trans}</code>.
      * </p>
+     *
      * @return a <code>string</code> representation of the main values of this
      *         view port
      */
     public String toString() {
             vcaballero
-            fdiaz
+        String str;
         str =
             "Datos del viewPort:\nExtent=" + extent + "\nadjustedExtent="
                 + adjustedExtent + "\nimageSize=" + imageSize + "\nescale="
                 + scale + "\ntrans=" + trans;
             vcaballero
-            fdiaz
+        return str;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Sets the position and size of the clipping rectangle.
      * </p>
+     *
      * @param rectView
      *            the clipping rectangle to set
      */
     public void setClipRect(Rectangle2D rectView) {
         this.updateDrawVersion();
         cliprect = rectView;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Converts and returns the {@link Rectangle2D Rectangle2D}, that is in
      * <i>map coordinates</i> to <i>screen coordinates</i> (pixels) using an
      * <i>inverse transform</i> with the transformation affine information in
      * the {@link #trans #trans} attribute.
      * </p>
+     *
      * @param r
      *            the 2D rectangle in <i>map coordinates</i>
      * @return 2D rectangle equivalent in <i>screen coordinates</i> (pixels)
+     *
      * @see #toMapRectangle(Rectangle2D)
      * @see #fromMapDistance(double)
      * @see #fromMapPoint(Point2D)
      */
     public Rectangle2D fromMapRectangle(Rectangle2D r) {
         Rectangle2D rect = new Rectangle2D.Double();
         Point2D p1 = fromMapPoint((int) r.getX(), (int) r.getY());
         Point2D p2 = fromMapPoint((int) r.getMaxX(), (int) r.getMaxY());
         rect.setFrameFromDiagonal(p1, p2);
         return rect;
+    }
             vcaballero
-            fdiaz
+    /**
      * <p>
      * Recalculates the current <code>{@linkplain #extent}</code> using an
      * scale. It's necessary execute {@linkplain #refreshExtent()} after.
      * </p>
+     *
      * @param s
      *            the scale to set
+     *
      * @deprecated since 07/09/07, use
      *             {@linkplain MapContext#setScaleView(long)}
      */
     public void setScale(long s) {
         double x = extent.getX();
         double y = extent.getY();
         double escalaX = imageSize.width / extent.getWidth();
         // double w = imageSize.width / s;
         // double h = imageSize.height / s;
         double difw = escalaX / s;
             jmvivo
-            fdiaz
+        double x1 = (-x * difw) - x + extent.getWidth() / 2;
         double y1 = (-y * difw) - y + extent.getHeight() / 2;
         double w1 = extent.getWidth() * difw;
         double h1 = extent.getHeight() * difw;
         extent.setRect(-x1, -y1, w1, h1);
+    }
             vcaballero
-            fdiaz
+    public long getDrawVersion() {
         return this.drawVersion;
+    }
             vcaballero
-            fdiaz
+    protected void updateDrawVersion() {
         this.drawVersion++;
+    }
             jtorres
-            jjdelcerro
+//    /**
 //     * Obtiene la representaci?n de un color como String
 //     *
 //     * @param c
 //     *            Color
 //     *
 //     * @return String
 //     */
 //    public static String color2String(Color c) {
 //        if (c == null)
 //            return null;
 //        return c.getRed() + "," + c.getGreen() + "," + c.getBlue() + ","
 //            + c.getAlpha();
 //    }
 //
 //    /**
 //     * Obtiene el color de un string generado con color2String
 //     *
 //     * @param stringColor
 //     *            string
 //     *
 //     * @return Color
 //     */
 //    public static Color string2Color(String stringColor) {
 //        if (stringColor == null || stringColor.equals("null"))
 //            return null;
 //        String[] ints = new String[4];
 //
 //        ints = CompatLocator.getStringUtils().split(stringColor, ",");
 //
 //        int[] ret = new int[4];
 //
 //        for (int i = 0; i < ret.length; i++) {
 //            ret[i] = new Integer(ints[i]).intValue();
 //        }
 //
 //        return new Color(ret[0], ret[1], ret[2], ret[3]);
 //    }
             jtorres
             vcaballero