Application: gvSIG desktop

/* 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.Color;

import java.awt.Graphics2D;

import java.awt.event.MouseEvent;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.geom.Point2D.Double;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import org.gvsig.andami.PluginServices;

import org.gvsig.app.project.documents.layout.geometryadapters.PolygonAdapter;

import org.gvsig.compat.print.PrintAttributes;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.symbology.SymbologyLocator;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.IFillSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.ISimpleLineSymbol;

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 b?sica que contiene una FFrame de cualquier tipo.

 * 

 * @author Vicente Caballero Navarro

 */

public class FFrameBasic extends FFrame {

    public static final String PERSISTENCE_DEFINITION_NAME = "FFrameBasic";

    private static final String FFRAMEGRAPHICS_FIELD = "fframeGraphics";

    private static final String FFRAME_FIELD = "fframe";

    private FFrameGraphics fframeGraphics;

    private IFFrame fframe;

    private MapContextManager mapContextManager = MapContextLocator

        .getMapContextManager();

    public void setRectangle(Rectangle2D r) {

        FFrameGraphics graphics =

            (FFrameGraphics) layoutManager

                .createFrame(FFrameGraphics.PERSISTENCE_DEFINITION_NAME);

        PolygonAdapter pa = new PolygonAdapter();

        pa.addPoint(new Point2D.Double(r.getX(), r.getY()));

        pa.addPoint(new Point2D.Double(r.getMaxX(), r.getY()));

        pa.addPoint(new Point2D.Double(r.getMaxX(), r.getMaxY()));

        pa.addPoint(new Point2D.Double(r.getX(), r.getMaxY()));

        pa.addPoint(new Point2D.Double(r.getX(), r.getY()));

        pa.end();

        graphics.setGeometryAdapter(pa);

        graphics.setBoundBox(r);

        /*

         * jaume; moved to ISymbol

         * FSymbol symbol=new FSymbol(FShape.POLYGON,Color.black);

         * symbol.setColor(new Color(255,255,255,0));

         * symbol.setOutlineColor(Color.black);

         */

        IFillSymbol symbol =

            (IFillSymbol) mapContextManager.getSymbolManager().createSymbol(

                IFillSymbol.SYMBOL_NAME);

        symbol.setFillColor(new Color(255, 255, 255, 0));

        ISimpleLineSymbol blackOutline =

            SymbologyLocator.getSymbologyManager().createSimpleLineSymbol();

        blackOutline.setLineColor(Color.BLACK);

        symbol.setOutline(blackOutline);

        graphics.setSymbol(symbol);

        graphics.setType(Geometry.TYPES.CURVE);

        setFframeGraphics(graphics);

    }

    public FFrameBasic() {

    }

    /**

     * 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 para acelerar el dibujado.

     */

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

        BufferedImage imgBase) {

        fframeGraphics.draw(g, at, rv, imgBase);

        if (fframe != null) {

            fframe.draw(g, at, rv, imgBase);

        }

    }

    /**

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

     */

    public String getNameFFrame() {

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

    }

    /**

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

        // fframeGraphics.setPrintingProperties(printingProperties);

        fframeGraphics.print(g, at, geom, printingProperties);

        // fframeGraphics.setPrintingProperties(null);

        if (fframe != null) {

            fframe.print(g, at, geom, printingProperties);

        }

    }

    public IFFrame getFframe() {

        return fframe;

    }

    public void setFframe(IFFrame fframe) {

        this.fframe = fframe;

    }

    public FFrameGraphics getFframeGraphics() {

        return fframeGraphics;

    }

    public void setFframeGraphics(FFrameGraphics fframeGraphics) {

        this.fframeGraphics = fframeGraphics;

    }

    public void drawHandlers(Graphics2D g) {

        fframeGraphics.drawHandlers(g);

    }

    public IFFrame clone() throws CloneNotSupportedException {

        FFrameBasic basic = new FFrameBasic();

        basic.setFframeGraphics((FFrameGraphics) fframeGraphics.clone());

        if (fframe != null) {

            basic.setFframe((IFFrame) fframe.clone());

        }

        return basic;

    }

    public boolean contains(Double p) {

        return getFframeGraphics().contains(p);

    }

    public void drawDraft(Graphics2D g) {

        super.drawDraft(g);

    }

    public void drawEmpty(Graphics2D g) {

        super.drawEmpty(g);

    }

    public void drawSymbolTag(Graphics2D g) {

        super.drawSymbolTag(g);

    }

    public java.awt.geom.Rectangle2D.Double getBoundBox() {

        return getFframeGraphics().getBoundBox();

    }

    public java.awt.geom.Rectangle2D.Double getBoundingBox(AffineTransform at) {

        return getFframeGraphics().getBoundingBox(at);

    }

    public int getContains(Double p) {

        return getFframeGraphics().getContains(p);

    }

    public int getLevel() {

        return super.getLevel();

    }

    public Rectangle2D getMovieRect(int difx, int dify) {

        return fframeGraphics.getMovieRect(difx, dify);

    }

    public String getName() {

        return PERSISTENCE_DEFINITION_NAME;

    }

    public double getRotation() {

        return super.getRotation();

    }

    public int getSelected() {

        return fframeGraphics.getSelected();

    }

    public String getTag() {

        return super.getTag();

    }

    public boolean intersects(Rectangle2D rv, Rectangle2D r) {

        return super.intersects(rv, r);

    }

    public void setBoundBox(Rectangle2D r) {

        if (getFframeGraphics() != null) {

            getFframeGraphics().setBoundBox(r);

        }

        if (getFframe() != null) {

            getFframe().setBoundBox(r);

            // super.setBoundBox(r);

        }

    }

    public void setLevel(int l) {

        super.setLevel(l);

    }

    public void setNum(int i) {

        super.setNum(i);

    }

    public void setRotation(double rotation) {

        super.setRotation(rotation);

    }

    public void setSelected(boolean b) {

        fframeGraphics.setSelected(b);

    }

    public void setSelected(Point2D p, MouseEvent e) {

        fframeGraphics.setSelected(p, e);

    }

    public void setTag(String s) {

        super.setTag(s);

    }

    public void updateRect(Rectangle2D r, AffineTransform at) {

        getFframeGraphics().updateRect(r, at);

    }

    public static void registerPersistent() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

            DynStruct definition =

                manager.addDefinition(FFrameBasic.class,

                    PERSISTENCE_DEFINITION_NAME,

                    "FFrameBasic persistence definition", null, null);

            definition.extend(manager

                .getDefinition(FFrame.PERSISTENCE_DEFINITION_NAME));

            definition.addDynFieldObject(FFRAMEGRAPHICS_FIELD)

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

            definition.addDynFieldDouble(FFRAME_FIELD);

        }

    }

    @Override

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        super.loadFromState(state);

        fframeGraphics = (FFrameGraphics) state.get(FFRAMEGRAPHICS_FIELD);

        fframe = (IFFrame) state.get(FFRAME_FIELD);

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set(FFRAMEGRAPHICS_FIELD, fframeGraphics);

        state.set(FFRAME_FIELD, fframe);

    }

}