Application: gvSIG desktop » gvSIG data provider for DXF

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

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

import org.gvsig.fmap.dal.store.dxf.DXFStoreProvider;

import org.gvsig.fmap.dal.store.dxf.LegendBuilder;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynMethod;

import org.gvsig.tools.dynobject.DynObject;

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

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

public class DXFGetLabeling implements DynMethod {

	private static Integer code = null;

	static void register(DynClass dxfLegendDynClass) {

		if (code != null) {

			return;

		}

		code = new Integer(ToolsLocator.getDynObjectManager()

				.registerDynMethod(dxfLegendDynClass, new DXFGetLabeling()));

	}

	public int getCode() throws DynMethodNotSupportedException {

		return code.intValue();

	}

	public String getDescription() {

		return "DXF Labeling";

	}

	public String getName() {

		return LegendBuilder.DYNMETHOD_GETLABELING_NAME;

	}

	public Object invoke(Object self, DynObject context)

			throws DynMethodException {

		try {

			return ((DXFStoreProvider) self).getLabeling();

		} catch (OpenException e) {

			//FIXME

			throw new RuntimeException(e);

		}

	}

}

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

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

import org.gvsig.fmap.dal.store.dxf.DXFStoreProvider;

import org.gvsig.fmap.dal.store.dxf.LegendBuilder;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynMethod;

import org.gvsig.tools.dynobject.DynObject;

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

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

public class DXFGetLegend implements DynMethod {

	private static Integer code = null;

	static void register(DynClass dxfLegendDynClass) {

		if (code != null) {

			return;

		}

		code = new Integer(ToolsLocator.getDynObjectManager()

				.registerDynMethod(dxfLegendDynClass, new DXFGetLegend()));

	}

	public int getCode() throws DynMethodNotSupportedException {

		return code.intValue();

	}

	public String getDescription() {

		return "DXF Legend";

	}

	public String getName() {

		return LegendBuilder.DYNMETHOD_GETLEGEND_NAME;

	}

	public Object invoke(Object self, DynObject context)

			throws DynMethodException {

		try {

			return ((DXFStoreProvider) self).getLegend();

		} catch (OpenException e) {

			//FIXME

			throw new RuntimeException(e);

		}

	}

}

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

import org.gvsig.fmap.dal.DALLibrary;

import org.gvsig.fmap.dal.store.dxf.DXFLibrary;

import org.gvsig.fmap.dal.store.dxf.DXFStoreProvider;

import org.gvsig.metadata.MetadataLibrary;

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

/**

 * @author jmvivo

 *

 */

public class DXFLegendLibrary extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsServiceOf(DALLibrary.class);

        require(DXFLibrary.class);

        require(MetadataLibrary.class);

        require(DALLibrary.class);

    }

	@Override

	protected void doInitialize() throws LibraryException {

	}

	@Override

	protected void doPostInitialize() throws LibraryException {

		DynClass metadataDefinition = (DynClass) MetadataLocator.getMetadataManager()

			.getDefinition(DXFStoreProvider.METADATA_DEFINITION_NAME);

		DXFGetLegendBuilder.register(metadataDefinition);

		DXFGetLegend.register(metadataDefinition);

		DXFGetLabeling.register(metadataDefinition);

	}

}

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

import org.gvsig.fmap.dal.store.dxf.LegendBuilder;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynMethod;

import org.gvsig.tools.dynobject.DynObject;

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

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

public class DXFGetLegendBuilder implements DynMethod {

	private static Integer code = null;

	static void register(DynClass dxfLegendDynClass) {

		if (code != null) {

			return;

		}

		code = new Integer(ToolsLocator.getDynObjectManager()

				.registerDynMethod(

						dxfLegendDynClass, new DXFGetLegendBuilder()));

	}

	public int getCode() throws DynMethodNotSupportedException {

		return code.intValue();

	}

	public String getDescription() {

		return "DXF LegendBuilder creator";

	}

	public String getName() {

		return LegendBuilder.DYNMETHOD_BUILDER_NAME;

	}

	public Object invoke(Object self, DynObject context)

			throws DynMethodException {

		return new DXFLegendBuilder();

	}

}

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

import java.awt.Color;

import org.gvsig.dxf.px.dxf.AcadColor;

import org.gvsig.fmap.dal.DataTypes;

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

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

import org.gvsig.fmap.dal.store.dxf.DXFStoreProvider;

import org.gvsig.fmap.dal.store.dxf.LegendBuilder;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.rendering.legend.IVectorialUniqueValueLegend;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.symbology.SymbologyLocator;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.styling.IAttrInTableLabelingStrategy;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.IFillSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.ILineSymbol;

public class DXFLegendBuilder implements LegendBuilder {

	private MapContextManager mapContextManager = MapContextLocator

			.getMapContextManager();

	private IVectorialUniqueValueLegend defaultLegend = null;

	private IAttrInTableLabelingStrategy labelingStragegy = null;

	public void begin() {

		// Nothing to do

	}

	public void end() {

		defaultLegend.useDefaultSymbol(true);

	}

	public Object getLegend() {

		return defaultLegend;

	}

	public LegendBuilder initialize(FeatureStoreProvider store) {

		defaultLegend = (IVectorialUniqueValueLegend) mapContextManager

				.createLegend(IVectorialUniqueValueLegend.LEGEND_NAME);

		defaultLegend.setShapeType(Geometry.TYPES.GEOMETRY);

		defaultLegend

				.setClassifyingFieldNames(new String[] { DXFStoreProvider.NAME_FIELD_COLOR });

		defaultLegend.setClassifyingFieldTypes(new int[] { DataTypes.INT });

		ISymbol myDefaultSymbol =

				mapContextManager.getSymbolManager().createSymbol(

				Geometry.TYPES.GEOMETRY, Color.BLACK);

		defaultLegend.setDefaultSymbol(myDefaultSymbol);

		defaultLegend.useDefaultSymbol(false);

		labelingStragegy = SymbologyLocator.getSymbologyManager().createAttrInTableLabelingStrategy();

		labelingStragegy.setTextField(DXFStoreProvider.NAME_FIELD_TEXT);

		labelingStragegy

				.setRotationField(DXFStoreProvider.NAME_FIELD_ROTATIONTEXT);

		labelingStragegy.setHeightField(DXFStoreProvider.NAME_FIELD_HEIGHTTEXT);

		labelingStragegy.setUnit(1); // MapContext.NAMES[1] (meters)

		return this;

	}

	public void process(FeatureProvider feature) {

		Integer clave = (Integer) feature.get("Color");

		if (clave == null) {

			return;

		}

		if (defaultLegend.getSymbolByValue(clave) == null) {

			ISymbol theSymbol;

			Color color = null;

			try {

				color = AcadColor.getColor(clave.intValue());

			} catch (ArrayIndexOutOfBoundsException e) {

				color = AcadColor.getColor(255);

			}

			// jaume, moved to ISymbol

			theSymbol =

					mapContextManager.getSymbolManager().createSymbol(

							Geometry.TYPES.GEOMETRY,

					color);

			theSymbol.setDescription(clave.toString());

			// Asigna los colores de Autocad a los

			// bordes de los pol?gonos y pone el relleno transparente.

			if (theSymbol instanceof IFillSymbol) {

				((IFillSymbol) theSymbol).getOutline().setLineColor(color);

				Color fillColor = new Color(color.getRed(), color.getGreen(), color.getBlue(), 0);

				((IFillSymbol) theSymbol).setFillColor(fillColor);

			}

			// Asigna los colores de Autocad a las l?neas

			if (theSymbol instanceof ILineSymbol) {

				((ILineSymbol) theSymbol).setLineColor(color);

			}

			if (theSymbol != null) {

				defaultLegend.addSymbol(clave, theSymbol);

			}

		}

	}

	public Object getLabeling() {

		return labelingStragegy;

	}

}

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

<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.dxf.provider.legend</artifactId>

  <packaging>jar</packaging>

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

  <description>DAL provider for dxf files</description>

  <parent>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.dxf</artifactId>

      <version>2.0.30</version>

  </parent>

  <dependencies>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.dxf.provider</artifactId>

      <scope>compile</scope>

    </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.fmap.mapcontext.api</artifactId>

        <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.dxf.provider</artifactId>

        <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.symbology.lib.api</artifactId>

        <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.timesupport.lib.api</artifactId>

        <scope>compile</scope>

    </dependency>  

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.utils</artifactId>

      <scope>compile</scope>

    </dependency>

    <!-- TESTS -->

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.tools.lib</artifactId>

      <type>test-jar</type>

      <scope>test</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.compat.se</artifactId>

      <scope>test</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.fmap.dal.impl</artifactId>

      <scope>test</scope>

    </dependency>

    <!--

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.fmap.geometry.generalpath</artifactId>

      <scope>test</scope>

    </dependency>

    -->

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.projection.cresques.impl</artifactId>

      <scope>test</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.timesupport.lib.impl</artifactId>

      <scope>test</scope>

    </dependency>   

  </dependencies>

</project>

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

import java.util.List;

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 DXFStoreProviderFactory extends AbstractFeatureStoreProviderFactory implements FeatureStoreProviderFactory{

	protected DXFStoreProviderFactory(String name, String description) {

		super(name, description);

	}

	public DataStoreProvider createProvider(DataParameters parameters,

			DataStoreProviderServices providerServices)

			throws InitializeException {

		return new DXFStoreProvider((DXFStoreParameters) parameters, providerServices);

	}

	public DynObject createParameters() {

		return new DXFStoreParameters();

	}

	public int allowCreate() {

		return YES;

	}

	public int allowWrite() {

		return YES;

	}

	public int allowRead() {

		return YES;

	}

	public int hasRasterSupport() {

		return NO;

	}

	public int hasTabularSupport() {

		return YES;

	}

	public int hasVectorialSupport() {

		return YES;

	}

	public int allowMultipleGeometryTypes() {

		return NO;

	}

	public int allowEditableFeatureType() {

		return NO;

	}

}

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

import java.io.File;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

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.fmap.geom.Geometry;

import org.gvsig.tools.dynobject.DelegatedDynObject;

public class DXFStoreParameters extends AbstractDataParameters implements

		DataStoreParameters, FilesystemStoreParameters,

		NewFeatureStoreParameters {

    public static final String PARAMETERS_DEFINITION_NAME = "DXFStoreParameters";

    private static final String FILE_PARAMTER_NAME = "File";

    private static final String CRS_PARAMTER_NAME = "CRS";

	private DelegatedDynObject parameters;

	public DXFStoreParameters() {

		this(PARAMETERS_DEFINITION_NAME);

	}

	protected DXFStoreParameters(String parametersDefinitionName) {

		this(parametersDefinitionName, DXFStoreProvider.NAME);

	}

	public DXFStoreParameters(String parametersDefinitionName, String name) {

		super();

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

		this.setDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME, name);

	}

	public String getDataStoreName() {

		return (String) this.getDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME);

	}

	public String getDescription() {

		return this.getDynClass().getDescription();

	}

	protected DelegatedDynObject getDelegatedDynObject() {

		return parameters;

	}

	public void setCRS(String srs) {

		setDynValue(CRS_PARAMTER_NAME, srs);

	}

	public void setCRS(IProjection srs) {

		setDynValue(CRS_PARAMTER_NAME, srs);

	}

	public IProjection getCRS() {

		return (IProjection) getDynValue(CRS_PARAMTER_NAME);

	}

	public String getFileName() {

		if( this.getFile() == null ) {

			return null;

		}

		return this.getFile().getPath();

	}

	public boolean isValid() {

		if (getCRS() == null ) {

			return false;

		}

		if (getFileName() == null) {

			return false;

		}

		return true;

	}

	public File getFile() {

		return (File) this.getDynValue(FILE_PARAMTER_NAME);

	}

	public void setFile(File file) {

		this.setDynValue(FILE_PARAMTER_NAME, file);

	}

	public void setFile(String file) {

		this.setDynValue(FILE_PARAMTER_NAME, file);

	}

	public EditableFeatureType getDefaultFeatureType() {

		// FIXME: Esto no se si funciona.

    	DataManager manager = DALLocator.getDataManager();

    	EditableFeatureType featureType = manager.createFeatureType();

		DXFStoreProvider.initializeFeatureType(featureType, null, Geometry.SUBTYPES.GEOM3D);

		return featureType;

	}

	public void setDefaultFeatureType(FeatureType defaultFeatureType) {

		throw new UnsupportedOperationException();

	}

}

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

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

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

public interface LegendBuilder {

	final public static String DYNMETHOD_BUILDER_NAME = "getLegendBuilder";

	final public static String DYNMETHOD_GETLEGEND_NAME = "getLegend";

	final public static String DYNMETHOD_GETLABELING_NAME = "getLabeling";

	public LegendBuilder initialize(FeatureStoreProvider store);

	public void begin();

	public void process(FeatureProvider feature);

	public void end();

	public Object getLegend();

	public Object getLabeling();

}

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

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.exceptions.MetadataException;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

public class DXFLibrary extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsServiceOf(DALLibrary.class);

        require(DALFileLibrary.class);

    }

	@Override

	protected void doInitialize() throws LibraryException {

	}

	@Override

	protected void doPostInitialize() throws LibraryException {

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

		FileHelper.registerParametersDefinition(

				DXFStoreParameters.PARAMETERS_DEFINITION_NAME,

				DXFStoreParameters.class, "DXFParameters.xml");

		try {

			FileHelper.registerMetadataDefinition(

					DXFStoreProvider.METADATA_DEFINITION_NAME,

					DXFStoreProvider.class, "DXFMetadata.xml");

		} catch (MetadataException e) {

			exs.add(e);

		}

		DataManagerProviderServices dataman = (DataManagerProviderServices) DALLocator

				.getDataManager();

		try {

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

				dataman.registerStoreProviderFactory(new DXFStoreProviderFactory(DXFStoreProvider.NAME, DXFStoreProvider.DESCRIPTION));

			}

		} catch (RuntimeException e) {

			exs.add(e);

		}

		try {

			DALFileLocator.getFilesystemServerExplorerManager()

					.registerProvider(DXFStoreProvider.NAME,

							DXFStoreProvider.DESCRIPTION,

							DXFFilesystemServerProvider.class);

		} catch (RuntimeException e) {

			exs.add(e);

		}

		if (exs.size() > 0) {

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

		}

	}

}

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

import java.io.File;

import java.io.IOException;

import org.cresques.cts.IProjection;

import org.gvsig.dxf.io.DxfFile;

import org.gvsig.dxf.px.dxf.DxfEntityMaker;

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

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

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

import org.gvsig.fmap.dal.resource.ResourceAction;

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

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 DXFFilesystemServerProvider extends AbstractFilesystemServerExplorerProvider 

	implements FilesystemServerExplorerProvider, ResourceConsumer {

	private FilesystemServerExplorerProviderServices serverExplorer;

	public String getDataStoreProviderName() {

		return DXFStoreProvider.NAME;

	}

	public int getMode() {

		return DataServerExplorer.MODE_FEATURE | DataServerExplorer.MODE_GEOMETRY;

	}

	public boolean accept(File pathname) {

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

	}

	public String getDescription() {

		return DXFStoreProvider.DESCRIPTION;

	}

	public DataStoreParameters getParameters(File file) throws DataException {

		DataManager manager = DALLocator.getDataManager();

		DXFStoreParameters params = (DXFStoreParameters) manager

				.createStoreParameters(this

				.getDataStoreProviderName());

		params.setFile(file.getPath());

		return params;

	}

	public boolean canCreate() {

		return true;

	}

	public boolean canCreate(NewDataStoreParameters parameters) {

		if (!(parameters instanceof DXFStoreParameters)) {

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

		}

		DXFStoreParameters dxfParams = (DXFStoreParameters) parameters;

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

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

		if (dxfParams.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 {

		final IProjection projection = null;

		DXFStoreParameters params = (DXFStoreParameters) parameters;

		File file = params.getFile();

		if (!file.isAbsolute()) {

			throw new AbsolutePathRequiredException(file.getPath());

		}

		if (file.exists()) {

			if (overwrite) {

				if (!file.delete()) {

					throw new CreateException(this.getDataStoreProviderName(),

							new IOException(

							"cannot delete file"));

				}

			} else {

				throw new CreateException(this.getDataStoreProviderName(),

						new IOException(

						"file already exist"));

			}

		}

		//		projection = CRSFactory.getCRS(params.getSRSID());

		final FileResource resource;

		try {

			resource = (FileResource) this.serverExplorer

					.getServerExplorerProviderServices().createResource(

							FileResource.NAME,

					new Object[] { file.getAbsolutePath() });

		} catch (InitializeException e1) {

			throw new CreateException(params.getFileName(), e1);

		}

		resource.addConsumer(this);

		try {

			resource.execute(new ResourceAction() {

				public Object run() throws Exception {

					Builder builder =

							new Builder().initialice(resource.getFileName(),

									projection);

					resource.notifyOpen();

					builder.begin();

					builder.create();

					builder.end();

					resource.notifyClose();

					resource.setData(null); // FIXME: Seguro que hay que ponerlo

											// a null ??

					resource.notifyChanges();

					return null;

				}

			});

		} catch (Exception e) {

			throw new CreateException(params.getFileName(), e);

		} finally {

			resource.removeConsumer(this);

		}

	}

	public class Builder {

		private String fileName;

		private IProjection projection;

		public Builder initialice(String fileName, IProjection projection) {

			this.fileName = fileName;

			this.projection = projection;

			return this;

		}

		public void begin() {

		}

		public void end() {

		}

		public void create() throws IOException {

			DxfEntityMaker entityMaker = new DxfEntityMaker(projection);

			DxfFile dxfFile = new DxfFile(null, fileName, entityMaker);

			dxfFile.setCadFlag(true);

			dxfFile.setDxf3DFlag(false);

			dxfFile.save(fileName);

		}

	}

	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(((DXFStoreParameters) 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

	}

}

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

import java.awt.geom.PathIterator;

import java.awt.geom.Point2D;

import java.io.File;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Vector;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.dxf.geo.Point3D;

import org.gvsig.dxf.io.DxfFile;

import org.gvsig.dxf.io.DxfGroup;

import org.gvsig.dxf.io.DxfGroupVector;

import org.gvsig.dxf.px.IObjList;

import org.gvsig.dxf.px.dxf.DxfEntityMaker;

import org.gvsig.dxf.px.dxf.DxfFeatureMaker;

import org.gvsig.dxf.px.dxf.DxfHeaderManager;

import org.gvsig.dxf.px.gml.Feature;

import org.gvsig.dxf.px.gml.LineString;

import org.gvsig.dxf.px.gml.LineString3D;

import org.gvsig.dxf.px.gml.Point;

import org.gvsig.dxf.px.gml.Polygon;

import org.gvsig.dxf.px.gml.Polygon3D;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

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

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.exception.WriteException;

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

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

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

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

import org.gvsig.fmap.dal.feature.exception.PerformEditingException;

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

import org.gvsig.fmap.dal.resource.exception.AccessResourceException;

import org.gvsig.fmap.dal.resource.exception.ResourceNotifyCloseException;

import org.gvsig.fmap.dal.resource.exception.ResourceNotifyOpenException;

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.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

import org.gvsig.fmap.geom.operation.GeometryOperationContext;

import org.gvsig.fmap.geom.operation.distance.PointDistance;

import org.gvsig.fmap.geom.operation.utils.PointGetAngle;

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

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

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

import org.gvsig.tools.exception.NotYetImplemented;

import org.gvsig.tools.logger.FilteredLogger;

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;

public class DXFStoreProvider extends AbstractMemoryStoreProvider implements

ResourceConsumer {

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

    public static final String NAME = "DXF";

    public static final String DESCRIPTION = "DXF file";

    public static final String METADATA_DEFINITION_NAME = NAME;

    public static final String NAME_FIELD_ID = "ID";

    public static final String NAME_FIELD_GEOMETRY = "Geometry";

    public static final String NAME_FIELD_ENTITY = "Entity";

    public static final String NAME_FIELD_LAYER = "Layer";

    public static final String NAME_FIELD_COLOR = "Color";

    public static final String NAME_FIELD_ELEVATION = "Elevation";

    public static final String NAME_FIELD_THICKNESS = "Thickness";

    public static final String NAME_FIELD_TEXT = "Text";

    public static final String NAME_FIELD_HEIGHTTEXT = "HeightText";

    public static final String NAME_FIELD_ROTATIONTEXT = "Rotation";

    private static final int ID_FIELD_ID = 0;

    private static final int ID_FIELD_GEOMETRY = 1;

    private static final int ID_FIELD_ENTITY = 2;

    private static final int ID_FIELD_LAYER = 3;

    private static final int ID_FIELD_COLOR = 4;

    private static final int ID_FIELD_ELEVATION = 5;

    private static final int ID_FIELD_THICKNESS = 6;

    private static final int ID_FIELD_TEXT = 7;

    private static final int ID_FIELD_HEIGHTTEXT = 8;

    private static final int ID_FIELD_ROTATIONTEXT = 9;

    private IProjection projection;

    private ResourceProvider resource;

    private LegendBuilder legendBuilder;

    private long counterNewsOIDs = 0;

    private Envelope envelope;

    private Writer writer;

    protected GeometryManager geomManager = GeometryLocator.getGeometryManager();

    private SimpleTaskStatus taskStatus;

    public DXFStoreProvider(DXFStoreParameters parameters,

        DataStoreProviderServices storeServices) throws InitializeException {

        super(

            parameters, 

            storeServices,

            FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME)

        );

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

        this.taskStatus = manager.creteDefaultSimpleTaskStatus("DXF");

        counterNewsOIDs = 0;

        //		projection = CRSFactory.getCRS(getParameters().getSRSID());

        File file = getDXFParameters().getFile();

        resource = this.createResource(

            FileResource.NAME,

            new Object[] { file.getAbsolutePath() }

        );

        resource.addConsumer(this);

        this.projection = this.getDXFParameters().getCRS();

        try {

            legendBuilder = (LegendBuilder) this.invokeDynMethod(

                LegendBuilder.DYNMETHOD_BUILDER_NAME, null);

        } catch (DynMethodException e) {

            legendBuilder = null;

        } catch (Exception e) {

            throw new InitializeException(e);

        }

        this.initializeFeatureTypes();

    }

    private DXFStoreParameters getDXFParameters() {

        return (DXFStoreParameters) this.getParameters();

    }

    public String getProviderName() {

        return NAME;

    }

    public boolean allowWrite() {

        return true;

    }

    public Object getLegend() throws OpenException {

        this.open();

        if (legendBuilder == null) {

            return null;

        }

        return legendBuilder.getLegend();

    }

    public Object getLabeling() throws OpenException {

        this.open();

        if (legendBuilder == null) {

            return null;

        }

        return legendBuilder.getLabeling();

    }

    private class DXFData {

        public List data = null;

        public FeatureType defaultFType = null;

        public List fTypes = null;

        public Envelope envelope = null;

        public IProjection projection;

        public LegendBuilder legendBuilder;

        public Envelope getEnvelopeCopy() throws CreateEnvelopeException {

            if (envelope == null) {

                return null;

            }

            Envelope newEnvelope;

            if (envelope.getDimension() == 2) {

                newEnvelope = geomManager.createEnvelope(SUBTYPES.GEOM2D);

            } else {

                newEnvelope = geomManager.createEnvelope(SUBTYPES.GEOM3D);

            }

            newEnvelope.setLowerCorner(envelope.getLowerCorner());

            newEnvelope.setUpperCorner(envelope.getUpperCorner());

            return newEnvelope;

        }

    }

    public void open() throws OpenException {

        if (this.data != null) {

            return;

        }

        openEver();

    }

    private void openEver() throws OpenException {

        try {

            this.taskStatus.add();

            getResource().execute(new ResourceAction() {

                public Object run() throws Exception {

                    DXFData dxfData = null;

                    resource.setData(new HashMap());

                    FeatureStoreProviderServices store = getStoreServices();

                    dxfData = new DXFData();

                    dxfData.data = new ArrayList();

                    data = dxfData.data;

                    counterNewsOIDs = 0;

                    Reader reader = new Reader().initialice(

                        getMemoryProvider(),

                        (File) resource.get(),

                        projection,

                        legendBuilder

                    );

                    reader.begin(store);

                    dxfData.defaultFType = reader.getDefaultType()

                    .getNotEditableCopy();

                    ArrayList types = new ArrayList();

                    Iterator it = reader.getTypes().iterator();

                    EditableFeatureType fType;

                    while (it.hasNext()) {

                        fType = (EditableFeatureType) it.next();

                        if (fType.getId().equals(dxfData.defaultFType.getId())) {

                            types.add(dxfData.defaultFType);

                        } else {

                            types.add(fType.getNotEditableCopy());

                        }

                    }

                    dxfData.fTypes = types;

                    resource.notifyOpen();

                    store.setFeatureTypes(dxfData.fTypes, dxfData.defaultFType);

                    reader.load();

                    dxfData.envelope = reader.getEnvelope();

                    dxfData.legendBuilder = legendBuilder;

                    dxfData.projection = projection;

                    reader.end();

                    resource.notifyClose();

                    ((Map) resource.getData()).put(projection.getAbrev(),

                        dxfData); // OJO la reproyeccion

                    data = dxfData.data;

                    store.setFeatureTypes(dxfData.fTypes, dxfData.defaultFType);

                    legendBuilder = dxfData.legendBuilder;

                    envelope= dxfData.getEnvelopeCopy();

                    // setDynValue("CRS", projection.getAbrev());

                    counterNewsOIDs = data.size();

                    return null;

                }

            });

            this.taskStatus.terminate();

        } catch (Exception e) {

            data = null;

            this.taskStatus.abort();

            try {

                throw new OpenException(resource.getName(), e);

            } catch (AccessResourceException e1) {

                throw new OpenException(getProviderName(), e);

            }

        } finally {

            this.taskStatus.remove();

        }

    }

    public DataServerExplorer getExplorer() throws ReadException {

        DataManager manager = DALLocator.getDataManager();

        FilesystemServerExplorerParameters params;

        try {

            params = (FilesystemServerExplorerParameters) manager

            .createServerExplorerParameters(FilesystemServerExplorer.NAME);

            params.setRoot(this.getDXFParameters().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 void performChanges(Iterator deleteds, Iterator inserteds, Iterator updateds, Iterator originalFeatureTypesUpdated) throws PerformEditingException {

        try {

            this.taskStatus.add();

            taskStatus.message("_preparing");

            getResource().execute(new ResourceAction() {

                public Object run() throws Exception {

                    FeatureSet features = null;

                    DisposableIterator it = null;

                    try {

                        File file = (File) resource.get();

                        String fileName = file.getAbsolutePath();

                        writer = new Writer().initialice(file, projection);

                        features =

                            getStoreServices().getFeatureStore()

                            .getFeatureSet();

                        List newdata = new ArrayList();

                        writer.begin();

                        it = features.fastIterator();

                        taskStatus.setRangeOfValues(0,0);

                        long counter=0;

                        while (it.hasNext()) {

                            taskStatus.setCurValue(counter++);

                            FeatureProvider feature = getStoreServices().getFeatureProviderFromFeature(

                                (org.gvsig.fmap.dal.feature.Feature) it.next());

                            writer.add(feature);

                            if (feature.getOID() == null){

                                logger.warn("feature without OID");

                                feature.setOID(createNewOID());

                            }

                            newdata.add(feature);

                        }

                        data = newdata;

                        writer.end();

                        if (writer.getEnvelope() != null){

                            envelope = writer.getEnvelope().getGeometry().getEnvelope();

                        }

                        resource.notifyChanges();

                        //					counterNewsOIDs = 0;

                    } finally {

                        if (it != null) {

                            it.dispose();

                        }

                        if (features != null) {

                            features.dispose();

                        }

                    }

                    return null;

                }

            });

            this.taskStatus.terminate();

        } catch (Exception e) {

            this.taskStatus.abort();

            throw new PerformEditingException(getResource().toString(), e);

        } finally {

            this.taskStatus.remove();

        }

    }

    public static void initializeFeatureType(EditableFeatureType featureType, IProjection projection, int geometrySubtype){

        featureType.setHasOID(true);

//        ID_FIELD_ID = 0;

        featureType.add(NAME_FIELD_ID, DataTypes.INT)

        .setDefaultValue(Integer.valueOf(0))

        .getIndex();

        EditableFeatureAttributeDescriptor attr = featureType.add(

            NAME_FIELD_GEOMETRY, DataTypes.GEOMETRY);