Application: gvSIG desktop

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

import java.io.FileWriter;

import java.io.IOException;

import java.io.Writer;

import java.text.DecimalFormatSymbols;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import javax.swing.JFileChooser;

import javax.swing.JOptionPane;

import javax.swing.table.DefaultTableModel;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.normalization.algorithm.NormalizationAlgorithm;

import org.gvsig.normalization.algorithm.impl.DefaultNormalizationAlgorithm;

import org.gvsig.normalization.pattern.Element;

import org.gvsig.normalization.pattern.Fieldseparator;

import org.gvsig.normalization.pattern.Fieldtype;

import org.gvsig.normalization.pattern.Infieldseparators;

import org.gvsig.normalization.pattern.Patternnormalization;

import org.gvsig.normalization.pattern.Stringvalue;

import org.gvsig.normalization.pattern.impl.DefaultElement;

import org.gvsig.normalization.pattern.impl.DefaultFieldseparator;

import org.gvsig.normalization.pattern.impl.DefaultFieldtype;

import org.gvsig.normalization.pattern.impl.DefaultInfieldseparators;

import org.gvsig.normalization.pattern.impl.DefaultPatternnormalization;

import org.gvsig.normalization.pattern.impl.DefaultStringvalue;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.persistence.PersistenceException;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import sun.text.Normalizer;

import com.iver.andami.PluginServices;

import com.iver.utiles.GenericFileFilter;

import com.iver.utiles.XMLEntity;

/**

 * Controller 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 NormalizationPanelController {

	private static final Logger log = LoggerFactory

			.getLogger(NormalizationPanelController.class);

	public static final int SAMPLES = 3;

	private int selectedField;

	private Patternnormalization pattern;

	private FeatureStore store = null;

	private int contador = 1;

	private String[] samples = new String[SAMPLES];

	/* SINGLETON DEFINITION */

	private volatile static NormalizationPanelController uniqueInstance;

	/**

	 * Get the instance of panel controller

	 * 

	 * @return panel model

	 */

	public static NormalizationPanelController getInstance() {

		if (uniqueInstance == null) {

			synchronized (NormalizationPanelController.class) {

				if (uniqueInstance == null) {

					uniqueInstance = new NormalizationPanelController();

				}

			}

		}

		return uniqueInstance;

	}

	/**

	 * Private constructor

	 */

	private NormalizationPanelController() {

		this.setPattern(initializeDefaultPattern());

	}

	/**

	 * This method fills the GUI sample table with the samples

	 * 

	 * @return Object[][]

	 */

	protected Object[][] normalizeOutSamples() {

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

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

		NormalizationAlgorithm na = new DefaultNormalizationAlgorithm(

				this.pattern);

		List<String> chains = null;

		for (int i = 0; i < 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 up the selected element one position in the list of Elements

	 * 

	 * @param pos

	 */

	protected 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

	 */

	protected 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

	 */

	protected void addField() {

		contador++;

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

		Element eleme = new DefaultElement();

		Fieldseparator fsep = new DefaultFieldseparator();

		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

		String vname = validateFieldName(nam);

		eleme.setFieldname(vname);

		eleme.setFieldseparator(fsep);

		eleme.setInfieldseparators(getDefaultInfieldseparators());

		eleme.setFieldtype(getDefaultNewFieldType());

		eleme.setFieldwidth(0);

		eleme.setImportfield(true);

		List<Element> elems = pattern.getElements();

		elems.add(tam, eleme);

	}

	/**

	 * This method erases a selected element to the list

	 * 

	 * @param pos

	 *            position

	 */

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

	 */

	protected 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 .xml

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

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

			}

			try {

				// the file exists

				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);

					}

				}

				// the file not exists

				else {

					writeSaveFile(thefile);

				}

			} catch (Exception e) {

				log.error("Error saving the pattern", e);

			}

		}

	}

	/**

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

	 * pattern and the String info

	 * 

	 * @return pattern

	 */

	protected Patternnormalization loadPatternXML() {

		PersistenceManager manager = ToolsLocator.getPersistenceManager();

		Patternnormalization pat = new DefaultPatternnormalization();

		File thefile = null;

		// 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();

		} else {

			return null;

		}

		FileReader reader = null;

		PersistentState state = null;

		try {

			reader = new FileReader(thefile);

			state = manager.loadState(reader);

			pat.loadFromState(state);

			reader.close();

		} catch (Exception e) {

			log.error("Error loading the pattern", e);

			return null;

		}

		return pat;

	}

	/**

	 * This method returns a Element of one position

	 * 

	 * @param index

	 * @return

	 */

	protected Element getElement(int index) {

		Element[] adrs = pattern.getArrayElements();

		return adrs[index];

	}

	/**

	 * This method generates and returns field separators

	 * 

	 * @return default separators between fields

	 */

	protected Fieldseparator getDefaultFieldseparators() {

		Fieldseparator filsep = new DefaultFieldseparator();

		filsep.setSemicolonsep(true);

		filsep.setJoinsep(false);

		filsep.setColonsep(false);

		filsep.setSpacesep(false);

		filsep.setTabsep(false);

		return filsep;

	}

	/**

	 * @return the pattern

	 */

	protected Patternnormalization getPattern() {

		return pattern;

	}

	/**

	 * This method sets the pattern

	 * 

	 * @pat pattern

	 */

	protected void setPattern(Patternnormalization pat) {

		pattern = pat;

	}

	/**

	 * 

	 * @return

	 */

	protected int getSelectedField() {

		return selectedField;

	}

	/**

	 * 

	 * @param selectedField

	 */

	protected void setSelectedField(int selectedField) {

		this.selectedField = selectedField;

	}

	/**

	 * 

	 * @return

	 */

	protected FeatureStore getStore() {

		return store;

	}

	/**

	 * 

	 * @param store

	 */

	protected void setStore(FeatureStore store) {

		this.store = store;

	}

	/**

	 * set the number of first rows that not normalize

	 * 

	 * @param first

	 *            select the first row

	 */

	protected void setFirstRows(int first) {

		pattern.setNofirstrows(first);

	}

	/**

	 * get Normalize the first row

	 * 

	 * @return normalize first row

	 */

	protected int getFirstRows() {

		return pattern.getNofirstrows();

	}

	/**

	 * This method creates the default Normalization pattern

	 */

	private Patternnormalization initializeDefaultPattern() {

		Patternnormalization pat = new DefaultPatternnormalization();

		pat.setPatternname("defaultPattern");

		pat.setNofirstrows(0);

		/* Create the first Address Element */

		Element elem = new DefaultElement();

		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);

		return pat;

	}

	/**

	 * This method validates the name of a new field

	 * 

	 * @param text

	 * @return field name formatted

	 */

	private String validateFieldName(String text) {

		String temp = Normalizer.normalize(text, Normalizer.DECOMP, 0);

		temp = temp.replaceAll("[^\\p{ASCII}]", "");

		temp = temp.replaceAll("[\\s]+", "_");

		temp = temp.toUpperCase();

		return temp;

	}

	/**

	 * This method generates and returns in field separators

	 * 

	 * @return special characters within one string

	 */

	private Infieldseparators getDefaultInfieldseparators() {

		/* create the default in-field separators */

		Locale loc = Locale.getDefault();

		DecimalFormatSymbols dfs = new DecimalFormatSymbols(loc);

		Infieldseparators infilsep = new DefaultInfieldseparators();

		infilsep.setThousandseparator(Character.toString(dfs

				.getGroupingSeparator()));

		infilsep.setDecimalseparator(Character.toString(dfs

				.getDecimalSeparator()));

		infilsep.setTextseparator("\"");

		return infilsep;

	}

	/**

	 * This method generates and returns a new field type of type Stringvalue

	 * 

	 * @return field type

	 */

	private Fieldtype getDefaultNewFieldType() {

		Fieldtype newtype = new DefaultFieldtype();

		Stringvalue strval = new DefaultStringvalue();

		strval.setStringvaluewidth(50);

		newtype.setStringvalue(strval);

		return newtype;

	}

	/**

	 * This method write the save xml file

	 * 

	 * @param file

	 * @throws IOException

	 * @throws PersistenceException

	 */

	private void writeSaveFile(File thefile) throws IOException,

			PersistenceException {

		PersistenceManager manager = ToolsLocator.getPersistenceManager();

		pattern.setPatternname(thefile.getName());

		Writer writer = new FileWriter(thefile);

		PersistentState state = manager.getState(pattern);

		state.save(writer);

		writer.close();

	}

	/**

	 * This method return the folder where gvSIG stores the patterns

	 * 

	 * @return

	 */

	private String getFolderPattern() {

		XMLEntity xml = PluginServices.getPluginServices(this)

				.getPersistentXML();

		String pathFolder = String.valueOf(xml

				.getStringProperty("Normalization_pattern_folder"));

		return pathFolder;

	}

	/**

	 * Gets the strings sample for the table of samples

	 * 

	 * @return table model

	 * @throws DataException 

	 */

	protected DefaultTableModel getSamplesDataStore(int noRows) throws DataException {

		FeatureSet features = (FeatureSet) store.getDataSet();

		Iterator<Feature> it = features.iterator(noRows);

		int contador = 0;

		while (it.hasNext()) {

			Feature feature = (Feature) it.next();

			if (contador < SAMPLES) {

				String sample = feature.get(selectedField).toString();

				samples[contador] = sample;

			}

		}

		// String samples

		Object[][] data = new Object[samples.length][1];

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

			data[i][0] = samples[i];

		}

		// table field name

		String fieldname = store.getDefaultFeatureType().getAttributeDescriptor(selectedField).getName();

		String[] names = { fieldname };

		DefaultTableModel tablemodel = new DefaultTableModel(data, names) {

			private static final long serialVersionUID = -7429493540158414622L;

			public boolean isCellEditable(int rowIndex, int columnIndex) {

				return false;

			}

		};

		return tablemodel;

	}

}

import javax.swing.JTextArea;

import com.iver.andami.ui.mdiManager.IWindow;

import com.iver.andami.ui.mdiManager.WindowInfo;

		implements ActionListener, ChangeListener {

	private NormalizationPanelController controller;

	private PluginServices ps;

	/* GUI */

	private JButton jButCancel;

	private JButton jButRun;

	private JCheckBox jChkColon;

	private JList jListOriginalFields;

	private JPanel jPanConsole;

	private JTable jTableResult;

	private JTable jTableSource;

	private JTextArea jTextAreaConsole;

	 * Creates new form NormalizationPanel to normalize field of datastore

	 * 

	 * @param control

	 * @return panel

	public NormalizationPanel(NormalizationPanelController control) {

		this.controller = control;

		init();

	}

	/**

	 * This method sets the PluginServices and update the string and icons

	 * 

	 * @param ps

	 *            PluginServices

	 */

	public void setPs(PluginServices ps) {

		this.ps = ps;

		if (ps != null) {

			setMessages();

			setImages();

		}

	}

	/**

	 * This method inserts the sample split strings into the Sample Table

	 * 

	 * @param chains

	 *            array with strings

	 */

	public void insertChainsInRowsTableSample(String[] chains) {

		DefaultTableModel dtm = new DefaultTableModel();

		int nfil = dtm.getRowCount();

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

			dtm.setValueAt(chains[0], i, 0);

		}

		jTableSource.setModel(dtm);

	}

	/**

	 * Insert in the console the message

	 * 

	 * @param e

	 */

	public void stateChanged(ChangeEvent e) {

		String info = parseInfo(e.getSource().toString());

		this.jTextAreaConsole.append(info);

	}

	/**

	 * This method inserts the model in the list with the names of the fields of

	 * the original table

	 * 

	 * @param fieldsNames

	 */

	public void insertFieldsCurrentTable(String[] fieldsNames) {

		DefaultListModel dcb = new DefaultListModel();

		int cont = fieldsNames.length;

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

			dcb.addElement(fieldsNames[i]);

		}

		this.jListOriginalFields.setModel(dcb);

		this.jListOriginalFields.setSelectedIndex(0);

	}

	/**

	 * getWindowInfo

	 * 

	 * @return windows properties

	 */

	public WindowInfo getWindowInfo() {

		WindowInfo info = new WindowInfo(WindowInfo.MODALDIALOG

				| WindowInfo.RESIZABLE);

		info.setWidth(780);

		info.setHeight(620);

		info.setTitle(PluginServices.getText(this, "normalize"));

		return info;

	}

	/**

	 * Initialize components and other custom code

	 */

	private void init() {

		/* Final initialize methods to set up the GUI */

		updateGUI();

		jListOriginalFields.setEnabled(false);

		jTableResult = new javax.swing.JTable();

		jTableSource = new javax.swing.JTable();

		jChkColon = new javax.swing.JCheckBox();

		jListOriginalFields = new javax.swing.JList();

		jPanConsole = new javax.swing.JPanel();

		jTextAreaConsole = new javax.swing.JTextArea();

		jButRun = new javax.swing.JButton();

		jButCancel = new javax.swing.JButton();

		setMinimumSize(new java.awt.Dimension(600, 620));

		setPreferredSize(new java.awt.Dimension(600, 620));

		addFocusListener(new java.awt.event.FocusAdapter() {

			public void focusGained(java.awt.event.FocusEvent evt) {

				mainPanelGetFocus(evt);

			}

		});

		jTableResult.setFont(new java.awt.Font("Courier New", 0, 11));

		jTableResult.setModel(new javax.swing.table.DefaultTableModel(

		jTableResult.setAutoResizeMode(javax.swing.JTable.AUTO_RESIZE_OFF);

		jTableResult.setEnabled(false);

		jScrollPane2.setViewportView(jTableResult);

		gridBagConstraints.insets = new java.awt.Insets(0, 5, 5, 5);

		jTableSource.setFont(new java.awt.Font("Courier New", 0, 11));

		jTableSource.setModel(new DefaultTableModel());

		jTableSource.getTableHeader().setReorderingAllowed(false);

		jScrollPaneSource.setViewportView(jTableSource);

		jCheckFirstRow.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				EvCheckFirstRow(evt);

			}

		});

		jTextNumberRows.addKeyListener(new java.awt.event.KeyAdapter() {

			public void keyReleased(java.awt.event.KeyEvent evt) {

				firstRowsvalueChange();

			}

		});

		gridBagConstraints.gridy = 1;

		gridBagConstraints.insets = new java.awt.Insets(5, 5, 5, 5);

		jListFieldList.addMouseListener(new MouseListener() {

			public void mouseClicked(MouseEvent e) {

			}

			public void mouseEntered(MouseEvent e) {

			}

			public void mouseExited(MouseEvent e) {

			}

			public void mousePressed(MouseEvent e) {

				selectedField = jListFieldList.getSelectedIndex();

			}

			public void mouseReleased(MouseEvent e) {

			}

		});

		jListFieldList

				.addListSelectionListener(new javax.swing.event.ListSelectionListener() {

					public void valueChanged(

							javax.swing.event.ListSelectionEvent evt) {

						jListFieldListValueChanged(evt);

					}

				});

		jButAddField.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				ActionButtonAddField(evt);

			}

		});

		gridBagConstraints.insets = new java.awt.Insets(0, 5, 5, 5);

		jButRemoveField.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				ActionButtonRemove(evt);

			}

		});

		gridBagConstraints.insets = new java.awt.Insets(0, 5, 5, 5);

		jButUpField.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				ActionButtonUp(evt);

			}

		});

		gridBagConstraints.insets = new java.awt.Insets(0, 5, 0, 5);

		jButDownField.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				ActionButtonDown(evt);

			}

		});

		gridBagConstraints.insets = new java.awt.Insets(5, 5, 0, 5);

		jRadioString.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				updateStringType(evt);

			}

		});

		gridBagConstraints.insets = new java.awt.Insets(0, 5, 5, 5);

		jRadioInteger.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				updateIntegerType(evt);

			}

		});

		gridBagConstraints.insets = new java.awt.Insets(0, 5, 5, 5);

		jRadioDecimal.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				updateDecimalType(evt);

			}

		});

		gridBagConstraints.insets = new java.awt.Insets(0, 5, 5, 5);

		jRadioDate.addItemListener(new java.awt.event.ItemListener() {

			public void itemStateChanged(java.awt.event.ItemEvent evt) {

				dateStateChanged(evt);

			}

		});

		gridBagConstraints.insets = new java.awt.Insets(0, 5, 5, 5);

		jComboDate.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				ActionListDateFormat(evt);

			}

		});

		gridBagConstraints.insets = new java.awt.Insets(0, 5, 5, 5);

		jChkTab.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				ActionTab(evt);

			}

		});

		jChkSpace.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				ActionSpace(evt);

			}

		});

		jChkColon.setText("Colon");

		jChkColon.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				ActionColon(evt);

			}

		});

		jPanFieldSeparators.add(jChkColon, gridBagConstraints);

		jChkSemicolon.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				ActionSemicolon(evt);

			}

		});

		jChkOther.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				enableOtherText(evt);

			}

		});

		jTextOther.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				ActionTextOther(evt);

			}

		});

		jChkJoin.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				ActionJoinSep(evt);

			}

		});

		jRadioFixed.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				fixedWidthEnable(evt);

			}

		});

		jRadioCharacter.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				charDelimitedEnable(evt);

			}

		});

		jTextFieldWidth.addKeyListener(new KeyListener() {

			public void keyPressed(KeyEvent evt) {

			}

			public void keyTyped(KeyEvent evt) {

			}

			public void keyReleased(KeyEvent e) {

				ActionTextFixedWidth(e);

			}

		});

		jChkDontImport.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				ActionDontImport(evt);

			}

		});

		jTextFieldName.addKeyListener(new KeyListener() {

			public void keyPressed(KeyEvent e) {

			}

			public void keyReleased(KeyEvent e) {

				KeyChangesFieldName(e);

			}

			public void keyTyped(KeyEvent e) {

			}

		});

		jButSave.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				jButSaveActionPerformed(evt);

			}

		});

		gridBagConstraints.insets = new java.awt.Insets(5, 5, 0, 5);

		jButLoad.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				jButLoadActionPerformed(evt);

			}

		});

		gridBagConstraints.insets = new java.awt.Insets(5, 5, 0, 5);

		jButTest.addActionListener(new java.awt.event.ActionListener() {

			public void actionPerformed(java.awt.event.ActionEvent evt) {

				testNormalizer(evt);

			}

		});

		gridBagConstraints.insets = new java.awt.Insets(5, 5, 0, 5);

		gridBagConstraints.insets = new java.awt.Insets(5, 5, 5, 15);

		jTextDecimal.addFocusListener(new java.awt.event.FocusAdapter() {

			public void focusLost(java.awt.event.FocusEvent evt) {

				ActionDecimal(evt);

			}

		});