Application: gvSIG desktop

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

 *

 * Copyright (C) 2007 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.

 */

package org.gvsig.raster.beans.canvas.layers;

import java.awt.Color;

import java.awt.Cursor;

import java.awt.Graphics;

import java.awt.Point;

import java.awt.event.MouseEvent;

import java.awt.geom.Point2D;

import java.util.ArrayList;

import org.gvsig.raster.beans.canvas.DrawableElement;

import org.gvsig.raster.beans.canvas.GCanvas;

/**

 * Representa una linea recta con puntos de arrastre para la ecualizaci?n de

 * un histograma y realce lineales y dencity slicing.

 *

 * 14-oct-2007

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

 */

public class StraightLine extends DrawableElement {

        /**

         * Representa un punto seleccionado sobre el canvas. Este es

         * dibujado como un peque?o cuadrado.

         *

         * 14-oct-2007

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

         */

        class Square {

                private Point2D     ul, lr;

                private Point2D     center = null;

                private int         width = 6;

                private Color       color = Color.WHITE;

                /**

                 * Constructor. Calcula las esquinas del cuadrado

                 * @param p

                 */

                public Square(Point p) {

                        init(p);

                }

                private void init(Point p) {

                        ul = new Point2D.Double(p.getX() - (width >> 1), p.getY() - (width >> 1));

                        lr = new Point2D.Double(p.getX() + (width >> 1), p.getY() + (width >> 1));

                        center = new Point2D.Double(p.getX(), p.getY());

                }

                /**

                 * Asigna una nueva posici?n al punto

                 * @param x

                 */

                public void setPosition(Point p) {

                        init(p);

                }

                /**

                 * Obtiene el punto central del cuadro

                 * @return Point2D

                 */

                public Point2D getCenter() {

                        return center;

                }

                /**

                 * Dibuja el cuadrado

                 * @param g

                 */

                protected void paint(Graphics g) {

                        g.setColor(color);

                        g.drawRect((int)ul.getX(), (int)ul.getY(), (int)width, (int)width);

                }

                /**

                 * Informa de si el punto pasado por par?metro cae dentro del cuadro o no

                 * @param p Punto a comprobar

                 * @return true si el punto est? dentro y false si no lo est?

                 */

                public boolean isInside(Point p) {

                        return (p.getX() >= ul.getX() && p.getX() <= lr.getX() && p.getY() >= ul.getY() && p.getY() <= lr.getY());

                }

                /**

                 * Asigna el color del cuadrado

                 * @param c Color

                 */

                public void setColor(Color c) {

                        this.color = c;

                }

        }

        /**

         * Lista de cuadrados que intersectan con la recta

         */

        private ArrayList        square = new ArrayList();

        private int              pointDragged = -1;

        /**

         * Constructor. Asigna el color

         * @param c

         */

        public StraightLine(Color c) {

                setColor(c);

        }

        /*

         *  (non-Javadoc)

         * @see org.gvsig.gui.beans.canvas.DrawableElement#firstDraw()

         */

        public void firstDrawActions() {

                //El primer dibujado asigna valores a los puntos inicial y final.

                //No puede hacerse fuera del paint porque a?n no tiene los datos.

                square.clear();

                Point beginPoint = new Point(canvas.getCanvasMinX(), canvas.getCanvasMaxY());

                square.add(new Square(beginPoint));

                Point endPoint = new Point(canvas.getCanvasMaxX(), canvas.getCanvasMinY());

                square.add(new Square(endPoint));

        }

        /**

         * Dibujado de las l?neas y cuadros sobre el canvas

         */

        public void paint(Graphics g) {

                g.setColor(color);

                //Dibujamos una l?nea desde un punto hasta el siguiente

                for (int i = 0; i < (square.size() - 1); i++) {

                        Square sq = ((Square)square.get(i));

                        Square sqNext = ((Square)square.get(i + 1));

                        g.drawLine((int)sq.getCenter().getX(), (int)sq.getCenter().getY(), (int)sqNext.getCenter().getX(), (int)sqNext.getCenter().getY());

                        sq.setColor(color);

                        sq.paint(g);

                }

                //Dibujamos el ?ltimo tramo de recta

                if(square.size() != 0)

                        ((Square)square.get(square.size() - 1)).paint(g);

        }

        /**

         * Asigna el objeto JComponent donde se pintan los elementos. Inicializa los puntos

         * de inicio y fin de l?nea y asigna los listener

         * @param canvas

         */

        public void setCanvas(GCanvas canvas) {

                super.setCanvas(canvas);

        }

        /**

         * Inserta un elemento (cuadrado) en el array entre los dos cuadrados entre los que se

         * encuentre el valor de su X, as? siempre est?n ordenados en el array por valor de X. 

         * @param element

         * @return Devuelve la posici?n del elemento insertado, en caso de no poder insertarse

         *         devolver? -1

         */

        private int insert(Square element) {

                for (int i = 0; i < (square.size() - 1); i++) {

                        int sqX = (int)((Square)square.get(i)).getCenter().getX();

                        int sqNextX = (int)((Square)square.get(i + 1)).getCenter().getX();

                        if(element.getCenter().getX() >= sqX && element.getCenter().getX() <= sqNextX) {

                                square.add(i + 1, element);

                                return i + 1;

                        }

                }

                return -1;

        }

        /**

         * Se captura el punto a arrastrar, en caso de que no coincida con un punto,

         * se inserta

         */

        public boolean mousePressed(MouseEvent e) {

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

                        if (((Square)square.get(i)).isInside(e.getPoint())) {

                                pointDragged = i;

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

                                return false;

                        }

                }

                // En caso de que nadie lo este tratando, osea, un cursor normal

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

                        pointDragged = insert(new Square(e.getPoint()));

                        canvas.repaint();

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

                        return false;

                }

                return true;

        }

        /**

         * Inicializamos el punto arrastrado a un valor fuera del array

         */

        public boolean mouseReleased(MouseEvent e) {

                pointDragged = -1;

                return true;

        }

        /**

         * Cuando se ha pinchado un punto y se arrastra se define aqu? su comportamiento.

         */

        public boolean mouseDragged(MouseEvent e) {

                if (pointDragged >= 0) {

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

                        int minX = canvas.getCanvasMinX();

                        int minY = canvas.getCanvasMinY();

                        int maxX = canvas.getCanvasMaxX();

                        int maxY = canvas.getCanvasMaxY();

                        //Controlamos que no se salga de los l?mites

                        int x = Math.min(Math.max(e.getX(), minX), maxX);

                        int y = Math.min(Math.max(e.getY(), minY), maxY);

                        Square point = ((Square)square.get(pointDragged)); 

                        try {

                                //El primer punto no se desplaza en X

                                if (pointDragged == 0) {

                                        point.setPosition(new Point(minX, y));

                                        return false;

                                }

                                //El ?ltimo punto no se desplaza en X

                                if (pointDragged == (square.size() - 1)) {

                                        point.setPosition(new Point(maxX, y));

                                        return false;

                                }

                                //Puntos centrales

                                point.setPosition(new Point(x, y));

                                //Arrastra a los de abajo si la X es menor que los inferiores

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

                                        Square lowPoint = ((Square)square.get(i));

                                        if(lowPoint.getCenter().getX() >= x) {

                                                lowPoint.setPosition(new Point(x, (int)lowPoint.getCenter().getY()));

                                                for (int j = i + 1; square.get(j) != point;) {

                                                        square.remove(j);

                                                        pointDragged --;

                                                }

                                                break;

                                        }

                                }

                                //Arrastra a los de arriba si la X es mayor que los superiores

                                for (int i = square.size() - 1; i > pointDragged; i--) {

                                        Square upperPoint = ((Square)square.get(i));

                                        if(upperPoint.getCenter().getX() <= x) {

                                                upperPoint.setPosition(new Point(x, (int)upperPoint.getCenter().getY()));

                                                for (int j = i - 1; square.get(j) != point; ) {

                                                        square.remove(j);

                                                        j --;

                                                }

                                                break;

                                        }

                                }

                        } finally {

                                // Siempre repintamos

                                canvas.repaint();

                        }

                        return false;

                }

                return true;

        }

        /*

         * (non-Javadoc)

         * @see org.gvsig.raster.beans.canvas.DrawableElement#mouseMoved(java.awt.event.MouseEvent)

         */

        public boolean mouseMoved(MouseEvent e) {

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

                        if (((Square)square.get(i)).isInside(e.getPoint())) {

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

                                return false;

                        }

                }

                return true;

        }

}