/ - Diff - gvSIG data provider for seismic formats - gvSIG

Revision 1255

     Put into this folder the resources needed by your classes.
     This folder is added to the classpath, so you can load any resources
     through the ClassLoader.
     By default, in this folder you can find an example of log4j configuration,
     prepared to log messages through the console, so logging works when you
     run your classes.

     <?xml version="1.0" encoding="ISO-8859-1" ?>
     <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
     <!--
     Log4J configuration file for unit tests execution.
      -->
     <log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
     	<!-- Appender configuration to show logging messages through the console -->
     	<appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">
     		<layout class="org.apache.log4j.PatternLayout">
     			<param name="ConversionPattern" value="%d{HH:mm:ss,SSS} %-5p [%c{2}.%M()]\n  %m%n" />
     		</layout>
     	</appender>
     	<!--
     	Activate logging messages of DEBUG level of higher only for the
     	org.gvsig.tools packages.
     	You can put full classes names or packages instead, to configure
     	logging for all the classes and subpackages of the package.
     	-->
     	<category name="org.gvsig.tools">
     		<priority value="DEBUG" />
     	</category>
     	<category name="org.gvsig.construc">
     		<priority value="DEBUG" />
     	</category>
     	<!--
     	By default, show only logging messages of INFO level or higher,
     	through the previously configured CONSOLE appender.
     	-->
     	<root>
     		<priority value="INFO" />
     		<appender-ref ref="CONSOLE" />
     	</root>
     </log4j:configuration>

     <?xml version="1.0" encoding="UTF-8" ?>
     <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
     <html xmlns="http://www.w3.org/1999/xhtml">
     <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
     <title>org.gvsig.construc package documentation</title>
     </head>
     <body>
     	<p>Construc library testing and demo application.</p>
     </body>
     </html>

     /* gvSIG. Geographic Information System of the Valencian Government
+     *
      * Copyright (C) 2007-2008 Infrastructures and Transports Department
      * of the Valencian Government (CIT)
+     *
      * This program is free software; you can redistribute it and/or
      * modify it under the terms of the GNU General Public License
      * as published by the Free Software Foundation; either version 2
      * of the License, or (at your option) any later version.
+     *
      * This program is distributed in the hope that it will be useful,
      * but WITHOUT ANY WARRANTY; without even the implied warranty of
      * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      * GNU General Public License for more details.
+     *
      * You should have received a copy of the GNU General Public License
      * along with this program; if not, write to the Free Software
      * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      */
     package org.gvsig.seismic.main;
     import java.awt.BorderLayout;
     import java.awt.Dimension;
     import java.awt.event.ActionEvent;
     import java.awt.event.ActionListener;
     import java.io.File;
     import java.net.URL;
     import javax.swing.AbstractAction;
     import javax.swing.Action;
     import javax.swing.JButton;
     import javax.swing.JFrame;
     import javax.swing.JMenu;
     import javax.swing.JMenuBar;
     import javax.swing.JMenuItem;
     import javax.swing.JPanel;
     import javax.swing.JToolBar;
     import javax.swing.UIManager;
     import javax.swing.UnsupportedLookAndFeelException;
     import javax.swing.WindowConstants;
     import org.gvsig.fmap.dal.DALLocator;
     import org.gvsig.fmap.geom.primitive.Envelope;
     import org.gvsig.fmap.mapcontext.MapContext;
     import org.gvsig.fmap.mapcontext.MapContextLocator;
     import org.gvsig.fmap.mapcontext.exceptions.LoadLayerException;
     import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;
     import org.gvsig.fmap.mapcontrol.MapControl;
     import org.gvsig.fmap.mapcontrol.MapControlCreationException;
     import org.gvsig.fmap.mapcontrol.MapControlLocator;
     import org.gvsig.fmap.mapcontrol.MapControlManager;
     import org.gvsig.fmap.mapcontrol.tools.PanListenerImpl;
     import org.gvsig.fmap.mapcontrol.tools.ZoomInListenerImpl;
     import org.gvsig.fmap.mapcontrol.tools.ZoomOutRightButtonListener;
     import org.gvsig.fmap.mapcontrol.tools.Behavior.Behavior;
     import org.gvsig.fmap.mapcontrol.tools.Behavior.MoveBehavior;
     import org.gvsig.fmap.mapcontrol.tools.Behavior.PointBehavior;
     import org.gvsig.fmap.mapcontrol.tools.Behavior.RectangleBehavior;
     import org.gvsig.seismic.swing.SeismicSwingLocator;
     import org.gvsig.seismic.swing.SeismicSwingManager;
     import org.gvsig.seismic.swing.gui.JSeismicWizard;
     import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;
     import org.gvsig.tools.locator.LocatorException;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import com.jgoodies.looks.plastic.PlasticLookAndFeel;
     import com.jgoodies.looks.plastic.PlasticXPLookAndFeel;
     /**
      * Main executable class for testing the Chart library.
+     *
      * @author gvSIG Team
      * @version $Id$
      */
     public class Main {
     	private static final Logger LOG = LoggerFactory.getLogger(Main.class);
         private static final String SHOWINFO_TOOL_NAME = "LandRegistryViewer.infotool";
         private MapControlManager mapControlManager;
         private MapControl mapControl;
     	private SeismicSwingManager swingManager;
     	private JSeismicWizard wizard;
     	public JSeismicWizard getWizard() {
     		return wizard;
+    	}
     	public static void main(String args[]) throws MapControlCreationException,
     			LocatorException, LoadLayerException, UnsupportedLookAndFeelException {
     		new DefaultLibrariesInitializer().fullInitialize();
     		PlasticLookAndFeel laf = new PlasticXPLookAndFeel();
     		UIManager.setLookAndFeel(laf);
     		Main main = new Main();
     		main.show();
+    	}
     	public SeismicSwingManager getSwingManager() {
     		if(swingManager == null){
     			swingManager = SeismicSwingLocator.getDriverSwingManager();
+    		}
     		return swingManager;
+    	}
     	@SuppressWarnings("serial")
         public void show() throws MapControlCreationException, LocatorException, LoadLayerException {
             AbstractAction exit = new AbstractAction("Exit") {
                 public void actionPerformed(ActionEvent e) {
                     System.exit(0);
+                }
             };
             JFrame frame = new JFrame("Example APP");
             frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
             JPanel content = new JPanel();
             content.setLayout(new BorderLayout());
             //Parser parser =  getSwingManager().getDriverManager().createParser("UKOOA-84");
             wizard = getSwingManager().createWizard();
             content.add(wizard.getJComponent(), BorderLayout.CENTER);
             JButton accept = new JButton("Load features to view");
             accept.addActionListener(new ActionListener() {
     			public void actionPerformed(ActionEvent e) {
     				try {
     					if(getWizard().accept()){
     						createLayer();
     					}else{
     						LOG.error("[Main - accept button] ERROR: There're problems generating the data");
+    					}
     				} catch (MapControlCreationException e1) {
     					// TODO Auto-generated catch block
     					e1.printStackTrace();
     				} catch (LocatorException e1) {
     					// TODO Auto-generated catch block
     					e1.printStackTrace();
     				} catch (LoadLayerException e1) {
     					// TODO Auto-generated catch block
     					e1.printStackTrace();
+    				}
+    			}
     		});
             content.add(accept,BorderLayout.SOUTH);
             frame.add(content);
             frame.setPreferredSize(new Dimension(510, 560));
             // Display the window.
             frame.pack();
             frame.setVisible(true);
+        }
     	    public void createLayer() throws MapControlCreationException, LocatorException, LoadLayerException {
     	    	mapControlManager = MapControlLocator.getMapControlManager();
     	        mapControl = mapControlManager.createJMapControlPanel();
     	        mapControl.addBehavior(
     	    		"zoom",
     			    new Behavior[] {
     				    new RectangleBehavior(new ZoomInListenerImpl(mapControl)),
     				    new PointBehavior(new ZoomOutRightButtonListener(mapControl))
+    	   			}
     	    	);
     	        mapControl.addBehavior(
     	        	"pan",
     	        	new MoveBehavior(
     	       			new PanListenerImpl(mapControl)
+    	        	)
     	        );
     	        mapControl.setTool("pan");
     	        Action exit = new AbstractAction("Exit") {
     	            public void actionPerformed(ActionEvent e) {
     	                System.exit(0);
+    	            }
     	        };
     	        JFrame frame = new JFrame("Driver view example app");
     	        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
     	        // Create the menu bar.
     	        JMenuBar menuBar = new JMenuBar();
     	        // Build the menu.
     	        JMenu menuFile = new JMenu("File");
     	        menuFile.add(new JMenuItem(exit));
     	        menuBar.add(menuFile);
     	        JToolBar toolBar = new JToolBar();
     	        toolBar.add(
     	            	new JButton(
     	    	       		new AbstractAction("Pan") {
     	    		            public void actionPerformed(ActionEvent e) {
     	    		                mapControl.setTool("pan");
+    	    		            }
+    	    		        }
+    	            	)
     	            );
     	        toolBar.add(
     	            	new JButton(
     	    	       		new AbstractAction("Zoom") {
     	    		            public void actionPerformed(ActionEvent e) {
     	    		                mapControl.setTool("zoom");
+    	    		            }
+    	    		        }
+    	            	)
     	            );
     	        toolBar.add(
     	            	new JButton(
     	    	       		new AbstractAction("Zoom all") {
     	    		            public void actionPerformed(ActionEvent e) {
     	    		                zoomAll();
+    	    		            }
+    	    		        }
+    	            	)
     	            );
     	        toolBar.add(
     	            	new JButton(
     	    	       		new AbstractAction("Info") {
     	    		            public void actionPerformed(ActionEvent e) {
     	    		            	mapControl.setTool(SHOWINFO_TOOL_NAME);;
+    	    		            }
+    	    		        }
+    	            	)
     	            );
     	        toolBar.add(new JButton(exit));
     	        frame.setPreferredSize(new Dimension(400, 300));
     	        frame.setJMenuBar(menuBar);
     	        frame.add(toolBar, BorderLayout.PAGE_START);
     	        frame.add(mapControl,BorderLayout.CENTER);
     	        // Display the window.
     	        frame.pack();
     	        frame.setVisible(true);
     	        LOG.info("Providers: " + DALLocator.getDataManager().getStoreProviders().toString());
     	        // Add the blocks layer
     //	        MapContextLocator.getMapContextManager().setDefaultVectorLegend(ISingleSymbolLegend.LEGEND_NAME);
     	    	FLyrVect layer = (FLyrVect) MapContextLocator.
     	    		getMapContextManager().createLayer(
     				    "test_driver",
     				    getWizard().getDriverStoreParameters()
     	    		);
     	    	mapControl.getMapContext().getLayers().addLayer(layer);
     //	    	PropertiesOfBlockListener listener = new PropertiesOfBlockListener();
     //	    	mapControl.addBehavior(SHOWINFO_TOOL_NAME, new PointBehavior(listener));
     	    	zoomAll();
+    	    }
     	    private void zoomAll() {
     	    	MapContext mapContext = mapControl.getMapContext();
     	    	Envelope all = mapContext.getLayers().getFullEnvelope();
     	    	LOG.info("Full extdents "+all.toString());
     	    	mapContext.getViewPort().setEnvelope(all);
     	    	mapContext.invalidate();
+    	    }
     	    private File getResource(String pathname) {
     	    	URL res = this.getClass().getClassLoader().getResource(pathname);
     	    	return new File(res.getPath());
+    	    }
+    }

     <?xml version="1.0" encoding="ISO-8859-1"?>
     <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     	<modelVersion>4.0.0</modelVersion>
     	<artifactId>org.gvsig.seismic.main</artifactId>
     	<packaging>jar</packaging>
     	<name>org.gvsig.seismic.main</name>
     	<parent>
     		<groupId>org.gvsig</groupId>
     		<artifactId>org.gvsig.seismic</artifactId>
     		<version>1.0.0-SNAPSHOT</version>
     	</parent>
     	<dependencies>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.seismic.lib.api</artifactId>
     			<scope>compile</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.seismic.lib.impl</artifactId>
     			<scope>runtime</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.seismic.swing.api</artifactId>
     			<scope>compile</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.seismic.provider</artifactId>
     			<scope>compile</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.seismic.swing.impl</artifactId>
     			<scope>runtime</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.tools.lib</artifactId>
     			<scope>compile</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.tools.dynform.api</artifactId>
     			<scope>compile</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.tools.dynform.impl</artifactId>
     			<scope>runtime</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.metadata.lib.basic.api</artifactId>
     			<scope>compile</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.tools.swing.api</artifactId>
     			<type>jar</type>
     			<scope>compile</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.fmap.control</artifactId>
     			<scope>compile</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.fmap.dal.api</artifactId>
     			<scope>compile</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.fmap.dal.spi</artifactId>
     			<scope>compile</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.fmap.geometry.api</artifactId>
     			<scope>compile</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.fmap.mapcontext.api</artifactId>
     			<scope>compile</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.metadata.lib.basic.impl</artifactId>
     			<scope>runtime</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.fmap.geometry.impl</artifactId>
     			<scope>runtime</scope>
     		</dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.fmap.geometry.operation</artifactId>
     			<scope>runtime</scope>
             </dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.fmap.mapcontext.impl</artifactId>
     			<scope>runtime</scope>
     		</dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.symbology.lib.impl</artifactId>
     			<scope>runtime</scope>
             </dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.fmap.dal.impl</artifactId>
     			<scope>runtime</scope>
     		</dependency>
     		<dependency>
     			<groupId>org.gvsig</groupId>
     			<artifactId>org.gvsig.fmap.dal.spi</artifactId>
     			<scope>runtime</scope>
     		</dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.fmap.dal.file.shp</artifactId>
     			<scope>runtime</scope>
             </dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.fmap.dal.file.dbf</artifactId>
     			<scope>runtime</scope>
             </dependency>
             <dependency>
                 <groupId>org.gvsig</groupId>
                 <artifactId>org.gvsig.fmap.dal.file.lib</artifactId>
     			<scope>runtime</scope>
             </dependency>
             <dependency>
                  <groupId>org.gvsig</groupId>
                  <artifactId>org.gvsig.timesupport.lib.api</artifactId>
     			<scope>runtime</scope>
              </dependency>
              <dependency>
                  <groupId>org.gvsig</groupId>
                  <artifactId>org.gvsig.timesupport.lib.impl</artifactId>
     			<scope>runtime</scope>
              </dependency>
              <dependency>
                  <groupId>org.gvsig</groupId>
                  <artifactId>org.gvsig.tools.evaluator.sqljep</artifactId>
     			<scope>runtime</scope>
              </dependency>
              <dependency>
                  <groupId>org.gvsig</groupId>
                  <artifactId>org.gvsig.proj.lib.proj4j</artifactId>
     			<scope>runtime</scope>
     		</dependency>
     	</dependencies>
     </project>

     Put into this folder the resources needed by your test classes.
     This folder is added to the Tests classpath, so you can load any resources
     through the ClassLoader.
     By default, in this folder you can find an example of log4j configuration,
     prepared to log messages through the console, so logging works when you
     run your tests classes.

     <?xml version="1.0" encoding="ISO-8859-1" ?>
     <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
     <!--
     Log4J configuration file for unit tests execution.
      -->
     <log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
     	<!-- Appender configuration to show logging messages through the console -->
     	<appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">
     		<layout class="org.apache.log4j.PatternLayout">
     			<param name="ConversionPattern" value="%d{HH:mm:ss,SSS} %-5p [%c{2}.%M()]\n  %m%n" />
     		</layout>
     	</appender>
     	<!--
     	Activate logging messages of DEBUG level of higher only for the
     	org.gvsig.tools packages.
     	You can put full classes names or packages instead, to configure
     	logging for all the classes and subpackages of the package.
     	-->
     	<category name="org.gvsig.tools">
     		<priority value="DEBUG" />
     	</category>
     	<category name="org.gvsig.chart">
     		<priority value="DEBUG" />
     	</category>
     	<!--
     	By default, show only logging messages of INFO level or higher,
     	through the previously configured CONSOLE appender.
     	-->
     	<root>
     		<priority value="DEBUG" />
     		<appender-ref ref="CONSOLE" />
     	</root>
     </log4j:configuration>

     <?xml version="1.0" encoding="UTF-8" ?>
     <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
     <html xmlns="http://www.w3.org/1999/xhtml">
     <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
     <title>org.gvsig.landregistryviewer package documentation</title>
     </head>
     <body>
     	<p>LandRegistryViewer library API default implementation.</p>
     </body>
     </html>

     package org.gvsig.seismic.impl;
     import java.io.BufferedReader;
     import java.io.File;
     import java.io.FileNotFoundException;
     import java.io.FileReader;
     import java.io.IOException;
     import java.util.ArrayList;
     import java.util.HashMap;
     import java.util.Iterator;
     import java.util.List;
     import java.util.Map;
     import java.util.regex.Matcher;
     import java.util.regex.Pattern;
     import javax.swing.JOptionPane;
     import org.cresques.cts.IProjection;
     import org.gvsig.fmap.crs.CRSFactory;
     import org.gvsig.fmap.dal.feature.EditableFeatureType;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.geom.DataTypes;
     import org.gvsig.fmap.geom.GeometryLocator;
     import org.gvsig.fmap.geom.GeometryManager;
     import org.gvsig.seismic.Parser;
     import org.gvsig.seismic.SeismicManager;
     import org.gvsig.tools.ToolsLocator;
     import org.gvsig.tools.dynobject.DynObject;
     import org.gvsig.tools.dynobject.DynObjectManager;
     import org.gvsig.tools.dynobject.DynStruct;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     public abstract class AbstractParser implements
     		Parser{
     	private static Logger logger= LoggerFactory.getLogger(AbstractParser.class);
     	private SeismicManager manager;
     	protected GeometryManager geomanager;
     	protected List<String> availableExtensions = new ArrayList<String>();
     	protected DynObjectManager dynManager;
     	//private List<Map<String, Object>> features;
     	protected DynStruct dynStruct;
     	protected File file;
     	protected Map<String, String> metadata;
     	private List<DynObject> data;
     	protected EditableFeatureType featureType;
     	protected int blankFieldCount = 1;
     	private List<FieldDefinition> fieldDefinitions;
     	private IProjection projection;
     	private boolean firstErrorShown = false;
     	private String projectid;
     	private String projectName;
     	private String projectYear;
     	private String estado;
     	protected IProjection defaultProjection;
     	public AbstractParser(SeismicManager manager){
     		this.manager = manager;
     		this.dynManager = ToolsLocator.getDynObjectManager();
     		this.geomanager =  GeometryLocator.getGeometryManager();
     		//this.defaultProjection = CRSFactory.getCRS("EPSG:4326");
+    	}
     	public void initializeParser(){
     		//this.features = null;
     		this.setData(null);
     //		this.featureStruct = null;
     		this.fieldDefinitions = null;
     		this.featureType = null;
     		this.dynStruct = null;
     		this.metadata = null;
+    	}
     	public boolean isFileSupported(File file) {
     		int dot = file.getName().lastIndexOf(".");
     		String extension = file.getName().substring(dot + 1);
     		if( availableExtensions.contains(extension.toLowerCase())){
     			return true;
+    		}
     		return false;
+    	}
     	public void setFile(File file){
     		this.file = file;
     		//this.features = null;
     		this.setData(null);
+    	}
     	public String[] getOrderedFieldNames() {
     		return new String[]{};
+    	}
     	protected void addFieldDefinition(String nombre, int type){
     		getFieldDefinitions().add(new FieldDefinition(nombre, type));
+    	}
     	public List<FieldDefinition> getFieldDefinitions(){
     		if(this.fieldDefinitions == null){
     			this.fieldDefinitions = new ArrayList<FieldDefinition>();
     			initializeDefinitions();
     			getDataStruct();
+    		}
     		return this.fieldDefinitions;
+    	}
     	protected void initializeDefinitions() {
     		addFieldDefinition("proyecto_id", DataTypes.STRING);
     		addFieldDefinition("proyecto", DataTypes.STRING);
     		addFieldDefinition("Fecha", DataTypes.STRING);
     		addFieldDefinition("Estado", DataTypes.STRING);
+    	}
     	public int getFieldDefinitionType(String name){
     		for(int i=0; i<getFieldDefinitions().size(); i++){
     			if(getFieldDefinitions().get(i).getName().equalsIgnoreCase(name)){
     				return getFieldDefinitions().get(i).getType();
+    			}
+    		}
     		return -1;
+    	}
     	protected void createDynObjectProjectInfo(DynObject dynObject){
     		if(getDataStruct().getDynField("proyecto_id") != null){
     			dynObject.setDynValue("proyecto_id", getProjectId());
+    		}
     		if(getDataStruct().getDynField("proyecto") != null){
     			dynObject.setDynValue("proyecto", getProjectName());
+    		}
     		if(getDataStruct().getDynField("Fecha") != null){
     			dynObject.setDynValue("Fecha", getProjectYear());
+    		}
     		if(getDataStruct().getDynField("Estado") != null){
     			dynObject.setDynValue("Estado", getEstado());
+    		}
+    	}
     	public String getProjectYear() {
     		return projectYear;
+    	}
     	public String getProjectName() {
     		return projectName;
+    	}
     	public String getProjectId() {
     		return projectid;
+    	}
     	public String getEstado() {
     		return estado;
+    	}
     	public String getFieldDefinitionName(String name){
     		for(int i=0; i<getFieldDefinitions().size(); i++){
     			if(getFieldDefinitions().get(i).getName().equalsIgnoreCase(name)){
     				return getFieldDefinitions().get(i).getName();
+    			}
+    		}
     		return null;
+    	}
     	public String getFieldDefinitionName(int index){
     		if(index < getFieldDefinitions().size()){
     			return getFieldDefinitions().get(index).getName();
+    		}
     		return null;
+    	}
     	public String getFieldDefinitionNewName(String name){
     		for(int i=0; i<getFieldDefinitions().size(); i++){
     			if(getFieldDefinitions().get(i).getName().equalsIgnoreCase(name)){
     				return getFieldDefinitions().get(i).getNewName();
+    			}
+    		}
     		return null;
+    	}
     	public String getFieldDefinitionNewName(int index){
     		if(index < getFieldDefinitions().size()){
     			return getFieldDefinitions().get(index).getNewName();
+    		}
     		return null;
+    	}
     	public void setFieldDefinitionNewName(String name, String newName){
     		for(int i=0; i<getFieldDefinitions().size(); i++){
     			if(getFieldDefinitions().get(i).getName().equalsIgnoreCase(name)){
     				getFieldDefinitions().get(i).setNewName(newName);
+    			}
+    		}
+    	}
     	protected List<String> getFieldNames(){
     		Iterator it = getFieldDefinitions().iterator();
     		List<String> aux = new ArrayList<String>();
     		while(it.hasNext()){
     			FieldDefinition fd = (FieldDefinition) it.next();
     			aux.add(fd.getName());
+    		}
     		return aux;
+    	}
     	protected class FieldDefinition{
     		private String name;
     		private String newName;
     		private int type;
     		public FieldDefinition(String name, int type){
     			this.setName(name);
     			this.setType(type);
+    		}
     		public String getName() {
     			return name;
+    		}
     		public void setName(String name) {
     			this.name = name;
+    		}
     		public int getType() {
     			return type;
+    		}
     		public void setType(int type) {
     			this.type = type;
+    		}
     		public String getNewName() {
     			if(newName == null || newName.trim().equals("")){
     				return name;
+    			}
     			return newName;
+    		}
     		public void setNewName(String newName) {
     			this.newName = newName;
+    		}
+    	}
     	public abstract String getName();
     	public abstract String getDescription();
     	public abstract boolean hasStartEndDelimiters();
     	public abstract String getStartDelimiter();
     	public abstract String getEndDelimiter();
     	public abstract boolean hasHeader();
     	public abstract String getHeaderToken();
     	public abstract boolean hasHeaderTokenRepited();
     	public abstract String getFieldDelimiter();
     	public abstract boolean hasFieldName();
     	public abstract String getFieldNameSeparator();
     	protected void preParsingProcess(){
+    	}
     	protected void postParsingProcess(){
+    	}
     	public SeismicManager getDriverManager(){
     		return this.manager;
+    	}
     	public List<DynObject> parseFile(File file){
     		setFile(file);
     		return updateDataContent(getDataStruct());
+    	}
     	public List<DynObject> parseFile(File file, DynStruct struct){
     		setFile(file);
     		return updateDataContent(struct);
+    	}
     //	protected DynStruct getFirstFeature() {
     //		if(this.file == null)
     //			return null;
     //
     //		if(this.featureStruct == null){
     //			extractFeatures(file, true);
     //			if(!getData().isEmpty()){
     //				postParsingProcess(getData());
     //				this.featureStruct = getData().get(0).getDynClass();
     //			}
     //		}
     //
     //		return this.featureStruct;
     //	}
     //
     	public void getFeatures(){
     		preParsingProcess();
     		extractFeatures(file, false);
     		postParsingProcess();
+    	}
     	protected void extractFeatures(File file, boolean onlyFirst){
     		readDocument(file, onlyFirst);
+    	}
     	public DynStruct getDataStruct(){
     		if(this.dynStruct == null){
     			if(file != null){
     				this.dynStruct = dynManager.createDynClass("Auxiliar", "Clase auxiliar para el parseo");
     				getDataStructure();
+    			}
+    		}
     		return this.dynStruct;
+    	}
     	public void setDataStruct(DynStruct struct){
     		this.dynStruct = struct;
     //		updateFeatureStoreDefinition();
+    	}
     	public FeatureStore getFeatureStore(){
     		return getDriverManager().getFeatureStore();
+    	}
     	public EditableFeatureType getFeatureType(){
     		return this.featureType;
+    	}
     	protected void getDataStructure() {
     		this.dynStruct = dynManager.createDynClass("Auxiliar", "Clase auxiliar para el parseo");
     		Iterator<FieldDefinition> it = getFieldDefinitions().iterator();
     		while(it.hasNext()){
     			FieldDefinition aux = (FieldDefinition)it.next();
     			this.dynStruct.addDynField(aux.getName());
     			if(getFieldDefinitionType(aux.getName())!= -1){
     				this.dynStruct.getDeclaredDynField(aux.getName()).setType(aux.getType());
+    			}
+    		}
+    	}
     	public List<DynObject> updateDataContent(){
     		return updateDataContent(getDataStruct());
+    	}
     	public List<DynObject> updateDataContent(DynStruct struct){
     		return updateDataContent(struct, null);
+    	}
     	public List<DynObject> updateDataContent(DynStruct struct, List<String> fieldNames){
     		getFeatures();
     		return this.getData();
+    	}
     //	public List<DynObject> updateDataContent(DynStruct struct, List<String> fieldNames){
     //		List<DynObject> dynObjectSet = new ArrayList<DynObject>();
     //
     //		getFeatures();
     //
     //		if(struct != null){
     //			for(int i=struct.getDynFields().length-1;i>=0;i--){
     //				DynField f = struct.getDynFields()[i];
     //				if(f.isHidden()){
     //					struct.removeDynField(f.getName());
     //				}
     //			}
     //		}
     //		Iterator itFeatures = getData().iterator();
     //		while(itFeatures.hasNext()){
     //			Map<String, Object> fields = (Map<String, Object>) itFeatures.next();
     //			DynObject dynObject = dynManager.createDynObject(struct);
     //
     //			if(fieldNames == null && (getFieldDefinitions() == null || getFieldDefinitions().isEmpty())){
     //
     //				for(int i = 0; i<struct.getDynFields().length;i++){
     //					Object value = getCorrectTypeValue(
     //							struct.getDynFields()[i].getType(),
     //							fields.get(struct.getDynFields()[i].getName()),
     //							struct.getDynFields()[i].getName());
     //					dynObject.setDynValue(struct.getDynFields()[i].getName(), value);
     //				}
     //			}else{
     //				if(fieldNames == null){
     //					fieldNames = getFieldNames();
     //				}
     //
     //				String[] originalFields = new String[fields.size()];
     //				originalFields = fields.keySet().toArray(originalFields);
     //				for(int i=0; i<fields.size();i++){
     //					if(fields.containsKey(originalFields[i])){
     //						String newFieldName = getFieldDefinitionNewName(originalFields[i]);
     //						if(struct.getDynField(newFieldName) != null){
     //							Object value = getCorrectTypeValue(
     //								struct.getDynField(newFieldName).getType(),
     //								fields.get(originalFields[i]),
     //								newFieldName);
     //							dynObject.setDynValue(
     //								newFieldName,
     //								value);
     //						}
     //					}
     //				}
     //			}
     //			dynObjectSet.add(dynObject);
     //		}
     //
     //		firstErrorShown = false;
     //
     //		return dynObjectSet;
     //	}
     	private Object getCorrectTypeValue(int type, Object value, String name) {
     		if(value == null){
     			return value;
+    		}
     		switch(type){
     		case DataTypes.STRING:
     			return value.toString();
     		case DataTypes.INT:
     			int i = 0;
     			try{
     				i =  Integer.parseInt(value.toString());
     			}catch(NumberFormatException e){
     				if(!firstErrorShown){
     					JOptionPane.showMessageDialog(null,
     						    "Error converting values from '"+ name+ "'\nfield into Integer.\nPlease check if that is correct",
     						    "Parsing values error",
     						    JOptionPane.ERROR_MESSAGE);
     					i = 0;
     					e.printStackTrace();
     					firstErrorShown = true;
+    				}
+    			}
     			return i;
     		case DataTypes.FLOAT:
     			float f = 0.0f;
     			try{
     				f =  Float.parseFloat(value.toString());
     			}catch(NumberFormatException e){
     				if(!firstErrorShown){
     					JOptionPane.showMessageDialog(null,
     						    "Error converting values from '"+ name+ "'\nfield into Float.\nPlease check if that is correct",
     						    "Parsing values error",
     						    JOptionPane.ERROR_MESSAGE);
     					f = 0.0f;
     					e.printStackTrace();
     					firstErrorShown = true;
+    				}
+    			}
     			return f;
     		case DataTypes.DOUBLE:
     			double d = 0.0;
     			try{
     				d =  Double.parseDouble(value.toString());
     			}catch(NumberFormatException e){
     				if(!firstErrorShown){
     					JOptionPane.showMessageDialog(null,
     						    "Error converting values from '"+ name+ "'\nfield into Double.\nPlease check if that is correct",
     						    "Parsing values error",
     						    JOptionPane.ERROR_MESSAGE);
     					d = 0.0;
     					e.printStackTrace();
     					firstErrorShown = true;
+    				}
+    			}
     			return d;
     		case DataTypes.DATE:
     			return value.toString();
     		case DataTypes.BOOLEAN:
     			return value.toString().trim().equalsIgnoreCase("true") || value.toString().trim().equalsIgnoreCase("t") ||
     					value.toString().trim().equalsIgnoreCase("yes") || value.toString().trim().equalsIgnoreCase("y");
     		case DataTypes.FILE:
     			return value.toString();
     		case DataTypes.GEOMETRY:
     			return value.toString();
     		default:
     			return value;
+    		}
+    	}
     	public Map<String, String> getMetadataInfo(File file){
     		if(this.metadata == null){
     			this.file = file;
     			readMetadata(file);
+    		}
     		return this.metadata;
+    	}
     	public void readMetadata(File file){
     		BufferedReader br = null;
     		String text = "";
     		String line = "";
     		if(!this.hasMetadata())
     			return;
     		try {
     			br = new BufferedReader(new FileReader(file.getAbsolutePath()));
     			boolean firstLine = true;
     			this.metadata = new HashMap<String, String>();
     			while ((line = br.readLine()) != null) {
     				Pattern delimiter = Pattern.compile("^"+     // Desde el principio de la cadena
     						 getMetadataToken()+                 // Inicio contenido feature
     						"(.*)$");              // Recoge todos los caracteres unidos al token de Metadato como separador
     				List<String> tagValues = new ArrayList<String>();
     				Matcher matcher = delimiter.matcher(line);
     				while (matcher.find()) {
     				    tagValues.add(matcher.group(1));
+    				}
     				if(tagValues.size()>0){
     					if(hasMetadataFieldName()){
     						for(int i=0;i<tagValues.size();i++){
     							String aux = tagValues.get(i);
     							if(aux != "" && aux.length()>28){
     								this.metadata.put(aux.substring(0,27).trim(), aux.substring(28).trim());
     								String key = aux.substring(0,27).trim();
     								String value = aux.substring(28).trim();
     								if(hasProjectionData(key)){
     									defaultProjection = getProjectionData(value);
+    								}
+    							}
+    						}
+    					}
     				}else{
     					// En el momento no coincida, ha acabado la cabecera.
     					// No hace falta seguir leyendo
     					br.close();
     					return;
+    				}
+    			}
     		} catch (FileNotFoundException e) {
     			e.printStackTrace();
     		} catch (IOException e) {
     			e.printStackTrace();
     		} finally {
     			if (br != null) {
     				try {
     					br.close();
     				} catch (IOException e) {
     					e.printStackTrace();
+    				}
+    			}
+    		}
+    	}
     	protected IProjection getProjectionData(String value) {
     		if(value.contains("58") || value.contains("21")){
     			defaultProjection = CRSFactory.getCRS("EPSG:24721");
+    		}
     		if(value.contains("63") || value.contains("20")){
     			defaultProjection = CRSFactory.getCRS("EPSG:24720");
+    		}
     		if(value.contains("69") || value.contains("19")){
     			defaultProjection = CRSFactory.getCRS("EPSG:24719");
+    		}
     		if(value.contains("75") || value.contains("18")){
     			defaultProjection = CRSFactory.getCRS("EPSG:24718");
+    		}
     		return defaultProjection;
+    	}
     	protected boolean hasProjectionData(String key) {
     		if(key.startsWith("H04") ||
     				key.startsWith("H19") ||
     				key.startsWith("H22")){
     			return true;
+    		}
     		return false;
+    	}
     	protected void readDocument(File file, boolean onlyFirst){
     		//String text = "";
     		String line = "";
     		//boolean firstLine = true;
     		List<DynObject> objects = new ArrayList<DynObject>();
     		//DynStruct struct = getDataStruct();
     		try {
     			 BufferedReader reader = new BufferedReader(new FileReader(file));
     			 while ((line = reader.readLine()) != null) {
     				 if(line.startsWith("EOF"))
     					 break;
     				 if(onlyFirst){
     						if(!this.hasMetadata() || !line.matches("^"+getMetadataToken()+"(.*)$")){
     							//text = line;
     							break;
+    						}
     				 }else{
     					if(!this.hasMetadata() || !line.matches("^"+getMetadataToken()+"(.*)$")){
     						String[] fields = null;
     						fields = line.trim().replaceAll("[  ]+", " ").split(getFieldDelimiter());
     						if(fields != null){
     							objects.add(createDynObject(fields));
+    						}
+    					}
+    				 }
+    		     }
     			 reader.close();
             }catch (Exception e) {
     			e.printStackTrace();
+    		}
     //
     //		// Fase 1a: Separar las Features
     //				String[] features = null;
     //				if(hasStartEndDelimiters()){
     //					Pattern delimiter = Pattern.compile(".*"+     // Ignora lo que haya antes
     //							 getStartDelimiter()+                 // Inicio contenido feature
     //							 "\\s*([^" + getEndDelimiter() + "]*)\\s*"+   // Hasta el primer final (no permite anidados)
     //							 getEndDelimiter()+                   // Final de la Feauture
     //							 ".*");                               // Ignora el resto
     //
     //					List<String> tagValues = new ArrayList<String>();
     //					Matcher matcher = delimiter.matcher(text);
     //					while (matcher.find()) {
     //					    tagValues.add(matcher.group(1));
     //					}
     //
     //					features = new String[tagValues.size()];
     //					features = tagValues.toArray(features);
     //				}else{
     //					features = text.split(getEndDelimiter());
     //				}
     //
     //				// Fase 1b: Obtener los fields de cada feature
     //				boolean firstTime = true;
     //				for(int i=0; i<features.length; i++){
     //					//Map<String,Object> auxFields = new HashMap<String,Object>();
     //
     //					// Si tiene cabecera, la primera iteraci?n es la definici?n
     //					if(hasHeader() && i==0){
     //						i++;
     //					}
     //
     //					String[] fields = features[i].trim().replaceAll("[  ]+", " ").split(getFieldDelimiter());
     //					for(int j=0; j<fields.length; j++){
     //						if(hasHeader()){
     //							String[] headerFields = features[0].split(getFieldDelimiter());
     //							if(headerFields.length == fields.length){
     //								String fieldName = headerFields[j];
     //								if(hasHeaderTokenRepited() && getHeaderToken() != null){
     //									fieldName = fieldName.replace(getHeaderToken(), "");
     //								}
     //								auxFields.put(fieldName, fields[j]);
     //								addFieldDefinition(fieldName, DataTypes.STRING);
     //							}
     //						}else{
     //							if(hasFieldName()){
     //								String[] aux = fields[j].split(getFieldNameSeparator());
     //								if(aux.length==2){
     //									auxFields.put(aux[0], aux[1]);
     //									addFieldDefinition(aux[0], DataTypes.STRING);
     //								}
     //							}else{
     //								auxFields.put("blank-field-name-"+this.blankFieldCount, fields[j]);
     //								if(firstTime){
     //									addFieldDefinition("blank-field-name-"+this.blankFieldCount, DataTypes.STRING);
     //								}
     //								this.blankFieldCount++;
     //							}
     //						}
     //					}
     //
     //					auxFeatures.add(auxFields);
     //					this.blankFieldCount=1;
     //					firstTime = false;
     //				}
     		this.setData(objects);
+    	}
     	protected DynObject createDynObject(String[] fields){
     		DynObject dynObject = dynManager.createDynObject(getDataStruct());
     		for(int j=0; j<fields.length; j++){
     			FieldDefinition fdef = getFieldDefinitions().get(j);
     			dynObject.setDynValue(fdef.getName(), fields[j]);
+    		}
     		return dynObject;
+    	}
     	public List<String> getExtensionSupported() {
     		return availableExtensions;
+    	}
     	public IProjection getProjection() {
     		if(this.projection == null){
     			return getDefaultProjection();
+    		}
     		return this.projection;
+    	}
     	public void setProjection(IProjection proj){
     		this.projection = proj;
+    	}
     	protected IProjection getDefaultProjection() {
     		return defaultProjection;
+    	}
     	public List<DynObject> getData() {
     		if(data == null){
     			data = this.parseFile(file, getDataStruct());
+    		}
     		return data;
+    	}
     	public void setData(List<DynObject> data) {
     		this.data = data;
+    	}
     	protected String getGeographicField(String original){
     		return original.replace(" ", "0");
+    	}
     	public void setProjectId(String projectId) {
     		this.projectid = projectId;
+    	}
     	public void setProjectName(String projectName) {
     		this.projectName = projectName;
+    	}
     	public void setProjectYear(String projectYear) {
     		this.projectYear = projectYear;
+    	}
     	public void setEstado(String estado) {
     		this.estado = estado;
+    	}
     	public abstract Parser clone();
+    }

     /* 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.
+     *
      */
     package org.gvsig.seismic.impl;
     import org.gvsig.seismic.SeismicLibrary;
     import org.gvsig.seismic.SeismicLocator;
     import org.gvsig.seismic.SeismicManager;
     import org.gvsig.seismic.impl.parser.CADParser;
     import org.gvsig.seismic.impl.parser.GEOGParser;
     import org.gvsig.seismic.impl.parser.H19Parser;
     import org.gvsig.seismic.impl.parser.P190Parser;
     import org.gvsig.seismic.impl.parser.PTOParser;
     import org.gvsig.seismic.impl.parser.R06Parser;
     import org.gvsig.seismic.impl.parser.RPSParser;
     import org.gvsig.seismic.impl.parser.UKOOA84Parser;
     import org.gvsig.tools.library.AbstractLibrary;
     import org.gvsig.tools.library.LibraryException;
     import org.gvsig.tools.util.Caller;
     import org.gvsig.tools.util.impl.DefaultCaller;
     /**
      * Library for default implementation initialization and configuration.
      * This default implementation will be based in JFreeChart library.
+     *
      * @author gvSIG team
      * @version $Id$

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff