| gvSIG desktop 1

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

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.IOException;

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

import org.gvsig.data.exception.OpenException;

import org.gvsig.data.exception.ReadException;

import org.gvsig.data.exception.UnsupportedEncodingException;

import org.gvsig.data.exception.WriteException;

import org.gvsig.data.vectorial.IFeature;

import org.gvsig.data.vectorial.IFeatureStore;

import org.gvsig.data.vectorial.IFeatureType;

import org.gvsig.datasources.common.IRandomFileChannel;

import es.prodevelop.gvsig.mobile.fmap.core.FNullGeometry;

import es.prodevelop.gvsig.mobile.fmap.core.FShape;

import es.prodevelop.gvsig.mobile.fmap.core.IGeometry;

//import com.iver.cit.gvsig.fmap.core.FNullGeometry;

//import com.iver.cit.gvsig.fmap.core.FShape;

//import com.iver.cit.gvsig.fmap.core.IGeometry;

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(IFeatureStore store) throws InitializeWriterException {

                super.init(store);

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

                shpFile=parameters.getSHPFile();

                setFile(shpFile);

                try {

                        shpWrite = new SHPFileWrite(getWriteChannel(shpPath),

                                        super.getWriteChannel(shxPath));

                } catch (IOException e) {

                        throw new InitializeWriterException(SHPStore.DATASTORE_NAME,e);

                }

                setSupportedGeometryTypes();

        }

        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(IFeature feature) throws WriteException, UnsupportedEncodingException {

                /* System.out.println("Intento escribir el registro " +

                 numRows + " de la capa " + lyrVect.getName()); */

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

                if (theGeom==null){

                        theGeom=new FNullGeometry();

                }

                // Revisamos que podemos escribir esa entidad

                // En un shpFile, podemos meter pol?gonos, pero que sean como

                // lineas. En cambio, en uno de puntos solo se pueden meter puntos

                // Con capas de anotaciones ?nicamente se pueden salvar los puntos,

                // de momento no hay problema porque est? limitado

                // y no se puede tener anotaciones de otro tipo de shape.

                if (canWriteGeometry(theGeom.getGeometryType()))// || canWriteGeometry(gvSIG_geometryType))

                        {

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

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

                shpFile = f;

        }

        private void setSupportedGeometryTypes() {

                switch (gvSIG_geometryType % FShape.Z)

                {

                case FShape.POINT:

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

                        break;

                case FShape.MULTIPOINT:

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

                        break;

                case FShape.LINE:

                        supportedGeometryTypes = new int[] {FShape.LINE, FShape.ELLIPSE,

                                                        FShape.ARC, FShape.CIRCLE, FShape.POLYGON, FShape.NULL };

                        break;

                case FShape.POLYGON:

                        supportedGeometryTypes = new int[] {FShape.ELLIPSE,

                                FShape.CIRCLE, FShape.POLYGON, FShape.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] | FShape.Z))

                                return true;

                }

                return false;

        }

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

                int fileLength = 100;

                DbaseFileHeader myHeader = DbaseFileHeader.createDbaseHeader(featureType);

                try {

                        DBFFeaturesWriter.create(parameters,featureType);

                        IRandomFileChannel shpChannel=getWriteChannel(parameters.getSHPFile().getAbsolutePath());

                        IRandomFileChannel shxChannel=getWriteChannel(parameters.getSHXFile().getAbsolutePath());

                        SHPFileWrite shpWrite = new SHPFileWrite(shpChannel,shxChannel);

                        int 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 Feature Writer",e);

                }

        }

}