Application: gvSIG desktop

package com.iver.cit.gvsig.fmap.edition.writers.shp;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.nio.channels.FileChannel;

import java.nio.channels.WritableByteChannel;

import java.sql.Types;

import com.iver.cit.gvsig.fmap.DriverException;

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

import com.iver.cit.gvsig.fmap.core.IFeature;

import com.iver.cit.gvsig.fmap.drivers.DriverIOException;

import com.iver.cit.gvsig.fmap.drivers.LayerDefinition;

import com.iver.cit.gvsig.fmap.drivers.shp.DbaseFileHeaderNIO;

import com.iver.cit.gvsig.fmap.drivers.shp.DbaseFileWriterNIO;

import com.iver.cit.gvsig.fmap.drivers.shp.write.SHPFileWrite;

import com.iver.cit.gvsig.fmap.drivers.shp.write.ShapefileException;

import com.iver.cit.gvsig.fmap.edition.EditionException;

import com.iver.cit.gvsig.fmap.edition.IRowEdited;

import com.iver.cit.gvsig.fmap.edition.ISpatialWriter;

import com.iver.cit.gvsig.fmap.edition.VectorialEditableAdapter;

import com.iver.cit.gvsig.fmap.edition.writers.AbstractWriter;

import com.iver.cit.gvsig.fmap.layers.FBitSet;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.iver.cit.gvsig.fmap.layers.SelectableDataSource;

import com.iver.cit.gvsig.fmap.layers.VectorialFileAdapter;

import com.iver.utiles.bigfile.BigByteBuffer2;

public class ShpWriter extends AbstractWriter implements ISpatialWriter {

        private String shpPath;

        private String shxPath;

        private String dbfPath;

        private File shpFile;

        private SHPFileWrite shpWrite;

        private DbaseFileWriterNIO dbfWrite;

        private DbaseFileHeaderNIO myHeader;

        private int shapeType;

        private int numRows;

        private int fileSize;

        private Rectangle2D fullExtent;

        private Object[] record;

        // private FLyrVect lyrVect;

        private FBitSet selection = null;

        public void setFile(File f)

        {

                shpPath = f.getAbsolutePath();

                String strFichshx = f.getAbsolutePath().replaceAll("\\.shp", ".shx");

                shxPath = strFichshx.replaceAll("\\.SHP", ".SHX");

                String strFichDbf = f.getAbsolutePath().replaceAll("\\.shp", ".dbf");

                dbfPath = strFichDbf.replaceAll("\\.SHP", ".DBF");

                shpFile = f;

        }

        private WritableByteChannel getWriteChannel(String path)

                                throws IOException

        {

                WritableByteChannel channel;

                File f = new File(path);

                if (!f.exists()) {

                        System.out.println("Creando fichero " + f.getAbsolutePath());

                        if (!f.createNewFile()) {

                                System.err.print("Error al crear el fichero " +

                                        f.getAbsolutePath());

                                throw new IOException("Cannot create file " + f);

                        }

                }

                RandomAccessFile raf = new RandomAccessFile(f, "rw");

                channel = raf.getChannel();

                return channel;

        }

        /**

         * Util para crear un fichero .shp desde cero.

         * @param lyrDef

         * @throws IOException

         * @throws DriverException

         */

        /*public ShpWriter(File shpFile, LayerDefinition lyrDef) throws IOException, DriverException

        {

                myHeader = DbaseFileHeaderNIO.createDbaseHeader(lyrDef.getFieldsDesc());

                initialize(shpFile, lyrDef.getShapeType());

        }

        public ShpWriter(File shpFile, FLyrVect lyrVect) throws IOException, DriverException

        {

                SelectableDataSource sds = lyrVect.getRecordset();

                myHeader = DbaseFileHeaderNIO.createDbaseHeader(sds);

                initialize(shpFile, lyrVect.getShapeType());

        }

        */

        /**

         * Use this function first of all, when you need to prepare a writer

         * having a FLayer as model.

         * IMPORTANT: Call setFile before calling this function.

         * @param lyrVect

         * @throws IOException

         * @throws DriverException

         */

        public void initialize(FLayer layer) throws EditionException{

                if (layer instanceof FLyrVect)

                {

                        FLyrVect lyrVect = (FLyrVect) layer;

                        SelectableDataSource sds = lyrVect.getRecordset();

                        try {

                                myHeader = DbaseFileHeaderNIO.createDbaseHeader(sds);

                                initialize(shpFile, lyrVect.getShapeType());

                        } catch (IOException e) {

                                e.printStackTrace();

                                throw new EditionException(e);

                        } catch (DriverException e) {

                                e.printStackTrace();

                                throw new EditionException(e);

                        }                

                }

                else

                {

                        throw new EditionException("No se puede usar una capa que no es vectorial como modelo para escribir un shp.");

                }

        }

        /**

         * Useful to create a layer from scratch

         * Call setFile before using this function

         * @param lyrDef

         * @throws IOException

         * @throws DriverException

         */

        public void initialize(LayerDefinition lyrDef) throws IOException, DriverException

        {

                myHeader = DbaseFileHeaderNIO.createDbaseHeader(lyrDef.getFieldsDesc());

                initialize(shpFile, lyrDef.getShapeType());

        }

        private void initialize(File shpFile, int typeFShape) throws IOException //, FLyrVect lyrVect, FBitSet selection) throws IOException, DriverException

        {

                // this.lyrVect = lyrVect;

                // this.selection = selection;

                setFile(shpFile);

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

                                (FileChannel) getWriteChannel(shxPath));

                shapeType = shpWrite.getShapeType(typeFShape);

        }

        public void preProcess() throws EditionException {

                // Por ahora solo escribimos los primeros bytes

                // de las cabeceras. Luego en el postprocess los escribiremos

                // correctamente, con el fullExtent y el numero de

                // registros que tocan.

                if (selection == null)

                {

                        try {

                                shpWrite.writeHeaders(new Rectangle2D.Double(),

                                                shapeType, 0, 0);

                                myHeader.setNumRecords(0);

                                dbfWrite = new DbaseFileWriterNIO(myHeader,

                                                (FileChannel) getWriteChannel(dbfPath));

                                record = new Object[myHeader.getNumFields()];

                                numRows = 0;

                                fullExtent = null;

                        } catch (IOException e) {

                                e.printStackTrace();

                                throw new EditionException(e);

                        }

                }

        }

        public void process(IRowEdited row) throws EditionException {

                IFeature feat = (IFeature) row.getLinkedRow();

                try {

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

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

                        fileSize = shpWrite.writeIGeometry(feat.getGeometry());

                        Rectangle2D boundsShp = feat.getGeometry().getBounds2D();

                        if (fullExtent == null) {

                                fullExtent = boundsShp;

                        } else {

                                fullExtent.add(boundsShp);

                        }

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

                                record[i] = feat.getAttribute(i);

                        dbfWrite.write(record);

                        numRows++;

                } catch (IOException e) {

                        e.printStackTrace();

                        throw new EditionException(e);

                } catch (ShapefileException e) {

                        e.printStackTrace();

                        throw new EditionException(e);

                }

        }

        public void postProcess() throws EditionException {

                try {

                        myHeader.setNumRecords(numRows);

                        if (fullExtent == null)

                                fullExtent = new Rectangle2D.Double();

                        shpWrite.writeHeaders(fullExtent,

                                        shapeType, numRows, fileSize);

                        dbfWrite = new DbaseFileWriterNIO(myHeader,

                                        (FileChannel) getWriteChannel(dbfPath));

                } catch (IOException e) {

                        e.printStackTrace();

                        throw new EditionException(e);

                }

        }

        /**

         * Devuelve el path del fichero Shp.

         *

         * @author azabala

         * @return shp path

         */

        public String getShpPath(){

                //Lo necesito para que el ShpSchemaManager sepa

                //como "construir" el esquema del fichero SHP/DBF

                //adem?s del ShpLayerDefinition

                //TODO hacer que ShpWriter implemente ISchemaManager

                return this.shpPath;

        }

        public String getName() {

                return "Shape Writer";

        }

        public boolean canWriteGeometry(int gvSIGgeometryType) {

                switch (gvSIGgeometryType)

                {

                case FShape.POINT:

                        return true;

                case FShape.LINE:

                        return true;

                case FShape.POLYGON:

                        return true;

                case FShape.ARC:

                        return false;

                case FShape.ELLIPSE:

                        return false;                        

                case FShape.MULTIPOINT:

                        return true;                        

                case FShape.TEXT:

                        return false;                                                

                }

                return false;

        }

        public boolean canWriteAttribute(int sqlType) {

                switch (sqlType)

                {

                case Types.DOUBLE:

                case Types.FLOAT: 

                case Types.INTEGER:

                case Types.BIGINT:

                        return true;

                case Types.DATE:

                        return true;

                case Types.BIT:

                case Types.BOOLEAN:

                        return true;                        

                case Types.VARCHAR:

                case Types.CHAR: 

                case Types.LONGVARCHAR:

                        return true; // TODO: Revisar esto, porque no creo que admita campos muy grandes

                }

                return false;

        }

}