| gvSIG desktop 1

 * Created on 12-may-2005

 *

 * 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

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

 */

import com.iver.cit.gvsig.fmap.core.AbstractHandler;

import com.iver.cit.gvsig.fmap.core.FShape;

import com.iver.cit.gvsig.fmap.core.Handler;

import com.iver.cit.gvsig.fmap.core.gt2.factory.FactoryFinder;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Geometry;

    private AffineTransform affineTransform = null;

    private boolean generalize = false;

    private double maxDistance = 1;

    // cached iterators

    private LineIterator lineIterator = new LineIterator();

    private GeomCollectionIterator collIterator = new GeomCollectionIterator();

    private float xScale;

    private float yScale;

    private GeometryFactory geomFac;

    private MathTransform mathTransform;

    private static final AffineTransform IDENTITY = new AffineTransform();

		/**

		 * Crea un nuevo PointHandler.

		 *

		 *

		 * @return DOCUMENT ME!

		 */

			c.x+=x;

			c.y+=y;

			geometry.geometryChanged();

			geometry.geometryChanged();

		}

	}

    /**

     * Creates a new LiteShape object.

     *

     * @param generalize - set to true if the geometry need to be generalized

     *        during rendering

     * @param maxDistance - distance used in the generalization process

     */

    public FLiteShape(Geometry geom, AffineTransform at, MathTransform mathTransform, boolean generalize,

        double maxDistance) throws TransformException, FactoryException {

     * @param generalize - set to true if the geometry need to be generalized

     *        during rendering

     * @param maxDistance - distance used in the generalization process

     */

    public FLiteShape(Geometry geom, AffineTransform at, MathTransform mathTransform, boolean generalize) throws TransformException, FactoryException {

        if( geom!=null)

     * @param generalize - set to true if the geometry need to be generalized

     *        during rendering

     * @param maxDistance - distance used in the generalization process

     */

    public FLiteShape(Geometry geom, AffineTransform at, boolean generalize,

        double maxDistance){

        this(geom, at, generalize);

        this.maxDistance = maxDistance;

    }

    public FLiteShape(Geometry geom)

    {

        this(geom, null, false);

     * @param generalize - set to true if the geometry need to be generalized

     *        during rendering

     * @param maxDistance - distance used in the generalization process

     */

    public FLiteShape(Geometry geom, AffineTransform at, boolean generalize){

        if( geom!=null)

                (affineTransform.getScaleY() * affineTransform.getScaleY())

                + (affineTransform.getShearY() * affineTransform.getShearY()));

    }

    private void transformGeometry(Geometry geometry) throws TransformException, FactoryException {

        if( mathTransform==null || mathTransform.isIdentity() ){

            if( !affineTransform.isIdentity() ){

                MathTransformFactory factory=FactoryFinder.getMathTransformFactory(null);

            factory.createConcatenatedTransform(mathTransform, factory.createAffineTransform(new GeneralMatrix(affineTransform)));

            affineTransform=IDENTITY;

        }

        if( mathTransform==null || mathTransform.isIdentity() )

            return;

        CoordinateSequenceTransformer transformer=new InPlaceCoordinateSequenceTransformer();

        if (geometry instanceof GeometryCollection) {

            GeometryCollection collection=(GeometryCollection)geometry;

            }

        }else if (geometry instanceof Point) {

            transformer.transform(((Point)geometry).getCoordinateSequence(), mathTransform);

            Polygon polygon=(Polygon) geometry;

            transformGeometry(polygon.getExteriorRing());

            for (int i = 0; i < polygon.getNumInteriorRing(); i++) {

            }

        } else if (geometry instanceof LineString) {

            transformer.transform(((LineString)geometry).getCoordinateSequence(), mathTransform);

    }

    private GeometryFactory getGeometryFactory() {

     * object instead of creating it again and again during rendering

     *

     * @param g

     */

    public void setGeometry(Geometry g) throws TransformException, FactoryException {

        if( g!=null){

        } catch (FactoryException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        xScale = (float) Math.sqrt(

            (affineTransform.getScaleX() * affineTransform.getScaleX())

            + (affineTransform.getShearX() * affineTransform.getShearX()));

        yScale = (float) Math.sqrt(

            (affineTransform.getScaleY() * affineTransform.getScaleY())

            + (affineTransform.getShearY() * affineTransform.getShearY()));

    }

    /**

     * Tests if the interior of the <code>Shape</code> entirely contains the

     * specified <code>Rectangle2D</code>. This method might conservatively

     * return <code>false</code> when:

     * <ul>

     * <li>

     * the <code>intersect</code> method returns <code>true</code> and

     * expensive.

     * </li>

     * </ul>

     * This means that this method might return <code>false</code> even though

     * the <code>Shape</code> contains the <code>Rectangle2D</code>. The

     * <code>Area</code> class can be used to perform more accurate

     * rectangular area must lie within the <code>Shape</code> for the entire

     * rectanglar area to be considered contained within the

     * <code>Shape</code>.

     * <p>

     * This method might conservatively return <code>false</code> when:

     * <ul>

     * <li>

     * the <code>intersect</code> method returns <code>true</code> and

     * entirely contains the rectangular area are prohibitively expensive.

     * </li>

     * </ul>

     * This means that this method might return <code>false</code> even though

     * the <code>Shape</code> contains the rectangular area. The

     * <code>Area</code> class can be used to perform more accurate

     * boundary and provides access to the geometry of the <code>Shape</code>

     * outline.  If an optional {@link AffineTransform} is specified, the

     * coordinates returned in the iteration are transformed accordingly.

     * <p>

     * Each call to this method returns a fresh <code>PathIterator</code>

     * object that traverses the geometry of the <code>Shape</code> object

     * independently from any other <code>PathIterator</code> objects in use

     * at the same time.

     * </p>

     * <p>

     * It is recommended, but not guaranteed, that objects implementing the

     * <code>Shape</code> interface isolate iterations that are in process

     * from any changes that might occur to the original object's geometry

     * during such iterations.

     * </p>

     * <p>

     * Before using a particular implementation of the <code>Shape</code>

     * interface in more than one thread simultaneously, refer to its

            pi = new PointIterator((Point) geometry, combined);

        }

            pi = new PolygonIterator((Polygon) geometry, combined, generalize,

                    maxDistance);

            if(combined == affineTransform)

                lineIterator.init((LineString) geometry, combined, generalize,

                        (float) maxDistance, xScale, yScale);

                lineIterator.init((LineString) geometry, combined, generalize,

                        (float) maxDistance);

            pi = lineIterator;

     * Returns an iterator object that iterates along the <code>Shape</code>

     * boundary and provides access to a flattened view of the

     * <code>Shape</code> outline geometry.

     * <p>

     * Only SEG_MOVETO, SEG_LINETO, and SEG_CLOSE point types are returned by

     * the iterator.

     * </p>

     * <p>

     * If an optional <code>AffineTransform</code> is specified, the

     * coordinates returned in the iteration are transformed accordingly.

     * </p>

     * <p>

     * The amount of subdivision of the curved segments is controlled by the

     * <code>flatness</code> parameter, which specifies the maximum distance

     * flattening parameters to be treated as larger values.  This limit, if

     * there is one, is defined by the particular implementation that is used.

     * </p>

     * <p>

     * Each call to this method returns a fresh <code>PathIterator</code>

     * object that traverses the <code>Shape</code> object geometry

     * independently from any other <code>PathIterator</code> objects in use

     * at the same time.

     * </p>

     * <p>

     * It is recommended, but not guaranteed, that objects implementing the

     * <code>Shape</code> interface isolate iterations that are in process

     * from any changes that might occur to the original object's geometry

     * during such iterations.

     * </p>

     * <p>

     * Before using a particular implementation of this interface in more than

     * one thread simultaneously, refer to its documentation to verify that it

     * Tests if the interior of the <code>Shape</code> intersects the interior

     * of a specified <code>Rectangle2D</code>. This method might

     * conservatively return <code>true</code> when:

     * <ul>

     * <li>

     * there is a high probability that the <code>Rectangle2D</code> and the

     * prohibitively expensive.

     * </li>

     * </ul>

     * This means that this method might return <code>true</code> even though

     * the <code>Rectangle2D</code> does not intersect the <code>Shape</code>.

     *

     * of a specified rectangular area. The rectangular area is considered to

     * intersect the <code>Shape</code> if any point is contained in both the

     * interior of the <code>Shape</code> and the specified rectangular area.

     * <p>

     * This method might conservatively return <code>true</code> when:

     * <ul>

     * <li>

     * there is a high probability that the rectangular area and the

     * prohibitively expensive.

     * </li>

     * </ul>

     * This means that this method might return <code>true</code> even though

     * the rectangular area does not intersect the <code>Shape</code>. The

     * {@link java.awt.geom.Area Area} class can be used to perform more

        return geometry.getFactory().createPolygon(lr, null);

    }

    /**

     * Returns the affine transform for this lite shape

     * @return

        if (geometry instanceof MultiLineString)

            type = FShape.LINE;

        return type;

    }

            pointCoords[i] = pt.getX();

            pointCoords[i+1] = pt.getY();

        } */

    }

	public Handler[] getStretchingHandlers() {