| gvSIG desktop 1

/**

 * <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

 * <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

 * <li><i>scale</i>: the scale between the adjusted extent and the image size.

 * <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.

 *  current extent.

 * <li><i>dist3pixel</i>: the distance in <i>world coordinates</i> equivalent to 3 pixels in the view with the

 *  current extent.

 * </ul>

 * </p>

 * @author Vicente Caballero Navarro

 */

public class ViewPort {

	public static int MILLAS = 4;

	/**

	 */

	public static int YARDAS = 5;

	/**

	 * <p>Screen resolution in <i>dots-per-inch</i>. Useful to calculate the geographic scale of the view.</p>

	 * @see Toolkit#getScreenResolution()

	 * @see #getScale()

	 */

	/**

	 * <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)

	 */

	/**

	 * <p>Location and dimensions of the extent adjusted to the image size.</p>

	 * @see #getAdjustedExtent()

	 */

	private 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()

	/**

	 * <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()

	/**

	 * <p>Measurement unit used for measuring distances and displaying information.</p>

	 * @see #getDistanceUnits()

	 * @see #setDistanceUnits(int)

	 */

	/**

	 * <p>Measurement unit used by this view port for the map.</p>

	 * @see #getMapUnits()

	 * @see #setMapUnits(int)

	 */

	/**

	 * <p>Array with the {@link ViewPortListener ViewPortListener}s registered to this view port.</p>

	 * @see #addViewPortListener(ViewPortListener)

	 * @see #removeViewPortListener(ViewPortListener)

	 */

	 * 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>Creates a new view port with the information of the projection in <code>proj</code> argument, and

	/**

	 * <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) {

	/**

 	 * <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) {

	 * @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

	 */

	 * @param d distance in pixels

	 *

	 * @return distance equivalent in <i>map coordinates</i>

	 * @see #fromMapDistance(double)

	 * @see AffineTransform

	 */

	 * <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)

		Point2D p1=fromMapPoint((int)r.getX(),(int)r.getY());

		return new Rectangle2D.Double(p1.getX(),p1.getY(),w,h);

	}

	/**

	 * <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)

		Point2D p1=toMapPoint((int)r.getX(),(int)r.getY());

		return new Rectangle2D.Double(p1.getX(),p1.getY(),w,h);

	}

	/**

	 * <p>Converts and returns the 2D point <code>(x,y)</code>, that is in <i>map

	 *  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)

	 */

	 * @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)

	 */

	 * <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)

	public Point2D toMapPoint(Point2D pScreen) {

		Point2D.Double pWorld = new Point2D.Double();

		AffineTransform at;

		try {

			at = trans.createInverse();

			at.transform(pScreen, pWorld);

		} catch (NoninvertibleTransformException e) {

			throw new RuntimeException(e);

		}

		return pWorld;

	}

	 * @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) {

	/**

	 * <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 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>

	 *

	 * @param r the new extent

	 * @see #getExtent()

	 * @see #getExtents()

	 * @see #calculateAffineTransform()

	 * <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>Recalculates the current <code>{@linkplain #extent}</code> using an scale. It's necessary execute {@linkplain #refreshExtent()} after.</p>

	 * @param s the scale to set

	 */

	public void setScale(long s){

		double x=extent.getX();

        double w1=extent.getWidth()*difw;

        double h1=extent.getHeight()*difw;

		extent.setRect(-x1,-y1,w1,h1);

	/**

	 * <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>

	 *

	 * @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

	 * @see #getImageSize()

	 * @see #calculateAffineTransform()

	 */

	 *  has changed.</p>

	 *

	 * @param newRect the new adjusted extend

	 * @see #refreshExtent()

	 * @see #setExtent(Rectangle2D)

	 * @see #setPreviousExtent()

	 *  has changed.</p>

	 *

	 * @param c the new background color

	 * @see #setBackColor(Color)

	 * @see ColorEvent

	 * @see ViewPortListener

	 *  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>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) {

	 * <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

	 * @see #getBackColor()

	 */

	public void setBackColor(Color c) {

	 * <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>

	 * @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() {

		return distanceUnits;

	}

	/**

	 * <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 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)

	/**

	 * <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)

	}

	/**

	 *

	 * @return the distance

	 * @see #setDist1pixel(double)

	 */

	public double getDist1pixel() {

	}

	/**

	 *

	 * @param dist1pixel the distance

	 * @see #getDist1pixel()

	 */

	public void setDist1pixel(double dist1pixel) {

	}

	/**

	 *

	 * @return the distance

	 * @see #setDist3pixel(double)

	 */

	public double getDist3pixel() {

	}

	/**

	 *

	 * @param dist3pixel the distance

	 * @see #getDist3pixel()

	 */

	public void setDist3pixel(double 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><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>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.

	 *  <li>If defined, the background color:

	 *   <ul>

	 *   <li><i>backColor</i>: background color.

	 *  <li>If defined, the clip:

	 *   <ul>

	 *   <li><i>clipY</i>: Y coordinate of clip.

	 *   <li><i>clipW</i>: width of the clip.

	 *   <li><i>clipH</i>: height of the clip.

	 *  <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>extentY</i>: Y coordinate of the extent.

	 *   <li><i>extentW</i>: width of the extent.

	 *   <li><i>extentH</i>: height of the extent.

	 *  <li><i>offsetX</i>: X coordinate of the offset.

	 *  <li>If defined, the projection:

	 *   <ul>

	 *   <li><i>proj</i>: the projection.

	 *  <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)

	 */

	 * @param xml an XML entity

	 *

	 * @return the new <code>ViewPort</code>

	 * @see #getXMLEntity()

	 * @see #createFromXML03(XMLEntity)

	 */

		vp.setDist1pixel(xml.getDoubleProperty("dist1pixel"));

		vp.setDist3pixel(xml.getDoubleProperty("dist3pixel"));

		vp.setDistanceUnits(xml.getIntProperty("distanceUnits"));

		vp.extents = ExtentHistory.createFromXML(xml.getChild(0));

		if (xml.contains("extentX")) {

	 * <p>Isn't a <i>deepclone</i> to avoid unnecessary memory consumption.</p>

	 *

	 * @return the new view port

	 * @see #createFromXML(XMLEntity)

	 */

	public ViewPort cloneViewPort() {

	/**

	 * <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() {

		String str;

		str = "Datos del viewPort:\nExtent=" + extent + "\nadjustedExtent=" +

			adjustedExtent + "\nimageSize=" + imageSize + "\nescale=" + scale +

	/**

	 * <p>Sets the position and size of the clipping rectangle.</p>

	 * @param rectView the clipping rectangle to set

	 */

	public void setClipRect(Rectangle2D rectView) {