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

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import org.gvsig.andami.PluginServices;

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

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

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

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

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

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

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

import org.gvsig.app.project.documents.layout.gui.LayoutPanel;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.observer.Observable;

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;

/**

 * Clase que implementa la interface IFFrame con los m�todos por defecto de

 * todos los FFrames que extenderan de este, dejando uno como m�todo

 * abstracto para implementar por todos los FFrames para ser dibujados.

 * 

 * @author Vicente Caballero Navarro

 */

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;

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

    }

    /**

     * Establece que tipo de selecci�n se realiza sobre el fframe.

     * 

     * @param p

     *            punto sobre el que se debe de establecer si se selecciona o no

     *            el fframe.

     */

    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;

    }

    /**

     * Devuelve un entero que representa el tipo de selecci�n que se ha

     * realizado sobre el fframe.

     * 

     * @return tipo de selecci�n que se ha realizado.

     */

    public int getSelected() {

        return m_Selected;

    }

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

    }

    /**

     * Devuelve un entero que representa donde esta contenido el punto que se

     * pasa como par�metro.

     * 

     * @param p

     *            punto a comparar.

     * 

     * @return entero que representa como esta contenido el punto.

     */

    public int getContains(Point2D p) {

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

            return N;

        } else

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

                return NE;

            } else

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

                    return E;

                } else

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

                        return SE;

                    } else

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

                            return S;

                        } else

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

                                return SO;

                            } else

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

                                    return O;

                                } else

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

                                        return NO;

                                    } else

                                        if (getBoundingBox(null).contains(

                                            p.getX(), p.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;

    }

    /**

     * Este m�todo se implementa en cada una de las fframe, ya que cada una se

     * dibuja de una forma diferente sobre el graphics. M�todo que dibuja

     * sobre el graphics que se le pasa como par�metro, seg�n la

     * transformada

     * afin que se debe de aplicar y el rect�ngulo que se debe de dibujar.

     * M�todo que dibuja sobre el graphics que se le pasa como par�metro,

     * seg�n la transformada afin que se debe de aplicar y el rect�ngulo que

     * se debe de dibujar.

     * 

     * @param g

     *            Graphics

     * @param at

     *            Transformada afin.

     * @param r

     *            rect�ngulo sobre el que hacer un clip.

     * @param imgBase

     *            DOCUMENT ME!

     */

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

    }

    /**

     * Rellena con el rect�ngulo que se pasa como par�metro el boundBox(en

     * cent�metros) del fframe del cual con una transformaci�n se podr�

     * calcular el BoundingBox (en pixels).

     * 

     * @param r

     *            Rect�ngulo en cent�metros.

     */

    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

     * Returns the rectangle that represents the FFrame in centimeters.

     * 

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

     */

    public Rectangle2D.Double getBoundBox() {

        return m_BoundBox;

    }

    /**

     * Pasando como par�metro true, se toma como que esta seleccionado el

     * fframe y si es false como que esta sin seleccionar, de esta forma se

     * selecciona un fframe directamente sin comprobar si un punto esta

     * contenido en �l.

     * 

     * @param b

     *            true si se quiere seleccionar y false si se quiere

     *            deseleccionar.

     */

    public void setSelected(boolean b) {

        if (b) {

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

    }

    /**

     * Rellenar la rotaci�n para aplicar al FFrame.

     * 

     * @param rotation

     *            rotaci�n que se quiere aplicar.

     */

    public void setRotation(double rotation) {

        m_rotation = rotation;

    }

    /**

     * Devuelve la rotaci�n del FFrame.

     * 

     * @return Rotaci�n del FFrame.

     */

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

        }

        /**

         * This method is called just before the FFrame is going to

         * be added to the Layout

         */

        protected void beforeAdded() {}

        /**

         * This method is called just before the FFrame is going to

         * be removed from the Layout

         */

        protected void beforeRemoved() {}

        /**

         * This method is called just after the FFrame has been

         * added to the Layout

         */

        protected void afterAdded() {}

        /**

         * This method is called just before the FFrame is going to

         * be removed from the Layout

         */

        protected void afterRemoved() {}

        public void update(Observable observable, Object notification) {

                if ((notification != null) && (notification instanceof FrameChangedNotificationImpl)){

                        FrameChangedNotificationImpl layoutNotification = (FrameChangedNotificationImpl)notification;

                        if (this.equals(layoutNotification.getFrame()) && FrameChangedNotificationImpl.FRAME_ADDED.equals(layoutNotification.getType())){

                                afterAdded();

                        }else if (this.equals(layoutNotification.getFrame()) && FrameChangedNotificationImpl.FRAME_ADDING.equals(layoutNotification.getType())){

                                beforeAdded();

                        }else if (this.equals(layoutNotification.getFrame()) && FrameChangedNotificationImpl.FRAME_REMOVING.equals(layoutNotification.getType())){

                                beforeRemoved();

                        }else if (this.equals(layoutNotification.getFrame()) && FrameChangedNotificationImpl.FRAME_REMOVED.equals(layoutNotification.getType())){

                                afterRemoved();

                        }

                }

        }

        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;

        }

}