Application: gvSIG desktop

/* jdwglib. Java Library for reading Dwg files.

 * 

 * Author: Jose Morell Rama (jose.morell@gmail.com).

 * Port from the Pythoncad Dwg library by Art Haas.

 *

 * Copyright (C) 2005 Jose Morell, IVER TI S.A. 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:

 *

 * Jose Morell (jose.morell@gmail.com)

 * 

 * or

 *

 * IVER TI S.A.

 *  C/Salamanca, 50

 *  46005 Valencia

 *  Spain

 *  +34 963163400

 *  dac@iver.es

 */

package com.iver.cit.jdwglib.dwg;

import java.awt.geom.Point2D;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.nio.ByteBuffer;

import java.nio.channels.FileChannel;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import com.iver.cit.jdwglib.dwg.objects.DwgArc;

import com.iver.cit.jdwglib.dwg.objects.DwgAttdef;

import com.iver.cit.jdwglib.dwg.objects.DwgAttrib;

import com.iver.cit.jdwglib.dwg.objects.DwgBlock;

import com.iver.cit.jdwglib.dwg.objects.DwgBlockHeader;

import com.iver.cit.jdwglib.dwg.objects.DwgCircle;

import com.iver.cit.jdwglib.dwg.objects.DwgEllipse;

import com.iver.cit.jdwglib.dwg.objects.DwgEndblk;

import com.iver.cit.jdwglib.dwg.objects.DwgInsert;

import com.iver.cit.jdwglib.dwg.objects.DwgLayer;

import com.iver.cit.jdwglib.dwg.objects.DwgLine;

import com.iver.cit.jdwglib.dwg.objects.DwgLwPolyline;

import com.iver.cit.jdwglib.dwg.objects.DwgMText;

import com.iver.cit.jdwglib.dwg.objects.DwgPoint;

import com.iver.cit.jdwglib.dwg.objects.DwgPolyline2D;

import com.iver.cit.jdwglib.dwg.objects.DwgPolyline3D;

import com.iver.cit.jdwglib.dwg.objects.DwgSeqend;

import com.iver.cit.jdwglib.dwg.objects.DwgSolid;

import com.iver.cit.jdwglib.dwg.objects.DwgText;

import com.iver.cit.jdwglib.dwg.objects.DwgVertex2D;

import com.iver.cit.jdwglib.dwg.readers.DwgFileV14Reader;

import com.iver.cit.jdwglib.dwg.readers.IDwgFileReader;

import com.iver.cit.jdwglib.dwg.readers.DwgFileV15Reader;

/**

 * The DwgFile class provides a revision-neutral interface for reading and handling

 * DWG files

 * Reading methods are useful for reading DWG files, and handling methods like

 * calculateDwgPolylines() are useful for handling more complex

 * objects in the DWG file

 * 

 * @author jmorell

 * @author azabala

 */

public class DwgFile {

        /**

         * It has all known DWG version's header.

         * Extracted from Autodesk web.

         */

        private static HashMap acadVersions = new HashMap();

        static{

                acadVersions.put("AC1004", "Autocad R9");

                acadVersions.put("AC1006", "Autocad R10");

                acadVersions.put("AC1007", "Autocad pre-R11");

                acadVersions.put("AC1007", "Autocad pre-R11");

                acadVersions.put("AC1008", "Autocad pre-R11b");

                acadVersions.put("AC1009", "Autocad R12");

                acadVersions.put("AC1010", "Autocad pre-R13 a");

                acadVersions.put("AC1011", "Autocad pre-R13 b");

                acadVersions.put("AC1012", "Autocad R13");

                acadVersions.put("AC1013", "Autocad pre-R14");

                acadVersions.put("AC1014", "Autocad R14");

                acadVersions.put("AC1500", "Autocad pre-2000");

                acadVersions.put("AC1015", "Autocad R2000, R2000i, R2002");

                acadVersions.put("AC402a", "Autocad pre-2004a");

                acadVersions.put("AC402b", "Autocad pre-2004b");

                acadVersions.put("AC1018", "Autocad R2004, R2005, R2006");

                acadVersions.put("AC1021", "Autocad R2007");

        }

        /**

         * Path and name of the dwg file

         * */

        private String fileName;

        /**

         * DWG version of the file (AC1013, AC1018, etc.)

         * */

        private String dwgVersion;

        /**

         * Offsets to the DWG sections

         */

        private ArrayList dwgSectionOffsets;

        /**

         * Header vars readed from the HEADER section of the DWG file

         * */

        private Map headerVars;

        /**

         * This list contains what in OpenDWG specification is called

         * the object map ( a collection of entries where each entry contains

         * the seek of each object, and its size)

         * */

        private ArrayList dwgObjectOffsets;

        /**

         * For each entry in dwgObjectOffsets, we have an instance of

         * DwgObject in the dwgObjects collection

         * 

         * */

        private List dwgObjects;

        private HashMap handle_objects;

        private ArrayList dwgClasses;

        /**

         * hash map that indexes all DwgLayer objects

         * by its handle property

         * */

        private HashMap layerTable; 

        /**

         * Specific reader of the DWG file version (12, 13, 14, 2000, etc., each

         * version will have an specific reader)

         * */

        private IDwgFileReader dwgReader;

        private boolean dwg3DFile;

        /**

         * Memory mapped byte buffer of the whole DWG file

         * */

        private ByteBuffer bb;

        /*

         * Optimizaciones para evitar leer el fichero completo en cada

         * pasada.

         * */

        /**

         * Contains all IDwgPolyline implementations

         * */

        private List dwgPolylines;

        /**

         * Contains all INSERT entities of the dwg file

         * (these entities must be processed in a second pass)

         * 

         * */

        private List insertList;

        /**

         * Constructor.

         * @param fileName an absolute path to the DWG file

         */

        public DwgFile(String fileName) {

                this.fileName = fileName;

                dwgSectionOffsets = new ArrayList();

                dwgObjectOffsets = new ArrayList();

                headerVars = new HashMap();

                dwgClasses = new ArrayList();

                dwgObjects = new ArrayList();

                handle_objects = new HashMap();

                layerTable = new HashMap();

                dwgPolylines = new ArrayList();

                insertList = new ArrayList();

        }

        public String getDwgVersion() {

                return dwgVersion;

        }

        /**

         * Reads a DWG file and put its objects in the dwgObjects Vector

         * This method is version independent

         * 

         * @throws IOException If the file location is wrong

         */

        public void read() throws IOException, 

                                DwgVersionNotSupportedException

        {

                setDwgVersion();

                //System.out.println("VERSION = "+dwgVersion);

                if (dwgVersion.equalsIgnoreCase("Autocad R2000, R2000i, R2002")) {

                        dwgReader = new DwgFileV15Reader();

                }else if (dwgVersion.equalsIgnoreCase("Autocad pre-R14")|| 

                                dwgVersion.equalsIgnoreCase("Autocad R14") ||

                                dwgVersion.equalsIgnoreCase("Autocad R13")) {

                        dwgReader = new DwgFileV14Reader();

                } else {

                        DwgVersionNotSupportedException exception = 

                                new DwgVersionNotSupportedException("Version de DWG no soportada");

                        exception.setDwgVersion(dwgVersion);

                        throw exception;

                }

                dwgReader.read(this, bb);

        }

        private void setDwgVersion() throws IOException {

                File file = new File(fileName);

                FileInputStream fileInputStream = new FileInputStream(file);

                FileChannel fileChannel = fileInputStream.getChannel();

                long channelSize = fileChannel.size();

                bb = fileChannel.map(FileChannel.MapMode.READ_ONLY, 0, channelSize);

                byte[] versionBytes = {bb.get(0), 

                                                                bb.get(1), 

                                                                bb.get(2),

                                                                bb.get(3),

                                                                bb.get(4), 

                                                                bb.get(5)};

                ByteBuffer versionByteBuffer = ByteBuffer.wrap(versionBytes);

                String[] bs = new String[versionByteBuffer.capacity()];

                String versionString = "";

                for (int i=0; i<versionByteBuffer.capacity(); i++) {

                        bs[i] = new String(new byte[]{(byte)(versionByteBuffer.get(i))});

                        versionString = versionString + bs[i];

                }

                String version = (String) acadVersions.get(versionString);

                if(version == null)

                        version = "Unknown Dwg format";

                this.dwgVersion = version;    

        }

        public void setHeader(String key, Object value){

                headerVars.put(key, value);

        }

        /*

         * A DwgLayer is a DWG drawing entity, so all DwgLayer objects are

         * saved in dwgObjects collection.

         * Instead of iterate over the full collection, is faster check every object

         * and save all the DwgLayer instances in their own collection.

         *

         */

        public void addDwgLayer(DwgLayer dwgLayer){

                layerTable.put(new Integer(dwgLayer.getHandle().getOffset()), 

                                dwgLayer);

        }

        private void printInfoOfAObject (DwgObject entity){

                // TODO: Eliminar este metodo cuando terminemos de depurar

                System.out.println("index = "+entity.getIndex() + " entity.type = " + entity.type + " entityClassName = "+ entity.getClass().getName());

                System.out.println ("handleCode = "+entity.getHandle().getCode());

                System.out.println ("entityLayerHandle = "+entity.getHandle().getOffset());

                if(entity.hasLayerHandle()){

                        System.out.println ("layerHandleCode = "+entity.getLayerHandle().getCode());

                        System.out.println ("layerHandle = "+entity.getLayerHandle().getOffset());

                }

                if(entity.hasSubEntityHandle()){

                        System.out.println ("subEntityHandleCode = "+entity.getSubEntityHandle().getCode());

                        System.out.println ("subEntityHandle = "+entity.getSubEntityHandle().getOffset());

                }

                if(entity.hasNextHandle()){

                        System.out.println ("nextHandleCode = "+entity.getNextHandle().getCode());

                        System.out.println ("nextHandle = "+entity.getNextHandle().getOffset());

                }

                if(entity.hasPreviousHandle()){

                        System.out.println ("previousHandleCode = "+entity.getPreviousHandle().getCode());

                        System.out.println ("previousHandle = "+entity.getPreviousHandle().getOffset());

                }

                if(entity.hasXDicObjHandle()){

                        System.out.println ("xDicObjHandleCode = "+entity.getXDicObjHandle());

                        System.out.println ("xDicObjHandle = "+entity.getXDicObjHandle());

                }

                if(entity.hasReactorsHandles()){

                        ArrayList reactorsHandles = entity.getReactorsHandles();

                        int size = reactorsHandles.size();

                        System.out.print ("NUMERO DE reactors = "+size);

                        DwgHandleReference hr;

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

                                hr=(DwgHandleReference)reactorsHandles.get(i);

                                System.out.print ("reactorHandleCode = "+hr.getCode());

                                System.out.println (" reactorHandle = "+hr.getOffset());

                        }

                }

        }

        public DwgLayer getDwgLayer(DwgObject entity){

                DwgHandleReference handle = entity.getLayerHandle();

                if(handle == null){

//                        System.out.print("Entidad con layer handle a null (debe ser una LwPolyline) ==> ");

//                        System.out.println(entity.getClass().getName());

                        //TODO Ver que hacemos con estas entidades (lanzan excepcion antes de hacer readTailer)

                        return null;

                }

                int        handleCode = handle.getCode();

                int        entityLayerHandle = entity.getLayerHandle().getOffset();

                int layerHandle = -1;

                int entityRecord;

                DwgObject object;

                /*

                 * OpenDWG spec, v3, page 11. HANDLE REFERENCES

                 * 

                 * A handle is formed by this fields:

                 * a) CODE (4 bits)

                 * b) COUNTER (4 bits)

                 * c) OFFSET of the object (handle itself).

                 * 

                 * CODE could take these values:

                 * 1) 0x2, 0x3, 0x4, 0x5 -> offset is the handle of the layer

                 * 2) 0x6 -> offset is the next object handle

                 * 3) 0x8 -> offset is the previous object handle

                 * 4) 0xA -> result is reference handle plus offset

                  * 5) 0xC -> result is reference handle minus offset

                 * 

                 * */

                // FIXME: Esto no esta terminado. Falta considerar los codigo

                // 0x2, 0x3, 0x6, 0xA que no han aparecido en los archivos de prueba.

                switch(handleCode){

                case 0x4:

                        if (entity.hasNextHandle()){

                                int nextHandleCode = entity.getNextHandle().getCode();

                                if (nextHandleCode == 0x5) {

                                        layerHandle = entity.getNextHandle().getOffset();

                                } else {

                                        //TODO: No se han previsto nextHandleCode != 0x5

//                                        System.out.println ("DwgFile.getDwgLayer: handleCode "+handleCode+

//                                                        " con nextHandleCode "+ nextHandleCode +" no implementado.");

                                }

                        } else {

                                layerHandle = entity.getLayerHandle().getOffset();

                        }

                        break;

                case 0x5:

                        layerHandle = entity.getLayerHandle().getOffset();

                        break;

                case 0x8:

                        if (entity.hasNextHandle()){

                                int nextHandleCode = entity.getNextHandle().getCode();

                                if (nextHandleCode == 0x5) {

                                        layerHandle = entity.getNextHandle().getOffset();

                                } else {

                                        //TODO No se han previsto nextHandleCode != 0x5

//                                        System.out.println ("DwgFile.getDwgLayer: handleCode "+handleCode+

//                                                        " con nextHandleCode "+ nextHandleCode +" no implementado.");

                                }

                        } else {

                                layerHandle = entity.getHandle().getOffset() - 1;

                        }

                        break;

                case 0xC:

                        if (entity.hasNextHandle()){

                                int nextHandleCode = entity.getNextHandle().getCode();

                                if (nextHandleCode == 0x5) {

                                        layerHandle = entity.getNextHandle().getOffset();

                                } else {

                                        //TODO: No se han previsto nextHandleCode != 0x5

//                                        System.out.println ("DwgFile.getDwgLayer: handleCode "+handleCode+

//                                                        " con nextHandleCode "+ nextHandleCode +" no implementado.");

                                }

                        } else {

                                layerHandle = entity.getHandle().getOffset() - entity.getLayerHandle().getOffset() + 1;

                        }

                        break;

                default:

//                        System.out.println ("DwgFile.getDwgLayer: handleCode "+handleCode+" no implementado. entityLayerHandle="+entityLayerHandle);

                }

                if(layerHandle != -1){

                        Iterator lyrIterator = layerTable.values().iterator();

                        while(lyrIterator.hasNext()){

                                DwgLayer lyr = (DwgLayer) lyrIterator.next();

                                int lyrHdl = lyr.getHandle().getOffset();

                                if (lyrHdl == layerHandle){

                                        return lyr;

                                }

                        }

                }

//                System.out.println("NO SE HA ENCONTRADO UNA CAPA CON HANDLE " + layerHandle);

//                printInfoOfAObject(entity);

                return null;

        }

        public DwgObject getDwgSuperEntity(DwgObject entity) {

                if(entity.hasSubEntityHandle()){

                        int handleCode = entity.subEntityHandle.getCode();

                        int offset = entity.subEntityHandle.getOffset();

                        int handle = -1;

                        DwgObject object;

                        switch(handleCode){

                        // TODO: case 0x2:

                        // TODO: case 0x3:

                        case 0x4:

                        case 0x5:

                                handle = offset;

                                break;

                        // TODO: case 0x6:

                        case 0x8:

                                handle=entity.getHandle().getOffset() - 1;

                                break;

                        case 0xA:

                                handle = entity.getHandle().getOffset() + offset;

                                break;

                        case 0xC:

                                handle = entity.getHandle().getOffset() - offset;

                                break;

                        default:

                                System.out.println ("DwgObject.getDwgSuperEntity: handleCode "+handleCode+" no implementado. offset = "+offset);

                        }

                        if(handle != -1){

                                object = getDwgObjectFromHandle(handle);

                                if(object != null)

                                        return object;

                        }

//                        System.out.println(" NO SE HA ENCONTRADO UN OBJETO CON HANDLE " + handle + ". handleCode = " + handleCode + " dwgObject.index = "+entity.index +" dwgObject.type = " + entity.type + " dwgObjectClassName = "+ entity.getClass().getName());

                }

                return null;

        }

        public String getLayerName(DwgObject entity) {                

                DwgLayer dwgLayer = getDwgLayer(entity);

                if(dwgLayer == null){//TODO Puede haber entidades sin layer???

                        return "";

                }else{

                        return dwgLayer.getName();

                }

        }

        /**

     * Returns the color of the layer of a DWG object 

         * 

     * @param entity DWG object which we want to know its layer color

         * @return int Layer color of the DWG object in the Autocad color code

         */

        public int getColorByLayer(DwgObject entity) {

                int colorByLayer;

                DwgLayer dwgLyr = getDwgLayer(entity);

                if(dwgLyr == null)

                        colorByLayer = 0;

                else

                        colorByLayer = dwgLyr.getColor();

                return colorByLayer;

        }

        /**

         * Configure the geometry of the polylines in a DWG file from the vertex list in

         * this DWG file. This geometry is given by an array of Points.

         * Besides, manage closed polylines and polylines with bulges in a GIS Data model.

     * It means that the arcs of the polylines will be done through a set of points and

     * a distance between these points.

         */

        public void calculateGisModelDwgPolylines() {

                /*

                 * Ahora mismo esto se est? haciendo al final (en una segunda pasada)

                 * porque posiblemente una Linea requiera de vertices que vengan

                 * despues, lo que complicar?a bastante todo....

                 * */

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

                        DwgObject pol = (DwgObject)dwgPolylines.get(i);

                        if (pol instanceof IDwgPolyline) {

                                ((IDwgPolyline)pol).calculateGisModel(this);

                        } 

                }

        }

    /**

     * Configure the geometry of the polylines in a DWG file from the vertex list in

     * this DWG file. This geometry is given by an array of Points

     * Besides, manage closed polylines and polylines with bulges in a GIS Data model.

     * It means that the arcs of the polylines will be done through a curvature

     * parameter called bulge associated with the points of the polyline.

     */

        //TODO Refactorizar para que solo se aplique a las Polilineas

        public void calculateCadModelDwgPolylines() {

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

                        DwgObject pol = (DwgObject)dwgObjects.get(i);

                        if (pol instanceof DwgPolyline2D) {

                                int flags = ((DwgPolyline2D)pol).getFlags();

                                int firstHandle = ((DwgPolyline2D)pol).getFirstVertexHandle().getOffset();

                                int lastHandle = ((DwgPolyline2D)pol).getLastVertexHandle().getOffset();

                                ArrayList pts = new ArrayList();

                                ArrayList bulges = new ArrayList();

                                double[] pt = new double[3];

                                for (int j=0;j<dwgObjects.size();j++) {

                                        DwgObject firstVertex = (DwgObject)dwgObjects.get(j);

                                        if (firstVertex instanceof DwgVertex2D) {

                                                int vertexHandle = firstVertex.getHandle().getOffset();

                                                if (vertexHandle==firstHandle) {

                                                        int k=0;

                                                        while (true) {

                                                                DwgObject vertex = (DwgObject)dwgObjects.get(j+k);

                                                                int vHandle = vertex.getHandle().getOffset();

                                                                if (vertex instanceof DwgVertex2D) {

                                                                        pt = ((DwgVertex2D)vertex).getPoint();

                                                                        pts.add(new Point2D.Double(pt[0], pt[1]));

                                                                        double bulge = ((DwgVertex2D)vertex).getBulge();

                                                                        bulges.add(new Double(bulge));

                                                                        k++;

                                                                        if (vHandle==lastHandle && vertex instanceof DwgVertex2D) {

                                                                                break;

                                                                        }

                                                                } else if (vertex instanceof DwgSeqend) {

                                                                        break;

                                                                }

                                                        }

                                                }

                                        }

                                }

                                if (pts.size()>0) {

                                        /*Point2D[] newPts = new Point2D[pts.size()];

                                        if ((flags & 0x1)==0x1) {

                                                newPts = new Point2D[pts.size()+1];

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

                                                        newPts[j] = (Point2D)pts.get(j);

                                                }

                                                newPts[pts.size()] = (Point2D)pts.get(0);

                                                bulges.add(new Double(0));

                                        } else {

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

                                                        newPts[j] = (Point2D)pts.get(j);

                                                }

                                        }*/

                                        double[] bs = new double[bulges.size()];

                                        for (int j=0;j<bulges.size();j++) {

                                                bs[j] = ((Double)bulges.get(j)).doubleValue();

                                        }

                                        ((DwgPolyline2D)pol).setBulges(bs);

                                        //Point2D[] points = GisModelCurveCalculator.calculateGisModelBulge(newPts, bs);

                                        Point2D[] points = new Point2D[pts.size()];

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

                                            points[j] = (Point2D)pts.get(j);

                                        }

                                        ((DwgPolyline2D)pol).setPts(points);

                                } else {

//                                        System.out.println("Encontrada polil?nea sin puntos ...");

                                        // TODO: No se debe mandar nunca una polil?nea sin puntos, si esto

                                        // ocurre es porque existe un error que hay que corregir ...

                                }

                        } else if (pol instanceof DwgPolyline3D) {

                        } else if (pol instanceof DwgLwPolyline && ((DwgLwPolyline)pol).getVertices()!=null) {

                        }

                }

        }

        public void blockManagement2(){

                //once we have read all dwg entities, we look for all of them

                //that has a superentity that is a block (to fill in the entity list

                //of each block

                Iterator it = dwgObjects.iterator();

                int i = 0;

                while(it.hasNext()){

                        DwgObject entity = (DwgObject)it.next();

                        DwgObject superEnt = getDwgSuperEntity(entity);

                        if(superEnt instanceof DwgBlockHeader){

                                DwgBlockHeader blk = (DwgBlockHeader)superEnt;

//                                System.out.println("Entidad "+

//                                                                                        i+

//                                                                " pertenece al bloque "+

//                                                                blk.getName());

                                blk.addObject(entity);

                                it.remove();//TODO Creo que esto es lento, mejor

                                //el metodo original (en java solo se duplican las referencias)

                                i++;

                        }

                }//while

                //after that, we process the INSERTs

                it = insertList.iterator();

                while(it.hasNext()){

                        DwgInsert insert = (DwgInsert) it.next();

                        if(insert.isProcessed()){

                                //It has been processed nexted to other insert

                                continue;

                        }

                        insert.setProcessed(true);

                        double[] p = insert.getInsertionPoint();

                        Point2D point = new Point2D.Double(p[0], p[1]);

                        double[] scale = insert.getScale();

                        double rot = insert.getRotation();

                        int blockHandle = insert.getBlockHeaderHandle().getOffset();

                        manageInsert2(point, scale,

                                        rot, blockHandle, 

                                        dwgObjects, handle_objects);

                }        

        }

    /**

     * Modify the geometry of the objects contained in the blocks of a DWG file and

     * add these objects to the DWG object list.

     * 

     * TODO Revisar los bloques que son XREF

     */

        public void blockManagement() {

                LinkedList dwgObjectsWithoutBlocks = new LinkedList();

                HashMap handle_objectsWithoutBlocks = new HashMap();

            boolean addingToBlock = false;

            try{

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

                                DwgObject entity = (DwgObject)dwgObjects.get(i);

                                if (entity instanceof DwgArc && !addingToBlock) {

                                        dwgObjectsWithoutBlocks.add(entity);

                                        handle_objectsWithoutBlocks.put(new Integer(entity.getHandle().getOffset()), entity);

                                } else if (entity instanceof DwgEllipse && !addingToBlock) {

                                        dwgObjectsWithoutBlocks.add(entity);

                                        handle_objectsWithoutBlocks.put(new Integer(entity.getHandle().getOffset()), entity);

                                } else if (entity instanceof DwgCircle && !addingToBlock) {

                                        dwgObjectsWithoutBlocks.add(entity);

                                        handle_objectsWithoutBlocks.put(new Integer(entity.getHandle().getOffset()), entity);

                                } else if (entity instanceof DwgPolyline2D && !addingToBlock) {

                                        dwgObjectsWithoutBlocks.add(entity);

                                        handle_objectsWithoutBlocks.put(new Integer(entity.getHandle().getOffset()), entity);

                                } else if (entity instanceof DwgPolyline3D && !addingToBlock) {

                                        dwgObjectsWithoutBlocks.add(entity);

                                        handle_objectsWithoutBlocks.put(new Integer(entity.getHandle().getOffset()), entity);

                                } else if (entity instanceof DwgLwPolyline && !addingToBlock) {

                                        dwgObjectsWithoutBlocks.add(entity);

                                        handle_objectsWithoutBlocks.put(new Integer(entity.getHandle().getOffset()), entity);

                                } else if (entity instanceof DwgSolid && !addingToBlock) {

                                        dwgObjectsWithoutBlocks.add(entity);

                                        handle_objectsWithoutBlocks.put(new Integer(entity.getHandle().getOffset()), entity);

                                } else if (entity instanceof DwgLine && !addingToBlock) {

                                        dwgObjectsWithoutBlocks.add(entity);

                                        handle_objectsWithoutBlocks.put(new Integer(entity.getHandle().getOffset()), entity);

                                } else if (entity instanceof DwgPoint && !addingToBlock) {

                                        dwgObjectsWithoutBlocks.add(entity);

                                        handle_objectsWithoutBlocks.put(new Integer(entity.getHandle().getOffset()), entity);

                                } else if (entity instanceof DwgMText && !addingToBlock) {

                                        dwgObjectsWithoutBlocks.add(entity);

                                        handle_objectsWithoutBlocks.put(new Integer(entity.getHandle().getOffset()), entity);

                                } else if (entity instanceof DwgText && !addingToBlock) {

                                        dwgObjectsWithoutBlocks.add(entity);

                                        handle_objectsWithoutBlocks.put(new Integer(entity.getHandle().getOffset()), entity);

                                } else if (entity instanceof DwgAttrib && !addingToBlock) {

                                        dwgObjectsWithoutBlocks.add(entity);

                                        handle_objectsWithoutBlocks.put(new Integer(entity.getHandle().getOffset()), entity);

                                } else if (entity instanceof DwgAttdef && !addingToBlock) {

                                        dwgObjectsWithoutBlocks.add(entity);

                                        handle_objectsWithoutBlocks.put(new Integer(entity.getHandle().getOffset()), entity);

                                } else if (entity instanceof DwgBlock) {

                                        addingToBlock = true;

                                } else if (entity instanceof DwgEndblk) {

                                        addingToBlock = false;

                                } else if (entity instanceof DwgBlockHeader) {

                                        addingToBlock = true;

                                } 

                                //Segun esto, un insert solo se procesa dentro de un Block (o BlockHeader)

                                //?Puede haber INSERT fuera de BLOCK-ENDBLK?

                                else if (entity instanceof DwgInsert && !addingToBlock) {

                                        double[] p = ((DwgInsert)entity).getInsertionPoint();

                                        Point2D point = new Point2D.Double(p[0], p[1]);

                                        double[] scale = ((DwgInsert)entity).getScale();

                                        double rot = ((DwgInsert)entity).getRotation();

                                        int blockHandle = ((DwgInsert)entity).getBlockHeaderHandle().getOffset();

                                        manageInsert(point, scale, rot, blockHandle, dwgObjectsWithoutBlocks, handle_objectsWithoutBlocks);

                                } else {

        //                                System.out.println(entity.getClass().getName() +" en un bloque");

                                        //Se ha encontrado una entidad rara, o forma parte de un bloque

                                        //y ser? procesada despu?s (con los punteros del propio bloque)

                                        //TODO No se podr?a hacer mas rapido, quitando de la lista original

                                        //las entidades que forman parte de bloque??

                                }

                        }

            }catch(RuntimeException re){

                    re.printStackTrace();

            }

                dwgObjects = dwgObjectsWithoutBlocks;

                this.handle_objects = (HashMap) handle_objectsWithoutBlocks;

        }

        public void manageInsert2(Point2D insPoint, double[] scale,

                        double rot, int bHandle, 

                        List dwgObjectsWithoutBlocks, 

                        Map handleObjectsWithoutBlocks) {

                DwgObject object = (DwgObject) handle_objects.get(new Integer(bHandle));

                if(object == null){

                        System.out.println("No hemos encontrado el BlockHeader cuyo handle es "+bHandle);

                        return;

                }else if(! (object instanceof DwgBlockHeader)){

                        //Hay un problema con la asignaci?n de handle

                        //Un INSERT tiene como handle de Block una entidad que no es block

//                        System.out.println("handle incorrecto." + object.getClass().getName() + " no es un blockheader");

                        return;

                }

                DwgBlockHeader blockHeader = (DwgBlockHeader)object;

                double[] bPoint = blockHeader.getBasePoint();

                String bname = blockHeader.getName();

                if (bname.startsWith("*")) 

                        return;

                //TODO Cambiar por List

                Iterator blkEntIt = blockHeader.getObjects().iterator();

                while(blkEntIt.hasNext()){

                        DwgObject obj = (DwgObject) blkEntIt.next();

                         manageBlockEntity(obj, bPoint, 

                                           insPoint, scale, 

                                           rot, dwgObjectsWithoutBlocks,

                                           handleObjectsWithoutBlocks);        

                }//while

        }

    /**

     * Manages an INSERT of a DWG file. This object is the insertion point of a DWG

     * block. 

     * 

     * @param insPoint, coordinates of the insertion point.

     * @param scale, scale of the elements of the block that will be inserted.

     * @param rot, rotation angle of the elements of the block.

     * 

     * @param bHandle, offset for the coordinates of the elements of the block.

     * @param id, count that serves as a id.

     * @param dwgObjectsWithoutBlocks, a object list with the elements extracted from

     * the blocks.

     */

        public void manageInsert(Point2D insPoint, double[] scale,

                                                        double rot, int bHandle, 

                                                        List dwgObjectsWithoutBlocks, 

                                                        Map handleObjectsWithoutBlocks) {

                DwgObject object = (DwgObject) handle_objects.get(new Integer(bHandle));

                if(object == null){

//                        System.out.println("No hemos encontrado el BlockHeader cuyo handle es "+bHandle);

                        return;

                }else if(! (object instanceof DwgBlockHeader)){

                        //Hay un problema con la asignaci?n de handle

                        //Un INSERT tiene como handle de Block una entidad que no es block

//                        System.out.println("handle incorrecto." + object.getClass().getName() + " no es un blockheader");

                        return;

                }

                DwgBlockHeader blockHeader = (DwgBlockHeader)object;

                double[] bPoint = blockHeader.getBasePoint();

                String bname = blockHeader.getName();

                if (bname.startsWith("*")) 

                        return;

                DwgHandleReference firstHdl = blockHeader.getFirstEntityHandle();

                DwgHandleReference lastHdl = blockHeader.getLastEntityHandle();

                if(firstHdl == null || lastHdl == null){

//                        System.out.println("Problemas en el bloque "+bname);

//                        System.out.println("1er obj="+firstHdl+" 2o obj="+lastHdl);

                        return;

                }        

                int firstObjectHandle = firstHdl.getOffset();   

                int lastObjectHandle = lastHdl.getOffset();

                //TODO Ver que hacia el metodo antiguo cuando llegaban handles a 0

                //como extremos de un bloque (sera bloque vacio, supongo)

                if(firstObjectHandle == 0 || lastObjectHandle == 0){

//                        System.out.println("Problemas en el bloque "+bname);

//                        System.out.println("1er obj="+firstObjectHandle+" 2o obj="+lastObjectHandle);

                        return;

                }        

                /*

                 * Ahora localiza la primera entidad del bloque, 

                 * y a partir de ah?, a?ade

                 * al bloque todas las entidades que encuentre hasta la 

                 * ?ltima entidad del bloque

                 * 

                 * */

                 DwgObject firstObj = (DwgObject) handle_objects.

                                                 get(new Integer(firstObjectHandle));

                 DwgObject lastObj =  (DwgObject) handle_objects.

                                                 get(new Integer(lastObjectHandle));

                 int firstObjIdx = dwgObjects.indexOf(firstObj);

                 int lastObjIdx = dwgObjects.indexOf(lastObj);

                 if(firstObjIdx == -1){

//                         System.out.println("El primer objeto del bloque "+

//                                                         blockHeader.getName()+

//                                                 " no ha sido localizado a partir del handle "+

//                                                 firstObjectHandle);

                         return;

                 }

                 if(lastObjIdx == -1){

//                         System.out.println("El ultimo objeto del bloque "+

//                                                         blockHeader.getName()+

//                                                 " no ha sido localizado a partir del handle "+

//                                                 lastObjectHandle);

                         //Intentamos ver si como delimitador final de bloque aparece EndBlk

                         LinkedList tempDwgObj = new LinkedList();

                         HashMap tempHdlObj = new HashMap();

                         DwgObject scannedEntity = (DwgObject) dwgObjects.get(firstObjIdx);

                         while(! (scannedEntity instanceof DwgEndblk)){

                                 manageBlockEntity(scannedEntity, bPoint, 

                                                 insPoint, scale, rot, 

                                                 tempDwgObj,

                                                 tempHdlObj);

                                 firstObjIdx++;

                                 scannedEntity = (DwgObject) dwgObjects.get(firstObjIdx);

                                 if( (scannedEntity instanceof DwgBlock) ||

                                        (scannedEntity instanceof DwgBlockHeader)){

                                         //No puede haber bloques anidados

                                         //Descartar 

//                                         System.out.println("Error, aparecen bloques anidados");

                         return;

                 }

                         }//while

                         if(tempDwgObj.size() > 0){

                                 dwgObjectsWithoutBlocks.addAll(tempDwgObj);

                                 handleObjectsWithoutBlocks.putAll(tempHdlObj);

                         }         

                         return;

                 }//if

                 for(int i = firstObjIdx; i <= lastObjIdx; i++){

                         DwgObject obj = (DwgObject) dwgObjects.get(i);

                         manageBlockEntity(obj, bPoint, 

                                                           insPoint, scale, 

                                                           rot, dwgObjectsWithoutBlocks, handleObjectsWithoutBlocks);

                 }//for

        }

        public int getIndexOf(DwgObject dwgObject){

                return dwgObjects.indexOf(dwgObject);

        }

    /**

     * Changes the location of an object extracted from a block. This location will be

     * obtained through the insertion parameters from the block and the corresponding

     * insert.

     * @param entity, the entity extracted from the block.

     * @param bPoint, offset for the coordinates of the entity.

     * @param insPoint, coordinates of the insertion point for the entity.

     * @param scale, scale for the entity.

     * @param rot, rotation angle for the entity.

     * @param id, a count as a id.

     * @param dwgObjectsWithoutBlocks, a object list with the elements extracted from

     * the blocks.

     */

        private void manageBlockEntity(DwgObject entity, 

                                                                        double[] bPoint, 

                                                                        Point2D insPoint, 

                                                                        double[] scale, 

                                                                        double rot, 

                                                                        List dwgObjectsWithoutBlocks,

                                                                        Map handleObjectsWithoutBlocks) {

                if(entity instanceof IDwgBlockMember){

                        IDwgBlockMember blockMember = (IDwgBlockMember)entity;

                        blockMember.transform2Block(bPoint, insPoint, scale, rot, 

                                        dwgObjectsWithoutBlocks,

                                        handleObjectsWithoutBlocks,this);

                }else{

                        //TODO REIMPLEMENTAR ENTIDADES QUE PUEDEN FORMAR PARTE DE BLOQUES.

                        //POR EJEMPLO: DwgText y DwgMText pueden formar parte 

                        //de bloques, y de hecho, est?n apareciendo

//                        System.out.println(entity.getClass().getName()+" dentro de un bloque");

                }

        }

        /**

         * Add a DWG section offset to the dwgSectionOffsets vector

         * 

         * @param key Define the DWG section

         * @param seek Offset of the section

         * @param size Size of the section

         */

        public void addDwgSectionOffset(String key, int seek, int size) {

                DwgSectionOffset dso = new DwgSectionOffset(key, seek, size);

                dwgSectionOffsets.add(dso);

        }

        /**

     * Returns the offset of DWG section given by its key 

         * 

     * @param key Define the DWG section

         * @return int Offset of the section in the DWG file

         */

        public int getDwgSectionOffset(String key) {

                int offset = 0;

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

                        DwgSectionOffset dso = (DwgSectionOffset)dwgSectionOffsets.get(i);

                        String ikey = dso.getKey();

                        if (key.equals(ikey)) {

                                offset = dso.getSeek();

                                break;

                        }

                }

                return offset;

        }

        /**

         * Add a DWG object offset to the dwgObjectOffsets vector

         * 

         * @param handle Object handle

         * @param offset Offset of the object data in the DWG file

         */

        public void addDwgObjectOffset(int handle, int offset) {

                DwgObjectOffset doo = new DwgObjectOffset(handle, offset);

                dwgObjectOffsets.add(doo);

        }

        /**

         * 

         * Add a DWG object to the dwgObject vector

         * 

         * @param dwgObject DWG object

         */

        public void addDwgObject(DwgObject dwgObject){

                //TODO Ver si puedo inicializar las listas especificas

                //(IDwgPolyline, etc) aqu? 

                dwgObjects.add(dwgObject);

                handle_objects.put(new Integer(dwgObject.getHandle().getOffset()), dwgObject);

                /*

                 * TODO Quitar todos estos if-then y sustituirlos por un metodo callbackj

                 * 

                 * 

                 * (dwgObject.init(this), y que cada objeto haga lo que tenga que hacer

                 * */

                if(dwgObject instanceof DwgLayer){

                        this.addDwgLayer((DwgLayer) dwgObject);

                }

                //Probamos a no aplicar las extrusiones

                if(dwgObject instanceof IDwgExtrusionable){

                        ((IDwgExtrusionable)dwgObject).applyExtrussion();

                }

                if(dwgObject instanceof IDwgPolyline){

                        dwgPolylines.add(dwgObject);

                }

                if(dwgObject instanceof IDwg3DTestable){

                        if(! dwg3DFile){//if its true, we dont check again

                                dwg3DFile = ((IDwg3DTestable)dwgObject).has3DData();

                        }

                }

                if(dwgObject instanceof DwgInsert){

                        insertList.add(dwgObject);

                }

        }

        /**

         * Returns dwgObjects from its insertion order (position

         * in the dwg file)

         * 

         * @param index order in the dwg file

         * @return position

         * */

        public DwgObject getDwgObject(int index){

                return (DwgObject) dwgObjects.get(index);

        }

        public DwgObject getDwgObjectFromHandle(int handle){

                return (DwgObject) handle_objects.get(new Integer(handle));

        }

        /**

         * Add a DWG class to the dwgClasses vector

         * 

         * @param dwgClass DWG class

         */

        public void addDwgClass(DwgClass dwgClass){

                dwgClasses.add(dwgClass);

        }

        public void printClasses(){

                System.out.println("#### CLASSES ####");

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

                        DwgClass clazz = (DwgClass) dwgClasses.get(i);

                        System.out.println(clazz.toString());

                }

                System.out.println("#############");

        }

        public List getDwgClasses(){

                return dwgClasses;

        }

    /**

     * @return Returns the dwgObjectOffsets.

     */

    public ArrayList getDwgObjectOffsets() {

        return dwgObjectOffsets;

    }

    /**

     * @return Returns the dwgObjects.

     */

    public List getDwgObjects() {

        return dwgObjects;

    }

    /**

     * @return Returns the fileName.

     */

    public String getFileName() {

        return fileName;

    }

    /**

     * @return Returns the dwg3DFile.

     */

    public boolean isDwg3DFile() {

        return dwg3DFile;

    }

    /**

     * @param dwg3DFile The dwg3DFile to set.

     */

    public void setDwg3DFile(boolean dwg3DFile) {

        this.dwg3DFile = dwg3DFile;

    }

}