Application: gvSIG desktop

/*

 * @(#)DXFMemoryDriver    29-dic-2004

 * 

 * @author jmorell (jose.morell@gmail.com)

 */

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

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

import java.awt.Color;

import java.awt.Font;

import java.awt.Graphics2D;

import java.awt.Paint;

import java.awt.Rectangle;

import java.awt.TexturePaint;

import java.awt.geom.AffineTransform;

import java.awt.geom.Arc2D;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.geom.Ellipse2D;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Vector;

import org.cresques.cts.IProjection;

import org.cresques.cts.ProjectionPool;

import org.cresques.io.DxfFile;

import org.cresques.px.IObjList;

import org.cresques.px.dxf.AcadColor;

import org.cresques.px.dxf.DxfCalArcs;

import org.cresques.px.dxf.DxfArc;

import org.cresques.px.dxf.DxfCalArcs;

import org.cresques.px.dxf.DxfCircle;

import org.cresques.px.dxf.DxfEllipse;

import org.cresques.px.dxf.DxfEntity;

import org.cresques.px.dxf.DxfEntityMaker;

import org.cresques.px.dxf.DxfFeatureMaker;

import org.cresques.px.dxf.DxfHeaderManager;

import org.cresques.px.dxf.DxfLine;

import org.cresques.px.dxf.DxfLwPolyline;

import org.cresques.px.dxf.DxfPoint;

import org.cresques.px.dxf.DxfPolyline;

import org.cresques.px.gml.Feature;

import org.cresques.px.gml.InsPoint;

import org.cresques.px.gml.LineString;

import org.cresques.px.gml.Point;

import org.cresques.px.gml.Polygon;

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

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

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

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

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

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

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

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

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

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

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.IGeometry;

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

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.DriverAttributes;

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

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

import com.iver.cit.gvsig.fmap.edition.cad.TrigonometricalFunctions;

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

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

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

/**

 * Lector de entidades procedentes de un DXF. Las convierte al modelo de objetos CAD 

 * del piloto de CAD.

 * 

 * @author jmorell (jose.morell@gmail.com)

 * @version 29-dic-2004

 */

public class DXFCadDriver extends MemoryDriver implements WithDefaultLegend {

        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_ELEVATION=4;

        private final int ID_FIELD_THICKNESS=5;

        private final int ID_FIELD_TEXT=6;

        private final int ID_FIELD_HEIGHTTEXT=7;

        private final int ID_FIELD_ROTATIONTEXT=8;

        VectorialUniqueValueLegend defaultLegend;

        private String path;

        private File m_Fich;

        //private DxfFile.EntityFactory featureMaker;

        private DxfFile.EntityFactory entityMaker;

        private DxfFile dxfEntityFile;

        private IObjList.vector entities;

        private DriverAttributes attr = new DriverAttributes();

        /**

         * Habilita la utilizaci?n del lector del HEADER del DXF.

         */

        private DxfFile.VarSettings headerManager;

        /* (non-Javadoc)

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

         */

        public void open(File f) throws IOException {

            m_Fich = f;

        }

        public void initialize() throws IOException {

                clearGeometryArray();

                float heightText = 10;

                attr.setLoadedInMemory(true);

                IProjection proj = ProjectionPool.get("EPSG:23030");

                /*featureMaker = new DxfFeatureMaker(proj);

                dxfFeatureFile = new DxfFile(proj, m_Fich.getAbsolutePath(), featureMaker);

                dxfFeatureFile.load();

                features = (IObjList.vector)((DxfFeatureMaker)featureMaker).getObjects();*/

                entityMaker = new DxfEntityMaker(proj);

                dxfEntityFile = new DxfFile(proj, m_Fich.getAbsolutePath(), entityMaker);

                dxfEntityFile.load();

                entities = (IObjList.vector)((DxfEntityMaker)entityMaker).getObjects();

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

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

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

                //int nAtt = entityMaker.getAttributes().size();

                // Campos de las MemoryLayer:

            //Value[] auxRow = new Value[9+nAtt];

            Value[] auxRow = new Value[9];

                ArrayList arrayFields = new ArrayList();

                arrayFields.add("ID");

                arrayFields.add("Entity");

                arrayFields.add("Layer");

                arrayFields.add("Color");

                arrayFields.add("Elevation");

                arrayFields.add("Thickness");

                arrayFields.add("Text");

                arrayFields.add("HeightText");

                arrayFields.add("RotationText");

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

                        String att[] = new String[2];

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

                        arrayFields.add(att[0]);

                }*/

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

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

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

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

            auxRow[ID_FIELD_TEXT] = ValueFactory.createNullValue();

                        //Feature fea = (Feature)entities.get(i);

                        DxfEntity ent = (DxfEntity)entities.get(i);

                        if (ent instanceof DxfPoint) {

                                DxfPoint point = (DxfPoint)ent;

                                Point2D pto = new Point2D.Double();

                                pto = (Point2D.Double)point.getPt();

                                FShape nuevoShp;

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

                auxRow[ID_FIELD_ENTITY] = ValueFactory.createValue(new String("dxfEntity"));

                auxRow[ID_FIELD_LAYER] = ValueFactory.createValue(new String("layer"));

                int auxInt = Integer.parseInt("0");

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

                    double auxE = Double.parseDouble("0.0");

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

                    double auxT = Double.parseDouble("0.0");

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

                nuevoShp = new FPoint2D(pto.getX(),pto.getY());                                

                                addShape(nuevoShp, auxRow);

                        } else if (ent instanceof DxfLine) {

                                DxfLine dxfLine = (DxfLine)ent;

                                Point2D init = dxfLine.getPts()[0];

                                Point2D end = dxfLine.getPts()[1];

                                GeneralPathX gp = new GeneralPathX();

                                gp.moveTo(init.getX(), init.getY());

                                gp.lineTo(end.getX(), end.getY());

                                FPolyline2D fLine = new FPolyline2D(gp);

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

                auxRow[ID_FIELD_ENTITY] = ValueFactory.createValue(new String("dxfEntity"));

                auxRow[ID_FIELD_LAYER] = ValueFactory.createValue(new String("layer"));

                int auxInt = Integer.parseInt("0");

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

                    double auxE = Double.parseDouble("0.0");

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

                    double auxT = Double.parseDouble("0.0");

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

                                //FShape nuevoShp = new FPoint3D(pto.getX(),pto.getY(),0);

                                addShape(fLine, auxRow);

                        } else if (ent instanceof DxfPolyline) {

                                DxfPolyline dxfPolyline = (DxfPolyline)ent;

                                int vertexNumber = dxfPolyline.getPts().size();

                                int flag = dxfPolyline.getFlags();

                                int geomNumber = 0;

                                if (flag==0 || flag==128) {

                                        geomNumber = vertexNumber-1;

                                } else if (flag==1 || flag==129){

                                        geomNumber = vertexNumber;

                                }

                                IGeometry[] geoms = new IGeometry[geomNumber];

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

                                        Point2D init = (Point2D)dxfPolyline.getPts().get(j);

                                        Point2D end = new Point2D.Double();

                                        if (j==geomNumber-1 && (flag==1 || flag==129)) {

                                                end = (Point2D)dxfPolyline.getPts().get(0);

                                        } else {

                                                end = (Point2D)dxfPolyline.getPts().get(j+1);

                                        }

                                        if (((Double)dxfPolyline.getBulges().get(j)).doubleValue()==0) {

                                                GeneralPathX gp = new GeneralPathX();

                                                gp.moveTo(init.getX(), init.getY());

                                                gp.lineTo(end.getX(), end.getY());

                                                //System.out.println("flag = " + flag);

                                                //if (j==geomNumber-1 && flag==1) {

                                                        /*Point2D first = (Point2D)dxfPolyline.getPts().get(0);

                                                        gp.lineTo(first.getX(), first.getY());*/

                                                        /*System.out.println("Polyline: Cierra el gp.");

                                                        gp.closePath();

                                                }*/

                                                geoms[j] = (IGeometry)ShapeFactory.createPolyline2D(gp);

                                        } else if (((Double)dxfPolyline.getBulges().get(j)).doubleValue()>0) {

                                                //IGeometry arc = (IGeometry)ShapeFactory.createArc();

                                                DxfCalArcs dxfCalArcs = new DxfCalArcs(init, end, ((Double)dxfPolyline.getBulges().get(j)).doubleValue());

                                                Vector arc = (Vector)dxfCalArcs.getCentralPoint();

                                                Point2D cent = (Point2D)arc.get(0);

                                                //System.out.println("init = " + init);

                                                //System.out.println("cent = " + cent);

                                                //System.out.println("end = " + end);

                                                geoms[j] = (IGeometry)ShapeFactory.createArc(init, cent, end);

                                        } else if (((Double)dxfPolyline.getBulges().get(j)).doubleValue()<0) {

                                                //IGeometry arc = (IGeometry)ShapeFactory.createArc();

                                                DxfCalArcs dxfCalArcs = new DxfCalArcs(init, end, ((Double)dxfPolyline.getBulges().get(j)).doubleValue());

                                                Vector arc = (Vector)dxfCalArcs.getCentralPoint();

                                                Point2D cent = (Point2D)arc.get(0);

                                                //System.out.println("init = " + init);

                                                //System.out.println("cent = " + cent);

                                                //System.out.println("end = " + end);

                                                geoms[j] = (IGeometry)ShapeFactory.createArc(init, cent, end);

                                                //((FArc2D)geoms[j].getShapes()[0]).setNegativeBulgeFlag(true);

                                        }

                                }

                                FGeometryCollection gc = new FGeometryCollection(geoms);

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

                auxRow[ID_FIELD_ENTITY] = ValueFactory.createValue(new String("dxfEntity"));

                auxRow[ID_FIELD_LAYER] = ValueFactory.createValue(new String("layer"));

                int auxInt = Integer.parseInt("0");

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

                    double auxE = Double.parseDouble("0.0");

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

                    double auxT = Double.parseDouble("0.0");

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

                                //FShape nuevoShp = new FPoint3D(pto.getX(),pto.getY(),0);

                                addGeometry(gc, auxRow);

                        /*} else if (ent instanceof DxfLwPolyline) {

                                DxfLwPolyline dxfLwPolyline = (DxfLwPolyline)ent;

                                int vertexNumber = dxfLwPolyline.getPts().size();

                                int geomNumber = vertexNumber-1;

                                int flag = dxfLwPolyline.getFlags();

                                IGeometry[] geoms = new IGeometry[geomNumber];

                                GeneralPathX gp = new GeneralPathX();

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

                                        // lines

                                        Point2D init = (Point2D)dxfLwPolyline.getPts().get(j);

                                        Point2D end = (Point2D)dxfLwPolyline.getPts().get(j+1);

                                        gp = new GeneralPathX();

                                        gp.moveTo(init.getX(), init.getY());

                                        gp.lineTo(end.getX(), end.getY());

                                        System.out.println("flag = " + flag);

                                        if (j==geomNumber-1 && flag==1) {

                                                /*Point2D first = (Point2D)dxfLwPolyline.getPts().get(0);

                                                gp.lineTo(first.getX(), first.getY());*/

                                                /*System.out.println("LwPolyline: Cierra el gp.");

                                                gp.closePath();

                                        }

                                        geoms[j] = (IGeometry)ShapeFactory.createPolyline2D(gp);

                                        //IGeometry arc = (IGeometry)ShapeFactory.createArc();

                                }

                                FGeometryCollection gc = new FGeometryCollection(geoms);

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

                auxRow[ID_FIELD_ENTITY] = ValueFactory.createValue(new String("dxfEntity"));

                auxRow[ID_FIELD_LAYER] = ValueFactory.createValue(new String("layer"));

                int auxInt = Integer.parseInt("0");

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

                    double auxE = Double.parseDouble("0.0");

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

                    double auxT = Double.parseDouble("0.0");

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

                                //FShape nuevoShp = new FPoint3D(pto.getX(),pto.getY(),0);

                                addGeometry(gc, auxRow);*/

                        } else if (ent instanceof DxfArc) {

                                DxfArc arc = (DxfArc)ent;

                                Point2D pc = arc.getCentralPoint();

                                Point2D in = arc.getInit();

                                Point2D e = arc.getEnd();

                                Arc2D arco = TrigonometricalFunctions.createArc(in, pc, e);

                                FArc2D fArc = new FArc2D(new GeneralPathX(arco),in,pc,e);

                                //FArc2D fArc = new FArc2D(gp, c, in, e); 

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

                auxRow[ID_FIELD_ENTITY] = ValueFactory.createValue(new String("dxfEntity"));

                auxRow[ID_FIELD_LAYER] = ValueFactory.createValue(new String("layer"));

                int auxInt = Integer.parseInt("0");

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

                    double auxE = Double.parseDouble("0.0");

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

                    double auxT = Double.parseDouble("0.0");

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

                                //FShape nuevoShp = new FPoint3D(pto.getX(),pto.getY(),0);

                                addShape(fArc, auxRow);                                        

                        } else if (ent instanceof DxfCircle) {

                                DxfCircle circle = (DxfCircle)ent;

                                Point2D c = circle.getCenter();

                                double r = circle.getRadius();

                                //System.out.println("r = " + r);

                                //System.out.println("c = " + c);

                                Arc2D.Double arc = new Arc2D.Double(c.getX()-r , c.getY()-r , 2*r , 2*r , 0 , 360 , Arc2D.OPEN);

                                FCircle2D fCircle = new FCircle2D(new GeneralPathX(arc),c,r);

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

                auxRow[ID_FIELD_ENTITY] = ValueFactory.createValue(new String("dxfEntity"));

                auxRow[ID_FIELD_LAYER] = ValueFactory.createValue(new String("layer"));

                int auxInt = Integer.parseInt("0");

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

                    double auxE = Double.parseDouble("0.0");

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

                    double auxT = Double.parseDouble("0.0");

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

                                //FShape nuevoShp = new FPoint3D(pto.getX(),pto.getY(),0);

                                addShape(fCircle, auxRow);                                        

                        } else if (ent instanceof DxfEllipse) {

                                DxfEllipse elip = (DxfEllipse)ent;

                                Point2D pt1 = elip.getPts()[0];

                                Point2D pt2 = elip.getPts()[1];

                                double semiMinorAxisL = elip.getMinorAxisLength()/2.0;

                                //System.out.println("semiMinorAxisL = " + semiMinorAxisL);

                                double xAxis = pt1.distance(pt2);

                                Arc2D.Double arc = new Arc2D.Double(pt1.getX(),

                                                pt1.getY() - semiMinorAxisL, xAxis, 2 * semiMinorAxisL, 0, 360, Arc2D.OPEN);

                                Point2D rotationPoint = new Point2D.Double(pt1.getX() + xAxis /2, pt1.getY());

//                                double angle = Math.atan2(axis1End.getX() - axis1Start.getX(),

//                                                axis1End.getY() - axis1Start.getY());

                                double angle = TrigonometricalFunctions.getAngle(pt1, pt2);

//                                double distortedAngle = Math.atan2(Math.sin(angle) * xAxis, Math.cos(angle) * 2 * axis2Length);

                                AffineTransform mT = AffineTransform.getRotateInstance(angle, pt1.getX(), pt1.getY());

                                GeneralPathX gp = new GeneralPathX(arc);

                                gp.transform(mT);

                                FEllipse2D fEllipse = new FEllipse2D(new GeneralPathX(gp),pt1,pt2,semiMinorAxisL);

                                //FEllipse2D fEllipse = (IGeometry)ShapeFactory.createEllipse(pt1,pt2,semiMinorAxisL);

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

                auxRow[ID_FIELD_ENTITY] = ValueFactory.createValue(new String("dxfEntity"));

                auxRow[ID_FIELD_LAYER] = ValueFactory.createValue(new String("layer"));

                int auxInt = Integer.parseInt("0");

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

                    double auxE = Double.parseDouble("0.0");

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

                    double auxT = Double.parseDouble("0.0");

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

                                //FShape nuevoShp = new FPoint3D(pto.getX(),pto.getY(),0);

                                addShape(fEllipse, auxRow);                                        

                        } else {

                                System.out.println("Detectada entidad desconocida");

                        }

                }

                defaultLegend = LegendFactory.createVectorialUniqueValueLegend(getShapeType());

                defaultLegend.setFieldName("Color");

                defaultLegend.setLabelField("Text");

                defaultLegend.setDefaultSymbol(new FSymbol(getShapeType()));

                defaultLegend.getDefaultSymbol().setShapeVisible(false);

                defaultLegend.getDefaultSymbol().setFontSizeInPixels(false);

                defaultLegend.getDefaultSymbol().setFont(new Font("SansSerif", Font.PLAIN, 9));

                defaultLegend.getDefaultSymbol().setFontColor(Color.BLACK);

                defaultLegend.getDefaultSymbol().setFontSize(heightText);

                defaultLegend.getDefaultSymbol().setStyle(FConstant.SYMBOL_STYLE_DGNSPECIAL);

                defaultLegend.getDefaultSymbol().setSize(3);

                defaultLegend.getDefaultSymbol().setSizeInPixels(true);

                defaultLegend.setLabelHeightField("HeightText");

                defaultLegend.setLabelRotationField("RotationText");

        ReadDriver rs = this;

                IntValue clave;

                FSymbol theSymbol = null;

                try {

                    // TODO: Provisional hasta que cambiemos los s?mbolos.

                    /*BufferedImage bi= new BufferedImage(5, 5, BufferedImage.TYPE_INT_ARGB);

                   Graphics2D big = bi.createGraphics();

                   Color color=new Color(0,0,0,0);

                   big.setBackground(color);

                   big.clearRect(0, 0, 5, 5);

                   Paint fillProv = null; 

                   Rectangle2D rProv = new Rectangle();

                   rProv.setFrame(0, 0,5,5);

                   fillProv = new TexturePaint(bi,rProv);*/                    

                        for (long j = 0; j < rs.getRowCount(); j++)

                        {

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

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

                                {

                                        theSymbol = new FSymbol(getShapeType());

                                        theSymbol.setDescription(clave.toString());

                                        theSymbol.setColor(AcadColor.getColor(clave.getValue()));

                                        //theSymbol.setFill(fillProv);

                                        // 050202, jmorell: Asigna los colores de Autocad a los bordes

                                        //                                        de los pol?gonos.

                                        theSymbol.setOutlineColor(AcadColor.getColor(clave.getValue()));

                                        //theSymbol.setStyle(FConstant.SYMBOL_STYLE_MARKER_SQUARE);

                                        theSymbol.setStyle(FConstant.SYMBOL_STYLE_DGNSPECIAL);

                                        theSymbol.setSize(3);

                                        theSymbol.setSizeInPixels(true);

                                        defaultLegend.addSymbol(clave, theSymbol);

                                }

                        } // for

                } catch (DriverException e) {

                        e.printStackTrace();

                        throw new IOException("Error al poner la leyenda por defecto en el DXF");

                }

        }

        /* (non-Javadoc)

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

         */

        public boolean accept(File f) {

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

        }

        /* (non-Javadoc)

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

         */

        public int getShapeType() {

                return FShape.MULTI;

        }

        /* (non-Javadoc)

         * @see com.iver.cit.gvsig.fmap.drivers.MemoryDriver#getName()

         */

        public String getName() {

                return "gvSIG DXF CAD Model Driver";

        }

        /* (non-Javadoc)

         * @see com.iver.cit.gvsig.fmap.drivers.WithDefaultLegend#getDefaultLegend()

         */

        public Legend getDefaultLegend() {

                return defaultLegend;

        }

    /* (non-Javadoc)

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

     */

    public DriverAttributes getDriverAttributes() {

        return attr;

    }

}