| gvSIG desktop 1

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

import java.awt.Color;

import java.awt.geom.Point2D;

import java.io.File;

import java.sql.Types;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

import java.util.logging.Logger;

import org.cresques.cts.IProjection;

import org.cresques.geo.Point3D;

import org.cresques.io.DxfFile;

import org.cresques.px.IObjList;

import org.cresques.px.dxf.DxfFeatureMaker;

import org.cresques.px.dxf.DxfHeaderManager;

import org.cresques.px.gml.Feature;

import org.cresques.px.gml.LineString;

import org.cresques.px.gml.LineString3D;

import org.cresques.px.gml.Point;

import org.cresques.px.gml.Polygon;

import org.cresques.px.gml.Polygon3D;

import org.gvsig.data.IDataCollection;

import org.gvsig.data.IDataExplorer;

import org.gvsig.data.IDataStoreParameters;

import org.gvsig.data.datastores.vectorial.IFeaturesReader;

import org.gvsig.data.datastores.vectorial.IFeaturesWriter;

import org.gvsig.data.datastores.vectorial.base.MemoryStore;

import org.gvsig.data.exception.CloseException;

import org.gvsig.data.exception.InitializeException;

import org.gvsig.data.exception.OpenException;

import org.gvsig.data.exception.ReadException;

import org.gvsig.data.exception.WriteException;

import org.gvsig.data.spatialprovisional.IExtent;

import org.gvsig.data.vectorial.DefaultAttributeDescriptor;

import org.gvsig.data.vectorial.DefaultFeatureType;

import org.gvsig.data.vectorial.FeatureStoreNotification;

import org.gvsig.data.vectorial.IFeature;

import org.gvsig.data.vectorial.IFeatureAttributeDescriptor;

import org.gvsig.data.vectorial.IFeatureCollection;

import org.gvsig.data.vectorial.IFeatureID;

import org.gvsig.data.vectorial.IFeatureType;

import org.gvsig.data.vectorial.MemoryFeature;

import org.gvsig.exceptions.BaseException;

import org.gvsig.metadata.IMetadata;

import org.gvsig.metadata.IMetadataManager;

import org.gvsig.metadata.MetadataManager;

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

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

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

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

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

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

import com.iver.cit.gvsig.fmap.core.symbols.ISymbol;

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

import com.iver.cit.gvsig.fmap.rendering.LegendFactory;

import com.iver.cit.gvsig.fmap.rendering.VectorialUniqueValueLegend;

import com.iver.cit.gvsig.fmap.rendering.styling.labeling.AttrInTableLabelingStrategy;

public class DXFStore extends MemoryStore{

        public static String DATASTORE_NAME = "DXFStore";

        protected final static int ID_FIELD_ID = 0;

        protected final static int ID_FIELD_FSHAPE = 1;

        protected final static int ID_FIELD_ENTITY = 2;

        protected final static int ID_FIELD_LAYER = 3;

        protected final static int ID_FIELD_COLOR = 4;

        protected final static int ID_FIELD_ELEVATION = 5;

        protected final static int ID_FIELD_THICKNESS = 6;

        protected final static int ID_FIELD_TEXT = 7;

        protected final static int ID_FIELD_HEIGHTTEXT = 8;

        protected final static int ID_FIELD_ROTATIONTEXT = 9;

        private DriverAttributes attr = new DriverAttributes();

        private DxfFile.EntityFactory featureMaker;

        private DxfFile.VarSettings headerManager;

        private DxfFile dxfFeatureFile;

        private IObjList.vector features;

        private AttrInTableLabelingStrategy labeling;

        private VectorialUniqueValueLegend defaultLegend;

        private IFeatureType featureType;

        private List featureTypes = new ArrayList();//<IFeatureType>

        private File dxfFile;

//        protected ArrayList featuresAux=new ArrayList();

        protected IMetadata metadata;

    private IProjection projection;

         public void init(IDataStoreParameters parameters) throws InitializeException {

                super.init(parameters);

                dxfFile=((DXFStoreParameters)parameters).getDXFFile();

                        projection=((DXFStoreParameters)parameters).getProjection();

                }

         static IFeatureType newFeatureType(){

                        DefaultFeatureType fType= new DefaultFeatureType();

                        DefaultAttributeDescriptor descriptorID = new DefaultAttributeDescriptor();

                        descriptorID.setType(IFeatureAttributeDescriptor.TYPE_INT);

                        descriptorID.setName("ID");

                        descriptorID.setDefaultValue(new Integer(0));

                        fType.add(descriptorID);

                        DefaultAttributeDescriptor descriptorShape = new DefaultAttributeDescriptor();

                        descriptorShape.setType(IFeatureAttributeDescriptor.TYPE_GEOMETRY);

                        descriptorShape.setName("GEOMETRY");

                        descriptorShape.setDefaultValue(null);

                        fType.add(descriptorShape);

                        fType.setDefaultGeometry("GEOMETRY");

                        DefaultAttributeDescriptor descriptorEntity = new DefaultAttributeDescriptor();

                        descriptorEntity.setType(IFeatureAttributeDescriptor.TYPE_STRING);

                        descriptorEntity.setName("Entity");

                        descriptorEntity.setDefaultValue("Entity");

                        fType.add(descriptorEntity);

                        DefaultAttributeDescriptor descriptorLayer = new DefaultAttributeDescriptor();

                        descriptorLayer.setType(IFeatureAttributeDescriptor.TYPE_STRING);

                        descriptorLayer.setName("Layer");

                        descriptorLayer.setDefaultValue("default");

                        fType.add(descriptorLayer);

                        DefaultAttributeDescriptor descriptorColor = new DefaultAttributeDescriptor();

                        descriptorColor.setType(IFeatureAttributeDescriptor.TYPE_INT);

                        descriptorColor.setName("Color");

                        descriptorColor.setDefaultValue(new Integer(0));

                        fType.add(descriptorColor);

                        DefaultAttributeDescriptor descriptorElevation = new DefaultAttributeDescriptor();

                        descriptorElevation.setType(IFeatureAttributeDescriptor.TYPE_DOUBLE);

                        descriptorElevation.setName("Elevation");

                        descriptorElevation.setDefaultValue(new Double(0));

                        fType.add(descriptorElevation);

                        DefaultAttributeDescriptor descriptorThickness = new DefaultAttributeDescriptor();

                        descriptorThickness.setType(IFeatureAttributeDescriptor.TYPE_DOUBLE);

                        descriptorThickness.setName("Thickness");

                        descriptorThickness.setDefaultValue(new Double(0));

                        fType.add(descriptorThickness);

                        DefaultAttributeDescriptor descriptorText = new DefaultAttributeDescriptor();

                        descriptorText.setType(IFeatureAttributeDescriptor.TYPE_STRING);

                        descriptorText.setName("Text");

                        descriptorText.setDefaultValue("");

                        fType.add(descriptorText);

                        DefaultAttributeDescriptor descriptorHeightText = new DefaultAttributeDescriptor();

                        descriptorHeightText.setType(IFeatureAttributeDescriptor.TYPE_FLOAT);

                        descriptorHeightText.setName("HeightText");

                        descriptorHeightText.setDefaultValue(new Float(10));

                        fType.add(descriptorHeightText);

                        DefaultAttributeDescriptor descriptorRotationText = new DefaultAttributeDescriptor();

                        descriptorRotationText.setType(IFeatureAttributeDescriptor.TYPE_DOUBLE);

                        descriptorRotationText.setName("Rotation");

                        descriptorRotationText.setDefaultValue(new Double(10));

                        fType.add(descriptorRotationText);

                        return fType;

         }

         private void initializeFeatureType() {

                        featureType= newFeatureType();

                }

        protected void doFinishEdition() throws WriteException, ReadException {

                IFeaturesWriter writer = getFeaturesWriter();

        writer.init(this);

        writer.updateFeatureType(featureType);

        writer.preProcess();

        Collection collection=getDataCollection();

        Iterator iterator=collection.iterator();

        IFeature feature;

        while (iterator.hasNext()) {

                feature= (IFeature) iterator.next();

                        writer.insertFeature(feature);

                }

        writer.postProcess();

        }

        public IDataCollection getDataCollection(IFeatureType type, String filter, String order) throws ReadException {

                if (type==null){

                        type=getDefaultFeatureType();

                }

                IDataCollection dataCollection= getFeatutesReader().getFeatures(featureManager,type,filter,order);

            this.addObserver(dataCollection);

            return dataCollection;

        }

        public IFeature getFeatureByID(IFeatureID id) throws ReadException {

                if (this.alterMode){

                    if (featureManager.contains(id)) {

                            return featureManager.getFeature(id);

                    }

            }

                return id.getFeature(featureType);

        }

        public List getFeatureTypes() {

                featureTypes.set(0,getDefaultFeatureType());

        return featureTypes;

        }

        public IFeatureType getDefaultFeatureType() {

                IFeatureType ft = featureType;

            if (isEditing()){

//                    Aqu? hay que construir un FeatureType con los cambios que se hayan hecho en la edici?n.

                    return attributeManager.getFeatureType(ft);

            }

        return ft;

        }

        public boolean isWithDefaultLegend() {

                return false;

        }

        public Object getDefaultLegend() {

                return null;

        }

        public Object getDefaultLabelingStrategy() {

                return null;

        }

        public boolean canAlterFeatureType() {

                return true;

        }

        public String getName() {

                return DATASTORE_NAME;

        }

        public void open() throws OpenException {

                this.observable.notifyObservers(

                                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_OPEN)

                );

                float heightText = 10;

                attr.setLoadedInMemory(true);

                featureMaker = new DxfFeatureMaker(projection);

                headerManager = new DxfHeaderManager();

                dxfFeatureFile = new DxfFile(projection, dxfFile.getAbsolutePath(),

                                featureMaker, headerManager);

                try {

                        dxfFeatureFile.load();

                } catch (Exception e1) {

                        throw new OpenException(getName(),e1);

                }

                features = (IObjList.vector) ((DxfFeatureMaker) featureMaker)

                                .getObjects();

                String acadVersion = (String) ((DxfHeaderManager) headerManager)

                                .getAcadVersion();

                System.out.println("initialize(): acadVersion = " + acadVersion);

                if (!featureMaker.isDxf3DFile() && !headerManager.isWritedDxf3D()) { // y no

                                                                                                                                                                // est?n

                                                                                                                                                                // todos

                                                                                                                                                                // a

                                                                                                                                                                // 9999

                        Feature[] features2D = new Feature[features.size()];

                        for (int i = 0; i < features.size(); i++) {

                                Feature fea = (Feature) features.get(i);

                                if (fea.getGeometry() instanceof org.cresques.px.gml.Point3D) {

                                        Point point = (Point) fea.getGeometry();

                                        Point point2 = new Point();

                                        for (int j = 0; j < point.pointNr(); j++) {

                                                point2.add(point.get(j));

                                        }

                                        point2.setTextPoint(point.isTextPoint());

                                        fea.setGeometry(point2);

                                        features2D[i] = fea;

                                        // } else if (fea.getGeometry() instanceof InsPoint3D) {

                                        // InsPoint insPoint = (InsPoint)fea.getGeometry();

                                        // InsPoint insPoint2 = new InsPoint();

                                        // for (int j=0;j<insPoint.pointNr();j++) {

                                        // insPoint2.add(insPoint.get(j));

                                        // }

                                        // fea.setGeometry(insPoint2);

                                        // features2D[i] = fea;

                                } else if (fea.getGeometry() instanceof LineString3D) {

                                        LineString lineString = (LineString) fea.getGeometry();

                                        LineString lineString2 = new LineString();

                                        for (int j = 0; j < lineString.pointNr(); j++) {

                                                lineString2.add(lineString.get(j));

                                        }

                                        fea.setGeometry(lineString2);

                                        features2D[i] = fea;

                                } else if (fea.getGeometry() instanceof Polygon3D) {

                                        Polygon polygon = (Polygon) fea.getGeometry();

                                        Polygon polygon2 = new Polygon();

                                        for (int j = 0; j < polygon.pointNr(); j++) {

                                                polygon2.add(polygon.get(j));

                                        }

                                        fea.setGeometry(polygon2);

                                        features2D[i] = fea;

                                }

                        }

                        features.clear();

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

                                features.add(features2D[i]);

                        }

                }

                // String acadVersion =

                // (String)((DxfHeaderManager)headerManager).getAcadVersion();

                // System.out.println("initialize(): acadVersion = " + acadVersion);

                int nAtt = featureMaker.getAttributes().size();

                // Campos de las MemoryLayer:

//                Object[] auxRow = new Object[10 + nAtt];

//                ArrayList arrayFields = new ArrayList();

//                arrayFields.add("ID");

//                arrayFields.add("FShape");

//                arrayFields.add("Entity");

//                arrayFields.add("Layer");

//                arrayFields.add("Color");

//                arrayFields.add("Elevation");

//                arrayFields.add("Thickness");

//                arrayFields.add("Text");

//                arrayFields.add("HeightText");

//                arrayFields.add("RotationText");

                initializeFeatureType();

                for (int i = 0; i < nAtt; i++) {

                        String att[] = new String[2];

                        att = (String[]) featureMaker.getAttributes().get(i);

                        DefaultAttributeDescriptor descriptorAux = new DefaultAttributeDescriptor();

                        descriptorAux.setType(IFeatureAttributeDescriptor.TYPE_STRING);

                        descriptorAux.setName(att[0]);

                        descriptorAux.setDefaultValue("");

                        featureType.add(descriptorAux);

//                        arrayFields.add(att[0]);

                }

                labeling = new AttrInTableLabelingStrategy();

                ((AttrInTableLabelingStrategy) labeling).setTextFieldId(ID_FIELD_TEXT);

                ((AttrInTableLabelingStrategy) labeling).setRotationFieldId(ID_FIELD_ROTATIONTEXT);

                ((AttrInTableLabelingStrategy) labeling).setHeightFieldId(ID_FIELD_HEIGHTTEXT);

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

//                getTableModel().setColumnIdentifiers(arrayFields.toArray());

                for (int i = 0; i < features.size(); i++) {

                        IFeature feature = new MemoryFeature(featureType,true);

//                        auxRow[ID_FIELD_HEIGHTTEXT] = new Double(0.0);

//                        auxRow[ID_FIELD_ROTATIONTEXT] = new Double(0.0);

//                        auxRow[ID_FIELD_TEXT] = null;

                        Feature fea = (Feature) features.get(i);

                        if (fea.getGeometry() instanceof Point

                                        && !(fea.getGeometry() instanceof org.cresques.px.gml.Point3D)) {

                                Point point = (Point) fea.getGeometry();

                                Point2D pto = new Point2D.Double();

                                pto = point.get(0);

                                FShape nuevoShp;

                                if (point.isTextPoint()) {

                                        feature.set(ID_FIELD_ID,i);

//                                        auxRow[ID_FIELD_ID] = new Integer(i);

//                                        feature.set(ID_FIELD_FSHAPE,"Point2D");

//                                        auxRow[ID_FIELD_FSHAPE] = new String("FPoint2D");

                                        feature.set(ID_FIELD_ENTITY,fea.getProp("dxfEntity"));

//                                        auxRow[ID_FIELD_ENTITY] = new String(fea.getProp("dxfEntity"));

                                        feature.set(ID_FIELD_LAYER,fea.getProp("layer"));

//                                        auxRow[ID_FIELD_LAYER] = new String(fea.getProp("layer"));

                                        int auxInt = Integer.parseInt(fea.getProp("color"));

                                        feature.set(ID_FIELD_COLOR,auxInt);

//                                        auxRow[ID_FIELD_COLOR] = new Integer(auxInt);

                                        feature.set(ID_FIELD_TEXT,fea.getProp("text"));

//                                        auxRow[ID_FIELD_TEXT] = ValueFactory

//                                                        .createValue(new String(fea.getProp("text")));

                                        heightText = Float.parseFloat(fea.getProp("textHeight"));

                                        feature.set(ID_FIELD_HEIGHTTEXT,heightText);

//                                        auxRow[ID_FIELD_HEIGHTTEXT] = ValueFactory

//                                                        .createValue(heightText);

                                        double auxR = Double.parseDouble(fea

                                                        .getProp("textRotation"));

                                        feature.set(ID_FIELD_ROTATIONTEXT,auxR);

//                                        auxRow[ID_FIELD_ROTATIONTEXT] = ValueFactory

//                                                        .createValue(auxR);

                                        double auxE = Double.parseDouble(fea.getProp("elevation"));

                                        feature.set(ID_FIELD_ELEVATION,auxE);

//                                        auxRow[ID_FIELD_ELEVATION] = ValueFactory.createValue(auxE);

                                        double auxT = Double.parseDouble(fea.getProp("thickness"));

                                        feature.set(ID_FIELD_THICKNESS,auxT);

//                                        auxRow[ID_FIELD_THICKNESS] = ValueFactory.createValue(auxT);

                                        // Attributes

                                        for (int j = 0; j < nAtt; j++) {

                                                String[] attributes = new String[2];

                                                attributes = (String[]) featureMaker.getAttributes()

                                                                .get(j);

                                                feature.set(10+j,attributes[1]);

//                                                auxRow[10 + j] = ValueFactory.createValue(new String(

//                                                                attributes[1]));

                                                if (!fea.getProp(attributes[0]).equals(attributes[1])) {

                                                        feature.set(10+j,fea.getProp(attributes[0]));

//                                                        auxRow[10 + j] = ValueFactory

//                                                                        .createValue(new String(fea

//                                                                                        .getProp(attributes[0])));

                                                }

                                        }

                                        IGeometry geom=ShapeFactory.createPoint2D(new FPoint2D(pto.getX(), pto.getY()));

                                        feature.set(ID_FIELD_FSHAPE,geom);

//                                        feature.setDefaultGeometry(geom);

                                        addFeature(feature);

//                                        addShape(nuevoShp, auxRow);

                                } else {

                                        feature.set(ID_FIELD_ID,i);

//                                        auxRow[ID_FIELD_ID] = ValueFactory.createValue(i);

//                                        feature.set(ID_FIELD_FSHAPE,"Point2D");

//                                        auxRow[ID_FIELD_FSHAPE] = ValueFactory

//                                                        .createValue(new String("FPoint2D"));

                                        feature.set(ID_FIELD_ENTITY,fea.getProp("dxfEntity"));

//                                        auxRow[ID_FIELD_ENTITY] = ValueFactory

//                                                        .createValue(new String(fea.getProp("dxfEntity")));

                                        feature.set(ID_FIELD_LAYER,fea.getProp("layer"));

//                                        auxRow[ID_FIELD_LAYER] = ValueFactory

//                                                        .createValue(new String(fea.getProp("layer")));

                                        int auxInt = Integer.parseInt(fea.getProp("color"));

                                        feature.set(ID_FIELD_COLOR,auxInt);

//                                        auxRow[ID_FIELD_COLOR] = ValueFactory.createValue(auxInt);

                                        double auxE = Double.parseDouble(fea.getProp("elevation"));

                                        feature.set(ID_FIELD_ELEVATION,auxE);

//                                        auxRow[ID_FIELD_ELEVATION] = ValueFactory.createValue(auxE);

                                        double auxT = Double.parseDouble(fea.getProp("thickness"));

                                        feature.set(ID_FIELD_THICKNESS,auxT);

//                                        auxRow[ID_FIELD_THICKNESS] = ValueFactory.createValue(auxT);

                                        // Attributes

                                        for (int j = 0; j < nAtt; j++) {

                                                String[] attributes = new String[2];

                                                attributes = (String[]) featureMaker.getAttributes()

                                                                .get(j);

                                                feature.set(10+j,attributes[1]);

//                                                auxRow[10 + j] = ValueFactory.createValue(new String(

//                                                                attributes[1]));

                                                if (!fea.getProp(attributes[0]).equals(attributes[1])) {

                                                        feature.set(10+j,fea.getProp(attributes[0]));

//                                                        auxRow[10 + j] = ValueFactory

//                                                                        .createValue(new String(fea

//                                                                                        .getProp(attributes[0])));

                                                }

                                        }

                                        IGeometry geom=ShapeFactory.createPoint2D(new FPoint2D(pto.getX(), pto.getY()));

                                        feature.set(ID_FIELD_FSHAPE,geom);

//                                        feature.setDefaultGeometry(geom);

                                        addFeature(feature);

//                                        addShape(nuevoShp, auxRow);

                                }

                        } else if (fea.getGeometry() instanceof org.cresques.px.gml.Point3D) {

                                org.cresques.px.gml.Point3D point = (org.cresques.px.gml.Point3D) fea

                                                .getGeometry();

                                Point3D pto = new Point3D();

                                pto = point.getPoint3D(0);

                                FShape nuevoShp;

                                if (point.isTextPoint()) {

                                        feature.set(ID_FIELD_ID,i);

//                                        auxRow[ID_FIELD_ID] = ValueFactory.createValue(i);

                                        feature.set(ID_FIELD_FSHAPE,"Point3D");

//                                        auxRow[ID_FIELD_FSHAPE] = ValueFactory

//                                                        .createValue(new String("FPoint3D"));

                                        feature.set(ID_FIELD_ENTITY,fea.getProp("dxfEntity"));

//                                        auxRow[ID_FIELD_ENTITY] = ValueFactory

//                                                        .createValue(new String(fea.getProp("dxfEntity")));

                                        feature.set(ID_FIELD_LAYER,fea.getProp("layer"));

//                                        auxRow[ID_FIELD_LAYER] = ValueFactory

//                                                        .createValue(new String(fea.getProp("layer")));

                                        int auxInt = Integer.parseInt(fea.getProp("color"));

                                        feature.set(ID_FIELD_COLOR,auxInt);

//                                        auxRow[ID_FIELD_COLOR] = ValueFactory.createValue(auxInt);

                                        feature.set(ID_FIELD_TEXT,fea.getProp("text"));

//                                        auxRow[ID_FIELD_TEXT] = ValueFactory

//                                                        .createValue(new String(fea.getProp("text")));

                                        heightText = Float.parseFloat(fea.getProp("textHeight"));

                                        feature.set(ID_FIELD_HEIGHTTEXT,heightText);

//                                        auxRow[ID_FIELD_HEIGHTTEXT] = ValueFactory

//                                                        .createValue(heightText);

                                        double auxR = Double.parseDouble(fea

                                                        .getProp("textRotation"));

                                        feature.set(ID_FIELD_ROTATIONTEXT,auxR);

//                                        auxRow[ID_FIELD_ROTATIONTEXT] = ValueFactory

//                                                        .createValue(auxR);

                                        double auxE = Double.parseDouble(fea.getProp("elevation"));

                                        feature.set(ID_FIELD_ELEVATION,auxE);

//                                        auxRow[ID_FIELD_ELEVATION] = ValueFactory.createValue(auxE);

                                        double auxT = Double.parseDouble(fea.getProp("thickness"));

                                        feature.set(ID_FIELD_THICKNESS,auxT);

//                                        auxRow[ID_FIELD_THICKNESS] = ValueFactory.createValue(auxT);

                                        // Attributes

                                        for (int j = 0; j < nAtt; j++) {

                                                String[] attributes = new String[2];

                                                attributes = (String[]) featureMaker.getAttributes()

                                                                .get(j);

                                                feature.set(10+j,attributes[1]);

//                                                auxRow[10 + j] = ValueFactory.createValue(new String(

//                                                                attributes[1]));

                                                if (!fea.getProp(attributes[0]).equals(attributes[1])) {

                                                        feature.set(10+j,fea.getProp(attributes[0]));

//                                                        auxRow[10 + j] = ValueFactory

//                                                                        .createValue(new String(fea

//                                                                                        .getProp(attributes[0])));

                                                }

                                        }

                                        IGeometry geom=ShapeFactory.createPoint3D(pto.getX(), pto.getY(), pto.getZ());

                                        feature.set(ID_FIELD_FSHAPE,geom);

//                                        feature.setDefaultGeometry(geom);

                                        addFeature(feature);

//                                        addShape(nuevoShp, auxRow);

                                } else {

                                        feature.set(ID_FIELD_ID,i);

//                                        auxRow[ID_FIELD_ID] = ValueFactory.createValue(i);

                                        feature.set(ID_FIELD_FSHAPE,"Point3D");

//                                        auxRow[ID_FIELD_FSHAPE] = ValueFactory

//                                                        .createValue(new String("FPoint3D"));

                                        feature.set(ID_FIELD_ENTITY,fea.getProp("dxfEntity"));

//                                        auxRow[ID_FIELD_ENTITY] = ValueFactory

//                                                        .createValue(new String(fea.getProp("dxfEntity")));

                                        feature.set(ID_FIELD_LAYER,fea.getProp("layer"));

//                                        auxRow[ID_FIELD_LAYER] = ValueFactory

//                                                        .createValue(new String(fea.getProp("layer")));

                                        int auxInt = Integer.parseInt(fea.getProp("color"));

                                        feature.set(ID_FIELD_COLOR,auxInt);

//                                        auxRow[ID_FIELD_COLOR] = ValueFactory.createValue(auxInt);

                                        double auxE = Double.parseDouble(fea.getProp("elevation"));

                                        feature.set(ID_FIELD_ELEVATION,auxE);

//                                        auxRow[ID_FIELD_ELEVATION] = ValueFactory.createValue(auxE);

                                        double auxT = Double.parseDouble(fea.getProp("thickness"));

                                        feature.set(ID_FIELD_THICKNESS,auxT);

//                                        auxRow[ID_FIELD_THICKNESS] = ValueFactory.createValue(auxT);

                                        // Attributes

                                        for (int j = 0; j < nAtt; j++) {

                                                String[] attributes = new String[2];

                                                attributes = (String[]) featureMaker.getAttributes()

                                                                .get(j);

                                                feature.set(10+j,attributes[1]);

//                                                auxRow[10 + j] = ValueFactory.createValue(new String(

//                                                                attributes[1]));

                                                if (!fea.getProp(attributes[0]).equals(attributes[1])) {

                                                        feature.set(10+j,fea.getProp(attributes[0]));

//                                                        auxRow[10 + j] = ValueFactory

//                                                                        .createValue(new String(fea

//                                                                                        .getProp(attributes[0])));

                                                }

                                        }

                                        IGeometry geom=ShapeFactory.createPoint3D(pto.getX(), pto.getY(), pto.getZ());

                                        feature.set(ID_FIELD_FSHAPE,geom);

//                                        feature.setDefaultGeometry(geom);

                                        addFeature(feature);

//                                        addShape(nuevoShp, auxRow);

                                }

                        } else if (fea.getGeometry() instanceof LineString

                                        && !(fea.getGeometry() instanceof LineString3D)) {

                                GeneralPathX genPathX = new GeneralPathX();

                                Point2D[] pts = new Point2D[fea.getGeometry().pointNr()];

                                for (int j = 0; j < fea.getGeometry().pointNr(); j++) {

                                        pts[j] = fea.getGeometry().get(j);

                                }

                                genPathX.moveTo(pts[0].getX(), pts[0].getY());

                                for (int j = 1; j < pts.length; j++) {

                                        genPathX.lineTo(pts[j].getX(), pts[j].getY());

                                }

                                feature.set(ID_FIELD_ID,i);

//                                auxRow[ID_FIELD_ID] = ValueFactory.createValue(i);

                                feature.set(ID_FIELD_FSHAPE,"Polyline2D");

//                                auxRow[ID_FIELD_FSHAPE] = ValueFactory.createValue(new String(

//                                                "FPolyline2D"));

                                feature.set(ID_FIELD_ENTITY,fea.getProp("dxfEntity"));

//                                auxRow[ID_FIELD_ENTITY] = ValueFactory.createValue(new String(

//                                                fea.getProp("dxfEntity")));

                                feature.set(ID_FIELD_LAYER,fea.getProp("layer"));

//                                auxRow[ID_FIELD_LAYER] = ValueFactory.createValue(new String(

//                                                fea.getProp("layer")));

                                int auxInt = Integer.parseInt(fea.getProp("color"));

                                feature.set(ID_FIELD_COLOR,auxInt);

//                                auxRow[ID_FIELD_COLOR] = ValueFactory.createValue(auxInt);

                                double auxE = Double.parseDouble(fea.getProp("elevation"));

                                feature.set(ID_FIELD_ELEVATION,auxE);

//                                auxRow[ID_FIELD_ELEVATION] = ValueFactory.createValue(auxE);

                                double auxT = Double.parseDouble(fea.getProp("thickness"));

                                feature.set(ID_FIELD_THICKNESS,auxT);

//                                auxRow[ID_FIELD_THICKNESS] = ValueFactory.createValue(auxT);

                                // Attributes

                                for (int j = 0; j < nAtt; j++) {

                                        String[] attributes = new String[2];

                                        attributes = (String[]) featureMaker.getAttributes().get(j);

                                        feature.set(10+j,attributes[1]);

//                                        auxRow[10 + j] = ValueFactory.createValue(new String(

//                                                         attributes[1]));

                                        if (!fea.getProp(attributes[0]).equals(attributes[1])) {

                                                feature.set(10+j,fea.getProp(attributes[0]));

//                                                auxRow[10 + j] = ValueFactory.createValue(new String(

//                                                                fea.getProp(attributes[0])));

                                        }

                                }

                                IGeometry geom=ShapeFactory.createPolyline2D(genPathX);

                                feature.set(ID_FIELD_FSHAPE,geom);

//                                feature.setDefaultGeometry(geom);

                                addFeature(feature);

//                                addShape(nuevoShp, auxRow);

                        } else if (fea.getGeometry() instanceof LineString3D) {

                                GeneralPathX genPathX = new GeneralPathX();

                                Point3D[] pts = new Point3D[fea.getGeometry().pointNr()];

                                for (int j = 0; j < fea.getGeometry().pointNr(); j++) {

                                        pts[j] = ((LineString3D) fea.getGeometry()).getPoint3D(j);

                                }

                                genPathX.moveTo(pts[0].getX(), pts[0].getY());

                                for (int j = 1; j < pts.length; j++) {

                                        genPathX.lineTo(pts[j].getX(), pts[j].getY());

                                }

                                double[] elevations = new double[pts.length];

                                for (int j = 0; j < pts.length; j++) {

                                        elevations[j] = pts[j].getZ();

                                }

                                feature.set(ID_FIELD_ID,i);

//                                auxRow[ID_FIELD_ID] = ValueFactory.createValue(i);

                                feature.set(ID_FIELD_FSHAPE,"Polyline3D");

//                                auxRow[ID_FIELD_FSHAPE] = ValueFactory.createValue(new String(

//                                                "FPolyline3D"));

                                feature.set(ID_FIELD_ENTITY,fea.getProp("dxfEntity"));

//                                auxRow[ID_FIELD_ENTITY] = ValueFactory.createValue(new String(

//                                                fea.getProp("dxfEntity")));

                                feature.set(ID_FIELD_LAYER,fea.getProp("layer"));

//                                auxRow[ID_FIELD_LAYER] = ValueFactory.createValue(new String(

//                                                fea.getProp("layer")));

                                int auxInt = Integer.parseInt(fea.getProp("color"));

                                feature.set(ID_FIELD_COLOR,auxInt);

//                                auxRow[ID_FIELD_COLOR] = ValueFactory.createValue(auxInt);

                                if (fea.getProp("elevation") != null) {

                                        double auxE = Double.parseDouble(fea.getProp("elevation"));

                                        feature.set(ID_FIELD_ELEVATION,auxE);

//                                        auxRow[ID_FIELD_ELEVATION] = ValueFactory.createValue(auxE);

                                }

                                double auxT = Double.parseDouble(fea.getProp("thickness"));

                                feature.set(ID_FIELD_THICKNESS,auxT);

//                                auxRow[ID_FIELD_THICKNESS] = ValueFactory.createValue(auxT);

                                // Attributes

                                for (int j = 0; j < nAtt; j++) {

                                        String[] attributes = new String[2];

                                        attributes = (String[]) featureMaker.getAttributes().get(j);

                                        feature.set(10+j,attributes[1]);

//                                        auxRow[10 + j] = ValueFactory.createValue(new String(

//                                                        attributes[1]));

                                        if (!fea.getProp(attributes[0]).equals(attributes[1])) {

                                                feature.set(10+j,fea.getProp(attributes[0]));

//                                                auxRow[10 + j] = ValueFactory.createValue(new String(

//                                                                fea.getProp(attributes[0])));

                                        }

                                }

                                IGeometry geom=ShapeFactory.createPolyline3D(genPathX,elevations);

                                feature.set(ID_FIELD_FSHAPE,geom);

//                                feature.setDefaultGeometry(geom);

                                addFeature(feature);

//                                addShape(nuevoShp, auxRow);

                        } else if (fea.getGeometry() instanceof Polygon

                                        && !(fea.getGeometry() instanceof Polygon3D)) {

                                GeneralPathX genPathX = new GeneralPathX();

                                // 050112: A?ado una posici?n m?s para el punto que cierra y

                                // creo el objeto firstPt.

                                Point2D firstPt = new Point2D.Double();

                                firstPt = fea.getGeometry().get(0);

                                Point2D[] pts = new Point2D[fea.getGeometry().pointNr() + 1];

                                for (int j = 0; j < fea.getGeometry().pointNr(); j++) {

                                        pts[j] = fea.getGeometry().get(j);

                                }

                                // 050112: A?ado el primer punto al final para cerrar los

                                // pol?gonos.

                                pts[fea.getGeometry().pointNr()] = firstPt;

                                genPathX.moveTo(pts[0].getX(), pts[0].getY());

                                for (int j = 1; j < pts.length; j++) {

                                        genPathX.lineTo(pts[j].getX(), pts[j].getY());

                                }

                                feature.set(ID_FIELD_ID,i);

//                                auxRow[ID_FIELD_ID] = ValueFactory.createValue(i);

                                feature.set(ID_FIELD_FSHAPE,"Polygon2D");

//                                auxRow[ID_FIELD_FSHAPE] = ValueFactory.createValue(new String(

//                                                "FPolygon2D"));

                                feature.set(ID_FIELD_ENTITY,fea.getProp("dxfEntity"));

//                                auxRow[ID_FIELD_ENTITY] = ValueFactory.createValue(new String(

//                                                fea.getProp("dxfEntity")));

                                feature.set(ID_FIELD_LAYER,fea.getProp("layer"));

//                                auxRow[ID_FIELD_LAYER] = ValueFactory.createValue(new String(

//                                                fea.getProp("layer")));

                                int auxInt = Integer.parseInt(fea.getProp("color"));

                                feature.set(ID_FIELD_COLOR,auxInt);

//                                auxRow[ID_FIELD_COLOR] = ValueFactory.createValue(auxInt);

                                double auxE = Double.parseDouble(fea.getProp("elevation"));

                                feature.set(ID_FIELD_ELEVATION,auxE);

//                                auxRow[ID_FIELD_ELEVATION] = ValueFactory.createValue(auxE);

                                double auxT = Double.parseDouble(fea.getProp("thickness"));

                                feature.set(ID_FIELD_THICKNESS,auxT);

//                                auxRow[ID_FIELD_THICKNESS] = ValueFactory.createValue(auxT);

                                // Attributes

                                for (int j = 0; j < nAtt; j++) {

                                        String[] attributes = new String[2];

                                        attributes = (String[]) featureMaker.getAttributes().get(j);

                                        feature.set(10+j,attributes[1]);

//                                        auxRow[10 + j] = ValueFactory.createValue(new String(

//                                                        attributes[1]));

                                        if (!fea.getProp(attributes[0]).equals(attributes[1])) {

                                                feature.set(10+j,fea.getProp(attributes[0]));

//                                                auxRow[10 + j] = ValueFactory.createValue(new String(

//                                                                fea.getProp(attributes[0])));

                                        }

                                }

                                IGeometry geom=ShapeFactory.createPolygon2D(genPathX);

                                feature.set(ID_FIELD_FSHAPE,geom);

//                                feature.setDefaultGeometry(geom);

                                addFeature(feature);

//                                addShape(nuevoShp, auxRow);

                        } else if (fea.getGeometry() instanceof Polygon3D) {

                                GeneralPathX genPathX = new GeneralPathX();

                                // 050112: A?ado una posici?n m?s para el punto que cierra y

                                // creo el objeto firstPt.

                                Point3D firstPt = new Point3D();

                                firstPt = ((Polygon3D) fea.getGeometry())

                                                .getPoint3D(0);

                                Point3D[] pts = new Point3D[fea.getGeometry().pointNr() + 1];

                                for (int j = 0; j < fea.getGeometry().pointNr(); j++) {

                                        pts[j] = ((Polygon3D) fea.getGeometry())

                                                        .getPoint3D(j);

                                }

                                // 050112: A?ado el primer punto al final para cerrar los

                                // pol?gonos.

                                pts[fea.getGeometry().pointNr()] = firstPt;

                                genPathX.moveTo(pts[0].getX(), pts[0].getY());

                                for (int j = 1; j < pts.length; j++) {

                                        genPathX.lineTo(pts[j].getX(), pts[j].getY());

                                }

                                double[] elevations = new double[pts.length];

                                for (int j = 0; j < pts.length; j++) {

                                        elevations[j] = pts[j].getZ();

                                }

                                feature.set(ID_FIELD_ID,i);

//                                auxRow[ID_FIELD_ID] = ValueFactory.createValue(i);

                                feature.set(ID_FIELD_FSHAPE,"Polygon3D");

//                                auxRow[ID_FIELD_FSHAPE] = ValueFactory.createValue(new String(

//                                                "FPolygon3D"));

                                feature.set(ID_FIELD_ENTITY,fea.getProp("dxfEntity"));

//                                auxRow[ID_FIELD_ENTITY] = ValueFactory.createValue(new String(

//                                                fea.getProp("dxfEntity")));

                                feature.set(ID_FIELD_LAYER,fea.getProp("layer"));

//                                auxRow[ID_FIELD_LAYER] = ValueFactory.createValue(new String(

//                                                fea.getProp("layer")));

                                int auxInt = Integer.parseInt(fea.getProp("color"));

                                feature.set(ID_FIELD_COLOR,auxInt);

//                                auxRow[ID_FIELD_COLOR] = ValueFactory.createValue(auxInt);

                                if (fea.getProp("elevation") != null) {

                                        double auxE = Double.parseDouble(fea.getProp("elevation"));

                                        feature.set(ID_FIELD_ELEVATION,auxE);

//                                        auxRow[ID_FIELD_ELEVATION] = ValueFactory.createValue(auxE);

                                }

                                double auxT = Double.parseDouble(fea.getProp("thickness"));

                                feature.set(ID_FIELD_THICKNESS,auxT);

//                                auxRow[ID_FIELD_THICKNESS] = ValueFactory.createValue(auxT);

                                // Attributes

                                for (int j = 0; j < nAtt; j++) {

                                        String[] attributes = new String[2];

                                        attributes = (String[]) featureMaker.getAttributes().get(j);

                                        feature.set(10+j,attributes[1]);

//                                        auxRow[10 + j] = ValueFactory.createValue(new String(

//                                                        attributes[1]));

                                        if (!fea.getProp(attributes[0]).equals(attributes[1])) {

                                                feature.set(10+j,fea.getProp(attributes[0]));

//                                                auxRow[10 + j] = ValueFactory.createValue(new String(

//                                                                fea.getProp(attributes[0])));

                                        }

                                }

                                IGeometry geom=ShapeFactory.createPolygon3D(genPathX,elevations);

                                feature.set(ID_FIELD_FSHAPE,geom);

//                                feature.setDefaultGeometry(geom);

                                addFeature(feature);

//                                addShape(nuevoShp, auxRow);

                        } else {

                                // System.out.println("Detectado feature desconocido");

                        }

                }

                defaultLegend = LegendFactory

                                .createVectorialUniqueValueLegend(FShape.MULTI);

                defaultLegend.setClassifyingFieldNames(new String[] {"Color"});

                defaultLegend.setClassifyingFieldTypes(new int[]{Types.INTEGER,Types.VARCHAR,Types.VARCHAR,Types.VARCHAR,Types.INTEGER,Types.DOUBLE,Types.DOUBLE});

                Logger.getAnonymousLogger().info("DXFStore: should check if this is a text symbol");

                ISymbol myDefaultSymbol = SymbologyFactory.

                        createDefaultSymbolByShapeType(FShape.MULTI, Color.BLACK);

                defaultLegend.setDefaultSymbol(myDefaultSymbol);

//                ISymbol theSymbol = null;

//

//                        for (long j = 0; j < featuresAux.size(); j++) {

//                                IFeature feat=(IFeature)featuresAux.get((int)j);

//                                int clave=feat.getInt(ID_FIELD_COLOR);

////                                clave = (IntValue) rs.getFieldValue(j, ID_FIELD_COLOR);

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

//                                        theSymbol = SymbologyFactory.

//                                                createDefaultSymbolByShapeType(

//                                                                FShape.MULTI,

//                                                                AcadColor.getColor(clave.getValue()));

//                                        theSymbol.setDescription(clave.toString());

//                                        // Asigna los colores de Autocad a los

//                                        // bordes

//                                        // de los pol?gonos.

//                                        if (theSymbol instanceof IFillSymbol) {

//                                                ((IFillSymbol) theSymbol).getOutline().setLineColor(AcadColor.getColor(clave

//                                                                .getValue()));

//

//                                        }

//                                        defaultLegend.addSymbol(clave, theSymbol);

//                                }

//                        } // for

                this.observable.notifyObservers(

                                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_OPEN)

                );

        }

        public void close() throws CloseException {

                this.observable.notifyObservers(

                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_CLOSE)

            );

                super.close();

                features.clear();

        this.observable.notifyObservers(

                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_CLOSE)

            );

        }

        public void dispose() throws CloseException {

                this.observable.notifyObservers(

                new FeatureStoreNotification(this,FeatureStoreNotification.BEFORE_DISPOSE)

            );

                close();

        this.observable.notifyObservers(

                new FeatureStoreNotification(this,FeatureStoreNotification.AFTER_DISPOSE)

            );

        }

        public boolean isEditable() {

                return false;

        }

        public IMetadata getMetadata() throws BaseException {

                if (metadata==null){

                        IMetadataManager manager=MetadataManager.getManager();

                        metadata=manager.create(DATASTORE_NAME);

                        IExtent extent=getFullExtent();

                        metadata.set("extent",extent);

                        String srs=getSRS();

                        metadata.set("srs",srs);

                }

                if (this.alterMode){

                        IExtent extent=(IExtent)metadata.get("extent");

                        IFeatureCollection featureCollection=(IFeatureCollection)getDataCollection();

                    if (spatialManager.isFullExtentDirty()){

                            if (!featureCollection.isEmpty()){

                                    Iterator featureIterator=featureCollection.iterator();

                                    extent = ((IFeature)featureIterator.next()).getExtent();

                                    while(featureIterator.hasNext()){

                                            IFeature feature=(IFeature)featureIterator.next();

                                            IExtent boundExtent=feature.getExtent();

                                            if (boundExtent!=null)

                                                    extent.add(boundExtent);

                                    }

                            }

                    }

                    metadata.set("extent",extent);

                }

                return metadata;

        }

        private String getSRS() {

                // TODO Auto-generated method stub

                return null;

        }

        public IFeaturesReader getFeatutesReader() {

                IFeaturesReader reader = new DXFFeaturesReader();

                reader.init(this);

                return reader;

        }

        public IFeaturesWriter getFeaturesWriter() {

                IFeaturesWriter writer = new DXFFeaturesWriter();

//                writer.init(this);

                return writer;

        }

        public IDataStoreParameters getParameters() {

                return parameters;

        }

        public IDataExplorer getExplorer() {

                // TODO Auto-generated method stub

                return null;

        }

}