gvSIG external » org.gvsig.jdk

<?xml version="1.0" encoding="ISO-8859-1"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<groupId>org.gvsig</groupId>

	<artifactId>org.gvsig.jdk</artifactId>

	<packaging>pom</packaging>

	<version>1.0.1</version>

	<name>org.gvsig.jdk</name>

	<description>This library contains some private classes of the OpenJDK</description>

	<url>https://devel.gvsig.org/redmine/projects/gvsig-external-jdk</url>

    <licenses>

        <license>

            <name>GPLv3</name>

            <url>http://www.gnu.org/licenses/gpl.html</url>

            <distribution>repo</distribution>

            <comments>

                "GPL" stands for "General Public License". The most widespread such

                license is the GNU General Public License, or GNU GPL for short.

                This can be further shortened to "GPL", when it is understood that

                the GNU GPL is the one intended.

            </comments>

        </license>

    </licenses>

    <organization>

        <name>gvSIG Association</name>

        <url>http://www.gvsig.com/</url>

    </organization>

    <scm>

        <connection>scm:svn:https://devel.gvsig.org/svn/gvsig-external-jdk/org.gvsig.jdk/tags/org.gvsig.jdk-1.0.1</connection>

        <developerConnection>scm:svn:https://devel.gvsig.org/svn/gvsig-external-jdk/org.gvsig.jdk/tags/org.gvsig.jdk-1.0.1</developerConnection>

        <url>scm:svn:https://devel.gvsig.org/svn/gvsig-external-jdk/org.gvsig.jdk/tags/org.gvsig.jdk-1.0.1</url>

    </scm>

   	<developers>

		<developer>

			<id>jjdelcerro</id>

			<name>Joaquin Jose del Cerro Murciano</name>

			<email>jjdelcerro@gvsig.com</email>

			<roles>

				<role>Architect</role>

				<role>Developer</role>

			</roles>

		</developer>

	</developers>

    <repositories>

        <repository>

            <id>gvsig-public-http-repository</id>

            <name>gvSIG maven public HTTP repository</name>

            <url>http://devel.gvsig.org/m2repo/j2se</url>

            <releases>

                <enabled>true</enabled>

                <updatePolicy>daily</updatePolicy>

                <checksumPolicy>warn</checksumPolicy>

            </releases>

            <snapshots>

                <enabled>true</enabled>

                <updatePolicy>daily</updatePolicy>

                <checksumPolicy>warn</checksumPolicy>

            </snapshots>

        </repository>

    </repositories>

    <distributionManagement>

        <site>

            <id>gvsig-repository</id>

            <url>dav:https://devel.gvsig.org/sites/${project.artifactId}/${project.version}</url>

        </site>

        <repository>

            <id>gvsig-repository</id>

            <name>gvSIG maven repository</name>

            <url>dav:https://devel.gvsig.org/m2repo/j2se</url>

            <uniqueVersion>false</uniqueVersion>

        </repository>

        <snapshotRepository>

            <id>gvsig-repository</id>

            <name>gvSIG maven repository</name>

            <url>dav:https://devel.gvsig.org/m2repo/j2se</url>

            <uniqueVersion>false</uniqueVersion>

        </snapshotRepository>

    </distributionManagement>

	<dependencyManagement>

		<dependencies>

			<dependency>

				<groupId>org.gvsig</groupId>

				<artifactId>org.gvsig.tools.lib</artifactId>

				<version>3.0.53</version>

			</dependency>

		</dependencies>

	</dependencyManagement>

	<build>

        <extensions>

            <extension>

                <groupId>org.apache.maven.wagon</groupId>

                <artifactId>wagon-webdav-jackrabbit</artifactId>

                <version>2.4</version>

            </extension>

        </extensions>

		<plugins>

		    <plugin>

		      <artifactId>maven-release-plugin</artifactId>

		      <version>2.0</version>

		      <configuration>

		        <tagBase>https://devel.gvsig.org/svn/gvsig-external-jdk/org.gvsig.jdk/tags</tagBase>

		      </configuration>

			</plugin>

		</plugins>

	</build>

	<modules>

<!--

		<module>org.gvsig.jdk.v1_4</module>

-->

		<module>org.gvsig.jdk.v1_6</module>

	</modules>

	<reporting>

		<plugins>

			<plugin>

				<groupId>org.apache.maven.plugins</groupId>

				<artifactId>maven-javadoc-plugin</artifactId>

				<configuration>

					<links>

						<link>http://java.sun.com/j2se/1.5.0/docs/api/</link>

						<link>http://www.slf4j.org/api/</link>

					</links>

				</configuration>

			</plugin>

		</plugins>

	</reporting>

</project>

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

<projectDescription>

	<name>org.gvsig.jdk</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

	</buildSpec>

	<natures>

	</natures>

</projectDescription>

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 * 

 */

/*

 * AUTHORS (In addition to CIT):

 * 2009 {Iver T.I.}   {Task}

 */

package org.gvsig.jdk;

import java.awt.geom.PathIterator;

import sun.awt.geom.Crossings;

import sun.awt.geom.Curve;

/**

 * This class contains some utility methods to access to some 

 * private classes of the OpenJDK. These classes have been copied

 * to this package and their visibility has been reduced. It is not

 * possible to access them without using this class. 

 * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>

 */

public class GeomUtilities {

	/**

	 * Tests if the specified rectangular area is inside the boundary of

	 * a <code>Shape</code>.

	 * @param pi the path iterator of a shape

	 * @param x, y the specified coordinates

	 * @param w the width of the specified rectangular area

	 * @param h the height of the specified rectangular area

	 * @return <code>true</code> if this <code>Shape</code> contains

	 * the specified rectangluar area; <code>false</code> otherwise.

	 */

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

		Crossings c = Crossings.findCrossings(pi,

				x, y, x+w, y+h);

		return (c != null && c.covers(y, y+h));

	}

	/**

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

	 * interior of a specified set of rectangular coordinates.

	 * @param pi the path iterator of a shape

	 * @param x, y the specified coordinates

	 * @param w the width of the specified rectangular coordinates

	 * @param h the height of the specified rectangular coordinates

	 * @return <code>true</code> if this <code>Shape</code> and the

	 * interior of the specified set of rectangular coordinates intersect

	 * each other; <code>false</code> otherwise.

	 */

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

		Crossings c = Crossings.findCrossings(pi,

				x, y, x+w, y+h);

		return (c == null || !c.isEmpty());

	}

	 /**

     * Calculates the number of times the given path

     * crosses the ray extending to the right from (px,py).

     * If the point lies on a part of the path,

     * then no crossings are counted for that intersection.

     * +1 is added for each crossing where the Y coordinate is increasing

     * -1 is added for each crossing where the Y coordinate is decreasing

     * The path must start with a SEG_MOVETO, otherwise an exception is

     * thrown.

     * The caller must check p[xy] for NaN values.

     * The caller may also reject infinite p[xy] values as well.

     * @param pi the path iterator of a shape

     * @param px the x coordinate

     * @param py the y coordinate

     * @return is the sum of all crossings for every segment in

     * the path

     */

	public static int pointCrossingsForPath(PathIterator pi, double px, double py){

		return Curve.crossingsForPath(pi, px, py);

	}

}

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

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

<title>${package} package documentation</title>

</head>

<body>

	<p>TODO: Example library API description.</p>

	<p>See the <a href="http://java.sun.com/j2se/1.4.2/docs/tooldocs/windows/javadoc.html${symbol_pound}packagecomment">Javadoc Tool documentation about the package file</a></p>

</body>

</html>

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

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

<title>${artifactId} package documentation</title>

</head>

<body>

	<p>TODO: Example library API overview.</p>

	<p>See the <a href="http://java.sun.com/j2se/1.4.2/docs/tooldocs/windows/javadoc.html${symbol_pound}overviewcomment">Javadoc Tool documentation about the overview file</a></p>

</body>

</html>

<?xml version="1.0" encoding="ISO-8859-1"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<artifactId>org.gvsig.jdk.v1_4</artifactId>

	<packaging>jar</packaging>

	<name>org.gvsig.jdk.v1_4</name>

	<description>Private classes of the OpenJDK v1.4</description>

	<parent>

		<groupId>org.gvsig</groupId>

		<artifactId>org.gvsig.jdk</artifactId>

		<version>1.0.1-SNAPSHOT</version>

	</parent>

	<dependencies>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.tools.lib</artifactId>

		</dependency>

	</dependencies>

	<profiles>

		<profile>

			<id>windows-profile</id>

			<activation>

				<os>

                    <family>Windows</family>

				</os>

			</activation>

		    <build>

		        <plugins>

		            <plugin>

		                <groupId>org.apache.maven.plugins</groupId>

		                <artifactId>maven-compiler-plugin</artifactId>

		                <configuration>

		                  <verbose>true</verbose>

		                  <fork>true</fork>

		                  <executable>C:\j2sdk1.4.2_19\bin\javac</executable>

		                  <compilerVersion>1.4</compilerVersion>

		                  <source>1.4</source>

		                  <target>1.4</target>

		                </configuration>

		            </plugin>

		            <plugin>

		                <groupId>org.codehaus.mojo</groupId>

		                <artifactId>animal-sniffer-maven-plugin</artifactId>

		                <configuration>

		                    <skip>true</skip>

		                </configuration>

		            </plugin>

		        </plugins>

		    </build>

		</profile>

		<profile>

			<id>linux-profile</id>

			<activation>

				<os>

                    <family>Linux</family>

				</os>

			</activation>

            <build>

		        <plugins>

		            <plugin>

		                <groupId>org.apache.maven.plugins</groupId>

		                <artifactId>maven-compiler-plugin</artifactId>

		                <configuration>

		                  <verbose>true</verbose>

		                  <fork>true</fork>

		                  <executable>/usr/lib/jvm/j2sdk1.4.2_19/bin/javac</executable>

		                  <compilerVersion>1.4</compilerVersion>

		                  <source>1.4</source>

		                  <target>1.4</target>

		                </configuration>

		            </plugin>

		            <plugin>

		                <groupId>org.codehaus.mojo</groupId>

		                <artifactId>animal-sniffer-maven-plugin</artifactId>

		                <configuration>

		                    <skip>true</skip>

		                </configuration>

		            </plugin>

		        </plugins>

		    </build>

		</profile>

	</profiles>

</project>

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

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

<title>${artifactId} package documentation</title>

</head>

<body>

	<p>TODO: Example library API overview.</p>

	<p>See the <a href="http://java.sun.com/j2se/1.4.2/docs/tooldocs/windows/javadoc.html${symbol_pound}overviewcomment">Javadoc Tool documentation about the overview file</a></p>

</body>

</html>

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

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

<title>${package} package documentation</title>

</head>

<body>

	<p>TODO: Example library API description.</p>

	<p>See the <a href="http://java.sun.com/j2se/1.4.2/docs/tooldocs/windows/javadoc.html${symbol_pound}packagecomment">Javadoc Tool documentation about the package file</a></p>

</body>

</html>

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 * 

 */

/*

 * AUTHORS (In addition to CIT):

 * 2009 {Iver T.I.}   {Task}

 */

package org.gvsig.jdk;

import java.awt.geom.PathIterator;

import org.gvsig.jdk.sun.awt.geom.Crossings;

import org.gvsig.jdk.sun.awt.geom.Curve;

/**

 * This class contains some utility methods to access to some 

 * private classes of the OpenJDK. These classes have been copied

 * to this package and their visibility has been reduced. It is not

 * possible to access them without using this class. 

 * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>

 */

public class GeomUtilities {

	/**

	 * Tests if the specified rectangular area is inside the boundary of

	 * a <code>Shape</code>.

	 * @param pi the path iterator of a shape

	 * @param x, y the specified coordinates

	 * @param w the width of the specified rectangular area

	 * @param h the height of the specified rectangular area

	 * @return <code>true</code> if this <code>Shape</code> contains

	 * the specified rectangluar area; <code>false</code> otherwise.

	 */

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

		Crossings c = Crossings.findCrossings(pi,

				x, y, x+w, y+h);

		return (c != null && c.covers(y, y+h));

	}

	/**

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

	 * interior of a specified set of rectangular coordinates.

	 * @param pi the path iterator of a shape

	 * @param x, y the specified coordinates

	 * @param w the width of the specified rectangular coordinates

	 * @param h the height of the specified rectangular coordinates

	 * @return <code>true</code> if this <code>Shape</code> and the

	 * interior of the specified set of rectangular coordinates intersect

	 * each other; <code>false</code> otherwise.

	 */

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

		Crossings c = Crossings.findCrossings(pi,

				x, y, x+w, y+h);

		return (c == null || !c.isEmpty());

	}

	 /**

     * Calculates the number of times the given path

     * crosses the ray extending to the right from (px,py).

     * If the point lies on a part of the path,

     * then no crossings are counted for that intersection.

     * +1 is added for each crossing where the Y coordinate is increasing

     * -1 is added for each crossing where the Y coordinate is decreasing

     * The path must start with a SEG_MOVETO, otherwise an exception is

     * thrown.

     * The caller must check p[xy] for NaN values.

     * The caller may also reject infinite p[xy] values as well.

     * @param pi the path iterator of a shape

     * @param px the x coordinate

     * @param py the y coordinate

     * @return is the sum of all crossings for every segment in

     * the path

     */

	public static int pointCrossingsForPath(PathIterator pi, double px, double py){

		return Curve.pointCrossingsForPath(pi, px, py);

	}

}

/*

 * Copyright 1998-2003 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package org.gvsig.jdk.sun.awt.geom;

import java.awt.geom.PathIterator;

import java.util.Enumeration;

import java.util.Vector;

public abstract class Crossings {

    public static final boolean debug = false;

    int limit = 0;

    double yranges[] = new double[10];

    double xlo, ylo, xhi, yhi;

    Crossings(double xlo, double ylo, double xhi, double yhi) {

        this.xlo = xlo;

        this.ylo = ylo;

        this.xhi = xhi;

        this.yhi = yhi;

    }

    public final double getXLo() {

        return xlo;

    }

    public final double getYLo() {

        return ylo;

    }

    public final double getXHi() {

        return xhi;

    }

    public final double getYHi() {

        return yhi;

    }

    public abstract void record(double ystart, double yend, int direction);

    public void print() {

        System.out.println("Crossings [");

        System.out.println("  bounds = ["+ylo+", "+yhi+"]");

        for (int i = 0; i < limit; i += 2) {

            System.out.println("  ["+yranges[i]+", "+yranges[i+1]+"]");

        }

        System.out.println("]");

    }

    public final boolean isEmpty() {

        return (limit == 0);

    }

    public abstract boolean covers(double ystart, double yend);

    public static Crossings findCrossings(Vector curves,

                                          double xlo, double ylo,

                                          double xhi, double yhi)

    {

        Crossings cross = new EvenOdd(xlo, ylo, xhi, yhi);

        Enumeration enum_ = curves.elements();

        while (enum_.hasMoreElements()) {

            Curve c = (Curve) enum_.nextElement();

            if (c.accumulateCrossings(cross)) {

                return null;

            }

        }

        if (debug) {

            cross.print();

        }

        return cross;

    }

    public static Crossings findCrossings(PathIterator pi,

                                          double xlo, double ylo,

                                          double xhi, double yhi)

    {

        Crossings cross;

        if (pi.getWindingRule() == pi.WIND_EVEN_ODD) {

            cross = new EvenOdd(xlo, ylo, xhi, yhi);

        } else {

            cross = new NonZero(xlo, ylo, xhi, yhi);

        }

        // coords array is big enough for holding:

        //     coordinates returned from currentSegment (6)

        //     OR

        //         two subdivided quadratic curves (2+4+4=10)

        //         AND

        //             0-1 horizontal splitting parameters

        //             OR

        //             2 parametric equation derivative coefficients

        //     OR

        //         three subdivided cubic curves (2+6+6+6=20)

        //         AND

        //             0-2 horizontal splitting parameters

        //             OR

        //             3 parametric equation derivative coefficients

        double coords[] = new double[23];

        double movx = 0;

        double movy = 0;

        double curx = 0;

        double cury = 0;

        double newx, newy;

        while (!pi.isDone()) {

            int type = pi.currentSegment(coords);

            switch (type) {

            case PathIterator.SEG_MOVETO:

                if (movy != cury &&

                    cross.accumulateLine(curx, cury, movx, movy))

                {

                    return null;

                }

                movx = curx = coords[0];

                movy = cury = coords[1];

                break;

            case PathIterator.SEG_LINETO:

                newx = coords[0];

                newy = coords[1];

                if (cross.accumulateLine(curx, cury, newx, newy)) {

                    return null;

                }

                curx = newx;

                cury = newy;

                break;

            case PathIterator.SEG_QUADTO:

                newx = coords[2];

                newy = coords[3];

                if (cross.accumulateQuad(curx, cury, coords)) {

                    return null;

                }

                curx = newx;

                cury = newy;

                break;

            case PathIterator.SEG_CUBICTO:

                newx = coords[4];

                newy = coords[5];

                if (cross.accumulateCubic(curx, cury, coords)) {

                    return null;

                }

                curx = newx;

                cury = newy;

                break;

            case PathIterator.SEG_CLOSE:

                if (movy != cury &&

                    cross.accumulateLine(curx, cury, movx, movy))

                {

                    return null;

                }

                curx = movx;

                cury = movy;

                break;

            }

            pi.next();

        }

        if (movy != cury) {

            if (cross.accumulateLine(curx, cury, movx, movy)) {

                return null;

            }

        }

        if (debug) {

            cross.print();

        }

        return cross;

    }

    public boolean accumulateLine(double x0, double y0,

                                  double x1, double y1)

    {

        if (y0 <= y1) {

            return accumulateLine(x0, y0, x1, y1, 1);

        } else {

            return accumulateLine(x1, y1, x0, y0, -1);

        }

    }

    public boolean accumulateLine(double x0, double y0,

                                  double x1, double y1,

                                  int direction)

    {

        if (yhi <= y0 || ylo >= y1) {

            return false;

        }

        if (x0 >= xhi && x1 >= xhi) {

            return false;

        }

        if (y0 == y1) {

            return (x0 >= xlo || x1 >= xlo);

        }

        double xstart, ystart, xend, yend;

        double dx = (x1 - x0);

        double dy = (y1 - y0);

        if (y0 < ylo) {

            xstart = x0 + (ylo - y0) * dx / dy;

            ystart = ylo;

        } else {

            xstart = x0;

            ystart = y0;

        }

        if (yhi < y1) {

            xend = x0 + (yhi - y0) * dx / dy;

            yend = yhi;

        } else {

            xend = x1;

            yend = y1;

        }

        if (xstart >= xhi && xend >= xhi) {

            return false;

        }

        if (xstart > xlo || xend > xlo) {

            return true;

        }

        record(ystart, yend, direction);

        return false;

    }

    private Vector tmp = new Vector();

    public boolean accumulateQuad(double x0, double y0, double coords[]) {

        if (y0 < ylo && coords[1] < ylo && coords[3] < ylo) {

            return false;

        }

        if (y0 > yhi && coords[1] > yhi && coords[3] > yhi) {

            return false;

        }

        if (x0 > xhi && coords[0] > xhi && coords[2] > xhi) {

            return false;

        }

        if (x0 < xlo && coords[0] < xlo && coords[2] < xlo) {

            if (y0 < coords[3]) {

                record(Math.max(y0, ylo), Math.min(coords[3], yhi), 1);

            } else if (y0 > coords[3]) {

                record(Math.max(coords[3], ylo), Math.min(y0, yhi), -1);

            }

            return false;

        }

        Curve.insertQuad(tmp, x0, y0, coords);

        Enumeration enum_ = tmp.elements();

        while (enum_.hasMoreElements()) {

            Curve c = (Curve) enum_.nextElement();

            if (c.accumulateCrossings(this)) {

                return true;

            }

        }

        tmp.clear();

        return false;

    }

    public boolean accumulateCubic(double x0, double y0, double coords[]) {

        if (y0 < ylo && coords[1] < ylo &&

            coords[3] < ylo && coords[5] < ylo)

        {

            return false;

        }

        if (y0 > yhi && coords[1] > yhi &&

            coords[3] > yhi && coords[5] > yhi)

        {

            return false;

        }

        if (x0 > xhi && coords[0] > xhi &&

            coords[2] > xhi && coords[4] > xhi)

        {

            return false;

        }

        if (x0 < xlo && coords[0] < xlo &&

            coords[2] < xlo && coords[4] < xlo)

        {

            if (y0 <= coords[5]) {

                record(Math.max(y0, ylo), Math.min(coords[5], yhi), 1);

            } else {

                record(Math.max(coords[5], ylo), Math.min(y0, yhi), -1);

            }

            return false;

        }

        Curve.insertCubic(tmp, x0, y0, coords);

        Enumeration enum_ = tmp.elements();

        while (enum_.hasMoreElements()) {

            Curve c = (Curve) enum_.nextElement();

            if (c.accumulateCrossings(this)) {

                return true;

            }

        }

        tmp.clear();

        return false;

    }

    final static class EvenOdd extends Crossings {

        public EvenOdd(double xlo, double ylo, double xhi, double yhi) {

            super(xlo, ylo, xhi, yhi);

        }

        public final boolean covers(double ystart, double yend) {

            return (limit == 2 && yranges[0] <= ystart && yranges[1] >= yend);

        }

        public void record(double ystart, double yend, int direction) {

            if (ystart >= yend) {

                return;

            }

            int from = 0;

            // Quickly jump over all pairs that are completely "above"

            while (from < limit && ystart > yranges[from+1]) {

                from += 2;

            }

            int to = from;

            while (from < limit) {

                double yrlo = yranges[from++];

                double yrhi = yranges[from++];

                if (yend < yrlo) {

                    // Quickly handle insertion of the new range

                    yranges[to++] = ystart;

                    yranges[to++] = yend;

                    ystart = yrlo;

                    yend = yrhi;

                    continue;

                }

                // The ranges overlap - sort, collapse, insert, iterate

                double yll, ylh, yhl, yhh;

                if (ystart < yrlo) {

                    yll = ystart;

                    ylh = yrlo;

                } else {

                    yll = yrlo;

                    ylh = ystart;

                }

                if (yend < yrhi) {

                    yhl = yend;

                    yhh = yrhi;

                } else {

                    yhl = yrhi;

                    yhh = yend;

                }

                if (ylh == yhl) {

                    ystart = yll;

                    yend = yhh;

                } else {

                    if (ylh > yhl) {

                        ystart = yhl;

                        yhl = ylh;

                        ylh = ystart;

                    }

                    if (yll != ylh) {

                        yranges[to++] = yll;

                        yranges[to++] = ylh;

                    }

                    ystart = yhl;

                    yend = yhh;

                }

                if (ystart >= yend) {

                    break;

                }

            }

            if (to < from && from < limit) {

                System.arraycopy(yranges, from, yranges, to, limit-from);

            }

            to += (limit-from);

            if (ystart < yend) {

                if (to >= yranges.length) {

                    double newranges[] = new double[to+10];

                    System.arraycopy(yranges, 0, newranges, 0, to);

                    yranges = newranges;

                }

                yranges[to++] = ystart;

                yranges[to++] = yend;

            }

            limit = to;

        }

    }

    final static class NonZero extends Crossings {

        private int crosscounts[];

        public NonZero(double xlo, double ylo, double xhi, double yhi) {

            super(xlo, ylo, xhi, yhi);

            crosscounts = new int[yranges.length / 2];

        }

        public final boolean covers(double ystart, double yend) {

            int i = 0;

            while (i < limit) {

                double ylo = yranges[i++];

                double yhi = yranges[i++];

                if (ystart >= yhi) {

                    continue;

                }

                if (ystart < ylo) {

                    return false;

                }

                if (yend <= yhi) {

                    return true;

                }

                ystart = yhi;

            }

            return (ystart >= yend);

        }

        public void remove(int cur) {

            limit -= 2;

            int rem = limit - cur;

            if (rem > 0) {

                System.arraycopy(yranges, cur+2, yranges, cur, rem);

                System.arraycopy(crosscounts, cur/2+1,

                                 crosscounts, cur/2,

                                 rem/2);

            }

        }

        public void insert(int cur, double lo, double hi, int dir) {

            int rem = limit - cur;

            double oldranges[] = yranges;

            int oldcounts[] = crosscounts;

            if (limit >= yranges.length) {

                yranges = new double[limit+10];

                System.arraycopy(oldranges, 0, yranges, 0, cur);

                crosscounts = new int[(limit+10)/2];

                System.arraycopy(oldcounts, 0, crosscounts, 0, cur/2);

            }

            if (rem > 0) {

                System.arraycopy(oldranges, cur, yranges, cur+2, rem);

                System.arraycopy(oldcounts, cur/2,

                                 crosscounts, cur/2+1,

                                 rem/2);

            }

            yranges[cur+0] = lo;

            yranges[cur+1] = hi;

            crosscounts[cur/2] = dir;

            limit += 2;

        }

        public void record(double ystart, double yend, int direction) {

            if (ystart >= yend) {

                return;

            }

            int cur = 0;

            // Quickly jump over all pairs that are completely "above"

            while (cur < limit && ystart > yranges[cur+1]) {

                cur += 2;

            }

            if (cur < limit) {

                int rdir = crosscounts[cur/2];

                double yrlo = yranges[cur+0];

                double yrhi = yranges[cur+1];

                if (yrhi == ystart && rdir == direction) {

                    // Remove the range from the list and collapse it

                    // into the range being inserted.  Note that the

                    // new combined range may overlap the following range

                    // so we must not simply combine the ranges in place

                    // unless we are at the last range.

                    if (cur+2 == limit) {

                        yranges[cur+1] = yend;

                        return;

                    }

                    remove(cur);

                    ystart = yrlo;

                    rdir = crosscounts[cur/2];

                    yrlo = yranges[cur+0];

                    yrhi = yranges[cur+1];

                }

                if (yend < yrlo) {

                    // Just insert the new range at the current location

                    insert(cur, ystart, yend, direction);

                    return;

                }

                if (yend == yrlo && rdir == direction) {

                    // Just prepend the new range to the current one

                    yranges[cur] = ystart;

                    return;

                }

                // The ranges must overlap - (yend > yrlo && yrhi > ystart)

                if (ystart < yrlo) {

                    insert(cur, ystart, yrlo, direction);

                    cur += 2;

                    ystart = yrlo;

                } else if (yrlo < ystart) {

                    insert(cur, yrlo, ystart, rdir);

                    cur += 2;

                    yrlo = ystart;

                }

                // assert(yrlo == ystart);

                int newdir = rdir + direction;

                double newend = Math.min(yend, yrhi);

                if (newdir == 0) {

                    remove(cur);

                } else {

                    crosscounts[cur/2] = newdir;

                    yranges[cur++] = ystart;

                    yranges[cur++] = newend;

                }

                ystart = yrlo = newend;

                if (yrlo < yrhi) {

                    insert(cur, yrlo, yrhi, rdir);

                }

            }

            if (ystart < yend) {

                insert(cur, ystart, yend, direction);

            }

        }

    }

}

/*

 * Copyright 1998 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package org.gvsig.jdk.sun.awt.geom;

import java.awt.geom.PathIterator;

import java.awt.geom.Rectangle2D;

final class Order0 extends Curve {

    private double x;

    private double y;

    Order0(double x, double y) {

        super(INCREASING);

        this.x = x;

        this.y = y;

    }

    public int getOrder() {

        return 0;

    }

    public double getXTop() {

        return x;

    }

    public double getYTop() {

        return y;

    }

    public double getXBot() {

        return x;

    }

    public double getYBot() {

        return y;

    }

    public double getXMin() {

        return x;

    }

    public double getXMax() {

        return x;

    }

    public double getX0() {

        return x;

    }

    public double getY0() {

        return y;

    }

    public double getX1() {

        return x;

    }

    public double getY1() {

        return y;

    }

    public double XforY(double y) {

        return y;

    }

    public double TforY(double y) {

        return 0;

    }

    public double XforT(double t) {

        return x;

    }

    public double YforT(double t) {

        return y;

    }

    public double dXforT(double t, int deriv) {

        return 0;

    }

    public double dYforT(double t, int deriv) {

        return 0;

    }

    public double nextVertical(double t0, double t1) {

        return t1;

    }

    public int crossingsFor(double x, double y) {

        return 0;

    }

    public boolean accumulateCrossings(Crossings c) {

        return (x > c.getXLo() &&

                x < c.getXHi() &&

                y > c.getYLo() &&

                y < c.getYHi());

    }

    public void enlarge(Rectangle2D r) {

        r.add(x, y);

    }

    public Curve getSubCurve(double ystart, double yend, int dir) {

        return this;

    }

    public Curve getReversedCurve() {

        return this;

    }

    public int getSegment(double coords[]) {

        coords[0] = x;

        coords[1] = y;

        return PathIterator.SEG_MOVETO;

    }

}

/*

 * Copyright 1998-2006 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package org.gvsig.jdk.sun.awt.geom;

import java.awt.geom.PathIterator;

import java.awt.geom.Rectangle2D;

final class Order1 extends Curve {

    private double x0;

    private double y0;

    private double x1;

    private double y1;

    private double xmin;

    private double xmax;

    Order1(double x0, double y0,

                  double x1, double y1,

                  int direction)

    {

        super(direction);

        this.x0 = x0;

        this.y0 = y0;

        this.x1 = x1;

        this.y1 = y1;

        if (x0 < x1) {

            this.xmin = x0;

            this.xmax = x1;

        } else {

            this.xmin = x1;

            this.xmax = x0;

        }

    }

    public int getOrder() {

        return 1;

    }

    public double getXTop() {

        return x0;

    }

    public double getYTop() {

        return y0;

    }

    public double getXBot() {

        return x1;

    }

    public double getYBot() {

        return y1;

    }

    public double getXMin() {

        return xmin;

    }

    public double getXMax() {

        return xmax;

    }

    public double getX0() {

        return (direction == INCREASING) ? x0 : x1;

    }

    public double getY0() {

        return (direction == INCREASING) ? y0 : y1;

    }

    public double getX1() {

        return (direction == DECREASING) ? x0 : x1;

    }

    public double getY1() {

        return (direction == DECREASING) ? y0 : y1;

    }

    public double XforY(double y) {

        if (x0 == x1 || y <= y0) {

            return x0;

        }

        if (y >= y1) {

            return x1;

        }

        // assert(y0 != y1); /* No horizontal lines... */

        return (x0 + (y - y0) * (x1 - x0) / (y1 - y0));

    }

    public double TforY(double y) {

        if (y <= y0) {

            return 0;

        }

        if (y >= y1) {

            return 1;

        }

        return (y - y0) / (y1 - y0);

    }

    public double XforT(double t) {

        return x0 + t * (x1 - x0);

    }

    public double YforT(double t) {

        return y0 + t * (y1 - y0);

    }

    public double dXforT(double t, int deriv) {

        switch (deriv) {

        case 0:

            return x0 + t * (x1 - x0);

        case 1:

            return (x1 - x0);

        default:

            return 0;

        }

    }

    public double dYforT(double t, int deriv) {

        switch (deriv) {

        case 0:

            return y0 + t * (y1 - y0);

        case 1:

            return (y1 - y0);

        default:

            return 0;

        }

    }

    public double nextVertical(double t0, double t1) {

        return t1;

    }

    public boolean accumulateCrossings(Crossings c) {

        double xlo = c.getXLo();

        double ylo = c.getYLo();

        double xhi = c.getXHi();

        double yhi = c.getYHi();

        if (xmin >= xhi) {

            return false;

        }

        double xstart, ystart, xend, yend;

        if (y0 < ylo) {

            if (y1 <= ylo) {

                return false;

            }

            ystart = ylo;

            xstart = XforY(ylo);

        } else {

            if (y0 >= yhi) {

                return false;

            }

            ystart = y0;

            xstart = x0;

        }

        if (y1 > yhi) {

            yend = yhi;

            xend = XforY(yhi);

        } else {

            yend = y1;

            xend = x1;

        }

        if (xstart >= xhi && xend >= xhi) {

            return false;

        }

        if (xstart > xlo || xend > xlo) {

            return true;

        }

        c.record(ystart, yend, direction);

        return false;

    }

    public void enlarge(Rectangle2D r) {

        r.add(x0, y0);

        r.add(x1, y1);

    }

    public Curve getSubCurve(double ystart, double yend, int dir) {

        if (ystart == y0 && yend == y1) {

            return getWithDirection(dir);

        }

        if (x0 == x1) {

            return new Order1(x0, ystart, x1, yend, dir);

        }

        double num = x0 - x1;

        double denom = y0 - y1;

        double xstart = (x0 + (ystart - y0) * num / denom);

        double xend = (x0 + (yend - y0) * num / denom);

        return new Order1(xstart, ystart, xend, yend, dir);

    }

    public Curve getReversedCurve() {

        return new Order1(x0, y0, x1, y1, -direction);

    }

    public int compareTo(Curve other, double yrange[]) {

        if (!(other instanceof Order1)) {

            return super.compareTo(other, yrange);

        }

        Order1 c1 = (Order1) other;

        if (yrange[1] <= yrange[0]) {

            throw new InternalError("yrange already screwed up...");

        }

        yrange[1] = Math.min(Math.min(yrange[1], y1), c1.y1);

        if (yrange[1] <= yrange[0]) {

            throw new InternalError("backstepping from "+yrange[0]+" to "+yrange[1]);

        }

        if (xmax <= c1.xmin) {

            return (xmin == c1.xmax) ? 0 : -1;

        }

        if (xmin >= c1.xmax) {

            return 1;

        }

        /*

         * If "this" is curve A and "other" is curve B, then...

         * xA(y) = x0A + (y - y0A) (x1A - x0A) / (y1A - y0A)

         * xB(y) = x0B + (y - y0B) (x1B - x0B) / (y1B - y0B)

         * xA(y) == xB(y)

         * x0A + (y - y0A) (x1A - x0A) / (y1A - y0A)

         *    == x0B + (y - y0B) (x1B - x0B) / (y1B - y0B)

         * 0 == x0A (y1A - y0A) (y1B - y0B) + (y - y0A) (x1A - x0A) (y1B - y0B)

         *    - x0B (y1A - y0A) (y1B - y0B) - (y - y0B) (x1B - x0B) (y1A - y0A)

         * 0 == (x0A - x0B) (y1A - y0A) (y1B - y0B)

         *    + (y - y0A) (x1A - x0A) (y1B - y0B)

         *    - (y - y0B) (x1B - x0B) (y1A - y0A)

         * If (dxA == x1A - x0A), etc...

         * 0 == (x0A - x0B) * dyA * dyB

         *    + (y - y0A) * dxA * dyB

         *    - (y - y0B) * dxB * dyA

         * 0 == (x0A - x0B) * dyA * dyB

         *    + y * dxA * dyB - y0A * dxA * dyB

         *    - y * dxB * dyA + y0B * dxB * dyA

         * 0 == (x0A - x0B) * dyA * dyB

         *    + y * dxA * dyB - y * dxB * dyA

         *    - y0A * dxA * dyB + y0B * dxB * dyA

         * 0 == (x0A - x0B) * dyA * dyB

         *    + y * (dxA * dyB - dxB * dyA)

         *    - y0A * dxA * dyB + y0B * dxB * dyA

         * y == ((x0A - x0B) * dyA * dyB

         *       - y0A * dxA * dyB + y0B * dxB * dyA)

         *    / (-(dxA * dyB - dxB * dyA))

         * y == ((x0A - x0B) * dyA * dyB

         *       - y0A * dxA * dyB + y0B * dxB * dyA)

         *    / (dxB * dyA - dxA * dyB)

         */

        double dxa = x1 - x0;

        double dya = y1 - y0;

        double dxb = c1.x1 - c1.x0;

        double dyb = c1.y1 - c1.y0;

        double denom = dxb * dya - dxa * dyb;

        double y;

        if (denom != 0) {

            double num = ((x0 - c1.x0) * dya * dyb

                          - y0 * dxa * dyb

                          + c1.y0 * dxb * dya);

            y = num / denom;

            if (y <= yrange[0]) {