Application: gvSIG desktop » gvSIG Document Layout

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.app.project.documents.layout;

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 java.util.List;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.app.project.documents.Document;

import org.gvsig.app.project.documents.layout.fframes.FFrameView;

import org.gvsig.app.project.documents.layout.fframes.IFFrame;

import org.gvsig.app.project.documents.layout.fframes.IFFrameUseFMap;

import org.gvsig.app.project.documents.view.ViewDocument;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.FLayers;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

/**

 * Clase que recoge m?todos est?ticos sobre el Layout.

 * 

 * @author Vicente Caballero Navarro

 */

public class FLayoutUtilities {

    private static Logger logger = LoggerFactory.getLogger(

        FLayoutUtilities.class);

    /**

     * Devuelve true si las dos ArrayList que se le pasan como parametro son

     * iguales.

     * 

     * @param n

     *            lista anterior

     * @param l

     *            lista actual

     * 

     * @return true si los ArrayList son iguales.

     */

    public static boolean isEqualList(ArrayList n, ArrayList l) {

        if (n.size() != l.size()) {

            return false;

        }

        for (int i = 0; i < n.size(); i++) {

            if (l.get(i) != n.get(i)) {

                return false;

            }

        }

        return true;

    }

    /**

     * Pasa una distancia en pixels a unidades del folio.

     * 

     * @param d

     *            distancia en pixels.

     * @param at

     *            Matriz de transformaci?n.

     * 

     * @return distancia en unidades de folio.

     */

    public static double toSheetDistance(double d, AffineTransform at) {

        double dist = d / at.getScaleX(); // pProv.x;

        return dist;

    }

    /**

     * Pasa una distancia de coordenadas del folio a pixels.

     * 

     * @param d

     *            distancia en coordenadas de folio.

     * @param at

     *            Matriz de transformaci?n.

     * 

     * @return double en pixels.

     */

    public static double fromSheetDistance(double d, AffineTransform at) {

        Point2D.Double pSheet1 = new Point2D.Double(0, 0);

        Point2D.Double pSheet2 = new Point2D.Double(1, 0);

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

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

        try {

            at.transform(pSheet1, pScreen1);

            at.transform(pSheet2, pScreen2);

        } catch (Exception e) {

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

        }

        return pScreen1.distance(pScreen2) * d;

    }

    /**

     * Pasa un punto en pixels a coordenadas del folio.

     * 

     * @param pScreen

     *            pixels.

     * @param at

     *            Matriz de transformaci?n.

     * 

     * @return Point2D en coordenadas de folio.

     */

    public static Point2D.Double toSheetPoint(Point2D pScreen,

        AffineTransform at) {

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

        AffineTransform at1;

        try {

            at1 = at.createInverse();

            at1.transform(pScreen, pWorld);

        } catch (NoninvertibleTransformException e) {

        }

        return pWorld;

    }

    /**

     * Pasa un ret?ngulo de pixels a coordenadas del folio.

     * 

     * @param r

     *            rect?ngulo en coordenadas de pixels a coordenadas de folio.

     * @param at

     *            Matriz de transformaci?n.

     * 

     * @return Rectangle2D en coordenadas de folio.

     */

    public static Rectangle2D.Double toSheetRect(Rectangle2D r,

        AffineTransform at) {

        Point2D.Double pSheet =

            toSheetPoint(new Point2D.Double(r.getX(), r.getY()), at);

        Point2D.Double pSheetX =

            toSheetPoint(new Point2D.Double(r.getMaxX(), r.getMinY()), at);

        Point2D.Double pSheetY =

            toSheetPoint(new Point2D.Double(r.getMinX(), r.getMaxY()), at);

        Rectangle2D.Double res = new Rectangle2D.Double();

        res.setRect(pSheet.getX(), pSheet.getY(), pSheet.distance(pSheetX),

            pSheet.distance(pSheetY));

        return res;

    }

    /**

     * Pasa de un punto en coordenadas del folio a pixels.

     * 

     * @param pSheet

     *            punto en coordenadas de folio.

     * @param at

     *            Matriz de transformaci?n.

     * 

     * @return Point2D en pixels.

     */

    public static Point2D.Double fromSheetPoint(Point2D pSheet,

        AffineTransform at) {

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

        try {

            at.transform(pSheet, pScreen);

        } catch (Exception e) {

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

        }

        return pScreen;

    }

    /**

     * Pasa un rect?ngulo en coordenadas del folio a pixels.

     * 

     * @param r

     *            rect?ngulo en coordenadas de folio.

     * @param at

     *            Matriz de transformaci?n.

     * 

     * @return Rectangle2D en pixels.

     */

    public static Rectangle2D.Double fromSheetRect(Rectangle2D r,

        AffineTransform at) {

        Point2D.Double pSheet = new Point2D.Double(r.getX(), r.getY());

        Point2D.Double pSX = new Point2D.Double(r.getMaxX(), r.getMinY());

        Point2D.Double pSY = new Point2D.Double(r.getMinX(), r.getMaxY());

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

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

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

        try {

            at.transform(pSheet, pScreen);

            at.transform(pSX, pScreenX);

            at.transform(pSY, pScreenY);

        } catch (Exception e) {

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

        }

        Rectangle2D.Double res = new Rectangle2D.Double();

        res.setRect(pScreen.getX(), pScreen.getY(), pScreen.distance(pScreenX),

            pScreen.distance(pScreenY));

        return res;

    }

    /**

     * Obtiene el punto ajustado al grid del layout.

     * 

     * @param p

     *            Punto a ajustar.

     * @param distX

     *            Distancia m?nima en cm de X.

     * @param distY

     *            Distancia m?nima en cm de Y.

     * @param at

     *            Matriz de transformaci?n.

     */

    public static Point getPointGrid(Point p, double distX, double distY,

        AffineTransform at) {

        if (distX * at.getScaleX() < 2 && distY * at.getScaleY() < 2) {

            /*

             * In this case, it makes no sense to care about snapping

             * because snapping would mean to move the position by one pixel

             */

            return p;

        }

        Point2D.Double auxp =

            FLayoutUtilities.fromSheetPoint(new Point2D.Double(0, 0), at);

        double gridintx = distX * at.getScaleX();

        double gridinty = distY * at.getScaleY();

        double seppx = p.x - Math.round(auxp.x);

        double seppy = p.y - Math.round(auxp.y);

        long round_int_p_x = Math.round(seppx / gridintx);

        long round_int_p_y = Math.round(seppy / gridinty);

        // Rounded

        seppx = round_int_p_x * gridintx;

        seppy = round_int_p_y * gridinty;

        return new Point(

            (int) (auxp.x + seppx),

            (int) (auxp.y + seppy));

    }

    /**

     * Cuando se dibuja sobre el graphics todo se tiene que situar en enteros y

     * aqu? lo que se comprueba es que si los valores que contiene el

     * Rectangle2D, que toma como par?metro, supera los valores soportados por

     * un entero.

     * 

     * @param r

     *            Rectangle2D a comprobar si los valores que contiene no superan

     *            a los que puede tener un entero.

     * 

     * @return true si no se han superado los l?mites.

     */

    public static boolean isPosible(Rectangle2D.Double r) {

        if ((r.getMaxX() > Integer.MAX_VALUE)

            || (r.getMaxY() > Integer.MAX_VALUE)

            || (r.getMinX() < Integer.MIN_VALUE)

            || (r.getMinY() < Integer.MIN_VALUE)

            || (r.getWidth() > Integer.MAX_VALUE)

            || (r.getHeight() > Integer.MAX_VALUE)) {

            return false;

        }

        return true;

    }

    /**

     * Devuelve un long representando a la escala en funci?n de que unidad de

     * medida se pase como par?metro.

     * 

     * @param map

     *            FMap

     * @param h

     *            Rect?ngulo.

     * 

     * @return escala.

     */

    public static long getScaleView(

        ViewPort viewPort,

        double wcm,

        double wpixels) {

        double dpi = (2.54*wpixels) / wcm;

        IProjection proj = viewPort.getProjection();

        if (viewPort.getAdjustedEnvelope() == null) {

            return 0;

        }

        if (proj == null || viewPort.getImageSize() == null) {

            return (long) (viewPort.getAdjustedEnvelope().getLength(1)

                / wcm * Attributes.CHANGE[viewPort.getMapUnits()]);

        }

        double[] trans2Meter = MapContext.getDistanceTrans2Meter();

        int mUnits = viewPort.getMapUnits();

        return (long) proj.getScale(

            viewPort.getAdjustedEnvelope().getMinimum(0) * trans2Meter[mUnits],

            viewPort.getAdjustedEnvelope().getMaximum(0) * trans2Meter[mUnits],

            wpixels, dpi);

    }

    public static List<Document> removeEditing(List<Document> list) {

        List<Document> resp = new ArrayList<Document>();

        Document item = null;

        ViewDocument viewdoc = null;

        for (int i=0; i<list.size(); i++) {

            item = list.get(i);

            if (item instanceof ViewDocument) {

                viewdoc = (ViewDocument) item;

                if (!hasEditingLayers(viewdoc)) {

                    resp.add(item);

                }

            }

        }

        return resp;

    }

    public static boolean hasEditingLayers(ViewDocument viewdoc) {

        return hasEditingLayers(viewdoc.getMapContext().getLayers());

    }

    /**

     * Recursively find out if any layer is in editing mode

     * 

     * @param lyrs

     * @return

     */

    public static boolean hasEditingLayers(FLayers lyrs) {

        int len = lyrs.getLayersCount();

        FLayer lyr = null;

        FLyrVect vlyr = null;

        for (int i=0; i<len; i++) {

            lyr = lyrs.getLayer(i);

            if (lyr instanceof FLyrVect) {

                vlyr = (FLyrVect) lyr;

                if (vlyr.isEditing()) {

                    return true;

                }

            } else {

                if (lyr instanceof FLayers) {

                    if (hasEditingLayers((FLayers) lyr)) {

                        return true;

                    }

                }

            }

        }

        return false;

    }    

    public static Point2D screenCoordinatesToViewportImageCoordinates(

        Point2D screenp, IFFrame frame) {

        if (screenp == null || frame == null || !(frame instanceof IFFrameUseFMap)) {

            logger.info("Bad parameters in screenCoordinatesToViewportImageCoordinates",

                new Exception("Null values or Frame has no MapContext"));

            return screenp;

        }

        Rectangle2D.Double rect = frame.getBoundingBox(null);

        double screenRectWidth = rect.width;

        double vpWidth = ((IFFrameUseFMap) frame).getMapContext().getViewPort().getImageWidth();

        if (screenRectWidth < 1 || vpWidth < 1) {

            logger.info("Bad size in screen/viewport ("

                + "screenRectWidth = " + screenRectWidth + ", "

                + "vpWidth = " + vpWidth + ")");

            return screenp;

        }

        /*

         * Get coordinates in the rectangle (remove offset)

         */

        Point2D po = new Point2D.Double(

            screenp.getX() - rect.x, screenp.getY() - rect.y);

        double ratio = (vpWidth * 1d) / (screenRectWidth * 1d);

        Point2D resp = new Point2D.Double(ratio * po.getX(), ratio * po.getY());

        return resp;

    }

}