Application: gvSIG desktop » gvSIG data providers based on gdal

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

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

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.dal.store.gpx;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.gdal.gdal.gdal;

import org.gdal.ogr.DataSource;

import org.gdal.ogr.Driver;

import org.gdal.ogr.FeatureDefn;

import org.gdal.ogr.Layer;

import org.gdal.ogr.ogr;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStoreNotification;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.FileHelper;

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureStoreProviderServices;

import org.gvsig.fmap.dal.feature.spi.memory.AbstractMemoryStoreProvider;

import org.gvsig.fmap.dal.resource.file.FileResource;

import org.gvsig.fmap.dal.resource.spi.ResourceConsumer;

import org.gvsig.fmap.dal.resource.spi.ResourceProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorer;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorerParameters;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryException;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.dynobject.exception.DynFieldNotFoundException;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.exception.NotYetImplemented;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class OGRStoreProvider extends AbstractMemoryStoreProvider implements

ResourceConsumer {

    private static final Logger logger = LoggerFactory.getLogger(OGRStoreProvider.class);

    public static final String NAME = "OGR_DRIVER";

    public static final String DESCRIPTION = "GPX file";

    public static final String METADATA_DEFINITION_NAME = NAME;

    private ResourceProvider resource;

    private long counterNewsOIDs = 0;

    private Envelope envelope;

    private boolean need_calculate_envelope = false;

    private SimpleTaskStatus taskStatus;

    public OGRStoreProvider(OGRStoreParameters parameters,

        DataStoreProviderServices storeServices) throws InitializeException {

        super(

            parameters, 

            storeServices,

            FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME)

        );

        gdal.AllRegister();

		ogr.RegisterAll();

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

        this.taskStatus = manager.createDefaultSimpleTaskStatus("Driver");

        counterNewsOIDs = 0;

        File file = getDriverParameters().getFile();

        resource = this.createResource(

            FileResource.NAME,

            new Object[] { file.getAbsolutePath() }

        );

        resource.addConsumer(this);

        initializeFeatureTypes();

    }

    private OGRStoreParameters getDriverParameters() {

        return (OGRStoreParameters) this.getParameters();

    }

    public String getProviderName() {

        return NAME;

    }

    public boolean allowWrite() {

        return false;

    }

    private String getFullFileName() {

    	// Usar solo para mostrar mensajes en el logger.

		String s = "(unknow)";

		try { 

			s = getDriverParameters().getFile().getAbsolutePath();

		} catch(Exception e2) {

			s = "(unknow)";

		}

		return s;

    }

    public void open() throws OpenException {

        if (this.data != null) {

            return;

        }

        this.data = new ArrayList<FeatureProvider>();

        resource.setData(new HashMap());

        counterNewsOIDs = 0;

		try {

			loadFeatures();

		} catch (RuntimeException e) {

			logger.warn("Can't load features from Driver '"+getFullFileName()+"'.", e);

			throw e;

		} catch (Exception e) {

			logger.warn("Can't load features from Driver '"+getFullFileName()+"'.", e);

			throw new RuntimeException(e);

		}

    }

    public DataServerExplorer getExplorer() throws ReadException {

        DataManager manager = DALLocator.getDataManager();

        FilesystemServerExplorerParameters params;

        try {

            params = (FilesystemServerExplorerParameters) manager

            .createServerExplorerParameters(FilesystemServerExplorer.NAME);

            params.setRoot(this.getDriverParameters().getFile().getParent());

            return manager.openServerExplorer(FilesystemServerExplorer.NAME,params);

        } catch (DataException e) {

            throw new ReadException(this.getProviderName(), e);

        } catch (ValidateDataParametersException e) {

            throw new ReadException(this.getProviderName(), e);

        }

    }

    public boolean closeResourceRequested(ResourceProvider resource) {

        return true;

    }

    public int getOIDType() {

        return DataTypes.LONG;

    }

    public boolean supportsAppendMode() {

        return false;

    }

    public void append(FeatureProvider featureProvider) {

    	throw new UnsupportedOperationException();

    }

    public void beginAppend() {

    	throw new UnsupportedOperationException();

    }

    public void endAppend() {

    	throw new UnsupportedOperationException();

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        throw new NotYetImplemented();

    }

    public void loadFromState(PersistentState state) throws PersistenceException {

        throw new NotYetImplemented();

    }

    public Object createNewOID() {

        return new Long(counterNewsOIDs++);

    }

    protected void initializeFeatureTypes() throws InitializeException {

        try {

            this.open();

        } catch (OpenException e) {

            throw new InitializeException(this.getProviderName(), e);

        }

    }

    public Envelope getEnvelope() throws DataException {

        this.open();

        if( this.envelope!= null )  {

        	return this.envelope;

        }

        if( !this.need_calculate_envelope ) {

        	return null;

        }

        FeatureStore fs = this.getFeatureStore();

        FeatureType ft = fs.getDefaultFeatureType();

        FeatureAttributeDescriptor fad = ft.getAttributeDescriptor(ft.getDefaultGeometryAttributeIndex());

        try {

            this.envelope = GeometryLocator.getGeometryManager().createEnvelope(fad.getGeomType().getSubType());

			fs.accept(new Visitor() {

				public void visit(Object obj) throws VisitCanceledException, BaseException {

					Feature f = (Feature) obj;

					Geometry geom = f.getDefaultGeometry();

					envelope.add(geom.getEnvelope());

				}

			});

		} catch (BaseException e) {

			logger.warn("Can't calculate the envelope of GPX file '"+this.getFullName()+"'.",e);

			this.envelope = null;

		}

        this.need_calculate_envelope = false;

        return this.envelope;

    }

    public Object getDynValue(String name) throws DynFieldNotFoundException {

//        if( DataStore.METADATA_ENVELOPE.equalsIgnoreCase(name) ) {

//            try {

//                return this.getEnvelope();

//            } catch (DataException e) {

//                return null;

//            }

//        } else {

//            if( DataStore.METADATA_CRS.equalsIgnoreCase(name) ) {

//                IProjection pro = DriverStoreParameters.getCRS(this.getDriverParameters());

//                if (pro != null){

//                    return pro;

//                }

//            }

//        }

        return super.getDynValue(name);

    }

    public void resourceChanged(ResourceProvider resource) {

        this.getStoreServices().notifyChange(

            DataStoreNotification.RESOURCE_CHANGED,

            resource);

    }

    public Object getSourceId() {

        return this.getDriverParameters().getFile();

    }

    public String getName() {

        String name = this.getDriverParameters().getFile().getName();

        return FilenameUtils.getBaseName(name);

    }

    public String getFullName() {

        return this.getDriverParameters().getFile().getAbsolutePath();

    }

    public ResourceProvider getResource() {

        return resource;

    }

	private void loadFeatures() throws IOException, DataException,

			CoercionException, CloneNotSupportedException {

		boolean bReadOnly = false;

		boolean bVerbose = false;

		File file = this.getDriverParameters().getFile();

		String pszDataSource = file.getAbsolutePath();

		DataSource poDS = ogr.Open(pszDataSource, !bReadOnly);

	    if (poDS == null && !bReadOnly){

	        poDS = ogr.Open(pszDataSource, false);

	        if (poDS == null && bVerbose){

	        	logger.warn( "Had to open data source read-only.");

	        }

	    }

	   if(poDS == null){	

		   logger.warn(file +" -> Unable to open datasource " + 

        		 "with the available drivers.");

	     if(ogr.GetDriverCount() == 0){

	    	 logger.warn("ERROR: no drivers availables");

	     }

	   }

	    if(poDS != null){ 

	    	Driver poDriver = poDS.GetDriver();

	    	logger.warn(file + " -> Opened using driver '" + poDriver.GetName() + "' successfully.");

	    	// Initialize the feature types

	    	FeatureStoreProviderServices store = this.getStoreServices();

	    	for(int ij=0; ij<poDS.GetLayerCount(); ij++){

		    	Layer layer = poDS.GetLayer(ij);

		    	FeatureDefn layerDef = layer.GetLayerDefn();

		    	String[] headers = new String[layerDef.GetFieldCount()];

		    	int[] types = new int[layerDef.GetFieldCount()];

		    	for(int ji=0; ji<layerDef.GetFieldCount(); ji++){

		    		headers[ji] = layerDef.GetFieldDefn(ji).GetName(); 

		    		types[ji]  = layerDef.GetFieldDefn(ji).GetFieldType();

		    	}

		    	EditableFeatureType edftype = this.getFeatureType(headers, types);

		    	String geomColumn = layer.GetGeometryColumn();

		    	if(!StringUtils.isBlank(geomColumn)){

		    		edftype.setDefaultGeometryAttributeName(layer.GetGeometryColumn());

		    	}else{

		    		edftype.setDefaultGeometryAttributeName("GEOM");

		    	}

	            FeatureType ftype = edftype.getNotEditableCopy();

	            List<FeatureType> ftypes = new ArrayList<FeatureType>();

	            ftypes.add(ftype);

	            store.setFeatureTypes(ftypes, ftype);

	            if ( ftype.getDefaultGeometryAttributeName() != null ) {

	                this.need_calculate_envelope = true;

	            }

	            taskStatus.message("_loading");

	            int count = 0;

	            int count_errors = 0;

	            boolean ignore_errors = false;

	            if(layer.GetFeatureCount()>0){

		            org.gdal.ogr.Feature row = layer.GetNextFeature();

		            while ( row != null ) {

		                taskStatus.setCurValue(++count);

		                FeatureProvider feature = this.createFeatureProvider(ftype);

		                for ( int i = 0; i < row.GetFieldCount(); i++ ) {

		                    try {

		                        feature.set(i, this.getFieldValue(row, i));

		                    } catch (RuntimeException ex) {

		                        if ( !ignore_errors ) {

		                            throw ex;

		                        }

		                        if ( count_errors++ < 10 ) {

		                            logger.warn("Can't load value of attribute " + i + " in row " + count + ".", ex);

		                        }

		                        if ( count_errors == 10 ) {

		                            logger.info("Too many errors, suppress messages.");

		                        }

		                    }

		                }

		                org.gdal.ogr.Geometry geom = row.GetGeometryRef();

	                    if(geom != null){

	                    	Geometry geometry;

							try {

								geometry = GeometryLocator.getGeometryManager().createFrom(geom.ExportToWkt());

								feature.setDefaultGeometry(geometry);

							} catch (CreateGeometryException e) {

								// TODO Auto-generated catch block

								e.printStackTrace();

							} catch (LocatorException e) {

								// TODO Auto-generated catch block

								e.printStackTrace();

							} catch (GeometryException e) {

								// TODO Auto-generated catch block

								e.printStackTrace();

							}

	                    }

		                this.addFeatureProvider(feature);

		                row = layer.GetNextFeature();

		            }

	            }

	            taskStatus.terminate();

	    	}

	    }

	}

    private Object getFieldValue(org.gdal.ogr.Feature row, int i) {

		int gdalType = row.GetDefnRef().GetFieldDefn(i).GetFieldType();

		switch(this.getFieldType(gdalType)){

			case DataTypes.STRING:

				return row.GetFieldAsString(i);

			case DataTypes.INT:

				return row.GetFieldAsInteger(i);

			default:

				return row.GetFieldAsString(i);

		}

	}

	private EditableFeatureType getFeatureType(String headers[], int automaticTypes[]) {

        EditableFeatureType fType = getStoreServices().createFeatureType(this.getName());

        fType.setHasOID(true);

        DataTypesManager dataTypesManager = ToolsLocator.getDataTypesManager();

        FieldTypeParser[] fieldTypes = new FieldTypeParser[headers.length];

        //

        // Calculamos cuales pueden ser los tipos de datos

        //

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

            fieldTypes[i] = new FieldTypeParser(headers[i], this.getFieldType(automaticTypes[i]));

        }

        //

        // Una vez ya sabemos los tipos de datos rellenamos el feature-type

        //

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

            EditableFeatureAttributeDescriptor fad = fType.add(

                    fieldTypes[i].name,

                    fieldTypes[i].type

            );

            fad.setSize(fieldTypes[i].size);

            fad.setAllowNull(fieldTypes[i].allowNulls);

            if ( fieldTypes[i].type == DataTypes.GEOMETRY

                    && fType.getDefaultGeometryAttributeName() == null ) {

                fType.setDefaultGeometryAttributeName(fieldTypes[i].name);

            }

        }

        EditableFeatureAttributeDescriptor attr = fType.add("GEOM", DataTypes.GEOMETRY);

        GeometryManager geommgr = GeometryLocator.getGeometryManager();

        GeometryType gt;

        try {

        	gt = geommgr.getGeometryType(Geometry.TYPES.GEOMETRY, Geometry.SUBTYPES.GEOM3D);

        	attr.setGeometryType(gt);

        } catch (Exception e) {

        	logger.warn("Can't set geometry type for the calculated field in GPX file '" + getFullFileName() + "'.", e);

        }

        return fType;

    }

	private int getFieldType(int gdalType) {

		switch(gdalType){

			case 2:

				return DataTypes.FLOAT;

			case 11:

				return DataTypes.DATE;

			case 4: 

				return DataTypes.STRING;

			default: 

				return DataTypes.STRING; 

		}

	}

	public String getDriver(int index){

		return ogr.GetDriver(index).getName();

	}

	public int getDriverCount(){

		return ogr.GetDriverCount();

	}

	 public List<String> getAvailableDrivers(){

		 List<String> aux = new ArrayList<String>();

	     for(int iDriver = 0; iDriver < ogr.GetDriverCount(); iDriver++ ){

	         aux.add( ogr.GetDriver(iDriver).GetName() );

	     }

	     return aux;

	 }

	 public String getOGRVersion(){

		 return gdal.VersionInfo();

	 }

	 private class FieldTypeParser {

	        public String name = null;

	        public int type = DataTypes.STRING;

	        public int size = 0;

	        public boolean allowNulls = true;

	        private String typename = "string";

	        FieldTypeParser(String name, int type) {

	        	this.name = name;

	        	this.type = type;

	        }

	        private int getType(String value) {

	            DataTypesManager dataTypesManager = ToolsLocator.getDataTypesManager();

	            return dataTypesManager.getType(typename);

	        }

	        // El formato seria:

	        //   name[:typename[:size[:notnull|null]]]

	        //   name[__typename[__size[__notnull|null]]]

	        //

	        public boolean parse(String value) {

	            String typename = null;

	            String[] ss = null;

	            if ( value.contains(":") ) {

	                ss = value.split(":");

	            } else if ( value.contains("__") ) {

	                ss = value.split("__");

	            }

	            if ( ss == null ) {

	                this.name = value;

	                return true;

	            }

	            switch (ss.length) {

	            case 4:

	                if ( ss[3].length() > 0 ) {

	                    if ( "notnull".equalsIgnoreCase(ss[3]) ) {

	                        this.allowNulls = false;

	                    } else {

	                        this.allowNulls = true;

	                    }

	                }

	            case 3:

	                if ( ss[2].length() > 0 ) {

	                    try {

	                        this.size = Integer.parseInt(ss[2]);

	                    } catch (Exception ex) {

	                        logger.warn("Ignore incorrect field size for field " + value + " in JExcel header of '" + getFullFileName() + "'.", ex);

	                    }

	                }

	            case 2:

	                if ( ss[1].length() > 0 ) {

	                    this.typename = ss[1];

	                    this.type = this.getType(this.typename);

	                    if ( this.type == DataTypes.INVALID ) {

	                        this.type = DataTypes.STRING;

	                        logger.info("Type '" + typename + "' not valid for attribute '" + value + "' in JExcel file '" + getFullFileName() + "'.");

	                    }

	                }

	            case 1:

	                this.name = ss[0];

	                break;

	            }

	            if ( this.type != DataTypes.STRING ) {

	                this.size = 0;

	            }

	            return true;

	        }

	    }

}

package org.gvsig.fmap.dal.store.gpx;

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

public class UnsupportedOGRVersionException extends DataException {

	/**

	 *

	 */

	private static final long serialVersionUID = -7335241420683266251L;

	private final static String MESSAGE_FORMAT = "Unssuported version of Driver of file '%(file)'. Try to convert using Autodesk convertor from '%(autodeskurl)'";

	private final static String MESSAGE_KEY = "_UnsupportedDriverVersionException";

	public final static String AUTODESK_URL = "http://usa.autodesk.com/adsk/servlet/item?siteID=123112&id=7024151";

	public UnsupportedOGRVersionException(String file,

			Throwable cause) {

		super(MESSAGE_FORMAT, cause, MESSAGE_KEY, serialVersionUID);

		setValue("file", file);

		setValue("autodeskurl", AUTODESK_URL);

	}

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

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

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.dal.store.gpx;

import org.gvsig.fmap.dal.DataParameters;

import org.gvsig.fmap.dal.DataStoreProvider;

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

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

import org.gvsig.fmap.dal.feature.spi.AbstractFeatureStoreProviderFactory;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

import org.gvsig.tools.dynobject.DynObject;

public class OGRStoreProviderFactory extends AbstractFeatureStoreProviderFactory implements FeatureStoreProviderFactory{

	public OGRStoreProviderFactory(String name, String description) {

		super(name, description);

	}

	public DataStoreProvider createProvider(DataParameters parameters,

			DataStoreProviderServices providerServices)

			throws InitializeException {

		return new OGRStoreProvider((OGRStoreParameters) parameters, providerServices);

	}

	public DynObject createParameters() {

		return new OGRStoreParameters();

	}

	public int allowCreate() {

		return NO;

	}

	public int allowWrite() {

		return NO;

	}

	public int allowRead() {

		return YES;

	}

	public int hasRasterSupport() {

		return NO;

	}

	public int hasTabularSupport() {

		return YES;

	}

	public int hasVectorialSupport() {

		return YES;

	}

	public int allowMultipleGeometryTypes() {

		return YES;

	}

	public int allowEditableFeatureType() {

		return NO;

	}

}

/* 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 IVER T.I. S.A.   {{Task}}

*/

package org.gvsig.fmap.dal.store.gpx;

import java.io.File;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.FileHelper;

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

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

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemStoreParameters;

import org.gvsig.fmap.dal.spi.AbstractDataParameters;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

import org.gvsig.tools.dynobject.DelegatedDynObject;

public class OGRStoreParameters extends AbstractDataParameters implements

		DataStoreParameters, FilesystemStoreParameters,

		NewFeatureStoreParameters {

	public static final String PARAMETERS_DEFINITION_NAME = "OGRStoreParameters";

	private static final String FIELD_FILE = "file";

	private static final String FIELD_CRS = "CRS";

	private static final String FIELD_DRIVER = "Driver";

	private DelegatedDynObject parameters;

	public OGRStoreParameters() {

		this(PARAMETERS_DEFINITION_NAME);

	}

	protected OGRStoreParameters(String parametersDefinitionName) {

		this(parametersDefinitionName, OGRStoreProvider.NAME);

	}

	public OGRStoreParameters(String parametersDefinitionName, String name) {

		super();

		this.parameters = (DelegatedDynObject) FileHelper.newParameters(parametersDefinitionName);

		this.setDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME,

						name);

	}

	protected DelegatedDynObject getDelegatedDynObject() {

		return parameters;

	}

	public String getDataStoreName() {

		return (String) this

				.getDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME);

	}

	public String getDescription() {

		return this.getDynClass().getDescription();

	}

	public void setCRS(IProjection crs) {

		setDynValue(FIELD_CRS, crs);

	}

	public void setCRS(String crs) {

		setDynValue(FIELD_CRS, crs);

	}

	public IProjection getCRS() {

		return (IProjection) getDynValue(FIELD_CRS);

	}

	public void setDriver(String driver) {

		setDynValue(FIELD_DRIVER, driver);

	}

	public String getDriver() {

		return (String) getDynValue(FIELD_DRIVER);

	}

	public String getFileName() {

		return this.getFile().getPath();

	}

	public void setFileName(String file) {

		setDynValue(FIELD_FILE, file);

	}

	public boolean isValid() {

		if (getCRS() == null) {

			return false;

		}

		if (getFile() == null) {

			return false;

		}

		return true;

	}

	public File getFile() {

		return (File) this.getDynValue(FIELD_FILE);

	}

	public void setFile(File file) {

		this.setDynValue(FIELD_FILE, file);

	}

	public EditableFeatureType getDefaultFeatureType() {

		return null; //TODO ????

	}

	public void setDefaultFeatureType(FeatureType defaultFeatureType) {

		throw new UnsupportedOperationException();

	}

}

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

* 2009 {Iver T.I.}   {Task}

*/

package org.gvsig.fmap.dal.store.gpx;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.dal.DALFileLibrary;

import org.gvsig.fmap.dal.DALFileLocator;

import org.gvsig.fmap.dal.DALLibrary;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.FileHelper;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

import org.gvsig.metadata.MetadataLibrary;

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class OGRLibrary extends AbstractLibrary {

	private static final Logger logger = LoggerFactory.getLogger(OGRLibrary.class);

	@Override

    public void doRegistration() {

        registerAsImplementationOf(OGRLibrary.class);

        require(DALLibrary.class);

        require(DALFileLibrary.class);

        require(MetadataLibrary.class);

    }

	@Override

	protected void doInitialize() throws LibraryException {

	}

	@Override

	protected void doPostInitialize() throws LibraryException {

		List<Throwable> exs = new ArrayList<Throwable>();

		FileHelper.registerParametersDefinition(

				OGRStoreParameters.PARAMETERS_DEFINITION_NAME, 

				OGRStoreParameters.class,

				"OGRParameters.xml"

		);

		try {

			FileHelper.registerMetadataDefinition(

					OGRStoreProvider.METADATA_DEFINITION_NAME, 

					OGRStoreProvider.class,

					"OGRMetadata.xml"

			);

		} catch (MetadataException e) {

			throw new LibraryException(getClass(), e);

		}

		DataManagerProviderServices dataman = (DataManagerProviderServices) DALLocator

				.getDataManager();

		try {

			if (!dataman.getStoreProviders().contains(OGRStoreProvider.NAME)) {

				dataman.registerStoreProviderFactory(new OGRStoreProviderFactory(OGRStoreProvider.NAME, OGRStoreProvider.DESCRIPTION));

			}

		} catch (RuntimeException e) {

			exs.add(e);

		}

		DALFileLocator.getFilesystemServerExplorerManager().registerProvider(

				OGRStoreProvider.NAME, OGRStoreProvider.DESCRIPTION,

				OGRFilesystemServerProvider.class);

		DynObjectManager dynMan = ToolsLocator.getDynObjectManager();

		DynClass dynClass = dynMan.get(

				OGRStoreProvider.METADATA_DEFINITION_NAME);

		DynField field;

		if (dynClass == null) {

			dynClass = dynMan.add(

					OGRStoreProvider.METADATA_DEFINITION_NAME);

		}

		if (exs.size() > 0) {

			throw new LibraryException(this.getClass(), exs);

		}

	}

}

package org.gvsig.fmap.dal.store.gpx;

import java.io.File;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.NewDataStoreParameters;

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

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

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

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

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

import org.gvsig.fmap.dal.resource.spi.ResourceConsumer;

import org.gvsig.fmap.dal.resource.spi.ResourceProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.impl.AbstractFilesystemServerExplorerProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerProviderServices;

public class OGRFilesystemServerProvider extends AbstractFilesystemServerExplorerProvider 

	implements FilesystemServerExplorerProvider, ResourceConsumer {

	//private FilesystemServerExplorerProviderServices serverExplorer;

	public String getDataStoreProviderName() {

		return OGRStoreProvider.NAME;

	}

	public int getMode() {

		return DataServerExplorer.MODE_FEATURE | DataServerExplorer.MODE_GEOMETRY;

	}

	public boolean accept(File pathname) {

		return (pathname.getName().toLowerCase().endsWith(".gpx"));

		//return true;

	}

	public String getDescription() {

		return OGRStoreProvider.DESCRIPTION;

	}

	public DataStoreParameters getParameters(File file) throws DataException {

		DataManager manager = DALLocator.getDataManager();

		OGRStoreParameters params = (OGRStoreParameters) manager

				.createStoreParameters(this

				.getDataStoreProviderName());

		params.setFileName(file.getPath());

		return params;

	}

	public boolean canCreate() {

		return true;

	}

	public boolean canCreate(NewDataStoreParameters parameters) {

		if (!(parameters instanceof OGRStoreParameters)) {

			throw new IllegalArgumentException(); // FIXME ???

		}

		OGRStoreParameters driverParams = (OGRStoreParameters) parameters;

		// TODO comporbar si el ftype es correcto (para este formato es fijo)

		File file = new File(driverParams.getFileName());

		if (driverParams.getCRS() == null) {

			return false;

		}

		// TODO comprobamos extension del fichero ??

		if (file.exists()) {

			return file.canWrite();

		} else {

			return file.getParentFile().canWrite();

		}

	}

	public void create(NewDataStoreParameters parameters, boolean overwrite)

			throws CreateException {

		// FIXME Exception

		throw new UnsupportedOperationException();

	}

	public NewDataStoreParameters getCreateParameters() throws DataException {

		return (NewFeatureStoreParameters) DALLocator.getDataManager()

				.createStoreParameters(this.getDataStoreProviderName());

	}

	public void initialize(

			FilesystemServerExplorerProviderServices serverExplorer) {

		//this.serverExplorer = serverExplorer;

	}

	public void remove(DataStoreParameters parameters) throws RemoveException {

		File file = new File(((OGRStoreParameters) parameters).getFileName());

		if (!file.exists()) {

			throw new RemoveException(this.getDataStoreProviderName(),

					new FileNotFoundException(file));

		}

		if (!file.delete()) {

			// FIXME throws ???

		}

	}

	public boolean closeResourceRequested(ResourceProvider resource) {

		// while it is using a resource anyone can't close it

		return false;

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see

	 * org.gvsig.fmap.dal.resource.spi.ResourceConsumer#resourceChanged(org.

	 * gvsig.fmap.dal.resource.spi.ResourceProvider)

	 */

	public void resourceChanged(ResourceProvider resource) {

		//Do nothing

	}

}

<?xml version= "1.0 "?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="OGRStoreParameters">

       <extends>

      	<class namespace="dal" name="ProviderParameters"/>

      </extends>

      <description>Store the parameters need to open a OGR file</description>

      <fields>

        <field name="File" type="file" mandatory="true" group="Basic">

          <description>Driver file</description>

        </field>

        <field name="Driver" type="string" mandatory="false" defaultValue="" group="Basic">

          <description>Sets the driver needed to open.</description>

        </field>

      </fields>

    </class>

  </classes>

</definitions>  

<?xml version="1.0"?>

<!--

Definitions of metadata fields of a shp file.  

 -->

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="OGR_DRIVER" namespace="Metadata">

      <extends>

      	<class namespace="Metadata" name="SpatialProvider"/>

      </extends>

      <description>Metadata of a OGR store</description>

      <fields>

      </fields>

    </class>

  </classes>

</definitions>  

org.gvsig.fmap.dal.store.gpx.OGRLibrary

<?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/xsd/maven-4.0.0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<artifactId>org.gvsig.gdal.gpx</artifactId>

	<packaging>jar</packaging>

	<name>org.gvsig.gdal.gpx</name>

	<parent>

		<groupId>org.gvsig</groupId>

		<artifactId>org.gvsig.gdal</artifactId>

		<version>1.0.16-SNAPSHOT</version>

	</parent>

	<dependencies>

	    <dependency>

		  <groupId>org.gdal</groupId>

		  <artifactId>gdal</artifactId>

		</dependency>

		<dependency>

			<groupId>commons-io</groupId>

			<artifactId>commons-io</artifactId>

			<scope>compile</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.projection.api</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.metadata.lib.basic.api</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.utils</artifactId>

			<scope>compile</scope>

		</dependency>

		<dependency>

			<groupId>org.gvsig</groupId>

			<artifactId>org.gvsig.fmap.dal.file.lib</artifactId>

			<scope>compile</scope>

		</dependency>

	</dependencies>

	<modules>

	</modules>

</project>

<assembly>

  <id>gvsig-plugin-package</id>

  <formats>

    <format>zip</format>

  </formats>

  <baseDirectory>${project.artifactId}</baseDirectory>

  <includeBaseDirectory>true</includeBaseDirectory>

  <files>

    <file>

      <source>target/${project.artifactId}-${project.version}.jar</source>

      <outputDirectory>lib</outputDirectory>

    </file>

    <file>

      <source>target/package.info</source>

    </file>

  </files>

  <fileSets>

    <fileSet>

      <directory>src/main/resources-plugin</directory>

      <outputDirectory>.</outputDirectory>

    </fileSet>

  </fileSets>

  <dependencySets>

    <dependencySet>

      <useProjectArtifact>false</useProjectArtifact>

      <useTransitiveDependencies>false</useTransitiveDependencies>

      <outputDirectory>lib</outputDirectory>

      <includes>

      	<include>org.gvsig:org.gvsig.gdal.gpx</include>

      </includes>

    </dependencySet>

  </dependencySets>

</assembly>

/* 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.gdal.app.gpx.gui;

import java.awt.FlowLayout;

import java.awt.GridBagConstraints;

import java.awt.GridBagLayout;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import java.io.File;

import java.net.URL;

import java.util.List;

import javax.swing.JButton;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTextArea;

import org.gdal.gdal.gdal;

import org.gdal.ogr.DataSource;

import org.gdal.ogr.Feature;

import org.gdal.ogr.FeatureDefn;

import org.gdal.ogr.FieldDefn;

import org.gdal.ogr.Layer;

import org.gdal.ogr.ogr;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.ui.mdiManager.IWindow;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.gui.WizardPanel;

import org.gvsig.app.gui.wizards.WizardListener;

import org.gvsig.app.gui.wizards.WizardListenerSupport;

import org.gvsig.app.project.ProjectManager;

import org.gvsig.app.project.documents.view.ViewDocument;

import org.gvsig.app.project.documents.view.gui.AbstractViewPanel;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

import org.gvsig.fmap.dal.store.gpx.OGRStoreParameters;

import org.gvsig.fmap.dal.store.gpx.OGRStoreProvider;

import org.gvsig.fmap.dal.store.gpx.OGRStoreProviderFactory;

import org.gvsig.fmap.mapcontext.exceptions.LoadLayerException;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.gdal.app.gpx.gui.utils.JFileField;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Wizard panel to add a new OSM raster layer

 * @author Jos? Bad?a (jbadia@scolab.es)

 */

public class GPXWizard extends WizardPanel implements MouseListener {

	private static final long           serialVersionUID      = 1L;

	private static final String         TAB_NAME              = "GDAL/OGR";

	private static Logger               logger                = LoggerFactory.getLogger(GPXWizard.class.getName());

	private AbstractViewPanel           view                  = null;

	private WizardListenerSupport       listenerSupport       = null;

	private JPanel chooserPanel;

	private JPanel jPanel1;

	private JFileField cmbHost;

	private JButton btnConnect;

	private JPanel jPanel;

	private JScrollPane jScrollPane;

	private JTextArea txtAbstract;

	private JPanel pnlName;

	private JLabel jLabel1;

	private JLabel lblTitle;

	private DataSource poDS = null;

	private File file = null;

	private OGRStoreParameters ogrStoreParameters;

	public GPXWizard() {

		super();

		initialize();

	}

	/**

	 * This method initializes this

	 *

	 * @return void

	 */

	private void initialize() {

		setTabName(PluginServices.getText(this, TAB_NAME));

		setLayout(new GridBagLayout());

		gdal.AllRegister();

		ogr.RegisterAll();

		IWindow iw = PluginServices.getMDIManager().getActiveWindow();

		if (iw == null) {

			return;

		}

		if (!(iw instanceof AbstractViewPanel)) {

			return;

		}

		view = (AbstractViewPanel) iw;

		setMapCtrl(view.getMapControl());

		GridBagConstraints gridBagConstraints = new GridBagConstraints();

		gridBagConstraints.fill = GridBagConstraints.BOTH;

		gridBagConstraints.weightx = 1.0;

		gridBagConstraints.weighty = 1.0;

		gridBagConstraints.gridx = 0;

		gridBagConstraints.gridy = 0;

		add(getFileChooserPanel(), gridBagConstraints);

		gridBagConstraints.weightx = 1.0;

		gridBagConstraints.gridy = 1;

		gridBagConstraints.weighty = 4;

		add(getDescriptionPanel(), gridBagConstraints);

	}

	private WizardListenerSupport getWizardListenerSupport() {

		if(listenerSupport == null)

			listenerSupport = new WizardListenerSupport();

		return listenerSupport;

	}

	/**

	 * This method checks for the options selected within the configuration

	 * dialog are correct.

	 *

	 * @return true if you're done, false if not.

	 */

	public boolean areSettingsValid() {