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

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

import org.gvsig.andami.PluginServices;

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

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

import org.gvsig.compat.print.PrintAttributes;

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.type.GeometryType;

import org.gvsig.fmap.geom.type.GeometryTypeNotSupportedException;

import org.gvsig.fmap.geom.type.GeometryTypeNotValidException;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol;

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 para contener un gr?fico.

 * 

 * @author Vicente Caballero Navarro

 */

public class FFrameGraphics extends FFrame implements IFFrameEditableVertex {

    private static final GeometryManager GEOMETRY_MANAGER =

        GeometryLocator.getGeometryManager();

    public static final String PERSISTENCE_DEFINITION_NAME = "FFrameGraphics";

    private static final String TYPE_FIELD = "type";

    private static final String SYMBOL_FIELD = "symbol";

    private static final String GEOMETRYADAPTER_FIELD = "geometryAdapter";

    private static double TOL = 0.2;

    protected GeometryType geometryType = null;

    private ISymbol symbol = null;

    private Color color = null;

    private GeometryAdapter geometryAdapter;

    private GeometryAdapter geometryEdit;

    private boolean editing = false;

    private double size = 0.5;

    private BitSet index = new BitSet();

    private MapContextManager mapContextManager = MapContextLocator

        .getMapContextManager();

    /**

     * Crea un nuevo FFrameGraphics.

     */

    public FFrameGraphics() {

    }

    /**

     * DOCUMENT ME!

     * 

     * @param geom

     *            DOCUMENT ME!

     */

    public void setGeometryAdapter(GeometryAdapter geom) {

        geometryAdapter = geom;

    }

    /**

     * Rellena el color que se utlizar? para dibujar el s?mbolo.

     * 

     * @param color

     */

    public void setColor(Color color) {

        this.color = color;

    }

    /**

     * Actualiza el Fsymbol a partir del tipo de Gr?fico que se pase como

     * par?metro.

     * 

     * @param type

     *            tipo de gr?fico.

     * @param at

     *            Transformada.

     */

    public void update(int type, AffineTransform at) {

        setType(type);

        if (color == null) {

            color = Color.black;

        }

        symbol = mapContextManager.getSymbolManager().createSymbol(type);

        if (symbol instanceof IFillSymbol) {

            ((IFillSymbol) symbol).setHasFill(false);

        }

    }

    /**

     * Devuelve el FSymbol que se representa.

     * 

     * @return DOCUMENT ME!

     */

    public ISymbol getFSymbol() {

        return symbol;

    }

    /**

     * Rellena el FSymbol que se representara al dibujar.

     * 

     * @param fs2d

     */

    public void setSymbol(ISymbol symbol) {

        this.symbol = symbol;

    }

    /**

     * 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

     *            DOCUMENT ME!

     */

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

        BufferedImage imgBase) {

        Rectangle2D.Double rect = getBoundingBox(at);

        g.rotate(Math.toRadians(getRotation()), rect.getCenterX(), rect.getCenterY());

        if (intersects(rv, rect)) {

            g.setColor(Color.black);

            if (geometryType.isTypeOf(Geometry.TYPES.POINT)) {

                ((IMarkerSymbol) symbol)

                .setSize((int) (rect.getWidth() * 0.7));

            }

            geometryAdapter.draw(g, at, symbol);

            if (editing) {

                g.setColor(Color.red);

                geometryAdapter.drawVertex(g, at);

            }

        }

        g.rotate(Math.toRadians(-getRotation()), rect.getCenterX(), rect.getCenterY());

    }

    /**

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

     */

    public void updateNum() {

    }

    /**

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

     */

    public int getNum() {

        return 0;

    }

    /**

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

     */

    public String getNameFFrame() {

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

    }

    public String getName() {

        return PERSISTENCE_DEFINITION_NAME;

    }

    /**

     * Inserta el tama?o del punto.

     * 

     * @param size

     *            entero que representa el tama?o del punto.

     */

    public void setSize(double size) {

        this.size = size;

        Rectangle2D r = geometryAdapter.getBounds2D();

        super.setBoundBox(new Rectangle2D.Double(r.getX() - size, r.getY()

            - size, size * 2, size * 2));

    }

    /**

     * Devuelve el tipo de gr?fico que contiene el fframe.

     * 

     * @return tipo de

     */

    public GeometryType getType(){

        return geometryType;

    }

    public void setType(int type) {

        try {

            geometryType = GEOMETRY_MANAGER.getGeometryType(type, SUBTYPES.GEOM2D);

        } catch (GeometryTypeNotSupportedException e) {

            LOG.error("Error setting the geometry type", e);

        } catch (GeometryTypeNotValidException e) {

            LOG.error("Error setting the geometry type", e);

        }

    }

    /**

     * DOCUMENT ME!

     * 

     * @param r

     *            DOCUMENT ME!

     */

    public void setBoundBox(Rectangle2D r) {      

        AffineTransform aT = new AffineTransform();

        if (getBoundBox().getWidth() != 0) {

            double w = r.getWidth() / getBoundBox().getWidth();

            double h = r.getHeight() / getBoundBox().getHeight();

            AffineTransform trans2 =

                AffineTransform.getTranslateInstance(r.getX(), r.getY());

            aT.concatenate(trans2);

            AffineTransform scale1 = AffineTransform.getScaleInstance(w, h);

            aT.concatenate(scale1);

            AffineTransform trans1 =

                AffineTransform.getTranslateInstance(-getBoundBox().getX(),

                    -getBoundBox().getY());

            aT.concatenate(trans1);

            geometryAdapter.applyTransform(aT);

            size = aT.getScaleX() * size;

        }

        super.setBoundBox(r);

    }

    /**

     * DOCUMENT ME!

     */

    public void startEditing() {

        editing = true;

    }

    /**

     * DOCUMENT ME!

     */

    public void stopEditing() {

        editing = false;

    }

    /**

     * DOCUMENT ME!

     * 

     * @return DOCUMENT ME!

     */

    public boolean isEditing() {

        return editing;

    }

    /**

     * DOCUMENT ME!

     * 

     * @param point

     *            DOCUMENT ME!

     * @param geom

     *            DOCUMENT ME!

     */

    public void pointReleased(Point2D point, GeometryAdapter geom) {

        index.clear();

        geometryAdapter = geom;

        Rectangle2D r = geometryAdapter.getBounds2D();

        super.setBoundBox(r);

    }

    /**

     * DOCUMENT ME!

     * 

     * @param point

     *            DOCUMENT ME!

     */

    public void pointPressed(Point2D point) {

        Rectangle2D.Double rect = getBoundBox();

        Point2D[] points = geometryAdapter.getPoints();

        try {

            geometryEdit = (GeometryAdapter) geometryAdapter.clone();

        } catch (CloneNotSupportedException e) {

            LOG.error("Error clonning the geometry", e);

        }

        Point2D pAux1 = new Point2D.Double();

        index.clear();

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

            if (getRotation() != 0) {

                AffineTransform af =

                    AffineTransform.getRotateInstance(

                        Math.toRadians(-getRotation()), rect.x

                            + (rect.width / 2), rect.y + (rect.height / 2));

                af.transform(point, pAux1);

                if (points[i].distance(pAux1) <= TOL) {

                    index.set(i);

                }

            } else {

                if (points[i].distance(point) <= TOL) {

                    index.set(i);

                }

            }

        }

    }

    /**

     * DOCUMENT ME!

     * 

     * @param point

     *            DOCUMENT ME!

     */

    public void pointDragged(Point2D point) {

        // Point2D[] points = geometry.getPoints();

        for (int j = index.nextSetBit(0); j >= 0; j = index.nextSetBit(j + 1)) {

            if (getRotation() != 0) {

                Rectangle2D.Double rect = getBoundBox();

                AffineTransform af =

                    AffineTransform.getRotateInstance(

                        Math.toRadians(-getRotation()), rect.x

                            + (rect.width / 2), rect.y + (rect.height / 2));

                af.transform(point, point);

            }

            geometryEdit.changePoint(j, point);

        }

        geometryEdit.end();

    }

    /**

     * DOCUMENT ME!

     * 

     * @param g

     *            DOCUMENT ME!

     * @param at

     *            DOCUMENT ME!

     */

    public void paint(Graphics2D g, AffineTransform at) {

        if (geometryEdit != null) {

            Rectangle2D.Double rect = getBoundingBox(at);

            if (getRotation() != 0) {

                g.rotate(Math.toRadians(getRotation()), rect.x

                    + (rect.width / 2), rect.y + (rect.height / 2));

                geometryEdit.paint(g, at, false);

                g.rotate(Math.toRadians(-getRotation()), rect.x

                    + (rect.width / 2), rect.y + (rect.height / 2));

            } else {

                geometryEdit.paint(g, at, false);

            }

        }

    }

    /**

     * DOCUMENT ME!

     * 

     * @return DOCUMENT ME!

     */

    public GeometryAdapter getGeometry() {

        return geometryEdit;

    }

    public void initialize() {

    }

    /**

     * 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 (geometryAdapter instanceof CircleAdapter) {

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

                return NE;

            } else

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

                    return SE;

                } else

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

                        return SO;

                    } else

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

                            return NO;

                        } else

                            if (getBoundingBox(null).contains(p.getX(),

                                p.getY())) {

                                return RECT;

                            }

            return NOSELECT;

        }

        return super.getContains(p);

    }

    /**

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

        if (geometryAdapter instanceof CircleAdapter) {

            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.rotate(Math.toRadians(-getRotation()), r.getX()

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

        } else {

            super.drawHandlers(g);

        }

    }

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

        PrintAttributes printingProperties) {

        Rectangle2D.Double rect = getBoundingBox(at);

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

            rect.y + (rect.height / 2));

        g.setColor(Color.black);

        geometryAdapter.print(g, at, symbol, printingProperties);

        if (editing) {

            g.setColor(Color.red);

            geometryAdapter.drawVertex(g, at);

        }

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

            rect.y + (rect.height / 2));

    }

    public static void registerPersistent() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

            DynStruct definition =

                manager.addDefinition(FFrameGraphics.class,

                    PERSISTENCE_DEFINITION_NAME,

                    "FFrameGraphics persistence definition", null, null);

            definition.extend(manager

                .getDefinition(FFrame.PERSISTENCE_DEFINITION_NAME));

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

            definition.addDynFieldObject(SYMBOL_FIELD).setMandatory(true)

                .setClassOfValue(ISymbol.class);

            definition.addDynFieldObject(GEOMETRYADAPTER_FIELD)

                .setClassOfValue(GeometryAdapter.class);

        }

        GeometryAdapter.registerPersistent();

    }

    @Override

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        super.loadFromState(state);

        try {

            geometryType =  GEOMETRY_MANAGER.getGeometryType(state.getInt(TYPE_FIELD), SUBTYPES.GEOM2D);

        } catch (GeometryTypeNotSupportedException e) {

            LOG.error("Error loading the geometry type", e);

        } catch (GeometryTypeNotValidException e) {

            LOG.error("Error loading the geometry type", e);

        }

        symbol = (ISymbol) state.get(SYMBOL_FIELD);

        geometryAdapter = (GeometryAdapter) state.get(GEOMETRYADAPTER_FIELD);

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        super.saveToState(state);

        state.set(TYPE_FIELD, geometryType.getType());

        state.set(SYMBOL_FIELD, symbol);

        state.set(GEOMETRYADAPTER_FIELD, geometryAdapter);

    }

    public Object clone() throws CloneNotSupportedException {

        FFrameGraphics resp = (FFrameGraphics) super.clone();

        GeometryAdapter nga = null;

        if (geometryAdapter != null) {

            nga = (GeometryAdapter) geometryAdapter.clone();

        }

        resp.setGeometryAdapter(nga);

        return resp;

    }

}