Application: gvSIG desktop

#

#Tue Oct 26 12:06:08 CEST 2010

state=devel

name=appgvSIG

official=true

code=org.gvsig.app

operating-system=all

architecture=all

java-version=j1_5

gvSIG-version=2.0.0

version=2.0-SNAPSHOT

type=plugin

build=2020

description=This is the plugin that contains the \n\tgvSIG application main extensions

<project basedir="../.." default="default" name="connectionData">

	<property name="basedir" location=".."/>

	<property name="passw" value="dokdeploy"/>

	<property name="server" value="192.168.0.1"/>

	<property name="port" value="10022"/>

	<property name="user" value="dokdeploy"/>	

	<property name="remoteDir1" value="/docdev/v1_0/apireference"/>

	<property name="remoteDir2" value="/plone/docdev/es/v1_0/apireference"/>

	<property name="ftp-passive" value="yes"/>

	<property name="verbose" value="no"/>

	<target name="default">

		<ant antfile="appgvSIG/scripts/buildApi.xml" target="deployAPIReference" inheritAll="true"/>

	</target>

</project>

<project basedir=".." name="build" default="buildAPIReference">

	<!--

	Note: the replacement in html links uses lots of memory, this script should

	be launched using the -Xmx512M parameter for the JVM.

	-->

	<property name="tmpSourceDir" value="/tmp/tmp-sources"/>

	<property name="apiReferenceDir" value="/tmp/docs/dist/html/APIReference"/>

	<property name="passw" value="my_password"/>

	<property name="server" value="my_server"/>

	<property name="port" value="6666"/>

	<property name="user" value="my_user"/>

	<property name="remoteDir1" value="/remoteDir1"/>

	<property name="remoteDir2" value="/remoteDir2"/>

	<property name="encoding" value="ISO-8859-1"/>

	<property name="ftp-passive" value="yes"/>

	<property name="verbose" value="yes"/>

<!--=======================================================================-->		

	<!-- Deploy del API -->

	<target name="deployAPIReference" depends="buildAPIReference">

		<!-- zope no acepta directorios llamados 'values' -->

		<antcall target="renameFiles">

			<param name="targetDir" value="${apiReferenceDir}" />

			<param name="oldValue" value="/values"/>

			<param name="newValue" value="/values_" />

		</antcall>

		<antcall target="replaceInLinks">

			<param name="targetDir" value="${apiReferenceDir}" />

			<param name="oldValue" value="/values"/>

			<param name="newValue" value="/values_" />

		</antcall>

		<!-- Deploy del API en el directorio no Plone-->

		<antcall target="deleteRemoteFiles">

			<param name="remoteDir" value="${remoteDir1}"/>

			<param name="excludeFiles" value=""/>

		</antcall>

		<antcall target="deleteRemoteDirs">

			<param name="remoteDir" value="${remoteDir1}"/>

			<param name="excludeDirs" value=""/>

		</antcall>

		<echo>apiReferenceDir ${apiReferenceDir}

			remoteDir1: ${remoteDir1}"

		</echo>

		<antcall target="copyFilesToRemote">

			<param name="sourceDir" value="${apiReferenceDir}"/>

			<param name="remoteDir" value="${remoteDir1}"/>

		</antcall>

		<!--

		No queremos crear el .zip con la API

		<antcall target="makeZipFile" 

			description="Crea un fichero .zip con la documentacion del api">

			<param name="dstDir" value="${basedir}/docs/dist/zip/apiref.zip"/>

			<param name="srcDir" value="${apiReferenceDir}"/>

		</antcall>

		<antcall target="copyFilesToRemote" 

			description="Copia el fichero apiref.zip al directorio remoto">

			<param name="sourceDir" value="${basedir}/docs/dist/zip"/>

			<param name="remoteDir" value="${remoteDir}/portal2"/>

		</antcall> -->

		<!-- Deploy del API en el directorio Plone-->

		<!-- Plone no acepta directorios llamados 'search' -->		

		<antcall target="renameFiles">

			<param name="targetDir" value="${apiReferenceDir}" />

			<param name="oldValue" value="/search"/>

			<param name="newValue" value="/search_" />

		</antcall>

		<antcall target="replaceInLinks">

			<param name="targetDir" value="${apiReferenceDir}" />

			<param name="oldValue" value="/search"/>

			<param name="newValue" value="/search_" />

		</antcall>

		<antcall target="renameFiles">

			<param name="targetDir" value="${apiReferenceDir}" />

			<param name="oldValue" value="/layout"/>

			<param name="newValue" value="/layout_" />

		</antcall>

		<antcall target="replaceInLinks">

			<param name="targetDir" value="${apiReferenceDir}" />

			<param name="oldValue" value="/layout"/>

			<param name="newValue" value="/layout_" />

		</antcall>

		<antcall target="renameFiles">

			<param name="targetDir" value="${apiReferenceDir}" />

			<param name="oldValue" value="/actions"/>

			<param name="newValue" value="/actions_" />

		</antcall>

		<antcall target="replaceInLinks">

			<param name="targetDir" value="${apiReferenceDir}" />

			<param name="oldValue" value="/actions"/>

			<param name="newValue" value="/actions_" />

		</antcall>

		<antcall target="renameFiles">

			<param name="targetDir" value="${apiReferenceDir}" />

			<param name="oldValue" value="/view"/>

			<param name="newValue" value="/view_" />

		</antcall>

		<antcall target="replaceInLinks">

			<param name="targetDir" value="${apiReferenceDir}" />

			<param name="oldValue" value="/view"/>

			<param name="newValue" value="/view_" />

		</antcall>

		<antcall target="renameFiles">

			<param name="targetDir" value="${apiReferenceDir}" />

			<param name="oldValue" value="/properties"/>

			<param name="newValue" value="/properties_" />

		</antcall>

		<antcall target="replaceInLinks">

			<param name="targetDir" value="${apiReferenceDir}" />

			<param name="oldValue" value="/properties"/>

			<param name="newValue" value="/properties_" />

		</antcall>

 		<antcall target="deleteRemoteFiles">

			<param name="remoteDir" value="${remoteDir2}"/>

			<param name="excludeFiles" value="${remoteDir2}/indice.html"/>

		</antcall>

		<antcall target="deleteRemoteDirs">

			<param name="remoteDir" value="${remoteDir2}"/>

			<param name="excludeDirs" value=""/>

		</antcall>

		<echo>apiReferenceDir ${apiReferenceDir}

			remoteDir1: ${remoteDir1}"

		</echo>

		<antcall target="copyFilesToRemote">

			<param name="sourceDir" value="${apiReferenceDir}"/>

			<param name="remoteDir" value="${remoteDir2}"/>

		</antcall>

	</target>	

	<target name="buildAPIReference" 

  		description="Crea el documento Javadoc del componente">

  		<delete dir="${apiReferenceDir}" />

  		<mkdir dir="${apiReferenceDir}"/>

		<echo>Basedir: ${basedir}</echo>

		<echo>Output dir: ${apiReferenceDir}</echo>

		<!--

			Copy the packaes from all the projects to a temporary directory.

			We need only one directory to properly generate the Javadocs.

		-->

		<delete dir="${tmpSourceDir}" failonerror="false"/>

		<mkdir dir="${tmpSourceDir}"/>		

		<copy todir="${tmpSourceDir}">

		    <fileset dir="${basedir}/_fwAndami/src">

		        <include name="**/*.java"/>

		    </fileset>

			<fileset dir="${basedir}/appgvSIG/src">

		        <include name="**/*.java"/>

		    </fileset>

			<fileset dir="${basedir}/extAddEventTheme/src">

		        <include name="**/*.java"/>

		    </fileset>

			<fileset dir="${basedir}/extCAD/src">

		        <include name="**/*.java"/>

		    </fileset>

			<fileset dir="${basedir}/extCatalogYNomenclator/src">

		        <include name="**/*.java"/>

		    </fileset>

			<fileset dir="${basedir}/extDataLocator/src">

		        <include name="**/*.java"/>

		    </fileset>

			<fileset dir="${basedir}/extDwg/src">

		        <include name="**/*.java"/>

		    </fileset>

			<fileset dir="${basedir}/extGeoProcessing/src">

		        <include name="**/*.java"/>

		    </fileset>

			<fileset dir="${basedir}/extJDBC/src">

		        <include name="**/*.java"/>

		    </fileset>

			<fileset dir="${basedir}/extRasterTools/src">

		        <include name="**/*.java"/>

		    </fileset>

			<fileset dir="${basedir}/extWCS/src">

		        <include name="**/*.java"/>

		    </fileset>

			<fileset dir="${basedir}/extWFS2/src">

		        <include name="**/*.java"/>

		    </fileset>

			<fileset dir="${basedir}/extWMS/src">

		        <include name="**/*.java"/>

		    </fileset>

			<fileset dir="${basedir}/libCorePlugin/src">

		        <include name="**/*.java"/>

		    </fileset>

		<!--	<fileset dir="${basedir}/libCq CMS for java/src">

		        <include name="**/*.java"/>

		    </fileset>			 -->

			<fileset dir="${basedir}/libDriverManager/src">

		        <include name="**/*.java"/>

		    </fileset>

			<fileset dir="${basedir}/libDwg/src">

		        <include name="**/*.java"/>

		    </fileset>

			<fileset dir="${basedir}/libFMap/src">

		        <include name="**/*.java"/>

		    </fileset>			

			<fileset dir="${basedir}/libInternationalization/src">

		        <include name="**/*.java"/>

		    </fileset>

			<fileset dir="${basedir}/libIverUtiles/src">

		        <include name="**/*.java"/>

		    </fileset>

			<fileset dir="${basedir}/libRemoteServices/src">

		        <include name="**/*.java"/>

		    </fileset>

			<fileset dir="${basedir}/libGDBMS/src/main/java/">

		        <include name="**/*.java"/>

		    </fileset>

		</copy>

  		<javadoc

			author="true"

			version="true"

			destdir="${apiReferenceDir}"

  			maxmemory="512m"

		  	source="1.4"

		  	doctitle="API DOCUMENTATION"

			bottom="API Documentation" 

			windowtitle="API Documentation"

  			verbose="${verbose}"

  			encoding="${encoding}">

  			<sourcepath>

  				<pathelement path="${tmpSourceDir}"/>

  			</sourcepath>

  			<packageset dir="/${tmpSourceDir}">

  				<include name="**/**"/>

  			</packageset>

	  	</javadoc>

  	</target>

<!-- ============================= Scripts ================================= -->

	<target name="makeRemoteDirs" 

		description="Crea un directorio por ftp">

		<ftp 

			action="mkdir" 

			server="${server}" 

			password="${passw}" 

			userid="${user}" 

			remotedir="${remoteDir}"

			port="${port}"

			passive="${ftp-passive}"

		/>

	</target>	

	<target name="deleteRemoteFiles" 

		description="Borra los archivos de los directorios remotos">

		<ftp

			action="del"

			server="${server}" 

			password="${passw}" 

			userid="${user}" 

			remotedir="${remoteDir}"

			port="${port}"

			passive="${ftp-passive}"

			verbose="${verbose}">

			<fileset dir="${remoteDir}">

				<include name="**"/>

				<exclude name="${excludeFiles}"/>

			</fileset>

		</ftp>

	</target>	

	<target name="deleteRemoteDirs" 

		description="Borra los directorios remotos">

		<ftp

			action="rmdir"

			server="${server}" 

			password="${passw}" 

			userid="${user}" 

			remotedir="${remoteDir}"

			port="${port}"

			passive="${ftp-passive}"

			verbose="${verbose}">

			<fileset>

				<include name="**"/>

				<exclude name="${excludeDirs}"/>

			</fileset>

		</ftp>

	</target>

	<target name="copyFilesToRemote"

		description="Copia archivos por ftp">

		<echo>Copying files to ftp://${server}/${remoteDir}</echo>

		<ftp server="${server}" 

			password="${passw}" 

			userid="${user}" 

			remotedir="${remoteDir}"

			port="${port}"

			passive="${ftp-passive}"

			verbose="${verbose}"

			binary="true">

			<fileset dir="${sourceDir}">

			    <include name="**/*"/>

			</fileset>

		</ftp>

	</target>

	<target name="moveDir"

		description="Mueve un directorio a otro">		

		<move todir="${dstDir}">

			<fileset dir="${srcDir}"/>

		</move>		

	</target>

	<target name="copyDir"

		description="Copia un árbol de directorios en otro directorio">		

		<copy todir="${dstDir}">

			<fileset dir="${srcDir}"/>

		</copy>		

	</target>

	<target name="makeZipFile"

		description="Crea un archivo zip">

		<zip destfile="${dstDir}"

			basedir="${srcDir}"

			includes="**/*.html">

		</zip>

	</target>

	<target name="replaceInLinks"

		description="For each html file in ${targetDir}, replaces ${oldValue} by ${newValue} in each href link">

		<replaceregexp flags="g">

			<regexp pattern='(A HREF="[^"]*)(${oldValue})([^"]*")'/>

			<substitution expression='\1${newValue}\3'/>

			<fileset dir="${apiReferenceDir}">

				<include name="**/*.html"/>

				<include name="**/*.HTML"/>

				<include name="**/*.htm"/>

				<include name="**/*.HTM"/>

			</fileset>

		</replaceregexp>

	</target>

	<!-- this target does not work perfectly:

	     - it will fail if two nested directories have to be replaced

	     - it will fail to replaces directory in the root directory

	     but anyway, we don't have these situations, so it will make the trick

	-->

	<target name="renameFiles"

		description="Rename directories from ${oldValue} to ${newValue} ">

		<move todir="${targetDir}" verbose="yes">

			<fileset 

				dir="${targetDir}"

				includes="**/*"/>

			<regexpmapper from="(.*)(${oldValue})(.*)" to="\1${newValue}\3" handledirsep="true"/>

		</move>

	</target>	

</project>

<project name="VoidTarget"  basedir=".">

	<description>

        	Void build file, to use it when a project is not present

   	</description>

	<property name="projectName" value="projectName" />

	<target name="batch-build">

		<echo>Warning: Project ${projectName} was skipped</echo>

	</target>

	<target name="clean">

		<echo>Warning: Project ${projectName} was skipped</echo>

	</target>

	<target name="import-build-number">

	</target>	

</project>

log4j.rootLogger=info, stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

# Pattern to output the caller's file name and line number.

log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n

log4j.appender.R=org.apache.log4j.RollingFileAppender

log4j.appender.R.File=application.log

log4j.appender.R.MaxFileSize=100KB

# Keep one backup file

log4j.appender.R.MaxBackupIndex=1

log4j.appender.R.layout=org.apache.log4j.PatternLayout

log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n

/*

 * The Unified Mapping Platform (JUMP) is an extensible, interactive GUI 

 * for visualizing and manipulating spatial features with geometry and attributes.

 *

 * Copyright (C) 2003 Vivid Solutions

 * 

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

 *

 * Vivid Solutions

 * Suite #1A

 * 2328 Government Street

 * Victoria BC  V8T 5G5

 * Canada

 *

 * (250)385-6040

 * www.vividsolutions.com

 */

package com.vividsolutions.jump.util;

// Fmt - some simple single-arg sprintf-like routines

//

// Copyright (C) 1996 by Jef Poskanzer <jef@acme.com>.  All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions

// are met:

// 1. Redistributions of source code must retain the above copyright

//    notice, this list of conditions and the following disclaimer.

// 2. Redistributions in binary form must reproduce the above copyright

//    notice, this list of conditions and the following disclaimer in the

//    documentation and/or other materials provided with the distribution.

//

// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND

// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

// ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

// SUCH DAMAGE.

//

// Visit the ACME Labs Java page for up-to-date versions of this and other

// fine Java utilities: http://www.acme.com/java/

/// Some simple single-arg sprintf-like routines.

// <P>

// It is apparently impossible to declare a Java method that accepts

// variable numbers of any type of argument.  You can declare it to take

// Objects, but numeric variables and constants are not in fact Objects.

// <P>

// However, using the built-in string concatenation, it's almost as

// convenient to make a series of single-argument formatting routines.

// <P>

// Fmt can format the following types:

// <BLOCKQUOTE><CODE>

// byte short int long float double char String Object

// </CODE></BLOCKQUOTE>

// For each type there is a set of overloaded methods, each returning

// a formatted String.  There's the plain formatting version:

// <BLOCKQUOTE><PRE>

// Fmt.fmt( x )

// </PRE></BLOCKQUOTE>

// There's a version specifying a minimum field width:

// <BLOCKQUOTE><PRE>

// Fmt.fmt( x, minWidth )

// </PRE></BLOCKQUOTE>

// And there's a version that takes flags:

// <BLOCKQUOTE><PRE>

// Fmt.fmt( x, minWidth, flags )

// </PRE></BLOCKQUOTE>

// Currently available flags are:

// <BLOCKQUOTE><PRE>

// Fmt.ZF - zero-fill

// Fmt.LJ - left justify

// Fmt.HX - hexadecimal

// Fmt.OC - octal

// </PRE></BLOCKQUOTE>

// The HX and OC flags imply unsigned output.

// <P>

// For doubles and floats, there's a significant-figures parameter before

// the flags:

// <BLOCKQUOTE><PRE>

// Fmt.fmt( d )

// Fmt.fmt( d, minWidth )

// Fmt.fmt( d, minWidth, sigFigs )

// Fmt.fmt( d, minWidth, sigFigs, flags )

// </PRE></BLOCKQUOTE>

// <P>

// <A HREF="/resources/classes/Acme/Fmt.java">Fetch the software.</A><BR>

// <A HREF="/resources/classes/Acme.tar.gz">Fetch the entire Acme package.</A>

// <HR>

// Similar classes:

// <UL>

// <LI> Andrew Scherpbier's <A HREF="http://www.sdsu.edu/doc/java-SDSU/sdsu.FormatString.html">FormatString</A>

// Tries to allow variable numbers of arguments by

// supplying overloaded routines with different combinations of parameters,

// but doesn't actually supply that many.  The floating point conversion

// is described as "very incomplete".

// <LI> Core Java's <A HREF="http://www.apl.jhu.edu/~hall/java/CoreJava-Format.html">Format</A>.

// The design seems a little weird.  They want you to create an instance,

// passing the format string to the constructor, and then call an instance

// method with your data to do the actual formatting.  The extra steps are

// pointless; better to just use static methods.

// </UL>

public class Fmt {

    // Flags.

    /// Zero-fill.

    public static final int ZF = 1;

    /// Left justify.

    public static final int LJ = 2;

    /// Hexadecimal.

    public static final int HX = 4;

    /// Octal.

    public static final int OC = 8;

    // Was a number - internal use.

    private static final int WN = 16;

    // byte

    public static String fmt(byte b) {

        return fmt(b, 0, 0);

    }

    public static String fmt(byte b, int minWidth) {

        return fmt(b, minWidth, 0);

    }

    public static String fmt(byte b, int minWidth, int flags) {

        boolean hexadecimal = ((flags & HX) != 0);

        boolean octal = ((flags & OC) != 0);

        if (hexadecimal) {

            return fmt(Integer.toString(b & 0xff, 16), minWidth, flags | WN);

        } else if (octal) {

            return fmt(Integer.toString(b & 0xff, 8), minWidth, flags | WN);

        } else {

            return fmt(Integer.toString(b & 0xff), minWidth, flags | WN);

        }

    }

    // short

    public static String fmt(short s) {

        return fmt(s, 0, 0);

    }

    public static String fmt(short s, int minWidth) {

        return fmt(s, minWidth, 0);

    }

    public static String fmt(short s, int minWidth, int flags) {

        boolean hexadecimal = ((flags & HX) != 0);

        boolean octal = ((flags & OC) != 0);

        if (hexadecimal) {

            return fmt(Integer.toString(s & 0xffff, 16), minWidth, flags | WN);

        } else if (octal) {

            return fmt(Integer.toString(s & 0xffff, 8), minWidth, flags | WN);

        } else {

            return fmt(Integer.toString(s), minWidth, flags | WN);

        }

    }

    // int

    public static String fmt(int i) {

        return fmt(i, 0, 0);

    }

    public static String fmt(int i, int minWidth) {

        return fmt(i, minWidth, 0);

    }

    public static String fmt(int i, int minWidth, int flags) {

        boolean hexadecimal = ((flags & HX) != 0);

        boolean octal = ((flags & OC) != 0);

        if (hexadecimal) {

            return fmt(Long.toString(i & 0xffffffffL, 16), minWidth, flags |

                WN);

        } else if (octal) {

            return fmt(Long.toString(i & 0xffffffffL, 8), minWidth, flags | WN);

        } else {

            return fmt(Integer.toString(i), minWidth, flags | WN);

        }

    }

    // long

    public static String fmt(long l) {

        return fmt(l, 0, 0);

    }

    public static String fmt(long l, int minWidth) {

        return fmt(l, minWidth, 0);

    }

    public static String fmt(long l, int minWidth, int flags) {

        boolean hexadecimal = ((flags & HX) != 0);

        boolean octal = ((flags & OC) != 0);

        if (hexadecimal) {

            if ((l & 0xf000000000000000L) != 0) {

                return fmt(Long.toString(l >>> 60, 16) +

                    fmt(l & 0x0fffffffffffffffL, 15, HX | ZF), minWidth,

                    flags | WN);

            } else {

                return fmt(Long.toString(l, 16), minWidth, flags | WN);

            }

        } else if (octal) {

            if ((l & 0x8000000000000000L) != 0) {

                return fmt(Long.toString(l >>> 63, 8) +

                    fmt(l & 0x7fffffffffffffffL, 21, OC | ZF), minWidth,

                    flags | WN);

            } else {

                return fmt(Long.toString(l, 8), minWidth, flags | WN);

            }

        } else {

            return fmt(Long.toString(l), minWidth, flags | WN);

        }

    }

    // float

    public static String fmt(float f) {

        return fmt(f, 0, 0, 0);

    }

    public static String fmt(float f, int minWidth) {

        return fmt(f, minWidth, 0, 0);

    }

    public static String fmt(float f, int minWidth, int sigFigs) {

        return fmt(f, minWidth, sigFigs, 0);

    }

    public static String fmt(float f, int minWidth, int sigFigs, int flags) {

        if (sigFigs != 0) {

            return fmt(sigFigFix(Float.toString(f), sigFigs), minWidth,

                flags | WN);

        } else {

            return fmt(Float.toString(f), minWidth, flags | WN);

        }

    }

    // double

    public static String fmt(double d) {

        return fmt(d, 0, 0, 0);

    }

    public static String fmt(double d, int minWidth) {

        return fmt(d, minWidth, 0, 0);

    }

    public static String fmt(double d, int minWidth, int sigFigs) {

        return fmt(d, minWidth, sigFigs, 0);

    }

    public static String fmt(double d, int minWidth, int sigFigs, int flags) {

        if (sigFigs != 0) {

            return fmt(sigFigFix(doubleToString(d), sigFigs), minWidth,

                flags | WN);

        } else {

            return fmt(doubleToString(d), minWidth, flags | WN);

        }

    }

    // char

    public static String fmt(char c) {

        return fmt(c, 0, 0);

    }

    public static String fmt(char c, int minWidth) {

        return fmt(c, minWidth, 0);

    }

    public static String fmt(char c, int minWidth, int flags) {

        // return fmt( Character.toString( c ), minWidth, flags );

        // Character currently lacks a static toString method.  Workaround

        // is to make a temporary instance and use the instance toString.

        return fmt(new Character(c).toString(), minWidth, flags);

    }

    // Object

    public static String fmt(Object o) {

        return fmt(o, 0, 0);

    }

    public static String fmt(Object o, int minWidth) {

        return fmt(o, minWidth, 0);

    }

    public static String fmt(Object o, int minWidth, int flags) {

        return fmt(o.toString(), minWidth, flags);

    }

    // String

    public static String fmt(String s) {

        return fmt(s, 0, 0);

    }

    public static String fmt(String s, int minWidth) {

        return fmt(s, minWidth, 0);

    }

    public static String fmt(String s, int minWidth, int flags) {

        int len = s.length();

        boolean zeroFill = ((flags & ZF) != 0);

        boolean leftJustify = ((flags & LJ) != 0);

        boolean hexadecimal = ((flags & HX) != 0);

        boolean octal = ((flags & OC) != 0);

        boolean wasNumber = ((flags & WN) != 0);

        if ((hexadecimal || octal || zeroFill) && !wasNumber) {

            throw new InternalError("Acme.Fmt: number flag on a non-number");

        }

        if (zeroFill && leftJustify) {

            throw new InternalError("Acme.Fmt: zero-fill left-justify is silly");

        }

        if (hexadecimal && octal) {

            throw new InternalError("Acme.Fmt: can't do both hex and octal");

        }

        if (len >= minWidth) {

            return s;

        }

        int fillWidth = minWidth - len;

        StringBuffer fill = new StringBuffer(fillWidth);

        for (int i = 0; i < fillWidth; ++i)

            if (zeroFill) {

                fill.append('0');

            } else {

                fill.append(' ');

            }

        if (leftJustify) {

            return s + fill;

        } else if (zeroFill && s.startsWith("-")) {

            return "-" + fill + s.substring(1);

        } else {

            return fill + s;

        }

    }

    // Internal routines.

    private static String sigFigFix(String s, int sigFigs) {

        // First dissect the floating-point number string into sign,

        // integer part, fraction part, and exponent.

        String sign;

        String unsigned;

        if (s.startsWith("-") || s.startsWith("+")) {

            sign = s.substring(0, 1);

            unsigned = s.substring(1);

        } else {

            sign = "";

            unsigned = s;

        }

        String mantissa;

        String exponent;

        int eInd = unsigned.indexOf('e');

        if (eInd == -1) { // it may be 'e' or 'E'

            eInd = unsigned.indexOf('E');

        }

        if (eInd == -1) {

            mantissa = unsigned;

            exponent = "";

        } else {

            mantissa = unsigned.substring(0, eInd);

            exponent = unsigned.substring(eInd);

        }

        StringBuffer number;

        StringBuffer fraction;

        int dotInd = mantissa.indexOf('.');

        if (dotInd == -1) {

            number = new StringBuffer(mantissa);

            fraction = new StringBuffer("");

        } else {

            number = new StringBuffer(mantissa.substring(0, dotInd));

            fraction = new StringBuffer(mantissa.substring(dotInd + 1));

        }

        int numFigs = number.length();

        int fracFigs = fraction.length();

        if (((numFigs == 0) || number.equals("0")) && (fracFigs > 0)) {

            // Don't count leading zeros in the fraction.

            numFigs = 0;

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

                if (fraction.charAt(i) != '0') {

                    break;

                }

                --fracFigs;

            }

        }

        int mantFigs = numFigs + fracFigs;

        if (sigFigs > mantFigs) {

            // We want more figures; just append zeros to the fraction.

            for (int i = mantFigs; i < sigFigs; ++i)

                fraction.append('0');

        } else if ((sigFigs < mantFigs) && (sigFigs >= numFigs)) {

            // Want fewer figures in the fraction; chop.

            fraction.setLength(fraction.length() -

                (fracFigs - (sigFigs - numFigs)));

            // Round?

        } else if (sigFigs < numFigs) {

            // Want fewer figures in the number; turn them to zeros.

            fraction.setLength(0); // should already be zero, but make sure

            for (int i = sigFigs; i < numFigs; ++i)

                number.setCharAt(i, '0');

            // Round?

        }

        // Else sigFigs == mantFigs, which is fine.

        if (fraction.length() == 0) {

            return sign + number + exponent;

        } else {

            return sign + number + "." + fraction + exponent;

        }

    }

    /// Improved version of Double.toString(), returns more decimal places.

    // <P>

    // The JDK 1.0.2 version of Double.toString() returns only six decimal

    // places on some systems.  In JDK 1.1 full precision is returned on

    // all platforms.

    // @deprecated

    // @see java.lang.Double#toString

    public static String doubleToString(double d) {

        // Handle special numbers first, to avoid complications.

        if (Double.isNaN(d)) {

            return "NaN";

        }

        if (d == Double.NEGATIVE_INFINITY) {

            return "-Inf";

        }

        if (d == Double.POSITIVE_INFINITY) {

            return "Inf";

        }

        // Grab the sign, and then make the number positive for simplicity.

        boolean negative = false;

        if (d < 0.0D) {

            negative = true;

            d = -d;

        }

        // Get the native version of the unsigned value, as a template.

        String unsStr = Double.toString(d);

        // Dissect out the exponent.

        String mantStr;

        // Dissect out the exponent.

        String expStr;

        int exp;

        int eInd = unsStr.indexOf('e');

        if (eInd == -1) { // it may be 'e' or 'E'

            eInd = unsStr.indexOf('E');

        }

        if (eInd == -1) {

            mantStr = unsStr;

            expStr = "";

            exp = 0;

        } else {

            mantStr = unsStr.substring(0, eInd);

            expStr = unsStr.substring(eInd + 1);

            if (expStr.startsWith("+")) {

                exp = Integer.parseInt(expStr.substring(1));

            } else {

                exp = Integer.parseInt(expStr);

            }

        }

        // Dissect out the number part.

        String numStr;

        int dotInd = mantStr.indexOf('.');

        if (dotInd == -1) {

            numStr = mantStr;

        } else {

            numStr = mantStr.substring(0, dotInd);

        }

        long num;

        if (numStr.length() == 0) {

            num = 0;

        } else {

            num = Integer.parseInt(numStr);

        }

        // Build the new mantissa.

        StringBuffer newMantBuf = new StringBuffer(numStr + ".");

        double p = Math.pow(10, exp);

        double frac = d - (num * p);

        String digits = "0123456789";

        int nDigits = 16 - numStr.length(); // about 16 digits in a double

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

            p /= 10.0D;

            int dig = (int) (frac / p);

            if (dig < 0) {

                dig = 0;

            }

            if (dig > 9) {

                dig = 9;

            }

            newMantBuf.append(digits.charAt(dig));

            frac -= (dig * p);

        }

        if ((int) ((frac / p) + 0.5D) == 1) {

            // Round up.

            boolean roundMore = true;

            for (int i = newMantBuf.length() - 1; i >= 0; --i) {

                int dig = digits.indexOf(newMantBuf.charAt(i));

                if (dig == -1) {

                    continue;

                }

                ++dig;

                if (dig == 10) {

                    newMantBuf.setCharAt(i, '0');

                    continue;

                }

                newMantBuf.setCharAt(i, digits.charAt(dig));

                roundMore = false;

                break;

            }

            if (roundMore) {

                // If this happens, we need to prepend a 1.  But I haven't

                // found a test case yet, so I'm leaving it out for now.

                // But if you get this message, please let me know!

                newMantBuf.append("ROUNDMORE");

            }

        }

        // Chop any trailing zeros.

        int len = newMantBuf.length();

        while (newMantBuf.charAt(len - 1) == '0')

            newMantBuf.setLength(--len);

        // And chop a trailing dot, if any.

        if (newMantBuf.charAt(len - 1) == '.') {

            newMantBuf.setLength(--len);

        }

        // Done.

        return (negative ? "-" : "") + newMantBuf +

        ((expStr.length() != 0) ? ("e" + expStr) : "");

    }

    /******************************************************************************

        /// Test program.

        public static void main( String[] args )

            {

            System.out.println( "Starting tests." );

            show( Fmt.fmt( "Hello there." ) );

            show( Fmt.fmt( 123 ) );

            show( Fmt.fmt( 123, 10 ) );

            show( Fmt.fmt( 123, 10, Fmt.ZF ) );

            show( Fmt.fmt( 123, 10, Fmt.LJ ) );

            show( Fmt.fmt( -123 ) );

            show( Fmt.fmt( -123, 10 ) );

            show( Fmt.fmt( -123, 10, Fmt.ZF ) );

            show( Fmt.fmt( -123, 10, Fmt.LJ ) );

            show( Fmt.fmt( (byte) 0xbe, 22, Fmt.OC ) );

            show( Fmt.fmt( (short) 0xbabe, 22, Fmt.OC ) );

            show( Fmt.fmt( 0xcafebabe, 22, Fmt.OC ) );

            show( Fmt.fmt( 0xdeadbeefcafebabeL, 22, Fmt.OC ) );

            show( Fmt.fmt( 0x8000000000000000L, 22, Fmt.OC ) );

            show( Fmt.fmt( (byte) 0xbe, 16, Fmt.HX ) );

            show( Fmt.fmt( (short) 0xbabe, 16, Fmt.HX ) );

            show( Fmt.fmt( 0xcafebabe, 16, Fmt.HX ) );

            show( Fmt.fmt( 0xdeadbeefcafebabeL, 16, Fmt.HX ) );

            show( Fmt.fmt( 0x8000000000000000L, 16, Fmt.HX ) );

            show( Fmt.fmt( 'c' ) );

            show( Fmt.fmt( new java.util.Date() ) );

            show( Fmt.fmt( 123.456F ) );

            show( Fmt.fmt( 123456000000000000.0F ) );

            show( Fmt.fmt( 123.456F, 0, 8 ) );

            show( Fmt.fmt( 123.456F, 0, 7 ) );

            show( Fmt.fmt( 123.456F, 0, 6 ) );

            show( Fmt.fmt( 123.456F, 0, 5 ) );

            show( Fmt.fmt( 123.456F, 0, 4 ) );

            show( Fmt.fmt( 123.456F, 0, 3 ) );

            show( Fmt.fmt( 123.456F, 0, 2 ) );

            show( Fmt.fmt( 123.456F, 0, 1 ) );

            show( Fmt.fmt( 123456000000000000.0F, 0, 4 ) );

            show( Fmt.fmt( -123.456F, 0, 4 ) );

            show( Fmt.fmt( -123456000000000000.0F, 0, 4 ) );

            show( Fmt.fmt( 123.0F ) );

            show( Fmt.fmt( 123.0D ) );

            show( Fmt.fmt( 1.234567890123456789F ) );

            show( Fmt.fmt( 1.234567890123456789D ) );

            show( Fmt.fmt( 1234567890123456789F ) );

            show( Fmt.fmt( 1234567890123456789D ) );

            show( Fmt.fmt( 0.000000000000000000001234567890123456789F ) );

            show( Fmt.fmt( 0.000000000000000000001234567890123456789D ) );

            show( Fmt.fmt( 12300.0F ) );

            show( Fmt.fmt( 12300.0D ) );

            show( Fmt.fmt( 123000.0F ) );

            show( Fmt.fmt( 123000.0D ) );

            show( Fmt.fmt( 1230000.0F ) );

            show( Fmt.fmt( 1230000.0D ) );

            show( Fmt.fmt( 12300000.0F ) );

            show( Fmt.fmt( 12300000.0D ) );

            show( Fmt.fmt( Float.NaN ) );

            show( Fmt.fmt( Float.POSITIVE_INFINITY ) );

            show( Fmt.fmt( Float.NEGATIVE_INFINITY ) );

            show( Fmt.fmt( Double.NaN ) );

            show( Fmt.fmt( Double.POSITIVE_INFINITY ) );

            show( Fmt.fmt( Double.NEGATIVE_INFINITY ) );

            show( Fmt.fmt( 1.0F / 8.0F ) );

            show( Fmt.fmt( 1.0D / 8.0D ) );

            System.out.println( "Done with tests." );

            }

        private static void show( String str )

            {

            System.out.println( "#" + str + "#" );

            }

    ******************************************************************************/

}

/*

 * The Unified Mapping Platform (JUMP) is an extensible, interactive GUI 

 * for visualizing and manipulating spatial features with geometry and attributes.

 *

 * Copyright (C) 2003 Vivid Solutions

 * 

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

 *

 * Vivid Solutions

 * Suite #1A

 * 2328 Government Street

 * Victoria BC  V8T 5G5

 * Canada

 *

 * (250)385-6040

 * www.vividsolutions.com

 */

package com.vividsolutions.jump.util;

import com.vividsolutions.jts.util.Stopwatch;

public class DebugTimer {

    private static final int TIME_LEN = 10;

    private static DebugTimer timer = new DebugTimer();

    private Stopwatch sw = null;

    private String blankStr;

    public DebugTimer() {

        sw = new Stopwatch();

        sw.start();

        blankStr = fillString(TIME_LEN, ' ');

    }

    public static void startStatic(String msg) {

        timer.start(msg);

    }

    public static void logEventStatic(String msg) {

        timer.logEvent(msg);

    }

    public void start(String msg) {

        System.out.println("Started    " + msg);

        sw.start();

    }

    public void logEvent(String msg) {

        String elapsedStr = formatTime(sw.getTimeString());

        System.out.println("Elapsed: " + elapsedStr + "    " + msg);

        sw.start();

    }

    public String formatTime(String timeStr) {

        if (timeStr.length() < TIME_LEN) {

            String filled = blankStr + timeStr;

            int start = filled.length() - TIME_LEN;

            return filled.substring(start);

        }

        // don't pad if it's already longer

        return timeStr;

    }

    public String fillString(int len, char ch) {

        StringBuffer buf = new StringBuffer(len);

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

            buf.append(ch);

        }

        return buf.toString();

    }

}

/*

 * The Unified Mapping Platform (JUMP) is an extensible, interactive GUI 

 * for visualizing and manipulating spatial features with geometry and attributes.

 *

 * Copyright (C) 2003 Vivid Solutions

 * 

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

 *

 * Vivid Solutions

 * Suite #1A

 * 2328 Government Street

 * Victoria BC  V8T 5G5

 * Canada

 *

 * (250)385-6040

 * www.vividsolutions.com

 */

package com.vividsolutions.jump.util;

/**

 * Additional math utilities.

 * @see Math

 */

public class MathUtil {

    public MathUtil() {

    }   

    public static double orderOfMagnitude(double x) {

        return base10Log(x);

    }

    public static double base10Log(double x) {

        return Math.log(x) / Math.log(10);

    }

    public static int mostSignificantDigit(double x) {

        return (int) (x / Math.pow(10, Math.floor(MathUtil.orderOfMagnitude(x))));

    }

    /**

     * Returns the average of two doubles

     * @param a one of the doubles to average

     * @param b the other double to average

     * @return the average of two doubles

     */

    public static double avg(double a, double b) {

        return (a + b) / 2d;

    }

}

/*

 * The Unified Mapping Platform (JUMP) is an extensible, interactive GUI 

 * for visualizing and manipulating spatial features with geometry and attributes.

 *

 * Copyright (C) 2003 Vivid Solutions

 * 

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

 *

 * Vivid Solutions

 * Suite #1A

 * 2328 Government Street

 * Victoria BC  V8T 5G5

 * Canada

 *

 * (250)385-6040

 * www.vividsolutions.com

 */

package com.vividsolutions.jump.util;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

import com.vividsolutions.jts.util.Assert;

/**

 *  A Map whose values are Collections.

 */

public class CollectionMap implements Map {

    private Map map;

    private Class collectionClass = ArrayList.class;

    /**

     * Creates a CollectionMap backed by the given Map class.

     * @param mapClass a Class that implements Map

     */

    public CollectionMap(Class mapClass) {

        try {

            map = (Map) mapClass.newInstance();

        } catch (InstantiationException e) {

            Assert.shouldNeverReachHere();

        } catch (IllegalAccessException e) {

            Assert.shouldNeverReachHere();

        }

    }

    public CollectionMap(Class mapClass, Class collectionClass) {

        this.collectionClass = collectionClass;

        try {

            map = (Map) mapClass.newInstance();

        } catch (InstantiationException e) {

            Assert.shouldNeverReachHere();

        } catch (IllegalAccessException e) {

            Assert.shouldNeverReachHere();

        }

    }    

    /**

     * Creates a CollectionMap.

     */

    public CollectionMap() {

        this(HashMap.class);

    }

    private Collection getItemsInternal(Object key) {

        Collection collection = (Collection) map.get(key);

        if (collection == null) {

            try {

                collection = (Collection) collectionClass.newInstance();

            } catch (InstantiationException e) {

                Assert.shouldNeverReachHere();

            } catch (IllegalAccessException e) {

                Assert.shouldNeverReachHere();

            }

            map.put(key, collection);

        }

        return collection;

    }

    /**

     * Adds the item to the Collection at the given key, creating a new Collection if

     * necessary.

     * @param key the key to the Collection to which the item should be added

     * @param item the item to add

     */

    public void addItem(Object key, Object item) {

        getItemsInternal(key).add(item);

    }

    public void removeItem(Object key, Object item) {

        getItemsInternal(key).remove(item);

    }

    public void clear() {

        map.clear();

    }

    /**

     * Adds the items to the Collection at the given key, creating a new Collection if

     * necessary.

     * @param key the key to the Collection to which the items should be added

     * @param items the items to add

     */

    public void addItems(Object key, Collection items) {

        for (Iterator i = items.iterator(); i.hasNext();) {

            addItem(key, i.next());

        }

    }

    public void addItems(CollectionMap other) {

        for (Iterator i = other.keySet().iterator(); i.hasNext(); ) {

            Object key = i.next();

            addItems(key, other.getItems(key));

        }

    }

    /**

     * Returns the values.

     * @return a view of the values, backed by this CollectionMap

     */

    public Collection values() {

        return map.values();

    }

    /**

     * Returns the keys.

     * @return a view of the keys, backed by this CollectionMap

     */

    public Set keySet() {

        return map.keySet();