| gvSIG desktop 1

/* Generated by Together */

package com.iver.cit.gvsig.fmap;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Point;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.util.ArrayList;

import org.cresques.cts.IProjection;

public class ViewPort {        

        public static int KILOMETROS = 1;

        public static int METROS = 2;

        public static int MILLAS = 3;

        public static int YARDAS = 4;

        public static int PIES = 5;

        public static int PULGADAS = 6;

        /**

         * Resoluci?n (Puntos por pulgada) de la vista actual.

         * Se necesita para los c?lculos de escala geogr?fica.

         */

        private static int dpi = java.awt.Toolkit.getDefaultToolkit().getScreenResolution();

    private Rectangle2D extent;

    private Rectangle2D adjustedExtent;

    private ExtentHistory extents = new ExtentHistory();

    private Dimension imageSize;

    private AffineTransform trans = new AffineTransform();

        private int distanceUnits = METROS;

        private int mapUnits = METROS;

    private ArrayList extentListeners=new ArrayList();

    private Point2D offset = new Point2D.Double(0, 0);

    private Rectangle2D clip;

        private Color backColor = Color.WHITE;

        private IProjection proj;

    private double dist1pixel;

    private double dist3pixel;

        private double scale;

        public boolean addExtentListener(ExtentListener arg0) {

                return extentListeners.add(arg0);

        }

        public boolean removeExtentListener(ExtentListener arg0) {

                return extentListeners.remove(arg0);

        }

    public int fromMapDistance(double d) {

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

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

        double nuevoX;

        double nuevoY;

        double cX;

        double cY;

        try {

            trans.deltaTransform(pWorld, pScreen);

        } catch (Exception e) {

            System.err.print(e.getMessage());

        }

        return (int) (d * pScreen.x);

    }

    public Point2D fromMapPoint(double x, double y) {

        Point2D.Double pWorld = new Point2D.Double(x, y);

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

        double nuevoX;

        double nuevoY;

        double cX;

        double cY;

        try {

            trans.transform(pWorld, pScreen);

        } catch (Exception e) {

            System.err.print(e.getMessage());

        }

        return pScreen;

    }

    public Point2D toMapPoint(int x, int y) {

            Point pScreen = new Point(x, y);

            return toMapPoint(pScreen);

    }

    public double toMapDistance(int d) {

             double dist = d / trans.getScaleX(); 

         return dist;

    }

    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;

    }

    public void setPreviousExtent() {

    }

    public Rectangle2D getExtent() {

            return extent;

    }

    public void setExtent(Rectangle2D r) {

            //Esto comprueba que el extent no es de anchura o altura = "0" 

            //y si es as? lo redimensiona.

            if (r.getWidth()==0 || r.getHeight()==0){

                    extent=new Rectangle2D.Double(r.getMinX()-0.1,r.getMinY()-0.1,r.getWidth()+0.2,r.getHeight()+0.2);

            }else{

            extent = r;

            }

            //TODO calcular la escala sin usar setScale

            //Calcula la transformaci?n af?n

            calculateAffineTransform();

    }

    public void setScale(double scale) {

            this.scale = scale;

            //TODO calcular el extent sin usar setExtent

            //Calcula la transformaci?n af?n

            calculateAffineTransform();

    }

    /**

     * Devuelve la escala. Debe estar siempre actualizada y

     * no calcularse nunca aqu? pues se utiliza en el dibujado

     * para cada geometr?a

     * @return

     */

    public double getScale() {

            return proj.getScale(extent.getMinX(), extent.getMaxX(), imageSize.getWidth(), dpi);

    }

        /**

         * @return

         */

        public AffineTransform getAffineTransform() {

                return trans;

        }

        /**

         * @return Returns the imageSize.

         */

        public Dimension getImageSize() {

                return imageSize;

        }

        /**

         * @param imageSize The imageSize to set.

         */

        public void setImageSize(Dimension imageSize) {

                this.imageSize = imageSize;

                calculateAffineTransform();

        }

        /**

         * 

         */

        private void calculateAffineTransform() {

                if ((imageSize == null) || (extent == null)) return;

        AffineTransform escalado = new AffineTransform();

        AffineTransform translacion = new AffineTransform();

        double escalaX;

        double escalaY;

        escalaX = imageSize.getWidth() / extent.getWidth();

        escalaY = imageSize.getHeight() / extent.getHeight();

        adjustedExtent = new Rectangle2D.Double();

        if (escalaX < escalaY) {

            scale = escalaX;

            adjustedExtent.setRect(extent.getX(), extent.getY(), extent.getWidth(), imageSize.getHeight() / scale);

        } else {

            scale = escalaY;

            adjustedExtent.setRect(extent.getX(), extent.getY(), imageSize.getWidth() / scale, extent.getHeight());

        }

        translacion.setToTranslation(-adjustedExtent.getX(), -adjustedExtent.getY() -

                        adjustedExtent.getHeight());

        escalado.setToScale(scale, -scale);

        AffineTransform offsetTrans = new AffineTransform();

        offsetTrans.setToTranslation(offset.getX(), offset.getY());

        trans.setToIdentity();

        trans.concatenate(offsetTrans);

        trans.concatenate(escalado);

        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

        AffineTransform at;

                try {

                        at = trans.createInverse();

                        java.awt.Point pPixel = new java.awt.Point(1, 1);

                Point2D.Float pProv = new Point2D.Float();

                at.deltaTransform(pPixel, pProv);

                dist1pixel = pProv.x;

                dist3pixel = 3 * pProv.x;

                } catch (NoninvertibleTransformException e) {

                        e.printStackTrace();

                }

        }

        public void setOffset(Point2D p){

                offset=p;

        }

        public void setBackColor(Color c) {

                backColor = c;

        }

        public Color getBackColor() {

                return backColor;

        }

        /**

         * @return Returns the adjustedExtent.

         */

        public Rectangle2D getAdjustedExtent() {

                return adjustedExtent;

        }

        /**

         * @return Returns the distanceUnits.

         */

        public int getDistanceUnits() {

                return distanceUnits;

        }

        /**

         * @param distanceUnits The distanceUnits to set.

         */

        public void setDistanceUnits(int distanceUnits) {

                this.distanceUnits = distanceUnits;

        }

        /**

         * @return Returns the mapUnits.

         */

        public int getMapUnits() {

                return mapUnits;

        }

        /**

         * @param mapUnits The mapUnits to set.

         */

        public void setMapUnits(int mapUnits) {

                this.mapUnits = mapUnits;

        }        

        public int getImageWidth(){

                return imageSize.width;

        }

        public int getImageHeight(){

                return imageSize.height;

        }

        public double getDist1pixel() {

                return dist1pixel;

        }

        public void setDist1pixel(double dist1pixel) {

                this.dist1pixel = dist1pixel;

        }

        public double getDist3pixel() {

                return dist3pixel;

        }

        public void setDist3pixel(double dist3pixel) {

                this.dist3pixel = dist3pixel;

        }

        /**

         * @return Returns the extents.

         */

        public ExtentHistory getExtents() {

                return extents;

        }

        /**

         * 

         */

        public void setExtentPrev() {

                setExtent(extents.removePrev());

        }

        /**

         * @return Returns the proj.

         */

        public IProjection getProjection() {

                return proj;

        }

        /**

         * @param proj The proj to set.

         */

        public void setProjection(IProjection proj) {

                this.proj = proj;

        }

}