| gvSIG desktop 1

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package org.gvsig.app.project.documents.layout.geometryadapters;

import java.awt.Graphics2D;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import org.gvsig.compat.print.PrintAttributes;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.lang.Cloneable;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

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

/**

 * Abstract adaptor to relate the geometries with the fframes and to be able to

 * integrate them in the Layout.

 * 

 * @author Vicente Caballero Navarro

 */

public abstract class GeometryAdapter implements Persistent, Cloneable {

    public static final String PERSISTENCE_DEFINITION_NAME = "GeometryAdapter";

    private static final String POINTS_FIELD = "points";

    protected static final GeometryManager geomManager = GeometryLocator.getGeometryManager();

    private List<Point2D> points = new ArrayList<Point2D>();

    private Geometry geometry;

    public GeometryAdapter() {

        super();

    }

    /**

     * Add a point to de geometry.

     * 

     * @param point

     *            Point that is added.

     * 

     * @return Number of points that contains the geometry.

     */

    public int addPoint(Point2D point) {

        points.add(point);

        return points.size();

    }

    /**

     * End the creation of the geometry with the last point added.

     */

    public void end() {

        obtainShape((Point2D) points.get(points.size() - 1));

    }

    /**

     * Adds the GeneralPathX with all the points of the geometry.

     * 

     * @param gpx

     *            GeneralPathX

     */

    protected void setGeometry(Geometry geometry) {

        this.geometry = geometry;

    }

    /**

     * Obtains the geometry passing him as parameter the last point.

     * 

     * @param p

     *            Last Point.

     * @throws CreateGeometryException 

     */

    public abstract void obtainShape(Point2D p);

    /**

     * Applies the transformation to all the points of the geometry.

     * 

     * @param at

     *            AffineTransform

     */

    public void applyTransform(AffineTransform at) {

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

            at.transform((Point2D) points.get(i), (Point2D) points.get(i));

        }

        geometry.transform(at);

    }

    /**

     * It draws the geometry on the Graphics that is passed like parameter.

     * 

     * @param g

     *            Graphics

     * @param at

     *            AffineTransform

     * @param symbol

     *            FSymbol

     */

    public void draw(Graphics2D g, AffineTransform at, ISymbol symbol){

        symbol.draw(g, at, geometry, null, null);

    }

    /**

     * It print the geometry on the Graphics that is passed like parameter.

     * 

     * @param g

     *            Graphics

     * @param at

     *            AffineTransform

     * @param symbol

     *            ISymbol

     * @param properties

     */

    public void print(Graphics2D g, AffineTransform at,

        ISymbol symbol, PrintAttributes properties){

        symbol.print(g, at, getGeometry(), properties);

    }

    /**

     * Paints the geometry on the Graphics adding him the last point if the

     * parameter andLastPoint is true.

     * 

     * @param g

     *            Graphics

     * @param at

     *            AffineTransform

     * @param andLastPoint

     *            If true add last point.

     */

    public abstract void paint(Graphics2D g, AffineTransform at,

        boolean andLastPoint);

    /**

     * Set the point of cursor.

     * 

     * @param p

     *            Point of cursor.

     */

    public abstract void pointPosition(Point2D p);

    /**

     * Obtains the shape of the Geometry.

     * 

     * @return Geometry.

     * @deprecated

     */

    public Geometry getGeometry(AffineTransform at){

        Geometry clonedGeom = geometry.cloneGeometry();

        clonedGeom.transform(at);

        return clonedGeom;

    }

    /**

     * Returns the geometry to draw

     * @return

     *      the geometry

     */

    public Geometry getGeometry(){

        return geometry;

    }

    /**

     * Returns all the points of Geometry.

     * 

     * @return Array of points.

     */

    public Point2D[] getPoints() {

        return (Point2D[]) points.toArray(new Point2D[0]);

    }

    /**

     * Draws a handler in each vertex of the Geometry.

     * 

     * @param g

     *            Graphics

     * @param at

     *            AffineTransform.

     */

    public void drawVertex(Graphics2D g, AffineTransform at) {

        Point2D[] ps = getPoints();

        Point2D[] pointRes = new Point2D[ps.length];

        at.transform(ps, 0, pointRes, 0, ps.length);

        int d = 3;

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

            g.fillRect((int) pointRes[i].getX() - d, (int) pointRes[i].getY()

                - d, d * 2, d * 2);

        }

    }

    /**

     * Modifies a point of the Geometry from an index by the one that is passed

     * like parameter.

     * 

     * @param pos

     *            Index

     * @param point

     *            Point

     */

    public void changePoint(int pos, Point2D point) {

        this.points.set(pos, point);

    }

    /**

     * Add all the points of Geometry.

     * 

     * @param points

     *            All points.

     */

    public void setPoints(Point2D[] points) {

        this.points.clear();

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

            this.points.add(points[i]);

        }

    }

    /**

     * Remove last point of Geometry.

     */

    public void delLastPoint() {

        if (points.size() > 0) {

            points.remove(points.size() - 1);

        }

    }

    public Object clone() throws CloneNotSupportedException {

        GeometryAdapter cloneAdapter = (GeometryAdapter) super.clone();

        Collections.copy(cloneAdapter.points, this.points);

        cloneAdapter.geometry = (Geometry) this.geometry.cloneGeometry();

        return cloneAdapter;

    }

    public Rectangle2D getBounds2D() {

        Rectangle2D r = geometry.getBounds2D();

        double w = r.getWidth();

        double h = r.getHeight();

        double x = r.getX();

        double y = r.getY();

        boolean modified = false;

        if (r.getWidth() < 0.5) {

            modified = true;

            w = 0.5;

            x = x - 0.25;

        }

        if (r.getHeight() < 0.5) {

            modified = true;

            h = 0.5;

            y = y - 0.25;

        }

        if (modified) {

            return new Rectangle2D.Double(x, y, w, h);

        }

        return r;

    }

    public static void registerPersistent() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

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

            DynStruct definition =

                manager.addDefinition(GeometryAdapter.class,

                    PERSISTENCE_DEFINITION_NAME,

                    "GeometryAdapter persistence definition", null, null);

            definition.addDynFieldList(POINTS_FIELD)

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

        }

        CircleAdapter.registerPersistent();

        PointAdapter.registerPersistent();

        PolygonAdapter.registerPersistent();

        PolyLineAdapter.registerPersistent();

        RectangleAdapter.registerPersistent();

    }

    public void loadFromState(PersistentState state)

        throws PersistenceException {

        points = state.getList(POINTS_FIELD);

        obtainShape((Point2D) points.get(points.size() - 1));

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set(POINTS_FIELD, points);

    }

}