/trunk/libraries/libFMap/src/com/iver/cit/gvsig/fmap/ViewPort.java - Diff - Application: gvSIG desktop - gvSIG

Revision 20098 trunk/libraries/libFMap/src/com/iver/cit/gvsig/fmap/ViewPort.java

     /**
      * <p>The <code>ViewPort</code> class represents the information needed to transform an area of a map that user
      *  will use to work to the available area of a gvSIG's view in screen.</p>
+     *
      * <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 of a view in <i>screen coordinates</i>.</p>
+     *
      * <p>Then we have:
      *  <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.
      *  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.
      *  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 unit, for data in screen.
      * <li><i>mapUnits</i>: measurement unit, for data in map.
      * <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 view, where start drawing the map.
      * <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>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 is by international agreement. It is defined to be precisely
     	 * <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>
     	 * <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>
     	 */
-...
     	/**
     	 * <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();
     	/**
     	 * <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
-...
     	 * which returns the extent that contains this one but regarding the current
     	 * view's aspect ratio.
     	 * </p>
+    	 *
+    	 *
     	 * @see #getExtent()
     	 * @see #setExtent(Rectangle2D)
     	 */
     	protected Rectangle2D extent;
     	/**
     	 * <p>Location and dimensions of the extent adjusted to the image size.</p>
+    	 *
+    	 *
     	 * @see #getAdjustedExtent()
     	 */
     	protected Rectangle2D adjustedExtent;
     	/**
     	 * <p>History with the last extents of the view.</p>
+    	 *
+    	 *
     	 * @see #setPreviousExtent()
     	 * @see #getExtents()
     	 */
-...
     	/**
     	 * <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 real world coordinates equivalent to 3 pixels ({@link #dist3pixel dist3pixel}) .
     	 * </ul>
     	 * </p>
+    	 *
+    	 *
     	 * @see #getImageSize()
     	 * @see #getImageHeight()
     	 * @see #getImageWidth()
     	 * @see #setImageSize(Dimension)
     	 */
     	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>
+    	 *
+    	 *
     	 * @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>
+    	 *
+    	 *
     	 * @see #getDistanceUnits()
     	 * @see #setDistanceUnits(int)
     	 */
     	private int distanceUnits = METROS;
     	/**
     	 * <p>Measurement unit used by this view port for the map.</p>
+    	 *
+    	 *
     	 * @see #getMapUnits()
     	 * @see #setMapUnits(int)
     	 */
     	private int mapUnits = METROS;
     	/**
     	 * <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>
+    	 *
+    	 *
     	 * @see #getOffset()
     	 * @see #setOffset(Point2D)
     	 */
-...
     	/**
     	 * <p>Background color of this view.</p>
+    	 *
+    	 *
     	 * @see #getBackColor()
     	 * @see #setBackColor(Color)
     	 */
-...
     	/**
     	 * <p>Information about the map projection used in this view.</p>
+    	 *
+    	 *
     	 * @see #getProjection()
     	 * @see #setProjection(IProjection)
     	 */
-...
     	/**
     	 * <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)
     	 */
-...
     	/**
     	 * <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)
     	 */
-...
     	/**
     	 * <p>Clipping area.</p>
+    	 *
+    	 *
     	 * @see #setClipRect(Rectangle2D)
     	 */
     	private Rectangle2D cliprect;
     	/**
     	 * <p>Enables or disables the <i>"adjustable extent"</i> mode.</p>
+    	 *
+    	 *
     	 * <p>
     	 * When calculates the affine transform, if
     	 * <ul>
-...
     	 * <li><i>disabled</i>: the new <code>adjustedExtent</code> will be like <code>extent</code>.
     	 * </ul>
     	 * </p>
+    	 *
+    	 *
     	 * @see #setAdjustable(boolean)
     	 */
     	private boolean adjustableExtent=true;
-...
     	/**
     	 * <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) {
-...
     	/**
     	 * <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) {
-...
+    	}
     	/**
     	 * @see ArrayList#remove(Object)
+    	 *
      	 * <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> argument, that is in <i>map
     	 * <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
     	 */
-...
     		return (int) (d * pScreen.x);
+    	}
     	/**
     	 * Devuelve un punto en pixels a partir de una coordenada X e Y real.
     	 * <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 Coordenada X real.
     	 * @param y Coordenada Y real.
     	 * @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 Punto en pixels.
     	 * @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);
-...
     	 * @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)
     	 */
-...
     	 * @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)
     	 */
-...
     		return toMapPoint(pScreen);
+    	}
     	/**
     	 * <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)
-...
     		rect.setFrameFromDiagonal(p1,p2);
     		return rect;
+    	}
     	/**
     	 * <p>Converts and returns the distance <code>d</code> argument, that is in <i>screen
     	 * <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)
+    	 *
     	 * @return 2D point equivalent in <i>map coordinates</i>
+    	 *
+    	 *
     	 * @see #toMapPoint(int, int)
     	 * @see AffineTransform#createInverse()
     	 * @see AffineTransform#transform(Point2D, Point2D)
-...
     	 * @param pt2 another 2D point in <i>map coordinates</i>
+    	 *
     	 * @return the distance in meters between the two points 2D
+    	 *
+    	 *
     	 * @see GeoCalc#distanceVincenty(Point2D, Point2D)
     	 */
     	public double distanceWorld(Point2D pt1, Point2D pt2) {
-...
+    		}
     		return (dist*MapContext.CHANGEM[getMapUnits()]);
+    	}
     	/**
     	 * <p>Sets as extent and adjusted extent of this view port, the previous. Recalculating
     	 *  its parameters.</p>
+    	 *
+    	 *
     	 * @see #getExtents()
     	 * @see #calculateAffineTransform()
     	 */
-...
     	/**
     	 * <p>Gets the area selected by user using some tool.</p>
+    	 *
     	 * <p>When the zoom changes (for instance when using the <i>zoom in</i> or <i>zoom out</i> tools,
+    	 *
     	 * <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 #setExtent(Rectangle2D)
     	 * @see #getAdjustedExtent()
     	 * @see #setPreviousExtent()
-...
+    	}
     	/**
     	 * <p>Changes the extent and adjusted extent 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 to all {@link ViewPortListener ViewPortListener}s registered that the extent has changed.
     	 * <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()
-...
+    	}
     	/**
     	 * <p>Changes the extent and adjusted extent 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}s registered that the extent has changed.
     	 * <li>Notifies to all {@link ViewPortListener ViewPortListener} registered that the extent has changed.
     	 * </ul>
     	 * </p>
+    	 *
+    	 *
     	 * @see #setExtent(Rectangle2D)
     	 * @see #calculateAffineTransform()
     	 */
-...
     	 *  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() {
-...
     	/**
     	 * <p>Affine transformation between <i>map 2D coordinates</i> to <i>screen 2D coordinates</i> (pixels),
     	 * preserving the "straightness" and "parallelism" of lines.</p>
     	 * 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>
+    	 *
     	 * @return the image size
+    	 *
+    	 *
     	 * @see #setImageSize(Dimension)
     	 * @see #getImageHeight()
     	 * @see #getImageWidth()
-...
     	public Dimension getImageSize() {
     		return imageSize;
+    	}
     	/**
     	 * <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()
     	 */
-...
     	 *  has changed.</p>
+    	 *
     	 * @param newRect the new adjusted extend
+    	 *
+    	 *
     	 * @see #refreshExtent()
     	 * @see #setExtent(Rectangle2D)
     	 * @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
+    	 *
+    	 *
     	 * @see #setBackColor(Color)
     	 * @see ColorEvent
     	 * @see ViewPortListener
-...
     			listener.backColorChanged(ce);
+    		}
+    	}
     	/**
     	 * <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>
+    	 *
+    	 *
     	 * <ul>
     	 * <li>The new {@link #scale scale} .
     	 * <li>The new {@link #adjustedExtent adjustedExtent} .
-...
     	 * <li>The new real world coordinates equivalent to 3 pixels ({@link #dist3pixel dist3pixel}) .
     	 * </ul>
     	 * </p>
+    	 *
+    	 *
     	 * @see #getAffineTransform()
     	 * @see #setAffineTransform(AffineTransform)
     	 * @see #refreshExtent()
-...
     	/**
     	 * <p>Sets the offset.</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>
+    	 *
     	 * @param p 2D point that represents the offset in pixels
+    	 *
+    	 *
     	 * @see #getOffset()
     	 */
     	public void setOffset(Point2D p) {
     		offset = p;
+    	}
     	/**
     	 * <p>Gets the offset.</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>
+    	 *
     	 * @return 2D point that represents the offset in pixels
+    	 *
+    	 *
     	 * @see #setOffset(Point2D)
     	 */
     	public Point2D getOffset() {
     		return offset;
+    	}
     	/**
     	 * <p>Sets the background color for the view.</p>
     	 * <p>Sets the background color.</p>
+    	 *
     	 * @param c the new background color
+    	 *
+    	 *
     	 * @see #getBackColor()
     	 */
     	public void setBackColor(Color c) {
-...
+    	}
     	/**
     	 * <p>Gets the background color of this view.</p>
     	 * <p>Gets the background color.</p>
+    	 *
     	 * @return the background color of the view
+    	 *
+    	 *
     	 * @see #setBackColor(Color)
     	 */
     	public Color getBackColor() {
     		return backColor;
+    	}
     	/**
     	 * <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)
     	 */
     	public Rectangle2D getAdjustedExtent() {
-...
     	 * <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() {
-...
     	 * <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;
+    	}
     	/**
     	 * <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() {
-...
     	 * <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) {
-...
+    	}
     	/**
     	 * <p>Gets the size in <i>screen coordinates</i> of the rectangle where the image is displayed.</p>
     	 * <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 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;
+    	}
     	/**
     	 * <p>Sets the size in <i>screen coordinates</i> of the rectangle where the image is displayed.</p>
     	 * <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 real world coordinates equivalent to 3 pixels ({@link #dist3pixel dist3pixel}) .
     	 * </ul>
     	 * </p>
+    	 *
+    	 *
     	 * @see #getImageWidth()
     	 * @see #getImageSize()
     	 * @see #setImageSize(Dimension)
-...
+    	}
     	/**
     	 * <p>Gets the distance in <i>world coordinates</i> equivalent to 1 pixel in the view with the current extent.</p>
     	 * <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() {
-...
+    	}
     	/**
     	 * <p>Sets the distance in <i>world coordinates</i> equivalent to 1 pixel in the view with the current extent.</p>
     	 * <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) {
-...
+    	}
     	/**
     	 * <p>Gets the distance in <i>world coordinates</i> equivalent to 3 pixels in the view with the current extent.</p>
     	 * <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() {
-...
+    	}
     	/**
     	 * <p>Sets the distance in <i>world coordinates</i> equivalent to 3 pixels in the view with the current extent.</p>
     	 * <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) {
     		this.dist3pixel = dist3pixel;
+    	}
     	/**
     	 * <p>Returns the last previous extents of this view port.</p>
+    	 *
     	 * @return the last previous extents of this view port
+    	 *
+    	 *
     	 * @see #setPreviousExtent()
     	 */
     	public ExtentHistory getExtents() {
-...
     	 * <p>Gets the projection used in this view port.</p>
+    	 *
     	 * @return projection used in this view port
+    	 *
+    	 *
     	 * @see #setProjection(IProjection)
     	 */
     	public IProjection getProjection() {
-...
     	 * <p>Sets the projection to this view port.</p>
+    	 *
     	 * @param proj the new projection
+    	 *
+    	 *
     	 * @see #getProjection()
     	 */
     	public void setProjection(IProjection proj) {
-...
     	/**
     	 * <p>Sets only the affine transform to this view port, without updating dependent attributes.</p>
     	 * <p><b><i>This method can be problematic!</i></b></p>
     	 * <p><b><i>This method could be problematic!</i></b></p>
+    	 *
     	 * @param at the affine transform to set
+    	 *
+    	 *
     	 * @see #getAffineTransform()
     	 * @see #calculateAffineTransform()
     	 */
-...
     	 *  <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>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>
     	 *   </ul>
     	 *  <li>If defined, the background color:
     	 *   <ul>
     	 *   <li><i>backColor</i>: background color.
     	 *   </ul>
     	 *   </ul>
     	 *  <li>If defined, the clip:
     	 *   <ul>
     	 *   <li><i>clipX</i>: X coordinate of the clip.
     	 *   <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>
     	 *   </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>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.
     	 *   </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><i>offsetY</i>: Y coordinate of the offset.
     	 *  <li>If defined, the projection:
     	 *   <ul>
     	 *   <li><i>proj</i>: 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:
-...
     	 *  <li>XML entity of the internal {@link ExtentHistory ExtentHistory} .
     	 *  </ul>
     	 * </ul>
+    	 *
+    	 *
     	 * @return the XML entity
+    	 *
+    	 *
     	 * @see #createFromXML(XMLEntity)
     	 */
     	public XMLEntity getXMLEntity() {
-...
     	 * @param xml an XML entity
+    	 *
     	 * @return the new <code>ViewPort</code>
+    	 *
+    	 *
     	 * @see #getXMLEntity()
     	 * @see #createFromXML(XMLEntity)
     	 */
-...
     		vp.refreshExtent();
     		return vp;
+    	}
     	/**
     	 * <p>Creates a new <code>ViewPort</code> from an XML entity.</p>
+    	 *
     	 * @param xml an XML entity
+    	 *
     	 * @return the new <code>ViewPort</code>
+    	 *
+    	 *
     	 * @see #getXMLEntity()
     	 * @see #createFromXML03(XMLEntity)
     	 */
-...
     	/**
     	 * <p>Fast clone implementation: creates and returns a clone of this view port using XML entities.</p>
     	 * <p>Doesn't <i>deepclone</i> to avoid unnecessary memory consumption.</p>
     	 * <p>Isn't a <i>deepclone</i> to avoid unnecessary memory consumption.</p>
+    	 *
     	 * @return the new view port
+    	 *
+    	 *
     	 * @see #createFromXML(XMLEntity)
     	 */
     	public ViewPort cloneViewPort() {
     		return createFromXML(getXMLEntity());
+    	}
     	/**
     	 * <p>Returns a <code>string</code> representation of the main values of this view port: <code>{@linkplain #extent}</code>,
     	 * <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() {
-...
     	/**
     	 * <p>Sets the position and size of the clipping rectangle.</p>
+    	 *
+    	 *
     	 * @param rectView the clipping rectangle to set
     	 */
     	public void setClipRect(Rectangle2D rectView) {
     		cliprect=rectView;
+    	}
     	/**
     	 * <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());
-...
     		rect.setFrameFromDiagonal(p1,p2);
     		return rect;
+    	}
     	/**
     	 * <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 h1=extent.getHeight()*difw;
     		extent.setRect(-x1,-y1,w1,h1);
+    	}
+    }

Also available in: Unified diff