Application: gvSIG desktop

#Build Number for ANT. Do not edit!

#Tue Aug 08 12:48:13 CEST 2006

build.number=859

llig-me.txt

**************************

gvSIG v 0.4

Requisits de la instal?laci?:

    - M?quina Virtual Java 1.4.2 o superior instal?lada (http://java.sun.com).

Requisits de l'aplicaci?:

    - Sistema

        ? M?nims: Pentium III / 256 MB RAM.

        ? Recomanables: Pentium IV / 512 MB RAM.

        ? Sistemes operatius: plataformes Windows i Linux.

        Provat en Win98/XP, Linux Suse 8.2/9.0/9.2 i Linux Debian(Lliurex).

    - Programari instal?lat (disponible en http://www.gvsig.gva.es o en http://java.sun.com)

        ? M?quina Virtual Java 1.4.2 (06 o superior).

        ? JAI (Java Advanced Imaging).

        ? JAI Image I/O.

Nota: les libreries JAI i JAI Image I/O han d'estar instal?lades sobre la M?quina Virtual Java que gvSIG utilitze en l'execuci?. Si s'instal?la una nova JVM en el sistema i s'usa per a executar gvSIG ser? indispensable instal?lar les llibreries sobre esta.

M?s informaci? ? suport:

    Web oficial del projecte:

        http://www.gvsig.gva.es

    Llistes de distribuci?:

        http://runas.cap.gva.es/mailman/listinfo/gvsig_usuarios (suport per a usuaris).

        http://runas.cap.gva.es/mailman/listinfo/gvsig_desarrolladores (suport per a desenvolupadors).

        http://runas.cap.gva.es/mailman/listinfo/gvsig_english (suport per a usuaris o desenvolupadors de parla no-hispana).

gvSIG v 0.2.0 beta.

Prerequisitos:

  - Java instalado (JRE 1.4.2 o superior) (http://java.sun.com)

  - JAI + JAI image I/O (http://java.sun.com)

  - librer?as din?micas para los ECW: vienen con cualquier

    producto de ERMAPPER y son gratuitas (Actualmente solo hay disponibles para

    MS windows)(http://www.ermapper.com)

Instalaci?n:

	Descomprimir el archivo zip completo en el directorio deseado

Ejecuci?n

	En windows: gvSIG.bat

	En linux:  gvSIG.sh

M?s informaci?n:

	gvsig@gva.es

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;

import java.util.*;

/**

 * A List that ignores duplicates. Note: performance is not optimized - a simple linear

 * search is performed.

 */

public class UniqueList implements List {

    private List list;

    /**

     * Creates a UniqueList.

     */

    public UniqueList() {

        this(new ArrayList());

    }

    /**

     * Creates a UniqueList backed by the given List.

     * @param list a List that will be this UniqueList's underlying List

     */

    public UniqueList(List list) {

        this.list = list;

    }

    public int size() {

        return list.size();

    }

    public boolean isEmpty() {

        return list.isEmpty();

    }

    public boolean contains(Object o) {

        return list.contains(o);

    }

    public Iterator iterator() {

        return list.iterator();

    }

    public Object[] toArray() {

        return list.toArray();

    }

    public Object[] toArray(Object[] a) {

        return list.toArray(a);

    }

    public boolean add(Object o) {

        if (list.contains(o)) {

            return false;

        }

        return list.add(o);

    }

    public boolean remove(Object o) {

        return list.remove(o);

    }

    public boolean containsAll(Collection c) {

        return list.containsAll(c);

    }

    public boolean addAll(Collection c) {

    	return addAll(size(), c);

    }

    public boolean addAll(int index, Collection c) {

		ArrayList itemsToAdd = new ArrayList(c);

		itemsToAdd.removeAll(this);

		return list.addAll(index, itemsToAdd);    	

    }

    public boolean removeAll(Collection c) {

        return list.removeAll(c);

    }

    public boolean retainAll(Collection c) {

        return list.retainAll(c);

    }

    public void clear() {

        list.clear();

    }

    public boolean equals(Object o) {

        return list.equals(o);

    }

    public Object get(int index) {

        return list.get(index);

    }

    public Object set(int index, Object element) {

        return list.set(index, element);

    }

    public void add(int index, Object element) {

        if (list.contains(element)) {

            return;

        }

        list.add(index, element);

    }

    public Object remove(int index) {

        return list.remove(index);

    }

    public int indexOf(Object o) {

        return list.indexOf(o);

    }

    public int lastIndexOf(Object o) {

        return list.lastIndexOf(o);

    }

    public ListIterator listIterator() {

        return list.listIterator();

    }

    public ListIterator listIterator(int index) {

        return list.listIterator(index);

    }

    public List subList(int fromIndex, int toIndex) {

        return list.subList(fromIndex, toIndex);

    }

}

#Forget 2-digit year specifications ("yyyy"). Otherwise yyMMdd will 

#consider "20040203" to be invalid (a valid "200402" with a couple of

#extra characters). (FlexibleDateParser skips patterns that don't

#parse *all* the characters). Anyway, FlexibleDateParser also tries

#the (deprecated) Date constructor, and that should parse the most

#common 2-digit-year formats. [Jon Aquino]

#Lines beginning with "#" and blank lines are ignored. [Jon Aquino]

#Earlier patterns have precedence over later patterns. [Jon Aquino]

#####################################################################

#Popular SimpleDateFormat strings, culled from the top 1000 hits on 

#Google and Google Groups on 21 May 2003 [Jon Aquino]

#Multiple Google hits [Jon Aquino]

yyyy-MM-dd

yyyyMMdd

dd.MM.yyyy

#Although dd/MM/yyyy had a few more hits in Google, give priority to

#MM/dd/yyyy because JUMP will be used mainly in North America. 

#Anyway, yyyy-MM-dd should be preferred to both. [Jon Aquino]

MM/dd/yyyy

dd/MM/yyyy

yyyy-MM-dd HH:mm:ss

yyyyMMddHHmmss

MMMM d, yyyy

yyyy.MM.dd hh:mm:ss

yyyy/MM/dd

HH:mm

MMddyyyy

HH:mm:ss

ddMMyyyy

dd-MMM-yyyy

dd-MM-yyyy

dd MMM yyyy

yyyyMMddHHmmssSSS

yyyyMMddHHmm

yyyy/MM/dd HH:mm:ss

yyyy/MM/dd HH:mm

yyyy.MM.dd

hh:mm a

h:mmaa

MMM d, yyyy

HHmm

#Single Google hits [Jon Aquino]

yyyyMMddhhmmss

yyyy_MM_dd.hh_mm_ss_a.zzz

yyyy_MM_dd

yyyyMMddhhmmssSSS

yyyyMMddHHss

yyyyMMddHHmmsszzzzHHmm

yyyy/MM/dd/HH/mm/ss/SS

yyyy.MMM.dd HH:mm:ss.SSS z

yyyy.MM.dd HH:mm:ss

yyyy-Md HH:mm:ss

yyyy-MM-dd-G-hh-mm-ss-z

yyyy-MM-dd'T'HH:mm:ss

yyyy-MM-dd hh:mm:ss

yyyy-MM-dd HH:mm:sszzzzzzzzz

yyyy-MM-dd HH:mm:sszzz

yyyy-MM-dd HH:mm:ss.SSSzzzzzzzzz

yyyy-MM-dd HH:mm:ss.SSSSSS z

yyyy-MM-dd HH:mm:ss.SSS z

yyyy-MM-dd HH:mm:ss z

yyyy-MM-dd HH:mm

yyyy-MM-d HH:mm:ss

yyyy-DDD/HH:mm:ss.SSS

yyyy'-'MM'-'dd

yyyy DDD:HH:mm:ss

yyyyMMdd HH:mm

yyyy/MM/dd hh:mm:ss

MMM dd, yyyy

mm:ss:SS

MM-dd-yyyy

hh:mm:ss:SSS

hh:mm:ss dd-MM-yyyy

hh:mm

h:mm a, zzzz

h:mm

h:m

ddMMyyyyHHmmssSSS

ddhhmmz MMM yyyy

ddMMMyyyy

dd/MM/yyyy HH:mm:ss zzz

dd/MMM/yyyy

dd/MM/yyyy:HHmm

dd/MM/yyyy -- HH:mm:ss

dd/MM/yyyy - HH:mm:ss

dd/MM/yyyy hh:mm

dd.MMM.yyyy

dd.MM.yyyy hh:mm:ss a zzz

dd.MM.yyyy HH:mm:ss

dd.MM.yyyy '-' HH:mm:ss z

dd-MMM-yyyy HH:mm

dd'/'MM'/'yyyy

dd MMMMM, yyyy

dd MMMM yyyy

dd MM yyyy

d_M_yyyy_hh_mm_ss

d MMM yyyy

MMddyyyy.HHmm

MMddyyyyHHmm

MMM-dd-yyyy HH:mm:ss.S

MMM d hh:mm:ss

MM/dd/yyyy hh:mm:ss z

MM/dd/yyyy hh:mm:ss.SSS a

MM/dd/yyyy HH:mm

MM.dd.yyyy

MM'/'dd'/'yyyy

M/dd/yyyy

M/d/yyyy

M-dd-yyyy

HH:mm:ss '-' dd.MM.yyyy

H:mm

:mm:ss

#####################################################################

# Excel patterns [Jon Aquino]

M/dd

dd-MMM

MMM-yyyy

MM/dd/yyyy hh:mm a

M-yyyy

hh:mm:ss a

#####################################################################

# Other patterns [Jon Aquino]

MMM d

MMM yyyy

/*

 * 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.io.ByteArrayOutputStream;

import java.io.PrintStream;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

import java.util.StringTokenizer;

import com.vividsolutions.jts.util.Assert;

/**

 * Useful String-related utilities.

 */

public class StringUtil {

    public static String s(int n) {

        return (n != 1) ? "s" : "";

    }

    public static String ies(int n) {

        return (n != 1) ? "ies" : "y";

    }

    public static String classNameWithoutQualifiers(String className) {

        return className.substring(

            Math.max(className.lastIndexOf("."), className.lastIndexOf("$")) + 1);

    }

    public static String classNameWithoutPackageQualifiers(String className) {

        return className.substring(className.lastIndexOf(".") + 1);

    }

    public static String repeat(char c, int n) {

        StringBuffer b = new StringBuffer();

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

            b.append(c);

        }

        return b.toString();

    }

    /**

     *  Line-wraps s by inserting a newline instead of the first space after the nth

     *  column. Word-wraps.

     */

    public static String split(String s, int n) {

        StringBuffer b = new StringBuffer();

        boolean wrapPending = false;

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

            if (((i % n) == 0) && (i > 0)) {

                wrapPending = true;

            }

            char c = s.charAt(i);

            if (wrapPending && (c == ' ')) {

                b.append("\n");

                wrapPending = false;

            } else {

                b.append(c);

            }

        }

        return b.toString();

    }

    public static String capitalize(String word) {

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

            return word;

        }

        return (word.charAt(0) + "").toUpperCase() + word.substring(1);

    }

    public static String uncapitalize(String word) {

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

            return word;

        }

        return (word.charAt(0) + "").toLowerCase() + word.substring(1);        

    }

    /**

     * Converts the comma-delimited string into a List of trimmed strings.

     * @param s a String with comma-delimited values

     * @return a List of the Strings that were delimited by commas

     */

    public static List fromCommaDelimitedString(String s) {

        ArrayList result = new ArrayList();

        StringTokenizer tokenizer = new StringTokenizer(s, ",");

        while (tokenizer.hasMoreTokens()) {

            result.add(tokenizer.nextToken().toString().trim());

        }

        return result;

    }

    /**

     * Returns a List of empty Strings.

     * @param size the size of the List to create

     * @return a List of blank Strings

     */

    public static List blankStringList(int size) {

        ArrayList list = new ArrayList();

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

            list.add("");

        }

        return list;

    }

    public static String toFriendlyName(String className) {

        return toFriendlyName(className, null);

    }

    public static String friendlyName(Class c) {

        return toFriendlyName(c.getName());

    }

    public static String toFriendlyName(String className, String substringToRemove) {

        String name = className;

        //Remove substring sooner rather than later because, for example,

        //?"PlugIn" will become "Plug In". [Jon Aquino]

        if (substringToRemove != null) {

            name = StringUtil.replaceAll(name, substringToRemove, "");

        }

        name = StringUtil.classNameWithoutQualifiers(name);

        name = insertSpaces(name);

        return name;

    }

    public static String insertSpaces(String s) {

        if (s.length() < 2) {

            return s;

        }

        String result = "";

        for (int i = 0; i < (s.length() - 2); i++) { //-2

            result += s.charAt(i);

            if ((Character.isLowerCase(s.charAt(i))

                && Character.isUpperCase(s.charAt(i + 1)))

                || (Character.isUpperCase(s.charAt(i + 1))

                    && Character.isLowerCase(s.charAt(i + 2)))) {

                result += " ";

            }

        }

        result += s.charAt(s.length() - 2);

        result += s.charAt(s.length() - 1);

        return result.trim();

    }

    /**

     * Returns the elements of c separated by commas. If c is empty, an empty

     * String will be returned.

     * @param c a Collection of objects to convert to Strings and delimit by commas

     * @return a String containing c's elements, delimited by commas

     */

    public static String toCommaDelimitedString(Collection c) {

        return toDelimitedString(c, ", ");

    }

    /**

     *  Returns original with all occurrences of oldSubstring replaced by

     *  newSubstring

     */

    public static String replaceAll(

        String original,

        String oldSubstring,

        String newSubstring) {

        return replace(original, oldSubstring, newSubstring, true);

    }

    /**

     *  Returns original with occurrences of oldSubstring replaced by

     *  newSubstring. Set all to true to replace all occurrences, or false to

     *  replace the first occurrence only.

     */

    public static String replace(

        String original,

        String oldSubstring,

        String newSubstring,

        boolean all) {

        StringBuffer b = new StringBuffer(original);

        replace(b, oldSubstring, newSubstring, all);

        return b.toString();

    }

    /**

     *  Replaces all instances of the String o with the String n in the

     *  StringBuffer orig if all is true, or only the first instance if all is

     *  false. Posted by Steve Chapel <schapel@breakthr.com> on UseNet

     */

    public static void replace(StringBuffer orig, String o, String n, boolean all) {

        if ((orig == null) || (o == null) || (o.length() == 0) || (n == null)) {

            throw new IllegalArgumentException("Null or zero-length String");

        }

        int i = 0;

        while ((i + o.length()) <= orig.length()) {

            if (orig.substring(i, i + o.length()).equals(o)) {

                orig.replace(i, i + o.length(), n);

                if (!all) {

                    break;

                } else {

                    i += n.length();

                }

            } else {

                i++;

            }

        }

    }

    /**

     * Returns an throwable's stack trace

     */

    public static String stackTrace(Throwable t) {

        ByteArrayOutputStream os = new ByteArrayOutputStream();

        PrintStream ps = new PrintStream(os);

        t.printStackTrace(ps);

        return os.toString();

    }

    public static String head(String s, int lines) {

        int newlinesEncountered = 0;

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

            if (s.charAt(i) == '\n') {

                newlinesEncountered++;

                if (newlinesEncountered == lines) {

                    return s.substring(0, i);

                }

            }

        }

        return s;

    }

    public static String limitLength(String s, int maxLength) {

        Assert.isTrue(maxLength >= 3);

        if (s == null) {

            return null;

        }

        if (s.length() > maxLength) {

            return s.substring(0, maxLength - 3) + "...";

        }

        return s;

    }

    public static boolean isNumber(String token) {

        try {

            Double.parseDouble(token);

            return true;

        } catch (NumberFormatException e) {

            return false;

        }

    }  

    public static String toDelimitedString(Collection c, String delimiter) {

        if (c.isEmpty()) {

            return "";

        }

        StringBuffer result = new StringBuffer();

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

            Object o = i.next();

            result.append(delimiter + ((o == null) ? "" : o.toString()));

        }

        return result.substring(delimiter.length());

    }

    public static String toTimeString(long milliseconds) {

        long remainder = milliseconds;

        long days = remainder / 86400000;

        remainder = remainder % 86400000;

        long hours = remainder / 3600000;

        remainder = remainder % 3600000;

        long minutes = remainder / 60000;

        remainder = remainder % 60000;

        long seconds = remainder / 1000;

        String s = "";

        if (days > 0) {

            s += (days + " days ");

        }

        s

            += (Fmt.fmt(hours, 2, Fmt.ZF)

                + ":"

                + Fmt.fmt(minutes, 2, Fmt.ZF)

                + ":"

                + Fmt.fmt(seconds, 2, Fmt.ZF));

        return s;

    }

}

/*

 * 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.Assert;

import java.awt.Color;

import java.awt.Component;

import java.io.IOException;

import java.io.InputStream;

import java.text.DateFormat;

import java.text.ParseException;

import java.text.ParsePosition;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Collection;

import java.util.Comparator;

import java.util.Date;

import java.util.Iterator;

import java.util.List;

import java.util.StringTokenizer;

import java.util.TreeSet;

import javax.swing.DefaultCellEditor;

import javax.swing.JComponent;

import javax.swing.JTable;

import javax.swing.JTextField;

import javax.swing.border.LineBorder;

import javax.swing.table.TableCellEditor;

/**

 * Warning: This class can parse a wide variety of formats. This flexibility is fine for parsing user

 * input because the user immediately sees whether the parser is correct and can fix it if

 * necessary. However, GML files are advised to stick with a safe format like yyyy-MM-dd.

 * yy/MM/dd is not as safe because while 99/03/04 will be parsed as yyyy/MM/dd, 

 * 02/03/04 will be parsed as MM/dd/yyyy (because MM/dd/yyyy appears earlier than yyyy/MM/dd

 * in FlexibleDateParser.txt).

 */

public class FlexibleDateParser {

    private static Collection lenientFormatters = null;

    private static Collection unlenientFormatters = null;

    //CellEditor used to be a static field CELL_EDITOR, but I was getting

    //problems calling it from ESETextField (it simply didn't appear).

    //The problems vanished when I turned it into a static class. I didn't

    //investigate further. [Jon Aquino]

    public static final class CellEditor extends DefaultCellEditor {

        public CellEditor() {

            super(new JTextField());

        }

        private Object value;

        private FlexibleDateParser parser = new FlexibleDateParser();

        public boolean stopCellEditing() {

            try {

                value = parser.parse((String) super.getCellEditorValue(), true);

            } catch (Exception e) {

                ((JComponent) getComponent()).setBorder(new LineBorder(Color.red));

                return false;

            }

            return super.stopCellEditing();

        }

        public Component getTableCellEditorComponent(

            JTable table,

            Object value,

            boolean isSelected,

            int row,

            int column) {

            this.value = null;

            ((JComponent) getComponent()).setBorder(new LineBorder(Color.black));

            return super.getTableCellEditorComponent(

                table,

                format((Date) value),

                isSelected,

                row,

                column);

        }

        private String format(Date date) {

            return (date == null) ? "" : formatter.format(date);

        }

        public Object getCellEditorValue() {

            return value;

        }

        //Same formatter as used by JTable.DateRenderer. [Jon Aquino]

        private DateFormat formatter = DateFormat.getDateInstance();

    };

    private boolean verbose = false;

    private Collection sortByComplexity(Collection patterns) {

        //Least complex to most complex. [Jon Aquino]

        TreeSet sortedPatterns = new TreeSet(new Comparator() {

            public int compare(Object o1, Object o2) {

                int result = complexity(o1.toString()) - complexity(o2.toString());

                if (result == 0) {

                    //The two patterns have the same level of complexity.

                    //Sort by order of appearance (e.g. to resolve

                    //MM/dd/yyyy vs dd/MM/yyyy [Jon Aquino]

                    result = ((Pattern) o1).index - ((Pattern) o2).index;

                }

                return result;

            }

            private TreeSet uniqueCharacters = new TreeSet();

            private int complexity(String pattern) {

                uniqueCharacters.clear();

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

                    if (("" + pattern.charAt(i)).trim().length() > 0) {

                        uniqueCharacters.add("" + pattern.charAt(i));

                    }

                }

                return uniqueCharacters.size();

            }

        });

        sortedPatterns.addAll(patterns);

        return sortedPatterns;

    }

    private Collection lenientFormatters() {

        if (lenientFormatters == null) {

            load();

        }

        return lenientFormatters;

    }

    private Collection unlenientFormatters() {

        if (unlenientFormatters == null) {

            load();

        }

        return unlenientFormatters;

    }

    /**

     * @return null if s is empty

     */

    public Date parse(String s, boolean lenient) throws ParseException {

        if (s.trim().length() == 0) {

            return null;

        }

        //The deprecated Date#parse method is actually pretty flexible. [Jon Aquino]

        try {

            if (verbose) {

                System.out.println(s + " -- Date constructor");

            }

            return new Date(s);

        } catch (Exception e) {

            //Eat it. [Jon Aquino]

        }

        try {

            return parse(s, unlenientFormatters());

        } catch (ParseException e) {

            if (lenient) {

                return parse(s, lenientFormatters());

            }

            throw e;

        }

    }

    private Date parse(String s, Collection formatters) throws ParseException {

        ParseException firstParseException = null;

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

            SimpleDateFormat formatter = (SimpleDateFormat) i.next();

            if (verbose) {

                System.out.println(

                    s

                        + " -- "

                        + formatter.toPattern()

                        + (formatter.isLenient() ? "lenient" : ""));

            }

            try {

                return parse(s, formatter);

            } catch (ParseException e) {

                if (firstParseException == null) {

                    firstParseException = e;

                }

            }

        }

        throw firstParseException;

    }

    private Date parse(String s, SimpleDateFormat formatter) throws ParseException {

        ParsePosition pos = new ParsePosition(0);

        Date date = formatter.parse(s, pos);

        if (pos.getIndex() == 0) {

            throw new ParseException(

                "Unparseable date: \"" + s + "\"",

                pos.getErrorIndex());

        }

        //SimpleDateFormat ignores trailing characters in the pattern string that it

        //doesn't need. Don't allow it to ignore any characters. [Jon Aquino]

        if (pos.getIndex() != s.length()) {

            throw new ParseException(

                "Unparseable date: \"" + s + "\"",

                pos.getErrorIndex());

        }

        Calendar calendar = Calendar.getInstance();

        calendar.setTime(date);

        if ((calendar.get(Calendar.YEAR) == 1970) && (s.indexOf("70") == -1)) {

            calendar.set(Calendar.YEAR, Calendar.getInstance().get(Calendar.YEAR));

        }

        return calendar.getTime();

    }

    private static class Pattern {

        private String pattern;

        private int index;

        public Pattern(String pattern, int index) {

            this.pattern = pattern;

            this.index = index;

        }

        public String toString() {

            return pattern;

        }

    }

    private void load() {

        if (lenientFormatters == null) {

            InputStream inputStream =

                getClass().getResourceAsStream("FlexibleDateParser.txt");

            try {

                try {

                    Collection patterns = new ArrayList();

                    int index = 0;

                    for (Iterator i = FileUtil.getContents(inputStream).iterator();

                        i.hasNext();

                        ) {

                        String line = ((String) i.next()).trim();

                        if (line.startsWith("#")) {

                            continue;

                        }

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

                            continue;

                        }

                        patterns.add(new Pattern(line, index));

                        index++;

                    }

                    unlenientFormatters = toFormatters(false, patterns);

                    lenientFormatters = toFormatters(true, patterns);

                } finally {

                    inputStream.close();

                }

            } catch (IOException e) {

                Assert.shouldNeverReachHere(e.toString());

            }

        }

    }

    private Collection toFormatters(boolean lenient, Collection patterns) {

        ArrayList formatters = new ArrayList();

        //Sort from least complex to most complex; otherwise, ddMMMyyyy 

        //instead of MMMd will match "May 15". [Jon Aquino]

        for (Iterator i = sortByComplexity(patterns).iterator(); i.hasNext();) {

            Pattern pattern = (Pattern) i.next();

            SimpleDateFormat formatter = new SimpleDateFormat(pattern.pattern);

            formatter.setLenient(lenient);

            formatters.add(formatter);

        }

        return formatters;

    }

    public static void main(String[] args) throws Exception {

        System.out.println(DateFormat.getDateInstance().parse("03-Mar-1998"));

    }

    public void setVerbose(boolean b) {

        verbose = b;

    }

}

/*

 * 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.*;

import com.vividsolutions.jts.algorithm.CGAlgorithms;

import com.vividsolutions.jts.algorithm.RobustCGAlgorithms;

import com.vividsolutions.jts.geom.*;

import com.vividsolutions.jts.util.Assert;

/**

 * Some utility functions for handling Coordinate arrays.

 */

public class CoordinateArrays {

    //<<TODO:REFACTORING>> JTS already has a class named CoordinateArrays.

    //I wonder if we should collapse this class into that one. [Jon Aquino]

    // MD - yep, at some point.

    private static final CGAlgorithms cga = new RobustCGAlgorithms();

    private final static Coordinate[] coordArrayType = new Coordinate[0];

    public static Coordinate[] toCoordinateArray(List coordList) {

        return (Coordinate[]) coordList.toArray(coordArrayType);

    }

    //<<TODO:REFACTORING>> This functionality is duplicated in

    //the protected method Geometry#reversePointOrder. Perhaps we should

    //make that method public and deprecate this method, or have this method

    //delegate to the other. [Jon Aquino]

    //MD: Geometry#reversePointOrder could delegate to this method.  Can't do it other way around.

    public static void reverse(Coordinate[] coord) {

        int last = coord.length - 1;

        int mid = last / 2;

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

            Coordinate tmp = coord[i];

            coord[i] = coord[last - i];

            coord[last - i] = tmp;

        }

    }

    /**

     * Converts an array of coordinates to a line or point, as appropriate.

     * @param coords the coordinates of a line or point

     * @param fact a factory used to create the Geometry

     * @return a line if there is more than one coordinate; a point if there is

     * just one coordinate; an empty point otherwise

     */

    public static Geometry toLineOrPoint(Coordinate[] coords,

        GeometryFactory fact) {

        if (coords.length > 1) {

            return fact.createLineString(coords);

        }

        if (coords.length == 1) {

            return fact.createPoint(coords[0]);

        }

        return fact.createPoint((Coordinate)null);

    }

    public static boolean equals(Coordinate[] coord1, Coordinate[] coord2) {

        if (coord1 == coord2) {

            return true;

        }

        if ((coord1 == null) || (coord2 == null)) {

            return false;

        }

        if (coord1.length != coord2.length) {

            return false;

        }

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

            if (!coord1[i].equals(coord2[i])) {

                return false;

            }

        }

        return true;

    }

    /**

     * Converts a collection of coordinate arrays to a collection of geometries.

     * @param coordArrays a collection of Coordinate[]

     * @param fact a factory used to create the Geometries

     * @return a collection of LineStrings and Points

     */

    public static List fromCoordinateArrays(List coordArrays,

        GeometryFactory fact) {

        List geomList = new ArrayList();

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

            Coordinate[] coords = (Coordinate[]) i.next();

            Geometry geom = toLineOrPoint(coords, fact);

            geomList.add(geom);

        }

        return geomList;

    }

    /**

     * Extract the coordinate arrays for a geometry into a List.

     * @param g the Geometry to extract from

     * @param coordArrayList the List to add the coordinate arrays to

     * @param orientPolygons whether or not the arrays in the List should be

     * oriented (clockwise for the shell, counterclockwise for the holes)

     */

    public static void addCoordinateArrays(Geometry g, boolean orientPolygons,

        List coordArrayList) {

        if (g.getDimension() <= 0) {

            return;

        } else if (g instanceof LineString) {

            LineString l = (LineString) g;

            coordArrayList.add(l.getCoordinates());

        } else if (g instanceof Polygon) {

            Polygon poly = (Polygon) g;

            Coordinate[] shell = poly.getExteriorRing().getCoordinates();

            if (orientPolygons) {

                shell = ensureOrientation(shell, CGAlgorithms.CLOCKWISE);

            }

            coordArrayList.add(shell);

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

                Coordinate[] hole = poly.getInteriorRingN(i).getCoordinates();

                if (orientPolygons) {

                    hole = ensureOrientation(hole, CGAlgorithms.COUNTERCLOCKWISE);

                }

                coordArrayList.add(hole);

            }

        } else if (g instanceof GeometryCollection) {

            GeometryCollection gc = (GeometryCollection) g;

            for (int i = 0; i < gc.getNumGeometries(); i++) {

                addCoordinateArrays(gc.getGeometryN(i), orientPolygons,

                    coordArrayList);

            }

        } else {

            Assert.shouldNeverReachHere("Geometry of type " +

                g.getClass().getName() + " not handled");

        }

    }

    /**

     * Sets the orientation of an array of coordinates.

     * @param coord the coordinates to inspect

     * @param desiredOrientation CGAlgorithms.CLOCKWISE or CGAlgorithms.COUNTERCLOCKWISE

     * @return a new array with entries in reverse order, if the orientation is

     * incorrect; otherwise, the original array

     */

    public static Coordinate[] ensureOrientation(Coordinate[] coord,

        int desiredOrientation) {

        if (coord.length == 0) {

            return coord;

        }

        int orientation = cga.isCCW(coord) ? CGAlgorithms.COUNTERCLOCKWISE

                                           : CGAlgorithms.CLOCKWISE;

        if (orientation != desiredOrientation) {

            Coordinate[] reverse = (Coordinate[]) coord.clone();

            CoordinateArrays.reverse(reverse);

            return reverse;

        }

        return coord;

    }

    /**

     * Extract the coordinate arrays for a geometry.

     * Polygons will be checked to ensure their rings are oriented correctly.

     * Note: coordinates from Points or MultiPoints will not be extracted.

     * @param g the Geometry to extract from

     * @param orientPolygons ensure that Polygons are correctly oriented

     * @return a list of Coordinate[]

     */

    public static List toCoordinateArrays(Geometry g, boolean orientPolygons) {

        List coordArrayList = new ArrayList();

        addCoordinateArrays(g, orientPolygons, coordArrayList);

        return coordArrayList;

    }

}

/*

 * 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.awt.Color;

public class ColorUtil {

  public static final Color GOLD = new Color(255, 192, 0, 150);

  public static final Color PALE_BLUE = new Color(153, 204, 255, 150);

  public static final Color PALE_RED = new Color(255, 204, 204, 150);  

}

/*

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

 *