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

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.Rectangle;

import java.awt.event.MouseEvent;

import java.awt.geom.AffineTransform;

import java.awt.geom.Area;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.ui.mdiManager.IWindowListener;

import org.gvsig.app.project.ProjectManager;

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.observer.ObservableHelper;

import org.gvsig.tools.observer.Observer;

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;

/**

 * Class implementing the IFFrame interface, that will be extended by all the

 * FFrames. It provides default methods useful for all fframes and abstract

 * methods to be implemented by them.

 *

 * @author Vicente Caballero Navarro

 * @author Cesar Martinez Izquierdo

 */

public abstract class FFrame implements IFFrame {

    public static final String PERSISTENCE_DEFINITION_NAME = "FFrame";

    private static final String BOUNDINGBOX_FIELD = "boundingBox";

    private static final String SELECTED_FIELD = "selected";

    private static final String TAG_FIELD = "tag";

    private static final String ROTATION_FIELD = "rotation";

    private static final String LEVEL_FIELD = "level";

    private static final String NUM_FIELD = "num";

        private static final String DOCUMENT_FIELD = "layoutDocument";

        private static final String LAYOUT_CONTEXT_FIELD = "layoutContext";

    protected static final Logger LOG = LoggerFactory.getLogger(FFrame.class);

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

    // initially identity

    protected AffineTransform lastAT = AffineTransform.getShearInstance(0,0);

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

    protected int m_Selected = 0;

    protected Rectangle n = new Rectangle();

    protected Rectangle ne = new Rectangle();

    protected Rectangle e = new Rectangle();

    protected Rectangle se = new Rectangle();

    protected Rectangle s = new Rectangle();

    protected Rectangle so = new Rectangle();

    protected Rectangle o = new Rectangle();

    protected Rectangle no = new Rectangle();

    private String tag = null;

    protected int num = 0;

    private double m_rotation = 0;

    private int level = -1;

    private Rectangle2D lastMoveRect;

    protected FrameFactory frameFactory;

    private static Image iNEResize = null;

    private static Image iEResize = null;

    private static Image iNResize = null;

    private static Image iMove = null;

    private static Image iSEResize = null;

    protected LayoutManager layoutManager = null;

    // user getters to access these variables:

    private LayoutContext layoutContext = null;

    private Document document = null;

    protected ObservableHelper observers;

    public FFrame() {

        super();

        layoutManager =

            (LayoutManager) ProjectManager.getInstance().getDocumentManager(

                DefaultLayoutManager.TYPENAME);

        observers = new ObservableHelper();

    }

    /**

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

     * par�metro.

     *

     * @param g

     *            Graphics sobre el que dibujar.

     */

    public void drawHandlers(Graphics2D g) {

        int size = 10;

        Rectangle2D r = getBoundingBox(null);

        Point2D p = new Point2D.Double();

        g.rotate(Math.toRadians(getRotation()), r.getX() + (r.getWidth() / 2),

            r.getY() + (r.getHeight() / 2));

        AffineTransform atRotate = new AffineTransform();

        atRotate.rotate(Math.toRadians(getRotation()), r.getX()

            + (r.getWidth() / 2), r.getY() + (r.getHeight() / 2));

        g.fillRect((int) r.getX() - size, (int) r.getY() - size, size, size);

        atRotate.transform(

            new Point2D.Double(r.getX() - size, r.getY() - size), p);

        no.setRect((int) p.getX(), (int) p.getY(), size, size);

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

        atRotate.transform(new Point2D.Double(r.getMaxX(), r.getY() - size), p);

        ne.setRect((int) p.getX(), (int) p.getY(), size, size);

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

        atRotate.transform(new Point2D.Double(r.getX() - size, r.getMaxY()), p);

        so.setRect((int) p.getX(), (int) p.getY(), size, size);

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

        atRotate.transform(new Point2D.Double(r.getMaxX(), r.getMaxY()), p);

        se.setRect((int) p.getX(), (int) p.getY(), size, size);

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

            size, size);

        atRotate

            .transform(new Point2D.Double(r.getCenterX() - (size / 2), r.getY()

                - size), p);

        n.setRect((int) p.getX(), (int) p.getY(), size, size);

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

            size);

        atRotate.transform(

            new Point2D.Double(r.getCenterX() - (size / 2), r.getMaxY()), p);

        s.setRect((int) p.getX(), (int) p.getY(), size, size);

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

            size, size);

        atRotate.transform(new Point2D.Double(r.getX() - size, r.getCenterY()

            - (size / 2)), p);

        o.setRect((int) p.getX(), (int) p.getY(), size, size);

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

            size);

        atRotate.transform(new Point2D.Double(r.getMaxX(), r.getCenterY()

            - (size / 2)), p);

        e.setRect((int) p.getX(), (int) p.getY(), size, size);

        g.rotate(Math.toRadians(-getRotation()), r.getX() + (r.getWidth() / 2),

            r.getY() + (r.getHeight() / 2));

    }

    /**

     * Sets the type of selection performed on the frame, based on the position

     * of the provided Point compared with the boundaries of the FFrame.

     * This method is usually called when the user clicks on the FFrame

     *

     * @param p

     *            Point which should be evaluated to establish if the FFrame must

     *            be selected or not

     * @param e   Mouse event that triggered this method call

     * @see {@link #isSelected()}, {@link #getSelected()}

     */

    public void setSelected(Point2D p, MouseEvent e) {

        doSetSelected(getContains(p));

    }

    /**

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

     * la matriz de transformaci�n.

     *

     * @param r

     *            Rect�ngulo.

     * @param at

     *            Matriz de transformaci�n.

     */

    public void updateRect(Rectangle2D r, AffineTransform at) {

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

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

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

        setBoundBox(rec);

    }

    /**

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

     * desplazamiento en el eje y.

     *

     * @param difx

     *            desplazamiento sobre el eje x.

     * @param dify

     *            desplazamiento sobre el eje y.

     *

     * @return rect�ngulo modificado en funci�n del desplazamiento

     *         realizado.

     */

    public Rectangle2D getMovieRect(int difx, int dify) {

        double x = 0;

        double y = 0;

        double w = 0;

        double h = 0;

        lastMoveRect =

            new Rectangle2D.Double(this.getBoundingBox(null).x,

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

                this.getBoundingBox(null).height);

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

        int difn = 0;

        difn = difx;

        x = lastMoveRect.getX();

        y = lastMoveRect.getY();

        w = lastMoveRect.getWidth();

        h = lastMoveRect.getHeight();

        switch (this.getSelected()) {

        case (RECT):

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

            break;

        case (N):

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

                y = rec.getMaxY();

            } else {

                y = y + dify;

            }

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

            break;

        case (O):

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

                x = rec.getMaxX();

            } else {

                x = x + difx;

            }

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

            break;

        case (S):

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

                y = rec.getMaxY() + dify;

            }

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

            break;

        case (E):

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

                x = rec.getMaxX() + difx;

            }

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

            break;

        case (NE):

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

                y = rec.getMaxY();

                x = rec.getMaxX() + difn;

            } else {

                y = y - difn;

            }

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

            break;

        case (NO):

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

                y = rec.getMaxY();

                x = rec.getMaxX();

            } else {

                x = x + difn;

                y = y + difn;

            }

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

            break;

        case (SE):

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

                y = rec.getMaxY() + difn;

                x = rec.getMaxX() + difn;

            }

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

            break;

        case (SO):

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

                x = rec.getMaxX();

                y = rec.getMaxY() - difn;

            } else {

                x = x + difn;

            }

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

            break;

        default:

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

        }

        return lastMoveRect;

    }

    /**

     * Devuelve el rect�ngulo que representa el �ltimo generado al desplazar

     * o modificar el tama�o del fframe.

     *

     * @return Rectangle2D

     *

     */

    public Rectangle2D getLastMoveRect() {

        return lastMoveRect;

    }

    /**

     * Returns an integer representing the type of selection applied to the

     * FFrame. Valid values are:

     * {@link IFFrame#NOSELECT},

     * {@link IFFrame#NO}, {@link IFFrame#N}, {@link IFFrame#NE},

     * {@link IFFrame#O}, {@link IFFrame#RECT}, {@link IFFrame#E},

     * {@link IFFrame#SO}, {@link IFFrame#S}, {@link IFFrame#SE}.

     *

     * @see {@link #isSelected()}, {@link #setSelected(boolean)}

     * @return The type of selection that has been applied

     */

    public int getSelected() {

        return m_Selected;

    }

    /**

     * Gets the selection status of the frame

     *

     * @return <code>true</code> if the frame is selected,

     *    <code>false</code> otherwise

     * @see {@link #getSelected()}, {@link #setSelected(boolean)}

     */

    public boolean isSelected() {

            return getSelected()!=IFFrame.NOSELECT;

    }

    /**

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

     * dentro del boundingbox del fframe.

     *

     * @param p

     *            punto a comprobar.

     *

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

     */

    public boolean contains(Point2D p) {

        return getBoundingBox(null).contains(p.getX(), p.getY());

    }

    /*

     * (non-Javadoc)

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

     */

    public int getContains(Point2D p) {

            Point2D point = new Point2D.Double();

            AffineTransform rotationAT = getRotationAT();

            if (rotationAT!=null) {

                    // if the frame is rotated, we need to inversely rotate the point in order

                    // to decide whether it is contained or not in the non-rotated frame

                    try {

                                rotationAT.createInverse().transform(p, point);

                        } catch (NoninvertibleTransformException e1) {}

            }

            else {

                    point = p;

            }

        if (n.contains(point.getX(), point.getY())) {

            return N;

        } else

            if (ne.contains(point.getX(), point.getY())) {

                return NE;

            } else

                if (e.contains(point.getX(), point.getY())) {

                    return E;

                } else

                    if (se.contains(point.getX(), point.getY())) {

                        return SE;

                    } else

                        if (s.contains(point.getX(), point.getY())) {

                            return S;

                        } else

                            if (so.contains(point.getX(), point.getY())) {

                                return SO;

                            } else

                                if (o.contains(point.getX(), point.getY())) {

                                    return O;

                                } else

                                    if (no.contains(point.getX(), point.getY())) {

                                        return NO;

                                    } else

                                        if (getBoundingBox(null).contains(

                                            point.getX(), point.getY())) {

                                            return RECT;

                                        }

        return NOSELECT;

    }

    /**

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

     * para desplazamiento, o cambio de tama�o.

     *

     * @param p

     *            punto a comprobar.

     *

     * @return Cursor adecuado a la posici�n.

     */

    public Image getMapCursor(Point2D p) {

        int select = getContains(p);

        switch (select) {

        case (N):

            return iNResize;

        case (NE):

            return iNEResize;

        case (E):

            return iEResize;

        case (SE):

            return iSEResize;

        case (S):

            return iNResize;

        case (SO):

            return iNEResize;

        case (O):

            return iEResize;

        case (NO):

            return iSEResize;

        case (RECT):

            return iMove;

        }

        return null;

    }

    /**

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

     * provided affine transform and the visible rectangle. It has to

     * to be implemented by each FFrame, as each of them usually draws

     * diffently.

     *

     * @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 abstract void draw(Graphics2D g, AffineTransform at, Rectangle2D r,

        BufferedImage imgBase);

    /**

     * Returns the bounding box (in pixels) of this FFrame, based on the provided

     * AffineTransform. If the AffineTransform is null, it returns the last

     * calculated bounding box.

     *

     * @param at Affine transform to apply to the sheet coordinates to get the

     *                  bounding box in pixels.

     * @return Rectangle representing the bounding box (in pixels) of this

     * FFrame

     */

    public Rectangle2D.Double getBoundingBox(AffineTransform at) {

        if (at != null) {

            lastAT = (AffineTransform) at.clone();

        }

        return FLayoutUtilities.fromSheetRect(m_BoundBox, lastAT);

    }

    /**

     * Sets the bounding box in centimeters of this FFrame, using  paper

     * coordinates.

     *

     * @param r

     *            Rectangle in centimeters

     */

    public void setBoundBox(Rectangle2D r) {

        if (r == null) {

            LOG.info("Warning: BBOX set to NULL in FFrame!");

            m_BoundBox = null;

        } else {

            m_BoundBox = new Rectangle2D.Double(r.getX(), r.getY(),

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

        }

    }

    /**

     * Returns the bounding box in centimeters of this FFrame, using paper

     * coordinates

     *

     * @return The bounding box of this FFrame, measured in centimeters.

     */

    public Rectangle2D.Double getBoundBox() {

        return m_BoundBox;

    }

    /**

     * Sets the selected status of the frame.

     *

     * @param selected

     *            <code>true</code> to select the frame, <code>false</code> to

     *            unselect it

     * @see {@link #isSelected()}, {@link #getSelected()}

     */

    public void setSelected(boolean selected) {

        if (selected) {

                doSetSelected(IFFrame.RECT);

        } else {

                doSetSelected(IFFrame.NOSELECT);

        }

    }

    protected void doSetSelected(int selectedStatus) {

            m_Selected = selectedStatus;

    }

    /**

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

     *

     * @param g

     *            Graphics so bre el que dibujar.

     */

    public void drawDraft(Graphics2D g) {

        Rectangle2D r = getBoundingBox(null);

        g.setColor(Color.lightGray);

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

            (int) r.getHeight());

        g.setColor(Color.black);

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

            (int) r.getHeight() - 1);

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

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

        g.setFont(f);

        g.drawString(getName(),

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

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

    }

    /**

     * Rellena con el n�mero de FFrame.

     *

     * @param i

     *            n�mero

     */

    public void setNum(int i) {

        num = i;

    }

    /**

     * Draws the FFrame rectangle on the provided Graphics2D, only showing the

     * FFrame name on an empty rectangle.

     *

     * @param g The graphics to draw on

     */

    public void drawEmpty(Graphics2D g) {

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

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

        g.setFont(f);

        String s =

            this.getNameFFrame() + " " + PluginServices.getText(this, "vacia");

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

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

    }

    /**

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

     * e intersecta.

     *

     * @param rv

     *            Rect�ngulo

     * @param r

     *            Rect�ngulo

     *

     * @return True si intersecta o es null.

     */

    public boolean intersects(Rectangle2D rv, Rectangle2D r) {

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

    }

    /**

     * Rellena el tag del FFrame.

     *

     * @param s

     *            String que representa el valor a guardar en el tag.

     */

    public void setTag(String s) {

        tag = s;

    }

    /**

     * Devuelve el tag.

     *

     * @return tag.

     */

    public String getTag() {

        return tag;

    }

    /**

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

     * representa que contiene un tag.

     *

     * @param g

     *            Graphics sobre el que dibujar el icono.

     */

    public void drawSymbolTag(Graphics2D g) {

        Rectangle2D rec = getBoundingBox(null);

        g.rotate(Math.toRadians(getRotation()), rec.getX()

            + (rec.getWidth() / 2), rec.getY() + (rec.getHeight() / 2));

        try {

            Image image =

                PluginServices.getIconTheme().get("symboltag-icon").getImage();

            g.drawImage(image, (int) rec.getX(), (int) rec.getCenterY(), 30,

                30, null);

        } catch (NullPointerException npe) {

        }

        g.rotate(Math.toRadians(-getRotation()), rec.getX()

            + (rec.getWidth() / 2), rec.getY() + (rec.getHeight() / 2));

    }

    /**

     * Sets the rotation of the frame, measured in arc degrees

     *

     * @param rotation

     *            Rotation to apply to the frame

     */

    public void setRotation(double rotation) {

        m_rotation = rotation;

    }

    /**

     * Gets the affine transform used to rotate the graphics when rotation is not 0

     *

     * @return

     */

    protected AffineTransform getRotationAT() {

            // it has to be calculated each time as the frameRect may change, for instance

            // because a zoom in/out to paper has been performed

            double rotation = getRotation();

            if (getLayoutContext()!=null && getLayoutContext().getAT()!=null && Math.abs(rotation)>0.00001) {

                    AffineTransform rotationAT = new AffineTransform();

                Rectangle2D.Double frameRect = getBoundingBox(getLayoutContext().getAT());

                rotationAT.rotate(Math.toRadians(getRotation()), frameRect.getCenterX(), frameRect.getCenterY());

                return rotationAT;

            }

            return null;

    }

    /**

     * Gets the rotation of the frame, measured in arc degrees

     *

     * @return Rotation of the frame

     */

    public double getRotation() {

        return m_rotation;

    }

    /**

     * Devuelve el nivel en el que se encuentra el FFrame.

     *

     * @return nivel

     */

    public int getLevel() {

        return level;

    }

    /**

     * Inserta el nivel al que se encuentra el FFrame.

     *

     * @param l

     *            entero que refleja el nivel del FFrame.

     */

    public void setLevel(int l) {

        level = l;

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

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

        frame.setBoundBox(this.getBoundBox());

        return frame;

    }

    public void setFrameFactory(FrameFactory flf) {

        frameFactory = flf;

    }

    public FrameFactory getFrameFactory() {

        return frameFactory;

    }

    /**

     * Initilizes the static icons

     */

    public static void initializeIcons() {

        iNEResize =

            PluginServices.getIconTheme().get("neresize-icon").getImage();

        iEResize = PluginServices.getIconTheme().get("eresize-icon").getImage();

        iNResize = PluginServices.getIconTheme().get("nresize-icon").getImage();

        iMove = PluginServices.getIconTheme().get("graphic-move-icon").getImage();

        iSEResize =

            PluginServices.getIconTheme().get("sereresize-icon").getImage();

    }

    public static void registerPersistent() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

            DynStruct definition =

                manager.addDefinition(FFrame.class,

                    PERSISTENCE_DEFINITION_NAME,

                    "FFrame persistence definition", null, null);

            definition.addDynFieldObject(BOUNDINGBOX_FIELD)

                .setClassOfValue(Rectangle2D.class).setMandatory(true);

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

            definition.addDynFieldString(TAG_FIELD).setMandatory(false);

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

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

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

            definition.addDynFieldObject(DOCUMENT_FIELD).setClassOfValue(LayoutDocument.class).setMandatory(false);

            definition.addDynFieldObject(LAYOUT_CONTEXT_FIELD).setClassOfValue(LayoutContext.class).setMandatory(false);

        }

        Attributes.registerPersistent();

        AbstractFFrameViewDependence.registerPersistent();

        FFrameBasic.registerPersistent();

        FFrameGraphics.registerPersistent();

        FFrameSymbol.registerPersistent();

        FFrameGrid.registerPersistent();

        FFrameGroup.registerPersistent();

        FFrameTable.registerPersistent();

        FFrameLegend.registerPersistent();

        FFramePicture.registerPersistent();

        FFrameNorth.registerPersistent();

        FFrameScaleBar.registerPersistent();

        FFrameText.registerPersistent();

        FFrameView.registerPersistent();

        FFrameOverView.registerPersistent();

    }

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        m_BoundBox = (Rectangle2D.Double) state.get(BOUNDINGBOX_FIELD);

        m_Selected = state.getInt(SELECTED_FIELD);

        tag = state.getString(TAG_FIELD);

        m_rotation = state.getDouble(ROTATION_FIELD);

        level = state.getInt(LEVEL_FIELD);

        num = state.getInt(NUM_FIELD);

        if (state.hasValue(DOCUMENT_FIELD)) {

                setDocument((LayoutDocument)state.get(DOCUMENT_FIELD ));

        }

        if (state.hasValue(LAYOUT_CONTEXT_FIELD)) {

                setLayoutContext((LayoutContext) state.get(LAYOUT_CONTEXT_FIELD));

        }

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set(BOUNDINGBOX_FIELD, getBoundBox());

        state.set(SELECTED_FIELD, m_Selected);

        state.set(TAG_FIELD, getTag());

        state.set(ROTATION_FIELD, getRotation());

        state.set(LEVEL_FIELD, getLevel());

        state.set(NUM_FIELD, num);

        state.set(DOCUMENT_FIELD, getDocument());

        state.set(LAYOUT_CONTEXT_FIELD, getLayoutContext());

    }

    public void addObserver(Observer o) {

        observers.addObserver(o);

    }

    public void deleteObserver(Observer o) {

      observers.deleteObserver(o);

    }

    public void deleteObservers() {

       observers.deleteObservers();

    }

    /*

     * (non-Javadoc)

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

     */

        public void dispose() {

        }

    /*

     * (non-Javadoc)

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

     */

        public void frameRemoved() {}

    /*

     * (non-Javadoc)

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

     */

        public void frameAdded() {}

        public LayoutContext getLayoutContext() {

                return layoutContext;

        }

        public void setLayoutContext(LayoutContext layoutContext) {

                this.layoutContext = layoutContext;

        }

        public Document getDocument() {

                return document;

        }

        public void setDocument(Document document) {

                this.document = document;

        }

    /**

     * Gets the visible rectangle of the frame, taking rotation into

     * consideration. The result of this method is the rectangular area

     * of the unrotated frame that will be visible when the frame gets

     * rotated.

     *

     * @param visibleLayoutDocRect

     *                         The visible area of the layout document

     * @param frame

     *                         The bounding box of this frame

     * @return

     *                         the rectangular area of the unrotated frame that will be

     * visible when the frame gets rotated, measured in screen coordinates

     */

    protected Rectangle2D getVisibleRect(Rectangle2D visibleLayoutDocRect, Rectangle2D frame) {

            if (Math.abs(getRotation())>0.00001d) { // non-zero rotation

                    Area area = new Area(frame);

                    AffineTransform at = new AffineTransform();

                    at.rotate(Math.toRadians(getRotation()), frame.getCenterX(), frame.getCenterY());

                    Area rotatedArea = area.createTransformedArea(at);

                    Area visibleArea = new Area(visibleLayoutDocRect);

                    // this is the visible rectangle of the rotated fframeview in layout coordinates

                    visibleArea.intersect(rotatedArea);

                    if (visibleArea.isEmpty()) {

                            return null;

                    }

                    // now we need to calculate the corresponding visible area of the fframeview before rotating,

                    // in order to know which area of the non-rotated fframeview must be drawn

                    try {

                            Area nonRotatedVisibleArea = visibleArea.createTransformedArea(at.createInverse());

                            Rectangle2D nonRotatedVisibleBounds = nonRotatedVisibleArea.getBounds2D();

                            return nonRotatedVisibleBounds;

                        } catch (NoninvertibleTransformException e) {

                                LoggerFactory.getLogger(FFrame.class).error(e.getMessage(), e);

                                return null;

                        }

            }

            else {

                    Rectangle2D.Double visibleArea = new Rectangle2D.Double();

                    Rectangle2D.intersect(visibleLayoutDocRect, frame, visibleArea);

                    if (visibleArea.isEmpty()) {

                            return null;

                    }

                    return visibleArea;

            }

    }

}