| gvSIG desktop 1

/*

 * Created on 17-may-2004

 *

 */

/* 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.fframes;

import com.iver.andami.PluginServices;

import com.iver.andami.messages.NotificationManager;

import com.iver.cit.gvsig.Abrir;

import com.iver.cit.gvsig.fmap.DriverException;

import com.iver.cit.gvsig.gui.layout.FLayoutUtilities;

import com.iver.cit.gvsig.gui.layout.Layout;

import com.iver.cit.gvsig.gui.layout.dialogs.Tag;

import com.iver.cit.gvsig.project.Project;

import com.iver.utiles.XMLEntity;

import java.awt.Color;

import java.awt.Cursor;

import java.awt.Font;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.net.URL;

import javax.swing.ImageIcon;

/**

 * Clase que implementa la interface IFFrame con los m?todos por defecto de

 * todos los FFrames  que extenderan de este, dejando uno como m?todo

 * abstracto para implementar por todos los  FFrames para ser dibujados.

 *

 * @author Vicente Caballero Navarro

 */

public abstract class FFrame implements IFFrame {

        private static final int N = 1;

        private static final int NE = 2;

        private static final int E = 3;

        private static final int SE = 4;

        private static final int S = 5;

        private static final int SO = 6;

        private static final int O = 7;

        private static final int NO = 8;

        private static final int RECT = 9;

        /** FFrame no selecccionado. */

        public static final int NOSELECT = 0;

        protected String m_name = "FFrame";

        private Rectangle2D.Double m_BoundBox = new Rectangle2D.Double();

        private Rectangle2D.Double m_BoundingBox = new Rectangle2D.Double();

        protected int m_Selected = 0;

        private Rectangle n = new Rectangle();

        private Rectangle ne = new Rectangle();

        private Rectangle e = new Rectangle();

        private Rectangle se = new Rectangle();

        private Rectangle s = new Rectangle();

        private Rectangle so = new Rectangle();

        private Rectangle o = new Rectangle();

        private Rectangle no = new Rectangle();

        private String tag = null;

        protected int num = 0;

        /**

         * Dibuja los handlers sobre el boundingBox en el graphics que se pasa como

         * par?metro.

         *

         * @param g Graphics sobre el que dibujar.

         */

        public void drawHandlers(Graphics2D g) {

                int size = 10;

                Rectangle2D.Double r = getBoundingBox(null);

                //g.drawRect((int) r.x, (int) r.y, (int) r.width, (int) r.height);

                g.fillRect((int) r.x - size, (int) r.y - size, size, size);

                no.setRect((int) r.x - size, (int) r.y - size, size, size);

                g.fillRect((int) r.getMaxX(), (int) r.y - size, size, size);

                ne.setRect((int) r.getMaxX(), (int) r.y - size, size, size);

                g.fillRect((int) r.x - size, (int) r.getMaxY(), size, size);

                so.setRect((int) r.x - size, (int) r.getMaxY(), size, size);

                g.fillRect((int) r.getMaxX(), (int) r.getMaxY(), size, size);

                se.setRect((int) r.getMaxX(), (int) r.getMaxY(), size, size);

                g.fillRect((int) r.getCenterX() - (size / 2), (int) r.y - size, size,

                        size);

                n.setRect((int) r.getCenterX() - (size / 2), (int) r.y - size, size,

                        size);

                g.fillRect((int) r.getCenterX() - (size / 2), (int) r.getMaxY(), size,

                        size);

                s.setRect((int) r.getCenterX() - (size / 2), (int) r.getMaxY(), size,

                        size);

                g.fillRect((int) r.x - size, (int) r.getCenterY() - (size / 2), size,

                        size);

                o.setRect((int) r.x - size, (int) r.getCenterY() - (size / 2), size,

                        size);

                g.fillRect((int) r.getMaxX(), (int) r.getCenterY() - (size / 2), size,

                        size);

                e.setRect((int) r.getMaxX(), (int) r.getCenterY() - (size / 2), size,

                        size);

        }

        /**

         * Establece que tipo de selecci?n se realiza sobre el fframe.

         *

         * @param p punto sobre el que se debe de establecer si se selecciona o no

         *                   el fframe.

         */

        public void setSelected(Point2D.Double p) {

                m_Selected = getContains(p);

        }

        /**

         * Actualiza el BoundBox del FFrame a partir de su rect?ngulo en pixels y

         * la matriz de transformaci?n.

         *

         * @param r Rect?ngulo.

         * @param at Matriz de transformaci?n.

         */

        public void updateRect(Rectangle2D r, AffineTransform at) {

                Rectangle2D.Double rec = FLayoutUtilities.toSheetRect(r, at);

                rec.setRect((int) rec.getMinX(), (int) rec.getMinY(),

                        (int) rec.getWidth(), (int) rec.getHeight());

                setBoundBox(rec);

        }

        /**

         * Devuelve el rect?ngulo a partir del desplazamiento en el eje x y el

         * desplazamiento en el eje y.

         *

         * @param difx desplazamiento sobre el eje x.

         * @param dify desplazamiento sobre el eje y.

         *

         * @return rect?ngulo modificado en funci?n del desplazamiento realizado.

         */

        public Rectangle2D getMovieRect(int difx, int dify) {

                double x = 0;

                double y = 0;

                double w = 0;

                double h = 0;

                Rectangle2D.Double rectaux = new Rectangle2D.Double(this.getBoundingBox(

                                        null).x, this.getBoundingBox(null).y,

                                this.getBoundingBox(null).width,

                                this.getBoundingBox(null).height);

                Rectangle2D.Double rec = this.getBoundingBox(null);

                int difn = 0;

                difn = difx;

                x = rectaux.x;

                y = rectaux.y;

                w = rectaux.width;

                h = rectaux.height;

                switch (this.getSelected()) {

                        case (RECT):

                                rectaux.setRect((x + difx), (y + dify), w, h);

                                break;

                        case (N):

                                if ((y + dify) > rec.getMaxY()) {

                                        y = rec.getMaxY();

                                } else {

                                        y = y + dify;

                                }

                                rectaux.setRect(x, y, w, Math.abs(h - dify));

                                break;

                        case (O):

                                if ((x + difx) > rec.getMaxX()) {

                                        x = rec.getMaxX();

                                } else {

                                        x = x + difx;

                                }

                                rectaux.setRect(x, y, Math.abs(w - difx), h);

                                break;

                        case (S):

                                if (y > (rec.getMaxY() + dify)) {

                                        y = rec.getMaxY() + dify;

                                }

                                rectaux.setRect(x, y, w, Math.abs(h + dify));

                                break;

                        case (E):

                                if (x > (rec.getMaxX() + difx)) {

                                        x = rec.getMaxX() + difx;

                                }

                                rectaux.setRect(x, y, Math.abs(w + difx), h);

                                break;

                        case (NE):

                                if ((y - difn) > rec.getMaxY()) {

                                        y = rec.getMaxY();

                                        x = rec.getMaxX() + difn;

                                } else {

                                        y = y - difn;

                                }

                                rectaux.setRect(x, y, Math.abs(w + difn), Math.abs(h + difn));

                                break;

                        case (NO):

                                if ((y + difn) > rec.getMaxY()) {

                                        y = rec.getMaxY();

                                        x = rec.getMaxX();

                                } else {

                                        x = x + difn;

                                        y = y + difn;

                                }

                                rectaux.setRect(x, y, Math.abs(w - difn), Math.abs(h - difn));

                                break;

                        case (SE):

                                if (y > (rec.getMaxY() + difn)) {

                                        y = rec.getMaxY() + difn;

                                        x = rec.getMaxX() + difn;

                                }

                                rectaux.setRect(x, y, Math.abs(w + difn), Math.abs(h + difn));

                                break;

                        case (SO):

                                if ((x + difn) > rec.getMaxX()) {

                                        x = rec.getMaxX();

                                        y = rec.getMaxY() - difn;

                                } else {

                                        x = x + difn;

                                }

                                rectaux.setRect(x, y, Math.abs(w - difn), Math.abs(h - difn));

                                break;

                        default:

                                rectaux.setRect((x), (y), w, h);

                }

                return rectaux;

        }

        /**

         * Devuelve un entero que representa el tipo de selecci?n que se ha

         * realizado sobre el fframe.

         *

         * @return tipo de selecci?n que se ha realizado.

         */

        public int getSelected() {

                return m_Selected;

        }

        /**

         * Devuelve true, si el punto que se pasa como par?metro esta contenido

         * dentro del boundingbox del fframe.

         *

         * @param p punto a comprobar.

         *

         * @return true si el punto esta dentro del boundingbox.

         */

        public boolean contains(Point2D.Double p) {

                return getBoundingBox(null).contains(p.x, p.y);

        }

        /**

         * Devuelve un entero que representa donde esta contenido el punto que se

         * pasa como par?metro.

         *

         * @param p punto a comparar.

         *

         * @return entero que representa como esta contenido el punto.

         */

        public int getContains(Point2D.Double p) {

                if (n.contains(p.x, p.y)) {

                        return N;

                } else if (ne.contains(p.x, p.y)) {

                        return NE;

                } else if (e.contains(p.x, p.y)) {

                        return E;

                } else if (e.contains(p.x, p.y)) {

                        return E;

                } else if (se.contains(p.x, p.y)) {

                        return SE;

                } else if (s.contains(p.x, p.y)) {

                        return S;

                } else if (so.contains(p.x, p.y)) {

                        return SO;

                } else if (o.contains(p.x, p.y)) {

                        return O;

                } else if (no.contains(p.x, p.y)) {

                        return NO;

                } else if (getBoundingBox(null).contains(p.x, p.y)) {

                        return RECT;

                }

                return 0;

        }

        /**

         * Devuelve el Cursor adecuado seg?n como est? contenido el punto, si es

         * para desplazamiento, o cambio de tama?o.

         *

         * @param p punto a comprobar.

         *

         * @return Cursor adecuado a la posici?n.

         */

        public Cursor getMapCursor(Point2D.Double p) {

                int select = getContains(p);

                switch (select) {

                        case (N):

                                return Cursor.getPredefinedCursor(Cursor.N_RESIZE_CURSOR);

                        case (NE):

                                return Cursor.getPredefinedCursor(Cursor.NE_RESIZE_CURSOR);

                        case (E):

                                return Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR);

                        case (SE):

                                return Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR);

                        case (S):

                                return Cursor.getPredefinedCursor(Cursor.S_RESIZE_CURSOR);

                        case (SO):

                                return Cursor.getPredefinedCursor(Cursor.SW_RESIZE_CURSOR);

                        case (O):

                                return Cursor.getPredefinedCursor(Cursor.W_RESIZE_CURSOR);

                        case (NO):

                                return Cursor.getPredefinedCursor(Cursor.NW_RESIZE_CURSOR);

                        case (RECT):

                                return Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR);

                }

                return null;

        }

        /**

         * Este m?todo se implementa en cada una de las fframe, ya que cada una se

         * dibuja de una forma diferente sobre el graphics. M?todo que dibuja

         * sobre el graphics que se le pasa como par?metro, seg?n la transformada

         * afin que se debe de aplicar y el rect?ngulo que se debe de dibujar.

         * M?todo que dibuja sobre el graphics que se le pasa como par?metro,

         * seg?n la transformada afin que se debe de aplicar y el rect?ngulo que

         * se debe de dibujar.

         *

         * @param g Graphics

         * @param at Transformada afin.

         * @param r rect?ngulo sobre el que hacer un clip.

         * @param imgBase DOCUMENT ME!

         *

         * @throws DriverException

         */

        public abstract void draw(Graphics2D g, AffineTransform at, Rectangle2D r,

                BufferedImage imgBase) throws DriverException;

        /**

         * Devuelve el nombre que representa al fframe.

         *

         * @return String

         */

        public String getName() {

                return m_name;

        }

        /**

         * Rellena el String que representa al nombre del fframe.

         *

         * @param n nombre del fframe.

         */

        public void setName(String n) {

                m_name = n;

        }

        /**

         * Devuelve el boundingBox del fframe en funci?n de la transformada af?n

         * que se pasa como par?metro. Si se pasa como par?metro null, devuelve el

         * ?ltimo boundingbox que se calcul?.

         *

         * @param at Transformada af?n

         *

         * @return Rect?ngulo que representa el BoundingBox del fframe.

         */

        public Rectangle2D.Double getBoundingBox(AffineTransform at) {

                if (at == null) {

                        return m_BoundingBox;

                }

                m_BoundingBox = FLayoutUtilities.fromSheetRect(m_BoundBox, at);

                return m_BoundingBox;

        }

        /**

         * Rellena con el rect?ngulo que se pasa como par?metro el boundBox(en

         * cent?metros) del fframe del cual con una transformaci?n se podr?

         * calcular el BoundingBox (en pixels).

         *

         * @param r Rect?ngulo en cent?metros.

         */

        public void setBoundBox(Rectangle2D.Double r) {

                m_BoundBox.setRect(r.getX(), r.getY(), r.getWidth(), r.getHeight());

        }

        /**

         * Devuelve el rect?ngulo que representa el fframe en cent?metros.

         *

         * @return Rect?ngulo en centimetros.

         */

        public Rectangle2D.Double getBoundBox() {

                return m_BoundBox;

        }

        /**

         * Pasando como par?metro true,  se toma como que esta seleccionado el

         * fframe  y si es false como que esta sin seleccionar,  de esta forma se

         * selecciona un fframe directamente  sin comprobar si un punto esta

         * contenido en ?l.

         *

         * @param b true si se quiere seleccionar y false si se quiere

         *                   deseleccionar.

         */

        public void setSelected(boolean b) {

                if (b) {

                        m_Selected = RECT;

                } else {

                        m_Selected = NOSELECT;

                }

        }

        /**

         * Crea un Objeto FFrame seg?n el tipo que sea, a partir de la informaci?n

         * del XMLEntity.

         *

         * @param xml XMLEntity

         * @param l Layout.

         * @param p Proyecto.

         *

         * @return Objeto de esta clase.

         */

        public static IFFrame createFFrame(XMLEntity xml, Layout l, Project p) {

                IFFrame fframe = null;

                try {

                        Class clase = Class.forName(xml.getStringProperty("className"));

                        fframe = (IFFrame) clase.newInstance();

                } catch (Exception e) {

                        NotificationManager.addError("Clase de Frame sobre el Layout no reconocida",

                                e);

                }

                if (fframe instanceof FFrameView) {

                        ((FFrameView) fframe).setProject(p);

                }

                fframe.setXMLEntity(xml, l);

                fframe.setName(xml.getStringProperty("m_name"));

                fframe.setBoundBox(new Rectangle2D.Double(xml.getDoubleProperty("x"),

                                xml.getDoubleProperty("y"), xml.getDoubleProperty("w"),

                                xml.getDoubleProperty("h")));

                fframe.setTag(xml.getStringProperty("tag"));

                return fframe;

        }

        /**

         * Dibuja sobre el graphics el rect?ngulo del fframe en modo borrador.

         *

         * @param g Graphics so bre el que dibujar.

         */

        public void drawDraft(Graphics2D g) {

                Rectangle2D.Double r = getBoundingBox(null);

                g.setColor(Color.lightGray);

                g.fillRect((int) r.x, (int) r.y, (int) r.width, (int) r.height);

                g.setColor(Color.black);

                int scale = (int) (r.width / 12);

                Font f = new Font("SansSerif", Font.PLAIN, scale);

                g.setFont(f);

                g.drawString(getName(),

                        (int) (r.getCenterX() - ((getName().length() * scale) / 4)),

                        (int) (r.getCenterY()));

        }

        /**

         * Rellena con el n?mero de FFrame.

         *

         * @param i n?mero

         */

        public void setNum(int i) {

                num = i;

        }

        /**

         * Dibuja sobre el graphics el rect?ngulo del fframe pero vacio, mostrando

         * el nombre del fframe y vacio.

         *

         * @param g Graphics sobre el que dibujar.

         */

        public void drawEmpty(Graphics2D g) {

                Rectangle2D.Double r = getBoundingBox(null);

                g.setColor(Color.lightGray);

                g.fillRect((int) r.x, (int) r.y, (int) r.width, (int) r.height);

                g.setColor(Color.black);

                int scale = (int) (r.width / 12);

                Font f = new Font("SansSerif", Font.PLAIN, scale);

                g.setFont(f);

                String s = this.getNameFFrame() + " " +

                        PluginServices.getText(this, "vacia");

                g.drawString(s, (int) (r.getCenterX() - ((s.length() * scale) / 4)),

                        (int) (r.getCenterY()));

        }

        /**

         * Devuelve true si el rect?ngulo primero es null o si es distinto de null

         * e intersecta.

         *

         * @param rv Rect?ngulo

         * @param r Rect?ngulo

         *

         * @return True si intersecta o es null.

         */

        public boolean intersects(Rectangle2D rv, Rectangle2D r) {

                return (((rv != null) && rv.intersects(r)) || (rv == null));

        }

        /**

         * Abre el di?logo para cambiar o a?adir el tag.

         */

        public void openTag() {

                Tag tag = new Tag(this);

                PluginServices.getMDIManager().addView(tag);

        }

        /**

         * Rellena el tag del FFrame.

         *

         * @param s String que representa el valor a guardar en el tag.

         */

        public void setTag(String s) {

                tag = s;

        }

        /**

         * Devuelve el tag.

         *

         * @return tag.

         */

        public String getTag() {

                return tag;

        }

        /**

         * Dibuja sobre el graphics que se pasa como par?metro el icono que

         * representa que contiene un tag.

         *

         * @param g Graphics sobre el que dibujar el icono.

         */

        public void drawSymbolTag(Graphics2D g) {

                Rectangle2D.Double rec = getBoundingBox(null);

                try {

                        URL url = Abrir.class.getClassLoader().getResource("images/symbolTag.gif");

                        Image image = new ImageIcon(url).getImage();

                        g.drawImage(image, (int) rec.x, (int) rec.y, 25, 30, null);

                } catch (NullPointerException npe) {

                }

        }

}