Application: gvSIG desktop

package org.gvsig.data.datastores.vectorial.file.shp;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.IOException;

import java.nio.channels.FileChannel;

import org.gvsig.data.DataException;

import org.gvsig.data.OpenException;

import org.gvsig.data.ReadException;

import org.gvsig.data.WriteException;

import org.gvsig.data.datastores.vectorial.file.dbf.DBFFeaturesWriter;

import org.gvsig.data.datastores.vectorial.file.dbf.utils.DbaseFileHeader;

import org.gvsig.data.datastores.vectorial.file.shp.utils.SHP;

import org.gvsig.data.datastores.vectorial.file.shp.utils.SHPFileWrite;

import org.gvsig.data.vectorial.Feature;

import org.gvsig.data.vectorial.FeatureStore;

import org.gvsig.data.vectorial.FeatureType;

import org.gvsig.data.vectorial.InitializeWriterException;

import org.gvsig.data.vectorial.UnsupportedEncodingException;

import org.gvsig.fmap.geom.Geometry;

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

public class ShpFeaturesWriter extends DBFFeaturesWriter {

        private File shpFile;

        private String shxPath;

        private String shpPath;

        private int shapeType;

        private int gvSIG_geometryType;

        private SHPFileWrite shpWrite;

        private int[] supportedGeometryTypes;

        private boolean bWriteHeaders=true;

        private Rectangle2D fullExtent;

        private int fileSize;

        public void init(FeatureStore store) throws InitializeWriterException {

                super.init(store);

                SHPStoreParameters parameters=(SHPStoreParameters)store.getParameters();

                shpFile=parameters.getFile();

                setFile(shpFile);

                try {

                        shpWrite = new SHPFileWrite((FileChannel) getWriteChannel(shpPath),

                                        (FileChannel) super.getWriteChannel(shxPath));

                } catch (IOException e) {

                        throw new InitializeWriterException(SHPStore.DATASTORE_NAME,e);

                }

                updateFeatureType(store.getDefaultFeatureType());

        }

        public void postProcess() throws OpenException, WriteException {

                super.postProcess();

                if (fullExtent == null)

                        fullExtent = new Rectangle2D.Double();

                        shpWrite.writeHeaders(fullExtent,

                                        shapeType, numRows, fileSize);

        }

        public void preProcess() throws WriteException, ReadException {

                super.preProcess();

                if (bWriteHeaders){

                                shpWrite.writeHeaders(new Rectangle2D.Double(),

                                        shapeType, 0, 0);

                }

                fullExtent = null;

        }

        public void insertFeature(Feature feature) throws WriteException, UnsupportedEncodingException {

                Geometry theGeom = (Geometry)feature.getDefaultGeometry();

                if (theGeom==null){

                        FeatureType type = feature.getType();

                        theGeom=(Geometry) type.get(type.getDefaultGeometry()).getDefaultValue();

                        if (theGeom == null){

                                theGeom = new NullGeometry();

                        }

                } 

                if (!canWriteGeometry(theGeom.getType())){

                        throw new WriteException("UnsupportedGeometryType: "+ theGeom.getGeometryType().getName(),SHPStore.DATASTORE_NAME);

                }

                super.insertFeature(feature);

                fileSize = shpWrite.writeIGeometry(theGeom);

                Rectangle2D boundsShp = theGeom.getBounds2D();

                if (boundsShp!=null){

                        if (fullExtent == null) {

                                fullExtent = boundsShp;

                        } else {

                                fullExtent.add(boundsShp);

                        }

                }

        }

        public void updateFeatureType(FeatureType featureType) {

                super.updateFeatureType(featureType);

                int type=featureType.getGeometryTypes()[0];

                shapeType = shpWrite.getShapeType(type);

                gvSIG_geometryType = type;

                setSupportedGeometryTypes();

        }

        public void setFile(File f)

        {

                shpPath = f.getAbsolutePath();

                shxPath = SHP.getShxFile(f).getAbsolutePath();

                super.setFile(SHP.getDbfFile(f));

//                dbfPath = SHP.getDbfFile(f).getAbsolutePath();

                shpFile = f;

        }

        private void setSupportedGeometryTypes() {

                switch (gvSIG_geometryType % Geometry.TYPES.Z)

                {

                case Geometry.TYPES.POINT:

                        supportedGeometryTypes = new int[] {Geometry.TYPES.POINT, Geometry.TYPES.NULL };

                        break;

                case Geometry.TYPES.MULTIPOINT:

                        supportedGeometryTypes = new int[] {Geometry.TYPES.MULTIPOINT, Geometry.TYPES.NULL };

                        break;

                case Geometry.TYPES.CURVE:

                        supportedGeometryTypes = new int[] {Geometry.TYPES.CURVE, Geometry.TYPES.ELLIPSE,

                                Geometry.TYPES.ARC, Geometry.TYPES.CIRCLE, Geometry.TYPES.SURFACE, Geometry.TYPES.NULL };

                        break;

                case Geometry.TYPES.SURFACE:

                        supportedGeometryTypes = new int[] {Geometry.TYPES.ELLIPSE,

                                Geometry.TYPES.CIRCLE, Geometry.TYPES.SURFACE, Geometry.TYPES.NULL };

                        break;

                default:

                        supportedGeometryTypes = new int[] {};

                }

        }

        public boolean canWriteGeometry(int gvSIGgeometryType) {

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

                {

                        if (gvSIGgeometryType == supportedGeometryTypes[i] ||

                                gvSIGgeometryType == (supportedGeometryTypes[i] | Geometry.TYPES.Z))

                                return true;

                }

                return false;

        }

        public static void create(SHPStoreParameters parameters, FeatureType featureType)throws OpenException, WriteException {

                int fileLength = 100;

                DbaseFileHeader myHeader = DbaseFileHeader.createDbaseHeader(featureType);

                try {

                        DBFFeaturesWriter.create(parameters,featureType);

                        FileChannel shpChannel=(FileChannel) getWriteChannel(parameters.getFile().getAbsolutePath());

                        FileChannel shxChannel=(FileChannel) getWriteChannel(SHP.getShxFile(parameters.getFile()).getAbsolutePath());

                        SHPFileWrite shpWrite = new SHPFileWrite(shpChannel,shxChannel);

                        int shapeType = 0;

                        if (featureType.getGeometryTypes().length > 0){

                                shapeType= shpWrite.getShapeType(featureType.getGeometryTypes()[0]);

                        }

                        myHeader.setNumRecords(0);

                                Rectangle2D fullExtent = new Rectangle2D.Double();

                        shpWrite.writeHeaders(fullExtent,

                                        shapeType, 0, fileLength);

                        shpChannel.close();

                        shxChannel.close();

                } catch (IOException e) {

                        throw new InitializeWriterException("SHP AbstractFeature Writer",e);

                }

        }

        /* (non-Javadoc)

         * @see org.gvsig.data.datastores.vectorial.file.dbf.DBFFeaturesWriter#dispose()

         */

        public void dispose() throws DataException {

                super.dispose();

                if (this.shpWrite != null){

                        this.shpWrite.close();

                        this.shpWrite = null;

                }

                this.fullExtent = null;

        }

}