| gvSIG desktop 1

<?xml version="1.0" encoding="UTF-8"?>

<projectDescription>

	<name>FMap 03</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

			<name>org.eclipse.jdt.core.javabuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

		<nature>org.eclipse.jem.workbench.JavaEMFNature</nature>

		<nature>org.eclipse.jdt.core.javanature</nature>

		<nature>org.eclipse.jem.beaninfo.BeanInfoNature</nature>

	</natures>

</projectDescription>

/* Generated by Together */

package com.iver.cit.gvsig.fmap;

import java.io.IOException;

import java.net.ProtocolException;

import com.iver.cit.gvsig.fmap.fshape.FGeometry;

public interface WFSDriver extends  VectorialDriver {

    void describeFeatureType() throws IOException, WFSException, ProtocolException;

    FGeometry[] getFeature() throws IOException, WFSException, ProtocolException;

    void lockFeature() throws IOException, WFSException, ProtocolException;

    void transaction() throws IOException, WFSException, ProtocolException;

}

/* Generated by Together */

package com.iver.cit.gvsig.fmap;

import com.iver.cit.gvsig.fmap.fshape.FGeometry;

public interface FeatureVisitor {

    /**

     * Recibe las geometr?as a medida que se van recorriendo en la estrategia.

     */

    void visit(FGeometry g);

    /**

     * M?todo invocado al finalizar las visitas con el fin de que se puedan liberar los recursos reservados en start 

     */

    void stop();

    /**

     * M?todo invocado antes de las visitas para que el visitor pueda reservar alg?n tipo de recurso que sea necesario 

     */

    void start();

}

/* Generated by Together */

package com.iver.cit.gvsig.fmap;

public interface ExtentListener {

    void extentChanged(ExtentEvent e);

}

package com.iver.cit.gvsig.fmap;

public class WFSException extends Exception {

	/**

	 * 

	 */

	public WFSException() {

		super();

	}

	/**

	 * @param message

	 */

	public WFSException(String message) {

		super(message);

	}

	/**

	 * @param message

	 * @param cause

	 */

	public WFSException(String message, Throwable cause) {

		super(message, cause);

	}

	/**

	 * @param cause

	 */

	public WFSException(Throwable cause) {

		super(cause);

	}

}

/* Generated by Together */

package com.iver.cit.gvsig.fmap;

import java.awt.Image;

import java.io.IOException;

import java.net.ProtocolException;

import java.net.URL;

public interface WMSDriver {

    void getCapabilities(URL servidor) throws WMSException, IOException, ProtocolException;

    Image getMap(MapQuery mapQuery) throws WMSException, IOException, ProtocolException;

    String getFeatureInfo(InfoQuery infoQuery) throws WMSException, IOException, ProtocolException;

}

/* Generated by Together */

package com.iver.cit.gvsig.fmap;

import java.awt.Graphics2D;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.cresques.geo.Projected;

import com.iver.cit.gvsig.fmap.fshape.FGeometry;

/**

 * DOCUMENT ME!

 *

 * @author Fernando Gonz?lez Cort?s

 */

public class FMap implements Strategy, Projected {

	public static final int EQUALS = 0;

	public static final int DISJOINT = 1;

	public static final int INTERSECTS = 2;

	public static final int TOUCHES = 3;

	public static final int CROSSES = 4;

	public static final int WITHIN = 5;

	public static final int CONTAINS = 6;

	public static final int OVERLAPS = 7;

	private FLayers layers = new FLayers();

	private ViewPort viewPort;

	/**

	 * DOCUMENT ME!

	 *

	 * @return DOCUMENT ME!

	 */

	public FLayers getLayers() {

		return layers;

	}

	/**

	 * Dibuja en la imagen que se pasa como par?metro el contenido de las capas

	 * visibles del mapa y teniendo en cuenta los datos del ViewPort contenido

	 * en este FMap

	 *

	 * @param b DOCUMENT ME!

	 */

	public void drawLabels(BufferedImage b) {

	}

	/**

	 * DOCUMENT ME!

	 *

	 * @param g DOCUMENT ME!

	 */

	public void print(Graphics2D g) {

	}

	/**

	 * Crea un nuevo FMap con la informaci?n del ViewPort que se pasa como

	 * par?metro.

	 *

	 * @param vp DOCUMENT ME!

	 *

	 * @return DOCUMENT ME!

	 */

	public FMap createNewFMap(ViewPort vp) {

		FMap ret = new FMap();

		ret.layers = this.layers;

		ret.viewPort = vp;

		return ret;

	}

	/**

	 * Crea un nuevo FMap totalmente desligado, se replican las capas y el

	 * ViewPort

	 *

	 * @return DOCUMENT ME!

	 */

	public FMap cloneFMap() {

		return createXMLEntity(getXMLEntity());

	}

	/**

	 * DOCUMENT ME!

	 *

	 * @return DOCUMENT ME!

	 */

	public XMLEntity getXMLEntity() {

		return new XMLEntity();

	}

	/**

	 * DOCUMENT ME!

	 *

	 * @param xe DOCUMENT ME!

	 *

	 * @return DOCUMENT ME!

	 */

	public FMap createXMLEntity(XMLEntity xe) {

		// TODO Implementar bien

		return new FMap();

	}

	/**

	 * A?ade la capa que se pasa como par?metro al nodo que se pasa como

	 * parametro y lanza ProjectionMismatchException si no est?n todas las

	 * capas de este FMap en la misma proyecci?n. Lanza un

	 * ChildNotAllowedException si la capa no es un FLayers y no permite hijos

	 *

	 * @param parent DOCUMENT ME!

	 * @param layer DOCUMENT ME!

	 *

	 * @throws ProjectionMismatchException DOCUMENT ME!

	 * @throws ChildrenNotAllowedException DOCUMENT ME!

	 */

	public void addLayer(LayerPath parent, FLayer layer)

		throws ProjectionMismatchException, ChildrenNotAllowedException {

		layers.addLayer(parent, layer);

	}

	/**

	 * A?ade una capa al grupo de capas que se sit?a por encima de todas las

	 * otras capas

	 *

	 * @param vectorial DOCUMENT ME!

	 */

	public void addToTrackLayer(FLyrVect vectorial) {

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.Strategy#setVectorial(com.iver.cit.gvsig.fmap.VectorialAdapter)

	 */

	public void setVectorial(VectorialAdapter v) {

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.Strategy#process(com.iver.cit.gvsig.fmap.FeatureSelectorVisitor)

	 */

	public void process(FeatureSelectorVisitor visitor) {

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.Strategy#processSelected(com.iver.cit.gvsig.fmap.FeatureVisitor)

	 */

	public void processSelected(FeatureVisitor visitor) {

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.Strategy#select(com.iver.cit.gvsig.fmap.FeatureSelectorVisitor)

	 */

	public void select(FeatureSelectorVisitor visitor) {

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.Strategy#selectFromSelection()

	 */

	public void selectFromSelection() {

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.Strategy#createIndex()

	 */

	public void createIndex() {

	}

	/**

	 * @see org.cresques.geo.Projected#getProjection()

	 */

	public IProjection getProjection() {

		return null;

	}

	/**

	 * @see org.cresques.geo.Projected#reProject(org.cresques.cts.ICoordTrans)

	 */

	public void reProject(ICoordTrans arg0) {

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.Strategy#selectByPoint(java.awt.geom.Point2D,

	 * 		double)

	 */

	public void selectByPoint(Point2D p, double tolerance) {

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.Strategy#selectByRect(java.awt.geom.Rectangle2D)

	 */

	public void selectByRect(Rectangle2D rect) {

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.Strategy#selectByShape(com.iver.cit.gvsig.fmap.fshape.FGeometry,

	 * 		int)

	 */

	public void selectByShape(FGeometry g, int relationship) {

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.Strategy#queryByPoint(java.awt.geom.Point2D,

	 * 		double)

	 */

	public Record[] queryByPoint(Point2D p, double tolerance) {

		return null;

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.Strategy#queryByRect(java.awt.geom.Rectangle2D)

	 */

	public Record[] queryByRect(Rectangle2D rect) {

		return null;

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.Strategy#queryByShape(com.iver.cit.gvsig.fmap.fshape.FGeometry,

	 * 		int)

	 */

	public Record[] queryByShape(FGeometry g, int relationship) {

		return null;

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.Strategy#getSelectionBounds()

	 */

	public Rectangle2D getSelectionBounds() {

		return null;

	}

	/**

	 * DOCUMENT ME!

	 *

	 * @param image DOCUMENT ME!

	 * @param g DOCUMENT ME!

	 * @param viewPort DOCUMENT ME!

	 *

	 * @throws DriverIOException

	 *

	 * @see com.iver.cit.gvsig.fmap.Operations#draw(java.awt.image.BufferedImage,

	 * 		java.awt.Graphics2D, com.iver.cit.gvsig.fmap.ViewPort)

	 */

	public void draw(BufferedImage image, Graphics2D g, ViewPort viewPort)

		throws DriverIOException {

		layers.draw(image, g, viewPort);

	}

	/**

	 * @return Returns the viewPort.

	 */

	public ViewPort getViewPort() {

		return viewPort;

	}

	/**

	 * @param viewPort The viewPort to set.

	 */

	public void setViewPort(ViewPort viewPort) {

		this.viewPort = viewPort;

	}

}

/* Generated by Together */

package com.iver.cit.gvsig.fmap;

import java.awt.BasicStroke;

import java.awt.Color;

import org.geotools.renderer.style.LineStyle2D;

import org.geotools.renderer.style.Style2D;

public class LegendFactory {

	public static LineStyle2D DEFAULT_LINE_SYMBOL = new LineStyle2D();

	static{

		DEFAULT_LINE_SYMBOL.setContour(Color.BLUE);

		BasicStroke stroke = new BasicStroke(1);

		DEFAULT_LINE_SYMBOL.setStroke(stroke);

	}

	// TODO Descomentar esto cuando se tenga la interfaz de datos

    /*

     * Crea un objeto renderer de valor ?nico con las caracter?sticas que se pasan como par?metro y con los s?mbolos por defecto. En funci?n de la carga del sistema se podr? crear un FRenderer que almacene la referencia al FRecordset, o un FRenderer que haga cach? de los valores necesarios

     *

    public static Legend createIntervalLegend(FRecordset data, int valueField, int labelField ) {

    }

    /*

     * Crea un objeto renderer de valor ?nico con las caracter?sticas que se pasan como par?metro y con los s?mbolos por defecto. En funci?n de la carga del sistema se podr? crear un FRenderer que almacene la referencia al FRecordset, o un FRenderer que haga cach? de los valores necesarios

     *

    public static Legend createUniqueValueLegend(FRecordset data, int valueField, int labelField ) {

    }

*/

    /**

     * Crea un objeto renderer de s?mbolo ?nico con las caracter?sticas que se pasan como par?metro

     */

    public static Legend createUniqueSymbolLegend(Style2D style) {

    	return new UniqueSymbolLegend(style);

    }

    /**

     * Obtiene un objeto con las propiedades del renderer. Este m?todo se invocar? con el fin de guardar el s?mbolo en disco.

     */

    public static XMLEntity getLegendProperties(Legend r) {

    	//TODO Implementar bien

    	return null;

    }

    /**

     * Crea un renderer con la informaci?n contenida en el objeto XMLEntity

     */

    public static Legend createLegend(XMLEntity info) {

    	//TODO Implementar bien

    	return null;

    }

    public static Legend cloneLegend(Legend l) {

    	return createLegend(getLegendProperties(l));

    }

}

/* Generated by Together */

package com.iver.cit.gvsig.fmap.fshape;

public class FLabel extends Point2D {

}

/* Generated by Together */

package com.iver.cit.gvsig.fmap.fshape;

public class NullGeometry implements FGeometry {

}

/* Generated by Together */

package com.iver.cit.gvsig.fmap.fshape;

public class Multipolygon2D implements FGeometry, WritableShape {

}

/* Generated by Together */

package com.iver.cit.gvsig.fmap.fshape;

public class Multipoint2D implements FGeometry, WritableShape {

    private Point2D[] points;

    /**

     * Obtiene el rect?ngulo m?nimo en el que se situa la Shape 

     */

    public Rectangle2D getBounds(){

        Rectangle2D rect = new Rectangle2D.Double(points[0].getX(), points[0].getX(), 0, 0);

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

            rect.add(new Rectangle2D.Double(points[i].getX(), points[i].getX(), 0, 0));

        }

    }

}

/* Generated by Together */

package com.iver.cit.gvsig.fmap.fshape;

public interface WritableShape {

    /**

     * Dispara en el handler que se pasa como par?metro los eventos SAX correspondientes con el GML del Shape 

     */

    void toGML(ContentHandler handler);

}

/*

 * Created on 10-jun-2004

 *

 * TODO To change the template for this generated file go to

 * Window - Preferences - Java - Code Generation - Code and Comments

 */

package com.iver.cit.gvsig.fmap.fshape;

import java.awt.geom.AffineTransform;

import java.awt.geom.PathIterator;

/*

 * @(#)GeneralPathXIterator.java	1.21 03/01/23

 *

 * Copyright 2003 Sun Microsystems, Inc. All rights reserved.

 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

 */

/**

 * This class represents the iterator for General Paths X.

 * It can be used to retrieve all of the elements in a GeneralPathX.

 * The {@link GeneralPathX#getPathIterator}

 *  method is used to create a

 * GeneralPathXIterator for a particular GeneralPathX.

 * The iterator can be used to iterator the path only once.

 * Subsequent iterations require a new iterator.

 *

 * @see GeneralPathX

 *

 * @version 10 Feb 1997

 * @author	Jim Graham

 */

class GeneralPathXIterator implements PathIterator {

    int typeIdx = 0;

    int pointIdx   = 0;

    GeneralPathX path;

    AffineTransform affine;

    private static final int curvesize[] = {2, 2, 4, 6, 0};

    /**

     * Constructs an iterator given a GeneralPathX.

     * @see GeneralPathX#getPathIterator

     */

    GeneralPathXIterator(GeneralPathX path) {

	this(path, null);

    }

    /**

     * Constructs an iterator given a GeneralPathX and an optional

     * AffineTransform.

     * @see GeneralPathX#getPathIterator

     */

    GeneralPathXIterator(GeneralPathX path, AffineTransform at) {

        this.path = path;

	this.affine = at;

    }

    /**

     * Return the winding rule for determining the interior of the

     * path.

     * @see PathIterator#WIND_EVEN_ODD

     * @see PathIterator#WIND_NON_ZERO

     */

    public int getWindingRule() {

	return path.getWindingRule();

    }

    /**

     * Tests if there are more points to read.

     * @return true if there are more points to read

     */

    public boolean isDone() {

        return (typeIdx >= path.numTypes);

    }

    /**

     * Moves the iterator to the next segment of the path forwards

     * along the primary direction of traversal as long as there are

     * more points in that direction.

     */

    public void next() {

	int type = path.pointTypes[typeIdx++];

	pointIdx += curvesize[type];

    }

    /**

     * Returns the coordinates and type of the current path segment in

     * the iteration.

     * The return value is the path segment type:

     * SEG_MOVETO, SEG_LINETO, SEG_QUADTO, SEG_CUBICTO, or SEG_CLOSE.

     * A float array of length 6 must be passed in and may be used to

     * store the coordinates of the point(s).

     * Each point is stored as a pair of float x,y coordinates.

     * SEG_MOVETO and SEG_LINETO types will return one point,

     * SEG_QUADTO will return two points,

     * SEG_CUBICTO will return 3 points

     * and SEG_CLOSE will not return any points.

     * @see PathIterator#SEG_MOVETO

     * @see PathIterator#SEG_LINETO

     * @see PathIterator#SEG_QUADTO

     * @see PathIterator#SEG_CUBICTO

     * @see PathIterator#SEG_CLOSE

     */

    public int currentSegment(float[] coords) {

	int type = path.pointTypes[typeIdx];

	int numCoords = curvesize[type];

	if (numCoords > 0 && affine != null) {

	    affine.transform(path.pointCoords, pointIdx,

			     coords, 0,

			     numCoords / 2);

	} else {

	    for (int i=0; i < numCoords; i++) {

			coords[i] = (float) path.pointCoords[pointIdx + i];

		    }

	}

        return type;

    }

    /**

     * Returns the coordinates and type of the current path segment in

     * the iteration.

     * The return value is the path segment type:

     * SEG_MOVETO, SEG_LINETO, SEG_QUADTO, SEG_CUBICTO, or SEG_CLOSE.

     * A double array of length 6 must be passed in and may be used to

     * store the coordinates of the point(s).

     * Each point is stored as a pair of double x,y coordinates.

     * SEG_MOVETO and SEG_LINETO types will return one point,

     * SEG_QUADTO will return two points,

     * SEG_CUBICTO will return 3 points

     * and SEG_CLOSE will not return any points.

     * @see PathIterator#SEG_MOVETO

     * @see PathIterator#SEG_LINETO

     * @see PathIterator#SEG_QUADTO

     * @see PathIterator#SEG_CUBICTO

     * @see PathIterator#SEG_CLOSE

     */

    public int currentSegment(double[] coords) {

	int type = path.pointTypes[typeIdx];

	int numCoords = curvesize[type];

	if (numCoords > 0 && affine != null) {

	    affine.transform(path.pointCoords, pointIdx,

			     coords, 0,

			     numCoords / 2);

	} else {

	    System.arraycopy(path.pointCoords, pointIdx, coords, 0, numCoords);

	}

        return type;

    }

}

/* Generated by Together */

package com.iver.cit.gvsig.fmap.fshape;

public class FLabel implements FGeometry {

    void setText(String newText);

}

/* Generated by Together */

package com.iver.cit.gvsig.fmap.fshape;

public class Point2D implements FGeometry {

}

/* Generated by Together */

package com.iver.cit.gvsig.fmap.fshape;

import java.awt.Graphics2D;

import java.awt.geom.AffineTransform;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import org.geotools.renderer.style.Style2D;

import com.iver.cit.gvsig.fmap.ViewPort;

/**

 * DOCUMENT ME!

 *

 * @author $author$

 */

public interface FGeometry extends java.awt.Shape {

	public static int BEST = 0;

	public static int N = 1;

	public static int NE = 2;

	public static int E = 3;

	public static int SE = 4;

	public static int S = 5;

	public static int SW = 6;

	public static int W = 7;

	public static int NW = 8;

	public final static int POINT = 1;

	public final static int LINE = 2;

	public final static int POLYGON = 4;

	public final static int TEXT = 8;

	/**

	 * Dibujar? esta Shape en el Graphics con el s?mbolo que se pasa como

	 * par?metro y despues de aplicarle la transformaci?n que se pasa tambi?n

	 * como par?metro. El parametro image que recibe es la imagen de la cual

	 * se obtuvo el graphics que tambi?n se pasa como par?metro. Dibujar? la

	 * geometria en caso de que la FGeometry intersecte o est? contenida en el

	 * rect?ngulo que se pasa como par?metro

	 *

	 * @param image DOCUMENT ME!

	 * @param g DOCUMENT ME!

	 * @param mt DOCUMENT ME!

	 * @param symbol DOCUMENT ME!

	 * @param extent DOCUMENT ME!

	 */

	void draw(BufferedImage image, Graphics2D g, Rectangle2D extent, AffineTransform at,

		Style2D symbol);

	/**

	 * Dibujar? esta Shape en el Graphics con el s?mbolo que se pasa como

	 * par?metro y despues de aplicarle la transformaci?n que se pasa tambi?n

	 * como par?metro. Dibujar? la geometria en caso de que la FGeometry

	 * intersecte o est? contenida en el rect?ngulo que se pasa como par?metro

	 *

	 * @param g DOCUMENT ME!

	 * @param mt DOCUMENT ME!

	 * @param symbol DOCUMENT ME!

	 * @param extent DOCUMENT ME!

	 */

	void print(Graphics2D g, AffineTransform mt, Style2D symbol,

		Rectangle2D extent);

	/**

	 * Devuelve el tipo de la geometr?a.

	 * 

	 * @return DOCUMENT ME!

	 */

	int getType();

	/**

	 * Transforma esta Shape en un Geometry de JTS

	 *

	 * @return DOCUMENT ME!

	 */

	JTSGeometry toJTSGeometry();

	/**

	 * Obtiene las posiciones donde se debe situar la etiqueta para esta

	 * FGeometry. Es un array porque si una geometria es un multipunto por

	 * ejemplo puede quererse etiquetar todos sus puntos. El par?metro que se

	 * pasa indica como debe de colocar la geometria la etiqueta

	 *

	 * @param position DOCUMENT ME!

	 * @param duplicates DOCUMENT ME!

	 *

	 * @return DOCUMENT ME!

	 */

	FGeometry[] createLabels(int position, boolean duplicates);

}

package com.iver.cit.gvsig.fmap.fshape;

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.PathIterator;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import org.geotools.renderer.style.Style2D;

public class Polyline2D implements FGeometry{

	private GeneralPathX gp;

	public Polyline2D(GeneralPathX gpx){

		gp = gpx;

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.fshape.FGeometry#draw(java.awt.image.BufferedImage, java.awt.Graphics2D, java.awt.geom.AffineTransform, org.geotools.renderer.style.Style2D, java.awt.geom.Rectangle2D)

	 */

	public void draw(BufferedImage image, Graphics2D g, Rectangle2D extent, AffineTransform at, Style2D symbol) {

//		if (gp.intersects(extent)){

			gp.transform(at);

			g.setPaint(Color.BLACK);

			g.draw(gp);

/*			StyledShapePainter painter = new StyledShapePainter();

			painter.paint(g, this, symbol, vp.getScale());

	*/	

//		}

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.fshape.FGeometry#print(java.awt.Graphics2D, java.awt.geom.AffineTransform, org.geotools.renderer.style.Style2D, java.awt.geom.Rectangle2D)

	 */

	public void print(Graphics2D g, AffineTransform mt, Style2D symbol, Rectangle2D extent) {

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.fshape.FGeometry#getType()

	 */

	public int getType() {

		return FGeometry.LINE;

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.fshape.FGeometry#createLabels(int, boolean)

	 */

	public FGeometry[] createLabels(int position, boolean duplicates) {

		return null;

	}

	/**

	 * @see java.awt.Shape#contains(double, double)

	 */

	public boolean contains(double x, double y) {

		return gp.contains(x, y);

	}

	/**

	 * @see java.awt.Shape#contains(double, double, double, double)

	 */

	public boolean contains(double x, double y, double w, double h) {

		return gp.contains(x, y, w, h);

	}

	/**

	 * @see java.awt.Shape#intersects(double, double, double, double)

	 */

	public boolean intersects(double x, double y, double w, double h) {

		return gp.intersects(x, y, w, h);

	}

	/**

	 * @see java.awt.Shape#getBounds()

	 */

	public Rectangle getBounds() {

		return gp.getBounds();

	}

	/**

	 * @see java.awt.Shape#contains(java.awt.geom.Point2D)

	 */

	public boolean contains(Point2D p) {

		return gp.contains(p);

	}

	/**

	 * @see java.awt.Shape#getBounds2D()

	 */

	public Rectangle2D getBounds2D() {

		return gp.getBounds2D();

	}

	/**

	 * @see java.awt.Shape#contains(java.awt.geom.Rectangle2D)

	 */

	public boolean contains(Rectangle2D r) {

		return gp.contains(r);

	}

	/**

	 * @see java.awt.Shape#intersects(java.awt.geom.Rectangle2D)

	 */

	public boolean intersects(Rectangle2D r) {

		return gp.intersects(r);

	}

	/**

	 * @see java.awt.Shape#getPathIterator(java.awt.geom.AffineTransform)

	 */

	public PathIterator getPathIterator(AffineTransform at) {

		return gp.getPathIterator(at);

	}

	/**

	 * @see java.awt.Shape#getPathIterator(java.awt.geom.AffineTransform, double)

	 */

	public PathIterator getPathIterator(AffineTransform at, double flatness) {

		return gp.getPathIterator(at, flatness);

	}

}

/*

 * Created on 10-jun-2004

 *

 * TODO To change the template for this generated file go to

 * Window - Preferences - Java - Code Generation - Code and Comments

 */

package com.iver.cit.gvsig.fmap.fshape;

/**

 * @author FJP

 *

 * TODO To change the template for this generated type comment go to

 * Window - Preferences - Java - Code Generation - Code and Comments

 */

/*

 * @(#)GeneralPathX.java	1.58 03/01/23

 *

 * Copyright 2003 Sun Microsystems, Inc. All rights reserved.

 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

 */

import java.awt.Shape;

import java.awt.geom.AffineTransform;

import java.awt.geom.FlatteningPathIterator;

import java.awt.geom.IllegalPathStateException;

import java.awt.geom.PathIterator;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import sun.awt.geom.Crossings;

import sun.awt.geom.Curve;

/**

 * The <code>GeneralPathX</code> class represents a geometric path 

 * constructed from straight lines, and quadratic and cubic

 * (Bézier) curves.  It can contain multiple subpaths.

 * <p>

 * The winding rule specifies how the interior of a path is

 * determined.  There are two types of winding rules:  

 * EVEN_ODD and NON_ZERO.

 * <p>

 * An EVEN_ODD winding rule means that enclosed regions

 * of the path alternate between interior and exterior areas as

 * traversed from the outside of the path towards a point inside

 * the region.  

 * <p>

 * A NON_ZERO winding rule means that if a ray is 

 * drawn in any direction from a given point to infinity

 * and the places where the path intersects

 * the ray are examined, the point is inside of the path if and only if

 * the number of times that the path crosses the ray from

 * left to right does not equal the  number of times that the path crosses

 * the ray from right to left.  

 * @version 1.58, 01/23/03

 * @author Jim Graham

 */

public final class GeneralPathX implements Shape, Cloneable {

    /**

     * An even-odd winding rule for determining the interior of

     * a path.  

     */

    public static final int WIND_EVEN_ODD = PathIterator.WIND_EVEN_ODD;

    /**

     * A non-zero winding rule for determining the interior of a

     * path.  

     */

    public static final int WIND_NON_ZERO = PathIterator.WIND_NON_ZERO;

    // For code simplicity, copy these constants to our namespace

    // and cast them to byte constants for easy storage.

    private static final byte SEG_MOVETO  = (byte) PathIterator.SEG_MOVETO;

    private static final byte SEG_LINETO  = (byte) PathIterator.SEG_LINETO;

    private static final byte SEG_QUADTO  = (byte) PathIterator.SEG_QUADTO;

    private static final byte SEG_CUBICTO = (byte) PathIterator.SEG_CUBICTO;

    private static final byte SEG_CLOSE   = (byte) PathIterator.SEG_CLOSE;

    byte[] pointTypes;

    double[] pointCoords;

    int numTypes;

    int numCoords;

    int windingRule;

    static final int INIT_SIZE = 20;

    static final int EXPAND_MAX = 500;

    /**

     * Constructs a new <code>GeneralPathX</code> object.

     * If an operation performed on this path requires the

     * interior of the path to be defined then the default NON_ZERO

     * winding rule is used.

     * @see #WIND_NON_ZERO

     */

    public GeneralPathX() {

	this(WIND_NON_ZERO, INIT_SIZE, INIT_SIZE);

    }

    /**

     * Constructs a new <code>GeneralPathX</code> object with the specified 

     * winding rule to control operations that require the interior of the

     * path to be defined.

     * @param rule the winding rule

     * @see #WIND_EVEN_ODD

     * @see #WIND_NON_ZERO

     */

    public GeneralPathX(int rule) {

	this(rule, INIT_SIZE, INIT_SIZE);

    }

    /**

     * Constructs a new <code>GeneralPathX</code> object with the specified 

     * winding rule and the specified initial capacity to store path 

     * coordinates. This number is an initial guess as to how many path 

     * segments are in the path, but the storage is expanded 

     * as needed to store whatever path segments are added to this path.

     * @param rule the winding rule

     * @param initialCapacity the estimate for the number of path segments

     * in the path

     * @see #WIND_EVEN_ODD

     * @see #WIND_NON_ZERO

     */

    public GeneralPathX(int rule, int initialCapacity) {

	this(rule, initialCapacity, initialCapacity);

    }

    /**

     * Constructs a new <code>GeneralPathX</code> object with the specified 

     * winding rule and the specified initial capacities to store point types

     * and coordinates.

     * These numbers are an initial guess as to how many path segments

     * and how many points are to be in the path, but the

     * storage is expanded as needed to store whatever path segments are

     * added to this path.

     * @param rule the winding rule

     * @param initialTypes the estimate for the number of path segments

     * in the path

     * @param initialCapacity the estimate for the number of points

     * @see #WIND_EVEN_ODD

     * @see #WIND_NON_ZERO

     */

    GeneralPathX(int rule, int initialTypes, int initialCoords) {

	setWindingRule(rule);

	pointTypes = new byte[initialTypes];

	pointCoords = new double[initialCoords * 2];

    }

    /**

     * Constructs a new <code>GeneralPathX</code> object from an arbitrary 

     * {@link Shape} object.

     * All of the initial geometry and the winding rule for this path are

     * taken from the specified <code>Shape</code> object.

     * @param s the specified <code>Shape</code> object

     */

    public GeneralPathX(Shape s) {

	this(WIND_NON_ZERO, INIT_SIZE, INIT_SIZE);

	PathIterator pi = s.getPathIterator(null);

	setWindingRule(pi.getWindingRule());

	append(pi, false);

    }

    private void needRoom(int newTypes, int newCoords, boolean needMove) {

	if (needMove && numTypes == 0) {

	    throw new IllegalPathStateException("missing initial moveto "+

						"in path definition");

	}

	int size = pointCoords.length;

	if (numCoords + newCoords > size) {

	    int grow = size;

	    if (grow > EXPAND_MAX * 2) {

		grow = EXPAND_MAX * 2;

	    }

	    if (grow < newCoords) {

		grow = newCoords;

	    }

	    double[] arr = new double[size + grow];

	    System.arraycopy(pointCoords, 0, arr, 0, numCoords);

	    pointCoords = arr;

	}

	size = pointTypes.length;

	if (numTypes + newTypes > size) {

	    int grow = size;

	    if (grow > EXPAND_MAX) {

		grow = EXPAND_MAX;

	    }

	    if (grow < newTypes) {

		grow = newTypes;

	    }

	    byte[] arr = new byte[size + grow];

	    System.arraycopy(pointTypes, 0, arr, 0, numTypes);

	    pointTypes = arr;

	}

    }

    /**

     * Adds a point to the path by moving to the specified

     * coordinates.

     * @param x, y the specified coordinates

     */

    public synchronized void moveTo(double x, double y) {

	if (numTypes > 0 && pointTypes[numTypes - 1] == SEG_MOVETO) {

	    pointCoords[numCoords - 2] = x;

	    pointCoords[numCoords - 1] = y;

	} else {

	    needRoom(1, 2, false);

	    pointTypes[numTypes++] = SEG_MOVETO;

	    pointCoords[numCoords++] = x;

	    pointCoords[numCoords++] = y;

	}

    }

    /**

     * Adds a point to the path by drawing a straight line from the

     * current coordinates to the new specified coordinates.

     * @param x, y the specified coordinates

     */

    public synchronized void lineTo(double x, double y) {

	needRoom(1, 2, true);

	pointTypes[numTypes++] = SEG_LINETO;

	pointCoords[numCoords++] = x;

	pointCoords[numCoords++] = y;

    }

    /**

     * Adds a curved segment, defined by two new points, to the path by

     * drawing a Quadratic curve that intersects both the current

     * coordinates and the coordinates (x2, y2), using the 

     * specified point (x1, y1) as a quadratic parametric control

     * point.

     * @param x1, y1 the coordinates of the first quadratic control

     *		point

     * @param x2, y2 the coordinates of the final endpoint

     */

    public synchronized void quadTo(double x1, double y1, double x2, double y2) {

	needRoom(1, 4, true);

	pointTypes[numTypes++] = SEG_QUADTO;

	pointCoords[numCoords++] = x1;

	pointCoords[numCoords++] = y1;

	pointCoords[numCoords++] = x2;

	pointCoords[numCoords++] = y2;

    }

    /**

     * Adds a curved segment, defined by three new points, to the path by

     * drawing a Bézier curve that intersects both the current

     * coordinates and the coordinates (x3, y3), using the    

     * specified points (x1, y1) and (x2, y2) as

     * Bézier control points.

     * @param x1, y1 the coordinates of the first Béezier

     *		control point

     * @param x2, y2 the coordinates of the second Bézier

     *		control point

     * @param x3, y3 the coordinates of the final endpoint

     */

    public synchronized void curveTo(double x1, double y1,

    		double x2, double y2,

    		double x3, double y3) {

	needRoom(1, 6, true);

	pointTypes[numTypes++] = SEG_CUBICTO;

	pointCoords[numCoords++] = x1;

	pointCoords[numCoords++] = y1;

	pointCoords[numCoords++] = x2;

	pointCoords[numCoords++] = y2;

	pointCoords[numCoords++] = x3;

	pointCoords[numCoords++] = y3;

    }

    /**

     * Closes the current subpath by drawing a straight line back to

     * the coordinates of the last <code>moveTo</code>.  If the path is already

     * closed then this method has no effect.

     */

    public synchronized void closePath() {

	if (numTypes == 0 || pointTypes[numTypes - 1] != SEG_CLOSE) {

	    needRoom(1, 0, true);

	    pointTypes[numTypes++] = SEG_CLOSE;

	}

    }

    /**

     * Appends the geometry of the specified <code>Shape</code> object to the

     * path, possibly connecting the new geometry to the existing path

     * segments with a line segment.

     * If the <code>connect</code> parameter is <code>true</code> and the 

     * path is not empty then any initial <code>moveTo</code> in the

     * geometry of the appended <code>Shape</code>

     * is turned into a <code>lineTo</code> segment.

     * If the destination coordinates of such a connecting <code>lineTo</code>

     * segment match the ending coordinates of a currently open

     * subpath then the segment is omitted as superfluous.

     * The winding rule of the specified <code>Shape</code> is ignored

     * and the appended geometry is governed by the winding

     * rule specified for this path.

     * @param s the <code>Shape</code> whose geometry is appended 

     * to this path

     * @param connect a boolean to control whether or not to turn an

     * initial <code>moveTo</code> segment into a <code>lineTo</code>

     * segment to connect the new geometry to the existing path

     */

    public void append(Shape s, boolean connect) {

	PathIterator pi = s.getPathIterator(null);

        append(pi,connect);

    }

    /**

     * Appends the geometry of the specified

     * {@link PathIterator} object 

     * to the path, possibly connecting the new geometry to the existing

     * path segments with a line segment.

     * If the <code>connect</code> parameter is <code>true</code> and the 

     * path is not empty then any initial <code>moveTo</code> in the

     * geometry of the appended <code>Shape</code> is turned into a

     * <code>lineTo</code> segment.

     * If the destination coordinates of such a connecting <code>lineTo</code>

     * segment match the ending coordinates of a currently open

     * subpath then the segment is omitted as superfluous.

     * The winding rule of the specified <code>Shape</code> is ignored

     * and the appended geometry is governed by the winding

     * rule specified for this path.

     * @param pi the <code>PathIterator</code> whose geometry is appended to 

     * this path

     * @param connect a boolean to control whether or not to turn an

     * initial <code>moveTo</code> segment into a <code>lineTo</code> segment

     * to connect the new geometry to the existing path

     */

    public void append(PathIterator pi, boolean connect) {

	double coords[] = new double[6];

	while (!pi.isDone()) {

	    switch (pi.currentSegment(coords)) {

	    case SEG_MOVETO:

		if (!connect || numTypes < 1 || numCoords < 2) {

		    moveTo(coords[0], coords[1]);

		    break;

		}

		if (pointTypes[numTypes - 1] != SEG_CLOSE &&

		    pointCoords[numCoords - 2] == coords[0] &&

		    pointCoords[numCoords - 1] == coords[1])

		{

		    // Collapse out initial moveto/lineto

		    break;

		}

		// NO BREAK;

	    case SEG_LINETO:

		lineTo(coords[0], coords[1]);

		break;

	    case SEG_QUADTO:

		quadTo(coords[0], coords[1],

		       coords[2], coords[3]);

		break;

	    case SEG_CUBICTO:

		curveTo(coords[0], coords[1],

			coords[2], coords[3],

			coords[4], coords[5]);

		break;

	    case SEG_CLOSE:

		closePath();

		break;

	    }

	    pi.next();

	    connect = false;

	}

    }

    /**

     * Returns the fill style winding rule.

     * @return an integer representing the current winding rule.

     * @see #WIND_EVEN_ODD  

     * @see #WIND_NON_ZERO

     * @see #setWindingRule

     */

    public synchronized int getWindingRule() {

        return windingRule;

    }

    /**

     * Sets the winding rule for this path to the specified value.

     * @param rule an integer representing the specified 

     * winding rule

     * @exception <code>IllegalArgumentException</code> if 

     *		<code>rule</code> is not either 

     *		<code>WIND_EVEN_ODD</code> or

     *		<code>WIND_NON_ZERO</code>

     * @see #WIND_EVEN_ODD  

     * @see #WIND_NON_ZERO

     * @see #getWindingRule

     */

    public void setWindingRule(int rule) {

	if (rule != WIND_EVEN_ODD && rule != WIND_NON_ZERO) {

	    throw new IllegalArgumentException("winding rule must be "+

					       "WIND_EVEN_ODD or "+

					       "WIND_NON_ZERO");

	}

	windingRule = rule;

    }

    /**

     * Returns the coordinates most recently added to the end of the path