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

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.andami.PluginServices;

import org.gvsig.app.project.Project;

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

import org.gvsig.compat.print.PrintAttributes;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 * FFrame que contiene a su vez un ArrayList de FFrames de cualquier tipo

 * incluso de si mismo.

 * 

 * @author Vicente Caballero Navarro

 */

public class FFrameGroup extends AbstractFFrameViewDependence implements

    IFFrameUseProject, IFFrameViewDependence {

    public static final String PERSISTENCE_DEFINITION_NAME = "FFrameGroup";

    private static final String FFRAMES_FIELD = "fframes";

    private List<IFFrame> m_fframes = new ArrayList<IFFrame>();

    private Rectangle2D.Double rg = null;

    private AffineTransform m_at;

    private Project project;

    /**

     * Crea un nuevo FFrameGroup.

     */

    public FFrameGroup() {

    }

    /**

     * A?ade al Arraylist un nuevo FFrame para formar parte del grupo.

     * 

     * @param fframe

     *            FFrame a a?adir.

     */

    public void addFFrame(IFFrame fframe) {

        m_fframes.add(fframe);

    }

    /**

     * Devuelve una ArrayList que contiene todos los FFrames que forman parte

     * del grupo.

     * 

     * @return Arraylist con los fframes.

     */

    public IFFrame[] getFFrames() {

        return m_fframes.toArray(new IFFrame[0]);

    }

    /**

     * Devuelve el rect?ngulo que contiene a todos los fframes seleccionados.

     * 

     * @param at

     *            Matriz de transformaci?n

     * 

     * @return Rect?ngulo.

     */

    public Rectangle2D.Double getRectangle(AffineTransform at) {

        boolean first = true;

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

        IFFrame[] fframes = getFFrames();

        for (int i = 0; i < fframes.length; i++) {

            Rectangle2D.Double rs = fframes[i].getBoundingBox(at);

            if (first) {

                rec.setRect(rs);

                first = false;

            }

            rec.add(rs);

        }

        rg = new Rectangle2D.Double();

        rg.setRect(FLayoutUtilities.toSheetRect(rec, m_at));

        return rec;

    }

    /**

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

     *            rect?ngulo sobre el que hacer un clip.

     * @param imgBase

     *            Imagen utilizada para acelerar el dibujado.

     */

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

        BufferedImage imgBase) {

        Rectangle2D.Double r = getBoundingBox(at);

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

            + (r.height / 2));

        m_at = at;

        for (int i = 0; i < m_fframes.size(); i++) {

            m_fframes.get(i).draw(g, at, rv, imgBase);

        }

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

            + (r.height / 2));

    }

    /**

     * Rellena la transformada que se esta utilizando en el Layout.

     * 

     * @param at

     *            Matriz de transformaci?n.

     */

    public void setAt(AffineTransform at) {

        m_at = at;

    }

    /**

     * Reimplementaci?n del m?todo papa poder modificar los BoundBox de cada

     * uno de los FFrames que contiene dentro este FFrameGroup.

     * 

     * @param r

     *            Rect?ngulo.

     */

    public void setBoundBox(Rectangle2D r) {

        getBoundBox().setRect(r.getX(), r.getY(), r.getWidth(), r.getHeight());

        double dx = 1;

        double dy = 1;

        double dw = 1;

        double dh = 1;

        if (rg != null) {

            Rectangle2D.Double raux1 =

                new Rectangle2D.Double(rg.x, rg.y, rg.width, rg.height);

            dx = r.getX() - raux1.x;

            dy = r.getY() - raux1.y;

            dw = r.getWidth() / raux1.width;

            dh = r.getHeight() / raux1.height;

            IFFrame[] fframes = getFFrames();

            for (int i = 0; i < fframes.length; i++) {

                IFFrame fframe = fframes[i];

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

                raux.setRect(fframe.getBoundBox());

                AffineTransform escalado = new AffineTransform();

                escalado.setToScale(dw, dh);

                escalado.translate(dx - r.getX(), dy - r.getY());

                Point2D.Double pd = new Point2D.Double();

                escalado.transform(new Point2D.Double(raux.x, raux.y), pd);

                raux.x = pd.x + r.getX();

                raux.y = pd.y + r.getY();

                raux.width = raux.width * dw;

                raux.height = raux.height * dh;

                fframe.setBoundBox(raux);

            }

        } else {

            rg = new Rectangle2D.Double();

            rg.setRect(r);

        }

        rg.setRect(r);

    }

    /**

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

     */

    public String getNameFFrame() {

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

    }

    public String getName() {

        return PERSISTENCE_DEFINITION_NAME;

    }

    /**

     * @see org.gvsig.app.project.documents.layout.fframes.IFFrame#print(java.awt.Graphics2D,

     *      java.awt.geom.AffineTransform)

     */

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

        PrintAttributes printingProperties) {

        Rectangle2D.Double r = getBoundingBox(at);

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

            + (r.height / 2));

        IFFrame[] fframes = m_fframes.toArray(new IFFrame[0]);

        for (int i = 0; i < fframes.length; i++) {

            fframes[i].print(g, at, geom, printingProperties);

        }

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

            + (r.height / 2));

    }

    /**

     * Inserta una referencia al proyecto nesecario.

     * 

     * @param project

     *            DOCUMENT ME!

     */

    public void setProject(Project project) {

        this.project = project;

    }

    public void initialize() {

    }

    public void clearFFrames() {

        m_fframes.clear();

    }

    public IFFrame removeFFrame(int i) {

        return m_fframes.remove(i);

    }

    public void removeFFrame(IFFrame fframe) {

        m_fframes.remove(fframe);

    }

    public IFFrame clone() throws CloneNotSupportedException {

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

        frame.setSelected(this.getSelected() != IFFrame.NOSELECT);

        frame.m_fframes = new ArrayList<IFFrame>();

        for (int i = 0; i < m_fframes.size(); i++) {

            frame.addFFrame((IFFrame) m_fframes.get(i).clone());

        }

        frame.m_at = new AffineTransform(m_at);

        frame.rg = new Rectangle2D.Double(rg.x, rg.y, rg.width, rg.height);

        return frame;

    }

    public void setFFrameDependence(IFFrame f) {

        IFFrame[] frames = getFFrames();

        for (int i = 0; i < frames.length; i++) {

            if (frames[i] instanceof IFFrameViewDependence) {

                ((IFFrameViewDependence) frames[i]).setFFrameDependence(f);

            }

        }

    }

    public IFFrame[] getFFrameDependence() {

        IFFrame[] frames = getFFrames();

        ArrayList<IFFrame> dependences = new ArrayList<IFFrame>();

        for (int i = 0; i < frames.length; i++) {

            if (frames[i] instanceof IFFrameViewDependence) {

                IFFrame[] framesAux =

                    ((IFFrameViewDependence) frames[i]).getFFrameDependence();

                for (int j = 0; j < framesAux.length; j++) {

                    dependences.add(framesAux[i]);

                }

            }

        }

        return dependences.toArray(new IFFrame[0]);

    }

    public void refreshDependence(IFFrame fant, IFFrame fnew) {

        IFFrame[] frames = getFFrames();

        for (int i = 0; i < frames.length; i++) {

            if (fnew instanceof FFrameGroup) {

                IFFrame[] framesGroupNew = ((FFrameGroup) fnew).getFFrames();

                for (int j = 0; j < framesGroupNew.length; j++) {

                    if (fant instanceof FFrameGroup) {

                        IFFrame[] framesGroupAnt =

                            ((FFrameGroup) fant).getFFrames();

                        for (int k = 0; k < framesGroupAnt.length; k++) {

                            if (framesGroupAnt[k] instanceof IFFrameViewDependence) {

                                refreshDependence(framesGroupAnt[k],

                                    framesGroupNew[j]);

                            }

                        }

                    }

                }

            } else

                if (frames[i] instanceof IFFrameViewDependence) {

                    ((IFFrameViewDependence) frames[i]).refreshDependence(fant,

                        fnew);

                }

        }

    }

    public static void registerPersistent() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

            DynStruct definition =

                manager.addDefinition(FFrameGroup.class,

                    PERSISTENCE_DEFINITION_NAME,

                    "FFrameGroup persistence definition", null, null);

            definition

                .extend(manager

                    .getDefinition(AbstractFFrameViewDependence.PERSISTENCE_DEFINITION_NAME));

            definition.addDynFieldList(FFRAMES_FIELD)

                .setClassOfItems(IFFrame.class).setMandatory(true);

        }

    }

    @Override

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        super.loadFromState(state);

        m_fframes = (List<IFFrame>) state.getList(FFRAMES_FIELD);

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set(FFRAMES_FIELD, m_fframes);

    }

}