Application: gvSIG desktop

/*

 * Created on 20-feb-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 org.gvsig.app.project.documents.layout.fframes;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Graphics2D;

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

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

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 PRESENTACION = 0;

    public static final int BORRADOR = 1;

    protected int m_Mode;

    protected int m_typeScale = AUTOMATICO;

    protected int m_extension = 0;

    protected int m_quality = PRESENTACION;

    protected int m_viewing = 0;

    protected boolean m_bLinked = true;

    protected ViewDocument view = null;

    protected MapContext m_fmap = null;

    protected double m_Scale = 0;

    protected int m_mapUnits = 1; //Metros.

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

        m_Scale = 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;

        m_Scale = 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 m_fmap;

    }

    /**

     * Rellena la calidad que se quiere aplicar.

     *

     * @param q entero que representa la calidad a aplicar.

     */

    public void setQuality(int q) {

        m_quality = q;

    }

    /**

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

     *

     * @return tipo de calidad selccionada.

     */

    public int getQuality() {

        return m_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 m_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) {

        m_viewing = v;

    }

    /**

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

     * mostrar.

     *

     * @param v Modelo de la vista.

     */

    public void setView(DefaultViewDocument v) {

        view=v;

        ViewPort vp =null;

        if (getMapContext()!=null){

            vp=getMapContext().getViewPort();

        }else{

            try {

                vp = (ViewPort) v.getMapContext().getViewPort().clone();

            } catch (CloneNotSupportedException e1) {

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

            }

        }

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

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

        if (m_bLinked) {

            if (getTypeScale() == AUTOMATICO) {

                try {

                    m_fmap = v.getMapContext().createNewFMap((ViewPort) v.getMapContext()

                        .getViewPort()

                        .clone());

                } catch (CloneNotSupportedException e1) {

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

                }

                m_fmap.getViewPort().setImageSize(new Dimension(

                    (int) getBoundingBox(null).width,

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

                v.getMapContext().getViewPort().addViewPortListener(this);

                v.getMapContext().addLayerListener(this);

            } else if (getTypeScale() == CONSTANTE) {

                m_fmap = v.getMapContext().createNewFMap(vp);

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

                v.getMapContext().getViewPort().addViewPortListener(this);

                v.getMapContext().addLayerListener(this);

            } else if (getTypeScale() == MANUAL) {

                m_fmap = v.getMapContext().createNewFMap(vp);

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

                v.getMapContext().getViewPort().addViewPortListener(this);

                v.getMapContext().addLayerListener(this);

            }

        } else if (!m_bLinked) {

            if (getTypeScale() == AUTOMATICO) {

                m_fmap = v.getMapContext().cloneFMap(); //(v.getMapContext().getViewPort().cloneViewPort());

                try {

                    m_fmap.setViewPort((ViewPort) v.getMapContext().getViewPort().clone());

                } catch (CloneNotSupportedException e1) {

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

                }

                m_fmap.getViewPort().setImageSize(new Dimension(

                    (int) getBoundingBox(null).width,

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

                v.getMapContext().getViewPort().addViewPortListener(this);

            } else if (getTypeScale() == CONSTANTE) {

                m_fmap = v.getMapContext().cloneFMap();

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

                m_fmap.setViewPort(vp);

                v.getMapContext().getViewPort().addViewPortListener(this);

            } else if (getTypeScale() == MANUAL) {

                m_fmap = v.getMapContext().cloneFMap();

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

                m_fmap.setViewPort(vp);

                v.getMapContext().getViewPort().addViewPortListener(this);

            }

            //            } catch (XMLException e1) {

            //                NotificationManager.addError("Cuando se a?ade una vista al Layout",

            //                    e1);

            //            }

        }

    }

    /**

     * Devuelve el modelo de la vista.

     *

     * @return Modelo de la vista.

     */

    public ViewDocument getView() {

        return view;

    }

    /**

     * 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 (m_fmap.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 = m_fmap.getViewPort().getEnvelope().getCenter(Geometry.DIMENSIONS.X) - (wextent / 2.0);

        double newy = m_fmap.getViewPort().getEnvelope().getCenter(Geometry.DIMENSIONS.Y) -  (hextent / 2.0);

        IProjection proj=m_fmap.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 = m_fmap.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 rv

     *            rect?ngulo sobre el que hacer un clip.

     * @param imgBase

     *            Imagen para acelerar el dibujado.

     */

    public void draw(Graphics2D g, AffineTransform at, Rectangle2D rv,

        BufferedImage imgBase) {

        Rectangle2D.Double r = getBoundingBox(at);

        if (getRotation() != 0) {

            g.rotate(Math.toRadians(getRotation()), r.x + (r.width / 2), r.y

                + (r.height / 2));

        }

        if (intersects(rv, r)) {

            if (getMapContext() == null) {

                drawEmpty(g);

            } else {

                if (rv != null) {

                    // Dibujamos en pantalla

                    Rectangle rclip = null;

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

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

                    }

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

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

                    if (getQuality() == PRESENTACION) {

                        if (rv.intersects(r)) {

                            ViewPort viewPort = this.getMapContext()

                            .getViewPort();

                            Color theBackColor = viewPort.getBackColor();

                            if (origin != null

                                && origin.equals(getLayoutControl().getRectOrigin())                                                                        

                                && getLayoutControl().getAT().getScaleX() == scaleAnt

                                && m_image != null && !refresh && !(r.getWidth() > getLayoutControl().getWidth()

                                    || r.getHeight() > getLayoutControl().getHeight())) {

                                if (theBackColor != null) {

                                    g.setColor(theBackColor);

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

                                        .getImageWidth(), viewPort

                                        .getImageHeight());

                                }

                                g.translate(r.getX(), r.getY());

                                g.drawImage(m_image, 0, 0, getLayoutControl().getComponent());

                                g.translate(-r.getX(), -r.getY());

                                scaleAnt = getLayoutControl().getAT().getScaleX();

                                origin = getLayoutControl().getRectOrigin();//.clone();

                            } else {

                                //                                                                System.err.println("r : " + r);

                                if (r.getWidth() > getLayoutControl().getWidth()

                                    || r.getHeight() > getLayoutControl().getHeight()) {

                                    viewPort.setOffset(

                                        new Point2D.Double(r.getX(), r

                                            .getY()));

                                    viewPort.setImageSize(

                                        new Dimension((int) r.getWidth(),

                                            (int) r.getHeight()));

                                    MapContext fmap = getMapContext().cloneToDraw();

                                    ViewPort viewp;

                                    try {

                                        viewp = (ViewPort) viewPort.clone();                            

                                        viewp.setImageSize(new Dimension(

                                            getLayoutControl().getWidth(),

                                            getLayoutControl().getHeight()));

                                        Envelope r1 = calculateEnvelope();

                                        double width = getLayoutContext().getAttributes()

                                        .getSizeInUnits().getAncho();

                                        double scale = FLayoutUtilities

                                        .getScaleView(viewp, width, r1

                                            .getLength(0)

                                            / width);

                                        viewp.setEnvelope(r1);

                                        fmap.setViewPort(viewp);

                                        g.translate(-r.getX(), -r.getY());

                                        if (theBackColor != null) {

                                            g.setColor(theBackColor);

                                            g.fillRect((int) r.x,

                                                (int) r.y,

                                                viewp.getImageWidth(),

                                                viewp.getImageHeight());

                                        }

                                        fmap.draw(imgBase, g, scale);

                                    } catch (ReadException e) {

                                        e.printStackTrace();

                                    } catch (MapContextException mpex) {

                                        mpex.printStackTrace();

                                    } catch (CloneNotSupportedException e1) {

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

                                    }

                                    g.translate(r.getX(), r.getY());

                                } else {

                                    viewPort.setOffset(

                                        new Point2D.Double(r.x, r.y));

                                    viewPort.setImageSize(

                                        new Dimension((int) r.width,

                                            (int) r.height));

                                    viewPort.refreshExtent();

                                    m_image = new BufferedImage((int) r

                                        .getWidth(), (int) r.getHeight(),

                                        BufferedImage.TYPE_INT_ARGB);

                                    Graphics2D gimg = (Graphics2D) m_image

                                    .getGraphics();

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

                                        .getY()));

                                    try {

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

                                    } catch (ReadException e) {

                                        e.printStackTrace();

                                    } catch (MapContextException mpex) {

                                        mpex.printStackTrace();

                                    }

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

                                        .getY()));

                                    if (theBackColor != null) {

                                        g.setColor(theBackColor);

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

                                            .getImageWidth(), viewPort

                                            .getImageHeight());

                                    }

                                    g.drawImage(m_image, (int) r.getX(),

                                        (int) r.getY(), getLayoutControl().getComponent());

                                }

                                scaleAnt = getLayoutControl().getAT().getScaleX();

                                origin = getLayoutControl().getRectOrigin();//.clone();

                                refresh = false;

                            }

                        }

                    } else {

                        drawDraft(g);

                    }

                    if (rclip != null) {

                        g.setClip(rclip.x, rclip.y, rclip.width,

                            rclip.height);

                    }

                } else {

                    printX(g, at);

                }

            }

        }

        if (getRotation() != 0) {

            g.rotate(Math.toRadians(-getRotation()), r.x + (r.width / 2), r.y

                + (r.height / 2));

        }

        if (getMapContext() != null) {

            setATMap(getMapContext().getViewPort()

                .getAffineTransform());

        }

        if (showGrid && grid!=null){

            ((FFrameGrid)grid).setFFrameDependence(this);

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

        }

    }

    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 prroperties) {

        draw(g, at, null, null);

    }

    private void printX(Graphics2D g, AffineTransform at) {

        Rectangle2D.Double r = getBoundingBox(at);

        // Dibujamos en impresora

        Rectangle rclip = g.getClipBounds();

        g.clipRect((int) r.getMinX(), (int) r.getMinY(), (int) r.getWidth(),

            (int) r.getHeight());

        this.getMapContext().getViewPort().setOffset(new Point2D.Double(r.x, r.y));

        this.getMapContext().getViewPort().setImageSize(new Dimension((int) r.width,

            (int) r.height));

        try {

            this.getMapContext().print(g, getScale(), getLayoutContext().getAttributes().toPrintAttributes());

        } catch (ReadException e) {

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

        } catch (MapContextException e) {

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

        }

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

    }

    /**

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

        m_mapUnits = i;

    }

    /**

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

     *

     * @return Unidad de medida.

     */

    public int getMapUnits() {

        return m_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) m_Scale;

        } else if (getTypeScale() == MANUAL) {

            return (long) m_Scale;

        }

        return (long) m_Scale;

    }

    /**

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

        m_bLinked = b;

    }

    /**

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

     *

     * @return True si la vista est? ligada.

     */

    public boolean getLinked() {

        return m_bLinked;

    }

    /**

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

    }

    /**

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

     * MANUAL.

     *

     * @return entero que representa el tipo seleccionado.

     */

    public int getTypeScale() {

        return m_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) {

        m_extension = i;

    }

    /**

     * Rellenar el tipo de escala que se desea.

     *

     * @param i entero que representa el tipo de escala.

     */

    public void setTypeScale(int i) {

        m_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 (getTypeScale() == AUTOMATICO) {

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

            if (getLayoutControl() != null) {

                getLayoutControl().setStatus(LayoutControl.DESACTUALIZADO);

            }

        }else if (getTypeScale() == MANUAL) {

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

            Envelope newExtent=e.getNewExtent();

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

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

            try {

                m_fmap.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();

            }

            if (getLayoutControl() != null) {

                getLayoutControl().setStatus(LayoutControl.DESACTUALIZADO);

            }

        }

        refresh=true;

    }

    /**

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

     */

    public void backColorChanged(ColorEvent e) {

        if (getLinked()) {

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

            getLayoutControl().setStatus(LayoutControl.DESACTUALIZADO);

            //setBufferedImage(null);

        }

    }

    /**

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

     */

    public void projectionChanged(ProjectionEvent e) {

        if (getTypeScale() == AUTOMATICO) {

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

            if (getLayoutControl() != null) {

                getLayoutControl().setStatus(LayoutControl.DESACTUALIZADO);

            }

        }

    }

    /**

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

            getLayoutControl().setStatus(LayoutControl.DESACTUALIZADO);

            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;

    }

    /**

     * DOCUMENT ME!

     *

     * @param arg0 DOCUMENT ME!

     *

     * @return DOCUMENT ME!

     */

    public boolean equals(Object arg0) {

        return this.compare(arg0);

    }

    public void refresh() {

        if (view!=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);

        }

    }

    protected void cloneActions(IFFrame frame) {

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

            return;

        }

        if (m_bLinked) {

            if (getTypeScale() == AUTOMATICO) {

                view.getMapContext().getViewPort().addViewPortListener(this);

                view.getMapContext().addLayerListener(this);

            } else if (getTypeScale() == CONSTANTE) {

                view.getMapContext().getViewPort().removeViewPortListener(this);

                view.getMapContext().addLayerListener(this);

            } else if (getTypeScale() == MANUAL) {

                view.getMapContext().getViewPort().removeViewPortListener(this);

                view.getMapContext().addLayerListener(this);

            }

        } else if (!m_bLinked) {

            if (getTypeScale() == AUTOMATICO) {

                view.getMapContext().getViewPort().addViewPortListener(this);

            } else if (getTypeScale() == CONSTANTE) {

                view.getMapContext().getViewPort().removeViewPortListener(this);

            } else if (getTypeScale() == MANUAL) {

                view.getMapContext().getViewPort().removeViewPortListener(this);

            }

        }

        ((FFrameView)frame).view.getMapContext().removeLayerListener((FFrameView)frame);

        ((FFrameView)frame).view.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) {

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

            view.getMapContext().getViewPort().refreshExtent();

        }else if (getTypeScale() == MANUAL){

            Envelope oldExtent = view.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 {

                view.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();

            }

            view.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);

        m_Mode = state.getInt(MODE_FIELD);

        m_typeScale = state.getInt(TYPESCALE_FIELD);  

        m_extension = state.getInt(EXTENSION_FIELD);

        m_quality = state.getInt(QUALITY_FIELD);  

        m_viewing = state.getInt(VIEWING_FIELD);

        m_bLinked = state.getBoolean(BLINKED_FIELD);  

        m_mapUnits = state.getInt(MAPUNITS_FIELD);

        m_Scale = state.getDouble(SCALE_FIELD);  

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

        if (state.hasValue(MAPCONTEXT_FIELD)){

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

            m_fmap.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, m_Mode);

        state.set(TYPESCALE_FIELD, m_typeScale);  

        state.set(EXTENSION_FIELD, m_extension);

        state.set(QUALITY_FIELD, m_quality);  

        state.set(VIEWING_FIELD, m_viewing);

        state.set(BLINKED_FIELD, m_bLinked);  

        state.set(MAPUNITS_FIELD, m_mapUnits);

        state.set(SCALE_FIELD, m_Scale);  

        state.set(VIEW_FIELD, view);

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

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

            state.set(MAPCONTEXT_FIELD, m_fmap);

        }

        state.set(SHOWGRID_FIELD, showGrid);  

        state.set(GRID_FIELD, grid);

    }

}