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

Revision 29519 branches/v2_0_0_prep/libraries/libFMap_mapcontext/src/org/gvsig/fmap/mapcontext/ViewPort.java

     import com.iver.utiles.StringUtilities;
     import com.iver.utiles.XMLEntity;
     /**
      * <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:
      * <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:
      * <ul>
      * <li><i>extent</i>: the area selected of the map, in <i>map coordinates</i>.
      * <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.
      * <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.
      * <li><i>scale</i>: the scale between the adjusted extent and the image size.
      * <li><i>backColor</i>: the default background color in the view, if there is no map.
      * <li><i>backColor</i>: the default background color in the view, if there is
      * no map.
      * <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.
      * <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.
      * <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.
      * </ul>
      * </p>
+     *
+     *
      * @author Vicente Caballero Navarro
      */
     public class ViewPort {
     //	/**
     //	 * <p>Metric unit or length equal to 1000 meters.</p>
     //	 */
     //	public static int KILOMETROS = 0;
     //
     //	/**
     //	 * <p>The base unit of length in the International System of Units that is equal to the distance
     //	 *  traveled by light in a vacuum in {frac;1;299,792,458} second or to about 39.37 inches.</p>
     //	 */
     //	public static int METROS = 1;
     //
     //	/**
     //	 * <p>Metric unit or length equal to 0'01 meters.</p>
     //	 */
     //	public static int CENTIMETRO = 2;
     //
     //	/**
     //	 * <p>Metric unit or length equal to 0'001 meters.</p>
     //	 */
     //	public static int MILIMETRO = 3;
     //
     //	/**
     //	 * <p>The international statute mile by international agreement. It is defined to be precisely
     //	 *  1,760 international yards (by definition, 0.9144 m each) and is therefore exactly 1,609.344
     //	 *  metres (1.609344 km).</p>
     //	 */
     //	public static int MILLAS = 4;
     //
     //	/**
     //	 * <p>Unit of length equal in the United States to 0.9144 meter.</p>
     //	 */
     //	public static int YARDAS = 5;
     //
     //	/**
     //	 * <p>Any of various units of length based on the length of the human foot; especially :
     //	 *  a unit equal to 1/3 yard and comprising 12 inches.</p>
     //	 */
     //	public static int PIES = 6;
     //
     //	/**
     //	 * <p>Unit of length equal to 1/36 yard.</p>
     //	 */
     //	public static int PULGADAS = 7;
     //
     //	/**
     //	 * <p>Grades according the current projection.</p>
     //	 */
     //	public static int GRADOS = 8;
     	private static final GeometryManager geomManager = GeometryLocator.getGeometryManager();
     	private static final Logger logger = LoggerFactory.getLogger(GeometryManager.class);
     	// /**
     	// * <p>Metric unit or length equal to 1000 meters.</p>
     	// */
     	// public static int KILOMETROS = 0;
     	//
     	// /**
     	// * <p>The base unit of length in the International System of Units that is
     	// equal to the distance
     	// * traveled by light in a vacuum in {frac;1;299,792,458} second or to
     	// about 39.37 inches.</p>
     	// */
     	// public static int METROS = 1;
     	//
     	// /**
     	// * <p>Metric unit or length equal to 0'01 meters.</p>
     	// */
     	// public static int CENTIMETRO = 2;
     	//
     	// /**
     	// * <p>Metric unit or length equal to 0'001 meters.</p>
     	// */
     	// public static int MILIMETRO = 3;
     	//
     	// /**
     	// * <p>The international statute mile by international agreement. It is
     	// defined to be precisely
     	// * 1,760 international yards (by definition, 0.9144 m each) and is
     	// therefore exactly 1,609.344
     	// * metres (1.609344 km).</p>
     	// */
     	// public static int MILLAS = 4;
     	//
     	// /**
     	// * <p>Unit of length equal in the United States to 0.9144 meter.</p>
     	// */
     	// public static int YARDAS = 5;
     	//
     	// /**
     	// * <p>Any of various units of length based on the length of the human
     	// foot; especially :
     	// * a unit equal to 1/3 yard and comprising 12 inches.</p>
     	// */
     	// public static int PIES = 6;
     	//
     	// /**
     	// * <p>Unit of length equal to 1/36 yard.</p>
     	// */
     	// public static int PULGADAS = 7;
     	//
     	// /**
     	// * <p>Grades according the current projection.</p>
     	// */
     	// public static int GRADOS = 8;
     	private static final GeometryManager geomManager = GeometryLocator
     			.getGeometryManager();
     	private static final Logger logger = LoggerFactory
     			.getLogger(GeometryManager.class);
     	/**
     	 * <p>Screen resolution in <i>dots-per-inch</i>. Useful to calculate the geographic scale of the view.</p>
+    	 *
     	 * <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();
     			.getScreenResolution();
     	/**
     	 * <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>
     	 * Area selected by user using some tool.
     	 * </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.
     	 * 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;
     	/**
     	 * <p>Location and dimensions of the extent adjusted to the image size.</p>
+    	 *
     	 * <p>
     	 * Location and dimensions of the extent adjusted to the image size.
     	 * </p>
+    	 *
     	 * @see #getAdjustedExtent()
     	 */
     	protected Rectangle2D adjustedExtent;
     	/**
     	 * 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;
     	/**
     	 * <p>History with the last extents of the view.</p>
+    	 *
     	 * 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;
     	/**
     	 * <p>
     	 * History with the last extents of the view.
     	 * </p>
+    	 *
     	 * @see #setPreviousExtent()
     	 * @see #getExtents()
     	 */
     	protected ExtentHistory extents = new ExtentHistory();
     	/**
     	 * <p>Size in <i>screen coordinates</i> of the rectangle where the image is displayed.</p>
     	 * <p>Used by {@linkplain #calculateAffineTransform()} to calculate:<br>
+      	 *
     	 * <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}) .
     	 * <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()
-...
     	private Dimension imageSize;
     	/**
     	 * <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>
+    	 *
     	 * <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();
     	/**
     	 * <p>Measurement unit used for measuring distances and displaying information.</p>
+    	 *
     	 * <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>
+    	 *
     	 * <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>
+    	 *
     	 * <p>
     	 * Measurement unit used by this view port for the map.
     	 * </p>
+    	 *
     	 * @see #getMapUnits()
     	 * @see #setMapUnits(int)
     	 */
     	private int mapUnits = 1;
     	/**
     	 * <p>Array with the {@link ViewPortListener ViewPortListener}s registered to this view port.</p>
+    	 *
     	 * <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();
     	/**
     	 * <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>
+    	 *
     	 * <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);
     	/**
     	 * <p>Clipping area.</p>
     	 * <p>
     	 * Clipping area.
     	 * </p>
     	 */
     	private Rectangle2D clip;
     	/**
     	 * <p>Background color of this view.</p>
+    	 *
     	 * <p>
     	 * Background color of this view.
     	 * </p>
+    	 *
     	 * @see #getBackColor()
     	 * @see #setBackColor(Color)
     	 */
     	private Color backColor = null; //Color.WHITE;
     	private Color backColor = null; // Color.WHITE;
     	/**
     	 * <p>Information about the map projection used in this view.</p>
+    	 *
     	 * <p>
     	 * Information about the map projection used in this view.
     	 * </p>
+    	 *
     	 * @see #getProjection()
     	 * @see #setProjection(IProjection)
     	 */
     	private IProjection proj;
     	/**
     	 * <p>Represents the distance in <i>world coordinates</i> equivalent to 1 pixel in the view with the current extent.</p>
+    	 *
     	 * <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;
     	/**
     	 * <p>Represents the distance in <i>world coordinates</i> equivalent to 3 pixels in the view with the current extent.</p>
+    	 *
     	 * <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;
     	/**
     	 * <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>
     	 * <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;
     	/**
     	 * <p>Clipping area.</p>
+    	 *
     	 * <p>
     	 * Clipping area.
     	 * </p>
+    	 *
     	 * @see #setClipRect(Rectangle2D)
     	 */
     	private Rectangle2D cliprect;
     	/**
     	 * <p>Enables or disables the <i>"adjustable extent"</i> mode.</p>
+    	 *
     	 * <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"</pre>.
     	 * <li><i>disabled</i>: the new <code>adjustedExtent</code> will be like <code>extent</code>.
     	 * <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;
     	private boolean adjustableExtent = true;
     	/**
     	 * <p>Creates a new view port with the information of the projection in <code>proj</code> argument, and
     	 *  default configuration:</p>
     	 * <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>
     	 * <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
+    	 *
     	 * @param proj
     	 *            information of the projection for this view port
     	 */
     	public ViewPort(IProjection proj) {
     		// Por defecto
-...
+    	}
     	/**
     	 * <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>
+    	 *
     	 * <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;
     		if (adjustable == adjustableExtent) {
     			return;
+    		}
     		adjustableExtent = adjustable;
     		this.updateDrawVersion();
     		this.updateDrawVersion();
+    	}
     	/**
     	 * <p>Appends the specified {@link ViewPortListener ViewPortListener} listener if weren't.</p>
+    	 *
     	 * @param arg0 the listener to add
+    	 *
     	 * <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) {
-...
+    	}
     	/**
      	 * <p>Removes the specified {@link ViewPortListener ViewPortListener} listener, if existed.</p>
+    	 *
     	 * @param arg0 the listener to remove
+    	 *
     	 * <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) {
-...
+    	}
     	/**
     	 * <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>
+    	 *
     	 * <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
     	 */
-...
+    	}
     	/**
     	 * <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
+    	 *
     	 * <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)
     	 */
-...
+    	}
     	/**
     	 * <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>
+    	 *
     	 * <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)
     	 */
-...
+    	}
     	/**
     	 * <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
+    	 *
     	 * <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)
     	 */
-...
+    	}
     	/**
     	 * <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)
     	 * <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);
     	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;
+    	}
     	/**
     	 * <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
+    	 *
     	 * <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
     	 */
-...
+    	}
     	/**
     	 * <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)
+    	 *
     	 * <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)
-...
     			at = trans.createInverse();
     			at.transform(pScreen, pWorld);
     		} catch (NoninvertibleTransformException e) {
     			throw new RuntimeException("Non invertible transform Exception",e);
     			throw new RuntimeException("Non invertible transform Exception", e);
+    		}
     		return pWorld;
+    	}
     	/**
     	 * <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>
+    	 *
     	 * <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) {
-...
     		dist = pt1.distance(pt2);
     		if ((proj != null) && !(proj instanceof UTM)) {
     			dist = new GeoCalc(proj).distanceVincenty(proj.toGeo(pt1),
     					proj.toGeo(pt2));
     			dist = new GeoCalc(proj).distanceVincenty(proj.toGeo(pt1), proj
     					.toGeo(pt2));
     			return dist;
+    		}
     		return (dist*MapContext.getDistanceTrans2Meter()[getMapUnits()]);
     		return (dist * MapContext.getDistanceTrans2Meter()[getMapUnits()]);
+    	}
     	/**
     	 * <p>Sets as extent and adjusted extent of this view port, the previous. Recalculating
     	 *  its parameters.</p>
+    	 *
     	 * <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();
+    	}
     	/**
     	 * <p>Sets as envelope and adjusted envelope of this view port, the previous. Recalculating
     	 *  its parameters.</p>
+    	 *
     	 * <p>
     	 * Sets as envelope and adjusted envelope of this view port, the previous.
     	 * Recalculating its parameters.
     	 * </p>
+    	 *
     	 * @see #getExtents()
     	 * @see #calculateAffineTransform()
     	 */
-...
     		this.updateDrawVersion();
     		extent = extents.removePrev();
     		//Calcula la transformaci�n af�n
     		// Calcula la transformaci�n af�n
     		calculateAffineTransform();
     		// Lanzamos los eventos de extent cambiado
-...
+    	}
     	/**
     	 * <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>
+    	 *
     	 * <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()
-...
     	public Rectangle2D getExtent() {
     		return extent;
+    	}
     	/**
     	 * <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>
+    	 *
     	 * <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(){
     	public Envelope getEnvelope() {
     		try {
     			return geomManager.createEnvelope(
     					extent.getMinX(), extent.getMinY(),
     					extent.getMaxX(), extent.getMaxY(),
     			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
     			// This class has to use Envelope instead of Rectangle2D. This catch
     			// will disappear
     		} catch (CreateEnvelopeException e) {
     			logger.error("Error creating the envelope");
     			logger.error("Error creating the envelope");
+    		}
     		return null;
+    	}
     	/**
     	 * <p>Changes the <i>extent</i> and <i>adjusted extent</i> of this view port:<br>
     	 * <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.
+    	 *
     	 * <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
+    	 *
+    	 *
     	 * @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) {
     		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);
     				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)));
     				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)));
+    			}
+    		}
     		if (this.extent != null && this.extent.equals(newExtent)){
     		if (this.extent != null && this.extent.equals(newExtent)) {
     			return;
+    		}
     		if (extent != null) {
-...
     		this.updateDrawVersion();
     		this.extent = newExtent;
     		//Calcula la transformaci�n af�n
     		// Calcula la transformaci�n af�n
     		calculateAffineTransform();
     		// Lanzamos los eventos de extent cambiado
-...
+    	}
     	/**
     	 * <p>Changes the <i>extent</i> and <i>adjusted extent</i> of this view port:<br>
     	 * <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.
     	 * <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;
     		// this.scale = scale;
     		//Calcula la transformaci�n af�n
     		// Calcula la transformaci�n af�n
     		calculateAffineTransform();
     		// Lanzamos los eventos de extent cambiado
-...
+    	}
     	/**
     	 * <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>
+    	 *
     	 * <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);
     				imageSize.width, dpi);
+    	}
     	/**
     	 * <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>
+    	 *
     	 * <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()
     	 */
-...
+    	}
     	/**
     	 * <p>Returns the size of the image projected.</p>
+    	 *
     	 * <p>
     	 * Returns the size of the image projected.
     	 * </p>
+    	 *
     	 * @return the image size
+    	 *
+    	 *
     	 * @see #setImageSize(Dimension)
     	 * @see #getImageHeight()
     	 * @see #getImageWidth()
-...
+    	}
     	/**
     	 * <p>Sets the size of the image projected, recalculating the parameters of this view port.</p>
+    	 *
     	 * @param imageSize the image size
+    	 *
     	 * <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) {
     		if (this.imageSize == null  || (!this.imageSize.equals(imageSize))){
     				this.updateDrawVersion();
     				this.imageSize = imageSize;
     				calculateAffineTransform();
     		if (this.imageSize == null || (!this.imageSize.equals(imageSize))) {
     			this.updateDrawVersion();
     			this.imageSize = imageSize;
     			calculateAffineTransform();
+    		}
+    	}
     	/**
     	 * <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
+    	 *
     	 * <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()
-...
+    	}
     	/**
     	 * <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
+    	 *
     	 * <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
-...
+    	}
     	/**
     	 * <p>Notifies to all view port listeners registered, that the projection of this view port
     	 *  has changed.</p>
+    	 *
     	 * @param projection the new projection
+    	 *
     	 * <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
-...
+    	}
     	/**
     	 * <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>
+    	 *
     	 * <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}) .
     	 * <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 AffineTransform
     	 */
     	private void calculateAffineTransform() {
     		if ((imageSize == null) || (extent == null) ||
     				(imageSize.width <= 0) || (imageSize.height <= 0)) {
     		if ((imageSize == null) || (extent == null) || (imageSize.width <= 0)
     				|| (imageSize.height <= 0)) {
     			return;
+    		}
-...
     				scale = escalaX;
     				newHeight = imageSize.height / scale;
     				adjustedExtent.setRect(xCenter - (extent.getWidth() / 2.0),
     					yCenter - (newHeight / 2.0), extent.getWidth(), newHeight);
     						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());
     				adjustedExtent.setRect(xCenter - (newWidth / 2.0), yCenter
     						- (extent.getHeight() / 2.0), newWidth, extent
     						.getHeight());
+    			}
     			escalado.setToScale(scale, -scale);
+    		}
     		else { // adjusted is same as extent
     		} else { // adjusted is same as extent
     			scale = escalaX;
     			adjustedExtent.setFrame(extent);
     			escalado.setToScale(escalaX, -escalaY);
+    		}
     		Envelope env=getAdjustedExtent();
     		Envelope env = getAdjustedExtent();
     		if (env == null) {
     			return;
+    		}
     		translacion.setToTranslation(-env.getMinimum(0),
     			-env.getMinimum(1) - getAdjustedExtent().getLength(1));
     		translacion.setToTranslation(-env.getMinimum(0), -env.getMinimum(1)
     				- getAdjustedExtent().getLength(1));
     		AffineTransform offsetTrans = new AffineTransform();
     		offsetTrans.setToTranslation(offset.getX(), offset.getY());
-...
     		trans.concatenate(translacion);
     		// 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
     		// 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;
     		try {
-...
     			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);
     			System.err.println("extent = " + extent.toString() + " imageSize= "
     					+ imageSize.toString());
     			throw new RuntimeException("Non invertible transform Exception", e);
+    		}
+    	}
     	/**
     	 * <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
+    	 *
     	 * <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)){
     		if (!offset.equals(p)) {
     			this.updateDrawVersion();
     			offset = p;
+    		}
+    	}
     	/**
     	 * <p>Gets the offset.</p>
     	 * <p>The offset is the position where start drawing the map.</p>
+    	 *
     	 * <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() {
-...
+    	}
     	/**
     	 * <p>Sets the background color.</p>
+    	 *
     	 * @param c the new background color
+    	 *
     	 * <p>
     	 * Sets the background color.
     	 * </p>
+    	 *
     	 * @param c
     	 *            the new background color
+    	 *
     	 * @see #getBackColor()
     	 */
     	public void setBackColor(Color c) {
     		if (!c.equals(this.backColor)){
     		if (!c.equals(this.backColor)) {
     			this.updateDrawVersion();
     			backColor = c;
     			callColorChanged(backColor);
-...
+    	}
     	/**
     	 * <p>Gets the background color.</p>
+    	 *
     	 * <p>
     	 * Gets the background color.
     	 * </p>
+    	 *
     	 * @return the background color of the view
+    	 *
+    	 *
     	 * @see #setBackColor(Color)
     	 */
     	public Color getBackColor() {
-...
+    	}
     	/**
     	 * <p>Returns the extent currently covered by the view adjusted (scaled) to the image size aspect.</p>
+    	 *
     	 * <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();
+    	}
     	/**
     	 * <p>Returns the envelope currently covered by the view adjusted (scaled) to the image size aspect.</p>
+    	 *
     	 * <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);
     		if (cliprect != null) {
     			Rectangle2D r = adjustedExtent.createIntersection(cliprect);
     			try {
     				return geomManager.createEnvelope(r.getX(),r.getY(),r.getMaxX(),r.getMaxY(), SUBTYPES.GEOM2D);
     				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);

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

Also available in: Unified diff