Application: gvSIG desktop

<project name="extGeocoding" default="generate-without-source" basedir=".">

	<description>

        Install the Normalization plugin

    </description>

	<!-- set global properties for this build -->

	<property name="src" location="src" />

	<property name="src-test" location="src-test" />

	<property name="build-test" location="bin-test" />

	<property name="build" location="bin" />

	<property name="dist" location="dist" />

	<property name="plugin" value="org.gvsig.normalization" />

	<property name="extension-dir" location="../_fwAndami/gvSIG/extensiones" />

	<import file="../binaries/ant/utilities.xml" />

	<target name="init">

		<!-- Create the time stamp -->

		<tstamp />

		<echo>Compiling ${ant.project.name}...</echo>

		<buildnumber />

	</target>

	<target name="generate-without-source" description="generate the distribution without the source file" >

		<!-- Create the distribution directory -->

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

		<!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file -->

		<jar jarfile="${dist}/${plugin}.jar" basedir="${build}" />

		<copy file="config/config.xml" todir="${dist}" />

		<copy todir="${dist}">

			<fileset dir="config" includes="text*.properties" />

			<fileset dir="lib" includes="**/**" />

		</copy>

		<copy todir="${dist}/images">

			<fileset dir="images/" includes="*" />

		</copy>

		<move todir="${extension-dir}/${plugin}/">

			<fileset dir="${dist}" includes="**/**" />

		</move>

	</target>

	<target name="compile" description="compile the source">

		<!-- Compile the Java code from ${src} to ${build} -->

		<!-- <antcall target="gvSIG-import-build-number"/> -->

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

		<loadEclipseClasspath project="${basedir}" />

		<gvSIG-javac classpath="${eclipseClasspath}" />

	</target>

	<target name="create-jar" description="Creates the plugin jar">

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

		<jar jarfile="${dist}/${jarName}" basedir="${build}" />

	</target>

	<target name="copy-data-files">

		<copy file="config/config.xml" todir="${dist}" />

		<copy file="build.number" todir="${dist}" />

		<copy todir="${dist}">

			<fileset dir="config" includes="text*.properties" />

		</copy>

		<copy todir="${dist}/images">

			<fileset dir="images/" includes="*" />

		</copy>

	</target>

	<target name="move-to-installDir">

		<move todir="${installDir}">

			<fileset dir="${dist}" includes="**/**" />

		</move>

	</target>

	<target name="batch-build" description="compile the sources, create the jar file" depends="init,compile,create-jar,copy-data-files,move-to-installDir">

	</target>

	<target name="install" description="compile the sources, create the jar file" depends="init,create-jar,copy-data-files,move-to-installDir">

	</target>

</project>

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

<classpath>

	<classpathentry kind="src" path="src"/>

	<classpathentry kind="src" path="src-test"/>

	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>

	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/3"/>

	<classpathentry kind="lib" path="/_fwAndami/lib/gvsig-i18n.jar" sourcepath="/libInternationalization/src"/>

	<classpathentry kind="lib" path="/_fwAndami/lib/iver-utiles.jar" sourcepath="/libIverUtiles"/>

	<classpathentry kind="lib" path="/_fwAndami/lib/log4j-1.2.8.jar"/>

	<classpathentry kind="lib" path="/_fwAndami/gvSIG/extensiones/com.iver.cit.gvsig/lib/com.iver.cit.gvsig.jar"/>

	<classpathentry kind="lib" path="/_fwAndami/gvSIG/extensiones/com.iver.cit.gvsig/lib/driver-manager-1.1.jar"/>

	<classpathentry kind="lib" path="/_fwAndami/gvSIG/extensiones/com.iver.cit.gvsig/lib/fmap.jar"/>

	<classpathentry kind="lib" path="/_fwAndami/gvSIG/extensiones/com.iver.cit.gvsig/lib/org.cresques.cts.jar"/>

	<classpathentry kind="lib" path="/_fwAndami/andami.jar"/>

	<classpathentry kind="lib" path="/_fwAndami/lib/org.gvsig.exceptions.jar" sourcepath="/libExceptions"/>

	<classpathentry kind="lib" path="/_fwAndami/lib/org.gvsig.ui.jar" sourcepath="/libUIComponent/src"/>

	<classpathentry kind="lib" path="lib/org.gvsig.tools.storage.jar" sourcepath="/libStorage"/>

	<classpathentry combineaccessrules="false" kind="src" path="/libGeocoding"/>

	<classpathentry kind="lib" path="/_fwAndami/gvSIG/extensiones/com.iver.cit.gvsig/lib/gdbms-0.8-SNAPSHOT.jar"/>

	<classpathentry kind="output" path="bin"/>

</classpath>

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

<projectDescription>

	<name>extNormalization</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

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

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

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

	</natures>

</projectDescription>

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

<plugin-config>

	<libraries library-dir="." />

	<depends plugin-name="com.iver.cit.gvsig" />

	<depends plugin-name="com.iver.cit.gvsig.cad" />

	<depends plugin-name="org.gvsig.scripting" />

	<resourceBundle name="text" />

	<extensions>

		<extension

			class-name="org.gvsig.normalization.extensions.NormalizationExtension"

			description="Extension for the preferences of Normalization."

			active="true">

		</extension>

		<extension

			class-name="org.gvsig.normalization.extensions.NormalizationFileExtension"

			description="Extension that normalize a file with strings."

			active="true">

			<menu text="Tabla/normalizefile" tooltip="normalizefile"

				action-command="NORMALIZE_FILE" icon="images/normalizefileicon.png"

				position="9997" />

				<!-- 

			<tool-bar name="field_toolbar">

				<action-tool icon="images/normalizefileicon.png"

					action-command="NORMALIZE_FILE" tooltip="normalizefile"

					position="9997" />

			</tool-bar>

			-->

		</extension>

		<extension

			class-name="org.gvsig.normalization.extensions.NormalizationTableExtension"

			description="Extension that normalize a table field with strings."

			active="true">

			<menu text="Tabla/normalizetable" tooltip="normalizetable"

				action-command="NORMALIZE_TABLE"

				icon="images/normalizetableicon.png" position="9998" />

			<tool-bar name="field_toolbar">

				<action-tool icon="images/normalizetableicon.png"

					action-command="NORMALIZE_TABLE" tooltip="normalizetable"

					position="9998" />

			</tool-bar>

		</extension>

		<!-- 

			<extension class-name="org.gvsig.geocoding.extension.AboutGeocodingExtension"

			description="Extension to add about panel."

			active="false"

			priority="1">

			</extension>

		-->

	</extensions>

</plugin-config>

#Extension

#Normalization

#Normalization

#Normalization

#labels

normalize=Normalizaci?n

normalizefile=Normalizar fichero de texto

normalizetable=Normalizar un campo de tabla

normtitle=Normalizaci?n de

normsource=Fuente de datos

normfirstrows=No normalizar las primeras

normfirstnumberrows=filas

normfields=Nuevos campos

normfieldsettings=Configuraci?n del nuevo campo

normfieldname=Nombre nuevo campo

normdontimport=No importar

normfieldtype=Tipo de campo

normfielddecimal=Decimal

normfieldinteger=Integer

normfieldstring=String

normfielddate=Date

normdelimetersnext=Separadores con el siguiente

normcharacter=Car?cter

normfixedwidth=Ancho fijo

normfieldseparators=Separadores

normtab=Tab

normspace=Espacio

normcolon=Coma

normsemicolon=Punto y coma

normother=Otros

normjoin=Unir delimitadores consecutivos

norminfieldseparators=Identificador

normdecimal=Decimal

normthousand=Miles

normtextdelimiter=Texto

normsampleout=Muestra de salida

normoutputopt=Opciones de salida

normaltertable=En la tabla actual

normnewtable=En una nueva tabla

normjoinfield=Campo com?n

normconsole=C?nsola de informaci?n

#buttons

normload=Cargar...

normsave=Guardar...

normcancel=Salir

normrun=Ejecutar

normtest=Testear

save_norm_pattern=Guardar patr?n de normalizaci?n

load_norm_pattern=Cargar el patr?n de normalizaci?n

normerrorloadingfile= Error cargando el archivo

normerrorreadingfile= Error leyendo el archivo

load_text_file=Cargar fichero de texto

txt_file=Fichero de texto (*.txt, *.csv)

pattern_norm_file=Fichero Patr?n Normalizaci?n (*.xml)

Normalizating=     Normalizando ...

generate_news_fields=     Generando los nuevos campos

cant_alter_table=Tabla no editable

already_exists_fields=Algunos de los nuevos campos ya existen en la tabla original 

chains_normalizated=     cadenas normalizadas

new_table=Nueva tabla

nofield=Selecciona un campo de la tabla

none_field=Ning?n campo

all_fields=Todos los campos

gdbmsdbfdriver=Driver dbf

file_exists=El fichero ya existe, ?desea sobreexcribirlo?

filenotfound=Fichero no se ha encontrado

parsingpatternxml=Leyendo el patr?n de normalizaci?n

loadsuccess=cargado correctamente

savesuccess=guardado correctamente

savingpat=Guardando el patr?n de normalizaci?n

fileexists= El fichero ya existe, proceso de normalizaci?n cancelado

finishprocess=Proceso de normalizaci?n terminado

filenotsave=El fichero no se ha guardado

filenotoverwrite=El fichero no se ha sobreescrito

startprocess=Empieza la normalizaci?n...

errorformattingdate=Formateando la fecha

errorformattingnumberrow=Formateando un n?mero en la fila 

errorformattingdaterow=Formateando la fecha en la fila 

errorformattingintegerrow=Formateando un entero en la fila

errorformattingdecimalrow=Formateando un decimal en la fila

errorformattingstringrow=Formateando una cadena de texto en la fila

errornullsubstring=Subcadena nula reemplazada por blanco en la fila

errornotselectedfield=No hay un campo seleccionado en la tabla

errordoubledname=Hay campos con el mismo nombre en la tabla

errormodifyoritable=Modificando la tabla principal

erroraddfieldstable=A?adiendo nuevos campos a la tabla principal

errortabledontaltered=Tabla no modificada

normalizing=Normalizando ...

endnormalizing=Fin del proceso de normalizacion

writtingdbf=Escribiendo fichero dbf ...

noload=Cancelada la carga del patr?n

nosave=Cancelado el guardado del patr?n

pref_title_folder=Carpeta para almacenar patrones de normalizaci?n

pref_change_folder=Cambiar carpeta

pref_dialog_forder=Indicar carpeta para ubicar patrones

pref_normalization=Normalizaci?n

pref_path_folder=Ubicaci?n de la carpeta

#Extension

#Normalization

#Normalization

#labels

normalize=Normalization

normalizefile=

normalizetable=

normtitle=Normalizaci?n de

normsource=Data source

normfirstrows=Don`t normalize the first

normfirstnumberrows=rows

normfields=New fields

normfieldsettings=Field settings

normfieldname=Field name

normdontimport=Don`t import

normfieldtype=Field type

normfielddecimal=Decimal

normfieldinteger=Integer

normfieldstring=String

normfielddate=Date

normdelimetersnext=Set how field delimiters with next one

normfixedwidth=Fixed width

normcharacter=Character

normfieldseparators=Select field separators

normtab=Tab

normspace=Space

normcolon=Colon

normsemicolon=Semicolon

normother=Other

normjoin=Join consecutive delimiters

norminfieldseparators=Identificator

normdecimal=Decimal

normthousand=Thousand

normtextdelimiter=Text

normsampleout=Sample output

normoutputopt=Output options

normaltertable=Alter table

normnewtable=Create new table

normjoinfield=Select join field

normconsole=Info console

#buttons

normload=Load...

normsave=Save...

normcancel=Exit

normrun=Run

normtest=Test

normerrorloadingfile= Error loading file

normerrorreadingfile= Error reading file

load_text_file=Load text file

txt_file=Text File (*.txt, *.csv)

pattern_norm_file=Normalization Pattern File (*.xml)

save_norm_pattern=Save Normalization Pattern

load_norm_pattern=Load Normalization Pattern

Normalizating=     Normalizating ...

generate_news_fields=     Generating new fields

cant_alter_table=Can`t alter this table

already_exists_fields=Some new fields already exist in the original table

chains_normalizated=     chains normalizated  

new_table=New table

nofield=Select a table field

preference_file=Address Elements

preference_location=File location

preference_edit=You can edit the list with new address elements

nolayersinview=No layer in view

combodefaulttext=...

combonamefields=Fields Names

comboaddresselements=Address Elements

none_field=None fields

all_fields=All fields

gdbmsdbfdriver=Driver dbf

file_exists=file already exists, you wish to overwrite it?

filenotfound=File not found

parsingpatternxml=Reading the pattern

loadsuccess= loaded

savesuccess= saved

savingpat=Saving the pattern

fileexists= File exists, process canceled

finishprocess=Process finished

filenotsave=File don't save

filenotoverwrite=File don't overwrite

startprocess=Start normalization...

errorformattingdate=Formatting the date

errorformattingnumberrow=Formatting the number in the row 

errorformattingdaterow=Formatting the date in the row

errorformattingintegerrow=Formatting the integer in the row

errorformattingdecimalrow=Formatting the double in the row

errorformattingstringrow=Formatting the string in the row

errornullsubstring=Null substring replaced for white in the row

errornotselectedfield=There isn`t field selected in the main table

errordoubledname=There are fields with the name doubled in the main table

errormodifyoritable=Altering original table

erroraddfieldstable=Adding news fields main table

errortabledontaltered=Table didn't alter

normalizing=Normalizing ...

endnormalizing= Normalization process ended

writtingdbf=Writing dbf file ...

noload=Loading pattern canceled

nosave=Saving pattern canceled

pref_title_folder=Normalization patterns folder path

pref_change_folder=Change folder

pref_dialog_forder=Select folder to store patterns

pref_normalization=Normalization

pref_path_folder=Folder path

#Build Number for ANT. Do not edit!

#Thu Jun 19 14:52:24 CEST 2008

build.number=5

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

 * 2008 Prodevelop S.L. main development

 */

package org.gvsig.normalization.gui;

import org.apache.log4j.Logger;

import org.gvsig.normalization.operations.Normalization;

import com.iver.andami.PluginServices;

import com.iver.utiles.swing.threads.AbstractMonitorableTask;

/**

 * Normalization task

 * 

 * @author <a href="mailto:jsanz@prodevelop.es"> Jorge Gaspar Sanz Salinas</a>

 * @author <a href="mailto:vsanjaime@prodevelop.es"> Vicente Sanjaime Calvet</a>

 */

public class NormalizationTask extends AbstractMonitorableTask {

	@SuppressWarnings("unused")

	private static final Logger log = Logger.getLogger(NormalizationTask.class);

	private Normalization normalization;

	private long finalStep;

	/**

	 * @param na

	 * @param normPanelModel

	 *            panel model

	 * 

	 */

	public NormalizationTask(Normalization na, INormPanelModel normPanelModel) {

		this.normalization = na;

		// configure task

		setInitialStep(0);

		setStatusMessage(PluginServices.getText(this, "Normalizating"));

		setDeterminatedProcess(true);

		finalStep = normalization.getEstimatedRowCount();

		setFinalStep((int) finalStep);

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.iver.utiles.swing.threads.ITask#run()

	 */

	public void run() throws Exception {

		String log = PluginServices.getText(this, "chains_normalizated");

		int firstRow = normalization.getPattern().getNofirstrows() == 0 ? 1

				: normalization.getPattern().getNofirstrows() + 1;

		for (int i = firstRow; i < finalStep + 1; i++) {

			if (!isCanceled()) {

				setCurrentStep(i);

				setNote(i + " " + log);

				normalization.fillRow(i - 1);

			} else {

				return;

			}

		}

		normalization.postProcess();

		normalization.removeAllListeners();

	}

}

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

 * 2008 Prodevelop S.L. main development

 */

package org.gvsig.normalization.gui;

import java.awt.Component;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.text.DecimalFormatSymbols;

import java.util.ArrayList;

import java.util.List;

import java.util.Locale;

import javax.swing.DefaultListModel;

import javax.swing.JFileChooser;

import javax.swing.JOptionPane;

import javax.swing.event.ChangeListener;

import org.apache.log4j.Logger;

import org.gvsig.normalization.operations.JoinedTableNormalization;

import org.gvsig.normalization.operations.NormAlgorithm;

import org.gvsig.normalization.operations.Normalization;

import org.gvsig.normalization.operations.NormalizationNewTable;

import org.gvsig.normalization.operations.StringListNormalization;

import org.gvsig.normalization.operations.TableNormalization;

import org.gvsig.normalization.patterns.Element;

import org.gvsig.normalization.patterns.Fieldseparator;

import org.gvsig.normalization.patterns.Fieldtype;

import org.gvsig.normalization.patterns.Infieldseparators;

import org.gvsig.normalization.patterns.Patternnormalization;

import org.gvsig.normalization.patterns.Stringvalue;

import org.gvsig.tools.storage.IStorage;

import org.gvsig.tools.storage.StorageXML;

import sun.text.Normalizer;

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

import com.hardcode.gdbms.engine.data.DataSource;

import com.hardcode.gdbms.engine.data.DataSourceFactory;

import com.iver.andami.PluginServices;

import com.iver.cit.gvsig.ProjectExtension;

import com.iver.cit.gvsig.fmap.drivers.FieldDescription;

import com.iver.cit.gvsig.fmap.edition.EditableAdapter;

import com.iver.cit.gvsig.fmap.edition.IEditableSource;

import com.iver.cit.gvsig.fmap.edition.IRowEdited;

import com.iver.cit.gvsig.fmap.layers.LayerFactory;

import com.iver.cit.gvsig.fmap.layers.SelectableDataSource;

import com.iver.cit.gvsig.project.Project;

import com.iver.cit.gvsig.project.ProjectFactory;

import com.iver.cit.gvsig.project.documents.ProjectDocumentFactory;

import com.iver.cit.gvsig.project.documents.table.ProjectTable;

import com.iver.cit.gvsig.project.documents.table.ProjectTableFactory;

import com.iver.cit.gvsig.project.documents.table.gui.Table;

import com.iver.utiles.GenericFileFilter;

import com.iver.utiles.XMLEntity;

import com.iver.utiles.extensionPoints.ExtensionPoints;

import com.iver.utiles.extensionPoints.ExtensionPointsSingleton;

/**

 * Model of the Normalization panel

 * 

 * @author <a href="mailto:jsanz@prodevelop.es"> Jorge Gaspar Sanz Salinas</a>

 * @author <a href="mailto:vsanjaime@prodevelop.es"> Vicente Sanjaime Calvet</a>

 */

public class NormPanelModel implements INormPanelModel {

	/* ATTRIBUTES */

	private static final Logger log = PluginServices.getLogger();

	private static final String ERROR = "ERROR: ";

	private static final String INFO = "INFO: ";

	private static StringBuffer infob = new StringBuffer();

	private String fieldToNormalize;

	private String[] samples;

	private Patternnormalization pattern;

	private Table tab;

	private boolean inNewTable;

	private int selectedFieldInList = 0;

	private int contador = 1;

	private String[] relateNames;

	private ArrayList<String> fileChains;

	private boolean isFile;

	private String nameFile;

	/* SINGLETON DEFINITION */

	private volatile static INormPanelModel uniqueInstance;

	/**

	 * Get the instance of panel model

	 * 

	 * @return panel model

	 */

	public static INormPanelModel getInstance() {

		if (uniqueInstance == null) {

			synchronized (NormPanelModel.class) {

				if (uniqueInstance == null) {

					uniqueInstance = new NormPanelModel();

				}

			}

		}

		return uniqueInstance;

	}

	/* BUILDERS */

	private NormPanelModel() {

		initPattern();

	}

	// Constructors prior to the singleton pattern adoption

	// private NormPanelModel(Table tab2) {

	// this();

	// isFile = false;

	// /* Table */

	// this.tab = tab2;

	// }

	//

	// private NormPanelModel(ArrayList<String> arr, String _nameFile) {

	// this();

	// isFile = true;

	// /* all strings from file */

	// fileChains = arr;

	// /* file name */

	// nameFile = _nameFile;

	// /* Samples of strings */

	// getSamplesFromFile();

	// }

	/* METHODS */

	/**

	 * This method fills the GUI sample table with the samples

	 * 

	 * @return Object[][]

	 */

	@SuppressWarnings("unchecked")

	public Object[][] normalizeSamples() {

		int numFields = pattern.getElements().size();

		Object[][] results = new Object[NormalizationPanel.SAMPLES][numFields];

		NormAlgorithm na = new NormAlgorithm(this.pattern);

		List<String> chains;

		for (int i = 0; i < NormalizationPanel.SAMPLES; i++) {

			chains = na.splitChain(samples[i]);

			numFields = chains.size();

			for (int j = 0; j < numFields; j++) {

				results[i][j] = chains.get(j);

			}

		}

		return results;

	}

	/**

	 * This method updates the model of the names FieldList

	 * 

	 * @return list model

	 */

	public DefaultListModel updateListModel() {

		DefaultListModel dlmodel = new DefaultListModel();

		Element[] adr = this.pattern.getArrayElements();

		String name = "";

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

			name = adr[i].getFieldname();

			dlmodel.add(i, name);

		}

		return dlmodel;

	}

	/**

	 * Run the process of normalization

	 * 

	 * @return process ok

	 */

	public boolean runModel(ChangeListener listener) {

		Normalization normAction = null;

		// REQUEST FILE TO OUPUT THE DBF

		File thefile = null;

		if (this.isFile || (!this.isFile && this.inNewTable)) {

			thefile = getDBFFile();

			if (thefile == null) {

				addInfo(INFO + PluginServices.getText(null, "endnormalizing")

						+ " \n");

				return false;

			}

			if (thefile.exists()) {

				addInfo(ERROR + PluginServices.getText(null, "fileexists")

						+ " \n");

				addInfo(INFO + PluginServices.getText(null, "endnormalizing")

						+ " \n");

				return false;

			}

		}

		// FILE NORMALIZATION

		if (this.isFile) {

			normAction = new StringListNormalization(pattern, fileChains,

					thefile);

		} else {

			IEditableSource source = tab.getModel().getModelo();

			int index = tab.getSelectedFieldIndices().nextSetBit(0);

			if (!this.inNewTable) {

				// ONE TALBE

				log.debug("New fields in the original table");

				normAction = new TableNormalization(source, index, pattern);

			} else {

				// JOINED TABLE

				normAction = new JoinedTableNormalization(source, index,

						pattern, relateNames, thefile);

			}

		}

		normAction.registerListener(listener);

		boolean pre = normAction.preProcess();

		if (pre) {

			PluginServices.cancelableBackgroundExecution(new NormalizationTask(

					normAction, this));

		} else {

			log.error("Error preprocessing tables");

			return false;

		}

		if (normAction instanceof NormalizationNewTable) {

			NormalizationNewTable normTable = (NormalizationNewTable) normAction;

			this.loadTable(normTable);

		}

		return true;

	}

	/**

	 * This method up the selected element one position in the list of Elements

	 * 

	 * @param pos

	 */

	public void fieldUp(int pos) {

		int nu = pattern.getElements().size();

		if (pos > 0 && nu > 1) {

			int newpos = pos - 1;

			Element[] ad = pattern.getArrayElements();

			Element ele21 = ad[pos];

			Element ele12 = ad[newpos];

			ad[newpos] = ele21;

			ad[pos] = ele12;

			List<Element> elems = new ArrayList<Element>();

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

				elems.add(ad[i]);

			}

			pattern.setElements(elems);

		}

	}

	/**

	 * This method down the selected element one position in the list of

	 * Elements

	 * 

	 * @param pos

	 */

	public void fieldDown(int pos) {

		int nu = pattern.getElements().size();

		if (pos != (nu - 1) && nu > 1) {

			int newpos = pos + 1;

			Element[] ad = pattern.getArrayElements();

			Element ele21 = ad[pos];

			Element ele12 = ad[newpos];

			ad[newpos] = ele21;

			ad[pos] = ele12;

			List<Element> elems = new ArrayList<Element>();

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

				elems.add(ad[i]);

			}

			pattern.setElements(elems);

		}

	}

	/**

	 * This method adds a new element to the pattern

	 */

	@SuppressWarnings("unchecked")

	public void addField() {

		contador++;

		int tam = pattern.getElements().size();

		Element elem = new Element();

		Fieldseparator fsep = new Fieldseparator();

		fsep.setSemicolonsep(true);

		fsep.setJoinsep(false);

		fsep.setColonsep(false);

		fsep.setSpacesep(false);

		fsep.setTabsep(false);

		String nam = "";

		boolean isOkName = true;

		do {

			isOkName = true;

			nam = "NewField" + contador;

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

				String napat = ((Element) pattern.getElements().get(i))

						.getFieldname();

				if (napat.compareToIgnoreCase(nam) == 0) {

					isOkName = false;

					break;

				}

			}

			if (!isOkName) {

				contador++;

			}

		} while (!isOkName);

		// validate the new field name

		elem.setFieldname(validateFieldName(nam));

		elem.setFieldseparator(fsep);

		elem.setInfieldseparators(getDefaultInfieldseparators());

		elem.setFieldtype(getDefaultNewFieldType());

		elem.setFieldwidth(0);

		elem.setImportfield(true);

		pattern.getElements().add(tam, elem);

	}

	/**

	 * This method erases a selected element to the list

	 * 

	 * @param pos

	 *            position

	 */

	public void deleteField(int pos) {

		int conta = pattern.getElements().size();

		if (conta > 1) {

			pattern.getElements().remove(pos);

		}

	}

	/**

	 * This method saves a Normalization pattern to XML file *

	 */

	public void savePatternXML() {

		JFileChooser jfc = new JFileChooser();

		jfc.setDialogTitle(PluginServices.getText(this, "save_norm_pattern"));

		String[] extensions = { "xml" };

		jfc.setCurrentDirectory(new File(getFolderPattern()));

		jfc.addChoosableFileFilter(new GenericFileFilter(extensions,

				PluginServices.getText(this, "pattern_norm_file")));

		int returnval = jfc.showSaveDialog((Component) PluginServices

				.getMainFrame());

		if (returnval == JFileChooser.APPROVE_OPTION) {

			File thefile = jfc.getSelectedFile();

			// Check if the file has extension

			if (!(thefile.getPath().toLowerCase().endsWith(".xml"))) {

				thefile = new File(thefile.getPath() + ".xml");

			}

			if (thefile.exists()) {

				int n = JOptionPane.showConfirmDialog(null, PluginServices

						.getText(null, "file_exists"), PluginServices.getText(

						null, "save_norm_pattern"), JOptionPane.YES_NO_OPTION);

				if (n == JOptionPane.YES_OPTION) {

					writeSaveFile(thefile);

					log.debug("overwrite file");

				} else if (n == JOptionPane.NO_OPTION) {

					log.debug("Don't save the file");

					addInfo(INFO

							+ PluginServices.getText(null, "filenotoverwrite")

							+ " \n");

				} else {

					log.debug("Don't save the file");

					addInfo(INFO + PluginServices.getText(null, "filenotsave")

							+ " \n");

				}

			} else {

				writeSaveFile(thefile);

			}

		} else {

			addInfo(INFO + PluginServices.getText(null, "nosave") + " \n");

		}

	}

	/**

	 * This method loads a Normalization pattern from a XML file and return the

	 * pattern and the String info

	 * 

	 * @return pattern

	 */

	public Patternnormalization loadPatternXML() {

		Patternnormalization pat = new Patternnormalization();

		File thefile = null;

		StringBuffer infob = new StringBuffer();

		// Show the FileChooser to select a pattern

		JFileChooser jfc = new JFileChooser();

		jfc.setCurrentDirectory(new File(getFolderPattern()));

		jfc.setDialogTitle(PluginServices.getText(this, "load_norm_pattern"));

		String[] extensions = { "xml" };

		jfc.addChoosableFileFilter(new GenericFileFilter(extensions,

				PluginServices.getText(this, "pattern_norm_file")));

		int returnval = jfc.showOpenDialog((Component) PluginServices

				.getMainFrame());

		if (returnval == JFileChooser.APPROVE_OPTION) {

			thefile = jfc.getSelectedFile();

			log.debug("file to open: " + thefile);

		} else {

			addInfo(INFO + PluginServices.getText(null, "noload") + " \n");

			return null;

		}

		FileReader red;

		IStorage storage;

		try {

			red = new FileReader(thefile);

			storage = new StorageXML();

			storage.load(red);

			pat.setstate(storage);

			addInfo(INFO + thefile.getName() + " "

					+ PluginServices.getText(null, "loadsuccess") + " \n");

		} catch (FileNotFoundException e) {

			pat = null;

			addInfo(ERROR + PluginServices.getText(null, "filenotfound")

					+ " \n");

			log.error("File not found", e);

		} catch (Exception e) {

			pat = null;

			addInfo(ERROR + PluginServices.getText(null, "parsingpatternxml")

					+ " \n");

			log.error("ERROR Parsing xml", e);

		}

		addInfo(infob.toString());

		return pat;

	}

	/* GETTERS Y SETTERS */

	/**

	 * Return the name of the field to normalize

	 * 

	 * @return field name

	 */

	public String getFieldToNormalize() {

		return fieldToNormalize;

	}

	/**

	 * Set the name of the field to normalize

	 * 

	 * @param fieldToNormalize

	 */

	public void setFieldToNormalize(String fieldToNormalize) {

		this.fieldToNormalize = fieldToNormalize;

		/* Get samples to put in the GUI table */

		getSamplesFromTable();

	}

	/**

	 * This method returns the names of the fields from the pattern

	 * 

	 * @return new fields names

	 */

	public String[] getNewFieldNames() {

		int numFields = pattern.getElements().size();

		String[] res = new String[numFields];

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

			res[i] = ((Element) pattern.getElements().get(i)).getFieldname();

		}

		return res;

	}

	/**

	 * Get the first or random samples from data source (FILE)

	 */

	public void getSamplesFromFile(int numNoRows) {

		int num = NormalizationPanel.SAMPLES;

		String[] res = new String[num];

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

			try {

				res[i] = (String) fileChains.get(i + numNoRows);

			} catch (Exception e) {

				res[i] = "";

			}

		}

		this.samples = res;

	}

	/**

	 * Return the samples Table

	 * 

	 * @return samples from table

	 */

	public String[] getSamplesTable() {

		return samples;

	}

	/**

	 * Return the samples File

	 * 

	 * @return samples from file

	 */

	public String[] getSamplesFile() {

		return samples;

	}

	/**

	 * This method sets the original table to the model

	 * 

	 * @param _table

	 */

	public void setTable(Table _table) {

		tab = _table;

	}

	/**

	 * This method says if the process will be in a new table (true) or in the

	 * original table (false)

	 * 

	 * @return

	 */

	public boolean isInNewTable() {

		return inNewTable;

	}

	/**

	 * Assign value the flag

	 * 

	 * @param inNewTable

	 */

	public void setInNewTable(boolean inNewTable) {

		this.inNewTable = inNewTable;

	}

	/**

	 * This method returns a Element of one position

	 * 

	 * @param index

	 * @return

	 */

	public Element getElement(int index) {

		Element[] adrs = pattern.getArrayElements();

		return adrs[index];

	}

	/**

	 * This method gets the position of the selected element in the List of

	 * names

	 * 

	 * @return position in the list

	 */

	public int getSelectedFieldInList() {

		return selectedFieldInList;

	}

	/**

	 * This method set the position of the selected element in the List

	 * 

	 * @param selectedFieldInList

	 */

	public void setSelectedFieldInList(int selectedFieldInList) {

		this.selectedFieldInList = selectedFieldInList;

	}

	/**

	 * This method returns the fields names of the original table

	 * 

	 * @return list model

	 */

	public DefaultListModel getAllOriginalFields() {

		FieldDescription[] fields = tab.getModel().getModelo()

				.getFieldsDescription();

		int num = fields.length;

		String names = "";

		DefaultListModel dlm = new DefaultListModel();

		dlm.add(0, PluginServices.getText(this, "none_field"));

		dlm.add(1, PluginServices.getText(this, "all_fields"));

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

			names = fields[i].getFieldName();

			dlm.addElement(names);

		}

		return dlm;

	}

	/**

	 * This method generates and returns field separators

	 * 

	 * @return default separators between fields

	 */

	public Fieldseparator getDefaultFieldseparators() {

		Fieldseparator filsep = new Fieldseparator();

		filsep.setSemicolonsep(true);

		filsep.setJoinsep(false);

		filsep.setColonsep(false);

		filsep.setSpacesep(false);

		filsep.setTabsep(false);

		return filsep;

	}

	/**

	 * Set the names of the relate Fields

	 * 

	 * @param list

	 *            of the names

	 */

	public void setNameRelateFields(String[] names) {

		relateNames = names;

	}

	/**

	 * This method returns the fields names of the original table

	 * 

	 * @return fields names of the main table

	 */

	public String[] getFieldNamesMainTable() {

		FieldDescription[] fds = tab.getModel().getModelo()

				.getFieldsDescription();

		String[] na = new String[fds.length];

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

			na[i] = fds[i].getFieldName();

		}

		return na;

	}

	/**

	 * This method sets the pattern

	 * 

	 * @pat pattern

	 */

	public void setPattern(Patternnormalization pat) {

		pattern = pat;

	}

	/**

	 * This method returns the debug info

	 * 

	 * @return info about the process

	 */

	public String getInfo() {

		return infob.toString();

	}

	/**

	 * This method adds info about the process

	 * 

	 * @param chain

	 *            message

	 */

	public void addInfo(String chain) {

		infob.append(chain);

	}

	/**

	 * This method returns the File name to normalize

	 * 

	 * @return file name

	 */

	public String getFileName() {

		return nameFile;

	}

	/**

	 * set the number of first rows that not normalize

	 * 

	 * @param first

	 *            select the first row

	 */

	public void setFirstRows(int first) {

		pattern.setNofirstrows(first);

	}

	/**

	 * Set the table

	 * 

	 * @param tab

	 *            the tab to set

	 */

	public void setTab(Table tab) {

		this.tab = tab;

	}

	/**

	 * Set the file strings

	 * 

	 * @param fileChains

	 *            the fileChains to set

	 */

	public void setFileChains(ArrayList<String> fileChains) {

		this.fileChains = fileChains;

		this.isFile = true;

		getSamplesFromFile(getFirstRows());

	}

	/**

	 * Get the file strings

	 * 

	 * @return the file strings

	 */

	public ArrayList<String> getFileChains() {

		return fileChains;

	}

	/**

	 * Get the file name

	 * 

	 * @return the nameFile

	 */

	public String getNameFile() {

		return nameFile;

	}

	/**

	 * Get the table

	 * 

	 * @return the tab

	 */

	public Table getTab() {

		return tab;

	}

	/**

	 * Set the file name

	 * 

	 * @param nameFile

	 *            the nameFile to set

	 */

	public void setNameFile(String nameFile) {

		this.nameFile = nameFile;

	}

	/**

	 * get Normalize the first row

	 * 

	 * @return normalize first row

	 */

	public int getFirstRows() {

		return pattern.getNofirstrows();

	}

	/**

	 * Set the file type

	 * 

	 * @param file

	 */

	public void isFile(boolean file) {

		this.isFile = file;

	}

	/**

	 * This method cleans the information about the process

	 */

	public void clearConsole() {

		int con = infob.length() > 0 ? infob.length() - 1 : 0;

		if (con > 0) {

			infob.delete(0, con);

		}

	}

	/**

	 * This method creates the default Normalization pattern

	 */

	public void initPattern() {

		Patternnormalization pat = new Patternnormalization();

		pat.setPatternname("defaultPattern");

		pat.setPatternurl("\\");

		pat.setNofirstrows(0);

		/* Create the first Address Element */

		Element elem = new Element();

		elem.setFieldname("NewField");

		elem.setFieldseparator(getDefaultFieldseparators());

		elem.setInfieldseparators(getDefaultInfieldseparators());

		elem.setFieldtype(getDefaultNewFieldType());

		elem.setFieldwidth(0);

		elem.setImportfield(true);

		List<Element> elems = new ArrayList<Element>();

		elems.add(elem);

		pat.setElements(elems);

		this.pattern = pat;

	}

	/* METHODS PRIVATES */

	/**

	 * This method loads the new table

	 * 

	 * @param normTable

	 */

	private void loadTable(NormalizationNewTable normTable) {

		String name = normTable.getOuputFile().getName();

		LayerFactory.getDataSourceFactory().addDataSource(

				normTable.getDriver(), name);

		EditableAdapter editAdapterSecond = null;

		DataSource dtSecond;

		try {

			dtSecond = LayerFactory.getDataSourceFactory()

					.createRandomDataSource(name,

							DataSourceFactory.AUTOMATIC_OPENING);

			editAdapterSecond = new EditableAdapter();