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

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Font;

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 org.cresques.cts.IProjection;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.andami.ui.mdiFrame.NewStatusBar;

import org.gvsig.app.project.Project;

import org.gvsig.app.project.ProjectManager;

import org.gvsig.app.project.documents.Document;

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

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

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

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

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

import org.gvsig.app.project.documents.view.toc.gui.TOC;

import org.gvsig.compat.print.PrintAttributes;

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

import org.gvsig.fmap.geom.Geometry;

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

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

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

import org.gvsig.fmap.mapcontext.layers.CancelationException;

import org.gvsig.fmap.mapcontext.layers.LayerCollectionEvent;

import org.gvsig.fmap.mapcontext.layers.LayerCollectionListener;

import org.gvsig.fmap.mapcontext.layers.LayerPositionEvent;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.fmap.mapcontext.rendering.legend.IVectorLegend;

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

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

import org.gvsig.gui.beans.Messages;

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;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * FFrame para introducir una vista en el Layout.

 * 

 * @author Vicente Caballero Navarro

 */

public class FFrameView extends FFrame implements 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 QUALITY_FIELD = "quality";

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

    // following fields are unused - should be deleted? 

    private static final String EXTENSION_FIELD = "extension";

    private static final String HAS_TOC = "hasToc";

    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 quality = PRESENTATION;

    protected boolean linked = true;

    protected ViewDocument viewDocument = null;

    protected MapContext mapContext = null;

    protected int mapUnits = 1; // Meters.

    protected BufferedImage m_image = null;

    protected AffineTransform at = null;

    protected Project project = null;

    protected double scaleAnt;

    protected Point origin;

    protected Point2D p1;

    protected Point2D p2;

    protected IFFrame grid;

    protected boolean showGrid = false;

        private boolean b_viewOriginatedUpdate = false;

        private boolean b_fframeOriginatedUpdate = false;

        protected boolean b_validCache = false;

        protected ViewDocListener viewDocListener;

        protected OwnMapContextListener ownMapContextListener;

        private boolean b_hasToc = false;

    /**

     * Creates a new FFrameView object.

     */

    public FFrameView() {

        num++;

        createListeners();

    }

    protected void createListeners() {

            viewDocListener = new ViewDocListener();

            ownMapContextListener = new OwnMapContextListener();

    }

    /**

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

            if (getMapContext()!=null) {

                    getMapContext().setScaleView((long) 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);

            updateScaleCtrl();

    }

    /**

     * Calculates the resolution (measured on dots per inch, DPI) to be

     * considered to draw the FFrameView on screen. It is calculated by

     * dividing the width (in pixels) of the FFrame divided by the width

     * in inches of the paper.

     */

    protected double getDrawPaperDPI() {

            return (2.54*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;

    }

    public void setViewMapContext(MapContext viewMapContext) {

            if (mapContext!=null) {

                    clearOwnListeners(mapContext);

            }

            try {

                    if (linked){

                            mapContext =

                                            viewMapContext.createNewFMap(

                                                            (ViewPort) viewMapContext.getViewPort().clone());

                    }

                    else {

                            mapContext = viewMapContext.cloneFMap();

                            mapContext.setViewPort((ViewPort) viewMapContext

                                            .getViewPort().clone());

                    }

                    ViewPort newViewPort = getMapContext().getViewPort();

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

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

                    newViewPort.setDPI(getDrawPaperDPI());

                    setListeners();

                    updateScaleCtrl();

                    setTocModel();

            } catch (CloneNotSupportedException e1) {

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

            }

    }

    /**

     * 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 oldDoc = dvd;

            if (oldDoc!=null && oldDoc.getMapContext()!=null) {

                    clearViewListeners(oldDoc.getMapContext());

            }

        viewDocument = dvd;

        if (dvd!=null) {

            setViewMapContext(dvd.getMapContext());

        }

    }

    /**

     * Devuelve el modelo de la vista.

     * 

     * @return Modelo de la vista.

     */

    public ViewDocument getView() {

        return viewDocument;

    }

    /**

     * Draws the FFrameView on the provided Graphics, according to the

     * provided affine transform and the visible rectangle.

     * 

     * @param g Graphics2D

     * @param at Affine transform to translate sheet coordinates (in cm)

     *                                 to screen coordinates (in pixels)

     * @param visibleLayoutDocRect visible rectangle

     * @param imgBase Image used to speed up the drawing process

     */

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

        Rectangle2D.Double fframeViewRect = getBoundingBox(at);  

        Rectangle originalClip = preDraw(g, fframeViewRect);    

        if (intersects(visibleLayoutDocRect, fframeViewRect)) {

            if (getMapContext() == null) {

                drawEmpty(g);

            } else {

                if (FLayoutUtilities.hasEditingLayers(getView())) {

                    /*

                     * We are not drawing if any layer is in editing mode

                     */

                    drawMessage(g, Messages.getText(

                        "_Cannot_draw_view_if_layers_in_editing_mode"));

                } else {

                    if (getQuality() == PRESENTATION) {

                        try {

                            drawPresentation(g, at, fframeViewRect, visibleLayoutDocRect, imgBase);

                        } catch (Exception exc) {

                            drawMessage(g, FLayoutFunctions.getLastMessage(exc));

                        }

                    } else {

                        drawDraft(g);

                    }               

                }

            }

        }

        postDraw(g, fframeViewRect, visibleLayoutDocRect, imgBase, originalClip, at); 

        if (showGrid && grid != null) {           

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

        }    

    }

    private void drawMessage(Graphics2D g, String msg) {

        Rectangle2D r = getBoundingBox(null);

        g.setColor(Color.lightGray);

        g.fillRect((int) r.getX(), (int) r.getY(), (int) r.getWidth(),

            (int) r.getHeight());

        g.setColor(Color.darkGray);

        g.setStroke(new BasicStroke(2));

        g.drawRect((int) r.getX(), (int) r.getY(), (int) r.getWidth(),

            (int) r.getHeight());

        g.setColor(Color.black);

        int scale = (int) (r.getWidth() / 24);

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

        g.setFont(f);

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

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

    }

    protected void drawPresentation(

        Graphics2D g,

        AffineTransform affineTransform,

        Rectangle2D.Double fframeViewRect,

        Rectangle2D visibleLayoutDocRect,

        BufferedImage imgBase) throws Exception {

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

            int drawWidth = (int)fframeViewRect.width;

            int drawHeight = (int)fframeViewRect.height;

        // paint the MapContext on m_image, if not already cached

        createImage(g, affineTransform, drawWidth, drawHeight, mapOrigin);

        //Draw the created image

        drawImage(g, m_image, fframeViewRect);

        scaleAnt = affineTransform.getScaleX();

        origin = mapOrigin;             

    }

    protected void createImage(Graphics2D g, AffineTransform affineTransform,

                    int width, int height, Point mapOrigin) throws ReadException, MapContextException {

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

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

            if (origin == null ||

                            !origin.equals(mapOrigin) ||

                            affineTransform.getScaleX() != scaleAnt ||

                            m_image == null ||

                            !b_validCache) { 

                    viewPort.setDPI(getDrawPaperDPI());

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

            m_image =

                    new BufferedImage(

                                    width,

                                    height,

                                    BufferedImage.TYPE_INT_ARGB);

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

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

            gimg.dispose();

            b_validCache = true;

        } 

    }

    protected void drawImage(Graphics2D g, BufferedImage image,

                    Rectangle2D.Double visibleRectangle) {

            Color theBackColor = getMapContext().getViewPort().getBackColor();

        if (theBackColor != null) {

            g.setColor(theBackColor);

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

                            (int)visibleRectangle.width,

                            (int)visibleRectangle.height);

        }

        g.drawImage(m_image, 

                        (int) visibleRectangle.x,

                        (int) visibleRectangle.y,

                        null);            

    }

    protected Rectangle preDraw(Graphics2D g, Rectangle2D.Double fframeViewRect){

        Rectangle originalClip = null;

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

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

        }

        if (getRotation() != 0) {

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

                + (fframeViewRect.height / 2));

        }       

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

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

        return originalClip;

    }

    protected void postDraw(Graphics2D g, Rectangle2D.Double fframeViewRect, Rectangle2D visibleLayoutDocRect, BufferedImage imgBase, 

        Rectangle originalClip, AffineTransform at){

        if (getRotation() != 0) {

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

        }

        if (getMapContext() != null) {

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

        }

        if (originalClip != null) {

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

        }            

    }

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

        }    

    }

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

        Rectangle2D.Double layoutRectangle = getBoundingBox(at);

        // FIXME: should we clone the mapcontext and viewport before printing ??

        // otherwise we will probably have unexpected results if the user modifies

        // the layout while printing

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

            return (long) getMapContext().getScaleView();

    }

    /**

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

        resetListeners();

    }

    /**

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

     * 

     * @return True si la vista est? ligada.

     */

    public boolean getLinked() {

        return linked;

    }

    /**

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

     * MANUAL.

     * 

     * @return entero que representa el tipo seleccionado.

     */

    public int getTypeScale() {

        return typeScale;

    }

    /**

     * Rellenar el tipo de escala que se desea.

     * 

     * @param i

     *            entero que representa el tipo de escala.

     */

    public void setTypeScale(int i) {

        typeScale = i;

        resetListeners();

    }

    /**

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

    }

    /**

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

    }

    public void updateScaleCtrl() {

            NewStatusBar statusbar = PluginServices.getMainFrame().getStatusBar();

            MapContext mapContext = this.getMapContext();

            if (mapContext==null) {

                    return;

            }

            statusbar.setMessage("units",

                            PluginServices.getText(this, mapContext.getDistanceName()));

            statusbar.setControlValue("layout-view-change-scale",

                            String.valueOf(getMapContext().getScaleView()));

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

            if (proj != null) {

                    statusbar.setMessage("projection", proj.getAbrev());

            } else {

                    statusbar.setMessage("projection", "");

            }

    }

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

    }

    public Object clone() throws CloneNotSupportedException {

            Document d = ProjectManager.getInstance().getCurrentProject().getDocuments().get(0);

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

        frame.setView(this.getView());

        frame.createListeners(); // necessary to create the listeners within the right scope

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

    }

    public static void registerPersistent() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

//            DynStruct definition =

//                    manager.addDefinition(FLyrVect.class,

//                        "FLyrVect",

//                        "FLyrVect Persistence definition",

//                        null,

//                        null);

//                definition.extend(PersistenceManager.PERSISTENCE_NAMESPACE,

//                    "FLyrDefault");

//

//                definition.addDynFieldObject("legend")

//                    .setClassOfValue(IVectorLegend.class)

            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(false);

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

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

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

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

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

            definition.addDynFieldBoolean(HAS_TOC).setMandatory(false);

        }

    }

    @Override

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        super.loadFromState(state);

        mode = state.getInt(MODE_FIELD);

        typeScale = state.getInt(TYPESCALE_FIELD);

        quality = state.getInt(QUALITY_FIELD);

        linked = state.getBoolean(BLINKED_FIELD);

        mapUnits = state.getInt(MAPUNITS_FIELD);;

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

        if (state.hasValue(MAPCONTEXT_FIELD)) {

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

            this.setViewMapContext(mctxt);

            double mapScale = state.getDouble(SCALE_FIELD);

            mapContext.getViewPort().setDPI(getDrawPaperDPI());

            mapContext.setScaleView((long)mapScale); // FIXME: really needed?? probably already persisted on Mapcontext

            mapContext.getViewPort().setEnvelope(

                (Envelope) state.get(ENVELOPE_FIELD));

            if (state.hasValue(HAS_TOC)) {

                    this.b_hasToc = state.getBoolean(HAS_TOC);

                    if (this.getLayoutContext()!=null) {

                            this.getLayoutContext().setTocModel(mapContext);

                    }

            }

        }

        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(QUALITY_FIELD, quality);

        state.set(BLINKED_FIELD, linked);

        state.set(MAPUNITS_FIELD, mapUnits);

        state.set(VIEW_FIELD, viewDocument);

        state.set(HAS_TOC, b_hasToc);

        if (getMapContext() != null

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

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

                .getEnvelope());

            state.set(SCALE_FIELD, (double)getMapContext().getScaleView());

            state.set(MAPCONTEXT_FIELD, getMapContext());

        }

        state.set(SHOWGRID_FIELD, showGrid);

        state.set(GRID_FIELD, grid);

    }

    @Override

    public void setBoundBox(Rectangle2D r) {

            super.setBoundBox(r);

            if (getMapContext()!=null) {

                    getMapContext().getViewPort().setImageSize(

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

                    getMapContext().getViewPort().setDPI(getDrawPaperDPI());

                    updateScaleCtrl();

                    // FIXME: what should we do here? should we invalidate the cache?

                    // should we also trigger a Layout redraw?

                    refresh();

            }

    }   

    /**

     * getRotation returns rotation of the frame

     * getMapRotation returns rotation of the map

     * 

     * @return in degrees

     */

    public double getMapRotation() {

        return 0;

    }

        protected void invalidateLayout() {

                b_validCache = false;

                if (getLayoutContext()!=null) {

                        getLayoutContext().notifAllObservers();

                }

        observers.notifyObservers(this, 

                new DefaultLayoutNotification(LayoutNotification.LAYOUT_REFRESH));

        }

        protected void invalidateToc() {

                if (getLayoutContext()!=null) {

                        getLayoutContext().updateFFrames();

                }

        }

        public void refresh() {

        // FIXME: what should we do here? do we really need to invalidate cache??

            b_validCache = false;                

        }

    protected void resetListeners() {

                if (this.getMapContext()!=null) {

                        clearOwnListeners(this.getMapContext());

                }

                if (this.getView()!=null && this.getView().getMapContext()!=null) {

                        clearViewListeners(this.getView().getMapContext());

                }

            setListeners();

    }

    protected void setListeners() {

            if (getView()!=null) {

                    if (linked) {

                            getView().getMapContext().addLayerListener(viewDocListener);

                            getView().getMapContext().getLayers().addLayerCollectionListener(viewDocListener);

                            getView().getMapContext().addAtomicEventListener(viewDocListener);

                    }

                    if (getTypeScale()==IFFrameUseFMap.AUTOMATICO) {

                            getView().getMapContext().getViewPort().addViewPortListener(viewDocListener);

                    }

            }

            if (getMapContext()!=null) {

                    getMapContext().addLayerListener(ownMapContextListener);

                    getMapContext().getLayers().addLayerCollectionListener(ownMapContextListener);

                    getMapContext().getViewPort().addViewPortListener(ownMapContextListener);

            }

    }

    protected void clearOwnListeners(MapContext mapContext) {

            mapContext.removeLayerListener(ownMapContextListener);

            mapContext.getViewPort().removeViewPortListener(ownMapContextListener);

            mapContext.getLayers().removeLayerCollectionListener(ownMapContextListener);

    }

    protected void clearViewListeners(MapContext mapContext) {

            mapContext.removeLayerListener(viewDocListener);

            mapContext.getViewPort().removeViewPortListener(viewDocListener);

            mapContext.getLayers().removeLayerCollectionListener(viewDocListener);

    }

    /*

     * (non-Javadoc)

     * @see org.gvsig.tools.dispose.Disposable#dispose()

     */

        public void dispose() {

                try {

                        if (this.getMapContext()!=null) {

                                clearOwnListeners(this.getMapContext());

                        }

                        if (this.getView()!=null && this.getView().getMapContext()!=null) {

                                clearViewListeners(this.getView().getMapContext());

                        }

                }

                catch (Exception ex) {}

                this.viewDocument = null;

                this.mapContext = null;

        }

        public void frameRemoved() {

                if (mapContext!=null) {

                        clearOwnListeners(mapContext);

                }

                if (this.getView()!=null && this.getView().getMapContext()!=null) {

                        clearViewListeners(this.getView().getMapContext());

                }

                if (b_hasToc && getLayoutContext()!=null) {

                        getLayoutContext().setTocModel(null);

                }

                m_image = null; // FIXME: we could instead move it to a LRU cache to keep the last N images

        }

        public void frameAdded() {

                setListeners();

                updateScaleCtrl();

        }

        public void setHasToc(boolean hasToc) {

                this.b_hasToc = hasToc;

                setTocModel();

        }

        protected void setTocModel() {

                if (getLayoutContext()!=null) {

                        if (b_hasToc && getMapContext()!=null) {

                                getLayoutContext().setTocModel(getMapContext());

                        }

                        else {

                                getLayoutContext().setTocModel(null);

                        }

                }

        }

        @Override

        protected void doSetSelected(int selectedStatus) {

                boolean oldSelectedStatus = isSelected();

                super.doSetSelected(selectedStatus);

                if (!oldSelectedStatus && isSelected()) { // changed from not selected to selected

                        setTocModel();

                        updateScaleCtrl();

                }

        }

        private class ViewDocListener

        implements ViewPortListener, LegendListener, LayerCollectionListener, AtomicEventListener {

                public void extentChanged(ExtentEvent e) {

                        if (!b_fframeOriginatedUpdate && getTypeScale()==AUTOMATICO) {

                                if (getMapContext()!=null) {

                                        b_viewOriginatedUpdate = true;

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

                                        updateScaleCtrl();

                                        invalidateLayout();

                                        b_viewOriginatedUpdate = false;

                                }

                        }                        

                }

                public void backColorChanged(ColorEvent e) {

                        if (!b_fframeOriginatedUpdate && linked) {

                                if (getMapContext()!=null) {

                                        b_viewOriginatedUpdate = true;

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

                                        invalidateLayout();

                                        b_viewOriginatedUpdate = true;

                                }

                        }

                }

                public void projectionChanged(ProjectionEvent e) {

                        if (!b_fframeOriginatedUpdate && getTypeScale()==AUTOMATICO) {

                                if (getMapContext()!=null) {

                                        b_viewOriginatedUpdate = true;

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

                                        invalidateLayout();

                                        // FIXME: force also a view redraw someway??

                                        b_viewOriginatedUpdate = false;

                                }

                        }

                }

                public void conditionalRedraw() {

                        if (!b_fframeOriginatedUpdate && linked) {

                                b_viewOriginatedUpdate = true;

                                invalidateLayout();

                                // the view should also receive the event and update automatically

                                b_viewOriginatedUpdate = false;

                        }                        

                }

                public void legendChanged(LegendChangedEvent e) {

                        conditionalRedraw();

                        invalidateToc();

                }

                public void layerAdded(LayerCollectionEvent e) {

                        conditionalRedraw();

                        invalidateToc();

                }

                public void layerMoved(LayerPositionEvent e) {

                        conditionalRedraw();

                        invalidateToc();

                }

                public void layerRemoved(LayerCollectionEvent e) {

                        conditionalRedraw();

                        invalidateToc();

                }

                public void layerAdding(LayerCollectionEvent e)

                                throws CancelationException {

                        // nothing needed

                }

                public void layerMoving(LayerPositionEvent e)

                                throws CancelationException {

                        // nothing needed

                }

                public void layerRemoving(LayerCollectionEvent e)

                                throws CancelationException {

                        // nothing needed

                }

                public void visibilityChanged(LayerCollectionEvent e)

                                throws CancelationException {

                        conditionalRedraw();

                        invalidateToc();

                }

                public void atomicEvent(AtomicEvent e) {

                        conditionalRedraw();

                        invalidateToc();

                }

        }

        private class OwnMapContextListener

        implements ViewPortListener, LegendListener, LayerCollectionListener {

                public void extentChanged(ExtentEvent e) {

                        if (!b_viewOriginatedUpdate && (getTypeScale() == AUTOMATICO)) {

                                if (getView()!=null) {

                                        b_fframeOriginatedUpdate = true;

                                        getView().getMapContext().getViewPort().setEnvelope(e.getNewExtent());

                                        updateScaleCtrl();

                                        invalidateLayout();

                                        b_fframeOriginatedUpdate = false;

                                }

                        }                        

                }

                public void backColorChanged(ColorEvent e) {

                        if (!b_viewOriginatedUpdate && linked) {

                                if (getView()!=null) {

                                        b_fframeOriginatedUpdate = true;

                                        getView().getMapContext().getViewPort().setBackColor(e.getNewColor());

                                        invalidateLayout();

                                        b_fframeOriginatedUpdate = false;

                                }

                        }

                }

                public void projectionChanged(ProjectionEvent e) {

                        if (!b_viewOriginatedUpdate && (getTypeScale() == AUTOMATICO)) {

                                if (getView()!=null) {

                                        b_fframeOriginatedUpdate = true;

                                        getView().getMapContext().getViewPort().setProjection(e.getNewProjection());

                                        invalidateLayout();

                                        // FIXME: force also a view redraw someway??

                                        b_fframeOriginatedUpdate = false;

                                }

                        }

                }

                public void conditionalRedraw() {

                        if (!b_viewOriginatedUpdate && linked) {

                                b_fframeOriginatedUpdate = true;

                                invalidateLayout();

                                // the view should also receive the event and update automatically

                                b_fframeOriginatedUpdate = false;

                        }

                }

                public void legendChanged(final LegendChangedEvent e) {

                        conditionalRedraw();

                }

                public void layerAdded(final LayerCollectionEvent e) {

                        conditionalRedraw();

                }

                public void layerMoved(final LayerPositionEvent e) {

                        conditionalRedraw();

                }

                public void layerRemoved(final LayerCollectionEvent e) {

                        conditionalRedraw();

                }

                public void layerAdding(LayerCollectionEvent e)

                                throws CancelationException {

                        // nothing neededO

                }

                public void layerMoving(LayerPositionEvent e)

                                throws CancelationException {

                        // nothing needed

                }

                public void layerRemoving(LayerCollectionEvent e)

                                throws CancelationException {

                        // nothing needed

                }

                public void visibilityChanged(LayerCollectionEvent e)

                                throws CancelationException {

                        conditionalRedraw();

                }

        }

}