Application: gvSIG desktop » gvSIG raster

/* 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.raster.georeferencing.swing.impl.layer;

import java.awt.Cursor;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.Point;

import java.awt.Toolkit;

import java.awt.event.MouseEvent;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.raster.georeferencing.swing.impl.view.CanvasZone;

import org.gvsig.raster.georeferencing.swing.model.GCPList;

import org.gvsig.raster.georeferencing.swing.view.GeoreferencingView;

import org.gvsig.raster.georeferencing.swing.view.IGraphicLayer;

import org.gvsig.raster.georeferencing.swing.view.ToolEvent;

import org.gvsig.raster.georeferencing.swing.view.ToolListener;

/**

 * Capa gr?fica que se dibuja sobre un ZoomControl y que dibuja 

 * una lista de puntos de control.

 * 22/12/2007

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class GCPsGraphicLayer implements IGraphicLayer {

        public boolean                  active          = true;

        //Operaciones sobre los puntos de control

        private static final int        NONE            = -1;

        private static final int        MOVE            = 0;

        private GCPList                 pointList       = null;

        private int                     type            = GPGraphic.MAP;

        private Image                   icoBlue         = null;

        private Image                   icoRed          = null;

        private CanvasZone              canvas          = null;

        private int                     operation       = NONE;

        //Punto de control sobre el que se realiza la operaci?n

        private GPGraphic               operanteGP      = null;

        private GPGraphic               lastGP          = null;

        //Listener para que objetos externos sean informados de las acciones de la capa

        private ToolListener            listener        = null;

        private boolean                 sleepActive     = false;

        private GeoreferencingView      view            = null;

        /**

         * Constructor. Asigna el tipo de punto a dibujar en la 

         * capa gr?fica.

         * @param type El valor de type viene definido por las constantes de GPGraphic

         * @param listener Listener para acciones de finalizaci?n de la operaci?n de mover punto

         */

        public GCPsGraphicLayer(int type, ToolListener listener, GCPList pointList) {

                this.type = type;

                this.pointList = pointList;

                this.listener = listener;

                try {

                        icoBlue = IconThemeHelper.getImage("crux_blue-icon"); 

                        icoRed = IconThemeHelper.getImage("crux_red-icon"); 

                } catch (NullPointerException e) {

                }

        }

        /**

         * Obtiene el identificador del punto requerido

         * @param pos Posici?n del punto en la capa

         * @return

         */

        public long getID(int pos) {

                try {

                        return ((GPGraphic)pointList.getGraphicPoint(pos)).getId();

                }catch (ArrayIndexOutOfBoundsException e) {

                        return -1;

                }

        }

        public void setGeoreferencingView(GeoreferencingView view) {

                this.view = view;

                this.canvas = (CanvasZone)view.getCanvas();

                canvas.addMouseMotionListener(this);

                canvas.addMouseListener(this);

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.rastertools.georeferencing.ui.zoom.IGraphicLayer#draw(java.awt.Graphics2D, org.gvsig.raster.datastruct.Extent, int, int)

         */

        public void draw(Graphics2D g, Rectangle2D ext, int w, int h) {

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

                        ((GPGraphic)pointList.getGraphicPoint(i)).draw(g, type, canvas);

        }

        /**

         * Asigna el flag que muestra u oculta la etiqueta del punto

         * @param showLabel true para mostrar la etiqueta y false para ocultarla

         */

        public void setShowLabel(boolean showLabel) {

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

                        ((GPGraphic)pointList.getGraphicPoint(i)).setShowLabel(showLabel);

        }

        /**

         * Asigna el flag que muestra u oculta el n?mero del punto

         * @param showLabel true para mostrar el punto y false para ocultarlo

         */

        /*public void setShowNumber(boolean showNumber) {

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

                        ((GPGraphic)pointList.getGraphicPoint(i)).setShowNumber(showNumber);

        }*/

        /**

         * Obtiene el punto de la posici?n indicada por el par?metro pos

         * @param pos Posici?n del punto

         * @return GPGraphic

         */

        public GPGraphic getPoint(int pos) {

                try {

                        return ((GPGraphic)pointList.getGraphicPoint(pos));

                } catch (IndexOutOfBoundsException e) {

                        return null;

                }

        }

        /**

         * Obtiene la lista de puntos

         * @return ArrayList

         */

        public GCPList getPointList() {

                return pointList;

        }

        /*

         * (non-Javadoc)

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

         */

        public void mouseClicked(MouseEvent e) {

        }

        /*

         * (non-Javadoc)

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

         */

        public void mouseEntered(MouseEvent e) {

        }

        /*

         * (non-Javadoc)

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

         */

        public void mouseExited(MouseEvent e) {

        }

        /*

         * (non-Javadoc)

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

         */

        public void mousePressed(MouseEvent e) {

        }

        /**

         * Cuando se suelta el bot?n del rat?n despu?s de haber arrastrado volvemos 

         * a dibujar el punto pero en la nueva ubicaci?n. Finalmente desactivamos la operaci?n de

         * mover punto y ponemos el punto sobre el que operamos a null.

         */

        public void mouseReleased(MouseEvent e) {

                if(!isActive() || getOperation() != MOVE)

                        return;

                operanteGP.setDraw(true);

                Point2D point = canvas.viewCoordsToWorld(e.getPoint());

                switch(type) {

                case GPGraphic.MAP: operanteGP.getGeoPoint().setMapPoint(point); break;

                case GPGraphic.PIXEL: operanteGP.getGeoPoint().setPixelPoint(point); break;

                }

                canvas.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));

                operanteGP = null;

                setOperation(NONE);

                if(listener != null)

                        listener.endAction(new ToolEvent(this, view));

        }

        /*

         * (non-Javadoc)

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

         */

        public void mouseDragged(MouseEvent e) {

                if(!isActive())

                        return;

                if(getOperation() == MOVE) {

                        operanteGP.setDraw(false);

                        if(type == GPGraphic.PIXEL && icoRed != null) 

                                canvas.setCursor(Toolkit.getDefaultToolkit().createCustomCursor(icoRed, new Point(16, 16), ""));

                        if(type == GPGraphic.MAP && icoBlue != null)

                                canvas.setCursor(Toolkit.getDefaultToolkit().createCustomCursor(icoBlue, new Point(16, 16), ""));                        

                }

        }

        /*

         * (non-Javadoc)

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

         */

        public void mouseMoved(MouseEvent e) {

                if(!isActive())

                        return;

                setOperation(NONE);

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

                        GPGraphic gp = ((GPGraphic)pointList.getGraphicPoint(i));

                        int pxLeft = 0, pxRight = 0, pyUp = 0, pyDown = 0;

                        Point2D p1 = null;

                        if(type == GPGraphic.PIXEL) {

                                p1 = gp.getGeoPoint().getPixelPoint();

                        }

                        if(type == GPGraphic.MAP) {

                                p1 = gp.getGeoPoint().getMapPoint();

                        }

                        if(p1 == null)

                                return;

                        p1 = canvas.viewCoordsFromWorld(p1);

                        pxLeft = (int)p1.getX() - 4;

                        pxRight = (int)p1.getX() + 4;

                        pyUp = (int)p1.getY() - 4;

                        pyDown = (int)p1.getY() + 4;

                        if(e.getX() >= pxLeft && e.getX() <= pxRight && e.getY() >= pyUp && e.getY() <= pyDown) {

                                lastGP = operanteGP = gp;

                                getPointList().setSelectedPoint(i);

                                setOperation(MOVE);

                        }                         

                }

        }

        /**

         * Obtiene la operaci?n sobre el cursor que hay seleccionada

         * @return Entero que representa a la operaci?n

         */

        private int getOperation() {

                return operation;

        }

        /**

         * Asigna la operaci?n sobre el cursor que hay seleccionada

         * @param op

         */

        private void setOperation(int op) {

                operation = op;

                if(op == NONE) 

                        listener.offTool(new ToolEvent(this, view));

                else 

                        listener.onTool(new ToolEvent(this, view));

        }

        /**

         * Consulta si est? activo el evento de pinchado y arrastrado de los puntos de 

         * control.

         * @return

         */

        public boolean isActive() {

                return active;

        }

        /**

         * Asigna el flag que activa y desactiva el evento de pinchado y arrastrado 

         * de los puntos de control. 

         * @param activeEvent

         */

        public void setActive(boolean active) {

                this.active = active;

        }

        /**

         * Desactiva la herramienta temporalmente. Guarda el estado en el que estaba

         * para restaurarlo cuando se invoque a awake

         */

        public void sleep() {

                sleepActive = active;

                active = false;

        }

        /**

         * Recupera el estado de activaci?n que ten?a antes de la ?ltima invocaci?n 

         * de sleep

         */

        public void awake() {

                active = sleepActive;

        }

        /**

         * Obtiene el ?ltimo punto arrastrado

         * @return GPGraphic

         */

        public GPGraphic getLastPoint() {

                return lastGP;

        }

}