Application: gvSIG desktop » gvSIG Document Layout

/* 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.app.project.documents.layout.fframes;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.Point;

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 javax.swing.SwingUtilities;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.app.project.Project;

import org.gvsig.app.project.documents.layout.DefaultLayoutNotification;

import org.gvsig.app.project.documents.layout.FLayoutUtilities;

import org.gvsig.app.project.documents.layout.LayoutNotification;

import org.gvsig.app.project.documents.view.DefaultViewDocument;

import org.gvsig.app.project.documents.view.ViewDocument;

import org.gvsig.compat.print.PrintAttributes;

import org.gvsig.fmap.dal.exception.ReadException;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextException;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.events.ColorEvent;

import org.gvsig.fmap.mapcontext.events.ExtentEvent;

import org.gvsig.fmap.mapcontext.events.ProjectionEvent;

import org.gvsig.fmap.mapcontext.events.listeners.ViewPortListener;

import org.gvsig.fmap.mapcontext.rendering.legend.events.LegendChangedEvent;

import org.gvsig.fmap.mapcontext.rendering.legend.events.listeners.LegendListener;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 * FFrame para introducir una vista en el Layout.

 * 

 * @author Vicente Caballero Navarro

 */

public class FFrameView extends FFrame implements ViewPortListener,

    LegendListener, IFFrameUseProject, IFFrameUseFMap {

    public static final String PERSISTENCE_DEFINITION_NAME = "FFrameView";

    private static final String MODE_FIELD = "mode";

    private static final String TYPESCALE_FIELD = "typeScale";

    private static final String EXTENSION_FIELD = "extension";

    private static final String QUALITY_FIELD = "quality";

    private static final String VIEWING_FIELD = "viewing";

    private static final String BLINKED_FIELD = "bLinked";

    private static final String MAPUNITS_FIELD = "mapUnits";

    private static final String SCALE_FIELD = "scale";

    private static final String VIEW_FIELD = "view";

    private static final String ENVELOPE_FIELD = "envelope";

    private static final String SHOWGRID_FIELD = "showGrid";

    private static final String GRID_FIELD = "gridview";

    private static final String MAPCONTEXT_FIELD = "mapContext";

    private static final GeometryManager geomManager = GeometryLocator

        .getGeometryManager();

    private static final Logger logger = LoggerFactory

        .getLogger(FFrameView.class);

    public static final int PRESENTATION = 0;

    public static final int DRAFT = 1;

    protected int mode;

    protected int typeScale = AUTOMATICO;

    protected int extension = 0;

    protected int quality = PRESENTATION;

    protected int viewing = 0;

    protected boolean linked = true;

    protected ViewDocument viewDocument = null;

    protected MapContext mapContext = null;

    protected double mapScale = 0;

    protected int mapUnits = 1; // Meters.

    private BufferedImage m_image = null;

    private AffineTransform at = null;

    protected Project project = null;

    private double scaleAnt;

    private boolean refresh = false;

    private Point origin;

    private Point2D p1;

    private Point2D p2;

    private IFFrame grid;

    private boolean showGrid = false;

    /**

     * Creates a new FFrameView object.

     */

    public FFrameView() {

        num++;

    }

    /**

     * Devuelve una descripci?n del FFrameView.

     * 

     * @return Descripci?n.

     */

    public String toString() {

        if (getView() == null) {

            return "FFrameView " + num + ": " + "Vacio";

        }

        return "FFrameView " + num + ": " + getView().getName();

    }

    /**

     * Rellena la escala de la vista que contiene el fframe.

     * 

     * @param d

     *            escala de la vista.

     */

    public void setScale(double d) {

        mapScale = d;

    }

    /**

     * Inserta el nuevo extent a la FFrameView.

     * 

     * @param r

     *            Rect?ngulo a ocupar por el FFrameView.

     */

    public void setNewEnvelope(Envelope r) {

        getMapContext().getViewPort().setEnvelope(r);

        refresh = true;

        mapScale =

            FLayoutUtilities.getScaleView(getMapContext().getViewPort(),

                getBoundBox().width, getBoundingBox(null).width

                    / getBoundBox().width);

    }

    /**

     * Devuelve el FMap de la vista o una clonaci?n de este si se utiliza una

     * escala fija.

     * 

     * @return FMap.

     */

    public MapContext getMapContext() {

        return mapContext;

    }

    /**

     * Rellena la calidad que se quiere aplicar.

     * 

     * @param q

     *            entero que representa la calidad a aplicar.

     */

    public void setQuality(int q) {

        quality = q;

    }

    /**

     * Devuelve un entero que representa la calidad que est? seleccionada.

     * 

     * @return tipo de calidad selccionada.

     */

    public int getQuality() {

        return quality;

    }

    /**

     * Devuelve un entero que representa la forma en que se actualiza la vista.

     * 

     * @return forma que se actualiza la vista.

     */

    public int getViewing() {

        return viewing;

    }

    /**

     * Rellena la forma de actualizar la vista(cuando activo o siempre). De

     * momento esta opci?n esta deshabilitada.

     * 

     * @param v

     *            entero que representa la forma de actualizar la vista.

     */

    public void setViewing(int v) {

        viewing = v;

    }

    /**

     * Inserta el ProjectView de donde obtener las propiedades de la vista a

     * mostrar.

     * 

     * @param v

     *            Modelo de la vista.

     */

    public void setView(ViewDocument dvd) {

        viewDocument = dvd;

        MapContext mctxt = dvd.getMapContext();

        ViewPort vp = null;

        if (getMapContext() != null) {

            vp = getMapContext().getViewPort();

        }else{

            try {

                vp = (ViewPort) mctxt.getViewPort().clone();

            } catch (CloneNotSupportedException e1) {

                NotificationManager.addError("Excepci?n :", e1);

            }

        }

        vp.setImageSize(new Dimension((int) getBoundingBox(null).width,

            (int) getBoundingBox(null).height));

        if (linked){

            if (getTypeScale() == AUTOMATICO) {

                try {

                    mapContext =

                        mctxt.createNewFMap(

                            (ViewPort) mctxt.getViewPort().clone());

                } catch (CloneNotSupportedException e1) {

                    NotificationManager.addError("Excepci?n :", e1);

                }

                mapContext.getViewPort().setImageSize(

                    new Dimension((int) getBoundingBox(null).width,

                        (int) getBoundingBox(null).height));

                mctxt.getViewPort().addViewPortListener(this);

                mctxt.addLayerListener(this);

            }else{

                if (getTypeScale() == CONSTANTE) {

                    mapContext = mctxt.createNewFMap(vp);

                    vp.setEnvelope(getNewEnvelope(getScale()));

                    mctxt.getViewPort().addViewPortListener(this);

                    mctxt.addLayerListener(this);

                }else{

                    if (getTypeScale() == MANUAL) {

                        mapContext = mctxt.createNewFMap(vp);

                        vp.setEnvelope(getNewEnvelope(getScale()));

                        mctxt.getViewPort()

                            .addViewPortListener(this);

                        mctxt.addLayerListener(this);

                    }

                }

            }

        }else{

            if (!linked) {

                if (getTypeScale() == AUTOMATICO) {

                    mapContext = mctxt.cloneFMap();

                    // (v.getMapContext().getViewPort().cloneViewPort());

                    try {

                        mapContext.setViewPort((ViewPort) mctxt

                            .getViewPort().clone());

                    } catch (CloneNotSupportedException e1) {

                        NotificationManager.addError("Excepci?n :", e1);

                    }

                    mapContext.getViewPort().setImageSize(

                        new Dimension((int) getBoundingBox(null).width,

                            (int) getBoundingBox(null).height));

                    mctxt.getViewPort().addViewPortListener(this);

                }else{

                    if (getTypeScale() == CONSTANTE) {

                        mapContext = mctxt.cloneFMap();

                        vp.setEnvelope(getNewEnvelope(getScale()));

                        mapContext.setViewPort(vp);

                        mctxt.getViewPort().addViewPortListener(this);

                    }else{

                        if (getTypeScale() == MANUAL) {

                            mapContext = mctxt.cloneFMap();

                            vp.setEnvelope(getNewEnvelope(getScale()));

                            mapContext.setViewPort(vp);

                            mctxt.getViewPort()

                                .addViewPortListener(this);

                        }

                    }

                }               

            }

        }

    }

    /**

     * Devuelve el modelo de la vista.

     * 

     * @return Modelo de la vista.

     */

    public ViewDocument getView() {

        return viewDocument;

    }

    /**

     * Devuelve un Rect?ngulo que representa el extent de la vista que se

     * requiere a partir de una escala.

     * 

     * @param scale

     *            Escala a mostrar.

     * 

     * @return Rect?ngulo.

     */

    protected Envelope getNewEnvelope(long scale) {

        double hview = getBoundBox().getHeight();

        double wview = getBoundBox().getWidth();

        double hextent = (scale * hview) / 100.0;

        double wextent = (scale * wview) / 100.0;

        if (mapContext.getViewPort().getEnvelope() == null) {

            try {

                return geomManager.createEnvelope(0, 0, 0, 0, SUBTYPES.GEOM2D);

            } catch (CreateEnvelopeException e) {

                logger.error("Error creating the envelope", e);

                return null;

            }

        }

        double newx =

            mapContext.getViewPort().getEnvelope().getCenter(Geometry.DIMENSIONS.X)

                - (wextent / 2.0);

        double newy =

            mapContext.getViewPort().getEnvelope().getCenter(Geometry.DIMENSIONS.Y)

                - (hextent / 2.0);

        IProjection proj = mapContext.getViewPort().getProjection();

        Envelope r = null;

        try {

            r =

                geomManager.createEnvelope(newx, newy, newx + wextent, newy

                    + hextent, SUBTYPES.GEOM2D);

        } catch (CreateEnvelopeException e) {

            logger.error("Error creating the envelope", e);

        }

        if (!proj.isProjected()) {

            Rectangle2D auxR =

                new Rectangle2D.Double(newx, newy, wextent, hextent);

            Rectangle2D aux =

                mapContext.getViewPort().getProjection()

                    .getExtent(auxR, scale, wview, hview, 1, 100, 2.54);

            try {

                r =

                    geomManager.createEnvelope(aux.getX(), aux.getY(),

                        aux.getMaxX(), aux.getMaxY(), SUBTYPES.GEOM2D);

            } catch (CreateEnvelopeException e) {

                logger.error("Error creating the envelope", e);

            }

        }

        return r;

    }

    /**

     * 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

     *            Graphics2D

     * @param at

     *            Transformada af?n.

     * @param rectangleView

     *            rect?ngulo sobre el que hacer un clip.

     * @param imgBase

     *            Imagen para acelerar el dibujado.

     */

    public void draw(Graphics2D g, AffineTransform at, Rectangle2D rectangleView, BufferedImage imgBase) {

        Rectangle2D.Double rectangleLayout = getBoundingBox(at);  

        Rectangle originalClip = preDraw(g, rectangleLayout);    

        if (intersects(rectangleView, rectangleLayout)) {

            if (getMapContext() == null) {

                drawEmpty(g);

            } else {      

                if (getQuality() == PRESENTATION) {

                    drawPresentation(g, at, rectangleLayout, rectangleView, imgBase);

                } else {

                    drawDraft(g);

                }               

            }

        }

        postDraw(g, rectangleLayout, rectangleView, imgBase, originalClip, at); 

        if (showGrid && grid != null) {           

            grid.draw(g, at, rectangleView, imgBase);

        }    

    }

    private void drawPresentation(Graphics2D g, AffineTransform affineTransform, Rectangle2D.Double rectangleLayout, Rectangle2D rectangleView, BufferedImage imgBase){

        Point mapOrigin = new Point((int)rectangleView.getMinX(), (int)rectangleView.getMaxY());

        ViewPort viewPort = this.getMapContext().getViewPort();

        Color theBackColor = viewPort.getBackColor();

        //If the image has to be created...

        if (!(origin != null

            && origin.equals(mapOrigin)

            && affineTransform.getScaleX() == scaleAnt

            && m_image != null

            && !refresh

            && !(rectangleLayout.getWidth() > rectangleView.getWidth() || rectangleLayout.getHeight() > rectangleView.getHeight()))) {

            double scale1_1 = MapContext.getScreenDPI() / 2.54;

            /*

             * This is the ratio between the size assumed by the

             * mapcontext drawer and the true size on screen

             */

            double visible_factor = affineTransform.getScaleX() / scale1_1;

            int draw_w = (int) (1d * rectangleLayout.width / visible_factor);

            int draw_h = (int) (1d * rectangleLayout.height / visible_factor);

            viewPort.setImageSize(new Dimension(draw_w, draw_h));

            viewPort.refreshExtent();

            /*

            viewPort.setOffset(new Point2D.Double(rectangleLayout.x, rectangleLayout.y));

            */

            m_image =

                new BufferedImage(

                    draw_w, //(int) rectangleLayout.getWidth(),

                    draw_h, //(int) rectangleLayout.getHeight(),

                    BufferedImage.TYPE_INT_ARGB);

            Graphics2D gimg = (Graphics2D) m_image.createGraphics();

            /*

            gimg.translate(-((int) rectangleLayout.getX()),

                -((int) rectangleLayout.getY()));

            */

            try {

                getMapContext().draw(m_image, gimg, getScale());

                gimg.dispose();

            } catch (ReadException e) {

                LOG.error("Error reading the provider" , e);

            } catch (MapContextException mpex) {

                LOG.error("Error reading the provider" , mpex);

            }

            /*

            gimg.translate(((int) rectangleLayout.getX()),

                ((int) rectangleLayout.getY()));

                */

            refresh = false;    

        } 

        //Draw the created image

        if (theBackColor != null) {

            g.setColor(theBackColor);

            g.fillRect((int) rectangleLayout.x, (int) rectangleLayout.y,

                viewPort.getImageWidth(),

                viewPort.getImageHeight());

        }

        m_image = copyForcingImageSize(

            m_image,

            (int) rectangleLayout.getWidth(),

            (int) rectangleLayout.getHeight());

        g.drawImage(m_image,

            (int) rectangleLayout.getX(),

            (int) rectangleLayout.getY(), null);

        scaleAnt = affineTransform.getScaleX();

        origin = mapOrigin;             

    }

    /**

     * @param m_image2

     * @param width

     * @param height

     * @return

     */

    private BufferedImage copyForcingImageSize(

        BufferedImage disp_img, int w, int h) {

        if (disp_img == null || w < 1 || h < 1) {

            return new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB);

        }

        int from_w = disp_img.getWidth(null);

        int from_h = disp_img.getHeight(null);

        if (from_w < 1 || from_h < 1) {

            return new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB);

        }

        BufferedImage resp =

            new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);

        Graphics rg = resp.createGraphics();

        double rat_w = (1d*w) / (1d*from_w);

        double rat_h = (1d*h) / (1d*from_h);

        int offset_w = 0;

        int offset_h = 0;

        Image aux = null;

        if (rat_w <= rat_h) {

            // apply resize of width

            int target_h = Math.max(1, (int) (from_h * rat_w));

            // w, target_h

            offset_w = 0;

            offset_h = (h - target_h) / 2;

            aux = disp_img.getScaledInstance(w, target_h, Image.SCALE_FAST);

            rg.drawImage(aux, offset_w, offset_h, null);

        } else {

            // apply resize from height

            int target_w = Math.max(1, (int) (from_w * rat_h));

            // target_w, h

            offset_w = (w - target_w) / 2;

            offset_h = 0;

            aux = disp_img.getScaledInstance(target_w, h, Image.SCALE_FAST);

            rg.drawImage(aux, offset_w, offset_h, null);

        }

        aux = null;

        resp.flush();

        rg.dispose();

        return resp;

    }

    private Rectangle preDraw(Graphics2D g, Rectangle2D.Double rectangleLayout){

        Rectangle originalClip = null;

        if (g.getClipBounds() != null) {

            originalClip = (Rectangle) g.getClipBounds().clone();

        }

        if (getRotation() != 0) {

            g.rotate(Math.toRadians(getRotation()), rectangleLayout.getCenterX(), rectangleLayout.getCenterY()

                + (rectangleLayout.height / 2));

        }       

        g.clipRect((int) rectangleLayout.getMinX(), (int) rectangleLayout.getMinY(),

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

        return originalClip;

    }

    private void postDraw(Graphics2D g, Rectangle2D.Double rectangleLayout, Rectangle2D rectangleView, BufferedImage imgBase, 

        Rectangle originalClip, AffineTransform at){

        if (getRotation() != 0) {

            g.rotate(Math.toRadians(-getRotation()), rectangleLayout.getCenterX(), rectangleLayout.getCenterY());

        }

        if (getMapContext() != null) {

            setATMap(getMapContext().getViewPort().getAffineTransform());

        }

        if (originalClip != null) {

            g.setClip(originalClip.x, originalClip.y, originalClip.width, originalClip.height);

        }            

    }

    private Envelope calculateEnvelope() {

        if (p1 == null || p2 == null) {

            try {

                return geomManager.createEnvelope(0, 0, 0, 0, SUBTYPES.GEOM2D);

            } catch (CreateEnvelopeException e) {

                logger.error("Error creating the envelope", e);

            }

        }

        Envelope r = null;

        try {

            r =

                geomManager.createEnvelope(p1.getX(), p1.getY(), p2.getX(),

                    p2.getY(), SUBTYPES.GEOM2D);

        } catch (CreateEnvelopeException e) {

            logger.error("Error creating the envelope", e);

        }

        return r;

    }

    public void print(Graphics2D g, AffineTransform at, Geometry geom,

        PrintAttributes printAttributes) {

        Rectangle2D.Double rectangleLayout = getBoundingBox(at);  

        Rectangle originalClip = preDraw(g, rectangleLayout);

        print(g, at, printAttributes);

        postDraw(g, rectangleLayout, null, null, originalClip, at);

        if (showGrid && grid != null) {

            grid.print(g, at, geom, printAttributes);

        }    

    }

    private void print(Graphics2D g, AffineTransform at, PrintAttributes printAttributes) {

        Rectangle2D.Double layoutRectangle = getBoundingBox(at);

        ViewPort viewPort = this.getMapContext().getViewPort();

        Point2D old_offset = viewPort.getOffset();

        Dimension old_imgsize = viewPort.getImageSize();

        viewPort.setOffset(new Point2D.Double(layoutRectangle.x, layoutRectangle.y));

        viewPort.setImageSize(new Dimension((int) layoutRectangle.width, (int) layoutRectangle.height));

        //Draw the backgroung color of the map

        Color theBackColor = viewPort.getBackColor();

        if (theBackColor != null) {

            g.setColor(theBackColor);

            g.fillRect((int) layoutRectangle.x, (int) layoutRectangle.y, viewPort

                    .getImageWidth(), viewPort

                    .getImageHeight());

        }        

        //Print the map

        try {

            this.getMapContext().print(g, getScale(), printAttributes);

        } catch (ReadException e) {

            NotificationManager.addError(e.getMessage(), e);

        } catch (MapContextException e) {

            NotificationManager.addError(e.getMessage(), e);

        }      

        // Restore offset, imgsize

        viewPort.setOffset(old_offset);

        viewPort.setImageSize(old_imgsize);

    }

    /**

     * Rellena la unidad de medida en la que est? la vista.

     * 

     * @param i

     *            entero que representa la unidad de medida de la vista.

     */

    public void setMapUnits(int i) {

        mapUnits = i;

    }

    /**

     * Obtiene la unidad de medida en la que est? la vista.

     * 

     * @return Unidad de medida.

     */

    public int getMapUnits() {

        return mapUnits;

    }

    /**

     * Devuelve la escala seg?n el tipo de escala que se haya seleccionado al

     * a?adida la vista.

     * 

     * @return escala.

     */

    public long getScale() {

        /*

         * if (m_bLinked){

         * return getScaleView1(METROS);

         * }

         */

        if (getMapContext() == null) {

            return 0;

        }

        if (getTypeScale() == AUTOMATICO) {

            return FLayoutUtilities.getScaleView(getMapContext().getViewPort(),

                getBoundBox().width, getBoundingBox(null).width);

        } else

            if (getTypeScale() == CONSTANTE) {

                return (long) mapScale;

            } else

                if (getTypeScale() == MANUAL) {

                    return (long) mapScale;

                }

        return (long) mapScale;

    }

    /**

     * Seleccionar si la vista esta relacionada o no con la original.

     * 

     * @param b

     *            true si est? ligada y false si no lo est?.

     */

    public void setLinked(boolean b) {

        linked = b;

    }

    /**

     * Devuelve si est? ligada o no el FFrameView con la vista.

     * 

     * @return True si la vista est? ligada.

     */

    public boolean getLinked() {

        return linked;

    }

    /**

     * Devuelve la opci?n seleccionada:Rellenar marco de la vista o recorte a

     * la vista.

     * 

     * @return entero que representa la opci?n elegida.

     */

    public int getExtension() {

        return extension;

    }

    /**

     * Devuelve el tipo de escala que est? seleccionada AUTOMATICO,CONSTANTE o

     * MANUAL.

     * 

     * @return entero que representa el tipo seleccionado.

     */

    public int getTypeScale() {

        return typeScale;

    }

    /**

     * Rellenar si se quiere:Rellenar marco de la vista o recorte a la vista.

     * 

     * @param i

     *            entero que representa la opci?n elegida.

     */

    public void setExtension(int i) {

        extension = i;

    }

    /**

     * Rellenar el tipo de escala que se desea.

     * 

     * @param i

     *            entero que representa el tipo de escala.

     */

    public void setTypeScale(int i) {

        typeScale = i;

    }

    /**

     * Inserta la imagen para repintar el FFrameView.

     * 

     * @param bi

     *            Imagen para repintar.

     */

    public void setBufferedImage(BufferedImage bi) {

        m_image = bi;

    }

    /**

     * Devuelve la imagen para repintar.

     * 

     * @return Imagen para repintar.

     */

    public BufferedImage getBufferedImage() {

        return m_image;

    }

    /**

     * Devuelve la MAtriz de transformaci?n utilizada por la FFrameView.

     * 

     * @return MAtriz de transformaci?n.

     */

    public AffineTransform getATMap() {

        return at;

    }

    /**

     * Inserta la matriz de transformaci?n.

     * 

     * @param transform

     *            Matriz de transformaci?n.

     */

    public void setATMap(AffineTransform transform) {

        at = transform;

    }

    /**

     * Inserta el proyecto.

     * 

     * @param p

     *            Proyecto.

     */

    public void setProject(Project p) {

        project = p;

    }

    /**

     * @see org.gvsig.app.project.documents.layout.fframes.IFFrame#getNameFFrame()

     */

    public String getNameFFrame() {

        return PluginServices.getText(this, "Vista") + num;

    }

    public String getName() {

        return PERSISTENCE_DEFINITION_NAME;

    }

    /**

     * @see com.iver.cit.gvsig.fmap.ExtentListener#extentChanged(org.gvsig.fmap.mapcontext.events.ExtentEvent)

     */

    public void extentChanged(ExtentEvent e) {

        if (linked){

            if (getTypeScale() == AUTOMATICO) {

                mapContext.getViewPort().setEnvelope(e.getNewExtent());

                observers.notifyObservers(this, 

                    new DefaultLayoutNotification(LayoutNotification.LAYOUT_INVALIDATED));      

            } else

                if (getTypeScale() == MANUAL) {

                    Envelope oldExtent = mapContext.getViewPort().getEnvelope();

                    Envelope newExtent = e.getNewExtent();

                    double xDif = newExtent.getCenter(0) - oldExtent.getCenter(0);

                    double yDif = newExtent.getCenter(1) - oldExtent.getCenter(1);

                    try {

                        mapContext.getViewPort().setEnvelope(

                            geomManager.createEnvelope(oldExtent.getMinimum(0)

                                + xDif, oldExtent.getMinimum(1) + yDif,

                                oldExtent.getMaximum(0) + xDif,

                                oldExtent.getMaximum(1) + yDif, SUBTYPES.GEOM2D));

                    } catch (CreateEnvelopeException e1) {

                        e1.printStackTrace();

                    }

                    observers.notifyObservers(this, 

                        new DefaultLayoutNotification(LayoutNotification.LAYOUT_INVALIDATED));           

                }

            refresh = true;

        }

    }

    /**

     * @see org.gvsig.fmap.mapcontext.events.listeners.ViewPortListener#backColorChanged(org.gvsig.fmap.mapcontext.events.ColorEvent)

     */

    public void backColorChanged(ColorEvent e) {

        if (getLinked()) {

            mapContext.getViewPort().setBackColor(e.getNewColor());

            observers.notifyObservers(this, 

                new DefaultLayoutNotification(LayoutNotification.LAYOUT_INVALIDATED));          

        }

    }

    /**

     * @see org.gvsig.fmap.mapcontext.events.listeners.ViewPortListener#projectionChanged(org.gvsig.fmap.mapcontext.events.ProjectionEvent)

     */

    public void projectionChanged(ProjectionEvent e) {

        if (getTypeScale() == AUTOMATICO) {

            mapContext.getViewPort().setProjection(e.getNewProjection());

            observers.notifyObservers(this, 

                new DefaultLayoutNotification(LayoutNotification.LAYOUT_INVALIDATED));      

        }

    }

    /**

     * DOCUMENT ME!

     * 

     * @param e

     *            DOCUMENT ME!

     */

    public void legendChanged(final LegendChangedEvent e) {

        if (!SwingUtilities.isEventDispatchThread()) {

            SwingUtilities.invokeLater(new Runnable() {

                public void run() {

                    legendChanged(e);

                }

            });

            return;

        }

        if (getLinked()) {

            observers.notifyObservers(this, 

                new DefaultLayoutNotification(LayoutNotification.LAYOUT_INVALIDATED));      

            refresh = true;

        }

    }

    /**

     * DOCUMENT ME!

     * 

     * @param arg0

     *            DOCUMENT ME!

     * 

     * @return DOCUMENT ME!

     */

    public boolean compare(Object arg0) {

        if (!(arg0 instanceof FFrameView)) {

            return false;

        }

        if (!this.getName().equals(((FFrameView) arg0).getName())) {

            return false;

        }

        if (Math.abs(this.getBoundBox().getWidth()

            - (((FFrameView) arg0).getBoundBox().getWidth())) > 0.05) {

            return false;

        }

        if (Math.abs(this.getBoundBox().getHeight()

            - (((FFrameView) arg0).getBoundBox().getHeight())) > 0.05) {

            return false;

        }

        if (!this.toString().equals(((FFrameView) arg0).toString())) {

            return false;

        }

        if (this.getMapContext() != null

            && !this.getMapContext()

                .equals(((FFrameView) arg0).getMapContext())) {

            return false;

        }

        if (this.getRotation() != ((FFrameView) arg0).getRotation()) {

            return false;

        }

        return true;

    }

    /*

     * This was causing issues with the notifications

     * because different instances were considered the same

     * after cloning a frame (the frame is cloned for example

     * when the user changes size of frame)

     * 

    public boolean equals(Object arg0) {

        return this.compare(arg0);

    }

    */

    public void refresh() {

        if (viewDocument != null

            && (getTypeScale() == MANUAL || getTypeScale() == CONSTANTE)) {

            getMapContext().getViewPort().setEnvelope(

                getNewEnvelope(getScale()));

        }

        refresh = true;

    }

    public void fullExtent() throws ReadException {

        setNewEnvelope(getMapContext().getFullEnvelope());

    }

    public void setPointsToZoom(Point2D px1, Point2D px2) {

        p1 = px1;

        p2 = px2;

    }

    public void movePoints(Point2D px1, Point2D px2) {

        double difX = -px2.getX() + px1.getX();

        double difY = -px2.getY() + px1.getY();

        if (p1 != null) {

            p1.setLocation(p1.getX() + difX, p1.getY() + difY);

            p2.setLocation(p2.getX() + difX, p2.getY() + difY);

        }

    }

    /**

     * This method deals with places where this fframeview and the cloned

     * fframeview (frame) are registered as listeners. The goal should be

     * leaving the cloned instance (frame) as listener in the same way

     * that 'this' instance is doing.

     */

    protected void cloneActions(FFrameView frame) {

        if (viewDocument == null || viewDocument.getMapContext() == null) {

            return;

        }

        frame.setTypeScale(this.getTypeScale());

        frame.setLinked(linked);

        if (linked) {

            if (getTypeScale() == AUTOMATICO) {

                frame.viewDocument.getMapContext().getViewPort().addViewPortListener(frame);

                frame.viewDocument.getMapContext().addLayerListener(frame);

            } else

                if (getTypeScale() == CONSTANTE) {

                    frame.viewDocument.getMapContext().getViewPort().removeViewPortListener(frame);

                    frame.viewDocument.getMapContext().addLayerListener(frame);

                } else

                    if (getTypeScale() == MANUAL) {

                        frame.viewDocument.getMapContext().getViewPort().removeViewPortListener(frame);

                        frame.viewDocument.getMapContext().addLayerListener(frame);

                    }

        } else

            if (!linked) {

                if (getTypeScale() == AUTOMATICO) {

                    frame.viewDocument.getMapContext().getViewPort().addViewPortListener(frame);

                } else

                    if (getTypeScale() == CONSTANTE) {

                        frame.viewDocument.getMapContext().getViewPort().removeViewPortListener(frame);

                    } else

                        if (getTypeScale() == MANUAL) {

                            frame.viewDocument.getMapContext().getViewPort().removeViewPortListener(frame);

                        }

            }

        /*

        ((FFrameView) frame).viewDocument.getMapContext().removeLayerListener(

            (FFrameView) frame);

        ((FFrameView) frame).viewDocument.getMapContext().getViewPort()

            .removeViewPortListener((FFrameView) frame);

        */

    }

    public Object clone() throws CloneNotSupportedException {

        FFrameView frame = (FFrameView) super.clone();

        frame.setSelected(this.getSelected() != IFFrame.NOSELECT);

        if (grid != null) {

            FFrameGrid newGrid = (FFrameGrid) this.grid.clone();

            newGrid.setFFrameDependence(frame);

            frame.setGrid(newGrid);

        }

        cloneActions(frame);

        return frame;

    }

    public void setGrid(IFFrame grid) {

        this.grid = grid;

        this.grid.setRotation(this.getRotation());

    }

    public IFFrame getGrid() {

        return this.grid;

    }

    public void setRotation(double rotation) {

        super.setRotation(rotation);

        if (grid != null) {

            grid.setRotation(rotation);

        }

    }

    public void showGrid(boolean b) {

        showGrid = b;

    }

    public boolean isShowGrid() {

        return showGrid;

    }

    public void refreshOriginalExtent() {

        if (getTypeScale() == AUTOMATICO) {

            viewDocument.getMapContext().getViewPort()

                .setEnvelope(getMapContext().getViewPort().getEnvelope());

            viewDocument.getMapContext().getViewPort().refreshExtent();

        } else

            if (getTypeScale() == MANUAL) {

                Envelope oldExtent =

                    viewDocument.getMapContext().getViewPort().getEnvelope();

                Envelope newExtent =

                    getMapContext().getViewPort().getEnvelope();

                double xDif = newExtent.getCenter(0) - oldExtent.getCenter(0);

                double yDif = newExtent.getCenter(1) - oldExtent.getCenter(1);

                try {

                    viewDocument.getMapContext()

                        .getViewPort()

                        .setEnvelope(

                            geomManager.createEnvelope(oldExtent.getMinimum(0)

                                + xDif, oldExtent.getMinimum(1) + yDif,

                                oldExtent.getMaximum(0) + xDif,

                                oldExtent.getMaximum(1) + yDif, SUBTYPES.GEOM2D));

                } catch (CreateEnvelopeException e) {

                    e.printStackTrace();

                }

                viewDocument.getMapContext().getViewPort().refreshExtent();

            }

    }

    public static void registerPersistent() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition(PERSISTENCE_DEFINITION_NAME) == null) {

            DynStruct definition =

                manager.addDefinition(FFrameView.class,

                    PERSISTENCE_DEFINITION_NAME,

                    "FFrameView persistence definition", null, null);

            definition.extend(manager

                .getDefinition(FFrame.PERSISTENCE_DEFINITION_NAME));

            definition.addDynFieldInt(MODE_FIELD).setMandatory(true);

            definition.addDynFieldInt(TYPESCALE_FIELD).setMandatory(true);

            definition.addDynFieldInt(EXTENSION_FIELD).setMandatory(true);

            definition.addDynFieldInt(QUALITY_FIELD).setMandatory(true);

            definition.addDynFieldInt(VIEWING_FIELD).setMandatory(true);

            definition.addDynFieldBoolean(BLINKED_FIELD).setMandatory(true);

            definition.addDynFieldInt(MAPUNITS_FIELD).setMandatory(true);

            definition.addDynFieldDouble(SCALE_FIELD).setMandatory(true);

            definition.addDynFieldObject(VIEW_FIELD)

                .setClassOfValue(ViewDocument.class).setMandatory(false);

            definition.addDynFieldObject(ENVELOPE_FIELD)

                .setClassOfValue(Envelope.class).setMandatory(false);

            definition.addDynFieldBoolean(SHOWGRID_FIELD).setMandatory(true);

            definition.addDynFieldObject(GRID_FIELD)

                .setClassOfValue(IFFrame.class).setMandatory(false);

            definition.addDynFieldObject(MAPCONTEXT_FIELD)

                .setClassOfValue(MapContext.class).setMandatory(false);

        }

    }

    @Override

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        super.loadFromState(state);

        mode = state.getInt(MODE_FIELD);

        typeScale = state.getInt(TYPESCALE_FIELD);

        extension = state.getInt(EXTENSION_FIELD);

        quality = state.getInt(QUALITY_FIELD);

        viewing = state.getInt(VIEWING_FIELD);

        linked = state.getBoolean(BLINKED_FIELD);

        mapUnits = state.getInt(MAPUNITS_FIELD);

        mapScale = state.getDouble(SCALE_FIELD);

        viewDocument = (ViewDocument) state.get(VIEW_FIELD);

        if (state.hasValue(MAPCONTEXT_FIELD)) {

            mapContext = (MapContext) state.get(MAPCONTEXT_FIELD);

            mapContext.getViewPort().setEnvelope(

                (Envelope) state.get(ENVELOPE_FIELD));

        }

        showGrid = state.getBoolean(SHOWGRID_FIELD);

        grid = (IFFrame) state.get(GRID_FIELD);

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set(MODE_FIELD, mode);

        state.set(TYPESCALE_FIELD, typeScale);

        state.set(EXTENSION_FIELD, extension);

        state.set(QUALITY_FIELD, quality);

        state.set(VIEWING_FIELD, viewing);

        state.set(BLINKED_FIELD, linked);

        state.set(MAPUNITS_FIELD, mapUnits);

        state.set(SCALE_FIELD, mapScale);

        state.set(VIEW_FIELD, viewDocument);

        if (getMapContext() != null

            && getMapContext().getViewPort().getEnvelope() != null) {

            state.set(ENVELOPE_FIELD, getMapContext().getViewPort()

                .getEnvelope());

            state.set(MAPCONTEXT_FIELD, mapContext);

        }

        state.set(SHOWGRID_FIELD, showGrid);

        state.set(GRID_FIELD, grid);

    }

    @Override

    public void setBoundBox(Rectangle2D r) {      

        super.setBoundBox(r);

        refresh();

    }   

}