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.Color;

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.Rectangle2D;

import org.gvsig.andami.IconThemeHelper;

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

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 una vista de zoom un cursor

 * rectangular que representa una ventanta de zoom sobre la vista

 * 22/12/2007

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

 */

public class ZoomCursorGraphicLayer implements IGraphicLayer {

        //Operaciones sobre el cursor gr?fico

        private static final int    NONE             = -1;

        private static final int    REDIM_LEFT       = 0;

        private static final int    REDIM_RIGHT      = 1;

        private static final int    REDIM_UP         = 2;

        private static final int    REDIM_DOWN       = 3;

        private static final int    MOVE_UR          = 4;

        private static final int    MOVE_UL          = 5;

        private static final int    MOVE_LR          = 6;

        private static final int    MOVE_LL          = 7;

        private final int           MIN_CURSOR_SIZE  = 10;

        private int                 operation        = NONE; 

        private int                 wCursor          = 0;

        private int                 hCursor          = 0;

        private int                 posX             = 0;

        private int                 posY             = 0;

        private Image               iconHoriz        = null;

        private Image               iconVert         = null;

        private Image               iconMove         = null;

        private CanvasZone          canvas           = null;

        //Memoria temporal de las posiciones en X y en Y previas a una operaci?n

        private int                 prevX, prevY;

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

        private ToolListener        listener         = null;

        private boolean             active           = true;

        private boolean             sleepActive      = true;

    private Color               cursorColor      = Color.RED;

    private boolean             initSize         = true;

    private int                 initWCursor      = 0;

        private int                 initHCursor      = 0;

        private GeoreferencingView  view             = null;

        /**

         * Constructor. Asigna el ancho y alto del rectangulo del cursor y la

         * posici?n en la inicializaci?n.

         * @param pX Posici?n en X del cursor en la vista

         * @param pY Posici?n en Y del cursor en la vista

         * @param w Ancho del cursor en la vista

         * @param h Alto del cursor en la vista

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

         */

        public ZoomCursorGraphicLayer(int pX, int pY, int w, int h, ToolListener listener) {

                wCursor = w;

                hCursor = h;

                posX = pX;

                posY = pY;

                this.listener = listener;

                try {

                        iconHoriz = IconThemeHelper.getImage("arrow_horiz-icon"); 

                        iconVert = IconThemeHelper.getImage("arrow_vert-icon");

                        iconMove = IconThemeHelper.getImage("arrow_move-icon");

                } catch (NullPointerException e) {

                }

        }

        public void setGeoreferencingView(GeoreferencingView view) {

                this.view = view;

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

                canvas.addMouseMotionListener(this);

                canvas.addMouseListener(this);

        }

        /**

         * Asigna la posici?n del cursor en el canvas

         * @param x Posici?n en X

         * @param y Posici?n en Y

         */

        public void setCursorPosition(int x, int y) {

                this.posX = x;

                this.posY = y;

        }

        /**

         * Asigna el tama?o del cursor en pixeles del canvas

         * @param w Ancho

         * @param h Alto

         */

        public void setCursorSize(int w, int h) {

                //Salva la primera vez como tama?o de inicializaci?n

                if(initSize) {

                        this.initWCursor = w;

                        this.initHCursor = h;

                        initSize = false;

                }

                this.wCursor = w;

                this.hCursor = h;

        }

        /**

         * Inicializa el tama?o del cursor

         */

        public void resetCursorSize() {

                this.wCursor = initWCursor;

                this.hCursor = initHCursor;

        }

        /**

         * Obtiene las coordenadas de la ventana de zoom. Las coordenadas son devueltas

         * en referencia a la vista. 

         * @return

         */

        public Rectangle2D getCursorViewCoordinates() {

                return new Rectangle2D.Double(posX - (wCursor >> 1), posY - (hCursor >> 1), wCursor, hCursor);

        }

        /*

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

                g.setColor(cursorColor);

                wCursor = Math.max(wCursor, MIN_CURSOR_SIZE); 

                hCursor = Math.max(hCursor, MIN_CURSOR_SIZE);

                g.drawRect(posX - (wCursor >> 1), posY - (hCursor >> 1), wCursor, hCursor);

                g.drawLine(posX, posY - (hCursor >> 1), posX, 0);

                g.drawLine(posX, posY + (hCursor >> 1), posX, h);

                g.drawLine(0, posY, posX - (wCursor >> 1), posY);

                g.drawLine(posX + (wCursor >> 1), posY, w, posY);

        }

        /*

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

                prevX = e.getX();

                prevY = e.getY();

        }

        /*

         * (non-Javadoc)

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

         */

        public void mouseReleased(MouseEvent e) {

                if(!isActive())

                        return;

                if(getOperation() != NONE) {

                        setOperation(NONE);

                        if(listener != null)

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

                }

        }

        /**

         * Cuando se pincha y se arrastra en los contornos se redimensiona el marco.

         */

        public void mouseDragged(MouseEvent e) {

                if(!isActive())

                        return;

                if(getOperation() == MOVE_UR) {

                        posX += (e.getX() - (wCursor >> 1)) - posX;

                        posY += (e.getY() + (hCursor >> 1)) - posY;

                        return;

                }

                if(getOperation() == MOVE_UL) {

                        posX += (e.getX() + (wCursor >> 1)) - posX;

                        posY += (e.getY() + (hCursor >> 1)) - posY;

                        return;

                }

                if(getOperation() == MOVE_LR) {

                        posX += (e.getX() - (wCursor >> 1)) - posX;

                        posY += (e.getY() - (hCursor >> 1)) - posY;

                        return;

                }

                if(getOperation() == MOVE_LL) {

                        posX += (e.getX() + (wCursor >> 1)) - posX;

                        posY += (e.getY() - (hCursor >> 1)) - posY;

                        return;

                }

                if(getOperation() == REDIM_LEFT) {

                        wCursor += prevX - e.getX();

                        posX = e.getX() + (wCursor >> 1);

                        prevX = e.getX();

                        return;

                }

                if(getOperation() == REDIM_RIGHT) {

                        int prevULX = posX - (wCursor >> 1);

                        wCursor += e.getX() - prevX;

                        posX = prevULX + (wCursor >> 1);

                        prevX = e.getX();

                        return;

                }

                if(getOperation() == REDIM_UP) {

                        hCursor += prevY - e.getY();

                        posY = e.getY() + (hCursor >> 1);

                        prevY = e.getY();

                        return;

                }

                if(getOperation() == REDIM_DOWN) {

                        int prevULY = posY - (hCursor >> 1);

                        hCursor += e.getY() - prevY;

                        posY = prevULY + (hCursor >> 1);

                        prevY = e.getY();

                        return;

                }

        }

        /*

         * (non-Javadoc)

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

         */

        public void mouseMoved(MouseEvent e) {

                if(!isActive())

                        return;

                int pxLeft = posX - (wCursor >> 1);

                int pxRight = posX + (wCursor >> 1);

                int pyUp = posY - (hCursor >> 1);

                int pyDown = posY + (hCursor >> 1);

                //Si estamos fuera del ?rea del cuadrado + 2 p?xeles ponemos el cursor por defecto y no hacemos nada

                if(e.getX() < (pxLeft - 2) || e.getX() > (pxRight + 2) || e.getY() < (pyUp - 2) || e.getY() > (pyDown + 2)) {

                        setOperation(NONE);

                        if(canvas.getCursor().getType() != Cursor.DEFAULT_CURSOR) {

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

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

                        }

                        return; 

                }

                if(e.getX() >= (pxRight - 2) && e.getY() <= (pyUp + 2)) {

                        if(iconMove != null)

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

                        setOperation(MOVE_UR);

                        return;

                }

                if(e.getX() <= (pxLeft + 2) && e.getY() <= (pyUp + 2)) {

                        if(iconMove != null)

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

                        setOperation(MOVE_UL);

                        return;

                }

                if(e.getX() <= (pxLeft + 2) && e.getY() >= (pyDown - 2)) {

                        if(iconMove != null)

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

                        setOperation(MOVE_LL);

                        return;

                }

                if(e.getX() >= (pxRight - 2) && e.getY() >= (pyDown - 2)) {

                        if(iconMove != null)

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

                        setOperation(MOVE_LR);

                        return;

                }

                if(e.getX() <= (pxLeft + 1)) {

                        if(iconHoriz != null)

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

                        setOperation(REDIM_LEFT);

                        return;

                }

                if(e.getX() >= (pxRight - 1)) {

                        if(iconHoriz != null)

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

                        setOperation(REDIM_RIGHT);

                        return;

                }

                if(e.getY() <= (pyUp + 1)) {

                        if(iconVert != null)

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

                        setOperation(REDIM_UP);

                        return;

                }

                if(e.getY() >= (pyDown - 1)) {

                        if(iconVert != null)

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

                        setOperation(REDIM_DOWN);

                        return;

                }

                setOperation(NONE);

                if(canvas.getCursor().getType() != Cursor.DEFAULT_CURSOR) {

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

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

                }

        }

        /**

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

         * @return Entero que representa a la operaci?n

         */

        public 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.onTool(new ToolEvent(this, view));

        }

        /**

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

        }

        /**

         * Consulta si es posible interactuar con el la capa de cursor de zoom

         * @return 

         */

        public boolean isActive() {

                return active;

        }

        /**

         * Asigna el flag que activa y desactiva la interactuaci?n con capa de control de zoom

         * @param activeEvent

         */

        public void setActive(boolean active) {

                this.active = active;

        }

        /**

         * Obtiene el color del cursor

         * @return Color

         */

        public Color getColor() {

                return cursorColor;

        }

        /**

         * Asigna el color del cursor

         * @param color

         */

        public void setColor(Color color) {

                this.cursorColor = color;

        }

        public void recalcPixelDrawCoordinates() {

        }

        public void recalcMapDrawCoordinates() {

        }

}