Application: gvSIG desktop

/*

 * Created on 27-dic-2004

 *

 * TODO To change the template for this generated file go to

 * Window - Preferences - Java - Code Generation - Code and Comments

 */

package com.iver.cit.gvsig.fmap.drivers;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import javax.swing.table.DefaultTableModel;

import com.hardcode.gdbms.engine.data.DriverException;

import com.hardcode.gdbms.engine.data.FileDriver;

import com.hardcode.gdbms.engine.values.Value;

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

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

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

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

import com.iver.cit.gvsig.fmap.operations.strategies.MemoryShapeInfo;

/**

 * @author FJP

 *

 * TODO To change the template for this generated type comment go to

 * Window - Preferences - Java - Code Generation - Code and Comments

 */

public abstract class MemoryDriver implements VectorialFileDriver, FileDriver, BoundedShapes {

    private MemoryShapeInfo memShapeInfo = new MemoryShapeInfo();

    private ArrayList arrayGeometries = new ArrayList();

    private Rectangle2D fullExtent;

    private int m_Position;

    private DefaultTableModel m_TableModel = new DefaultTableModel();

    public DefaultTableModel getTableModel()

    {

    	return m_TableModel;

    }

    public void addShape(FShape shp, Object [] row) {

    	if (shp == null) return; // No a?adimos nada

    	Rectangle2D boundsShp = shp.getBounds(); 

        memShapeInfo.addShapeInfo(boundsShp, shp.getShapeType());

        arrayGeometries.add(ShapeFactory.createGeometry(shp));

        m_TableModel.addRow(row);

        try {

			fullExtent = getFullExtent();

		} catch (IOException e) {

			e.printStackTrace();

		}

        if (fullExtent == null)

        {

        	fullExtent = boundsShp;

        }

        else

        	fullExtent.add(boundsShp);

        m_Position++;

    }

    public Rectangle2D getShapeBounds(int index) throws IOException

	{

		return memShapeInfo.getBoundingBox(index);

	}

	public int getShapeType(int index) 

	{

		return memShapeInfo.getType(index);

	}

	/* (non-Javadoc)

	 * @see com.iver.cit.gvsig.fmap.drivers.VectorialFileDriver#open(java.io.File)

	 */

	public abstract void open(File f) throws IOException;

	/* (non-Javadoc)

	 * @see com.iver.cit.gvsig.fmap.drivers.VectorialFileDriver#close()

	 */

	public void close() throws IOException {

		// No hago nada, lo he abierto y cerrado en el inicialize de la clase hija

	}

	/* (non-Javadoc)

	 * @see com.iver.cit.gvsig.fmap.drivers.VectorialFileDriver#getShape(int)

	 */

	public IGeometry getShape(int index) throws IOException {

		return (IGeometry) arrayGeometries.get(index);

	}

	/* (non-Javadoc)

	 * @see com.iver.cit.gvsig.fmap.drivers.VectorialFileDriver#getShapeCount()

	 */

	public int getShapeCount() throws IOException {

		return arrayGeometries.size();

	}

	/* (non-Javadoc)

	 * @see com.iver.cit.gvsig.fmap.drivers.VectorialFileDriver#getFullExtent()

	 */

	public Rectangle2D getFullExtent() throws IOException {

		return fullExtent;

	}

	/* (non-Javadoc)

	 * @see com.iver.cit.gvsig.fmap.drivers.VectorialFileDriver#initialize()

	 */

	public void initialize() throws IOException {

	}

	/* (non-Javadoc)

	 * @see com.iver.cit.gvsig.fmap.drivers.VectorialFileDriver#accept(java.io.File)

	 */

	public abstract boolean accept(File f);

	/* (non-Javadoc)

	 * @see com.iver.cit.gvsig.fmap.drivers.VectorialDriver#getShapeType()

	 */

	public int getShapeType() {

		return 15;

	}

	/* (non-Javadoc)

	 * @see com.hardcode.driverManager.Driver#getName()

	 */

	public abstract String getName();

	/* (non-Javadoc)

	 * @see com.hardcode.gdbms.engine.data.FileDriver#fileAccepted(java.io.File)

	 */

	public boolean fileAccepted(File f) {

		return false;

	}

	/* (non-Javadoc)

	 * @see com.hardcode.gdbms.engine.data.ReadDriver#getFieldValue(long, int)

	 */

	public Value getFieldValue(long rowIndex, int fieldId) throws DriverException {

		return (Value) m_TableModel.getValueAt((int) rowIndex, fieldId);

	}

	/* (non-Javadoc)

	 * @see com.hardcode.gdbms.engine.data.ReadDriver#getFieldCount()

	 */

	public int getFieldCount() throws DriverException {

		return m_TableModel.getColumnCount();

	}

	/* (non-Javadoc)

	 * @see com.hardcode.gdbms.engine.data.ReadDriver#getFieldName(int)

	 */

	public String getFieldName(int fieldId) throws DriverException {

		return m_TableModel.getColumnName(fieldId);

	}

	/* (non-Javadoc)

	 * @see com.hardcode.gdbms.engine.data.ReadDriver#getRowCount()

	 */

	public long getRowCount() throws DriverException {

		return arrayGeometries.size();

	}

}

package com.iver.cit.gvsig.fmap.drivers.dgn;

import java.awt.geom.AffineTransform;

import java.awt.geom.Arc2D;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.TreeMap;

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

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

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

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

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

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

import com.iver.cit.gvsig.fmap.core.v02.FConstant;

import com.iver.cit.gvsig.fmap.core.v02.FSymbol;

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

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

/**

 * DOCUMENT ME!

 *

 * @author Vicente Caballero Navarro

 */

public class DgnMemoryDriver extends MemoryDriver {

	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;

	DGNReader m_DgnReader;

	private String path;

	private File m_Fich;

    /**

     * @see com.iver.cit.gvsig.fmap.drivers.VectorialFileDriver#open(java.io.File)

     */

    public void open(File f) throws IOException {

    	m_Fich = f;

    }

    /**

     * @see com.iver.cit.gvsig.fmap.drivers.VectorialFileDriver#initialize()

     */

    public void initialize() throws IOException {

		float heightText = 10;

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

    	Object [] auxRow = new Object[7];

    	Object [] cellRow = new Object[7];

    	Object [] complexRow = new Object[7];

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

		// Ahora las rellenamos.

		FShape aux;

		boolean bElementoCompuesto = false, 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, 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;

	        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)

		        			{

		        				auxRow[ID_FIELD_ENTITY] = cellRow[ID_FIELD_ENTITY];

		        			}

		        			else

		        			{

		        				auxRow = complexRow;

		        			}

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

		        			addShape(new FPolyline2D(elementoCompuesto), auxRow);

		        			if (bEsPoligono)

		        			{

								if (complex_index_fill_color != -1)

									auxRow[ID_FIELD_COLOR] = new Integer(complex_index_fill_color);

		        				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;

						cellRow[ID_FIELD_ID] = new Integer(elemento.element_id);

		                cellRow[ID_FIELD_LAYER] = new Integer(elemento.level);

		                cellRow[ID_FIELD_COLOR] = new Integer(elemento.color);

		                cellRow[ID_FIELD_ENTITY] = new String("Shared Cell");

						break;

					case DGNFileHeader.DGNST_CELL_HEADER:

						bInsideCell = true;

						DGNElemCellHeader psCellHeader = (DGNElemCellHeader) elemento;

						cellRow[ID_FIELD_ID] = new Integer(elemento.element_id);

		                cellRow[ID_FIELD_LAYER] = new Integer(elemento.level);

		                cellRow[ID_FIELD_COLOR] = new Integer(elemento.color);

		                cellRow[ID_FIELD_ENTITY] = new String("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;

						complexRow[ID_FIELD_ID] = new Integer(elemento.element_id);

		                complexRow[ID_FIELD_LAYER] = new Integer(elemento.level);

		                complexRow[ID_FIELD_COLOR] = new Integer(elemento.color);

		                complexRow[ID_FIELD_ENTITY] = new String("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;			                		                

		                auxRow[ID_FIELD_LAYER] = new Integer(elemento.level);

		                auxRow[ID_FIELD_COLOR] = new Integer(elemento.color);

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

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

		                {

		                	auxRow[ID_FIELD_ENTITY] = new String("Point");

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

			               }

			               auxRow[ID_FIELD_ID] = new Integer(elemento.element_id);

		                	auxRow[ID_FIELD_ENTITY] = new String("Multipoint");

		                	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)

										auxRow[ID_FIELD_COLOR] = new Integer(elemento.color);

								}

		                		if (elemento.complex == 0)

		                			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		                	

	                			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

     	              }

     	              auxRow[ID_FIELD_ID] = new Integer(elemento.element_id);

		               auxRow[ID_FIELD_ENTITY] = new String("Arc");

		               auxRow[ID_FIELD_LAYER] = new Integer(elemento.level);

		               auxRow[ID_FIELD_COLOR] = new Integer(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	

		            	{

		            		addShape(new FPolyline2D(elShapeArc), auxRow);

		            		if (psArc.type == DGNFileHeader.DGNT_ELLIPSE)

		            			addShape(new FPolygon2D(elShapeArc), auxRow);

		            	}

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

	                    break;

	                case DGNFileHeader.DGNST_TEXT: 

	                    DGNElemText psText = (DGNElemText) elemento;

		                FPoint2D elShapeTxt = new FPoint3D(

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

		                auxRow[ID_FIELD_ID] = new Integer(elemento.element_id);

		                auxRow[ID_FIELD_ENTITY] = new String("Text");

		                auxRow[ID_FIELD_LAYER] = new Integer(elemento.level);

		                auxRow[ID_FIELD_COLOR] = new Integer(elemento.color);

		                heightText = (float) psText.height_mult;

		                auxRow[ID_FIELD_HEIGHTTEXT] = new Double(heightText);

		                auxRow[ID_FIELD_ROTATIONTEXT] = new Double(psText.rotation);

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

		                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)

			{

				auxRow = cellRow;

			}

			else

			{

				auxRow = complexRow;

			}

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

			addShape(new FPolyline2D(elementoCompuesto), auxRow);

			if (bEsPoligono)

			{

				if (complex_index_fill_color != -1)

					auxRow[ID_FIELD_COLOR] = new Integer(complex_index_fill_color);

				addShape(new FPolygon2D(elementoCompuesto), auxRow);

			}

		}

		/* Legend rendererLines = lyrLines.getLegend();

		rendererLines.setField("Color");

		rendererLines.setLegendType(FConstant.LEGEND_TYPE_VALUE);

        FRecordset rs = lyrLines.getRecordset();

		rendererLines.m_symbolList = new TreeMap(

				new Comparator() {

					public int compare(Object o1, Object o2)

					{

						int resul = -1;

						if ((o1 != null) && (o2 != null))

						{

							double d2 = Double.parseDouble((String)o2);

							double d1 = Double.parseDouble((String)o1);

							resul = (int) (d1-d2);

						}

						return resul;

					}

				}		

			); 

		String clave;

		FSymbol theSymbol = null;

		for (int j = 0; j < lyrLines.m_NumShapes; j++)

		{

			rs.moveTo(j);

			clave =rs.getFieldValueAsString(ID_FIELD_COLOR);

			////Comprobar que no esta repetido y no hace falta introducir en el hashtable el campo junto con el simbolo.

			if (!rendererLines.m_symbolList.containsKey(clave)) {

				//si no esta creado el simbolo se crea

				theSymbol = new FSymbol(lyrLines.m_shapeType);				

				theSymbol.m_Descrip = clave.toString();

				theSymbol.m_Color = m_DgnReader.DGNLookupColor(rs.getFieldValueAsNumber(ID_FIELD_COLOR).intValue());

				rendererLines.addSymbol(clave, theSymbol);								

			}

			lyrLines.m_legendValues[j] = rs.getFieldValueAsString(ID_FIELD_COLOR);

		} // for

		Legend rendererPoly = lyrPolygons.getLegend();

		rendererPoly.setField("Color");

		rendererPoly.setLegendType(FConstant.LEGEND_TYPE_VALUE);

        rs = lyrPolygons.getRecordset();

        rendererPoly.m_symbolList = new TreeMap(

				new Comparator() {

					public int compare(Object o1, Object o2)

					{

						int resul = -1;

						if ((o1 != null) && (o2 != null))

						{

							double d2 = Double.parseDouble((String)o2);

							double d1 = Double.parseDouble((String)o1);

							resul = (int) (d1-d2);

						}

						return resul;

					}

				}		

			);  

		for (int j = 0; j < lyrPolygons.m_NumShapes; j++)

		{

			rs.moveTo(j);

			clave =rs.getFieldValueAsString(ID_FIELD_COLOR);

			////Comprobar que no esta repetido y no hace falta introducir en el hashtable el campo junto con el simbolo.

			if (!rendererPoly.m_symbolList.containsKey(clave)) {

				//si no esta creado el simbolo se crea

				theSymbol = new FSymbol(lyrPolygons.m_shapeType);				

				theSymbol.m_Descrip = clave.toString();

				theSymbol.m_Color = m_DgnReader.DGNLookupColor(rs.getFieldValueAsNumber(ID_FIELD_COLOR).intValue());

				rendererPoly.addSymbol(clave, theSymbol);								

			}

			lyrPolygons.m_legendValues[j] = rs.getFieldValueAsString(ID_FIELD_COLOR);

		} // for

    	*/

    }

    /**

	 * @see com.hardcode.driverManager.Driver#getType()

	 */

	public String getName() {

		return "gvSIG DGN Memory Driver";

	}

	/**

	 * @see com.iver.cit.gvsig.fmap.drivers.VectorialFileDriver#accept(java.io.File)

	 */

	public boolean accept(File f) {

		return f.getName().toUpperCase().endsWith("DGN");

	}

}

	// Campos del registro en cache:

	Object [] auxRow = new Object[7];

	Object [] cellRow = new Object[7];

	Object [] complexRow = new Object[7];

	/**

	 * Traduce las posiciones de comienzo de las entidades del DGN

	 * a nuestras entidades FShape. (Una FShape puede corresponder

	 * a varias entidades de un DGN).

	 */

	private int[] m_posShapes;

		arrayFields.add("HeightText");

		arrayFields.add("RotationText");

		arrayFields.add("Text");