Application: gvSIG desktop

import org.gvsig.data.datastores.vectorial.file.dgn.DGNStore;

import org.gvsig.data.datastores.vectorial.file.dgn.DGNStoreParameters;

import org.gvsig.data.datastores.vectorial.file.dgn.Register;

import org.gvsig.data.vectorial.FeatureManager;

import org.gvsig.data.vectorial.IsNotFeatureSettingException;

import org.gvsig.data.vectorial.expansionadapter.MemoryExpansionAdapter;

import java.io.File;

import org.gvsig.data.exception.CloseException;

	private DXFStoreParameters parameters;

	/**

	 * @param aFile

	 */

		this.parameters = params;

		// TODO Auto-generated method stub

		// TODO Auto-generated method stub

		// TODO Auto-generated method stub

		DxfFile.EntityFactory featureMaker = new DxfFeatureMaker(parameters.getProjection());

		dxfFeatureFile = new DxfFile(parameters.getProjection(), this.getFile().getAbsolutePath(),

					FShape nuevoShp;

					FShape nuevoShp;

import org.gvsig.data.vectorial.IsNotFeatureSettingException;

import java.awt.Color;

import java.awt.geom.Point2D;

import java.io.File;

import java.sql.Types;

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 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.rendering.LegendFactory;

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

	private File dxfFile;

	private IProjection projection;

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

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

		return true;

			// TODO Auto-generated catch block

		return false;

import java.awt.geom.AffineTransform;

import java.awt.geom.Arc2D;

import java.sql.Types;

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

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

import org.gvsig.data.datastores.vectorial.file.dgn.utils.DGNElemArc;

import org.gvsig.data.datastores.vectorial.file.dgn.utils.DGNElemCellHeader;

import org.gvsig.data.datastores.vectorial.file.dgn.utils.DGNElemComplexHeader;

import org.gvsig.data.datastores.vectorial.file.dgn.utils.DGNElemCore;

import org.gvsig.data.datastores.vectorial.file.dgn.utils.DGNElemMultiPoint;

import org.gvsig.data.datastores.vectorial.file.dgn.utils.DGNElemText;

import org.gvsig.data.datastores.vectorial.file.dgn.utils.DGNFileHeader;

import org.gvsig.data.datastores.vectorial.file.dgn.utils.DGNReader;

import org.gvsig.data.vectorial.Feature;

import org.gvsig.data.vectorial.FeatureStoreNotification;

import org.gvsig.data.vectorial.IsNotFeatureSettingException;

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.rendering.LegendFactory;

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

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

public class DGNStore extends MemoryStore{

	private final int ID_FIELD_ID = 0;

	private final int ID_FIELD_ENTITY = 1;

	private final int ID_FIELD_LAYER = 2;

	private final int ID_FIELD_COLOR = 3;

	private final int ID_FIELD_HEIGHTTEXT = 4;

	private final int ID_FIELD_ROTATIONTEXT = 5;

	private final int ID_FIELD_TEXT = 6;

	private final int ID_FIELD_GEOMETRY = 7;

	private File dgnFile;

	private AttrInTableLabelingStrategy labeling;

	private VectorialUniqueValueLegend defaultLegend;

		super.init(parameters);

		dgnFile=dgnParameters.getFile();

	private void initializeFeatureType() {

		featureType = newFeatureType();

	}

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

		ArrayList originalFeatures=this.getFeatures();

		int originalSize=originalFeatures.size();

		int j=0;

			if (i<this.getFeatureCount()){

				feature=this.getFeature(i);

		return false;

	public Object getDefaultLegend() {

		return null;

		return true;

		float heightText = 10;

//		attr.setLoadedInMemory(true);

		initializeFeatureType();

		DGNReader m_DgnReader;

		try {

			m_DgnReader = new DGNReader(dgnFile.getAbsolutePath());

		} catch (ReadException e) {

			throw new OpenException(getName(),e);

		}

		try{

//			Value[] auxRow = new Value[7];

//			Value[] cellRow = new Value[7];

//			Value[] complexRow = new Value[7];

			DGNFeature auxFeature=new DGNFeature(featureType,true);

			auxFeature.loading();

			DGNFeature cellFeature=new DGNFeature(featureType,false);

			cellFeature.loading();

			DGNFeature complexFeature=new DGNFeature(featureType,false);

			complexFeature.loading();

			initializeFeatureType();

//			ArrayList arrayFields = new ArrayList();

//			arrayFields.add("ID");

//			arrayFields.add("Entity");

//			arrayFields.add("Layer");

//			arrayFields.add("Color");

//			arrayFields.add("HeightText");

//			arrayFields.add("RotationText");

//			arrayFields.add("Text");

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

			// jaume

			labeling = new AttrInTableLabelingStrategy();

			((AttrInTableLabelingStrategy) labeling).setTextFieldId(featureType.getFieldIndex("Text"));

			((AttrInTableLabelingStrategy) labeling).setRotationFieldId(featureType.getFieldIndex("RotationText"));

			((AttrInTableLabelingStrategy) labeling).setHeightFieldId(featureType.getFieldIndex("HeightText"));

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

			// Ahora las rellenamos.

//			FShape aux;

			boolean bElementoCompuesto = false;

			boolean bEsPoligono = false;

			boolean bInsideCell = false;

			boolean bFirstHoleEntity = false;

			boolean bConnect = false; // Se usa para que los pol?gonos cierren bien cuando son formas compuestas

//			int contadorSubElementos = 0;

//			int numSubElementos = 0;

			int complex_index_fill_color = -1;

			int nClass; // Para filtrar los elementos de construcci?n, etc.

			GeneralPathX elementoCompuesto = new GeneralPathX(GeneralPathX.WIND_EVEN_ODD);

			for (int id = 0; id < m_DgnReader.getNumEntities(); id++) {

				// System.out.println("Elemento " + id + " de " + m_DgnReader.getNumEntities());

				m_DgnReader.DGNGotoElement(id);

				DGNElemCore elemento = m_DgnReader.DGNReadElement();

				nClass = 0;

//				auxRow[ID_FIELD_HEIGHTTEXT] = ValueFactory.createValue(0);

//				auxRow[ID_FIELD_ROTATIONTEXT] = ValueFactory.createValue(0);

//				auxRow[ID_FIELD_TEXT] = ValueFactory.createNullValue();

				if (elemento.properties != 0) {

					nClass = elemento.properties & DGNFileHeader.DGNPF_CLASS;

				}

				if ((elemento != null) && (elemento.deleted == 0) && (nClass == 0)) //Leer un elemento

				{

//					aux = null;

					// if ((elemento.element_id > 3800) && (elemento.element_id < 3850))

					// 	m_DgnReader.DGNDumpElement(m_DgnReader.getInfo(),elemento,"");

					if ((elemento.stype == DGNFileHeader.DGNST_MULTIPOINT) ||

							(elemento.stype == DGNFileHeader.DGNST_ARC) ||

							(elemento.stype == DGNFileHeader.DGNST_CELL_HEADER) ||

							(elemento.stype == DGNFileHeader.DGNST_SHARED_CELL_DEFN) ||

							(elemento.stype == DGNFileHeader.DGNST_COMPLEX_HEADER)) {

						if (elemento.complex != 0) {

							bElementoCompuesto = true;

						} else {

							if (bElementoCompuesto) {

								if (bInsideCell) {

									auxFeature.set(ID_FIELD_ENTITY,cellFeature.get(ID_FIELD_ENTITY));

//									auxRow[ID_FIELD_ENTITY] = cellRow[ID_FIELD_ENTITY];

								} else {

									auxFeature=complexFeature;

//									auxRow = complexRow;

								}

								// System.err.println("Entidad compuesta. bInsideCell = " + bInsideCell + " auxRow = " + auxRow[ID_FIELD_ENTITY]);

								IGeometry geom=ShapeFactory.createPolyline2D(elementoCompuesto);

								auxFeature.set(ID_FIELD_GEOMETRY,geom);

//								auxFeature.setDefaultGeometry(geom);

								addDGNFeature(auxFeature);

//								addShape(new FPolyline2D(elementoCompuesto), auxRow);

								if (bEsPoligono) {

									if (complex_index_fill_color != -1) {

										auxFeature.set(ID_FIELD_COLOR,complex_index_fill_color);

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

									}

									geom=ShapeFactory.createPolygon2D(elementoCompuesto);

									auxFeature.set(ID_FIELD_GEOMETRY,geom);

//									auxFeature.setDefaultGeometry(geom);

									addDGNFeature(auxFeature);

//									addShape(new FPolygon2D(elementoCompuesto),	auxRow);

								}

								elementoCompuesto = new GeneralPathX(GeneralPathX.WIND_EVEN_ODD);

							}

							// System.err.println("Entidad simple");

							bElementoCompuesto = false;

							bEsPoligono = false;

							bConnect = false;

							// elementoCompuesto = new GeneralPathX();

							bInsideCell = false;

						}

					}

					switch (elemento.stype) {

					case DGNFileHeader.DGNST_SHARED_CELL_DEFN:

						bInsideCell = true;

						cellFeature.set(ID_FIELD_ID,elemento.element_id);

//						cellRow[ID_FIELD_ID] = ValueFactory.createValue(elemento.element_id);

						cellFeature.set(ID_FIELD_LAYER,elemento.level);

//						cellRow[ID_FIELD_LAYER] = ValueFactory.createValue(elemento.level);

						cellFeature.set(ID_FIELD_COLOR,elemento.color);

//						cellRow[ID_FIELD_COLOR] = ValueFactory.createValue(elemento.color);

						cellFeature.set(ID_FIELD_ENTITY,"Shared Cell");

//						cellRow[ID_FIELD_ENTITY] = ValueFactory.createValue(

//						"Shared Cell");

						break;

					case DGNFileHeader.DGNST_CELL_HEADER:

						bInsideCell = true;

						DGNElemCellHeader psCellHeader = (DGNElemCellHeader) elemento;

						cellFeature.set(ID_FIELD_ID,elemento.element_id);

//						cellRow[ID_FIELD_ID] = ValueFactory.createValue(elemento.element_id);

						cellFeature.set(ID_FIELD_LAYER,elemento.level);

//						cellRow[ID_FIELD_LAYER] = ValueFactory.createValue(elemento.level);

						cellFeature.set(ID_FIELD_COLOR,elemento.color);

//						cellRow[ID_FIELD_COLOR] = ValueFactory.createValue(elemento.color);

						cellFeature.set(ID_FIELD_ENTITY,"Cell");

//						cellRow[ID_FIELD_ENTITY] = ValueFactory.createValue(

//						"Cell");

						complex_index_fill_color = m_DgnReader.DGNGetShapeFillInfo(elemento);

						// System.err.println("Cell Header " + complex_index_fill_color);

						break;

					case DGNFileHeader.DGNST_COMPLEX_HEADER:

						// bElementoCompuesto = true;

						// System.err.println("Complex Header");

//						contadorSubElementos = 0;

						DGNElemComplexHeader psComplexHeader = (DGNElemComplexHeader) elemento;

//						numSubElementos = psComplexHeader.numelems;

						complexFeature.set(ID_FIELD_ID,elemento.element_id);

//						complexRow[ID_FIELD_ID] = ValueFactory.createValue(elemento.element_id);

						complexFeature.set(ID_FIELD_LAYER,elemento.level);

//						complexRow[ID_FIELD_LAYER] = ValueFactory.createValue(elemento.level);

						complexFeature.set(ID_FIELD_COLOR,elemento.color);

//						complexRow[ID_FIELD_COLOR] = ValueFactory.createValue(elemento.color);

						complexFeature.set(ID_FIELD_ENTITY,"Complex");

//						complexRow[ID_FIELD_ENTITY] = ValueFactory.createValue(

//						"Complex");

						if (psComplexHeader.type == DGNFileHeader.DGNT_COMPLEX_SHAPE_HEADER) {

							bEsPoligono = true;

							// Si es un agujero, no conectamos con el anterior

							if ((psComplexHeader.properties & 0x8000) != 0) {

								bFirstHoleEntity = true;

							} else {

								// Miramos si tiene color de relleno

								// complex_index_fill_color = -1;

								// if (elemento.attr_bytes > 0) {

								complex_index_fill_color = m_DgnReader.DGNGetShapeFillInfo(elemento);

								// System.err.println("complex shape fill color = " + elemento.color);

								// }

							}

							bConnect = true;

						} else {

							bEsPoligono = false;

							bConnect = false;

						}

						break;

					case DGNFileHeader.DGNST_MULTIPOINT:

						// OJO: Si lo que viene en este multipoint es un elemento con type=11 (curve), se trata de una "parametric

						// spline curve". La vamos a tratar como si no fuera curva, pero seg?n la documentaci?n, los 2 primeros puntos

						// y los 2 ?ltimos puntos definen "endpoint derivatives" y NO se muestran.

						// TODAV?A HAY UN PEQUE?O FALLO CON EL FICHERO dgn-sample.dgn, pero lo dejo por ahora.

						// Es posible que tenga que ver con lo de los arcos (arco distorsionado), que

						// todav?a no est? metido.

						DGNElemMultiPoint psLine = (DGNElemMultiPoint) elemento;

						auxFeature.set(ID_FIELD_ID,elemento.element_id);

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

						auxFeature.set(ID_FIELD_ENTITY,"Multipoint");

//						auxRow[ID_FIELD_ENTITY] = ValueFactory.createValue(

//						"Multipoint");

						auxFeature.set(ID_FIELD_LAYER,elemento.level);

//						auxRow[ID_FIELD_LAYER] = ValueFactory.createValue(elemento.level);

						auxFeature.set(ID_FIELD_COLOR,elemento.color);

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

						if ((psLine.num_vertices == 2) &&

								(psLine.vertices[0].x == psLine.vertices[1].x) &&

								(psLine.vertices[0].y == psLine.vertices[1].y)) {

							auxFeature.set(ID_FIELD_ENTITY,"Point");

//							auxRow[ID_FIELD_ENTITY] = ValueFactory.createValue(

//							"Point");

							IGeometry geom=ShapeFactory.createPoint3D(psLine.vertices[0].x,

									psLine.vertices[0].y, psLine.vertices[0].z);

							auxFeature.set(ID_FIELD_GEOMETRY,geom);

//							auxFeature.setDefaultGeometry(geom);

							addDGNFeature(auxFeature);

//							addShape(new FPoint3D(psLine.vertices[0].x,

//							psLine.vertices[0].y, psLine.vertices[0].z),

//							auxRow);

						} else {

							GeneralPathX elShape = new GeneralPathX(GeneralPathX.WIND_EVEN_ODD);

							if (psLine.type == DGNFileHeader.DGNT_CURVE) {

								psLine.num_vertices = psLine.num_vertices - 4;

								for (int aux_n = 0;

								aux_n < psLine.num_vertices; aux_n++) {

									psLine.vertices[aux_n] = psLine.vertices[aux_n +

									                                         2];

								}

							}

							if ((psLine.type == DGNFileHeader.DGNT_SHAPE) &&

									((psLine.properties & 0x8000) != 0)) {

								// Invertimos el orden porque es un agujero

								elShape.moveTo(psLine.vertices[psLine.num_vertices -

								                               1].x,

								                               psLine.vertices[psLine.num_vertices - 1].y);

								for (int i = psLine.num_vertices - 2; i >= 0;

								i--)

									elShape.lineTo(psLine.vertices[i].x,

											psLine.vertices[i].y);

							} else {

								elShape.moveTo(psLine.vertices[0].x,

										psLine.vertices[0].y);

								for (int i = 1; i < psLine.num_vertices; i++)

									elShape.lineTo(psLine.vertices[i].x,

											psLine.vertices[i].y);

							}

							if ((psLine.vertices[0].x == psLine.vertices[psLine.num_vertices -

							                                             1].x) &&

							                                             (psLine.vertices[0].y == psLine.vertices[psLine.num_vertices -

							                                                                                      1].y)) {

								// Lo a?adimos tambi?n como pol?gono

								bEsPoligono = true;

								// Miramos si tiene color de relleno

								if (elemento.attr_bytes > 0) {

									elemento.color = m_DgnReader.DGNGetShapeFillInfo(elemento);

									// System.err.println("fill color = " + elemento.color);

									if (elemento.color != -1) {

										auxFeature.set(ID_FIELD_COLOR,elemento.color);

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

									}

								}

								if (elemento.complex == 0) {

									IGeometry geom=ShapeFactory.createPolygon2D(elShape);

									auxFeature.set(ID_FIELD_GEOMETRY,geom);

//									auxFeature.setDefaultGeometry(geom);

									addDGNFeature(auxFeature);

//									addShape(new FPolygon2D(elShape), auxRow);

								}

							}

							if (elemento.complex != 0) {

								// Si es un agujero o

								// es la primera entidad del agujero, lo a?adimos sin unir al anterior

								if (bFirstHoleEntity ||

										((psLine.type == DGNFileHeader.DGNT_SHAPE) &&

												((psLine.properties & 0x8000) != 0))) {

									elementoCompuesto.append(elShape, false);

									bFirstHoleEntity = false;

								} else {

									elementoCompuesto.append(elShape, bConnect);

								}

							} else {

								IGeometry geom=ShapeFactory.createPolyline2D(elShape);

								auxFeature.set(ID_FIELD_GEOMETRY,geom);

//								auxFeature.setDefaultGeometry(geom);

								addDGNFeature(auxFeature);

//								addShape(new FPolyline2D(elShape), auxRow);

							}

						}

						break;

					case DGNFileHeader.DGNST_ARC:

						// m_DgnReader.DGNDumpElement(m_DgnReader.getInfo(), elemento,"");

						DGNElemArc psArc = (DGNElemArc) elemento;

						// La definici?n de arco de MicroStation es distinta a la de Java.

						// En el dgn el origin se entiende que es el centro del arco,

						// y a la hora de crear un Arc2D las 2 primeras coordenadas son

						// la esquina inferior izquierda del rect?ngulo que rodea al arco.

						// 1.- Creamos la elipse sin rotaci?n.

						// 2.- Creamos el arco

						// 3.- Rotamos el resultado

						/* System.out.println("Arco con primari axis: " + psArc.primary_axis +

						 " start angle: " + psArc.startang + " sweepang = " + psArc.sweepang);

						 System.out.println("secondaria axis: " + psArc.secondary_axis +

						 " rotation = " + psArc.rotation); */

						AffineTransform mT = AffineTransform.getRotateInstance(Math.toRadians(

								psArc.rotation), psArc.origin.x,

								psArc.origin.y);

						// mT.preConcatenate(AffineTransform.getScaleInstance(100.0,100.0));

						Arc2D.Double elArco = new Arc2D.Double(psArc.origin.x -

								psArc.primary_axis,

								psArc.origin.y - psArc.secondary_axis,

								2.0 * psArc.primary_axis,

								2.0 * psArc.secondary_axis, -psArc.startang,

								-psArc.sweepang, Arc2D.OPEN);

						// Ellipse2D.Double elArco = new Ellipse2D.Double(psArc.origin.x - psArc.primary_axis,

						// 		psArc.origin.y - psArc.secondary_axis,2.0 * psArc.primary_axis, 2.0 * psArc.secondary_axis);

						GeneralPathX elShapeArc = new GeneralPathX(elArco);

						// Transformamos el GeneralPahtX porque si transformamos elArco nos lo convierte

						// a GeneralPath y nos guarda las coordenadas en float, con la correspondiente p?rdida de precisi?n

						elShapeArc.transform(mT);

						if (m_DgnReader.getInfo().dimension == 3) {

							//Aqu? podr?amos hacer cosas con la coordenada Z

						}

						auxFeature.set(ID_FIELD_ID,elemento.element_id);

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

						auxFeature.set(ID_FIELD_ENTITY,"Arc");

//						auxRow[ID_FIELD_ENTITY] = ValueFactory.createValue(

//						"Arc");

						auxFeature.set(ID_FIELD_LAYER,elemento.level);

//						auxRow[ID_FIELD_LAYER] = ValueFactory.createValue(elemento.level);

						auxFeature.set(ID_FIELD_COLOR,elemento.color);

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

						/* Line2D.Double ejeMayor = new Line2D.Double(psArc.origin.x - psArc.primary_axis, psArc.origin.y,

						 psArc.origin.x + psArc.primary_axis, psArc.origin.y);

						 lyrLines.addShape(new FShape(FConstant.SHAPE_TYPE_POLYLINE, new GeneralPathX(ejeMayor)), auxRow); */

						// lyrLines.addShape(new FShape(FConstant.SHAPE_TYPE_POLYLINE, elShapeArc), auxRow);

						if (elemento.complex != 0) {

							// Esto es una posible fuente de fallos si detr?s de una

							// elipse vienen m?s cosas pegadas. Deber?amos volver

							// a conectar una vez pasada la elipse.

							if (elemento.type == DGNFileHeader.DGNT_ELLIPSE) {

								bConnect = false;

							}

							// SI LA ELIPSE ES UN AGUJERO, SE A?ADE SIN PEGAR

							// Y EL ELEMENTO ES UN POLIGONO

							if (bFirstHoleEntity ||

									((elemento.type == DGNFileHeader.DGNT_SHAPE) &&

											((elemento.properties & 0x8000) != 0))) {

								elementoCompuesto.append(elShapeArc, false);

								bFirstHoleEntity = false;

							} else {

								elementoCompuesto.append(elShapeArc, bConnect);

							}

						} else {

							IGeometry geom=ShapeFactory.createPolyline2D(elShapeArc);

							auxFeature.set(ID_FIELD_GEOMETRY,geom);

//							auxFeature.setDefaultGeometry(geom);

							addDGNFeature(auxFeature);

//							addShape(new FPolyline2D(elShapeArc), auxRow);

							if (psArc.type == DGNFileHeader.DGNT_ELLIPSE) {

								geom=ShapeFactory.createPolygon2D(elShapeArc);

								auxFeature.set(ID_FIELD_GEOMETRY,geom);

//								auxFeature.setDefaultGeometry(geom);

								addDGNFeature(auxFeature);

//								addShape(new FPolygon2D(elShapeArc), auxRow);

							}

						}

						// System.err.println("Entra un Arco");

						break;

					case DGNFileHeader.DGNST_TEXT:

						DGNElemText psText = (DGNElemText) elemento;

						auxFeature.set(ID_FIELD_ID,elemento.element_id);

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

						auxFeature.set(ID_FIELD_ENTITY,"Text");

//						auxRow[ID_FIELD_ENTITY] = ValueFactory.createValue(

//						"Text");

						auxFeature.set(ID_FIELD_LAYER,elemento.level);

//						auxRow[ID_FIELD_LAYER] = ValueFactory.createValue(elemento.level);

						auxFeature.set(ID_FIELD_COLOR,elemento.color);

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

						heightText = (float) psText.height_mult;

						auxFeature.set(ID_FIELD_HEIGHTTEXT,heightText);

//						auxRow[ID_FIELD_HEIGHTTEXT] = ValueFactory.createValue(heightText);

						auxFeature.set(ID_FIELD_ROTATIONTEXT,psText.rotation);

//						auxRow[ID_FIELD_ROTATIONTEXT] = ValueFactory.createValue(psText.rotation);

						auxFeature.set(ID_FIELD_TEXT,psText.string);

//						auxRow[ID_FIELD_TEXT] = ValueFactory.createValue(psText.string); // .trim();

						IGeometry geom=ShapeFactory.createPoint3D(psText.origin.x,

								psText.origin.y, psText.origin.z);

						auxFeature.set(ID_FIELD_GEOMETRY,geom);

//						auxFeature.setDefaultGeometry(geom);

						addDGNFeature(auxFeature);

//						addShape(elShapeTxt, auxRow);

						// System.out.println("Rotaci?n texto: " + psText.rotation + "Altura Texto = " + heightText);

						/* System.out.println("  origin=(" + psText.origin.x +

						 ", " + psText.origin.y + ") rotation=" +

						 psText.rotation + "\n" + "  font=" +

						 psText.font_id + " just=" +

						 psText.justification + "length_mult=" +

						 psText.length_mult + " height_mult=" +

						 psText.height_mult + "\n" + "  string =" +

						 new String(psText.string).toString().trim() +

						 "\n"); */

						break;

						/* default:

						 m_DgnReader.DGNDumpElement(m_DgnReader.getInfo(), elemento, "");

						 */

					} // switch

				} // if

			} // for

			if (bElementoCompuesto) {

				if (bInsideCell) {

					auxFeature=cellFeature;

//					auxRow = cellRow;

				} else {

					auxFeature=complexFeature;

//					auxRow = complexRow;

				}

				// System.err.println("Entidad compuesta. bInsideCell = " + bInsideCell + " auxRow = " + auxRow[ID_FIELD_ENTITY]);

				IGeometry geom=ShapeFactory.createPolyline2D(elementoCompuesto);

				auxFeature.set(ID_FIELD_GEOMETRY,geom);

//				auxFeature.setDefaultGeometry(geom);

				addDGNFeature(auxFeature);

//				addShape(new FPolyline2D(elementoCompuesto), auxRow);

				if (bEsPoligono) {

					if (complex_index_fill_color != -1) {

						auxFeature.set(ID_FIELD_COLOR,complex_index_fill_color);

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

					}

					geom=ShapeFactory.createPolygon2D(elementoCompuesto);

					auxFeature.set(ID_FIELD_GEOMETRY,geom);

//					auxFeature.setDefaultGeometry(geom);

					addDGNFeature(auxFeature);

//					addShape(new FPolygon2D(elementoCompuesto), auxRow);

				}

			}

			cellFeature.stopLoading();

			auxFeature.stopLoading();

			complexFeature.stopLoading();

			defaultLegend = LegendFactory.createVectorialUniqueValueLegend(FShape.MULTI);

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

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

			ISymbol myDefaultSymbol = SymbologyFactory.

			createDefaultSymbolByShapeType(FShape.MULTI);

			defaultLegend.setDefaultSymbol(myDefaultSymbol);

		}catch (IsNotFeatureSettingException e) {

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

		} catch (ReadException e) {

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

		}

//		ISymbol theSymbol = null;

//		try {

//		for (long j = 0; j < getFeatureCount(); j++) {

//		IFeature feat=(IFeature)getFeature((int)j);

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

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

//		Color c = m_DgnReader.DGNLookupColor(

//		clave.getValue());

//		theSymbol =	SymbologyFactory.

//		createDefaultSymbolByShapeType(featureType.getGeometryTypes()[0], c);

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

//		if (theSymbol instanceof IMarkerSymbol) {

//		((IMarkerSymbol) theSymbol).setSize(1);

//		}

//		if (theSymbol instanceof ILineSymbol) {

//		((ILineSymbol) theSymbol).setLineWidth(1);

//		}

//		if (theSymbol instanceof IFillSymbol) {

//		((IFillSymbol) theSymbol).getOutline().setLineColor(c);

//		((IFillSymbol) theSymbol).getOutline().setLineWidth(1);

//		((IFillSymbol) theSymbol).setFillColor(null);

//		}

//		// theSymbol.setStyle(FConstant.SYMBOL_STYLE_FILL_TRANSPARENT);

//		defaultLegend.addSymbol(clave, theSymbol);

//		}

//		if ("Text".equalsIgnoreCase(((StringValue) rs.getFieldValue(j, ID_FIELD_ENTITY)).toString())) {

//		}

//		} // for

//		} catch (ReadException e) {

//		throw new OpenException(getName(),e);

//		}

		super.doClose();

		close();

		this.metadata=null;

		this.featureType=null;

		this.defaultLegend=null;

			IExtent extent=getFullExtent();

	private void addDGNFeature(IFeature feature) throws ReadException{

		this.addFeature(new DGNFeature(feature));

	}