Application: gvSIG desktop

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package com.iver.cit.gvsig.gui.layout;

import java.awt.Color;

import java.awt.Graphics;

import java.awt.Point;

import java.awt.event.MouseEvent;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.IOException;

import com.iver.cit.gvsig.fmap.core.FGeometry;

import com.iver.cit.gvsig.fmap.core.Handler;

import com.iver.cit.gvsig.fmap.core.IGeometry;

import com.iver.cit.gvsig.fmap.drivers.DriverIOException;

import com.iver.cit.gvsig.fmap.layers.SelectionSupport;

import com.iver.cit.gvsig.fmap.tools.BehaviorException;

import com.iver.cit.gvsig.gui.cad.CADToolAdapter;

import com.iver.cit.gvsig.gui.cad.tools.SelectionCadTool;

/**

 * DOCUMENT ME!

 *

 * @author Vicente Caballero Navarro

 */

public class LayoutCADToolAdapter extends CADToolAdapter {

        private Layout layout;

        //private Point adjustedPoint;

        //private boolean adjustSnapping=false;

        //private Point2D mapAdjustedPoint;

        /**

         *

         */

        public LayoutCADToolAdapter(Layout l) {

                layout = l;

        }

        /**

         * @see java.awt.event.MouseListener#mousePressed(java.awt.event.MouseEvent)

         */

/*        public void mousePressed(MouseEvent e) throws BehaviorException {

                if (e.getButton() == MouseEvent.BUTTON1) {

                        Point2D.Double aux = new Point2D.Double(e.getX(), e.getY());

                        Point2D p = FLayoutUtilities.toSheetPoint(aux, layout.getAT());

                        this.transition("punto", getEditableFeatureSource(),getSelection(),

                                new double[] { p.getX(), p.getY() });

                }

        }

        */

        public AffineTransform getAT(){

                return layout.getAT();

        }

        public double toDistance(int i){

                return FLayoutUtilities.toSheetDistance(i,getAT());

        }

        public void refresh(){

                layout.refresh();

        }

        public void paintComponent(Graphics g){

                if (layout.getTool()==Layout.GRAPHICS) {

                        getCadTool().setAT(getAT());

                        Point2D.Double paux=new Point2D.Double(adjustedPoint.getX(),adjustedPoint.getY());

                        paux=FLayoutUtilities.toSheetPoint(paux,getAT());

                        getCadTool().drawOperation(g, null, null,

                                paux.getX(),paux.getY());

                        //drawCursor(g);

                }

                //grid.drawGrid(g);

        }

        /**

         * DOCUMENT ME!

         *

         * @param point

         */

/*        private void calculateSnapPoint(Point point) {

                //Se comprueba el ajuste a rejilla

                Point gridAdjustedPoint = (Point) point.clone();

                double minDistance = grid.adjustToGrid(gridAdjustedPoint);

                if (minDistance < Double.MAX_VALUE) {

                        adjustedPoint = gridAdjustedPoint;

                        mapAdjustedPoint = toPoint(adjustedPoint);

                }

                //Se comprueba el ajuste a los handlers

                Point handlerAdjustedPoint = (Point) point.clone();

                Point2D mapPoint = new Point2D.Double();

                double distance = adjustToHandler(handlerAdjustedPoint, mapPoint);

                if (distance < minDistance) {

                        adjustSnapping=true;

                        adjustedPoint = handlerAdjustedPoint;

                        mapAdjustedPoint = mapPoint;

                        minDistance = distance;

                }

                //Si no hay ajuste

                if (minDistance == Double.MAX_VALUE) {

                        adjustedPoint = point;

                        mapAdjustedPoint = null;

                }

        }

*/

        /**

         * Ajusta un punto de la imagen que se pasa como  par?metro al grid si ?ste

         * est? activo y devuelve la distancia de un punto al punto ajustado

         *

         * @param point

         *

         * @return Distancia del punto que se pasa como par?metro al punto ajustado

         */

/*        private double adjustToHandler(Point point, Point2D mapHandlerAdjustedPoint) {

                //if (selection.cardinality() > 0) {

                        try {

                                Point2D mapPoint = toPoint(point);

                                Rectangle2D r = new Rectangle2D.Double(mapPoint.getX() - 1,

                                                mapPoint.getY() - 1, 2, 2);

                                int[] indexes = getEditableFeatureSource().getGeometriesIndexes(r);

                                double min = Double.MAX_VALUE;

                                Point2D argmin = null;

                                Point2D mapArgmin = null;

                                for (int i = 0; i < indexes.length; i++) {

                                        //if (!selection.get(indexes[i])) continue;

                                        IGeometry geom;

                                        geom = getEditableFeatureSource().getGeometry(indexes[i]);

                                        Handler[] handlers = geom.getHandlers(FGeometry.STRETCHINGHANDLER);

                                        for (int j = 0; j < handlers.length; j++) {

                                                Point2D handlerPoint = handlers[j].getPoint();

                                                Point2D handlerImagePoint = fromPoint(handlerPoint);

                                                double dist = handlerImagePoint.distance(point);

                                                if ((dist < SelectionCadTool.tolerance) &&

                                                                (dist < min)) {

                                                        min = dist;

                                                        argmin = handlerImagePoint;

                                                        mapArgmin = handlerPoint;

                                                }

                                        }

                                }

                                if (argmin != null) {

                                        point.setLocation(argmin);

                                        //Se hace el casting porque no se quiere redondeo

                                        point.setLocation((int)argmin.getX(),

                                                        (int) argmin.getY());

                                        mapHandlerAdjustedPoint.setLocation(mapArgmin);

                                        return min;

                                }

                        } catch (IOException e) {

                                e.printStackTrace();

                        } catch (DriverIOException e) {

                                e.printStackTrace();

                        }

                //}

                return Double.MAX_VALUE;

        }

*/

        /**

         * DOCUMENT ME!

         *

         * @param g DOCUMENT ME!

         */

/*        private void drawCursor(Graphics g) {

                Point p = adjustedPoint;

                if (p==null) grid.setAT(getAT());

                int size1 = 15;

                int size2 = 3;

                g.drawLine((int) (p.getX() - size1), (int) (p.getY()),

                        (int) (p.getX() + size1), (int) (p.getY()));

                g.drawLine((int) (p.getX()), (int) (p.getY() - size1),

                        (int) (p.getX()), (int) (p.getY() + size1));

                if (adjustedPoint!=null){

                        if (adjustSnapping){

                                g.setColor(Color.ORANGE);

                                g.drawRect((int)(adjustedPoint.getX()-5),(int)(adjustedPoint.getY()-5),10,10);

                                g.drawRect((int)(adjustedPoint.getX()-3),(int)(adjustedPoint.getY()-3),6,6);

                                g.setColor(Color.MAGENTA);

                                g.drawRect((int)(adjustedPoint.getX()-4),(int)(adjustedPoint.getY()-4),8,8);

                                adjustSnapping=false;

                        }else{

                                g.drawRect((int) (p.getX() - size2), (int) (p.getY() - size2),

                                                (int) (size2 * 2), (int) (size2 * 2));

                        }

                }

        }

        */

        public Point2D toPoint(Point2D p){

                return FLayoutUtilities.toSheetPoint(p,getAT());

        }

        public Rectangle2D getExtent(){

                return FLayoutUtilities.toSheetRect(layout.getRect(),getAT());

        }

        public double fromDistance(double d){

                return FLayoutUtilities.fromSheetDistance(d,getAT());

        }

        public Point2D fromPoint(Point2D p){

                return FLayoutUtilities.fromSheetPoint(p,getAT());

        }

        /**

         * @see java.awt.event.MouseMotionListener#mouseMoved(java.awt.event.MouseEvent)

         */

        public void mouseMoved(MouseEvent e) throws BehaviorException {

                calculateSnapPoint(e.getPoint());

        }

        public Point2D getAdjustedPoint(){

                return adjustedPoint;

        }

        public void drawGrid(Graphics g){

                grid.drawGrid(g);

        }

        /**

         * DOCUMENT ME!

         *

         * @param value DOCUMENT ME!

         */

        public void setGrid(boolean value) {

                grid.setUseGrid(value);

                grid.setAT(getAT());

        }

}