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.ui.mdiFrame.NewStatusBar;

import org.gvsig.app.project.Project;

import org.gvsig.app.project.ProjectManager;

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.layout.TocModelChangedNotification;

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

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

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

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

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

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

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 used for embedding a View in the Layout. The View is not actually

 * inserted on the Layout, but it is used together with the MapContext in order

 * do draw an image which is then painted on the FFrame. Therefore, no

 * MapControl is used in current implementation, but a similar behavior is

 * simulated by the FFrameView. The original MapContext is cloned when assigned

 * to the FFrameView, which is then used for drawing.

 *

 * The FFrameView and the associated View can be synchronized, depending on the

 * values of {@link #getTypeScale()} and {@link #getLinked()}.

 *

 * The main synchronization logic is kept on two internal classes:

 * {@link OwnMapContextListener} and {@link ViewDocListener}. The first one

 * listens for events on the FFrameView and synchronizes the View accordingly.

 * The second one listens for events on the View and synchronizes the FFrameView

 * accordingly. There synchronization process is flagged using

 * {@link #b_updating} and {@link #b_updating}, in order to avoid incurring on

 * infinite synchronization loops.

 *

 */

public class FFrameView extends FFrame implements IFFrameUseProject,

        IFFrameUseFMap, LayoutPanelListener {

    private static final Logger logger = LoggerFactory.getLogger(FFrameView.class);

    public static final String PERSISTENCE_DEFINITION_NAME = "FFrameView";

    private static final String QUALITY_FIELD = "quality";

    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 HAS_TOC_FIELD = "hasToc";

    private static final String LAYER_SYNC_FIELD = "layerSync";

    private static final String EXTENT_SYNC_FIELD = "extentSync";

    private static final String SCALE_TYPE_FIELD = "scaleType";

    // following fields are unused - they are kept for backward-compatibility

    private static final String EXTENSION_FIELD = "extension";

    private static final String BLINKED_FIELD = "bLinked";

    private static final String MODE_FIELD = "mode";

    private static final String TYPESCALE_FIELD = "typeScale";

    private static final String MAPCONTEXT_FIELD = "mapContext";

    private static final String VIEWING_FIELD = "viewing";

    public static final int PRESENTATION = 0;

    public static final int DRAFT = 1;

    protected boolean syncLayers = true;

    protected boolean syncExtents = true;

    protected int quality = PRESENTATION;

    protected ViewDocument viewDocument = null;

    protected MapContext mapContext = null;

    protected int mapUnits = 1; // Meters.

    protected BufferedImage m_image = null;

    protected AffineTransform mapAT = 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_updating = false;

    protected boolean b_validCache = false;

    protected boolean b_drawing = false;

    private ViewDocListener viewDocListener;

    private OwnMapContextListener ownMapContextListener;

    private boolean b_hasToc = true;

    protected static final GeometryManager geomManager = GeometryLocator.getGeometryManager();

    /**

     * When we load a FFrameview from project, it will receive a wrong

     * extentChanged event the first time the View is painted, so we must ignore

     * this first event.

     */

    private boolean b_frameInitialized = true;

    protected AffineTransform originalGraphicsAT = null;

    protected Rectangle originalClip = null;

    private SCALE_TYPE scaleType = SCALE_TYPE.NORMAL;

    private Double fixedScale = null;

    private Envelope fixedExtent = null;

    /**

     * Creates a new FFrameView object.

     */

    public FFrameView() {

        num++;

//        logger.info("Create FFrameView "+ Integer.toHexString(this.hashCode()));

        createListeners();

    }

    /**

     * Returns a description of the FFrame

     *

     * @return Description.

     */

    @Override

    public String toString() {

        if (getView() == null) {

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

        }

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

    }

    /**

     * Sets the scale of the MapContext contained in this FFrameView

     *

     * @param d Scale to be set

     */

    @Override

    public void setScale(double d) {

        if (getMapContext() != null) {

            getMapContext().setScaleView((long) d);

        }

    }

    /**

     * Sets a new Envelope on the MapContext contained in this FFrameView

     *

     * @param r Envelope to be set

     */

    @Override

    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.

     *

     * @return

     */

    protected double getDrawPaperDPI() {

        AffineTransform at = null;

        if (getLayoutContext() != null) {

            at = getLayoutContext().getAT();

        }

        return (2.54 * getBoundingBox(at).width) / getBoundBox().width;

    }

    /**

     * Returns the MapContext contained in this FFrameView, which is usually a

     * clone of the associated View. This MapContext may be synchronized with

     * the View one, depending on the scale type that has been set (see

     * {{@link #getTypeScale()}.

     *

     * @return The mapContext object

     */

    @Override

    public MapContext getMapContext() {

        return mapContext;

    }

    /**

     * Sets the quality of the visualization of the FFrame on screen. Valid

     * values include {@link #DRAFT} and {@link #PRESENTATION}. Draft will

     * disable the frame normal drawing, which will be replaced by an empty

     * rectangle only showing the name of the frame.

     *

     * @param q Integer representing the quality.

     */

    public void setQuality(int q) {

        quality = q;

    }

    /**

     * Gets the quality of the visualization of the FFrame on screen. Valid

     * values include {@link #DRAFT} and {@link #PRESENTATION}. Draft will

     * disable the frame normal drawing, which will be replaced by an empty

     * rectangle only showing the name of the frame.

     *

     * @return

     */

    public int getQuality() {

        return quality;

    }

    /**

     * Sets the MapContext associated with this FFrameView, which will be used

     * to clone the layers and synchronize the FFrameView with the associated

     * View

     *

     * @param viewMapContext

     */

    public void setViewMapContext(MapContext viewMapContext) {

        Envelope oldEnvelope = null;

        if (mapContext != null) {

            removeOwnListeners();

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

                oldEnvelope = mapContext.getViewPort().getEnvelope();

            }

        }

        if (viewMapContext == null) { // disconnect the view from the map

            this.mapContext = null;

            return;

        }

        try {

            if (syncLayers) {

                mapContext

                        = viewMapContext.createNewFMap(

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

            } else {

                mapContext = viewMapContext.cloneFMap();

                mapContext.setViewPort((ViewPort) viewMapContext

                        .getViewPort().clone());

            }

            ViewPort newViewPort = getMapContext().getViewPort();

            if (!syncExtents && oldEnvelope != null) {

                // if extent is not synced with the view, restore the previous

                // envelope if existing

                newViewPort.setEnvelope(oldEnvelope);

            }

            AffineTransform at;

            if (getLayoutContext() != null) {

                at = getLayoutContext().getAT();

            } else {

                at = null;

            }

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

                    (int) getBoundingBox(at).height));

            newViewPort.setDPI(getDrawPaperDPI());

            addAllListeners();

            updateScaleCtrl();

            setTocModel();

        } catch (CloneNotSupportedException e1) {

            logger.warn("Can't set mapcontext of the fframeview", e1);

        }

    }

    /**

     * Sets the View associated with this FFrameView, which will be used to

     * clone the MapContext and the layers. It will also used to synchronize the

     * FFrameView with the associated View, depending on the selected scale type

     *

     * @param viewDocument

     */

    public void setView(ViewDocument viewDocument) {

        removeViewListeners();

        this.viewDocument = viewDocument;

        if (this.viewDocument != null) {

            setViewMapContext(this.viewDocument.getMapContext());

        } else {

            setViewMapContext(null);

        }

    }

    /**

     * Gets the associated View

     *

     * @return The associated view

     * @see {@link #setView(ViewDocument)}

     */

    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

     */

    @Override

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

        Rectangle2D.Double fframeViewRect = getBoundingBox(at);

        Rectangle2D.Double visibleArea = (Rectangle2D.Double) getVisibleRect(visibleLayoutDocRect, fframeViewRect);

        if (visibleArea == null) {

            return;

        }

        preDraw(g, fframeViewRect, visibleArea);

        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, visibleArea, imgBase);

                    } catch (Exception exc) {

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

                    }

                } else {

                    drawDraft(g);

                }

            }

        }

        postDraw(g, fframeViewRect, 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);

        if (msg == null) {

            msg = Messages.getText("error");

        }

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

                (int) (r.getCenterY())

        );

    }

    /**

     * Gets the visible envelope, in map coordinates

     *

     * @param fframeViewRect Rectangle defining the bounding box of the

     * FFrameView, in screen coordinates

     * @param visiblefframeViewRect Rectangle defining the bounding box of the

     * visible area of the fframeView, in screen coordinates

     * @return

     */

    protected Envelope getVisibleEnvelope(Rectangle2D.Double fframeViewRect,

            Rectangle2D.Double visiblefframeViewRect) {

        Envelope oldEnv = getMapContext().getViewPort().getAdjustedEnvelope();

        double widthFactor = ((int) visiblefframeViewRect.width) / fframeViewRect.width;

        double heightFactor = ((int) visiblefframeViewRect.height) / fframeViewRect.height;

        double newWidth = oldEnv.getLength(0) * widthFactor;

        double newHeight = oldEnv.getLength(1) * heightFactor;

        double translateX = visiblefframeViewRect.x - fframeViewRect.x;

        double translateY = visiblefframeViewRect.y - fframeViewRect.y;

        double translateFactorX = translateX / fframeViewRect.width;

        double translateFactorY = translateY / fframeViewRect.height;

        double newX = oldEnv.getMinimum(0) + translateFactorX * oldEnv.getLength(0);

        double newMaxY = oldEnv.getMaximum(1) - translateFactorY * oldEnv.getLength(1);

        double newMaxX = newX + newWidth;

        double newY = newMaxY - newHeight;

        Envelope newEnv = null;

        try {

            newEnv = geomManager.createEnvelope(newX, newY, newMaxX, newMaxY, SUBTYPES.GEOM2D);

        } catch (CreateEnvelopeException ex) {

            logger.warn("Can't calculate the envelope of the visible area.", ex);

        }

        return newEnv;

    }

    protected void drawPresentation(

            Graphics2D g,

            AffineTransform affineTransform,

            Rectangle2D.Double fframeViewRect,

            Rectangle2D.Double visibleRect,

            BufferedImage imgBase) throws Exception {

        b_drawing = true;

        int drawWidth = (int) visibleRect.width;

        int drawHeight = (int) visibleRect.height;

        Envelope oldEnvelope = null;

        if (!visibleRect.equals(fframeViewRect)) {

            // if visible area is smaller than the fframe, we will only draw this area,

            // so we need to tell the ViewPort the image size and extent for drawing,

            // and restore the real extent after drawing

            oldEnvelope = getMapContext().getViewPort().getEnvelope();

            if (oldEnvelope == null) {

                return;

            }

            Envelope newEnvelope = getVisibleEnvelope(fframeViewRect, visibleRect);

            // image size must be set before the envelope, as it has influence on the adjustedExtent

            getMapContext().getViewPort().setImageSize(new Dimension(drawWidth, drawHeight));

            getMapContext().getViewPort().setEnvelope(newEnvelope);

        } else {

            getMapContext().getViewPort().setImageSize(new Dimension(drawWidth, drawHeight));

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

        }

        // map origin should be calculated using the full fframeview, as the visible position will be relative

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

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

        createImage(affineTransform, drawWidth, drawHeight, mapOrigin);

        //Draw the created image

        drawImage(g, m_image, visibleRect);

        if (oldEnvelope != null) {

            // restore real envelope and image size

            getMapContext().getViewPort().setImageSize(new Dimension((int) fframeViewRect.width, (int) fframeViewRect.height));

            getMapContext().getViewPort().setEnvelope(oldEnvelope);

        }

        scaleAnt = affineTransform.getScaleX();

        origin = mapOrigin;

        b_drawing = false;

    }

    protected void createImage(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 void preDraw(Graphics2D g, Rectangle2D.Double fframeViewRect, Rectangle2D.Double visibleRect) {

        originalGraphicsAT = (AffineTransform) g.getTransform().clone();

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

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

        }

        AffineTransform rotationAT = getRotationAT();

        if (rotationAT != null) {

            g.transform(rotationAT);

        }

        g.setClip((int) visibleRect.getMinX(), (int) visibleRect.getMinY(),

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

    }

    protected void postDraw(Graphics2D g, Rectangle2D.Double fframeViewRect, AffineTransform at) {

        g.setTransform(originalGraphicsAT);

        if (getMapContext() != null) {

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

        }

        if (originalClip != null) {

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

        }

    }

    /**

     * @param g

     * @param rectangleLayout

     * @param rectangleView

     * @param originalClip

     * @param imgBase

     * @param at

     * @deprecated Use

     * {@link #postDraw(Graphics2D, java.awt.geom.Rectangle2D.Double, AffineTransform)}

     * instead.

     */

    @Deprecated

    protected void postDraw(Graphics2D g, Rectangle2D.Double rectangleLayout, Rectangle2D rectangleView, BufferedImage imgBase, Rectangle originalClip, AffineTransform at) {

        postDraw(g, rectangleLayout, at);

    }

    /**

     * @param g

     * @param rectangleLayout

     * @return

     * @deprecated Use {@link #preDraw(Graphics2D, java.awt.geom.Rectangle2D.Double, java.awt.geom.Rectangle2D.Double) instead

     */

    @Deprecated

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

        Rectangle originalClip = null;

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

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

        }

        preDraw(g, rectangleLayout, rectangleLayout);

        return originalClip;

    }

    @Override

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

            PrintAttributes printAttributes) {

        Rectangle2D.Double rectangleLayout = getBoundingBox(at);

        preDraw(g, rectangleLayout, rectangleLayout);

        print(g, at, printAttributes);

        postDraw(g, rectangleLayout, 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 (answer: not an issue at the moment as printing is

        // a blocking operation)

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

        Point2D old_offset = viewPort.getOffset();

        Dimension old_imgsize = viewPort.getImageSize();

        double oldDpi = viewPort.getDPI();

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

        viewPort.setImageSize(

                new Dimension(

                        (int) layoutRectangle.width,

                        (int) layoutRectangle.height

                )

        );

        double dpi = PrintAttributes.PRINT_QUALITY_DPI[printAttributes.getPrintQuality()];

        viewPort.setDPI(dpi);

        //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 (Exception ex) {

            logger.warn("Can't print frame view.", ex);

        }

        // Restore offset, imgsize

        viewPort.setOffset(old_offset);

        viewPort.setImageSize(old_imgsize);

        viewPort.setDPI(oldDpi);

    }

    /**

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

    }

    /**

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

     */

    @Override

    public BufferedImage getBufferedImage() {

        return m_image;

    }

    /**

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

     *

     * @return MAtriz de transformaci?n.

     */

    @Override

    public AffineTransform getATMap() {

        return mapAT;

    }

    /**

     * Inserta la matriz de transformaci?n.

     *

     * @param transform Matriz de transformaci?n.

     */

    @Override

    public void setATMap(AffineTransform transform) {

        mapAT = transform;

    }

    /**

     * Inserta el proyecto.

     *

     * @param p Proyecto.

     */

    @Override

    public void setProject(Project p) {

        project = p;

    }

    /**

     * @see

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

     */

    @Override

    public String getNameFFrame() {

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

    }

    @Override

    public String getName() {

        return PERSISTENCE_DEFINITION_NAME;

    }

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

        );

        String scale;

        if (fixedScale != null && getScaleType() == SCALE_TYPE.FIXED_SCALE) {

            // prefer fixedScale as getScaleView() may offer slight differences

            // because the influence of the adjusted envelope

            scale = String.valueOf(fixedScale.longValue());

        } else {

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

        }

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

                scale);

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

        if (proj != null) {

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

        } else {

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

        }

    }

    @Override

    public void fullExtent() throws ReadException {

        setNewEnvelope(getMapContext().getFullEnvelope());

    }

    @Override

    public void setPointsToZoom(Point2D px1, Point2D px2) {

        p1 = px1;

        p2 = px2;

    }

    @Override

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

        }

    }

    @Override

    public FFrameView clone() throws CloneNotSupportedException {

//        logger.info("clone FFrameView "+ Integer.toHexString(this.hashCode()));

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

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

        frame.setView(this.getView());

        frame.removeAllListeners(); // remove listeners add by setView

        if (grid != null) {

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

            newGrid.setFFrameDependence(frame);

            frame.setGrid(newGrid);

        }

//        logger.info("cloned FFrameView "+ Integer.toHexString(frame.hashCode()));

        return frame;

    }

    public void setGrid(IFFrame grid) {

        this.grid = grid;

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

    }

    public IFFrame getGrid() {

        return this.grid;

    }

    @Override

    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;

    }

    @Override

    public void refreshOriginalExtent() {

    }

    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(QUALITY_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.addDynFieldBoolean(HAS_TOC_FIELD).setMandatory(false);

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

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

            definition.addDynFieldInt(SCALE_TYPE_FIELD).setMandatory(false);

            // unused fields, kept for backward compatibility

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

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

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

            definition.addDynFieldObject(MAPCONTEXT_FIELD)

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

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

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

        }

    }

    @Override

    public void loadFromState(PersistentState state)

            throws PersistenceException {

        super.loadFromState(state);

        b_frameInitialized = false;

        if (state.hasValue(EXTENT_SYNC_FIELD)) {

            syncExtents = state.getBoolean(EXTENT_SYNC_FIELD);

        } else {

            syncExtents = true;

        }

        if (state.hasValue(LAYER_SYNC_FIELD)) {

            syncLayers = state.getBoolean(LAYER_SYNC_FIELD);

        } else {

            syncLayers = true;

        }

        Double layoutScale = null;

        if (state.hasValue(SCALE_FIELD)) {

            layoutScale = state.getDouble(SCALE_FIELD);

        }

        Envelope envelope = (Envelope) state.get(ENVELOPE_FIELD);

        if (state.hasValue(SCALE_TYPE_FIELD)) {

            int value = state.getInt(SCALE_TYPE_FIELD);

            if (value == SCALE_TYPE.FIXED_EXTENT.ordinal()) {

                scaleType = SCALE_TYPE.FIXED_EXTENT;

                fixedExtent = envelope;

            } else if (value == SCALE_TYPE.FIXED_SCALE.ordinal()) {

                scaleType = SCALE_TYPE.FIXED_SCALE;

                fixedScale = layoutScale;

            }

            // else use the default value

        }

        quality = state.getInt(QUALITY_FIELD);

        mapUnits = state.getInt(MAPUNITS_FIELD);

        if (state.hasValue(HAS_TOC_FIELD)) {

            this.b_hasToc = state.getBoolean(HAS_TOC_FIELD);

        }

        // When copying and pasting layout documents (in project manager), the view

        // is first persisted (copy action) and then re-created from persistence (paste action).

        // This is a problem, as the re-created view is not the same view as the original one

        // and thus layout stops being synchronized with the right view.

        // Therefore, we try to get first the "live" view if available, and get the persisted

        // one otherwise, which will be used when opening projects.

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

        if (persistenceView != null) {

            ViewDocument view = (ViewDocument) ProjectManager.getInstance().getCurrentProject().getDocument(persistenceView.getName(), persistenceView.getTypeName());

            if (view == null) {

                view = persistenceView;

            }

            this.setView(view);

            // it is crucial to don't persist the MapContext and get a cloned one from the View instead,

            // as the cloned instance is different from the one created using persistence. In particular,

            // the cloned one will share the EventBuffer with the original one, while persistence would

            // create 2 separate EventBuffers, which will then have a very stange behaviour

        }

        if (getMapContext() != null) {

            if (layoutScale != null) {

                getMapContext().setScaleView(layoutScale.longValue());

            }

            getMapContext().getViewPort().setEnvelope(envelope);

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

                this.getLayoutContext().setTocModel(getMapContext());

            }

        }

        showGrid = state.getBoolean(SHOWGRID_FIELD);

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

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set(EXTENT_SYNC_FIELD, syncExtents);

        state.set(LAYER_SYNC_FIELD, syncLayers);

        state.set(QUALITY_FIELD, quality);

        state.set(MAPUNITS_FIELD, mapUnits);

        state.set(VIEW_FIELD, viewDocument);

        state.set(HAS_TOC_FIELD, b_hasToc);

        state.set(SCALE_TYPE_FIELD, scaleType.ordinal());

        if (getMapContext() != null

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

            if (scaleType == SCALE_TYPE.FIXED_SCALE) {

                if (fixedScale == null) {

                    fixedScale = new Double(getMapContext().getScaleView());

                }

                state.set(SCALE_FIELD, (double) fixedScale);

            } else {

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

            }

            if (scaleType == SCALE_TYPE.FIXED_EXTENT) {

                if (fixedExtent == null) {

                    fixedExtent = getMapContext().getViewPort().getAdjustedEnvelope();

                }

                state.set(ENVELOPE_FIELD, fixedExtent);

            } else {

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

                        .getAdjustedEnvelope());

            }

        }

        state.set(SHOWGRID_FIELD, showGrid);

        state.set(GRID_FIELD, grid);

    }

    @Override

    public void setBoundBox(Rectangle2D r) {

        super.setBoundBox(r);

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

            AffineTransform at = this.getLayoutContext().getAT();

            long scale = getMapContext().getScaleView();

            getMapContext().getViewPort().setImageSize(

                    new Dimension(

                            (int) getBoundingBox(at).getWidth(),

                            (int) getBoundingBox(at).getHeight()

                    )

            );

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

            if (getScaleType() == SCALE_TYPE.FIXED_SCALE) {

                getMapContext().setScaleView((long) scale);

            }

            updateScaleCtrl();

            refresh();

        }

    }

    /**

     * Gets the rotation of the frame

     *

     * @return Rotation 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().notifyTocUpdated(TocModelChangedNotification.Type.ITEM_UPDATED);

        }

    }

    protected void refreshToc() {

        if (getLayoutContext() != null) {

            getLayoutContext().notifyTocUpdated(TocModelChangedNotification.Type.MODEL_CHANGED);

        }

    }

    @Override

    public void refresh() {

        // force re-creating the cache on the next drawing cycle

        b_validCache = false;

    }

    protected void createListeners() {

        this.removeAllListeners();

        viewDocListener = new ViewDocListener(this);

        ownMapContextListener = new OwnMapContextListener(this);

//        logger.info("createListeners.viewDocListener "+ viewDocListener.getID());

//        logger.info("createListeners.ownMapContextListener "+ ownMapContextListener.getID());

    }

    protected void addAllListeners() {

        if (viewDocListener == null && ownMapContextListener == null) {

            this.createListeners();

        }

        if (getView() != null) {

            if (syncLayers) {

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

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

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

            }

            if (getExtentSynced()) {

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

            }

        }

        if (getMapContext() != null) {

            getMapContext().addLayerListener(ownMapContextListener);

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

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

        }

//        logger.info("addAllListeners.viewDocListener " + viewDocListener.getID());

//        logger.info("addAllListeners.ownMapContextListener " + ownMapContextListener.getID());

    }

    protected void resetAllListeners() {

        this.removeAllListeners();

        this.addAllListeners();

    }

    protected void removeAllListeners() {

        removeOwnListeners();

        removeViewListeners();

    }

    protected void removeOwnListeners() {

        if (this.ownMapContextListener == null) {

            return;

        }

        if (this.mapContext == null) {

            return;

        }

        this.mapContext.removeLayerListener(ownMapContextListener);

        this.mapContext.getViewPort().removeViewPortListener(ownMapContextListener);

        this.mapContext.getLayers().removeLayerCollectionListener(ownMapContextListener);

//        logger.info("removeOwnListeners.ownMapContextListener " + ownMapContextListener.getID());

    }

    protected void removeViewListeners() {

        if (this.viewDocListener == null) {

            return;

        }

        if (this.getView() == null) {

            return;

        }

        MapContext mapContext = this.getView().getMapContext();

        if (mapContext == null) {

            return;

        }

        mapContext.removeLayerListener(viewDocListener);

        mapContext.getViewPort().removeViewPortListener(viewDocListener);

        mapContext.getLayers().removeLayerCollectionListener(viewDocListener);

        mapContext.removeAtomicEventListener(viewDocListener);

//        logger.info("removeViewListeners.viewDocListener " + viewDocListener.getID());

    }

    @Override

    public void dispose() {

        this.removeAllListeners();

        this.viewDocListener = null;

        this.ownMapContextListener = null;

        this.viewDocument = null;

        this.mapContext = null;

    }

    @Override

    public void frameRemoved() {

        this.removeAllListeners();

        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

    }

    @Override

    public void frameAdded() {

        addAllListeners();

        setTocModel();

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

        }

    }

    @Override

    public boolean getLayerSynced() {

        return syncLayers;

    }

    @Override

    public void setLayerSynced(boolean synced) {

        syncLayers = synced;

        resetAllListeners();

    }

    @Override

    public boolean getExtentSynced() {

        return syncExtents;

    }

    @Override

    public void setExtentSynced(boolean synced) {

        syncExtents = synced;

        resetAllListeners();

    }

    /**

     * Returns true if the newEnvelope represents a pan operation on

     * oldEnvelope, (both extents have the same height and width)

     *

     * @param oldEnvelope

     * @param newEnvelope

     * @return

     */

    public static boolean isPan(Envelope oldEnvelope, Envelope newEnvelope) {

        if (oldEnvelope != null && newEnvelope != null) {

            double toleranceX = 0.00000001 * Math.min(

                    oldEnvelope.getLength(0), newEnvelope.getLength(0)

            );

            double toleranceY = 0.00000001 * Math.min(

                    oldEnvelope.getLength(1), newEnvelope.getLength(1)

            );

            // we consider it to be a pan if both lengths are equal

            // (we use tolerance to avoid direct comparison of double values)

            if (((oldEnvelope.getLength(0) - newEnvelope.getLength(0)) < toleranceX)

                    && ((oldEnvelope.getLength(1) - newEnvelope.getLength(1)) < toleranceY)) {

                return true;

            }

        }

        return false;

    }

    /**

     * Calculates the new extent for the FFrame. It is necessary to avoid scale

     * changes when a pan is triggered from the view, as the different size

     * factors from View/FFrameView introduces scale changes even for pans

     *

     * @return

     */

    protected Envelope calculateNewExtent() {

        Envelope newEnvelope = getView().getMapContext().getViewPort().getEnvelope();

        Envelope oldViewEnvelope = null;

        try {

            if (getView().getMapContext().getViewPort().getEnvelopes().hasPrevious()) {

                Rectangle2D r = getView().getMapContext().getViewPort().getEnvelopes().getPrev();

                oldViewEnvelope = GeometryLocator.getGeometryManager().createEnvelope(

                        r.getMinX(), r.getMinY(), r.getMaxX(), r.getMaxY(), SUBTYPES.GEOM2D

                );

            }

            if (isPan(oldViewEnvelope, newEnvelope)) {

                Envelope envelope = getMapContext().getViewPort().getAdjustedEnvelope();

                double shiftX = newEnvelope.getMinimum(0) - oldViewEnvelope.getMinimum(0);

                double shiftY = newEnvelope.getMinimum(1) - oldViewEnvelope.getMinimum(1);

                double minX = envelope.getMinimum(0) + shiftX;

                double minY = envelope.getMinimum(1) + shiftY;

                double maxX = envelope.getMaximum(0) + shiftX;

                double maxY = envelope.getMaximum(1) + shiftY;

                return GeometryLocator.getGeometryManager().createEnvelope(

                        minX, minY, maxX, maxY, SUBTYPES.GEOM2D

                );

            }

        } catch (Exception ex) {

        }

        return newEnvelope;

    }

    protected boolean isDrawing() {

        return this.b_drawing;

    }

    protected boolean isUpdating() {

        return this.b_updating;

    }

    protected boolean skipFirstChangeExtent() {

        if (this.b_frameInitialized) {

            return false;

        }