/ - Diff - | gvSIG desktop 1 - gvSIG

      * @author FJP
      */
     public class FGeometry implements IGeometry3D {
     	/**
+    	 *
     	 */
     	private static final long serialVersionUID = 5431865770186523337L;
     	private FShape shp;
     	private Rectangle2D bounds2D;
         /**
+         *
          */
         private static final long serialVersionUID = 5431865770186523337L;
         private FShape shp;
         private Rectangle2D bounds2D;
         private int type=FShape.LINE;
     	/**
     	 * Crea un nuevo FGeometry.
+    	 *
     	 * @param shp DOCUMENT ME!
     	 */
     	FGeometry(FShape shp) {
     		this.shp = shp;
+    	}
         /**
          * Crea un nuevo FGeometry.
+         *
          * @param shp DOCUMENT ME!
          */
         FGeometry(FShape shp) {
             this.shp = shp;
+        }
     	/* (non-Javadoc)
     	 * @see com.iver.cit.gvsig.fmap.core.IGeometry#draw(java.awt.Graphics2D, com.iver.cit.gvsig.fmap.ViewPort, org.geotools.renderer.style.Style2D)
     	 */
     	public void draw(Graphics2D g, ViewPort vp, FStyle2D symbol) {
     		// OJO CON LA PRECISION. DEBERIAMOS USAR: ((GeneralPathX) shp.m_Polyline).transform(mT);
     		// O HACER UNA FUNCION DE TRANSFORMACI?N QUE USE LOS DOUBLES DEL
     		// SHAPE
     		// Shape shpTrans = vp.getAffineTransform().createTransformedShape(shp);
     		transform(vp.getAffineTransform());
         /* (non-Javadoc)
          * @see com.iver.cit.gvsig.fmap.core.IGeometry#draw(java.awt.Graphics2D, com.iver.cit.gvsig.fmap.ViewPort, org.geotools.renderer.style.Style2D)
          */
         public void draw(Graphics2D g, ViewPort vp, FStyle2D symbol) {
             // OJO CON LA PRECISION. DEBERIAMOS USAR: ((GeneralPathX) shp.m_Polyline).transform(mT);
             // O HACER UNA FUNCION DE TRANSFORMACI?N QUE USE LOS DOUBLES DEL
             // SHAPE
             // Shape shpTrans = vp.getAffineTransform().createTransformedShape(shp);
             transform(vp.getAffineTransform());
     		switch (shp.getShapeType()) {
     			case FShape.POINT:
     				shpPainter.paint(g, shp, symbol.getPointStyle2D(), 0);
             switch (shp.getShapeType()) {
                 case FShape.POINT:
                     shpPainter.paint(g, shp, symbol.getPointStyle2D(), 0);
     				break;
                     break;
     			case FShape.LINE:
     				shpPainter.paint(g, shp, symbol.getLineStyle2D(), 0);
                 case FShape.LINE:
                     shpPainter.paint(g, shp, symbol.getLineStyle2D(), 0);
     				break;
                     break;
     			case FShape.POLYGON:
     				shpPainter.paint(g, shp, symbol.getPolygonStyle2D(), 0);
                 case FShape.POLYGON:
                     shpPainter.paint(g, shp, symbol.getPolygonStyle2D(), 0);
     				break;
                     break;
     			case FShape.TEXT:
     				shpPainter.paint(g, shp, symbol.getTextStyle2D(), 0);
+    		}
+    	}
                 case FShape.TEXT:
                     shpPainter.paint(g, shp, symbol.getTextStyle2D(), 0);
+            }
+        }
     	/**
     	 * Dibuja la geometria actual en el graphics que se le pasa como par?metro,
     	 * aplicandole las caracter?sticas del s?mbolo.
+    	 *
     	 * @param g Graphics2D.
     	 * @param vp ViewPort.
     	 * @param symbol S?mbolo.
     	 */
     	public void draw(Graphics2D g, ViewPort vp, FSymbol symbol) {
     		// OJO CON LA PRECISION. DEBERIAMOS USAR: ((GeneralPathX) shp.m_Polyline).transform(mT);
     		// O HACER UNA FUNCION DE TRANSFORMACI?N QUE USE LOS DOUBLES DEL
     		// SHAPE
     		// Shape shpTrans = vp.getAffineTransform().createTransformedShape(shp);
     		transform(vp.getAffineTransform());
     		FGraphicUtilities.DrawShape(g, vp.getAffineTransform(), shp, symbol);
+    	}
         /**
          * Dibuja la geometria actual en el graphics que se le pasa como par?metro,
          * aplicandole las caracter?sticas del s?mbolo.
+         *
          * @param g Graphics2D.
          * @param vp ViewPort.
          * @param symbol S?mbolo.
          */
         public void draw(Graphics2D g, ViewPort vp, FSymbol symbol) {
             // OJO CON LA PRECISION. DEBERIAMOS USAR: ((GeneralPathX) shp.m_Polyline).transform(mT);
             // O HACER UNA FUNCION DE TRANSFORMACI?N QUE USE LOS DOUBLES DEL
             // SHAPE
             // Shape shpTrans = vp.getAffineTransform().createTransformedShape(shp);
             transform(vp.getAffineTransform());
             FGraphicUtilities.DrawShape(g, vp.getAffineTransform(), shp, symbol);
+        }
         /* (non-Javadoc)
          * @see com.iver.cit.gvsig.fmap.core.IGeometry#drawInts(java.awt.Graphics2D, com.iver.cit.gvsig.fmap.ViewPort, com.iver.cit.gvsig.fmap.core.v02.FSymbol)
-...
             FGraphicUtilities.DrawShape(g, vp.getAffineTransform(), decimatedShape, symbol);
+        }
     	/**
     	 * Aplica la transformaci?n a la geometr?a de la matriz de transformaci?n
     	 * que se pasa como par?metro.
+    	 *
     	 * @param at Matriz de transformaci?n.
     	 */
     	public void transform(AffineTransform at) {
     		shp.transform(at);
+    	}
         /**
          * Aplica la transformaci?n a la geometr?a de la matriz de transformaci?n
          * que se pasa como par?metro.
+         *
          * @param at Matriz de transformaci?n.
          */
         public void transform(AffineTransform at) {
             shp.transform(at);
+        }
     	/* (non-Javadoc)
     	 * @see com.iver.cit.gvsig.fmap.core.IGeometry#intersects(java.awt.geom.Rectangle2D)
     	 */
     	public boolean intersects(Rectangle2D r) {
     		return shp.intersects(r);
+    	}
         /* (non-Javadoc)
          * @see com.iver.cit.gvsig.fmap.core.IGeometry#intersects(java.awt.geom.Rectangle2D)
          */
         public boolean intersects(Rectangle2D r) {
         	if (getGeometryType()==FShape.LINE && shp.getShapeType()==FShape.POLYGON) {
             	return shp.intersects(r) && !shp.contains(r);
+            }
             return shp.intersects(r);
+        }
     	/* (non-Javadoc)
     	 * @see com.iver.cit.gvsig.fmap.core.IGeometry#getBounds2D()
     	 */
     	public Rectangle2D getBounds2D() {
     		if (bounds2D == null)
+    		{
     			bounds2D = shp.getBounds2D();
+    		}
     		// return shp.getBounds2D();
     		return bounds2D;
+    	}
     	public Rectangle2D reCalculateBounds2D()
+    	{
     		return shp.getBounds2D();
+    	}
         /* (non-Javadoc)
          * @see com.iver.cit.gvsig.fmap.core.IGeometry#getBounds2D()
          */
         public Rectangle2D getBounds2D() {
             if (bounds2D == null)
+            {
                 bounds2D = shp.getBounds2D();
+            }
             // return shp.getBounds2D();
             return bounds2D;
+        }
     	/* (non-Javadoc)
     	 * @see com.iver.cit.gvsig.fmap.core.IGeometry#toJTSGeometry()
     	 */
     	public Geometry toJTSGeometry() {
     		return FConverter.java2d_to_jts(shp);
+    	}
         public Rectangle2D reCalculateBounds2D()
+        {
             return shp.getBounds2D();
+        }
     	/* (non-Javadoc)
     	 * @see com.iver.cit.gvsig.fmap.core.IGeometry#createLabels(int, boolean)
     	 */
     	public FLabel[] createLabels(int position, boolean duplicates) {
     		FLabel[] aux = new FLabel[1];
     		aux[0] = FLabel.createFLabel(shp);
         /* (non-Javadoc)
          * @see com.iver.cit.gvsig.fmap.core.IGeometry#toJTSGeometry()
          */
         public Geometry toJTSGeometry() {
             return FConverter.java2d_to_jts(shp);
+        }
     		return aux;
+    	}
         /* (non-Javadoc)
          * @see com.iver.cit.gvsig.fmap.core.IGeometry#createLabels(int, boolean)
          */
         public FLabel[] createLabels(int position, boolean duplicates) {
             FLabel[] aux = new FLabel[1];
             aux[0] = FLabel.createFLabel(shp);
     	/**
     	 * @see com.iver.cit.gvsig.fmap.core.IGeometry#getGeometryType()
     	 */
     	public int getGeometryType() {
     		return shp.getShapeType();
+    	}
             return aux;
+        }
     	/* (non-Javadoc)
     	 * @see com.iver.cit.gvsig.fmap.core.IGeometry#cloneGeometry()
     	 */
     	public IGeometry cloneGeometry() {
     		return new FGeometry(shp.cloneFShape());
+    	}
         /**
          * @see com.iver.cit.gvsig.fmap.core.IGeometry#getGeometryType()
          */
         public int getGeometryType() {
             return type;
+        }
     	/* (non-Javadoc)
     	 * @see com.iver.cit.gvsig.fmap.core.IGeometry#reProject(org.cresques.cts.ICoordTrans)
     	 */
     	public void reProject(ICoordTrans ct) {
     		shp.reProject(ct);
+    	}
         /* (non-Javadoc)
          * @see com.iver.cit.gvsig.fmap.core.IGeometry#cloneGeometry()
          */
         public IGeometry cloneGeometry() {
             IGeometry geom=new FGeometry(shp.cloneFShape());
             geom.setGeometryType(type);
             return geom;
+        }
     	/**
     	 * @see com.iver.cit.gvsig.fmap.core.IGeometry#getPathIterator(AffineTransform)
     	 */
     	public PathIterator getPathIterator(AffineTransform at) {
     		return (GeneralPathXIterator)shp.getPathIterator(null);
+    	}
         /* (non-Javadoc)
          * @see com.iver.cit.gvsig.fmap.core.IGeometry#reProject(org.cresques.cts.ICoordTrans)
          */
         public void reProject(ICoordTrans ct) {
             shp.reProject(ct);
+        }
         /**
          * @see com.iver.cit.gvsig.fmap.core.IGeometry#getPathIterator(AffineTransform)
          */
         public PathIterator getPathIterator(AffineTransform at) {
             return (GeneralPathXIterator)shp.getPathIterator(null);
+        }
         /* (non-Javadoc)
          * @see com.iver.cit.gvsig.fmap.core.IGeometry#fastIntersects(double, double, double, double)
          */
-...
             return WKBEncoder.encodeGeometry(toJTSGeometry());
+        }
         /**
     	 * Devuelve un array con todos los valores de Z.
+    	 *
     	 * @return Array de Zs.
     	 */
     	public double[] getZs() {
     		return ((FShape3D) shp).getZs();
+    	}
     	/**
     	 * @see com.iver.cit.gvsig.fmap.core.IGeometry#getHandlers()
     	 */
     	public Handler[] getHandlers(int type) {
     		if (type==STRETCHINGHANDLER){
     		return shp.getStretchingHandlers();
     		}else if (type==SELECTHANDLER){
     			return shp.getSelectHandlers();
+    		}
     		return null;
+    	}
          * Devuelve un array con todos los valores de Z.
+         *
          * @return Array de Zs.
          */
         public double[] getZs() {
             return ((FShape3D) shp).getZs();
+        }
         /**
          * @see com.iver.cit.gvsig.fmap.core.IGeometry#getHandlers()
          */
         public Handler[] getHandlers(int type) {
             if (type==STRETCHINGHANDLER){
             return shp.getStretchingHandlers();
             }else if (type==SELECTHANDLER){
                 return shp.getSelectHandlers();
+            }
             return null;
+        }
     	/* (non-Javadoc)
     	 * @see com.iver.cit.gvsig.fmap.core.IGeometry#getGeneralPathXIterator(java.awt.geom.AffineTransform, double)
     	 */
     	public PathIterator getPathIterator(AffineTransform at, double flatness) {
     		return shp.getPathIterator(at, flatness);
+    	}
         /* (non-Javadoc)
          * @see com.iver.cit.gvsig.fmap.core.IGeometry#getGeneralPathXIterator(java.awt.geom.AffineTransform, double)
          */
         public PathIterator getPathIterator(AffineTransform at, double flatness) {
             return shp.getPathIterator(at, flatness);
+        }
     	public boolean contains(double x, double y) {
     		return shp.contains(x,y);
+    	}
         public boolean contains(double x, double y) {
             return shp.contains(x,y);
+        }
     	public boolean contains(double x, double y, double w, double h) {
     		return shp.contains(x,y,w,h);
+    	}
         public boolean contains(double x, double y, double w, double h) {
             return shp.contains(x,y,w,h);
+        }
     	public boolean intersects(double x, double y, double w, double h) {
     		return shp.intersects(x,y,w,h);
+    	}
         public boolean intersects(double x, double y, double w, double h) {
         	if (getGeometryType()==FShape.LINE && shp.getShapeType()==FShape.POLYGON) {
             	return shp.intersects(x,y,w,h) && !shp.contains(x,y,w,h);
+            }
             return shp.intersects(x,y,w,h);
+        }
     	public Rectangle getBounds() {
     		return shp.getBounds();
+    	}
         public Rectangle getBounds() {
             return shp.getBounds();
+        }
     	public boolean contains(Point2D p) {
     		return shp.contains(p);
+    	}
         public boolean contains(Point2D p) {
             return shp.contains(p);
+        }
     	public boolean contains(Rectangle2D r) {
     		return shp.contains(r);
+    	}
         public boolean contains(Rectangle2D r) {
             return shp.contains(r);
+        }
     	public Shape getInternalShape() {
     		return shp;
+    	}
         public Shape getInternalShape() {
             return shp;
+        }
     	/* public void move(double x, double y) {
     		AffineTransform at = new AffineTransform();
     		at.translate(x, y);
     		transform(at);
+    	}
     	public void rotate(double r, double x, double y) {
     		AffineTransform at = new AffineTransform();
     		at.rotate(r, x, y);
     		transform(at);
+    	}
     	public void scale(Point2D point,double x, double y) {
     		AffineTransform at = new AffineTransform();
     		at.setToTranslation(point.getX(),point.getY());
     		at.scale(x,y);
     		at.translate(-point.getX(),-point.getY());
     		transform(at);
     	} */
         public int getOriginalGeometryType() {
             return shp.getShapeType();
+        }
         public void setGeometryType(int type) {
             this.type=type;
+        }
         /* public void move(double x, double y) {
             AffineTransform at = new AffineTransform();
             at.translate(x, y);
             transform(at);
+        }
         public void rotate(double r, double x, double y) {
             AffineTransform at = new AffineTransform();
             at.rotate(r, x, y);
             transform(at);
+        }
         public void scale(Point2D point,double x, double y) {
             AffineTransform at = new AffineTransform();
             at.setToTranslation(point.getX(),point.getY());
             at.scale(x,y);
             at.translate(-point.getX(),-point.getY());
             transform(at);
         } */
+    }

trunk/libraries/libFMap/src/com/iver/cit/gvsig/fmap/core/FShape.java
95	95	* @return Handlers
96	96	*/
97	97	public Handler[] getSelectHandlers();
98
	98
99	99	public void transform(AffineTransform at);
100	100	}

          */
         public class Gt2Geometry implements IGeometry {
             /**
+    		 *
+    		 *
     		 */
     		private static final long serialVersionUID = 1587400440363673610L;
     		private FLiteShape shp;
             /**
              * Crea un nuevo FGeometry.
+             *
-...
     			return shp;
+    		}
     		public int getOriginalGeometryType() {
     			return shp.getShapeType();
+    		}
     		public void setGeometryType(int type) {
+    		}
+    }

trunk/libraries/libFMap/src/com/iver/cit/gvsig/fmap/core/Handler.java
74	74	* @return Punto.
75	75	*/
76	76	public Point2D getPoint();
77
	77
	78	public boolean equalsPoint(Object obj);
78	79	}

      */
     public class FMultiPoint2D implements IGeometry {
     	FPoint2D[] points = null;
     	private int type=FShape.POINT;
     	/**
     	 * Crea un nuevo MultiPoint2D.
-...
                 theGeoms[i] = c;
+            }
             MultiPoint geomCol = new GeometryFactory().createMultiPoint(theGeoms);
     		return geomCol;
+    	}
-...
     	 * @see com.iver.cit.gvsig.fmap.core.IGeometry#getGeometryType()
     	 */
     	public int getGeometryType() {
     		return FShape.MULTIPOINT;
     		return type;
+    	}
     	/* (non-Javadoc)
-...
+    		{
     			aux[i] = (FPoint2D) points[i].cloneFShape();
+    		}
     		return new FMultiPoint2D(aux);
     		IGeometry geom=new FMultiPoint2D(aux);
     		//geom.setGeometryType(type);
     		return geom;
+    	}
     	/* (non-Javadoc)
-...
     	public Shape getInternalShape() {
     		return this;
+    	}
     	public int getOriginalGeometryType() {
     		return FShape.MULTIPOINT;
+    	}
     	public void setGeometryType(int type) {
     		this.type=type;
+    	}
+    }

trunk/libraries/libFMap/src/com/iver/cit/gvsig/fmap/core/AbstractHandler.java
61	61	public Point2D getPoint() {
62	62	return point;
63	63	}
64
	64
65	65	public void select(boolean b) {
66	66	select=b;
67	67	}
68	68	public boolean isSelected(){
69	69	return select;
70	70	}
	71	public boolean equalsPoint(Object obj) {
	72	Point2D p1=this.getPoint();
	73	Point2D p2=((Handler)obj).getPoint();
	74	if (p1.getX()==p2.getX() && p1.getY()==p2.getY()) {
	75	return true;
	76	}
	77	return false;
	78	}
71	79	}

     	 * @return una de las constantes de FShape: POINT, LINE, POLIGON
     	 */
     	int getGeometryType();
     	/**
     	 * Obtiene el tipo de la geometr?a
+    	 *
     	 * @return una de las constantes de FShape: POINT, LINE, POLIGON
     	 */
     	void setGeometryType(int type);
     	/**
     	 * Obtiene el tipo original de la geometr?a
+    	 *
     	 * @return una de las constantes de FShape: POINT, LINE, POLIGON, CIRCLE, ARC, ELLIPSE...
     	 */
     	int getOriginalGeometryType();
     	/**
     	 * Clona la Geometr?a.
+    	 *
     	 * @return Geometr?a clonada.
-...
     	public void transform(AffineTransform at);
     	PathIterator getPathIterator(AffineTransform at, double flatness);
     	/**
     	 * Useful to have the real shape behind the scenes.
     	 * May be uses to edit it knowing it it is a Circle, Ellipse, etc

      * 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
      */
-...
         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();
     	class PointHandler extends AbstractHandler {
     		/**
     		 * Crea un nuevo PointHandler.
-...
+    		 *
     		 * @return DOCUMENT ME!
     		 */
     		public void move(double x, double y) {
     		public void move(double x, double y) {
     			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
          * @throws TransformException
          * @throws FactoryException
          * @throws TransformException
          * @throws FactoryException
          */
         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
          * @throws TransformException
          * @throws FactoryException
          * @throws TransformException
          * @throws FactoryException
          */
         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
          * @throws TransformException
          * @throws TransformException
          */
         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
          * @throws TransformException
          * @throws TransformException
          */
         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);
             }else if (geometry instanceof Polygon) {
             }else if (geometry instanceof Polygon) {
                 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
          * @throws TransformException
          * @throws FactoryException
          * @throws TransformException
          * @throws FactoryException
          */
         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);
+            }
             if (this.geometry instanceof Polygon) {
             if (this.geometry instanceof Polygon) {
                 pi = new PolygonIterator((Polygon) geometry, combined, generalize,
                         maxDistance);
-...
                 if(combined == affineTransform)
                     lineIterator.init((LineString) geometry, combined, generalize,
                             (float) maxDistance, xScale, yScale);
                 else
                 else
                     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() {

     import java.awt.geom.Rectangle2D;
     import java.io.IOException;
     import java.util.ArrayList;
     import java.util.Comparator;
     import java.util.TreeMap;
     import org.cresques.cts.ICoordTrans;
     import org.geotools.data.postgis.attributeio.WKBEncoder;
-...
      */
     public class FGeometryCollection implements IGeometry {
     	private ArrayList geometries = new ArrayList();
     	private int type=FShape.LINE;
     	/**
     	 * Crea un nuevo FGeometryCollection.
+    	 *
-...
     	 */
     	public boolean intersects(Rectangle2D r) {
     	    boolean resul = false;
     		for (int i = 0; i < geometries.size(); i++)
+    		{
     			resul = ((IGeometry)geometries.get(i)).intersects(r);
     			if (resul) break;
     		if (type==FShape.LINE) {
     	    	for (int i = 0; i < geometries.size(); i++){
     				resul = ((IGeometry)geometries.get(i)).intersects(r);
     				if (resul) break;
+    			}
     		}else if (type==FShape.POLYGON) {
     			GeneralPathX gpx=new GeneralPathX();
     			Handler lastHandler=null;
     			for (int i = 0; i < geometries.size(); i++) {
     				IGeometry geom=(IGeometry)geometries.get(i);
     				GeneralPathXIterator gpxi=(GeneralPathXIterator)geom.getPathIterator(null);
     				Handler[] handlers=geom.getHandlers(IGeometry.SELECTHANDLER);
     				if (lastHandler==null || handlers[0].getPoint().distance(lastHandler.getPoint())==0) {
     					gpx.append(gpxi,true);
     				}else {
     					gpx.append(gpxi,false);
+    				}
     				lastHandler=handlers[handlers.length-1];
+    			}
     			resul=ShapeFactory.createPolygon2D(gpx).intersects(r);
+    		}
     		return resul;
+    	}
-...
     		return ret;
     		*/
     		return FShape.LINE;
     		return type;
+    	}
     	public void setGeometryType(int type) {
     		this.type=type;
+    	}
     	/* (non-Javadoc)
     	 * @see com.iver.cit.gvsig.fmap.core.IGeometry#draw(java.awt.Graphics2D, com.iver.cit.gvsig.fmap.ViewPort, com.iver.cit.gvsig.fmap.core.v02.FSymbol)
     	 */
     	public void draw(Graphics2D g, ViewPort vp, FSymbol symbol) {
     		for (int i = 0; i < geometries.size(); i++)
     			((IGeometry)geometries.get(i)).draw(g, vp, symbol);
     		if (type==FShape.LINE) {
     			for (int i = 0; i < geometries.size(); i++)
     				((IGeometry)geometries.get(i)).draw(g, vp, symbol);
     		}else if (type==FShape.POLYGON) {
     			//GeneralPathXIterator gpxi=(GeneralPathXIterator)getPathIterator(null);
     			GeneralPathX gpx=new GeneralPathX();
     			Handler lastHandler=null;
     			for (int i = 0; i < geometries.size(); i++) {
     				IGeometry geom=(IGeometry)geometries.get(i);
     				GeneralPathXIterator gpxi=(GeneralPathXIterator)geom.getPathIterator(null);
     				Handler[] handlers=geom.getHandlers(IGeometry.SELECTHANDLER);
     				if (lastHandler==null || handlers[0].getPoint().distance(lastHandler.getPoint())==0) {
     					gpx.append(gpxi,true);
     				}else {
     					gpx.append(gpxi,false);
+    				}
     				lastHandler=handlers[handlers.length-1];
+    			}
     			ShapeFactory.createPolygon2D(gpx).draw(g,vp,symbol);
+    		}
+    	}
     	/* (non-Javadoc)
-...
     		for (int i = 0; i < geometries.size(); i++)
     			newGeometries[i] = ((IGeometry)geometries.get(i)).cloneGeometry();
     		return new FGeometryCollection(newGeometries);
     		FGeometryCollection gc=new FGeometryCollection(newGeometries);
     		gc.type=type;
     		return gc;
+    	}
     	/* (non-Javadoc)
-...
                 theGeoms[i] = ((IGeometry)geometries.get(i)).toJTSGeometry();
+            }
             GeometryCollection geomCol = new GeometryFactory().createGeometryCollection(theGeoms);
     		return geomCol;
+    	}
-...
          * @see com.iver.cit.gvsig.fmap.core.IGeometry#drawInts(java.awt.Graphics2D, com.iver.cit.gvsig.fmap.ViewPort, com.iver.cit.gvsig.fmap.core.v02.FSymbol)
          */
         public void drawInts(Graphics2D g, ViewPort vp, FSymbol symbol) {
             for (int i = 0; i < geometries.size(); i++)
                 ((IGeometry)geometries.get(i)).drawInts(g, vp, symbol);
         	if (type==FShape.LINE) {
     			for (int i = 0; i < geometries.size(); i++)
     				((IGeometry)geometries.get(i)).drawInts(g, vp, symbol);
         	}else if (type==FShape.POLYGON) {
     			//GeneralPathXIterator gpxi=(GeneralPathXIterator)getPathIterator(null);
     			GeneralPathX gpx=new GeneralPathX();
     			Handler lastHandler=null;
     			for (int i = 0; i < geometries.size(); i++) {
     				IGeometry geom=(IGeometry)geometries.get(i);
     				GeneralPathXIterator gpxi=(GeneralPathXIterator)geom.getPathIterator(null);
     				Handler[] handlers=geom.getHandlers(IGeometry.SELECTHANDLER);
     				if (lastHandler==null || handlers[0].getPoint().distance(lastHandler.getPoint())==0) {
     					gpx.append(gpxi,true);
     				}else {
     					gpx.append(gpxi,false);
+    				}
     				lastHandler=handlers[handlers.length-1];
+    			}
     			IGeometry geom=ShapeFactory.createPolygon2D(gpx);
     			geom.setGeometryType(type);
     			geom.drawInts(g,vp,symbol);
+    		}
+        }
-...
     		for (int i = 0; i < geometries.size(); i++){
     			Handler[] handAux=((IGeometry)geometries.get(i)).getHandlers(type);
     			for (int j=0;j<handAux.length;j++){
     				handlers.add(handAux[j]);
     				if (!handlers.contains(handAux[j]))
     					handlers.add(handAux[j]);
+    			}
+    		}
     		return (Handler[])handlers.toArray(new Handler[0]);
-...
+    	}
     	public boolean intersects(double x, double y, double w, double h) {
     		boolean bRes;
     		for (int i=0; i < geometries.size(); i++)
+    		{
     			IGeometry gAux = (IGeometry) geometries.get(i);
     			bRes = gAux.intersects(x,y, w, h);
     			if (bRes) return bRes;
     		boolean resul = false;
     		if (type==FShape.LINE) {
     			for (int i=0; i < geometries.size(); i++){
     				IGeometry gAux = (IGeometry) geometries.get(i);
     				resul= gAux.intersects(x,y, w, h);
     				if (resul) break;
+    			}
     		}else if (type==FShape.POLYGON) {
     			GeneralPathX gpx=new GeneralPathX();
     			Handler lastHandler=null;
     			for (int i = 0; i < geometries.size(); i++) {
     				IGeometry geom=(IGeometry)geometries.get(i);
     				GeneralPathXIterator gpxi=(GeneralPathXIterator)geom.getPathIterator(null);
     				Handler[] handlers=geom.getHandlers(IGeometry.SELECTHANDLER);
     				if (lastHandler==null || handlers[0].getPoint().distance(lastHandler.getPoint())==0) {
     					gpx.append(gpxi,true);
     				}else {
     					gpx.append(gpxi,false);
+    				}
     				lastHandler=handlers[handlers.length-1];
+    			}
     			IGeometry geom=ShapeFactory.createPolygon2D(gpx);
     			geom.setGeometryType(FShape.POLYGON);
     			resul=geom.intersects(x,y,w,h);
+    		}
     		return false;
     		return resul;
+    	}
     	public Rectangle getBounds() {
-...
     	public Shape getInternalShape() {
     		return this;
+    	}
     	public int getOriginalGeometryType() {
     		return type;
+    	}
     	public boolean isClosed() {
     		GeneralPathX gpx=new GeneralPathX();
     		PathIterator pi=getPathIterator(null);
     		gpx.append(pi,true);
     		return gpx.isClosed();
+    	}
+    }

      * @author Vicente Caballero Navarro
      */
     public class FPolygon2D extends FPolyline2D {
     	private int type=FShape.POLYGON;
     	/**
     	 * Crea un nuevo Polygon2D.
+    	 *
-...
     	 * @see com.iver.cit.gvsig.fmap.core.FShape#getShapeType()
     	 */
     	public int getShapeType() {
     		return type;
+    	}
     	public void setShapeType(int type) {
     		this.type=type;
+    	}
     	public int getShapeTypeOriginal() {
     		return FShape.POLYGON;
+    	}
     	/**
     	 * Clona FPolygon2D.
+    	 *
-...
     	/* public void draw(Graphics2D g, ViewPort vp, Style2D symbol) {
     	   gp.transform(vp.getAffineTransform());
     	       g.setPaint(Color.red);
     	       g.fill(gp);
     	       g.setPaint(Color.black);

     import java.awt.geom.AffineTransform;
     import java.awt.geom.Arc2D;
     import java.awt.geom.Line2D;
     import java.awt.geom.Point2D;
     import java.awt.geom.Rectangle2D;
     import java.util.ArrayList;
     import com.iver.cit.gvsig.fmap.edition.UtilFunctions;
-...
+    *
     * @author Vicente Caballero Navarro
     */
     public class FEllipse2D extends FPolyline2D {
     public class FEllipse2D extends FPolygon2D {
     	private Point2D init;
     	private Point2D end;
     	private double ydist;
-...
     			AffineTransform mT = AffineTransform.getRotateInstance(angle, init.getX(), init.getY());
     			gp = new GeneralPathX(arc);
     			gp.transform(mT);
+    		}
+    		}
+    	}
     	/* (non-Javadoc)
     	 * @see com.iver.cit.gvsig.fmap.core.FPolyline2D#intersects(java.awt.geom.Rectangle2D)
     	 */

trunk/libraries/libFMap/src/com/iver/cit/gvsig/fmap/core/FNullGeometry.java
203	203	// TODO Auto-generated method stub
204	204	return null;
205	205	}
	206
	207	public int getOriginalGeometryType() {
	208	return FShape.NULL;
	209	}
	210
	211	public void setGeometryType(int type) {
	212
	213	}
206	214	}

+     *
      * @author Vicente Caballero Navarro
      */
     public class FCircle2D extends FPolyline2D {
     public class FCircle2D extends FPolygon2D {
     	private Point2D center;
     	private double radio;

      */
     package com.iver.cit.gvsig;
     import java.util.ArrayList;
     import com.iver.andami.PluginServices;
     import com.iver.andami.plugins.Extension;
     import com.iver.cit.gvsig.fmap.DriverException;
-...
     import com.iver.cit.gvsig.fmap.layers.FLyrVect;
     import com.iver.cit.gvsig.gui.View;
     import com.iver.cit.gvsig.gui.cad.tools.InternalPolygonCADTool;
     import com.iver.cit.gvsig.layers.VectorialLayerEdited;
     /**
      * Extensi?n que gestiona la inserci?n de pol?gonos internos en edici?n.
-...
     				mapControl = (MapControl) view.getMapControl();
     				if (CADExtension.getEditionManager().getActiveLayerEdited()==null)
     					return false;
     				FLyrVect lv=(FLyrVect)CADExtension.getEditionManager().getActiveLayerEdited().getLayer();
     				EditionManager em=CADExtension.getEditionManager();
     				if (em.getActiveLayerEdited()==null)
     					return false;
     				VectorialLayerEdited vle=(VectorialLayerEdited)em.getActiveLayerEdited();
     				FLyrVect lv=(FLyrVect)vle.getLayer();
     				ArrayList selectedRows=vle.getSelectedRow();
     				if (selectedRows.size()<1) {
     					return false;
+    				}
     				if (internalpolygon.isApplicable(lv.getShapeType())){
     					return true;
+    				}

     /* 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 com.iver.cit.gvsig;
     import java.util.ArrayList;
     import com.iver.andami.PluginServices;
     import com.iver.andami.plugins.Extension;
     import com.iver.cit.gvsig.fmap.DriverException;
     import com.iver.cit.gvsig.fmap.MapControl;
     import com.iver.cit.gvsig.fmap.layers.FLyrVect;
     import com.iver.cit.gvsig.gui.View;
     import com.iver.cit.gvsig.gui.cad.tools.ExploitCADTool;
     import com.iver.cit.gvsig.gui.cad.tools.InternalPolygonCADTool;
     import com.iver.cit.gvsig.layers.VectorialLayerEdited;
     /**
      * Extensi?n que gestiona la simplificaci?n de una geometr?a compuesta en otras m?s sencillas.
+     *
      * @author Vicente Caballero Navarro
      */
     public class ExploitExtension extends Extension {
     	private View view;
     	private MapControl mapControl;
     	private ExploitCADTool exploit;
     	/**
     	 * @see com.iver.andami.plugins.IExtension#initialize()
     	 */
     	public void initialize() {
     		exploit=new ExploitCADTool();
     		CADExtension.addCADTool("_exploit",exploit);
+    	}
     	/**
     	 * @see com.iver.andami.plugins.IExtension#execute(java.lang.String)
     	 */
     	public void execute(String s) {
     		CADExtension.initFocus();
     		if (s.equals("_exploit")) {
             	CADExtension.setCADTool(s,true);
+            }
     		CADExtension.getEditionManager().setMapControl(mapControl);
     		CADExtension.getCADToolAdapter().configureMenu();
+    	}
     	/**
     	 * @see com.iver.andami.plugins.IExtension#isEnabled()
     	 */
     	public boolean isEnabled() {
     		try {
     			if (EditionUtilities.getEditionStatus() == EditionUtilities.EDITION_STATUS_ONE_VECTORIAL_LAYER_ACTIVE_AND_EDITABLE) {
     				view = (View) PluginServices.getMDIManager().getActiveView();
     				mapControl = (MapControl) view.getMapControl();
     				EditionManager em=CADExtension.getEditionManager();
     				if (em.getActiveLayerEdited()==null)
     					return false;
     				VectorialLayerEdited vle=(VectorialLayerEdited)em.getActiveLayerEdited();
     				FLyrVect lv=(FLyrVect)vle.getLayer();
     				ArrayList selectedRows=vle.getSelectedRow();
     				if (selectedRows.size()<1) {
     					return false;
+    				}
     				if (exploit.isApplicable(lv.getShapeType())){
     					return true;
+    				}
+    			}
     		} catch (DriverException e) {
     			e.printStackTrace();
+    		}
     		return false;
+    	}
     	/**
     	 * @see com.iver.andami.plugins.IExtension#isVisible()

| gvSIG desktop 1

Revision 5878